mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-19 22:11:01 +01:00
622 lines
19 KiB
Rust
622 lines
19 KiB
Rust
use crate::{binding_model, command, pipeline, resource, Color, Extent3d, Origin3d};
|
|
|
|
pub fn map_buffer_usage(
|
|
usage: resource::BufferUsageFlags,
|
|
) -> (hal::buffer::Usage, hal::memory::Properties) {
|
|
use crate::resource::BufferUsageFlags as W;
|
|
use hal::buffer::Usage as U;
|
|
use hal::memory::Properties as P;
|
|
|
|
let mut hal_memory = P::empty();
|
|
if usage.contains(W::MAP_READ) {
|
|
hal_memory |= P::CPU_VISIBLE | P::CPU_CACHED;
|
|
}
|
|
if usage.contains(W::MAP_WRITE) {
|
|
hal_memory |= P::CPU_VISIBLE;
|
|
}
|
|
|
|
let mut hal_usage = U::empty();
|
|
if usage.contains(W::TRANSFER_SRC) {
|
|
hal_usage |= U::TRANSFER_SRC;
|
|
}
|
|
if usage.contains(W::TRANSFER_DST) {
|
|
hal_usage |= U::TRANSFER_DST;
|
|
}
|
|
if usage.contains(W::INDEX) {
|
|
hal_usage |= U::INDEX;
|
|
}
|
|
if usage.contains(W::VERTEX) {
|
|
hal_usage |= U::VERTEX;
|
|
}
|
|
if usage.contains(W::UNIFORM) {
|
|
hal_usage |= U::UNIFORM;
|
|
}
|
|
if usage.contains(W::STORAGE) {
|
|
hal_usage |= U::STORAGE;
|
|
}
|
|
|
|
(hal_usage, hal_memory)
|
|
}
|
|
|
|
pub fn map_texture_usage(
|
|
usage: resource::TextureUsageFlags,
|
|
aspects: hal::format::Aspects,
|
|
) -> hal::image::Usage {
|
|
use crate::resource::TextureUsageFlags as W;
|
|
use hal::image::Usage as U;
|
|
|
|
let mut value = U::empty();
|
|
if usage.contains(W::TRANSFER_SRC) {
|
|
value |= U::TRANSFER_SRC;
|
|
}
|
|
if usage.contains(W::TRANSFER_DST) {
|
|
value |= U::TRANSFER_DST;
|
|
}
|
|
if usage.contains(W::SAMPLED) {
|
|
value |= U::SAMPLED;
|
|
}
|
|
if usage.contains(W::STORAGE) {
|
|
value |= U::STORAGE;
|
|
}
|
|
if usage.contains(W::OUTPUT_ATTACHMENT) {
|
|
if aspects.intersects(hal::format::Aspects::DEPTH | hal::format::Aspects::STENCIL) {
|
|
value |= U::DEPTH_STENCIL_ATTACHMENT;
|
|
} else {
|
|
value |= U::COLOR_ATTACHMENT;
|
|
}
|
|
}
|
|
// Note: TextureUsageFlags::Present does not need to be handled explicitly
|
|
// TODO: HAL Transient Attachment, HAL Input Attachment
|
|
value
|
|
}
|
|
|
|
pub fn map_binding_type(binding_ty: binding_model::BindingType) -> hal::pso::DescriptorType {
|
|
use crate::binding_model::BindingType::*;
|
|
use hal::pso::DescriptorType as H;
|
|
match binding_ty {
|
|
UniformBuffer => H::UniformBuffer,
|
|
Sampler => H::Sampler,
|
|
SampledTexture => H::SampledImage,
|
|
StorageBuffer => H::StorageBuffer,
|
|
}
|
|
}
|
|
|
|
pub fn map_shader_stage_flags(
|
|
shader_stage_flags: binding_model::ShaderStageFlags,
|
|
) -> hal::pso::ShaderStageFlags {
|
|
use crate::binding_model::ShaderStageFlags as F;
|
|
use hal::pso::ShaderStageFlags as H;
|
|
|
|
let mut value = H::empty();
|
|
if shader_stage_flags.contains(F::VERTEX) {
|
|
value |= H::VERTEX;
|
|
}
|
|
if shader_stage_flags.contains(F::FRAGMENT) {
|
|
value |= H::FRAGMENT;
|
|
}
|
|
if shader_stage_flags.contains(F::COMPUTE) {
|
|
value |= H::COMPUTE;
|
|
}
|
|
value
|
|
}
|
|
|
|
pub fn map_origin(origin: Origin3d) -> hal::image::Offset {
|
|
hal::image::Offset {
|
|
x: origin.x as i32,
|
|
y: origin.y as i32,
|
|
z: origin.z as i32,
|
|
}
|
|
}
|
|
|
|
pub fn map_extent(extent: Extent3d) -> hal::image::Extent {
|
|
hal::image::Extent {
|
|
width: extent.width,
|
|
height: extent.height,
|
|
depth: extent.depth,
|
|
}
|
|
}
|
|
|
|
pub fn map_primitive_topology(primitive_topology: pipeline::PrimitiveTopology) -> hal::Primitive {
|
|
use crate::pipeline::PrimitiveTopology::*;
|
|
use hal::Primitive as H;
|
|
match primitive_topology {
|
|
PointList => H::PointList,
|
|
LineList => H::LineList,
|
|
LineStrip => H::LineStrip,
|
|
TriangleList => H::TriangleList,
|
|
TriangleStrip => H::TriangleStrip,
|
|
}
|
|
}
|
|
|
|
pub fn map_color_state_descriptor(
|
|
desc: &pipeline::ColorStateDescriptor,
|
|
) -> hal::pso::ColorBlendDesc {
|
|
let color_mask = desc.write_mask;
|
|
let blend_state = if desc.color != pipeline::BlendDescriptor::REPLACE
|
|
|| desc.alpha != pipeline::BlendDescriptor::REPLACE
|
|
{
|
|
hal::pso::BlendState::On {
|
|
color: map_blend_descriptor(&desc.color),
|
|
alpha: map_blend_descriptor(&desc.alpha),
|
|
}
|
|
} else {
|
|
hal::pso::BlendState::Off
|
|
};
|
|
hal::pso::ColorBlendDesc(map_color_write_flags(color_mask), blend_state)
|
|
}
|
|
|
|
fn map_color_write_flags(flags: pipeline::ColorWriteFlags) -> hal::pso::ColorMask {
|
|
use crate::pipeline::ColorWriteFlags as F;
|
|
use hal::pso::ColorMask as H;
|
|
|
|
let mut value = H::empty();
|
|
if flags.contains(F::RED) {
|
|
value |= H::RED;
|
|
}
|
|
if flags.contains(F::GREEN) {
|
|
value |= H::GREEN;
|
|
}
|
|
if flags.contains(F::BLUE) {
|
|
value |= H::BLUE;
|
|
}
|
|
if flags.contains(F::ALPHA) {
|
|
value |= H::ALPHA;
|
|
}
|
|
value
|
|
}
|
|
|
|
fn map_blend_descriptor(blend_desc: &pipeline::BlendDescriptor) -> hal::pso::BlendOp {
|
|
use crate::pipeline::BlendOperation::*;
|
|
use hal::pso::BlendOp as H;
|
|
match blend_desc.operation {
|
|
Add => H::Add {
|
|
src: map_blend_factor(blend_desc.src_factor),
|
|
dst: map_blend_factor(blend_desc.dst_factor),
|
|
},
|
|
Subtract => H::Sub {
|
|
src: map_blend_factor(blend_desc.src_factor),
|
|
dst: map_blend_factor(blend_desc.dst_factor),
|
|
},
|
|
ReverseSubtract => H::RevSub {
|
|
src: map_blend_factor(blend_desc.src_factor),
|
|
dst: map_blend_factor(blend_desc.dst_factor),
|
|
},
|
|
Min => H::Min,
|
|
Max => H::Max,
|
|
}
|
|
}
|
|
|
|
fn map_blend_factor(blend_factor: pipeline::BlendFactor) -> hal::pso::Factor {
|
|
use crate::pipeline::BlendFactor::*;
|
|
use hal::pso::Factor as H;
|
|
match blend_factor {
|
|
Zero => H::Zero,
|
|
One => H::One,
|
|
SrcColor => H::SrcColor,
|
|
OneMinusSrcColor => H::OneMinusSrcColor,
|
|
SrcAlpha => H::SrcAlpha,
|
|
OneMinusSrcAlpha => H::OneMinusSrcAlpha,
|
|
DstColor => H::DstColor,
|
|
OneMinusDstColor => H::OneMinusDstColor,
|
|
DstAlpha => H::DstAlpha,
|
|
OneMinusDstAlpha => H::OneMinusDstAlpha,
|
|
SrcAlphaSaturated => H::SrcAlphaSaturate,
|
|
BlendColor => H::ConstColor,
|
|
OneMinusBlendColor => H::OneMinusConstColor,
|
|
}
|
|
}
|
|
|
|
pub fn map_depth_stencil_state_descriptor(
|
|
desc: &pipeline::DepthStencilStateDescriptor,
|
|
) -> hal::pso::DepthStencilDesc {
|
|
hal::pso::DepthStencilDesc {
|
|
depth: if desc.depth_write_enabled
|
|
|| desc.depth_compare != resource::CompareFunction::Always
|
|
{
|
|
hal::pso::DepthTest::On {
|
|
fun: map_compare_function(desc.depth_compare),
|
|
write: desc.depth_write_enabled,
|
|
}
|
|
} else {
|
|
hal::pso::DepthTest::Off
|
|
},
|
|
depth_bounds: false, // TODO
|
|
stencil: if desc.stencil_read_mask != !0
|
|
|| desc.stencil_write_mask != !0
|
|
|| desc.stencil_front != pipeline::StencilStateFaceDescriptor::IGNORE
|
|
|| desc.stencil_back != pipeline::StencilStateFaceDescriptor::IGNORE
|
|
{
|
|
hal::pso::StencilTest::On {
|
|
front: map_stencil_face(
|
|
&desc.stencil_front,
|
|
desc.stencil_read_mask,
|
|
desc.stencil_write_mask,
|
|
),
|
|
back: map_stencil_face(
|
|
&desc.stencil_back,
|
|
desc.stencil_read_mask,
|
|
desc.stencil_write_mask,
|
|
),
|
|
}
|
|
} else {
|
|
hal::pso::StencilTest::Off
|
|
},
|
|
}
|
|
}
|
|
|
|
fn map_stencil_face(
|
|
stencil_state_face_desc: &pipeline::StencilStateFaceDescriptor,
|
|
stencil_read_mask: u32,
|
|
stencil_write_mask: u32,
|
|
) -> hal::pso::StencilFace {
|
|
hal::pso::StencilFace {
|
|
fun: map_compare_function(stencil_state_face_desc.compare),
|
|
mask_read: hal::pso::State::Static(stencil_read_mask), // TODO dynamic?
|
|
mask_write: hal::pso::State::Static(stencil_write_mask), // TODO dynamic?
|
|
op_fail: map_stencil_operation(stencil_state_face_desc.fail_op),
|
|
op_depth_fail: map_stencil_operation(stencil_state_face_desc.depth_fail_op),
|
|
op_pass: map_stencil_operation(stencil_state_face_desc.pass_op),
|
|
reference: hal::pso::State::Static(0), // TODO can this be set?
|
|
}
|
|
}
|
|
|
|
pub fn map_compare_function(compare_function: resource::CompareFunction) -> hal::pso::Comparison {
|
|
use crate::resource::CompareFunction::*;
|
|
use hal::pso::Comparison as H;
|
|
match compare_function {
|
|
Never => H::Never,
|
|
Less => H::Less,
|
|
Equal => H::Equal,
|
|
LessEqual => H::LessEqual,
|
|
Greater => H::Greater,
|
|
NotEqual => H::NotEqual,
|
|
GreaterEqual => H::GreaterEqual,
|
|
Always => H::Always,
|
|
}
|
|
}
|
|
|
|
fn map_stencil_operation(stencil_operation: pipeline::StencilOperation) -> hal::pso::StencilOp {
|
|
use crate::pipeline::StencilOperation::*;
|
|
use hal::pso::StencilOp as H;
|
|
match stencil_operation {
|
|
Keep => H::Keep,
|
|
Zero => H::Zero,
|
|
Replace => H::Replace,
|
|
Invert => H::Invert,
|
|
IncrementClamp => H::IncrementClamp,
|
|
DecrementClamp => H::DecrementClamp,
|
|
IncrementWrap => H::IncrementWrap,
|
|
DecrementWrap => H::DecrementWrap,
|
|
}
|
|
}
|
|
|
|
pub fn map_texture_format(texture_format: resource::TextureFormat) -> hal::format::Format {
|
|
use crate::resource::TextureFormat::*;
|
|
use hal::format::Format as H;
|
|
match texture_format {
|
|
// Normal 8 bit formats
|
|
R8Unorm => H::R8Unorm,
|
|
R8UnormSrgb => H::R8Srgb,
|
|
R8Snorm => H::R8Inorm,
|
|
R8Uint => H::R8Uint,
|
|
R8Sint => H::R8Int,
|
|
|
|
// Normal 16 bit formats
|
|
R16Unorm => H::R16Unorm,
|
|
R16Snorm => H::R16Inorm,
|
|
R16Uint => H::R16Uint,
|
|
R16Sint => H::R16Int,
|
|
R16Float => H::R16Float,
|
|
|
|
Rg8Unorm => H::Rg8Unorm,
|
|
Rg8UnormSrgb => H::Rg8Srgb,
|
|
Rg8Snorm => H::Rg8Inorm,
|
|
Rg8Uint => H::Rg8Uint,
|
|
Rg8Sint => H::Rg8Int,
|
|
|
|
// Packed 16 bit formats
|
|
B5g6r5Unorm => H::B5g6r5Unorm,
|
|
|
|
// Normal 32 bit formats
|
|
R32Uint => H::R32Uint,
|
|
R32Sint => H::R32Int,
|
|
R32Float => H::R32Float,
|
|
Rg16Unorm => H::Rg16Unorm,
|
|
Rg16Snorm => H::Rg16Inorm,
|
|
Rg16Uint => H::Rg16Uint,
|
|
Rg16Sint => H::Rg16Int,
|
|
Rg16Float => H::Rg16Float,
|
|
Rgba8Unorm => H::Rgba8Unorm,
|
|
Rgba8UnormSrgb => H::Rgba8Srgb,
|
|
Rgba8Snorm => H::Rgba8Inorm,
|
|
Rgba8Uint => H::Rgba8Uint,
|
|
Rgba8Sint => H::Rgba8Int,
|
|
Bgra8Unorm => H::Bgra8Unorm,
|
|
Bgra8UnormSrgb => H::Bgra8Srgb,
|
|
|
|
// Packed 32 bit formats
|
|
Rgb10a2Unorm => H::A2r10g10b10Unorm,
|
|
Rg11b10Float => H::B10g11r11Ufloat,
|
|
|
|
// Normal 64 bit formats
|
|
Rg32Uint => H::Rg32Uint,
|
|
Rg32Sint => H::Rg32Int,
|
|
Rg32Float => H::Rg32Float,
|
|
Rgba16Unorm => H::Rgba16Unorm,
|
|
Rgba16Snorm => H::Rgba16Inorm,
|
|
Rgba16Uint => H::Rgba16Uint,
|
|
Rgba16Sint => H::Rgba16Int,
|
|
Rgba16Float => H::Rgba16Float,
|
|
|
|
// Normal 128 bit formats
|
|
Rgba32Uint => H::Rgba32Uint,
|
|
Rgba32Sint => H::Rgba32Int,
|
|
Rgba32Float => H::Rgba32Float,
|
|
|
|
// Depth and stencil formats
|
|
D16Unorm => H::D16Unorm,
|
|
D32Float => H::D32Float,
|
|
D24UnormS8Uint => H::D24UnormS8Uint,
|
|
D32FloatS8Uint => H::D32FloatS8Uint,
|
|
}
|
|
}
|
|
|
|
pub fn map_vertex_format(vertex_format: pipeline::VertexFormat) -> hal::format::Format {
|
|
use crate::pipeline::VertexFormat::*;
|
|
use hal::format::Format as H;
|
|
match vertex_format {
|
|
Uchar => H::R8Uint,
|
|
Uchar2 => H::Rg8Uint,
|
|
Uchar3 => H::Rgb8Uint,
|
|
Uchar4 => H::Rgba8Uint,
|
|
Char => H::R8Int,
|
|
Char2 => H::Rg8Int,
|
|
Char3 => H::Rgb8Int,
|
|
Char4 => H::Rgba8Int,
|
|
UcharNorm => H::R8Unorm,
|
|
Uchar2Norm => H::Rg8Unorm,
|
|
Uchar3Norm => H::Rgb8Unorm,
|
|
Uchar4Norm => H::Rgba8Unorm,
|
|
Uchar4NormBgra => H::Bgra8Unorm,
|
|
CharNorm => H::R8Inorm,
|
|
Char2Norm => H::Rg8Inorm,
|
|
Char3Norm => H::Rgb8Inorm,
|
|
Char4Norm => H::Rgba8Inorm,
|
|
Ushort => H::R16Uint,
|
|
Ushort2 => H::Rg16Uint,
|
|
Ushort3 => H::Rgb16Uint,
|
|
Ushort4 => H::Rgba16Uint,
|
|
Short => H::R16Int,
|
|
Short2 => H::Rg16Int,
|
|
Short3 => H::Rgb16Int,
|
|
Short4 => H::Rgba16Int,
|
|
UshortNorm => H::R16Unorm,
|
|
Ushort2Norm => H::Rg16Unorm,
|
|
Ushort3Norm => H::Rgb16Unorm,
|
|
Ushort4Norm => H::Rgba16Unorm,
|
|
ShortNorm => H::R16Inorm,
|
|
Short2Norm => H::Rg16Inorm,
|
|
Short3Norm => H::Rgb16Inorm,
|
|
Short4Norm => H::Rgba16Inorm,
|
|
Half => H::R16Float,
|
|
Half2 => H::Rg16Float,
|
|
Half3 => H::Rgb16Float,
|
|
Half4 => H::Rgba16Float,
|
|
Float => H::R32Float,
|
|
Float2 => H::Rg32Float,
|
|
Float3 => H::Rgb32Float,
|
|
Float4 => H::Rgba32Float,
|
|
Uint => H::R32Uint,
|
|
Uint2 => H::Rg32Uint,
|
|
Uint3 => H::Rgb32Uint,
|
|
Uint4 => H::Rgba32Uint,
|
|
Int => H::R32Int,
|
|
Int2 => H::Rg32Int,
|
|
Int3 => H::Rgb32Int,
|
|
Int4 => H::Rgba32Int,
|
|
}
|
|
}
|
|
|
|
fn checked_u32_as_u16(value: u32) -> u16 {
|
|
assert!(value <= ::std::u16::MAX as u32);
|
|
value as u16
|
|
}
|
|
|
|
pub fn map_texture_dimension_size(
|
|
dimension: resource::TextureDimension,
|
|
Extent3d {
|
|
width,
|
|
height,
|
|
depth,
|
|
}: Extent3d,
|
|
array_size: u32,
|
|
) -> hal::image::Kind {
|
|
use crate::resource::TextureDimension::*;
|
|
use hal::image::Kind as H;
|
|
match dimension {
|
|
D1 => {
|
|
assert_eq!(height, 1);
|
|
assert_eq!(depth, 1);
|
|
H::D1(width, checked_u32_as_u16(array_size))
|
|
}
|
|
D2 => {
|
|
assert_eq!(depth, 1);
|
|
H::D2(width, height, checked_u32_as_u16(array_size), 1) // TODO: Samples
|
|
}
|
|
D3 => {
|
|
assert_eq!(array_size, 1);
|
|
H::D3(width, height, depth)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn map_texture_view_dimension(
|
|
dimension: resource::TextureViewDimension,
|
|
) -> hal::image::ViewKind {
|
|
use crate::resource::TextureViewDimension::*;
|
|
use hal::image::ViewKind as H;
|
|
match dimension {
|
|
D1 => H::D1,
|
|
D2 => H::D2,
|
|
D2Array => H::D2Array,
|
|
Cube => H::Cube,
|
|
CubeArray => H::CubeArray,
|
|
D3 => H::D3,
|
|
}
|
|
}
|
|
|
|
pub fn map_texture_aspect_flags(aspect: resource::TextureAspectFlags) -> hal::format::Aspects {
|
|
use crate::resource::TextureAspectFlags as Taf;
|
|
use hal::format::Aspects;
|
|
|
|
let mut flags = Aspects::empty();
|
|
if aspect.contains(Taf::COLOR) {
|
|
flags |= Aspects::COLOR;
|
|
}
|
|
if aspect.contains(Taf::DEPTH) {
|
|
flags |= Aspects::DEPTH;
|
|
}
|
|
if aspect.contains(Taf::STENCIL) {
|
|
flags |= Aspects::STENCIL;
|
|
}
|
|
flags
|
|
}
|
|
|
|
pub fn map_buffer_state(usage: resource::BufferUsageFlags) -> hal::buffer::State {
|
|
use crate::resource::BufferUsageFlags as W;
|
|
use hal::buffer::Access as A;
|
|
|
|
let mut access = A::empty();
|
|
if usage.contains(W::TRANSFER_SRC) {
|
|
access |= A::TRANSFER_READ;
|
|
}
|
|
if usage.contains(W::TRANSFER_DST) {
|
|
access |= A::TRANSFER_WRITE;
|
|
}
|
|
if usage.contains(W::INDEX) {
|
|
access |= A::INDEX_BUFFER_READ;
|
|
}
|
|
if usage.contains(W::VERTEX) {
|
|
access |= A::VERTEX_BUFFER_READ;
|
|
}
|
|
if usage.contains(W::UNIFORM) {
|
|
access |= A::CONSTANT_BUFFER_READ | A::SHADER_READ;
|
|
}
|
|
if usage.contains(W::STORAGE) {
|
|
access |= A::SHADER_WRITE;
|
|
}
|
|
|
|
access
|
|
}
|
|
|
|
pub fn map_texture_state(
|
|
usage: resource::TextureUsageFlags,
|
|
aspects: hal::format::Aspects,
|
|
) -> hal::image::State {
|
|
use crate::resource::TextureUsageFlags as W;
|
|
use hal::image::{Access as A, Layout as L};
|
|
|
|
let is_color = aspects.contains(hal::format::Aspects::COLOR);
|
|
let layout = match usage {
|
|
W::UNINITIALIZED => return (A::empty(), L::Undefined),
|
|
W::TRANSFER_SRC => L::TransferSrcOptimal,
|
|
W::TRANSFER_DST => L::TransferDstOptimal,
|
|
W::SAMPLED => L::ShaderReadOnlyOptimal,
|
|
W::OUTPUT_ATTACHMENT if is_color => L::ColorAttachmentOptimal,
|
|
W::OUTPUT_ATTACHMENT => L::DepthStencilAttachmentOptimal, //TODO: read-only depth/stencil
|
|
_ => L::General,
|
|
};
|
|
|
|
let mut access = A::empty();
|
|
if usage.contains(W::TRANSFER_SRC) {
|
|
access |= A::TRANSFER_READ;
|
|
}
|
|
if usage.contains(W::TRANSFER_DST) {
|
|
access |= A::TRANSFER_WRITE;
|
|
}
|
|
if usage.contains(W::SAMPLED) {
|
|
access |= A::SHADER_READ;
|
|
}
|
|
if usage.contains(W::STORAGE) {
|
|
access |= A::SHADER_WRITE;
|
|
}
|
|
if usage.contains(W::OUTPUT_ATTACHMENT) {
|
|
//TODO: read-only attachments
|
|
access |= if is_color {
|
|
A::COLOR_ATTACHMENT_WRITE
|
|
} else {
|
|
A::DEPTH_STENCIL_ATTACHMENT_WRITE
|
|
};
|
|
}
|
|
|
|
(access, layout)
|
|
}
|
|
|
|
pub fn map_load_store_ops(
|
|
load: command::LoadOp,
|
|
store: command::StoreOp,
|
|
) -> hal::pass::AttachmentOps {
|
|
hal::pass::AttachmentOps {
|
|
load: match load {
|
|
command::LoadOp::Clear => hal::pass::AttachmentLoadOp::Clear,
|
|
command::LoadOp::Load => hal::pass::AttachmentLoadOp::Load,
|
|
},
|
|
store: match store {
|
|
command::StoreOp::Store => hal::pass::AttachmentStoreOp::Store,
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn map_color(color: &Color) -> hal::pso::ColorValue {
|
|
[color.r, color.g, color.b, color.a]
|
|
}
|
|
|
|
pub fn map_filter(filter: resource::FilterMode) -> hal::image::Filter {
|
|
match filter {
|
|
resource::FilterMode::Nearest => hal::image::Filter::Nearest,
|
|
resource::FilterMode::Linear => hal::image::Filter::Linear,
|
|
}
|
|
}
|
|
|
|
pub fn map_wrap(address: resource::AddressMode) -> hal::image::WrapMode {
|
|
use crate::resource::AddressMode as Am;
|
|
use hal::image::WrapMode as W;
|
|
match address {
|
|
Am::ClampToEdge => W::Clamp,
|
|
Am::Repeat => W::Tile,
|
|
Am::MirrorRepeat => W::Mirror,
|
|
Am::ClampToBorderColor => W::Border,
|
|
}
|
|
}
|
|
|
|
pub fn map_rasterization_state_descriptor(
|
|
desc: &pipeline::RasterizationStateDescriptor,
|
|
) -> hal::pso::Rasterizer {
|
|
hal::pso::Rasterizer {
|
|
depth_clamping: false,
|
|
polygon_mode: hal::pso::PolygonMode::Fill,
|
|
cull_face: match desc.cull_mode {
|
|
pipeline::CullMode::None => hal::pso::Face::empty(),
|
|
pipeline::CullMode::Front => hal::pso::Face::FRONT,
|
|
pipeline::CullMode::Back => hal::pso::Face::BACK,
|
|
},
|
|
front_face: match desc.front_face {
|
|
pipeline::FrontFace::Ccw => hal::pso::FrontFace::CounterClockwise,
|
|
pipeline::FrontFace::Cw => hal::pso::FrontFace::Clockwise,
|
|
},
|
|
depth_bias: if desc.depth_bias != 0
|
|
|| desc.depth_bias_slope_scale != 0.0
|
|
|| desc.depth_bias_clamp != 0.0
|
|
{
|
|
Some(hal::pso::State::Static(hal::pso::DepthBias {
|
|
const_factor: desc.depth_bias as f32,
|
|
slope_factor: desc.depth_bias_slope_scale,
|
|
clamp: desc.depth_bias_clamp,
|
|
}))
|
|
} else {
|
|
None
|
|
},
|
|
conservative: false,
|
|
}
|
|
}
|