wgpu/wgpu-hal/Cargo.toml

[package]
name = "wgpu-hal"
version = "23.0.0"
authors = ["gfx-rs developers"]
edition = "2021"
description = "WebGPU hardware abstraction layer"
homepage = "https://wgpu.rs/"
repository = "https://github.com/gfx-rs/wgpu"
keywords = ["graphics"]
license = "MIT OR Apache-2.0"

# Override the workspace's `rust-version` key. Firefox uses `cargo vendor` to
# copy the crates it actually uses out of the workspace, so it's meaningful for
# them to have less restrictive MSRVs individually than the workspace as a
# whole, if their code permits. See `../README.md` for details.
rust-version = "1.76"

[package.metadata.docs.rs]
# Ideally we would enable all the features.
#
# However, the metal features fail to be documented because the docs.rs runner cross-compiling under
# x86_64-unknown-linux-gnu and metal-rs cannot compile in that environment at the moment. The same applies
# for the dx12 feature.
features = ["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"]

[lib]

[features]
## Enables the Metal backend when targeting Apple platforms.
##
## Has no effect on non-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-if-target-apple",
    "dep:block",
]
vulkan = [
    "naga/spv-out",
    "dep:ash",
    "dep:gpu-alloc",
    "dep:gpu-descriptor",
    "dep:libloading",
    "dep:smallvec",
    "dep:android_system_properties",
]
gles = [
    "naga/glsl-out",
    "dep:bytemuck",
    "dep:glow",
    "dep:glutin_wgl_sys",
    "dep:khronos-egl",
    "dep:libloading",
    "dep:ndk-sys",
    "windows/Win32_Graphics_OpenGL",
    "windows/Win32_Graphics_Gdi",
    "windows/Win32_System_LibraryLoader",
    "windows/Win32_UI_WindowsAndMessaging",
]
## Enables the DX12 backend when targeting Windows.
##
## Has no effect if not targeting Windows.
dx12 = [
    # DX12 is only available on Windows, therefore request HLSL output also only if we target Windows.
    "dep:bit-set",
    "dep:libloading",
    "dep:range-alloc",
    "dep:windows-core",
    "gpu-allocator/d3d12",
    "naga/hlsl-out-if-target-windows",
    "windows/Win32_Graphics_Direct3D_Fxc",
    "windows/Win32_Graphics_Direct3D_Dxc",
    "windows/Win32_Graphics_Direct3D",
    "windows/Win32_Graphics_Direct3D12",
    "windows/Win32_Graphics_DirectComposition",
    "windows/Win32_Graphics_Dxgi_Common",
    "windows/Win32_Security",
    "windows/Win32_System_Diagnostics_Debug",
    "windows/Win32_System_Kernel",
    "windows/Win32_System_Performance",
    "windows/Win32_System_Threading",
    "windows/Win32_UI_WindowsAndMessaging",
]
renderdoc = ["dep:libloading", "dep:renderdoc-sys"]
fragile-send-sync-non-atomic-wasm = ["wgt/fragile-send-sync-non-atomic-wasm"]
# Panic when running into an out-of-memory error (for debugging purposes).
#
# Only affects the d3d12 and vulkan backends.
oom_panic = []
# 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 = []

[[example]]
name = "halmark"

[[example]]
name = "raw-gles"
required-features = ["gles"]

[dependencies]
bitflags.workspace = true
parking_lot.workspace = true
profiling = { workspace = true, default-features = false }
raw-window-handle.workspace = true
thiserror.workspace = true
once_cell.workspace = true

# backends common
arrayvec.workspace = true
rustc-hash.workspace = true
log.workspace = true

# backend: Gles
bytemuck = { workspace = true, optional = true }
glow = { workspace = true, optional = true }

[dependencies.wgt]
package = "wgpu-types"
path = "../wgpu-types"
version = "23.0.0"

[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
# backend: Vulkan
ash = { workspace = true, optional = true }
gpu-alloc = { workspace = true, optional = true }
gpu-descriptor = { workspace = true, optional = true }
smallvec = { workspace = true, optional = true, features = ["union"] }

khronos-egl = { workspace = true, features = ["dynamic"], optional = true }
libloading = { workspace = true, optional = true }
renderdoc-sys = { workspace = true, optional = true }

[target.'cfg(target_os = "emscripten")'.dependencies]
khronos-egl = { workspace = 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(windows)'.dependencies]
# backend: Dx12 and Gles
windows = { workspace = true, optional = true }
# backend: Dx12
bit-set = { workspace = true, optional = true }
range-alloc = { workspace = true, optional = true }
gpu-allocator = { workspace = true, optional = true }
# For core macros. This crate is also reexported as windows::core.
windows-core = { workspace = true, optional = true }

# backend: Gles
glutin_wgl_sys = { workspace = true, optional = true }

[target.'cfg(any(target_os="macos", target_os="ios"))'.dependencies]
# backend: Metal
block = { workspace = true, optional = true }

metal.workspace = true
objc.workspace = true
core-graphics-types.workspace = true

[target.'cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))'.dependencies]
wasm-bindgen.workspace = true
web-sys = { workspace = true, features = [
    "Window",
    "HtmlCanvasElement",
    "WebGl2RenderingContext",
    "OffscreenCanvas",
] }
js-sys.workspace = true

[target.'cfg(unix)'.dependencies]
libc.workspace = true

[target.'cfg(target_os = "android")'.dependencies]
android_system_properties = { workspace = true, optional = true }
ndk-sys = { workspace = true, optional = true }

[dependencies.naga]
path = "../naga"
version = "23.0.0"

[build-dependencies]
cfg_aliases.workspace = true

# DEV dependencies
[dev-dependencies.naga]
path = "../naga"
version = "23.0.0"
features = ["wgsl-in"]

[dev-dependencies]
cfg-if.workspace = true
env_logger.workspace = true
glam.workspace = true       # for ray-traced-triangle example
winit.workspace = true      # for "halmark" example

[target.'cfg(not(any(target_arch = "wasm32", target_os = "ios")))'.dev-dependencies]
glutin-winit = { workspace = true, features = [
    "egl",
    "wgl",
    "wayland",
    "x11",
] } # for "raw-gles" example
glutin = { workspace = true, features = [
    "egl",
    "wgl",
    "wayland",
    "x11",
] } # for "raw-gles" example
rwh_05 = { version = "0.5", package = "raw-window-handle" } # temporary compatibility for glutin-winit in "raw-gles" example
winit = { workspace = true, features = ["rwh_05"] } # for "raw-gles" example