79f78f904b
The crates.io sources of wgpu-hal 30.0.1, minus its examples, lock file and VCS metadata, so the next commit can apply one upstream fix that has no release yet. Excluded from the workspace: it keeps its own lints. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
468 lines
19 KiB
Rust
468 lines
19 KiB
Rust
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,
|
|
)
|
|
}
|