From 2bda1508f166e453290e2030f350c61ee907e288 Mon Sep 17 00:00:00 2001
From: Wumpf <r_andreas2@web.de>
Date: Tue, 16 Mar 2021 03:33:44 +0100
Subject: [PATCH] [rs] Added example for conservative rasterization (#791)

* Example for conservative rasterization

* Update to wgpu-core/types 717c2d73e725c064a3c4696d6d7bdb428c9500b6

* conservative-raster example: fix wglsl const & readme

* conservative raster example: optional lines, no more interaction
---
 wgpu/Cargo.toml                               |   6 +-
 wgpu/examples/README.md                       |  69 ++--
 wgpu/examples/conservative-raster/README.md   |  20 ++
 wgpu/examples/conservative-raster/main.rs     | 316 ++++++++++++++++++
 .../conservative-raster/screenshot.png        | Bin 0 -> 19106 bytes
 .../triangle_and_lines.wgsl                   |  22 ++
 .../examples/conservative-raster/upscale.wgsl |  24 ++
 7 files changed, 420 insertions(+), 37 deletions(-)
 create mode 100644 wgpu/examples/conservative-raster/README.md
 create mode 100644 wgpu/examples/conservative-raster/main.rs
 create mode 100644 wgpu/examples/conservative-raster/screenshot.png
 create mode 100644 wgpu/examples/conservative-raster/triangle_and_lines.wgsl
 create mode 100644 wgpu/examples/conservative-raster/upscale.wgsl

diff --git a/wgpu/Cargo.toml b/wgpu/Cargo.toml
index 3de4f3289a..5ecb007aaf 100644
--- a/wgpu/Cargo.toml
+++ b/wgpu/Cargo.toml
@@ -26,20 +26,20 @@ webgl = ["wgc"]
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies.wgc]
 package = "wgpu-core"
 git = "https://github.com/gfx-rs/wgpu"
-rev = "5e15980bb53d2a5c24546dab640dcc72d211bd36"
+rev = "717c2d73e725c064a3c4696d6d7bdb428c9500b6"
 features = ["raw-window-handle", "cross"]
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.wgc]
 package = "wgpu-core"
 git = "https://github.com/gfx-rs/wgpu"
-rev = "5e15980bb53d2a5c24546dab640dcc72d211bd36"
+rev = "717c2d73e725c064a3c4696d6d7bdb428c9500b6"
 features = ["raw-window-handle", "cross"]
 optional = true
 
 [dependencies.wgt]
 package = "wgpu-types"
 git = "https://github.com/gfx-rs/wgpu"
-rev = "5e15980bb53d2a5c24546dab640dcc72d211bd36"
+rev = "717c2d73e725c064a3c4696d6d7bdb428c9500b6"
 
 [dependencies]
 arrayvec = "0.5"
diff --git a/wgpu/examples/README.md b/wgpu/examples/README.md
index e1740072e6..f2e178edbd 100644
--- a/wgpu/examples/README.md
+++ b/wgpu/examples/README.md
@@ -10,40 +10,41 @@ Notably, `capture` example shows rendering without a surface/window. It reads ba
 All framework-based examples render to the window.
 
 ## Feature matrix
