Use Push Constants instead of an Uniform Buffer for the window viewport (#1)

* testing push constants

* works

* dunno

* dunno

* some improvements

* cleanup

Author: LukasBombach

src/app.rs

@@ -17,7 +17,6 @@ impl<'window> ApplicationHandler for App<'window> {
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
         if self.window.is_none() {
             let win_attr = Window::default_attributes().with_title("wgpu winit example");
-            // use Arc.
             let window = Arc::new(
                 event_loop
                     .create_window(win_attr)
@@ -37,13 +36,11 @@ impl<'window> ApplicationHandler for App<'window> {
     ) {
         match event {
             WindowEvent::CloseRequested => {
-                // macOS err: https://github.com/rust-windowing/winit/issues/3668
-                // This will be fixed as winit 0.30.1.
                 event_loop.exit();
             }
             WindowEvent::Resized(size) => {
                 if let Some(gpu) = self.gpu.as_mut() {
-                    gpu.resize(size.width, size.height);
+                    gpu.set_size(size.width, size.height);
                 }
             }
             WindowEvent::RedrawRequested => {

src/gpu.rs

@@ -1,3 +1,4 @@
+use bytemuck::bytes_of;
 use bytemuck::cast_slice;
 use bytemuck::Pod;
 use bytemuck::Zeroable;
@@ -8,12 +9,6 @@ use wgpu::MemoryHints::Performance;
 use wgpu::ShaderSource;
 use winit::window::Window;
 
-#[repr(C)]
-#[derive(Debug, Copy, Clone, Pod, Zeroable)]
-struct Uniforms {
-    screen_size: [f32; 2],
-}
-
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Pod, Zeroable)]
 struct Instance {
@@ -41,9 +36,7 @@ pub struct Gpu<'window> {
     num_indices: u32,
     instance_buffer: wgpu::Buffer,
     instance_count: u32,
-
-    uniform_buffer: wgpu::Buffer,
-    uniform_bind_group: wgpu::BindGroup,
+    viewport: [f32; 2],
 }
 
 impl<'window> Gpu<'window> {
@@ -52,16 +45,22 @@ impl<'window> Gpu<'window> {
     }
 
     pub async fn new_async(window: Arc<Window>) -> Gpu<'window> {
+        /*
+         * window
+         */
+
         let size = window.inner_size();
         let width = size.width.max(1);
         let height = size.height.max(1);
+        let viewport = [width as f32, height as f32];
 
         /*
          * wgpu
          */
 
         let instance = wgpu::Instance::default();
         let surface = instance.create_surface(Arc::clone(&window)).unwrap();
+        let push_const_size = std::mem::size_of::<[f32; 2]>() as u32;
 
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
@@ -76,9 +75,11 @@ impl<'window> Gpu<'window> {
             .request_device(
                 &wgpu::DeviceDescriptor {
                     label: None,
-                    required_features: wgpu::Features::empty(),
-                    required_limits: wgpu::Limits::downlevel_webgl2_defaults()
-                        .using_resolution(adapter.limits()),
+                    required_features: wgpu::Features::PUSH_CONSTANTS,
+                    required_limits: wgpu::Limits {
+                        max_push_constant_size: push_const_size,
+                        ..Default::default()
+                    },
                     memory_hints: Performance,
                 },
                 None,
@@ -90,6 +91,15 @@ impl<'window> Gpu<'window> {
 
         surface.configure(&device, &config);
 
+        /*
+         * push constants
+         */
+
+        let push_constant_range = wgpu::PushConstantRange {
+            stages: wgpu::ShaderStages::VERTEX,
+            range: 0..push_const_size,
+        };
+
         /*
          * rects
          */
@@ -100,17 +110,6 @@ impl<'window> Gpu<'window> {
             Instance::new(700.0, 100.0, 200.0, 200.0),
         ];
 
-        /*
-         * instances
-         */
-
-        let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Instance Buffer"),
-            contents: cast_slice(&rects),
-            usage: wgpu::BufferUsages::VERTEX,
-        });
-        let instance_count = rects.len() as u32;
-
         /*
          * vertices
          */
@@ -138,42 +137,15 @@ impl<'window> Gpu<'window> {
         let num_indices = indices.len() as u32;
 
         /*
-         * uniforms
+         * instances
          */
 
-        let uniforms = Uniforms {
-            screen_size: [width as f32, height as f32],
-        };
-
-        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-            label: Some("Uniform Buffer"),
-            contents: cast_slice(&[uniforms]),
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-        });
-
-        let uniform_bind_group_layout =
-            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                label: Some("Uniform Bind Group Layout"),
-                entries: &[wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::VERTEX,
-                    ty: wgpu::BindingType::Buffer {
-                        ty: wgpu::BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: None,
-                    },
-                    count: None,
-                }],
-            });
-
-        let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Uniform Bind Group"),
-            layout: &uniform_bind_group_layout,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: uniform_buffer.as_entire_binding(),
-            }],
+        let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Instance Buffer"),
+            contents: cast_slice(&rects),
+            usage: wgpu::BufferUsages::VERTEX,
         });
