[render] test vertex/index buffer

Author: ARessegetesStery

crates/eqx_window/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 winit = { version = "0.29", features = ["rwh_05"] }
+bytemuck = { version = "1.22", features = ["derive"] }
 cgmath = "0.18"
 log = "0.4"
 wgpu = "24.0"

crates/eqx_window/src/lib.rs

@@ -1,3 +1,4 @@
+mod primitives;
 mod window;
 
 pub mod prelude {

crates/eqx_window/src/primitives.rs

@@ -0,0 +1,44 @@
+#[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Zeroable, bytemuck::Pod)]
+pub struct Vertex {
+    position: [f32; 3],
+    color: [f32; 3],
+}
+
+impl Vertex {
+    const ATTRIBUTE: [wgpu::VertexAttribute; 2] =
+        wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3];
+
+    pub fn descriptor() -> wgpu::VertexBufferLayout<'static> {
+        wgpu::VertexBufferLayout {
+            array_stride: size_of::<Self>() as wgpu::BufferAddress,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &Self::ATTRIBUTE,
+        }
+    }
+}
+
+pub const TEST_VERTICES: &[Vertex] = &[
+    Vertex {
+        position: [-0.0868241, 0.49240386, 0.0],
+        color: [0.5, 0.0, 0.5],
+    }, // A
+    Vertex {
+        position: [-0.49513406, 0.06958647, 0.0],
+        color: [0.5, 0.0, 0.5],
+    }, // B
+    Vertex {
+        position: [-0.21918549, -0.44939706, 0.0],
+        color: [0.5, 0.0, 0.5],
+    }, // C
+    Vertex {
+        position: [0.35966998, -0.3473291, 0.0],
+        color: [0.5, 0.0, 0.5],
+    }, // D
+    Vertex {
+        position: [0.44147372, 0.2347359, 0.0],
+        color: [0.5, 0.0, 0.5],
+    }, // E
+];
+
+pub const TEST_INDICES: &[u16] = &[0, 1, 4, 1, 2, 4, 2, 3, 4];

crates/eqx_window/src/window.rs

@@ -1,3 +1,7 @@
+use wgpu::util::{BufferInitDescriptor, DeviceExt};
+
+use crate::primitives::{Vertex, TEST_INDICES, TEST_VERTICES};
+
 use eqx_app::prelude::Module;
 
 use winit::{
@@ -20,6 +24,8 @@ struct State<'a> {
     size: winit::dpi::PhysicalSize<u32>,
     window: &'a WInitWindow,
     render_pipeline: wgpu::RenderPipeline,
+    vertex_buffer: wgpu::Buffer,
+    index_buffer: wgpu::Buffer,
 }
 
 impl<'a> State<'a> {
@@ -96,7 +102,7 @@ impl<'a> State<'a> {
             vertex: wgpu::VertexState {
                 module: &shader,
                 entry_point: Some(VS_MAIN),
-                buffers: &[],
+                buffers: &[Vertex::descriptor()],
                 compilation_options: wgpu::PipelineCompilationOptions::default(),
             },
             fragment: Some(wgpu::FragmentState {
@@ -128,6 +134,18 @@ impl<'a> State<'a> {
             cache: None,
         });
 
+        let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
+            label: Some("VertexBuffer"),
+            contents: bytemuck::cast_slice(TEST_VERTICES),
+            usage: wgpu::BufferUsages::VERTEX,
+        });
+
+        let index_buffer = device.create_buffer_init(&BufferInitDescriptor {
+            label: Some("IndexBuffer"),
+            contents: bytemuck::cast_slice(TEST_INDICES),
+            usage: wgpu::BufferUsages::INDEX,
+        });
+
         Self {
             surface,
             device,
@@ -136,6 +154,8 @@ impl<'a> State<'a> {
             size,
             window,
             render_pipeline,
+            vertex_buffer,
+            index_buffer,
         }
     }
 
@@ -193,7 +213,9 @@ impl<'a> State<'a> {
             });
 
             render_pass.set_pipeline(&self.render_pipeline);
-            render_pass.draw(0..3, 0..1)
+            render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
+            render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
+            render_pass.draw_indexed(0..TEST_INDICES.len() as u32, 0, 0..1);
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));

shaders/trig/shader.wgsl

@@ -1,24 +1,27 @@
+struct VertexInput {
+    @location(0) vert_pos: vec3<f32>,
+    @location(1) vert_color: vec3<f32>,
+}
+
 struct VertexOutput {
     @builtin(position) clip_position: vec4<f32>,
-    @location(0) vert_pos: vec3<f32>,
+    @location(0) color: vec3<f32>,
 }
 
 @vertex
 fn vs_main(
-    @builtin(vertex_index) in_vertex_index: u32
+    model: VertexInput
 ) -> VertexOutput {
     var out: VertexOutput;
-    let x = f32(1 - i32(in_vertex_index)) * 0.5;
-    let y = f32(i32(in_vertex_index & 1u) * 2 - 1) * 0.5;
-    out.clip_position = vec4<f32>(x, y, 0.0, 1.0);
-    out.vert_pos = out.clip_position.xyz;
+    out.clip_position = vec4<f32>(model.vert_pos, 1.0);
+    out.color = model.vert_color;
     return out;
 }
 
 @fragment
 fn fs_main(
     in: VertexOutput
 ) -> @location(0) vec4<f32> {
-    return vec4<f32>(0.3, 0.2, 0.1, 1.0);
+    return vec4<f32>(in.color, 1.0);
 }