-| Feature                | boids  | cube   | mipmap | msaa-line | shadow | skybox | texture-arrays | water  |
-| ---------------------- | ------ | ------ | ------ | --------- | ------ | ------ | -------------- | ------ |
-| WGSL shaders           | :star: | :star: | :star: | :star:    | :star: | :star: |                |        |
-| vertex attributes      | :star: | :star: |        | :star:    | :star: | :star: | :star:         | :star: |
-| instancing             | :star: |        |        |           |        |        |                |        |
-| lines and points       |        |        |        | :star:    |        |        |                |        |
-| dynamic buffer offsets |        |        |        |           | :star: |        |                |        |
-| implicit layout        |        |        | :star: |           |        |        |                |        |
-| sampled color textures | :star: | :star: | :star: |           |        | :star: | :star:         | :star: |
-| storage textures       | :star: |        |        |           |        |        |                |        |
-| binding array          |        |        |        |           |        |        | :star:         |        |
-| comparison samplers    |        |        |        |           | :star: |        |                |        |
-| subresource views      |        |        | :star: |           | :star: |        |                |        |
-| cubemaps               |        |        |        |           |        | :star: |                |        |
-| multisampling          |        |        |        | :star:    |        |        |                |        |
-| off-screen rendering   |        |        |        |           | :star: |        |                | :star: |
-| stencil testing        |        |        |        |           |        |        |                |        |
-| depth testing          |        |        |        |           | :star: | :star: |                | :star: |
-| depth biasing          |        |        |        |           | :star: |        |                |        |
-| read-only depth        |        |        |        |           |        |        |                | :star: |
-| blending               |        | :star: |        |           |        |        |                | :star: |
-| render bundles         |        |        |        | :star:    |        |        |                | :star: |
-| compute passes         | :star: |        |        |           |        |        |                |        |
-| *optional extensions*  |        |        |        |           |        |        | :star:         |        |
-| - binding indexing     |        |        |        |           |        |        | :star:         |        |
-| - push constants       |        |        |        |           |        |        | :star:         |        |
-| - depth clamping       |        |        |        |           | :star: |        |                |        |
-| - compressed textures  |        |        |        |           |        | :star: |                |        |
-| - polygon mode         |        | :star: |        |           |        |        |                |        |
-| - queries              |        |        | :star: |           |        |        |                |        |
-| *integrations*         |        |        |        |           |        |        |                |        |
-| - staging belt         |        |        |        |           |        |        |                |        |
-| - typed arena          |        |        |        |           |        |        |                |        |
-| - obj loading          |        |        |        |           |        | :star: |                |        |
+| Feature                      | boids  | cube   | mipmap | msaa-line | shadow | skybox | texture-arrays | water  | conservative-raster |
+| ---------------------------- | ------ | ------ | ------ | --------- | ------ | ------ | -------------- | ------ | ------------------- |
+| WGSL shaders                 | :star: | :star: | :star: | :star:    | :star: | :star: |                |        | :star:              |
+| vertex attributes            | :star: | :star: |        | :star:    | :star: | :star: | :star:         | :star: |                     |
+| instancing                   | :star: |        |        |           |        |        |                |        |                     |
+| lines and points             |        |        |        | :star:    |        |        |                |        | :star:              |
+| dynamic buffer offsets       |        |        |        |           | :star: |        |                |        |                     |
+| implicit layout              |        |        | :star: |           |        |        |                |        |                     |
+| sampled color textures       | :star: | :star: | :star: |           |        | :star: | :star:         | :star: | :star:              |
+| storage textures             | :star: |        |        |           |        |        |                |        |                     |
+| binding array                |        |        |        |           |        |        | :star:         |        |                     |
+| comparison samplers          |        |        |        |           | :star: |        |                |        |                     |
+| subresource views            |        |        | :star: |           | :star: |        |                |        |                     |
+| cubemaps                     |        |        |        |           |        | :star: |                |        |                     |
+| multisampling                |        |        |        | :star:    |        |        |                |        |                     |
+| off-screen rendering         |        |        |        |           | :star: |        |                | :star: | :star:              |
+| stencil testing              |        |        |        |           |        |        |                |        |                     |
+| depth testing                |        |        |        |           | :star: | :star: |                | :star: |                     |
+| depth biasing                |        |        |        |           | :star: |        |                |        |                     |
+| read-only depth              |        |        |        |           |        |        |                | :star: |                     |
+| blending                     |        | :star: |        |           |        |        |                | :star: |                     |
+| render bundles               |        |        |        | :star:    |        |        |                | :star: |                     |
+| compute passes               | :star: |        |        |           |        |        |                |        |                     |
+| *optional extensions*        |        |        |        |           |        |        | :star:         |        |                     |
+| - binding indexing           |        |        |        |           |        |        | :star:         |        |                     |
+| - push constants             |        |        |        |           |        |        | :star:         |        |                     |
+| - depth clamping             |        |        |        |           | :star: |        |                |        |                     |
+| - compressed textures        |        |        |        |           |        | :star: |                |        |                     |
+| - polygon mode               |        | :star: |        |           |        |        |                |        |                     |
+| - queries                    |        |        | :star: |           |        |        |                |        |                     |
+| - conservative rasterization |        |        |        |           |        |        |                |        | :star:              |
+| *integrations*               |        |        |        |           |        |        |                |        |                     |
+| - staging belt               |        |        |        |           |        |        |                |        |                     |
+| - typed arena                |        |        |        |           |        |        |                |        |                     |
+| - obj loading                |        |        |        |           |        | :star: |                |        |                     |
 
 ## Hacking
 
