render-zig

commit e480b0f0bf1c8a42199140025c933d9dd5b7eaba
parent bc9c9cb43fb639a35195dc334ce1ae3a68ecdebc
Author: Christian Ermann <christianermann@gmail.com>
Date:   Fri, 26 Apr 2024 19:36:50 -0400

Render triangle

Diffstat:
M
build.zig
 | 
16
+++++++++-------
M
build.zig.zon
 | 
2
++
M
src/main.zig
 | 
78
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------

3 files changed, 82 insertions(+), 14 deletions(-)
diff --git a/build.zig b/build.zig
@@ -37,18 +37,20 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
-    const glfw_dep = b.dependency("mach-glfw", .{
+    if (b.lazyDependency("mach-glfw", .{
         .target = target,
         .optimize = optimize,
-    });
-    exe.root_module.addImport("mach_glfw", glfw_dep.module("mach-glfw"));
+    })) |glfw_dep| {
+        exe.root_module.addImport("mach_glfw", glfw_dep.module("mach-glfw"));
+    }
 
-    const gpu_dep = b.dependency("mach-gpu", .{
+    if (b.lazyDependency("mach-gpu", .{
         .target = target,
         .optimize = optimize,
-    });
-    exe.root_module.addImport("mach_gpu", gpu_dep.module("mach-gpu"));
-    try gpu.link(gpu_dep.builder, exe, &exe.root_module, .{});
+    })) |gpu_dep| {
+        exe.root_module.addImport("mach_gpu", gpu_dep.module("mach-gpu"));
+        try gpu.link(gpu_dep.builder, exe, &exe.root_module, .{});
+    }
 
     // This declares intent for the executable to be installed into the
     // standard location when the user invokes the "install" step (the default
diff --git a/build.zig.zon b/build.zig.zon
@@ -18,10 +18,12 @@
         .@"mach-glfw" = .{
             .url = "https://pkg.machengine.org/mach-glfw/e57190c095097810980703aa26d4f0669a21dbab.tar.gz",
             .hash = "12205a32c8e6ca23c68191b1e95405d2bd5f8e3055cba1c8ce0738d673ef49aef913",
+            .lazy = true,
         },
         .@"mach-gpu" = .{
             .url = "https://pkg.machengine.org/mach-gpu/528dad0823dafeae5d474c88cc658b091bf2e605.tar.gz",
             .hash = "1220fe2e555ca66741539bc0f97769b2513c5e609c968d27eb8997f577a1d195f048",
+            .lazy = true,
         },
     },
     .paths = .{
diff --git a/src/main.zig b/src/main.zig
@@ -41,13 +41,6 @@ fn glfwDetectBackendOptions() glfw.BackendOptions {
     };
 }
 
-const AppSwapChain = struct {
-    gpu_swap_chain: ?*gpu.SwapChain,
-    format: gpu.Texture.Format,
-    current_descriptor: gpu.SwapChain.Descriptor,
-    target_descriptor: gpu.SwapChain.Descriptor,
-};
-
 const App = struct {
     window: glfw.Window,
     instance: *gpu.Instance,
@@ -56,6 +49,7 @@ const App = struct {
     device: *gpu.Device,
     queue: *gpu.Queue,
     swap_chain: *AppSwapChain,
+    pipeline: DefaultRenderPipeline,
 
     pub fn init(app: *App, allocator: std.mem.Allocator) !void {
         try gpu.Impl.init(allocator, .{});
@@ -103,6 +97,9 @@ const App = struct {
 
         app.swap_chain = try app.createSwapChain(allocator);
         app.window.setUserPointer(app.swap_chain);
+
+        app.pipeline = undefined;
+        app.pipeline.init(app);
     }
 
     pub fn deinit(app: *App) void {
@@ -229,6 +226,9 @@ const App = struct {
                 const pass = encoder.beginRenderPass(&render_pass_info);
                 defer pass.release();
                 defer pass.end();
+
+                pass.setPipeline(app.pipeline.pipeline);
+                pass.draw(3, 1, 0, 0);
             }
 
             {
@@ -241,6 +241,70 @@ const App = struct {
     }
 };
 
+const AppSwapChain = struct {
+    gpu_swap_chain: ?*gpu.SwapChain,
+    format: gpu.Texture.Format,
+    current_descriptor: gpu.SwapChain.Descriptor,
+    target_descriptor: gpu.SwapChain.Descriptor,
+};
+
+const DefaultRenderPipeline = struct {
+    pipeline: *gpu.RenderPipeline,
+
+    pub fn init(self: *DefaultRenderPipeline, app: *App) void {
+        const vs =
+            \\ @vertex fn main(
+            \\     @builtin(vertex_index) VertexIndex : u32
+            \\ ) -> @builtin(position) vec4<f32> {
+            \\     var pos = array<vec2<f32>, 3>(
+            \\         vec2<f32>( 0.0,  0.5),
+            \\         vec2<f32>(-0.5, -0.5),
+            \\         vec2<f32>( 0.5, -0.5)
+            \\     );
+            \\     return vec4<f32>(pos[VertexIndex], 0.0, 1.0);
+            \\ }
+        ;
+        const vs_module = app.device.createShaderModuleWGSL("default vertex shader", vs);
+        defer vs_module.release();
+
+        const vertex = gpu.VertexState{
+            .module = vs_module,
+            .entry_point = "main",
+        };
+
+        const fs =
+            \\ @fragment fn main() -> @location(0) vec4<f32> {
+            \\     return vec4<f32>(1.0, 0.0, 0.0, 1.0);
+            \\ }
+        ;
+        const fs_module = app.device.createShaderModuleWGSL("default fragment shader", fs);
+        defer fs_module.release();
+
+        const blend: gpu.BlendState = .{};
+        const color_target = gpu.ColorTargetState{
+            .format = app.swap_chain.format,
+            .blend = &blend,
+            .write_mask = gpu.ColorWriteMaskFlags.all,
+        };
+        const fragment = gpu.FragmentState.init(.{
+            .module = fs_module,
+            .entry_point = "main",
+            .targets = &.{color_target},
+        });
+
+        const pipeline_descriptor = gpu.RenderPipeline.Descriptor{
+            .label = "default render pipeline",
+            .fragment = &fragment,
+            .layout = null,
+            .depth_stencil = null,
+            .vertex = vertex,
+            .multisample = .{},
+            .primitive = .{},
+        };
+        self.pipeline = app.device.createRenderPipeline(&pipeline_descriptor);
+    }
+};
+
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();