Stencil Additions

blade-graphics/src/gles/command.rs

@@ -308,6 +308,10 @@
         self.commands
             .push(super::Command::SetViewport(viewport.clone()));
     }
+
+    fn set_stencil_reference(&mut self, reference: u32) {
+        unimplemented!()
+    }
 }
 
 impl super::PassEncoder<'_, super::RenderPipeline> {
@@ -460,6 +464,10 @@
         self.commands
             .push(super::Command::SetViewport(viewport.clone()));
     }
+
+    fn set_stencil_reference(&mut self, reference: u32) {
+        unimplemented!()
+    }
 }
 
 #[hidden_trait::expose]
@@ -813,10 +821,10 @@
                 gl.bind_buffer(glow::PIXEL_UNPACK_BUFFER, None);
             }
             Self::CopyTextureToBuffer {
                 ref src,
                 ref dst,
                 bytes_per_row,
                 ref size,
             } => unimplemented!(),
             Self::ResetFramebuffer => {
                 for &attachment in COLOR_ATTACHMENTS.iter() {
@@ -1040,9 +1048,9 @@
                 gl.scissor(rect.x, rect.y, rect.w as i32, rect.h as i32);
             }
             Self::SetStencilFunc {
                 face,
                 function,
                 reference,
                 read_mask,
             } => unimplemented!(),
             Self::SetStencilOps {

blade-graphics/src/gles/mod.rs

@@ -610,6 +610,16 @@ fn describe_texture_format(format: crate::TextureFormat) -> FormatInfo {
         Tf::Rg32Uint => (glow::RG32UI, glow::RG, glow::UNSIGNED_INT),
         Tf::Rgba32Uint => (glow::RGBA32UI, glow::RGBA, glow::UNSIGNED_INT),
         Tf::Depth32Float => (glow::DEPTH_COMPONENT32F, glow::DEPTH_COMPONENT, glow::FLOAT),
+        Tf::Depth32FloatStencil8Uint => (
+            glow::DEPTH32F_STENCIL8,
+            glow::DEPTH_STENCIL,
+            glow::FLOAT_32_UNSIGNED_INT_24_8_REV,
+        ),
+        Tf::Stencil8Uint => (
+            glow::STENCIL_INDEX8,
+            glow::STENCIL_INDEX,
+            glow::UNSIGNED_BYTE,
+        ),
         Tf::Bc1Unorm => (glow::COMPRESSED_RGBA_S3TC_DXT1_EXT, glow::RGBA, 0),
         Tf::Bc1UnormSrgb => (glow::COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, glow::RGBA, 0),
         Tf::Bc2Unorm => (glow::COMPRESSED_RGBA_S3TC_DXT3_EXT, glow::RGBA, 0),

blade-graphics/src/lib.rs

@@ -296,6 +296,8 @@ pub enum TextureFormat {
     Rgba32Uint,
     // depth and stencil
     Depth32Float,
+    Depth32FloatStencil8Uint,
+    Stencil8Uint,
     // S3TC block compression
     Bc1Unorm,
     Bc1UnormSrgb,

blade-graphics/src/metal/command.rs

@@ -256,30 +256,61 @@ impl super::CommandEncoder {
             }
 
             if let Some(ref rt) = targets.depth_stencil {
-                let at_descriptor = descriptor.depthAttachment();
-                at_descriptor.setTexture(Some(rt.view.as_ref()));
-                let load_action = match rt.init_op {
-                    crate::InitOp::Load => metal::MTLLoadAction::Load,
-                    crate::InitOp::Clear(color) => {
-                        let clear_depth = match color {
-                            crate::TextureColor::TransparentBlack
-                            | crate::TextureColor::OpaqueBlack => 0.0,
-                            crate::TextureColor::White => 1.0,
-                        };
-                        at_descriptor.setClearDepth(clear_depth);
-                        metal::MTLLoadAction::Clear
-                    }
-                    crate::InitOp::DontCare => metal::MTLLoadAction::DontCare,
-                };
-                let store_action = match rt.finish_op {
-                    crate::FinishOp::Store | crate::FinishOp::Ignore => {
-                        metal::MTLStoreAction::Store
-                    }
-                    crate::FinishOp::Discard => metal::MTLStoreAction::DontCare,
-                    crate::FinishOp::ResolveTo(_) => panic!("Can't resolve depth texture"),
-                };
-                at_descriptor.setLoadAction(load_action);
-                at_descriptor.setStoreAction(store_action);
+                if rt.view.aspects.contains(crate::TexelAspects::DEPTH) {
+                    let at_descriptor = descriptor.depthAttachment();
+                    at_descriptor.setTexture(Some(rt.view.as_ref()));
+                    let load_action = match rt.init_op {
+                        crate::InitOp::Load => metal::MTLLoadAction::Load,
+                        crate::InitOp::Clear(color) => {
+                            let clear_depth = match color {
+                                crate::TextureColor::TransparentBlack
+                                | crate::TextureColor::OpaqueBlack => 0.0,
+                                crate::TextureColor::White => 1.0,
+                            };
+                            at_descriptor.setClearDepth(clear_depth);
+                            metal::MTLLoadAction::Clear
+                        }
+                        crate::InitOp::DontCare => metal::MTLLoadAction::DontCare,
+                    };
+                    let store_action = match rt.finish_op {
+                        crate::FinishOp::Store | crate::FinishOp::Ignore => {
+                            metal::MTLStoreAction::Store
+                        }
+                        crate::FinishOp::Discard => metal::MTLStoreAction::DontCare,
+                        crate::FinishOp::ResolveTo(_) => panic!("Can't resolve depth texture"),
+                    };
+                    at_descriptor.setLoadAction(load_action);
+                    at_descriptor.setStoreAction(store_action);
+                }
+
+                if rt.view.aspects.contains(crate::TexelAspects::STENCIL) {
+                    let at_descriptor = descriptor.stencilAttachment();
+                    at_descriptor.setTexture(Some(rt.view.as_ref()));
+
+                    let load_action = match rt.init_op {
+                        crate::InitOp::Load => metal::MTLLoadAction::Load,
+                        crate::InitOp::Clear(color) => {
+                            let clear_stencil = match color {
+                                crate::TextureColor::TransparentBlack
+                                | crate::TextureColor::OpaqueBlack => 0,
+                                crate::TextureColor::White => !0,
+                            };
+                            at_descriptor.setClearStencil(clear_stencil);
+                            metal::MTLLoadAction::Clear
+                        }
+                        crate::InitOp::DontCare => metal::MTLLoadAction::DontCare,
+                    };
+                    let store_action = match rt.finish_op {
+                        crate::FinishOp::Store | crate::FinishOp::Ignore => {
+                            metal::MTLStoreAction::Store
+                        }
+                        crate::FinishOp::Discard => metal::MTLStoreAction::DontCare,
+                        crate::FinishOp::ResolveTo(_) => panic!("Can't resolve stencil texture"),
+                    };
+
+                    at_descriptor.setLoadAction(load_action);
+                    at_descriptor.setStoreAction(store_action);
+                }
             }
 
             if let Some(ref mut td_array) = self.timing_datas {
@@ -604,6 +635,10 @@ impl crate::traits::RenderEncoder for super::RenderCommandEncoder<'_> {
     fn set_viewport(&mut self, viewport: &crate::Viewport) {
         self.raw.setViewport(viewport.to_metal());
     }
+
+    fn set_stencil_reference(&mut self, stencil_reference: u32) {
+        self.raw.setStencilReferenceValue(stencil_reference);
+    }
 }
 
 impl super::RenderCommandEncoder<'_> {
@@ -724,6 +759,9 @@ impl crate::traits::RenderEncoder for super::RenderPipelineContext<'_> {
     fn set_viewport(&mut self, viewport: &crate::Viewport) {
         self.encoder.setViewport(viewport.to_metal());
     }
+    fn set_stencil_reference(&mut self, stencil_reference: u32) {
+        self.encoder.setStencilReferenceValue(stencil_reference);
+    }
 }
 
 #[hidden_trait::expose]

blade-graphics/src/metal/mod.rs

@@ -40,6 +40,7 @@ impl Frame {
     pub fn texture_view(&self) -> TextureView {
         TextureView {
             raw: Retained::as_ptr(&self.texture) as *mut _,
+            aspects: crate::TexelAspects::COLOR,
         }
     }
 }
@@ -116,6 +117,7 @@ impl Texture {
 #[derive(Clone, Copy, Debug, Hash, PartialEq)]
 pub struct TextureView {
     raw: *mut ProtocolObject<dyn metal::MTLTexture>,
+    aspects: crate::TexelAspects,
 }
 
 unsafe impl Send for TextureView {}
@@ -125,6 +127,7 @@ impl Default for TextureView {
     fn default() -> Self {
         Self {
             raw: ptr::null_mut(),
+            aspects: crate::TexelAspects::COLOR,
         }
     }
 }
@@ -136,9 +139,13 @@ impl TextureView {
 
     /// Create a TextureView from a raw Metal Texture.
     /// Does not keep a reference, need not being destoryed.
-    pub fn from_metal_texture(raw: &Retained<ProtocolObject<dyn metal::MTLTexture>>) -> Self {
+    pub fn from_metal_texture(
+        raw: &Retained<ProtocolObject<dyn metal::MTLTexture>>,
+        aspects: crate::TexelAspects,
+    ) -> Self {
         Self {
             raw: Retained::into_raw(raw.clone()),
+            aspects,
         }
     }
 }
@@ -335,6 +342,8 @@ fn map_texture_format(format: crate::TextureFormat) -> metal::MTLPixelFormat {
         Tf::Rg32Uint => Mpf::RG32Uint,
         Tf::Rgba32Uint => Mpf::RGBA32Uint,
         Tf::Depth32Float => Mpf::Depth32Float,
+        Tf::Depth32FloatStencil8Uint => Mpf::Depth32Float_Stencil8,
+        Tf::Stencil8Uint => Mpf::Stencil8,
         Tf::Bc1Unorm => Mpf::BC1_RGBA,
         Tf::Bc1UnormSrgb => Mpf::BC1_RGBA_sRGB,
         Tf::Bc2Unorm => Mpf::BC2_RGBA,

blade-graphics/src/metal/pipeline.rs

@@ -504,7 +504,9 @@ impl crate::traits::ShaderDevice for super::Context {
                 Some(ref ds) => {
                     let raw_format = super::map_texture_format(ds.format);
                     descriptor.setDepthAttachmentPixelFormat(raw_format);
-                    //TODO: descriptor.set_stencil_attachment_pixel_format(raw_format);
+                    if ds.format.aspects().contains(crate::TexelAspects::STENCIL) {
+                        descriptor.setStencilAttachmentPixelFormat(raw_format);
+                    }
 
                     let ds_descriptor = create_depth_stencil_desc(ds);
                     let raw = self

blade-graphics/src/metal/resource.rs

@@ -306,6 +306,7 @@ impl crate::traits::ResourceDevice for super::Context {
         }
         super::TextureView {
             raw: Retained::into_raw(object),
+            aspects: desc.format.aspects(),
         }
     }
 

blade-graphics/src/traits.rs

@@ -111,6 +111,7 @@ pub trait AccelerationStructureEncoder {
 pub trait RenderEncoder {
     fn set_scissor_rect(&mut self, rect: &super::ScissorRect);
     fn set_viewport(&mut self, viewport: &super::Viewport);
+    fn set_stencil_reference(&mut self, reference: u32);
 }
 
 pub trait PipelineEncoder {

blade-graphics/src/util.rs

@@ -74,6 +74,8 @@ impl super::TextureFormat {
             Self::Rg32Uint => uncompressed(8),
             Self::Rgba32Uint => uncompressed(16),
             Self::Depth32Float => uncompressed(4),
+            Self::Depth32FloatStencil8Uint => uncompressed(5),
+            Self::Stencil8Uint => uncompressed(1),
             Self::Bc1Unorm => cx_bc(8),
             Self::Bc1UnormSrgb => cx_bc(8),
             Self::Bc2Unorm => cx_bc(16),
@@ -97,6 +99,13 @@ impl super::TextureFormat {
     pub fn aspects(&self) -> super::TexelAspects {
         match *self {
             Self::Depth32Float => super::TexelAspects::DEPTH,
+
+            Self::Depth32FloatStencil8Uint => {
+                super::TexelAspects::DEPTH | super::TexelAspects::STENCIL
+            }
+
+            Self::Stencil8Uint => super::TexelAspects::STENCIL,
+
             _ => super::TexelAspects::COLOR,
         }
     }

blade-graphics/src/vulkan/command.rs

@@ -885,6 +885,16 @@ impl crate::traits::RenderEncoder for super::RenderCommandEncoder<'_> {
                 .cmd_set_viewport(self.cmd_buf.raw, 0, &[vk_viewport])
         };
     }
+
+    fn set_stencil_reference(&mut self, reference: u32) {
+        unsafe {
+            self.device.core.cmd_set_stencil_reference(
+                self.cmd_buf.raw,
+                vk::StencilFaceFlags::FRONT_AND_BACK,
+                reference,
+            )
+        };
+    }
 }
 
 #[hidden_trait::expose]
@@ -953,6 +963,16 @@ impl crate::traits::RenderEncoder for super::PipelineEncoder<'_, '_> {
                 .cmd_set_viewport(self.cmd_buf.raw, 0, &[vk_viewport])
         };
     }
+
+    fn set_stencil_reference(&mut self, reference: u32) {
+        unsafe {
+            self.device.core.cmd_set_stencil_reference(
+                self.cmd_buf.raw,
+                vk::StencilFaceFlags::FRONT_AND_BACK,
+                reference,
+            )
+        };
+    }
 }
 
 #[hidden_trait::expose]

blade-graphics/src/vulkan/mod.rs

@@ -552,6 +552,8 @@ fn map_texture_format(format: crate::TextureFormat) -> vk::Format {
         Tf::Rg32Uint => vk::Format::R32G32_UINT,
         Tf::Rgba32Uint => vk::Format::R32G32B32A32_UINT,
         Tf::Depth32Float => vk::Format::D32_SFLOAT,
+        Tf::Depth32FloatStencil8Uint => vk::Format::D32_SFLOAT_S8_UINT,
+        Tf::Stencil8Uint => vk::Format::S8_UINT,
         Tf::Bc1Unorm => vk::Format::BC1_RGBA_SRGB_BLOCK,
         Tf::Bc1UnormSrgb => vk::Format::BC1_RGBA_UNORM_BLOCK,
         Tf::Bc2Unorm => vk::Format::BC2_UNORM_BLOCK,

blade-graphics/src/vulkan/pipeline.rs

@@ -548,8 +548,8 @@ impl crate::traits::ShaderDevice for super::Context {
             }
             if ds.stencil != crate::StencilState::default() {
                 let s = &ds.stencil;
-                let front = map_stencil_face(&s.front, s.read_mask, s.write_mask);
-                let back = map_stencil_face(&s.back, s.read_mask, s.write_mask);
+                let front = map_stencil_face_state(&s.front, s.read_mask, s.write_mask);
+                let back = map_stencil_face_state(&s.back, s.read_mask, s.write_mask);
                 vk_depth_stencil = vk_depth_stencil
                     .stencil_test_enable(true)
                     .front(front)
@@ -705,7 +705,7 @@ fn map_stencil_op(op: crate::StencilOperation) -> vk::StencilOp {
     }
 }
 
-fn map_stencil_face(
+fn map_stencil_face_state(
     face: &crate::StencilFaceState,
     compare_mask: u32,
     write_mask: u32,