+        let instance_count = rects.len() as u32;
 
         /*
          * shader
@@ -191,8 +163,8 @@ impl<'window> Gpu<'window> {
         let render_pipeline_layout =
             device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                 label: Some("Render Pipeline Layout"),
-                bind_group_layouts: &[&uniform_bind_group_layout],
-                push_constant_ranges: &[],
+                bind_group_layouts: &[],
+                push_constant_ranges: &[push_constant_range],
             });
 
         let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
@@ -202,6 +174,7 @@ impl<'window> Gpu<'window> {
                 module: &shader,
                 entry_point: Some("vs_main"),
                 buffers: &[
+                    // Vertex buffer
                     wgpu::VertexBufferLayout {
                         array_stride: std::mem::size_of::<[f32; 2]>() as wgpu::BufferAddress,
                         step_mode: wgpu::VertexStepMode::Vertex,
@@ -211,6 +184,7 @@ impl<'window> Gpu<'window> {
                             format: wgpu::VertexFormat::Float32x2,
                         }],
                     },
+                    // Instance buffer
                     wgpu::VertexBufferLayout {
                         array_stride: std::mem::size_of::<Instance>() as wgpu::BufferAddress,
                         step_mode: wgpu::VertexStepMode::Instance,
@@ -238,16 +212,6 @@ impl<'window> Gpu<'window> {
             }),
             primitive: wgpu::PrimitiveState {
                 topology: wgpu::PrimitiveTopology::TriangleList,
-                // strip_index_format: None,
-                // front_face: wgpu::FrontFace::Ccw,
-                // cull_mode: Some(wgpu::Face::Back),
-                // // Setting this to anything other than Fill requires Features::POLYGON_MODE_LINE
-                // // or Features::POLYGON_MODE_POINT
-                // polygon_mode: wgpu::PolygonMode::Fill,
-                // // Requires Features::DEPTH_CLIP_CONTROL
-                // unclipped_depth: false,
-                // // Requires Features::CONSERVATIVE_RASTERIZATION
-                // conservative: false,
                 ..Default::default()
             },
             depth_stencil: None,
@@ -267,31 +231,23 @@ impl<'window> Gpu<'window> {
             num_indices,
             instance_buffer,
             instance_count,
-            uniform_buffer,
-            uniform_bind_group,
+            viewport,
         }
     }
 
-    pub fn resize(&mut self, width: u32, height: u32) {
-        self.device.poll(wgpu::Maintain::Wait);
-
+    pub fn set_size(&mut self, width: u32, height: u32) {
         let width = width.max(1);
         let height = height.max(1);
 
         self.config.width = width;
         self.config.height = height;
-
         self.surface.configure(&self.device, &self.config);
-
-        let surface_uniform = Uniforms {
-            screen_size: [width as f32, height as f32],
-        };
-
-        self.queue
-            .write_buffer(&self.uniform_buffer, 0, cast_slice(&[surface_uniform]));
+        self.viewport = [width as f32, height as f32];
     }
 
     pub fn draw(&mut self) {
+        self.device.poll(wgpu::Maintain::Wait);
+
         let frame = self
             .surface
             .get_current_texture()
@@ -314,12 +270,7 @@ impl<'window> Gpu<'window> {
                     view: &view,
                     resolve_target: None,
                     ops: wgpu::Operations {
-                        load: wgpu::LoadOp::Clear(wgpu::Color {
-                            r: 0.104,
-                            g: 0.133,
-                            b: 0.212,
-                            a: 1.0,
-                        }),
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                         store: wgpu::StoreOp::Store,
                     },
                 })],
@@ -329,7 +280,7 @@ impl<'window> Gpu<'window> {
             });
 
             rpass.set_pipeline(&self.render_pipeline);
-            rpass.set_bind_group(0, &self.uniform_bind_group, &[]);
+            rpass.set_push_constants(wgpu::ShaderStages::VERTEX, 0, bytes_of(&self.viewport));
             rpass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
             rpass.set_vertex_buffer(1, self.instance_buffer.slice(..));
             rpass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);

src/shader.wgsl

@@ -1,5 +1,4 @@
-@group(0) @binding(0) 
-var<uniform> view_size: vec2<f32>;
+var<push_constant> viewport: vec2<f32>;
 
 struct VertexOutput {
     @builtin(position) clip_position: vec4<f32>,
@@ -21,8 +20,8 @@ fn vs_main(
     );
 
     let pos = inst_pos + vert_pos * inst_size;
-    let ndc_x = (pos.x / view_size.x) * 2.0 - 1.0;
-    let ndc_y = 1.0 - (pos.y / view_size.y) * 2.0;
+    let ndc_x = (pos.x / viewport.x) * 2.0 - 1.0;
+    let ndc_y = 1.0 - (pos.y / viewport.y) * 2.0;
 
     var output: VertexOutput;
     output.clip_position = vec4<f32>(ndc_x, ndc_y, 1.0, 1.0);