render-zig

render_pipeline.zig (8913B)

---

 const std = @import("std");
 const gpu = @import("mach_gpu");
 
 const App = @import("main.zig").App;
 const MeshBuffer = @import("main.zig").MeshBuffer;
 const UniformData = @import("main.zig").UniformData;
 const f32x4 = @import("main.zig").f32x4;
 const mat4 = @import("main.zig").mat4;
 const CubeMap = @import("cubemap.zig");
 const Textures = @import("textures.zig");
 
 pub const RenderPipeline = struct {
     ptr: *anyopaque,
     frameFn: *const fn (ptr: *anyopaque, pass: *gpu.RenderPassEncoder) void,
 
     pub fn frame(self: *const RenderPipeline, pass: *gpu.RenderPassEncoder) void {
         return self.frameFn(self.ptr, pass);
     }
 };
 
 pub const TriangleRenderPipeline = struct {
     gpu_pipeline: *gpu.RenderPipeline,
 
     pub fn init(app: *App) TriangleRenderPipeline {
         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("example 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("example 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 = "example render pipeline",
             .fragment = &fragment,
             .layout = null,
             .depth_stencil = null,
             .vertex = vertex,
             .multisample = .{},
             .primitive = .{},
         };
 
         return .{
             .gpu_pipeline = app.device.createRenderPipeline(&pipeline_descriptor),
         };
     }
 
     pub fn frame(ptr: *anyopaque, pass: *gpu.RenderPassEncoder) void {
         const self: *TriangleRenderPipeline = @ptrCast(@alignCast(ptr));
         pass.setPipeline(self.gpu_pipeline);
         pass.draw(3, 1, 0, 0);
     }
 
     pub fn pipeline(self: *TriangleRenderPipeline) RenderPipeline {
         return .{
             .ptr = self,
             .frameFn = frame,
         };
     }
 };
 
 pub const SkyBoxRenderPipeline = struct {
     gpu_pipeline: *gpu.RenderPipeline,
     uniform_buffer: *gpu.Buffer,
     bind_group: *gpu.BindGroup,
 
     pub const UniformData = struct {
         inv_view: mat4,
         inv_proj: mat4,
     };
 
     pub fn init(app: *App, cube_map: CubeMap) SkyBoxRenderPipeline {
         const vs =
             \\ struct VertexOutput {
             \\     @builtin(position) clip_position: vec4<f32>,
             \\     @location(0) position: vec4<f32>,
             \\ };
             \\
             \\ @vertex fn main(
             \\     @builtin(vertex_index) VertexIndex : u32
             \\ ) -> VertexOutput {
             \\     var pos = array<vec2<f32>, 3>(
             \\         vec2<f32>(-1,  3),
             \\         vec2<f32>(-1, -1),
             \\         vec2<f32>( 3, -1),
             \\     );
             \\     let vtx_pos = vec4<f32>(pos[VertexIndex], 1, 1);
             \\     return VertexOutput(vtx_pos, vtx_pos);
             \\ }
         ;
         const vs_module = app.device.createShaderModuleWGSL("skybox vertex shader", vs);
         defer vs_module.release();
 
         const vertex = gpu.VertexState{
             .module = vs_module,
             .entry_point = "main",
         };
 
         const fs =
             \\ @group(0) @binding(0)
             \\ var<uniform> uniform_data: UniformData;
             \\ struct UniformData {
             \\     inv_view: mat4x4<f32>,
             \\     inv_proj: mat4x4<f32>,
             \\ };
             \\
             \\ @group(0) @binding(1) var cubemap_sampler: sampler;
             \\ @group(0) @binding(2) var cubemap_texture: texture_cube<f32>;
             \\
             \\ struct VertexOutput {
             \\     @builtin(position) clip_position: vec4<f32>,
             \\     @location(0) position: vec4<f32>,
             \\ };
             \\
             \\ @fragment fn main(in: VertexOutput) -> @location(0) vec4<f32> {
             \\     let inv_cam = uniform_data.inv_view * uniform_data.inv_proj;
             \\     let pos_world = inv_cam * in.position;
             \\     let dir = normalize(pos_world.xyz / pos_world.w) * vec3<f32>(-1, 1, 1);
             \\     let sample = textureSample(cubemap_texture, cubemap_sampler, dir);
             \\     //return vec4<f32>((dir + 1) * 0.5, 1.0);
             \\     return sample;
             \\ }
         ;
         const fs_module = app.device.createShaderModuleWGSL("skybox fragment shader", fs);
         defer fs_module.release();
 
         const color_target = gpu.ColorTargetState{
             .format = app.swap_chain.format,
             .blend = &.{},
             .write_mask = gpu.ColorWriteMaskFlags.all,
         };
         const fragment = gpu.FragmentState.init(.{
             .module = fs_module,
             .entry_point = "main",
             .targets = &.{color_target},
         });
 
         const buffer_descriptor = gpu.Buffer.Descriptor{
             .size = @sizeOf(SkyBoxRenderPipeline.UniformData),
             .usage = .{ .uniform = true, .copy_dst = true },
             .mapped_at_creation = .false,
         };
         const uniform_buffer = app.device.createBuffer(&buffer_descriptor);
 
         const bind_group_layout = SkyBoxRenderPipeline.bindGroupLayout(app.device);
         const bind_group_descriptor = gpu.BindGroup.Descriptor.init(.{
             .layout = bind_group_layout,
             .entries = &.{
                 gpu.BindGroup.Entry.buffer(0, uniform_buffer, 0, @sizeOf(SkyBoxRenderPipeline.UniformData)),
                 gpu.BindGroup.Entry.sampler(1, cube_map.sampler),
                 gpu.BindGroup.Entry.textureView(2, cube_map.view),
             },
         });
         const bind_group = app.device.createBindGroup(&bind_group_descriptor);
 
         const pipeline_layout_descriptor = gpu.PipelineLayout.Descriptor.init(.{
             .bind_group_layouts = &.{bind_group_layout},
         });
         const pipeline_layout = app.device.createPipelineLayout(&pipeline_layout_descriptor);
         defer pipeline_layout.release();
 
         const pipeline_descriptor = gpu.RenderPipeline.Descriptor{
             .label = "skybox render pipeline",
             .fragment = &fragment,
             .layout = pipeline_layout,
             .depth_stencil = &.{
                 .format = .depth24_plus,
                 .depth_write_enabled = .true,
                 .depth_compare = .less_equal,
             },
             .vertex = vertex,
             .multisample = .{},
             .primitive = .{},
         };
 
         return .{
             .gpu_pipeline = app.device.createRenderPipeline(&pipeline_descriptor),
             .uniform_buffer = uniform_buffer,
             .bind_group = bind_group,
         };
     }
 
     fn bindGroupLayout(device: *gpu.Device) *gpu.BindGroupLayout {
         const descriptor = gpu.BindGroupLayout.Descriptor.init(.{
             .entries = &.{
                 gpu.BindGroupLayout.Entry.buffer(0, .{
                     .vertex = false,
                     .fragment = true,
                 }, .uniform, false, 0),
                 gpu.BindGroupLayout.Entry.sampler(1, .{
                     .vertex = false,
                     .fragment = true,
                 }, .filtering),
                 gpu.BindGroupLayout.Entry.texture(2, .{
                     .vertex = false,
                     .fragment = true,
                 }, .float, .dimension_cube, false),
             },
         });
         return device.createBindGroupLayout(&descriptor);
     }
 
     pub fn frame(ptr: *anyopaque, pass: *gpu.RenderPassEncoder) void {
         const self: *SkyBoxRenderPipeline = @ptrCast(@alignCast(ptr));
         pass.setPipeline(self.gpu_pipeline);
         pass.setBindGroup(0, self.bind_group, null);
         pass.draw(3, 1, 0, 0);
     }
 
     pub fn pipeline(self: *SkyBoxRenderPipeline) RenderPipeline {
         return .{
             .ptr = self,
             .frameFn = frame,
         };
     }
 };