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:
Fábio Soares authored and GitHub committed 2026-11-04 08:22:28 +07:00
1 parent 87f09c4d16
commit bbc06cb9c1
89 files changed
+56768 -5

No files matched your search

Generated
-2
View File
@@ -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",
+5
View File
@@ -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" }
+25 -3
View File
@@ -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));
}
}
+7
View File
@@ -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
+25
View File
@@ -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).
+542
View File
@@ -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
View File
@@ -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"] }
+176
View File
@@ -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
+21
View File
@@ -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.
+119
View File
@@ -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
+36
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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>
+396
View File
@@ -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();
}
}
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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
}
}
}
}
+241
View File
@@ -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
View File
@@ -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}")
}
};
}
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+467
View File
@@ -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,
)
}
+120
View File
@@ -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
View File
@@ -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))
}
+2691
View File
File diff suppressed because it is too large. Load diff
+176
View File
@@ -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),
}
+189
View File
@@ -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()
}
}
+1908
View File
File diff suppressed because it is too large. Load diff
+344
View File
@@ -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());
}
}
+252
View File
@@ -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
View File
@@ -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
View File
@@ -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)
}
}
+39
View File
@@ -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,
}
+370
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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()
}
}
+212
View File
@@ -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(),
),
}
}
}
+61
View File
@@ -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
View File
@@ -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()) }
}
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+430
View File
@@ -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!(),
}
}
+1823
View File
File diff suppressed because it is too large. Load diff
+1470
View File
File diff suppressed because it is too large. Load diff
+26
View File
@@ -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
}
}
+198
View File
@@ -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"),
);
}
}
}
}
+1215
View File
File diff suppressed because it is too large. Load diff
+1980
View File
File diff suppressed because it is too large. Load diff
+7
View File
@@ -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
View File
@@ -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);
}
+16
View File
@@ -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));
}
+18
View File
@@ -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);
}
+490
View File
@@ -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) {}
}
+905
View File
@@ -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) {}
}
+3086
View File
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+494
View File
@@ -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
}
File diff suppressed because it is too large. Load diff
+48
View File
@@ -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
}
+1410
View File
File diff suppressed because it is too large. Load diff
+409
View File
@@ -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) {}
}
+38
View File
@@ -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
}
}
+88
View File
@@ -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
}
+356
View File
@@ -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);
}
}
}
}
}
+487
View File
@@ -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
View File
@@ -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()
}
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+1136
View File
File diff suppressed because it is too large. Load diff
+339
View File
@@ -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,
})
}
File diff suppressed because it is too large. Load diff
+252
View File
@@ -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))
}
}
File diff suppressed because it is too large. Load diff
+1763
View File
File diff suppressed because it is too large. Load diff
+177
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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)
}
}