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, } }