diff --git a/wgpu/examples/conservative-raster/README.md b/wgpu/examples/conservative-raster/README.md
new file mode 100644
index 0000000000..bd157319b5
--- /dev/null
+++ b/wgpu/examples/conservative-raster/README.md
@@ -0,0 +1,20 @@
+# conservative-raster
+
+This example shows how to render with conservative rasterization (native extension with limited support).
+
+When enabled, any pixel touched by a triangle primitive is rasterized.
+This is useful for various advanced techniques, most prominently for implementing realtime voxelization.
+
+The demonstration here is implemented by rendering a triangle to a low-resolution target and then upscaling it with nearest-neighbor filtering.
+The outlines of the triangle are then rendered in the original solution, using the same vertex shader as the triangle.
+Pixels only drawn with conservative rasterization enabled are depicted red.
+
+## To Run
+
+```
+cargo run --example conservative-raster
+```
+
+## Screenshots
+
+![Conservative-raster window](./screenshot.png)
diff --git a/wgpu/examples/conservative-raster/main.rs b/wgpu/examples/conservative-raster/main.rs
new file mode 100644
index 0000000000..e379520fab
--- /dev/null
+++ b/wgpu/examples/conservative-raster/main.rs
@@ -0,0 +1,316 @@
+#[path = "../framework.rs"]
+mod framework;
+
+use std::borrow::Cow;
+
+const RENDER_TARGET_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
+
+struct Example {
+    low_res_target: wgpu::TextureView,
+    bind_group_upscale: wgpu::BindGroup,
+
+    pipeline_triangle_conservative: wgpu::RenderPipeline,
+    pipeline_triangle_regular: wgpu::RenderPipeline,
+    pipeline_upscale: wgpu::RenderPipeline,
+    pipeline_lines: Option<wgpu::RenderPipeline>,
+    bind_group_layout_upscale: wgpu::BindGroupLayout,
+}
+
+impl Example {
+    fn create_low_res_target(
+        sc_desc: &wgpu::SwapChainDescriptor,
+        device: &wgpu::Device,
+        bind_group_layout_upscale: &wgpu::BindGroupLayout,
+    ) -> (wgpu::TextureView, wgpu::BindGroup) {
+        let texture_view = device
+            .create_texture(&wgpu::TextureDescriptor {
+                label: Some("Low Resolution Target"),
+                size: wgpu::Extent3d {
+                    width: sc_desc.width / 16,
+                    height: sc_desc.width / 16,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: RENDER_TARGET_FORMAT,
+                usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::RENDER_ATTACHMENT,
+            })
+            .create_view(&Default::default());
+
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Nearest Neighbor Sampler"),
+            mag_filter: wgpu::FilterMode::Nearest,
+            min_filter: wgpu::FilterMode::Nearest,
+            ..Default::default()
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("upscale bind group"),
+            layout: &bind_group_layout_upscale,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&texture_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::Sampler(&sampler),
+                },
+            ],
+        });
+
+        (texture_view, bind_group)
+    }
+}
+
+impl framework::Example for Example {
+    fn required_features() -> wgpu::Features {
+        wgpu::Features::CONSERVATIVE_RASTERIZATION
+    }
+    fn optional_features() -> wgpu::Features {
+        wgpu::Features::NON_FILL_POLYGON_MODE
+    }
+    fn init(
+        sc_desc: &wgpu::SwapChainDescriptor,
+        adapter: &wgpu::Adapter,
+        device: &wgpu::Device,
+        _queue: &wgpu::Queue,
+    ) -> Self {
+        let pipeline_layout_empty =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                bind_group_layouts: &[],
+                push_constant_ranges: &[],
+            });
+
+        let shader_triangle_and_lines =
+            device.create_shader_module(&wgpu::ShaderModuleDescriptor {
+                label: None,
+                source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!(
+                    "triangle_and_lines.wgsl"
+                ))),
+                flags: wgpu::ShaderFlags::all(),
+            });
+
+        let pipeline_triangle_conservative =
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some("Conservative Rasterization"),
+                layout: Some(&pipeline_layout_empty),
+                vertex: wgpu::VertexState {
+                    module: &shader_triangle_and_lines,
+                    entry_point: "vs_main",
+                    buffers: &[],
+                },
+                fragment: Some(wgpu::FragmentState {
+                    module: &shader_triangle_and_lines,
+                    entry_point: "fs_main_red",
+                    targets: &[RENDER_TARGET_FORMAT.into()],
+                }),
+                primitive: wgpu::PrimitiveState {
+                    conservative: true,
+                    ..Default::default()
+                },
+                depth_stencil: None,
+                multisample: wgpu::MultisampleState::default(),
+            });
+
+        let pipeline_triangle_regular =
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some("Regular Rasterization"),
+                layout: Some(&pipeline_layout_empty),
+                vertex: wgpu::VertexState {
+                    module: &shader_triangle_and_lines,
+                    entry_point: "vs_main",
+                    buffers: &[],
+                },
+                fragment: Some(wgpu::FragmentState {
+                    module: &shader_triangle_and_lines,
+                    entry_point: "fs_main_blue",
+                    targets: &[RENDER_TARGET_FORMAT.into()],
+                }),
+                primitive: wgpu::PrimitiveState::default(),
+                depth_stencil: None,
+                multisample: wgpu::MultisampleState::default(),
+            });
+
+        let pipeline_lines = if adapter
+            .features()
+            .contains(wgpu::Features::NON_FILL_POLYGON_MODE)
+        {
+            Some(
+                device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                    label: Some("Lines"),
+                    layout: Some(&pipeline_layout_empty),
+                    vertex: wgpu::VertexState {
+                        module: &shader_triangle_and_lines,
+                        entry_point: "vs_main",
+                        buffers: &[],
+                    },
+                    fragment: Some(wgpu::FragmentState {
+                        module: &shader_triangle_and_lines,
+                        entry_point: "fs_main_white",
+                        targets: &[sc_desc.format.into()],
+                    }),
+                    primitive: wgpu::PrimitiveState {
+                        polygon_mode: wgpu::PolygonMode::Line,
+                        topology: wgpu::PrimitiveTopology::LineStrip,
+                        ..Default::default()
+                    },
+                    depth_stencil: None,
+                    multisample: wgpu::MultisampleState::default(),
+                }),
+            )
+        } else {
+            None
+        };
+
+        let (pipeline_upscale, bind_group_layout_upscale) = {
+            let bind_group_layout =
+                device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                    label: Some("upscale bindgroup"),
+                    entries: &[
+                        wgpu::BindGroupLayoutEntry {
+                            binding: 0,
+                            visibility: wgpu::ShaderStage::FRAGMENT,
+                            ty: wgpu::BindingType::Texture {
+                                sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                                view_dimension: wgpu::TextureViewDimension::D2,
+                                multisampled: false,
+                            },
+                            count: None,
+                        },
+                        wgpu::BindGroupLayoutEntry {
+                            binding: 1,
+                            visibility: wgpu::ShaderStage::FRAGMENT,
+                            ty: wgpu::BindingType::Sampler {
+                                filtering: false,
+                                comparison: false,
+                            },
+                            count: None,
+                        },
+                    ],
+                });
+
+            let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                bind_group_layouts: &[&bind_group_layout],
+                push_constant_ranges: &[],
+            });
+            let shader = device.create_shader_module(&wgpu::ShaderModuleDescriptor {
+                label: None,
+                source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("upscale.wgsl"))),
+                flags: wgpu::ShaderFlags::all(),
+            });
+            (
+                device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                    label: Some("Upscale"),
+                    layout: Some(&pipeline_layout),
+                    vertex: wgpu::VertexState {
+                        module: &shader,
+                        entry_point: "vs_main",
+                        buffers: &[],
+                    },
+                    fragment: Some(wgpu::FragmentState {
+                        module: &shader,
+                        entry_point: "fs_main",
+                        targets: &[sc_desc.format.into()],
+                    }),
+                    primitive: wgpu::PrimitiveState::default(),
+                    depth_stencil: None,
+                    multisample: wgpu::MultisampleState::default(),
+                }),
+                bind_group_layout,
+            )
+        };
+
+        let (low_res_target, bind_group_upscale) =
+            Self::create_low_res_target(sc_desc, device, &bind_group_layout_upscale);
+
+        Self {
+            low_res_target,
+            bind_group_upscale,
+
+            pipeline_triangle_conservative,
+            pipeline_triangle_regular,
+            pipeline_upscale,
+            pipeline_lines,
+            bind_group_layout_upscale,
+        }
+    }
+
+    fn resize(
+        &mut self,
+        sc_desc: &wgpu::SwapChainDescriptor,
+        device: &wgpu::Device,
+        _queue: &wgpu::Queue,
+    ) {
+        let (low_res_target, bind_group_upscale) =
+            Self::create_low_res_target(sc_desc, device, &self.bind_group_layout_upscale);
+        self.low_res_target = low_res_target;
+        self.bind_group_upscale = bind_group_upscale;
+    }
+
+    fn update(&mut self, _event: winit::event::WindowEvent) {}
+
+    fn render(
+        &mut self,
+        frame: &wgpu::SwapChainTexture,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        _spawner: &framework::Spawner,
+    ) {
+        let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+            label: Some("primary"),
+        });
+
+        {
+            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("low resolution"),
+                color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
+                    attachment: &self.low_res_target,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                        store: true,
+                    },
+                }],
+                depth_stencil_attachment: None,
+            });
+
+            rpass.set_pipeline(&self.pipeline_triangle_conservative);
+            rpass.draw(0..3, 0..1);
+            rpass.set_pipeline(&self.pipeline_triangle_regular);
+            rpass.draw(0..3, 0..1);
+        }
+        {
+            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("full resolution"),
+                color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
+                    attachment: &frame.view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                        store: true,
+                    },
+                }],
+                depth_stencil_attachment: None,
+            });
+
+            rpass.set_pipeline(&self.pipeline_upscale);
+            rpass.set_bind_group(0, &self.bind_group_upscale, &[]);
+            rpass.draw(0..3, 0..1);
+
+            if let Some(pipeline_lines) = &self.pipeline_lines {
+                rpass.set_pipeline(pipeline_lines);
+                rpass.draw(0..4, 0..1);
+            }
+        }
+
+        queue.submit(Some(encoder.finish()));
+    }
+}
+
+fn main() {
+    framework::run::<Example>("conservative-raster");
+}
diff --git a/wgpu/examples/conservative-raster/screenshot.png b/wgpu/examples/conservative-raster/screenshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..e227e10e659f795267464910db71ba73c0cacd9b
GIT binary patch
literal 19106
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
X?3inBs0k$~LiRRJTk<w}{rbNE_o(rA

literal 0
HcmV?d00001

diff --git a/wgpu/examples/conservative-raster/triangle_and_lines.wgsl b/wgpu/examples/conservative-raster/triangle_and_lines.wgsl
new file mode 100644
index 0000000000..2f0331f04e
--- /dev/null
+++ b/wgpu/examples/conservative-raster/triangle_and_lines.wgsl
@@ -0,0 +1,22 @@
+[[stage(vertex)]]
+fn vs_main([[builtin(vertex_index)]] vertex_index: u32) -> [[builtin(position)]] vec4<f32> {
+    const i: i32 = i32(vertex_index % 3u);
+    const x: f32 = f32(i - 1) * 0.75;
+    const y: f32 = f32((i & 1) * 2 - 1) * 0.75 + x * 0.2 + 0.1;
+    return vec4<f32>(x, y, 0.0, 1.0);
+}
+
+[[stage(fragment)]]
+fn fs_main_red() -> [[location(0)]] vec4<f32> {
+    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
+}
+
+[[stage(fragment)]]
+fn fs_main_blue() -> [[location(0)]] vec4<f32> {
+    return vec4<f32>(0.13, 0.31, 0.85, 1.0); // cornflower blue in linear space
+}
+
+[[stage(fragment)]]
+fn fs_main_white() -> [[location(0)]] vec4<f32> {
+    return vec4<f32>(1.0, 1.0, 1.0, 1.0);
+}
\ No newline at end of file
diff --git a/wgpu/examples/conservative-raster/upscale.wgsl b/wgpu/examples/conservative-raster/upscale.wgsl
new file mode 100644
index 0000000000..ff1c00ebaa
--- /dev/null
+++ b/wgpu/examples/conservative-raster/upscale.wgsl
@@ -0,0 +1,24 @@
+struct VertexOutput {
+    [[builtin(position)]] position: vec4<f32>;
+    [[location(0)]] tex_coords: vec2<f32>;
+};
+
+[[stage(vertex)]]
+fn vs_main([[builtin(vertex_index)]] vertex_index: u32) -> VertexOutput {
+    const x: f32 = f32(i32(vertex_index & 1) << 2) - 1.0;
+    const y: f32 = f32(i32(vertex_index & 2) << 1) - 1.0;
+    var output: VertexOutput;
+    output.position = vec4<f32>(x, -y, 0.0, 1.0);
+    output.tex_coords = vec2<f32>(x + 1.0, y + 1.0) * 0.5;
+    return output;
+}
+
+[[group(0), binding(0)]]
+var r_color: texture_2d<f32>;
+[[group(0), binding(1)]]
+var r_sampler: sampler;
+
+[[stage(fragment)]]
+fn fs_main(in: VertexOutput) -> [[location(0)]] vec4<f32> {
+    return textureSample(r_color, r_sampler, in.tex_coords);
+}
\ No newline at end of file