render-zig

mesh_render_pipeline.zig (7323B)

---

 const std = @import("std");
 const gpu = @import("mach_gpu");
 
 const App = @import("main.zig").App;
 const Buffer = @import("main.zig").Buffer;
 const RenderData = @import("render_data.zig");
 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");
 const RenderPipeline = @import("render_pipeline.zig").RenderPipeline;
 
 const MeshRenderPipeline = @This();
 
 pub const Buffers = struct {
     positions: *const Buffer(f32x4),
     normals: *const Buffer(f32x4),
     tex_coords: *const Buffer(f32x4),
     tangents: *const Buffer(f32x4),
     bitangents: *const Buffer(f32x4),
     indices: *const Buffer(u32),
     instance_data: *const Buffer(RenderData.InstanceData),
     object_data: *const Buffer(RenderData.ObjectData),
     indirect: *const Buffer([5]u32),
 };
 
 gpu_pipeline: *gpu.RenderPipeline,
 buffers: Buffers,
 bind_group: *gpu.BindGroup,
 uniform_buffer: *gpu.Buffer,
 
 pub fn init(
     app: *App,
     buffers: Buffers,
     textures: *const Textures,
     comptime shader_path: []const u8,
 ) !MeshRenderPipeline {
     const src = @embedFile(shader_path);
 
     const module = app.device.createShaderModuleWGSL("mesh shader", src);
     defer module.release();
 
     const layouts = MeshRenderPipeline.bufferLayouts();
     const vertex = gpu.VertexState.init(.{
         .module = module,
         .entry_point = "vertex",
         .buffers = &layouts,
     });
 
     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 = module,
         .entry_point = "fragment",
         .targets = &.{color_target},
     });
 
     const buffer_descriptor = gpu.Buffer.Descriptor{
         .size = @sizeOf(UniformData),
         .usage = .{ .uniform = true, .copy_dst = true },
         .mapped_at_creation = .false,
     };
     const uniform_buffer = app.device.createBuffer(&buffer_descriptor);
 
     const bind_group_layout = MeshRenderPipeline.bindGroupLayout(app.device);
     const bind_group_descriptor = gpu.BindGroup.Descriptor.init(.{
         .layout = bind_group_layout,
         .entries = &.{
             gpu.BindGroup.Entry.buffer(0, buffers.object_data.data, 0, buffers.object_data.size),
             gpu.BindGroup.Entry.buffer(1, uniform_buffer, 0, @sizeOf(UniformData)),
             gpu.BindGroup.Entry.sampler(2, textures.sampler),
             gpu.BindGroup.Entry.textureView(3, textures.view),
             gpu.BindGroup.Entry.buffer(4, buffers.instance_data.data, 0, buffers.instance_data.size),
         },
     });
     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 = "mesh render pipeline",
         .fragment = &fragment,
         .layout = pipeline_layout,
         .depth_stencil = &.{
             .format = .depth24_plus,
             .depth_write_enabled = .true,
             .depth_compare = .less,
         },
         .vertex = vertex,
         .multisample = .{},
         .primitive = .{
             .topology = .triangle_list,
             .front_face = .ccw,
             .cull_mode = .back,
         },
     };
 
     return .{
         .gpu_pipeline = app.device.createRenderPipeline(&pipeline_descriptor),
         .buffers = buffers,
         .bind_group = bind_group,
         .uniform_buffer = uniform_buffer,
     };
 }
 
 fn bufferLayouts() [5]gpu.VertexBufferLayout {
     const positions = gpu.VertexBufferLayout.init(.{
         .array_stride = @sizeOf(f32x4),
         .step_mode = .vertex,
         .attributes = &.{
             .{ .format = .float32x4, .shader_location = 0, .offset = 0 },
         },
     });
     const normals = gpu.VertexBufferLayout.init(.{
         .array_stride = @sizeOf(f32x4),
         .step_mode = .vertex,
         .attributes = &.{
             .{ .format = .float32x3, .shader_location = 1, .offset = 0 },
         },
     });
     const tex_coords = gpu.VertexBufferLayout.init(.{
         .array_stride = @sizeOf(f32x4),
         .step_mode = .vertex,
         .attributes = &.{
             .{ .format = .float32x3, .shader_location = 2, .offset = 0 },
         },
     });
     const tangents = gpu.VertexBufferLayout.init(.{
         .array_stride = @sizeOf(f32x4),
         .step_mode = .vertex,
         .attributes = &.{
             .{ .format = .float32x3, .shader_location = 3, .offset = 0 },
         },
     });
     const bitangents = gpu.VertexBufferLayout.init(.{
         .array_stride = @sizeOf(f32x4),
         .step_mode = .vertex,
         .attributes = &.{
             .{ .format = .float32x3, .shader_location = 4, .offset = 0 },
         },
     });
     return .{ positions, normals, tex_coords, tangents, bitangents };
 }
 
 fn bindGroupLayout(device: *gpu.Device) *gpu.BindGroupLayout {
     const descriptor = gpu.BindGroupLayout.Descriptor.init(.{
         .entries = &.{
             gpu.BindGroupLayout.Entry.buffer(0, .{
                 .vertex = true,
                 .fragment = true,
             }, .read_only_storage, false, 0),
             gpu.BindGroupLayout.Entry.buffer(1, .{
                 .vertex = true,
                 .fragment = false,
             }, .uniform, false, 0),
             gpu.BindGroupLayout.Entry.sampler(2, .{
                 .vertex = false,
                 .fragment = true,
             }, .filtering),
             gpu.BindGroupLayout.Entry.texture(3, .{
                 .vertex = false,
                 .fragment = true,
             }, .float, .dimension_2d_array, false),
             gpu.BindGroupLayout.Entry.buffer(4, .{
                 .vertex = true,
                 .fragment = true,
             }, .read_only_storage, false, 0),
         },
     });
     return device.createBindGroupLayout(&descriptor);
 }
 
 pub fn frame(ptr: *anyopaque, pass: *gpu.RenderPassEncoder) void {
     const self: *MeshRenderPipeline = @ptrCast(@alignCast(ptr));
     pass.setPipeline(self.gpu_pipeline);
 
     pass.setVertexBuffer(0, self.buffers.positions.data, 0, self.buffers.positions.size);
     pass.setVertexBuffer(1, self.buffers.normals.data, 0, self.buffers.normals.size);
     pass.setVertexBuffer(2, self.buffers.tex_coords.data, 0, self.buffers.tex_coords.size);
     pass.setVertexBuffer(3, self.buffers.tangents.data, 0, self.buffers.tangents.size);
     pass.setVertexBuffer(4, self.buffers.bitangents.data, 0, self.buffers.bitangents.size);
     pass.setBindGroup(0, self.bind_group, null);
     pass.setIndexBuffer(self.buffers.indices.data, .uint32, 0, self.buffers.indices.size);
 
     const num_indirect = self.buffers.indirect.count();
     for (0..num_indirect) |idx| {
         const offset = idx * self.buffers.indirect.attrib_size;
         pass.drawIndexedIndirect(self.buffers.indirect.data, offset);
     }
 }
 
 pub fn pipeline(self: *MeshRenderPipeline) RenderPipeline {
     return .{
         .ptr = self,
         .frameFn = frame,
     };
 }