mirror of
https://github.com/storytold/craft-anything.git
synced 2026-11-19 05:50:53 +01:00
Start the window on Macs whose Metal compiler rejects the OS's shader version (#744)
The window opens on Macs whose Metal compiler rejects the shader language version wgpu takes from the macOS version: a patched wgpu-hal 30.0.1 (identical to the released crate except for this probe) compiles a tiny kernel with each version up to the OS's and keeps the first one accepted. A lost device on a Mac no longer points at the Windows-only software renderer setting (fixes #742).
This commit is contained in:
1 parent
87f09c4d16
commit
bbc06cb9c1
89 files changed
+56768
-5
No files matched your search
Generated
-2
@@ -7327,8 +7327,6 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "wgpu-hal"
|
||||
version = "30.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6b7fb58561a792bc237628ba0792e332de418fefe145f13b5ed8201e6d52f58"
|
||||
dependencies = [
|
||||
"android_system_properties",
|
||||
"arrayvec",
|
||||
|
||||
@@ -92,3 +92,8 @@ codegen-units = 1
|
||||
debug = false
|
||||
strip = true
|
||||
panic = "abort"
|
||||
|
||||
# wgpu-hal with a Metal shader-language probe (Craft Anything #742; upstream wgpu #10687).
|
||||
# Remove this once the upstream wgpu release picks a Metal version the compiler accepts. See vendor/wgpu-hal/CRAFT_ANYTHING.md.
|
||||
[patch.crates-io]
|
||||
wgpu-hal = { path = "vendor/wgpu-hal" }
|
||||
@@ -135,11 +135,16 @@ fn wants_software(setting: Option<&str>) -> bool {
|
||||
setting.is_some_and(|s| s.trim().eq_ignore_ascii_case("software"))
|
||||
}
|
||||
|
||||
/// What to try when the window can't start: a lost graphics device gets the way to the software
|
||||
/// renderer, and anything else the usual driver advice.
|
||||
/// What to try when the window can't start. A lost graphics device on Windows gets the way to the
|
||||
/// software renderer; on macOS that setting does nothing (only Windows picks its adapter), so it
|
||||
/// gets the update advice and the report path. Anything else gets the usual driver advice.
|
||||
fn graphics_advice(error: &str) -> &'static str {
|
||||
if error.to_lowercase().contains("device is lost") {
|
||||
"The graphics driver stopped while the window opened. Update it, then try again. If it keeps happening, set the environment variable CRAFT_ANYTHING_RENDERER=software to draw without the graphics card (slower), and start the app again."
|
||||
if cfg!(target_os = "macos") {
|
||||
"The Mac's graphics stopped while the window opened. Install the latest macOS update, then try again. If it keeps happening, please report it with the log file (Craft Anything issue #742 covers the Metal shader case)."
|
||||
} else {
|
||||
"The graphics driver stopped while the window opened. Update it, then try again. If it keeps happening, set the environment variable CRAFT_ANYTHING_RENDERER=software to draw without the graphics card (slower), and start the app again."
|
||||
}
|
||||
} else {
|
||||
"Updating your graphics driver often fixes this."
|
||||
}
|
||||
@@ -282,10 +287,27 @@ mod graphics_tests {
|
||||
assert!(matches!(dx12_compiler(Some(Dx12Compiler::StaticDxc)), Dx12Compiler::StaticDxc));
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn a_lost_device_says_how_to_draw_without_the_graphics_card() {
|
||||
assert!(graphics_advice("WGPU error: Parent device is lost").contains("CRAFT_ANYTHING_RENDERER=software"));
|
||||
assert!(!graphics_advice("No adapter").contains("software"));
|
||||
assert!(wants_software(Some(" Software ")) && !wants_software(Some("gpu")) && !wants_software(None));
|
||||
}
|
||||
|
||||
/// #742: on macOS `CRAFT_ANYTHING_RENDERER` does nothing, so the advice must not name it.
|
||||
#[cfg(target_os = "macos")]
|
||||
#[test]
|
||||
fn a_lost_device_on_a_mac_does_not_point_at_the_windows_only_setting() {
|
||||
let advice = graphics_advice("WGPU error: Parent device is lost");
|
||||
assert!(!advice.contains("CRAFT_ANYTHING_RENDERER"), "{advice}");
|
||||
assert!(advice.contains("#742"));
|
||||
assert!(!graphics_advice("No adapter").contains("CRAFT_ANYTHING_RENDERER"));
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[test]
|
||||
fn wants_software_reads_the_setting() {
|
||||
assert!(wants_software(Some(" Software ")) && !wants_software(Some("gpu")) && !wants_software(None));
|
||||
}
|
||||
}
|
||||
@@ -258,6 +258,13 @@ instead breaks desktops whose monitors are on the discrete card. Draw on the GPU
|
||||
screen, read from the connected displays, and keep wgpu's environment variables as the override;
|
||||
when a window is slow to open, check which adapter `desktop.log` says it drew with.
|
||||
|
||||
**A Metal version taken from the OS, not from the compiler.** wgpu-hal picks the Metal shading
|
||||
language from the macOS version alone; on a 2012 iMac under OpenCore Legacy Patcher, macOS 15 asked
|
||||
for `metal3.2`, the compiler stopped at 3.1, every shader failed and the window never opened (#742,
|
||||
upstream #10687). Our `[patch]` of wgpu-hal probes the compiler (`vendor/wgpu-hal/CRAFT_ANYTHING.md`).
|
||||
The advice on a lost device named `CRAFT_ANYTHING_RENDERER`, which only Windows reads: check that
|
||||
advice names only settings the platform actually reads. Not run on the reporter's Mac.
|
||||
|
||||
**A Mac app that couldn't find Claude Code, and offered a GitHub key instead.** An app opened from
|
||||
the Dock gets the system's short `PATH`, not the shell's, so `claude` in `~/.local/bin` wasn't
|
||||
found; "Built by" then fell back to "Claude Code on github.com-work", an `~/.ssh/config` alias
|
||||
|
||||
Vendored
+25
@@ -0,0 +1,25 @@
|
||||
# wgpu-hal 30.0.1, patched for Craft Anything
|
||||
|
||||
This is a copy of `wgpu-hal` 30.0.1 (MIT OR Apache-2.0, see `LICENSE.*`) with one change, used through
|
||||
`[patch.crates-io]` in the workspace `Cargo.toml`.
|
||||
|
||||
## The change
|
||||
|
||||
`src/metal/adapter.rs`: the Metal shader language version is no longer taken from the macOS version
|
||||
alone. `accepted_msl_version` compiles a tiny probe kernel with each version up to the OS's, highest
|
||||
first, and keeps the first one the system's Metal compiler accepts. If none is accepted it keeps the
|
||||
OS's version, as upstream does.
|
||||
|
||||
## Why
|
||||
|
||||
On some Macs the OS expects a Metal language version its compiler does not accept. On iMac 2012 Macs
|
||||
(GT 640M, macOS 15 under OpenCore Legacy Patcher) macOS 15 selects `metal3.2` and the compiler stops at
|
||||
`metal3.1`. Every shader fails, the device is lost and the app's window never opens.
|
||||
|
||||
- Craft Anything issue #742.
|
||||
- Upstream: gfx-rs/wgpu #10687 (closed as a duplicate, no fix on trunk), #10592 (open).
|
||||
|
||||
## Removing it
|
||||
|
||||
Delete this directory and the `[patch.crates-io]` entry once a released wgpu picks a Metal version the
|
||||
compiler accepts (check that the 2012 iMac case in #742 works on that release first).
|
||||
Vendored
+542
@@ -0,0 +1,542 @@
|
||||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g., crates.io) dependencies.
|
||||
#
|
||||
# If you are reading this file be aware that the original Cargo.toml
|
||||
# will likely look very different (and much more reasonable).
|
||||
# See Cargo.toml.orig for the original contents.
|
||||
|
||||
[package]
|
||||
edition = "2021"
|
||||
rust-version = "1.87"
|
||||
name = "wgpu-hal"
|
||||
version = "30.0.1"
|
||||
authors = ["gfx-rs developers"]
|
||||
build = "build.rs"
|
||||
autolib = false
|
||||
autobins = false
|
||||
autoexamples = false
|
||||
autotests = false
|
||||
autobenches = false
|
||||
description = "Hardware abstraction layer for wgpu, the cross-platform, safe, pure-rust graphics API"
|
||||
homepage = "https://wgpu.rs/"
|
||||
readme = "README.md"
|
||||
keywords = ["graphics"]
|
||||
license = "MIT OR Apache-2.0"
|
||||
repository = "https://github.com/gfx-rs/wgpu"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
features = [
|
||||
"metal",
|
||||
"vulkan",
|
||||
"gles",
|
||||
"renderdoc",
|
||||
]
|
||||
rustdoc-args = [
|
||||
"--cfg",
|
||||
"docsrs",
|
||||
]
|
||||
targets = [
|
||||
"x86_64-unknown-linux-gnu",
|
||||
"x86_64-apple-darwin",
|
||||
"x86_64-pc-windows-msvc",
|
||||
"wasm32-unknown-unknown",
|
||||
]
|
||||
|
||||
[package.metadata.cargo-machete]
|
||||
ignored = ["cfg_aliases"]
|
||||
|
||||
[features]
|
||||
device_lost_panic = []
|
||||
dx12 = [
|
||||
"dep:arrayvec",
|
||||
"dep:bit-set",
|
||||
"dep:bytemuck",
|
||||
"dep:gpu-allocator",
|
||||
"dep:libloading",
|
||||
"dep:once_cell",
|
||||
"dep:ordered-float",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:range-alloc",
|
||||
"dep:windows-core",
|
||||
"gpu-allocator/d3d12",
|
||||
"naga/hlsl-out",
|
||||
"once_cell/std",
|
||||
"windows/Win32_Devices_DeviceAndDriverInstallation",
|
||||
"windows/Win32_Devices_Display",
|
||||
"windows/Win32_Graphics_Direct3D_Dxc",
|
||||
"windows/Win32_Graphics_Direct3D_Fxc",
|
||||
"windows/Win32_Graphics_Direct3D",
|
||||
"windows/Win32_Graphics_Direct3D12",
|
||||
"windows/Win32_Graphics_DirectComposition",
|
||||
"windows/Win32_Graphics_Dxgi_Common",
|
||||
"windows/Win32_Graphics_Gdi",
|
||||
"windows/Win32_Security",
|
||||
"windows/Win32_System_Diagnostics_Debug",
|
||||
"windows/Win32_System_Kernel",
|
||||
"windows/Win32_System_Performance",
|
||||
"windows/Win32_System_Threading",
|
||||
"windows/Win32_UI_WindowsAndMessaging",
|
||||
]
|
||||
fragile-send-sync-non-atomic-wasm = ["wgpu-types/fragile-send-sync-non-atomic-wasm"]
|
||||
gles = [
|
||||
"dep:arrayvec",
|
||||
"dep:bytemuck",
|
||||
"dep:glow",
|
||||
"dep:glutin_wgl_sys",
|
||||
"dep:js-sys",
|
||||
"dep:khronos-egl",
|
||||
"dep:libloading",
|
||||
"dep:ndk-sys",
|
||||
"dep:objc2",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:wasm-bindgen",
|
||||
"dep:wayland-sys",
|
||||
"dep:web-sys",
|
||||
"dep:windows-result",
|
||||
"naga/glsl-out",
|
||||
"wgpu-types/web",
|
||||
"windows-result/std",
|
||||
"windows/Win32_Graphics_Gdi",
|
||||
"windows/Win32_Graphics_OpenGL",
|
||||
"windows/Win32_System_LibraryLoader",
|
||||
"windows/Win32_UI_WindowsAndMessaging",
|
||||
]
|
||||
internal_error_panic = []
|
||||
metal = [
|
||||
"naga/msl-out",
|
||||
"dep:arrayvec",
|
||||
"dep:block2",
|
||||
"dep:bytemuck",
|
||||
"dep:libloading",
|
||||
"dep:objc2",
|
||||
"dep:objc2-core-foundation",
|
||||
"dep:objc2-core-graphics",
|
||||
"dep:objc2-foundation",
|
||||
"dep:objc2-metal",
|
||||
"dep:objc2-quartz-core",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:smallvec",
|
||||
"dep:raw-window-metal",
|
||||
]
|
||||
portable-atomic = [
|
||||
"dep:portable-atomic",
|
||||
"dep:portable-atomic-util",
|
||||
]
|
||||
renderdoc = [
|
||||
"dep:libloading",
|
||||
"dep:renderdoc-sys",
|
||||
]
|
||||
static-dxc = ["dep:mach-dxcompiler-rs"]
|
||||
validation_canary = ["dep:parking_lot"]
|
||||
vulkan = [
|
||||
"naga/spv-out",
|
||||
"dep:android_system_properties",
|
||||
"dep:arrayvec",
|
||||
"dep:ash",
|
||||
"dep:bytemuck",
|
||||
"dep:libc",
|
||||
"dep:libloading",
|
||||
"dep:ordered-float",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:raw-window-metal",
|
||||
"dep:smallvec",
|
||||
"dep:windows",
|
||||
"gpu-allocator/vulkan",
|
||||
"windows/Win32",
|
||||
"windows/Win32_Devices_Display",
|
||||
"windows/Win32_Foundation",
|
||||
"windows/Win32_Graphics_Dxgi",
|
||||
"windows/Win32_Graphics_Dxgi_Common",
|
||||
"windows/Win32_Graphics_Gdi",
|
||||
]
|
||||
|
||||
[lib]
|
||||
name = "wgpu_hal"
|
||||
path = "src/lib.rs"
|
||||
|
||||
[[example]]
|
||||
name = "halmark"
|
||||
path = "examples/halmark/main.rs"
|
||||
|
||||
[[example]]
|
||||
name = "raw-gles"
|
||||
path = "examples/raw-gles.rs"
|
||||
required-features = ["gles"]
|
||||
|
||||
[[example]]
|
||||
name = "ray-traced-triangle"
|
||||
path = "examples/ray-traced-triangle/main.rs"
|
||||
|
||||
[dependencies.arrayvec]
|
||||
version = "0.7.1"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[dependencies.bitflags]
|
||||
version = "2.9"
|
||||
|
||||
[dependencies.bytemuck]
|
||||
version = "1.22"
|
||||
features = [
|
||||
"extern_crate_alloc",
|
||||
"min_const_generics",
|
||||
"derive",
|
||||
]
|
||||
optional = true
|
||||
|
||||
[dependencies.cfg-if]
|
||||
version = "1"
|
||||
|
||||
[dependencies.glow]
|
||||
version = "0.17"
|
||||
optional = true
|
||||
|
||||
[dependencies.hashbrown]
|
||||
version = "0.17"
|
||||
features = [
|
||||
"default-hasher",
|
||||
"inline-more",
|
||||
]
|
||||
default-features = false
|
||||
|
||||
[dependencies.log]
|
||||
version = "0.4.29"
|
||||
|
||||
[dependencies.naga]
|
||||
version = "30.0.0"
|
||||
|
||||
[dependencies.naga-types]
|
||||
version = "30.0.0"
|
||||
|
||||
[dependencies.ordered-float]
|
||||
version = ">=3, <6.0"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[dependencies.parking_lot]
|
||||
version = "0.12.3"
|
||||
optional = true
|
||||
|
||||
[dependencies.profiling]
|
||||
version = "1.0.1"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[dependencies.raw-window-handle]
|
||||
version = "0.6.2"
|
||||
default-features = false
|
||||
|
||||
[dependencies.static_assertions]
|
||||
version = "1.1"
|
||||
|
||||
[dependencies.thiserror]
|
||||
version = "2.0.12"
|
||||
default-features = false
|
||||
|
||||
[dependencies.wgpu-naga-bridge]
|
||||
version = "30.0.0"
|
||||
|
||||
[dependencies.wgpu-types]
|
||||
version = "30.0.0"
|
||||
default-features = false
|
||||
|
||||
[dev-dependencies.env_logger]
|
||||
version = "0.11"
|
||||
default-features = false
|
||||
|
||||
[dev-dependencies.glam]
|
||||
version = "0.33.0"
|
||||
|
||||
[dev-dependencies.naga]
|
||||
version = "30.0.0"
|
||||
features = [
|
||||
"wgsl-in",
|
||||
"termcolor",
|
||||
]
|
||||
|
||||
[dev-dependencies.winit]
|
||||
version = "0.30.8"
|
||||
features = ["android-native-activity"]
|
||||
|
||||
[build-dependencies.cfg_aliases]
|
||||
version = "0.2.2"
|
||||
|
||||
[target.'cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))'.dependencies.js-sys]
|
||||
version = "0.3.104"
|
||||
optional = true
|
||||
default-features = true
|
||||
|
||||
[target.'cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))'.dependencies.wasm-bindgen]
|
||||
version = "0.2.127"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))'.dependencies.web-sys]
|
||||
version = "0.3.104"
|
||||
features = [
|
||||
"default",
|
||||
"Window",
|
||||
"HtmlCanvasElement",
|
||||
"WebGl2RenderingContext",
|
||||
"OffscreenCanvas",
|
||||
"VideoFrame",
|
||||
]
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(all(unix, not(target_vendor = "apple"), not(target_family = "wasm")))'.dependencies.drm]
|
||||
version = "0.15"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(all(windows, not(target_arch = "aarch64"), target_env = "msvc"))'.dependencies.mach-dxcompiler-rs]
|
||||
version = "0.1.4"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(any(not(target_has_atomic = "64"), not(target_has_atomic = "ptr")))'.dependencies.portable-atomic]
|
||||
version = "1.10"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(not(any(target_arch = "wasm32", target_os = "ios", target_os = "visionos", target_env = "ohos")))'.dev-dependencies.glutin]
|
||||
version = "0.32"
|
||||
features = [
|
||||
"egl",
|
||||
"wgl",
|
||||
"wayland",
|
||||
"x11",
|
||||
]
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(not(any(target_arch = "wasm32", target_os = "ios", target_os = "visionos", target_env = "ohos")))'.dev-dependencies.glutin-winit]
|
||||
version = "0.5"
|
||||
features = [
|
||||
"egl",
|
||||
"wgl",
|
||||
"wayland",
|
||||
"x11",
|
||||
]
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies.ash]
|
||||
version = "0.38"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies.gpu-allocator]
|
||||
version = "0.28"
|
||||
features = ["hashbrown"]
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies.khronos-egl]
|
||||
version = "6"
|
||||
features = ["dynamic"]
|
||||
optional = true
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies.libloading]
|
||||
version = "0.8"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies.renderdoc-sys]
|
||||
version = "1"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies.smallvec]
|
||||
version = "1.14"
|
||||
features = ["union"]
|
||||
optional = true
|
||||
|
||||
[target.'cfg(not(target_has_atomic = "ptr"))'.dependencies.portable-atomic-util]
|
||||
version = "0.2.4"
|
||||
features = ["alloc"]
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_os = "android")'.dependencies.android_system_properties]
|
||||
version = "0.1.1"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_os = "android")'.dependencies.ndk-sys]
|
||||
version = "0.6"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_os = "emscripten")'.dependencies.khronos-egl]
|
||||
version = "6"
|
||||
features = [
|
||||
"static",
|
||||
"no-pkg-config",
|
||||
]
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_os = "emscripten")'.dependencies.libloading]
|
||||
version = "0.8"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.block2]
|
||||
version = "0.6.2"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.bytemuck]
|
||||
version = "1.22"
|
||||
features = [
|
||||
"extern_crate_alloc",
|
||||
"min_const_generics",
|
||||
]
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.objc2]
|
||||
version = "0.6.3"
|
||||
optional = true
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.objc2-core-foundation]
|
||||
version = "0.3.2"
|
||||
features = [
|
||||
"std",
|
||||
"CFCGTypes",
|
||||
]
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.objc2-core-graphics]
|
||||
version = "0.3.2"
|
||||
features = [
|
||||
"std",
|
||||
"CGColorSpace",
|
||||
]
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.objc2-foundation]
|
||||
version = "0.3.2"
|
||||
features = [
|
||||
"std",
|
||||
"NSError",
|
||||
"NSProcessInfo",
|
||||
"NSRange",
|
||||
"NSString",
|
||||
]
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.objc2-metal]
|
||||
version = "0.3.2"
|
||||
features = [
|
||||
"std",
|
||||
"block2",
|
||||
"MTLAllocation",
|
||||
"MTLBlitCommandEncoder",
|
||||
"MTLBlitPass",
|
||||
"MTLBuffer",
|
||||
"MTLCaptureManager",
|
||||
"MTLCaptureScope",
|
||||
"MTLCommandBuffer",
|
||||
"MTLCommandEncoder",
|
||||
"MTLCommandQueue",
|
||||
"MTLComputeCommandEncoder",
|
||||
"MTLComputePass",
|
||||
"MTLComputePipeline",
|
||||
"MTLCounters",
|
||||
"MTLDepthStencil",
|
||||
"MTLDevice",
|
||||
"MTLDrawable",
|
||||
"MTLEvent",
|
||||
"MTLLibrary",
|
||||
"MTLPipeline",
|
||||
"MTLPixelFormat",
|
||||
"MTLRenderCommandEncoder",
|
||||
"MTLRenderPass",
|
||||
"MTLRenderPipeline",
|
||||
"MTLResource",
|
||||
"MTLSampler",
|
||||
"MTLStageInputOutputDescriptor",
|
||||
"MTLTexture",
|
||||
"MTLTypes",
|
||||
"MTLVertexDescriptor",
|
||||
"MTLAccelerationStructure",
|
||||
"MTLAccelerationStructureTypes",
|
||||
"MTLAccelerationStructureCommandEncoder",
|
||||
"MTLResidencySet",
|
||||
]
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.objc2-quartz-core]
|
||||
version = "0.3.2"
|
||||
features = [
|
||||
"std",
|
||||
"objc2-core-foundation",
|
||||
"objc2-core-graphics",
|
||||
"CALayer",
|
||||
"CAMetalLayer",
|
||||
"objc2-metal",
|
||||
]
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies.raw-window-metal]
|
||||
version = "1.0"
|
||||
optional = true
|
||||
|
||||
[target."cfg(unix)".dependencies.libc]
|
||||
version = "0.2.183"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target."cfg(unix)".dependencies.wayland-sys]
|
||||
version = "0.31.3"
|
||||
features = [
|
||||
"client",
|
||||
"dlopen",
|
||||
"egl",
|
||||
]
|
||||
optional = true
|
||||
|
||||
[target."cfg(windows)".dependencies.bit-set]
|
||||
version = "0.10"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target."cfg(windows)".dependencies.glutin_wgl_sys]
|
||||
version = "0.6"
|
||||
optional = true
|
||||
|
||||
[target."cfg(windows)".dependencies.once_cell]
|
||||
version = "1.21"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target."cfg(windows)".dependencies.range-alloc]
|
||||
version = "0.1"
|
||||
optional = true
|
||||
|
||||
[target."cfg(windows)".dependencies.windows]
|
||||
version = "0.62"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target."cfg(windows)".dependencies.windows-core]
|
||||
version = "0.62"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[target."cfg(windows)".dependencies.windows-result]
|
||||
version = "0.4"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[lints.rust]
|
||||
missing_debug_implementations = "warn"
|
||||
|
||||
[lints.rust.unexpected_cfgs]
|
||||
level = "warn"
|
||||
priority = 0
|
||||
check-cfg = [
|
||||
'cfg(feature, values("cargo-clippy"))',
|
||||
"cfg(web_sys_unstable_apis)",
|
||||
]
|
||||
+365
@@ -0,0 +1,365 @@
|
||||
[package]
|
||||
name = "wgpu-hal"
|
||||
version.workspace = true
|
||||
authors.workspace = true
|
||||
edition.workspace = true
|
||||
description = "Hardware abstraction layer for wgpu, the cross-platform, safe, pure-rust graphics API"
|
||||
homepage.workspace = true
|
||||
repository.workspace = true
|
||||
keywords.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
# Override the workspace's `rust-version` key. `wgpu-core` and its dependencies
|
||||
# have a less strict MSRV, to allow firefox more leeway in updating their Rust toolchain.
|
||||
#
|
||||
# See the repo README for more information on MSRV policy.
|
||||
rust-version = "1.87"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
# Ideally we would enable all the features.
|
||||
#
|
||||
# However, the dx12 features fail to be documented because the docs.rs runner cross-compiling under
|
||||
# x86_64-unknown-linux-gnu cannot compile in that environment at the moment.
|
||||
features = ["metal", "vulkan", "gles", "renderdoc"]
|
||||
rustdoc-args = ["--cfg", "docsrs"]
|
||||
targets = [
|
||||
"x86_64-unknown-linux-gnu",
|
||||
"x86_64-apple-darwin",
|
||||
"x86_64-pc-windows-msvc",
|
||||
"wasm32-unknown-unknown",
|
||||
]
|
||||
|
||||
[package.metadata.cargo-machete]
|
||||
# Cargo machete can't check build.rs dependencies. See https://github.com/bnjbvr/cargo-machete/issues/100
|
||||
ignored = ["cfg_aliases"]
|
||||
|
||||
[lints.rust]
|
||||
missing_debug_implementations = "warn"
|
||||
unexpected_cfgs = { level = "warn", check-cfg = [
|
||||
'cfg(feature, values("cargo-clippy"))', # objc's `msg_send` macro injects this in our code https://github.com/SSheldon/rust-objc/issues/125
|
||||
'cfg(web_sys_unstable_apis)', # web-sys uses this
|
||||
] }
|
||||
|
||||
[lib]
|
||||
|
||||
[features]
|
||||
########################
|
||||
### Backend Features ###
|
||||
########################
|
||||
|
||||
# The interaction of features between wgpu-core and wgpu-hal is a bit nuanced to get
|
||||
# the desired behavior on all platforms.
|
||||
#
|
||||
# At the wgpu-hal level the features are defined to enable the backends on all platforms
|
||||
# that can compile the backend. Vulkan for example will have an effect on Windows, Mac, Linux, and Android.
|
||||
# This is done with target conditional dependencies in wgpu-hal. This allows `--all-features`
|
||||
# to compile on all platforms.
|
||||
#
|
||||
# wgpu-core's features are defined to enable the backends on their "default" platforms. For example we
|
||||
# exclude the Vulkan backend on MacOS unless a separate feature `vulkan-portability` is enabled. In response
|
||||
# to these features, it enables features of platform specific crates. For example, the `vulkan` feature in wgpu-core
|
||||
# enables the `vulkan` feature in `wgpu-core-deps-windows-linux-android` which in turn enables the
|
||||
# `vulkan` feature in `wgpu-hal` _only_ on those platforms. If you enable the `vulkan-portability` feature, it
|
||||
# will enable the `vulkan` feature in `wgpu-core-deps-apple`. The only way to do this is unfortunately to have
|
||||
# a separate crate for each platform category that participates in the feature unification.
|
||||
#
|
||||
# This trick doesn't work at the `wgpu` level, because the `wgpu` -> `wgpu-core` dependency is conditional,
|
||||
# making the Cargo.toml signifigantly more complicated in all areas.
|
||||
#
|
||||
# See https://github.com/gfx-rs/wgpu/issues/3514, https://github.com/gfx-rs/wgpu/pull/7076,
|
||||
# and https://github.com/rust-lang/cargo/issues/1197 for more information.
|
||||
|
||||
## Enables the Metal backend when targeting Apple platforms.
|
||||
metal = [
|
||||
# Metal is only available on Apple platforms, therefore request MSL output also only if we target an Apple platform.
|
||||
"naga/msl-out",
|
||||
"dep:arrayvec",
|
||||
"dep:block2",
|
||||
"dep:bytemuck",
|
||||
"dep:libloading",
|
||||
"dep:objc2",
|
||||
"dep:objc2-core-foundation",
|
||||
"dep:objc2-core-graphics",
|
||||
"dep:objc2-foundation",
|
||||
"dep:objc2-metal",
|
||||
"dep:objc2-quartz-core",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:smallvec",
|
||||
"dep:raw-window-metal",
|
||||
]
|
||||
vulkan = [
|
||||
"naga/spv-out",
|
||||
"dep:android_system_properties",
|
||||
"dep:arrayvec",
|
||||
"dep:ash",
|
||||
"dep:bytemuck",
|
||||
"dep:libc",
|
||||
"dep:libloading",
|
||||
"dep:ordered-float",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:raw-window-metal",
|
||||
"dep:smallvec",
|
||||
"dep:windows",
|
||||
"gpu-allocator/vulkan",
|
||||
"windows/Win32",
|
||||
"windows/Win32_Devices_Display",
|
||||
"windows/Win32_Foundation",
|
||||
"windows/Win32_Graphics_Dxgi",
|
||||
"windows/Win32_Graphics_Dxgi_Common",
|
||||
"windows/Win32_Graphics_Gdi",
|
||||
]
|
||||
gles = [
|
||||
"dep:arrayvec",
|
||||
"dep:bytemuck",
|
||||
"dep:glow",
|
||||
"dep:glutin_wgl_sys",
|
||||
"dep:js-sys",
|
||||
"dep:khronos-egl",
|
||||
"dep:libloading",
|
||||
"dep:ndk-sys",
|
||||
"dep:objc2",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:wasm-bindgen",
|
||||
"dep:wayland-sys",
|
||||
"dep:web-sys",
|
||||
"dep:windows-result",
|
||||
"naga/glsl-out",
|
||||
"wgpu-types/web",
|
||||
"windows-result/std", # Need to enable this for the `Error` impl on `windows_result::Error` to work.
|
||||
"windows/Win32_Graphics_Gdi",
|
||||
"windows/Win32_Graphics_OpenGL",
|
||||
"windows/Win32_System_LibraryLoader",
|
||||
"windows/Win32_UI_WindowsAndMessaging",
|
||||
]
|
||||
## Enables the DX12 backend when targeting Windows.
|
||||
dx12 = [
|
||||
"dep:arrayvec",
|
||||
"dep:bit-set",
|
||||
"dep:bytemuck",
|
||||
"dep:gpu-allocator",
|
||||
"dep:libloading",
|
||||
"dep:once_cell",
|
||||
"dep:ordered-float",
|
||||
"dep:parking_lot",
|
||||
"dep:profiling",
|
||||
"dep:range-alloc",
|
||||
"dep:windows-core",
|
||||
"gpu-allocator/d3d12",
|
||||
"naga/hlsl-out",
|
||||
"once_cell/std",
|
||||
"windows/Win32_Devices_DeviceAndDriverInstallation",
|
||||
"windows/Win32_Devices_Display",
|
||||
"windows/Win32_Graphics_Direct3D_Dxc",
|
||||
"windows/Win32_Graphics_Direct3D_Fxc",
|
||||
"windows/Win32_Graphics_Direct3D",
|
||||
"windows/Win32_Graphics_Direct3D12",
|
||||
"windows/Win32_Graphics_DirectComposition",
|
||||
"windows/Win32_Graphics_Dxgi_Common",
|
||||
"windows/Win32_Graphics_Gdi",
|
||||
"windows/Win32_Security",
|
||||
"windows/Win32_System_Diagnostics_Debug",
|
||||
"windows/Win32_System_Kernel",
|
||||
"windows/Win32_System_Performance",
|
||||
"windows/Win32_System_Threading",
|
||||
"windows/Win32_UI_WindowsAndMessaging",
|
||||
]
|
||||
|
||||
###########################
|
||||
### Misc Other Features ###
|
||||
###########################
|
||||
|
||||
static-dxc = ["dep:mach-dxcompiler-rs"]
|
||||
renderdoc = ["dep:libloading", "dep:renderdoc-sys"]
|
||||
fragile-send-sync-non-atomic-wasm = [
|
||||
"wgpu-types/fragile-send-sync-non-atomic-wasm",
|
||||
]
|
||||
portable-atomic = ["dep:portable-atomic", "dep:portable-atomic-util"]
|
||||
|
||||
###################################
|
||||
### Internal Debugging Features ###
|
||||
###################################
|
||||
|
||||
# Panic when running into a device lost error (for debugging purposes).
|
||||
# Only affects the d3d12 and vulkan backends.
|
||||
device_lost_panic = []
|
||||
# Panic when running into an internal error other than out-of-memory and device lost
|
||||
# (for debugging purposes).
|
||||
#
|
||||
# Only affects the d3d12 and vulkan backends.
|
||||
internal_error_panic = []
|
||||
# Tracks validation errors in a `VALIDATION_CANARY` static.
|
||||
validation_canary = ["dep:parking_lot"]
|
||||
|
||||
[[example]]
|
||||
name = "halmark"
|
||||
|
||||
[[example]]
|
||||
name = "raw-gles"
|
||||
required-features = ["gles"]
|
||||
|
||||
#####################
|
||||
### Platform: All ###
|
||||
#####################
|
||||
|
||||
[dependencies]
|
||||
naga.workspace = true
|
||||
wgpu-naga-bridge.workspace = true
|
||||
naga-types = { workspace = true }
|
||||
wgpu-types = { workspace = true, default-features = false }
|
||||
|
||||
# Dependencies in the lib and empty backend
|
||||
bitflags.workspace = true
|
||||
cfg-if.workspace = true
|
||||
log = { workspace = true }
|
||||
parking_lot = { workspace = true, optional = true }
|
||||
raw-window-handle.workspace = true
|
||||
thiserror.workspace = true
|
||||
|
||||
# Target agnostic dependencies used only in backends.
|
||||
arrayvec = { workspace = true, optional = true }
|
||||
bytemuck = { workspace = true, optional = true, features = ["derive"] }
|
||||
hashbrown = { workspace = true }
|
||||
ordered-float = { workspace = true, optional = true }
|
||||
profiling = { workspace = true, optional = true, default-features = false }
|
||||
static_assertions = { workspace = true }
|
||||
|
||||
# Backend: GLES
|
||||
glow = { workspace = true, optional = true }
|
||||
|
||||
########################
|
||||
### Platform: Native ###
|
||||
########################
|
||||
|
||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
||||
# Backend: Vulkan and Dx12
|
||||
gpu-allocator = { workspace = true, optional = true }
|
||||
# Backend: Vulkan
|
||||
ash = { workspace = true, optional = true }
|
||||
smallvec = { workspace = true, optional = true, features = ["union"] }
|
||||
# Backend: GLES
|
||||
khronos-egl = { workspace = true, features = ["dynamic"], optional = true }
|
||||
libloading = { workspace = true, optional = true }
|
||||
renderdoc-sys = { workspace = true, optional = true }
|
||||
|
||||
##########################
|
||||
### Platform: All Unix ###
|
||||
##########################
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
# Backend: Vulkan
|
||||
libc = { workspace = true, optional = true }
|
||||
# backend: GLES
|
||||
wayland-sys = { version = "0.31.3", features = [
|
||||
"client",
|
||||
"dlopen",
|
||||
"egl",
|
||||
], optional = true }
|
||||
|
||||
## Support creating textures from DRM display/window handles.
|
||||
[target.'cfg(all(unix, not(target_vendor = "apple"), not(target_family = "wasm")))'.dependencies]
|
||||
drm = { version = "0.15", optional = true }
|
||||
|
||||
#########################
|
||||
### Platform: Windows ###
|
||||
#########################
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
# Backend: Dx12 and GLES
|
||||
windows = { workspace = true, optional = true }
|
||||
windows-core = { workspace = true, optional = true }
|
||||
windows-result = { workspace = true, optional = true }
|
||||
# Backend: Dx12
|
||||
bit-set = { workspace = true, optional = true }
|
||||
range-alloc = { workspace = true, optional = true }
|
||||
once_cell = { workspace = true, optional = true }
|
||||
# backend: GLES
|
||||
glutin_wgl_sys = { workspace = true, optional = true }
|
||||
|
||||
### Platform: x86/x86_64 Windows ###
|
||||
# This doesn't support aarch64. See https://github.com/gfx-rs/wgpu/issues/6860.
|
||||
# This doesn't support x86_64-pc-windows-gnu. See https://github.com/gfx-rs/wgpu/issues/8303
|
||||
#
|
||||
# ⚠️ Keep in sync with static_dxc cfg in build.rs and cfg_alias in `wgpu` crate ⚠️
|
||||
[target.'cfg(all(windows, not(target_arch = "aarch64"), target_env = "msvc"))'.dependencies]
|
||||
mach-dxcompiler-rs = { workspace = true, optional = true }
|
||||
|
||||
#######################
|
||||
### Platform: Apple ###
|
||||
#######################
|
||||
|
||||
[target.'cfg(target_vendor = "apple")'.dependencies]
|
||||
# Backend: Metal
|
||||
block2 = { workspace = true, optional = true }
|
||||
bytemuck = { workspace = true, optional = true }
|
||||
objc2 = { workspace = true, optional = true }
|
||||
objc2-core-foundation = { workspace = true, optional = true }
|
||||
objc2-core-graphics = { workspace = true, optional = true }
|
||||
objc2-foundation = { workspace = true, optional = true }
|
||||
objc2-metal = { workspace = true, optional = true }
|
||||
objc2-quartz-core = { workspace = true, optional = true }
|
||||
|
||||
# backend: Metal + Vulkan
|
||||
raw-window-metal = { workspace = true, optional = true }
|
||||
|
||||
#########################
|
||||
### Platform: Android ###
|
||||
#########################
|
||||
|
||||
[target.'cfg(target_os = "android")'.dependencies]
|
||||
android_system_properties = { workspace = true, optional = true }
|
||||
ndk-sys = { workspace = true, optional = true }
|
||||
|
||||
#############################
|
||||
### Platform: Webassembly ###
|
||||
#############################
|
||||
|
||||
[target.'cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))'.dependencies]
|
||||
# Backend: GLES
|
||||
wasm-bindgen = { workspace = true, optional = true }
|
||||
web-sys = { workspace = true, optional = true, features = [
|
||||
"default",
|
||||
"Window",
|
||||
"HtmlCanvasElement",
|
||||
"WebGl2RenderingContext",
|
||||
"OffscreenCanvas",
|
||||
"VideoFrame",
|
||||
] }
|
||||
js-sys = { workspace = true, optional = true, default-features = true }
|
||||
|
||||
############################
|
||||
### Platform: Emscripten ###
|
||||
############################
|
||||
|
||||
[target.'cfg(target_os = "emscripten")'.dependencies]
|
||||
# Backend: GLES
|
||||
khronos-egl = { workspace = true, optional = true, features = [
|
||||
"static",
|
||||
"no-pkg-config",
|
||||
] }
|
||||
# Note: it's unused by emscripten, but we keep it to have single code base in egl.rs
|
||||
libloading = { workspace = true, optional = true }
|
||||
|
||||
[target.'cfg(any(not(target_has_atomic = "64"), not(target_has_atomic = "ptr")))'.dependencies]
|
||||
portable-atomic = { workspace = true, optional = true }
|
||||
|
||||
[target.'cfg(not(target_has_atomic = "ptr"))'.dependencies]
|
||||
portable-atomic-util = { workspace = true, features = [
|
||||
"alloc",
|
||||
], optional = true }
|
||||
|
||||
[build-dependencies]
|
||||
cfg_aliases.workspace = true
|
||||
|
||||
[dev-dependencies]
|
||||
env_logger.workspace = true
|
||||
glam.workspace = true # for ray-traced-triangle example
|
||||
naga = { workspace = true, features = ["wgsl-in", "termcolor"] }
|
||||
winit.workspace = true # for "halmark" example
|
||||
|
||||
### Platform: Windows + MacOS + Linux for "raw-gles" example ###
|
||||
[target.'cfg(not(any(target_arch = "wasm32", target_os = "ios", target_os = "visionos", target_env = "ohos")))'.dev-dependencies]
|
||||
glutin-winit = { workspace = true, features = ["egl", "wgl", "wayland", "x11"] }
|
||||
glutin = { workspace = true, features = ["egl", "wgl", "wayland", "x11"] }
|
||||
Vendored
+176
@@ -0,0 +1,176 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
Vendored
+21
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2025 The gfx-rs developers
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
Vendored
+119
@@ -0,0 +1,119 @@
|
||||
# `wgpu_hal`: a cross-platform unsafe graphics abstraction
|
||||
|
||||
This crate defines a set of traits abstracting over modern graphics APIs,
|
||||
with implementations ("backends") for Vulkan, Metal, Direct3D, and GL.
|
||||
|
||||
`wgpu_hal` is a spiritual successor to
|
||||
[gfx-hal](https://github.com/gfx-rs/gfx), but with reduced scope, and
|
||||
oriented towards WebGPU implementation goals. It has no overhead for
|
||||
validation or tracking, and the API translation overhead is kept to the bare
|
||||
minimum by the design of WebGPU. This API can be used for resource-demanding
|
||||
applications and engines.
|
||||
|
||||
The `wgpu_hal` crate's main design choices:
|
||||
|
||||
- Our traits are meant to be _portable_: proper use
|
||||
should get equivalent results regardless of the backend.
|
||||
|
||||
- Our traits' contracts are _unsafe_: implementations perform minimal
|
||||
validation, if any, and incorrect use will often cause undefined behavior.
|
||||
This allows us to minimize the overhead we impose over the underlying
|
||||
graphics system. If you need safety, the [`wgpu-core`] crate provides a
|
||||
safe API for driving `wgpu_hal`, implementing all necessary validation,
|
||||
resource state tracking, and so on. (Note that `wgpu-core` is designed for
|
||||
use via FFI; the [`wgpu`] crate provides more idiomatic Rust bindings for
|
||||
`wgpu-core`.) Or, you can do your own validation.
|
||||
|
||||
- In the same vein, returned errors _only cover cases the user can't
|
||||
anticipate_, like running out of memory or losing the device. Any errors
|
||||
that the user could reasonably anticipate are their responsibility to
|
||||
avoid. For example, `wgpu_hal` returns no error for mapping a buffer that's
|
||||
not mappable: as the buffer creator, the user should already know if they
|
||||
can map it.
|
||||
|
||||
- We use _static dispatch_. The traits are not
|
||||
generally object-safe. You must select a specific backend type
|
||||
like [`vulkan::Api`] or [`metal::Api`], and then use that
|
||||
according to the main traits, or call backend-specific methods.
|
||||
|
||||
- We use _idiomatic Rust parameter passing_,
|
||||
taking objects by reference, returning them by value, and so on,
|
||||
unlike `wgpu-core`, which refers to objects by ID.
|
||||
|
||||
- We map buffer contents _persistently_. This means that the buffer
|
||||
can remain mapped on the CPU while the GPU reads or writes to it.
|
||||
You must explicitly indicate when data might need to be
|
||||
transferred between CPU and GPU, if `wgpu_hal` indicates that the
|
||||
mapping is not coherent (that is, automatically synchronized
|
||||
between the two devices).
|
||||
|
||||
- You must record _explicit barriers_ between different usages of a
|
||||
resource. For example, if a buffer is written to by a compute
|
||||
shader, and then used as and index buffer to a draw call, you
|
||||
must use [`CommandEncoder::transition_buffers`] between those two
|
||||
operations.
|
||||
|
||||
- Pipeline layouts are _explicitly specified_ when setting bind
|
||||
group. Incompatible layouts disturb groups bound at higher indices.
|
||||
|
||||
- The API _accepts collections as iterators_, to avoid forcing the user to
|
||||
store data in particular containers. The implementation doesn't guarantee
|
||||
that any of the iterators are drained, unless stated otherwise by the
|
||||
function documentation. For this reason, we recommend that iterators don't
|
||||
do any mutating work.
|
||||
|
||||
Unfortunately, `wgpu_hal`'s safety requirements are not fully documented.
|
||||
Ideally, all trait methods would have doc comments setting out the
|
||||
requirements users must meet to ensure correct and portable behavior. If you
|
||||
are aware of a specific requirement that a backend imposes that is not
|
||||
ensured by the traits' documented rules, please file an issue. Or, if you are
|
||||
a capable technical writer, please file a pull request!
|
||||
|
||||
[`wgpu-core`]: https://crates.io/crates/wgpu-core
|
||||
[`wgpu`]: https://crates.io/crates/wgpu
|
||||
[`vulkan::Api`]: vulkan/struct.Api.html
|
||||
[`metal::Api`]: metal/struct.Api.html
|
||||
|
||||
## Primary backends
|
||||
|
||||
The `wgpu_hal` crate has full-featured backends implemented on the following
|
||||
platform graphics APIs:
|
||||
|
||||
- Vulkan, available on Linux, Android, and Windows, using the [`ash`] crate's
|
||||
Vulkan bindings. It's also available on macOS, if you install [MoltenVK].
|
||||
|
||||
- Metal on macOS, using the [`metal`] crate's bindings.
|
||||
|
||||
- Direct3D 12 on Windows, using the [`windows`] crate's bindings.
|
||||
|
||||
[`ash`]: https://crates.io/crates/ash
|
||||
[MoltenVK]: https://github.com/KhronosGroup/MoltenVK
|
||||
[`metal`]: https://crates.io/crates/metal
|
||||
[`windows`]: https://crates.io/crates/windows
|
||||
|
||||
## Secondary backends
|
||||
|
||||
The `wgpu_hal` crate has a partial implementation based on the following
|
||||
platform graphics API:
|
||||
|
||||
- The GL backend is available anywhere OpenGL, OpenGL ES, or WebGL are
|
||||
available. See the [`gles`] module documentation for details.
|
||||
|
||||
[`gles`]: gles/index.html
|
||||
|
||||
You can see what capabilities an adapter is missing by checking the
|
||||
[`DownlevelCapabilities`][tdc] in [`ExposedAdapter::capabilities`], available
|
||||
from [`Instance::enumerate_adapters`].
|
||||
|
||||
The API is generally designed to fit the primary backends better than the
|
||||
secondary backends, so the latter may impose more overhead.
|
||||
|
||||
[tdc]: wgt::DownlevelCapabilities
|
||||
|
||||
## Debugging
|
||||
|
||||
Most of the information on the wiki [Debugging wgpu Applications][wiki-debug]
|
||||
page still applies to this API, with the exception of API tracing/replay
|
||||
functionality, which is only available in `wgpu-core`.
|
||||
|
||||
[wiki-debug]: https://github.com/gfx-rs/wgpu/wiki/Debugging-wgpu-Applications
|
||||
Vendored
+36
@@ -0,0 +1,36 @@
|
||||
fn main() {
|
||||
cfg_aliases::cfg_aliases! {
|
||||
native: { not(target_arch = "wasm32") },
|
||||
send_sync: { any(
|
||||
not(target_arch = "wasm32"),
|
||||
all(feature = "fragile-send-sync-non-atomic-wasm", not(target_feature = "atomics"))
|
||||
) },
|
||||
webgl: { all(target_arch = "wasm32", not(target_os = "emscripten"), gles) },
|
||||
Emscripten: { all(target_os = "emscripten", gles) },
|
||||
dx12: { all(target_os = "windows", feature = "dx12") },
|
||||
gles: { all(feature = "gles") },
|
||||
// Within the GL ES backend, use `std` and be Send + Sync only if we are using a target
|
||||
// that, among the ones where the GL ES backend is supported, has `std`.
|
||||
gles_with_std: { all(
|
||||
feature = "gles",
|
||||
any(
|
||||
not(target_arch = "wasm32"),
|
||||
// Accept wasm32-unknown-unknown, which uniquely has a stub `std`
|
||||
all(target_vendor = "unknown", target_os = "unknown"),
|
||||
// Accept wasm32-unknown-emscripten and similar, which has a real `std`
|
||||
target_os = "emscripten"
|
||||
)
|
||||
) },
|
||||
metal: { all(target_vendor = "apple", feature = "metal") },
|
||||
vulkan: { all(not(target_arch = "wasm32"), feature = "vulkan") },
|
||||
drm: { all(
|
||||
feature = "drm",
|
||||
any(target_os = "linux", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd")
|
||||
) },
|
||||
any_backend: { any(dx12, metal, vulkan, gles) },
|
||||
// ⚠️ Keep in sync with target.cfg() definition in Cargo.toml and cfg_alias in `wgpu` crate ⚠️
|
||||
static_dxc: { all(target_os = "windows", feature = "static-dxc", not(target_arch = "aarch64"), target_env = "msvc") },
|
||||
supports_64bit_atomics: { target_has_atomic = "64" },
|
||||
supports_ptr_atomics: { target_has_atomic = "ptr" }
|
||||
}
|
||||
}
|
||||
+919
@@ -0,0 +1,919 @@
|
||||
//! This example shows basic usage of wgpu-hal by rendering
|
||||
//! a ton of moving sprites, each with a separate texture and draw call.
|
||||
extern crate wgpu_hal as hal;
|
||||
|
||||
use hal::{
|
||||
Adapter as _, CommandEncoder as _, Device as _, Instance as _, Queue as _, Surface as _,
|
||||
};
|
||||
use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
|
||||
use winit::{
|
||||
application::ApplicationHandler,
|
||||
event::{ElementState, KeyEvent, WindowEvent},
|
||||
event_loop::{ActiveEventLoop, ControlFlow},
|
||||
keyboard::{Key, NamedKey},
|
||||
window::Window,
|
||||
};
|
||||
|
||||
use std::{
|
||||
borrow::{Borrow, Cow},
|
||||
iter,
|
||||
num::NonZeroU64,
|
||||
ptr,
|
||||
time::Instant,
|
||||
};
|
||||
|
||||
const MAX_BUNNIES: usize = 1 << 20;
|
||||
const BUNNY_SIZE: f32 = 0.15 * 256.0;
|
||||
const GRAVITY: f32 = -9.8 * 100.0;
|
||||
const MAX_VELOCITY: f32 = 750.0;
|
||||
const DESIRED_MAX_LATENCY: u32 = 2;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy)]
|
||||
struct Globals {
|
||||
mvp: [[f32; 4]; 4],
|
||||
size: [f32; 2],
|
||||
pad: [f32; 2],
|
||||
}
|
||||
|
||||
#[repr(C, align(256))]
|
||||
#[derive(Clone, Copy)]
|
||||
struct Locals {
|
||||
position: [f32; 2],
|
||||
velocity: [f32; 2],
|
||||
color: u32,
|
||||
_pad: u32,
|
||||
}
|
||||
|
||||
struct ExecutionContext<A: hal::Api> {
|
||||
encoder: A::CommandEncoder,
|
||||
fence: A::Fence,
|
||||
fence_value: hal::FenceValue,
|
||||
used_views: Vec<A::TextureView>,
|
||||
used_cmd_bufs: Vec<A::CommandBuffer>,
|
||||
frames_recorded: usize,
|
||||
}
|
||||
|
||||
impl<A: hal::Api> ExecutionContext<A> {
|
||||
unsafe fn wait_and_clear(&mut self, device: &A::Device) {
|
||||
device.wait(&self.fence, self.fence_value, None).unwrap();
|
||||
self.encoder.reset_all(self.used_cmd_bufs.drain(..));
|
||||
for view in self.used_views.drain(..) {
|
||||
device.destroy_texture_view(view);
|
||||
}
|
||||
self.frames_recorded = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
struct Example<A: hal::Api> {
|
||||
instance: A::Instance,
|
||||
adapter: A::Adapter,
|
||||
surface: A::Surface,
|
||||
surface_format: wgpu_types::TextureFormat,
|
||||
device: A::Device,
|
||||
queue: A::Queue,
|
||||
global_group: A::BindGroup,
|
||||
local_group: A::BindGroup,
|
||||
global_group_layout: A::BindGroupLayout,
|
||||
local_group_layout: A::BindGroupLayout,
|
||||
pipeline_layout: A::PipelineLayout,
|
||||
shader: A::ShaderModule,
|
||||
pipeline: A::RenderPipeline,
|
||||
bunnies: Vec<Locals>,
|
||||
local_buffer: A::Buffer,
|
||||
local_alignment: u32,
|
||||
global_buffer: A::Buffer,
|
||||
sampler: A::Sampler,
|
||||
texture: A::Texture,
|
||||
texture_view: A::TextureView,
|
||||
contexts: Vec<ExecutionContext<A>>,
|
||||
context_index: usize,
|
||||
extent: [u32; 2],
|
||||
start: Instant,
|
||||
}
|
||||
|
||||
impl<A: hal::Api> Example<A> {
|
||||
fn init(window: &winit::window::Window) -> Result<Self, Box<dyn std::error::Error>> {
|
||||
// The Instance can be initialized with the DisplayHandle from the EventLoop as well
|
||||
let raw_display_handle = window.display_handle()?;
|
||||
|
||||
let instance_desc = hal::InstanceDescriptor {
|
||||
name: "example",
|
||||
flags: wgpu_types::InstanceFlags::from_build_config().with_env(),
|
||||
memory_budget_thresholds: wgpu_types::MemoryBudgetThresholds::default(),
|
||||
// Can't rely on having DXC available, so use FXC instead
|
||||
backend_options: wgpu_types::BackendOptions::default(),
|
||||
telemetry: None,
|
||||
display: Some(raw_display_handle),
|
||||
};
|
||||
let instance = unsafe { A::Instance::init(&instance_desc)? };
|
||||
let surface = {
|
||||
let raw_window_handle = window.window_handle()?.as_raw();
|
||||
|
||||
unsafe {
|
||||
instance
|
||||
.create_surface(raw_display_handle.as_raw(), raw_window_handle)
|
||||
.unwrap()
|
||||
}
|
||||
};
|
||||
|
||||
let (adapter, capabilities) = unsafe {
|
||||
let mut adapters = instance.enumerate_adapters(Some(&surface));
|
||||
if adapters.is_empty() {
|
||||
return Err("no adapters found".into());
|
||||
}
|
||||
let exposed = adapters.swap_remove(0);
|
||||
(exposed.adapter, exposed.capabilities)
|
||||
};
|
||||
|
||||
let surface_caps = unsafe { adapter.surface_capabilities(&surface) }
|
||||
.ok_or("failed to get surface capabilities")?;
|
||||
log::info!("Surface caps: {surface_caps:#?}");
|
||||
|
||||
let hal::OpenDevice { device, queue } = unsafe {
|
||||
adapter
|
||||
.open(
|
||||
wgpu_types::Features::empty(),
|
||||
&wgpu_types::Limits::default(),
|
||||
&wgpu_types::MemoryHints::default(),
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
|
||||
let window_size: (u32, u32) = window.inner_size().into();
|
||||
let surface_config = hal::SurfaceConfiguration {
|
||||
maximum_frame_latency: DESIRED_MAX_LATENCY.clamp(
|
||||
*surface_caps.maximum_frame_latency.start(),
|
||||
*surface_caps.maximum_frame_latency.end(),
|
||||
),
|
||||
present_mode: wgpu_types::PresentMode::Fifo,
|
||||
composite_alpha_mode: wgpu_types::CompositeAlphaMode::Opaque,
|
||||
format: wgpu_types::TextureFormat::Bgra8UnormSrgb,
|
||||
color_space: wgpu_types::SurfaceColorSpace::Srgb,
|
||||
extent: wgpu_types::Extent3d {
|
||||
width: window_size.0,
|
||||
height: window_size.1,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
usage: wgpu_types::TextureUses::COLOR_TARGET,
|
||||
view_formats: vec![],
|
||||
};
|
||||
unsafe {
|
||||
surface.configure(&device, &surface_config).unwrap();
|
||||
};
|
||||
|
||||
let naga_shader = {
|
||||
let shader_file = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("examples")
|
||||
.join("halmark")
|
||||
.join("shader.wgsl");
|
||||
let source = std::fs::read_to_string(shader_file).unwrap();
|
||||
let module = naga::front::wgsl::Frontend::new().parse(&source).unwrap();
|
||||
let info = naga::valid::Validator::new(
|
||||
naga::valid::ValidationFlags::all(),
|
||||
naga::valid::Capabilities::empty(),
|
||||
)
|
||||
.validate(&module)
|
||||
.unwrap();
|
||||
hal::NagaShader {
|
||||
module: Cow::Owned(module),
|
||||
info,
|
||||
debug_source: None,
|
||||
}
|
||||
};
|
||||
let shader_desc = hal::ShaderModuleDescriptor {
|
||||
label: None,
|
||||
runtime_checks: wgpu_types::ShaderRuntimeChecks::checked(),
|
||||
};
|
||||
let shader = unsafe {
|
||||
device
|
||||
.create_shader_module(&shader_desc, hal::ShaderInput::Naga(naga_shader))
|
||||
.unwrap()
|
||||
};
|
||||
|
||||
let global_bgl_desc = hal::BindGroupLayoutDescriptor {
|
||||
label: None,
|
||||
flags: hal::BindGroupLayoutFlags::empty(),
|
||||
entries: &[
|
||||
wgpu_types::BindGroupLayoutEntry {
|
||||
binding: 0,
|
||||
visibility: wgpu_types::ShaderStages::VERTEX,
|
||||
ty: wgpu_types::BindingType::Buffer {
|
||||
ty: wgpu_types::BufferBindingType::Uniform,
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: wgpu_types::BufferSize::new(size_of::<Globals>() as _),
|
||||
},
|
||||
count: None,
|
||||
},
|
||||
wgpu_types::BindGroupLayoutEntry {
|
||||
binding: 1,
|
||||
visibility: wgpu_types::ShaderStages::FRAGMENT,
|
||||
ty: wgpu_types::BindingType::Texture {
|
||||
sample_type: wgpu_types::TextureSampleType::Float { filterable: true },
|
||||
view_dimension: wgpu_types::TextureViewDimension::D2,
|
||||
multisampled: false,
|
||||
},
|
||||
count: None,
|
||||
},
|
||||
wgpu_types::BindGroupLayoutEntry {
|
||||
binding: 2,
|
||||
visibility: wgpu_types::ShaderStages::FRAGMENT,
|
||||
ty: wgpu_types::BindingType::Sampler(wgpu_types::SamplerBindingType::Filtering),
|
||||
count: None,
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
let global_group_layout =
|
||||
unsafe { device.create_bind_group_layout(&global_bgl_desc).unwrap() };
|
||||
|
||||
let local_bgl_desc = hal::BindGroupLayoutDescriptor {
|
||||
label: None,
|
||||
flags: hal::BindGroupLayoutFlags::empty(),
|
||||
entries: &[wgpu_types::BindGroupLayoutEntry {
|
||||
binding: 0,
|
||||
visibility: wgpu_types::ShaderStages::VERTEX,
|
||||
ty: wgpu_types::BindingType::Buffer {
|
||||
ty: wgpu_types::BufferBindingType::Uniform,
|
||||
has_dynamic_offset: true,
|
||||
min_binding_size: wgpu_types::BufferSize::new(size_of::<Locals>() as _),
|
||||
},
|
||||
count: None,
|
||||
}],
|
||||
};
|
||||
let local_group_layout =
|
||||
unsafe { device.create_bind_group_layout(&local_bgl_desc).unwrap() };
|
||||
|
||||
let pipeline_layout_desc = hal::PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
flags: hal::PipelineLayoutFlags::empty(),
|
||||
bind_group_layouts: &[Some(&global_group_layout), Some(&local_group_layout)],
|
||||
immediate_size: 0,
|
||||
};
|
||||
let pipeline_layout = unsafe {
|
||||
device
|
||||
.create_pipeline_layout(&pipeline_layout_desc)
|
||||
.unwrap()
|
||||
};
|
||||
|
||||
let constants = naga::back::PipelineConstants::default();
|
||||
let pipeline_desc = hal::RenderPipelineDescriptor {
|
||||
label: None,
|
||||
layout: &pipeline_layout,
|
||||
vertex_processor: hal::VertexProcessor::Standard {
|
||||
vertex_stage: hal::ProgrammableStage {
|
||||
module: &shader,
|
||||
entry_point: "vs_main",
|
||||
constants: &constants,
|
||||
zero_initialize_workgroup_memory: true,
|
||||
},
|
||||
vertex_buffers: &[],
|
||||
},
|
||||
fragment_stage: Some(hal::ProgrammableStage {
|
||||
module: &shader,
|
||||
entry_point: "fs_main",
|
||||
constants: &constants,
|
||||
zero_initialize_workgroup_memory: true,
|
||||
}),
|
||||
primitive: wgpu_types::PrimitiveState {
|
||||
topology: wgpu_types::PrimitiveTopology::TriangleStrip,
|
||||
..wgpu_types::PrimitiveState::default()
|
||||
},
|
||||
depth_stencil: None,
|
||||
multisample: wgpu_types::MultisampleState::default(),
|
||||
color_targets: &[Some(wgpu_types::ColorTargetState {
|
||||
format: surface_config.format,
|
||||
blend: Some(wgpu_types::BlendState::ALPHA_BLENDING),
|
||||
write_mask: wgpu_types::ColorWrites::default(),
|
||||
})],
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
};
|
||||
let pipeline = unsafe { device.create_render_pipeline(&pipeline_desc).unwrap() };
|
||||
|
||||
let texture_data = [0xFFu8; 4];
|
||||
|
||||
let staging_buffer_desc = hal::BufferDescriptor {
|
||||
label: Some("stage"),
|
||||
size: texture_data.len() as wgpu_types::BufferAddress,
|
||||
usage: wgpu_types::BufferUses::MAP_WRITE | wgpu_types::BufferUses::COPY_SRC,
|
||||
memory_flags: hal::MemoryFlags::TRANSIENT | hal::MemoryFlags::PREFER_COHERENT,
|
||||
};
|
||||
let staging_buffer = unsafe { device.create_buffer(&staging_buffer_desc).unwrap() };
|
||||
unsafe {
|
||||
let mapping = device
|
||||
.map_buffer(&staging_buffer, 0..staging_buffer_desc.size)
|
||||
.unwrap();
|
||||
ptr::copy_nonoverlapping(
|
||||
texture_data.as_ptr(),
|
||||
mapping.ptr.as_ptr(),
|
||||
texture_data.len(),
|
||||
);
|
||||
device.unmap_buffer(&staging_buffer);
|
||||
assert!(mapping.is_coherent);
|
||||
}
|
||||
|
||||
let texture_desc = hal::TextureDescriptor {
|
||||
label: None,
|
||||
size: wgpu_types::Extent3d {
|
||||
width: 1,
|
||||
height: 1,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu_types::TextureDimension::D2,
|
||||
format: wgpu_types::TextureFormat::Rgba8UnormSrgb,
|
||||
usage: wgpu_types::TextureUses::COPY_DST | wgpu_types::TextureUses::RESOURCE,
|
||||
memory_flags: hal::MemoryFlags::empty(),
|
||||
view_formats: vec![],
|
||||
};
|
||||
let texture = unsafe { device.create_texture(&texture_desc).unwrap() };
|
||||
|
||||
let cmd_encoder_desc = hal::CommandEncoderDescriptor {
|
||||
label: None,
|
||||
queue: &queue,
|
||||
};
|
||||
let mut cmd_encoder = unsafe { device.create_command_encoder(&cmd_encoder_desc).unwrap() };
|
||||
unsafe { cmd_encoder.begin_encoding(Some("init")).unwrap() };
|
||||
{
|
||||
let buffer_barrier = hal::BufferBarrier {
|
||||
buffer: &staging_buffer,
|
||||
usage: hal::StateTransition {
|
||||
from: wgpu_types::BufferUses::empty(),
|
||||
to: wgpu_types::BufferUses::COPY_SRC,
|
||||
},
|
||||
};
|
||||
let texture_barrier1 = hal::TextureBarrier {
|
||||
texture: &texture,
|
||||
range: wgpu_types::ImageSubresourceRange::default(),
|
||||
usage: hal::StateTransition {
|
||||
from: wgpu_types::TextureUses::UNINITIALIZED,
|
||||
to: wgpu_types::TextureUses::COPY_DST,
|
||||
},
|
||||
};
|
||||
let texture_barrier2 = hal::TextureBarrier {
|
||||
texture: &texture,
|
||||
range: wgpu_types::ImageSubresourceRange::default(),
|
||||
usage: hal::StateTransition {
|
||||
from: wgpu_types::TextureUses::COPY_DST,
|
||||
to: wgpu_types::TextureUses::RESOURCE,
|
||||
},
|
||||
};
|
||||
let copy = hal::BufferTextureCopy {
|
||||
buffer_layout: wgpu_types::TexelCopyBufferLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(4),
|
||||
rows_per_image: None,
|
||||
},
|
||||
texture_base: hal::TextureCopyBase {
|
||||
origin: wgpu_types::Origin3d::ZERO,
|
||||
mip_level: 0,
|
||||
array_layer: 0,
|
||||
aspect: hal::FormatAspects::COLOR,
|
||||
},
|
||||
size: hal::CopyExtent {
|
||||
width: 1,
|
||||
height: 1,
|
||||
depth: 1,
|
||||
},
|
||||
};
|
||||
unsafe {
|
||||
cmd_encoder.transition_buffers(iter::once(buffer_barrier));
|
||||
cmd_encoder.transition_textures(iter::once(texture_barrier1));
|
||||
cmd_encoder.copy_buffer_to_texture(&staging_buffer, &texture, iter::once(copy));
|
||||
cmd_encoder.transition_textures(iter::once(texture_barrier2));
|
||||
}
|
||||
}
|
||||
|
||||
let sampler_desc = hal::SamplerDescriptor {
|
||||
label: None,
|
||||
address_modes: [wgpu_types::AddressMode::ClampToEdge; 3],
|
||||
mag_filter: wgpu_types::FilterMode::Linear,
|
||||
min_filter: wgpu_types::FilterMode::Nearest,
|
||||
mipmap_filter: wgpu_types::MipmapFilterMode::Nearest,
|
||||
lod_clamp: 0.0..32.0,
|
||||
compare: None,
|
||||
anisotropy_clamp: 1,
|
||||
border_color: None,
|
||||
};
|
||||
let sampler = unsafe { device.create_sampler(&sampler_desc).unwrap() };
|
||||
|
||||
let globals = Globals {
|
||||
// cgmath::ortho() projection
|
||||
mvp: [
|
||||
[2.0 / window_size.0 as f32, 0.0, 0.0, 0.0],
|
||||
[0.0, 2.0 / window_size.1 as f32, 0.0, 0.0],
|
||||
[0.0, 0.0, 1.0, 0.0],
|
||||
[-1.0, -1.0, 0.0, 1.0],
|
||||
],
|
||||
size: [BUNNY_SIZE; 2],
|
||||
pad: [0.0; 2],
|
||||
};
|
||||
|
||||
let global_buffer_desc = hal::BufferDescriptor {
|
||||
label: Some("global"),
|
||||
size: size_of::<Globals>() as wgpu_types::BufferAddress,
|
||||
usage: wgpu_types::BufferUses::MAP_WRITE | wgpu_types::BufferUses::UNIFORM,
|
||||
memory_flags: hal::MemoryFlags::PREFER_COHERENT,
|
||||
};
|
||||
let global_buffer = unsafe {
|
||||
let buffer = device.create_buffer(&global_buffer_desc).unwrap();
|
||||
let mapping = device
|
||||
.map_buffer(&buffer, 0..global_buffer_desc.size)
|
||||
.unwrap();
|
||||
ptr::copy_nonoverlapping(
|
||||
&globals as *const Globals as *const u8,
|
||||
mapping.ptr.as_ptr(),
|
||||
size_of::<Globals>(),
|
||||
);
|
||||
device.unmap_buffer(&buffer);
|
||||
assert!(mapping.is_coherent);
|
||||
buffer
|
||||
};
|
||||
|
||||
let local_alignment = wgpu_types::math::align_to(
|
||||
size_of::<Locals>() as u32,
|
||||
capabilities.limits.min_uniform_buffer_offset_alignment,
|
||||
);
|
||||
let local_buffer_desc = hal::BufferDescriptor {
|
||||
label: Some("local"),
|
||||
size: (MAX_BUNNIES as wgpu_types::BufferAddress)
|
||||
* (local_alignment as wgpu_types::BufferAddress),
|
||||
usage: wgpu_types::BufferUses::MAP_WRITE | wgpu_types::BufferUses::UNIFORM,
|
||||
memory_flags: hal::MemoryFlags::PREFER_COHERENT,
|
||||
};
|
||||
let local_buffer = unsafe { device.create_buffer(&local_buffer_desc).unwrap() };
|
||||
|
||||
let view_desc = hal::TextureViewDescriptor {
|
||||
label: None,
|
||||
format: texture_desc.format,
|
||||
dimension: wgpu_types::TextureViewDimension::D2,
|
||||
usage: wgpu_types::TextureUses::RESOURCE,
|
||||
range: wgpu_types::ImageSubresourceRange::default(),
|
||||
};
|
||||
let texture_view = unsafe { device.create_texture_view(&texture, &view_desc).unwrap() };
|
||||
|
||||
let global_group = {
|
||||
// SAFETY: This is the same size that was specified for buffer creation.
|
||||
let global_buffer_binding = hal::BufferBinding::new_unchecked(
|
||||
&global_buffer,
|
||||
0,
|
||||
NonZeroU64::new(global_buffer_desc.size),
|
||||
);
|
||||
let texture_binding = hal::TextureBinding {
|
||||
view: &texture_view,
|
||||
usage: wgpu_types::TextureUses::RESOURCE,
|
||||
};
|
||||
let global_group_desc = hal::BindGroupDescriptor {
|
||||
label: Some("global"),
|
||||
layout: &global_group_layout,
|
||||
buffers: &[global_buffer_binding],
|
||||
samplers: &[&sampler],
|
||||
textures: &[texture_binding],
|
||||
acceleration_structures: &[],
|
||||
external_textures: &[],
|
||||
entries: &[
|
||||
hal::BindGroupEntry {
|
||||
binding: 0,
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
},
|
||||
hal::BindGroupEntry {
|
||||
binding: 1,
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
},
|
||||
hal::BindGroupEntry {
|
||||
binding: 2,
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
},
|
||||
],
|
||||
};
|
||||
unsafe { device.create_bind_group(&global_group_desc).unwrap() }
|
||||
};
|
||||
|
||||
let local_group = {
|
||||
// SAFETY: The size must fit within the buffer.
|
||||
let local_buffer_binding = hal::BufferBinding::new_unchecked(
|
||||
&local_buffer,
|
||||
0,
|
||||
wgpu_types::BufferSize::new(size_of::<Locals>() as _),
|
||||
);
|
||||
let local_group_desc = hal::BindGroupDescriptor {
|
||||
label: Some("local"),
|
||||
layout: &local_group_layout,
|
||||
buffers: &[local_buffer_binding],
|
||||
samplers: &[],
|
||||
textures: &[],
|
||||
acceleration_structures: &[],
|
||||
external_textures: &[],
|
||||
entries: &[hal::BindGroupEntry {
|
||||
binding: 0,
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
}],
|
||||
};
|
||||
unsafe { device.create_bind_group(&local_group_desc).unwrap() }
|
||||
};
|
||||
|
||||
let init_fence_value = 1;
|
||||
let fence = unsafe {
|
||||
let mut fence = device.create_fence().unwrap();
|
||||
let init_cmd = cmd_encoder.end_encoding().unwrap();
|
||||
queue
|
||||
.submit(&[&init_cmd], &[], (&mut fence, init_fence_value))
|
||||
.unwrap();
|
||||
device.wait(&fence, init_fence_value, None).unwrap();
|
||||
device.destroy_buffer(staging_buffer);
|
||||
cmd_encoder.reset_all(iter::once(init_cmd));
|
||||
fence
|
||||
};
|
||||
|
||||
Ok(Example {
|
||||
instance,
|
||||
surface,
|
||||
surface_format: surface_config.format,
|
||||
adapter,
|
||||
device,
|
||||
queue,
|
||||
pipeline_layout,
|
||||
shader,
|
||||
pipeline,
|
||||
global_group,
|
||||
local_group,
|
||||
global_group_layout,
|
||||
local_group_layout,
|
||||
bunnies: Vec::new(),
|
||||
local_buffer,
|
||||
local_alignment,
|
||||
global_buffer,
|
||||
sampler,
|
||||
texture,
|
||||
texture_view,
|
||||
contexts: vec![ExecutionContext {
|
||||
encoder: cmd_encoder,
|
||||
fence,
|
||||
fence_value: init_fence_value + 1,
|
||||
used_views: Vec::new(),
|
||||
used_cmd_bufs: Vec::new(),
|
||||
frames_recorded: 0,
|
||||
}],
|
||||
context_index: 0,
|
||||
extent: [window_size.0, window_size.1],
|
||||
start: Instant::now(),
|
||||
})
|
||||
}
|
||||
|
||||
fn is_empty(&self) -> bool {
|
||||
self.bunnies.is_empty()
|
||||
}
|
||||
|
||||
fn exit(mut self) {
|
||||
unsafe {
|
||||
{
|
||||
let ctx = &mut self.contexts[self.context_index];
|
||||
self.queue
|
||||
.submit(&[], &[], (&mut ctx.fence, ctx.fence_value))
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
for mut ctx in self.contexts {
|
||||
ctx.wait_and_clear(&self.device);
|
||||
drop(ctx.encoder);
|
||||
self.device.destroy_fence(ctx.fence);
|
||||
}
|
||||
|
||||
self.device.destroy_bind_group(self.local_group);
|
||||
self.device.destroy_bind_group(self.global_group);
|
||||
self.device.destroy_buffer(self.local_buffer);
|
||||
self.device.destroy_buffer(self.global_buffer);
|
||||
self.device.destroy_texture_view(self.texture_view);
|
||||
self.device.destroy_texture(self.texture);
|
||||
self.device.destroy_sampler(self.sampler);
|
||||
self.device.destroy_shader_module(self.shader);
|
||||
self.device.destroy_render_pipeline(self.pipeline);
|
||||
self.device
|
||||
.destroy_bind_group_layout(self.local_group_layout);
|
||||
self.device
|
||||
.destroy_bind_group_layout(self.global_group_layout);
|
||||
self.device.destroy_pipeline_layout(self.pipeline_layout);
|
||||
|
||||
self.surface.unconfigure(&self.device);
|
||||
drop(self.queue);
|
||||
drop(self.device);
|
||||
drop(self.surface);
|
||||
drop(self.adapter);
|
||||
}
|
||||
}
|
||||
|
||||
fn update(&mut self, event: winit::event::WindowEvent) {
|
||||
if let winit::event::WindowEvent::KeyboardInput {
|
||||
event:
|
||||
KeyEvent {
|
||||
logical_key: Key::Named(NamedKey::Space),
|
||||
state: ElementState::Pressed,
|
||||
..
|
||||
},
|
||||
..
|
||||
} = event
|
||||
{
|
||||
let spawn_count = 64 + self.bunnies.len() / 2;
|
||||
let elapsed = self.start.elapsed();
|
||||
let color = elapsed.as_nanos() as u32;
|
||||
println!(
|
||||
"Spawning {} bunnies, total at {}",
|
||||
spawn_count,
|
||||
self.bunnies.len() + spawn_count
|
||||
);
|
||||
for i in 0..spawn_count {
|
||||
let random = ((elapsed.as_nanos() * (i + 1) as u128) & 0xFF) as f32 / 255.0;
|
||||
let speed = random * MAX_VELOCITY - (MAX_VELOCITY * 0.5);
|
||||
self.bunnies.push(Locals {
|
||||
position: [0.0, 0.5 * (self.extent[1] as f32)],
|
||||
velocity: [speed, 0.0],
|
||||
color,
|
||||
_pad: 0,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn render(&mut self) {
|
||||
let delta = 0.01;
|
||||
for bunny in self.bunnies.iter_mut() {
|
||||
bunny.position[0] += bunny.velocity[0] * delta;
|
||||
bunny.position[1] += bunny.velocity[1] * delta;
|
||||
bunny.velocity[1] += GRAVITY * delta;
|
||||
if (bunny.velocity[0] > 0.0
|
||||
&& bunny.position[0] + 0.5 * BUNNY_SIZE > self.extent[0] as f32)
|
||||
|| (bunny.velocity[0] < 0.0 && bunny.position[0] - 0.5 * BUNNY_SIZE < 0.0)
|
||||
{
|
||||
bunny.velocity[0] *= -1.0;
|
||||
}
|
||||
if bunny.velocity[1] < 0.0 && bunny.position[1] < 0.5 * BUNNY_SIZE {
|
||||
bunny.velocity[1] *= -1.0;
|
||||
}
|
||||
}
|
||||
|
||||
if !self.bunnies.is_empty() {
|
||||
let size = self.bunnies.len() * self.local_alignment as usize;
|
||||
unsafe {
|
||||
let mapping = self
|
||||
.device
|
||||
.map_buffer(&self.local_buffer, 0..size as wgpu_types::BufferAddress)
|
||||
.unwrap();
|
||||
ptr::copy_nonoverlapping(
|
||||
self.bunnies.as_ptr() as *const u8,
|
||||
mapping.ptr.as_ptr(),
|
||||
size,
|
||||
);
|
||||
assert!(mapping.is_coherent);
|
||||
self.device.unmap_buffer(&self.local_buffer);
|
||||
}
|
||||
}
|
||||
|
||||
let ctx = &mut self.contexts[self.context_index];
|
||||
|
||||
let surface_tex = unsafe {
|
||||
self.surface
|
||||
.acquire_texture(None, &ctx.fence)
|
||||
.unwrap()
|
||||
.texture
|
||||
};
|
||||
|
||||
let target_barrier0 = hal::TextureBarrier {
|
||||
texture: surface_tex.borrow(),
|
||||
range: wgpu_types::ImageSubresourceRange::default(),
|
||||
usage: hal::StateTransition {
|
||||
from: wgpu_types::TextureUses::UNINITIALIZED,
|
||||
to: wgpu_types::TextureUses::COLOR_TARGET,
|
||||
},
|
||||
};
|
||||
unsafe {
|
||||
ctx.encoder.begin_encoding(Some("frame")).unwrap();
|
||||
ctx.encoder.transition_textures(iter::once(target_barrier0));
|
||||
}
|
||||
|
||||
let surface_view_desc = hal::TextureViewDescriptor {
|
||||
label: None,
|
||||
format: self.surface_format,
|
||||
dimension: wgpu_types::TextureViewDimension::D2,
|
||||
usage: wgpu_types::TextureUses::COLOR_TARGET,
|
||||
range: wgpu_types::ImageSubresourceRange::default(),
|
||||
};
|
||||
let surface_tex_view = unsafe {
|
||||
self.device
|
||||
.create_texture_view(surface_tex.borrow(), &surface_view_desc)
|
||||
.unwrap()
|
||||
};
|
||||
let pass_desc = hal::RenderPassDescriptor {
|
||||
label: None,
|
||||
extent: wgpu_types::Extent3d {
|
||||
width: self.extent[0],
|
||||
height: self.extent[1],
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
sample_count: 1,
|
||||
color_attachments: &[Some(hal::ColorAttachment {
|
||||
target: hal::Attachment {
|
||||
view: &surface_tex_view,
|
||||
usage: wgpu_types::TextureUses::COLOR_TARGET,
|
||||
},
|
||||
depth_slice: None,
|
||||
resolve_target: None,
|
||||
ops: hal::AttachmentOps::STORE | hal::AttachmentOps::LOAD_CLEAR,
|
||||
clear_value: wgpu_types::Color {
|
||||
r: 0.1,
|
||||
g: 0.2,
|
||||
b: 0.3,
|
||||
a: 1.0,
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
multiview_mask: None,
|
||||
timestamp_writes: None,
|
||||
occlusion_query_set: None,
|
||||
};
|
||||
unsafe {
|
||||
ctx.encoder.begin_render_pass(&pass_desc).unwrap();
|
||||
ctx.encoder.set_render_pipeline(&self.pipeline);
|
||||
ctx.encoder
|
||||
.set_bind_group(&self.pipeline_layout, 0, &self.global_group, &[]);
|
||||
}
|
||||
|
||||
for i in 0..self.bunnies.len() {
|
||||
let offset = (i as wgpu_types::DynamicOffset)
|
||||
* (self.local_alignment as wgpu_types::DynamicOffset);
|
||||
unsafe {
|
||||
ctx.encoder
|
||||
.set_bind_group(&self.pipeline_layout, 1, &self.local_group, &[offset]);
|
||||
ctx.encoder.draw(0, 4, 0, 1);
|
||||
}
|
||||
}
|
||||
|
||||
ctx.frames_recorded += 1;
|
||||
|
||||
let target_barrier1 = hal::TextureBarrier {
|
||||
texture: surface_tex.borrow(),
|
||||
range: wgpu_types::ImageSubresourceRange::default(),
|
||||
usage: hal::StateTransition {
|
||||
from: wgpu_types::TextureUses::COLOR_TARGET,
|
||||
to: wgpu_types::TextureUses::PRESENT,
|
||||
},
|
||||
};
|
||||
unsafe {
|
||||
ctx.encoder.end_render_pass();
|
||||
ctx.encoder.transition_textures(iter::once(target_barrier1));
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let cmd_buf = ctx.encoder.end_encoding().unwrap();
|
||||
self.queue
|
||||
.submit(
|
||||
&[&cmd_buf],
|
||||
&[&surface_tex],
|
||||
(&mut ctx.fence, ctx.fence_value),
|
||||
)
|
||||
.unwrap();
|
||||
self.queue.present(&self.surface, surface_tex).unwrap();
|
||||
ctx.used_cmd_bufs.push(cmd_buf);
|
||||
ctx.used_views.push(surface_tex_view);
|
||||
};
|
||||
|
||||
log::debug!("Context switch from {}", self.context_index);
|
||||
let old_fence_value = ctx.fence_value;
|
||||
if self.contexts.len() == 1 {
|
||||
let hal_desc = hal::CommandEncoderDescriptor {
|
||||
label: None,
|
||||
queue: &self.queue,
|
||||
};
|
||||
self.contexts.push(unsafe {
|
||||
ExecutionContext {
|
||||
encoder: self.device.create_command_encoder(&hal_desc).unwrap(),
|
||||
fence: self.device.create_fence().unwrap(),
|
||||
fence_value: 0,
|
||||
used_views: Vec::new(),
|
||||
used_cmd_bufs: Vec::new(),
|
||||
frames_recorded: 0,
|
||||
}
|
||||
});
|
||||
}
|
||||
self.context_index = (self.context_index + 1) % self.contexts.len();
|
||||
let next = &mut self.contexts[self.context_index];
|
||||
unsafe {
|
||||
next.wait_and_clear(&self.device);
|
||||
}
|
||||
next.fence_value = old_fence_value + 1;
|
||||
}
|
||||
}
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
// Apple + Metal
|
||||
if #[cfg(all(target_vendor = "apple", feature = "metal"))] {
|
||||
type Api = hal::api::Metal;
|
||||
}
|
||||
// Wasm + Vulkan
|
||||
else if #[cfg(all(not(target_arch = "wasm32"), feature = "vulkan"))] {
|
||||
type Api = hal::api::Vulkan;
|
||||
}
|
||||
// Windows + DX12
|
||||
else if #[cfg(all(windows, feature = "dx12"))] {
|
||||
type Api = hal::api::Dx12;
|
||||
}
|
||||
// Anything + GLES
|
||||
else if #[cfg(feature = "gles")] {
|
||||
type Api = hal::api::Gles;
|
||||
}
|
||||
// Fallback
|
||||
else {
|
||||
type Api = hal::api::Noop;
|
||||
}
|
||||
}
|
||||
|
||||
struct App {
|
||||
example: Option<Example<Api>>,
|
||||
window: Option<Window>,
|
||||
last_frame_inst: Instant,
|
||||
frame_count: u32,
|
||||
accum_time: f32,
|
||||
}
|
||||
|
||||
impl ApplicationHandler for App {
|
||||
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
|
||||
if self.window.is_some() {
|
||||
return;
|
||||
}
|
||||
let window = event_loop
|
||||
.create_window(Window::default_attributes().with_title("hal-bunnymark"))
|
||||
.unwrap();
|
||||
let example = Example::<Api>::init(&window).expect("Selected backend is not supported");
|
||||
self.window = Some(window);
|
||||
self.example = Some(example);
|
||||
println!("Press space to spawn bunnies.");
|
||||
self.window.as_ref().unwrap().request_redraw();
|
||||
}
|
||||
|
||||
fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
|
||||
self.example.take().unwrap().exit();
|
||||
}
|
||||
|
||||
fn window_event(
|
||||
&mut self,
|
||||
event_loop: &ActiveEventLoop,
|
||||
_window_id: winit::window::WindowId,
|
||||
event: WindowEvent,
|
||||
) {
|
||||
event_loop.set_control_flow(ControlFlow::Poll);
|
||||
|
||||
match event {
|
||||
WindowEvent::KeyboardInput {
|
||||
event:
|
||||
KeyEvent {
|
||||
logical_key: Key::Named(NamedKey::Escape),
|
||||
state: ElementState::Pressed,
|
||||
..
|
||||
},
|
||||
..
|
||||
}
|
||||
| WindowEvent::CloseRequested => event_loop.exit(),
|
||||
WindowEvent::RedrawRequested => {
|
||||
let ex = self.example.as_mut().unwrap();
|
||||
{
|
||||
self.accum_time += self.last_frame_inst.elapsed().as_secs_f32();
|
||||
self.last_frame_inst = Instant::now();
|
||||
self.frame_count += 1;
|
||||
if self.frame_count == 100 && !ex.is_empty() {
|
||||
println!(
|
||||
"Avg frame time {}ms",
|
||||
self.accum_time * 1000.0 / self.frame_count as f32
|
||||
);
|
||||
self.accum_time = 0.0;
|
||||
self.frame_count = 0;
|
||||
}
|
||||
}
|
||||
ex.render();
|
||||
self.window.as_ref().unwrap().request_redraw();
|
||||
}
|
||||
_ => {
|
||||
self.example.as_mut().unwrap().update(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
env_logger::init();
|
||||
|
||||
let event_loop = winit::event_loop::EventLoop::new().unwrap();
|
||||
let mut app = App {
|
||||
example: None,
|
||||
window: None,
|
||||
last_frame_inst: Instant::now(),
|
||||
frame_count: 0,
|
||||
accum_time: 0.0,
|
||||
};
|
||||
event_loop.run_app(&mut app).unwrap();
|
||||
}
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
struct Globals {
|
||||
mvp: mat4x4<f32>,
|
||||
size: vec2<f32>,
|
||||
_pad0: u32,
|
||||
_pad1: u32,
|
||||
};
|
||||
|
||||
struct Locals {
|
||||
position: vec2<f32>,
|
||||
velocity: vec2<f32>,
|
||||
color: u32,
|
||||
_pad0: u32,
|
||||
_pad1: u32,
|
||||
_pad2: u32,
|
||||
};
|
||||
|
||||
@group(0)
|
||||
@binding(0)
|
||||
var<uniform> globals: Globals;
|
||||
|
||||
@group(1)
|
||||
@binding(0)
|
||||
var<uniform> locals: Locals;
|
||||
|
||||
struct VertexOutput {
|
||||
@builtin(position) position: vec4<f32>,
|
||||
@location(0) tex_coords: vec2<f32>,
|
||||
@location(1) color: vec4<f32>,
|
||||
};
|
||||
|
||||
@vertex
|
||||
fn vs_main(@builtin(vertex_index) vi: u32) -> VertexOutput {
|
||||
let tc = vec2<f32>(f32(vi & 1u), 0.5 * f32(vi & 2u));
|
||||
let offset = vec2<f32>(tc.x * globals.size.x, tc.y * globals.size.y);
|
||||
let pos = globals.mvp * vec4<f32>(locals.position + offset, 0.0, 1.0);
|
||||
let color = vec4<f32>((vec4<u32>(locals.color) >> vec4<u32>(0u, 8u, 16u, 24u)) & vec4<u32>(255u)) / 255.0;
|
||||
return VertexOutput(pos, tc, color);
|
||||
}
|
||||
|
||||
@group(0)
|
||||
@binding(1)
|
||||
var tex: texture_2d<f32>;
|
||||
@group(0)
|
||||
@binding(2)
|
||||
var sam: sampler;
|
||||
|
||||
@fragment
|
||||
fn fs_main(vertex: VertexOutput) -> @location(0) vec4<f32> {
|
||||
return vertex.color * textureSampleLevel(tex, sam, vertex.tex_coords, 0.0);
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
</head>
|
||||
<body>
|
||||
<canvas id="canvas" width="640" height="400"></canvas>
|
||||
<script>
|
||||
var Module = {
|
||||
canvas: document.getElementById("canvas"),
|
||||
preRun: [
|
||||
function () {
|
||||
ENV.RUST_LOG = "debug";
|
||||
},
|
||||
],
|
||||
};
|
||||
</script>
|
||||
<script src="raw-gles.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
Vendored
+396
@@ -0,0 +1,396 @@
|
||||
//! This example shows interop with raw GLES contexts -
|
||||
//! the ability to hook up wgpu-hal to an existing context and draw into it.
|
||||
//!
|
||||
//! Emscripten build:
|
||||
//! 1. install emsdk
|
||||
//! 2. build this example with cargo:
|
||||
//! EMCC_CFLAGS="-g -s ERROR_ON_UNDEFINED_SYMBOLS=0 --no-entry -s FULL_ES3=1" cargo build --example raw-gles --target wasm32-unknown-emscripten
|
||||
//! 3. copy raw-gles.em.html into target directory and open it in browser:
|
||||
//! cp wgpu-hal/examples/raw-gles.em.html target/wasm32-unknown-emscripten/debug/examples
|
||||
|
||||
extern crate wgpu_hal as hal;
|
||||
|
||||
#[cfg(not(any(
|
||||
target_arch = "wasm32",
|
||||
target_os = "ios",
|
||||
target_os = "visionos",
|
||||
target_env = "ohos"
|
||||
)))]
|
||||
fn main() {
|
||||
use std::ffi::CString;
|
||||
|
||||
use glutin::{
|
||||
config::GlConfig as _,
|
||||
context::{NotCurrentGlContext as _, PossiblyCurrentGlContext as _, Version},
|
||||
display::{GetGlDisplay as _, GlDisplay as _},
|
||||
surface::GlSurface as _,
|
||||
};
|
||||
use glutin_winit::GlWindow as _;
|
||||
use raw_window_handle::HasWindowHandle as _;
|
||||
use winit::{
|
||||
application::ApplicationHandler,
|
||||
event::{KeyEvent, WindowEvent},
|
||||
event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
|
||||
keyboard::{Key, NamedKey},
|
||||
window::Window,
|
||||
};
|
||||
|
||||
env_logger::init();
|
||||
println!("Initializing external GL context");
|
||||
|
||||
/// Find the config with the maximum number of samples, so our triangle will be
|
||||
/// smooth.
|
||||
fn gl_config_picker(
|
||||
configs: Box<dyn Iterator<Item = glutin::config::Config> + '_>,
|
||||
) -> glutin::config::Config {
|
||||
configs
|
||||
.reduce(|accum, config| {
|
||||
if config.num_samples() > accum.num_samples() {
|
||||
config
|
||||
} else {
|
||||
accum
|
||||
}
|
||||
})
|
||||
.expect("Failed to find a matching config")
|
||||
}
|
||||
|
||||
struct App {
|
||||
gl_config: Option<glutin::config::Config>,
|
||||
not_current_gl_context: Option<glutin::context::NotCurrentContext>,
|
||||
state: Option<(
|
||||
glutin::context::PossiblyCurrentContext,
|
||||
glutin::surface::Surface<glutin::surface::WindowSurface>,
|
||||
Window,
|
||||
)>,
|
||||
exposed: Option<hal::ExposedAdapter<hal::api::Gles>>,
|
||||
}
|
||||
|
||||
impl App {
|
||||
fn new() -> Self {
|
||||
Self {
|
||||
gl_config: None,
|
||||
not_current_gl_context: None,
|
||||
state: None,
|
||||
exposed: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ApplicationHandler for App {
|
||||
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
|
||||
// First call: create display, pick config, create GL context.
|
||||
if self.gl_config.is_none() {
|
||||
// Only Windows requires the window to be present before creating the display.
|
||||
// Other platforms don't really need one.
|
||||
let window_attributes = cfg!(windows).then(|| {
|
||||
Window::default_attributes()
|
||||
.with_title("wgpu raw GLES example (press Escape to exit)")
|
||||
});
|
||||
|
||||
let template = glutin::config::ConfigTemplateBuilder::new();
|
||||
|
||||
let display_builder =
|
||||
glutin_winit::DisplayBuilder::new().with_window_attributes(window_attributes);
|
||||
|
||||
let (window, gl_config) = display_builder
|
||||
.build(event_loop, template, gl_config_picker)
|
||||
.expect("Failed to build window and config from display");
|
||||
|
||||
println!("Picked a config with {} samples", gl_config.num_samples());
|
||||
|
||||
let raw_window_handle = window
|
||||
.as_ref()
|
||||
.and_then(|window| window.window_handle().ok())
|
||||
.map(|handle| handle.as_raw());
|
||||
|
||||
let gl_display = gl_config.display();
|
||||
|
||||
// Glutin tries to create an OpenGL context by default.
|
||||
// Force it to use any version of GLES.
|
||||
let context_attributes = glutin::context::ContextAttributesBuilder::new()
|
||||
// wgpu expects GLES 3.0+.
|
||||
.with_context_api(glutin::context::ContextApi::Gles(Some(Version::new(3, 0))))
|
||||
.build(raw_window_handle);
|
||||
|
||||
let gl_context = unsafe {
|
||||
gl_display
|
||||
.create_context(&gl_config, &context_attributes)
|
||||
.expect("failed to create context")
|
||||
};
|
||||
|
||||
self.not_current_gl_context = Some(gl_context);
|
||||
self.gl_config = Some(gl_config);
|
||||
|
||||
// On Windows, the window was already created by DisplayBuilder.
|
||||
if let Some(window) = window {
|
||||
self.create_surface(event_loop, window);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Create window + surface (non-Windows first call, or Android re-resume).
|
||||
if self.state.is_none() {
|
||||
let gl_config = self.gl_config.as_ref().unwrap();
|
||||
let window = glutin_winit::finalize_window(
|
||||
event_loop,
|
||||
Window::default_attributes()
|
||||
.with_title("wgpu raw GLES example (press Escape to exit)"),
|
||||
gl_config,
|
||||
)
|
||||
.unwrap();
|
||||
self.create_surface(event_loop, window);
|
||||
}
|
||||
}
|
||||
|
||||
fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
|
||||
// This event is only raised on Android, where the backing NativeWindow for a GL
|
||||
// Surface can appear and disappear at any moment.
|
||||
println!("Android window removed");
|
||||
|
||||
// Destroy the GL Surface and un-current the GL Context before ndk-glue releases
|
||||
// the window back to the system.
|
||||
if let Some((gl_context, ..)) = self.state.take() {
|
||||
assert!(self
|
||||
.not_current_gl_context
|
||||
.replace(gl_context.make_not_current().unwrap())
|
||||
.is_none());
|
||||
}
|
||||
}
|
||||
|
||||
fn window_event(
|
||||
&mut self,
|
||||
event_loop: &ActiveEventLoop,
|
||||
_window_id: winit::window::WindowId,
|
||||
event: WindowEvent,
|
||||
) {
|
||||
event_loop.set_control_flow(ControlFlow::Wait);
|
||||
|
||||
match event {
|
||||
WindowEvent::CloseRequested
|
||||
| WindowEvent::KeyboardInput {
|
||||
event:
|
||||
KeyEvent {
|
||||
logical_key: Key::Named(NamedKey::Escape),
|
||||
..
|
||||
},
|
||||
..
|
||||
} => event_loop.exit(),
|
||||
WindowEvent::Resized(size) => {
|
||||
if size.width != 0 && size.height != 0 {
|
||||
// Some platforms like EGL require resizing GL surface to update the size.
|
||||
// Notable platforms here are Wayland and macOS, other don't require it
|
||||
// and the function is no-op, but it's wise to resize it for portability
|
||||
// reasons.
|
||||
if let Some((gl_context, gl_surface, window)) = &self.state {
|
||||
window.resize_surface(gl_surface, gl_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
WindowEvent::RedrawRequested => {
|
||||
if let (Some(exposed), Some((gl_context, gl_surface, window))) =
|
||||
(&self.exposed, &self.state)
|
||||
{
|
||||
let inner_size = window.inner_size();
|
||||
|
||||
fill_screen(exposed, inner_size.width, inner_size.height);
|
||||
|
||||
println!("Showing the window");
|
||||
gl_surface
|
||||
.swap_buffers(gl_context)
|
||||
.expect("Failed to swap buffers");
|
||||
}
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl App {
|
||||
fn create_surface(&mut self, _event_loop: &ActiveEventLoop, window: Window) {
|
||||
let gl_config = self.gl_config.as_ref().unwrap();
|
||||
|
||||
let attrs = window
|
||||
.build_surface_attributes(Default::default())
|
||||
.expect("Failed to build surface attributes");
|
||||
let gl_surface = unsafe {
|
||||
gl_config
|
||||
.display()
|
||||
.create_window_surface(gl_config, &attrs)
|
||||
.expect("Cannot create GL WindowSurface")
|
||||
};
|
||||
|
||||
// Make it current.
|
||||
let gl_context = self
|
||||
.not_current_gl_context
|
||||
.take()
|
||||
.unwrap()
|
||||
.make_current(&gl_surface)
|
||||
.expect("GL context cannot be made current with WindowSurface");
|
||||
|
||||
// The context needs to be current for the Renderer to set up shaders and
|
||||
// buffers. It also performs function loading, which needs a current context on
|
||||
// WGL.
|
||||
println!("Hooking up to wgpu-hal");
|
||||
self.exposed.get_or_insert_with(|| {
|
||||
unsafe {
|
||||
<hal::api::Gles as hal::Api>::Adapter::new_external(
|
||||
|name| {
|
||||
// XXX: On WGL this should only be called after the context was
|
||||
// made current
|
||||
gl_config
|
||||
.display()
|
||||
.get_proc_address(&CString::new(name).expect(name))
|
||||
},
|
||||
wgpu_types::GlBackendOptions::default(),
|
||||
)
|
||||
}
|
||||
.expect("GL adapter can't be initialized")
|
||||
});
|
||||
|
||||
window.request_redraw();
|
||||
self.state = Some((gl_context, gl_surface, window));
|
||||
}
|
||||
}
|
||||
|
||||
let event_loop = EventLoop::new().unwrap();
|
||||
let mut app = App::new();
|
||||
event_loop
|
||||
.run_app(&mut app)
|
||||
.expect("Couldn't run event loop");
|
||||
}
|
||||
|
||||
#[cfg(target_os = "emscripten")]
|
||||
fn main() {
|
||||
env_logger::init();
|
||||
|
||||
println!("Initializing external GL context");
|
||||
let egl = khronos_egl::Instance::new(khronos_egl::Static);
|
||||
let display = unsafe { egl.get_display(khronos_egl::DEFAULT_DISPLAY) }.unwrap();
|
||||
egl.initialize(display)
|
||||
.expect("unable to initialize display");
|
||||
|
||||
let attributes = [
|
||||
khronos_egl::RED_SIZE,
|
||||
8,
|
||||
khronos_egl::GREEN_SIZE,
|
||||
8,
|
||||
khronos_egl::BLUE_SIZE,
|
||||
8,
|
||||
khronos_egl::NONE,
|
||||
];
|
||||
|
||||
let config = egl
|
||||
.choose_first_config(display, &attributes)
|
||||
.unwrap()
|
||||
.expect("unable to choose config");
|
||||
let surface = unsafe {
|
||||
let window = std::ptr::null_mut::<std::ffi::c_void>();
|
||||
egl.create_window_surface(display, config, window, None)
|
||||
}
|
||||
.expect("unable to create surface");
|
||||
|
||||
let context_attributes = [khronos_egl::CONTEXT_CLIENT_VERSION, 3, khronos_egl::NONE];
|
||||
|
||||
let gl_context = egl
|
||||
.create_context(display, config, None, &context_attributes)
|
||||
.expect("unable to create context");
|
||||
egl.make_current(display, Some(surface), Some(surface), Some(gl_context))
|
||||
.expect("can't make context current");
|
||||
|
||||
println!("Hooking up to wgpu-hal");
|
||||
let exposed = unsafe {
|
||||
<hal::api::Gles as hal::Api>::Adapter::new_external(|name| {
|
||||
egl.get_proc_address(name)
|
||||
.map_or(std::ptr::null(), |p| p as *const _)
|
||||
})
|
||||
}
|
||||
.expect("GL adapter can't be initialized");
|
||||
|
||||
fill_screen(&exposed, 640, 400);
|
||||
}
|
||||
|
||||
#[cfg(any(
|
||||
all(target_arch = "wasm32", not(target_os = "emscripten")),
|
||||
target_os = "ios",
|
||||
target_os = "visionos",
|
||||
target_env = "ohos"
|
||||
))]
|
||||
fn main() {
|
||||
eprintln!("This example is not supported on this platform")
|
||||
}
|
||||
|
||||
#[cfg(not(any(
|
||||
all(target_arch = "wasm32", not(target_os = "emscripten")),
|
||||
target_os = "ios",
|
||||
target_os = "visionos"
|
||||
)))]
|
||||
fn fill_screen(exposed: &hal::ExposedAdapter<hal::api::Gles>, width: u32, height: u32) {
|
||||
use hal::{Adapter as _, CommandEncoder as _, Device as _, Queue as _};
|
||||
|
||||
let od = unsafe {
|
||||
exposed.adapter.open(
|
||||
wgpu_types::Features::empty(),
|
||||
&wgpu_types::Limits::downlevel_defaults(),
|
||||
&wgpu_types::MemoryHints::default(),
|
||||
)
|
||||
}
|
||||
.unwrap();
|
||||
|
||||
let format = wgpu_types::TextureFormat::Rgba8UnormSrgb;
|
||||
let texture = <hal::api::Gles as hal::Api>::Texture::default_framebuffer(format);
|
||||
let view = unsafe {
|
||||
od.device
|
||||
.create_texture_view(
|
||||
&texture,
|
||||
&hal::TextureViewDescriptor {
|
||||
label: None,
|
||||
format,
|
||||
dimension: wgpu_types::TextureViewDimension::D2,
|
||||
usage: wgpu_types::TextureUses::COLOR_TARGET,
|
||||
range: wgpu_types::ImageSubresourceRange::default(),
|
||||
},
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
|
||||
println!("Filling the screen");
|
||||
let mut encoder = unsafe {
|
||||
od.device
|
||||
.create_command_encoder(&hal::CommandEncoderDescriptor {
|
||||
label: None,
|
||||
queue: &od.queue,
|
||||
})
|
||||
.unwrap()
|
||||
};
|
||||
let mut fence = unsafe { od.device.create_fence().unwrap() };
|
||||
let rp_desc = hal::RenderPassDescriptor {
|
||||
label: None,
|
||||
extent: wgpu_types::Extent3d {
|
||||
width,
|
||||
height,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
sample_count: 1,
|
||||
color_attachments: &[Some(hal::ColorAttachment {
|
||||
target: hal::Attachment {
|
||||
view: &view,
|
||||
usage: wgpu_types::TextureUses::COLOR_TARGET,
|
||||
},
|
||||
depth_slice: None,
|
||||
resolve_target: None,
|
||||
ops: hal::AttachmentOps::STORE | hal::AttachmentOps::LOAD_CLEAR,
|
||||
clear_value: wgpu_types::Color::BLUE,
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
multiview_mask: None,
|
||||
timestamp_writes: None,
|
||||
occlusion_query_set: None,
|
||||
};
|
||||
unsafe {
|
||||
encoder.begin_encoding(None).unwrap();
|
||||
encoder.begin_render_pass(&rp_desc).unwrap();
|
||||
encoder.end_render_pass();
|
||||
let cmd_buf = encoder.end_encoding().unwrap();
|
||||
od.queue.submit(&[&cmd_buf], &[], (&mut fence, 0)).unwrap();
|
||||
}
|
||||
}
|
||||
+1225
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,39 @@
|
||||
enable wgpu_ray_query;
|
||||
|
||||
struct Uniforms {
|
||||
view_inv: mat4x4<f32>,
|
||||
proj_inv: mat4x4<f32>,
|
||||
};
|
||||
@group(0) @binding(0)
|
||||
var<uniform> uniforms: Uniforms;
|
||||
|
||||
@group(0) @binding(1)
|
||||
var output: texture_storage_2d<rgba8unorm, write>;
|
||||
|
||||
@group(0) @binding(2)
|
||||
var acc_struct: acceleration_structure;
|
||||
|
||||
@compute @workgroup_size(8, 8)
|
||||
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
|
||||
let target_size = textureDimensions(output);
|
||||
|
||||
let pixel_center = vec2<f32>(global_id.xy) + vec2<f32>(0.5);
|
||||
let in_uv = pixel_center / vec2<f32>(target_size.xy);
|
||||
let d = in_uv * 2.0 - 1.0;
|
||||
|
||||
let origin = (uniforms.view_inv * vec4<f32>(0.0, 0.0, 0.0, 1.0)).xyz;
|
||||
let temp = uniforms.proj_inv * vec4<f32>(d.x, d.y, 1.0, 1.0);
|
||||
let direction = (uniforms.view_inv * vec4<f32>(normalize(temp.xyz), 0.0)).xyz;
|
||||
|
||||
var rq: ray_query;
|
||||
rayQueryInitialize(&rq, acc_struct, RayDesc(0u, 0xFFu, 0.1, 200.0, origin, direction));
|
||||
rayQueryProceed(&rq);
|
||||
|
||||
var color = vec4<f32>(0.0, 0.0, 0.0, 1.0);
|
||||
let intersection = rayQueryGetCommittedIntersection(&rq);
|
||||
if intersection.kind != RAY_QUERY_INTERSECTION_NONE {
|
||||
color = vec4<f32>(intersection.barycentrics, 1.0 - intersection.barycentrics.x - intersection.barycentrics.y, 1.0);
|
||||
}
|
||||
|
||||
textureStore(output, global_id.xy, color);
|
||||
}
|
||||
+301
@@ -0,0 +1,301 @@
|
||||
use alloc::string::String;
|
||||
use std::{ffi::OsString, os::windows::ffi::OsStringExt};
|
||||
|
||||
use windows::Win32::Graphics::Dxgi;
|
||||
|
||||
// Helper to convert DXGI adapter name to a normal string
|
||||
pub fn map_adapter_name(name: [u16; 128]) -> String {
|
||||
let len = name.iter().take_while(|&&c| c != 0).count();
|
||||
let name = OsString::from_wide(&name[..len]);
|
||||
name.to_string_lossy().into_owned()
|
||||
}
|
||||
|
||||
pub fn map_texture_format_failable(
|
||||
format: wgt::TextureFormat,
|
||||
) -> Option<Dxgi::Common::DXGI_FORMAT> {
|
||||
use wgt::TextureFormat as Tf;
|
||||
use Dxgi::Common::*;
|
||||
|
||||
Some(match format {
|
||||
Tf::R8Unorm => DXGI_FORMAT_R8_UNORM,
|
||||
Tf::R8Snorm => DXGI_FORMAT_R8_SNORM,
|
||||
Tf::R8Uint => DXGI_FORMAT_R8_UINT,
|
||||
Tf::R8Sint => DXGI_FORMAT_R8_SINT,
|
||||
Tf::R16Uint => DXGI_FORMAT_R16_UINT,
|
||||
Tf::R16Sint => DXGI_FORMAT_R16_SINT,
|
||||
Tf::R16Unorm => DXGI_FORMAT_R16_UNORM,
|
||||
Tf::R16Snorm => DXGI_FORMAT_R16_SNORM,
|
||||
Tf::R16Float => DXGI_FORMAT_R16_FLOAT,
|
||||
Tf::Rg8Unorm => DXGI_FORMAT_R8G8_UNORM,
|
||||
Tf::Rg8Snorm => DXGI_FORMAT_R8G8_SNORM,
|
||||
Tf::Rg8Uint => DXGI_FORMAT_R8G8_UINT,
|
||||
Tf::Rg8Sint => DXGI_FORMAT_R8G8_SINT,
|
||||
Tf::Rg16Unorm => DXGI_FORMAT_R16G16_UNORM,
|
||||
Tf::Rg16Snorm => DXGI_FORMAT_R16G16_SNORM,
|
||||
Tf::R32Uint => DXGI_FORMAT_R32_UINT,
|
||||
Tf::R32Sint => DXGI_FORMAT_R32_SINT,
|
||||
Tf::R32Float => DXGI_FORMAT_R32_FLOAT,
|
||||
Tf::Rg16Uint => DXGI_FORMAT_R16G16_UINT,
|
||||
Tf::Rg16Sint => DXGI_FORMAT_R16G16_SINT,
|
||||
Tf::Rg16Float => DXGI_FORMAT_R16G16_FLOAT,
|
||||
Tf::Rgba8Unorm => DXGI_FORMAT_R8G8B8A8_UNORM,
|
||||
Tf::Rgba8UnormSrgb => DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
|
||||
Tf::Bgra8UnormSrgb => DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,
|
||||
Tf::Rgba8Snorm => DXGI_FORMAT_R8G8B8A8_SNORM,
|
||||
Tf::Bgra8Unorm => DXGI_FORMAT_B8G8R8A8_UNORM,
|
||||
Tf::Rgba8Uint => DXGI_FORMAT_R8G8B8A8_UINT,
|
||||
Tf::Rgba8Sint => DXGI_FORMAT_R8G8B8A8_SINT,
|
||||
Tf::Rgb9e5Ufloat => DXGI_FORMAT_R9G9B9E5_SHAREDEXP,
|
||||
Tf::Rgb10a2Uint => DXGI_FORMAT_R10G10B10A2_UINT,
|
||||
Tf::Rgb10a2Unorm => DXGI_FORMAT_R10G10B10A2_UNORM,
|
||||
Tf::Rg11b10Ufloat => DXGI_FORMAT_R11G11B10_FLOAT,
|
||||
Tf::R64Uint => DXGI_FORMAT_R32G32_UINT, // R64 emulated by R32G32
|
||||
Tf::Rg32Uint => DXGI_FORMAT_R32G32_UINT,
|
||||
Tf::Rg32Sint => DXGI_FORMAT_R32G32_SINT,
|
||||
Tf::Rg32Float => DXGI_FORMAT_R32G32_FLOAT,
|
||||
Tf::Rgba16Uint => DXGI_FORMAT_R16G16B16A16_UINT,
|
||||
Tf::Rgba16Sint => DXGI_FORMAT_R16G16B16A16_SINT,
|
||||
Tf::Rgba16Unorm => DXGI_FORMAT_R16G16B16A16_UNORM,
|
||||
Tf::Rgba16Snorm => DXGI_FORMAT_R16G16B16A16_SNORM,
|
||||
Tf::Rgba16Float => DXGI_FORMAT_R16G16B16A16_FLOAT,
|
||||
Tf::Rgba32Uint => DXGI_FORMAT_R32G32B32A32_UINT,
|
||||
Tf::Rgba32Sint => DXGI_FORMAT_R32G32B32A32_SINT,
|
||||
Tf::Rgba32Float => DXGI_FORMAT_R32G32B32A32_FLOAT,
|
||||
Tf::Stencil8 => DXGI_FORMAT_D24_UNORM_S8_UINT,
|
||||
Tf::Depth16Unorm => DXGI_FORMAT_D16_UNORM,
|
||||
Tf::Depth24Plus => DXGI_FORMAT_D24_UNORM_S8_UINT,
|
||||
Tf::Depth24PlusStencil8 => DXGI_FORMAT_D24_UNORM_S8_UINT,
|
||||
Tf::Depth32Float => DXGI_FORMAT_D32_FLOAT,
|
||||
Tf::Depth32FloatStencil8 => DXGI_FORMAT_D32_FLOAT_S8X24_UINT,
|
||||
Tf::NV12 => DXGI_FORMAT_NV12,
|
||||
Tf::P010 => DXGI_FORMAT_P010,
|
||||
Tf::Bc1RgbaUnorm => DXGI_FORMAT_BC1_UNORM,
|
||||
Tf::Bc1RgbaUnormSrgb => DXGI_FORMAT_BC1_UNORM_SRGB,
|
||||
Tf::Bc2RgbaUnorm => DXGI_FORMAT_BC2_UNORM,
|
||||
Tf::Bc2RgbaUnormSrgb => DXGI_FORMAT_BC2_UNORM_SRGB,
|
||||
Tf::Bc3RgbaUnorm => DXGI_FORMAT_BC3_UNORM,
|
||||
Tf::Bc3RgbaUnormSrgb => DXGI_FORMAT_BC3_UNORM_SRGB,
|
||||
Tf::Bc4RUnorm => DXGI_FORMAT_BC4_UNORM,
|
||||
Tf::Bc4RSnorm => DXGI_FORMAT_BC4_SNORM,
|
||||
Tf::Bc5RgUnorm => DXGI_FORMAT_BC5_UNORM,
|
||||
Tf::Bc5RgSnorm => DXGI_FORMAT_BC5_SNORM,
|
||||
Tf::Bc6hRgbUfloat => DXGI_FORMAT_BC6H_UF16,
|
||||
Tf::Bc6hRgbFloat => DXGI_FORMAT_BC6H_SF16,
|
||||
Tf::Bc7RgbaUnorm => DXGI_FORMAT_BC7_UNORM,
|
||||
Tf::Bc7RgbaUnormSrgb => DXGI_FORMAT_BC7_UNORM_SRGB,
|
||||
Tf::Etc2Rgb8Unorm
|
||||
| Tf::Etc2Rgb8UnormSrgb
|
||||
| Tf::Etc2Rgb8A1Unorm
|
||||
| Tf::Etc2Rgb8A1UnormSrgb
|
||||
| Tf::Etc2Rgba8Unorm
|
||||
| Tf::Etc2Rgba8UnormSrgb
|
||||
| Tf::EacR11Unorm
|
||||
| Tf::EacR11Snorm
|
||||
| Tf::EacRg11Unorm
|
||||
| Tf::EacRg11Snorm
|
||||
| Tf::Astc {
|
||||
block: _,
|
||||
channel: _,
|
||||
} => return None,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn map_texture_format(format: wgt::TextureFormat) -> Dxgi::Common::DXGI_FORMAT {
|
||||
match map_texture_format_failable(format) {
|
||||
Some(f) => f,
|
||||
None => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
// Note: DXGI doesn't allow sRGB format on the swapchain,
|
||||
// but creating RTV of swapchain buffers with sRGB works.
|
||||
pub fn map_texture_format_nosrgb(format: wgt::TextureFormat) -> Dxgi::Common::DXGI_FORMAT {
|
||||
match format {
|
||||
wgt::TextureFormat::Bgra8UnormSrgb => Dxgi::Common::DXGI_FORMAT_B8G8R8A8_UNORM,
|
||||
wgt::TextureFormat::Rgba8UnormSrgb => Dxgi::Common::DXGI_FORMAT_R8G8B8A8_UNORM,
|
||||
_ => map_texture_format(format),
|
||||
}
|
||||
}
|
||||
|
||||
// SRV and UAV can't use the depth or typeless formats
|
||||
// see https://microsoft.github.io/DirectX-Specs/d3d/PlanarDepthStencilDDISpec.html#view-creation
|
||||
pub fn map_texture_format_for_srv_uav(
|
||||
format: wgt::TextureFormat,
|
||||
aspect: crate::FormatAspects,
|
||||
) -> Option<Dxgi::Common::DXGI_FORMAT> {
|
||||
Some(match (format, aspect) {
|
||||
(wgt::TextureFormat::Depth16Unorm, crate::FormatAspects::DEPTH) => {
|
||||
Dxgi::Common::DXGI_FORMAT_R16_UNORM
|
||||
}
|
||||
(wgt::TextureFormat::Depth32Float, crate::FormatAspects::DEPTH) => {
|
||||
Dxgi::Common::DXGI_FORMAT_R32_FLOAT
|
||||
}
|
||||
(wgt::TextureFormat::Depth32FloatStencil8, crate::FormatAspects::DEPTH) => {
|
||||
Dxgi::Common::DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS
|
||||
}
|
||||
(
|
||||
wgt::TextureFormat::Depth24Plus | wgt::TextureFormat::Depth24PlusStencil8,
|
||||
crate::FormatAspects::DEPTH,
|
||||
) => Dxgi::Common::DXGI_FORMAT_R24_UNORM_X8_TYPELESS,
|
||||
|
||||
(wgt::TextureFormat::Depth32FloatStencil8, crate::FormatAspects::STENCIL) => {
|
||||
Dxgi::Common::DXGI_FORMAT_X32_TYPELESS_G8X24_UINT
|
||||
}
|
||||
(
|
||||
wgt::TextureFormat::Stencil8 | wgt::TextureFormat::Depth24PlusStencil8,
|
||||
crate::FormatAspects::STENCIL,
|
||||
) => Dxgi::Common::DXGI_FORMAT_X24_TYPELESS_G8_UINT,
|
||||
|
||||
(_, crate::FormatAspects::DEPTH)
|
||||
| (_, crate::FormatAspects::STENCIL)
|
||||
| (_, crate::FormatAspects::DEPTH_STENCIL) => return None,
|
||||
|
||||
_ => map_texture_format(format),
|
||||
})
|
||||
}
|
||||
|
||||
// see https://microsoft.github.io/DirectX-Specs/d3d/PlanarDepthStencilDDISpec.html#planar-layout-for-staging-from-buffer
|
||||
pub fn map_texture_format_for_copy(
|
||||
format: wgt::TextureFormat,
|
||||
aspect: crate::FormatAspects,
|
||||
) -> Option<Dxgi::Common::DXGI_FORMAT> {
|
||||
Some(match (format, aspect) {
|
||||
(wgt::TextureFormat::Depth16Unorm, crate::FormatAspects::DEPTH) => {
|
||||
Dxgi::Common::DXGI_FORMAT_R16_UNORM
|
||||
}
|
||||
(
|
||||
wgt::TextureFormat::Depth32Float | wgt::TextureFormat::Depth32FloatStencil8,
|
||||
crate::FormatAspects::DEPTH,
|
||||
) => Dxgi::Common::DXGI_FORMAT_R32_FLOAT,
|
||||
|
||||
(
|
||||
wgt::TextureFormat::Stencil8
|
||||
| wgt::TextureFormat::Depth24PlusStencil8
|
||||
| wgt::TextureFormat::Depth32FloatStencil8,
|
||||
crate::FormatAspects::STENCIL,
|
||||
) => Dxgi::Common::DXGI_FORMAT_R8_UINT,
|
||||
|
||||
// `CopyTextureRegion` on a plane subresource wants the
|
||||
// single-plane DXGI format, not the planar one.
|
||||
(format, aspects) if format.is_multi_planar_format() && aspects.is_one() => {
|
||||
map_texture_format(format.aspect_specific_format(aspects.map())?)
|
||||
}
|
||||
|
||||
(format, crate::FormatAspects::COLOR) => map_texture_format(format),
|
||||
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn map_texture_format_for_resource(
|
||||
format: wgt::TextureFormat,
|
||||
usage: wgt::TextureUses,
|
||||
has_view_formats: bool,
|
||||
casting_fully_typed_format_supported: bool,
|
||||
) -> Dxgi::Common::DXGI_FORMAT {
|
||||
use wgt::TextureFormat as Tf;
|
||||
use Dxgi::Common::*;
|
||||
|
||||
if casting_fully_typed_format_supported {
|
||||
map_texture_format(format)
|
||||
|
||||
// We might view this resource as srgb or non-srgb
|
||||
} else if has_view_formats {
|
||||
match format {
|
||||
Tf::Rgba8Unorm | Tf::Rgba8UnormSrgb => DXGI_FORMAT_R8G8B8A8_TYPELESS,
|
||||
Tf::Bgra8Unorm | Tf::Bgra8UnormSrgb => DXGI_FORMAT_B8G8R8A8_TYPELESS,
|
||||
Tf::Bc1RgbaUnorm | Tf::Bc1RgbaUnormSrgb => DXGI_FORMAT_BC1_TYPELESS,
|
||||
Tf::Bc2RgbaUnorm | Tf::Bc2RgbaUnormSrgb => DXGI_FORMAT_BC2_TYPELESS,
|
||||
Tf::Bc3RgbaUnorm | Tf::Bc3RgbaUnormSrgb => DXGI_FORMAT_BC3_TYPELESS,
|
||||
Tf::Bc7RgbaUnorm | Tf::Bc7RgbaUnormSrgb => DXGI_FORMAT_BC7_TYPELESS,
|
||||
format => map_texture_format(format),
|
||||
}
|
||||
|
||||
// We might view this resource as SRV/UAV but also as DSV
|
||||
} else if format.is_depth_stencil_format()
|
||||
&& usage.intersects(
|
||||
wgt::TextureUses::RESOURCE
|
||||
| wgt::TextureUses::STORAGE_READ_ONLY
|
||||
| wgt::TextureUses::STORAGE_WRITE_ONLY
|
||||
| wgt::TextureUses::STORAGE_READ_WRITE,
|
||||
)
|
||||
{
|
||||
match format {
|
||||
Tf::Depth16Unorm => DXGI_FORMAT_R16_TYPELESS,
|
||||
Tf::Depth32Float => DXGI_FORMAT_R32_TYPELESS,
|
||||
Tf::Depth32FloatStencil8 => DXGI_FORMAT_R32G8X24_TYPELESS,
|
||||
Tf::Stencil8 | Tf::Depth24Plus | Tf::Depth24PlusStencil8 => DXGI_FORMAT_R24G8_TYPELESS,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
} else {
|
||||
map_texture_format(format)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_index_format(format: wgt::IndexFormat) -> Dxgi::Common::DXGI_FORMAT {
|
||||
match format {
|
||||
wgt::IndexFormat::Uint16 => Dxgi::Common::DXGI_FORMAT_R16_UINT,
|
||||
wgt::IndexFormat::Uint32 => Dxgi::Common::DXGI_FORMAT_R32_UINT,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_vertex_format(format: wgt::VertexFormat) -> Dxgi::Common::DXGI_FORMAT {
|
||||
use wgt::VertexFormat as Vf;
|
||||
use Dxgi::Common::*;
|
||||
|
||||
match format {
|
||||
Vf::Unorm8 => DXGI_FORMAT_R8_UNORM,
|
||||
Vf::Snorm8 => DXGI_FORMAT_R8_SNORM,
|
||||
Vf::Uint8 => DXGI_FORMAT_R8_UINT,
|
||||
Vf::Sint8 => DXGI_FORMAT_R8_SINT,
|
||||
Vf::Unorm8x2 => DXGI_FORMAT_R8G8_UNORM,
|
||||
Vf::Snorm8x2 => DXGI_FORMAT_R8G8_SNORM,
|
||||
Vf::Uint8x2 => DXGI_FORMAT_R8G8_UINT,
|
||||
Vf::Sint8x2 => DXGI_FORMAT_R8G8_SINT,
|
||||
Vf::Unorm8x4 => DXGI_FORMAT_R8G8B8A8_UNORM,
|
||||
Vf::Snorm8x4 => DXGI_FORMAT_R8G8B8A8_SNORM,
|
||||
Vf::Uint8x4 => DXGI_FORMAT_R8G8B8A8_UINT,
|
||||
Vf::Sint8x4 => DXGI_FORMAT_R8G8B8A8_SINT,
|
||||
Vf::Unorm16 => DXGI_FORMAT_R16_UNORM,
|
||||
Vf::Snorm16 => DXGI_FORMAT_R16_SNORM,
|
||||
Vf::Uint16 => DXGI_FORMAT_R16_UINT,
|
||||
Vf::Sint16 => DXGI_FORMAT_R16_SINT,
|
||||
Vf::Float16 => DXGI_FORMAT_R16_FLOAT,
|
||||
Vf::Unorm16x2 => DXGI_FORMAT_R16G16_UNORM,
|
||||
Vf::Snorm16x2 => DXGI_FORMAT_R16G16_SNORM,
|
||||
Vf::Uint16x2 => DXGI_FORMAT_R16G16_UINT,
|
||||
Vf::Sint16x2 => DXGI_FORMAT_R16G16_SINT,
|
||||
Vf::Float16x2 => DXGI_FORMAT_R16G16_FLOAT,
|
||||
Vf::Unorm16x4 => DXGI_FORMAT_R16G16B16A16_UNORM,
|
||||
Vf::Snorm16x4 => DXGI_FORMAT_R16G16B16A16_SNORM,
|
||||
Vf::Uint16x4 => DXGI_FORMAT_R16G16B16A16_UINT,
|
||||
Vf::Sint16x4 => DXGI_FORMAT_R16G16B16A16_SINT,
|
||||
Vf::Float16x4 => DXGI_FORMAT_R16G16B16A16_FLOAT,
|
||||
Vf::Uint32 => DXGI_FORMAT_R32_UINT,
|
||||
Vf::Sint32 => DXGI_FORMAT_R32_SINT,
|
||||
Vf::Float32 => DXGI_FORMAT_R32_FLOAT,
|
||||
Vf::Uint32x2 => DXGI_FORMAT_R32G32_UINT,
|
||||
Vf::Sint32x2 => DXGI_FORMAT_R32G32_SINT,
|
||||
Vf::Float32x2 => DXGI_FORMAT_R32G32_FLOAT,
|
||||
Vf::Uint32x3 => DXGI_FORMAT_R32G32B32_UINT,
|
||||
Vf::Sint32x3 => DXGI_FORMAT_R32G32B32_SINT,
|
||||
Vf::Float32x3 => DXGI_FORMAT_R32G32B32_FLOAT,
|
||||
Vf::Uint32x4 => DXGI_FORMAT_R32G32B32A32_UINT,
|
||||
Vf::Sint32x4 => DXGI_FORMAT_R32G32B32A32_SINT,
|
||||
Vf::Float32x4 => DXGI_FORMAT_R32G32B32A32_FLOAT,
|
||||
Vf::Unorm10_10_10_2 => DXGI_FORMAT_R10G10B10A2_UNORM,
|
||||
Vf::Unorm8x4Bgra => DXGI_FORMAT_B8G8R8A8_UNORM,
|
||||
Vf::Float64 | Vf::Float64x2 | Vf::Float64x3 | Vf::Float64x4 => unimplemented!(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_acomposite_alpha_mode(mode: wgt::CompositeAlphaMode) -> Dxgi::Common::DXGI_ALPHA_MODE {
|
||||
match mode {
|
||||
wgt::CompositeAlphaMode::PreMultiplied => Dxgi::Common::DXGI_ALPHA_MODE_PREMULTIPLIED,
|
||||
wgt::CompositeAlphaMode::PostMultiplied => Dxgi::Common::DXGI_ALPHA_MODE_STRAIGHT,
|
||||
wgt::CompositeAlphaMode::Opaque => Dxgi::Common::DXGI_ALPHA_MODE_IGNORE,
|
||||
wgt::CompositeAlphaMode::Auto | wgt::CompositeAlphaMode::Inherit => {
|
||||
Dxgi::Common::DXGI_ALPHA_MODE_UNSPECIFIED
|
||||
}
|
||||
}
|
||||
}
|
||||
+97
@@ -0,0 +1,97 @@
|
||||
use alloc::{borrow::Cow, string::String};
|
||||
|
||||
use parking_lot::Mutex;
|
||||
use windows::Win32::{Foundation, System::Diagnostics::Debug};
|
||||
|
||||
// This is a mutex as opposed to an atomic as we need to completely
|
||||
// lock everyone out until we have registered or unregistered the
|
||||
// exception handler, otherwise really nasty races could happen.
|
||||
//
|
||||
// By routing all the registration through these functions we can guarantee
|
||||
// there is either 1 or 0 exception handlers registered, not multiple.
|
||||
static EXCEPTION_HANDLER_COUNT: Mutex<usize> = Mutex::new(0);
|
||||
|
||||
pub fn register_exception_handler() {
|
||||
let mut count_guard = EXCEPTION_HANDLER_COUNT.lock();
|
||||
if *count_guard == 0 {
|
||||
unsafe { Debug::AddVectoredExceptionHandler(0, Some(output_debug_string_handler)) };
|
||||
}
|
||||
*count_guard += 1;
|
||||
}
|
||||
|
||||
pub fn unregister_exception_handler() {
|
||||
let mut count_guard = EXCEPTION_HANDLER_COUNT.lock();
|
||||
if *count_guard == 1 {
|
||||
unsafe { Debug::RemoveVectoredExceptionHandler(output_debug_string_handler as *mut _) };
|
||||
}
|
||||
*count_guard -= 1;
|
||||
}
|
||||
|
||||
const MESSAGE_PREFIXES: &[(&str, log::Level)] = &[
|
||||
("CORRUPTION", log::Level::Error),
|
||||
("ERROR", log::Level::Error),
|
||||
("WARNING", log::Level::Warn),
|
||||
// We intentionally suppress "INFO" messages down to debug
|
||||
// so that users are not innundated with info messages from the runtime.
|
||||
("INFO", log::Level::Debug),
|
||||
("MESSAGE", log::Level::Trace),
|
||||
];
|
||||
|
||||
unsafe extern "system" fn output_debug_string_handler(
|
||||
exception_info: *mut Debug::EXCEPTION_POINTERS,
|
||||
) -> i32 {
|
||||
// See https://stackoverflow.com/a/41480827
|
||||
let record = unsafe { &*(*exception_info).ExceptionRecord };
|
||||
if record.NumberParameters != 2 {
|
||||
return Debug::EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
let message = match record.ExceptionCode {
|
||||
Foundation::DBG_PRINTEXCEPTION_C => {
|
||||
String::from_utf8_lossy(bytemuck::cast_slice(&record.ExceptionInformation))
|
||||
}
|
||||
Foundation::DBG_PRINTEXCEPTION_WIDE_C => Cow::Owned(String::from_utf16_lossy(
|
||||
bytemuck::cast_slice(&record.ExceptionInformation),
|
||||
)),
|
||||
_ => return Debug::EXCEPTION_CONTINUE_SEARCH,
|
||||
};
|
||||
|
||||
let message = match message.strip_prefix("D3D12 ") {
|
||||
Some(msg) => msg
|
||||
.trim_end_matches("\n\0")
|
||||
.trim_end_matches("[ STATE_CREATION WARNING #0: UNKNOWN]"),
|
||||
None => return Debug::EXCEPTION_CONTINUE_SEARCH,
|
||||
};
|
||||
|
||||
let (message, level) = match MESSAGE_PREFIXES
|
||||
.iter()
|
||||
.find(|&&(prefix, _)| message.starts_with(prefix))
|
||||
{
|
||||
Some(&(prefix, level)) => (&message[prefix.len() + 2..], level),
|
||||
None => (message, log::Level::Debug),
|
||||
};
|
||||
|
||||
if level == log::Level::Warn && message.contains("#82") {
|
||||
// This is are useless spammy warnings (#820, #821):
|
||||
// "The application did not pass any clear value to resource creation"
|
||||
return Debug::EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
|
||||
if level == log::Level::Warn && message.contains("DRAW_EMPTY_SCISSOR_RECTANGLE") {
|
||||
// This is normal, WebGPU allows passing empty scissor rectangles.
|
||||
return Debug::EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
|
||||
let _ = std::panic::catch_unwind(|| {
|
||||
log::log!(level, "{message}");
|
||||
});
|
||||
|
||||
#[cfg(feature = "validation_canary")]
|
||||
if cfg!(debug_assertions) && level == log::Level::Error {
|
||||
use alloc::string::ToString as _;
|
||||
|
||||
// Set canary and continue
|
||||
crate::VALIDATION_CANARY.add(message.to_string());
|
||||
}
|
||||
|
||||
Debug::EXCEPTION_CONTINUE_EXECUTION
|
||||
}
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
use alloc::{string::String, vec::Vec};
|
||||
use core::ops::Deref;
|
||||
|
||||
use windows::{core::Interface as _, Win32::Graphics::Dxgi};
|
||||
|
||||
use crate::dx12::DxgiLib;
|
||||
|
||||
use super::result::HResult as _;
|
||||
|
||||
// We can rely on the presence of DXGI 1.4 since D3D12 requires WDDM 2.0, Windows 10 (1507), and so does DXGI 1.4.
|
||||
|
||||
fn should_keep_adapter(adapter: &Dxgi::IDXGIAdapter1) -> bool {
|
||||
let desc = unsafe { adapter.GetDesc1() }.unwrap();
|
||||
|
||||
// The Intel Haswell family of iGPUs had support for the D3D12 API but it was later
|
||||
// removed due to a security vulnerability.
|
||||
//
|
||||
// We are explicitly filtering out all the devices in the family because we are now
|
||||
// getting reports of device loss at a later time than at device creation time (`D3D12CreateDevice`).
|
||||
//
|
||||
// See https://www.intel.com/content/www/us/en/support/articles/000057520/graphics.html
|
||||
// This list of device IDs is from https://dgpu-docs.intel.com/devices/hardware-table.html
|
||||
let haswell_device_ids = [
|
||||
0x0422, 0x0426, 0x042A, 0x042B, 0x042E, 0x0C22, 0x0C26, 0x0C2A, 0x0C2B, 0x0C2E, 0x0A22,
|
||||
0x0A2A, 0x0A2B, 0x0D2A, 0x0D2B, 0x0D2E, 0x0A26, 0x0A2E, 0x0D22, 0x0D26, 0x0412, 0x0416,
|
||||
0x0D12, 0x041A, 0x041B, 0x0C12, 0x0C16, 0x0C1A, 0x0C1B, 0x0C1E, 0x0A12, 0x0A1A, 0x0A1B,
|
||||
0x0D16, 0x0D1A, 0x0D1B, 0x0D1E, 0x041E, 0x0A16, 0x0A1E, 0x0402, 0x0406, 0x040A, 0x040B,
|
||||
0x040E, 0x0C02, 0x0C06, 0x0C0A, 0x0C0B, 0x0C0E, 0x0A02, 0x0A06, 0x0A0A, 0x0A0B, 0x0A0E,
|
||||
0x0D02, 0x0D06, 0x0D0A, 0x0D0B, 0x0D0E,
|
||||
];
|
||||
if desc.VendorId == 0x8086 && haswell_device_ids.contains(&desc.DeviceId) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// If run completely headless, windows will show two different WARP adapters, one
|
||||
// which is lying about being an integrated card. This is so that programs
|
||||
// that ignore software adapters will actually run on headless/gpu-less machines.
|
||||
//
|
||||
// We don't want that and discourage that kind of filtering anyway, so we skip the integrated WARP.
|
||||
if desc.VendorId == 5140
|
||||
&& !Dxgi::DXGI_ADAPTER_FLAG(desc.Flags as i32).contains(Dxgi::DXGI_ADAPTER_FLAG_SOFTWARE)
|
||||
{
|
||||
let adapter_name = super::conv::map_adapter_name(desc.Description);
|
||||
if adapter_name.contains("Microsoft Basic Render Driver") {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
true
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum DxgiAdapter {
|
||||
/// Provided by DXGI 1.4
|
||||
Adapter3(Dxgi::IDXGIAdapter3),
|
||||
/// Provided by DXGI 1.6
|
||||
Adapter4(Dxgi::IDXGIAdapter4),
|
||||
}
|
||||
|
||||
impl DxgiAdapter {
|
||||
pub fn query_video_memory_info(
|
||||
&self,
|
||||
group: Dxgi::DXGI_MEMORY_SEGMENT_GROUP,
|
||||
) -> Result<Dxgi::DXGI_QUERY_VIDEO_MEMORY_INFO, crate::DeviceError> {
|
||||
let mut info = Dxgi::DXGI_QUERY_VIDEO_MEMORY_INFO::default();
|
||||
unsafe { self.QueryVideoMemoryInfo(0, group, &mut info) }
|
||||
.into_device_result("QueryVideoMemoryInfo")?;
|
||||
Ok(info)
|
||||
}
|
||||
}
|
||||
|
||||
impl Deref for DxgiAdapter {
|
||||
type Target = Dxgi::IDXGIAdapter3;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
match self {
|
||||
DxgiAdapter::Adapter3(a) => a,
|
||||
DxgiAdapter::Adapter4(a) => a,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn enumerate_adapters(factory: DxgiFactory) -> Vec<DxgiAdapter> {
|
||||
let mut adapters = Vec::with_capacity(8);
|
||||
|
||||
for cur_index in 0.. {
|
||||
profiling::scope!("IDXGIFactory1::EnumAdapters1");
|
||||
let adapter1: Dxgi::IDXGIAdapter1 = match unsafe { factory.EnumAdapters1(cur_index) } {
|
||||
Ok(a) => a,
|
||||
Err(e) if e.code() == Dxgi::DXGI_ERROR_NOT_FOUND => break,
|
||||
Err(e) => {
|
||||
log::error!("Failed enumerating adapters: {e}");
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
if !should_keep_adapter(&adapter1) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Ok(adapter4) = adapter1.cast::<Dxgi::IDXGIAdapter4>() {
|
||||
adapters.push(DxgiAdapter::Adapter4(adapter4));
|
||||
} else {
|
||||
let adapter3 = adapter1.cast::<Dxgi::IDXGIAdapter3>().unwrap();
|
||||
adapters.push(DxgiAdapter::Adapter3(adapter3));
|
||||
}
|
||||
}
|
||||
|
||||
adapters
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum DxgiFactory {
|
||||
/// Provided by DXGI 1.4
|
||||
Factory4(Dxgi::IDXGIFactory4),
|
||||
/// Provided by DXGI 1.5
|
||||
Factory5(Dxgi::IDXGIFactory5),
|
||||
/// Provided by DXGI 1.6
|
||||
Factory6(Dxgi::IDXGIFactory6),
|
||||
}
|
||||
|
||||
impl Deref for DxgiFactory {
|
||||
type Target = Dxgi::IDXGIFactory4;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
match self {
|
||||
DxgiFactory::Factory4(f) => f,
|
||||
DxgiFactory::Factory5(f) => f,
|
||||
DxgiFactory::Factory6(f) => f,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DxgiFactory {
|
||||
pub fn as_factory5(&self) -> Option<&Dxgi::IDXGIFactory5> {
|
||||
match self {
|
||||
Self::Factory4(_) => None,
|
||||
Self::Factory5(f) => Some(f),
|
||||
Self::Factory6(f) => Some(f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_factory(
|
||||
instance_flags: wgt::InstanceFlags,
|
||||
) -> Result<(DxgiLib, DxgiFactory), crate::InstanceError> {
|
||||
let lib_dxgi = DxgiLib::new().map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("failed to load dxgi.dll"), e)
|
||||
})?;
|
||||
|
||||
let mut factory_flags = Dxgi::DXGI_CREATE_FACTORY_FLAGS::default();
|
||||
|
||||
if instance_flags.contains(wgt::InstanceFlags::VALIDATION) {
|
||||
// The `DXGI_CREATE_FACTORY_DEBUG` flag is only allowed to be passed to
|
||||
// `CreateDXGIFactory2` if the debug interface is actually available. So
|
||||
// we check for whether it exists first.
|
||||
if let Ok(Some(_)) = lib_dxgi.debug_interface1() {
|
||||
factory_flags |= Dxgi::DXGI_CREATE_FACTORY_DEBUG;
|
||||
}
|
||||
}
|
||||
|
||||
let factory4 = match lib_dxgi.create_factory4(factory_flags) {
|
||||
Ok(factory) => factory,
|
||||
Err(err) => {
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("IDXGIFactory4 creation failed"),
|
||||
err,
|
||||
));
|
||||
}
|
||||
};
|
||||
|
||||
if let Ok(factory6) = factory4.cast::<Dxgi::IDXGIFactory6>() {
|
||||
return Ok((lib_dxgi, DxgiFactory::Factory6(factory6)));
|
||||
}
|
||||
|
||||
if let Ok(factory5) = factory4.cast::<Dxgi::IDXGIFactory5>() {
|
||||
return Ok((lib_dxgi, DxgiFactory::Factory5(factory5)));
|
||||
}
|
||||
|
||||
Ok((lib_dxgi, DxgiFactory::Factory4(factory4)))
|
||||
}
|
||||
+352
@@ -0,0 +1,352 @@
|
||||
//! Reading a window's [`wgt::DisplayHdrInfo`] through DXGI.
|
||||
//!
|
||||
//! Lives in `auxil/dxgi` so the DX12 and Vulkan-on-Windows backends share it:
|
||||
//! both query through a [`DxgiHdrSource`], so the same monitor reports identical
|
||||
//! numbers under either backend.
|
||||
|
||||
use parking_lot::Mutex;
|
||||
use windows::{
|
||||
core::Interface as _,
|
||||
Win32::{
|
||||
Foundation::HWND,
|
||||
Graphics::{Dxgi, Gdi},
|
||||
},
|
||||
};
|
||||
|
||||
/// The primary colors of a color space, in CIE 1931 xy:
|
||||
/// `[[red_x, red_y], [green_x, green_y], [blue_x, blue_y]]`.
|
||||
type Primaries = [[f32; 2]; 3];
|
||||
|
||||
/// Reference primaries (CIE 1931 xy: red, green, blue) for the three coarse
|
||||
/// gamut buckets, used to classify a display's reported primaries.
|
||||
const REC709: Primaries = [[0.640, 0.330], [0.300, 0.600], [0.150, 0.060]];
|
||||
const DISPLAY_P3: Primaries = [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060]];
|
||||
const REC2020: Primaries = [[0.708, 0.292], [0.170, 0.797], [0.131, 0.046]];
|
||||
|
||||
/// Classifies reported primaries into the closest coarse [`wgt::DisplayGamut`]
|
||||
/// bucket (least-squares over the R/G/B chromaticities). Advisory only.
|
||||
///
|
||||
/// Returns `None` if every primary is zeroed (the EDID reported nothing usable),
|
||||
/// so a bogus all-zero descriptor is not misclassified as sRGB.
|
||||
fn classify_gamut(red: [f32; 2], green: [f32; 2], blue: [f32; 2]) -> Option<wgt::DisplayGamut> {
|
||||
let measured = [red, green, blue];
|
||||
if measured.iter().all(|p| p[0] == 0.0 && p[1] == 0.0) {
|
||||
return None;
|
||||
}
|
||||
let dist = |reference: &Primaries| -> f32 {
|
||||
measured
|
||||
.iter()
|
||||
.zip(reference)
|
||||
.map(|(m, r)| {
|
||||
let dx = m[0] - r[0];
|
||||
let dy = m[1] - r[1];
|
||||
dx * dx + dy * dy
|
||||
})
|
||||
.sum()
|
||||
};
|
||||
[
|
||||
(wgt::DisplayGamut::Srgb, dist(&REC709)),
|
||||
(wgt::DisplayGamut::DisplayP3, dist(&DISPLAY_P3)),
|
||||
(wgt::DisplayGamut::Rec2020, dist(&REC2020)),
|
||||
]
|
||||
.into_iter()
|
||||
.min_by(|a, b| a.1.total_cmp(&b.1))
|
||||
.map(|(gamut, _)| gamut)
|
||||
}
|
||||
|
||||
/// Maps an [`IDXGIOutput6::GetDesc1`] result and the SDR white level (from
|
||||
/// [`sdr_white_nits_for_monitor`]) into the backend-agnostic
|
||||
/// [`wgt::DisplayHdrInfo`].
|
||||
///
|
||||
/// Pure: it interprets `desc1` without any system call. Numeric values are
|
||||
/// advisory (EDID-sourced); see [`wgt::DisplayLuminance`].
|
||||
///
|
||||
/// [`IDXGIOutput6::GetDesc1`]: windows::Win32::Graphics::Dxgi::IDXGIOutput6::GetDesc1
|
||||
fn display_hdr_info_from_desc1(
|
||||
desc1: &Dxgi::DXGI_OUTPUT_DESC1,
|
||||
sdr_white_nits: Option<f32>,
|
||||
) -> wgt::DisplayHdrInfo {
|
||||
// The output is in an HDR color space if its `ColorSpace` is one of the two
|
||||
// Windows uses for HDR swap-chains: HDR10 / PQ (`G2084_NONE_P2020`) or
|
||||
// scRGB / linear-extended-sRGB (`G10_NONE_P709`). Checking both ensures scRGB
|
||||
// HDR is not misreported as SDR.
|
||||
let high_dynamic_range = desc1.ColorSpace
|
||||
== Dxgi::Common::DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020
|
||||
|| desc1.ColorSpace == Dxgi::Common::DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709;
|
||||
|
||||
let luminance = wgt::DisplayLuminance {
|
||||
max_nits: Some(desc1.MaxLuminance),
|
||||
max_full_frame_nits: Some(desc1.MaxFullFrameLuminance),
|
||||
min_nits: Some(desc1.MinLuminance),
|
||||
sdr_white_nits,
|
||||
};
|
||||
|
||||
let chromaticity = wgt::DisplayChromaticity {
|
||||
red: Some(desc1.RedPrimary),
|
||||
green: Some(desc1.GreenPrimary),
|
||||
blue: Some(desc1.BluePrimary),
|
||||
white: Some(desc1.WhitePoint),
|
||||
};
|
||||
|
||||
let coarse = wgt::DisplayCoarseRange {
|
||||
high_dynamic_range: Some(high_dynamic_range),
|
||||
gamut: classify_gamut(desc1.RedPrimary, desc1.GreenPrimary, desc1.BluePrimary),
|
||||
};
|
||||
|
||||
// `headroom` is `None`: DXGI exposes absolute luminance (captured in
|
||||
// `luminance`) rather than a relative headroom ratio. `bits_per_color` drops
|
||||
// values that don't fit `u8`.
|
||||
wgt::DisplayHdrInfo {
|
||||
luminance: Some(luminance),
|
||||
headroom: None,
|
||||
chromaticity: Some(chromaticity),
|
||||
coarse: Some(coarse),
|
||||
bits_per_color: u8::try_from(desc1.BitsPerColor).ok(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A window's display HDR info, read through DXGI.
|
||||
///
|
||||
/// Bundles the window's `HWND` with the DXGI factory used to query it. The factory
|
||||
/// is built once and reused, rebuilt only when DXGI reports it stale; the monitor
|
||||
/// lookup and adapter/output walk still run every call, since the window can move
|
||||
/// between displays and the SDR white level changes at runtime.
|
||||
pub struct DxgiHdrSource {
|
||||
hwnd: HWND,
|
||||
factory: Mutex<Option<Dxgi::IDXGIFactory1>>,
|
||||
}
|
||||
|
||||
// SAFETY: `HWND` and `IDXGIFactory1` are `!Send`/`!Sync` in windows-rs. The `HWND`
|
||||
// is only ever read to run a DXGI query (fine from any thread), and the factory is
|
||||
// free-threaded for the enumeration done here with the `Mutex` serializing access.
|
||||
// This mirrors the manual `Send`/`Sync` on `dx12::Surface`.
|
||||
unsafe impl Send for DxgiHdrSource {}
|
||||
unsafe impl Sync for DxgiHdrSource {}
|
||||
|
||||
impl DxgiHdrSource {
|
||||
/// Creates a source for the window identified by `hwnd`. The `HWND` is
|
||||
/// borrowed; using the source after that window is destroyed is undefined
|
||||
/// behavior.
|
||||
pub fn new(hwnd: HWND) -> Self {
|
||||
Self {
|
||||
hwnd,
|
||||
factory: Mutex::new(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Reads the window's [`wgt::DisplayHdrInfo`], or `None` if its monitor can't
|
||||
/// be identified or queried (a headless or composition window, a
|
||||
/// pre-Win10-1703 system without `IDXGIOutput6`, or a COM failure). Never
|
||||
/// panics.
|
||||
pub fn display_hdr_info(&self) -> Option<wgt::DisplayHdrInfo> {
|
||||
let desc1 = self.output_desc1()?;
|
||||
let sdr_white_nits = sdr_white_nits_for_monitor(desc1.Monitor);
|
||||
Some(display_hdr_info_from_desc1(&desc1, sdr_white_nits))
|
||||
}
|
||||
|
||||
/// The [`DXGI_OUTPUT_DESC1`] for the window's monitor, reusing the cached
|
||||
/// factory unless DXGI reports it stale.
|
||||
///
|
||||
/// [`DXGI_OUTPUT_DESC1`]: Dxgi::DXGI_OUTPUT_DESC1
|
||||
fn output_desc1(&self) -> Option<Dxgi::DXGI_OUTPUT_DESC1> {
|
||||
let mut factory = self.factory.lock();
|
||||
|
||||
// A factory only enumerates the adapter/output topology it saw at
|
||||
// creation, so rebuild it once it reports `IsCurrent() == false` (a
|
||||
// monitor or GPU was plugged or unplugged).
|
||||
// SAFETY: a cached factory is live; `IsCurrent` takes no caller pointers.
|
||||
let need_new = factory
|
||||
.as_ref()
|
||||
.is_none_or(|f| !unsafe { f.IsCurrent() }.as_bool());
|
||||
if need_new {
|
||||
// SAFETY: `CreateDXGIFactory1` takes no caller pointers; the `windows`
|
||||
// binding fills the interface out-pointer itself.
|
||||
match unsafe { Dxgi::CreateDXGIFactory1() } {
|
||||
Ok(new) => *factory = Some(new),
|
||||
Err(e) => {
|
||||
log::warn!("CreateDXGIFactory1 failed: {e}");
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
output_desc1_from_factory(factory.as_ref()?, self.hwnd)
|
||||
}
|
||||
}
|
||||
|
||||
/// The [`DXGI_OUTPUT_DESC1`] for the monitor backing `wnd_handle`, found by
|
||||
/// walking every adapter's outputs on `factory` — not just the rendering
|
||||
/// adapter's, so the monitor is found on hybrid-GPU systems where the window sits
|
||||
/// on a display wired to a different adapter. `None` if none match.
|
||||
///
|
||||
/// [`DXGI_OUTPUT_DESC1`]: Dxgi::DXGI_OUTPUT_DESC1
|
||||
fn output_desc1_from_factory(
|
||||
factory: &Dxgi::IDXGIFactory1,
|
||||
wnd_handle: HWND,
|
||||
) -> Option<Dxgi::DXGI_OUTPUT_DESC1> {
|
||||
// SAFETY: `MonitorFromWindow` is sound for any `HWND`; an invalid one yields
|
||||
// a null `HMONITOR`, checked below.
|
||||
let hmonitor = unsafe { Gdi::MonitorFromWindow(wnd_handle, Gdi::MONITOR_DEFAULTTONEAREST) };
|
||||
if hmonitor.is_invalid() {
|
||||
log::warn!("MonitorFromWindow failed; cannot identify the window's output");
|
||||
return None;
|
||||
}
|
||||
for adapter_index in 0.. {
|
||||
// SAFETY: `factory` is live; `EnumAdapters1` takes only an index.
|
||||
let adapter = match unsafe { factory.EnumAdapters1(adapter_index) } {
|
||||
Ok(adapter) => adapter,
|
||||
// End of the adapter list: the monitor matched none of them.
|
||||
Err(e) if e.code() == Dxgi::DXGI_ERROR_NOT_FOUND => break,
|
||||
Err(e) => {
|
||||
log::warn!("IDXGIFactory1::EnumAdapters1 failed: {e}");
|
||||
break;
|
||||
}
|
||||
};
|
||||
for output_index in 0.. {
|
||||
// SAFETY: `adapter` is live (from above); `EnumOutputs` takes only
|
||||
// an index.
|
||||
let output = match unsafe { adapter.EnumOutputs(output_index) } {
|
||||
Ok(output) => output,
|
||||
// End of this adapter's outputs: move on to the next adapter.
|
||||
Err(e) if e.code() == Dxgi::DXGI_ERROR_NOT_FOUND => break,
|
||||
Err(e) => {
|
||||
log::warn!("IDXGIAdapter1::EnumOutputs failed: {e}");
|
||||
break;
|
||||
}
|
||||
};
|
||||
// SAFETY: `output` is live (from above); `GetDesc` returns a
|
||||
// binding-owned `DXGI_OUTPUT_DESC` by value.
|
||||
let desc = match unsafe { output.GetDesc() } {
|
||||
Ok(desc) => desc,
|
||||
Err(e) => {
|
||||
log::warn!("IDXGIOutput::GetDesc failed: {e}");
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if desc.Monitor != hmonitor {
|
||||
continue;
|
||||
}
|
||||
// The window's monitor matched, so a failure past this point is a
|
||||
// real anomaly. `IDXGIOutput6` (DXGI 1.6 / Win10 1703+) is required
|
||||
// for `GetDesc1`.
|
||||
let output6 = match output.cast::<Dxgi::IDXGIOutput6>() {
|
||||
Ok(output6) => output6,
|
||||
Err(e) => {
|
||||
log::warn!("Casting to IDXGIOutput6 failed: {e}");
|
||||
return None;
|
||||
}
|
||||
};
|
||||
// SAFETY: `output6` is live (from the cast above); `GetDesc1`
|
||||
// returns a binding-owned `DXGI_OUTPUT_DESC1` by value.
|
||||
return match unsafe { output6.GetDesc1() } {
|
||||
Ok(desc1) => Some(desc1),
|
||||
Err(e) => {
|
||||
log::warn!("IDXGIOutput6::GetDesc1 failed: {e}");
|
||||
None
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
log::warn!("No DXGI output matches the window's monitor");
|
||||
None
|
||||
}
|
||||
|
||||
/// Best-effort SDR white level in nits for `hmonitor`, via the Windows
|
||||
/// DisplayConfig API. Tracks the brightness slider, so it changes at runtime.
|
||||
///
|
||||
/// This is the only [`wgt::DisplayLuminance`] field `GetDesc1` doesn't carry; it
|
||||
/// bridges absolute nits and relative headroom. It lives in
|
||||
/// `DISPLAYCONFIG_SDR_WHITE_LEVEL`, outside DXGI, so it needs its own query.
|
||||
///
|
||||
/// Returns `None` on any failure (no match, query error, or a `0` reading). Never
|
||||
/// panics. Pass [`Dxgi::DXGI_OUTPUT_DESC1::Monitor`] so the value matches the rest
|
||||
/// of the `DisplayHdrInfo`.
|
||||
fn sdr_white_nits_for_monitor(hmonitor: Gdi::HMONITOR) -> Option<f32> {
|
||||
use windows::Win32::{
|
||||
Devices::Display::{
|
||||
DisplayConfigGetDeviceInfo, GetDisplayConfigBufferSizes, QueryDisplayConfig,
|
||||
DISPLAYCONFIG_DEVICE_INFO_GET_SDR_WHITE_LEVEL,
|
||||
DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME, DISPLAYCONFIG_MODE_INFO,
|
||||
DISPLAYCONFIG_PATH_INFO, DISPLAYCONFIG_SDR_WHITE_LEVEL,
|
||||
DISPLAYCONFIG_SOURCE_DEVICE_NAME, QDC_ONLY_ACTIVE_PATHS,
|
||||
},
|
||||
Foundation::ERROR_SUCCESS,
|
||||
Graphics::Gdi::{GetMonitorInfoW, MONITORINFO, MONITORINFOEXW},
|
||||
};
|
||||
|
||||
// 1. HMONITOR -> GDI device name (e.g. `\\.\DISPLAY1`).
|
||||
let mut monitor_info = MONITORINFOEXW::default();
|
||||
monitor_info.monitorInfo.cbSize = size_of::<MONITORINFOEXW>() as u32;
|
||||
// `GetMonitorInfoW` takes a `*mut MONITORINFO`; the `EXW` variant is
|
||||
// layout-compatible (it starts with `MONITORINFO`) and reports `cbSize`.
|
||||
let lpmi = core::ptr::from_mut(&mut monitor_info).cast::<MONITORINFO>();
|
||||
// SAFETY: `lpmi` points at a live `MONITORINFOEXW` with `cbSize` set, which
|
||||
// bounds the write; an invalid `hmonitor` just fails (handled below).
|
||||
let got_info = unsafe { GetMonitorInfoW(hmonitor, lpmi) };
|
||||
if !got_info.as_bool() {
|
||||
return None;
|
||||
}
|
||||
let gdi_device_name = monitor_info.szDevice;
|
||||
|
||||
// 2. Enumerate the active DisplayConfig paths.
|
||||
let mut path_count = 0u32;
|
||||
let mut mode_count = 0u32;
|
||||
// SAFETY: both out-params are live `u32`s; the call only writes the required
|
||||
// buffer sizes into them.
|
||||
if unsafe {
|
||||
GetDisplayConfigBufferSizes(QDC_ONLY_ACTIVE_PATHS, &mut path_count, &mut mode_count)
|
||||
} != ERROR_SUCCESS
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let mut paths = alloc::vec![DISPLAYCONFIG_PATH_INFO::default(); path_count as usize];
|
||||
let mut modes = alloc::vec![DISPLAYCONFIG_MODE_INFO::default(); mode_count as usize];
|
||||
// SAFETY: `paths`/`modes` are sized to the counts reported above and passed
|
||||
// with those counts, bounding the writes.
|
||||
if unsafe {
|
||||
QueryDisplayConfig(
|
||||
QDC_ONLY_ACTIVE_PATHS,
|
||||
&mut path_count,
|
||||
paths.as_mut_ptr(),
|
||||
&mut mode_count,
|
||||
modes.as_mut_ptr(),
|
||||
None,
|
||||
)
|
||||
} != ERROR_SUCCESS
|
||||
{
|
||||
return None;
|
||||
}
|
||||
|
||||
// 3. Match the path whose source is this monitor, then read its target's
|
||||
// SDR white level. `DisplayConfigGetDeviceInfo` returns a WIN32 code as
|
||||
// `i32` (`0` == `ERROR_SUCCESS`).
|
||||
for path in paths.iter().take(path_count as usize) {
|
||||
let mut source = DISPLAYCONFIG_SOURCE_DEVICE_NAME::default();
|
||||
source.header.r#type = DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME;
|
||||
source.header.size = size_of::<DISPLAYCONFIG_SOURCE_DEVICE_NAME>() as u32;
|
||||
source.header.adapterId = path.sourceInfo.adapterId;
|
||||
source.header.id = path.sourceInfo.id;
|
||||
// SAFETY: `source` is live with `header.type`/`header.size` set, which
|
||||
// bounds the call's access to that struct.
|
||||
if unsafe { DisplayConfigGetDeviceInfo(&mut source.header) } != ERROR_SUCCESS.0 as i32 {
|
||||
continue;
|
||||
}
|
||||
if source.viewGdiDeviceName != gdi_device_name {
|
||||
continue;
|
||||
}
|
||||
|
||||
let mut white = DISPLAYCONFIG_SDR_WHITE_LEVEL::default();
|
||||
white.header.r#type = DISPLAYCONFIG_DEVICE_INFO_GET_SDR_WHITE_LEVEL;
|
||||
white.header.size = size_of::<DISPLAYCONFIG_SDR_WHITE_LEVEL>() as u32;
|
||||
white.header.adapterId = path.targetInfo.adapterId;
|
||||
white.header.id = path.targetInfo.id;
|
||||
// SAFETY: `white` is live with `header.type`/`header.size` set, which
|
||||
// bounds the call's access to that struct.
|
||||
if unsafe { DisplayConfigGetDeviceInfo(&mut white.header) } != ERROR_SUCCESS.0 as i32 {
|
||||
return None;
|
||||
}
|
||||
// `SDRWhiteLevel` encodes nits as `(nits / 80) * 1000`; `0` means the OS
|
||||
// reported nothing usable.
|
||||
return (white.SDRWhiteLevel > 0).then(|| white.SDRWhiteLevel as f32 * 80.0 / 1000.0);
|
||||
}
|
||||
None
|
||||
}
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
// Every module here is gated behind `dx12` except `hdr` (the
|
||||
// `DXGI_OUTPUT_DESC1` -> `DisplayHdrInfo` mapping), which the
|
||||
// Vulkan-on-Windows backend also uses.
|
||||
#[cfg(dx12)]
|
||||
pub mod conv;
|
||||
#[cfg(dx12)]
|
||||
pub mod exception;
|
||||
#[cfg(dx12)]
|
||||
pub mod factory;
|
||||
pub mod hdr;
|
||||
#[cfg(dx12)]
|
||||
pub mod name;
|
||||
#[cfg(dx12)]
|
||||
pub mod result;
|
||||
#[cfg(dx12)]
|
||||
pub mod time;
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
use windows::Win32::Graphics::Direct3D12::ID3D12Object;
|
||||
|
||||
use crate::auxil::dxgi::result::HResult;
|
||||
|
||||
/// Helper trait for setting the name of a D3D12 object.
|
||||
///
|
||||
/// This is implemented on all types that can be converted to an [`ID3D12Object`].
|
||||
pub trait ObjectExt {
|
||||
fn set_name(&self, name: &str) -> Result<(), crate::DeviceError>;
|
||||
}
|
||||
|
||||
impl<T> ObjectExt for T
|
||||
where
|
||||
// Windows impls `From` for all parent interfaces, so we can use that to convert to ID3D12Object.
|
||||
//
|
||||
// This includes implementations for references.
|
||||
for<'a> &'a ID3D12Object: From<&'a T>,
|
||||
{
|
||||
fn set_name(&self, name: &str) -> Result<(), crate::DeviceError> {
|
||||
let name = windows::core::HSTRING::from(name);
|
||||
let object: &ID3D12Object = self.into();
|
||||
unsafe { object.SetName(&name).into_device_result("SetName") }
|
||||
}
|
||||
}
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
use windows::Win32::{Foundation, Graphics::Dxgi};
|
||||
|
||||
pub(crate) trait HResult<O> {
|
||||
fn into_device_result(self, description: &str) -> Result<O, crate::DeviceError>;
|
||||
}
|
||||
impl<T> HResult<T> for windows::core::Result<T> {
|
||||
fn into_device_result(self, description: &str) -> Result<T, crate::DeviceError> {
|
||||
#![allow(unreachable_code)]
|
||||
|
||||
self.map_err(|err| {
|
||||
log::error!("{description} failed: {err}");
|
||||
|
||||
match err.code() {
|
||||
Foundation::E_OUTOFMEMORY => crate::DeviceError::OutOfMemory,
|
||||
Dxgi::DXGI_ERROR_DEVICE_RESET | Dxgi::DXGI_ERROR_DEVICE_REMOVED => {
|
||||
#[cfg(feature = "device_lost_panic")]
|
||||
panic!("{description} failed: Device lost ({err})");
|
||||
crate::DeviceError::Lost
|
||||
}
|
||||
_ => {
|
||||
#[cfg(feature = "internal_error_panic")]
|
||||
panic!("{description} failed: {err}");
|
||||
crate::DeviceError::Unexpected
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
+97
@@ -0,0 +1,97 @@
|
||||
#![allow(dead_code, reason = "IPresentationManager is unused currently")]
|
||||
|
||||
use windows::Win32::System::Performance::{QueryPerformanceCounter, QueryPerformanceFrequency};
|
||||
|
||||
pub enum PresentationTimer {
|
||||
/// DXGI uses [`QueryPerformanceCounter()`]
|
||||
Dxgi {
|
||||
/// How many ticks of QPC per second
|
||||
frequency: u64,
|
||||
},
|
||||
/// [`IPresentationManager`] uses [`QueryInterruptTimePrecise()`]
|
||||
///
|
||||
/// [`IPresentationManager`]: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Graphics/CompositionSwapchain/struct.IPresentationManager.html
|
||||
/// [`QueryInterruptTimePrecise()`]: https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/System/WindowsProgramming/fn.QueryInterruptTimePrecise.html
|
||||
#[allow(non_snake_case)]
|
||||
IPresentationManager {
|
||||
fnQueryInterruptTimePrecise: unsafe extern "system" fn(*mut u64),
|
||||
},
|
||||
}
|
||||
|
||||
impl core::fmt::Debug for PresentationTimer {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
||||
match *self {
|
||||
Self::Dxgi { frequency } => f
|
||||
.debug_struct("DXGI")
|
||||
.field("frequency", &frequency)
|
||||
.finish(),
|
||||
Self::IPresentationManager {
|
||||
fnQueryInterruptTimePrecise,
|
||||
} => f
|
||||
.debug_struct("IPresentationManager")
|
||||
.field(
|
||||
"QueryInterruptTimePrecise",
|
||||
&(fnQueryInterruptTimePrecise as usize),
|
||||
)
|
||||
.finish(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PresentationTimer {
|
||||
/// Create a presentation timer using QueryPerformanceFrequency (what DXGI uses for presentation times)
|
||||
pub fn new_dxgi() -> Self {
|
||||
let mut frequency = 0;
|
||||
unsafe { QueryPerformanceFrequency(&mut frequency) }.unwrap();
|
||||
|
||||
Self::Dxgi {
|
||||
frequency: frequency
|
||||
.try_into()
|
||||
.expect("Frequency should not be negative"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a presentation timer using QueryInterruptTimePrecise (what IPresentationManager uses for presentation times)
|
||||
///
|
||||
/// Panics if QueryInterruptTimePrecise isn't found (below Win10)
|
||||
pub fn new_ipresentation_manager() -> Self {
|
||||
// We need to load this explicitly, as QueryInterruptTimePrecise is only available on Windows 10+
|
||||
//
|
||||
// Docs say it's in kernel32.dll, but it's actually in kernelbase.dll.
|
||||
// api-ms-win-core-realtime-l1-1-1.dll
|
||||
let kernelbase =
|
||||
libloading::os::windows::Library::open_already_loaded("kernelbase.dll").unwrap();
|
||||
// No concerns about lifetimes here as kernelbase is always there.
|
||||
let ptr = unsafe {
|
||||
kernelbase
|
||||
.get(c"QueryInterruptTimePrecise".to_bytes())
|
||||
.unwrap()
|
||||
};
|
||||
Self::IPresentationManager {
|
||||
fnQueryInterruptTimePrecise: *ptr,
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets the current time in nanoseconds.
|
||||
pub fn get_timestamp_ns(&self) -> u128 {
|
||||
// Always do u128 math _after_ hitting the timing function.
|
||||
match *self {
|
||||
PresentationTimer::Dxgi { frequency } => {
|
||||
let mut counter = 0;
|
||||
unsafe { QueryPerformanceCounter(&mut counter) }.unwrap();
|
||||
|
||||
// counter * (1_000_000_000 / freq) but re-ordered to make more precise
|
||||
(counter as u128 * 1_000_000_000) / frequency as u128
|
||||
}
|
||||
PresentationTimer::IPresentationManager {
|
||||
fnQueryInterruptTimePrecise,
|
||||
} => {
|
||||
let mut counter = 0;
|
||||
unsafe { fnQueryInterruptTimePrecise(&mut counter) };
|
||||
|
||||
// QueryInterruptTimePrecise uses units of 100ns for its tick.
|
||||
counter as u128 * 100
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Vendored
+241
@@ -0,0 +1,241 @@
|
||||
// Mostly DX12-only, but also compiled for Vulkan-on-Windows, which reuses
|
||||
// `dxgi::hdr` to query display HDR info. The DX12-only submodules stay gated
|
||||
// behind `dx12` in `dxgi/mod.rs`.
|
||||
#[cfg(any(dx12, all(vulkan, windows)))]
|
||||
pub(super) mod dxgi;
|
||||
|
||||
#[cfg(all(native, feature = "renderdoc"))]
|
||||
pub(super) mod renderdoc;
|
||||
|
||||
pub mod db {
|
||||
pub mod amd {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x1002;
|
||||
}
|
||||
pub mod apple {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x106B;
|
||||
}
|
||||
pub mod arm {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x13B5;
|
||||
}
|
||||
pub mod broadcom {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x14E4;
|
||||
}
|
||||
pub mod imgtec {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x1010;
|
||||
}
|
||||
pub mod intel {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x8086;
|
||||
pub const DEVICE_KABY_LAKE_MASK: u32 = 0x5900;
|
||||
pub const DEVICE_SKY_LAKE_MASK: u32 = 0x1900;
|
||||
}
|
||||
pub mod mesa {
|
||||
// Mesa does not actually have a PCI vendor id.
|
||||
//
|
||||
// To match Vulkan, we use the VkVendorId for Mesa in the gles backend so that lavapipe (Vulkan) and
|
||||
// llvmpipe (OpenGL) have the same vendor id.
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x10005;
|
||||
}
|
||||
pub mod nvidia {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x10DE;
|
||||
}
|
||||
pub mod qualcomm {
|
||||
/// cbindgen:ignore
|
||||
pub const VENDOR: u32 = 0x5143;
|
||||
}
|
||||
}
|
||||
|
||||
/// Maximum binding size for the shaders that only support `i32` indexing.
|
||||
/// Interestingly, the index itself can't reach that high, because the minimum
|
||||
/// element size is 4 bytes, but the compiler toolchain still computes the
|
||||
/// offset at some intermediate point, internally, as i32.
|
||||
pub const MAX_I32_BINDING_SIZE: u32 = (1 << 31) - 1;
|
||||
|
||||
pub use wgpu_naga_bridge::map_naga_stage;
|
||||
|
||||
impl crate::CopyExtent {
|
||||
pub fn map_extent_to_copy_size(extent: &wgt::Extent3d, dim: wgt::TextureDimension) -> Self {
|
||||
Self {
|
||||
width: extent.width,
|
||||
height: extent.height,
|
||||
depth: match dim {
|
||||
wgt::TextureDimension::D1 | wgt::TextureDimension::D2 => 1,
|
||||
wgt::TextureDimension::D3 => extent.depth_or_array_layers,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn min(&self, other: &Self) -> Self {
|
||||
Self {
|
||||
width: self.width.min(other.width),
|
||||
height: self.height.min(other.height),
|
||||
depth: self.depth.min(other.depth),
|
||||
}
|
||||
}
|
||||
|
||||
// Get the copy size at a specific mipmap level. This doesn't make most sense,
|
||||
// since the copy extents are provided *for* a mipmap level to start with.
|
||||
// But backends use `CopyExtent` more sparingly, and this piece is shared.
|
||||
pub fn at_mip_level(&self, level: u32) -> Self {
|
||||
Self {
|
||||
width: (self.width >> level).max(1),
|
||||
height: (self.height >> level).max(1),
|
||||
depth: (self.depth >> level).max(1),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::TextureCopyBase {
|
||||
pub fn max_copy_size(&self, full_size: &crate::CopyExtent) -> crate::CopyExtent {
|
||||
let mip = full_size.at_mip_level(self.mip_level);
|
||||
crate::CopyExtent {
|
||||
width: mip.width - self.origin.x,
|
||||
height: mip.height - self.origin.y,
|
||||
depth: mip.depth - self.origin.z,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::BufferTextureCopy {
|
||||
pub fn clamp_size_to_virtual(&mut self, full_size: &crate::CopyExtent) {
|
||||
let max_size = self.texture_base.max_copy_size(full_size);
|
||||
self.size = self.size.min(&max_size);
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::TextureCopy {
|
||||
pub fn clamp_size_to_virtual(
|
||||
&mut self,
|
||||
full_src_size: &crate::CopyExtent,
|
||||
full_dst_size: &crate::CopyExtent,
|
||||
) {
|
||||
let max_src_size = self.src_base.max_copy_size(full_src_size);
|
||||
let max_dst_size = self.dst_base.max_copy_size(full_dst_size);
|
||||
self.size = self.size.min(&max_src_size).min(&max_dst_size);
|
||||
}
|
||||
}
|
||||
|
||||
/// Adjust `limits` to honor HAL-imposed maximums and comply with WebGPU's
|
||||
/// adapter capability guarantees.
|
||||
#[cfg_attr(not(any_backend), allow(dead_code))]
|
||||
pub(crate) fn adjust_raw_limits(mut limits: wgt::Limits) -> wgt::Limits {
|
||||
// Apply hal limits.
|
||||
limits.max_bind_groups = limits.max_bind_groups.min(crate::MAX_BIND_GROUPS as u32);
|
||||
limits.max_vertex_buffers = limits
|
||||
.max_vertex_buffers
|
||||
.min(crate::MAX_VERTEX_BUFFERS as u32);
|
||||
// Once we allow the 2 limits above to be higher than 24 we should use
|
||||
// `cap_limits_to_be_under_the_sum_limit` to cap them under
|
||||
// `max_bind_groups_plus_vertex_buffers`.
|
||||
const { assert!(crate::MAX_BIND_GROUPS + crate::MAX_VERTEX_BUFFERS == 24) };
|
||||
limits.max_bind_groups_plus_vertex_buffers = limits.max_bind_groups_plus_vertex_buffers.min(24);
|
||||
limits.max_color_attachments = limits
|
||||
.max_color_attachments
|
||||
.min(crate::MAX_COLOR_ATTACHMENTS as u32);
|
||||
|
||||
// Adjust limits according to WebGPU adapter capability guarantees.
|
||||
// See <https://gpuweb.github.io/gpuweb/#adapter-capability-guarantees>.
|
||||
|
||||
// WebGPU requires maxBindingsPerBindGroup to be at least the sum of all
|
||||
// per-stage limits multiplied with the maximum shader stages per pipeline.
|
||||
//
|
||||
// Since backends already report their maximum maxBindingsPerBindGroup,
|
||||
// we need to lower all per-stage limits to satisfy this guarantee.
|
||||
const MAX_SHADER_STAGES_PER_PIPELINE: u32 = 2;
|
||||
let max_per_stage_resources =
|
||||
limits.max_bindings_per_bind_group / MAX_SHADER_STAGES_PER_PIPELINE;
|
||||
|
||||
cap_limits_to_be_under_the_sum_limit(
|
||||
[
|
||||
&mut limits.max_sampled_textures_per_shader_stage,
|
||||
&mut limits.max_uniform_buffers_per_shader_stage,
|
||||
&mut limits.max_storage_textures_per_shader_stage,
|
||||
&mut limits.max_storage_buffers_per_shader_stage,
|
||||
&mut limits.max_samplers_per_shader_stage,
|
||||
&mut limits.max_acceleration_structures_per_shader_stage,
|
||||
],
|
||||
max_per_stage_resources,
|
||||
);
|
||||
|
||||
// Not required by the spec but dynamic buffers count
|
||||
// towards non-dynamic buffer limits as well.
|
||||
limits.max_dynamic_uniform_buffers_per_pipeline_layout = limits
|
||||
.max_dynamic_uniform_buffers_per_pipeline_layout
|
||||
.min(limits.max_uniform_buffers_per_shader_stage);
|
||||
limits.max_dynamic_storage_buffers_per_pipeline_layout = limits
|
||||
.max_dynamic_storage_buffers_per_pipeline_layout
|
||||
.min(limits.max_storage_buffers_per_shader_stage);
|
||||
|
||||
limits.min_uniform_buffer_offset_alignment = limits.min_uniform_buffer_offset_alignment.max(32);
|
||||
limits.min_storage_buffer_offset_alignment = limits.min_storage_buffer_offset_alignment.max(32);
|
||||
|
||||
limits.max_uniform_buffer_binding_size = limits
|
||||
.max_uniform_buffer_binding_size
|
||||
.min(limits.max_buffer_size);
|
||||
limits.max_storage_buffer_binding_size = limits
|
||||
.max_storage_buffer_binding_size
|
||||
.min(limits.max_buffer_size);
|
||||
|
||||
limits.max_storage_buffer_binding_size &= !(u64::from(wgt::STORAGE_BINDING_SIZE_ALIGNMENT) - 1);
|
||||
limits.max_vertex_buffer_array_stride &= !(wgt::VERTEX_ALIGNMENT as u32 - 1);
|
||||
|
||||
let x = limits.max_compute_workgroup_size_x;
|
||||
let y = limits.max_compute_workgroup_size_y;
|
||||
let z = limits.max_compute_workgroup_size_z;
|
||||
let m = limits.max_compute_invocations_per_workgroup;
|
||||
limits.max_compute_workgroup_size_x = x.min(m);
|
||||
limits.max_compute_workgroup_size_y = y.min(m);
|
||||
limits.max_compute_workgroup_size_z = z.min(m);
|
||||
limits.max_compute_invocations_per_workgroup = m.min(x.saturating_mul(y).saturating_mul(z));
|
||||
|
||||
limits.max_immediate_size = limits.max_immediate_size.min(256);
|
||||
|
||||
limits
|
||||
}
|
||||
|
||||
/// Evenly allocates space to each limit,
|
||||
/// capping them only if strictly necessary.
|
||||
pub fn cap_limits_to_be_under_the_sum_limit<const N: usize>(
|
||||
mut limits: [&mut u32; N],
|
||||
sum_limit: u32,
|
||||
) {
|
||||
limits.sort();
|
||||
|
||||
let mut rem_limit = sum_limit;
|
||||
let mut divisor = limits.len() as u32;
|
||||
for limit_to_adjust in limits {
|
||||
let limit = rem_limit / divisor;
|
||||
*limit_to_adjust = (*limit_to_adjust).min(limit);
|
||||
rem_limit -= *limit_to_adjust;
|
||||
divisor -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_cap_limits_to_be_under_the_sum_limit() {
|
||||
test([3, 3, 3], 3, [1, 1, 1]);
|
||||
test([3, 2, 1], 3, [1, 1, 1]);
|
||||
test([1, 2, 3], 6, [1, 2, 3]);
|
||||
test([1, 2, 3], 3, [1, 1, 1]);
|
||||
test([1, 8, 100], 6, [1, 2, 3]);
|
||||
test([2, 80, 80], 6, [2, 2, 2]);
|
||||
test([2, 80, 80], 12, [2, 5, 5]);
|
||||
|
||||
#[track_caller]
|
||||
fn test<const N: usize>(mut input: [u32; N], limit: u32, output: [u32; N]) {
|
||||
cap_limits_to_be_under_the_sum_limit(input.each_mut(), limit);
|
||||
assert_eq!(input, output);
|
||||
}
|
||||
}
|
||||
}
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
//! RenderDoc integration - <https://renderdoc.org/>
|
||||
#![cfg_attr(not(any(feature = "gles", feature = "vulkan")), allow(dead_code))]
|
||||
|
||||
use alloc::format;
|
||||
use alloc::string::String;
|
||||
use core::{ffi, ptr};
|
||||
|
||||
/// The dynamically loaded RenderDoc API function table
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
pub struct RenderDocApi {
|
||||
api: renderdoc_sys::RENDERDOC_API_1_4_1,
|
||||
lib: libloading::Library,
|
||||
}
|
||||
|
||||
unsafe impl Send for RenderDocApi {}
|
||||
unsafe impl Sync for RenderDocApi {}
|
||||
|
||||
/// RenderDoc API type
|
||||
#[derive(Debug)]
|
||||
pub enum RenderDoc {
|
||||
/// RenderDoc functionality is available
|
||||
Available {
|
||||
/// RenderDoc API with function pointers
|
||||
api: RenderDocApi,
|
||||
},
|
||||
/// RenderDoc functionality is _not_ available
|
||||
NotAvailable {
|
||||
/// A description why renderdoc functionality is not available
|
||||
reason: String,
|
||||
},
|
||||
}
|
||||
|
||||
// TODO: replace with libloading API once supported
|
||||
#[cfg(unix)]
|
||||
const RTLD_NOLOAD: i32 = 0x4;
|
||||
|
||||
impl RenderDoc {
|
||||
pub unsafe fn new() -> Self {
|
||||
type GetApiFn = unsafe extern "C" fn(version: u32, out: *mut *mut ffi::c_void) -> i32;
|
||||
|
||||
#[cfg(windows)]
|
||||
let renderdoc_filename = "renderdoc.dll";
|
||||
#[cfg(all(unix, not(target_os = "android")))]
|
||||
let renderdoc_filename = "librenderdoc.so";
|
||||
#[cfg(target_os = "android")]
|
||||
let renderdoc_filename = "libVkLayer_GLES_RenderDoc.so";
|
||||
|
||||
#[cfg(unix)]
|
||||
let renderdoc_result: Result<libloading::Library, libloading::Error> = unsafe {
|
||||
libloading::os::unix::Library::open(
|
||||
Some(renderdoc_filename),
|
||||
libloading::os::unix::RTLD_NOW | RTLD_NOLOAD,
|
||||
)
|
||||
}
|
||||
.map(|lib| lib.into());
|
||||
|
||||
#[cfg(windows)]
|
||||
let renderdoc_result: Result<libloading::Library, libloading::Error> =
|
||||
libloading::os::windows::Library::open_already_loaded(renderdoc_filename)
|
||||
.map(|lib| lib.into());
|
||||
|
||||
let renderdoc_lib = match renderdoc_result {
|
||||
Ok(lib) => lib,
|
||||
Err(e) => {
|
||||
return RenderDoc::NotAvailable {
|
||||
reason: format!(
|
||||
"Unable to load renderdoc library '{renderdoc_filename}': {e:?}"
|
||||
),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let get_api: libloading::Symbol<GetApiFn> =
|
||||
match unsafe { renderdoc_lib.get(c"RENDERDOC_GetAPI".to_bytes()) } {
|
||||
Ok(api) => api,
|
||||
Err(e) => {
|
||||
return RenderDoc::NotAvailable {
|
||||
reason: format!(
|
||||
"Unable to get RENDERDOC_GetAPI from renderdoc library '{renderdoc_filename}': {e:?}"
|
||||
),
|
||||
}
|
||||
}
|
||||
};
|
||||
let mut obj = ptr::null_mut();
|
||||
match unsafe { get_api(10401, &mut obj) } {
|
||||
1 => RenderDoc::Available {
|
||||
api: RenderDocApi {
|
||||
api: unsafe { *obj.cast::<renderdoc_sys::RENDERDOC_API_1_4_1>() },
|
||||
lib: renderdoc_lib,
|
||||
},
|
||||
},
|
||||
return_value => RenderDoc::NotAvailable {
|
||||
reason: format!(
|
||||
"Unable to get API from renderdoc library '{renderdoc_filename}': {return_value}"
|
||||
),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for RenderDoc {
|
||||
fn default() -> Self {
|
||||
if !cfg!(debug_assertions) {
|
||||
return RenderDoc::NotAvailable {
|
||||
reason: "RenderDoc support is only enabled with 'debug_assertions'".into(),
|
||||
};
|
||||
}
|
||||
unsafe { Self::new() }
|
||||
}
|
||||
}
|
||||
/// An implementation specific handle
|
||||
pub type Handle = *mut ffi::c_void;
|
||||
|
||||
impl RenderDoc {
|
||||
/// Start a RenderDoc frame capture
|
||||
pub unsafe fn start_frame_capture(&self, device_handle: Handle, window_handle: Handle) -> bool {
|
||||
match *self {
|
||||
Self::Available { api: ref entry } => {
|
||||
unsafe { entry.api.StartFrameCapture.unwrap()(device_handle, window_handle) };
|
||||
true
|
||||
}
|
||||
Self::NotAvailable { ref reason } => {
|
||||
log::warn!("Could not start RenderDoc frame capture: {reason}");
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// End a RenderDoc frame capture
|
||||
pub unsafe fn end_frame_capture(&self, device_handle: Handle, window_handle: Handle) {
|
||||
match *self {
|
||||
Self::Available { api: ref entry } => {
|
||||
unsafe { entry.api.EndFrameCapture.unwrap()(device_handle, window_handle) };
|
||||
}
|
||||
Self::NotAvailable { ref reason } => {
|
||||
log::warn!("Could not end RenderDoc frame capture: {reason}")
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
Vendored
+1546
File diff suppressed because it is too large.
Load diff
Vendored
+1868
File diff suppressed because it is too large.
Load diff
Vendored
+467
@@ -0,0 +1,467 @@
|
||||
use windows::Win32::Graphics::{Direct3D, Direct3D12, Dxgi};
|
||||
|
||||
pub fn map_buffer_usage_to_resource_flags(
|
||||
usage: wgt::BufferUses,
|
||||
) -> Direct3D12::D3D12_RESOURCE_FLAGS {
|
||||
let mut flags = Direct3D12::D3D12_RESOURCE_FLAG_NONE;
|
||||
if usage.contains(wgt::BufferUses::STORAGE_READ_WRITE)
|
||||
|| usage.contains(wgt::BufferUses::ACCELERATION_STRUCTURE_QUERY)
|
||||
{
|
||||
flags |= Direct3D12::D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
|
||||
}
|
||||
flags
|
||||
}
|
||||
|
||||
pub fn map_buffer_descriptor(
|
||||
desc: &crate::BufferDescriptor<'_>,
|
||||
) -> Direct3D12::D3D12_RESOURCE_DESC {
|
||||
Direct3D12::D3D12_RESOURCE_DESC {
|
||||
Dimension: Direct3D12::D3D12_RESOURCE_DIMENSION_BUFFER,
|
||||
Alignment: 0,
|
||||
Width: desc.size,
|
||||
Height: 1,
|
||||
DepthOrArraySize: 1,
|
||||
MipLevels: 1,
|
||||
Format: Dxgi::Common::DXGI_FORMAT_UNKNOWN,
|
||||
SampleDesc: Dxgi::Common::DXGI_SAMPLE_DESC {
|
||||
Count: 1,
|
||||
Quality: 0,
|
||||
},
|
||||
Layout: Direct3D12::D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
|
||||
Flags: map_buffer_usage_to_resource_flags(desc.usage),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_texture_dimension(dim: wgt::TextureDimension) -> Direct3D12::D3D12_RESOURCE_DIMENSION {
|
||||
match dim {
|
||||
wgt::TextureDimension::D1 => Direct3D12::D3D12_RESOURCE_DIMENSION_TEXTURE1D,
|
||||
wgt::TextureDimension::D2 => Direct3D12::D3D12_RESOURCE_DIMENSION_TEXTURE2D,
|
||||
wgt::TextureDimension::D3 => Direct3D12::D3D12_RESOURCE_DIMENSION_TEXTURE3D,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_texture_usage_to_resource_flags(
|
||||
usage: wgt::TextureUses,
|
||||
) -> Direct3D12::D3D12_RESOURCE_FLAGS {
|
||||
let mut flags = Direct3D12::D3D12_RESOURCE_FLAG_NONE;
|
||||
|
||||
if usage.contains(wgt::TextureUses::COLOR_TARGET) {
|
||||
flags |= Direct3D12::D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
|
||||
}
|
||||
if usage
|
||||
.intersects(wgt::TextureUses::DEPTH_STENCIL_READ | wgt::TextureUses::DEPTH_STENCIL_WRITE)
|
||||
{
|
||||
flags |= Direct3D12::D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
|
||||
if !usage.contains(wgt::TextureUses::RESOURCE) {
|
||||
flags |= Direct3D12::D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
|
||||
}
|
||||
}
|
||||
if usage.intersects(
|
||||
wgt::TextureUses::STORAGE_READ_ONLY
|
||||
| wgt::TextureUses::STORAGE_WRITE_ONLY
|
||||
| wgt::TextureUses::STORAGE_READ_WRITE,
|
||||
) {
|
||||
flags |= Direct3D12::D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
|
||||
}
|
||||
|
||||
flags
|
||||
}
|
||||
|
||||
pub fn map_address_mode(mode: wgt::AddressMode) -> Direct3D12::D3D12_TEXTURE_ADDRESS_MODE {
|
||||
use wgt::AddressMode as Am;
|
||||
match mode {
|
||||
Am::Repeat => Direct3D12::D3D12_TEXTURE_ADDRESS_MODE_WRAP,
|
||||
Am::MirrorRepeat => Direct3D12::D3D12_TEXTURE_ADDRESS_MODE_MIRROR,
|
||||
Am::ClampToEdge => Direct3D12::D3D12_TEXTURE_ADDRESS_MODE_CLAMP,
|
||||
Am::ClampToBorder => Direct3D12::D3D12_TEXTURE_ADDRESS_MODE_BORDER,
|
||||
//Am::MirrorClamp => Direct3D12::D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_filter_mode(mode: wgt::FilterMode) -> Direct3D12::D3D12_FILTER_TYPE {
|
||||
match mode {
|
||||
wgt::FilterMode::Nearest => Direct3D12::D3D12_FILTER_TYPE_POINT,
|
||||
wgt::FilterMode::Linear => Direct3D12::D3D12_FILTER_TYPE_LINEAR,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_mipmap_filter_mode(mode: wgt::MipmapFilterMode) -> Direct3D12::D3D12_FILTER_TYPE {
|
||||
match mode {
|
||||
wgt::MipmapFilterMode::Nearest => Direct3D12::D3D12_FILTER_TYPE_POINT,
|
||||
wgt::MipmapFilterMode::Linear => Direct3D12::D3D12_FILTER_TYPE_LINEAR,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_comparison(func: wgt::CompareFunction) -> Direct3D12::D3D12_COMPARISON_FUNC {
|
||||
use wgt::CompareFunction as Cf;
|
||||
match func {
|
||||
Cf::Never => Direct3D12::D3D12_COMPARISON_FUNC_NEVER,
|
||||
Cf::Less => Direct3D12::D3D12_COMPARISON_FUNC_LESS,
|
||||
Cf::LessEqual => Direct3D12::D3D12_COMPARISON_FUNC_LESS_EQUAL,
|
||||
Cf::Equal => Direct3D12::D3D12_COMPARISON_FUNC_EQUAL,
|
||||
Cf::GreaterEqual => Direct3D12::D3D12_COMPARISON_FUNC_GREATER_EQUAL,
|
||||
Cf::Greater => Direct3D12::D3D12_COMPARISON_FUNC_GREATER,
|
||||
Cf::NotEqual => Direct3D12::D3D12_COMPARISON_FUNC_NOT_EQUAL,
|
||||
Cf::Always => Direct3D12::D3D12_COMPARISON_FUNC_ALWAYS,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_border_color(border_color: Option<wgt::SamplerBorderColor>) -> [f32; 4] {
|
||||
use wgt::SamplerBorderColor as Sbc;
|
||||
match border_color {
|
||||
Some(Sbc::TransparentBlack) | Some(Sbc::Zero) | None => [0.0; 4],
|
||||
Some(Sbc::OpaqueBlack) => [0.0, 0.0, 0.0, 1.0],
|
||||
Some(Sbc::OpaqueWhite) => [1.0; 4],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_visibility(visibility: wgt::ShaderStages) -> Direct3D12::D3D12_SHADER_VISIBILITY {
|
||||
match visibility {
|
||||
wgt::ShaderStages::VERTEX => Direct3D12::D3D12_SHADER_VISIBILITY_VERTEX,
|
||||
wgt::ShaderStages::FRAGMENT => Direct3D12::D3D12_SHADER_VISIBILITY_PIXEL,
|
||||
_ => Direct3D12::D3D12_SHADER_VISIBILITY_ALL,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_binding_type(ty: &wgt::BindingType) -> Direct3D12::D3D12_DESCRIPTOR_RANGE_TYPE {
|
||||
use wgt::BindingType as Bt;
|
||||
match *ty {
|
||||
Bt::Sampler { .. } => Direct3D12::D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER,
|
||||
Bt::Buffer {
|
||||
ty: wgt::BufferBindingType::Uniform,
|
||||
..
|
||||
} => Direct3D12::D3D12_DESCRIPTOR_RANGE_TYPE_CBV,
|
||||
Bt::Buffer {
|
||||
ty: wgt::BufferBindingType::Storage { read_only: true },
|
||||
..
|
||||
}
|
||||
| Bt::Texture { .. } => Direct3D12::D3D12_DESCRIPTOR_RANGE_TYPE_SRV,
|
||||
Bt::Buffer {
|
||||
ty: wgt::BufferBindingType::Storage { read_only: false },
|
||||
..
|
||||
}
|
||||
| Bt::StorageTexture { .. } => Direct3D12::D3D12_DESCRIPTOR_RANGE_TYPE_UAV,
|
||||
Bt::AccelerationStructure { .. } => Direct3D12::D3D12_DESCRIPTOR_RANGE_TYPE_SRV,
|
||||
// External textures require multiple bindings and therefore cannot
|
||||
// be mapped to a single descriptor range type. They must be handled
|
||||
// separately by the caller.
|
||||
Bt::ExternalTexture => unreachable!("External textures must be handled separately"),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_buffer_usage_to_state(usage: wgt::BufferUses) -> Direct3D12::D3D12_RESOURCE_STATES {
|
||||
use wgt::BufferUses as Bu;
|
||||
let mut state = Direct3D12::D3D12_RESOURCE_STATE_COMMON;
|
||||
|
||||
if usage.intersects(Bu::COPY_SRC) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_COPY_SOURCE;
|
||||
}
|
||||
if usage.intersects(Bu::COPY_DST) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_COPY_DEST;
|
||||
}
|
||||
if usage.intersects(Bu::INDEX) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_INDEX_BUFFER;
|
||||
}
|
||||
if usage.intersects(Bu::VERTEX | Bu::UNIFORM) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
|
||||
}
|
||||
if usage.intersects(Bu::STORAGE_READ_WRITE) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
|
||||
} else if usage.intersects(Bu::STORAGE_READ_ONLY) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE
|
||||
| Direct3D12::D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
|
||||
}
|
||||
if usage.intersects(Bu::INDIRECT) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
|
||||
}
|
||||
if usage.intersects(Bu::ACCELERATION_STRUCTURE_QUERY) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
pub fn map_texture_usage_to_state(usage: wgt::TextureUses) -> Direct3D12::D3D12_RESOURCE_STATES {
|
||||
use wgt::TextureUses as Tu;
|
||||
let mut state = Direct3D12::D3D12_RESOURCE_STATE_COMMON;
|
||||
//Note: `RESOLVE_SOURCE` and `RESOLVE_DEST` are not used here
|
||||
//Note: `PRESENT` is the same as `COMMON`
|
||||
if usage == wgt::TextureUses::UNINITIALIZED {
|
||||
return state;
|
||||
}
|
||||
|
||||
if usage.intersects(Tu::COPY_SRC) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_COPY_SOURCE;
|
||||
}
|
||||
if usage.intersects(Tu::COPY_DST) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_COPY_DEST;
|
||||
}
|
||||
if usage.intersects(Tu::RESOURCE) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE
|
||||
| Direct3D12::D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
|
||||
}
|
||||
if usage.intersects(Tu::COLOR_TARGET) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_RENDER_TARGET;
|
||||
}
|
||||
if usage.intersects(Tu::DEPTH_STENCIL_READ) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_DEPTH_READ;
|
||||
}
|
||||
if usage.intersects(Tu::DEPTH_STENCIL_WRITE) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_DEPTH_WRITE;
|
||||
}
|
||||
if usage.intersects(Tu::STORAGE_READ_ONLY | Tu::STORAGE_WRITE_ONLY | Tu::STORAGE_READ_WRITE) {
|
||||
state |= Direct3D12::D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
|
||||
}
|
||||
state
|
||||
}
|
||||
|
||||
pub fn map_topology(
|
||||
topology: wgt::PrimitiveTopology,
|
||||
) -> (
|
||||
Direct3D12::D3D12_PRIMITIVE_TOPOLOGY_TYPE,
|
||||
Direct3D::D3D_PRIMITIVE_TOPOLOGY,
|
||||
) {
|
||||
match topology {
|
||||
wgt::PrimitiveTopology::PointList => (
|
||||
Direct3D12::D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT,
|
||||
Direct3D::D3D_PRIMITIVE_TOPOLOGY_POINTLIST,
|
||||
),
|
||||
wgt::PrimitiveTopology::LineList => (
|
||||
Direct3D12::D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
|
||||
Direct3D::D3D_PRIMITIVE_TOPOLOGY_LINELIST,
|
||||
),
|
||||
wgt::PrimitiveTopology::LineStrip => (
|
||||
Direct3D12::D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE,
|
||||
Direct3D::D3D_PRIMITIVE_TOPOLOGY_LINESTRIP,
|
||||
),
|
||||
wgt::PrimitiveTopology::TriangleList => (
|
||||
Direct3D12::D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
|
||||
Direct3D::D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
|
||||
),
|
||||
wgt::PrimitiveTopology::TriangleStrip => (
|
||||
Direct3D12::D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
|
||||
Direct3D::D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_polygon_mode(mode: wgt::PolygonMode) -> Direct3D12::D3D12_FILL_MODE {
|
||||
match mode {
|
||||
wgt::PolygonMode::Fill => Direct3D12::D3D12_FILL_MODE_SOLID,
|
||||
wgt::PolygonMode::Line => Direct3D12::D3D12_FILL_MODE_WIREFRAME,
|
||||
wgt::PolygonMode::Point => panic!(
|
||||
"{:?} is not enabled for this backend",
|
||||
wgt::Features::POLYGON_MODE_POINT
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
/// D3D12 doesn't support passing factors ending in `_COLOR` for alpha blending
|
||||
/// (see <https://learn.microsoft.com/en-us/windows/win32/api/d3d12/ns-d3d12-d3d12_render_target_blend_desc>).
|
||||
/// Therefore this function takes an additional `is_alpha` argument
|
||||
/// which if set will return an equivalent `_ALPHA` factor.
|
||||
fn map_blend_factor(factor: wgt::BlendFactor, is_alpha: bool) -> Direct3D12::D3D12_BLEND {
|
||||
use wgt::BlendFactor as Bf;
|
||||
match factor {
|
||||
Bf::Zero => Direct3D12::D3D12_BLEND_ZERO,
|
||||
Bf::One => Direct3D12::D3D12_BLEND_ONE,
|
||||
Bf::Src if is_alpha => Direct3D12::D3D12_BLEND_SRC_ALPHA,
|
||||
Bf::Src => Direct3D12::D3D12_BLEND_SRC_COLOR,
|
||||
Bf::OneMinusSrc if is_alpha => Direct3D12::D3D12_BLEND_INV_SRC_ALPHA,
|
||||
Bf::OneMinusSrc => Direct3D12::D3D12_BLEND_INV_SRC_COLOR,
|
||||
Bf::Dst if is_alpha => Direct3D12::D3D12_BLEND_DEST_ALPHA,
|
||||
Bf::Dst => Direct3D12::D3D12_BLEND_DEST_COLOR,
|
||||
Bf::OneMinusDst if is_alpha => Direct3D12::D3D12_BLEND_INV_DEST_ALPHA,
|
||||
Bf::OneMinusDst => Direct3D12::D3D12_BLEND_INV_DEST_COLOR,
|
||||
Bf::SrcAlpha => Direct3D12::D3D12_BLEND_SRC_ALPHA,
|
||||
Bf::OneMinusSrcAlpha => Direct3D12::D3D12_BLEND_INV_SRC_ALPHA,
|
||||
Bf::DstAlpha => Direct3D12::D3D12_BLEND_DEST_ALPHA,
|
||||
Bf::OneMinusDstAlpha => Direct3D12::D3D12_BLEND_INV_DEST_ALPHA,
|
||||
Bf::Constant => Direct3D12::D3D12_BLEND_BLEND_FACTOR,
|
||||
Bf::OneMinusConstant => Direct3D12::D3D12_BLEND_INV_BLEND_FACTOR,
|
||||
Bf::SrcAlphaSaturated => Direct3D12::D3D12_BLEND_SRC_ALPHA_SAT,
|
||||
Bf::Src1 if is_alpha => Direct3D12::D3D12_BLEND_SRC1_ALPHA,
|
||||
Bf::Src1 => Direct3D12::D3D12_BLEND_SRC1_COLOR,
|
||||
Bf::OneMinusSrc1 if is_alpha => Direct3D12::D3D12_BLEND_INV_SRC1_ALPHA,
|
||||
Bf::OneMinusSrc1 => Direct3D12::D3D12_BLEND_INV_SRC1_COLOR,
|
||||
Bf::Src1Alpha => Direct3D12::D3D12_BLEND_SRC1_ALPHA,
|
||||
Bf::OneMinusSrc1Alpha => Direct3D12::D3D12_BLEND_INV_SRC1_ALPHA,
|
||||
}
|
||||
}
|
||||
|
||||
fn map_blend_component(
|
||||
component: &wgt::BlendComponent,
|
||||
is_alpha: bool,
|
||||
) -> (
|
||||
Direct3D12::D3D12_BLEND_OP,
|
||||
Direct3D12::D3D12_BLEND,
|
||||
Direct3D12::D3D12_BLEND,
|
||||
) {
|
||||
let raw_op = match component.operation {
|
||||
wgt::BlendOperation::Add => Direct3D12::D3D12_BLEND_OP_ADD,
|
||||
wgt::BlendOperation::Subtract => Direct3D12::D3D12_BLEND_OP_SUBTRACT,
|
||||
wgt::BlendOperation::ReverseSubtract => Direct3D12::D3D12_BLEND_OP_REV_SUBTRACT,
|
||||
wgt::BlendOperation::Min => Direct3D12::D3D12_BLEND_OP_MIN,
|
||||
wgt::BlendOperation::Max => Direct3D12::D3D12_BLEND_OP_MAX,
|
||||
};
|
||||
let raw_src = map_blend_factor(component.src_factor, is_alpha);
|
||||
let raw_dst = map_blend_factor(component.dst_factor, is_alpha);
|
||||
(raw_op, raw_src, raw_dst)
|
||||
}
|
||||
|
||||
pub fn map_render_targets(
|
||||
color_targets: &[Option<wgt::ColorTargetState>],
|
||||
) -> [Direct3D12::D3D12_RENDER_TARGET_BLEND_DESC;
|
||||
Direct3D12::D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT as usize] {
|
||||
let dummy_target = Direct3D12::D3D12_RENDER_TARGET_BLEND_DESC {
|
||||
BlendEnable: false.into(),
|
||||
LogicOpEnable: false.into(),
|
||||
SrcBlend: Direct3D12::D3D12_BLEND_ZERO,
|
||||
DestBlend: Direct3D12::D3D12_BLEND_ZERO,
|
||||
BlendOp: Direct3D12::D3D12_BLEND_OP_ADD,
|
||||
SrcBlendAlpha: Direct3D12::D3D12_BLEND_ZERO,
|
||||
DestBlendAlpha: Direct3D12::D3D12_BLEND_ZERO,
|
||||
BlendOpAlpha: Direct3D12::D3D12_BLEND_OP_ADD,
|
||||
LogicOp: Direct3D12::D3D12_LOGIC_OP_CLEAR,
|
||||
RenderTargetWriteMask: 0,
|
||||
};
|
||||
let mut raw_targets =
|
||||
[dummy_target; Direct3D12::D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT as usize];
|
||||
|
||||
for (raw, ct) in raw_targets.iter_mut().zip(color_targets.iter()) {
|
||||
if let Some(ct) = ct.as_ref() {
|
||||
raw.RenderTargetWriteMask = ct.write_mask.bits() as u8;
|
||||
if let Some(ref blend) = ct.blend {
|
||||
let (color_op, color_src, color_dst) = map_blend_component(&blend.color, false);
|
||||
let (alpha_op, alpha_src, alpha_dst) = map_blend_component(&blend.alpha, true);
|
||||
raw.BlendEnable = true.into();
|
||||
raw.BlendOp = color_op;
|
||||
raw.SrcBlend = color_src;
|
||||
raw.DestBlend = color_dst;
|
||||
raw.BlendOpAlpha = alpha_op;
|
||||
raw.SrcBlendAlpha = alpha_src;
|
||||
raw.DestBlendAlpha = alpha_dst;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
raw_targets
|
||||
}
|
||||
|
||||
fn map_stencil_op(op: wgt::StencilOperation) -> Direct3D12::D3D12_STENCIL_OP {
|
||||
use wgt::StencilOperation as So;
|
||||
match op {
|
||||
So::Keep => Direct3D12::D3D12_STENCIL_OP_KEEP,
|
||||
So::Zero => Direct3D12::D3D12_STENCIL_OP_ZERO,
|
||||
So::Replace => Direct3D12::D3D12_STENCIL_OP_REPLACE,
|
||||
So::IncrementClamp => Direct3D12::D3D12_STENCIL_OP_INCR_SAT,
|
||||
So::IncrementWrap => Direct3D12::D3D12_STENCIL_OP_INCR,
|
||||
So::DecrementClamp => Direct3D12::D3D12_STENCIL_OP_DECR_SAT,
|
||||
So::DecrementWrap => Direct3D12::D3D12_STENCIL_OP_DECR,
|
||||
So::Invert => Direct3D12::D3D12_STENCIL_OP_INVERT,
|
||||
}
|
||||
}
|
||||
|
||||
fn map_stencil_face(face: &wgt::StencilFaceState) -> Direct3D12::D3D12_DEPTH_STENCILOP_DESC {
|
||||
Direct3D12::D3D12_DEPTH_STENCILOP_DESC {
|
||||
StencilFailOp: map_stencil_op(face.fail_op),
|
||||
StencilDepthFailOp: map_stencil_op(face.depth_fail_op),
|
||||
StencilPassOp: map_stencil_op(face.pass_op),
|
||||
StencilFunc: map_comparison(face.compare),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_depth_stencil(ds: &wgt::DepthStencilState) -> Direct3D12::D3D12_DEPTH_STENCIL_DESC {
|
||||
Direct3D12::D3D12_DEPTH_STENCIL_DESC {
|
||||
DepthEnable: ds.is_depth_enabled().into(),
|
||||
DepthWriteMask: if ds.depth_write_enabled.unwrap_or_default() {
|
||||
Direct3D12::D3D12_DEPTH_WRITE_MASK_ALL
|
||||
} else {
|
||||
Direct3D12::D3D12_DEPTH_WRITE_MASK_ZERO
|
||||
},
|
||||
DepthFunc: map_comparison(ds.depth_compare.unwrap_or_default()),
|
||||
StencilEnable: ds.stencil.is_enabled().into(),
|
||||
StencilReadMask: ds.stencil.read_mask as u8,
|
||||
StencilWriteMask: ds.stencil.write_mask as u8,
|
||||
FrontFace: map_stencil_face(&ds.stencil.front),
|
||||
BackFace: map_stencil_face(&ds.stencil.back),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn map_acceleration_structure_build_flags(
|
||||
flags: wgt::AccelerationStructureFlags,
|
||||
mode: Option<crate::AccelerationStructureBuildMode>,
|
||||
) -> Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS {
|
||||
let mut d3d_flags = Default::default();
|
||||
if flags.contains(wgt::AccelerationStructureFlags::ALLOW_COMPACTION) {
|
||||
d3d_flags |=
|
||||
Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION;
|
||||
}
|
||||
|
||||
if flags.contains(wgt::AccelerationStructureFlags::ALLOW_UPDATE) {
|
||||
d3d_flags |= Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE;
|
||||
}
|
||||
|
||||
if flags.contains(wgt::AccelerationStructureFlags::LOW_MEMORY) {
|
||||
d3d_flags |= Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY;
|
||||
}
|
||||
|
||||
if flags.contains(wgt::AccelerationStructureFlags::PREFER_FAST_BUILD) {
|
||||
d3d_flags |=
|
||||
Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD;
|
||||
}
|
||||
|
||||
if flags.contains(wgt::AccelerationStructureFlags::PREFER_FAST_TRACE) {
|
||||
d3d_flags |=
|
||||
Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE;
|
||||
}
|
||||
|
||||
if let Some(crate::AccelerationStructureBuildMode::Update) = mode {
|
||||
d3d_flags |= Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE
|
||||
}
|
||||
|
||||
d3d_flags
|
||||
}
|
||||
|
||||
pub(crate) fn map_acceleration_structure_geometry_flags(
|
||||
flags: wgt::AccelerationStructureGeometryFlags,
|
||||
) -> Direct3D12::D3D12_RAYTRACING_GEOMETRY_FLAGS {
|
||||
let mut d3d_flags = Default::default();
|
||||
if flags.contains(wgt::AccelerationStructureGeometryFlags::OPAQUE) {
|
||||
d3d_flags |= Direct3D12::D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE;
|
||||
}
|
||||
if flags.contains(wgt::AccelerationStructureGeometryFlags::NO_DUPLICATE_ANY_HIT_INVOCATION) {
|
||||
d3d_flags |= Direct3D12::D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION;
|
||||
}
|
||||
d3d_flags
|
||||
}
|
||||
|
||||
pub(crate) fn map_acceleration_structure_copy_mode(
|
||||
mode: wgt::AccelerationStructureCopy,
|
||||
) -> Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE {
|
||||
match mode {
|
||||
wgt::AccelerationStructureCopy::Clone => {
|
||||
Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE
|
||||
}
|
||||
wgt::AccelerationStructureCopy::Compact => {
|
||||
Direct3D12::D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) const fn make_shader_component_mapping(
|
||||
src0: Direct3D12::D3D12_SHADER_COMPONENT_MAPPING,
|
||||
src1: Direct3D12::D3D12_SHADER_COMPONENT_MAPPING,
|
||||
src2: Direct3D12::D3D12_SHADER_COMPONENT_MAPPING,
|
||||
src3: Direct3D12::D3D12_SHADER_COMPONENT_MAPPING,
|
||||
) -> Direct3D12::D3D12_SHADER_COMPONENT_MAPPING {
|
||||
const M: i32 = Direct3D12::D3D12_SHADER_COMPONENT_MAPPING_MASK as i32;
|
||||
const S: i32 = Direct3D12::D3D12_SHADER_COMPONENT_MAPPING_SHIFT as i32;
|
||||
Direct3D12::D3D12_SHADER_COMPONENT_MAPPING(
|
||||
(src0.0 & M)
|
||||
| (src1.0 & M) << S
|
||||
| (src2.0 & M) << (S * 2)
|
||||
| (src3.0 & M) << (S * 3)
|
||||
| Direct3D12::D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES
|
||||
as i32,
|
||||
)
|
||||
}
|
||||
Vendored
+120
@@ -0,0 +1,120 @@
|
||||
use alloc::sync::Arc;
|
||||
use core::{ffi, ptr};
|
||||
|
||||
use once_cell::sync::Lazy;
|
||||
use windows::{
|
||||
core::Interface as _,
|
||||
Win32::{Foundation::HWND, Graphics::DirectComposition},
|
||||
};
|
||||
|
||||
use super::DynLib;
|
||||
|
||||
// Lazy-loaded DirectComposition library
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct DCompLib {
|
||||
lib: Lazy<Result<DynLib, crate::SurfaceError>>,
|
||||
}
|
||||
|
||||
impl DCompLib {
|
||||
pub(crate) fn new() -> Self {
|
||||
Self {
|
||||
lib: Lazy::new(|| unsafe {
|
||||
DynLib::new("dcomp.dll").map_err(|err| {
|
||||
log::error!("Error loading dcomp.dll: {err}");
|
||||
crate::SurfaceError::Other("Error loading dcomp.dll")
|
||||
})
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
fn get_lib(&self) -> Result<&DynLib, crate::SurfaceError> {
|
||||
match self.lib.as_ref() {
|
||||
Ok(lib) => Ok(lib),
|
||||
Err(err) => Err(err.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn create_device(
|
||||
&self,
|
||||
) -> Result<DirectComposition::IDCompositionDevice, crate::SurfaceError> {
|
||||
let lib = self.get_lib()?;
|
||||
|
||||
// Calls windows::Win32::Graphics::DirectComposition::DCompositionCreateDevice2 on dcomp.dll
|
||||
type Fun = extern "system" fn(
|
||||
pdxdevice: *mut ffi::c_void,
|
||||
riid: *const windows_core::GUID,
|
||||
ppdcompdevice: *mut *mut ffi::c_void,
|
||||
) -> windows_core::HRESULT;
|
||||
let func: libloading::Symbol<Fun> =
|
||||
unsafe { lib.get(c"DCompositionCreateDevice2".to_bytes()) }?;
|
||||
|
||||
let mut res: Option<DirectComposition::IDCompositionDevice> = None;
|
||||
|
||||
(func)(
|
||||
ptr::null_mut(),
|
||||
&DirectComposition::IDCompositionDevice::IID,
|
||||
<*mut _>::cast(&mut res),
|
||||
)
|
||||
.map(|| res.unwrap())
|
||||
.map_err(|err| {
|
||||
log::error!("DirectComposition::DCompositionCreateDevice2 failed: {err}");
|
||||
crate::SurfaceError::Other("DirectComposition::DCompositionCreateDevice2")
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct DCompState {
|
||||
inner: Option<InnerState>,
|
||||
}
|
||||
|
||||
impl DCompState {
|
||||
/// This will create a DirectComposition device and a target for the window handle if not already initialized.
|
||||
/// If the device is already initialized, it will return the existing state.
|
||||
pub unsafe fn get_or_init(
|
||||
&mut self,
|
||||
lib: &Arc<DCompLib>,
|
||||
hwnd: &HWND,
|
||||
) -> Result<&mut InnerState, crate::SurfaceError> {
|
||||
if self.inner.is_none() {
|
||||
self.inner = Some(unsafe { InnerState::init(lib, hwnd) }?);
|
||||
}
|
||||
Ok(self.inner.as_mut().unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct InnerState {
|
||||
pub visual: DirectComposition::IDCompositionVisual,
|
||||
pub device: DirectComposition::IDCompositionDevice,
|
||||
// Must be kept alive but is otherwise unused after initialization.
|
||||
pub _target: DirectComposition::IDCompositionTarget,
|
||||
}
|
||||
|
||||
impl InnerState {
|
||||
/// Creates a DirectComposition device and a target for the given window handle.
|
||||
pub unsafe fn init(lib: &Arc<DCompLib>, hwnd: &HWND) -> Result<Self, crate::SurfaceError> {
|
||||
profiling::scope!("DCompState::init");
|
||||
let dcomp_device = lib.create_device()?;
|
||||
|
||||
let target = unsafe { dcomp_device.CreateTargetForHwnd(*hwnd, false) }.map_err(|err| {
|
||||
log::error!("IDCompositionDevice::CreateTargetForHwnd failed: {err}");
|
||||
crate::SurfaceError::Other("IDCompositionDevice::CreateTargetForHwnd")
|
||||
})?;
|
||||
|
||||
let visual = unsafe { dcomp_device.CreateVisual() }.map_err(|err| {
|
||||
log::error!("IDCompositionDevice::CreateVisual failed: {err}");
|
||||
crate::SurfaceError::Other("IDCompositionDevice::CreateVisual")
|
||||
})?;
|
||||
|
||||
unsafe { target.SetRoot(&visual) }.map_err(|err| {
|
||||
log::error!("IDCompositionTarget::SetRoot failed: {err}");
|
||||
crate::SurfaceError::Other("IDCompositionTarget::SetRoot")
|
||||
})?;
|
||||
|
||||
Ok(InnerState {
|
||||
visual,
|
||||
device: dcomp_device,
|
||||
_target: target,
|
||||
})
|
||||
}
|
||||
}
|
||||
+329
@@ -0,0 +1,329 @@
|
||||
use alloc::vec::Vec;
|
||||
use core::fmt;
|
||||
|
||||
use bit_set::BitSet;
|
||||
use parking_lot::Mutex;
|
||||
use range_alloc::RangeAllocator;
|
||||
use windows::Win32::Graphics::Direct3D12;
|
||||
|
||||
use crate::auxil::dxgi::result::HResult as _;
|
||||
|
||||
const HEAP_SIZE_FIXED: usize = 64;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub(super) struct DualHandle {
|
||||
cpu: Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE,
|
||||
pub gpu: Direct3D12::D3D12_GPU_DESCRIPTOR_HANDLE,
|
||||
/// How large the block allocated to this handle is.
|
||||
count: u64,
|
||||
}
|
||||
|
||||
impl fmt::Debug for DualHandle {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("DualHandle")
|
||||
.field("cpu", &self.cpu.ptr)
|
||||
.field("gpu", &self.gpu.ptr)
|
||||
.field("count", &self.count)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
type DescriptorIndex = u64;
|
||||
|
||||
pub(super) struct GeneralHeap {
|
||||
pub raw: Direct3D12::ID3D12DescriptorHeap,
|
||||
ty: Direct3D12::D3D12_DESCRIPTOR_HEAP_TYPE,
|
||||
handle_size: u64,
|
||||
total_handles: u64,
|
||||
start: DualHandle,
|
||||
ranges: Mutex<RangeAllocator<DescriptorIndex>>,
|
||||
}
|
||||
|
||||
impl GeneralHeap {
|
||||
pub(super) fn new(
|
||||
device: &Direct3D12::ID3D12Device,
|
||||
ty: Direct3D12::D3D12_DESCRIPTOR_HEAP_TYPE,
|
||||
total_handles: u64,
|
||||
) -> Result<Self, crate::DeviceError> {
|
||||
let raw = {
|
||||
profiling::scope!("ID3D12Device::CreateDescriptorHeap");
|
||||
let desc = Direct3D12::D3D12_DESCRIPTOR_HEAP_DESC {
|
||||
Type: ty,
|
||||
NumDescriptors: total_handles as u32,
|
||||
Flags: Direct3D12::D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
|
||||
NodeMask: 0,
|
||||
};
|
||||
unsafe { device.CreateDescriptorHeap::<Direct3D12::ID3D12DescriptorHeap>(&desc) }
|
||||
.into_device_result("Descriptor heap creation")?
|
||||
};
|
||||
|
||||
let start = DualHandle {
|
||||
cpu: unsafe { raw.GetCPUDescriptorHandleForHeapStart() },
|
||||
gpu: unsafe { raw.GetGPUDescriptorHandleForHeapStart() },
|
||||
count: 0,
|
||||
};
|
||||
|
||||
Ok(Self {
|
||||
raw,
|
||||
ty,
|
||||
handle_size: unsafe { device.GetDescriptorHandleIncrementSize(ty) } as u64,
|
||||
total_handles,
|
||||
start,
|
||||
ranges: Mutex::new(RangeAllocator::new(0..total_handles)),
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn at(&self, index: DescriptorIndex, count: u64) -> DualHandle {
|
||||
assert!(index < self.total_handles);
|
||||
DualHandle {
|
||||
cpu: self.cpu_descriptor_at(index),
|
||||
gpu: self.gpu_descriptor_at(index),
|
||||
count,
|
||||
}
|
||||
}
|
||||
|
||||
fn cpu_descriptor_at(&self, index: u64) -> Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE {
|
||||
Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE {
|
||||
ptr: self.start.cpu.ptr + (self.handle_size * index) as usize,
|
||||
}
|
||||
}
|
||||
|
||||
fn gpu_descriptor_at(&self, index: u64) -> Direct3D12::D3D12_GPU_DESCRIPTOR_HANDLE {
|
||||
Direct3D12::D3D12_GPU_DESCRIPTOR_HANDLE {
|
||||
ptr: self.start.gpu.ptr + self.handle_size * index,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn allocate_slice(&self, count: u64) -> Result<DescriptorIndex, crate::DeviceError> {
|
||||
let range = self.ranges.lock().allocate_range(count).map_err(|err| {
|
||||
log::error!("Unable to allocate descriptors: {err:?}");
|
||||
crate::DeviceError::OutOfMemory
|
||||
})?;
|
||||
Ok(range.start)
|
||||
}
|
||||
|
||||
/// Free handles previously given out by this `DescriptorHeapSlice`.
|
||||
/// Do not use this with handles not given out by this `DescriptorHeapSlice`.
|
||||
pub(crate) fn free_slice(&self, handle: DualHandle) {
|
||||
let start = (handle.gpu.ptr - self.start.gpu.ptr) / self.handle_size;
|
||||
self.ranges.lock().free_range(start..start + handle.count);
|
||||
}
|
||||
}
|
||||
|
||||
/// Fixed-size free-list allocator for CPU descriptors.
|
||||
struct FixedSizeHeap {
|
||||
_raw: Direct3D12::ID3D12DescriptorHeap,
|
||||
/// Bit flag representation of available handles in the heap.
|
||||
///
|
||||
/// 0 - Occupied
|
||||
/// 1 - free
|
||||
availability: u64,
|
||||
handle_size: usize,
|
||||
start: Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE,
|
||||
}
|
||||
|
||||
impl FixedSizeHeap {
|
||||
fn new(
|
||||
device: &Direct3D12::ID3D12Device,
|
||||
ty: Direct3D12::D3D12_DESCRIPTOR_HEAP_TYPE,
|
||||
) -> Result<Self, crate::DeviceError> {
|
||||
let desc = Direct3D12::D3D12_DESCRIPTOR_HEAP_DESC {
|
||||
Type: ty,
|
||||
NumDescriptors: HEAP_SIZE_FIXED as u32,
|
||||
Flags: Direct3D12::D3D12_DESCRIPTOR_HEAP_FLAG_NONE,
|
||||
NodeMask: 0,
|
||||
};
|
||||
let heap =
|
||||
unsafe { device.CreateDescriptorHeap::<Direct3D12::ID3D12DescriptorHeap>(&desc) }
|
||||
.into_device_result("Descriptor heap creation")?;
|
||||
|
||||
Ok(Self {
|
||||
handle_size: unsafe { device.GetDescriptorHandleIncrementSize(ty) } as usize,
|
||||
availability: !0, // all free!
|
||||
start: unsafe { heap.GetCPUDescriptorHandleForHeapStart() },
|
||||
_raw: heap,
|
||||
})
|
||||
}
|
||||
|
||||
fn alloc_handle(
|
||||
&mut self,
|
||||
) -> Result<Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE, crate::DeviceError> {
|
||||
// Find first free slot.
|
||||
let slot = self.availability.trailing_zeros() as usize;
|
||||
if slot >= HEAP_SIZE_FIXED {
|
||||
log::error!("Failed to allocate a handle form a fixed size heap");
|
||||
return Err(crate::DeviceError::OutOfMemory);
|
||||
}
|
||||
// Set the slot as occupied.
|
||||
self.availability ^= 1 << slot;
|
||||
|
||||
Ok(Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE {
|
||||
ptr: self.start.ptr + self.handle_size * slot,
|
||||
})
|
||||
}
|
||||
|
||||
fn free_handle(&mut self, handle: Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE) {
|
||||
let slot = (handle.ptr - self.start.ptr) / self.handle_size;
|
||||
assert!(slot < HEAP_SIZE_FIXED);
|
||||
assert_eq!(self.availability & (1 << slot), 0);
|
||||
self.availability ^= 1 << slot;
|
||||
}
|
||||
|
||||
fn is_full(&self) -> bool {
|
||||
self.availability == 0
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub(super) struct Handle {
|
||||
pub raw: Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE,
|
||||
heap_index: usize,
|
||||
}
|
||||
|
||||
impl fmt::Debug for Handle {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
fmt.debug_struct("Handle")
|
||||
.field("ptr", &self.raw.ptr)
|
||||
.field("heap_index", &self.heap_index)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct CpuPool {
|
||||
device: Direct3D12::ID3D12Device,
|
||||
ty: Direct3D12::D3D12_DESCRIPTOR_HEAP_TYPE,
|
||||
heaps: Vec<FixedSizeHeap>,
|
||||
available_heap_indices: BitSet,
|
||||
}
|
||||
|
||||
impl CpuPool {
|
||||
pub(super) fn new(
|
||||
device: Direct3D12::ID3D12Device,
|
||||
ty: Direct3D12::D3D12_DESCRIPTOR_HEAP_TYPE,
|
||||
) -> Self {
|
||||
Self {
|
||||
device,
|
||||
ty,
|
||||
heaps: Vec::new(),
|
||||
available_heap_indices: BitSet::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn alloc_handle(&mut self) -> Result<Handle, crate::DeviceError> {
|
||||
let heap_index = self
|
||||
.available_heap_indices
|
||||
.iter()
|
||||
.next()
|
||||
.unwrap_or(self.heaps.len());
|
||||
|
||||
// Allocate a new heap
|
||||
if heap_index == self.heaps.len() {
|
||||
self.heaps.push(FixedSizeHeap::new(&self.device, self.ty)?);
|
||||
self.available_heap_indices.insert(heap_index);
|
||||
}
|
||||
|
||||
let heap = &mut self.heaps[heap_index];
|
||||
let handle = Handle {
|
||||
raw: heap.alloc_handle()?,
|
||||
heap_index,
|
||||
};
|
||||
if heap.is_full() {
|
||||
self.available_heap_indices.remove(heap_index);
|
||||
}
|
||||
|
||||
Ok(handle)
|
||||
}
|
||||
|
||||
pub(super) fn free_handle(&mut self, handle: Handle) {
|
||||
self.heaps[handle.heap_index].free_handle(handle.raw);
|
||||
self.available_heap_indices.insert(handle.heap_index);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct CpuHeapInner {
|
||||
pub _raw: Direct3D12::ID3D12DescriptorHeap,
|
||||
pub stage: Vec<Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE>,
|
||||
}
|
||||
|
||||
pub(super) struct CpuHeap {
|
||||
pub inner: Mutex<CpuHeapInner>,
|
||||
start: Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE,
|
||||
handle_size: u32,
|
||||
total: u32,
|
||||
}
|
||||
|
||||
unsafe impl Send for CpuHeap {}
|
||||
unsafe impl Sync for CpuHeap {}
|
||||
|
||||
impl CpuHeap {
|
||||
pub(super) fn new(
|
||||
device: &Direct3D12::ID3D12Device,
|
||||
ty: Direct3D12::D3D12_DESCRIPTOR_HEAP_TYPE,
|
||||
total: u32,
|
||||
) -> Result<Self, crate::DeviceError> {
|
||||
let handle_size = unsafe { device.GetDescriptorHandleIncrementSize(ty) };
|
||||
let desc = Direct3D12::D3D12_DESCRIPTOR_HEAP_DESC {
|
||||
Type: ty,
|
||||
NumDescriptors: total,
|
||||
Flags: Direct3D12::D3D12_DESCRIPTOR_HEAP_FLAG_NONE,
|
||||
NodeMask: 0,
|
||||
};
|
||||
let raw = unsafe { device.CreateDescriptorHeap::<Direct3D12::ID3D12DescriptorHeap>(&desc) }
|
||||
.into_device_result("CPU descriptor heap creation")?;
|
||||
|
||||
let start = unsafe { raw.GetCPUDescriptorHandleForHeapStart() };
|
||||
|
||||
Ok(Self {
|
||||
inner: Mutex::new(CpuHeapInner {
|
||||
_raw: raw,
|
||||
stage: Vec::new(),
|
||||
}),
|
||||
start,
|
||||
handle_size,
|
||||
total,
|
||||
})
|
||||
}
|
||||
|
||||
pub(super) fn at(&self, index: u32) -> Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE {
|
||||
debug_assert!(
|
||||
index < self.total,
|
||||
"Index ({index}) out of bounds {total}",
|
||||
total = self.total
|
||||
);
|
||||
Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE {
|
||||
ptr: self.start.ptr + (self.handle_size * index) as usize,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for CpuHeap {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("CpuHeap")
|
||||
.field("start", &self.start.ptr)
|
||||
.field("handle_size", &self.handle_size)
|
||||
.field("total", &self.total)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) unsafe fn upload(
|
||||
device: &Direct3D12::ID3D12Device,
|
||||
src: &CpuHeapInner,
|
||||
dst: &GeneralHeap,
|
||||
dummy_copy_counts: &[u32],
|
||||
) -> Result<DualHandle, crate::DeviceError> {
|
||||
let count = src.stage.len() as u32;
|
||||
let index = dst.allocate_slice(count as u64)?;
|
||||
unsafe {
|
||||
device.CopyDescriptors(
|
||||
1,
|
||||
&dst.cpu_descriptor_at(index),
|
||||
Some(&count),
|
||||
count,
|
||||
src.stage.as_ptr(),
|
||||
Some(dummy_copy_counts.as_ptr()),
|
||||
dst.ty,
|
||||
)
|
||||
};
|
||||
Ok(dst.at(index, count as u64))
|
||||
}
|
||||
Vendored
+2691
File diff suppressed because it is too large.
Load diff
+176
@@ -0,0 +1,176 @@
|
||||
use alloc::sync::Arc;
|
||||
use core::ops::Deref;
|
||||
|
||||
use windows::core::Interface as _;
|
||||
use windows::Win32::Graphics::{Direct3D, Direct3D12};
|
||||
|
||||
use super::D3D12Lib;
|
||||
use crate::auxil::dxgi::factory::DxgiAdapter;
|
||||
|
||||
/// Abstraction over D3D12 device creation.
|
||||
///
|
||||
/// Supports two paths:
|
||||
/// - **Independent**: Uses `ID3D12DeviceFactory` from the Agility SDK's Independent Devices API.
|
||||
/// - **Legacy**: Uses the traditional `D3D12CreateDevice` export.
|
||||
pub(super) enum DeviceFactory {
|
||||
/// Uses `ID3D12DeviceFactory` from the Independent Devices API.
|
||||
Independent(Direct3D12::ID3D12DeviceFactory),
|
||||
/// Uses the traditional `D3D12CreateDevice` export.
|
||||
Legacy,
|
||||
}
|
||||
|
||||
impl DeviceFactory {
|
||||
/// Create a new `DeviceFactory`.
|
||||
///
|
||||
/// If `agility_sdk` is `Some`, attempts to set up the Independent Devices API path.
|
||||
/// On failure, the behavior depends on
|
||||
/// [`on_load_failure`](wgt::Dx12AgilitySDKLoadFailure):
|
||||
/// - [`Fallback`](wgt::Dx12AgilitySDKLoadFailure::Fallback): logs a warning and
|
||||
/// returns `Ok(Legacy)`.
|
||||
/// - [`Error`](wgt::Dx12AgilitySDKLoadFailure::Error): returns an `Err`.
|
||||
pub(super) fn new(
|
||||
lib: &D3D12Lib,
|
||||
agility_sdk: Option<&wgt::Dx12AgilitySDK>,
|
||||
) -> Result<Self, crate::InstanceError> {
|
||||
let Some(agility_sdk) = agility_sdk else {
|
||||
log::debug!("No D3D12 Agility SDK configuration provided; using system D3D12 runtime");
|
||||
return Ok(Self::Legacy);
|
||||
};
|
||||
|
||||
match Self::try_create_independent(lib, agility_sdk) {
|
||||
Ok(factory) => {
|
||||
log::debug!(
|
||||
"Using D3D12 Agility SDK v{} from '{}'",
|
||||
agility_sdk.sdk_version,
|
||||
agility_sdk.sdk_path
|
||||
);
|
||||
Ok(Self::Independent(factory))
|
||||
}
|
||||
Err(err) => {
|
||||
let message = format!(
|
||||
"Failed to initialize D3D12 Agility SDK (v{} at '{}'): {err}",
|
||||
agility_sdk.sdk_version, agility_sdk.sdk_path
|
||||
);
|
||||
|
||||
match agility_sdk.on_load_failure {
|
||||
wgt::Dx12AgilitySDKLoadFailure::Fallback => {
|
||||
log::warn!("{message}; falling back to system D3D12 runtime");
|
||||
Ok(Self::Legacy)
|
||||
}
|
||||
wgt::Dx12AgilitySDKLoadFailure::Error => {
|
||||
Err(crate::InstanceError::new(message))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn try_create_independent(
|
||||
lib: &D3D12Lib,
|
||||
agility_sdk: &wgt::Dx12AgilitySDK,
|
||||
) -> Result<Direct3D12::ID3D12DeviceFactory, DeviceFactoryError> {
|
||||
// Step 1: Get ID3D12SDKConfiguration1 via D3D12GetInterface
|
||||
let sdk_config: Direct3D12::ID3D12SDKConfiguration1 = lib
|
||||
.get_interface(&Direct3D12::CLSID_D3D12SDKConfiguration)
|
||||
.map_err(DeviceFactoryError::GetInterface)?;
|
||||
|
||||
// Step 2: Create device factory with the specified SDK version and path
|
||||
let sdk_path = std::ffi::CString::new(agility_sdk.sdk_path.as_bytes())
|
||||
.map_err(|_| DeviceFactoryError::InvalidPath)?;
|
||||
let factory: Direct3D12::ID3D12DeviceFactory = unsafe {
|
||||
sdk_config.CreateDeviceFactory(
|
||||
agility_sdk.sdk_version,
|
||||
windows::core::PCSTR(sdk_path.as_ptr().cast::<u8>()),
|
||||
)
|
||||
}
|
||||
.map_err(DeviceFactoryError::CreateDeviceFactory)?;
|
||||
|
||||
Ok(factory)
|
||||
}
|
||||
|
||||
/// Enable the D3D12 debug layer and optionally GPU-based validation.
|
||||
///
|
||||
/// - **Legacy**: configures debug globally via `D3D12GetDebugInterface`.
|
||||
/// - **Independent**: uses `GetConfigurationInterface` to get an
|
||||
/// `ID3D12Debug` scoped to the factory.
|
||||
pub(super) fn enable_debug_layer(&self, lib: &D3D12Lib, flags: wgt::InstanceFlags) {
|
||||
if !flags
|
||||
.intersects(wgt::InstanceFlags::VALIDATION | wgt::InstanceFlags::GPU_BASED_VALIDATION)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
let debug_controller = match self {
|
||||
Self::Independent(factory) => {
|
||||
match unsafe {
|
||||
factory.GetConfigurationInterface::<Direct3D12::ID3D12Debug>(
|
||||
&Direct3D12::CLSID_D3D12Debug,
|
||||
)
|
||||
} {
|
||||
Ok(debug) => debug,
|
||||
Err(err) => {
|
||||
log::warn!("Failed to get debug interface from device factory: {err}");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::Legacy => match lib.debug_interface() {
|
||||
Ok(Some(debug)) => debug,
|
||||
Ok(None) => return,
|
||||
Err(err) => {
|
||||
log::warn!("Failed to get debug interface: {err}");
|
||||
return;
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
if flags.intersects(wgt::InstanceFlags::VALIDATION) {
|
||||
unsafe { debug_controller.EnableDebugLayer() }
|
||||
}
|
||||
if flags.intersects(wgt::InstanceFlags::GPU_BASED_VALIDATION) {
|
||||
if let Ok(debug1) = debug_controller.cast::<Direct3D12::ID3D12Debug1>() {
|
||||
unsafe { debug1.SetEnableGPUBasedValidation(true) }
|
||||
} else {
|
||||
log::warn!("Failed to enable GPU-based validation");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a D3D12 device using the appropriate method.
|
||||
pub(super) fn create_device(
|
||||
&self,
|
||||
lib: &Arc<D3D12Lib>,
|
||||
adapter: &DxgiAdapter,
|
||||
feature_level: Direct3D::D3D_FEATURE_LEVEL,
|
||||
) -> Result<Direct3D12::ID3D12Device, super::CreateDeviceError> {
|
||||
match self {
|
||||
Self::Independent(factory) => {
|
||||
let mut result__: Option<Direct3D12::ID3D12Device> = None;
|
||||
unsafe { factory.CreateDevice(adapter.deref(), feature_level, &mut result__) }
|
||||
.map_err(|e| super::CreateDeviceError::D3D12CreateDevice(e.into()))?;
|
||||
|
||||
result__.ok_or(super::CreateDeviceError::RetDeviceIsNull)
|
||||
}
|
||||
Self::Legacy => lib.create_device(adapter, feature_level),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl core::fmt::Debug for DeviceFactory {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
||||
match self {
|
||||
Self::Independent(_) => write!(f, "DeviceFactory::Independent"),
|
||||
Self::Legacy => write!(f, "DeviceFactory::Legacy"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
enum DeviceFactoryError {
|
||||
#[error("failed to get ID3D12SDKConfiguration1: {0}")]
|
||||
GetInterface(super::GetInterfaceError),
|
||||
#[error("SDK path contains null bytes")]
|
||||
InvalidPath,
|
||||
#[error("CreateDeviceFactory failed: {0}")]
|
||||
CreateDeviceFactory(windows::core::Error),
|
||||
}
|
||||
Vendored
+189
@@ -0,0 +1,189 @@
|
||||
use alloc::{string::String, sync::Arc, vec::Vec};
|
||||
|
||||
use parking_lot::RwLock;
|
||||
use windows::Win32::{Foundation, Graphics::Dxgi};
|
||||
|
||||
use super::SurfaceTarget;
|
||||
use crate::{
|
||||
auxil,
|
||||
dx12::{
|
||||
device_creation::DeviceFactory, shader_compilation::CompilerContainer, D3D12Lib, DCompLib,
|
||||
},
|
||||
};
|
||||
|
||||
impl crate::Instance for super::Instance {
|
||||
type A = super::Api;
|
||||
|
||||
unsafe fn init(desc: &crate::InstanceDescriptor<'_>) -> Result<Self, crate::InstanceError> {
|
||||
profiling::scope!("Init DX12 Backend");
|
||||
let lib_main = D3D12Lib::new().map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("failed to load d3d12.dll"), e)
|
||||
})?;
|
||||
|
||||
// Create DeviceFactory first so we know which debug path to use
|
||||
let device_factory =
|
||||
DeviceFactory::new(&lib_main, desc.backend_options.dx12.agility_sdk.as_ref())?;
|
||||
|
||||
device_factory.enable_debug_layer(&lib_main, desc.flags);
|
||||
|
||||
let (lib_dxgi, factory) = auxil::dxgi::factory::create_factory(desc.flags)?;
|
||||
|
||||
// Create IDXGIFactoryMedia
|
||||
let factory_media = lib_dxgi.create_factory_media().ok();
|
||||
|
||||
let mut supports_allow_tearing = false;
|
||||
if let Some(factory5) = factory.as_factory5() {
|
||||
let mut allow_tearing = Foundation::FALSE;
|
||||
let hr = unsafe {
|
||||
factory5.CheckFeatureSupport(
|
||||
Dxgi::DXGI_FEATURE_PRESENT_ALLOW_TEARING,
|
||||
<*mut _>::cast(&mut allow_tearing),
|
||||
size_of_val(&allow_tearing) as u32,
|
||||
)
|
||||
};
|
||||
|
||||
match hr {
|
||||
Err(err) => log::warn!("Unable to check for tearing support: {err}"),
|
||||
Ok(()) => supports_allow_tearing = true,
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize the shader compiler
|
||||
let compiler_container = match desc.backend_options.dx12.shader_compiler.clone() {
|
||||
wgt::Dx12Compiler::DynamicDxc { dxc_path } => {
|
||||
CompilerContainer::new_dynamic_dxc(dxc_path.into()).map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("Failed to load dynamic DXC"), e)
|
||||
})?
|
||||
}
|
||||
wgt::Dx12Compiler::StaticDxc => CompilerContainer::new_static_dxc().map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("Failed to load static DXC"), e)
|
||||
})?,
|
||||
wgt::Dx12Compiler::Fxc => CompilerContainer::new_fxc().map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("Failed to load FXC"), e)
|
||||
})?,
|
||||
wgt::Dx12Compiler::Auto => {
|
||||
if cfg!(static_dxc) {
|
||||
// Prefer static DXC if its compiled in
|
||||
CompilerContainer::new_static_dxc().map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("Failed to load static DXC"),
|
||||
e,
|
||||
)
|
||||
})?
|
||||
} else {
|
||||
// Try to load dynamic DXC
|
||||
let dynamic = CompilerContainer::new_dynamic_dxc("dxcompiler.dll".into());
|
||||
match dynamic {
|
||||
Ok(v) => v,
|
||||
Err(super::shader_compilation::GetContainerError::FailedToLoad(..)) => {
|
||||
// If it can't be found load FXC
|
||||
CompilerContainer::new_fxc().map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("Failed to load FXC"),
|
||||
e,
|
||||
)
|
||||
})?
|
||||
}
|
||||
Err(e) => {
|
||||
// If another error occurs when loading static DXC return that error
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("Failed to load dynamic DXC"),
|
||||
e,
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
match compiler_container {
|
||||
CompilerContainer::DynamicDxc(..) => {
|
||||
log::debug!("Using dynamic DXC for shader compilation")
|
||||
}
|
||||
CompilerContainer::StaticDxc(..) => {
|
||||
log::debug!("Using static DXC for shader compilation")
|
||||
}
|
||||
CompilerContainer::Fxc(..) => {
|
||||
log::debug!("Using FXC for shader compilation")
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
// The call to create_factory will only succeed if we get a factory4, so this is safe.
|
||||
factory,
|
||||
factory_media,
|
||||
library: Arc::new(lib_main),
|
||||
device_factory: Arc::new(device_factory),
|
||||
dcomp_lib: Arc::new(DCompLib::new()),
|
||||
presentation_system: desc.backend_options.dx12.presentation_system,
|
||||
_lib_dxgi: lib_dxgi,
|
||||
supports_allow_tearing,
|
||||
flags: desc.flags,
|
||||
memory_budget_thresholds: desc.memory_budget_thresholds,
|
||||
compiler_container: Arc::new(compiler_container),
|
||||
options: desc.backend_options.dx12.clone(),
|
||||
telemetry: desc.telemetry,
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn create_surface(
|
||||
&self,
|
||||
display_handle: raw_window_handle::RawDisplayHandle,
|
||||
window_handle: raw_window_handle::RawWindowHandle,
|
||||
) -> Result<super::Surface, crate::InstanceError> {
|
||||
assert!(matches!(
|
||||
display_handle,
|
||||
raw_window_handle::RawDisplayHandle::Windows(_)
|
||||
));
|
||||
match window_handle {
|
||||
raw_window_handle::RawWindowHandle::Win32(handle) => {
|
||||
// https://github.com/rust-windowing/raw-window-handle/issues/171
|
||||
let handle = Foundation::HWND(handle.hwnd.get() as *mut _);
|
||||
let target = match self.presentation_system {
|
||||
wgt::Dx12SwapchainKind::DxgiFromHwnd => SurfaceTarget::WndHandle(handle),
|
||||
wgt::Dx12SwapchainKind::DxgiFromVisual => SurfaceTarget::VisualFromWndHandle {
|
||||
handle,
|
||||
dcomp_state: Default::default(),
|
||||
},
|
||||
};
|
||||
|
||||
Ok(super::Surface {
|
||||
factory: self.factory.clone(),
|
||||
factory_media: self.factory_media.clone(),
|
||||
target,
|
||||
supports_allow_tearing: self.supports_allow_tearing,
|
||||
swap_chain: RwLock::new(None),
|
||||
options: self.options.clone(),
|
||||
hdr_source: Some(auxil::dxgi::hdr::DxgiHdrSource::new(handle)),
|
||||
})
|
||||
}
|
||||
_ => Err(crate::InstanceError::new(format!(
|
||||
"window handle {window_handle:?} is not a Win32 handle"
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn enumerate_adapters(
|
||||
&self,
|
||||
_surface_hint: Option<&super::Surface>,
|
||||
) -> Vec<crate::ExposedAdapter<super::Api>> {
|
||||
let adapters = auxil::dxgi::factory::enumerate_adapters(self.factory.clone());
|
||||
|
||||
adapters
|
||||
.into_iter()
|
||||
.filter_map(|raw| {
|
||||
super::Adapter::expose(
|
||||
raw,
|
||||
&self.library,
|
||||
&self.device_factory,
|
||||
&self.dcomp_lib,
|
||||
self.flags,
|
||||
self.memory_budget_thresholds,
|
||||
self.compiler_container.clone(),
|
||||
self.options.clone(),
|
||||
self.telemetry,
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
Vendored
+1908
File diff suppressed because it is too large.
Load diff
+344
@@ -0,0 +1,344 @@
|
||||
//! We try to use pipeline stream descriptors where possible, but this isn't allowed
|
||||
//! on some older windows 10 versions. Therefore, we also must have some logic to
|
||||
//! convert such descriptors to the "traditional" equivalent,
|
||||
//! `D3D12_GRAPHICS_PIPELINE_STATE_DESC`.
|
||||
//!
|
||||
//! Stream descriptors allow extending the pipeline, enabling more advanced features,
|
||||
//! including mesh shaders and multiview/view instancing. Using a stream descriptor
|
||||
//! is like using a vulkan descriptor with a `pNext` chain. It doesn't have direct
|
||||
//! benefits to all use cases, but allows new use cases.
|
||||
//!
|
||||
//! The code for pipeline stream descriptors is very complicated, and can have bad
|
||||
//! consequences if it is written incorrectly. It has been isolated to this file for
|
||||
//! that reason.
|
||||
|
||||
use core::{ffi::c_void, mem::ManuallyDrop, ptr::NonNull};
|
||||
|
||||
use alloc::vec::Vec;
|
||||
use windows::Win32::Graphics::Direct3D12::*;
|
||||
use windows::Win32::Graphics::Dxgi::Common::*;
|
||||
use windows_core::Interface;
|
||||
|
||||
use crate::dx12::borrow_interface_temporarily;
|
||||
|
||||
// Wrapper newtypes for various pipeline subobjects which
|
||||
// use complicated or non-unique representations.
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
// Option<NonNull<c_void>> is guaranteed to have the same representation as a raw pointer.
|
||||
struct RootSignature(Option<NonNull<c_void>>);
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
struct VertexShader(D3D12_SHADER_BYTECODE);
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
struct PixelShader(D3D12_SHADER_BYTECODE);
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
struct MeshShader(D3D12_SHADER_BYTECODE);
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
struct TaskShader(D3D12_SHADER_BYTECODE);
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
struct SampleMask(u32);
|
||||
|
||||
#[repr(transparent)]
|
||||
#[derive(Copy, Clone)]
|
||||
struct NodeMask(u32);
|
||||
|
||||
/// Trait for types that can be used as subobjects in a pipeline state stream.
|
||||
///
|
||||
/// Safety:
|
||||
/// - The type must be the correct alignment and size for the subobject it represents.
|
||||
/// - The type must map to exactly one `D3D12_PIPELINE_STATE_SUBOBJECT_TYPE` variant.
|
||||
/// - The variant must correctly represent the type's role in the pipeline state stream.
|
||||
/// - The type must be `Copy` to ensure safe duplication in the stream.
|
||||
/// - The type must be valid to memcpy into the pipeline state stream.
|
||||
unsafe trait RenderPipelineStreamObject: Copy {
|
||||
const SUBOBJECT_TYPE: D3D12_PIPELINE_STATE_SUBOBJECT_TYPE;
|
||||
}
|
||||
|
||||
macro_rules! implement_stream_object {
|
||||
(unsafe $ty:ty => $variant:expr) => {
|
||||
unsafe impl RenderPipelineStreamObject for $ty {
|
||||
const SUBOBJECT_TYPE: D3D12_PIPELINE_STATE_SUBOBJECT_TYPE = $variant;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
implement_stream_object! { unsafe RootSignature => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE }
|
||||
implement_stream_object! { unsafe VertexShader => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS }
|
||||
implement_stream_object! { unsafe PixelShader => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS }
|
||||
implement_stream_object! { unsafe MeshShader => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS }
|
||||
implement_stream_object! { unsafe TaskShader => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS }
|
||||
implement_stream_object! { unsafe D3D12_BLEND_DESC => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND }
|
||||
implement_stream_object! { unsafe SampleMask => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK }
|
||||
implement_stream_object! { unsafe D3D12_RASTERIZER_DESC => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER }
|
||||
implement_stream_object! { unsafe D3D12_DEPTH_STENCIL_DESC => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL }
|
||||
implement_stream_object! { unsafe D3D12_PRIMITIVE_TOPOLOGY_TYPE => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY }
|
||||
implement_stream_object! { unsafe D3D12_RT_FORMAT_ARRAY => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS }
|
||||
implement_stream_object! { unsafe DXGI_FORMAT => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT }
|
||||
implement_stream_object! { unsafe DXGI_SAMPLE_DESC => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC }
|
||||
implement_stream_object! { unsafe NodeMask => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK }
|
||||
implement_stream_object! { unsafe D3D12_CACHED_PIPELINE_STATE => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO }
|
||||
implement_stream_object! { unsafe D3D12_PIPELINE_STATE_FLAGS => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS }
|
||||
implement_stream_object! { unsafe D3D12_INPUT_LAYOUT_DESC => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT }
|
||||
implement_stream_object! { unsafe D3D12_INDEX_BUFFER_STRIP_CUT_VALUE => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE }
|
||||
implement_stream_object! { unsafe D3D12_STREAM_OUTPUT_DESC => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT }
|
||||
implement_stream_object! { unsafe D3D12_VIEW_INSTANCING_DESC => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING }
|
||||
|
||||
/// Implementaation of a pipeline state stream, which is a sequence of subobjects put into
|
||||
/// a byte array according to some basic alignment rules.
|
||||
///
|
||||
/// Each subobject must start on an 8 byte boundary. Each subobject contains a 32 bit
|
||||
/// type identifier, followed by the actual subobject data, aligned as required by the
|
||||
/// subobject's structure.
|
||||
///
|
||||
/// See <https://learn.microsoft.com/en-us/windows/win32/api/d3d12/ns-d3d12-d3d12_pipeline_state_stream_desc>
|
||||
/// for more information.
|
||||
pub(super) struct RenderPipelineStateStream<'a> {
|
||||
bytes: Vec<u8>,
|
||||
_marker: core::marker::PhantomData<&'a ()>,
|
||||
}
|
||||
|
||||
impl<'a> RenderPipelineStateStream<'a> {
|
||||
fn new() -> Self {
|
||||
// Dynamic allocation is used here because the resulting stream can become very large.
|
||||
// We pre-allocate the size based on an estimate of the size of the struct plus some extra space
|
||||
// per member for tags and alignment padding. In practice this will always be too big, as not
|
||||
// all members will be used.
|
||||
let size_of_stream_desc = size_of::<RenderPipelineStateStreamDesc>();
|
||||
let members = 20; // Approximate number of members we might push
|
||||
let capacity = size_of_stream_desc + members * 8; // Extra space for tags and alignment
|
||||
Self {
|
||||
bytes: Vec::with_capacity(capacity),
|
||||
_marker: core::marker::PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Align the internal byte buffer to the given alignment,
|
||||
/// padding with zeros as necessary.
|
||||
fn align_to(&mut self, alignment: usize) {
|
||||
let aligned_length = self.bytes.len().next_multiple_of(alignment);
|
||||
self.bytes.resize(aligned_length, 0);
|
||||
}
|
||||
|
||||
/// Adds a subobject to the pipeline state stream.
|
||||
fn add_object<T: RenderPipelineStreamObject>(&mut self, object: T) {
|
||||
// Ensure 8-byte alignment for the subobject start.
|
||||
self.align_to(8);
|
||||
|
||||
// Append the type tag (u32)
|
||||
let tag: u32 = T::SUBOBJECT_TYPE.0 as u32;
|
||||
self.bytes.extend_from_slice(&tag.to_ne_bytes());
|
||||
|
||||
// Align the data to its natural alignment.
|
||||
self.align_to(align_of_val::<T>(&object));
|
||||
|
||||
// Append the data itself, as raw bytes
|
||||
let data_ptr: *const T = &object;
|
||||
let data_u8_ptr: *const u8 = data_ptr.cast::<u8>();
|
||||
let data_size = size_of_val::<T>(&object);
|
||||
let slice = unsafe { core::slice::from_raw_parts::<u8>(data_u8_ptr, data_size) };
|
||||
self.bytes.extend_from_slice(slice);
|
||||
}
|
||||
|
||||
/// Creates a pipeline state object from the stream.
|
||||
///
|
||||
/// Safety:
|
||||
/// - All unsafety invariants required by [`ID3D12Device2::CreatePipelineState`] must be upheld by the caller.
|
||||
pub unsafe fn create_pipeline_state(
|
||||
&mut self,
|
||||
device: &ID3D12Device2,
|
||||
) -> windows::core::Result<ID3D12PipelineState> {
|
||||
let stream_desc = D3D12_PIPELINE_STATE_STREAM_DESC {
|
||||
SizeInBytes: self.bytes.len(),
|
||||
pPipelineStateSubobjectStream: self.bytes.as_mut_ptr().cast(),
|
||||
};
|
||||
|
||||
// Safety: lifetime on Self preserved the contents
|
||||
// of the stream. Other unsafety invariants are upheld by the caller.
|
||||
unsafe { device.CreatePipelineState(&stream_desc) }
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
pub struct RenderPipelineStateStreamDesc<'a> {
|
||||
pub root_signature: Option<&'a ID3D12RootSignature>,
|
||||
pub pixel_shader: D3D12_SHADER_BYTECODE,
|
||||
pub blend_state: D3D12_BLEND_DESC,
|
||||
pub sample_mask: u32,
|
||||
pub rasterizer_state: D3D12_RASTERIZER_DESC,
|
||||
pub depth_stencil_state: D3D12_DEPTH_STENCIL_DESC,
|
||||
pub primitive_topology_type: D3D12_PRIMITIVE_TOPOLOGY_TYPE,
|
||||
pub rtv_formats: D3D12_RT_FORMAT_ARRAY,
|
||||
pub dsv_format: DXGI_FORMAT,
|
||||
pub sample_desc: DXGI_SAMPLE_DESC,
|
||||
pub node_mask: u32,
|
||||
pub cached_pso: D3D12_CACHED_PIPELINE_STATE,
|
||||
pub flags: D3D12_PIPELINE_STATE_FLAGS,
|
||||
pub view_instancing: Option<D3D12_VIEW_INSTANCING_DESC>,
|
||||
|
||||
// Vertex pipeline specific
|
||||
pub vertex_shader: D3D12_SHADER_BYTECODE,
|
||||
pub input_layout: D3D12_INPUT_LAYOUT_DESC,
|
||||
pub index_buffer_strip_cut_value: D3D12_INDEX_BUFFER_STRIP_CUT_VALUE,
|
||||
pub stream_output: D3D12_STREAM_OUTPUT_DESC,
|
||||
|
||||
// Mesh pipeline specific
|
||||
pub task_shader: D3D12_SHADER_BYTECODE,
|
||||
pub mesh_shader: D3D12_SHADER_BYTECODE,
|
||||
}
|
||||
|
||||
impl RenderPipelineStateStreamDesc<'_> {
|
||||
pub fn to_stream(&self) -> RenderPipelineStateStream<'_> {
|
||||
let mut stream = RenderPipelineStateStream::new();
|
||||
|
||||
// Importantly here, the ID3D12RootSignature _itself_ is the pointer we're
|
||||
// trying to serialize into the stream, not a pointer to the pointer.
|
||||
//
|
||||
// This is correct because as_raw() returns turns that smart object into the raw
|
||||
// pointer that _is_ the com object handle.
|
||||
let root_sig_pointer = self
|
||||
.root_signature
|
||||
.map(|a| NonNull::new(a.as_raw()).unwrap());
|
||||
// Because the stream object borrows from self for its entire lifetime,
|
||||
// it is safe to store the pointer into it.
|
||||
stream.add_object(RootSignature(root_sig_pointer));
|
||||
|
||||
stream.add_object(self.blend_state);
|
||||
stream.add_object(SampleMask(self.sample_mask));
|
||||
stream.add_object(self.rasterizer_state);
|
||||
stream.add_object(self.depth_stencil_state);
|
||||
stream.add_object(self.primitive_topology_type);
|
||||
if self.rtv_formats.NumRenderTargets != 0 {
|
||||
stream.add_object(self.rtv_formats);
|
||||
}
|
||||
if self.dsv_format != DXGI_FORMAT_UNKNOWN {
|
||||
stream.add_object(self.dsv_format);
|
||||
}
|
||||
stream.add_object(self.sample_desc);
|
||||
if self.node_mask != 0 {
|
||||
stream.add_object(NodeMask(self.node_mask));
|
||||
}
|
||||
if !self.cached_pso.pCachedBlob.is_null() {
|
||||
stream.add_object(self.cached_pso);
|
||||
}
|
||||
stream.add_object(self.flags);
|
||||
if let Some(view_instancing) = self.view_instancing {
|
||||
stream.add_object(view_instancing);
|
||||
}
|
||||
if !self.pixel_shader.pShaderBytecode.is_null() {
|
||||
stream.add_object(PixelShader(self.pixel_shader));
|
||||
}
|
||||
if !self.vertex_shader.pShaderBytecode.is_null() {
|
||||
stream.add_object(VertexShader(self.vertex_shader));
|
||||
stream.add_object(self.input_layout);
|
||||
stream.add_object(self.index_buffer_strip_cut_value);
|
||||
stream.add_object(self.stream_output);
|
||||
}
|
||||
if !self.task_shader.pShaderBytecode.is_null() {
|
||||
stream.add_object(TaskShader(self.task_shader));
|
||||
}
|
||||
if !self.mesh_shader.pShaderBytecode.is_null() {
|
||||
stream.add_object(MeshShader(self.mesh_shader));
|
||||
}
|
||||
|
||||
stream
|
||||
}
|
||||
|
||||
/// Returns a traditional D3D12_GRAPHICS_PIPELINE_STATE_DESC.
|
||||
///
|
||||
/// Safety:
|
||||
/// - This returned struct must not outlive self.
|
||||
pub unsafe fn to_graphics_pipeline_descriptor(&self) -> D3D12_GRAPHICS_PIPELINE_STATE_DESC {
|
||||
D3D12_GRAPHICS_PIPELINE_STATE_DESC {
|
||||
pRootSignature: if let Some(rsig) = self.root_signature {
|
||||
unsafe { borrow_interface_temporarily(rsig) }
|
||||
} else {
|
||||
ManuallyDrop::new(None)
|
||||
},
|
||||
VS: self.vertex_shader,
|
||||
PS: self.pixel_shader,
|
||||
DS: D3D12_SHADER_BYTECODE::default(),
|
||||
HS: D3D12_SHADER_BYTECODE::default(),
|
||||
GS: D3D12_SHADER_BYTECODE::default(),
|
||||
StreamOutput: self.stream_output,
|
||||
BlendState: self.blend_state,
|
||||
SampleMask: self.sample_mask,
|
||||
RasterizerState: self.rasterizer_state,
|
||||
DepthStencilState: self.depth_stencil_state,
|
||||
InputLayout: self.input_layout,
|
||||
IBStripCutValue: self.index_buffer_strip_cut_value,
|
||||
PrimitiveTopologyType: self.primitive_topology_type,
|
||||
NumRenderTargets: self.rtv_formats.NumRenderTargets,
|
||||
RTVFormats: self.rtv_formats.RTFormats,
|
||||
DSVFormat: self.dsv_format,
|
||||
SampleDesc: self.sample_desc,
|
||||
NodeMask: self.node_mask,
|
||||
CachedPSO: self.cached_pso,
|
||||
Flags: self.flags,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn wrappers() {
|
||||
assert_eq!(size_of::<RootSignature>(), size_of::<ID3D12RootSignature>());
|
||||
assert_eq!(
|
||||
align_of::<RootSignature>(),
|
||||
align_of::<ID3D12RootSignature>()
|
||||
)
|
||||
}
|
||||
|
||||
implement_stream_object!(unsafe u16 => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE(1));
|
||||
implement_stream_object!(unsafe u32 => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE(2));
|
||||
implement_stream_object!(unsafe u64 => D3D12_PIPELINE_STATE_SUBOBJECT_TYPE(3));
|
||||
|
||||
#[test]
|
||||
fn stream() {
|
||||
let mut stream = RenderPipelineStateStream::new();
|
||||
|
||||
stream.add_object(42u16);
|
||||
stream.add_object(84u32);
|
||||
stream.add_object(168u64);
|
||||
|
||||
assert_eq!(stream.bytes.len(), 32);
|
||||
|
||||
// Object 1: u16
|
||||
|
||||
// Tag at the beginning
|
||||
assert_eq!(&stream.bytes[0..4], &1u32.to_ne_bytes());
|
||||
// Data tucked in, aligned to the natural alignment of u16
|
||||
assert_eq!(&stream.bytes[4..6], &42u16.to_ne_bytes());
|
||||
// Padding to align the next subobject to an 8 byte boundary.
|
||||
assert_eq!(&stream.bytes[6..8], &[0, 0]);
|
||||
|
||||
// Object 2: u32
|
||||
|
||||
// Tag at the beginning
|
||||
assert_eq!(&stream.bytes[8..12], &2u32.to_ne_bytes());
|
||||
// Data tucked in, aligned to the natural alignment of u32
|
||||
assert_eq!(&stream.bytes[12..16], &84u32.to_ne_bytes());
|
||||
|
||||
// Object 3: u64
|
||||
|
||||
// Tag at the beginning
|
||||
assert_eq!(&stream.bytes[16..20], &3u32.to_ne_bytes());
|
||||
// Padding to align the u64 to an 8 byte boundary.
|
||||
assert_eq!(&stream.bytes[20..24], &[0, 0, 0, 0]);
|
||||
// Data tucked in, aligned to the natural alignment of u64
|
||||
assert_eq!(&stream.bytes[24..32], &168u64.to_ne_bytes());
|
||||
}
|
||||
}
|
||||
Vendored
+252
@@ -0,0 +1,252 @@
|
||||
//! Sampler management for DX12.
|
||||
//!
|
||||
//! Nearly identical to the Vulkan sampler cache, with added descriptor heap management.
|
||||
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use hashbrown::{hash_map::Entry, HashMap};
|
||||
|
||||
use ordered_float::OrderedFloat;
|
||||
use parking_lot::Mutex;
|
||||
use windows::Win32::Graphics::Direct3D12::*;
|
||||
|
||||
use crate::dx12::HResult;
|
||||
|
||||
/// The index of a sampler in the global sampler heap.
|
||||
///
|
||||
/// This is a type-safe, transparent wrapper around a u32.
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub(crate) struct SamplerIndex(u32);
|
||||
|
||||
/// [`D3D12_SAMPLER_DESC`] is not hashable, so we wrap it in a newtype that is.
|
||||
///
|
||||
/// We use [`OrderedFloat`] to allow for floating point values to be compared and
|
||||
/// hashed in a defined way.
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
struct HashableSamplerDesc(D3D12_SAMPLER_DESC);
|
||||
|
||||
impl PartialEq for HashableSamplerDesc {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.0.Filter == other.0.Filter
|
||||
&& self.0.AddressU == other.0.AddressU
|
||||
&& self.0.AddressV == other.0.AddressV
|
||||
&& self.0.AddressW == other.0.AddressW
|
||||
&& OrderedFloat(self.0.MipLODBias) == OrderedFloat(other.0.MipLODBias)
|
||||
&& self.0.MaxAnisotropy == other.0.MaxAnisotropy
|
||||
&& self.0.ComparisonFunc == other.0.ComparisonFunc
|
||||
&& self.0.BorderColor.map(OrderedFloat) == other.0.BorderColor.map(OrderedFloat)
|
||||
&& OrderedFloat(self.0.MinLOD) == OrderedFloat(other.0.MinLOD)
|
||||
&& OrderedFloat(self.0.MaxLOD) == OrderedFloat(other.0.MaxLOD)
|
||||
}
|
||||
}
|
||||
|
||||
impl Eq for HashableSamplerDesc {}
|
||||
|
||||
impl core::hash::Hash for HashableSamplerDesc {
|
||||
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
|
||||
self.0.Filter.0.hash(state);
|
||||
self.0.AddressU.0.hash(state);
|
||||
self.0.AddressV.0.hash(state);
|
||||
self.0.AddressW.0.hash(state);
|
||||
OrderedFloat(self.0.MipLODBias).hash(state);
|
||||
self.0.MaxAnisotropy.hash(state);
|
||||
self.0.ComparisonFunc.0.hash(state);
|
||||
self.0.BorderColor.map(OrderedFloat).hash(state);
|
||||
OrderedFloat(self.0.MinLOD).hash(state);
|
||||
OrderedFloat(self.0.MaxLOD).hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
/// Entry in the sampler cache.
|
||||
struct CacheEntry {
|
||||
index: SamplerIndex,
|
||||
ref_count: u32,
|
||||
}
|
||||
|
||||
/// Container for the mutable management state of the sampler heap.
|
||||
///
|
||||
/// We have this separated, using interior mutability, to allow for the outside world
|
||||
/// to access the heap directly without needing to take the lock.
|
||||
pub(crate) struct SamplerHeapState {
|
||||
/// Mapping from the sampler description to the index within the heap and the refcount.
|
||||
mapping: HashMap<HashableSamplerDesc, CacheEntry>,
|
||||
/// List of free sampler indices.
|
||||
freelist: Vec<SamplerIndex>,
|
||||
}
|
||||
|
||||
/// Global sampler heap for the device.
|
||||
///
|
||||
/// As D3D12 only allows 2048 samplers to be in a single heap, we need to cache
|
||||
/// samplers aggressively and refer to them in shaders by index.
|
||||
pub(crate) struct SamplerHeap {
|
||||
/// Mutable management state of the sampler heap.
|
||||
state: Mutex<SamplerHeapState>,
|
||||
|
||||
/// The heap itself.
|
||||
heap: ID3D12DescriptorHeap,
|
||||
/// The CPU-side handle to the first descriptor in the heap.
|
||||
///
|
||||
/// Both the CPU and GPU handles point to the same descriptor, just in
|
||||
/// different contexts.
|
||||
heap_cpu_start_handle: D3D12_CPU_DESCRIPTOR_HANDLE,
|
||||
/// The GPU-side handle to the first descriptor in the heap.
|
||||
///
|
||||
/// Both the CPU and GPU handles point to the same descriptor, just in
|
||||
/// different contexts.
|
||||
heap_gpu_start_handle: D3D12_GPU_DESCRIPTOR_HANDLE,
|
||||
|
||||
/// This is the device-specific size of sampler descriptors.
|
||||
descriptor_stride: u32,
|
||||
}
|
||||
|
||||
impl SamplerHeap {
|
||||
pub fn new(
|
||||
device: &ID3D12Device,
|
||||
private_caps: &super::PrivateCapabilities,
|
||||
) -> Result<Self, crate::DeviceError> {
|
||||
profiling::scope!("SamplerHeap::new");
|
||||
|
||||
// WARP can report this as 2M or more. We clamp it to 64k to be safe.
|
||||
const SAMPLER_HEAP_SIZE_CLAMP: u32 = 64 * 1024;
|
||||
|
||||
let max_unique_samplers = private_caps
|
||||
.max_sampler_descriptor_heap_size
|
||||
.min(SAMPLER_HEAP_SIZE_CLAMP);
|
||||
|
||||
let desc = D3D12_DESCRIPTOR_HEAP_DESC {
|
||||
Type: D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
|
||||
NumDescriptors: max_unique_samplers,
|
||||
Flags: D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
|
||||
NodeMask: 0,
|
||||
};
|
||||
let heap = unsafe { device.CreateDescriptorHeap::<ID3D12DescriptorHeap>(&desc) }
|
||||
.into_device_result("Failed to create global GPU-Visible Sampler Descriptor Heap")?;
|
||||
|
||||
let heap_cpu_start_handle = unsafe { heap.GetCPUDescriptorHandleForHeapStart() };
|
||||
let heap_gpu_start_handle = unsafe { heap.GetGPUDescriptorHandleForHeapStart() };
|
||||
|
||||
let descriptor_stride =
|
||||
unsafe { device.GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) };
|
||||
|
||||
Ok(Self {
|
||||
state: Mutex::new(SamplerHeapState {
|
||||
mapping: HashMap::new(),
|
||||
// Reverse so that samplers get allocated starting from zero.
|
||||
freelist: (0..max_unique_samplers).map(SamplerIndex).rev().collect(),
|
||||
}),
|
||||
heap,
|
||||
heap_cpu_start_handle,
|
||||
heap_gpu_start_handle,
|
||||
descriptor_stride,
|
||||
})
|
||||
}
|
||||
|
||||
/// Returns a reference to the raw descriptor heap.
|
||||
pub fn heap(&self) -> &ID3D12DescriptorHeap {
|
||||
&self.heap
|
||||
}
|
||||
|
||||
/// Returns a reference the handle to be bound to the descriptor table.
|
||||
pub fn gpu_descriptor_table(&self) -> D3D12_GPU_DESCRIPTOR_HANDLE {
|
||||
self.heap_gpu_start_handle
|
||||
}
|
||||
|
||||
/// Add a sampler with the given description to the heap.
|
||||
///
|
||||
/// If the sampler already exists, the refcount is incremented and the existing index is returned.
|
||||
///
|
||||
/// If the sampler does not exist, a new sampler is created and the index is returned.
|
||||
///
|
||||
/// If the heap is full, an error is returned.
|
||||
pub fn create_sampler(
|
||||
&self,
|
||||
device: &ID3D12Device,
|
||||
desc: D3D12_SAMPLER_DESC,
|
||||
) -> Result<SamplerIndex, crate::DeviceError> {
|
||||
profiling::scope!("SamplerHeap::create_sampler");
|
||||
|
||||
let hashable_desc = HashableSamplerDesc(desc);
|
||||
|
||||
// Eagarly dereference the lock to allow split borrows.
|
||||
let state = &mut *self.state.lock();
|
||||
|
||||
// Lookup the sampler in the mapping.
|
||||
match state.mapping.entry(hashable_desc) {
|
||||
Entry::Occupied(occupied_entry) => {
|
||||
// We have found a match, so increment the refcount and return the index.
|
||||
let entry = occupied_entry.into_mut();
|
||||
entry.ref_count += 1;
|
||||
Ok(entry.index)
|
||||
}
|
||||
Entry::Vacant(vacant_entry) => {
|
||||
// We need to create a new sampler.
|
||||
|
||||
// Try to get a new index from the freelist.
|
||||
let Some(index) = state.freelist.pop() else {
|
||||
// If the freelist is empty, we have hit the maximum number of samplers.
|
||||
log::error!("There is no more room in the global sampler heap for more unique samplers. Your device supports a maximum of {} unique samplers.", state.mapping.len());
|
||||
return Err(crate::DeviceError::OutOfMemory);
|
||||
};
|
||||
|
||||
// Compute the CPU side handle for the new sampler.
|
||||
let handle = D3D12_CPU_DESCRIPTOR_HANDLE {
|
||||
ptr: self.heap_cpu_start_handle.ptr
|
||||
+ self.descriptor_stride as usize * index.0 as usize,
|
||||
};
|
||||
|
||||
unsafe {
|
||||
device.CreateSampler(&desc, handle);
|
||||
}
|
||||
|
||||
// Insert the new sampler into the mapping.
|
||||
vacant_entry.insert(CacheEntry {
|
||||
index,
|
||||
ref_count: 1,
|
||||
});
|
||||
|
||||
Ok(index)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Decrement the refcount of the sampler with the given description.
|
||||
///
|
||||
/// If the refcount reaches zero, the sampler is destroyed and the index is returned to the freelist.
|
||||
///
|
||||
/// The provided index is checked against the index of the sampler with the given description, ensuring
|
||||
/// that there isn't a clerical error from the caller.
|
||||
pub fn destroy_sampler(&self, desc: D3D12_SAMPLER_DESC, provided_index: SamplerIndex) {
|
||||
profiling::scope!("SamplerHeap::destroy_sampler");
|
||||
|
||||
// Eagarly dereference the lock to allow split borrows.
|
||||
let state = &mut *self.state.lock();
|
||||
|
||||
// Get the index of the sampler to destroy.
|
||||
let Entry::Occupied(mut hash_map_entry) = state.mapping.entry(HashableSamplerDesc(desc))
|
||||
else {
|
||||
log::error!(
|
||||
"Tried to destroy a sampler that doesn't exist. Sampler description: {desc:#?}"
|
||||
);
|
||||
return;
|
||||
};
|
||||
let cache_entry = hash_map_entry.get_mut();
|
||||
|
||||
// Ensure that the provided index matches the index of the sampler to destroy.
|
||||
assert_eq!(
|
||||
cache_entry.index, provided_index,
|
||||
"Mismatched sampler index, this is an implementation bug"
|
||||
);
|
||||
|
||||
// Decrement the refcount of the sampler.
|
||||
cache_entry.ref_count -= 1;
|
||||
|
||||
// If we are the last reference, remove the sampler from the mapping and return the index to the freelist.
|
||||
//
|
||||
// As samplers only exist as descriptors in the heap, there is nothing needed to be done to destroy the sampler.
|
||||
if cache_entry.ref_count == 0 {
|
||||
state.freelist.push(cache_entry.index);
|
||||
hash_map_entry.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
+450
@@ -0,0 +1,450 @@
|
||||
use alloc::{string::String, vec::Vec};
|
||||
use core::ffi::CStr;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use crate::auxil::dxgi::result::HResult;
|
||||
use thiserror::Error;
|
||||
use windows::{
|
||||
core::{Interface, PCSTR, PCWSTR},
|
||||
Win32::Graphics::Direct3D::{Dxc, Fxc, ID3DBlob, D3D_SHADER_MACRO},
|
||||
};
|
||||
|
||||
pub(super) enum CompilerContainer {
|
||||
Fxc(CompilerFxc),
|
||||
DynamicDxc(CompilerDynamicDxc),
|
||||
#[cfg_attr(not(static_dxc), allow(unused))]
|
||||
StaticDxc(CompilerStaticDxc),
|
||||
}
|
||||
|
||||
pub(super) struct CompilerFxc {
|
||||
fxc: FxcLib,
|
||||
}
|
||||
|
||||
pub(super) struct CompilerDynamicDxc {
|
||||
max_shader_model: wgt::DxcShaderModel,
|
||||
compiler: Dxc::IDxcCompiler3,
|
||||
// Has to be held onto for the lifetime of the device otherwise shaders will fail to compile.
|
||||
// Only needed when using dynamic linking.
|
||||
_dxc: DxcLib,
|
||||
}
|
||||
|
||||
pub(super) struct CompilerStaticDxc {
|
||||
max_shader_model: wgt::DxcShaderModel,
|
||||
compiler: Dxc::IDxcCompiler3,
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub(super) enum GetContainerError {
|
||||
#[error(transparent)]
|
||||
Device(#[from] crate::DeviceError),
|
||||
#[error("Failed to load {0}: {1}")]
|
||||
FailedToLoad(&'static str, libloading::Error),
|
||||
}
|
||||
|
||||
impl CompilerContainer {
|
||||
pub(super) fn new_fxc() -> Result<Self, GetContainerError> {
|
||||
FxcLib::new_dynamic().map(|fxc| Self::Fxc(CompilerFxc { fxc }))
|
||||
}
|
||||
|
||||
pub(super) fn new_dynamic_dxc(dxc_path: PathBuf) -> Result<Self, GetContainerError> {
|
||||
let dxc = DxcLib::new_dynamic(dxc_path)
|
||||
.map_err(|e| GetContainerError::FailedToLoad("dxcompiler.dll", e))?;
|
||||
|
||||
let compiler = dxc.create_instance::<Dxc::IDxcCompiler3>()?;
|
||||
|
||||
let (mut major, mut minor) = (1, 0);
|
||||
// DXC 1.0 didn't support this. If the cast fails assume it is DXC 1.0.
|
||||
if let Ok(version_info) = compiler.cast::<Dxc::IDxcVersionInfo>() {
|
||||
unsafe {
|
||||
version_info.GetVersion(&mut major, &mut minor).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Self::DynamicDxc(CompilerDynamicDxc {
|
||||
max_shader_model: wgt::DxcShaderModel::from_dxc_version(major, minor),
|
||||
compiler,
|
||||
_dxc: dxc,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Creates a [`CompilerContainer`] that delegates to the statically-linked version of DXC.
|
||||
pub(super) fn new_static_dxc() -> Result<CompilerContainer, crate::DeviceError> {
|
||||
#[cfg(static_dxc)]
|
||||
{
|
||||
unsafe {
|
||||
let compiler = dxc_create_instance::<Dxc::IDxcCompiler3>(|clsid, iid, ppv| {
|
||||
windows_core::HRESULT(mach_dxcompiler_rs::DxcCreateInstance(
|
||||
clsid.cast(),
|
||||
iid.cast(),
|
||||
ppv,
|
||||
))
|
||||
})?;
|
||||
|
||||
Ok(CompilerContainer::StaticDxc(CompilerStaticDxc {
|
||||
max_shader_model: wgt::DxcShaderModel::V6_7,
|
||||
compiler,
|
||||
}))
|
||||
}
|
||||
}
|
||||
#[cfg(not(static_dxc))]
|
||||
{
|
||||
panic!("Attempted to create a static DXC shader compiler, but the static-dxc feature was not enabled")
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn max_shader_model(&self) -> Option<wgt::DxcShaderModel> {
|
||||
match self {
|
||||
CompilerContainer::Fxc(..) => None,
|
||||
CompilerContainer::DynamicDxc(CompilerDynamicDxc {
|
||||
max_shader_model, ..
|
||||
})
|
||||
| CompilerContainer::StaticDxc(CompilerStaticDxc {
|
||||
max_shader_model, ..
|
||||
}) => Some(max_shader_model.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn compile(
|
||||
&self,
|
||||
device: &super::Device,
|
||||
source: &str,
|
||||
source_name: Option<&CStr>,
|
||||
raw_ep: &str,
|
||||
stage_bit: wgt::ShaderStages,
|
||||
full_stage: &str,
|
||||
) -> Result<super::CompiledShader, crate::PipelineError> {
|
||||
match self {
|
||||
CompilerContainer::Fxc(CompilerFxc { fxc }) => compile_fxc(
|
||||
device,
|
||||
source,
|
||||
source_name,
|
||||
raw_ep,
|
||||
stage_bit,
|
||||
full_stage,
|
||||
fxc,
|
||||
),
|
||||
CompilerContainer::DynamicDxc(CompilerDynamicDxc { compiler, .. })
|
||||
| CompilerContainer::StaticDxc(CompilerStaticDxc { compiler, .. }) => compile_dxc(
|
||||
device,
|
||||
source,
|
||||
source_name,
|
||||
raw_ep,
|
||||
stage_bit,
|
||||
full_stage,
|
||||
compiler,
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type D3DCompileFn = unsafe extern "system" fn(
|
||||
psrcdata: *const core::ffi::c_void,
|
||||
srcdatasize: usize,
|
||||
psourcename: PCSTR,
|
||||
pdefines: *const D3D_SHADER_MACRO,
|
||||
pinclude: *mut core::ffi::c_void,
|
||||
pentrypoint: PCSTR,
|
||||
ptarget: PCSTR,
|
||||
flags1: u32,
|
||||
flags2: u32,
|
||||
ppcode: *mut *mut core::ffi::c_void,
|
||||
pperrormsgs: *mut *mut core::ffi::c_void,
|
||||
) -> windows_core::HRESULT;
|
||||
|
||||
#[derive(Debug)]
|
||||
struct FxcLib {
|
||||
// `d3dcompile_fn` points into `_lib`, so `_lib` must be held for as long
|
||||
// as we want to keep compiling shaders with FXC.
|
||||
_lib: crate::dx12::DynLib,
|
||||
d3dcompile_fn: D3DCompileFn,
|
||||
}
|
||||
|
||||
impl FxcLib {
|
||||
const PATH: &str = "d3dcompiler_47.dll";
|
||||
|
||||
fn new_dynamic() -> Result<Self, GetContainerError> {
|
||||
unsafe {
|
||||
let lib = crate::dx12::DynLib::new(Self::PATH)
|
||||
.map_err(|e| GetContainerError::FailedToLoad(FxcLib::PATH, e))?;
|
||||
let d3dcompile_fn: D3DCompileFn = *lib.get::<D3DCompileFn>(c"D3DCompile".to_bytes())?;
|
||||
|
||||
Ok(Self {
|
||||
_lib: lib,
|
||||
d3dcompile_fn,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn compile(
|
||||
&self,
|
||||
source: &str,
|
||||
source_name: Option<&CStr>,
|
||||
raw_ep: &str,
|
||||
full_stage: &str,
|
||||
compile_flags: u32,
|
||||
shader_data: &mut Option<ID3DBlob>,
|
||||
error: &mut Option<ID3DBlob>,
|
||||
) -> Result<windows_core::Result<()>, crate::DeviceError> {
|
||||
unsafe {
|
||||
let raw_ep = alloc::ffi::CString::new(raw_ep).unwrap();
|
||||
let full_stage = alloc::ffi::CString::new(full_stage).unwrap();
|
||||
|
||||
// If no name has been set, D3DCompile wants the null pointer.
|
||||
let source_name = source_name
|
||||
.map(|cstr| cstr.as_ptr().cast())
|
||||
.unwrap_or(core::ptr::null());
|
||||
|
||||
let shader_data: *mut Option<ID3DBlob> = shader_data;
|
||||
let error: *mut Option<ID3DBlob> = error;
|
||||
|
||||
{
|
||||
profiling::scope!("Fxc::D3DCompile");
|
||||
Ok((self.d3dcompile_fn)(
|
||||
source.as_ptr().cast(),
|
||||
source.len(),
|
||||
PCSTR(source_name),
|
||||
core::ptr::null(),
|
||||
core::ptr::null_mut(),
|
||||
PCSTR(raw_ep.as_ptr().cast()),
|
||||
PCSTR(full_stage.as_ptr().cast()),
|
||||
compile_flags,
|
||||
0,
|
||||
shader_data.cast(),
|
||||
error.cast(),
|
||||
)
|
||||
.ok())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn compile_fxc(
|
||||
device: &super::Device,
|
||||
source: &str,
|
||||
source_name: Option<&CStr>,
|
||||
raw_ep: &str,
|
||||
stage_bit: wgt::ShaderStages,
|
||||
full_stage: &str,
|
||||
fxc: &FxcLib,
|
||||
) -> Result<super::CompiledShader, crate::PipelineError> {
|
||||
profiling::scope!("compile_fxc");
|
||||
let mut compile_flags = Fxc::D3DCOMPILE_ENABLE_STRICTNESS;
|
||||
if device
|
||||
.shared
|
||||
.private_caps
|
||||
.instance_flags
|
||||
.contains(wgt::InstanceFlags::DEBUG)
|
||||
{
|
||||
compile_flags |= Fxc::D3DCOMPILE_DEBUG | Fxc::D3DCOMPILE_SKIP_OPTIMIZATION;
|
||||
}
|
||||
|
||||
let mut shader_data = None;
|
||||
let mut error = None;
|
||||
let hr = fxc.compile(
|
||||
source,
|
||||
source_name,
|
||||
raw_ep,
|
||||
full_stage,
|
||||
compile_flags,
|
||||
&mut shader_data,
|
||||
&mut error,
|
||||
)?;
|
||||
|
||||
match hr {
|
||||
Ok(()) => {
|
||||
let shader_data = shader_data.unwrap();
|
||||
Ok(super::CompiledShader::Fxc(shader_data))
|
||||
}
|
||||
Err(e) => {
|
||||
let mut full_msg = format!("FXC D3DCompile error ({e})");
|
||||
if let Some(error) = error {
|
||||
use core::fmt::Write as _;
|
||||
let message = unsafe {
|
||||
core::slice::from_raw_parts(
|
||||
error.GetBufferPointer().cast(),
|
||||
error.GetBufferSize(),
|
||||
)
|
||||
};
|
||||
let _ = write!(full_msg, ": {}", String::from_utf8_lossy(message));
|
||||
}
|
||||
Err(crate::PipelineError::Linkage(stage_bit, full_msg))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
trait DxcObj: Interface {
|
||||
const CLSID: windows::core::GUID;
|
||||
}
|
||||
impl DxcObj for Dxc::IDxcCompiler3 {
|
||||
const CLSID: windows::core::GUID = Dxc::CLSID_DxcCompiler;
|
||||
}
|
||||
impl DxcObj for Dxc::IDxcUtils {
|
||||
const CLSID: windows::core::GUID = Dxc::CLSID_DxcUtils;
|
||||
}
|
||||
impl DxcObj for Dxc::IDxcValidator {
|
||||
const CLSID: windows::core::GUID = Dxc::CLSID_DxcValidator;
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct DxcLib {
|
||||
lib: crate::dx12::DynLib,
|
||||
}
|
||||
|
||||
impl DxcLib {
|
||||
fn new_dynamic(lib_path: PathBuf) -> Result<Self, libloading::Error> {
|
||||
unsafe { crate::dx12::DynLib::new(lib_path).map(|lib| Self { lib }) }
|
||||
}
|
||||
|
||||
pub fn create_instance<T: DxcObj>(&self) -> Result<T, crate::DeviceError> {
|
||||
unsafe {
|
||||
type DxcCreateInstanceFn = unsafe extern "system" fn(
|
||||
rclsid: *const windows_core::GUID,
|
||||
riid: *const windows_core::GUID,
|
||||
ppv: *mut *mut core::ffi::c_void,
|
||||
)
|
||||
-> windows_core::HRESULT;
|
||||
|
||||
let func: libloading::Symbol<DxcCreateInstanceFn> =
|
||||
self.lib.get(c"DxcCreateInstance".to_bytes())?;
|
||||
dxc_create_instance::<T>(|clsid, iid, ppv| func(clsid, iid, ppv))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Invokes the provided library function to create a DXC object.
|
||||
unsafe fn dxc_create_instance<T: DxcObj>(
|
||||
f: impl Fn(
|
||||
*const windows_core::GUID,
|
||||
*const windows_core::GUID,
|
||||
*mut *mut core::ffi::c_void,
|
||||
) -> windows_core::HRESULT,
|
||||
) -> Result<T, crate::DeviceError> {
|
||||
let mut result__ = None;
|
||||
f(&T::CLSID, &T::IID, <*mut _>::cast(&mut result__))
|
||||
.ok()
|
||||
.into_device_result("DxcCreateInstance")?;
|
||||
result__.ok_or(crate::DeviceError::Unexpected)
|
||||
}
|
||||
|
||||
/// Owned PCWSTR
|
||||
#[allow(clippy::upper_case_acronyms)]
|
||||
struct OPCWSTR {
|
||||
inner: Vec<u16>,
|
||||
}
|
||||
|
||||
impl OPCWSTR {
|
||||
fn new(s: &str) -> Self {
|
||||
let mut inner: Vec<_> = s.encode_utf16().collect();
|
||||
inner.push(0);
|
||||
Self { inner }
|
||||
}
|
||||
|
||||
fn ptr(&self) -> PCWSTR {
|
||||
PCWSTR(self.inner.as_ptr())
|
||||
}
|
||||
}
|
||||
|
||||
fn get_output<T: Interface>(
|
||||
res: &Dxc::IDxcResult,
|
||||
kind: Dxc::DXC_OUT_KIND,
|
||||
) -> Result<T, crate::DeviceError> {
|
||||
let mut result__: Option<T> = None;
|
||||
unsafe { res.GetOutput::<T>(kind, &mut None, <*mut _>::cast(&mut result__)) }
|
||||
.into_device_result("GetOutput")?;
|
||||
result__.ok_or(crate::DeviceError::Unexpected)
|
||||
}
|
||||
|
||||
fn as_err_str(blob: &Dxc::IDxcBlobUtf8) -> Result<&str, crate::DeviceError> {
|
||||
let ptr = unsafe { blob.GetStringPointer() };
|
||||
let len = unsafe { blob.GetStringLength() };
|
||||
core::str::from_utf8(unsafe { core::slice::from_raw_parts(ptr.0, len) })
|
||||
.map_err(|_| crate::DeviceError::Unexpected)
|
||||
}
|
||||
|
||||
fn compile_dxc(
|
||||
device: &crate::dx12::Device,
|
||||
source: &str,
|
||||
source_name: Option<&CStr>,
|
||||
raw_ep: &str,
|
||||
stage_bit: wgt::ShaderStages,
|
||||
full_stage: &str,
|
||||
compiler: &Dxc::IDxcCompiler3,
|
||||
) -> Result<crate::dx12::CompiledShader, crate::PipelineError> {
|
||||
profiling::scope!("compile_dxc");
|
||||
|
||||
let source_name = source_name.and_then(|cstr| cstr.to_str().ok());
|
||||
|
||||
let source_name = source_name.map(OPCWSTR::new);
|
||||
let raw_ep = OPCWSTR::new(raw_ep);
|
||||
let full_stage = OPCWSTR::new(full_stage);
|
||||
|
||||
let mut compile_args = arrayvec::ArrayVec::<PCWSTR, 13>::new_const();
|
||||
|
||||
if let Some(source_name) = source_name.as_ref() {
|
||||
compile_args.push(source_name.ptr())
|
||||
}
|
||||
|
||||
compile_args.extend([
|
||||
windows::core::w!("-E"),
|
||||
raw_ep.ptr(),
|
||||
windows::core::w!("-T"),
|
||||
full_stage.ptr(),
|
||||
windows::core::w!("-HV"),
|
||||
windows::core::w!("2018"), // Use HLSL 2018, Naga doesn't supported 2021 yet.
|
||||
windows::core::w!("-no-warnings"),
|
||||
Dxc::DXC_ARG_ENABLE_STRICTNESS,
|
||||
]);
|
||||
|
||||
if device
|
||||
.shared
|
||||
.private_caps
|
||||
.instance_flags
|
||||
.contains(wgt::InstanceFlags::DEBUG)
|
||||
&& !device
|
||||
.shared
|
||||
.private_caps
|
||||
.workarounds
|
||||
.avoid_shader_debug_info
|
||||
{
|
||||
compile_args.push(Dxc::DXC_ARG_DEBUG);
|
||||
compile_args.push(Dxc::DXC_ARG_SKIP_OPTIMIZATIONS);
|
||||
}
|
||||
|
||||
if device
|
||||
.features
|
||||
.intersects(wgt::Features::SHADER_F16 | wgt::Features::SHADER_I16)
|
||||
{
|
||||
compile_args.push(windows::core::w!("-enable-16bit-types"));
|
||||
}
|
||||
|
||||
let buffer = Dxc::DxcBuffer {
|
||||
Ptr: source.as_ptr().cast(),
|
||||
Size: source.len(),
|
||||
Encoding: Dxc::DXC_CP_UTF8.0,
|
||||
};
|
||||
|
||||
let compile_res: Dxc::IDxcResult =
|
||||
unsafe { compiler.Compile(&buffer, Some(&compile_args), None) }
|
||||
.into_device_result("Compile")?;
|
||||
|
||||
drop(compile_args);
|
||||
drop(source_name);
|
||||
drop(raw_ep);
|
||||
drop(full_stage);
|
||||
|
||||
let err_blob = get_output::<Dxc::IDxcBlobUtf8>(&compile_res, Dxc::DXC_OUT_ERRORS)?;
|
||||
|
||||
let len = unsafe { err_blob.GetStringLength() };
|
||||
if len != 0 {
|
||||
let err = as_err_str(&err_blob)?;
|
||||
return Err(crate::PipelineError::Linkage(
|
||||
stage_bit,
|
||||
format!("DXC compile error: {err}"),
|
||||
));
|
||||
}
|
||||
|
||||
let blob = get_output::<Dxc::IDxcBlob>(&compile_res, Dxc::DXC_OUT_OBJECT)?;
|
||||
|
||||
Ok(crate::dx12::CompiledShader::Dxc(blob))
|
||||
}
|
||||
+603
@@ -0,0 +1,603 @@
|
||||
use alloc::sync::Arc;
|
||||
|
||||
use gpu_allocator::{d3d12::AllocationCreateDesc, MemoryLocation};
|
||||
use parking_lot::Mutex;
|
||||
use windows::Win32::Graphics::{Direct3D12, Dxgi};
|
||||
|
||||
use crate::{
|
||||
auxil::dxgi::{name::ObjectExt as _, result::HResult as _},
|
||||
dx12::conv,
|
||||
AllocationSizes,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum AllocationType {
|
||||
Buffer,
|
||||
Texture,
|
||||
AccelerationStructure,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum AllocationInner {
|
||||
/// This resource is suballocated from a heap.
|
||||
Placed {
|
||||
inner: gpu_allocator::d3d12::Allocation,
|
||||
},
|
||||
/// This resource is a committed resource and does not belong to a
|
||||
/// suballocated heap. We store an approximate size, so we can manage our counters
|
||||
/// correctly.
|
||||
///
|
||||
/// This is only used for Intel Xe drivers, which have a bug that
|
||||
/// prevents suballocation from working correctly.
|
||||
Committed { size: u64 },
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct Allocation {
|
||||
inner: AllocationInner,
|
||||
ty: AllocationType,
|
||||
}
|
||||
|
||||
impl Allocation {
|
||||
pub fn placed(inner: gpu_allocator::d3d12::Allocation, ty: AllocationType) -> Self {
|
||||
Self {
|
||||
inner: AllocationInner::Placed { inner },
|
||||
ty,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn none(ty: AllocationType, size: u64) -> Self {
|
||||
Self {
|
||||
inner: AllocationInner::Committed { size },
|
||||
ty,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn size(&self) -> u64 {
|
||||
match self.inner {
|
||||
AllocationInner::Placed { ref inner } => inner.size(),
|
||||
AllocationInner::Committed { size } => size,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct Allocator {
|
||||
inner: Arc<Mutex<gpu_allocator::d3d12::Allocator>>,
|
||||
device_memblock_size: u64,
|
||||
host_memblock_size: u64,
|
||||
pub memory_budget_thresholds: wgt::MemoryBudgetThresholds,
|
||||
}
|
||||
|
||||
impl Allocator {
|
||||
pub(crate) fn new(
|
||||
raw: &Direct3D12::ID3D12Device,
|
||||
memory_hints: &wgt::MemoryHints,
|
||||
memory_budget_thresholds: wgt::MemoryBudgetThresholds,
|
||||
) -> Result<Self, crate::DeviceError> {
|
||||
let allocation_sizes = AllocationSizes::from_memory_hints(memory_hints);
|
||||
let device_memblock_size = allocation_sizes.min_device_memblock_size;
|
||||
let host_memblock_size = allocation_sizes.min_host_memblock_size;
|
||||
|
||||
let allocator_desc = gpu_allocator::d3d12::AllocatorCreateDesc {
|
||||
device: gpu_allocator::d3d12::ID3D12DeviceVersion::Device(raw.clone()),
|
||||
debug_settings: Default::default(),
|
||||
allocation_sizes: allocation_sizes.into(),
|
||||
};
|
||||
|
||||
let allocator = gpu_allocator::d3d12::Allocator::new(&allocator_desc).inspect_err(|e| {
|
||||
log::error!("Failed to create d3d12 allocator, error: {e}");
|
||||
})?;
|
||||
|
||||
Ok(Self {
|
||||
inner: Arc::new(Mutex::new(allocator)),
|
||||
device_memblock_size,
|
||||
host_memblock_size,
|
||||
memory_budget_thresholds,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn generate_report(&self) -> wgt::AllocatorReport {
|
||||
let mut upstream = self.inner.lock().generate_report();
|
||||
|
||||
let allocations = upstream
|
||||
.allocations
|
||||
.iter_mut()
|
||||
.map(|alloc| wgt::AllocationReport {
|
||||
name: core::mem::take(&mut alloc.name),
|
||||
offset: alloc.offset,
|
||||
size: alloc.size,
|
||||
})
|
||||
.collect();
|
||||
|
||||
let blocks = upstream
|
||||
.blocks
|
||||
.iter()
|
||||
.map(|block| wgt::MemoryBlockReport {
|
||||
size: block.size,
|
||||
allocations: block.allocations.clone(),
|
||||
})
|
||||
.collect();
|
||||
|
||||
wgt::AllocatorReport {
|
||||
allocations,
|
||||
blocks,
|
||||
total_allocated_bytes: upstream.total_allocated_bytes,
|
||||
total_reserved_bytes: upstream.total_capacity_bytes,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// To allow us to construct buffers from both a `Device` and `CommandEncoder`
|
||||
/// without needing each function to take a million arguments, we create a
|
||||
/// borrowed context struct that contains the relevant members.
|
||||
pub(crate) struct DeviceAllocationContext<'a> {
|
||||
pub(crate) raw: &'a Direct3D12::ID3D12Device,
|
||||
pub(crate) shared: &'a super::DeviceShared,
|
||||
pub(crate) mem_allocator: &'a Allocator,
|
||||
pub(crate) counters: &'a wgt::HalCounters,
|
||||
}
|
||||
|
||||
impl<'a> From<&'a super::Device> for DeviceAllocationContext<'a> {
|
||||
fn from(device: &'a super::Device) -> Self {
|
||||
Self {
|
||||
raw: &device.raw,
|
||||
shared: &device.shared,
|
||||
mem_allocator: &device.mem_allocator,
|
||||
counters: &device.counters,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a super::CommandEncoder> for DeviceAllocationContext<'a> {
|
||||
fn from(encoder: &'a super::CommandEncoder) -> Self {
|
||||
Self {
|
||||
raw: &encoder.device,
|
||||
shared: &encoder.shared,
|
||||
mem_allocator: &encoder.mem_allocator,
|
||||
counters: &encoder.counters,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> DeviceAllocationContext<'a> {
|
||||
///////////////////////
|
||||
// Resource Creation //
|
||||
///////////////////////
|
||||
|
||||
pub(crate) fn create_buffer(
|
||||
&self,
|
||||
desc: &crate::BufferDescriptor,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let is_cpu_read = desc.usage.contains(wgt::BufferUses::MAP_READ);
|
||||
let is_cpu_write = desc.usage.contains(wgt::BufferUses::MAP_WRITE);
|
||||
|
||||
let location = match (is_cpu_read, is_cpu_write) {
|
||||
(true, true) => MemoryLocation::CpuToGpu,
|
||||
(true, false) => MemoryLocation::GpuToCpu,
|
||||
(false, true) => MemoryLocation::CpuToGpu,
|
||||
(false, false) => MemoryLocation::GpuOnly,
|
||||
};
|
||||
|
||||
let raw_desc = conv::map_buffer_descriptor(desc);
|
||||
let allocation_info =
|
||||
self.error_if_would_oom_on_resource_allocation(&raw_desc, location)?;
|
||||
|
||||
let (resource, allocation) = if self.shared.private_caps.suballocation_supported {
|
||||
self.create_placed_buffer(desc, raw_desc, allocation_info, location)?
|
||||
} else {
|
||||
self.create_committed_buffer(raw_desc, location)?
|
||||
};
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
resource.set_name(label)?;
|
||||
}
|
||||
|
||||
self.counters.buffer_memory.add(allocation.size() as isize);
|
||||
|
||||
Ok((resource, allocation))
|
||||
}
|
||||
|
||||
pub(crate) fn create_texture(
|
||||
&self,
|
||||
desc: &crate::TextureDescriptor,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let location = MemoryLocation::GpuOnly;
|
||||
let allocation_info =
|
||||
self.error_if_would_oom_on_resource_allocation(&raw_desc, location)?;
|
||||
|
||||
let (resource, allocation) = if self.shared.private_caps.suballocation_supported {
|
||||
self.create_placed_texture(desc, raw_desc, allocation_info, location)?
|
||||
} else {
|
||||
self.create_committed_texture(desc, raw_desc)?
|
||||
};
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
resource.set_name(label)?;
|
||||
}
|
||||
|
||||
self.counters.texture_memory.add(allocation.size() as isize);
|
||||
|
||||
Ok((resource, allocation))
|
||||
}
|
||||
|
||||
pub(crate) fn create_acceleration_structure(
|
||||
&self,
|
||||
desc: &crate::AccelerationStructureDescriptor,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let location = MemoryLocation::GpuOnly;
|
||||
let allocation_info =
|
||||
self.error_if_would_oom_on_resource_allocation(&raw_desc, location)?;
|
||||
|
||||
let (resource, allocation) = if self.shared.private_caps.suballocation_supported {
|
||||
self.create_placed_acceleration_structure(desc, raw_desc, allocation_info, location)?
|
||||
} else {
|
||||
self.create_committed_acceleration_structure(desc, raw_desc)?
|
||||
};
|
||||
|
||||
if let Some(label) = desc.label {
|
||||
resource.set_name(label)?;
|
||||
}
|
||||
|
||||
self.counters
|
||||
.acceleration_structure_memory
|
||||
.add(allocation.size() as isize);
|
||||
|
||||
Ok((resource, allocation))
|
||||
}
|
||||
|
||||
//////////////////////////
|
||||
// Resource Destruction //
|
||||
//////////////////////////
|
||||
|
||||
pub(crate) fn free_resource(
|
||||
&self,
|
||||
resource: Direct3D12::ID3D12Resource,
|
||||
allocation: Allocation,
|
||||
) {
|
||||
// Make sure the resource is released before we free the allocation.
|
||||
drop(resource);
|
||||
|
||||
let counter = match allocation.ty {
|
||||
AllocationType::Buffer => &self.counters.buffer_memory,
|
||||
AllocationType::Texture => &self.counters.texture_memory,
|
||||
AllocationType::AccelerationStructure => &self.counters.acceleration_structure_memory,
|
||||
};
|
||||
counter.sub(allocation.size() as isize);
|
||||
|
||||
if let AllocationInner::Placed { inner } = allocation.inner {
|
||||
match self.mem_allocator.inner.lock().free(inner) {
|
||||
Ok(_) => (),
|
||||
// TODO: Don't panic here
|
||||
Err(e) => panic!("Failed to destroy dx12 {:?}, {e}", allocation.ty),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////
|
||||
// Placed Resource Creation ///
|
||||
///////////////////////////////
|
||||
|
||||
fn create_placed_buffer(
|
||||
&self,
|
||||
desc: &crate::BufferDescriptor<'_>,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
allocation_info: Direct3D12::D3D12_RESOURCE_ALLOCATION_INFO,
|
||||
location: MemoryLocation,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let name = desc.label.unwrap_or("Unlabeled buffer");
|
||||
|
||||
let mut allocator = self.mem_allocator.inner.lock();
|
||||
|
||||
let allocation_desc = AllocationCreateDesc {
|
||||
name,
|
||||
location,
|
||||
size: allocation_info.SizeInBytes,
|
||||
alignment: allocation_info.Alignment,
|
||||
resource_category: gpu_allocator::d3d12::ResourceCategory::from(&raw_desc),
|
||||
};
|
||||
|
||||
let allocation = allocator.allocate(&allocation_desc)?;
|
||||
let mut resource = None;
|
||||
unsafe {
|
||||
self.raw.CreatePlacedResource(
|
||||
allocation.heap(),
|
||||
allocation.offset(),
|
||||
&raw_desc,
|
||||
Direct3D12::D3D12_RESOURCE_STATE_COMMON,
|
||||
None,
|
||||
&mut resource,
|
||||
)
|
||||
}
|
||||
.into_device_result("Placed buffer creation")?;
|
||||
|
||||
let resource = resource.ok_or(crate::DeviceError::Unexpected)?;
|
||||
let wrapped_allocation = Allocation::placed(allocation, AllocationType::Buffer);
|
||||
|
||||
Ok((resource, wrapped_allocation))
|
||||
}
|
||||
|
||||
fn create_placed_texture(
|
||||
&self,
|
||||
desc: &crate::TextureDescriptor<'_>,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
allocation_info: Direct3D12::D3D12_RESOURCE_ALLOCATION_INFO,
|
||||
location: MemoryLocation,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let name = desc.label.unwrap_or("Unlabeled texture");
|
||||
|
||||
let mut allocator = self.mem_allocator.inner.lock();
|
||||
|
||||
let allocation_desc = AllocationCreateDesc {
|
||||
name,
|
||||
location,
|
||||
size: allocation_info.SizeInBytes,
|
||||
alignment: allocation_info.Alignment,
|
||||
resource_category: gpu_allocator::d3d12::ResourceCategory::from(&raw_desc),
|
||||
};
|
||||
|
||||
let allocation = allocator.allocate(&allocation_desc)?;
|
||||
let mut resource = None;
|
||||
unsafe {
|
||||
self.raw.CreatePlacedResource(
|
||||
allocation.heap(),
|
||||
allocation.offset(),
|
||||
&raw_desc,
|
||||
Direct3D12::D3D12_RESOURCE_STATE_COMMON,
|
||||
None, // clear value
|
||||
&mut resource,
|
||||
)
|
||||
}
|
||||
.into_device_result("Placed texture creation")?;
|
||||
|
||||
let resource = resource.ok_or(crate::DeviceError::Unexpected)?;
|
||||
let wrapped_allocation = Allocation::placed(allocation, AllocationType::Texture);
|
||||
|
||||
Ok((resource, wrapped_allocation))
|
||||
}
|
||||
|
||||
fn create_placed_acceleration_structure(
|
||||
&self,
|
||||
desc: &crate::AccelerationStructureDescriptor<'_>,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
allocation_info: Direct3D12::D3D12_RESOURCE_ALLOCATION_INFO,
|
||||
location: MemoryLocation,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let name = desc.label.unwrap_or("Unlabeled acceleration structure");
|
||||
|
||||
let mut allocator = self.mem_allocator.inner.lock();
|
||||
|
||||
let allocation_desc = AllocationCreateDesc {
|
||||
name,
|
||||
location,
|
||||
size: allocation_info.SizeInBytes,
|
||||
alignment: allocation_info.Alignment,
|
||||
resource_category: gpu_allocator::d3d12::ResourceCategory::from(&raw_desc),
|
||||
};
|
||||
|
||||
let allocation = allocator.allocate(&allocation_desc)?;
|
||||
let mut resource = None;
|
||||
unsafe {
|
||||
self.raw.CreatePlacedResource(
|
||||
allocation.heap(),
|
||||
allocation.offset(),
|
||||
&raw_desc,
|
||||
Direct3D12::D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE,
|
||||
None,
|
||||
&mut resource,
|
||||
)
|
||||
}
|
||||
.into_device_result("Placed acceleration structure creation")?;
|
||||
|
||||
let resource = resource.ok_or(crate::DeviceError::Unexpected)?;
|
||||
let wrapped_allocation =
|
||||
Allocation::placed(allocation, AllocationType::AccelerationStructure);
|
||||
|
||||
Ok((resource, wrapped_allocation))
|
||||
}
|
||||
|
||||
/////////////////////////////////
|
||||
// Committed Resource Creation //
|
||||
/////////////////////////////////
|
||||
|
||||
fn create_committed_buffer(
|
||||
&self,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
location: MemoryLocation,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let is_uma = matches!(
|
||||
self.shared.private_caps.memory_architecture,
|
||||
crate::dx12::MemoryArchitecture::Unified { .. }
|
||||
);
|
||||
|
||||
let heap_properties = Direct3D12::D3D12_HEAP_PROPERTIES {
|
||||
Type: Direct3D12::D3D12_HEAP_TYPE_CUSTOM,
|
||||
CPUPageProperty: match location {
|
||||
MemoryLocation::GpuOnly => Direct3D12::D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE,
|
||||
MemoryLocation::CpuToGpu => Direct3D12::D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE,
|
||||
MemoryLocation::GpuToCpu => Direct3D12::D3D12_CPU_PAGE_PROPERTY_WRITE_BACK,
|
||||
_ => unreachable!(),
|
||||
},
|
||||
MemoryPoolPreference: match (is_uma, location) {
|
||||
// On dedicated GPUs, we only use L1 for GPU-only allocations.
|
||||
(false, MemoryLocation::GpuOnly) => Direct3D12::D3D12_MEMORY_POOL_L1,
|
||||
(_, _) => Direct3D12::D3D12_MEMORY_POOL_L0,
|
||||
},
|
||||
CreationNodeMask: 0,
|
||||
VisibleNodeMask: 0,
|
||||
};
|
||||
|
||||
let mut resource = None;
|
||||
|
||||
unsafe {
|
||||
self.raw.CreateCommittedResource(
|
||||
&heap_properties,
|
||||
if self.shared.private_caps.heap_create_not_zeroed {
|
||||
Direct3D12::D3D12_HEAP_FLAG_CREATE_NOT_ZEROED
|
||||
} else {
|
||||
Direct3D12::D3D12_HEAP_FLAG_NONE
|
||||
},
|
||||
&raw_desc,
|
||||
Direct3D12::D3D12_RESOURCE_STATE_COMMON,
|
||||
None,
|
||||
&mut resource,
|
||||
)
|
||||
}
|
||||
.into_device_result("Committed buffer creation")?;
|
||||
|
||||
let resource = resource.ok_or(crate::DeviceError::Unexpected)?;
|
||||
let wrapped_allocation = Allocation::none(AllocationType::Buffer, raw_desc.Width);
|
||||
|
||||
Ok((resource, wrapped_allocation))
|
||||
}
|
||||
|
||||
fn create_committed_texture(
|
||||
&self,
|
||||
desc: &crate::TextureDescriptor,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let heap_properties = Direct3D12::D3D12_HEAP_PROPERTIES {
|
||||
Type: Direct3D12::D3D12_HEAP_TYPE_CUSTOM,
|
||||
CPUPageProperty: Direct3D12::D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE,
|
||||
MemoryPoolPreference: match self.shared.private_caps.memory_architecture {
|
||||
crate::dx12::MemoryArchitecture::NonUnified => Direct3D12::D3D12_MEMORY_POOL_L1,
|
||||
crate::dx12::MemoryArchitecture::Unified { .. } => Direct3D12::D3D12_MEMORY_POOL_L0,
|
||||
},
|
||||
CreationNodeMask: 0,
|
||||
VisibleNodeMask: 0,
|
||||
};
|
||||
|
||||
let mut resource = None;
|
||||
|
||||
unsafe {
|
||||
self.raw.CreateCommittedResource(
|
||||
&heap_properties,
|
||||
if self.shared.private_caps.heap_create_not_zeroed {
|
||||
Direct3D12::D3D12_HEAP_FLAG_CREATE_NOT_ZEROED
|
||||
} else {
|
||||
Direct3D12::D3D12_HEAP_FLAG_NONE
|
||||
},
|
||||
&raw_desc,
|
||||
Direct3D12::D3D12_RESOURCE_STATE_COMMON,
|
||||
None, // clear value
|
||||
&mut resource,
|
||||
)
|
||||
}
|
||||
.into_device_result("Committed texture creation")?;
|
||||
|
||||
let resource = resource.ok_or(crate::DeviceError::Unexpected)?;
|
||||
let wrapped_allocation = Allocation::none(
|
||||
AllocationType::Texture,
|
||||
desc.format.theoretical_memory_footprint(desc.size),
|
||||
);
|
||||
|
||||
Ok((resource, wrapped_allocation))
|
||||
}
|
||||
|
||||
fn create_committed_acceleration_structure(
|
||||
&self,
|
||||
desc: &crate::AccelerationStructureDescriptor,
|
||||
raw_desc: Direct3D12::D3D12_RESOURCE_DESC,
|
||||
) -> Result<(Direct3D12::ID3D12Resource, Allocation), crate::DeviceError> {
|
||||
let heap_properties = Direct3D12::D3D12_HEAP_PROPERTIES {
|
||||
Type: Direct3D12::D3D12_HEAP_TYPE_CUSTOM,
|
||||
CPUPageProperty: Direct3D12::D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE,
|
||||
MemoryPoolPreference: match self.shared.private_caps.memory_architecture {
|
||||
crate::dx12::MemoryArchitecture::NonUnified => Direct3D12::D3D12_MEMORY_POOL_L1,
|
||||
crate::dx12::MemoryArchitecture::Unified { .. } => Direct3D12::D3D12_MEMORY_POOL_L0,
|
||||
},
|
||||
CreationNodeMask: 0,
|
||||
VisibleNodeMask: 0,
|
||||
};
|
||||
|
||||
let mut resource = None;
|
||||
|
||||
unsafe {
|
||||
self.raw.CreateCommittedResource(
|
||||
&heap_properties,
|
||||
if self.shared.private_caps.heap_create_not_zeroed {
|
||||
Direct3D12::D3D12_HEAP_FLAG_CREATE_NOT_ZEROED
|
||||
} else {
|
||||
Direct3D12::D3D12_HEAP_FLAG_NONE
|
||||
},
|
||||
&raw_desc,
|
||||
Direct3D12::D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE,
|
||||
None,
|
||||
&mut resource,
|
||||
)
|
||||
}
|
||||
.into_device_result("Committed acceleration structure creation")?;
|
||||
|
||||
let resource = resource.ok_or(crate::DeviceError::Unexpected)?;
|
||||
let wrapped_allocation = Allocation::none(AllocationType::AccelerationStructure, desc.size);
|
||||
|
||||
Ok((resource, wrapped_allocation))
|
||||
}
|
||||
|
||||
fn error_if_would_oom_on_resource_allocation(
|
||||
&self,
|
||||
desc: &Direct3D12::D3D12_RESOURCE_DESC,
|
||||
location: MemoryLocation,
|
||||
) -> Result<Direct3D12::D3D12_RESOURCE_ALLOCATION_INFO, crate::DeviceError> {
|
||||
let allocation_info = unsafe {
|
||||
self.raw
|
||||
.GetResourceAllocationInfo(0, core::slice::from_ref(desc))
|
||||
};
|
||||
|
||||
// Some versions of WARP return SizeInBytes == 0 for very large
|
||||
// allocations. Proceeding to attempt to allocate a zero-sized resource
|
||||
// will result in a device lost error, so it seems preferable to return
|
||||
// an out of memory error now.
|
||||
if allocation_info.SizeInBytes == 0 {
|
||||
return Err(crate::DeviceError::OutOfMemory);
|
||||
}
|
||||
|
||||
let Some(threshold) = self
|
||||
.mem_allocator
|
||||
.memory_budget_thresholds
|
||||
.for_resource_creation
|
||||
else {
|
||||
return Ok(allocation_info);
|
||||
};
|
||||
|
||||
let memory_segment_group = match location {
|
||||
MemoryLocation::Unknown => unreachable!(),
|
||||
MemoryLocation::GpuOnly => Dxgi::DXGI_MEMORY_SEGMENT_GROUP_LOCAL,
|
||||
MemoryLocation::CpuToGpu | MemoryLocation::GpuToCpu => {
|
||||
match self.shared.private_caps.memory_architecture {
|
||||
super::MemoryArchitecture::Unified { .. } => {
|
||||
Dxgi::DXGI_MEMORY_SEGMENT_GROUP_LOCAL
|
||||
}
|
||||
super::MemoryArchitecture::NonUnified => {
|
||||
Dxgi::DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let info = self
|
||||
.shared
|
||||
.adapter
|
||||
.query_video_memory_info(memory_segment_group)?;
|
||||
|
||||
let memblock_size = match location {
|
||||
MemoryLocation::Unknown => unreachable!(),
|
||||
MemoryLocation::GpuOnly => self.mem_allocator.device_memblock_size,
|
||||
MemoryLocation::CpuToGpu | MemoryLocation::GpuToCpu => {
|
||||
self.mem_allocator.host_memblock_size
|
||||
}
|
||||
};
|
||||
|
||||
if info
|
||||
.CurrentUsage
|
||||
.checked_add(allocation_info.SizeInBytes.max(memblock_size))
|
||||
.is_none_or(|usage| usage >= info.Budget / 100 * threshold as u64)
|
||||
{
|
||||
return Err(crate::DeviceError::OutOfMemory);
|
||||
}
|
||||
|
||||
Ok(allocation_info)
|
||||
}
|
||||
}
|
||||
Vendored
+39
@@ -0,0 +1,39 @@
|
||||
#![allow(non_camel_case_types)]
|
||||
#![allow(non_snake_case)]
|
||||
|
||||
use windows::Win32::Graphics::Dxgi;
|
||||
|
||||
windows_core::imp::define_interface!(
|
||||
ISwapChainPanelNative,
|
||||
ISwapChainPanelNative_Vtbl,
|
||||
0x63aad0b8_7c24_40ff_85a8_640d944cc325
|
||||
);
|
||||
impl core::ops::Deref for ISwapChainPanelNative {
|
||||
type Target = windows_core::IUnknown;
|
||||
fn deref(&self) -> &Self::Target {
|
||||
unsafe { core::mem::transmute(self) }
|
||||
}
|
||||
}
|
||||
windows_core::imp::interface_hierarchy!(ISwapChainPanelNative, windows_core::IUnknown);
|
||||
impl ISwapChainPanelNative {
|
||||
pub unsafe fn SetSwapChain<P0>(&self, swap_chain: P0) -> windows_core::Result<()>
|
||||
where
|
||||
P0: windows_core::Param<Dxgi::IDXGISwapChain1>,
|
||||
{
|
||||
unsafe {
|
||||
(windows_core::Interface::vtable(self).SetSwapChain)(
|
||||
windows_core::Interface::as_raw(self),
|
||||
swap_chain.param().abi(),
|
||||
)
|
||||
}
|
||||
.ok()
|
||||
}
|
||||
}
|
||||
#[repr(C)]
|
||||
pub struct ISwapChainPanelNative_Vtbl {
|
||||
pub base__: windows_core::IUnknown_Vtbl,
|
||||
pub SetSwapChain: unsafe extern "system" fn(
|
||||
swap_chain_panel_native: *mut core::ffi::c_void,
|
||||
swap_chain: *mut core::ffi::c_void,
|
||||
) -> windows_core::HRESULT,
|
||||
}
|
||||
Vendored
+370
@@ -0,0 +1,370 @@
|
||||
use windows::Win32::Graphics::{Direct3D12, Dxgi};
|
||||
|
||||
use crate::auxil;
|
||||
|
||||
pub(super) struct ViewDescriptor {
|
||||
dimension: wgt::TextureViewDimension,
|
||||
pub aspects: crate::FormatAspects,
|
||||
pub rtv_dsv_format: Dxgi::Common::DXGI_FORMAT,
|
||||
srv_uav_format: Option<Dxgi::Common::DXGI_FORMAT>,
|
||||
multisampled: bool,
|
||||
array_layer_base: u32,
|
||||
array_layer_count: u32,
|
||||
mip_level_base: u32,
|
||||
mip_level_count: u32,
|
||||
plane_slice_override: Option<u32>,
|
||||
}
|
||||
|
||||
impl crate::TextureViewDescriptor<'_> {
|
||||
pub(super) fn to_internal(&self, texture: &super::Texture) -> ViewDescriptor {
|
||||
let aspects = crate::FormatAspects::new(texture.format, self.range.aspect);
|
||||
|
||||
ViewDescriptor {
|
||||
dimension: self.dimension,
|
||||
aspects,
|
||||
rtv_dsv_format: auxil::dxgi::conv::map_texture_format(self.format),
|
||||
srv_uav_format: auxil::dxgi::conv::map_texture_format_for_srv_uav(self.format, aspects),
|
||||
multisampled: texture.sample_count > 1,
|
||||
mip_level_base: self.range.base_mip_level,
|
||||
mip_level_count: self.range.mip_level_count.unwrap_or(!0),
|
||||
array_layer_base: self.range.base_array_layer,
|
||||
array_layer_count: self.range.array_layer_count.unwrap_or(!0),
|
||||
plane_slice_override: texture.plane_slice_override(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn aspects_to_plane(aspects: crate::FormatAspects) -> u32 {
|
||||
match aspects {
|
||||
crate::FormatAspects::STENCIL => 1,
|
||||
crate::FormatAspects::PLANE_1 => 1,
|
||||
crate::FormatAspects::PLANE_2 => 2,
|
||||
_ => 0,
|
||||
}
|
||||
}
|
||||
|
||||
impl ViewDescriptor {
|
||||
pub(super) fn plane_slice(&self) -> u32 {
|
||||
self.plane_slice_override
|
||||
.unwrap_or_else(|| aspects_to_plane(self.aspects))
|
||||
}
|
||||
}
|
||||
|
||||
/// Shader component mapping for stencil views
|
||||
///
|
||||
/// Stencil views use `DXGI_FORMAT_X24_TYPELESS_G8_UINT` or
|
||||
/// `DXGI_FORMAT_X32_TYPELESS_G8X24_UINT`, which have the stencil value in
|
||||
/// the green component. WebGPU specifies that the stencil value be in the
|
||||
/// red component. It also specifies that the remaining components _should_
|
||||
/// be (0, 0, 1), but may have an unspecified value.
|
||||
const STENCIL_COMPONENT_MAPPING: Direct3D12::D3D12_SHADER_COMPONENT_MAPPING =
|
||||
super::conv::make_shader_component_mapping(
|
||||
Direct3D12::D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1,
|
||||
Direct3D12::D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0,
|
||||
Direct3D12::D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0,
|
||||
Direct3D12::D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1,
|
||||
);
|
||||
|
||||
impl ViewDescriptor {
|
||||
pub(crate) unsafe fn to_srv(&self) -> Option<Direct3D12::D3D12_SHADER_RESOURCE_VIEW_DESC> {
|
||||
let swizzle = if self.aspects == crate::FormatAspects::STENCIL {
|
||||
STENCIL_COMPONENT_MAPPING.0 as u32
|
||||
} else {
|
||||
Direct3D12::D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING
|
||||
};
|
||||
|
||||
let mut desc = Direct3D12::D3D12_SHADER_RESOURCE_VIEW_DESC {
|
||||
Format: self.srv_uav_format?,
|
||||
ViewDimension: Direct3D12::D3D12_SRV_DIMENSION_UNKNOWN,
|
||||
Shader4ComponentMapping: swizzle,
|
||||
Anonymous: Default::default(),
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURE1D;
|
||||
desc.Anonymous.Texture1D = Direct3D12::D3D12_TEX1D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
/*
|
||||
wgt::TextureViewDimension::D1Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
|
||||
desc.Anonymous.Texture1DArray = Direct3D12::D3D12_TEX1D_ARRAY_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
*/
|
||||
wgt::TextureViewDimension::D2 if self.multisampled && self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURE2DMS;
|
||||
desc.Anonymous.Texture2DMS = Direct3D12::D3D12_TEX2DMS_SRV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURE2D;
|
||||
desc.Anonymous.Texture2D = Direct3D12::D3D12_TEX2D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
PlaneSlice: self.plane_slice(),
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array
|
||||
if self.multisampled =>
|
||||
{
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY;
|
||||
desc.Anonymous.Texture2DMSArray = Direct3D12::D3D12_TEX2DMS_ARRAY_SRV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
|
||||
desc.Anonymous.Texture2DArray = Direct3D12::D3D12_TEX2D_ARRAY_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: self.plane_slice(),
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURE3D;
|
||||
desc.Anonymous.Texture3D = Direct3D12::D3D12_TEX3D_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::Cube if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURECUBE;
|
||||
desc.Anonymous.TextureCube = Direct3D12::D3D12_TEXCUBE_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::Cube | wgt::TextureViewDimension::CubeArray => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
|
||||
desc.Anonymous.TextureCubeArray = Direct3D12::D3D12_TEXCUBE_ARRAY_SRV {
|
||||
MostDetailedMip: self.mip_level_base,
|
||||
MipLevels: self.mip_level_count,
|
||||
First2DArrayFace: self.array_layer_base,
|
||||
NumCubes: if self.array_layer_count == !0 {
|
||||
!0
|
||||
} else {
|
||||
self.array_layer_count / 6
|
||||
},
|
||||
ResourceMinLODClamp: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Some(desc)
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn to_uav(&self) -> Option<Direct3D12::D3D12_UNORDERED_ACCESS_VIEW_DESC> {
|
||||
let mut desc = Direct3D12::D3D12_UNORDERED_ACCESS_VIEW_DESC {
|
||||
Format: self.srv_uav_format?,
|
||||
ViewDimension: Direct3D12::D3D12_UAV_DIMENSION_UNKNOWN,
|
||||
Anonymous: Default::default(),
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_UAV_DIMENSION_TEXTURE1D;
|
||||
desc.Anonymous.Texture1D = Direct3D12::D3D12_TEX1D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
/*
|
||||
wgt::TextureViewDimension::D1Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_UAV_DIMENSION_TEXTURE1DARRAY;
|
||||
desc.Anonymous.Texture1DArray = Direct3D12::D3D12_TEX1D_ARRAY_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize,
|
||||
}
|
||||
}*/
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_UAV_DIMENSION_TEXTURE2D;
|
||||
desc.Anonymous.Texture2D = Direct3D12::D3D12_TEX2D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
PlaneSlice: self.plane_slice(),
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
|
||||
desc.Anonymous.Texture2DArray = Direct3D12::D3D12_TEX2D_ARRAY_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: self.plane_slice(),
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_UAV_DIMENSION_TEXTURE3D;
|
||||
desc.Anonymous.Texture3D = Direct3D12::D3D12_TEX3D_UAV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstWSlice: 0,
|
||||
WSize: u32::MAX,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::Cube | wgt::TextureViewDimension::CubeArray => {
|
||||
panic!("Unable to view texture as cube UAV")
|
||||
}
|
||||
}
|
||||
|
||||
Some(desc)
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn to_rtv(&self) -> Direct3D12::D3D12_RENDER_TARGET_VIEW_DESC {
|
||||
let mut desc = Direct3D12::D3D12_RENDER_TARGET_VIEW_DESC {
|
||||
Format: self.rtv_dsv_format,
|
||||
ViewDimension: Direct3D12::D3D12_RTV_DIMENSION_UNKNOWN,
|
||||
Anonymous: Default::default(),
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_RTV_DIMENSION_TEXTURE1D;
|
||||
desc.Anonymous.Texture1D = Direct3D12::D3D12_TEX1D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
/*
|
||||
wgt::TextureViewDimension::D1Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_RTV_DIMENSION_TEXTURE1DARRAY;
|
||||
desc.Anonymous.Texture1DArray = Direct3D12::D3D12_TEX1D_ARRAY_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize,
|
||||
}
|
||||
}*/
|
||||
wgt::TextureViewDimension::D2 if self.multisampled && self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_RTV_DIMENSION_TEXTURE2DMS;
|
||||
desc.Anonymous.Texture2DMS = Direct3D12::D3D12_TEX2DMS_RTV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_RTV_DIMENSION_TEXTURE2D;
|
||||
desc.Anonymous.Texture2D = Direct3D12::D3D12_TEX2D_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
PlaneSlice: self.plane_slice(),
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array
|
||||
if self.multisampled =>
|
||||
{
|
||||
desc.ViewDimension = Direct3D12::D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY;
|
||||
desc.Anonymous.Texture2DMSArray = Direct3D12::D3D12_TEX2DMS_ARRAY_RTV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
|
||||
desc.Anonymous.Texture2DArray = Direct3D12::D3D12_TEX2D_ARRAY_RTV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
PlaneSlice: self.plane_slice(),
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3
|
||||
| wgt::TextureViewDimension::Cube
|
||||
| wgt::TextureViewDimension::CubeArray => {
|
||||
panic!("Unable to view texture as cube or 3D RTV")
|
||||
}
|
||||
}
|
||||
|
||||
desc
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn to_dsv(
|
||||
&self,
|
||||
read_only: bool,
|
||||
) -> Direct3D12::D3D12_DEPTH_STENCIL_VIEW_DESC {
|
||||
let mut desc = Direct3D12::D3D12_DEPTH_STENCIL_VIEW_DESC {
|
||||
Format: self.rtv_dsv_format,
|
||||
ViewDimension: Direct3D12::D3D12_DSV_DIMENSION_UNKNOWN,
|
||||
Flags: {
|
||||
let mut flags = Direct3D12::D3D12_DSV_FLAG_NONE;
|
||||
if read_only {
|
||||
if self.aspects.contains(crate::FormatAspects::DEPTH) {
|
||||
flags |= Direct3D12::D3D12_DSV_FLAG_READ_ONLY_DEPTH;
|
||||
}
|
||||
if self.aspects.contains(crate::FormatAspects::STENCIL) {
|
||||
flags |= Direct3D12::D3D12_DSV_FLAG_READ_ONLY_STENCIL;
|
||||
}
|
||||
}
|
||||
flags
|
||||
},
|
||||
Anonymous: Default::default(),
|
||||
};
|
||||
|
||||
match self.dimension {
|
||||
wgt::TextureViewDimension::D1 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_DSV_DIMENSION_TEXTURE1D;
|
||||
desc.Anonymous.Texture1D = Direct3D12::D3D12_TEX1D_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
/*
|
||||
wgt::TextureViewDimension::D1Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_DSV_DIMENSION_TEXTURE1DARRAY;
|
||||
desc.Anonymous.Texture1DArray = Direct3D12::D3D12_TEX1D_ARRAY_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize,
|
||||
}
|
||||
}*/
|
||||
wgt::TextureViewDimension::D2 if self.multisampled && self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_DSV_DIMENSION_TEXTURE2DMS;
|
||||
desc.Anonymous.Texture2DMS = Direct3D12::D3D12_TEX2DMS_DSV {
|
||||
UnusedField_NothingToDefine: 0,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 if self.array_layer_base == 0 => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_DSV_DIMENSION_TEXTURE2D;
|
||||
|
||||
desc.Anonymous.Texture2D = Direct3D12::D3D12_TEX2D_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array
|
||||
if self.multisampled =>
|
||||
{
|
||||
desc.ViewDimension = Direct3D12::D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY;
|
||||
desc.Anonymous.Texture2DMSArray = Direct3D12::D3D12_TEX2DMS_ARRAY_DSV {
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D2 | wgt::TextureViewDimension::D2Array => {
|
||||
desc.ViewDimension = Direct3D12::D3D12_DSV_DIMENSION_TEXTURE2DARRAY;
|
||||
desc.Anonymous.Texture2DArray = Direct3D12::D3D12_TEX2D_ARRAY_DSV {
|
||||
MipSlice: self.mip_level_base,
|
||||
FirstArraySlice: self.array_layer_base,
|
||||
ArraySize: self.array_layer_count,
|
||||
}
|
||||
}
|
||||
wgt::TextureViewDimension::D3
|
||||
| wgt::TextureViewDimension::Cube
|
||||
| wgt::TextureViewDimension::CubeArray => {
|
||||
panic!("Unable to view texture as cube or 3D DSV")
|
||||
}
|
||||
}
|
||||
|
||||
desc
|
||||
}
|
||||
}
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
use alloc::boxed::Box;
|
||||
|
||||
use crate::{
|
||||
Adapter, Api, DeviceError, OpenDevice, SurfaceCapabilities, TextureFormatCapabilities,
|
||||
};
|
||||
|
||||
use super::{DynDevice, DynQueue, DynResource, DynResourceExt, DynSurface};
|
||||
|
||||
#[expect(missing_debug_implementations, reason = "dyn")]
|
||||
pub struct DynOpenDevice {
|
||||
pub device: Box<dyn DynDevice>,
|
||||
pub queue: Box<dyn DynQueue>,
|
||||
}
|
||||
|
||||
impl<A: Api> From<OpenDevice<A>> for DynOpenDevice {
|
||||
fn from(open_device: OpenDevice<A>) -> Self {
|
||||
Self {
|
||||
device: Box::new(open_device.device),
|
||||
queue: Box::new(open_device.queue),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait DynAdapter: DynResource {
|
||||
unsafe fn open(
|
||||
&self,
|
||||
features: wgt::Features,
|
||||
limits: &wgt::Limits,
|
||||
memory_hints: &wgt::MemoryHints,
|
||||
) -> Result<DynOpenDevice, DeviceError>;
|
||||
|
||||
unsafe fn texture_format_capabilities(
|
||||
&self,
|
||||
format: wgt::TextureFormat,
|
||||
) -> TextureFormatCapabilities;
|
||||
|
||||
unsafe fn surface_capabilities(&self, surface: &dyn DynSurface) -> Option<SurfaceCapabilities>;
|
||||
|
||||
unsafe fn surface_display_hdr_info(
|
||||
&self,
|
||||
surface: &dyn DynSurface,
|
||||
) -> Option<wgt::DisplayHdrInfo>;
|
||||
|
||||
unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp;
|
||||
|
||||
fn get_ordered_buffer_usages(&self) -> wgt::BufferUses;
|
||||
|
||||
fn get_ordered_texture_usages(&self) -> wgt::TextureUses;
|
||||
}
|
||||
|
||||
impl<A: Adapter + DynResource> DynAdapter for A {
|
||||
unsafe fn open(
|
||||
&self,
|
||||
features: wgt::Features,
|
||||
limits: &wgt::Limits,
|
||||
memory_hints: &wgt::MemoryHints,
|
||||
) -> Result<DynOpenDevice, DeviceError> {
|
||||
unsafe { A::open(self, features, limits, memory_hints) }.map(|open_device| DynOpenDevice {
|
||||
device: Box::new(open_device.device),
|
||||
queue: Box::new(open_device.queue),
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn texture_format_capabilities(
|
||||
&self,
|
||||
format: wgt::TextureFormat,
|
||||
) -> TextureFormatCapabilities {
|
||||
unsafe { A::texture_format_capabilities(self, format) }
|
||||
}
|
||||
|
||||
unsafe fn surface_capabilities(&self, surface: &dyn DynSurface) -> Option<SurfaceCapabilities> {
|
||||
let surface = surface.expect_downcast_ref();
|
||||
unsafe { A::surface_capabilities(self, surface) }
|
||||
}
|
||||
|
||||
unsafe fn surface_display_hdr_info(
|
||||
&self,
|
||||
surface: &dyn DynSurface,
|
||||
) -> Option<wgt::DisplayHdrInfo> {
|
||||
let surface = surface.expect_downcast_ref();
|
||||
unsafe { A::surface_display_hdr_info(self, surface) }
|
||||
}
|
||||
|
||||
unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
|
||||
unsafe { A::get_presentation_timestamp(self) }
|
||||
}
|
||||
|
||||
fn get_ordered_buffer_usages(&self) -> wgt::BufferUses {
|
||||
A::get_ordered_buffer_usages(self)
|
||||
}
|
||||
|
||||
fn get_ordered_texture_usages(&self) -> wgt::TextureUses {
|
||||
A::get_ordered_texture_usages(self)
|
||||
}
|
||||
}
|
||||
+823
@@ -0,0 +1,823 @@
|
||||
use alloc::{boxed::Box, vec::Vec};
|
||||
use core::ops::Range;
|
||||
|
||||
use crate::{
|
||||
AccelerationStructureBarrier, Api, Attachment, BufferBarrier, BufferBinding, BufferCopy,
|
||||
BufferTextureCopy, BuildAccelerationStructureDescriptor, ColorAttachment, CommandEncoder,
|
||||
ComputePassDescriptor, DepthStencilAttachment, DeviceError, DynRayTracingPipeline, Label,
|
||||
MemoryRange, PassTimestampWrites, RayTracingPassDescriptor, Rect, RenderPassDescriptor,
|
||||
TextureBarrier, TextureCopy,
|
||||
};
|
||||
|
||||
use super::{
|
||||
DynAccelerationStructure, DynBindGroup, DynBuffer, DynCommandBuffer, DynComputePipeline,
|
||||
DynPipelineLayout, DynQuerySet, DynRenderPipeline, DynResource, DynResourceExt as _,
|
||||
DynTexture, DynTextureView,
|
||||
};
|
||||
|
||||
pub trait DynCommandEncoder: DynResource + core::fmt::Debug {
|
||||
unsafe fn begin_encoding(&mut self, label: Label) -> Result<(), DeviceError>;
|
||||
|
||||
unsafe fn discard_encoding(&mut self);
|
||||
|
||||
unsafe fn end_encoding(&mut self) -> Result<Box<dyn DynCommandBuffer>, DeviceError>;
|
||||
|
||||
unsafe fn reset_all(&mut self, command_buffers: Vec<Box<dyn DynCommandBuffer>>);
|
||||
|
||||
unsafe fn transition_buffers(&mut self, barriers: &[BufferBarrier<'_, dyn DynBuffer>]);
|
||||
unsafe fn transition_textures(&mut self, barriers: &[TextureBarrier<'_, dyn DynTexture>]);
|
||||
|
||||
unsafe fn clear_buffer(&mut self, buffer: &dyn DynBuffer, range: MemoryRange);
|
||||
|
||||
unsafe fn copy_buffer_to_buffer(
|
||||
&mut self,
|
||||
src: &dyn DynBuffer,
|
||||
dst: &dyn DynBuffer,
|
||||
regions: &[BufferCopy],
|
||||
);
|
||||
|
||||
unsafe fn copy_texture_to_texture(
|
||||
&mut self,
|
||||
src: &dyn DynTexture,
|
||||
src_usage: wgt::TextureUses,
|
||||
dst: &dyn DynTexture,
|
||||
regions: &[TextureCopy],
|
||||
);
|
||||
|
||||
unsafe fn copy_buffer_to_texture(
|
||||
&mut self,
|
||||
src: &dyn DynBuffer,
|
||||
dst: &dyn DynTexture,
|
||||
regions: &[BufferTextureCopy],
|
||||
);
|
||||
|
||||
unsafe fn copy_texture_to_buffer(
|
||||
&mut self,
|
||||
src: &dyn DynTexture,
|
||||
src_usage: wgt::TextureUses,
|
||||
dst: &dyn DynBuffer,
|
||||
regions: &[BufferTextureCopy],
|
||||
);
|
||||
|
||||
unsafe fn set_bind_group(
|
||||
&mut self,
|
||||
layout: &dyn DynPipelineLayout,
|
||||
index: u32,
|
||||
group: &dyn DynBindGroup,
|
||||
dynamic_offsets: &[wgt::DynamicOffset],
|
||||
);
|
||||
|
||||
unsafe fn set_immediates(
|
||||
&mut self,
|
||||
layout: &dyn DynPipelineLayout,
|
||||
offset_bytes: u32,
|
||||
data: &[u32],
|
||||
);
|
||||
|
||||
unsafe fn insert_debug_marker(&mut self, label: &str);
|
||||
unsafe fn begin_debug_marker(&mut self, group_label: &str);
|
||||
unsafe fn end_debug_marker(&mut self);
|
||||
|
||||
unsafe fn begin_query(&mut self, set: &dyn DynQuerySet, index: u32);
|
||||
unsafe fn end_query(&mut self, set: &dyn DynQuerySet, index: u32);
|
||||
unsafe fn write_timestamp(&mut self, set: &dyn DynQuerySet, index: u32);
|
||||
unsafe fn reset_queries(&mut self, set: &dyn DynQuerySet, range: Range<u32>);
|
||||
unsafe fn copy_query_results(
|
||||
&mut self,
|
||||
set: &dyn DynQuerySet,
|
||||
range: Range<u32>,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
stride: wgt::BufferSize,
|
||||
);
|
||||
|
||||
unsafe fn begin_render_pass(
|
||||
&mut self,
|
||||
desc: &RenderPassDescriptor<dyn DynQuerySet, dyn DynTextureView>,
|
||||
) -> Result<(), DeviceError>;
|
||||
unsafe fn end_render_pass(&mut self);
|
||||
|
||||
unsafe fn set_render_pipeline(&mut self, pipeline: &dyn DynRenderPipeline);
|
||||
|
||||
unsafe fn set_index_buffer<'a>(
|
||||
&mut self,
|
||||
binding: BufferBinding<'a, dyn DynBuffer>,
|
||||
format: wgt::IndexFormat,
|
||||
);
|
||||
|
||||
unsafe fn set_vertex_buffer<'a>(
|
||||
&mut self,
|
||||
index: u32,
|
||||
binding: BufferBinding<'a, dyn DynBuffer>,
|
||||
);
|
||||
unsafe fn set_viewport(&mut self, rect: &Rect<f32>, depth_range: Range<f32>);
|
||||
unsafe fn set_scissor_rect(&mut self, rect: &Rect<u32>);
|
||||
unsafe fn set_stencil_reference(&mut self, value: u32);
|
||||
unsafe fn set_blend_constants(&mut self, color: &[f32; 4]);
|
||||
|
||||
unsafe fn draw(
|
||||
&mut self,
|
||||
first_vertex: u32,
|
||||
vertex_count: u32,
|
||||
first_instance: u32,
|
||||
instance_count: u32,
|
||||
);
|
||||
unsafe fn draw_indexed(
|
||||
&mut self,
|
||||
first_index: u32,
|
||||
index_count: u32,
|
||||
base_vertex: i32,
|
||||
first_instance: u32,
|
||||
instance_count: u32,
|
||||
);
|
||||
unsafe fn draw_mesh_tasks(
|
||||
&mut self,
|
||||
group_count_x: u32,
|
||||
group_count_y: u32,
|
||||
group_count_z: u32,
|
||||
);
|
||||
unsafe fn draw_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
);
|
||||
unsafe fn draw_indexed_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
);
|
||||
unsafe fn draw_mesh_tasks_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
);
|
||||
unsafe fn draw_indirect_count(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &dyn DynBuffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
);
|
||||
unsafe fn draw_indexed_indirect_count(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &dyn DynBuffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
);
|
||||
unsafe fn draw_mesh_tasks_indirect_count(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &dyn DynBuffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
);
|
||||
|
||||
unsafe fn begin_compute_pass(&mut self, desc: &ComputePassDescriptor<dyn DynQuerySet>);
|
||||
unsafe fn end_compute_pass(&mut self);
|
||||
|
||||
unsafe fn set_compute_pipeline(&mut self, pipeline: &dyn DynComputePipeline);
|
||||
|
||||
unsafe fn dispatch_workgroups(&mut self, count: [u32; 3]);
|
||||
unsafe fn dispatch_workgroups_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
);
|
||||
|
||||
unsafe fn begin_ray_tracing_pass(&mut self, desc: &RayTracingPassDescriptor);
|
||||
unsafe fn end_ray_tracing_pass(&mut self);
|
||||
|
||||
unsafe fn trace_rays(
|
||||
&mut self,
|
||||
count: [u32; 3],
|
||||
ray_generation_group_data: crate::PipelineGroupData<dyn DynBuffer>,
|
||||
miss_group_data: crate::PipelineGroupData<dyn DynBuffer>,
|
||||
intersection_group_data: crate::PipelineGroupData<dyn DynBuffer>,
|
||||
);
|
||||
|
||||
unsafe fn set_ray_tracing_pipeline(&mut self, pipeline: &dyn DynRayTracingPipeline);
|
||||
|
||||
unsafe fn build_acceleration_structures<'a>(
|
||||
&mut self,
|
||||
descriptors: &'a [BuildAccelerationStructureDescriptor<
|
||||
'a,
|
||||
dyn DynBuffer,
|
||||
dyn DynAccelerationStructure,
|
||||
>],
|
||||
);
|
||||
unsafe fn place_acceleration_structure_barrier(
|
||||
&mut self,
|
||||
barrier: AccelerationStructureBarrier,
|
||||
);
|
||||
unsafe fn copy_acceleration_structure_to_acceleration_structure(
|
||||
&mut self,
|
||||
src: &dyn DynAccelerationStructure,
|
||||
dst: &dyn DynAccelerationStructure,
|
||||
copy: wgt::AccelerationStructureCopy,
|
||||
);
|
||||
unsafe fn read_acceleration_structure_compact_size(
|
||||
&mut self,
|
||||
acceleration_structure: &dyn DynAccelerationStructure,
|
||||
buf: &dyn DynBuffer,
|
||||
);
|
||||
unsafe fn set_acceleration_structure_dependencies(
|
||||
&self,
|
||||
command_buffers: &[Box<dyn DynCommandBuffer>],
|
||||
dependencies: &[&dyn DynAccelerationStructure],
|
||||
);
|
||||
}
|
||||
|
||||
impl<C: CommandEncoder + DynResource> DynCommandEncoder for C {
|
||||
unsafe fn begin_encoding(&mut self, label: Label) -> Result<(), DeviceError> {
|
||||
unsafe { C::begin_encoding(self, label) }
|
||||
}
|
||||
|
||||
unsafe fn discard_encoding(&mut self) {
|
||||
unsafe { C::discard_encoding(self) }
|
||||
}
|
||||
|
||||
unsafe fn end_encoding(&mut self) -> Result<Box<dyn DynCommandBuffer>, DeviceError> {
|
||||
unsafe { C::end_encoding(self) }.map(|cb| {
|
||||
let boxed_command_buffer: Box<<C::A as Api>::CommandBuffer> = Box::new(cb);
|
||||
let boxed_command_buffer: Box<dyn DynCommandBuffer> = boxed_command_buffer;
|
||||
boxed_command_buffer
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn reset_all(&mut self, command_buffers: Vec<Box<dyn DynCommandBuffer>>) {
|
||||
unsafe { C::reset_all(self, command_buffers.into_iter().map(|cb| cb.unbox())) }
|
||||
}
|
||||
|
||||
unsafe fn transition_buffers(&mut self, barriers: &[BufferBarrier<'_, dyn DynBuffer>]) {
|
||||
let barriers = barriers.iter().map(|barrier| BufferBarrier {
|
||||
buffer: barrier.buffer.expect_downcast_ref(),
|
||||
usage: barrier.usage.clone(),
|
||||
});
|
||||
unsafe { self.transition_buffers(barriers) };
|
||||
}
|
||||
|
||||
unsafe fn transition_textures(&mut self, barriers: &[TextureBarrier<'_, dyn DynTexture>]) {
|
||||
let barriers = barriers.iter().map(|barrier| TextureBarrier {
|
||||
texture: barrier.texture.expect_downcast_ref(),
|
||||
usage: barrier.usage.clone(),
|
||||
range: barrier.range,
|
||||
});
|
||||
unsafe { self.transition_textures(barriers) };
|
||||
}
|
||||
|
||||
unsafe fn clear_buffer(&mut self, buffer: &dyn DynBuffer, range: MemoryRange) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { C::clear_buffer(self, buffer, range) };
|
||||
}
|
||||
|
||||
unsafe fn copy_buffer_to_buffer(
|
||||
&mut self,
|
||||
src: &dyn DynBuffer,
|
||||
dst: &dyn DynBuffer,
|
||||
regions: &[BufferCopy],
|
||||
) {
|
||||
let src = src.expect_downcast_ref();
|
||||
let dst = dst.expect_downcast_ref();
|
||||
unsafe {
|
||||
C::copy_buffer_to_buffer(self, src, dst, regions.iter().copied());
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn copy_texture_to_texture(
|
||||
&mut self,
|
||||
src: &dyn DynTexture,
|
||||
src_usage: wgt::TextureUses,
|
||||
dst: &dyn DynTexture,
|
||||
regions: &[TextureCopy],
|
||||
) {
|
||||
let src = src.expect_downcast_ref();
|
||||
let dst = dst.expect_downcast_ref();
|
||||
unsafe {
|
||||
C::copy_texture_to_texture(self, src, src_usage, dst, regions.iter().cloned());
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn copy_buffer_to_texture(
|
||||
&mut self,
|
||||
src: &dyn DynBuffer,
|
||||
dst: &dyn DynTexture,
|
||||
regions: &[BufferTextureCopy],
|
||||
) {
|
||||
let src = src.expect_downcast_ref();
|
||||
let dst = dst.expect_downcast_ref();
|
||||
unsafe {
|
||||
C::copy_buffer_to_texture(self, src, dst, regions.iter().cloned());
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn copy_texture_to_buffer(
|
||||
&mut self,
|
||||
src: &dyn DynTexture,
|
||||
src_usage: wgt::TextureUses,
|
||||
dst: &dyn DynBuffer,
|
||||
regions: &[BufferTextureCopy],
|
||||
) {
|
||||
let src = src.expect_downcast_ref();
|
||||
let dst = dst.expect_downcast_ref();
|
||||
unsafe {
|
||||
C::copy_texture_to_buffer(self, src, src_usage, dst, regions.iter().cloned());
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn set_bind_group(
|
||||
&mut self,
|
||||
layout: &dyn DynPipelineLayout,
|
||||
index: u32,
|
||||
group: &dyn DynBindGroup,
|
||||
dynamic_offsets: &[wgt::DynamicOffset],
|
||||
) {
|
||||
let layout = layout.expect_downcast_ref();
|
||||
let group = group.expect_downcast_ref();
|
||||
unsafe { C::set_bind_group(self, layout, index, group, dynamic_offsets) };
|
||||
}
|
||||
|
||||
unsafe fn set_immediates(
|
||||
&mut self,
|
||||
layout: &dyn DynPipelineLayout,
|
||||
offset_bytes: u32,
|
||||
data: &[u32],
|
||||
) {
|
||||
let layout = layout.expect_downcast_ref();
|
||||
unsafe { C::set_immediates(self, layout, offset_bytes, data) };
|
||||
}
|
||||
|
||||
unsafe fn insert_debug_marker(&mut self, label: &str) {
|
||||
unsafe {
|
||||
C::insert_debug_marker(self, label);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn begin_debug_marker(&mut self, group_label: &str) {
|
||||
unsafe {
|
||||
C::begin_debug_marker(self, group_label);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn end_debug_marker(&mut self) {
|
||||
unsafe {
|
||||
C::end_debug_marker(self);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn begin_query(&mut self, set: &dyn DynQuerySet, index: u32) {
|
||||
let set = set.expect_downcast_ref();
|
||||
unsafe { C::begin_query(self, set, index) };
|
||||
}
|
||||
|
||||
unsafe fn end_query(&mut self, set: &dyn DynQuerySet, index: u32) {
|
||||
let set = set.expect_downcast_ref();
|
||||
unsafe { C::end_query(self, set, index) };
|
||||
}
|
||||
|
||||
unsafe fn write_timestamp(&mut self, set: &dyn DynQuerySet, index: u32) {
|
||||
let set = set.expect_downcast_ref();
|
||||
unsafe { C::write_timestamp(self, set, index) };
|
||||
}
|
||||
|
||||
unsafe fn reset_queries(&mut self, set: &dyn DynQuerySet, range: Range<u32>) {
|
||||
let set = set.expect_downcast_ref();
|
||||
unsafe { C::reset_queries(self, set, range) };
|
||||
}
|
||||
|
||||
unsafe fn copy_query_results(
|
||||
&mut self,
|
||||
set: &dyn DynQuerySet,
|
||||
range: Range<u32>,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
stride: wgt::BufferSize,
|
||||
) {
|
||||
let set = set.expect_downcast_ref();
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { C::copy_query_results(self, set, range, buffer, offset, stride) };
|
||||
}
|
||||
|
||||
unsafe fn begin_render_pass(
|
||||
&mut self,
|
||||
desc: &RenderPassDescriptor<dyn DynQuerySet, dyn DynTextureView>,
|
||||
) -> Result<(), DeviceError> {
|
||||
let color_attachments = desc
|
||||
.color_attachments
|
||||
.iter()
|
||||
.map(|attachment| {
|
||||
attachment
|
||||
.as_ref()
|
||||
.map(|attachment| attachment.expect_downcast())
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let desc: RenderPassDescriptor<<C::A as Api>::QuerySet, <C::A as Api>::TextureView> =
|
||||
RenderPassDescriptor {
|
||||
label: desc.label,
|
||||
extent: desc.extent,
|
||||
sample_count: desc.sample_count,
|
||||
color_attachments: &color_attachments,
|
||||
depth_stencil_attachment: desc
|
||||
.depth_stencil_attachment
|
||||
.as_ref()
|
||||
.map(|ds| ds.expect_downcast()),
|
||||
multiview_mask: desc.multiview_mask,
|
||||
timestamp_writes: desc
|
||||
.timestamp_writes
|
||||
.as_ref()
|
||||
.map(|writes| writes.expect_downcast()),
|
||||
occlusion_query_set: desc
|
||||
.occlusion_query_set
|
||||
.map(|set| set.expect_downcast_ref()),
|
||||
};
|
||||
unsafe { C::begin_render_pass(self, &desc) }
|
||||
}
|
||||
|
||||
unsafe fn end_render_pass(&mut self) {
|
||||
unsafe {
|
||||
C::end_render_pass(self);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn set_viewport(&mut self, rect: &Rect<f32>, depth_range: Range<f32>) {
|
||||
unsafe {
|
||||
C::set_viewport(self, rect, depth_range);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn set_scissor_rect(&mut self, rect: &Rect<u32>) {
|
||||
unsafe {
|
||||
C::set_scissor_rect(self, rect);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn set_stencil_reference(&mut self, value: u32) {
|
||||
unsafe {
|
||||
C::set_stencil_reference(self, value);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn set_blend_constants(&mut self, color: &[f32; 4]) {
|
||||
unsafe { C::set_blend_constants(self, color) };
|
||||
}
|
||||
|
||||
unsafe fn draw(
|
||||
&mut self,
|
||||
first_vertex: u32,
|
||||
vertex_count: u32,
|
||||
first_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
unsafe {
|
||||
C::draw(
|
||||
self,
|
||||
first_vertex,
|
||||
vertex_count,
|
||||
first_instance,
|
||||
instance_count,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn draw_indexed(
|
||||
&mut self,
|
||||
first_index: u32,
|
||||
index_count: u32,
|
||||
base_vertex: i32,
|
||||
first_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
unsafe {
|
||||
C::draw_indexed(
|
||||
self,
|
||||
first_index,
|
||||
index_count,
|
||||
base_vertex,
|
||||
first_instance,
|
||||
instance_count,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn draw_mesh_tasks(
|
||||
&mut self,
|
||||
group_count_x: u32,
|
||||
group_count_y: u32,
|
||||
group_count_z: u32,
|
||||
) {
|
||||
unsafe { C::draw_mesh_tasks(self, group_count_x, group_count_y, group_count_z) };
|
||||
}
|
||||
|
||||
unsafe fn draw_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { C::draw_indirect(self, buffer, offset, draw_count) };
|
||||
}
|
||||
|
||||
unsafe fn draw_indexed_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { C::draw_indexed_indirect(self, buffer, offset, draw_count) };
|
||||
}
|
||||
|
||||
unsafe fn draw_mesh_tasks_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { C::draw_mesh_tasks_indirect(self, buffer, offset, draw_count) };
|
||||
}
|
||||
|
||||
unsafe fn draw_indirect_count(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &dyn DynBuffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
let count_buffer = count_buffer.expect_downcast_ref();
|
||||
unsafe {
|
||||
C::draw_indirect_count(self, buffer, offset, count_buffer, count_offset, max_count)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn draw_indexed_indirect_count(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &dyn DynBuffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
let count_buffer = count_buffer.expect_downcast_ref();
|
||||
unsafe {
|
||||
C::draw_indexed_indirect_count(
|
||||
self,
|
||||
buffer,
|
||||
offset,
|
||||
count_buffer,
|
||||
count_offset,
|
||||
max_count,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn draw_mesh_tasks_indirect_count(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &dyn DynBuffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
let count_buffer = count_buffer.expect_downcast_ref();
|
||||
unsafe {
|
||||
C::draw_mesh_tasks_indirect_count(
|
||||
self,
|
||||
buffer,
|
||||
offset,
|
||||
count_buffer,
|
||||
count_offset,
|
||||
max_count,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
unsafe fn begin_compute_pass(&mut self, desc: &ComputePassDescriptor<dyn DynQuerySet>) {
|
||||
let desc = ComputePassDescriptor {
|
||||
label: desc.label,
|
||||
timestamp_writes: desc
|
||||
.timestamp_writes
|
||||
.as_ref()
|
||||
.map(|writes| writes.expect_downcast()),
|
||||
};
|
||||
unsafe { C::begin_compute_pass(self, &desc) };
|
||||
}
|
||||
|
||||
unsafe fn end_compute_pass(&mut self) {
|
||||
unsafe { C::end_compute_pass(self) };
|
||||
}
|
||||
|
||||
unsafe fn set_compute_pipeline(&mut self, pipeline: &dyn DynComputePipeline) {
|
||||
let pipeline = pipeline.expect_downcast_ref();
|
||||
unsafe { C::set_compute_pipeline(self, pipeline) };
|
||||
}
|
||||
|
||||
unsafe fn dispatch_workgroups(&mut self, count: [u32; 3]) {
|
||||
unsafe { C::dispatch_workgroups(self, count) };
|
||||
}
|
||||
|
||||
unsafe fn dispatch_workgroups_indirect(
|
||||
&mut self,
|
||||
buffer: &dyn DynBuffer,
|
||||
offset: wgt::BufferAddress,
|
||||
) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { C::dispatch_workgroups_indirect(self, buffer, offset) };
|
||||
}
|
||||
|
||||
unsafe fn set_render_pipeline(&mut self, pipeline: &dyn DynRenderPipeline) {
|
||||
let pipeline = pipeline.expect_downcast_ref();
|
||||
unsafe { C::set_render_pipeline(self, pipeline) };
|
||||
}
|
||||
|
||||
unsafe fn set_index_buffer<'a>(
|
||||
&mut self,
|
||||
binding: BufferBinding<'a, dyn DynBuffer>,
|
||||
format: wgt::IndexFormat,
|
||||
) {
|
||||
let binding = binding.expect_downcast();
|
||||
unsafe { self.set_index_buffer(binding, format) };
|
||||
}
|
||||
|
||||
unsafe fn set_vertex_buffer<'a>(
|
||||
&mut self,
|
||||
index: u32,
|
||||
binding: BufferBinding<'a, dyn DynBuffer>,
|
||||
) {
|
||||
let binding = binding.expect_downcast();
|
||||
unsafe { self.set_vertex_buffer(index, binding) };
|
||||
}
|
||||
|
||||
unsafe fn begin_ray_tracing_pass(&mut self, desc: &RayTracingPassDescriptor) {
|
||||
let desc = RayTracingPassDescriptor { label: desc.label };
|
||||
unsafe { C::begin_ray_tracing_pass(self, &desc) };
|
||||
}
|
||||
|
||||
unsafe fn end_ray_tracing_pass(&mut self) {
|
||||
unsafe { C::end_ray_tracing_pass(self) };
|
||||
}
|
||||
|
||||
unsafe fn set_ray_tracing_pipeline(&mut self, pipeline: &dyn DynRayTracingPipeline) {
|
||||
let pipeline = pipeline.expect_downcast_ref();
|
||||
unsafe { C::set_ray_tracing_pipeline(self, pipeline) };
|
||||
}
|
||||
|
||||
unsafe fn trace_rays<'a>(
|
||||
&mut self,
|
||||
count: [u32; 3],
|
||||
ray_generation_group_data: crate::PipelineGroupData<'a, dyn DynBuffer>,
|
||||
miss_group_data: crate::PipelineGroupData<'a, dyn DynBuffer>,
|
||||
intersection_group_data: crate::PipelineGroupData<'a, dyn DynBuffer>,
|
||||
) {
|
||||
let downcast_group_data =
|
||||
|data: crate::PipelineGroupData<'a, dyn DynBuffer>| crate::PipelineGroupData {
|
||||
buffer: data.buffer.expect_downcast_ref(),
|
||||
offset: data.offset,
|
||||
stride: data.stride,
|
||||
count: data.count,
|
||||
};
|
||||
|
||||
unsafe {
|
||||
C::trace_rays(
|
||||
self,
|
||||
count,
|
||||
downcast_group_data(ray_generation_group_data),
|
||||
downcast_group_data(miss_group_data),
|
||||
downcast_group_data(intersection_group_data),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn build_acceleration_structures<'a>(
|
||||
&mut self,
|
||||
descriptors: &'a [BuildAccelerationStructureDescriptor<
|
||||
'a,
|
||||
dyn DynBuffer,
|
||||
dyn DynAccelerationStructure,
|
||||
>],
|
||||
) {
|
||||
// Need to collect entries here so we can reference them in the descriptor.
|
||||
// TODO: API should be redesigned to avoid this and other descriptor copies that happen due to the dyn api.
|
||||
let descriptor_entries = descriptors
|
||||
.iter()
|
||||
.map(|d| d.entries.expect_downcast())
|
||||
.collect::<Vec<_>>();
|
||||
let descriptors = descriptors
|
||||
.iter()
|
||||
.zip(descriptor_entries.iter())
|
||||
.map(|(d, entries)| BuildAccelerationStructureDescriptor::<
|
||||
<C::A as Api>::Buffer,
|
||||
<C::A as Api>::AccelerationStructure,
|
||||
> {
|
||||
entries,
|
||||
mode: d.mode,
|
||||
flags: d.flags,
|
||||
source_acceleration_structure: d
|
||||
.source_acceleration_structure
|
||||
.map(|a| a.expect_downcast_ref()),
|
||||
destination_acceleration_structure: d
|
||||
.destination_acceleration_structure
|
||||
.expect_downcast_ref(),
|
||||
scratch_buffer: d.scratch_buffer.expect_downcast_ref(),
|
||||
scratch_buffer_offset: d.scratch_buffer_offset,
|
||||
});
|
||||
unsafe { C::build_acceleration_structures(self, descriptors.len() as _, descriptors) };
|
||||
}
|
||||
|
||||
unsafe fn place_acceleration_structure_barrier(
|
||||
&mut self,
|
||||
barrier: AccelerationStructureBarrier,
|
||||
) {
|
||||
unsafe { C::place_acceleration_structure_barrier(self, barrier) };
|
||||
}
|
||||
|
||||
unsafe fn copy_acceleration_structure_to_acceleration_structure(
|
||||
&mut self,
|
||||
src: &dyn DynAccelerationStructure,
|
||||
dst: &dyn DynAccelerationStructure,
|
||||
copy: wgt::AccelerationStructureCopy,
|
||||
) {
|
||||
let src = src.expect_downcast_ref();
|
||||
let dst = dst.expect_downcast_ref();
|
||||
unsafe { C::copy_acceleration_structure_to_acceleration_structure(self, src, dst, copy) };
|
||||
}
|
||||
unsafe fn read_acceleration_structure_compact_size(
|
||||
&mut self,
|
||||
acceleration_structure: &dyn DynAccelerationStructure,
|
||||
buf: &dyn DynBuffer,
|
||||
) {
|
||||
let acceleration_structure = acceleration_structure.expect_downcast_ref();
|
||||
let buf = buf.expect_downcast_ref();
|
||||
unsafe { C::read_acceleration_structure_compact_size(self, acceleration_structure, buf) }
|
||||
}
|
||||
|
||||
unsafe fn set_acceleration_structure_dependencies(
|
||||
&self,
|
||||
command_buffers: &[Box<dyn DynCommandBuffer>],
|
||||
dependencies: &[&dyn DynAccelerationStructure],
|
||||
) {
|
||||
let command_buffers: Vec<&<C::A as Api>::CommandBuffer> = command_buffers
|
||||
.iter()
|
||||
.map(|command_buffer| command_buffer.expect_downcast_ref())
|
||||
.collect();
|
||||
let dependencies: Vec<&<C::A as Api>::AccelerationStructure> = dependencies
|
||||
.iter()
|
||||
.map(|dependency| dependency.expect_downcast_ref())
|
||||
.collect();
|
||||
unsafe { C::set_acceleration_structure_dependencies(&command_buffers, &dependencies) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PassTimestampWrites<'a, dyn DynQuerySet> {
|
||||
pub fn expect_downcast<B: DynQuerySet>(&self) -> PassTimestampWrites<'a, B> {
|
||||
PassTimestampWrites {
|
||||
query_set: self.query_set.expect_downcast_ref(),
|
||||
beginning_of_pass_write_index: self.beginning_of_pass_write_index,
|
||||
end_of_pass_write_index: self.end_of_pass_write_index,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Attachment<'a, dyn DynTextureView> {
|
||||
pub fn expect_downcast<B: DynTextureView>(&self) -> Attachment<'a, B> {
|
||||
Attachment {
|
||||
view: self.view.expect_downcast_ref(),
|
||||
usage: self.usage,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ColorAttachment<'a, dyn DynTextureView> {
|
||||
pub fn expect_downcast<B: DynTextureView>(&self) -> ColorAttachment<'a, B> {
|
||||
ColorAttachment {
|
||||
target: self.target.expect_downcast(),
|
||||
depth_slice: self.depth_slice,
|
||||
resolve_target: self.resolve_target.as_ref().map(|rt| rt.expect_downcast()),
|
||||
ops: self.ops,
|
||||
clear_value: self.clear_value,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> DepthStencilAttachment<'a, dyn DynTextureView> {
|
||||
pub fn expect_downcast<B: DynTextureView>(&self) -> DepthStencilAttachment<'a, B> {
|
||||
DepthStencilAttachment {
|
||||
target: self.target.expect_downcast(),
|
||||
depth_ops: self.depth_ops,
|
||||
stencil_ops: self.stencil_ops,
|
||||
clear_value: self.clear_value,
|
||||
}
|
||||
}
|
||||
}
|
||||
+622
@@ -0,0 +1,622 @@
|
||||
use alloc::{borrow::ToOwned as _, boxed::Box, vec::Vec};
|
||||
|
||||
use crate::{
|
||||
AccelerationStructureBuildSizes, AccelerationStructureDescriptor, Api, BindGroupDescriptor,
|
||||
BindGroupLayoutDescriptor, BufferDescriptor, BufferMapping, CommandEncoderDescriptor,
|
||||
ComputePipelineDescriptor, Device, DeviceError, FenceValue,
|
||||
GetAccelerationStructureBuildSizesDescriptor, Label, MemoryRange, PipelineCacheDescriptor,
|
||||
PipelineCacheError, PipelineError, PipelineLayoutDescriptor, RayObjectIntersectionState,
|
||||
RayTracingPipelineDescriptor, RenderPipelineDescriptor, SamplerDescriptor, ShaderError,
|
||||
ShaderInput, ShaderModuleDescriptor, TextureDescriptor, TextureViewDescriptor, TlasInstance,
|
||||
};
|
||||
|
||||
use super::{
|
||||
DynAccelerationStructure, DynBindGroup, DynBindGroupLayout, DynBuffer, DynCommandEncoder,
|
||||
DynComputePipeline, DynFence, DynPipelineCache, DynPipelineLayout, DynQuerySet, DynQueue,
|
||||
DynRayTracingPipeline, DynRenderPipeline, DynResource, DynResourceExt as _, DynSampler,
|
||||
DynShaderModule, DynTexture, DynTextureView,
|
||||
};
|
||||
|
||||
pub trait DynDevice: DynResource {
|
||||
unsafe fn create_buffer(
|
||||
&self,
|
||||
desc: &BufferDescriptor,
|
||||
) -> Result<Box<dyn DynBuffer>, DeviceError>;
|
||||
|
||||
unsafe fn destroy_buffer(&self, buffer: Box<dyn DynBuffer>);
|
||||
unsafe fn add_raw_buffer(&self, buffer: &dyn DynBuffer);
|
||||
|
||||
unsafe fn map_buffer(
|
||||
&self,
|
||||
buffer: &dyn DynBuffer,
|
||||
range: MemoryRange,
|
||||
) -> Result<BufferMapping, DeviceError>;
|
||||
|
||||
unsafe fn unmap_buffer(&self, buffer: &dyn DynBuffer);
|
||||
|
||||
unsafe fn flush_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]);
|
||||
unsafe fn invalidate_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]);
|
||||
|
||||
unsafe fn create_texture(
|
||||
&self,
|
||||
desc: &TextureDescriptor,
|
||||
) -> Result<Box<dyn DynTexture>, DeviceError>;
|
||||
unsafe fn destroy_texture(&self, texture: Box<dyn DynTexture>);
|
||||
unsafe fn add_raw_texture(&self, texture: &dyn DynTexture);
|
||||
|
||||
unsafe fn create_texture_view(
|
||||
&self,
|
||||
texture: &dyn DynTexture,
|
||||
desc: &TextureViewDescriptor,
|
||||
) -> Result<Box<dyn DynTextureView>, DeviceError>;
|
||||
unsafe fn destroy_texture_view(&self, view: Box<dyn DynTextureView>);
|
||||
unsafe fn create_sampler(
|
||||
&self,
|
||||
desc: &SamplerDescriptor,
|
||||
) -> Result<Box<dyn DynSampler>, DeviceError>;
|
||||
unsafe fn destroy_sampler(&self, sampler: Box<dyn DynSampler>);
|
||||
|
||||
unsafe fn create_command_encoder(
|
||||
&self,
|
||||
desc: &CommandEncoderDescriptor<dyn DynQueue>,
|
||||
) -> Result<Box<dyn DynCommandEncoder>, DeviceError>;
|
||||
|
||||
unsafe fn create_bind_group_layout(
|
||||
&self,
|
||||
desc: &BindGroupLayoutDescriptor,
|
||||
) -> Result<Box<dyn DynBindGroupLayout>, DeviceError>;
|
||||
unsafe fn destroy_bind_group_layout(&self, bg_layout: Box<dyn DynBindGroupLayout>);
|
||||
|
||||
unsafe fn create_pipeline_layout(
|
||||
&self,
|
||||
desc: &PipelineLayoutDescriptor<dyn DynBindGroupLayout>,
|
||||
) -> Result<Box<dyn DynPipelineLayout>, DeviceError>;
|
||||
unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Box<dyn DynPipelineLayout>);
|
||||
|
||||
unsafe fn create_bind_group(
|
||||
&self,
|
||||
desc: &BindGroupDescriptor<
|
||||
dyn DynBindGroupLayout,
|
||||
dyn DynBuffer,
|
||||
dyn DynSampler,
|
||||
dyn DynTextureView,
|
||||
dyn DynAccelerationStructure,
|
||||
>,
|
||||
) -> Result<Box<dyn DynBindGroup>, DeviceError>;
|
||||
unsafe fn destroy_bind_group(&self, group: Box<dyn DynBindGroup>);
|
||||
|
||||
unsafe fn create_shader_module(
|
||||
&self,
|
||||
desc: &ShaderModuleDescriptor,
|
||||
shader: ShaderInput,
|
||||
) -> Result<Box<dyn DynShaderModule>, ShaderError>;
|
||||
unsafe fn destroy_shader_module(&self, module: Box<dyn DynShaderModule>);
|
||||
|
||||
unsafe fn create_render_pipeline(
|
||||
&self,
|
||||
desc: &RenderPipelineDescriptor<
|
||||
dyn DynPipelineLayout,
|
||||
dyn DynShaderModule,
|
||||
dyn DynPipelineCache,
|
||||
>,
|
||||
) -> Result<Box<dyn DynRenderPipeline>, PipelineError>;
|
||||
unsafe fn destroy_render_pipeline(&self, pipeline: Box<dyn DynRenderPipeline>);
|
||||
|
||||
unsafe fn create_compute_pipeline(
|
||||
&self,
|
||||
desc: &ComputePipelineDescriptor<
|
||||
dyn DynPipelineLayout,
|
||||
dyn DynShaderModule,
|
||||
dyn DynPipelineCache,
|
||||
>,
|
||||
) -> Result<Box<dyn DynComputePipeline>, PipelineError>;
|
||||
unsafe fn destroy_compute_pipeline(&self, pipeline: Box<dyn DynComputePipeline>);
|
||||
|
||||
unsafe fn create_ray_tracing_pipeline(
|
||||
&self,
|
||||
desc: &RayTracingPipelineDescriptor<
|
||||
dyn DynPipelineLayout,
|
||||
dyn DynShaderModule,
|
||||
dyn DynPipelineCache,
|
||||
>,
|
||||
) -> Result<Box<dyn DynRayTracingPipeline>, PipelineError>;
|
||||
unsafe fn destroy_ray_tracing_pipeline(&self, pipeline: Box<dyn DynRayTracingPipeline>);
|
||||
unsafe fn get_raytracing_pipeline_group_data(
|
||||
&self,
|
||||
pipeline: &dyn DynRayTracingPipeline,
|
||||
groups: core::ops::Range<u32>,
|
||||
) -> Result<Vec<u8>, DeviceError>;
|
||||
|
||||
unsafe fn create_pipeline_cache(
|
||||
&self,
|
||||
desc: &PipelineCacheDescriptor<'_>,
|
||||
) -> Result<Box<dyn DynPipelineCache>, PipelineCacheError>;
|
||||
fn pipeline_cache_validation_key(&self) -> Option<[u8; 16]> {
|
||||
None
|
||||
}
|
||||
unsafe fn destroy_pipeline_cache(&self, cache: Box<dyn DynPipelineCache>);
|
||||
|
||||
unsafe fn create_query_set(
|
||||
&self,
|
||||
desc: &wgt::QuerySetDescriptor<Label>,
|
||||
) -> Result<Box<dyn DynQuerySet>, DeviceError>;
|
||||
unsafe fn destroy_query_set(&self, set: Box<dyn DynQuerySet>);
|
||||
|
||||
unsafe fn create_fence(&self) -> Result<Box<dyn DynFence>, DeviceError>;
|
||||
unsafe fn destroy_fence(&self, fence: Box<dyn DynFence>);
|
||||
unsafe fn get_fence_value(&self, fence: &dyn DynFence) -> Result<FenceValue, DeviceError>;
|
||||
|
||||
unsafe fn wait(
|
||||
&self,
|
||||
fence: &dyn DynFence,
|
||||
value: FenceValue,
|
||||
timeout: Option<core::time::Duration>,
|
||||
) -> Result<bool, DeviceError>;
|
||||
|
||||
unsafe fn start_graphics_debugger_capture(&self) -> bool;
|
||||
unsafe fn stop_graphics_debugger_capture(&self);
|
||||
|
||||
unsafe fn pipeline_cache_get_data(&self, cache: &dyn DynPipelineCache) -> Option<Vec<u8>>;
|
||||
|
||||
unsafe fn create_acceleration_structure(
|
||||
&self,
|
||||
desc: &AccelerationStructureDescriptor,
|
||||
) -> Result<Box<dyn DynAccelerationStructure>, DeviceError>;
|
||||
unsafe fn get_acceleration_structure_build_sizes(
|
||||
&self,
|
||||
desc: &GetAccelerationStructureBuildSizesDescriptor<dyn DynBuffer>,
|
||||
) -> AccelerationStructureBuildSizes;
|
||||
unsafe fn get_acceleration_structure_device_address(
|
||||
&self,
|
||||
acceleration_structure: &dyn DynAccelerationStructure,
|
||||
) -> wgt::BufferAddress;
|
||||
unsafe fn destroy_acceleration_structure(
|
||||
&self,
|
||||
acceleration_structure: Box<dyn DynAccelerationStructure>,
|
||||
);
|
||||
fn tlas_instance_to_bytes(&self, instance: TlasInstance) -> Vec<u8>;
|
||||
|
||||
fn get_internal_counters(&self) -> wgt::HalCounters;
|
||||
fn generate_allocator_report(&self) -> Option<wgt::AllocatorReport>;
|
||||
|
||||
fn check_if_oom(&self) -> Result<(), DeviceError>;
|
||||
}
|
||||
|
||||
impl<D: Device + DynResource> DynDevice for D {
|
||||
unsafe fn create_buffer(
|
||||
&self,
|
||||
desc: &BufferDescriptor,
|
||||
) -> Result<Box<dyn DynBuffer>, DeviceError> {
|
||||
unsafe { D::create_buffer(self, desc) }.map(|b| -> Box<dyn DynBuffer> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_buffer(&self, buffer: Box<dyn DynBuffer>) {
|
||||
unsafe { D::destroy_buffer(self, buffer.unbox()) };
|
||||
}
|
||||
unsafe fn add_raw_buffer(&self, buffer: &dyn DynBuffer) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { D::add_raw_buffer(self, buffer) };
|
||||
}
|
||||
|
||||
unsafe fn map_buffer(
|
||||
&self,
|
||||
buffer: &dyn DynBuffer,
|
||||
range: MemoryRange,
|
||||
) -> Result<BufferMapping, DeviceError> {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { D::map_buffer(self, buffer, range) }
|
||||
}
|
||||
|
||||
unsafe fn unmap_buffer(&self, buffer: &dyn DynBuffer) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { D::unmap_buffer(self, buffer) }
|
||||
}
|
||||
|
||||
unsafe fn flush_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { D::flush_mapped_ranges(self, buffer, ranges.iter().cloned()) }
|
||||
}
|
||||
|
||||
unsafe fn invalidate_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]) {
|
||||
let buffer = buffer.expect_downcast_ref();
|
||||
unsafe { D::invalidate_mapped_ranges(self, buffer, ranges.iter().cloned()) }
|
||||
}
|
||||
|
||||
unsafe fn create_texture(
|
||||
&self,
|
||||
desc: &TextureDescriptor,
|
||||
) -> Result<Box<dyn DynTexture>, DeviceError> {
|
||||
unsafe { D::create_texture(self, desc) }.map(|b| {
|
||||
let boxed_texture: Box<<D::A as Api>::Texture> = Box::new(b);
|
||||
let boxed_texture: Box<dyn DynTexture> = boxed_texture;
|
||||
boxed_texture
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn destroy_texture(&self, texture: Box<dyn DynTexture>) {
|
||||
unsafe { D::destroy_texture(self, texture.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn add_raw_texture(&self, texture: &dyn DynTexture) {
|
||||
let texture = texture.expect_downcast_ref();
|
||||
unsafe { D::add_raw_texture(self, texture) };
|
||||
}
|
||||
|
||||
unsafe fn create_texture_view(
|
||||
&self,
|
||||
texture: &dyn DynTexture,
|
||||
desc: &TextureViewDescriptor,
|
||||
) -> Result<Box<dyn DynTextureView>, DeviceError> {
|
||||
let texture = texture.expect_downcast_ref();
|
||||
unsafe { D::create_texture_view(self, texture, desc) }.map(|b| {
|
||||
let boxed_texture_view: Box<<D::A as Api>::TextureView> = Box::new(b);
|
||||
let boxed_texture_view: Box<dyn DynTextureView> = boxed_texture_view;
|
||||
boxed_texture_view
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn destroy_texture_view(&self, view: Box<dyn DynTextureView>) {
|
||||
unsafe { D::destroy_texture_view(self, view.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_sampler(
|
||||
&self,
|
||||
desc: &SamplerDescriptor,
|
||||
) -> Result<Box<dyn DynSampler>, DeviceError> {
|
||||
unsafe { D::create_sampler(self, desc) }.map(|b| {
|
||||
let boxed_sampler: Box<<D::A as Api>::Sampler> = Box::new(b);
|
||||
let boxed_sampler: Box<dyn DynSampler> = boxed_sampler;
|
||||
boxed_sampler
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn destroy_sampler(&self, sampler: Box<dyn DynSampler>) {
|
||||
unsafe { D::destroy_sampler(self, sampler.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_command_encoder(
|
||||
&self,
|
||||
desc: &CommandEncoderDescriptor<'_, dyn DynQueue>,
|
||||
) -> Result<Box<dyn DynCommandEncoder>, DeviceError> {
|
||||
let desc = CommandEncoderDescriptor {
|
||||
label: desc.label,
|
||||
queue: desc.queue.expect_downcast_ref(),
|
||||
};
|
||||
unsafe { D::create_command_encoder(self, &desc) }
|
||||
.map(|b| -> Box<dyn DynCommandEncoder> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn create_bind_group_layout(
|
||||
&self,
|
||||
desc: &BindGroupLayoutDescriptor,
|
||||
) -> Result<Box<dyn DynBindGroupLayout>, DeviceError> {
|
||||
unsafe { D::create_bind_group_layout(self, desc) }
|
||||
.map(|b| -> Box<dyn DynBindGroupLayout> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_bind_group_layout(&self, bg_layout: Box<dyn DynBindGroupLayout>) {
|
||||
unsafe { D::destroy_bind_group_layout(self, bg_layout.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_pipeline_layout(
|
||||
&self,
|
||||
desc: &PipelineLayoutDescriptor<dyn DynBindGroupLayout>,
|
||||
) -> Result<Box<dyn DynPipelineLayout>, DeviceError> {
|
||||
let bind_group_layouts: Vec<_> = desc
|
||||
.bind_group_layouts
|
||||
.iter()
|
||||
.map(|bgl| bgl.map(|bgl| bgl.expect_downcast_ref()))
|
||||
.collect();
|
||||
let desc = PipelineLayoutDescriptor {
|
||||
label: desc.label,
|
||||
bind_group_layouts: &bind_group_layouts,
|
||||
immediate_size: desc.immediate_size,
|
||||
flags: desc.flags,
|
||||
};
|
||||
|
||||
unsafe { D::create_pipeline_layout(self, &desc) }
|
||||
.map(|b| -> Box<dyn DynPipelineLayout> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Box<dyn DynPipelineLayout>) {
|
||||
unsafe { D::destroy_pipeline_layout(self, pipeline_layout.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_bind_group(
|
||||
&self,
|
||||
desc: &BindGroupDescriptor<
|
||||
dyn DynBindGroupLayout,
|
||||
dyn DynBuffer,
|
||||
dyn DynSampler,
|
||||
dyn DynTextureView,
|
||||
dyn DynAccelerationStructure,
|
||||
>,
|
||||
) -> Result<Box<dyn DynBindGroup>, DeviceError> {
|
||||
let buffers: Vec<_> = desc
|
||||
.buffers
|
||||
.iter()
|
||||
.map(|b| b.clone().expect_downcast())
|
||||
.collect();
|
||||
let samplers: Vec<_> = desc
|
||||
.samplers
|
||||
.iter()
|
||||
.map(|s| s.expect_downcast_ref())
|
||||
.collect();
|
||||
let textures: Vec<_> = desc
|
||||
.textures
|
||||
.iter()
|
||||
.map(|t| t.clone().expect_downcast())
|
||||
.collect();
|
||||
let acceleration_structures: Vec<_> = desc
|
||||
.acceleration_structures
|
||||
.iter()
|
||||
.map(|a| a.expect_downcast_ref())
|
||||
.collect();
|
||||
let external_textures: Vec<_> = desc
|
||||
.external_textures
|
||||
.iter()
|
||||
.map(|et| et.clone().expect_downcast())
|
||||
.collect();
|
||||
|
||||
let desc = BindGroupDescriptor {
|
||||
label: desc.label.to_owned(),
|
||||
layout: desc.layout.expect_downcast_ref(),
|
||||
buffers: &buffers,
|
||||
samplers: &samplers,
|
||||
textures: &textures,
|
||||
entries: desc.entries,
|
||||
acceleration_structures: &acceleration_structures,
|
||||
external_textures: &external_textures,
|
||||
};
|
||||
|
||||
unsafe { D::create_bind_group(self, &desc) }
|
||||
.map(|b| -> Box<dyn DynBindGroup> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_bind_group(&self, group: Box<dyn DynBindGroup>) {
|
||||
unsafe { D::destroy_bind_group(self, group.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_shader_module(
|
||||
&self,
|
||||
desc: &ShaderModuleDescriptor,
|
||||
shader: ShaderInput,
|
||||
) -> Result<Box<dyn DynShaderModule>, ShaderError> {
|
||||
unsafe { D::create_shader_module(self, desc, shader) }
|
||||
.map(|b| -> Box<dyn DynShaderModule> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_shader_module(&self, module: Box<dyn DynShaderModule>) {
|
||||
unsafe { D::destroy_shader_module(self, module.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_render_pipeline(
|
||||
&self,
|
||||
desc: &RenderPipelineDescriptor<
|
||||
dyn DynPipelineLayout,
|
||||
dyn DynShaderModule,
|
||||
dyn DynPipelineCache,
|
||||
>,
|
||||
) -> Result<Box<dyn DynRenderPipeline>, PipelineError> {
|
||||
let desc = RenderPipelineDescriptor {
|
||||
label: desc.label,
|
||||
layout: desc.layout.expect_downcast_ref(),
|
||||
vertex_processor: match &desc.vertex_processor {
|
||||
crate::VertexProcessor::Standard {
|
||||
vertex_buffers,
|
||||
vertex_stage,
|
||||
} => crate::VertexProcessor::Standard {
|
||||
vertex_buffers,
|
||||
vertex_stage: vertex_stage.clone().expect_downcast(),
|
||||
},
|
||||
crate::VertexProcessor::Mesh {
|
||||
task_stage: task,
|
||||
mesh_stage: mesh,
|
||||
} => crate::VertexProcessor::Mesh {
|
||||
task_stage: task.as_ref().map(|a| a.clone().expect_downcast()),
|
||||
mesh_stage: mesh.clone().expect_downcast(),
|
||||
},
|
||||
},
|
||||
primitive: desc.primitive,
|
||||
depth_stencil: desc.depth_stencil.clone(),
|
||||
multisample: desc.multisample,
|
||||
fragment_stage: desc.fragment_stage.clone().map(|f| f.expect_downcast()),
|
||||
color_targets: desc.color_targets,
|
||||
multiview_mask: desc.multiview_mask,
|
||||
cache: desc.cache.map(|c| c.expect_downcast_ref()),
|
||||
};
|
||||
|
||||
unsafe { D::create_render_pipeline(self, &desc) }
|
||||
.map(|b| -> Box<dyn DynRenderPipeline> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_render_pipeline(&self, pipeline: Box<dyn DynRenderPipeline>) {
|
||||
unsafe { D::destroy_render_pipeline(self, pipeline.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_compute_pipeline(
|
||||
&self,
|
||||
desc: &ComputePipelineDescriptor<
|
||||
dyn DynPipelineLayout,
|
||||
dyn DynShaderModule,
|
||||
dyn DynPipelineCache,
|
||||
>,
|
||||
) -> Result<Box<dyn DynComputePipeline>, PipelineError> {
|
||||
let desc = ComputePipelineDescriptor {
|
||||
label: desc.label,
|
||||
layout: desc.layout.expect_downcast_ref(),
|
||||
stage: desc.stage.clone().expect_downcast(),
|
||||
cache: desc.cache.as_ref().map(|c| c.expect_downcast_ref()),
|
||||
};
|
||||
|
||||
unsafe { D::create_compute_pipeline(self, &desc) }
|
||||
.map(|b| -> Box<dyn DynComputePipeline> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_compute_pipeline(&self, pipeline: Box<dyn DynComputePipeline>) {
|
||||
unsafe { D::destroy_compute_pipeline(self, pipeline.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_ray_tracing_pipeline(
|
||||
&self,
|
||||
desc: &RayTracingPipelineDescriptor<
|
||||
dyn DynPipelineLayout,
|
||||
dyn DynShaderModule,
|
||||
dyn DynPipelineCache,
|
||||
>,
|
||||
) -> Result<Box<dyn DynRayTracingPipeline>, PipelineError> {
|
||||
let ray_intersection: Vec<_> = desc
|
||||
.intersection
|
||||
.iter()
|
||||
.map(|stage| RayObjectIntersectionState {
|
||||
closest_hit: stage.closest_hit.clone().expect_downcast(),
|
||||
any_hit: stage
|
||||
.any_hit
|
||||
.as_ref()
|
||||
.map(|stage| stage.clone().expect_downcast()),
|
||||
})
|
||||
.collect();
|
||||
|
||||
let desc = RayTracingPipelineDescriptor {
|
||||
label: desc.label,
|
||||
layout: desc.layout.expect_downcast_ref(),
|
||||
ray_generation: desc.ray_generation.clone().expect_downcast(),
|
||||
miss: desc.miss.clone().expect_downcast(),
|
||||
intersection: &ray_intersection,
|
||||
max_recursion_depth: desc.max_recursion_depth,
|
||||
cache: desc.cache.as_ref().map(|c| c.expect_downcast_ref()),
|
||||
};
|
||||
|
||||
unsafe { D::create_ray_tracing_pipeline(self, &desc) }
|
||||
.map(|b| -> Box<dyn DynRayTracingPipeline> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_ray_tracing_pipeline(&self, pipeline: Box<dyn DynRayTracingPipeline>) {
|
||||
unsafe {
|
||||
D::destroy_ray_tracing_pipeline(self, pipeline.unbox());
|
||||
};
|
||||
}
|
||||
unsafe fn get_raytracing_pipeline_group_data(
|
||||
&self,
|
||||
pipeline: &dyn DynRayTracingPipeline,
|
||||
groups: core::ops::Range<u32>,
|
||||
) -> Result<Vec<u8>, DeviceError> {
|
||||
unsafe {
|
||||
D::get_raytracing_pipeline_group_data(self, pipeline.expect_downcast_ref(), groups)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn create_pipeline_cache(
|
||||
&self,
|
||||
desc: &PipelineCacheDescriptor<'_>,
|
||||
) -> Result<Box<dyn DynPipelineCache>, PipelineCacheError> {
|
||||
unsafe { D::create_pipeline_cache(self, desc) }
|
||||
.map(|b| -> Box<dyn DynPipelineCache> { Box::new(b) })
|
||||
}
|
||||
|
||||
fn pipeline_cache_validation_key(&self) -> Option<[u8; 16]> {
|
||||
D::pipeline_cache_validation_key(self)
|
||||
}
|
||||
|
||||
unsafe fn destroy_pipeline_cache(&self, pipeline_cache: Box<dyn DynPipelineCache>) {
|
||||
unsafe { D::destroy_pipeline_cache(self, pipeline_cache.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_query_set(
|
||||
&self,
|
||||
desc: &wgt::QuerySetDescriptor<Label>,
|
||||
) -> Result<Box<dyn DynQuerySet>, DeviceError> {
|
||||
unsafe { D::create_query_set(self, desc) }.map(|b| -> Box<dyn DynQuerySet> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_query_set(&self, query_set: Box<dyn DynQuerySet>) {
|
||||
unsafe { D::destroy_query_set(self, query_set.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn create_fence(&self) -> Result<Box<dyn DynFence>, DeviceError> {
|
||||
unsafe { D::create_fence(self) }.map(|b| -> Box<dyn DynFence> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn destroy_fence(&self, fence: Box<dyn DynFence>) {
|
||||
unsafe { D::destroy_fence(self, fence.unbox()) };
|
||||
}
|
||||
|
||||
unsafe fn get_fence_value(&self, fence: &dyn DynFence) -> Result<FenceValue, DeviceError> {
|
||||
let fence = fence.expect_downcast_ref();
|
||||
unsafe { D::get_fence_value(self, fence) }
|
||||
}
|
||||
|
||||
unsafe fn wait(
|
||||
&self,
|
||||
fence: &dyn DynFence,
|
||||
value: FenceValue,
|
||||
timeout: Option<core::time::Duration>,
|
||||
) -> Result<bool, DeviceError> {
|
||||
let fence = fence.expect_downcast_ref();
|
||||
unsafe { D::wait(self, fence, value, timeout) }
|
||||
}
|
||||
|
||||
unsafe fn start_graphics_debugger_capture(&self) -> bool {
|
||||
unsafe { D::start_graphics_debugger_capture(self) }
|
||||
}
|
||||
|
||||
unsafe fn stop_graphics_debugger_capture(&self) {
|
||||
unsafe { D::stop_graphics_debugger_capture(self) }
|
||||
}
|
||||
|
||||
unsafe fn pipeline_cache_get_data(&self, cache: &dyn DynPipelineCache) -> Option<Vec<u8>> {
|
||||
let cache = cache.expect_downcast_ref();
|
||||
unsafe { D::pipeline_cache_get_data(self, cache) }
|
||||
}
|
||||
|
||||
unsafe fn create_acceleration_structure(
|
||||
&self,
|
||||
desc: &AccelerationStructureDescriptor,
|
||||
) -> Result<Box<dyn DynAccelerationStructure>, DeviceError> {
|
||||
unsafe { D::create_acceleration_structure(self, desc) }
|
||||
.map(|b| -> Box<dyn DynAccelerationStructure> { Box::new(b) })
|
||||
}
|
||||
|
||||
unsafe fn get_acceleration_structure_build_sizes(
|
||||
&self,
|
||||
desc: &GetAccelerationStructureBuildSizesDescriptor<dyn DynBuffer>,
|
||||
) -> AccelerationStructureBuildSizes {
|
||||
let entries = desc.entries.expect_downcast();
|
||||
let desc = GetAccelerationStructureBuildSizesDescriptor {
|
||||
entries: &entries,
|
||||
flags: desc.flags,
|
||||
};
|
||||
unsafe { D::get_acceleration_structure_build_sizes(self, &desc) }
|
||||
}
|
||||
|
||||
unsafe fn get_acceleration_structure_device_address(
|
||||
&self,
|
||||
acceleration_structure: &dyn DynAccelerationStructure,
|
||||
) -> wgt::BufferAddress {
|
||||
let acceleration_structure = acceleration_structure.expect_downcast_ref();
|
||||
unsafe { D::get_acceleration_structure_device_address(self, acceleration_structure) }
|
||||
}
|
||||
|
||||
unsafe fn destroy_acceleration_structure(
|
||||
&self,
|
||||
acceleration_structure: Box<dyn DynAccelerationStructure>,
|
||||
) {
|
||||
unsafe { D::destroy_acceleration_structure(self, acceleration_structure.unbox()) }
|
||||
}
|
||||
|
||||
fn tlas_instance_to_bytes(&self, instance: TlasInstance) -> Vec<u8> {
|
||||
D::tlas_instance_to_bytes(self, instance)
|
||||
}
|
||||
|
||||
fn get_internal_counters(&self) -> wgt::HalCounters {
|
||||
D::get_internal_counters(self)
|
||||
}
|
||||
|
||||
fn generate_allocator_report(&self) -> Option<wgt::AllocatorReport> {
|
||||
D::generate_allocator_report(self)
|
||||
}
|
||||
|
||||
fn check_if_oom(&self) -> Result<(), DeviceError> {
|
||||
D::check_if_oom(self)
|
||||
}
|
||||
}
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
use alloc::{boxed::Box, vec::Vec};
|
||||
|
||||
use crate::{Api, Capabilities, ExposedAdapter, Instance, InstanceError};
|
||||
|
||||
use super::{DynAdapter, DynResource, DynResourceExt as _, DynSurface};
|
||||
|
||||
#[expect(missing_debug_implementations, reason = "dyn")]
|
||||
pub struct DynExposedAdapter {
|
||||
pub adapter: Box<dyn DynAdapter>,
|
||||
pub info: wgt::AdapterInfo,
|
||||
pub features: wgt::Features,
|
||||
pub capabilities: Capabilities,
|
||||
}
|
||||
|
||||
impl DynExposedAdapter {
|
||||
/// Returns the backend this adapter is using.
|
||||
pub fn backend(&self) -> wgt::Backend {
|
||||
self.info.backend
|
||||
}
|
||||
}
|
||||
|
||||
impl<A: Api> From<ExposedAdapter<A>> for DynExposedAdapter {
|
||||
fn from(exposed_adapter: ExposedAdapter<A>) -> Self {
|
||||
Self {
|
||||
adapter: Box::new(exposed_adapter.adapter),
|
||||
info: exposed_adapter.info,
|
||||
features: exposed_adapter.features,
|
||||
capabilities: exposed_adapter.capabilities,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait DynInstance: DynResource {
|
||||
unsafe fn create_surface(
|
||||
&self,
|
||||
display_handle: raw_window_handle::RawDisplayHandle,
|
||||
window_handle: raw_window_handle::RawWindowHandle,
|
||||
) -> Result<Box<dyn DynSurface>, InstanceError>;
|
||||
|
||||
unsafe fn enumerate_adapters(
|
||||
&self,
|
||||
surface_hint: Option<&dyn DynSurface>,
|
||||
) -> Vec<DynExposedAdapter>;
|
||||
}
|
||||
|
||||
impl<I: Instance + DynResource> DynInstance for I {
|
||||
unsafe fn create_surface(
|
||||
&self,
|
||||
display_handle: raw_window_handle::RawDisplayHandle,
|
||||
window_handle: raw_window_handle::RawWindowHandle,
|
||||
) -> Result<Box<dyn DynSurface>, InstanceError> {
|
||||
unsafe { I::create_surface(self, display_handle, window_handle) }
|
||||
.map(|surface| -> Box<dyn DynSurface> { Box::new(surface) })
|
||||
}
|
||||
|
||||
unsafe fn enumerate_adapters(
|
||||
&self,
|
||||
surface_hint: Option<&dyn DynSurface>,
|
||||
) -> Vec<DynExposedAdapter> {
|
||||
let surface_hint = surface_hint.map(|s| s.expect_downcast_ref());
|
||||
unsafe { I::enumerate_adapters(self, surface_hint) }
|
||||
.into_iter()
|
||||
.map(|exposed| DynExposedAdapter {
|
||||
adapter: Box::new(exposed.adapter),
|
||||
info: exposed.info,
|
||||
features: exposed.features,
|
||||
capabilities: exposed.capabilities,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
Vendored
+212
@@ -0,0 +1,212 @@
|
||||
mod adapter;
|
||||
mod command;
|
||||
mod device;
|
||||
mod instance;
|
||||
mod queue;
|
||||
mod surface;
|
||||
|
||||
pub use adapter::{DynAdapter, DynOpenDevice};
|
||||
pub use command::DynCommandEncoder;
|
||||
pub use device::DynDevice;
|
||||
pub use instance::{DynExposedAdapter, DynInstance};
|
||||
pub use queue::DynQueue;
|
||||
pub use surface::{DynAcquiredSurfaceTexture, DynSurface};
|
||||
|
||||
use alloc::boxed::Box;
|
||||
use core::{
|
||||
any::{Any, TypeId},
|
||||
fmt,
|
||||
};
|
||||
|
||||
use wgt::WasmNotSendSync;
|
||||
|
||||
use crate::{
|
||||
AccelerationStructureAABBs, AccelerationStructureEntries, AccelerationStructureInstances,
|
||||
AccelerationStructureTriangleIndices, AccelerationStructureTriangleTransform,
|
||||
AccelerationStructureTriangles, BufferBinding, ExternalTextureBinding, ProgrammableStage,
|
||||
TextureBinding,
|
||||
};
|
||||
|
||||
/// Base trait for all resources, allows downcasting via [`Any`].
|
||||
pub trait DynResource: Any + WasmNotSendSync + 'static {
|
||||
fn as_any(&self) -> &dyn Any;
|
||||
fn as_any_mut(&mut self) -> &mut dyn Any;
|
||||
}
|
||||
|
||||
/// Utility macro for implementing `DynResource` for a list of types.
|
||||
macro_rules! impl_dyn_resource {
|
||||
($($type:ty),*) => {
|
||||
$(
|
||||
impl crate::DynResource for $type {
|
||||
fn as_any(&self) -> &dyn ::core::any::Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn as_any_mut(&mut self) -> &mut dyn ::core::any::Any {
|
||||
self
|
||||
}
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
pub(crate) use impl_dyn_resource;
|
||||
|
||||
/// Extension trait for `DynResource` used by implementations of various dynamic resource traits.
|
||||
trait DynResourceExt {
|
||||
/// # Panics
|
||||
///
|
||||
/// - Panics if `self` is not downcastable to `T`.
|
||||
fn expect_downcast_ref<T: DynResource>(&self) -> &T;
|
||||
|
||||
/// Unboxes a `Box<dyn DynResource>` to a concrete type.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// - `self` must be the correct concrete type.
|
||||
unsafe fn unbox<T: DynResource + 'static>(self: Box<Self>) -> T;
|
||||
}
|
||||
|
||||
impl<R: DynResource + ?Sized> DynResourceExt for R {
|
||||
fn expect_downcast_ref<'a, T: DynResource>(&'a self) -> &'a T {
|
||||
self.as_any()
|
||||
.downcast_ref()
|
||||
.expect("Resource doesn't have the expected backend type.")
|
||||
}
|
||||
|
||||
unsafe fn unbox<T: DynResource + 'static>(self: Box<Self>) -> T {
|
||||
debug_assert!(
|
||||
<Self as Any>::type_id(self.as_ref()) == TypeId::of::<T>(),
|
||||
"Resource doesn't have the expected type, expected {:?}, got {:?}",
|
||||
TypeId::of::<T>(),
|
||||
<Self as Any>::type_id(self.as_ref())
|
||||
);
|
||||
|
||||
let casted_ptr = Box::into_raw(self).cast::<T>();
|
||||
// SAFETY: This is adheres to the safety contract of `Box::from_raw` because:
|
||||
//
|
||||
// - We are casting the value of a previously `Box`ed value, which guarantees:
|
||||
// - `casted_ptr` is not null.
|
||||
// - `casted_ptr` is valid for reads and writes, though by itself this does not mean
|
||||
// valid reads and writes for `T` (read on for that).
|
||||
// - We don't change the allocator.
|
||||
// - The contract of `Box::from_raw` requires that an initialized and aligned `T` is stored
|
||||
// within `casted_ptr`.
|
||||
*unsafe { Box::from_raw(casted_ptr) }
|
||||
}
|
||||
}
|
||||
|
||||
pub trait DynAccelerationStructure: DynResource + fmt::Debug {}
|
||||
pub trait DynBindGroup: DynResource + fmt::Debug {}
|
||||
pub trait DynBindGroupLayout: DynResource + fmt::Debug {}
|
||||
pub trait DynBuffer: DynResource + fmt::Debug {}
|
||||
pub trait DynCommandBuffer: DynResource + fmt::Debug {}
|
||||
pub trait DynComputePipeline: DynResource + fmt::Debug {}
|
||||
pub trait DynFence: DynResource + fmt::Debug {}
|
||||
pub trait DynPipelineCache: DynResource + fmt::Debug {}
|
||||
pub trait DynPipelineLayout: DynResource + fmt::Debug {}
|
||||
pub trait DynQuerySet: DynResource + fmt::Debug {}
|
||||
pub trait DynRenderPipeline: DynResource + fmt::Debug {}
|
||||
pub trait DynRayTracingPipeline: DynResource + fmt::Debug {}
|
||||
pub trait DynSampler: DynResource + fmt::Debug {}
|
||||
pub trait DynShaderModule: DynResource + fmt::Debug {}
|
||||
pub trait DynSurfaceTexture:
|
||||
DynResource + core::borrow::Borrow<dyn DynTexture> + fmt::Debug
|
||||
{
|
||||
}
|
||||
pub trait DynTexture: DynResource + fmt::Debug {}
|
||||
pub trait DynTextureView: DynResource + fmt::Debug {}
|
||||
|
||||
impl<'a> BufferBinding<'a, dyn DynBuffer> {
|
||||
pub fn expect_downcast<B: DynBuffer>(self) -> BufferBinding<'a, B> {
|
||||
BufferBinding {
|
||||
buffer: self.buffer.expect_downcast_ref(),
|
||||
offset: self.offset,
|
||||
size: self.size,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TextureBinding<'a, dyn DynTextureView> {
|
||||
pub fn expect_downcast<T: DynTextureView>(self) -> TextureBinding<'a, T> {
|
||||
TextureBinding {
|
||||
view: self.view.expect_downcast_ref(),
|
||||
usage: self.usage,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ExternalTextureBinding<'a, dyn DynBuffer, dyn DynTextureView> {
|
||||
pub fn expect_downcast<B: DynBuffer, T: DynTextureView>(
|
||||
self,
|
||||
) -> ExternalTextureBinding<'a, B, T> {
|
||||
let planes = self.planes.map(|plane| plane.expect_downcast());
|
||||
let params = self.params.expect_downcast();
|
||||
ExternalTextureBinding { planes, params }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ProgrammableStage<'a, dyn DynShaderModule> {
|
||||
fn expect_downcast<T: DynShaderModule>(self) -> ProgrammableStage<'a, T> {
|
||||
ProgrammableStage {
|
||||
module: self.module.expect_downcast_ref(),
|
||||
entry_point: self.entry_point,
|
||||
constants: self.constants,
|
||||
zero_initialize_workgroup_memory: self.zero_initialize_workgroup_memory,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> AccelerationStructureEntries<'a, dyn DynBuffer> {
|
||||
fn expect_downcast<B: DynBuffer>(&self) -> AccelerationStructureEntries<'a, B> {
|
||||
match self {
|
||||
AccelerationStructureEntries::Instances(instances) => {
|
||||
AccelerationStructureEntries::Instances(AccelerationStructureInstances {
|
||||
buffer: instances.buffer.map(|b| b.expect_downcast_ref()),
|
||||
offset: instances.offset,
|
||||
count: instances.count,
|
||||
})
|
||||
}
|
||||
AccelerationStructureEntries::Triangles(triangles) => {
|
||||
AccelerationStructureEntries::Triangles(
|
||||
triangles
|
||||
.iter()
|
||||
.map(|t| AccelerationStructureTriangles {
|
||||
vertex_buffer: t.vertex_buffer.map(|b| b.expect_downcast_ref()),
|
||||
vertex_format: t.vertex_format,
|
||||
first_vertex: t.first_vertex,
|
||||
vertex_count: t.vertex_count,
|
||||
vertex_stride: t.vertex_stride,
|
||||
indices: t.indices.as_ref().map(|i| {
|
||||
AccelerationStructureTriangleIndices {
|
||||
buffer: i.buffer.map(|b| b.expect_downcast_ref()),
|
||||
format: i.format,
|
||||
offset: i.offset,
|
||||
count: i.count,
|
||||
}
|
||||
}),
|
||||
transform: t.transform.as_ref().map(|t| {
|
||||
AccelerationStructureTriangleTransform {
|
||||
buffer: t.buffer.expect_downcast_ref(),
|
||||
offset: t.offset,
|
||||
}
|
||||
}),
|
||||
flags: t.flags,
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
AccelerationStructureEntries::AABBs(entries) => AccelerationStructureEntries::AABBs(
|
||||
entries
|
||||
.iter()
|
||||
.map(|e| AccelerationStructureAABBs {
|
||||
buffer: e.buffer.map(|b| b.expect_downcast_ref()),
|
||||
offset: e.offset,
|
||||
count: e.count,
|
||||
stride: e.stride,
|
||||
flags: e.flags,
|
||||
})
|
||||
.collect(),
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
Vendored
+61
@@ -0,0 +1,61 @@
|
||||
use alloc::{boxed::Box, vec::Vec};
|
||||
|
||||
use crate::{
|
||||
DeviceError, DynCommandBuffer, DynFence, DynResource, DynSurface, DynSurfaceTexture,
|
||||
FenceValue, Queue, SurfaceError,
|
||||
};
|
||||
|
||||
use super::DynResourceExt as _;
|
||||
|
||||
pub trait DynQueue: DynResource {
|
||||
unsafe fn submit(
|
||||
&self,
|
||||
command_buffers: &[&dyn DynCommandBuffer],
|
||||
surface_textures: &[&dyn DynSurfaceTexture],
|
||||
signal_fence: (&dyn DynFence, FenceValue),
|
||||
) -> Result<(), DeviceError>;
|
||||
unsafe fn present(
|
||||
&self,
|
||||
surface: &dyn DynSurface,
|
||||
texture: Box<dyn DynSurfaceTexture>,
|
||||
) -> Result<(), SurfaceError>;
|
||||
unsafe fn get_timestamp_period(&self) -> f32;
|
||||
unsafe fn wait_for_idle(&self) -> Result<(), DeviceError>;
|
||||
}
|
||||
|
||||
impl<Q: Queue + DynResource> DynQueue for Q {
|
||||
unsafe fn submit(
|
||||
&self,
|
||||
command_buffers: &[&dyn DynCommandBuffer],
|
||||
surface_textures: &[&dyn DynSurfaceTexture],
|
||||
signal_fence: (&dyn DynFence, FenceValue),
|
||||
) -> Result<(), DeviceError> {
|
||||
let command_buffers = command_buffers
|
||||
.iter()
|
||||
.map(|cb| (*cb).expect_downcast_ref())
|
||||
.collect::<Vec<_>>();
|
||||
let surface_textures = surface_textures
|
||||
.iter()
|
||||
.map(|surface| (*surface).expect_downcast_ref())
|
||||
.collect::<Vec<_>>();
|
||||
let signal_fence = (signal_fence.0.expect_downcast_ref(), signal_fence.1);
|
||||
unsafe { Q::submit(self, &command_buffers, &surface_textures, signal_fence) }
|
||||
}
|
||||
|
||||
unsafe fn present(
|
||||
&self,
|
||||
surface: &dyn DynSurface,
|
||||
texture: Box<dyn DynSurfaceTexture>,
|
||||
) -> Result<(), SurfaceError> {
|
||||
let surface = surface.expect_downcast_ref();
|
||||
unsafe { Q::present(self, surface, texture.unbox()) }
|
||||
}
|
||||
|
||||
unsafe fn get_timestamp_period(&self) -> f32 {
|
||||
unsafe { Q::get_timestamp_period(self) }
|
||||
}
|
||||
|
||||
unsafe fn wait_for_idle(&self) -> Result<(), DeviceError> {
|
||||
unsafe { Q::wait_for_idle(self) }
|
||||
}
|
||||
}
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
use alloc::boxed::Box;
|
||||
use core::time::Duration;
|
||||
|
||||
use crate::{
|
||||
DynDevice, DynFence, DynResource, DynSurfaceTexture, Surface, SurfaceConfiguration,
|
||||
SurfaceError,
|
||||
};
|
||||
|
||||
use super::DynResourceExt as _;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct DynAcquiredSurfaceTexture {
|
||||
pub texture: Box<dyn DynSurfaceTexture>,
|
||||
/// The presentation configuration no longer matches
|
||||
/// the surface properties exactly, but can still be used to present
|
||||
/// to the surface successfully.
|
||||
pub suboptimal: bool,
|
||||
}
|
||||
|
||||
pub trait DynSurface: DynResource {
|
||||
unsafe fn configure(
|
||||
&self,
|
||||
device: &dyn DynDevice,
|
||||
config: &SurfaceConfiguration,
|
||||
) -> Result<(), SurfaceError>;
|
||||
|
||||
unsafe fn unconfigure(&self, device: &dyn DynDevice);
|
||||
|
||||
unsafe fn acquire_texture(
|
||||
&self,
|
||||
timeout: Option<Duration>,
|
||||
fence: &dyn DynFence,
|
||||
) -> Result<DynAcquiredSurfaceTexture, SurfaceError>;
|
||||
|
||||
unsafe fn discard_texture(&self, texture: Box<dyn DynSurfaceTexture>);
|
||||
}
|
||||
|
||||
impl<S: Surface + DynResource> DynSurface for S {
|
||||
unsafe fn configure(
|
||||
&self,
|
||||
device: &dyn DynDevice,
|
||||
config: &SurfaceConfiguration,
|
||||
) -> Result<(), SurfaceError> {
|
||||
let device = device.expect_downcast_ref();
|
||||
unsafe { S::configure(self, device, config) }
|
||||
}
|
||||
|
||||
unsafe fn unconfigure(&self, device: &dyn DynDevice) {
|
||||
let device = device.expect_downcast_ref();
|
||||
unsafe { S::unconfigure(self, device) }
|
||||
}
|
||||
|
||||
unsafe fn acquire_texture(
|
||||
&self,
|
||||
timeout: Option<Duration>,
|
||||
fence: &dyn DynFence,
|
||||
) -> Result<DynAcquiredSurfaceTexture, SurfaceError> {
|
||||
let fence = fence.expect_downcast_ref();
|
||||
unsafe { S::acquire_texture(self, timeout, fence) }.map(|ast| {
|
||||
let texture = Box::new(ast.texture);
|
||||
let suboptimal = ast.suboptimal;
|
||||
DynAcquiredSurfaceTexture {
|
||||
texture,
|
||||
suboptimal,
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn discard_texture(&self, texture: Box<dyn DynSurfaceTexture>) {
|
||||
unsafe { S::discard_texture(self, texture.unbox()) }
|
||||
}
|
||||
}
|
||||
Vendored
+1470
File diff suppressed because it is too large.
Load diff
Vendored
+1345
File diff suppressed because it is too large.
Load diff
Vendored
+430
@@ -0,0 +1,430 @@
|
||||
impl super::AdapterShared {
|
||||
pub(super) fn describe_texture_format(
|
||||
&self,
|
||||
texture_format: wgt::TextureFormat,
|
||||
) -> super::TextureFormatDesc {
|
||||
use wgt::TextureFormat as Tf;
|
||||
use wgt::{AstcBlock, AstcChannel};
|
||||
|
||||
let (internal, external, data_type) = match texture_format {
|
||||
Tf::R8Unorm => (glow::R8, glow::RED, glow::UNSIGNED_BYTE),
|
||||
Tf::R8Snorm => (glow::R8_SNORM, glow::RED, glow::BYTE),
|
||||
Tf::R8Uint => (glow::R8UI, glow::RED_INTEGER, glow::UNSIGNED_BYTE),
|
||||
Tf::R8Sint => (glow::R8I, glow::RED_INTEGER, glow::BYTE),
|
||||
Tf::R16Uint => (glow::R16UI, glow::RED_INTEGER, glow::UNSIGNED_SHORT),
|
||||
Tf::R16Sint => (glow::R16I, glow::RED_INTEGER, glow::SHORT),
|
||||
Tf::R16Unorm => (glow::R16, glow::RED, glow::UNSIGNED_SHORT),
|
||||
Tf::R16Snorm => (glow::R16_SNORM, glow::RED, glow::SHORT),
|
||||
Tf::R16Float => (glow::R16F, glow::RED, glow::HALF_FLOAT),
|
||||
Tf::Rg8Unorm => (glow::RG8, glow::RG, glow::UNSIGNED_BYTE),
|
||||
Tf::Rg8Snorm => (glow::RG8_SNORM, glow::RG, glow::BYTE),
|
||||
Tf::Rg8Uint => (glow::RG8UI, glow::RG_INTEGER, glow::UNSIGNED_BYTE),
|
||||
Tf::Rg8Sint => (glow::RG8I, glow::RG_INTEGER, glow::BYTE),
|
||||
Tf::R32Uint => (glow::R32UI, glow::RED_INTEGER, glow::UNSIGNED_INT),
|
||||
Tf::R32Sint => (glow::R32I, glow::RED_INTEGER, glow::INT),
|
||||
Tf::R32Float => (glow::R32F, glow::RED, glow::FLOAT),
|
||||
Tf::Rg16Uint => (glow::RG16UI, glow::RG_INTEGER, glow::UNSIGNED_SHORT),
|
||||
Tf::Rg16Sint => (glow::RG16I, glow::RG_INTEGER, glow::SHORT),
|
||||
Tf::Rg16Unorm => (glow::RG16, glow::RG, glow::UNSIGNED_SHORT),
|
||||
Tf::Rg16Snorm => (glow::RG16_SNORM, glow::RG, glow::SHORT),
|
||||
Tf::Rg16Float => (glow::RG16F, glow::RG, glow::HALF_FLOAT),
|
||||
Tf::Rgba8Unorm => (glow::RGBA8, glow::RGBA, glow::UNSIGNED_BYTE),
|
||||
Tf::Rgba8UnormSrgb => (glow::SRGB8_ALPHA8, glow::RGBA, glow::UNSIGNED_BYTE),
|
||||
Tf::Bgra8UnormSrgb => (glow::SRGB8_ALPHA8, glow::BGRA, glow::UNSIGNED_BYTE), //TODO?
|
||||
Tf::Rgba8Snorm => (glow::RGBA8_SNORM, glow::RGBA, glow::BYTE),
|
||||
Tf::Bgra8Unorm => (glow::RGBA8, glow::BGRA, glow::UNSIGNED_BYTE), //TODO?
|
||||
Tf::Rgba8Uint => (glow::RGBA8UI, glow::RGBA_INTEGER, glow::UNSIGNED_BYTE),
|
||||
Tf::Rgba8Sint => (glow::RGBA8I, glow::RGBA_INTEGER, glow::BYTE),
|
||||
Tf::Rgb10a2Uint => (
|
||||
glow::RGB10_A2UI,
|
||||
glow::RGBA_INTEGER,
|
||||
glow::UNSIGNED_INT_2_10_10_10_REV,
|
||||
),
|
||||
Tf::Rgb10a2Unorm => (
|
||||
glow::RGB10_A2,
|
||||
glow::RGBA,
|
||||
glow::UNSIGNED_INT_2_10_10_10_REV,
|
||||
),
|
||||
Tf::Rg11b10Ufloat => (
|
||||
glow::R11F_G11F_B10F,
|
||||
glow::RGB,
|
||||
glow::UNSIGNED_INT_10F_11F_11F_REV,
|
||||
),
|
||||
Tf::R64Uint => (glow::RG32UI, glow::RED_INTEGER, glow::UNSIGNED_INT),
|
||||
Tf::Rg32Uint => (glow::RG32UI, glow::RG_INTEGER, glow::UNSIGNED_INT),
|
||||
Tf::Rg32Sint => (glow::RG32I, glow::RG_INTEGER, glow::INT),
|
||||
Tf::Rg32Float => (glow::RG32F, glow::RG, glow::FLOAT),
|
||||
Tf::Rgba16Uint => (glow::RGBA16UI, glow::RGBA_INTEGER, glow::UNSIGNED_SHORT),
|
||||
Tf::Rgba16Sint => (glow::RGBA16I, glow::RGBA_INTEGER, glow::SHORT),
|
||||
Tf::Rgba16Unorm => (glow::RGBA16, glow::RGBA, glow::UNSIGNED_SHORT),
|
||||
Tf::Rgba16Snorm => (glow::RGBA16_SNORM, glow::RGBA, glow::SHORT),
|
||||
Tf::Rgba16Float => (glow::RGBA16F, glow::RGBA, glow::HALF_FLOAT),
|
||||
Tf::Rgba32Uint => (glow::RGBA32UI, glow::RGBA_INTEGER, glow::UNSIGNED_INT),
|
||||
Tf::Rgba32Sint => (glow::RGBA32I, glow::RGBA_INTEGER, glow::INT),
|
||||
Tf::Rgba32Float => (glow::RGBA32F, glow::RGBA, glow::FLOAT),
|
||||
Tf::Stencil8 => (
|
||||
glow::STENCIL_INDEX8,
|
||||
glow::STENCIL_INDEX,
|
||||
glow::UNSIGNED_BYTE,
|
||||
),
|
||||
Tf::Depth16Unorm => (
|
||||
glow::DEPTH_COMPONENT16,
|
||||
glow::DEPTH_COMPONENT,
|
||||
glow::UNSIGNED_SHORT,
|
||||
),
|
||||
Tf::Depth32Float => (glow::DEPTH_COMPONENT32F, glow::DEPTH_COMPONENT, glow::FLOAT),
|
||||
Tf::Depth32FloatStencil8 => (
|
||||
glow::DEPTH32F_STENCIL8,
|
||||
glow::DEPTH_STENCIL,
|
||||
glow::FLOAT_32_UNSIGNED_INT_24_8_REV,
|
||||
),
|
||||
Tf::Depth24Plus => (
|
||||
glow::DEPTH_COMPONENT24,
|
||||
glow::DEPTH_COMPONENT,
|
||||
glow::UNSIGNED_INT,
|
||||
),
|
||||
Tf::Depth24PlusStencil8 => (
|
||||
glow::DEPTH24_STENCIL8,
|
||||
glow::DEPTH_STENCIL,
|
||||
glow::UNSIGNED_INT_24_8,
|
||||
),
|
||||
Tf::NV12 => unreachable!(),
|
||||
Tf::P010 => unreachable!(),
|
||||
Tf::Rgb9e5Ufloat => (glow::RGB9_E5, glow::RGB, glow::UNSIGNED_INT_5_9_9_9_REV),
|
||||
Tf::Bc1RgbaUnorm => (glow::COMPRESSED_RGBA_S3TC_DXT1_EXT, glow::RGBA, 0),
|
||||
Tf::Bc1RgbaUnormSrgb => (glow::COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, glow::RGBA, 0),
|
||||
Tf::Bc2RgbaUnorm => (glow::COMPRESSED_RGBA_S3TC_DXT3_EXT, glow::RGBA, 0),
|
||||
Tf::Bc2RgbaUnormSrgb => (glow::COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, glow::RGBA, 0),
|
||||
Tf::Bc3RgbaUnorm => (glow::COMPRESSED_RGBA_S3TC_DXT5_EXT, glow::RGBA, 0),
|
||||
Tf::Bc3RgbaUnormSrgb => (glow::COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, glow::RGBA, 0),
|
||||
Tf::Bc4RUnorm => (glow::COMPRESSED_RED_RGTC1, glow::RED, 0),
|
||||
Tf::Bc4RSnorm => (glow::COMPRESSED_SIGNED_RED_RGTC1, glow::RED, 0),
|
||||
Tf::Bc5RgUnorm => (glow::COMPRESSED_RG_RGTC2, glow::RG, 0),
|
||||
Tf::Bc5RgSnorm => (glow::COMPRESSED_SIGNED_RG_RGTC2, glow::RG, 0),
|
||||
Tf::Bc6hRgbUfloat => (glow::COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, glow::RGB, 0),
|
||||
Tf::Bc6hRgbFloat => (glow::COMPRESSED_RGB_BPTC_SIGNED_FLOAT, glow::RGB, 0),
|
||||
Tf::Bc7RgbaUnorm => (glow::COMPRESSED_RGBA_BPTC_UNORM, glow::RGBA, 0),
|
||||
Tf::Bc7RgbaUnormSrgb => (glow::COMPRESSED_SRGB_ALPHA_BPTC_UNORM, glow::RGBA, 0),
|
||||
Tf::Etc2Rgb8Unorm => (glow::COMPRESSED_RGB8_ETC2, glow::RGB, 0),
|
||||
Tf::Etc2Rgb8UnormSrgb => (glow::COMPRESSED_SRGB8_ETC2, glow::RGB, 0),
|
||||
Tf::Etc2Rgb8A1Unorm => (
|
||||
glow::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
|
||||
glow::RGBA,
|
||||
0,
|
||||
),
|
||||
Tf::Etc2Rgb8A1UnormSrgb => (
|
||||
glow::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
|
||||
glow::RGBA,
|
||||
0,
|
||||
),
|
||||
Tf::Etc2Rgba8Unorm => (glow::COMPRESSED_RGBA8_ETC2_EAC, glow::RGBA, 0),
|
||||
Tf::Etc2Rgba8UnormSrgb => (glow::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, glow::RGBA, 0),
|
||||
Tf::EacR11Unorm => (glow::COMPRESSED_R11_EAC, glow::RED, 0),
|
||||
Tf::EacR11Snorm => (glow::COMPRESSED_SIGNED_R11_EAC, glow::RED, 0),
|
||||
Tf::EacRg11Unorm => (glow::COMPRESSED_RG11_EAC, glow::RG, 0),
|
||||
Tf::EacRg11Snorm => (glow::COMPRESSED_SIGNED_RG11_EAC, glow::RG, 0),
|
||||
Tf::Astc { block, channel } => match channel {
|
||||
AstcChannel::Unorm | AstcChannel::Hdr => match block {
|
||||
AstcBlock::B4x4 => (glow::COMPRESSED_RGBA_ASTC_4x4_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B5x4 => (glow::COMPRESSED_RGBA_ASTC_5x4_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B5x5 => (glow::COMPRESSED_RGBA_ASTC_5x5_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B6x5 => (glow::COMPRESSED_RGBA_ASTC_6x5_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B6x6 => (glow::COMPRESSED_RGBA_ASTC_6x6_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B8x5 => (glow::COMPRESSED_RGBA_ASTC_8x5_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B8x6 => (glow::COMPRESSED_RGBA_ASTC_8x6_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B8x8 => (glow::COMPRESSED_RGBA_ASTC_8x8_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B10x5 => (glow::COMPRESSED_RGBA_ASTC_10x5_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B10x6 => (glow::COMPRESSED_RGBA_ASTC_10x6_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B10x8 => (glow::COMPRESSED_RGBA_ASTC_10x8_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B10x10 => (glow::COMPRESSED_RGBA_ASTC_10x10_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B12x10 => (glow::COMPRESSED_RGBA_ASTC_12x10_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B12x12 => (glow::COMPRESSED_RGBA_ASTC_12x12_KHR, glow::RGBA, 0),
|
||||
},
|
||||
AstcChannel::UnormSrgb => match block {
|
||||
AstcBlock::B4x4 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B5x4 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B5x5 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B6x5 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B6x6 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B8x5 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B8x6 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B8x8 => (glow::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, glow::RGBA, 0),
|
||||
AstcBlock::B10x5 => {
|
||||
(glow::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, glow::RGBA, 0)
|
||||
}
|
||||
AstcBlock::B10x6 => {
|
||||
(glow::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, glow::RGBA, 0)
|
||||
}
|
||||
AstcBlock::B10x8 => {
|
||||
(glow::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, glow::RGBA, 0)
|
||||
}
|
||||
AstcBlock::B10x10 => {
|
||||
(glow::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, glow::RGBA, 0)
|
||||
}
|
||||
AstcBlock::B12x10 => {
|
||||
(glow::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, glow::RGBA, 0)
|
||||
}
|
||||
AstcBlock::B12x12 => {
|
||||
(glow::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, glow::RGBA, 0)
|
||||
}
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
super::TextureFormatDesc {
|
||||
internal,
|
||||
external,
|
||||
data_type,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn describe_vertex_format(vertex_format: wgt::VertexFormat) -> super::VertexFormatDesc {
|
||||
use super::VertexAttribKind as Vak;
|
||||
use wgt::VertexFormat as Vf;
|
||||
|
||||
let (element_count, element_format, attrib_kind) = match vertex_format {
|
||||
Vf::Unorm8 => (1, glow::UNSIGNED_BYTE, Vak::Float),
|
||||
Vf::Snorm8 => (1, glow::BYTE, Vak::Float),
|
||||
Vf::Uint8 => (1, glow::UNSIGNED_BYTE, Vak::Integer),
|
||||
Vf::Sint8 => (1, glow::BYTE, Vak::Integer),
|
||||
Vf::Unorm8x2 => (2, glow::UNSIGNED_BYTE, Vak::Float),
|
||||
Vf::Snorm8x2 => (2, glow::BYTE, Vak::Float),
|
||||
Vf::Uint8x2 => (2, glow::UNSIGNED_BYTE, Vak::Integer),
|
||||
Vf::Sint8x2 => (2, glow::BYTE, Vak::Integer),
|
||||
Vf::Unorm8x4 => (4, glow::UNSIGNED_BYTE, Vak::Float),
|
||||
Vf::Snorm8x4 => (4, glow::BYTE, Vak::Float),
|
||||
Vf::Uint8x4 => (4, glow::UNSIGNED_BYTE, Vak::Integer),
|
||||
Vf::Sint8x4 => (4, glow::BYTE, Vak::Integer),
|
||||
Vf::Unorm16 => (1, glow::UNSIGNED_SHORT, Vak::Float),
|
||||
Vf::Snorm16 => (1, glow::SHORT, Vak::Float),
|
||||
Vf::Uint16 => (1, glow::UNSIGNED_SHORT, Vak::Integer),
|
||||
Vf::Sint16 => (1, glow::SHORT, Vak::Integer),
|
||||
Vf::Float16 => (1, glow::HALF_FLOAT, Vak::Float),
|
||||
Vf::Unorm16x2 => (2, glow::UNSIGNED_SHORT, Vak::Float),
|
||||
Vf::Snorm16x2 => (2, glow::SHORT, Vak::Float),
|
||||
Vf::Uint16x2 => (2, glow::UNSIGNED_SHORT, Vak::Integer),
|
||||
Vf::Sint16x2 => (2, glow::SHORT, Vak::Integer),
|
||||
Vf::Float16x2 => (2, glow::HALF_FLOAT, Vak::Float),
|
||||
Vf::Unorm16x4 => (4, glow::UNSIGNED_SHORT, Vak::Float),
|
||||
Vf::Snorm16x4 => (4, glow::SHORT, Vak::Float),
|
||||
Vf::Uint16x4 => (4, glow::UNSIGNED_SHORT, Vak::Integer),
|
||||
Vf::Sint16x4 => (4, glow::SHORT, Vak::Integer),
|
||||
Vf::Float16x4 => (4, glow::HALF_FLOAT, Vak::Float),
|
||||
Vf::Uint32 => (1, glow::UNSIGNED_INT, Vak::Integer),
|
||||
Vf::Sint32 => (1, glow::INT, Vak::Integer),
|
||||
Vf::Float32 => (1, glow::FLOAT, Vak::Float),
|
||||
Vf::Uint32x2 => (2, glow::UNSIGNED_INT, Vak::Integer),
|
||||
Vf::Sint32x2 => (2, glow::INT, Vak::Integer),
|
||||
Vf::Float32x2 => (2, glow::FLOAT, Vak::Float),
|
||||
Vf::Uint32x3 => (3, glow::UNSIGNED_INT, Vak::Integer),
|
||||
Vf::Sint32x3 => (3, glow::INT, Vak::Integer),
|
||||
Vf::Float32x3 => (3, glow::FLOAT, Vak::Float),
|
||||
Vf::Uint32x4 => (4, glow::UNSIGNED_INT, Vak::Integer),
|
||||
Vf::Sint32x4 => (4, glow::INT, Vak::Integer),
|
||||
Vf::Float32x4 => (4, glow::FLOAT, Vak::Float),
|
||||
Vf::Unorm10_10_10_2 => (4, glow::UNSIGNED_INT_2_10_10_10_REV, Vak::Float),
|
||||
Vf::Unorm8x4Bgra => (glow::BGRA as i32, glow::UNSIGNED_BYTE, Vak::Float),
|
||||
Vf::Float64 | Vf::Float64x2 | Vf::Float64x3 | Vf::Float64x4 => unimplemented!(),
|
||||
};
|
||||
|
||||
super::VertexFormatDesc {
|
||||
element_count,
|
||||
element_format,
|
||||
attrib_kind,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_filter_modes(
|
||||
min: wgt::FilterMode,
|
||||
mag: wgt::FilterMode,
|
||||
mip: wgt::MipmapFilterMode,
|
||||
) -> (u32, u32) {
|
||||
use wgt::FilterMode as Fm;
|
||||
use wgt::MipmapFilterMode as Mfm;
|
||||
|
||||
let mag_filter = match mag {
|
||||
Fm::Nearest => glow::NEAREST,
|
||||
Fm::Linear => glow::LINEAR,
|
||||
};
|
||||
|
||||
let min_filter = match (min, mip) {
|
||||
(Fm::Nearest, Mfm::Nearest) => glow::NEAREST_MIPMAP_NEAREST,
|
||||
(Fm::Nearest, Mfm::Linear) => glow::NEAREST_MIPMAP_LINEAR,
|
||||
(Fm::Linear, Mfm::Nearest) => glow::LINEAR_MIPMAP_NEAREST,
|
||||
(Fm::Linear, Mfm::Linear) => glow::LINEAR_MIPMAP_LINEAR,
|
||||
};
|
||||
|
||||
(min_filter, mag_filter)
|
||||
}
|
||||
|
||||
pub fn map_address_mode(mode: wgt::AddressMode) -> u32 {
|
||||
match mode {
|
||||
wgt::AddressMode::Repeat => glow::REPEAT,
|
||||
wgt::AddressMode::MirrorRepeat => glow::MIRRORED_REPEAT,
|
||||
wgt::AddressMode::ClampToEdge => glow::CLAMP_TO_EDGE,
|
||||
wgt::AddressMode::ClampToBorder => glow::CLAMP_TO_BORDER,
|
||||
//wgt::AddressMode::MirrorClamp => glow::MIRROR_CLAMP_TO_EDGE,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_compare_func(fun: wgt::CompareFunction) -> u32 {
|
||||
use wgt::CompareFunction as Cf;
|
||||
match fun {
|
||||
Cf::Never => glow::NEVER,
|
||||
Cf::Less => glow::LESS,
|
||||
Cf::LessEqual => glow::LEQUAL,
|
||||
Cf::Equal => glow::EQUAL,
|
||||
Cf::GreaterEqual => glow::GEQUAL,
|
||||
Cf::Greater => glow::GREATER,
|
||||
Cf::NotEqual => glow::NOTEQUAL,
|
||||
Cf::Always => glow::ALWAYS,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_primitive_topology(topology: wgt::PrimitiveTopology) -> u32 {
|
||||
use wgt::PrimitiveTopology as Pt;
|
||||
match topology {
|
||||
Pt::PointList => glow::POINTS,
|
||||
Pt::LineList => glow::LINES,
|
||||
Pt::LineStrip => glow::LINE_STRIP,
|
||||
Pt::TriangleList => glow::TRIANGLES,
|
||||
Pt::TriangleStrip => glow::TRIANGLE_STRIP,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn map_primitive_state(state: &wgt::PrimitiveState) -> super::PrimitiveState {
|
||||
super::PrimitiveState {
|
||||
//Note: we are flipping the front face, so that
|
||||
// the Y-flip in the generated GLSL keeps the same visibility.
|
||||
// See `naga::back::glsl::WriterFlags::ADJUST_COORDINATE_SPACE`.
|
||||
front_face: match state.front_face {
|
||||
wgt::FrontFace::Cw => glow::CCW,
|
||||
wgt::FrontFace::Ccw => glow::CW,
|
||||
},
|
||||
cull_face: match state.cull_mode {
|
||||
Some(wgt::Face::Front) => glow::FRONT,
|
||||
Some(wgt::Face::Back) => glow::BACK,
|
||||
None => 0,
|
||||
},
|
||||
unclipped_depth: state.unclipped_depth,
|
||||
polygon_mode: match state.polygon_mode {
|
||||
wgt::PolygonMode::Fill => glow::FILL,
|
||||
wgt::PolygonMode::Line => glow::LINE,
|
||||
wgt::PolygonMode::Point => glow::POINT,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn _map_view_dimension(dim: wgt::TextureViewDimension) -> u32 {
|
||||
use wgt::TextureViewDimension as Tvd;
|
||||
match dim {
|
||||
Tvd::D1 | Tvd::D2 => glow::TEXTURE_2D,
|
||||
Tvd::D2Array => glow::TEXTURE_2D_ARRAY,
|
||||
Tvd::Cube => glow::TEXTURE_CUBE_MAP,
|
||||
Tvd::CubeArray => glow::TEXTURE_CUBE_MAP_ARRAY,
|
||||
Tvd::D3 => glow::TEXTURE_3D,
|
||||
}
|
||||
}
|
||||
|
||||
fn map_stencil_op(operation: wgt::StencilOperation) -> u32 {
|
||||
use wgt::StencilOperation as So;
|
||||
match operation {
|
||||
So::Keep => glow::KEEP,
|
||||
So::Zero => glow::ZERO,
|
||||
So::Replace => glow::REPLACE,
|
||||
So::Invert => glow::INVERT,
|
||||
So::IncrementClamp => glow::INCR,
|
||||
So::DecrementClamp => glow::DECR,
|
||||
So::IncrementWrap => glow::INCR_WRAP,
|
||||
So::DecrementWrap => glow::DECR_WRAP,
|
||||
}
|
||||
}
|
||||
|
||||
fn map_stencil_ops(face: &wgt::StencilFaceState) -> super::StencilOps {
|
||||
super::StencilOps {
|
||||
pass: map_stencil_op(face.pass_op),
|
||||
fail: map_stencil_op(face.fail_op),
|
||||
depth_fail: map_stencil_op(face.depth_fail_op),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn map_stencil(state: &wgt::StencilState) -> super::StencilState {
|
||||
super::StencilState {
|
||||
front: super::StencilSide {
|
||||
function: map_compare_func(state.front.compare),
|
||||
mask_read: state.read_mask,
|
||||
mask_write: state.write_mask,
|
||||
reference: 0,
|
||||
ops: map_stencil_ops(&state.front),
|
||||
},
|
||||
back: super::StencilSide {
|
||||
function: map_compare_func(state.back.compare),
|
||||
mask_read: state.read_mask,
|
||||
mask_write: state.write_mask,
|
||||
reference: 0,
|
||||
ops: map_stencil_ops(&state.back),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn map_blend_factor(factor: wgt::BlendFactor) -> u32 {
|
||||
use wgt::BlendFactor as Bf;
|
||||
match factor {
|
||||
Bf::Zero => glow::ZERO,
|
||||
Bf::One => glow::ONE,
|
||||
Bf::Src => glow::SRC_COLOR,
|
||||
Bf::OneMinusSrc => glow::ONE_MINUS_SRC_COLOR,
|
||||
Bf::Dst => glow::DST_COLOR,
|
||||
Bf::OneMinusDst => glow::ONE_MINUS_DST_COLOR,
|
||||
Bf::SrcAlpha => glow::SRC_ALPHA,
|
||||
Bf::OneMinusSrcAlpha => glow::ONE_MINUS_SRC_ALPHA,
|
||||
Bf::DstAlpha => glow::DST_ALPHA,
|
||||
Bf::OneMinusDstAlpha => glow::ONE_MINUS_DST_ALPHA,
|
||||
Bf::Constant => glow::CONSTANT_COLOR,
|
||||
Bf::OneMinusConstant => glow::ONE_MINUS_CONSTANT_COLOR,
|
||||
Bf::SrcAlphaSaturated => glow::SRC_ALPHA_SATURATE,
|
||||
Bf::Src1 => glow::SRC1_COLOR,
|
||||
Bf::OneMinusSrc1 => glow::ONE_MINUS_SRC1_COLOR,
|
||||
Bf::Src1Alpha => glow::SRC1_ALPHA,
|
||||
Bf::OneMinusSrc1Alpha => glow::ONE_MINUS_SRC1_ALPHA,
|
||||
}
|
||||
}
|
||||
|
||||
fn map_blend_component(component: &wgt::BlendComponent) -> super::BlendComponent {
|
||||
super::BlendComponent {
|
||||
src: map_blend_factor(component.src_factor),
|
||||
dst: map_blend_factor(component.dst_factor),
|
||||
equation: match component.operation {
|
||||
wgt::BlendOperation::Add => glow::FUNC_ADD,
|
||||
wgt::BlendOperation::Subtract => glow::FUNC_SUBTRACT,
|
||||
wgt::BlendOperation::ReverseSubtract => glow::FUNC_REVERSE_SUBTRACT,
|
||||
wgt::BlendOperation::Min => glow::MIN,
|
||||
wgt::BlendOperation::Max => glow::MAX,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn map_blend(blend: &wgt::BlendState) -> super::BlendDesc {
|
||||
super::BlendDesc {
|
||||
color: map_blend_component(&blend.color),
|
||||
alpha: map_blend_component(&blend.alpha),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn map_storage_access(access: wgt::StorageTextureAccess) -> u32 {
|
||||
match access {
|
||||
wgt::StorageTextureAccess::ReadOnly => glow::READ_ONLY,
|
||||
wgt::StorageTextureAccess::WriteOnly => glow::WRITE_ONLY,
|
||||
wgt::StorageTextureAccess::ReadWrite => glow::READ_WRITE,
|
||||
wgt::StorageTextureAccess::Atomic => glow::READ_WRITE,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn is_layered_target(target: u32) -> bool {
|
||||
match target {
|
||||
glow::TEXTURE_2D | glow::TEXTURE_CUBE_MAP => false,
|
||||
glow::TEXTURE_2D_ARRAY | glow::TEXTURE_CUBE_MAP_ARRAY | glow::TEXTURE_3D => true,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
Vendored
+1823
File diff suppressed because it is too large.
Load diff
Vendored
+1470
File diff suppressed because it is too large.
Load diff
+26
@@ -0,0 +1,26 @@
|
||||
extern "C" {
|
||||
/// returns 1 if success. 0 if failure. extension name must be null terminated
|
||||
fn emscripten_webgl_enable_extension(
|
||||
context: core::ffi::c_int,
|
||||
extension: *const core::ffi::c_char,
|
||||
) -> core::ffi::c_int;
|
||||
fn emscripten_webgl_get_current_context() -> core::ffi::c_int;
|
||||
}
|
||||
/// Webgl requires extensions to be enabled before using them.
|
||||
/// This function can be used to enable webgl extension on emscripten target.
|
||||
///
|
||||
/// returns true on success
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// - opengl context MUST BE current
|
||||
/// - extension_name_null_terminated argument must be a valid string with null terminator.
|
||||
/// - extension must be present. check `glow_context.supported_extensions()`
|
||||
pub unsafe fn enable_extension(extension_name_null_terminated: &str) -> bool {
|
||||
unsafe {
|
||||
emscripten_webgl_enable_extension(
|
||||
emscripten_webgl_get_current_context(),
|
||||
extension_name_null_terminated.as_ptr().cast(),
|
||||
) == 1
|
||||
}
|
||||
}
|
||||
Vendored
+198
@@ -0,0 +1,198 @@
|
||||
use alloc::{sync::Arc, vec::Vec};
|
||||
use core::sync::atomic::Ordering;
|
||||
use parking_lot::RwLock;
|
||||
|
||||
use glow::HasContext;
|
||||
|
||||
use crate::AtomicFenceValue;
|
||||
|
||||
#[derive(Debug)]
|
||||
struct GLFence {
|
||||
// Since a fence can be `Copy`ed, there can exist some
|
||||
// cases where a fence could be destroyed while something
|
||||
// else is still using it. Therefore, while a function is
|
||||
// using this fence (and doesn't keep pending read locked),
|
||||
// it should clone the `Arc` to show it needs this to
|
||||
// stay alive.
|
||||
//
|
||||
// The arc should not be kept after a function has finished
|
||||
sync: Arc<glow::Fence>,
|
||||
value: crate::FenceValue,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Fence {
|
||||
last_completed: AtomicFenceValue,
|
||||
pending: RwLock<Vec<GLFence>>,
|
||||
fence_behavior: wgt::GlFenceBehavior,
|
||||
}
|
||||
|
||||
impl crate::DynFence for Fence {}
|
||||
|
||||
#[cfg(send_sync)]
|
||||
unsafe impl Send for Fence {}
|
||||
#[cfg(send_sync)]
|
||||
unsafe impl Sync for Fence {}
|
||||
|
||||
impl Fence {
|
||||
pub fn new(options: &wgt::GlBackendOptions) -> Self {
|
||||
Self {
|
||||
last_completed: AtomicFenceValue::new(0),
|
||||
pending: RwLock::new(Vec::new()),
|
||||
fence_behavior: options.fence_behavior,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn signal(
|
||||
&self,
|
||||
gl: &glow::Context,
|
||||
value: crate::FenceValue,
|
||||
) -> Result<(), crate::DeviceError> {
|
||||
if self.fence_behavior.is_auto_finish() {
|
||||
self.last_completed.store(value, Ordering::Release);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let sync = unsafe { gl.fence_sync(glow::SYNC_GPU_COMMANDS_COMPLETE, 0) }
|
||||
.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
self.pending.write().push(GLFence {
|
||||
sync: Arc::new(sync),
|
||||
value,
|
||||
});
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn satisfied(&self, value: crate::FenceValue) -> bool {
|
||||
self.last_completed.load(Ordering::Acquire) >= value
|
||||
}
|
||||
|
||||
pub fn get_latest(&self, gl: &glow::Context) -> crate::FenceValue {
|
||||
let mut max_value = self.last_completed.load(Ordering::Acquire);
|
||||
|
||||
if self.fence_behavior.is_auto_finish() {
|
||||
return max_value;
|
||||
}
|
||||
|
||||
let pending = self.pending.read();
|
||||
|
||||
for gl_fence in pending.iter() {
|
||||
if gl_fence.value <= max_value {
|
||||
// We already know this was good, no need to check again
|
||||
continue;
|
||||
}
|
||||
// We have pending `read` locked, so we shouldn't have to clone it.
|
||||
let status = unsafe { gl.get_sync_status(*gl_fence.sync) };
|
||||
if status == glow::SIGNALED {
|
||||
max_value = gl_fence.value;
|
||||
} else {
|
||||
// Anything after the first unsignalled is guaranteed to also be unsignalled
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Track the latest value, to save ourselves some querying later
|
||||
self.last_completed.fetch_max(max_value, Ordering::AcqRel);
|
||||
|
||||
max_value
|
||||
}
|
||||
|
||||
pub fn maintain(&self, gl: &glow::Context) {
|
||||
if self.fence_behavior.is_auto_finish() {
|
||||
return;
|
||||
}
|
||||
|
||||
let latest = self.get_latest(gl);
|
||||
let mut pending = self.pending.write();
|
||||
pending.retain_mut(|gl_fence| {
|
||||
if gl_fence.value > latest {
|
||||
true
|
||||
} else if let Some(fence) = Arc::get_mut(&mut gl_fence.sync) {
|
||||
unsafe {
|
||||
gl.delete_sync(*fence);
|
||||
}
|
||||
false
|
||||
} else {
|
||||
// Another function is currently using this value. In general, these should finish
|
||||
// very quickly (for wait because the fence should already be signaled, an all
|
||||
// others are just fast), but submit should be very fast, so we shouldn't block on
|
||||
// this.
|
||||
true
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
pub fn wait(
|
||||
&self,
|
||||
gl: &glow::Context,
|
||||
wait_value: crate::FenceValue,
|
||||
timeout_ns: u32,
|
||||
) -> Result<bool, crate::DeviceError> {
|
||||
let last_completed = self.last_completed.load(Ordering::Acquire);
|
||||
|
||||
if self.fence_behavior.is_auto_finish() {
|
||||
return Ok(last_completed >= wait_value);
|
||||
}
|
||||
|
||||
// We already know this fence has been signalled to that value. Return signalled.
|
||||
if last_completed >= wait_value {
|
||||
return Ok(true);
|
||||
}
|
||||
|
||||
let pending = self.pending.read();
|
||||
|
||||
// Find a matching fence
|
||||
let gl_fence = pending.iter().find(|gl_fence| gl_fence.value >= wait_value);
|
||||
|
||||
let Some(gl_fence) = gl_fence else {
|
||||
log::warn!("Tried to wait for {wait_value} but that value has not been signalled yet");
|
||||
return Ok(false);
|
||||
};
|
||||
|
||||
// clone to show we're using the fence
|
||||
let sync = gl_fence.sync.clone();
|
||||
let fence_value = gl_fence.value;
|
||||
|
||||
drop(pending);
|
||||
|
||||
let status = unsafe {
|
||||
gl.client_wait_sync(
|
||||
*sync,
|
||||
glow::SYNC_FLUSH_COMMANDS_BIT,
|
||||
timeout_ns.min(i32::MAX as u32) as i32,
|
||||
)
|
||||
};
|
||||
|
||||
drop(sync);
|
||||
|
||||
let signalled = match status {
|
||||
glow::ALREADY_SIGNALED | glow::CONDITION_SATISFIED => true,
|
||||
glow::TIMEOUT_EXPIRED | glow::WAIT_FAILED => false,
|
||||
_ => {
|
||||
log::warn!("Unexpected result from client_wait_sync: {status}");
|
||||
false
|
||||
}
|
||||
};
|
||||
|
||||
if signalled {
|
||||
self.last_completed.fetch_max(fence_value, Ordering::AcqRel);
|
||||
}
|
||||
|
||||
Ok(signalled)
|
||||
}
|
||||
|
||||
pub fn destroy(self, gl: &glow::Context) {
|
||||
if self.fence_behavior.is_auto_finish() {
|
||||
return;
|
||||
}
|
||||
|
||||
for gl_fence in self.pending.into_inner() {
|
||||
unsafe {
|
||||
gl.delete_sync(
|
||||
Arc::into_inner(gl_fence.sync)
|
||||
.expect("A function has failed to drop all its references to this"),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Vendored
+1215
File diff suppressed because it is too large.
Load diff
Vendored
+1980
File diff suppressed because it is too large.
Load diff
+7
@@ -0,0 +1,7 @@
|
||||
uniform vec4 color;
|
||||
//Hack: Some WebGL implementations don't find "color" otherwise.
|
||||
uniform vec4 color_workaround;
|
||||
out vec4 frag;
|
||||
void main() {
|
||||
frag = color + color_workaround;
|
||||
}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
// A triangle that fills the whole screen
|
||||
vec2[3] TRIANGLE_POS = vec2[](
|
||||
vec2( 0.0, -3.0),
|
||||
vec2(-3.0, 1.0),
|
||||
vec2( 3.0, 1.0)
|
||||
);
|
||||
void main() {
|
||||
gl_Position = vec4(TRIANGLE_POS[gl_VertexID], 0.0, 1.0);
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#version 300 es
|
||||
precision mediump float;
|
||||
in vec2 uv;
|
||||
uniform sampler2D present_texture;
|
||||
out vec4 frag;
|
||||
vec4 linear_to_srgb(vec4 linear) {
|
||||
vec3 color_linear = linear.rgb;
|
||||
vec3 selector = ceil(color_linear - 0.0031308); // 0 if under value, 1 if over
|
||||
vec3 under = 12.92 * color_linear;
|
||||
vec3 over = 1.055 * pow(color_linear, vec3(0.41666)) - 0.055;
|
||||
vec3 result = mix(under, over, selector);
|
||||
return vec4(result, linear.a);
|
||||
}
|
||||
void main() {
|
||||
frag = linear_to_srgb(texture(present_texture, uv));
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
#version 300 es
|
||||
precision mediump float;
|
||||
// A triangle that fills the whole screen
|
||||
const vec2[3] TRIANGLE_POS = vec2[](
|
||||
vec2( 0.0, -3.0),
|
||||
vec2(-3.0, 1.0),
|
||||
vec2( 3.0, 1.0)
|
||||
);
|
||||
const vec2[3] TRIANGLE_UV = vec2[](
|
||||
vec2( 0.5, 1.),
|
||||
vec2( -1.0, -1.0),
|
||||
vec2( 2.0, -1.0)
|
||||
);
|
||||
out vec2 uv;
|
||||
void main() {
|
||||
uv = TRIANGLE_UV[gl_VertexID];
|
||||
gl_Position = vec4(TRIANGLE_POS[gl_VertexID], 0.0, 1.0);
|
||||
}
|
||||
Vendored
+490
@@ -0,0 +1,490 @@
|
||||
use alloc::{format, string::String, vec::Vec};
|
||||
|
||||
use glow::HasContext;
|
||||
use parking_lot::{Mutex, RwLock};
|
||||
use wasm_bindgen::{JsCast, JsValue};
|
||||
|
||||
use super::TextureFormatDesc;
|
||||
|
||||
/// A wrapper around a [`glow::Context`] to provide a fake `lock()` api that makes it compatible
|
||||
/// with the `AdapterContext` API from the EGL implementation.
|
||||
#[derive(Debug)]
|
||||
pub struct AdapterContext {
|
||||
pub glow_context: glow::Context,
|
||||
pub webgl2_context: web_sys::WebGl2RenderingContext,
|
||||
}
|
||||
|
||||
impl AdapterContext {
|
||||
pub fn is_owned(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
/// Obtain a lock to the EGL context and get handle to the [`glow::Context`] that can be used to
|
||||
/// do rendering.
|
||||
#[track_caller]
|
||||
pub fn lock(&self) -> &glow::Context {
|
||||
&self.glow_context
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Instance {
|
||||
options: wgt::GlBackendOptions,
|
||||
}
|
||||
|
||||
impl Instance {
|
||||
pub fn create_surface_from_canvas(
|
||||
&self,
|
||||
canvas: web_sys::HtmlCanvasElement,
|
||||
) -> Result<Surface, crate::InstanceError> {
|
||||
let result =
|
||||
canvas.get_context_with_context_options("webgl2", &Self::create_context_options());
|
||||
self.create_surface_from_context(Canvas::Canvas(canvas), result)
|
||||
}
|
||||
|
||||
pub fn create_surface_from_offscreen_canvas(
|
||||
&self,
|
||||
canvas: web_sys::OffscreenCanvas,
|
||||
) -> Result<Surface, crate::InstanceError> {
|
||||
let result =
|
||||
canvas.get_context_with_context_options("webgl2", &Self::create_context_options());
|
||||
self.create_surface_from_context(Canvas::Offscreen(canvas), result)
|
||||
}
|
||||
|
||||
/// Common portion of public `create_surface_from_*` functions.
|
||||
///
|
||||
/// Note: Analogous code also exists in the WebGPU backend at
|
||||
/// `wgpu::backend::web::Context`.
|
||||
fn create_surface_from_context(
|
||||
&self,
|
||||
canvas: Canvas,
|
||||
context_result: Result<Option<js_sys::Object>, JsValue>,
|
||||
) -> Result<Surface, crate::InstanceError> {
|
||||
let context_object: js_sys::Object = match context_result {
|
||||
Ok(Some(context)) => context,
|
||||
Ok(None) => {
|
||||
// <https://html.spec.whatwg.org/multipage/canvas.html#dom-canvas-getcontext-dev>
|
||||
// A getContext() call “returns null if contextId is not supported, or if the
|
||||
// canvas has already been initialized with another context type”. Additionally,
|
||||
// “not supported” could include “insufficient GPU resources” or “the GPU process
|
||||
// previously crashed”. So, we must return it as an `Err` since it could occur
|
||||
// for circumstances outside the application author's control.
|
||||
return Err(crate::InstanceError::new(String::from(concat!(
|
||||
"canvas.getContext() returned null; ",
|
||||
"webgl2 not available or canvas already in use"
|
||||
))));
|
||||
}
|
||||
Err(js_error) => {
|
||||
// <https://html.spec.whatwg.org/multipage/canvas.html#dom-canvas-getcontext>
|
||||
// A thrown exception indicates misuse of the canvas state.
|
||||
return Err(crate::InstanceError::new(format!(
|
||||
"canvas.getContext() threw exception {js_error:?}",
|
||||
)));
|
||||
}
|
||||
};
|
||||
|
||||
// Not returning this error because it is a type error that shouldn't happen unless
|
||||
// the browser, JS builtin objects, or wasm bindings are misbehaving somehow.
|
||||
let webgl2_context: web_sys::WebGl2RenderingContext = context_object
|
||||
.dyn_into()
|
||||
.expect("canvas context is not a WebGl2RenderingContext");
|
||||
|
||||
Ok(Surface {
|
||||
canvas,
|
||||
webgl2_context,
|
||||
srgb_present_program: Mutex::new(None),
|
||||
swapchain: RwLock::new(None),
|
||||
texture: Mutex::new(None),
|
||||
presentable: true,
|
||||
})
|
||||
}
|
||||
|
||||
fn create_context_options() -> js_sys::Object {
|
||||
let context_options = js_sys::Object::new();
|
||||
js_sys::Reflect::set(&context_options, &"antialias".into(), &JsValue::FALSE)
|
||||
.expect("Cannot create context options");
|
||||
context_options
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(send_sync)]
|
||||
static_assertions::assert_impl_all!(Instance: Send, Sync);
|
||||
|
||||
impl crate::Instance for Instance {
|
||||
type A = super::Api;
|
||||
|
||||
unsafe fn init(desc: &crate::InstanceDescriptor<'_>) -> Result<Self, crate::InstanceError> {
|
||||
profiling::scope!("Init OpenGL (WebGL) Backend");
|
||||
Ok(Instance {
|
||||
options: desc.backend_options.gl.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn enumerate_adapters(
|
||||
&self,
|
||||
surface_hint: Option<&Surface>,
|
||||
) -> Vec<crate::ExposedAdapter<super::Api>> {
|
||||
if let Some(surface_hint) = surface_hint {
|
||||
let gl = glow::Context::from_webgl2_context(surface_hint.webgl2_context.clone());
|
||||
|
||||
unsafe {
|
||||
super::Adapter::expose(
|
||||
AdapterContext {
|
||||
glow_context: gl,
|
||||
webgl2_context: surface_hint.webgl2_context.clone(),
|
||||
},
|
||||
self.options.clone(),
|
||||
)
|
||||
}
|
||||
.into_iter()
|
||||
.collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn create_surface(
|
||||
&self,
|
||||
_display_handle: raw_window_handle::RawDisplayHandle,
|
||||
window_handle: raw_window_handle::RawWindowHandle,
|
||||
) -> Result<Surface, crate::InstanceError> {
|
||||
let canvas: web_sys::HtmlCanvasElement = match window_handle {
|
||||
raw_window_handle::RawWindowHandle::Web(handle) => web_sys::window()
|
||||
.and_then(|win| win.document())
|
||||
.expect("Cannot get document")
|
||||
.query_selector(&format!("canvas[data-raw-handle=\"{}\"]", handle.id))
|
||||
.expect("Cannot query for canvas")
|
||||
.expect("Canvas is not found")
|
||||
.dyn_into()
|
||||
.expect("Failed to downcast to canvas type"),
|
||||
raw_window_handle::RawWindowHandle::WebCanvas(handle) => {
|
||||
let value: &JsValue = unsafe { handle.obj.cast().as_ref() };
|
||||
value.clone().unchecked_into()
|
||||
}
|
||||
raw_window_handle::RawWindowHandle::WebOffscreenCanvas(handle) => {
|
||||
let value: &JsValue = unsafe { handle.obj.cast().as_ref() };
|
||||
let canvas: web_sys::OffscreenCanvas = value.clone().unchecked_into();
|
||||
|
||||
return self.create_surface_from_offscreen_canvas(canvas);
|
||||
}
|
||||
_ => {
|
||||
return Err(crate::InstanceError::new(format!(
|
||||
"window handle {window_handle:?} is not a web handle"
|
||||
)))
|
||||
}
|
||||
};
|
||||
|
||||
self.create_surface_from_canvas(canvas)
|
||||
}
|
||||
}
|
||||
|
||||
impl super::Adapter {
|
||||
/// Creates a new external adapter from an existing WebGL2 rendering context.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// - The underlying WebGL2 context must be valid (not lost).
|
||||
/// - The underlying WebGL2 context must be valid when interfacing with any objects returned by
|
||||
/// wgpu-hal from this adapter.
|
||||
/// - The underlying WebGL2 context must be valid when dropping this adapter and when
|
||||
/// dropping any objects returned from this adapter.
|
||||
pub unsafe fn new_external(
|
||||
webgl2_context: web_sys::WebGl2RenderingContext,
|
||||
options: wgt::GlBackendOptions,
|
||||
) -> Option<crate::ExposedAdapter<super::Api>> {
|
||||
let glow_context = glow::Context::from_webgl2_context(webgl2_context.clone());
|
||||
unsafe {
|
||||
Self::expose(
|
||||
AdapterContext {
|
||||
glow_context,
|
||||
webgl2_context,
|
||||
},
|
||||
options,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn adapter_context(&self) -> &AdapterContext {
|
||||
&self.shared.context
|
||||
}
|
||||
}
|
||||
|
||||
impl super::Device {
|
||||
/// Returns the underlying WebGL2 `AdapterContext`.
|
||||
pub fn context(&self) -> &AdapterContext {
|
||||
&self.shared.context
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Surface {
|
||||
canvas: Canvas,
|
||||
pub(super) webgl2_context: web_sys::WebGl2RenderingContext,
|
||||
pub(super) swapchain: RwLock<Option<Swapchain>>,
|
||||
texture: Mutex<Option<glow::Texture>>,
|
||||
pub(super) presentable: bool,
|
||||
srgb_present_program: Mutex<Option<glow::Program>>,
|
||||
}
|
||||
|
||||
impl Clone for Surface {
|
||||
fn clone(&self) -> Self {
|
||||
Self {
|
||||
canvas: self.canvas.clone(),
|
||||
webgl2_context: self.webgl2_context.clone(),
|
||||
swapchain: RwLock::new(self.swapchain.read().clone()),
|
||||
texture: Mutex::new(*self.texture.lock()),
|
||||
presentable: self.presentable,
|
||||
srgb_present_program: Mutex::new(*self.srgb_present_program.lock()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(send_sync)]
|
||||
unsafe impl Sync for Surface {}
|
||||
#[cfg(send_sync)]
|
||||
unsafe impl Send for Surface {}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum Canvas {
|
||||
Canvas(web_sys::HtmlCanvasElement),
|
||||
Offscreen(web_sys::OffscreenCanvas),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Swapchain {
|
||||
pub(crate) extent: wgt::Extent3d,
|
||||
// pub(crate) channel: f::ChannelType,
|
||||
pub(super) format: wgt::TextureFormat,
|
||||
pub(super) framebuffer: glow::Framebuffer,
|
||||
pub(super) format_desc: TextureFormatDesc,
|
||||
}
|
||||
|
||||
impl Surface {
|
||||
pub(super) unsafe fn present(
|
||||
&self,
|
||||
_suf_texture: super::Texture,
|
||||
context: &AdapterContext,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
let gl = &context.glow_context;
|
||||
let swapchain = self.swapchain.read();
|
||||
let swapchain = swapchain.as_ref().ok_or(crate::SurfaceError::Other(
|
||||
"need to configure surface before presenting",
|
||||
))?;
|
||||
|
||||
if swapchain.format.is_srgb() {
|
||||
// Important to set the viewport since we don't know in what state the user left it.
|
||||
unsafe {
|
||||
gl.viewport(
|
||||
0,
|
||||
0,
|
||||
swapchain.extent.width as _,
|
||||
swapchain.extent.height as _,
|
||||
)
|
||||
};
|
||||
unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None) };
|
||||
unsafe { gl.bind_sampler(0, None) };
|
||||
unsafe { gl.active_texture(glow::TEXTURE0) };
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, *self.texture.lock()) };
|
||||
unsafe { gl.use_program(*self.srgb_present_program.lock()) };
|
||||
unsafe { gl.disable(glow::DEPTH_TEST) };
|
||||
unsafe { gl.disable(glow::STENCIL_TEST) };
|
||||
unsafe { gl.disable(glow::SCISSOR_TEST) };
|
||||
unsafe { gl.disable(glow::BLEND) };
|
||||
unsafe { gl.disable(glow::CULL_FACE) };
|
||||
unsafe { gl.draw_buffers(&[glow::BACK]) };
|
||||
unsafe { gl.draw_arrays(glow::TRIANGLES, 0, 3) };
|
||||
} else {
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(swapchain.framebuffer)) };
|
||||
unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None) };
|
||||
// Note the Y-flipping here. GL's presentation is not flipped,
|
||||
// but main rendering is. Therefore, we Y-flip the output positions
|
||||
// in the shader, and also this blit.
|
||||
unsafe {
|
||||
gl.blit_framebuffer(
|
||||
0,
|
||||
swapchain.extent.height as i32,
|
||||
swapchain.extent.width as i32,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
swapchain.extent.width as i32,
|
||||
swapchain.extent.height as i32,
|
||||
glow::COLOR_BUFFER_BIT,
|
||||
glow::NEAREST,
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn create_srgb_present_program(gl: &glow::Context) -> glow::Program {
|
||||
let program = unsafe { gl.create_program() }.expect("Could not create shader program");
|
||||
let vertex =
|
||||
unsafe { gl.create_shader(glow::VERTEX_SHADER) }.expect("Could not create shader");
|
||||
unsafe { gl.shader_source(vertex, include_str!("./shaders/srgb_present.vert")) };
|
||||
unsafe { gl.compile_shader(vertex) };
|
||||
let fragment =
|
||||
unsafe { gl.create_shader(glow::FRAGMENT_SHADER) }.expect("Could not create shader");
|
||||
unsafe { gl.shader_source(fragment, include_str!("./shaders/srgb_present.frag")) };
|
||||
unsafe { gl.compile_shader(fragment) };
|
||||
unsafe { gl.attach_shader(program, vertex) };
|
||||
unsafe { gl.attach_shader(program, fragment) };
|
||||
unsafe { gl.link_program(program) };
|
||||
unsafe { gl.delete_shader(vertex) };
|
||||
unsafe { gl.delete_shader(fragment) };
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, None) };
|
||||
|
||||
program
|
||||
}
|
||||
|
||||
pub fn supports_srgb(&self) -> bool {
|
||||
// present.frag takes care of handling srgb conversion
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::Surface for Surface {
|
||||
type A = super::Api;
|
||||
|
||||
unsafe fn configure(
|
||||
&self,
|
||||
device: &super::Device,
|
||||
config: &crate::SurfaceConfiguration,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
match self.canvas {
|
||||
Canvas::Canvas(ref canvas) => {
|
||||
canvas.set_width(config.extent.width);
|
||||
canvas.set_height(config.extent.height);
|
||||
}
|
||||
Canvas::Offscreen(ref canvas) => {
|
||||
canvas.set_width(config.extent.width);
|
||||
canvas.set_height(config.extent.height);
|
||||
}
|
||||
}
|
||||
|
||||
let gl = &device.shared.context.lock();
|
||||
|
||||
{
|
||||
let mut swapchain = self.swapchain.write();
|
||||
if let Some(swapchain) = swapchain.take() {
|
||||
// delete all frame buffers already allocated
|
||||
unsafe { gl.delete_framebuffer(swapchain.framebuffer) };
|
||||
}
|
||||
}
|
||||
{
|
||||
let mut srgb_present_program = self.srgb_present_program.lock();
|
||||
if srgb_present_program.is_none() && config.format.is_srgb() {
|
||||
*srgb_present_program = Some(unsafe { Self::create_srgb_present_program(gl) });
|
||||
}
|
||||
}
|
||||
{
|
||||
let mut texture = self.texture.lock();
|
||||
if let Some(texture) = texture.take() {
|
||||
unsafe { gl.delete_texture(texture) };
|
||||
}
|
||||
|
||||
*texture = Some(unsafe { gl.create_texture() }.map_err(|error| {
|
||||
log::error!("Internal swapchain texture creation failed: {error}");
|
||||
crate::DeviceError::OutOfMemory
|
||||
})?);
|
||||
|
||||
let desc = device.shared.describe_texture_format(config.format);
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, *texture) };
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(
|
||||
glow::TEXTURE_2D,
|
||||
glow::TEXTURE_MIN_FILTER,
|
||||
glow::NEAREST as _,
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(
|
||||
glow::TEXTURE_2D,
|
||||
glow::TEXTURE_MAG_FILTER,
|
||||
glow::NEAREST as _,
|
||||
)
|
||||
};
|
||||
unsafe {
|
||||
gl.tex_storage_2d(
|
||||
glow::TEXTURE_2D,
|
||||
1,
|
||||
desc.internal,
|
||||
config.extent.width as i32,
|
||||
config.extent.height as i32,
|
||||
)
|
||||
};
|
||||
|
||||
let framebuffer = unsafe { gl.create_framebuffer() }.map_err(|error| {
|
||||
log::error!("Internal swapchain framebuffer creation failed: {error}");
|
||||
crate::DeviceError::OutOfMemory
|
||||
})?;
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(framebuffer)) };
|
||||
unsafe {
|
||||
gl.framebuffer_texture_2d(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
glow::TEXTURE_2D,
|
||||
*texture,
|
||||
0,
|
||||
)
|
||||
};
|
||||
unsafe { gl.bind_texture(glow::TEXTURE_2D, None) };
|
||||
|
||||
let mut swapchain = self.swapchain.write();
|
||||
*swapchain = Some(Swapchain {
|
||||
extent: config.extent,
|
||||
// channel: config.format.base_format().1,
|
||||
format: config.format,
|
||||
format_desc: desc,
|
||||
framebuffer,
|
||||
});
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn unconfigure(&self, device: &super::Device) {
|
||||
let gl = device.shared.context.lock();
|
||||
{
|
||||
let mut swapchain = self.swapchain.write();
|
||||
if let Some(swapchain) = swapchain.take() {
|
||||
unsafe { gl.delete_framebuffer(swapchain.framebuffer) };
|
||||
}
|
||||
}
|
||||
if let Some(renderbuffer) = self.texture.lock().take() {
|
||||
unsafe { gl.delete_texture(renderbuffer) };
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn acquire_texture(
|
||||
&self,
|
||||
_timeout_ms: Option<core::time::Duration>, //TODO
|
||||
_fence: &super::Fence,
|
||||
) -> Result<crate::AcquiredSurfaceTexture<super::Api>, crate::SurfaceError> {
|
||||
let swapchain = self.swapchain.read();
|
||||
let sc = swapchain.as_ref().unwrap();
|
||||
let texture = super::Texture {
|
||||
inner: super::TextureInner::Texture {
|
||||
raw: self.texture.lock().unwrap(),
|
||||
target: glow::TEXTURE_2D,
|
||||
},
|
||||
drop_guard: None,
|
||||
array_layer_count: 1,
|
||||
mip_level_count: 1,
|
||||
format: sc.format,
|
||||
format_desc: sc.format_desc.clone(),
|
||||
copy_size: crate::CopyExtent {
|
||||
width: sc.extent.width,
|
||||
height: sc.extent.height,
|
||||
depth: 1,
|
||||
},
|
||||
};
|
||||
Ok(crate::AcquiredSurfaceTexture {
|
||||
texture,
|
||||
suboptimal: false,
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn discard_texture(&self, _texture: super::Texture) {}
|
||||
}
|
||||
Vendored
+905
@@ -0,0 +1,905 @@
|
||||
#![expect(
|
||||
missing_debug_implementations,
|
||||
reason = "TODO: someone developing on Windows add Debug impls where possible"
|
||||
)]
|
||||
|
||||
use alloc::{borrow::ToOwned as _, ffi::CString, string::String, sync::Arc, vec::Vec};
|
||||
use core::{
|
||||
ffi::{c_int, c_void, CStr},
|
||||
mem::{self, ManuallyDrop},
|
||||
ptr,
|
||||
time::Duration,
|
||||
};
|
||||
use std::{
|
||||
sync::{
|
||||
mpsc::{sync_channel, SyncSender},
|
||||
LazyLock,
|
||||
},
|
||||
thread,
|
||||
};
|
||||
|
||||
use glow::HasContext;
|
||||
use glutin_wgl_sys::wgl_extra::{
|
||||
Wgl, CONTEXT_CORE_PROFILE_BIT_ARB, CONTEXT_DEBUG_BIT_ARB, CONTEXT_FLAGS_ARB,
|
||||
CONTEXT_PROFILE_MASK_ARB,
|
||||
};
|
||||
use hashbrown::HashSet;
|
||||
use parking_lot::{Mutex, MutexGuard, RwLock};
|
||||
use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
|
||||
use wgt::InstanceFlags;
|
||||
use windows::{
|
||||
core::{Error, PCSTR},
|
||||
Win32::{
|
||||
Foundation,
|
||||
Graphics::{Gdi, OpenGL},
|
||||
System::LibraryLoader,
|
||||
UI::WindowsAndMessaging,
|
||||
},
|
||||
};
|
||||
|
||||
/// The amount of time to wait while trying to obtain a lock to the adapter context
|
||||
const CONTEXT_LOCK_TIMEOUT_SECS: u64 = 1;
|
||||
|
||||
/// A wrapper around a `[`glow::Context`]` and the required WGL context that uses locking to
|
||||
/// guarantee exclusive access when shared with multiple threads.
|
||||
pub struct AdapterContext {
|
||||
inner: Arc<Mutex<Inner>>,
|
||||
}
|
||||
|
||||
#[cfg(send_sync)]
|
||||
static_assertions::assert_impl_all!(AdapterContext: Send, Sync);
|
||||
|
||||
impl AdapterContext {
|
||||
pub fn is_owned(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
pub fn raw_context(&self) -> *mut c_void {
|
||||
match self.inner.lock().context {
|
||||
Some(ref wgl) => wgl.context.0,
|
||||
None => ptr::null_mut(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Obtain a lock to the WGL context and get handle to the [`glow::Context`] that can be used to
|
||||
/// do rendering.
|
||||
#[track_caller]
|
||||
pub fn lock(&self) -> AdapterContextLock<'_> {
|
||||
let inner = self
|
||||
.inner
|
||||
// Don't lock forever. If it takes longer than 1 second to get the lock we've got a
|
||||
// deadlock and should panic to show where we got stuck
|
||||
.try_lock_for(Duration::from_secs(CONTEXT_LOCK_TIMEOUT_SECS))
|
||||
.expect("Could not lock adapter context. This is most-likely a deadlock.");
|
||||
|
||||
if let Some(wgl) = &inner.context {
|
||||
wgl.make_current(inner.device.dc).unwrap()
|
||||
};
|
||||
|
||||
AdapterContextLock { inner }
|
||||
}
|
||||
|
||||
/// Obtain a lock to the WGL context and get handle to the [`glow::Context`] that can be used to
|
||||
/// do rendering.
|
||||
///
|
||||
/// Unlike [`lock`](Self::lock), this accepts a device to pass to `make_current` and exposes the error
|
||||
/// when `make_current` fails.
|
||||
#[track_caller]
|
||||
fn lock_with_dc(&self, device: Gdi::HDC) -> windows::core::Result<AdapterContextLock<'_>> {
|
||||
let inner = self
|
||||
.inner
|
||||
.try_lock_for(Duration::from_secs(CONTEXT_LOCK_TIMEOUT_SECS))
|
||||
.expect("Could not lock adapter context. This is most-likely a deadlock.");
|
||||
|
||||
if let Some(wgl) = &inner.context {
|
||||
wgl.make_current(device)?;
|
||||
}
|
||||
|
||||
Ok(AdapterContextLock { inner })
|
||||
}
|
||||
}
|
||||
|
||||
/// A guard containing a lock to an [`AdapterContext`], while the GL context is kept current.
|
||||
pub struct AdapterContextLock<'a> {
|
||||
inner: MutexGuard<'a, Inner>,
|
||||
}
|
||||
|
||||
impl<'a> core::ops::Deref for AdapterContextLock<'a> {
|
||||
type Target = glow::Context;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.inner.gl
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Drop for AdapterContextLock<'a> {
|
||||
fn drop(&mut self) {
|
||||
if let Some(wgl) = &self.inner.context {
|
||||
wgl.unmake_current().unwrap()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct WglContext {
|
||||
context: OpenGL::HGLRC,
|
||||
}
|
||||
|
||||
impl WglContext {
|
||||
fn make_current(&self, device: Gdi::HDC) -> windows::core::Result<()> {
|
||||
unsafe { OpenGL::wglMakeCurrent(device, self.context) }
|
||||
}
|
||||
|
||||
fn unmake_current(&self) -> windows::core::Result<()> {
|
||||
if unsafe { OpenGL::wglGetCurrentContext() }.is_invalid() {
|
||||
return Ok(());
|
||||
}
|
||||
unsafe { OpenGL::wglMakeCurrent(Default::default(), Default::default()) }
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for WglContext {
|
||||
fn drop(&mut self) {
|
||||
if let Err(e) = unsafe { OpenGL::wglDeleteContext(self.context) } {
|
||||
log::error!("failed to delete WGL context: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Send for WglContext {}
|
||||
unsafe impl Sync for WglContext {}
|
||||
|
||||
struct Inner {
|
||||
gl: ManuallyDrop<glow::Context>,
|
||||
device: InstanceDevice,
|
||||
context: Option<WglContext>,
|
||||
}
|
||||
|
||||
impl Drop for Inner {
|
||||
fn drop(&mut self) {
|
||||
struct CurrentGuard<'a>(&'a WglContext);
|
||||
impl Drop for CurrentGuard<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.unmake_current().unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
// Context must be current when dropped. See safety docs on
|
||||
// `glow::HasContext`.
|
||||
//
|
||||
// NOTE: This is only set to `None` by `Adapter::new_external` which
|
||||
// requires the context to be current when anything that may be holding
|
||||
// the `Arc<AdapterShared>` is dropped.
|
||||
let _guard = self.context.as_ref().map(|wgl| {
|
||||
wgl.make_current(self.device.dc).unwrap();
|
||||
CurrentGuard(wgl)
|
||||
});
|
||||
// SAFETY: Field not used after this.
|
||||
unsafe { ManuallyDrop::drop(&mut self.gl) };
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Send for Inner {}
|
||||
unsafe impl Sync for Inner {}
|
||||
|
||||
pub struct Instance {
|
||||
srgb_capable: bool,
|
||||
options: wgt::GlBackendOptions,
|
||||
inner: Arc<Mutex<Inner>>,
|
||||
}
|
||||
|
||||
#[cfg(send_sync)]
|
||||
static_assertions::assert_impl_all!(Instance: Send, Sync);
|
||||
|
||||
fn load_gl_func(name: &str, module: Option<Foundation::HMODULE>) -> *const c_void {
|
||||
let addr = CString::new(name.as_bytes()).unwrap();
|
||||
let mut ptr = unsafe { OpenGL::wglGetProcAddress(PCSTR(addr.as_ptr().cast())) };
|
||||
if ptr.is_none() {
|
||||
if let Some(module) = module {
|
||||
ptr = unsafe { LibraryLoader::GetProcAddress(module, PCSTR(addr.as_ptr().cast())) };
|
||||
}
|
||||
}
|
||||
ptr.map_or_else(ptr::null_mut, |p| p as *mut c_void)
|
||||
}
|
||||
|
||||
fn get_extensions(extra: &Wgl, dc: Gdi::HDC) -> HashSet<String> {
|
||||
if extra.GetExtensionsStringARB.is_loaded() {
|
||||
unsafe { CStr::from_ptr(extra.GetExtensionsStringARB(dc.0)) }
|
||||
.to_str()
|
||||
.unwrap_or("")
|
||||
} else {
|
||||
""
|
||||
}
|
||||
.split(' ')
|
||||
.map(|s| s.to_owned())
|
||||
.collect()
|
||||
}
|
||||
|
||||
unsafe fn setup_pixel_format(dc: Gdi::HDC) -> Result<(), crate::InstanceError> {
|
||||
{
|
||||
let format = OpenGL::PIXELFORMATDESCRIPTOR {
|
||||
nVersion: 1,
|
||||
nSize: size_of::<OpenGL::PIXELFORMATDESCRIPTOR>() as u16,
|
||||
dwFlags: OpenGL::PFD_DRAW_TO_WINDOW
|
||||
| OpenGL::PFD_SUPPORT_OPENGL
|
||||
| OpenGL::PFD_DOUBLEBUFFER,
|
||||
iPixelType: OpenGL::PFD_TYPE_RGBA,
|
||||
cColorBits: 8,
|
||||
..unsafe { mem::zeroed() }
|
||||
};
|
||||
|
||||
let index = unsafe { OpenGL::ChoosePixelFormat(dc, &format) };
|
||||
if index == 0 {
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("unable to choose pixel format"),
|
||||
Error::from_thread(),
|
||||
));
|
||||
}
|
||||
|
||||
let current = unsafe { OpenGL::GetPixelFormat(dc) };
|
||||
|
||||
if index != current {
|
||||
unsafe { OpenGL::SetPixelFormat(dc, index, &format) }.map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("unable to set pixel format"), e)
|
||||
})?;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
let index = unsafe { OpenGL::GetPixelFormat(dc) };
|
||||
if index == 0 {
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("unable to get pixel format index"),
|
||||
Error::from_thread(),
|
||||
));
|
||||
}
|
||||
let mut format = Default::default();
|
||||
if unsafe {
|
||||
OpenGL::DescribePixelFormat(dc, index, size_of_val(&format) as u32, Some(&mut format))
|
||||
} == 0
|
||||
{
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("unable to read pixel format"),
|
||||
Error::from_thread(),
|
||||
));
|
||||
}
|
||||
|
||||
if !format.dwFlags.contains(OpenGL::PFD_SUPPORT_OPENGL)
|
||||
|| format.iPixelType != OpenGL::PFD_TYPE_RGBA
|
||||
{
|
||||
return Err(crate::InstanceError::new(String::from(
|
||||
"unsuitable pixel format",
|
||||
)));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn create_global_window_class() -> Result<CString, crate::InstanceError> {
|
||||
let instance = unsafe { LibraryLoader::GetModuleHandleA(None) }.map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("unable to get executable instance"), e)
|
||||
})?;
|
||||
|
||||
// Use the address of `UNIQUE` as part of the window class name to ensure different
|
||||
// `wgpu` versions use different names.
|
||||
static UNIQUE: Mutex<u8> = Mutex::new(0);
|
||||
let class_addr: *const _ = &UNIQUE;
|
||||
let name = format!("wgpu Device Class {:x}\0", class_addr as usize);
|
||||
let name = CString::from_vec_with_nul(name.into_bytes()).unwrap();
|
||||
|
||||
// The window class may already be registered if we are a dynamic library that got
|
||||
// unloaded & loaded back into the same process. If so, just skip creation.
|
||||
let already_exists = unsafe {
|
||||
let mut wc = mem::zeroed::<WindowsAndMessaging::WNDCLASSEXA>();
|
||||
WindowsAndMessaging::GetClassInfoExA(
|
||||
Some(instance.into()),
|
||||
PCSTR(name.as_ptr().cast()),
|
||||
&mut wc,
|
||||
)
|
||||
.is_ok()
|
||||
};
|
||||
if already_exists {
|
||||
return Ok(name);
|
||||
}
|
||||
|
||||
// Use a wrapper function for compatibility with `windows-rs`.
|
||||
unsafe extern "system" fn wnd_proc(
|
||||
window: Foundation::HWND,
|
||||
msg: u32,
|
||||
wparam: Foundation::WPARAM,
|
||||
lparam: Foundation::LPARAM,
|
||||
) -> Foundation::LRESULT {
|
||||
unsafe { WindowsAndMessaging::DefWindowProcA(window, msg, wparam, lparam) }
|
||||
}
|
||||
|
||||
let window_class = WindowsAndMessaging::WNDCLASSEXA {
|
||||
cbSize: size_of::<WindowsAndMessaging::WNDCLASSEXA>() as u32,
|
||||
style: WindowsAndMessaging::CS_OWNDC,
|
||||
lpfnWndProc: Some(wnd_proc),
|
||||
cbClsExtra: 0,
|
||||
cbWndExtra: 0,
|
||||
hInstance: instance.into(),
|
||||
hIcon: WindowsAndMessaging::HICON::default(),
|
||||
hCursor: WindowsAndMessaging::HCURSOR::default(),
|
||||
hbrBackground: Gdi::HBRUSH::default(),
|
||||
lpszMenuName: PCSTR::null(),
|
||||
lpszClassName: PCSTR(name.as_ptr().cast()),
|
||||
hIconSm: WindowsAndMessaging::HICON::default(),
|
||||
};
|
||||
|
||||
let atom = unsafe { WindowsAndMessaging::RegisterClassExA(&window_class) };
|
||||
|
||||
if atom == 0 {
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("unable to register window class"),
|
||||
Error::from_thread(),
|
||||
));
|
||||
}
|
||||
|
||||
// We intentionally leak the window class as we only need one per process.
|
||||
|
||||
Ok(name)
|
||||
}
|
||||
|
||||
fn get_global_window_class() -> Result<CString, crate::InstanceError> {
|
||||
static GLOBAL: LazyLock<Result<CString, crate::InstanceError>> =
|
||||
LazyLock::new(create_global_window_class);
|
||||
GLOBAL.clone()
|
||||
}
|
||||
|
||||
struct InstanceDevice {
|
||||
dc: Gdi::HDC,
|
||||
|
||||
/// This is used to keep the thread owning `dc` alive until this struct is dropped.
|
||||
_tx: SyncSender<()>,
|
||||
}
|
||||
|
||||
fn create_instance_device() -> Result<InstanceDevice, crate::InstanceError> {
|
||||
#[derive(Clone, Copy)]
|
||||
// TODO: We can get these SendSync definitions in the upstream metadata if this is the case
|
||||
struct SendDc(Gdi::HDC);
|
||||
unsafe impl Sync for SendDc {}
|
||||
unsafe impl Send for SendDc {}
|
||||
|
||||
struct Window {
|
||||
window: Foundation::HWND,
|
||||
}
|
||||
impl Drop for Window {
|
||||
fn drop(&mut self) {
|
||||
if let Err(e) = unsafe { WindowsAndMessaging::DestroyWindow(self.window) } {
|
||||
log::error!("failed to destroy window: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let window_class = get_global_window_class()?;
|
||||
|
||||
let (drop_tx, drop_rx) = sync_channel(0);
|
||||
let (setup_tx, setup_rx) = sync_channel(0);
|
||||
|
||||
// We spawn a thread which owns the hidden window for this instance.
|
||||
thread::Builder::new()
|
||||
.stack_size(256 * 1024)
|
||||
.name("wgpu-hal WGL Instance Thread".to_owned())
|
||||
.spawn(move || {
|
||||
let setup = (|| {
|
||||
let instance = unsafe { LibraryLoader::GetModuleHandleA(None) }.map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("unable to get executable instance"),
|
||||
e,
|
||||
)
|
||||
})?;
|
||||
|
||||
// Create a hidden window since we don't pass `WS_VISIBLE`.
|
||||
let window = unsafe {
|
||||
WindowsAndMessaging::CreateWindowExA(
|
||||
WindowsAndMessaging::WINDOW_EX_STYLE::default(),
|
||||
PCSTR(window_class.as_ptr().cast()),
|
||||
PCSTR(window_class.as_ptr().cast()),
|
||||
WindowsAndMessaging::WINDOW_STYLE::default(),
|
||||
0,
|
||||
0,
|
||||
1,
|
||||
1,
|
||||
None,
|
||||
None,
|
||||
Some(instance.into()),
|
||||
None,
|
||||
)
|
||||
}
|
||||
.map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("unable to create hidden instance window"),
|
||||
e,
|
||||
)
|
||||
})?;
|
||||
let window = Window { window };
|
||||
|
||||
let dc = unsafe { Gdi::GetDC(Some(window.window)) };
|
||||
if dc.is_invalid() {
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("unable to create memory device"),
|
||||
Error::from_thread(),
|
||||
));
|
||||
}
|
||||
let dc = DeviceContextHandle {
|
||||
device: dc,
|
||||
window: window.window,
|
||||
};
|
||||
unsafe { setup_pixel_format(dc.device)? };
|
||||
|
||||
Ok((window, dc))
|
||||
})();
|
||||
|
||||
match setup {
|
||||
Ok((_window, dc)) => {
|
||||
setup_tx.send(Ok(SendDc(dc.device))).unwrap();
|
||||
// Wait for the shutdown event to free the window and device context handle.
|
||||
drop_rx.recv().ok();
|
||||
}
|
||||
Err(err) => {
|
||||
setup_tx.send(Err(err)).unwrap();
|
||||
}
|
||||
}
|
||||
})
|
||||
.map_err(|e| {
|
||||
crate::InstanceError::with_source(String::from("unable to create instance thread"), e)
|
||||
})?;
|
||||
|
||||
let dc = setup_rx.recv().unwrap()?.0;
|
||||
|
||||
Ok(InstanceDevice { dc, _tx: drop_tx })
|
||||
}
|
||||
|
||||
impl crate::Instance for Instance {
|
||||
type A = super::Api;
|
||||
|
||||
unsafe fn init(desc: &crate::InstanceDescriptor<'_>) -> Result<Self, crate::InstanceError> {
|
||||
profiling::scope!("Init OpenGL (WGL) Backend");
|
||||
let opengl_module =
|
||||
unsafe { LibraryLoader::LoadLibraryA(PCSTR(c"opengl32.dll".as_ptr().cast())) }
|
||||
.map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("unable to load the OpenGL library"),
|
||||
e,
|
||||
)
|
||||
})?;
|
||||
|
||||
let device = create_instance_device()?;
|
||||
let dc = device.dc;
|
||||
|
||||
let context = unsafe { OpenGL::wglCreateContext(dc) }.map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("unable to create initial OpenGL context"),
|
||||
e,
|
||||
)
|
||||
})?;
|
||||
let context = WglContext { context };
|
||||
context.make_current(dc).map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("unable to set initial OpenGL context as current"),
|
||||
e,
|
||||
)
|
||||
})?;
|
||||
|
||||
let extra = Wgl::load_with(|name| load_gl_func(name, None));
|
||||
let extensions = get_extensions(&extra, dc);
|
||||
|
||||
let can_use_profile = extensions.contains("WGL_ARB_create_context_profile")
|
||||
&& extra.CreateContextAttribsARB.is_loaded();
|
||||
|
||||
let context = if can_use_profile {
|
||||
let attributes = [
|
||||
CONTEXT_PROFILE_MASK_ARB as c_int,
|
||||
CONTEXT_CORE_PROFILE_BIT_ARB as c_int,
|
||||
CONTEXT_FLAGS_ARB as c_int,
|
||||
if desc.flags.contains(InstanceFlags::DEBUG) {
|
||||
CONTEXT_DEBUG_BIT_ARB as c_int
|
||||
} else {
|
||||
0
|
||||
},
|
||||
0, // End of list
|
||||
];
|
||||
let context =
|
||||
unsafe { extra.CreateContextAttribsARB(dc.0, ptr::null(), attributes.as_ptr()) };
|
||||
if context.is_null() {
|
||||
return Err(crate::InstanceError::with_source(
|
||||
String::from("unable to create OpenGL context"),
|
||||
Error::from_thread(),
|
||||
));
|
||||
}
|
||||
WglContext {
|
||||
context: OpenGL::HGLRC(context.cast_mut()),
|
||||
}
|
||||
} else {
|
||||
context
|
||||
};
|
||||
|
||||
context.make_current(dc).map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("unable to set OpenGL context as current"),
|
||||
e,
|
||||
)
|
||||
})?;
|
||||
|
||||
let mut gl = unsafe {
|
||||
glow::Context::from_loader_function(|name| load_gl_func(name, Some(opengl_module)))
|
||||
};
|
||||
|
||||
let extra = Wgl::load_with(|name| load_gl_func(name, None));
|
||||
let extensions = get_extensions(&extra, dc);
|
||||
|
||||
let srgb_capable = extensions.contains("WGL_EXT_framebuffer_sRGB")
|
||||
|| extensions.contains("WGL_ARB_framebuffer_sRGB")
|
||||
|| gl
|
||||
.supported_extensions()
|
||||
.contains("GL_ARB_framebuffer_sRGB");
|
||||
|
||||
// In contrast to OpenGL ES, OpenGL requires explicitly enabling sRGB conversions,
|
||||
// as otherwise the user has to do the sRGB conversion.
|
||||
if srgb_capable {
|
||||
unsafe { gl.enable(glow::FRAMEBUFFER_SRGB) };
|
||||
}
|
||||
|
||||
if desc.flags.contains(InstanceFlags::VALIDATION) && gl.supports_debug() {
|
||||
log::debug!("Enabling GL debug output");
|
||||
unsafe { gl.enable(glow::DEBUG_OUTPUT) };
|
||||
unsafe { gl.debug_message_callback(super::gl_debug_message_callback) };
|
||||
}
|
||||
|
||||
// Wrap in ManuallyDrop to make it easier to "current" the GL context before dropping this
|
||||
// GLOW context, which could also happen if a panic occurs after we uncurrent the context
|
||||
// below but before Inner is constructed.
|
||||
let gl = ManuallyDrop::new(gl);
|
||||
context.unmake_current().map_err(|e| {
|
||||
crate::InstanceError::with_source(
|
||||
String::from("unable to unset the current WGL context"),
|
||||
e,
|
||||
)
|
||||
})?;
|
||||
|
||||
Ok(Instance {
|
||||
inner: Arc::new(Mutex::new(Inner {
|
||||
device,
|
||||
gl,
|
||||
context: Some(context),
|
||||
})),
|
||||
options: desc.backend_options.gl.clone(),
|
||||
srgb_capable,
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn create_surface(
|
||||
&self,
|
||||
display_handle: RawDisplayHandle,
|
||||
window_handle: RawWindowHandle,
|
||||
) -> Result<Surface, crate::InstanceError> {
|
||||
assert!(matches!(display_handle, RawDisplayHandle::Windows(_)));
|
||||
let window = if let RawWindowHandle::Win32(handle) = window_handle {
|
||||
handle
|
||||
} else {
|
||||
return Err(crate::InstanceError::new(format!(
|
||||
"unsupported window: {window_handle:?}"
|
||||
)));
|
||||
};
|
||||
Ok(Surface {
|
||||
// This cast exists because of https://github.com/rust-windowing/raw-window-handle/issues/171
|
||||
window: Foundation::HWND(window.hwnd.get() as *mut _),
|
||||
presentable: true,
|
||||
swapchain: RwLock::new(None),
|
||||
srgb_capable: self.srgb_capable,
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn enumerate_adapters(
|
||||
&self,
|
||||
_surface_hint: Option<&Surface>,
|
||||
) -> Vec<crate::ExposedAdapter<super::Api>> {
|
||||
unsafe {
|
||||
super::Adapter::expose(
|
||||
AdapterContext {
|
||||
inner: self.inner.clone(),
|
||||
},
|
||||
self.options.clone(),
|
||||
)
|
||||
}
|
||||
.into_iter()
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl super::Adapter {
|
||||
/// Creates a new external adapter using the specified loader function.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// - The underlying OpenGL ES context must be current.
|
||||
/// - The underlying OpenGL ES context must be current when interfacing with any objects returned by
|
||||
/// wgpu-hal from this adapter.
|
||||
/// - The underlying OpenGL ES context must be current when dropping this adapter and when
|
||||
/// dropping any objects returned from this adapter.
|
||||
pub unsafe fn new_external(
|
||||
fun: impl FnMut(&str) -> *const c_void,
|
||||
options: wgt::GlBackendOptions,
|
||||
) -> Option<crate::ExposedAdapter<super::Api>> {
|
||||
let context = unsafe { glow::Context::from_loader_function(fun) };
|
||||
unsafe {
|
||||
Self::expose(
|
||||
AdapterContext {
|
||||
inner: Arc::new(Mutex::new(Inner {
|
||||
gl: ManuallyDrop::new(context),
|
||||
device: create_instance_device().ok()?,
|
||||
context: None,
|
||||
})),
|
||||
},
|
||||
options,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn adapter_context(&self) -> &AdapterContext {
|
||||
&self.shared.context
|
||||
}
|
||||
}
|
||||
|
||||
impl super::Device {
|
||||
/// Returns the underlying WGL context.
|
||||
pub fn context(&self) -> &AdapterContext {
|
||||
&self.shared.context
|
||||
}
|
||||
}
|
||||
|
||||
struct DeviceContextHandle {
|
||||
device: Gdi::HDC,
|
||||
window: Foundation::HWND,
|
||||
}
|
||||
|
||||
impl Drop for DeviceContextHandle {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
Gdi::ReleaseDC(Some(self.window), self.device);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Swapchain {
|
||||
framebuffer: glow::Framebuffer,
|
||||
renderbuffer: glow::Renderbuffer,
|
||||
|
||||
/// Extent because the window lies
|
||||
extent: wgt::Extent3d,
|
||||
|
||||
format: wgt::TextureFormat,
|
||||
format_desc: super::TextureFormatDesc,
|
||||
#[allow(unused)]
|
||||
sample_type: wgt::TextureSampleType,
|
||||
}
|
||||
|
||||
pub struct Surface {
|
||||
window: Foundation::HWND,
|
||||
pub(super) presentable: bool,
|
||||
swapchain: RwLock<Option<Swapchain>>,
|
||||
srgb_capable: bool,
|
||||
}
|
||||
|
||||
unsafe impl Send for Surface {}
|
||||
unsafe impl Sync for Surface {}
|
||||
|
||||
impl Surface {
|
||||
pub(super) unsafe fn present(
|
||||
&self,
|
||||
_suf_texture: super::Texture,
|
||||
context: &AdapterContext,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
let swapchain = self.swapchain.read();
|
||||
let sc = swapchain.as_ref().unwrap();
|
||||
let dc = unsafe { Gdi::GetDC(Some(self.window)) };
|
||||
if dc.is_invalid() {
|
||||
log::error!(
|
||||
"unable to get the device context from window: {}",
|
||||
Error::from_thread()
|
||||
);
|
||||
return Err(crate::SurfaceError::Other(
|
||||
"unable to get the device context from window",
|
||||
));
|
||||
}
|
||||
let dc = DeviceContextHandle {
|
||||
device: dc,
|
||||
window: self.window,
|
||||
};
|
||||
|
||||
let gl = context.lock_with_dc(dc.device).map_err(|e| {
|
||||
log::error!("unable to make the OpenGL context current for surface: {e}",);
|
||||
crate::SurfaceError::Other("unable to make the OpenGL context current for surface")
|
||||
})?;
|
||||
|
||||
unsafe { gl.bind_framebuffer(glow::DRAW_FRAMEBUFFER, None) };
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(sc.framebuffer)) };
|
||||
|
||||
if self.srgb_capable {
|
||||
// Disable sRGB conversions for `glBlitFramebuffer` as behavior does diverge between
|
||||
// drivers and formats otherwise and we want to ensure no sRGB conversions happen.
|
||||
unsafe { gl.disable(glow::FRAMEBUFFER_SRGB) };
|
||||
}
|
||||
|
||||
// Note the Y-flipping here. GL's presentation is not flipped,
|
||||
// but main rendering is. Therefore, we Y-flip the output positions
|
||||
// in the shader, and also this blit.
|
||||
unsafe {
|
||||
gl.blit_framebuffer(
|
||||
0,
|
||||
sc.extent.height as i32,
|
||||
sc.extent.width as i32,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
sc.extent.width as i32,
|
||||
sc.extent.height as i32,
|
||||
glow::COLOR_BUFFER_BIT,
|
||||
glow::NEAREST,
|
||||
)
|
||||
};
|
||||
|
||||
if self.srgb_capable {
|
||||
unsafe { gl.enable(glow::FRAMEBUFFER_SRGB) };
|
||||
}
|
||||
|
||||
unsafe { gl.bind_renderbuffer(glow::RENDERBUFFER, None) };
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, None) };
|
||||
|
||||
if let Err(e) = unsafe { OpenGL::SwapBuffers(dc.device) } {
|
||||
log::error!("unable to swap buffers: {e}");
|
||||
return Err(crate::SurfaceError::Other("unable to swap buffers"));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn supports_srgb(&self) -> bool {
|
||||
self.srgb_capable
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::Surface for Surface {
|
||||
type A = super::Api;
|
||||
|
||||
unsafe fn configure(
|
||||
&self,
|
||||
device: &super::Device,
|
||||
config: &crate::SurfaceConfiguration,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
// Remove the old configuration.
|
||||
unsafe { self.unconfigure(device) };
|
||||
|
||||
let dc = unsafe { Gdi::GetDC(Some(self.window)) };
|
||||
if dc.is_invalid() {
|
||||
log::error!(
|
||||
"unable to get the device context from window: {}",
|
||||
Error::from_thread()
|
||||
);
|
||||
return Err(crate::SurfaceError::Other(
|
||||
"unable to get the device context from window",
|
||||
));
|
||||
}
|
||||
let dc = DeviceContextHandle {
|
||||
device: dc,
|
||||
window: self.window,
|
||||
};
|
||||
|
||||
if let Err(e) = unsafe { setup_pixel_format(dc.device) } {
|
||||
log::error!("unable to setup surface pixel format: {e}",);
|
||||
return Err(crate::SurfaceError::Other(
|
||||
"unable to setup surface pixel format",
|
||||
));
|
||||
}
|
||||
|
||||
let format_desc = device.shared.describe_texture_format(config.format);
|
||||
let gl = &device.shared.context.lock_with_dc(dc.device).map_err(|e| {
|
||||
log::error!("unable to make the OpenGL context current for surface: {e}",);
|
||||
crate::SurfaceError::Other("unable to make the OpenGL context current for surface")
|
||||
})?;
|
||||
|
||||
let renderbuffer = unsafe { gl.create_renderbuffer() }.map_err(|error| {
|
||||
log::error!("Internal swapchain renderbuffer creation failed: {error}");
|
||||
crate::DeviceError::OutOfMemory
|
||||
})?;
|
||||
unsafe { gl.bind_renderbuffer(glow::RENDERBUFFER, Some(renderbuffer)) };
|
||||
unsafe {
|
||||
gl.renderbuffer_storage(
|
||||
glow::RENDERBUFFER,
|
||||
format_desc.internal,
|
||||
config.extent.width as _,
|
||||
config.extent.height as _,
|
||||
)
|
||||
};
|
||||
|
||||
let framebuffer = unsafe { gl.create_framebuffer() }.map_err(|error| {
|
||||
log::error!("Internal swapchain framebuffer creation failed: {error}");
|
||||
crate::DeviceError::OutOfMemory
|
||||
})?;
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(framebuffer)) };
|
||||
unsafe {
|
||||
gl.framebuffer_renderbuffer(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
glow::RENDERBUFFER,
|
||||
Some(renderbuffer),
|
||||
)
|
||||
};
|
||||
unsafe { gl.bind_renderbuffer(glow::RENDERBUFFER, None) };
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, None) };
|
||||
|
||||
// Setup presentation mode
|
||||
let extra = Wgl::load_with(|name| load_gl_func(name, None));
|
||||
let extensions = get_extensions(&extra, dc.device);
|
||||
if !(extensions.contains("WGL_EXT_swap_control") && extra.SwapIntervalEXT.is_loaded()) {
|
||||
log::error!("WGL_EXT_swap_control is unsupported");
|
||||
return Err(crate::SurfaceError::Other(
|
||||
"WGL_EXT_swap_control is unsupported",
|
||||
));
|
||||
}
|
||||
|
||||
let vsync = match config.present_mode {
|
||||
wgt::PresentMode::Immediate => false,
|
||||
wgt::PresentMode::Fifo => true,
|
||||
_ => {
|
||||
log::error!("unsupported present mode: {:?}", config.present_mode);
|
||||
return Err(crate::SurfaceError::Other("unsupported present mode"));
|
||||
}
|
||||
};
|
||||
|
||||
if unsafe { extra.SwapIntervalEXT(if vsync { 1 } else { 0 }) } == Foundation::FALSE.0 {
|
||||
log::error!("unable to set swap interval: {}", Error::from_thread());
|
||||
return Err(crate::SurfaceError::Other("unable to set swap interval"));
|
||||
}
|
||||
|
||||
self.swapchain.write().replace(Swapchain {
|
||||
renderbuffer,
|
||||
framebuffer,
|
||||
extent: config.extent,
|
||||
format: config.format,
|
||||
format_desc,
|
||||
sample_type: wgt::TextureSampleType::Float { filterable: false },
|
||||
});
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn unconfigure(&self, device: &super::Device) {
|
||||
let gl = &device.shared.context.lock();
|
||||
if let Some(sc) = self.swapchain.write().take() {
|
||||
unsafe {
|
||||
gl.delete_renderbuffer(sc.renderbuffer);
|
||||
gl.delete_framebuffer(sc.framebuffer)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn acquire_texture(
|
||||
&self,
|
||||
_timeout_ms: Option<Duration>,
|
||||
_fence: &super::Fence,
|
||||
) -> Result<crate::AcquiredSurfaceTexture<super::Api>, crate::SurfaceError> {
|
||||
let swapchain = self.swapchain.read();
|
||||
let sc = swapchain.as_ref().unwrap();
|
||||
let texture = super::Texture {
|
||||
inner: super::TextureInner::Renderbuffer {
|
||||
raw: sc.renderbuffer,
|
||||
},
|
||||
drop_guard: None,
|
||||
array_layer_count: 1,
|
||||
mip_level_count: 1,
|
||||
format: sc.format,
|
||||
format_desc: sc.format_desc.clone(),
|
||||
copy_size: crate::CopyExtent {
|
||||
width: sc.extent.width,
|
||||
height: sc.extent.height,
|
||||
depth: 1,
|
||||
},
|
||||
};
|
||||
Ok(crate::AcquiredSurfaceTexture {
|
||||
texture,
|
||||
suboptimal: false,
|
||||
})
|
||||
}
|
||||
unsafe fn discard_texture(&self, _texture: super::Texture) {}
|
||||
}
|
||||
Vendored
+3086
File diff suppressed because it is too large.
Load diff
Vendored
+1851
File diff suppressed because it is too large.
Load diff
Vendored
+1979
File diff suppressed because it is too large.
Load diff
Vendored
+494
@@ -0,0 +1,494 @@
|
||||
use objc2::rc::Retained;
|
||||
use objc2_foundation::{NSArray, NSRange};
|
||||
use objc2_metal::{
|
||||
MTLAccelerationStructureBoundingBoxGeometryDescriptor, MTLAccelerationStructureDescriptor,
|
||||
MTLAccelerationStructureGeometryDescriptor, MTLAccelerationStructureInstanceDescriptorType,
|
||||
MTLAccelerationStructureTriangleGeometryDescriptor, MTLAccelerationStructureUsage,
|
||||
MTLAttributeFormat, MTLBlendFactor, MTLBlendOperation, MTLBlitOption, MTLClearColor,
|
||||
MTLColorWriteMask, MTLCompareFunction, MTLCullMode, MTLIndexType,
|
||||
MTLInstanceAccelerationStructureDescriptor, MTLOrigin,
|
||||
MTLPrimitiveAccelerationStructureDescriptor, MTLPrimitiveTopologyClass, MTLPrimitiveType,
|
||||
MTLRenderStages, MTLResourceUsage, MTLSamplerAddressMode, MTLSamplerBorderColor,
|
||||
MTLSamplerMinMagFilter, MTLSize, MTLStencilOperation, MTLStoreAction, MTLTextureType,
|
||||
MTLTextureUsage, MTLVertexFormat, MTLVertexStepFunction, MTLWinding,
|
||||
};
|
||||
|
||||
pub fn map_texture_usage(format: wgt::TextureFormat, usage: wgt::TextureUses) -> MTLTextureUsage {
|
||||
use wgt::TextureUses as Tu;
|
||||
|
||||
let mut mtl_usage = MTLTextureUsage::Unknown;
|
||||
|
||||
mtl_usage.set(
|
||||
MTLTextureUsage::RenderTarget,
|
||||
usage.intersects(Tu::COLOR_TARGET | Tu::DEPTH_STENCIL_READ | Tu::DEPTH_STENCIL_WRITE),
|
||||
);
|
||||
mtl_usage.set(
|
||||
MTLTextureUsage::ShaderRead,
|
||||
usage.intersects(
|
||||
Tu::RESOURCE | Tu::DEPTH_STENCIL_READ | Tu::STORAGE_READ_ONLY | Tu::STORAGE_READ_WRITE,
|
||||
),
|
||||
);
|
||||
mtl_usage.set(
|
||||
MTLTextureUsage::ShaderWrite,
|
||||
usage.intersects(Tu::STORAGE_WRITE_ONLY | Tu::STORAGE_READ_WRITE),
|
||||
);
|
||||
// needed for combined depth/stencil formats since we might
|
||||
// create a stencil-only view from them
|
||||
mtl_usage.set(
|
||||
MTLTextureUsage::PixelFormatView,
|
||||
format.is_combined_depth_stencil_format(),
|
||||
);
|
||||
|
||||
mtl_usage.set(
|
||||
MTLTextureUsage::ShaderAtomic,
|
||||
usage.intersects(Tu::STORAGE_ATOMIC),
|
||||
);
|
||||
|
||||
mtl_usage
|
||||
}
|
||||
|
||||
pub fn map_texture_view_dimension(dim: wgt::TextureViewDimension) -> MTLTextureType {
|
||||
use wgt::TextureViewDimension as Tvd;
|
||||
use MTLTextureType as MTL;
|
||||
match dim {
|
||||
Tvd::D1 => MTL::Type1D,
|
||||
Tvd::D2 => MTL::Type2D,
|
||||
Tvd::D2Array => MTL::Type2DArray,
|
||||
Tvd::D3 => MTL::Type3D,
|
||||
Tvd::Cube => MTL::TypeCube,
|
||||
Tvd::CubeArray => MTL::TypeCubeArray,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_compare_function(fun: wgt::CompareFunction) -> MTLCompareFunction {
|
||||
use wgt::CompareFunction as Cf;
|
||||
use MTLCompareFunction as MTL;
|
||||
match fun {
|
||||
Cf::Never => MTL::Never,
|
||||
Cf::Less => MTL::Less,
|
||||
Cf::LessEqual => MTL::LessEqual,
|
||||
Cf::Equal => MTL::Equal,
|
||||
Cf::GreaterEqual => MTL::GreaterEqual,
|
||||
Cf::Greater => MTL::Greater,
|
||||
Cf::NotEqual => MTL::NotEqual,
|
||||
Cf::Always => MTL::Always,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_filter_mode(filter: wgt::FilterMode) -> MTLSamplerMinMagFilter {
|
||||
use MTLSamplerMinMagFilter as MTL;
|
||||
match filter {
|
||||
wgt::FilterMode::Nearest => MTL::Nearest,
|
||||
wgt::FilterMode::Linear => MTL::Linear,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_address_mode(address: wgt::AddressMode) -> MTLSamplerAddressMode {
|
||||
use wgt::AddressMode as Fm;
|
||||
use MTLSamplerAddressMode as MTL;
|
||||
match address {
|
||||
Fm::Repeat => MTL::Repeat,
|
||||
Fm::MirrorRepeat => MTL::MirrorRepeat,
|
||||
Fm::ClampToEdge => MTL::ClampToEdge,
|
||||
Fm::ClampToBorder => MTL::ClampToBorderColor,
|
||||
//Fm::MirrorClamp => MTL::MirrorClampToEdge,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_border_color(border_color: wgt::SamplerBorderColor) -> MTLSamplerBorderColor {
|
||||
use MTLSamplerBorderColor as MTL;
|
||||
match border_color {
|
||||
wgt::SamplerBorderColor::TransparentBlack => MTL::TransparentBlack,
|
||||
wgt::SamplerBorderColor::OpaqueBlack => MTL::OpaqueBlack,
|
||||
wgt::SamplerBorderColor::OpaqueWhite => MTL::OpaqueWhite,
|
||||
wgt::SamplerBorderColor::Zero => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_primitive_topology(
|
||||
topology: wgt::PrimitiveTopology,
|
||||
) -> (MTLPrimitiveTopologyClass, MTLPrimitiveType) {
|
||||
use wgt::PrimitiveTopology as Pt;
|
||||
match topology {
|
||||
Pt::PointList => (MTLPrimitiveTopologyClass::Point, MTLPrimitiveType::Point),
|
||||
Pt::LineList => (MTLPrimitiveTopologyClass::Line, MTLPrimitiveType::Line),
|
||||
Pt::LineStrip => (MTLPrimitiveTopologyClass::Line, MTLPrimitiveType::LineStrip),
|
||||
Pt::TriangleList => (
|
||||
MTLPrimitiveTopologyClass::Triangle,
|
||||
MTLPrimitiveType::Triangle,
|
||||
),
|
||||
Pt::TriangleStrip => (
|
||||
MTLPrimitiveTopologyClass::Triangle,
|
||||
MTLPrimitiveType::TriangleStrip,
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_color_write(mask: wgt::ColorWrites) -> MTLColorWriteMask {
|
||||
let mut raw_mask = MTLColorWriteMask::empty();
|
||||
|
||||
if mask.contains(wgt::ColorWrites::RED) {
|
||||
raw_mask |= MTLColorWriteMask::Red;
|
||||
}
|
||||
if mask.contains(wgt::ColorWrites::GREEN) {
|
||||
raw_mask |= MTLColorWriteMask::Green;
|
||||
}
|
||||
if mask.contains(wgt::ColorWrites::BLUE) {
|
||||
raw_mask |= MTLColorWriteMask::Blue;
|
||||
}
|
||||
if mask.contains(wgt::ColorWrites::ALPHA) {
|
||||
raw_mask |= MTLColorWriteMask::Alpha;
|
||||
}
|
||||
|
||||
raw_mask
|
||||
}
|
||||
|
||||
pub fn map_blend_factor(factor: wgt::BlendFactor) -> MTLBlendFactor {
|
||||
use wgt::BlendFactor as Bf;
|
||||
use MTLBlendFactor as MTL;
|
||||
|
||||
match factor {
|
||||
Bf::Zero => MTL::Zero,
|
||||
Bf::One => MTL::One,
|
||||
Bf::Src => MTL::SourceColor,
|
||||
Bf::OneMinusSrc => MTL::OneMinusSourceColor,
|
||||
Bf::Dst => MTL::DestinationColor,
|
||||
Bf::OneMinusDst => MTL::OneMinusDestinationColor,
|
||||
Bf::SrcAlpha => MTL::SourceAlpha,
|
||||
Bf::OneMinusSrcAlpha => MTL::OneMinusSourceAlpha,
|
||||
Bf::DstAlpha => MTL::DestinationAlpha,
|
||||
Bf::OneMinusDstAlpha => MTL::OneMinusDestinationAlpha,
|
||||
Bf::Constant => MTL::BlendColor,
|
||||
Bf::OneMinusConstant => MTL::OneMinusBlendColor,
|
||||
Bf::SrcAlphaSaturated => MTL::SourceAlphaSaturated,
|
||||
Bf::Src1 => MTL::Source1Color,
|
||||
Bf::OneMinusSrc1 => MTL::OneMinusSource1Color,
|
||||
Bf::Src1Alpha => MTL::Source1Alpha,
|
||||
Bf::OneMinusSrc1Alpha => MTL::OneMinusSource1Alpha,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_blend_op(operation: wgt::BlendOperation) -> MTLBlendOperation {
|
||||
use wgt::BlendOperation as Bo;
|
||||
use MTLBlendOperation as MTL;
|
||||
|
||||
match operation {
|
||||
Bo::Add => MTL::Add,
|
||||
Bo::Subtract => MTL::Subtract,
|
||||
Bo::ReverseSubtract => MTL::ReverseSubtract,
|
||||
Bo::Min => MTL::Min,
|
||||
Bo::Max => MTL::Max,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_blend_component(
|
||||
component: &wgt::BlendComponent,
|
||||
) -> (MTLBlendOperation, MTLBlendFactor, MTLBlendFactor) {
|
||||
(
|
||||
map_blend_op(component.operation),
|
||||
map_blend_factor(component.src_factor),
|
||||
map_blend_factor(component.dst_factor),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn map_vertex_format(format: wgt::VertexFormat) -> MTLVertexFormat {
|
||||
use wgt::VertexFormat as Vf;
|
||||
use MTLVertexFormat as MTL;
|
||||
|
||||
match format {
|
||||
Vf::Unorm8 => MTL::UCharNormalized,
|
||||
Vf::Snorm8 => MTL::CharNormalized,
|
||||
Vf::Uint8 => MTL::UChar,
|
||||
Vf::Sint8 => MTL::Char,
|
||||
Vf::Unorm8x2 => MTL::UChar2Normalized,
|
||||
Vf::Snorm8x2 => MTL::Char2Normalized,
|
||||
Vf::Uint8x2 => MTL::UChar2,
|
||||
Vf::Sint8x2 => MTL::Char2,
|
||||
Vf::Unorm8x4 => MTL::UChar4Normalized,
|
||||
Vf::Snorm8x4 => MTL::Char4Normalized,
|
||||
Vf::Uint8x4 => MTL::UChar4,
|
||||
Vf::Sint8x4 => MTL::Char4,
|
||||
Vf::Unorm16 => MTL::UShortNormalized,
|
||||
Vf::Snorm16 => MTL::ShortNormalized,
|
||||
Vf::Uint16 => MTL::UShort,
|
||||
Vf::Sint16 => MTL::Short,
|
||||
Vf::Float16 => MTL::Half,
|
||||
Vf::Unorm16x2 => MTL::UShort2Normalized,
|
||||
Vf::Snorm16x2 => MTL::Short2Normalized,
|
||||
Vf::Uint16x2 => MTL::UShort2,
|
||||
Vf::Sint16x2 => MTL::Short2,
|
||||
Vf::Float16x2 => MTL::Half2,
|
||||
Vf::Unorm16x4 => MTL::UShort4Normalized,
|
||||
Vf::Snorm16x4 => MTL::Short4Normalized,
|
||||
Vf::Uint16x4 => MTL::UShort4,
|
||||
Vf::Sint16x4 => MTL::Short4,
|
||||
Vf::Float16x4 => MTL::Half4,
|
||||
Vf::Uint32 => MTL::UInt,
|
||||
Vf::Sint32 => MTL::Int,
|
||||
Vf::Float32 => MTL::Float,
|
||||
Vf::Uint32x2 => MTL::UInt2,
|
||||
Vf::Sint32x2 => MTL::Int2,
|
||||
Vf::Float32x2 => MTL::Float2,
|
||||
Vf::Uint32x3 => MTL::UInt3,
|
||||
Vf::Sint32x3 => MTL::Int3,
|
||||
Vf::Float32x3 => MTL::Float3,
|
||||
Vf::Uint32x4 => MTL::UInt4,
|
||||
Vf::Sint32x4 => MTL::Int4,
|
||||
Vf::Float32x4 => MTL::Float4,
|
||||
Vf::Unorm10_10_10_2 => MTL::UInt1010102Normalized,
|
||||
Vf::Unorm8x4Bgra => MTL::UChar4Normalized_BGRA,
|
||||
Vf::Float64 | Vf::Float64x2 | Vf::Float64x3 | Vf::Float64x4 => unimplemented!(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_index_format(format: wgt::IndexFormat) -> (u64, MTLIndexType) {
|
||||
match format {
|
||||
wgt::IndexFormat::Uint16 => (2, MTLIndexType::UInt16),
|
||||
wgt::IndexFormat::Uint32 => (4, MTLIndexType::UInt32),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_step_mode(mode: wgt::VertexStepMode) -> MTLVertexStepFunction {
|
||||
match mode {
|
||||
wgt::VertexStepMode::Vertex => MTLVertexStepFunction::PerVertex,
|
||||
wgt::VertexStepMode::Instance => MTLVertexStepFunction::PerInstance,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_stencil_op(op: wgt::StencilOperation) -> MTLStencilOperation {
|
||||
use wgt::StencilOperation as So;
|
||||
use MTLStencilOperation as MTL;
|
||||
|
||||
match op {
|
||||
So::Keep => MTL::Keep,
|
||||
So::Zero => MTL::Zero,
|
||||
So::Replace => MTL::Replace,
|
||||
So::IncrementClamp => MTL::IncrementClamp,
|
||||
So::IncrementWrap => MTL::IncrementWrap,
|
||||
So::DecrementClamp => MTL::DecrementClamp,
|
||||
So::DecrementWrap => MTL::DecrementWrap,
|
||||
So::Invert => MTL::Invert,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_winding(winding: wgt::FrontFace) -> MTLWinding {
|
||||
match winding {
|
||||
wgt::FrontFace::Cw => MTLWinding::Clockwise,
|
||||
wgt::FrontFace::Ccw => MTLWinding::CounterClockwise,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_cull_mode(face: Option<wgt::Face>) -> MTLCullMode {
|
||||
match face {
|
||||
None => MTLCullMode::None,
|
||||
Some(wgt::Face::Front) => MTLCullMode::Front,
|
||||
Some(wgt::Face::Back) => MTLCullMode::Back,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_range(range: &crate::MemoryRange) -> NSRange {
|
||||
NSRange {
|
||||
location: range.start as usize,
|
||||
length: (range.end - range.start) as usize,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_copy_extent(extent: &crate::CopyExtent) -> MTLSize {
|
||||
MTLSize {
|
||||
width: extent.width as usize,
|
||||
height: extent.height as usize,
|
||||
depth: extent.depth as usize,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_origin(origin: &wgt::Origin3d) -> MTLOrigin {
|
||||
MTLOrigin {
|
||||
x: origin.x as usize,
|
||||
y: origin.y as usize,
|
||||
z: origin.z as usize,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_store_action(store: bool, resolve: bool) -> MTLStoreAction {
|
||||
use MTLStoreAction as MTL;
|
||||
match (store, resolve) {
|
||||
(true, true) => MTL::StoreAndMultisampleResolve,
|
||||
(false, true) => MTL::MultisampleResolve,
|
||||
(true, false) => MTL::Store,
|
||||
(false, false) => MTL::DontCare,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_clear_color(color: &wgt::Color) -> MTLClearColor {
|
||||
MTLClearColor {
|
||||
red: color.r,
|
||||
green: color.g,
|
||||
blue: color.b,
|
||||
alpha: color.a,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_blit_option(format: wgt::TextureFormat, aspect: crate::FormatAspects) -> MTLBlitOption {
|
||||
if format.is_combined_depth_stencil_format() {
|
||||
match aspect {
|
||||
crate::FormatAspects::DEPTH => MTLBlitOption::DepthFromDepthStencil,
|
||||
crate::FormatAspects::STENCIL => MTLBlitOption::StencilFromDepthStencil,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
} else {
|
||||
MTLBlitOption::None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_render_stages(stage: wgt::ShaderStages) -> MTLRenderStages {
|
||||
let mut raw_stages = MTLRenderStages::empty();
|
||||
|
||||
if stage.contains(wgt::ShaderStages::VERTEX) {
|
||||
raw_stages |= MTLRenderStages::Vertex;
|
||||
}
|
||||
if stage.contains(wgt::ShaderStages::FRAGMENT) {
|
||||
raw_stages |= MTLRenderStages::Fragment;
|
||||
}
|
||||
|
||||
raw_stages
|
||||
}
|
||||
|
||||
pub fn map_resource_usage(ty: &wgt::BindingType) -> MTLResourceUsage {
|
||||
match ty {
|
||||
#[allow(deprecated)]
|
||||
wgt::BindingType::Texture { .. } => MTLResourceUsage::Sample,
|
||||
wgt::BindingType::StorageTexture { access, .. } => match access {
|
||||
wgt::StorageTextureAccess::WriteOnly => MTLResourceUsage::Write,
|
||||
wgt::StorageTextureAccess::ReadOnly => MTLResourceUsage::Read,
|
||||
wgt::StorageTextureAccess::Atomic | wgt::StorageTextureAccess::ReadWrite => {
|
||||
MTLResourceUsage::Read | MTLResourceUsage::Write
|
||||
}
|
||||
},
|
||||
wgt::BindingType::Sampler(..) => MTLResourceUsage::empty(),
|
||||
wgt::BindingType::Buffer { ty, .. } => match ty {
|
||||
wgt::BufferBindingType::Uniform
|
||||
| wgt::BufferBindingType::Storage { read_only: true } => MTLResourceUsage::Read,
|
||||
wgt::BufferBindingType::Storage { read_only: false } => {
|
||||
MTLResourceUsage::Read | MTLResourceUsage::Write
|
||||
}
|
||||
},
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_acceleration_structure_descriptor<'a>(
|
||||
entries: &'a crate::AccelerationStructureEntries<'a, super::Buffer>,
|
||||
flags: crate::AccelerationStructureBuildFlags,
|
||||
) -> Retained<MTLAccelerationStructureDescriptor> {
|
||||
let descriptor = match entries {
|
||||
crate::AccelerationStructureEntries::Instances(instances) => {
|
||||
let descriptor = MTLInstanceAccelerationStructureDescriptor::new();
|
||||
descriptor.setInstanceDescriptorType(
|
||||
MTLAccelerationStructureInstanceDescriptorType::Indirect,
|
||||
);
|
||||
descriptor.setInstanceCount(instances.count as usize);
|
||||
descriptor.setInstanceDescriptorBuffer(Some(&instances.buffer.unwrap().raw));
|
||||
unsafe {
|
||||
descriptor.setInstanceDescriptorBufferOffset(instances.offset as usize);
|
||||
}
|
||||
descriptor.into_super()
|
||||
}
|
||||
crate::AccelerationStructureEntries::Triangles(entries) => {
|
||||
let geometry_descriptors = entries
|
||||
.iter()
|
||||
.map(|triangles| {
|
||||
let descriptor = MTLAccelerationStructureTriangleGeometryDescriptor::new();
|
||||
if let Some(indices) = triangles.indices.as_ref() {
|
||||
descriptor.setIndexBuffer(Some(&indices.buffer.unwrap().raw));
|
||||
unsafe {
|
||||
descriptor.setIndexBufferOffset(indices.offset as usize);
|
||||
}
|
||||
descriptor.setIndexType(map_index_format(indices.format).1);
|
||||
descriptor.setTriangleCount(indices.count as usize / 3);
|
||||
} else {
|
||||
descriptor.setTriangleCount(triangles.vertex_count as usize / 3);
|
||||
}
|
||||
descriptor.setVertexBuffer(Some(&triangles.vertex_buffer.unwrap().raw));
|
||||
unsafe {
|
||||
descriptor.setVertexBufferOffset(
|
||||
triangles.first_vertex as usize * triangles.vertex_stride as usize,
|
||||
);
|
||||
}
|
||||
descriptor.setVertexStride(triangles.vertex_stride as usize);
|
||||
// Safety: MTLVertexFormat and MTLAttributeFormat are identical.
|
||||
// https://docs.rs/objc2-metal/latest/objc2_metal/struct.MTLAttributeFormat.html
|
||||
// https://docs.rs/objc2-metal/latest/objc2_metal/struct.MTLVertexFormat.html
|
||||
descriptor.setVertexFormat(unsafe {
|
||||
core::mem::transmute::<MTLVertexFormat, MTLAttributeFormat>(
|
||||
map_vertex_format(triangles.vertex_format),
|
||||
)
|
||||
});
|
||||
if let Some(transform) = triangles.transform.as_ref() {
|
||||
unsafe {
|
||||
descriptor.setTransformationMatrixBuffer(Some(&transform.buffer.raw));
|
||||
descriptor
|
||||
.setTransformationMatrixBufferOffset(transform.offset as usize);
|
||||
}
|
||||
}
|
||||
descriptor.setOpaque(
|
||||
triangles
|
||||
.flags
|
||||
.contains(wgt::AccelerationStructureGeometryFlags::OPAQUE),
|
||||
);
|
||||
if !triangles.flags.contains(
|
||||
wgt::AccelerationStructureGeometryFlags::NO_DUPLICATE_ANY_HIT_INVOCATION,
|
||||
) {
|
||||
descriptor.allowDuplicateIntersectionFunctionInvocation();
|
||||
}
|
||||
// descriptor.setIntersectionFunctionTableOffset(offset);
|
||||
descriptor.into_super()
|
||||
})
|
||||
.collect::<alloc::vec::Vec<Retained<MTLAccelerationStructureGeometryDescriptor>>>();
|
||||
let descriptor = MTLPrimitiveAccelerationStructureDescriptor::new();
|
||||
descriptor.setGeometryDescriptors(Some(&NSArray::from_retained_slice(
|
||||
geometry_descriptors.as_slice(),
|
||||
)));
|
||||
descriptor.into_super()
|
||||
}
|
||||
crate::AccelerationStructureEntries::AABBs(entries) => {
|
||||
let geometry_descriptors = entries
|
||||
.iter()
|
||||
.map(|aabbs| {
|
||||
let descriptor = MTLAccelerationStructureBoundingBoxGeometryDescriptor::new();
|
||||
descriptor.setBoundingBoxBuffer(Some(&aabbs.buffer.unwrap().raw));
|
||||
descriptor.setBoundingBoxCount(aabbs.count as usize);
|
||||
unsafe {
|
||||
descriptor.setBoundingBoxStride(aabbs.stride as usize);
|
||||
descriptor.setBoundingBoxBufferOffset(aabbs.offset as usize);
|
||||
}
|
||||
descriptor.setOpaque(
|
||||
aabbs
|
||||
.flags
|
||||
.contains(wgt::AccelerationStructureGeometryFlags::OPAQUE),
|
||||
);
|
||||
if !aabbs.flags.contains(
|
||||
wgt::AccelerationStructureGeometryFlags::NO_DUPLICATE_ANY_HIT_INVOCATION,
|
||||
) {
|
||||
descriptor.allowDuplicateIntersectionFunctionInvocation();
|
||||
}
|
||||
// descriptor.setIntersectionFunctionTableOffset(offset);
|
||||
descriptor.into_super()
|
||||
})
|
||||
.collect::<alloc::vec::Vec<Retained<MTLAccelerationStructureGeometryDescriptor>>>();
|
||||
let descriptor = MTLPrimitiveAccelerationStructureDescriptor::new();
|
||||
descriptor.setGeometryDescriptors(Some(&NSArray::from_retained_slice(
|
||||
geometry_descriptors.as_slice(),
|
||||
)));
|
||||
descriptor.into_super()
|
||||
}
|
||||
};
|
||||
let mut usage = MTLAccelerationStructureUsage::None;
|
||||
if flags.contains(wgt::AccelerationStructureFlags::ALLOW_UPDATE) {
|
||||
usage |= MTLAccelerationStructureUsage::Refit;
|
||||
}
|
||||
if flags.contains(wgt::AccelerationStructureFlags::PREFER_FAST_BUILD) {
|
||||
usage |= MTLAccelerationStructureUsage::PreferFastBuild;
|
||||
}
|
||||
descriptor.setUsage(usage);
|
||||
descriptor
|
||||
}
|
||||
Vendored
+2170
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,48 @@
|
||||
use core::{ffi::c_void, ptr::NonNull};
|
||||
|
||||
use objc2::{
|
||||
msg_send,
|
||||
rc::Retained,
|
||||
runtime::{AnyObject, ProtocolObject},
|
||||
};
|
||||
use objc2_foundation::NSError;
|
||||
use objc2_metal::{MTLDevice, MTLLibrary};
|
||||
|
||||
#[link(name = "System")] // libdispatch lives inside libSystem
|
||||
extern "C" {
|
||||
fn dispatch_data_create(
|
||||
buffer: NonNull<c_void>,
|
||||
size: usize,
|
||||
queue: Option<NonNull<c_void>>, // dispatch_queue_t _Nullable
|
||||
destructor: *mut c_void, // dispatch_block_t _Nullable
|
||||
) -> *mut AnyObject; // dispatch_data_t
|
||||
|
||||
fn dispatch_release(object: *mut AnyObject); // dispatch_data_t
|
||||
}
|
||||
|
||||
const DISPATCH_DATA_DESTRUCTOR_DEFAULT: *mut c_void = core::ptr::null_mut();
|
||||
|
||||
/// See <https://github.com/madsmtm/objc2/issues/819>.
|
||||
///
|
||||
/// newLibraryWithData requires DispatchData, part of the Dispatch library.
|
||||
/// Not only is this a big additional dependency for a glorified `Vec<u8>`
|
||||
/// in this case, but the code in the dispatch2 rust crate is a WIP and
|
||||
/// Mozilla has decided not to vendor it yet.
|
||||
///
|
||||
/// This function allows us to deal with DispatchData without dealing
|
||||
/// with these problems.
|
||||
pub(crate) fn new_library_from_metallib_bytes(
|
||||
device: &ProtocolObject<dyn MTLDevice>,
|
||||
data: &[u8],
|
||||
) -> Result<Retained<ProtocolObject<dyn MTLLibrary>>, Retained<NSError>> {
|
||||
let buffer = NonNull::new(data.as_ptr().cast_mut()).unwrap().cast();
|
||||
let data =
|
||||
unsafe { dispatch_data_create(buffer, data.len(), None, DISPATCH_DATA_DESTRUCTOR_DEFAULT) };
|
||||
assert!(!data.is_null());
|
||||
|
||||
let res: Result<Retained<ProtocolObject<dyn MTLLibrary>>, Retained<NSError>> =
|
||||
unsafe { msg_send![device, newLibraryWithData: data, error: _] };
|
||||
|
||||
unsafe { dispatch_release(data) };
|
||||
res
|
||||
}
|
||||
Vendored
+1410
File diff suppressed because it is too large.
Load diff
Vendored
+409
@@ -0,0 +1,409 @@
|
||||
use std::sync::LazyLock;
|
||||
|
||||
use alloc::borrow::ToOwned as _;
|
||||
|
||||
use objc2::{
|
||||
available,
|
||||
rc::{autoreleasepool, Retained},
|
||||
runtime::ProtocolObject,
|
||||
ClassType, Message,
|
||||
};
|
||||
use objc2_core_foundation::{CFString, CGSize};
|
||||
use objc2_core_graphics::CGColorSpace;
|
||||
use objc2_foundation::NSObjectProtocol;
|
||||
use objc2_metal::MTLTextureType;
|
||||
use objc2_quartz_core::{CAMetalDrawable, CAMetalLayer};
|
||||
use parking_lot::{Mutex, RwLock};
|
||||
|
||||
use super::OsFeatures;
|
||||
|
||||
/// Walks up from `start` to the `NSWindow` hosting this layer: the first ancestor
|
||||
/// layer with a delegate is the backing `NSView`, and we return its `window`.
|
||||
/// `None` if no ancestor has a delegate.
|
||||
#[cfg(target_os = "macos")]
|
||||
fn hosting_window(
|
||||
start: Retained<objc2_quartz_core::CALayer>,
|
||||
) -> Option<Retained<objc2::runtime::NSObject>> {
|
||||
let mut current = Some(start);
|
||||
while let Some(layer) = current {
|
||||
if let Some(delegate) = layer.delegate() {
|
||||
return unsafe { objc2::msg_send![&*delegate, window] };
|
||||
}
|
||||
current = layer.superlayer();
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
impl super::Surface {
|
||||
pub fn new(layer: Retained<CAMetalLayer>) -> Self {
|
||||
Self {
|
||||
render_layer: Mutex::new(layer),
|
||||
swapchain_format: RwLock::new(None),
|
||||
extent: RwLock::new(wgt::Extent3d::default()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_layer(layer: &CAMetalLayer) -> Self {
|
||||
assert!(layer.isKindOfClass(CAMetalLayer::class()));
|
||||
Self::new(layer.retain())
|
||||
}
|
||||
|
||||
pub fn render_layer(&self) -> &Mutex<Retained<CAMetalLayer>> {
|
||||
&self.render_layer
|
||||
}
|
||||
|
||||
/// Returns the EDR headroom of the screen hosting this surface, as a
|
||||
/// [`wgt::DisplayHdrInfo`].
|
||||
///
|
||||
/// macOS only. Returns `None` on other Apple platforms (iOS, tvOS, visionOS),
|
||||
/// when the hosting screen can't be resolved (e.g. an off-screen window), or
|
||||
/// when called off the main thread: `NSScreen` and `NSWindow` are
|
||||
/// main-thread-only, and off-thread access is undefined behavior.
|
||||
///
|
||||
/// Only `headroom` and the coarse `high_dynamic_range` bit are filled: Apple
|
||||
/// exposes a relative EDR multiplier (`1.0` == SDR white), no absolute nits,
|
||||
/// and no HDR-mode flag. `high_dynamic_range` tracks the live `current`
|
||||
/// multiplier (`> 1.0`), so it reports HDR active, not merely capable.
|
||||
pub(super) fn display_hdr_info(&self) -> Option<wgt::DisplayHdrInfo> {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
use objc2::rc::Retained;
|
||||
use objc2::runtime::NSObject;
|
||||
|
||||
// Bail before any message send if we are not on the main thread.
|
||||
// `MainThreadMarker::new()` is `None` off the main thread and does no
|
||||
// Objective-C work, so it is a cheap, safe gate.
|
||||
if objc2::MainThreadMarker::new().is_none() {
|
||||
// Of the paths that yield `None`, this is the only one a caller
|
||||
// can fix (the others — off-screen window, non-macOS — are
|
||||
// environmental), so leave a breadcrumb instead of failing
|
||||
// silently. Warn once per process so a caller that polls this
|
||||
// per frame is not spammed.
|
||||
static WARN_ONCE: std::sync::Once = std::sync::Once::new();
|
||||
WARN_ONCE.call_once(|| {
|
||||
log::warn!(
|
||||
"Surface::display_hdr_info() was called from thread {:?} \
|
||||
and will return None. On the Metal backend, it must be \
|
||||
called from the main thread to succeed.",
|
||||
std::thread::current().id()
|
||||
);
|
||||
});
|
||||
return None;
|
||||
}
|
||||
|
||||
// Take an owned reference to the layer and drop the lock before
|
||||
// accessing the window and screen, so a main-thread AppKit callback
|
||||
// can never deadlock against this lock.
|
||||
let render_layer = {
|
||||
let guard = self.render_layer.lock();
|
||||
guard.clone()
|
||||
};
|
||||
|
||||
// Resolve the hosting `NSScreen` from the hosting window. `NSWindow.screen`
|
||||
// is nil when the window is off-screen, so this can legitimately yield `None`.
|
||||
let screen: Retained<NSObject> = autoreleasepool(|_| {
|
||||
hosting_window(Retained::into_super(render_layer))
|
||||
.and_then(|window| unsafe { objc2::msg_send![&*window, screen] })
|
||||
})?;
|
||||
|
||||
// AppKit documents these EDR properties as finite multipliers
|
||||
// (`1.0` == SDR white), but guard against a non-finite read anyway so
|
||||
// the advisory values stay finite and the coarse `high_dynamic_range`
|
||||
// bit reports unknown (`None`) rather than a false `Some(false)`,
|
||||
// mirroring the `is_finite` discipline in
|
||||
// [`wgt::DisplayHdrInfo::tone_map_headroom`]. The EDR properties return
|
||||
// `CGFloat` (`f64` on 64-bit macOS).
|
||||
let finite = |v: f64| v.is_finite().then_some(v as f32);
|
||||
|
||||
// `maximumExtendedDynamicRangeColorComponentValue` is macOS 10.11+, so
|
||||
// it is safe at our 10.13 minimum.
|
||||
let current: f64 = unsafe {
|
||||
objc2::msg_send![&*screen, maximumExtendedDynamicRangeColorComponentValue]
|
||||
};
|
||||
|
||||
// Apple exposes no discrete HDR-mode flag, so derive the coarse
|
||||
// dynamic-range bit from the live `current` EDR multiplier (`> 1.0`),
|
||||
// not `potential` (which is `> 1.0` on nearly every Apple display and
|
||||
// would conflate "capable" with "active").
|
||||
let high_dynamic_range = current.is_finite().then_some(current > 1.0);
|
||||
|
||||
// `maximumPotential...` and `maximumReference...` are macOS 10.15+,
|
||||
// below which sending them would raise an unrecognized-selector
|
||||
// exception, so only message them where available; otherwise leave
|
||||
// them `None`.
|
||||
let (potential, reference) = if available!(macos = 10.15) {
|
||||
let potential: f64 = unsafe {
|
||||
objc2::msg_send![
|
||||
&*screen,
|
||||
maximumPotentialExtendedDynamicRangeColorComponentValue
|
||||
]
|
||||
};
|
||||
let reference: f64 = unsafe {
|
||||
objc2::msg_send![
|
||||
&*screen,
|
||||
maximumReferenceExtendedDynamicRangeColorComponentValue
|
||||
]
|
||||
};
|
||||
// AppKit reports `0.0` when there is no reference value; treat that
|
||||
// (and any non-finite read) as "unknown" rather than a real `0.0`.
|
||||
(finite(potential), finite(reference).filter(|&v| v > 0.0))
|
||||
} else {
|
||||
(None, None)
|
||||
};
|
||||
let headroom = wgt::DisplayHeadroom {
|
||||
current: finite(current),
|
||||
potential,
|
||||
reference,
|
||||
};
|
||||
|
||||
// `NSScreen.colorSpace` returns generic names on HDR panels
|
||||
// post-Monterey, so deriving a gamut bucket from it would lie; leave
|
||||
// `gamut` as `None` on macOS.
|
||||
let coarse = wgt::DisplayCoarseRange {
|
||||
high_dynamic_range,
|
||||
gamut: None,
|
||||
};
|
||||
|
||||
// Apple exposes no absolute nits, CIE-xy primaries, or panel bit
|
||||
// depth, so `luminance` / `chromaticity` / `bits_per_color` stay `None`.
|
||||
let info = wgt::DisplayHdrInfo {
|
||||
luminance: None,
|
||||
headroom: Some(headroom),
|
||||
chromaticity: None,
|
||||
coarse: Some(coarse),
|
||||
bits_per_color: None,
|
||||
};
|
||||
Some(info)
|
||||
}
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
{
|
||||
// TODO: iOS/tvOS/visionOS could report EDR headroom via
|
||||
// `UIScreen.currentEDRHeadroom`.
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets the current dimensions of the `Surface`.
|
||||
///
|
||||
/// This function is safe to call off of the main thread. However, note that
|
||||
/// `bounds` and `contentsScale` may be modified by the main thread while
|
||||
/// this function is running, possibly resulting in the two values being out
|
||||
/// of sync. This is sound, as these properties are accessed atomically.
|
||||
/// See: <https://github.com/gfx-rs/wgpu/pull/7692>
|
||||
pub(super) fn dimensions(&self) -> wgt::Extent3d {
|
||||
let (size, scale) = {
|
||||
let render_layer = self.render_layer.lock();
|
||||
let bounds = render_layer.bounds();
|
||||
let contents_scale = render_layer.contentsScale();
|
||||
(bounds.size, contents_scale)
|
||||
};
|
||||
|
||||
wgt::Extent3d {
|
||||
width: (size.width * scale) as u32,
|
||||
height: (size.height * scale) as u32,
|
||||
depth_or_array_layers: 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// objc2 strings are not, in general, thread-safe, but these should be constants.
|
||||
unsafe impl Send for ColorSpaces {}
|
||||
unsafe impl Sync for ColorSpaces {}
|
||||
|
||||
struct ColorSpaces {
|
||||
extended_display_p3: &'static CFString,
|
||||
itur_bt2100_pq: &'static CFString,
|
||||
itur_bt2100_hlg: &'static CFString,
|
||||
}
|
||||
|
||||
static COLOR_SPACES: LazyLock<Result<ColorSpaces, crate::SurfaceError>> = LazyLock::new(|| {
|
||||
// Stable Rust doesn't support weak linkage, so objc2 doesn't
|
||||
// offer it. To avoid link errors on old OS versions, resolve
|
||||
// these dynamically.
|
||||
let lib = unsafe {
|
||||
libloading::Library::new("/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics")
|
||||
.map_err(|_| crate::SurfaceError::Other("error loading CoreGraphics"))?
|
||||
};
|
||||
fn lookup(
|
||||
lib: &libloading::Library,
|
||||
name: &[u8],
|
||||
) -> Result<&'static CFString, crate::SurfaceError> {
|
||||
let sym = unsafe { lib.get(name) }
|
||||
.map_err(|_| crate::SurfaceError::Other("error resolving symbol in CoreGraphics"))?;
|
||||
Ok(*sym)
|
||||
}
|
||||
let extended_display_p3 = lookup(&lib, b"kCGColorSpaceExtendedDisplayP3\0")?;
|
||||
let itur_bt2100_pq = lookup(&lib, b"kCGColorSpaceITUR_2100_PQ\0")?;
|
||||
let itur_bt2100_hlg = lookup(&lib, b"kCGColorSpaceITUR_2100_HLG\0")?;
|
||||
Ok(ColorSpaces {
|
||||
extended_display_p3,
|
||||
itur_bt2100_pq,
|
||||
itur_bt2100_hlg,
|
||||
})
|
||||
});
|
||||
|
||||
impl crate::Surface for super::Surface {
|
||||
type A = super::Api;
|
||||
|
||||
unsafe fn configure(
|
||||
&self,
|
||||
device: &super::Device,
|
||||
config: &crate::SurfaceConfiguration,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
log::debug!("build swapchain {config:?}");
|
||||
|
||||
let caps = &device.shared.private_texture_format_caps;
|
||||
*self.swapchain_format.write() = Some(config.format);
|
||||
*self.extent.write() = config.extent;
|
||||
|
||||
let render_layer = self.render_layer.lock();
|
||||
let framebuffer_only = config.usage == wgt::TextureUses::COLOR_TARGET;
|
||||
let display_sync = match config.present_mode {
|
||||
wgt::PresentMode::Fifo => true,
|
||||
wgt::PresentMode::Immediate => false,
|
||||
m => unreachable!("Unsupported present mode: {m:?}"),
|
||||
};
|
||||
// CGFloat is f64 on 64-bit, f32 on 32-bit (arm64_32/ILP32)
|
||||
let drawable_size = CGSize::new(config.extent.width as _, config.extent.height as _);
|
||||
|
||||
match config.composite_alpha_mode {
|
||||
wgt::CompositeAlphaMode::Opaque => render_layer.setOpaque(true),
|
||||
wgt::CompositeAlphaMode::PostMultiplied => render_layer.setOpaque(false),
|
||||
_ => (),
|
||||
}
|
||||
|
||||
let device_raw = &device.shared.device;
|
||||
render_layer.setDevice(Some(device_raw));
|
||||
render_layer.setPixelFormat(caps.map_format(config.format));
|
||||
render_layer.setFramebufferOnly(framebuffer_only);
|
||||
// Opt into Metal EDR for the HDR color spaces (more display power, memory,
|
||||
// and bandwidth). The HDR spaces are exactly those `is_hdr()` classifies.
|
||||
let wants_edr = config.color_space.is_hdr();
|
||||
if wants_edr != render_layer.wantsExtendedDynamicRangeContent() {
|
||||
render_layer.setWantsExtendedDynamicRangeContent(wants_edr);
|
||||
}
|
||||
|
||||
let colorspace_name: Option<&'static CFString> = match config.color_space {
|
||||
wgt::SurfaceColorSpace::Auto => {
|
||||
unreachable!("wgpu-core resolves `Auto` before configuring the surface")
|
||||
}
|
||||
// Reset to the layer's default, which treats contents as sRGB.
|
||||
wgt::SurfaceColorSpace::Srgb => None,
|
||||
wgt::SurfaceColorSpace::ExtendedSrgbLinear => {
|
||||
Some(unsafe { objc2_core_graphics::kCGColorSpaceExtendedLinearSRGB })
|
||||
}
|
||||
wgt::SurfaceColorSpace::ExtendedSrgb => {
|
||||
Some(unsafe { objc2_core_graphics::kCGColorSpaceExtendedSRGB })
|
||||
}
|
||||
wgt::SurfaceColorSpace::ExtendedDisplayP3 => {
|
||||
// TODO: This needs protection in `surface_capabilities` like the BT.2100 cases.
|
||||
Some(
|
||||
COLOR_SPACES
|
||||
.as_ref()
|
||||
.map_err(|e| e.clone())?
|
||||
.extended_display_p3,
|
||||
)
|
||||
}
|
||||
wgt::SurfaceColorSpace::DisplayP3 => {
|
||||
Some(unsafe { objc2_core_graphics::kCGColorSpaceDisplayP3 })
|
||||
}
|
||||
wgt::SurfaceColorSpace::Bt2100Pq | wgt::SurfaceColorSpace::Bt2100Hlg => {
|
||||
// The ITUR_2100 color space constants require macOS 11.0/iOS 14.0;
|
||||
// `surface_capabilities` only reports BT.2100 PQ/HLG on those OS versions.
|
||||
if !available!(macos = 11.0, ios = 14.0, tvos = 14.0, visionos = 1.0) {
|
||||
unreachable!("BT.2100 PQ/HLG color spaces are only reported on macOS 11.0+/iOS 14.0+/tvOS 14.0+");
|
||||
}
|
||||
Some(if config.color_space == wgt::SurfaceColorSpace::Bt2100Pq {
|
||||
COLOR_SPACES.as_ref().map_err(|e| e.clone())?.itur_bt2100_pq
|
||||
} else {
|
||||
COLOR_SPACES
|
||||
.as_ref()
|
||||
.map_err(|e| e.clone())?
|
||||
.itur_bt2100_hlg
|
||||
})
|
||||
}
|
||||
};
|
||||
let colorspace = colorspace_name.and_then(|name| CGColorSpace::with_name(Some(name)));
|
||||
render_layer.setColorspace(colorspace.as_deref());
|
||||
|
||||
// this gets ignored on iOS for certain OS/device combinations (iphone5s iOS 10.3)
|
||||
render_layer.setMaximumDrawableCount(config.maximum_frame_latency as usize + 1);
|
||||
render_layer.setDrawableSize(drawable_size);
|
||||
// https://developer.apple.com/documentation/quartzcore/cametallayer/allowsnextdrawabletimeout
|
||||
if available!(macos = 10.13, ios = 11.0, tvos = 11.0, visionos = 1.0) {
|
||||
render_layer.setAllowsNextDrawableTimeout(false);
|
||||
}
|
||||
if OsFeatures::display_sync() {
|
||||
render_layer.setDisplaySyncEnabled(display_sync);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn unconfigure(&self, _device: &super::Device) {
|
||||
*self.swapchain_format.write() = None;
|
||||
}
|
||||
|
||||
unsafe fn acquire_texture(
|
||||
&self,
|
||||
_timeout: Option<core::time::Duration>, // TODO
|
||||
_fence: &super::Fence,
|
||||
) -> Result<crate::AcquiredSurfaceTexture<super::Api>, crate::SurfaceError> {
|
||||
let render_layer = self.render_layer.lock();
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
// Workaround for https://github.com/gfx-rs/wgpu/issues/8309
|
||||
// When the window is occluded on macOS, presented drawables get stuck waiting
|
||||
// for vsync. Check the window's occlusion state and skip acquisition if
|
||||
// the window is not visible - this avoids a 1-second hang in nextDrawable().
|
||||
use objc2::rc::Retained;
|
||||
|
||||
// The CAMetalLayer is typically a sublayer; find the hosting window
|
||||
// and skip acquisition while it is occluded.
|
||||
if let Some(window) = hosting_window(Retained::into_super(render_layer.clone())) {
|
||||
const NS_WINDOW_OCCLUSION_STATE_VISIBLE: usize = 1 << 1;
|
||||
let occlusion_state: usize = unsafe { objc2::msg_send![&*window, occlusionState] };
|
||||
if occlusion_state & NS_WINDOW_OCCLUSION_STATE_VISIBLE == 0 {
|
||||
return Err(crate::SurfaceError::Occluded);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let (drawable, texture) = match autoreleasepool(|_| {
|
||||
render_layer
|
||||
.nextDrawable()
|
||||
.map(|drawable| (drawable.to_owned(), drawable.texture().to_owned()))
|
||||
}) {
|
||||
Some(pair) => pair,
|
||||
None => return Err(crate::SurfaceError::Timeout),
|
||||
};
|
||||
|
||||
let swapchain_format = self.swapchain_format.read().unwrap();
|
||||
let extent = self.extent.read();
|
||||
let suf_texture = super::SurfaceTexture {
|
||||
texture: super::Texture {
|
||||
raw: texture,
|
||||
format: swapchain_format,
|
||||
raw_type: MTLTextureType::Type2D,
|
||||
array_layers: 1,
|
||||
mip_levels: 1,
|
||||
copy_size: crate::CopyExtent {
|
||||
width: extent.width,
|
||||
height: extent.height,
|
||||
depth: 1,
|
||||
},
|
||||
_drop_guard: None,
|
||||
},
|
||||
drawable: ProtocolObject::from_retained(drawable),
|
||||
present_with_transaction: render_layer.presentsWithTransaction(),
|
||||
};
|
||||
|
||||
Ok(crate::AcquiredSurfaceTexture {
|
||||
texture: suf_texture,
|
||||
suboptimal: false,
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn discard_texture(&self, _texture: super::SurfaceTexture) {}
|
||||
}
|
||||
Vendored
+38
@@ -0,0 +1,38 @@
|
||||
//! Handling of global timestamps.
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
struct MachTimebaseInfo {
|
||||
numerator: u32,
|
||||
denominator: u32,
|
||||
}
|
||||
extern "C" {
|
||||
fn mach_timebase_info(out: *mut MachTimebaseInfo) -> u32;
|
||||
fn mach_absolute_time() -> u64;
|
||||
}
|
||||
|
||||
/// A timer which uses mach_absolute_time to get its time. This is what the metal callbacks use.
|
||||
#[derive(Debug)]
|
||||
pub struct PresentationTimer {
|
||||
scale: MachTimebaseInfo,
|
||||
}
|
||||
impl PresentationTimer {
|
||||
/// Generates a new timer.
|
||||
pub fn new() -> Self {
|
||||
// Default to 1 / 1 in case the call to timebase_info fails.
|
||||
let mut scale = MachTimebaseInfo {
|
||||
numerator: 1,
|
||||
denominator: 1,
|
||||
};
|
||||
unsafe { mach_timebase_info(&mut scale) };
|
||||
|
||||
Self { scale }
|
||||
}
|
||||
|
||||
/// Gets the current time in nanoseconds.
|
||||
pub fn get_timestamp_ns(&self) -> u128 {
|
||||
let time = unsafe { mach_absolute_time() };
|
||||
|
||||
(time as u128 * self.scale.numerator as u128) / self.scale.denominator as u128
|
||||
}
|
||||
}
|
||||
Vendored
+88
@@ -0,0 +1,88 @@
|
||||
use alloc::vec::Vec;
|
||||
use core::{cell::UnsafeCell, ops::Range, ptr};
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(supports_ptr_atomics)] {
|
||||
use alloc::sync::Arc;
|
||||
} else if #[cfg(feature = "portable-atomic")] {
|
||||
use portable_atomic_util::Arc;
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Buffer {
|
||||
/// This data is potentially accessed mutably in arbitrary non-overlapping slices,
|
||||
/// so we must store it in `UnsafeCell` to avoid making any too-strong no-aliasing claims.
|
||||
storage: Arc<UnsafeCell<[u8]>>,
|
||||
|
||||
/// Size of the allocation.
|
||||
///
|
||||
/// This is redundant with `storage.get().len()`, but that method is not
|
||||
/// available until our MSRV is 1.79 or greater.
|
||||
size: usize,
|
||||
}
|
||||
|
||||
/// SAFETY:
|
||||
/// This shared mutable data will not be accessed in a way which causes data races;
|
||||
/// the obligation to do so is on the caller of the HAL API.
|
||||
/// For safe code, `wgpu-core` validation manages appropriate access.
|
||||
unsafe impl Send for Buffer {}
|
||||
unsafe impl Sync for Buffer {}
|
||||
|
||||
impl Buffer {
|
||||
pub(super) fn new(desc: &crate::BufferDescriptor) -> Result<Self, crate::DeviceError> {
|
||||
let &crate::BufferDescriptor {
|
||||
label: _,
|
||||
size,
|
||||
usage: _,
|
||||
memory_flags: _,
|
||||
} = desc;
|
||||
|
||||
let size = usize::try_from(size).map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
|
||||
let mut vector: Vec<u8> = Vec::new();
|
||||
vector
|
||||
.try_reserve_exact(size)
|
||||
.map_err(|_| crate::DeviceError::OutOfMemory)?;
|
||||
vector.resize(size, 0);
|
||||
let storage: Arc<[u8]> = Arc::from(vector);
|
||||
debug_assert_eq!(storage.len(), size);
|
||||
|
||||
// SAFETY: `UnsafeCell<[u8]>` and `[u8]` have the same layout.
|
||||
// This is just adding a wrapper type without changing any layout,
|
||||
// because there is not currently a safe language/`std` way to accomplish this.
|
||||
let storage: Arc<UnsafeCell<[u8]>> =
|
||||
unsafe { Arc::from_raw(Arc::into_raw(storage) as *mut UnsafeCell<[u8]>) };
|
||||
|
||||
Ok(Buffer { storage, size })
|
||||
}
|
||||
|
||||
/// Returns a pointer to the memory owned by this buffer within the given `range`.
|
||||
///
|
||||
/// This may be used to create any number of simultaneous pointers;
|
||||
/// aliasing is only a concern when actually reading, writing, or converting the pointer
|
||||
/// to a reference.
|
||||
pub(super) fn get_slice_ptr(&self, range: crate::MemoryRange) -> *mut [u8] {
|
||||
let base_ptr = self.storage.get();
|
||||
let range = range_to_usize(range, self.size);
|
||||
|
||||
// We must obtain a slice pointer without ever creating a slice reference
|
||||
// that could alias with another slice.
|
||||
ptr::slice_from_raw_parts_mut(
|
||||
// SAFETY: `range_to_usize` bounds checks this addition.
|
||||
unsafe { base_ptr.cast::<u8>().add(range.start) },
|
||||
range.len(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert a [`crate::MemoryRange`] to `Range<usize>` and bounds check it.
|
||||
fn range_to_usize(range: crate::MemoryRange, upper_bound: usize) -> Range<usize> {
|
||||
// Note: these assertions should be impossible to trigger from safe code.
|
||||
// We're doing them anyway since this entire backend is for testing
|
||||
// (except for when it is an unused placeholder)
|
||||
let start = usize::try_from(range.start).expect("range too large");
|
||||
let end = usize::try_from(range.end).expect("range too large");
|
||||
assert!(start <= end && end <= upper_bound, "range out of bounds");
|
||||
start..end
|
||||
}
|
||||
Vendored
+356
@@ -0,0 +1,356 @@
|
||||
use alloc::vec::Vec;
|
||||
use core::mem;
|
||||
use core::ops::Range;
|
||||
|
||||
use super::{Api, Buffer, DeviceResult, Resource};
|
||||
|
||||
/// Command buffer type, which performs double duty as the command encoder type too.
|
||||
#[derive(Debug)]
|
||||
pub struct CommandBuffer {
|
||||
commands: Vec<Command>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum Command {
|
||||
ClearBuffer {
|
||||
buffer: Buffer,
|
||||
range: crate::MemoryRange,
|
||||
},
|
||||
CopyBufferToBuffer {
|
||||
src: Buffer,
|
||||
dst: Buffer,
|
||||
regions: Vec<crate::BufferCopy>,
|
||||
},
|
||||
}
|
||||
|
||||
impl CommandBuffer {
|
||||
/// # Safety
|
||||
///
|
||||
/// Must be called with appropriate synchronization for the resources affected by the command,
|
||||
/// such as ensuring that buffers are not accessed by a command while aliasing references exist.
|
||||
pub(crate) unsafe fn execute(&self) {
|
||||
for command in &self.commands {
|
||||
unsafe { command.execute() };
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn new() -> Self {
|
||||
Self {
|
||||
commands: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::CommandEncoder for CommandBuffer {
|
||||
type A = Api;
|
||||
|
||||
unsafe fn begin_encoding(&mut self, label: crate::Label) -> DeviceResult<()> {
|
||||
assert!(self.commands.is_empty());
|
||||
Ok(())
|
||||
}
|
||||
unsafe fn discard_encoding(&mut self) {
|
||||
self.commands.clear();
|
||||
}
|
||||
unsafe fn end_encoding(&mut self) -> DeviceResult<CommandBuffer> {
|
||||
Ok(CommandBuffer {
|
||||
commands: mem::take(&mut self.commands),
|
||||
})
|
||||
}
|
||||
unsafe fn reset_all<I>(&mut self, command_buffers: I) {}
|
||||
|
||||
unsafe fn transition_buffers<'a, T>(&mut self, barriers: T)
|
||||
where
|
||||
T: Iterator<Item = crate::BufferBarrier<'a, Buffer>>,
|
||||
{
|
||||
}
|
||||
|
||||
unsafe fn transition_textures<'a, T>(&mut self, barriers: T)
|
||||
where
|
||||
T: Iterator<Item = crate::TextureBarrier<'a, Resource>>,
|
||||
{
|
||||
}
|
||||
|
||||
unsafe fn clear_buffer(&mut self, buffer: &Buffer, range: crate::MemoryRange) {
|
||||
self.commands.push(Command::ClearBuffer {
|
||||
buffer: buffer.clone(),
|
||||
range,
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn copy_buffer_to_buffer<T>(&mut self, src: &Buffer, dst: &Buffer, regions: T)
|
||||
where
|
||||
T: Iterator<Item = crate::BufferCopy>,
|
||||
{
|
||||
self.commands.push(Command::CopyBufferToBuffer {
|
||||
src: src.clone(),
|
||||
dst: dst.clone(),
|
||||
regions: regions.collect(),
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(webgl)]
|
||||
unsafe fn copy_external_image_to_texture<T>(
|
||||
&mut self,
|
||||
src: &wgt::CopyExternalImageSourceInfo,
|
||||
dst: &Resource,
|
||||
dst_premultiplication: bool,
|
||||
regions: T,
|
||||
) where
|
||||
T: Iterator<Item = crate::TextureCopy>,
|
||||
{
|
||||
}
|
||||
|
||||
unsafe fn copy_texture_to_texture<T>(
|
||||
&mut self,
|
||||
src: &Resource,
|
||||
src_usage: wgt::TextureUses,
|
||||
dst: &Resource,
|
||||
regions: T,
|
||||
) {
|
||||
// TODO: consider implementing this and other texture manipulation
|
||||
}
|
||||
|
||||
unsafe fn copy_buffer_to_texture<T>(&mut self, src: &Buffer, dst: &Resource, regions: T) {
|
||||
// TODO: consider implementing this and other texture manipulation
|
||||
}
|
||||
|
||||
unsafe fn copy_texture_to_buffer<T>(
|
||||
&mut self,
|
||||
src: &Resource,
|
||||
src_usage: wgt::TextureUses,
|
||||
dst: &Buffer,
|
||||
regions: T,
|
||||
) {
|
||||
// TODO: consider implementing this and other texture manipulation
|
||||
}
|
||||
|
||||
unsafe fn begin_query(&mut self, set: &Resource, index: u32) {}
|
||||
unsafe fn end_query(&mut self, set: &Resource, index: u32) {}
|
||||
unsafe fn write_timestamp(&mut self, set: &Resource, index: u32) {}
|
||||
unsafe fn read_acceleration_structure_compact_size(
|
||||
&mut self,
|
||||
acceleration_structure: &Resource,
|
||||
buf: &Buffer,
|
||||
) {
|
||||
}
|
||||
unsafe fn reset_queries(&mut self, set: &Resource, range: Range<u32>) {}
|
||||
unsafe fn copy_query_results(
|
||||
&mut self,
|
||||
set: &Resource,
|
||||
range: Range<u32>,
|
||||
buffer: &Buffer,
|
||||
offset: wgt::BufferAddress,
|
||||
stride: wgt::BufferSize,
|
||||
) {
|
||||
}
|
||||
|
||||
// render
|
||||
|
||||
unsafe fn begin_render_pass(
|
||||
&mut self,
|
||||
desc: &crate::RenderPassDescriptor<Resource, Resource>,
|
||||
) -> DeviceResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
unsafe fn end_render_pass(&mut self) {}
|
||||
|
||||
unsafe fn set_bind_group(
|
||||
&mut self,
|
||||
layout: &Resource,
|
||||
index: u32,
|
||||
group: &Resource,
|
||||
dynamic_offsets: &[wgt::DynamicOffset],
|
||||
) {
|
||||
}
|
||||
unsafe fn set_immediates(&mut self, layout: &Resource, offset_bytes: u32, data: &[u32]) {}
|
||||
|
||||
unsafe fn insert_debug_marker(&mut self, label: &str) {}
|
||||
unsafe fn begin_debug_marker(&mut self, group_label: &str) {}
|
||||
unsafe fn end_debug_marker(&mut self) {}
|
||||
|
||||
unsafe fn set_render_pipeline(&mut self, pipeline: &Resource) {}
|
||||
|
||||
unsafe fn set_index_buffer<'a>(
|
||||
&mut self,
|
||||
binding: crate::BufferBinding<'a, Buffer>,
|
||||
format: wgt::IndexFormat,
|
||||
) {
|
||||
}
|
||||
unsafe fn set_vertex_buffer<'a>(
|
||||
&mut self,
|
||||
index: u32,
|
||||
binding: crate::BufferBinding<'a, Buffer>,
|
||||
) {
|
||||
}
|
||||
unsafe fn set_viewport(&mut self, rect: &crate::Rect<f32>, depth_range: Range<f32>) {}
|
||||
unsafe fn set_scissor_rect(&mut self, rect: &crate::Rect<u32>) {}
|
||||
unsafe fn set_stencil_reference(&mut self, value: u32) {}
|
||||
unsafe fn set_blend_constants(&mut self, color: &[f32; 4]) {}
|
||||
|
||||
unsafe fn draw(
|
||||
&mut self,
|
||||
first_vertex: u32,
|
||||
vertex_count: u32,
|
||||
first_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_indexed(
|
||||
&mut self,
|
||||
first_index: u32,
|
||||
index_count: u32,
|
||||
base_vertex: i32,
|
||||
first_instance: u32,
|
||||
instance_count: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_mesh_tasks(
|
||||
&mut self,
|
||||
group_count_x: u32,
|
||||
group_count_y: u32,
|
||||
group_count_z: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_indirect(
|
||||
&mut self,
|
||||
buffer: &Buffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_indexed_indirect(
|
||||
&mut self,
|
||||
buffer: &Buffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_mesh_tasks_indirect(
|
||||
&mut self,
|
||||
buffer: &<Self::A as crate::Api>::Buffer,
|
||||
offset: wgt::BufferAddress,
|
||||
draw_count: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_indirect_count(
|
||||
&mut self,
|
||||
buffer: &Buffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &Buffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_indexed_indirect_count(
|
||||
&mut self,
|
||||
buffer: &Buffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &Buffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
}
|
||||
unsafe fn draw_mesh_tasks_indirect_count(
|
||||
&mut self,
|
||||
buffer: &<Self::A as crate::Api>::Buffer,
|
||||
offset: wgt::BufferAddress,
|
||||
count_buffer: &<Self::A as crate::Api>::Buffer,
|
||||
count_offset: wgt::BufferAddress,
|
||||
max_count: u32,
|
||||
) {
|
||||
}
|
||||
|
||||
// compute
|
||||
|
||||
unsafe fn begin_compute_pass(&mut self, desc: &crate::ComputePassDescriptor<Resource>) {}
|
||||
unsafe fn end_compute_pass(&mut self) {}
|
||||
|
||||
unsafe fn set_compute_pipeline(&mut self, pipeline: &Resource) {}
|
||||
|
||||
unsafe fn dispatch_workgroups(&mut self, count: [u32; 3]) {}
|
||||
unsafe fn dispatch_workgroups_indirect(&mut self, buffer: &Buffer, offset: wgt::BufferAddress) {
|
||||
}
|
||||
|
||||
unsafe fn build_acceleration_structures<'a, T>(
|
||||
&mut self,
|
||||
_descriptor_count: u32,
|
||||
descriptors: T,
|
||||
) where
|
||||
Api: 'a,
|
||||
T: IntoIterator<Item = crate::BuildAccelerationStructureDescriptor<'a, Buffer, Resource>>,
|
||||
{
|
||||
}
|
||||
|
||||
unsafe fn place_acceleration_structure_barrier(
|
||||
&mut self,
|
||||
_barriers: crate::AccelerationStructureBarrier,
|
||||
) {
|
||||
}
|
||||
|
||||
unsafe fn copy_acceleration_structure_to_acceleration_structure(
|
||||
&mut self,
|
||||
src: &Resource,
|
||||
dst: &Resource,
|
||||
copy: wgt::AccelerationStructureCopy,
|
||||
) {
|
||||
}
|
||||
|
||||
unsafe fn set_acceleration_structure_dependencies(
|
||||
command_buffers: &[&CommandBuffer],
|
||||
dependencies: &[&Resource],
|
||||
) {
|
||||
}
|
||||
|
||||
unsafe fn begin_ray_tracing_pass(&mut self, _desc: &crate::RayTracingPassDescriptor) {}
|
||||
|
||||
unsafe fn end_ray_tracing_pass(&mut self) {}
|
||||
|
||||
unsafe fn set_ray_tracing_pipeline(
|
||||
&mut self,
|
||||
_pipeline: &<Self::A as crate::Api>::RayTracingPipeline,
|
||||
) {
|
||||
}
|
||||
|
||||
unsafe fn trace_rays(
|
||||
&mut self,
|
||||
_count: [u32; 3],
|
||||
_ray_generation_group_data: crate::PipelineGroupData<Buffer>,
|
||||
_miss_group_data: crate::PipelineGroupData<Buffer>,
|
||||
_intersection_group_data: crate::PipelineGroupData<Buffer>,
|
||||
) {
|
||||
}
|
||||
}
|
||||
|
||||
impl Command {
|
||||
/// # Safety
|
||||
///
|
||||
/// Must be called with appropriate synchronization for the resources affected by the command,
|
||||
/// such as ensuring that buffers are not accessed by a command while aliasing references exist.
|
||||
unsafe fn execute(&self) {
|
||||
match self {
|
||||
Command::ClearBuffer { ref buffer, range } => {
|
||||
// SAFETY:
|
||||
// Caller is responsible for ensuring this does not alias.
|
||||
let buffer_slice: &mut [u8] = unsafe { &mut *buffer.get_slice_ptr(range.clone()) };
|
||||
buffer_slice.fill(0);
|
||||
}
|
||||
|
||||
Command::CopyBufferToBuffer { src, dst, regions } => {
|
||||
for &crate::BufferCopy {
|
||||
src_offset,
|
||||
dst_offset,
|
||||
size,
|
||||
} in regions
|
||||
{
|
||||
// SAFETY:
|
||||
// Caller is responsible for ensuring this does not alias.
|
||||
let src_region: &[u8] =
|
||||
unsafe { &*src.get_slice_ptr(src_offset..src_offset + size.get()) };
|
||||
let dst_region: &mut [u8] =
|
||||
unsafe { &mut *dst.get_slice_ptr(dst_offset..dst_offset + size.get()) };
|
||||
dst_region.copy_from_slice(src_region);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Vendored
+487
@@ -0,0 +1,487 @@
|
||||
#![allow(unused_variables)]
|
||||
|
||||
use alloc::{string::String, sync::Arc, vec, vec::Vec};
|
||||
use core::{ptr, sync::atomic::Ordering, time::Duration};
|
||||
|
||||
#[cfg(supports_64bit_atomics)]
|
||||
use core::sync::atomic::AtomicU64;
|
||||
#[cfg(not(supports_64bit_atomics))]
|
||||
use portable_atomic::AtomicU64;
|
||||
|
||||
use crate::TlasInstance;
|
||||
|
||||
mod buffer;
|
||||
pub use buffer::Buffer;
|
||||
mod command;
|
||||
pub use command::CommandBuffer;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Api;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Context {
|
||||
options: Arc<wgt::NoopBackendOptions>,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct Encoder;
|
||||
#[derive(Debug)]
|
||||
pub struct Resource;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Fence {
|
||||
value: AtomicU64,
|
||||
}
|
||||
|
||||
type DeviceResult<T> = Result<T, crate::DeviceError>;
|
||||
|
||||
impl crate::Api for Api {
|
||||
const VARIANT: wgt::Backend = wgt::Backend::Noop;
|
||||
|
||||
type Instance = Context;
|
||||
type Surface = Context;
|
||||
type Adapter = Context;
|
||||
type Device = Context;
|
||||
|
||||
type Queue = Context;
|
||||
type CommandEncoder = CommandBuffer;
|
||||
type CommandBuffer = CommandBuffer;
|
||||
|
||||
type Buffer = Buffer;
|
||||
type Texture = Resource;
|
||||
type SurfaceTexture = Resource;
|
||||
type TextureView = Resource;
|
||||
type Sampler = Resource;
|
||||
type QuerySet = Resource;
|
||||
type Fence = Fence;
|
||||
type AccelerationStructure = Resource;
|
||||
type PipelineCache = Resource;
|
||||
|
||||
type BindGroupLayout = Resource;
|
||||
type BindGroup = Resource;
|
||||
type PipelineLayout = Resource;
|
||||
type ShaderModule = Resource;
|
||||
type RenderPipeline = Resource;
|
||||
type RayTracingPipeline = Resource;
|
||||
type ComputePipeline = Resource;
|
||||
}
|
||||
|
||||
crate::impl_dyn_resource!(Buffer, CommandBuffer, Context, Fence, Resource);
|
||||
|
||||
impl crate::DynAccelerationStructure for Resource {}
|
||||
impl crate::DynBindGroup for Resource {}
|
||||
impl crate::DynBindGroupLayout for Resource {}
|
||||
impl crate::DynBuffer for Buffer {}
|
||||
impl crate::DynCommandBuffer for CommandBuffer {}
|
||||
impl crate::DynComputePipeline for Resource {}
|
||||
impl crate::DynFence for Fence {}
|
||||
impl crate::DynPipelineCache for Resource {}
|
||||
impl crate::DynPipelineLayout for Resource {}
|
||||
impl crate::DynQuerySet for Resource {}
|
||||
impl crate::DynRenderPipeline for Resource {}
|
||||
impl crate::DynRayTracingPipeline for Resource {}
|
||||
impl crate::DynSampler for Resource {}
|
||||
impl crate::DynShaderModule for Resource {}
|
||||
impl crate::DynSurfaceTexture for Resource {}
|
||||
impl crate::DynTexture for Resource {}
|
||||
impl crate::DynTextureView for Resource {}
|
||||
|
||||
impl core::borrow::Borrow<dyn crate::DynTexture> for Resource {
|
||||
fn borrow(&self) -> &dyn crate::DynTexture {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::Instance for Context {
|
||||
type A = Api;
|
||||
|
||||
unsafe fn init(desc: &crate::InstanceDescriptor<'_>) -> Result<Self, crate::InstanceError> {
|
||||
let options = Arc::new(desc.backend_options.noop.clone());
|
||||
if options.enable {
|
||||
Ok(Context { options })
|
||||
} else {
|
||||
Err(crate::InstanceError::new(String::from(
|
||||
"noop backend disabled because NoopBackendOptions::enable is false",
|
||||
)))
|
||||
}
|
||||
}
|
||||
unsafe fn create_surface(
|
||||
&self,
|
||||
_display_handle: raw_window_handle::RawDisplayHandle,
|
||||
_window_handle: raw_window_handle::RawWindowHandle,
|
||||
) -> Result<Context, crate::InstanceError> {
|
||||
Ok(Context {
|
||||
options: Arc::clone(&self.options),
|
||||
})
|
||||
}
|
||||
unsafe fn enumerate_adapters(
|
||||
&self,
|
||||
_surface_hint: Option<&Context>,
|
||||
) -> Vec<crate::ExposedAdapter<Api>> {
|
||||
let device_type = self.options.device_type.unwrap_or(wgt::DeviceType::Other);
|
||||
let subgroup_min_size = self
|
||||
.options
|
||||
.subgroup_min_size
|
||||
.unwrap_or(wgt::MINIMUM_SUBGROUP_MIN_SIZE);
|
||||
let subgroup_max_size = self
|
||||
.options
|
||||
.subgroup_max_size
|
||||
.unwrap_or(wgt::MAXIMUM_SUBGROUP_MAX_SIZE);
|
||||
let features = self.options.features.unwrap_or(wgt::Features::all());
|
||||
let limits = self
|
||||
.options
|
||||
.limits
|
||||
.clone()
|
||||
.unwrap_or(CAPABILITIES.limits.clone());
|
||||
|
||||
let info = wgt::AdapterInfo {
|
||||
subgroup_min_size,
|
||||
subgroup_max_size,
|
||||
..adapter_info()
|
||||
};
|
||||
|
||||
let capabilities = crate::Capabilities {
|
||||
limits,
|
||||
..CAPABILITIES
|
||||
};
|
||||
|
||||
vec![crate::ExposedAdapter {
|
||||
adapter: Context {
|
||||
options: Arc::clone(&self.options),
|
||||
},
|
||||
info,
|
||||
features,
|
||||
capabilities,
|
||||
}]
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the adapter info for the noop backend.
|
||||
///
|
||||
/// This is used in the test harness to construct info about
|
||||
/// the noop backend adapter without actually initializing wgpu.
|
||||
pub fn adapter_info() -> wgt::AdapterInfo {
|
||||
wgt::AdapterInfo {
|
||||
name: String::from("noop wgpu backend"),
|
||||
driver: String::from("wgpu"),
|
||||
..wgt::AdapterInfo::new(wgt::DeviceType::Cpu, wgt::Backend::Noop)
|
||||
}
|
||||
}
|
||||
|
||||
/// The capabilities of the noop backend.
|
||||
///
|
||||
/// This is used in the test harness to construct capabilities
|
||||
/// of the noop backend without actually initializing wgpu.
|
||||
pub const CAPABILITIES: crate::Capabilities = {
|
||||
crate::Capabilities {
|
||||
limits: wgt::Limits::unlimited(),
|
||||
alignments: crate::Alignments {
|
||||
// All maximally permissive
|
||||
buffer_copy_offset: wgt::BufferSize::MIN,
|
||||
buffer_copy_pitch: wgt::BufferSize::MIN,
|
||||
uniform_bounds_check_alignment: wgt::BufferSize::MIN,
|
||||
raw_tlas_instance_size: 0,
|
||||
ray_tracing_scratch_buffer_alignment: 1,
|
||||
ray_tracing_pipeline_group_data_size: 1,
|
||||
ray_tracing_pipeline_group_data_alignment: 1,
|
||||
ray_tracing_pipeline_data_offset_alignment: 1,
|
||||
},
|
||||
downlevel: wgt::DownlevelCapabilities {
|
||||
flags: wgt::DownlevelFlags::all(),
|
||||
limits: wgt::DownlevelLimits {},
|
||||
shader_model: wgt::ShaderModel::Sm5,
|
||||
},
|
||||
cooperative_matrix_properties: Vec::new(),
|
||||
}
|
||||
};
|
||||
|
||||
impl crate::Surface for Context {
|
||||
type A = Api;
|
||||
|
||||
unsafe fn configure(
|
||||
&self,
|
||||
device: &Context,
|
||||
config: &crate::SurfaceConfiguration,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn unconfigure(&self, device: &Context) {}
|
||||
|
||||
unsafe fn acquire_texture(
|
||||
&self,
|
||||
_timeout: Option<Duration>,
|
||||
_fence: &Fence,
|
||||
) -> Result<crate::AcquiredSurfaceTexture<Api>, crate::SurfaceError> {
|
||||
Err(crate::SurfaceError::Timeout)
|
||||
}
|
||||
unsafe fn discard_texture(&self, texture: Resource) {}
|
||||
}
|
||||
|
||||
impl crate::Adapter for Context {
|
||||
type A = Api;
|
||||
|
||||
unsafe fn open(
|
||||
&self,
|
||||
features: wgt::Features,
|
||||
_limits: &wgt::Limits,
|
||||
_memory_hints: &wgt::MemoryHints,
|
||||
) -> DeviceResult<crate::OpenDevice<Api>> {
|
||||
Ok(crate::OpenDevice {
|
||||
device: Context {
|
||||
options: Arc::clone(&self.options),
|
||||
},
|
||||
queue: Context {
|
||||
options: Arc::clone(&self.options),
|
||||
},
|
||||
})
|
||||
}
|
||||
unsafe fn texture_format_capabilities(
|
||||
&self,
|
||||
format: wgt::TextureFormat,
|
||||
) -> crate::TextureFormatCapabilities {
|
||||
crate::TextureFormatCapabilities::empty()
|
||||
}
|
||||
|
||||
unsafe fn surface_capabilities(&self, surface: &Context) -> Option<crate::SurfaceCapabilities> {
|
||||
None
|
||||
}
|
||||
|
||||
unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
|
||||
wgt::PresentationTimestamp::INVALID_TIMESTAMP
|
||||
}
|
||||
|
||||
fn get_ordered_buffer_usages(&self) -> wgt::BufferUses {
|
||||
wgt::BufferUses::INCLUSIVE | wgt::BufferUses::MAP_WRITE
|
||||
}
|
||||
|
||||
fn get_ordered_texture_usages(&self) -> wgt::TextureUses {
|
||||
wgt::TextureUses::INCLUSIVE
|
||||
| wgt::TextureUses::COLOR_TARGET
|
||||
| wgt::TextureUses::DEPTH_STENCIL_WRITE
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::Queue for Context {
|
||||
type A = Api;
|
||||
|
||||
unsafe fn submit(
|
||||
&self,
|
||||
command_buffers: &[&CommandBuffer],
|
||||
surface_textures: &[&Resource],
|
||||
(fence, fence_value): (&Fence, crate::FenceValue),
|
||||
) -> DeviceResult<()> {
|
||||
// All commands are executed synchronously.
|
||||
for cb in command_buffers {
|
||||
// SAFETY: Caller is responsible for ensuring synchronization between commands and
|
||||
// other mutations.
|
||||
unsafe {
|
||||
cb.execute();
|
||||
}
|
||||
}
|
||||
fence.value.store(fence_value, Ordering::Release);
|
||||
Ok(())
|
||||
}
|
||||
unsafe fn present(
|
||||
&self,
|
||||
surface: &Context,
|
||||
texture: Resource,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn get_timestamp_period(&self) -> f32 {
|
||||
1.0
|
||||
}
|
||||
|
||||
unsafe fn wait_for_idle(&self) -> Result<(), crate::DeviceError> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::Device for Context {
|
||||
type A = Api;
|
||||
|
||||
unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult<Buffer> {
|
||||
Buffer::new(desc)
|
||||
}
|
||||
|
||||
unsafe fn destroy_buffer(&self, buffer: Buffer) {}
|
||||
unsafe fn add_raw_buffer(&self, _buffer: &Buffer) {}
|
||||
|
||||
unsafe fn map_buffer(
|
||||
&self,
|
||||
buffer: &Buffer,
|
||||
range: crate::MemoryRange,
|
||||
) -> DeviceResult<crate::BufferMapping> {
|
||||
// Safety: the `wgpu-core` validation layer will prevent any user-accessible aliasing
|
||||
// mappings from being created, so we don’t need to perform any checks here, except for
|
||||
// bounds checks on the range which are built into `get_slice_ptr()`.
|
||||
Ok(crate::BufferMapping {
|
||||
ptr: ptr::NonNull::new(buffer.get_slice_ptr(range).cast::<u8>()).unwrap(),
|
||||
is_coherent: true,
|
||||
})
|
||||
}
|
||||
unsafe fn unmap_buffer(&self, buffer: &Buffer) {}
|
||||
unsafe fn flush_mapped_ranges<I>(&self, buffer: &Buffer, ranges: I) {}
|
||||
unsafe fn invalidate_mapped_ranges<I>(&self, buffer: &Buffer, ranges: I) {}
|
||||
|
||||
unsafe fn create_texture(&self, desc: &crate::TextureDescriptor) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_texture(&self, texture: Resource) {}
|
||||
unsafe fn add_raw_texture(&self, _texture: &Resource) {}
|
||||
|
||||
unsafe fn create_texture_view(
|
||||
&self,
|
||||
texture: &Resource,
|
||||
desc: &crate::TextureViewDescriptor,
|
||||
) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_texture_view(&self, view: Resource) {}
|
||||
unsafe fn create_sampler(&self, desc: &crate::SamplerDescriptor) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_sampler(&self, sampler: Resource) {}
|
||||
|
||||
unsafe fn create_command_encoder(
|
||||
&self,
|
||||
desc: &crate::CommandEncoderDescriptor<Context>,
|
||||
) -> DeviceResult<CommandBuffer> {
|
||||
Ok(CommandBuffer::new())
|
||||
}
|
||||
|
||||
unsafe fn create_bind_group_layout(
|
||||
&self,
|
||||
desc: &crate::BindGroupLayoutDescriptor,
|
||||
) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_bind_group_layout(&self, bg_layout: Resource) {}
|
||||
unsafe fn create_pipeline_layout(
|
||||
&self,
|
||||
desc: &crate::PipelineLayoutDescriptor<Resource>,
|
||||
) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {}
|
||||
unsafe fn create_bind_group(
|
||||
&self,
|
||||
desc: &crate::BindGroupDescriptor<Resource, Buffer, Resource, Resource, Resource>,
|
||||
) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_bind_group(&self, group: Resource) {}
|
||||
|
||||
unsafe fn create_shader_module(
|
||||
&self,
|
||||
desc: &crate::ShaderModuleDescriptor,
|
||||
shader: crate::ShaderInput,
|
||||
) -> Result<Resource, crate::ShaderError> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_shader_module(&self, module: Resource) {}
|
||||
unsafe fn create_render_pipeline(
|
||||
&self,
|
||||
desc: &crate::RenderPipelineDescriptor<Resource, Resource, Resource>,
|
||||
) -> Result<Resource, crate::PipelineError> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_render_pipeline(&self, pipeline: Resource) {}
|
||||
unsafe fn create_compute_pipeline(
|
||||
&self,
|
||||
desc: &crate::ComputePipelineDescriptor<Resource, Resource, Resource>,
|
||||
) -> Result<Resource, crate::PipelineError> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_compute_pipeline(&self, pipeline: Resource) {}
|
||||
unsafe fn create_ray_tracing_pipeline(
|
||||
&self,
|
||||
desc: &crate::RayTracingPipelineDescriptor<Resource, Resource, Resource>,
|
||||
) -> Result<Resource, crate::PipelineError> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_ray_tracing_pipeline(&self, pipeline: Resource) {}
|
||||
unsafe fn get_raytracing_pipeline_group_data(
|
||||
&self,
|
||||
pipeline: &Resource,
|
||||
groups: core::ops::Range<u32>,
|
||||
) -> Result<Vec<u8>, crate::DeviceError> {
|
||||
Ok(vec![0; groups.count()])
|
||||
}
|
||||
unsafe fn create_pipeline_cache(
|
||||
&self,
|
||||
desc: &crate::PipelineCacheDescriptor<'_>,
|
||||
) -> Result<Resource, crate::PipelineCacheError> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_pipeline_cache(&self, cache: Resource) {}
|
||||
|
||||
unsafe fn create_query_set(
|
||||
&self,
|
||||
desc: &wgt::QuerySetDescriptor<crate::Label>,
|
||||
) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn destroy_query_set(&self, set: Resource) {}
|
||||
unsafe fn create_fence(&self) -> DeviceResult<Fence> {
|
||||
Ok(Fence {
|
||||
value: AtomicU64::new(0),
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_fence(&self, fence: Fence) {}
|
||||
unsafe fn get_fence_value(&self, fence: &Fence) -> DeviceResult<crate::FenceValue> {
|
||||
Ok(fence.value.load(Ordering::Acquire))
|
||||
}
|
||||
unsafe fn wait(
|
||||
&self,
|
||||
fence: &Fence,
|
||||
value: crate::FenceValue,
|
||||
timeout: Option<Duration>,
|
||||
) -> DeviceResult<bool> {
|
||||
// The relevant commands must have already been submitted, and noop-backend commands are
|
||||
// executed synchronously, so there is no waiting — either it is already done,
|
||||
// or this method was called incorrectly.
|
||||
assert!(
|
||||
fence.value.load(Ordering::Acquire) >= value,
|
||||
"submission must have already been done"
|
||||
);
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
unsafe fn start_graphics_debugger_capture(&self) -> bool {
|
||||
false
|
||||
}
|
||||
unsafe fn stop_graphics_debugger_capture(&self) {}
|
||||
unsafe fn create_acceleration_structure(
|
||||
&self,
|
||||
desc: &crate::AccelerationStructureDescriptor,
|
||||
) -> DeviceResult<Resource> {
|
||||
Ok(Resource)
|
||||
}
|
||||
unsafe fn get_acceleration_structure_build_sizes<'a>(
|
||||
&self,
|
||||
_desc: &crate::GetAccelerationStructureBuildSizesDescriptor<'a, Buffer>,
|
||||
) -> crate::AccelerationStructureBuildSizes {
|
||||
Default::default()
|
||||
}
|
||||
unsafe fn get_acceleration_structure_device_address(
|
||||
&self,
|
||||
_acceleration_structure: &Resource,
|
||||
) -> wgt::BufferAddress {
|
||||
Default::default()
|
||||
}
|
||||
unsafe fn destroy_acceleration_structure(&self, _acceleration_structure: Resource) {}
|
||||
|
||||
fn tlas_instance_to_bytes(&self, instance: TlasInstance) -> Vec<u8> {
|
||||
vec![]
|
||||
}
|
||||
|
||||
fn get_internal_counters(&self) -> wgt::HalCounters {
|
||||
Default::default()
|
||||
}
|
||||
|
||||
fn check_if_oom(&self) -> DeviceResult<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
use alloc::{string::String, vec::Vec};
|
||||
|
||||
use parking_lot::Mutex;
|
||||
|
||||
/// Stores the text of any validation errors that have occurred since
|
||||
/// the last call to `get_and_reset`.
|
||||
///
|
||||
/// Each value is a validation error and a message associated with it,
|
||||
/// or `None` if the error has no message from the api.
|
||||
///
|
||||
/// This is used for internal wgpu testing only and _must not_ be used
|
||||
/// as a way to check for errors.
|
||||
///
|
||||
/// This works as a static because `cargo nextest` runs all of our
|
||||
/// tests in separate processes, so each test gets its own canary.
|
||||
///
|
||||
/// This prevents the issue of one validation error terminating the
|
||||
/// entire process.
|
||||
pub static VALIDATION_CANARY: ValidationCanary = ValidationCanary {
|
||||
inner: Mutex::new(Vec::new()),
|
||||
};
|
||||
|
||||
/// Flag for internal testing.
|
||||
#[derive(Debug)]
|
||||
pub struct ValidationCanary {
|
||||
inner: Mutex<Vec<String>>,
|
||||
}
|
||||
|
||||
impl ValidationCanary {
|
||||
#[allow(dead_code, reason = "in some configurations this function is dead")]
|
||||
pub(crate) fn add(&self, msg: String) {
|
||||
self.inner.lock().push(msg);
|
||||
}
|
||||
|
||||
/// Returns any API validation errors that have occurred in this process
|
||||
/// since the last call to this function.
|
||||
pub fn get_and_reset(&self) -> Vec<String> {
|
||||
self.inner.lock().drain(..).collect()
|
||||
}
|
||||
}
|
||||
+3551
File diff suppressed because it is too large.
Load diff
+1495
File diff suppressed because it is too large.
Load diff
Vendored
+1136
File diff suppressed because it is too large.
Load diff
+339
@@ -0,0 +1,339 @@
|
||||
use alloc::vec::Vec;
|
||||
use arrayvec::ArrayVec;
|
||||
use ash::vk;
|
||||
use hashbrown::{HashMap, HashSet};
|
||||
|
||||
const POOL_MIN_SETS: u32 = 64;
|
||||
const POOL_MAX_SETS: u32 = 512;
|
||||
|
||||
/// The dynamic counts are tracked separately since dynamic textures/buffers
|
||||
/// have distinct descriptor types compared to their non-dynamic counterparts.
|
||||
#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
|
||||
pub struct DescriptorCounts {
|
||||
pub sampler: u32,
|
||||
pub sampled_image: u32,
|
||||
pub storage_image: u32,
|
||||
pub uniform_buffer: u32,
|
||||
pub uniform_buffer_dynamic: u32,
|
||||
pub storage_buffer: u32,
|
||||
pub storage_buffer_dynamic: u32,
|
||||
pub acceleration_structure: u32,
|
||||
}
|
||||
|
||||
impl DescriptorCounts {
|
||||
fn total(&self) -> u32 {
|
||||
self.sampler
|
||||
+ self.sampled_image
|
||||
+ self.storage_image
|
||||
+ self.uniform_buffer
|
||||
+ self.uniform_buffer_dynamic
|
||||
+ self.storage_buffer
|
||||
+ self.storage_buffer_dynamic
|
||||
+ self.acceleration_structure
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct DescriptorSet {
|
||||
raw: vk::DescriptorSet,
|
||||
bucket_key: BucketKey,
|
||||
pool_index: usize,
|
||||
}
|
||||
|
||||
impl DescriptorSet {
|
||||
pub fn raw(&self) -> vk::DescriptorSet {
|
||||
self.raw
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Hash)]
|
||||
struct BucketKey {
|
||||
counts: DescriptorCounts,
|
||||
update_after_bind: bool,
|
||||
}
|
||||
|
||||
struct Pool {
|
||||
raw: vk::DescriptorPool,
|
||||
capacity: u32,
|
||||
available: u32,
|
||||
}
|
||||
|
||||
/// Keeps track of all pools created with this bucket's [`BucketKey`].
|
||||
#[derive(Default)]
|
||||
struct Bucket {
|
||||
/// We keep track of all descriptor set layouts that might use this bucket.
|
||||
/// If the set becomes empty, the bucket is destroyed.
|
||||
layouts: HashSet<vk::DescriptorSetLayout>,
|
||||
pools: Vec<Pool>,
|
||||
available_sets: u32,
|
||||
allocated_sets: u32,
|
||||
}
|
||||
|
||||
impl Bucket {
|
||||
fn create_pool(
|
||||
&mut self,
|
||||
device: &ash::Device,
|
||||
key: &BucketKey,
|
||||
capacity_hint: u32,
|
||||
) -> Result<(usize, &mut Pool), crate::DeviceError> {
|
||||
let index = self.pools.len();
|
||||
let pool = create_descriptor_pool(device, key, capacity_hint)?;
|
||||
self.available_sets += pool.capacity;
|
||||
self.pools.push(pool);
|
||||
Ok((index, self.pools.last_mut().unwrap()))
|
||||
}
|
||||
}
|
||||
|
||||
pub struct DescriptorAllocator {
|
||||
buckets: HashMap<BucketKey, Bucket>,
|
||||
max_update_after_bind_descriptors_in_all_pools: u32,
|
||||
update_after_bind_descriptors_in_all_pools: u32,
|
||||
}
|
||||
|
||||
impl super::BindGroupLayout {
|
||||
fn bucket_key(&self) -> BucketKey {
|
||||
let update_after_bind = self.contains_binding_arrays;
|
||||
let counts = self.desc_count.clone();
|
||||
BucketKey {
|
||||
counts,
|
||||
update_after_bind,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DescriptorAllocator {
|
||||
pub fn new(max_update_after_bind_descriptors_in_all_pools: u32) -> Self {
|
||||
DescriptorAllocator {
|
||||
buckets: HashMap::default(),
|
||||
max_update_after_bind_descriptors_in_all_pools,
|
||||
update_after_bind_descriptors_in_all_pools: 0,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn register_layout(
|
||||
&mut self,
|
||||
device: &ash::Device,
|
||||
layout: &super::BindGroupLayout,
|
||||
) -> Result<(), crate::DeviceError> {
|
||||
let key = layout.bucket_key();
|
||||
let bucket = match self.buckets.entry(key) {
|
||||
hashbrown::hash_map::Entry::Occupied(occupied_entry) => occupied_entry.into_mut(),
|
||||
hashbrown::hash_map::Entry::Vacant(vacant_entry) => {
|
||||
let mut bucket = Bucket::default();
|
||||
// Create at least 1 pool upfront instead of doing this when
|
||||
// creating the first bind group.
|
||||
bucket.create_pool(device, vacant_entry.key(), POOL_MIN_SETS)?;
|
||||
vacant_entry.insert(bucket)
|
||||
}
|
||||
};
|
||||
|
||||
assert!(bucket.layouts.insert(layout.raw));
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn unregister_layout(&mut self, device: &ash::Device, layout: &super::BindGroupLayout) {
|
||||
let key = layout.bucket_key();
|
||||
let bucket = self.buckets.get_mut(&key).unwrap();
|
||||
|
||||
assert!(bucket.layouts.remove(&layout.raw));
|
||||
|
||||
if bucket.layouts.is_empty() {
|
||||
// Remove the bucket and destroy any remaining pools.
|
||||
let bucket = self.buckets.remove(&key).unwrap();
|
||||
for pool in bucket.pools {
|
||||
assert_eq!(
|
||||
pool.available, pool.capacity,
|
||||
"pool is not empty, at least one DescriptorSet has not been freed"
|
||||
);
|
||||
unsafe { device.destroy_descriptor_pool(pool.raw, None) };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn alloc(
|
||||
&mut self,
|
||||
device: &ash::Device,
|
||||
layout: &super::BindGroupLayout,
|
||||
) -> Result<DescriptorSet, crate::DeviceError> {
|
||||
let update_after_bind = layout.contains_binding_arrays;
|
||||
let total_descriptors = layout.desc_count.total();
|
||||
|
||||
if update_after_bind
|
||||
&& self.max_update_after_bind_descriptors_in_all_pools
|
||||
- self.update_after_bind_descriptors_in_all_pools
|
||||
< total_descriptors
|
||||
{
|
||||
return Err(crate::DeviceError::OutOfMemory);
|
||||
}
|
||||
|
||||
let key = layout.bucket_key();
|
||||
let bucket = self.buckets.get_mut(&key).unwrap();
|
||||
|
||||
// Prefer smaller/older/fuller pools for new allocations to prevent
|
||||
// fragmentation and possibly fragmentation of hardware resources
|
||||
// (VK_ERROR_FRAGMENTATION)
|
||||
let pool = bucket
|
||||
.pools
|
||||
.iter_mut()
|
||||
.enumerate()
|
||||
.find(|(_, pool)| pool.available != 0);
|
||||
|
||||
let (pool_index, pool) = if let Some(pool) = pool {
|
||||
pool
|
||||
} else {
|
||||
let capacity_hint = bucket.allocated_sets;
|
||||
bucket.create_pool(device, &key, capacity_hint)?
|
||||
};
|
||||
|
||||
let vk_info = vk::DescriptorSetAllocateInfo::default()
|
||||
.descriptor_pool(pool.raw)
|
||||
.set_layouts(core::slice::from_ref(&layout.raw));
|
||||
|
||||
let raw = match unsafe { device.allocate_descriptor_sets(&vk_info) } {
|
||||
Ok(sets) => Ok(sets[0]),
|
||||
// We make sure not to exceed the size of the pool.
|
||||
Err(vk::Result::ERROR_OUT_OF_POOL_MEMORY) => unreachable!(),
|
||||
// We only allocate from a pool if the nr and type of descriptors
|
||||
// used by a layout is the same as those specified at pool
|
||||
// creation time.
|
||||
//
|
||||
// > Additionally, if all sets allocated from the pool since it was
|
||||
// created or most recently reset use the same number of
|
||||
// descriptors (of each type) and the requested allocation also
|
||||
// uses that same number of descriptors (of each type),
|
||||
// then fragmentation must not cause an allocation failure.
|
||||
//
|
||||
// from https://docs.vulkan.org/refpages/latest/refpages/source/VkDescriptorPoolCreateInfo.html#_description
|
||||
Err(vk::Result::ERROR_FRAGMENTED_POOL) => unreachable!(),
|
||||
Err(err) => Err(super::map_host_device_oom_err(err)),
|
||||
}?;
|
||||
|
||||
pool.available -= 1;
|
||||
bucket.available_sets -= 1;
|
||||
bucket.allocated_sets += 1;
|
||||
if update_after_bind {
|
||||
self.update_after_bind_descriptors_in_all_pools += total_descriptors;
|
||||
}
|
||||
|
||||
Ok(DescriptorSet {
|
||||
raw,
|
||||
bucket_key: key,
|
||||
pool_index,
|
||||
})
|
||||
}
|
||||
|
||||
pub unsafe fn free(&mut self, device: &ash::Device, set: DescriptorSet) {
|
||||
let bucket = self.buckets.get_mut(&set.bucket_key).unwrap();
|
||||
let pool = bucket.pools.get_mut(set.pool_index).unwrap();
|
||||
|
||||
let result =
|
||||
unsafe { device.free_descriptor_sets(pool.raw, core::slice::from_ref(&set.raw())) };
|
||||
if let Err(err) = result {
|
||||
// vkFreeDescriptorSets is documented to return:
|
||||
// - VK_ERROR_UNKNOWN
|
||||
// - VK_ERROR_VALIDATION_FAILED (we shouldn't encounter this one)
|
||||
// wgpu-hal doesn't currently report errors in destroy functions.
|
||||
// Panic here for now. It might be ok to ignore the error but the
|
||||
// proper solution would probably be to lose the device.
|
||||
panic!("vkFreeDescriptorSets error: {err}, please report this error");
|
||||
}
|
||||
|
||||
pool.available += 1;
|
||||
bucket.available_sets += 1;
|
||||
bucket.allocated_sets -= 1;
|
||||
if set.bucket_key.update_after_bind {
|
||||
self.update_after_bind_descriptors_in_all_pools -= set.bucket_key.counts.total();
|
||||
}
|
||||
|
||||
// Do not immediately destroy empty pools since they might have
|
||||
// been recently created.
|
||||
// Destroy a pool only if it's empty and we have 1/4th its capacity
|
||||
// in other pools.
|
||||
// Note that this logic will never destroy the last pool.
|
||||
let pool = bucket.pools.last().unwrap();
|
||||
if pool.available == pool.capacity
|
||||
&& bucket.available_sets - pool.capacity > pool.capacity / 4
|
||||
{
|
||||
let pool = bucket.pools.pop().unwrap();
|
||||
unsafe { device.destroy_descriptor_pool(pool.raw, None) };
|
||||
bucket.available_sets -= pool.capacity;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for DescriptorAllocator {
|
||||
fn drop(&mut self) {
|
||||
if !std::thread::panicking() {
|
||||
assert!(
|
||||
self.buckets.is_empty(),
|
||||
"buckets are not empty, at least one BGL has not been unregistered"
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn create_descriptor_pool(
|
||||
device: &ash::Device,
|
||||
key: &BucketKey,
|
||||
capacity_hint: u32,
|
||||
) -> Result<Pool, crate::DeviceError> {
|
||||
let counts = &key.counts;
|
||||
|
||||
const NR_OF_DESCRIPTOR_TYPES: usize = 8;
|
||||
|
||||
use vk::DescriptorType as Dt;
|
||||
let counts: [_; NR_OF_DESCRIPTOR_TYPES] = [
|
||||
(Dt::SAMPLER, counts.sampler),
|
||||
(Dt::SAMPLED_IMAGE, counts.sampled_image),
|
||||
(Dt::STORAGE_IMAGE, counts.storage_image),
|
||||
(Dt::UNIFORM_BUFFER, counts.uniform_buffer),
|
||||
(Dt::UNIFORM_BUFFER_DYNAMIC, counts.uniform_buffer_dynamic),
|
||||
(Dt::STORAGE_BUFFER, counts.storage_buffer),
|
||||
(Dt::STORAGE_BUFFER_DYNAMIC, counts.storage_buffer_dynamic),
|
||||
(
|
||||
Dt::ACCELERATION_STRUCTURE_KHR,
|
||||
counts.acceleration_structure,
|
||||
),
|
||||
];
|
||||
|
||||
// bounded doubling growth strategy
|
||||
let mut capacity = capacity_hint
|
||||
.clamp(POOL_MIN_SETS, POOL_MAX_SETS)
|
||||
.next_power_of_two();
|
||||
|
||||
// Lower capacity to avoid overflowing `count * capacity` calculations
|
||||
// below. The resulting `capacity` might not be a power of 2 but that's
|
||||
// ok.
|
||||
for (_, count) in counts {
|
||||
capacity = (u32::MAX / count.max(1)).min(capacity);
|
||||
}
|
||||
|
||||
let pool_sizes = counts
|
||||
.into_iter()
|
||||
.filter(|&(_, count)| count != 0)
|
||||
.map(|(ty, count)| vk::DescriptorPoolSize {
|
||||
ty,
|
||||
descriptor_count: count * capacity,
|
||||
})
|
||||
.collect::<ArrayVec<_, NR_OF_DESCRIPTOR_TYPES>>();
|
||||
|
||||
let mut flags = vk::DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET;
|
||||
if key.update_after_bind {
|
||||
flags |= vk::DescriptorPoolCreateFlags::UPDATE_AFTER_BIND;
|
||||
};
|
||||
|
||||
let vk_info = vk::DescriptorPoolCreateInfo::default()
|
||||
.flags(flags)
|
||||
.max_sets(capacity)
|
||||
.pool_sizes(&pool_sizes);
|
||||
|
||||
let raw = unsafe { device.create_descriptor_pool(&vk_info, None) }
|
||||
.map_err(super::map_host_device_oom_and_fragmentation_err)?;
|
||||
|
||||
Ok(Pool {
|
||||
raw,
|
||||
capacity,
|
||||
available: capacity,
|
||||
})
|
||||
}
|
||||
Vendored
+3116
File diff suppressed because it is too large.
Load diff
Vendored
+252
@@ -0,0 +1,252 @@
|
||||
#![cfg(drm)]
|
||||
|
||||
use alloc::{string::ToString, vec::Vec};
|
||||
use core::{mem::MaybeUninit, num::NonZeroU32};
|
||||
use std::os::fd::{AsFd, BorrowedFd};
|
||||
|
||||
use ash::{ext, khr, vk};
|
||||
|
||||
use drm::{
|
||||
self,
|
||||
control::{self, connector, Device as _},
|
||||
};
|
||||
|
||||
struct Card(i32);
|
||||
impl AsFd for Card {
|
||||
fn as_fd(&self) -> BorrowedFd<'_> {
|
||||
unsafe { BorrowedFd::borrow_raw(self.0) }
|
||||
}
|
||||
}
|
||||
impl control::Device for Card {}
|
||||
impl drm::Device for Card {}
|
||||
|
||||
macro_rules! to_u64 {
|
||||
($expr:expr) => {{
|
||||
#[allow(trivial_numeric_casts)]
|
||||
let expr = $expr as u64;
|
||||
assert!(size_of_val(&expr) <= size_of::<u64>());
|
||||
expr
|
||||
}};
|
||||
}
|
||||
|
||||
impl super::Instance {
|
||||
/// Creates a new surface from the given drm fd and plane, deriving the connector and mode.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// - All parameters must point to valid DRM values.
|
||||
pub fn create_surface_from_drm_plane(
|
||||
&self,
|
||||
fd: i32,
|
||||
plane: u32,
|
||||
) -> Result<super::Surface, crate::InstanceError> {
|
||||
let card = Card(fd);
|
||||
let plane_info = card
|
||||
.get_plane(
|
||||
NonZeroU32::new(plane)
|
||||
.ok_or(crate::InstanceError::new("Invalid drm plane".to_string()))?
|
||||
.into(),
|
||||
)
|
||||
.map_err(|e| crate::InstanceError::with_source("drm plane not found".to_string(), e))?;
|
||||
let crtc_handle = plane_info.crtc().ok_or(crate::InstanceError::new(
|
||||
"No CRTC for drm plane".to_string(),
|
||||
))?;
|
||||
let crtc_info = card
|
||||
.get_crtc(crtc_handle)
|
||||
.map_err(|e| crate::InstanceError::with_source("drm CRTC not found".to_string(), e))?;
|
||||
let mode = crtc_info.mode().ok_or(crate::InstanceError::new(
|
||||
"No mode for drm CRTC".to_string(),
|
||||
))?;
|
||||
|
||||
let mut connector_and_mode = None;
|
||||
let resources = card.resource_handles().map_err(|e| {
|
||||
crate::InstanceError::with_source("No drm resource handles found".to_string(), e)
|
||||
})?;
|
||||
for connector_handle in resources.connectors() {
|
||||
let Ok(connector_info) = card.get_connector(*connector_handle, false) else {
|
||||
continue;
|
||||
};
|
||||
if connector_info.state() != connector::State::Connected {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Some(encoder_handle) = connector_info.current_encoder() {
|
||||
if let Ok(encoder_info) = card.get_encoder(encoder_handle) {
|
||||
if encoder_info.crtc() == Some(crtc_handle) {
|
||||
connector_and_mode = Some((*connector_handle, mode));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let (connector_handle, mode) = connector_and_mode.ok_or(crate::InstanceError::new(
|
||||
"Failed to derive drm connector and mode for plane".to_string(),
|
||||
))?;
|
||||
let (width, height) = mode.size();
|
||||
// Rate in millihertz
|
||||
let refresh_rate = (((mode.clock() as f64 * 1000.0)
|
||||
/ (mode.hsync().2 as f64 * mode.vsync().2 as f64))
|
||||
* 1000.0)
|
||||
.round() as u32;
|
||||
unsafe {
|
||||
self.create_surface_from_drm(
|
||||
fd,
|
||||
plane,
|
||||
connector_handle.into(),
|
||||
width as u32,
|
||||
height as u32,
|
||||
refresh_rate,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new surface from the given drm configuration.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// - All parameters must point to valid DRM values.
|
||||
pub unsafe fn create_surface_from_drm(
|
||||
&self,
|
||||
fd: i32,
|
||||
plane: u32,
|
||||
connector_id: u32,
|
||||
width: u32,
|
||||
height: u32,
|
||||
refresh_rate: u32,
|
||||
) -> Result<super::Surface, crate::InstanceError> {
|
||||
if !self
|
||||
.shared
|
||||
.extensions
|
||||
.contains(&ext::acquire_drm_display::NAME)
|
||||
{
|
||||
return Err(crate::InstanceError::new(
|
||||
"Vulkan driver does not support VK_EXT_acquire_drm_display".to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
let drm_stat = {
|
||||
let mut stat = MaybeUninit::<libc::stat>::uninit();
|
||||
|
||||
if unsafe { libc::fstat(fd, stat.as_mut_ptr()) } != 0 {
|
||||
return Err(crate::InstanceError::new(
|
||||
"Unable to fstat drm device".to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
unsafe { stat.assume_init() }
|
||||
};
|
||||
|
||||
let raw_devices = match unsafe { self.shared.raw.enumerate_physical_devices() } {
|
||||
Ok(devices) => devices,
|
||||
Err(err) => {
|
||||
log::error!("enumerate_adapters: {err}");
|
||||
Vec::new()
|
||||
}
|
||||
};
|
||||
|
||||
let mut physical_device = None;
|
||||
|
||||
for device in raw_devices {
|
||||
let properties2 = vk::PhysicalDeviceProperties2KHR::default();
|
||||
|
||||
let mut drm_props = vk::PhysicalDeviceDrmPropertiesEXT::default();
|
||||
let mut properties2 = properties2.push_next(&mut drm_props);
|
||||
|
||||
unsafe {
|
||||
self.shared
|
||||
.raw
|
||||
.get_physical_device_properties2(device, &mut properties2)
|
||||
};
|
||||
|
||||
/*
|
||||
The makedev call is just bit manipulation to combine major and minor device numbers into a Unix device ID.
|
||||
It doesn't perform any filesystem operations, only bitshifting.
|
||||
See: https://github.com/rust-lang/libc/blob/268e1b3810ac07ed637d9005bc1a54e49218c958/src/unix/linux_like/linux/mod.rs#L6049
|
||||
We use the resulting device IDs to check if the Vulkan raw device from enumerate_physical_devices
|
||||
matches the DRM device referred to by our file descriptor.
|
||||
*/
|
||||
|
||||
let primary_devid =
|
||||
libc::makedev(drm_props.primary_major as _, drm_props.primary_minor as _);
|
||||
let render_devid =
|
||||
libc::makedev(drm_props.render_major as _, drm_props.render_minor as _);
|
||||
|
||||
// On most platforms, both `*_devid`s and `st_rdev` are `dev_t`s (which is generally
|
||||
// observed to be an unsigned integral type no greater than 64 bits). However, on some
|
||||
// platforms, there divergences from this pattern:
|
||||
//
|
||||
// - `armv7-linux-androideabi`: `dev_t` is `c_ulong`, and `*_devid`s are `dev_t`, but
|
||||
// `st_rdev` is `c_ulonglong`. So, we can't just do a `==` comparison.
|
||||
// - OpenBSD has `dev_t` on both sides, but is `i32` (N.B., unsigned). Therefore, we
|
||||
// can't just use `u64::from`.
|
||||
#[allow(clippy::useless_conversion)]
|
||||
if [primary_devid, render_devid]
|
||||
.map(|devid| to_u64!(devid))
|
||||
.contains(&to_u64!(drm_stat.st_rdev))
|
||||
{
|
||||
physical_device = Some(device)
|
||||
}
|
||||
}
|
||||
|
||||
let physical_device = physical_device.ok_or(crate::InstanceError::new(
|
||||
"Failed to find suitable drm device".to_string(),
|
||||
))?;
|
||||
|
||||
let acquire_drm_display_instance =
|
||||
ext::acquire_drm_display::Instance::new(&self.shared.entry, &self.shared.raw);
|
||||
|
||||
let display = unsafe {
|
||||
acquire_drm_display_instance
|
||||
.get_drm_display(physical_device, fd, connector_id)
|
||||
.expect("Failed to get drm display")
|
||||
};
|
||||
|
||||
unsafe {
|
||||
acquire_drm_display_instance
|
||||
.acquire_drm_display(physical_device, fd, display)
|
||||
.expect("Failed to acquire drm display")
|
||||
}
|
||||
|
||||
let display_instance = khr::display::Instance::new(&self.shared.entry, &self.shared.raw);
|
||||
|
||||
let modes = unsafe {
|
||||
display_instance
|
||||
.get_display_mode_properties(physical_device, display)
|
||||
.expect("Failed to get display modes")
|
||||
};
|
||||
|
||||
let mut mode = None;
|
||||
|
||||
for current_mode in modes {
|
||||
log::trace!(
|
||||
"Comparing mode {}x{}@{} with {width}x{height}@{refresh_rate}",
|
||||
current_mode.parameters.visible_region.width,
|
||||
current_mode.parameters.visible_region.height,
|
||||
current_mode.parameters.refresh_rate
|
||||
);
|
||||
if current_mode.parameters.refresh_rate == refresh_rate
|
||||
&& current_mode.parameters.visible_region.width == width
|
||||
&& current_mode.parameters.visible_region.height == height
|
||||
{
|
||||
mode = Some(current_mode)
|
||||
}
|
||||
}
|
||||
|
||||
let mode = mode.ok_or(crate::InstanceError::new(
|
||||
"Failed to find suitable display mode".to_string(),
|
||||
))?;
|
||||
|
||||
let create_info = vk::DisplaySurfaceCreateInfoKHR::default()
|
||||
.display_mode(mode.display_mode)
|
||||
.image_extent(mode.parameters.visible_region)
|
||||
.transform(vk::SurfaceTransformFlagsKHR::IDENTITY)
|
||||
.alpha_mode(vk::DisplayPlaneAlphaFlagsKHR::OPAQUE)
|
||||
.plane_index(plane);
|
||||
|
||||
let surface = unsafe { display_instance.create_display_plane_surface(&create_info, None) }
|
||||
.expect("Failed to create DRM surface");
|
||||
|
||||
Ok(self.create_surface_from_vk_surface_khr(surface, None))
|
||||
}
|
||||
}
|
||||
+1051
File diff suppressed because it is too large.
Load diff
Vendored
+1763
File diff suppressed because it is too large.
Load diff
+177
@@ -0,0 +1,177 @@
|
||||
//! Sampler cache for Vulkan backend.
|
||||
//!
|
||||
//! Nearly identical to the DX12 sampler cache, without descriptor heap management.
|
||||
|
||||
use ash::vk;
|
||||
use hashbrown::{hash_map::Entry, HashMap};
|
||||
use ordered_float::OrderedFloat;
|
||||
|
||||
/// If the allowed sampler count is above this value, the sampler cache is disabled.
|
||||
const ENABLE_SAMPLER_CACHE_CUTOFF: u32 = 1 << 20;
|
||||
|
||||
/// [`vk::SamplerCreateInfo`] is not hashable, so we wrap it in a newtype that is.
|
||||
///
|
||||
/// We use [`OrderedFloat`] to allow for floating point values to be compared and
|
||||
/// hashed in a defined way.
|
||||
#[derive(Copy, Clone)]
|
||||
struct HashableSamplerCreateInfo(vk::SamplerCreateInfo<'static>);
|
||||
|
||||
impl PartialEq for HashableSamplerCreateInfo {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.0.flags == other.0.flags
|
||||
&& self.0.mag_filter == other.0.mag_filter
|
||||
&& self.0.min_filter == other.0.min_filter
|
||||
&& self.0.mipmap_mode == other.0.mipmap_mode
|
||||
&& self.0.address_mode_u == other.0.address_mode_u
|
||||
&& self.0.address_mode_v == other.0.address_mode_v
|
||||
&& self.0.address_mode_w == other.0.address_mode_w
|
||||
&& OrderedFloat(self.0.mip_lod_bias) == OrderedFloat(other.0.mip_lod_bias)
|
||||
&& self.0.anisotropy_enable == other.0.anisotropy_enable
|
||||
&& OrderedFloat(self.0.max_anisotropy) == OrderedFloat(other.0.max_anisotropy)
|
||||
&& self.0.compare_enable == other.0.compare_enable
|
||||
&& self.0.compare_op == other.0.compare_op
|
||||
&& OrderedFloat(self.0.min_lod) == OrderedFloat(other.0.min_lod)
|
||||
&& OrderedFloat(self.0.max_lod) == OrderedFloat(other.0.max_lod)
|
||||
&& self.0.border_color == other.0.border_color
|
||||
&& self.0.unnormalized_coordinates == other.0.unnormalized_coordinates
|
||||
}
|
||||
}
|
||||
|
||||
impl Eq for HashableSamplerCreateInfo {}
|
||||
|
||||
impl core::hash::Hash for HashableSamplerCreateInfo {
|
||||
fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
|
||||
self.0.flags.hash(state);
|
||||
self.0.mag_filter.hash(state);
|
||||
self.0.min_filter.hash(state);
|
||||
self.0.mipmap_mode.hash(state);
|
||||
self.0.address_mode_u.hash(state);
|
||||
self.0.address_mode_v.hash(state);
|
||||
self.0.address_mode_w.hash(state);
|
||||
OrderedFloat(self.0.mip_lod_bias).hash(state);
|
||||
self.0.anisotropy_enable.hash(state);
|
||||
OrderedFloat(self.0.max_anisotropy).hash(state);
|
||||
self.0.compare_enable.hash(state);
|
||||
self.0.compare_op.hash(state);
|
||||
OrderedFloat(self.0.min_lod).hash(state);
|
||||
OrderedFloat(self.0.max_lod).hash(state);
|
||||
self.0.border_color.hash(state);
|
||||
self.0.unnormalized_coordinates.hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
/// Entry in the sampler cache.
|
||||
struct CacheEntry {
|
||||
sampler: vk::Sampler,
|
||||
ref_count: u32,
|
||||
}
|
||||
|
||||
/// Global sampler cache.
|
||||
///
|
||||
/// As some devices have a low limit (4000) on the number of unique samplers that can be created,
|
||||
/// we need to cache samplers to avoid running out if people eagerly create duplicate samplers.
|
||||
pub(crate) struct SamplerCache {
|
||||
/// Mapping from the sampler description to sampler and reference count.
|
||||
samplers: HashMap<HashableSamplerCreateInfo, CacheEntry>,
|
||||
/// Maximum number of unique samplers that can be created.
|
||||
total_capacity: u32,
|
||||
/// If true, the sampler cache is disabled and all samplers are created on demand.
|
||||
passthrough: bool,
|
||||
}
|
||||
|
||||
impl SamplerCache {
|
||||
pub fn new(total_capacity: u32) -> Self {
|
||||
let passthrough = total_capacity >= ENABLE_SAMPLER_CACHE_CUTOFF;
|
||||
Self {
|
||||
samplers: HashMap::new(),
|
||||
total_capacity,
|
||||
passthrough,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a sampler, or return an existing one if it already exists.
|
||||
///
|
||||
/// If the sampler already exists, the reference count is incremented.
|
||||
///
|
||||
/// If the sampler does not exist, a new sampler is created and inserted into the cache.
|
||||
///
|
||||
/// If the cache is full, an error is returned.
|
||||
pub fn create_sampler(
|
||||
&mut self,
|
||||
device: &ash::Device,
|
||||
create_info: vk::SamplerCreateInfo<'static>,
|
||||
) -> Result<vk::Sampler, crate::DeviceError> {
|
||||
if self.passthrough {
|
||||
return unsafe { device.create_sampler(&create_info, None) }
|
||||
.map_err(super::map_host_device_oom_and_ioca_err);
|
||||
};
|
||||
|
||||
// Get the number of used samplers. Needs to be done before to appease the borrow checker.
|
||||
let used_samplers = self.samplers.len();
|
||||
|
||||
match self.samplers.entry(HashableSamplerCreateInfo(create_info)) {
|
||||
Entry::Occupied(occupied_entry) => {
|
||||
// We have found a match, so increment the refcount and return the index.
|
||||
let value = occupied_entry.into_mut();
|
||||
value.ref_count += 1;
|
||||
Ok(value.sampler)
|
||||
}
|
||||
Entry::Vacant(vacant_entry) => {
|
||||
// We need to create a new sampler.
|
||||
|
||||
// We need to check if we can create more samplers.
|
||||
if used_samplers >= self.total_capacity as usize {
|
||||
log::error!("There is no more room in the global sampler heap for more unique samplers. Your device supports a maximum of {} unique samplers.", self.samplers.len());
|
||||
return Err(crate::DeviceError::OutOfMemory);
|
||||
}
|
||||
|
||||
// Create the sampler.
|
||||
let sampler = unsafe { device.create_sampler(&create_info, None) }
|
||||
.map_err(super::map_host_device_oom_and_ioca_err)?;
|
||||
|
||||
// Insert the new sampler into the mapping.
|
||||
vacant_entry.insert(CacheEntry {
|
||||
sampler,
|
||||
ref_count: 1,
|
||||
});
|
||||
|
||||
Ok(sampler)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Decrease the reference count of a sampler and destroy it if the reference count reaches 0.
|
||||
///
|
||||
/// The provided sampler is checked against the sampler in the cache to ensure there is no clerical error.
|
||||
pub fn destroy_sampler(
|
||||
&mut self,
|
||||
device: &ash::Device,
|
||||
create_info: vk::SamplerCreateInfo<'static>,
|
||||
provided_sampler: vk::Sampler,
|
||||
) {
|
||||
if self.passthrough {
|
||||
unsafe { device.destroy_sampler(provided_sampler, None) };
|
||||
return;
|
||||
};
|
||||
|
||||
let Entry::Occupied(mut hash_map_entry) =
|
||||
self.samplers.entry(HashableSamplerCreateInfo(create_info))
|
||||
else {
|
||||
log::error!("Trying to destroy a sampler that does not exist.");
|
||||
return;
|
||||
};
|
||||
let cache_entry = hash_map_entry.get_mut();
|
||||
|
||||
assert_eq!(
|
||||
cache_entry.sampler, provided_sampler,
|
||||
"Provided sampler does not match the sampler in the cache."
|
||||
);
|
||||
|
||||
cache_entry.ref_count -= 1;
|
||||
|
||||
if cache_entry.ref_count == 0 {
|
||||
unsafe { device.destroy_sampler(cache_entry.sampler, None) };
|
||||
hash_map_entry.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
+218
@@ -0,0 +1,218 @@
|
||||
//! Definition of the [`SemaphoreList`] type.
|
||||
|
||||
use alloc::vec::Vec;
|
||||
use ash::vk;
|
||||
use core::mem::MaybeUninit;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum SemaphoreListMode {
|
||||
Wait,
|
||||
Signal,
|
||||
}
|
||||
|
||||
/// A list of Vulkan semaphores to wait for or signal.
|
||||
///
|
||||
/// This represents a list of binary or timeline semaphores, together
|
||||
/// with values for the timeline semaphores, and stage masks, if these
|
||||
/// are used for waiting.
|
||||
///
|
||||
/// This type ensures that the array of semaphores to be signaled
|
||||
/// stays aligned with the array of values for timeline semaphores
|
||||
/// appearing in that list. The [`add_to_submit`] method prepares the
|
||||
/// `vkQueueSubmit` arguments appropriately for whatever semaphores we
|
||||
/// actually have.
|
||||
///
|
||||
/// [`add_to_submit`]: SemaphoreList::add_to_submit
|
||||
#[derive(Debug)]
|
||||
pub struct SemaphoreList {
|
||||
/// Mode of the semaphore list. Used for validation.
|
||||
mode: SemaphoreListMode,
|
||||
|
||||
/// Semaphores to use.
|
||||
///
|
||||
/// This can be a mix of binary and timeline semaphores.
|
||||
semaphores: Vec<vk::Semaphore>,
|
||||
|
||||
/// Values for the timeline semaphores.
|
||||
///
|
||||
/// If no timeline semaphores are present in [`semaphores`], this
|
||||
/// is empty. If any timeline semaphores are present, then this
|
||||
/// has the same length as [`semaphores`], with dummy !0 values
|
||||
/// in the elements corresponding to binary semaphores, since
|
||||
/// Vulkan ignores these.
|
||||
///
|
||||
/// [`semaphores`]: Self::semaphores
|
||||
values: Vec<u64>,
|
||||
|
||||
/// Stage masks for wait semaphores.
|
||||
///
|
||||
/// This is only used if `mode` is `Wait`.
|
||||
pub stage_masks: Vec<vk::PipelineStageFlags>,
|
||||
}
|
||||
|
||||
impl SemaphoreList {
|
||||
pub fn new(mode: SemaphoreListMode) -> Self {
|
||||
Self {
|
||||
mode,
|
||||
semaphores: Vec::new(),
|
||||
values: Vec::new(),
|
||||
stage_masks: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.semaphores.is_empty()
|
||||
}
|
||||
|
||||
/// Add this list to the semaphores to be signalled by a `vkQueueSubmit` call.
|
||||
///
|
||||
/// - Set `submit_info`'s `pSignalSemaphores` list to this list's
|
||||
/// semaphores.
|
||||
///
|
||||
/// - If this list contains any timeline semaphores, then initialize
|
||||
/// `timeline_info`, set its `pSignalSemaphoreValues` to this
|
||||
/// list's values, and add it to `submit_info`s extension chain.
|
||||
///
|
||||
/// Return the revised `submit_info` value.
|
||||
pub fn add_to_submit<'info, 'semaphores: 'info>(
|
||||
wait_semaphores: &'semaphores mut Self,
|
||||
signal_semaphores: &'semaphores mut Self,
|
||||
submit_info: vk::SubmitInfo<'info>,
|
||||
timeline_info: &'info mut MaybeUninit<vk::TimelineSemaphoreSubmitInfo<'info>>,
|
||||
) -> vk::SubmitInfo<'info> {
|
||||
wait_semaphores.check();
|
||||
signal_semaphores.check();
|
||||
|
||||
assert!(matches!(wait_semaphores.mode, SemaphoreListMode::Wait));
|
||||
assert!(matches!(signal_semaphores.mode, SemaphoreListMode::Signal));
|
||||
|
||||
let timeline_info = timeline_info.write(vk::TimelineSemaphoreSubmitInfo::default());
|
||||
|
||||
let mut uses_timeline = false;
|
||||
|
||||
if !wait_semaphores.values.is_empty() {
|
||||
*timeline_info = timeline_info.wait_semaphore_values(&wait_semaphores.values);
|
||||
uses_timeline = true;
|
||||
}
|
||||
|
||||
if !signal_semaphores.values.is_empty() {
|
||||
*timeline_info = timeline_info.signal_semaphore_values(&signal_semaphores.values);
|
||||
uses_timeline = true;
|
||||
}
|
||||
|
||||
let mut submit_info = submit_info
|
||||
.wait_semaphores(&wait_semaphores.semaphores)
|
||||
.wait_dst_stage_mask(&wait_semaphores.stage_masks)
|
||||
.signal_semaphores(&signal_semaphores.semaphores);
|
||||
|
||||
if uses_timeline {
|
||||
submit_info = submit_info.push_next(timeline_info);
|
||||
}
|
||||
|
||||
submit_info
|
||||
}
|
||||
|
||||
/// Add a semaphore to be signaled. Panics if this is a list of semaphores to wait.
|
||||
pub fn push_signal(&mut self, semaphore: SemaphoreType) {
|
||||
assert!(matches!(self.mode, SemaphoreListMode::Signal));
|
||||
self.push_inner(semaphore);
|
||||
}
|
||||
|
||||
/// Add a semaphore to be waited for. Panics if this is a list of semaphores to signal.
|
||||
pub fn push_wait(&mut self, semaphore: SemaphoreType, stage: vk::PipelineStageFlags) {
|
||||
assert!(matches!(self.mode, SemaphoreListMode::Wait));
|
||||
|
||||
self.stage_masks.push(stage);
|
||||
self.push_inner(semaphore);
|
||||
}
|
||||
|
||||
fn push_inner(&mut self, semaphore: SemaphoreType) {
|
||||
match semaphore {
|
||||
SemaphoreType::Binary(semaphore) => {
|
||||
self.semaphores.push(semaphore);
|
||||
// Push a dummy value if necessary.
|
||||
if !self.values.is_empty() {
|
||||
self.values.push(!0);
|
||||
}
|
||||
}
|
||||
SemaphoreType::Timeline(semaphore, value) => {
|
||||
// We may be the first timeline semaphore, ensure that the values
|
||||
// array is filled with dummy values for existing binary semaphores.
|
||||
self.pad_values();
|
||||
self.semaphores.push(semaphore);
|
||||
self.values.push(value);
|
||||
}
|
||||
}
|
||||
|
||||
self.check();
|
||||
}
|
||||
|
||||
/// Remove all entries matching `semaphore` from the list. Returns `true`
|
||||
/// if anything was removed.
|
||||
pub fn remove(&mut self, semaphore: vk::Semaphore) -> bool {
|
||||
let mut removed = false;
|
||||
let mut i = 0;
|
||||
while i < self.semaphores.len() {
|
||||
if self.semaphores[i] == semaphore {
|
||||
self.semaphores.swap_remove(i);
|
||||
if !self.values.is_empty() {
|
||||
self.values.swap_remove(i);
|
||||
}
|
||||
if !self.stage_masks.is_empty() {
|
||||
self.stage_masks.swap_remove(i);
|
||||
}
|
||||
removed = true;
|
||||
} else {
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
self.check();
|
||||
removed
|
||||
}
|
||||
|
||||
/// Append `other` to `self`, leaving `other` empty.
|
||||
pub fn append(&mut self, other: &mut Self) {
|
||||
assert_eq!(self.mode, other.mode);
|
||||
|
||||
// If we're about to receive values, ensure we're aligned first.
|
||||
if !other.values.is_empty() {
|
||||
self.pad_values();
|
||||
}
|
||||
self.semaphores.append(&mut other.semaphores);
|
||||
self.values.append(&mut other.values);
|
||||
// If we had values, but `other` did not, re-align.
|
||||
if !self.values.is_empty() {
|
||||
self.pad_values();
|
||||
}
|
||||
self.stage_masks.append(&mut other.stage_masks);
|
||||
self.check();
|
||||
}
|
||||
|
||||
/// Pad `self.values` with dummy values for binary semaphores,
|
||||
/// in preparation for adding a timeline semaphore value.
|
||||
///
|
||||
/// This is a no-op if we already have values.
|
||||
fn pad_values(&mut self) {
|
||||
self.values.resize(self.semaphores.len(), !0);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn check(&self) {
|
||||
debug_assert!(self.values.is_empty() || self.values.len() == self.semaphores.len());
|
||||
match self.mode {
|
||||
SemaphoreListMode::Wait => {
|
||||
debug_assert!(
|
||||
self.stage_masks.is_empty() || self.stage_masks.len() == self.semaphores.len()
|
||||
);
|
||||
}
|
||||
SemaphoreListMode::Signal => {
|
||||
debug_assert!(self.stage_masks.is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub enum SemaphoreType {
|
||||
Binary(vk::Semaphore),
|
||||
Timeline(vk::Semaphore, u64),
|
||||
}
|
||||
+119
@@ -0,0 +1,119 @@
|
||||
use alloc::boxed::Box;
|
||||
use core::{any::Any, fmt::Debug, time::Duration};
|
||||
|
||||
use crate::vulkan::{semaphore_list::SemaphoreType, DeviceShared};
|
||||
|
||||
pub(super) use native::*;
|
||||
|
||||
mod native;
|
||||
|
||||
/// Win32 `HWND`, handed to a Win32 [`NativeSurface`] at construction so it can
|
||||
/// build its [`DxgiHdrSource`](crate::auxil::dxgi::hdr::DxgiHdrSource) for the
|
||||
/// display-HDR query. Borrowed from the app's window.
|
||||
///
|
||||
/// A newtype rather than a bare `isize` so the cfg lives in one place: off Windows
|
||||
/// it is an uninhabited enum, so the non-Windows surface paths can't construct one
|
||||
/// and the constructor signatures stay cfg-free.
|
||||
#[cfg(windows)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub(crate) struct WindowHandle(pub(crate) windows::Win32::Foundation::HWND);
|
||||
|
||||
#[cfg(not(windows))]
|
||||
#[derive(Clone, Copy)]
|
||||
pub(crate) enum WindowHandle {}
|
||||
|
||||
pub(super) trait Surface: Send + Sync + 'static {
|
||||
/// Returns the surface capabilities for the given adapter.
|
||||
///
|
||||
/// Returns `None` if the surface is not compatible with the adapter.
|
||||
fn surface_capabilities(&self, adapter: &super::Adapter) -> Option<crate::SurfaceCapabilities>;
|
||||
|
||||
/// Creates a swapchain for the surface with the given configuration.
|
||||
///
|
||||
/// If this is not the first swapchain created for the surface, the old swapchain
|
||||
/// must be provided. [`Swapchain::release_resources`] must be called on the old swapchain
|
||||
/// before calling this method.
|
||||
unsafe fn create_swapchain(
|
||||
&self,
|
||||
device: &super::Device,
|
||||
config: &crate::SurfaceConfiguration,
|
||||
provided_old_swapchain: Option<Box<dyn Swapchain>>,
|
||||
) -> Result<Box<dyn Swapchain>, crate::SurfaceError>;
|
||||
|
||||
/// This surface's current display HDR info, if it can report it.
|
||||
///
|
||||
/// `Some` only for Win32 surfaces (read through DXGI); `None` otherwise
|
||||
/// (Wayland / X11 / Android / Metal), which is the default.
|
||||
fn display_hdr_info(&self) -> Option<wgt::DisplayHdrInfo> {
|
||||
None
|
||||
}
|
||||
|
||||
/// Allows downcasting to the concrete type.
|
||||
fn as_any(&self) -> &dyn Any;
|
||||
}
|
||||
|
||||
pub(super) trait Swapchain: Send + Sync + 'static {
|
||||
/// Releases all resources associated with the swapchain, without
|
||||
/// destroying the swapchain itself. Must be called before calling
|
||||
/// either [`Surface::create_swapchain`] or dropping the swapchain.
|
||||
///
|
||||
/// The swapchain must not be in use when this is called.
|
||||
unsafe fn release_resources(&mut self, device: &super::Device);
|
||||
|
||||
/// Acquires the next available surface texture for rendering.
|
||||
///
|
||||
/// `timeout` specifies the maximum time to wait for an image to become available.
|
||||
/// If `None` is specified, this function will wait indefinitely.
|
||||
///
|
||||
/// Returns `Err(SurfaceError::Timeout)` if the timeout elapsed before an image became available.
|
||||
unsafe fn acquire(
|
||||
&mut self,
|
||||
timeout: Option<Duration>,
|
||||
fence: &super::Fence,
|
||||
) -> Result<crate::AcquiredSurfaceTexture<crate::api::Vulkan>, crate::SurfaceError>;
|
||||
|
||||
/// Tries to discard the acquired texture without presenting it.
|
||||
///
|
||||
/// In practice, this doesn't really work in the current implementations.
|
||||
unsafe fn discard_texture(
|
||||
&mut self,
|
||||
texture: super::SurfaceTexture,
|
||||
) -> Result<(), crate::SurfaceError>;
|
||||
|
||||
/// Presents the given surface texture using the queue.
|
||||
unsafe fn present(
|
||||
&mut self,
|
||||
queue: &super::Queue,
|
||||
texture: crate::vulkan::SurfaceTexture,
|
||||
) -> Result<(), crate::SurfaceError>;
|
||||
|
||||
/// Allows downcasting to the concrete type.
|
||||
fn as_any(&self) -> &dyn Any;
|
||||
|
||||
/// Allows downcasting to the concrete type mutably.
|
||||
fn as_any_mut(&mut self) -> &mut dyn Any;
|
||||
}
|
||||
|
||||
/// Swapchain specific metadata associated with a surface texture.
|
||||
pub(super) trait SurfaceTextureMetadata: Debug + Send + Sync + 'static {
|
||||
/// Returns a guard which can yield the semaphores needed for submission using this swapchain texture.
|
||||
fn get_semaphore_guard(&self) -> Box<dyn SwapchainSubmissionSemaphoreGuard + '_>;
|
||||
|
||||
/// Allows downcasting to the concrete type.
|
||||
fn as_any(&self) -> &dyn Any;
|
||||
}
|
||||
|
||||
/// Guard type for managing swapchain submission semaphores.
|
||||
pub(super) trait SwapchainSubmissionSemaphoreGuard {
|
||||
/// Sets the Fence value for this submission.
|
||||
fn set_used_fence_value(&mut self, value: u64);
|
||||
|
||||
/// Gets semaphores to wait on before doing GPU work for this swapchain texture.
|
||||
fn get_acquire_wait_semaphore(&mut self) -> Option<SemaphoreType>;
|
||||
|
||||
/// Gets the semaphore to signal when GPU work for this swapchain texture is complete.
|
||||
fn get_submit_signal_semaphore(
|
||||
&mut self,
|
||||
device: &DeviceShared,
|
||||
) -> Result<SemaphoreType, crate::DeviceError>;
|
||||
}
|
||||
+937
@@ -0,0 +1,937 @@
|
||||
//! Vulkan Surface and Swapchain implementation using native Vulkan surfaces.
|
||||
|
||||
use alloc::{boxed::Box, sync::Arc, vec::Vec};
|
||||
use core::any::Any;
|
||||
|
||||
use ash::{khr, vk};
|
||||
use parking_lot::{Mutex, MutexGuard};
|
||||
|
||||
use crate::vulkan::{
|
||||
conv, map_host_device_oom_and_lost_err,
|
||||
semaphore_list::SemaphoreType,
|
||||
swapchain::{
|
||||
Surface, SurfaceTextureMetadata, Swapchain, SwapchainSubmissionSemaphoreGuard, WindowHandle,
|
||||
},
|
||||
DeviceShared, InstanceShared,
|
||||
};
|
||||
|
||||
pub(crate) struct NativeSurface {
|
||||
raw: vk::SurfaceKHR,
|
||||
functor: khr::surface::Instance,
|
||||
instance: Arc<InstanceShared>,
|
||||
/// Built from the window's `HWND` (Windows only) to answer the display-HDR
|
||||
/// query; `None` for non-Win32 surfaces.
|
||||
#[cfg(windows)]
|
||||
hdr_source: Option<crate::auxil::dxgi::hdr::DxgiHdrSource>,
|
||||
}
|
||||
|
||||
impl NativeSurface {
|
||||
pub fn from_vk_surface_khr(
|
||||
instance: &crate::vulkan::Instance,
|
||||
raw: vk::SurfaceKHR,
|
||||
hwnd: Option<WindowHandle>,
|
||||
) -> Self {
|
||||
#[cfg(not(windows))]
|
||||
let _ = hwnd;
|
||||
let functor = khr::surface::Instance::new(&instance.shared.entry, &instance.shared.raw);
|
||||
Self {
|
||||
raw,
|
||||
functor,
|
||||
instance: Arc::clone(&instance.shared),
|
||||
#[cfg(windows)]
|
||||
hdr_source: hwnd.map(|wh| crate::auxil::dxgi::hdr::DxgiHdrSource::new(wh.0)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn as_raw(&self) -> vk::SurfaceKHR {
|
||||
self.raw
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for NativeSurface {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.functor.destroy_surface(self.raw, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Surface for NativeSurface {
|
||||
fn surface_capabilities(
|
||||
&self,
|
||||
adapter: &crate::vulkan::Adapter,
|
||||
) -> Option<crate::SurfaceCapabilities> {
|
||||
if !adapter.private_caps.can_present {
|
||||
return None;
|
||||
}
|
||||
let queue_family_index = 0; //TODO
|
||||
{
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfaceSupportKHR");
|
||||
match unsafe {
|
||||
self.functor.get_physical_device_surface_support(
|
||||
adapter.raw,
|
||||
queue_family_index,
|
||||
self.raw,
|
||||
)
|
||||
} {
|
||||
Ok(true) => (),
|
||||
Ok(false) => return None,
|
||||
Err(e) => {
|
||||
log::error!("get_physical_device_surface_support: {e}");
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let caps = {
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
|
||||
match unsafe {
|
||||
self.functor
|
||||
.get_physical_device_surface_capabilities(adapter.raw, self.raw)
|
||||
} {
|
||||
Ok(caps) => caps,
|
||||
Err(e) => {
|
||||
log::error!("get_physical_device_surface_capabilities: {e}");
|
||||
return None;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// If image count is 0, the support number of images is unlimited.
|
||||
let max_image_count = if caps.max_image_count == 0 {
|
||||
!0
|
||||
} else {
|
||||
caps.max_image_count
|
||||
};
|
||||
|
||||
// `0xFFFFFFFF` indicates that the extent depends on the created swapchain.
|
||||
let current_extent = if caps.current_extent.width != !0 && caps.current_extent.height != !0
|
||||
{
|
||||
Some(wgt::Extent3d {
|
||||
width: caps.current_extent.width,
|
||||
height: caps.current_extent.height,
|
||||
depth_or_array_layers: 1,
|
||||
})
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let raw_present_modes = {
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfacePresentModesKHR");
|
||||
match unsafe {
|
||||
self.functor
|
||||
.get_physical_device_surface_present_modes(adapter.raw, self.raw)
|
||||
} {
|
||||
Ok(present_modes) => present_modes,
|
||||
Err(e) => {
|
||||
log::error!("get_physical_device_surface_present_modes: {e}");
|
||||
// Per definition of `SurfaceCapabilities`, there must be at least one present mode.
|
||||
return None;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let raw_surface_formats = {
|
||||
profiling::scope!("vkGetPhysicalDeviceSurfaceFormatsKHR");
|
||||
match unsafe {
|
||||
self.functor
|
||||
.get_physical_device_surface_formats(adapter.raw, self.raw)
|
||||
} {
|
||||
Ok(formats) => formats,
|
||||
Err(e) => {
|
||||
log::error!("get_physical_device_surface_formats: {e}");
|
||||
// Per definition of `SurfaceCapabilities`, there must be at least one present format.
|
||||
return None;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Group the driver's (format, color space) pairs into one entry per
|
||||
// format, preserving the driver's format order.
|
||||
let mut formats: Vec<wgt::SurfaceFormatCapabilities> = Vec::new();
|
||||
for (format, color_space) in raw_surface_formats
|
||||
.into_iter()
|
||||
.filter_map(conv::map_vk_surface_formats)
|
||||
{
|
||||
let color_spaces = color_space.to_color_spaces().unwrap();
|
||||
match formats.iter_mut().find(|fc| fc.format == format) {
|
||||
Some(fc) => fc.color_spaces |= color_spaces,
|
||||
None => formats.push(wgt::SurfaceFormatCapabilities {
|
||||
format,
|
||||
color_spaces,
|
||||
}),
|
||||
}
|
||||
}
|
||||
Some(crate::SurfaceCapabilities {
|
||||
formats,
|
||||
// TODO: Right now we're always truncating the swap chain
|
||||
// (presumably - we're actually setting the min image count which isn't necessarily the swap chain size)
|
||||
// Instead, we should use extensions when available to wait in present.
|
||||
// See https://github.com/gfx-rs/wgpu/issues/2869
|
||||
maximum_frame_latency: (caps.min_image_count - 1)..=(max_image_count - 1), // Note this can't underflow since both `min_image_count` is at least one and we already patched `max_image_count`.
|
||||
current_extent,
|
||||
usage: conv::map_vk_image_usage(caps.supported_usage_flags),
|
||||
present_modes: raw_present_modes
|
||||
.into_iter()
|
||||
.flat_map(conv::map_vk_present_mode)
|
||||
.collect(),
|
||||
composite_alpha_modes: conv::map_vk_composite_alpha(caps.supported_composite_alpha),
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn create_swapchain(
|
||||
&self,
|
||||
device: &crate::vulkan::Device,
|
||||
config: &crate::SurfaceConfiguration,
|
||||
provided_old_swapchain: Option<Box<dyn Swapchain>>,
|
||||
) -> Result<Box<dyn Swapchain>, crate::SurfaceError> {
|
||||
profiling::scope!("Device::create_swapchain");
|
||||
let functor = khr::swapchain::Device::new(&self.instance.raw, &device.shared.raw);
|
||||
|
||||
let old_swapchain = provided_old_swapchain
|
||||
.as_ref()
|
||||
.map(|osc| osc.as_any().downcast_ref::<NativeSwapchain>().unwrap().raw)
|
||||
.unwrap_or(vk::SwapchainKHR::null());
|
||||
|
||||
let color_space = conv::map_surface_color_space(config.color_space);
|
||||
|
||||
let original_format = device.shared.private_caps.map_texture_format(config.format);
|
||||
let mut raw_flags = vk::SwapchainCreateFlagsKHR::empty();
|
||||
let mut raw_view_formats: Vec<vk::Format> = vec![];
|
||||
if !config.view_formats.is_empty() {
|
||||
raw_flags |= vk::SwapchainCreateFlagsKHR::MUTABLE_FORMAT;
|
||||
raw_view_formats = config
|
||||
.view_formats
|
||||
.iter()
|
||||
.map(|f| device.shared.private_caps.map_texture_format(*f))
|
||||
.collect();
|
||||
raw_view_formats.push(original_format);
|
||||
}
|
||||
|
||||
let mut info = vk::SwapchainCreateInfoKHR::default()
|
||||
.flags(raw_flags)
|
||||
.surface(self.raw)
|
||||
.min_image_count(config.maximum_frame_latency + 1) // TODO: https://github.com/gfx-rs/wgpu/issues/2869
|
||||
.image_format(original_format)
|
||||
.image_color_space(color_space)
|
||||
.image_extent(vk::Extent2D {
|
||||
width: config.extent.width,
|
||||
height: config.extent.height,
|
||||
})
|
||||
.image_array_layers(config.extent.depth_or_array_layers)
|
||||
.image_usage(conv::map_texture_usage(config.usage))
|
||||
.image_sharing_mode(vk::SharingMode::EXCLUSIVE)
|
||||
.pre_transform(vk::SurfaceTransformFlagsKHR::IDENTITY)
|
||||
.composite_alpha(conv::map_composite_alpha_mode(config.composite_alpha_mode))
|
||||
.present_mode(conv::map_present_mode(config.present_mode))
|
||||
.clipped(true)
|
||||
.old_swapchain(old_swapchain);
|
||||
|
||||
let mut format_list_info = vk::ImageFormatListCreateInfo::default();
|
||||
if !raw_view_formats.is_empty() {
|
||||
format_list_info = format_list_info.view_formats(&raw_view_formats);
|
||||
info = info.push_next(&mut format_list_info);
|
||||
}
|
||||
|
||||
let result = {
|
||||
profiling::scope!("vkCreateSwapchainKHR");
|
||||
unsafe { functor.create_swapchain(&info, None) }
|
||||
};
|
||||
|
||||
let raw = match result {
|
||||
Ok(swapchain) => swapchain,
|
||||
Err(error) => {
|
||||
return Err(match error {
|
||||
vk::Result::ERROR_SURFACE_LOST_KHR
|
||||
| vk::Result::ERROR_INITIALIZATION_FAILED => crate::SurfaceError::Lost,
|
||||
vk::Result::ERROR_NATIVE_WINDOW_IN_USE_KHR => {
|
||||
crate::SurfaceError::Other("Native window is in use")
|
||||
}
|
||||
// We don't use VK_EXT_image_compression_control
|
||||
// VK_ERROR_COMPRESSION_EXHAUSTED_EXT
|
||||
other => map_host_device_oom_and_lost_err(other).into(),
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
let images = unsafe { functor.get_swapchain_images(raw) }
|
||||
.map_err(crate::vulkan::map_host_device_oom_err)?;
|
||||
|
||||
// This fence is only used to throttle acquisition on Windows. It is very important to
|
||||
// avoid bad frame pacing when the Vulkan driver is using a DXGI swapchain. See
|
||||
// https://github.com/gfx-rs/wgpu/issues/8310 and
|
||||
// https://github.com/gfx-rs/wgpu/issues/8354 for more details.
|
||||
let fence = if cfg!(target_os = "windows") {
|
||||
let raw = unsafe {
|
||||
device
|
||||
.shared
|
||||
.raw
|
||||
.create_fence(&vk::FenceCreateInfo::default(), None)
|
||||
.map_err(crate::vulkan::map_host_device_oom_err)?
|
||||
};
|
||||
Some(raw)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
// NOTE: It's important that we define the same number of acquire/present semaphores
|
||||
// as we will need to index into them with the image index.
|
||||
let acquire_semaphores = (0..images.len())
|
||||
.map(|i| {
|
||||
SwapchainAcquireSemaphore::new(&device.shared, i)
|
||||
.map(Mutex::new)
|
||||
.map(Arc::new)
|
||||
})
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
|
||||
let present_semaphores = (0..images.len())
|
||||
.map(|i| Arc::new(Mutex::new(SwapchainPresentSemaphores::new(i))))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
Ok(Box::new(NativeSwapchain {
|
||||
raw,
|
||||
functor,
|
||||
device: Arc::clone(&device.shared),
|
||||
images,
|
||||
fence,
|
||||
config: config.clone(),
|
||||
acquire_semaphores,
|
||||
next_acquire_index: 0,
|
||||
present_semaphores,
|
||||
next_present_time: None,
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn display_hdr_info(&self) -> Option<wgt::DisplayHdrInfo> {
|
||||
self.hdr_source.as_ref()?.display_hdr_info()
|
||||
}
|
||||
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct NativeSwapchain {
|
||||
raw: vk::SwapchainKHR,
|
||||
functor: khr::swapchain::Device,
|
||||
device: Arc<DeviceShared>,
|
||||
images: Vec<vk::Image>,
|
||||
/// Fence used to wait on the acquired image.
|
||||
fence: Option<vk::Fence>,
|
||||
config: crate::SurfaceConfiguration,
|
||||
|
||||
/// Semaphores used between image acquisition and the first submission
|
||||
/// that uses that image. This is indexed using [`next_acquire_index`].
|
||||
///
|
||||
/// Because we need to provide this to [`vkAcquireNextImageKHR`], we haven't
|
||||
/// received the swapchain image index for the frame yet, so we cannot use
|
||||
/// that to index it.
|
||||
///
|
||||
/// Before we pass this to [`vkAcquireNextImageKHR`], we ensure that we wait on
|
||||
/// the submission indicated by [`previously_used_submission_index`]. This ensures
|
||||
/// the semaphore is no longer in use before we use it.
|
||||
///
|
||||
/// [`next_acquire_index`]: NativeSwapchain::next_acquire_index
|
||||
/// [`vkAcquireNextImageKHR`]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#vkAcquireNextImageKHR
|
||||
/// [`previously_used_submission_index`]: SwapchainAcquireSemaphore::previously_used_submission_index
|
||||
acquire_semaphores: Vec<Arc<Mutex<SwapchainAcquireSemaphore>>>,
|
||||
/// The index of the next acquire semaphore to use.
|
||||
///
|
||||
/// This is incremented each time we acquire a new image, and wraps around
|
||||
/// to 0 when it reaches the end of [`acquire_semaphores`].
|
||||
///
|
||||
/// [`acquire_semaphores`]: NativeSwapchain::acquire_semaphores
|
||||
next_acquire_index: usize,
|
||||
|
||||
/// Semaphore sets used between all submissions that write to an image and
|
||||
/// the presentation of that image.
|
||||
///
|
||||
/// This is indexed by the swapchain image index returned by
|
||||
/// [`vkAcquireNextImageKHR`].
|
||||
///
|
||||
/// We know it is safe to use these semaphores because use them
|
||||
/// _after_ the acquire semaphore. Because the acquire semaphore
|
||||
/// has been signaled, the previous presentation using that image
|
||||
/// is known-finished, so this semaphore is no longer in use.
|
||||
///
|
||||
/// [`vkAcquireNextImageKHR`]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#vkAcquireNextImageKHR
|
||||
present_semaphores: Vec<Arc<Mutex<SwapchainPresentSemaphores>>>,
|
||||
|
||||
/// The present timing information which will be set in the next call to [`present()`](crate::Queue::present()).
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// This must only be set if [`wgt::Features::VULKAN_GOOGLE_DISPLAY_TIMING`] is enabled, and
|
||||
/// so the VK_GOOGLE_display_timing extension is present.
|
||||
next_present_time: Option<vk::PresentTimeGOOGLE>,
|
||||
}
|
||||
|
||||
impl Drop for NativeSwapchain {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
self.functor.destroy_swapchain(self.raw, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Swapchain for NativeSwapchain {
|
||||
unsafe fn release_resources(&mut self, device: &crate::vulkan::Device) {
|
||||
profiling::scope!("Swapchain::release_resources");
|
||||
{
|
||||
profiling::scope!("vkDeviceWaitIdle");
|
||||
// We need to also wait until all presentation work is done. Because there is no way to portably wait until
|
||||
// the presentation work is done, we are forced to wait until the device is idle.
|
||||
let _ = unsafe {
|
||||
device
|
||||
.shared
|
||||
.raw
|
||||
.device_wait_idle()
|
||||
.map_err(map_host_device_oom_and_lost_err)
|
||||
};
|
||||
};
|
||||
|
||||
if let Some(fence) = self.fence {
|
||||
unsafe { device.shared.raw.destroy_fence(fence, None) }
|
||||
}
|
||||
|
||||
// We cannot take this by value, as the function returns `self`.
|
||||
for semaphore in self.acquire_semaphores.drain(..) {
|
||||
let arc_removed = Arc::into_inner(semaphore).expect(
|
||||
"Trying to destroy a SwapchainAcquireSemaphore that is still in use by a SurfaceTexture",
|
||||
);
|
||||
let mutex_removed = arc_removed.into_inner();
|
||||
|
||||
unsafe { mutex_removed.destroy(&device.shared.raw) };
|
||||
}
|
||||
|
||||
for semaphore in self.present_semaphores.drain(..) {
|
||||
let arc_removed = Arc::into_inner(semaphore).expect(
|
||||
"Trying to destroy a SwapchainPresentSemaphores that is still in use by a SurfaceTexture",
|
||||
);
|
||||
let mutex_removed = arc_removed.into_inner();
|
||||
|
||||
unsafe { mutex_removed.destroy(&device.shared.raw) };
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn acquire(
|
||||
&mut self,
|
||||
timeout: Option<core::time::Duration>,
|
||||
fence: &crate::vulkan::Fence,
|
||||
) -> Result<crate::AcquiredSurfaceTexture<crate::api::Vulkan>, crate::SurfaceError> {
|
||||
let mut timeout_ns = match timeout {
|
||||
Some(duration) => duration.as_nanos() as u64,
|
||||
None => u64::MAX,
|
||||
};
|
||||
|
||||
// AcquireNextImageKHR on Android (prior to Android 11) doesn't support timeouts
|
||||
// and will also log verbose warnings if tying to use a timeout.
|
||||
//
|
||||
// Android 10 implementation for reference:
|
||||
// https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-mainline-10.0.0_r13/vulkan/libvulkan/swapchain.cpp#1426
|
||||
// Android 11 implementation for reference:
|
||||
// https://android.googlesource.com/platform/frameworks/native/+/refs/tags/android-mainline-11.0.0_r45/vulkan/libvulkan/swapchain.cpp#1438
|
||||
//
|
||||
// Android 11 corresponds to an SDK_INT/ro.build.version.sdk of 30
|
||||
if cfg!(target_os = "android") && self.device.instance.android_sdk_version < 30 {
|
||||
timeout_ns = u64::MAX;
|
||||
}
|
||||
|
||||
let acquire_semaphore_arc = self.get_acquire_semaphore();
|
||||
// Nothing should be using this, so we don't block, but panic if we fail to lock.
|
||||
let acquire_semaphore_guard = acquire_semaphore_arc
|
||||
.try_lock()
|
||||
.expect("Failed to lock a SwapchainSemaphores.");
|
||||
|
||||
// Wait for all commands writing to the previously acquired image to
|
||||
// complete.
|
||||
//
|
||||
// Almost all the steps in the usual acquire-draw-present flow are
|
||||
// asynchronous: they get something started on the presentation engine
|
||||
// or the GPU, but on the CPU, control returns immediately. Without some
|
||||
// sort of intervention, the CPU could crank out frames much faster than
|
||||
// the presentation engine can display them.
|
||||
//
|
||||
// This is the intervention: if any submissions drew on this image, and
|
||||
// thus waited for `locked_swapchain_semaphores.acquire`, wait for all
|
||||
// of them to finish, thus ensuring that it's okay to pass `acquire` to
|
||||
// `vkAcquireNextImageKHR` again.
|
||||
let completed = self.device.wait_for_fence(
|
||||
fence,
|
||||
acquire_semaphore_guard.previously_used_submission_index,
|
||||
timeout_ns,
|
||||
)?;
|
||||
if !completed {
|
||||
return Err(crate::SurfaceError::Timeout);
|
||||
}
|
||||
|
||||
let acquire_fence = self.fence.unwrap_or_else(vk::Fence::null);
|
||||
|
||||
// will block if no image is available
|
||||
let (index, suboptimal) = match unsafe {
|
||||
profiling::scope!("vkAcquireNextImageKHR");
|
||||
self.functor.acquire_next_image(
|
||||
self.raw,
|
||||
timeout_ns,
|
||||
acquire_semaphore_guard.acquire,
|
||||
acquire_fence,
|
||||
)
|
||||
} {
|
||||
// We treat `VK_SUBOPTIMAL_KHR` as `VK_SUCCESS` on Android.
|
||||
// See the comment in `Queue::present`.
|
||||
#[cfg(target_os = "android")]
|
||||
Ok((index, _)) => (index, false),
|
||||
#[cfg(not(target_os = "android"))]
|
||||
Ok(pair) => pair,
|
||||
Err(error) => {
|
||||
return match error {
|
||||
vk::Result::TIMEOUT => Err(crate::SurfaceError::Timeout),
|
||||
vk::Result::NOT_READY | vk::Result::ERROR_OUT_OF_DATE_KHR => {
|
||||
Err(crate::SurfaceError::Outdated)
|
||||
}
|
||||
vk::Result::ERROR_SURFACE_LOST_KHR => Err(crate::SurfaceError::Lost),
|
||||
// We don't use VK_EXT_full_screen_exclusive
|
||||
// VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT
|
||||
other => Err(map_host_device_oom_and_lost_err(other).into()),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
if let Some(fence) = self.fence {
|
||||
unsafe {
|
||||
// The `wait_all` argument must be `true` to avoid crash on some Android devices. See https://github.com/gfx-rs/wgpu/pull/8769
|
||||
self.device
|
||||
.raw
|
||||
.wait_for_fences(&[fence], true, timeout_ns)
|
||||
.map_err(map_host_device_oom_and_lost_err)?;
|
||||
|
||||
self.device
|
||||
.raw
|
||||
.reset_fences(&[fence])
|
||||
.map_err(map_host_device_oom_and_lost_err)?;
|
||||
}
|
||||
}
|
||||
|
||||
drop(acquire_semaphore_guard);
|
||||
// We only advance the surface semaphores if we successfully acquired an image, otherwise
|
||||
// we should try to re-acquire using the same semaphores.
|
||||
self.advance_acquire_semaphore();
|
||||
|
||||
let present_semaphore_arc = self.get_present_semaphores(index);
|
||||
|
||||
// special case for Intel Vulkan returning bizarre values (ugh)
|
||||
if self.device.vendor_id == crate::auxil::db::intel::VENDOR && index > 0x100 {
|
||||
return Err(crate::SurfaceError::Outdated);
|
||||
}
|
||||
|
||||
let identity = self.device.texture_identity_factory.next();
|
||||
|
||||
let texture = crate::vulkan::SurfaceTexture {
|
||||
index,
|
||||
texture: crate::vulkan::Texture {
|
||||
raw: self.images[index as usize],
|
||||
drop_guard: None,
|
||||
memory: crate::vulkan::TextureMemory::External,
|
||||
format: self.config.format,
|
||||
copy_size: crate::CopyExtent {
|
||||
width: self.config.extent.width,
|
||||
height: self.config.extent.height,
|
||||
depth: 1,
|
||||
},
|
||||
identity,
|
||||
},
|
||||
metadata: Box::new(NativeSurfaceTextureMetadata {
|
||||
acquire_semaphores: acquire_semaphore_arc,
|
||||
present_semaphores: present_semaphore_arc,
|
||||
}),
|
||||
};
|
||||
Ok(crate::AcquiredSurfaceTexture {
|
||||
texture,
|
||||
suboptimal,
|
||||
})
|
||||
}
|
||||
|
||||
unsafe fn discard_texture(
|
||||
&mut self,
|
||||
_texture: crate::vulkan::SurfaceTexture,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
// TODO: Current implementation no-ops
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe fn present(
|
||||
&mut self,
|
||||
queue: &crate::vulkan::Queue,
|
||||
texture: crate::vulkan::SurfaceTexture,
|
||||
) -> Result<(), crate::SurfaceError> {
|
||||
let metadata = texture
|
||||
.metadata
|
||||
.as_any()
|
||||
.downcast_ref::<NativeSurfaceTextureMetadata>()
|
||||
.unwrap();
|
||||
let mut acquire_semaphore = metadata.acquire_semaphores.lock();
|
||||
let mut present_semaphores = metadata.present_semaphores.lock();
|
||||
|
||||
let wait_semaphores = present_semaphores.get_present_wait_semaphores();
|
||||
|
||||
// Reset the acquire and present semaphores internal state
|
||||
// to be ready for the next frame.
|
||||
//
|
||||
// We do this before the actual call to present to ensure that
|
||||
// even if this method errors and early outs, we have reset
|
||||
// the state for next frame.
|
||||
acquire_semaphore.end_semaphore_usage();
|
||||
present_semaphores.end_semaphore_usage();
|
||||
|
||||
drop(acquire_semaphore);
|
||||
|
||||
let swapchains = [self.raw];
|
||||
let image_indices = [texture.index];
|
||||
let vk_info = vk::PresentInfoKHR::default()
|
||||
.swapchains(&swapchains)
|
||||
.image_indices(&image_indices)
|
||||
.wait_semaphores(&wait_semaphores);
|
||||
|
||||
let mut display_timing;
|
||||
let present_times;
|
||||
let vk_info = if let Some(present_time) = self.next_present_time.take() {
|
||||
debug_assert!(
|
||||
self.device
|
||||
.features
|
||||
.contains(wgt::Features::VULKAN_GOOGLE_DISPLAY_TIMING),
|
||||
"`next_present_time` should only be set if `VULKAN_GOOGLE_DISPLAY_TIMING` is enabled"
|
||||
);
|
||||
present_times = [present_time];
|
||||
display_timing = vk::PresentTimesInfoGOOGLE::default().times(&present_times);
|
||||
// SAFETY: We know that VK_GOOGLE_display_timing is present because of the safety contract on `next_present_time`.
|
||||
vk_info.push_next(&mut display_timing)
|
||||
} else {
|
||||
vk_info
|
||||
};
|
||||
|
||||
let suboptimal = {
|
||||
profiling::scope!("vkQueuePresentKHR");
|
||||
unsafe { self.functor.queue_present(queue.raw, &vk_info) }.map_err(|error| {
|
||||
match error {
|
||||
vk::Result::ERROR_OUT_OF_DATE_KHR => crate::SurfaceError::Outdated,
|
||||
vk::Result::ERROR_SURFACE_LOST_KHR => crate::SurfaceError::Lost,
|
||||
// We don't use VK_EXT_full_screen_exclusive
|
||||
// VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT
|
||||
_ => map_host_device_oom_and_lost_err(error).into(),
|
||||
}
|
||||
})?
|
||||
};
|
||||
if suboptimal {
|
||||
// We treat `VK_SUBOPTIMAL_KHR` as `VK_SUCCESS` on Android.
|
||||
// On Android 10+, libvulkan's `vkQueuePresentKHR` implementation returns `VK_SUBOPTIMAL_KHR` if not doing pre-rotation
|
||||
// (i.e `VkSwapchainCreateInfoKHR::preTransform` not being equal to the current device orientation).
|
||||
// This is always the case when the device orientation is anything other than the identity one, as we unconditionally use `VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR`.
|
||||
#[cfg(not(target_os = "android"))]
|
||||
log::debug!("Suboptimal present of frame {}", texture.index);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn as_any_mut(&mut self) -> &mut dyn Any {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl NativeSwapchain {
|
||||
pub(crate) fn as_raw(&self) -> vk::SwapchainKHR {
|
||||
self.raw
|
||||
}
|
||||
|
||||
pub fn set_next_present_time(&mut self, present_timing: vk::PresentTimeGOOGLE) {
|
||||
let features = wgt::Features::VULKAN_GOOGLE_DISPLAY_TIMING;
|
||||
if self.device.features.contains(features) {
|
||||
self.next_present_time = Some(present_timing);
|
||||
} else {
|
||||
// Ideally we'd use something like `device.required_features` here, but that's in `wgpu-core`, which we are a dependency of
|
||||
panic!(
|
||||
concat!(
|
||||
"Tried to set display timing properties ",
|
||||
"without the corresponding feature ({:?}) enabled."
|
||||
),
|
||||
features
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Mark the current frame finished, advancing to the next acquire semaphore.
|
||||
fn advance_acquire_semaphore(&mut self) {
|
||||
let semaphore_count = self.acquire_semaphores.len();
|
||||
self.next_acquire_index = (self.next_acquire_index + 1) % semaphore_count;
|
||||
}
|
||||
|
||||
/// Get the next acquire semaphore that should be used with this swapchain.
|
||||
fn get_acquire_semaphore(&self) -> Arc<Mutex<SwapchainAcquireSemaphore>> {
|
||||
self.acquire_semaphores[self.next_acquire_index].clone()
|
||||
}
|
||||
|
||||
/// Get the set of present semaphores that should be used with the given image index.
|
||||
fn get_present_semaphores(&self, index: u32) -> Arc<Mutex<SwapchainPresentSemaphores>> {
|
||||
self.present_semaphores[index as usize].clone()
|
||||
}
|
||||
}
|
||||
|
||||
/// Semaphore used to acquire a swapchain image.
|
||||
#[derive(Debug)]
|
||||
struct SwapchainAcquireSemaphore {
|
||||
/// A semaphore that is signaled when this image is safe for us to modify.
|
||||
///
|
||||
/// When [`vkAcquireNextImageKHR`] returns the index of the next swapchain
|
||||
/// image that we should use, that image may actually still be in use by the
|
||||
/// presentation engine, and is not yet safe to modify. However, that
|
||||
/// function does accept a semaphore that it will signal when the image is
|
||||
/// indeed safe to begin messing with.
|
||||
///
|
||||
/// This semaphore is:
|
||||
///
|
||||
/// - waited for by the first queue submission to operate on this image
|
||||
/// since it was acquired, and
|
||||
///
|
||||
/// - signaled by [`vkAcquireNextImageKHR`] when the acquired image is ready
|
||||
/// for us to use.
|
||||
///
|
||||
/// [`vkAcquireNextImageKHR`]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#vkAcquireNextImageKHR
|
||||
acquire: vk::Semaphore,
|
||||
|
||||
/// True if the next command submission operating on this image should wait
|
||||
/// for [`acquire`].
|
||||
///
|
||||
/// We must wait for `acquire` before drawing to this swapchain image, but
|
||||
/// because `wgpu-hal` queue submissions are always strongly ordered, only
|
||||
/// the first submission that works with a swapchain image actually needs to
|
||||
/// wait. We set this flag when this image is acquired, and clear it the
|
||||
/// first time it's passed to [`Queue::submit`] as a surface texture.
|
||||
///
|
||||
/// Additionally, semaphores can only be waited on once, so we need to ensure
|
||||
/// that we only actually pass this semaphore to the first submission that
|
||||
/// uses that image.
|
||||
///
|
||||
/// [`acquire`]: SwapchainAcquireSemaphore::acquire
|
||||
/// [`Queue::submit`]: crate::Queue::submit
|
||||
should_wait_for_acquire: bool,
|
||||
|
||||
/// The fence value of the last command submission that wrote to this image.
|
||||
///
|
||||
/// The next time we try to acquire this image, we'll block until
|
||||
/// this submission finishes, proving that [`acquire`] is ready to
|
||||
/// pass to `vkAcquireNextImageKHR` again.
|
||||
///
|
||||
/// [`acquire`]: SwapchainAcquireSemaphore::acquire
|
||||
previously_used_submission_index: crate::FenceValue,
|
||||
}
|
||||
|
||||
impl SwapchainAcquireSemaphore {
|
||||
fn new(device: &DeviceShared, index: usize) -> Result<Self, crate::DeviceError> {
|
||||
Ok(Self {
|
||||
acquire: device
|
||||
.new_binary_semaphore(&format!("SwapchainImageSemaphore: Index {index} acquire"))?,
|
||||
should_wait_for_acquire: true,
|
||||
previously_used_submission_index: 0,
|
||||
})
|
||||
}
|
||||
|
||||
/// Sets the fence value which the next acquire will wait for. This prevents
|
||||
/// the semaphore from being used while the previous submission is still in flight.
|
||||
fn set_used_fence_value(&mut self, value: crate::FenceValue) {
|
||||
self.previously_used_submission_index = value;
|
||||
}
|
||||
|
||||
/// Return the semaphore that commands drawing to this image should wait for, if any.
|
||||
///
|
||||
/// This only returns `Some` once per acquisition; see
|
||||
/// [`SwapchainAcquireSemaphore::should_wait_for_acquire`] for details.
|
||||
fn get_acquire_wait_semaphore(&mut self) -> Option<vk::Semaphore> {
|
||||
if self.should_wait_for_acquire {
|
||||
self.should_wait_for_acquire = false;
|
||||
Some(self.acquire)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Indicates the cpu-side usage of this semaphore has finished for the frame,
|
||||
/// so reset internal state to be ready for the next frame.
|
||||
fn end_semaphore_usage(&mut self) {
|
||||
// Reset the acquire semaphore, so that the next time we acquire this
|
||||
// image, we can wait for it again.
|
||||
self.should_wait_for_acquire = true;
|
||||
}
|
||||
|
||||
unsafe fn destroy(&self, device: &ash::Device) {
|
||||
unsafe {
|
||||
device.destroy_semaphore(self.acquire, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct SwapchainPresentSemaphores {
|
||||
/// A pool of semaphores for ordering presentation after drawing.
|
||||
///
|
||||
/// The first [`present_index`] semaphores in this vector are:
|
||||
///
|
||||
/// - all waited on by the call to [`vkQueuePresentKHR`] that presents this
|
||||
/// image, and
|
||||
///
|
||||
/// - each signaled by some [`vkQueueSubmit`] queue submission that draws to
|
||||
/// this image, when the submission finishes execution.
|
||||
///
|
||||
/// This vector accumulates one semaphore per submission that writes to this
|
||||
/// image. This is awkward, but hard to avoid: [`vkQueuePresentKHR`]
|
||||
/// requires a semaphore to order it with respect to drawing commands, and
|
||||
/// we can't attach new completion semaphores to a command submission after
|
||||
/// it's been submitted. This means that, at submission time, we must create
|
||||
/// the semaphore we might need if the caller's next action is to enqueue a
|
||||
/// presentation of this image.
|
||||
///
|
||||
/// An alternative strategy would be for presentation to enqueue an empty
|
||||
/// submit, ordered relative to other submits in the usual way, and
|
||||
/// signaling a single presentation semaphore. But we suspect that submits
|
||||
/// are usually expensive enough, and semaphores usually cheap enough, that
|
||||
/// performance-sensitive users will avoid making many submits, so that the
|
||||
/// cost of accumulated semaphores will usually be less than the cost of an
|
||||
/// additional submit.
|
||||
///
|
||||
/// Only the first [`present_index`] semaphores in the vector are actually
|
||||
/// going to be signalled by submitted commands, and need to be waited for
|
||||
/// by the next present call. Any semaphores beyond that index were created
|
||||
/// for prior presents and are simply being retained for recycling.
|
||||
///
|
||||
/// [`present_index`]: SwapchainPresentSemaphores::present_index
|
||||
/// [`vkQueuePresentKHR`]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#vkQueuePresentKHR
|
||||
/// [`vkQueueSubmit`]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#vkQueueSubmit
|
||||
present: Vec<vk::Semaphore>,
|
||||
|
||||
/// The number of semaphores in [`present`] to be signalled for this submission.
|
||||
///
|
||||
/// [`present`]: SwapchainPresentSemaphores::present
|
||||
present_index: usize,
|
||||
|
||||
/// Which image this semaphore set is used for.
|
||||
frame_index: usize,
|
||||
}
|
||||
|
||||
impl SwapchainPresentSemaphores {
|
||||
pub fn new(frame_index: usize) -> Self {
|
||||
Self {
|
||||
present: Vec::new(),
|
||||
present_index: 0,
|
||||
frame_index,
|
||||
}
|
||||
}
|
||||
|
||||
/// Return the semaphore that the next submission that writes to this image should
|
||||
/// signal when it's done.
|
||||
///
|
||||
/// See [`SwapchainPresentSemaphores::present`] for details.
|
||||
fn get_submit_signal_semaphore(
|
||||
&mut self,
|
||||
device: &DeviceShared,
|
||||
) -> Result<vk::Semaphore, crate::DeviceError> {
|
||||
// Try to recycle a semaphore we created for a previous presentation.
|
||||
let sem = match self.present.get(self.present_index) {
|
||||
Some(sem) => *sem,
|
||||
None => {
|
||||
let sem = device.new_binary_semaphore(&format!(
|
||||
"SwapchainImageSemaphore: Image {} present semaphore {}",
|
||||
self.frame_index, self.present_index
|
||||
))?;
|
||||
self.present.push(sem);
|
||||
sem
|
||||
}
|
||||
};
|
||||
|
||||
self.present_index += 1;
|
||||
|
||||
Ok(sem)
|
||||
}
|
||||
|
||||
/// Indicates the cpu-side usage of this semaphore has finished for the frame,
|
||||
/// so reset internal state to be ready for the next frame.
|
||||
fn end_semaphore_usage(&mut self) {
|
||||
// Reset the index to 0, so that the next time we get a semaphore, we
|
||||
// start from the beginning of the list.
|
||||
self.present_index = 0;
|
||||
}
|
||||
|
||||
/// Return the semaphores that a presentation of this image should wait on.
|
||||
///
|
||||
/// Return a slice of semaphores that the call to [`vkQueueSubmit`] that
|
||||
/// ends this image's acquisition should wait for. See
|
||||
/// [`SwapchainPresentSemaphores::present`] for details.
|
||||
///
|
||||
/// Reset `self` to be ready for the next acquisition cycle.
|
||||
///
|
||||
/// [`vkQueueSubmit`]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#vkQueueSubmit
|
||||
fn get_present_wait_semaphores(&mut self) -> Vec<vk::Semaphore> {
|
||||
self.present[0..self.present_index].to_vec()
|
||||
}
|
||||
|
||||
unsafe fn destroy(&self, device: &ash::Device) {
|
||||
unsafe {
|
||||
for sem in &self.present {
|
||||
device.destroy_semaphore(*sem, None);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct NativeSurfaceTextureMetadata {
|
||||
acquire_semaphores: Arc<Mutex<SwapchainAcquireSemaphore>>,
|
||||
present_semaphores: Arc<Mutex<SwapchainPresentSemaphores>>,
|
||||
}
|
||||
|
||||
impl SurfaceTextureMetadata for NativeSurfaceTextureMetadata {
|
||||
fn get_semaphore_guard(&self) -> Box<dyn SwapchainSubmissionSemaphoreGuard + '_> {
|
||||
Box::new(NativeSwapchainSubmissionSemaphoreGuard {
|
||||
acquire_semaphore_guard: self
|
||||
.acquire_semaphores
|
||||
.try_lock()
|
||||
.expect("Failed to lock surface acquire semaphore"),
|
||||
present_semaphores_guard: self
|
||||
.present_semaphores
|
||||
.try_lock()
|
||||
.expect("Failed to lock surface present semaphores"),
|
||||
})
|
||||
}
|
||||
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
struct NativeSwapchainSubmissionSemaphoreGuard<'a> {
|
||||
acquire_semaphore_guard: MutexGuard<'a, SwapchainAcquireSemaphore>,
|
||||
present_semaphores_guard: MutexGuard<'a, SwapchainPresentSemaphores>,
|
||||
}
|
||||
|
||||
impl<'a> SwapchainSubmissionSemaphoreGuard for NativeSwapchainSubmissionSemaphoreGuard<'a> {
|
||||
fn set_used_fence_value(&mut self, value: u64) {
|
||||
self.acquire_semaphore_guard.set_used_fence_value(value);
|
||||
}
|
||||
|
||||
fn get_acquire_wait_semaphore(&mut self) -> Option<SemaphoreType> {
|
||||
self.acquire_semaphore_guard
|
||||
.get_acquire_wait_semaphore()
|
||||
.map(SemaphoreType::Binary)
|
||||
}
|
||||
|
||||
fn get_submit_signal_semaphore(
|
||||
&mut self,
|
||||
device: &DeviceShared,
|
||||
) -> Result<SemaphoreType, crate::DeviceError> {
|
||||
self.present_semaphores_guard
|
||||
.get_submit_signal_semaphore(device)
|
||||
.map(SemaphoreType::Binary)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user