[render] render pipeline/first triangle

Author: ARessegetesStery

crates/eqx_window/src/window.rs

@@ -1,5 +1,5 @@
 use eqx_app::prelude::Module;
-use wgpu::{MemoryHints, RenderPassDescriptor};
+use wgpu::{MemoryHints, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor};
 
 use winit::{
     event::*,
@@ -10,16 +10,21 @@ use winit::{
 
 use winit::window::Window as WInitWindow;
 
+const VS_MAIN: &str = "vs_main";
+const FS_MAIN: &str = "fs_main";
+
 struct State<'a> {
     surface: wgpu::Surface<'a>,
     device: wgpu::Device,
     queue: wgpu::Queue,
     config: wgpu::SurfaceConfiguration,
     size: winit::dpi::PhysicalSize<u32>,
     window: &'a WInitWindow,
+    render_pipeline: wgpu::RenderPipeline,
 }
 
 impl<'a> State<'a> {
+    /// Accepts only mesh with counter-clockwise winding
     async fn new(window: &'a WInitWindow) -> State<'a> {
         let size = window.inner_size();
 
@@ -72,13 +77,66 @@ impl<'a> State<'a> {
             desired_maximum_frame_latency: 2,
         };
 
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("TrigShader"),
+            source: wgpu::ShaderSource::Wgsl(
+                include_str!("../../../shaders/trig/shader.wgsl").into(),
+            ),
+        });
+
+        let render_pipeline_layout =
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: Some("RenderPipelineLayout"),
+                bind_group_layouts: &[],
+                push_constant_ranges: &[],
+            });
+
+        let render_pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
+            label: Some("RenderPipeline"),
+            layout: Some(&render_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: Some(VS_MAIN),
+                buffers: &[],
+                compilation_options: wgpu::PipelineCompilationOptions::default(),
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: Some(FS_MAIN),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: config.format,
+                    blend: Some(wgpu::BlendState::REPLACE),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+                compilation_options: wgpu::PipelineCompilationOptions::default(),
+            }),
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+                front_face: wgpu::FrontFace::Ccw,
+                cull_mode: Some(wgpu::Face::Back),
+                polygon_mode: wgpu::PolygonMode::Fill,
+                unclipped_depth: false,
+                conservative: false,
+            },
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState {
+                count: 1,                         // TODO: check multi-sampling
+                mask: !0,                         // enable all the mask bits
+                alpha_to_coverage_enabled: false, // TODO: check anti-aliasing
+            },
+            multiview: None,
+            cache: None,
+        });
+
         Self {
             surface,
             device,
             queue,
             config,
             size,
             window,
+            render_pipeline,
         }
     }
 
@@ -95,7 +153,7 @@ impl<'a> State<'a> {
         }
     }
 
-    fn fully_processed(&self, event: &WindowEvent) -> bool {
+    fn process_input(&self, event: &WindowEvent) -> bool {
         false
     }
 
@@ -115,7 +173,7 @@ impl<'a> State<'a> {
             });
 
         {
-            let _render_pass = encoder.begin_render_pass(&RenderPassDescriptor {
+            let mut render_pass = encoder.begin_render_pass(&RenderPassDescriptor {
                 label: Some("RenderPass"),
                 color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                     view: &view,
@@ -134,6 +192,9 @@ impl<'a> State<'a> {
                 timestamp_writes: None,
                 occlusion_query_set: None,
             });
+
+            render_pass.set_pipeline(&self.render_pipeline);
+            render_pass.draw(0..3, 0..1)
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));
@@ -143,6 +204,7 @@ impl<'a> State<'a> {
     }
 }
 
+// TODO: refactor this class, so that more utilities (e.g. `Input`) can be integrated
 pub struct WindowDisplay {}
 
 impl Default for WindowDisplay {
@@ -165,7 +227,7 @@ impl Module for WindowDisplay {
                     ref event,
                     window_id,
                 } if window_id == state.window.id() => {
-                    if (!state.fully_processed(event)) {
+                    if (!state.process_input(event)) {
                         match event {
                             WindowEvent::CloseRequested
                             | WindowEvent::KeyboardInput {

shaders/trig/shader.wgsl

@@ -0,0 +1,24 @@
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) vert_pos: vec3<f32>,
+}
+
+@vertex
+fn vs_main(
+    @builtin(vertex_index) in_vertex_index: u32
+) -> 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;
+    return out;
+}
+
+@fragment
+fn fs_main(
+    in: VertexOutput
+) -> @location(0) vec4<f32> {
+    return vec4<f32>(0.3, 0.2, 0.1, 1.0);
+}
+