render-zig

render_data.zig (8305B)

---

 const std = @import("std");
 const gpu = @import("mach_gpu");
 
 const Buffer = @import("main.zig").Buffer;
 const Material = @import("material.zig");
 const Mesh = @import("mesh.zig");
 const Transform = @import("transform.zig");
 
 const RenderData = @This();
 
 pub const f32x3 = @Vector(3, f32);
 pub const f32x4 = @Vector(4, f32);
 pub const mat4 = [4]@Vector(4, f32);
 
 pub const InstanceData = struct {
     object_id: u32,
 };
 
 pub const ObjectData = struct {
     model_matrix: mat4,
     material: Material,
 };
 
 pub const RenderObject = struct {
     num_vertices: usize,
     num_indices: usize,
     transform: *Transform,
     material: Material = undefined,
     dirty: bool = false,
 
     pub fn instanceData(self: *const RenderObject) ObjectData {
         return .{
             .model_matrix = self.transform.matrix(),
             .material = self.material,
         };
     }
 
     pub fn setScale(self: *RenderObject, scale: f32) void {
         self.transform.scale = .{ scale, scale, scale };
         self.dirty = true;
     }
 
     pub fn setOffset(self: *RenderObject, offset: f32x3) void {
         self.transform.offset = offset;
         self.dirty = true;
     }
 
     pub fn setMaterial(self: *RenderObject, material: *const Material) void {
         self.material = material.*;
         self.dirty = true;
     }
 };
 
 device: *gpu.Device,
 queue: *gpu.Queue,
 
 positions: Buffer(f32x4),
 normals: Buffer(f32x4),
 tex_coords: Buffer(f32x4),
 tangents: Buffer(f32x4),
 bitangents: Buffer(f32x4),
 indices: Buffer(u32),
 
 // TODO: indirect buffers should be generated by pipelines
 indirect_mesh: Buffer([5]u32),
 indirect_line: Buffer([5]u32),
 
 instance_data: Buffer(InstanceData),
 object_data: Buffer(ObjectData),
 
 objects: std.ArrayList(RenderObject),
 
 pub const Options = struct {
     device: *gpu.Device,
     queue: *gpu.Queue,
     n_instances: u32,
     n_objects: u32,
     n_vertices: u32,
     n_indices: u32,
 };
 
 pub fn init(options: Options, allocator: std.mem.Allocator) RenderData {
     return .{
         .device = options.device,
         .queue = options.queue,
         .positions = Buffer(f32x4).init(
             options.n_vertices,
             options.device,
             .{ .vertex = true, .copy_dst = true },
             false,
         ),
         .normals = Buffer(f32x4).init(
             options.n_vertices,
             options.device,
             .{ .vertex = true, .copy_dst = true },
             false,
         ),
         .tex_coords = Buffer(f32x4).init(
             options.n_vertices,
             options.device,
             .{ .vertex = true, .copy_dst = true },
             false,
         ),
         .tangents = Buffer(f32x4).init(
             options.n_vertices,
             options.device,
             .{ .vertex = true, .copy_dst = true },
             false,
         ),
         .bitangents = Buffer(f32x4).init(
             options.n_vertices,
             options.device,
             .{ .vertex = true, .copy_dst = true },
             false,
         ),
         .indices = Buffer(u32).init(
             options.n_indices,
             options.device,
             .{ .index = true, .copy_dst = true },
             false,
         ),
         .instance_data = Buffer(InstanceData).init(
             options.n_instances,
             options.device,
             .{ .storage = true, .copy_dst = true },
             false,
         ),
         .object_data = Buffer(ObjectData).init(
             options.n_objects,
             options.device,
             .{ .storage = true, .copy_dst = true },
             false,
         ),
         .indirect_mesh = Buffer([5]u32).init(
             options.n_instances,
             options.device,
             .{ .indirect = true, .copy_dst = true },
             false,
         ),
         .indirect_line = Buffer([5]u32).init(
             options.n_instances,
             options.device,
             .{ .indirect = true, .copy_dst = true },
             false,
         ),
         .objects = std.ArrayList(RenderObject).init(allocator),
     };
 }
 
 pub fn addLines(
     self: *RenderData,
     positions: []const f32x4,
     indices: []const u32,
     transform: *Transform,
 ) !*RenderObject {
     const offset_p = try self.positions.allocWrite(positions, self.queue);
     const n: u32 = @intCast(positions.len);
     _ = try self.normals.alloc(n);
     _ = try self.tex_coords.alloc(n);
     _ = try self.tangents.alloc(n);
     _ = try self.bitangents.alloc(n);
     const offset_i = try self.indices.allocWrite(indices, self.queue);
 
     const object = RenderObject{
         .num_vertices = positions.len,
         .num_indices = indices.len,
         .transform = transform,
     };
     const object_data = [_]ObjectData{object.instanceData()};
     _ = try self.object_data.allocWrite(&object_data, self.queue);
 
     const instance_data = [_]InstanceData{
         .{ .object_id = @intCast(self.objects.items.len) },
     };
     const indirect_args = [_][5]u32{.{
         @intCast(indices.len),
         1,
         offset_i,
         offset_p,
         // lines are always one "piece", so we don't need to map from an
         // instance id to an object
         @intCast(self.objects.items.len),
     }};
     _ = try self.instance_data.allocWrite(&instance_data, self.queue);
     _ = try self.indirect_line.allocWrite(&indirect_args, self.queue);
 
     try self.objects.append(object);
     return &self.objects.items[self.objects.items.len - 1];
 }
 
 pub fn addMesh(
     self: *RenderData,
     transform: *Transform,
     mesh: *const Mesh,
     allocator: std.mem.Allocator,
 ) !*RenderObject {
     const offset_p = try self.positions.allocWrite(mesh.positions, self.queue);
     const n: u32 = @intCast(mesh.positions.len);
     if (mesh.normals.len > 0) {
         _ = try self.normals.allocWrite(mesh.normals, self.queue);
     } else {
         _ = try self.normals.alloc(n);
     }
     if (mesh.tex_coords.len > 0) {
         _ = try self.tex_coords.allocWrite(mesh.tex_coords, self.queue);
     } else {
         _ = try self.tex_coords.alloc(n);
     }
     _ = try self.tangents.allocWrite(mesh.tangents, self.queue);
     _ = try self.bitangents.allocWrite(mesh.bitangents, self.queue);
     const offset_i = try self.indices.allocWrite(mesh.indices, self.queue);
 
     const object = RenderObject{
         .num_vertices = mesh.positions.len,
         .num_indices = mesh.indices.len,
         .transform = transform,
     };
     const object_data = [_]ObjectData{object.instanceData()};
     _ = try self.object_data.allocWrite(&object_data, self.queue);
 
     if (mesh.descriptors != null) {
         const descriptors = mesh.descriptors.?;
         const instance_data = try allocator.alloc(InstanceData, descriptors.len);
         defer allocator.free(instance_data);
         const indirect_args = try allocator.alloc([5]u32, descriptors.len);
         defer allocator.free(indirect_args);
 
         var instance_id = self.indirect_mesh.count();
         for (descriptors, 0..) |descriptor, i| {
             instance_data[i] = .{ .object_id = @intCast(self.objects.items.len) };
             indirect_args[i] = .{
                 @intCast(descriptor.num_triangles * 3),
                 1,
                 offset_i + descriptor.offset,
                 offset_p,
                 instance_id,
             };
             instance_id += 1;
         }
         _ = try self.instance_data.allocWrite(instance_data, self.queue);
         _ = try self.indirect_mesh.allocWrite(indirect_args, self.queue);
     } else {
         const instance_data = [_]InstanceData{
             .{ .object_id = @intCast(self.objects.items.len) },
         };
         const indirect_args = [_][5]u32{.{
             @intCast(mesh.indices.len),
             1,
             offset_i,
             offset_p,
             self.indirect_mesh.count(),
         }};
         _ = try self.instance_data.allocWrite(&instance_data, self.queue);
         _ = try self.indirect_mesh.allocWrite(&indirect_args, self.queue);
     }
 
     try self.objects.append(object);
     return &self.objects.items[self.objects.items.len - 1];
 }
 
 pub fn updateObjects(self: *RenderData) void {
     for (self.objects.items, 0..) |*object, i| {
         if (!object.dirty) {
             continue;
         }
         const object_data = [_]ObjectData{object.instanceData()};
         self.object_data.write(&object_data, self.queue, @intCast(i));
         object.dirty = false;
     }
 }