Out-of-pass image clears

reftests/local.ron

@@ -25,6 +25,11 @@
 			jobs: ["copy-image-buf"],
 			expect: Buffer("buffer.output", [52, 53, 54, 55]),
 		),
+		"clear-image": (
+			features: (bits: 0),
+			jobs: ["clear-image"],
+			expect: ImageRow("image.output", 0, [128, 128, 128, 128]),
+		),
 		"blit-image": (
 			features: (bits: 0),
 			jobs: ["blit-image"],

reftests/scenes/transfer.ron

@@ -140,6 +140,20 @@
 				],
 			),
 		),
+		"clear-image": Transfer(
+			ClearImage(
+				image: "image.output",
+				color: Float((0.5, 0.5, 0.5, 0.5)),
+				depth_stencil: (0.0, 0),
+				ranges: [
+					(
+						aspects: (bits: 0x1), //COLOR
+						levels: (start: 0, end: 1),
+						layers: (start: 0, end: 1),
+					),
+				],
+			),
+		),
 		"blit-image": Transfer(
 			BlitImage(
 				src: "image.input",

src/backend/dx12/src/command.rs

@@ -899,7 +899,7 @@ impl com::RawCommandBuffer<Backend> for CommandBuffer {
         self.reset();
     }
 
-    fn begin_render_pass_raw<T>(
+    fn begin_render_pass<T>(
         &mut self,
         render_pass: &n::RenderPass,
         framebuffer: &n::Framebuffer,
@@ -1105,38 +1105,33 @@ impl com::RawCommandBuffer<Backend> for CommandBuffer {
         }
     }
 
-    fn clear_color_image_raw(
+    fn clear_image<T>(
         &mut self,
         image: &n::Image,
         _: image::Layout,
-        range: image::SubresourceRange,
-        value: com::ClearColorRaw,
-    ) {
-        assert_eq!(range.aspects, Aspects::COLOR);
-        assert_eq!(range.levels, 0 .. 1); //TODO
-        for layer in range.layers {
-            let rtv = image.clear_cv[layer as usize];
-            self.clear_render_target_view(rtv, value, &[]);
-        }
-    }
-
-    fn clear_depth_stencil_image_raw(
-        &mut self,
-        image: &n::Image,
-        _layout: image::Layout,
-        range: image::SubresourceRange,
-        value: com::ClearDepthStencilRaw,
-    ) {
-        assert!((Aspects::DEPTH | Aspects::STENCIL).contains(range.aspects));
-        assert_eq!(range.levels, 0 .. 1); //TODO
-        for layer in range.layers {
-            if range.aspects.contains(Aspects::DEPTH) {
-                let dsv = image.clear_dv[layer as usize];
-                self.clear_depth_stencil_view(dsv, Some(value.depth), None, &[]);
-            }
-            if range.aspects.contains(Aspects::STENCIL) {
-                let dsv = image.clear_sv[layer as usize];
-                self.clear_depth_stencil_view(dsv, None, Some(value.stencil as _), &[]);
+        color: com::ClearColorRaw,
+        depth_stencil: com::ClearDepthStencilRaw,
+        subresource_ranges: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<image::SubresourceRange>,
+    {
+        for subresource_range in subresource_ranges {
+            let sub = subresource_range.borrow();
+            assert_eq!(sub.levels, 0 .. 1); //TODO
+            for layer in sub.layers.clone() {
+                if sub.aspects.contains(Aspects::COLOR) {
+                    let rtv = image.clear_cv[layer as usize];
+                    self.clear_render_target_view(rtv, color, &[]);
+                }
+                if sub.aspects.contains(Aspects::DEPTH) {
+                    let dsv = image.clear_dv[layer as usize];
+                    self.clear_depth_stencil_view(dsv, Some(depth_stencil.depth), None, &[]);
+                }
+                if sub.aspects.contains(Aspects::STENCIL) {
+                    let dsv = image.clear_sv[layer as usize];
+                    self.clear_depth_stencil_view(dsv, None, Some(depth_stencil.stencil as _), &[]);
+                }
             }
         }
     }

src/backend/empty/src/lib.rs

@@ -434,23 +434,17 @@ impl command::RawCommandBuffer<Backend> for RawCommandBuffer {
         unimplemented!()
     }
 
-    fn clear_color_image_raw(
+    fn clear_image<T>(
         &mut self,
         _: &(),
         _: image::Layout,
-        _: image::SubresourceRange,
         _: command::ClearColorRaw,
-    ) {
-        unimplemented!()
-    }
-
-    fn clear_depth_stencil_image_raw(
-        &mut self,
-        _: &(),
-        _: image::Layout,
-        _: image::SubresourceRange,
         _: command::ClearDepthStencilRaw,
-    ) {
+        _: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<image::SubresourceRange>,
+    {
         unimplemented!()
     }
 
@@ -533,7 +527,7 @@ impl command::RawCommandBuffer<Backend> for RawCommandBuffer {
     }
 
 
-    fn begin_render_pass_raw<T>(
+    fn begin_render_pass<T>(
         &mut self,
         _: &(),
         _: &(),

src/backend/gl/src/command.rs

@@ -542,7 +542,7 @@ impl command::RawCommandBuffer<Backend> for RawCommandBuffer {
         unimplemented!()
     }
 
-    fn begin_render_pass_raw<T>(
+    fn begin_render_pass<T>(
         &mut self,
         render_pass: &n::RenderPass,
         framebuffer: &n::FrameBuffer,
@@ -609,13 +609,17 @@ impl command::RawCommandBuffer<Backend> for RawCommandBuffer {
         // TODO
     }
 
-    fn clear_color_image_raw(
+    fn clear_image<T>(
         &mut self,
         image: &n::Image,
         _: image::Layout,
-        _range: image::SubresourceRange,
-        value: command::ClearColorRaw,
-    ) {
+        color: command::ClearColorRaw,
+        _depth_stencil: command::ClearDepthStencilRaw,
+        _subresource_ranges: T,
+    ) where
+        T: IntoIterator,
+        T::Item: Borrow<image::SubresourceRange>,
+    {
         // TODO: clearing strategies
         //  1.  < GL 3.0 / GL ES 3.0: glClear
         //  2.  < GL 4.4: glClearBuffer
@@ -635,22 +639,12 @@ impl command::RawCommandBuffer<Backend> for RawCommandBuffer {
         match image.channel {
             ChannelType::Unorm | ChannelType::Inorm | ChannelType::Ufloat |
             ChannelType::Float | ChannelType::Srgb | ChannelType::Uscaled |
-            ChannelType::Iscaled => self.push_cmd(Command::ClearBufferColorF(0, unsafe { value.float32 })),
-            ChannelType::Uint => self.push_cmd(Command::ClearBufferColorU(0, unsafe { value.uint32 })),
-            ChannelType::Int => self.push_cmd(Command::ClearBufferColorI(0, unsafe { value.int32 })),
+            ChannelType::Iscaled => self.push_cmd(Command::ClearBufferColorF(0, unsafe { color.float32 })),
+            ChannelType::Uint => self.push_cmd(Command::ClearBufferColorU(0, unsafe { color.uint32 })),
+            ChannelType::Int => self.push_cmd(Command::ClearBufferColorI(0, unsafe { color.int32 })),
         }
     }
 
-    fn clear_depth_stencil_image_raw(
-        &mut self,
-        _image: &n::Image,
-        _: image::Layout,
-        _range: image::SubresourceRange,
-        _value: command::ClearDepthStencilRaw,
-    ) {
-        unimplemented!()
-    }
-
     fn clear_attachments<T, U>(&mut self, _: T, _: U)
     where
         T: IntoIterator,

src/backend/metal/Cargo.toml

@@ -22,7 +22,7 @@ name = "gfx_backend_metal"
 gfx-hal = { path = "../../hal", version = "0.1" }
 log = "0.4"
 winit = { version = "0.13", optional = true }
-metal-rs = "0.9.2"
+metal-rs = "0.9.3"
 foreign-types = "0.3"
 objc = "0.2"
 block = "0.1"

src/backend/metal/shaders/commands.metal

@@ -1,6 +1,44 @@
 #include <metal_stdlib>
 using namespace metal;
 
+// -------------- Image Clears -------------- //
+
+typedef struct {
+    float4 coords [[attribute(0)]];
+} ClearAttributes;
+
+typedef struct {
+    float4 position [[position]];
+    uint layer [[render_target_array_index]];
+} ClearVertexData;
+
+vertex ClearVertexData vs_clear(ClearAttributes in [[stage_in]]) {
+    float4 pos = { 0.0, 0.0, 0.0f, 1.0f };
+    pos.xy = in.coords.xy * 2.0 - 1.0;
+    return ClearVertexData { pos, uint(in.coords.z) };
+}
+
+fragment float4 ps_blit_float(
+    ClearVertexData in [[stage_in]],
+    constant float4 &value [[ buffer(0) ]]
+) {
+  return value;
+}
+
+fragment int4 ps_blit_int(
+    ClearVertexData in [[stage_in]],
+    constant int4 &value [[ buffer(0) ]]
+) {
+  return value;
+}
+
+fragment uint4 ps_blit_uint(
+    ClearVertexData in [[stage_in]],
+    constant uint4 &value [[ buffer(0) ]]
+) {
+  return value;
+}
+
 // -------------- Image Blits -------------- //
 
 typedef struct {