render-zig

main.zig (20114B)

---

 const std = @import("std");
 const glfw = @import("mach_glfw");
 const gpu = @import("mach_gpu");
 const builtin = @import("builtin");
 
 const RenderPass = @import("render_pass.zig").RenderPass;
 const ForwardScreenPass = @import("render_pass.zig").ForwardScreenPass;
 const RenderPipeline = @import("render_pipeline.zig").RenderPipeline;
 const MeshRenderPipeline = @import("mesh_render_pipeline.zig");
 const LineRenderPipeline = @import("line_render_pipeline.zig");
 const SkyBoxRenderPipeline = @import("render_pipeline.zig").SkyBoxRenderPipeline;
 const CubeMap = @import("cubemap.zig");
 const Textures = @import("textures.zig");
 const Material = @import("material.zig");
 const Mesh = @import("mesh.zig");
 const RenderData = @import("render_data.zig");
 
 const Camera = @import("camera.zig");
 const input = @import("input.zig");
 const Transform = @import("transform.zig");
 
 const load_obj = @import("load_obj.zig");
 
 const objc = @import("objc_message.zig");
 
 fn glfwErrorCallback(error_code: glfw.ErrorCode, description: [:0]const u8) void {
     std.log.err("glfw: {}: {s}\n", .{ error_code, description });
 }
 
 inline fn gpuErrorCallback(_: void, error_type: gpu.ErrorType, message: [*:0]const u8) void {
     switch (error_type) {
         .validation => std.log.err("gpu: validation error: {s}\n", .{message}),
         .out_of_memory => std.log.err("gpu: out of memory: {s}\n", .{message}),
         .device_lost => std.log.err("gpu: device lost: {s}\n", .{message}),
         .unknown => std.log.err("gpu: unknown error: {s}\n", .{message}),
         else => unreachable,
     }
     std.process.exit(1);
 }
 
 fn gpuDetectBackendType() !gpu.BackendType {
     return .metal;
 }
 
 fn glfwWindowHintsForBackend(backend: gpu.BackendType) glfw.Window.Hints {
     return switch (backend) {
         else => .{
             .client_api = .no_api,
         },
     };
 }
 
 fn glfwDetectBackendOptions() glfw.BackendOptions {
     if (builtin.target.isDarwin()) return .{ .cocoa = true };
     return switch (builtin.target.os.tag) {
         .windows => .{ .win32 = true },
         .linux => .{ .x11 = true, .wayland = true },
         else => .{},
     };
 }
 
 pub const App = struct {
     window: glfw.Window,
     instance: *gpu.Instance,
     surface: *gpu.Surface,
     adapter: *gpu.Adapter,
     device: *gpu.Device,
     queue: *gpu.Queue,
     swap_chain: *AppSwapChain,
     depth_texture: *gpu.Texture,
     depth_texture_view: *gpu.TextureView,
     inputs: std.ArrayList(input.UserInput),
 
     pub fn init(app: *App, allocator: std.mem.Allocator) !void {
         try gpu.Impl.init(allocator, .{});
 
         glfw.setErrorCallback(glfwErrorCallback);
         if (!glfw.init(.{})) {
             const msg = "failed to initialize GLFW: {?s}";
             std.log.err(msg, .{glfw.getErrorString()});
             std.process.exit(1);
         }
 
         const backend_type = try gpuDetectBackendType();
         const hints = glfwWindowHintsForBackend(backend_type);
         const title = "Hello, World!";
         app.window = glfw.Window.create(640, 480, title, null, null, hints) orelse {
             const msg = "failed to create GLFW window: {?s}";
             std.log.err(msg, .{glfw.getErrorString()});
             std.process.exit(1);
         };
 
         app.instance = gpu.createInstance(null) orelse {
             std.log.err("failed to create GPU instance", .{});
             std.process.exit(1);
         };
 
         app.surface = try app.createSurfaceForWindow();
         app.adapter = try app.createAdapter();
 
         var props = std.mem.zeroes(gpu.Adapter.Properties);
         app.adapter.getProperties(&props);
         std.debug.print("found {s} backend on {s} adapter: {s}, {s}\n", .{
             props.backend_type.name(),
             props.adapter_type.name(),
             props.name,
             props.driver_description,
         });
 
         const features = [_]gpu.FeatureName{
             gpu.FeatureName.indirect_first_instance,
         };
         const device_descriptor = gpu.Device.Descriptor{
             .required_features_count = 1,
             .required_features = &features,
             .device_lost_callback = undefined,
             .device_lost_userdata = undefined,
         };
         app.device = app.adapter.createDevice(&device_descriptor) orelse {
             std.log.err("failed to create GPU device", .{});
             std.process.exit(1);
         };
         app.device.setUncapturedErrorCallback({}, gpuErrorCallback);
 
         app.queue = app.device.getQueue();
 
         app.swap_chain = try app.createSwapChain(allocator);
 
         app.inputs = std.ArrayList(input.UserInput).init(allocator);
         app.window.setKeyCallback(glfwKeyCallback);
 
         app.window.setUserPointer(app);
 
         const framebuffer_size = app.window.getFramebufferSize();
         app.depth_texture = app.device.createTexture(&gpu.Texture.Descriptor{
             .size = gpu.Extent3D{
                 .width = framebuffer_size.width,
                 .height = framebuffer_size.height,
             },
             .format = .depth24_plus,
             .usage = .{
                 .render_attachment = true,
             },
         });
         app.depth_texture_view = app.depth_texture.createView(&gpu.TextureView.Descriptor{
             .format = .depth24_plus,
             .dimension = .dimension_2d,
             .array_layer_count = 1,
             .mip_level_count = 1,
         });
     }
 
     pub fn deinit(app: *App) void {
         app.window.destroy();
         glfw.terminate();
         app.inputs.deinit();
     }
 
     fn createSurfaceForWindow(app: *App) !*gpu.Surface {
         const glfw_options = comptime glfwDetectBackendOptions();
         const glfw_native = glfw.Native(glfw_options);
         if (glfw_options.cocoa) {
             const ns_window = glfw_native.getCocoaWindow(app.window);
             const ns_view = msgSend(ns_window, "contentView", .{}, *anyopaque);
 
             // Create a CAMetalLayer that covers the whole window.
             msgSend(ns_view, "setWantsLayer:", .{true}, void);
             const layer = msgSend(objc.objc_getClass("CAMetalLayer"), "layer", .{}, ?*anyopaque) orelse {
                 @panic("failed to create Metal layer");
             };
             msgSend(ns_view, "setLayer:", .{layer}, void);
 
             // Use retina if the window was created with retina support.
             const scale_factor = msgSend(ns_window, "backingScaleFactor", .{}, f64);
             msgSend(layer, "setContentsScale:", .{scale_factor}, void);
 
             return app.instance.createSurface(&gpu.Surface.Descriptor{
                 .next_in_chain = .{
                     .from_metal_layer = &.{ .layer = layer },
                 },
             });
         }
     }
 
     fn createAdapter(app: *App) !*gpu.Adapter {
         const RequestAdapterResponse = struct {
             status: gpu.RequestAdapterStatus,
             adapter: ?*gpu.Adapter,
             message: ?[*:0]const u8,
 
             pub inline fn callback(
                 context: *@This(),
                 status: gpu.RequestAdapterStatus,
                 adapter: ?*gpu.Adapter,
                 message: ?[*:0]const u8,
             ) void {
                 context.* = @This(){
                     .status = status,
                     .adapter = adapter,
                     .message = message,
                 };
             }
         };
 
         var response: RequestAdapterResponse = undefined;
         app.instance.requestAdapter(&gpu.RequestAdapterOptions{
             .compatible_surface = app.surface,
             .power_preference = .undefined,
             .force_fallback_adapter = .false,
         }, &response, RequestAdapterResponse.callback);
         if (response.status != .success) {
             const msg = "failed to create GPU adapter: {s}\n";
             std.debug.print(msg, .{response.message.?});
             std.process.exit(1);
         }
         return response.adapter.?;
     }
 
     fn createSwapChain(app: *App, allocator: std.mem.Allocator) !*AppSwapChain {
         const format = .bgra8_unorm;
         const framebuffer_size = app.window.getFramebufferSize();
         const descriptor = gpu.SwapChain.Descriptor{
             .label = "basic swap chain",
             .usage = .{ .render_attachment = true },
             .format = format,
             .width = framebuffer_size.width,
             .height = framebuffer_size.height,
             .present_mode = .fifo,
         };
         const swap_chain = try allocator.create(AppSwapChain);
         swap_chain.* = .{
             .gpu_swap_chain = null,
             .format = format,
             .current_descriptor = descriptor,
             .target_descriptor = descriptor,
         };
         return swap_chain;
     }
 
     fn getCurrentSwapChain(app: *App) *gpu.SwapChain {
         const sc = app.swap_chain;
         const not_exists = sc.gpu_swap_chain == null;
         const changed = !std.meta.eql(sc.current_descriptor, sc.target_descriptor);
         if (not_exists or changed) {
             sc.gpu_swap_chain = app.device.createSwapChain(app.surface, &sc.target_descriptor);
             sc.current_descriptor = sc.target_descriptor;
         }
         return sc.gpu_swap_chain.?;
     }
 
     pub fn frame(app: *App, passes: []const RenderPass) !void {
         app.device.tick();
         const swap_chain = app.getCurrentSwapChain();
         defer swap_chain.present();
 
         const back_buffer_view = swap_chain.getCurrentTextureView().?;
         defer back_buffer_view.release();
 
         {
             const encoder = app.device.createCommandEncoder(null);
             defer encoder.release();
             for (passes) |pass| {
                 pass.frame(encoder, back_buffer_view);
             }
 
             {
                 var command = encoder.finish(null);
                 defer command.release();
 
                 app.queue.submit(&[_]*gpu.CommandBuffer{command});
             }
         }
     }
 
     pub fn keyCallback(app: *App, args: input.KeyCallbackArgs) void {
         for (app.inputs.items) |user_input| {
             user_input.keyCallback(args);
         }
     }
 };
 
 const AppSwapChain = struct {
     gpu_swap_chain: ?*gpu.SwapChain,
     format: gpu.Texture.Format,
     current_descriptor: gpu.SwapChain.Descriptor,
     target_descriptor: gpu.SwapChain.Descriptor,
 };
 
 pub const f32x3 = @Vector(3, f32);
 pub const f32x4 = @Vector(4, f32);
 pub const mat4 = [4]@Vector(4, f32);
 
 pub const UniformData = struct {
     pw_camera: f32x3,
     view_matrix: mat4,
     proj_matrix: mat4,
 };
 
 pub fn Buffer(comptime T: type) type {
     return struct {
         const Self = @This();
         const attrib_size = @sizeOf(T);
 
         data: *gpu.Buffer,
         size: u32,
         offset: u32,
         attrib_size: u32,
 
         pub fn init(
             max_attribs: u32,
             device: *gpu.Device,
             usage: gpu.Buffer.UsageFlags,
             mapped_at_creation: bool,
         ) Self {
             std.log.info("buffer init: {} {}", .{ max_attribs, T });
             const size = max_attribs * attrib_size;
             const descriptor = gpu.Buffer.Descriptor{
                 .size = size,
                 .usage = usage,
                 .mapped_at_creation = gpu.Bool32.from(mapped_at_creation),
             };
             const data = device.createBuffer(&descriptor);
             return .{
                 .data = data,
                 .size = size,
                 .offset = 0,
                 .attrib_size = attrib_size,
             };
         }
 
         pub fn alloc(self: *Self, n_attribs: u32) !u32 {
             const size = n_attribs * attrib_size;
             const offset_start = self.offset;
             const offset_after = self.offset + size;
             std.log.info("buffer alloc: {} {}", .{ n_attribs, T });
             if (offset_after > self.size) {
                 std.log.err("buffer out of memory", .{});
                 return error.BufferEmpty;
             }
             self.offset = offset_after;
             return offset_start / attrib_size;
         }
 
         pub fn write(
             self: *Self,
             data_slice: anytype,
             queue: *gpu.Queue,
             offset: u32,
         ) void {
             queue.writeBuffer(self.data, offset * attrib_size, data_slice);
         }
 
         pub fn allocWrite(
             self: *Self,
             data_slice: anytype,
             queue: *gpu.Queue,
         ) !u32 {
             const offset = try self.alloc(@intCast(data_slice.len));
             queue.writeBuffer(self.data, offset * attrib_size, data_slice);
             return offset;
         }
 
         pub fn count(self: *const Self) u32 {
             return self.offset / attrib_size;
         }
     };
 }
 
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();
 
     var app: App = undefined;
     try app.init(allocator);
     defer app.deinit();
 
     var textures = Textures.init(allocator, app.device);
 
     //const images = .{
     //    .pos_x = "cube/cube-pos-x.png",
     //    .neg_x = "cube/cube-neg-x.png",
     //    .pos_y = "cube/cube-pos-y.png",
     //    .neg_y = "cube/cube-neg-y.png",
     //    .pos_z = "cube/cube-pos-z.png",
     //    .neg_z = "cube/cube-neg-z.png",
     //};
     const images = .{
         .pos_x = "alps_field_4k/px.png",
         .neg_x = "alps_field_4k/nx.png",
         .pos_y = "alps_field_4k/py.png",
         .neg_y = "alps_field_4k/ny.png",
         .pos_z = "alps_field_4k/pz.png",
         .neg_z = "alps_field_4k/nz.png",
     };
     const cube_map = try CubeMap.init(images, allocator, &app);
 
     var camera = Camera{};
     camera.logParams();
 
     var render_data = RenderData.init(
         .{
             .device = app.device,
             .queue = app.queue,
             .n_instances = 2000,
             .n_objects = 500,
             .n_vertices = 60000,
             .n_indices = 60000,
         },
         allocator,
     );
 
     var mesh = try load_obj.loadFile(.{
         .allocator = allocator,
         .path = "Cottage_Clean/cottage.obj",
     });
 
     var bunny_mesh = try load_obj.loadFile(.{
         .allocator = allocator,
         .path = "teapot.obj",
     });
 
     const optimizeMesh = @import("forsyth_optimize.zig").optimize;
     try optimizeMesh(allocator, &mesh, 32, .{});
     try optimizeMesh(allocator, &bunny_mesh, 32, .{});
 
     const buildClusters = @import("meshlets.zig").buildClusters;
     const cluster_mesh = try buildClusters(allocator, &mesh, 64, 126);
     const cbunny_mesh = try buildClusters(allocator, &bunny_mesh, 64, 126);
     std.log.info("num clusters: {}", .{cluster_mesh.descriptors.?.len});
 
     const generateUVSphere = @import("uvsphere.zig").generateUVSphere;
     const sphere_mesh = try generateUVSphere(16, 16, allocator);
 
     const generateCube = @import("cube.zig").generateCube;
     const cube_mesh = try generateCube(1, allocator);
 
     const generateCubeSphere = @import("cubesphere.zig").generateCubeSphere;
     const cubesphere_mesh = try generateCubeSphere(16, allocator);
 
     var rp = try MeshRenderPipeline.init(
         &app,
         .{
             .positions = &render_data.positions,
             .normals = &render_data.normals,
             .tex_coords = &render_data.tex_coords,
             .tangents = &render_data.tangents,
             .bitangents = &render_data.bitangents,
             .indices = &render_data.indices,
             .instance_data = &render_data.instance_data,
             .object_data = &render_data.object_data,
             .indirect = &render_data.indirect_mesh,
         },
         &textures,
         "shaders/mesh_clusters.wgsl",
     );
 
     var lrp = try LineRenderPipeline.init(
         &app,
         .{
             .positions = &render_data.positions,
             .indices = &render_data.indices,
             .object_data = &render_data.object_data,
             .indirect = &render_data.indirect_line,
         },
         "shaders/lines.wgsl",
     );
 
     var transform_1 = Transform{};
     var transform_2 = Transform{};
     var transform_3 = Transform{ .offset = .{ 3, 3, 3 } };
     var transform_4 = Transform{ .offset = .{ -3, -3, 0 } };
     var transform_5 = Transform{ .offset = .{ 3, -3, 1 } };
 
     var render_mesh = try render_data.addMesh(
         &transform_1,
         &cluster_mesh,
         allocator,
     );
 
     _ = try render_data.addMesh(
         &transform_2,
         &cbunny_mesh,
         allocator,
     );
 
     _ = try render_data.addMesh(
         &transform_3,
         &sphere_mesh,
         allocator,
     );
 
     _ = try render_data.addMesh(
         &transform_4,
         &cube_mesh,
         allocator,
     );
 
     _ = try render_data.addMesh(
         &transform_5,
         &cubesphere_mesh,
         allocator,
     );
 
     const corners = mesh.bboxVertices();
     const bbox_indices = Mesh.bboxIndices();
 
     var lines = try render_data.addLines(&corners, &bbox_indices, &transform_1);
 
     const material = try Material.init(
         &textures,
         "Cottage_Clean/Cottage_Clean_Base_Color_fixed.png",
         "Cottage_Clean/Cottage_Clean_Normal_fixed.png",
         "Cottage_Clean/Cottage_Clean_Roughness_fixed.png",
         "Cottage_Clean/Cottage_Clean_Metallic_fixed.png",
         app.queue,
     );
 
     render_mesh.setMaterial(&material);
     render_data.updateObjects();
 
     var skybox = SkyBoxRenderPipeline.init(&app, cube_map);
 
     var fp = ForwardScreenPass.init(.{
         .depth = app.depth_texture_view,
         .pipelines = &.{ rp.pipeline(), lrp.pipeline(), skybox.pipeline() },
     });
 
     const passes = [_]RenderPass{fp.renderPass()};
 
     try app.inputs.append(camera.input.userInput());
 
     var uniform_data = UniformData{
         .pw_camera = undefined,
         .view_matrix = undefined,
         .proj_matrix = undefined,
     };
 
     var skybox_uniform = SkyBoxRenderPipeline.UniformData{
         .inv_view = undefined,
         .inv_proj = undefined,
     };
 
     while (!app.window.shouldClose()) {
         glfw.pollEvents();
 
         camera.update(0.01);
         camera.view(&uniform_data.view_matrix);
         camera.proj(&uniform_data.proj_matrix);
         uniform_data.pw_camera = camera.position;
         app.queue.writeBuffer(rp.uniform_buffer, 0, &[1]UniformData{uniform_data});
         app.queue.writeBuffer(lrp.uniform_buffer, 0, &[1]UniformData{uniform_data});
 
         camera.invView(&skybox_uniform.inv_view);
         camera.invProj(&skybox_uniform.inv_proj);
         app.queue.writeBuffer(skybox.uniform_buffer, 0, &[1]SkyBoxRenderPipeline.UniformData{skybox_uniform});
 
         transform_1.translate(.{ 0.01, 0, 0 });
         render_mesh.dirty = true;
         lines.dirty = true;
 
         render_data.updateObjects();
 
         try app.frame(&passes);
     }
 }
 
 // Borrowed from https://github.com/hexops/mach-gpu
 // Borrowed from https://github.com/hazeycode/zig-objcrt
 pub fn msgSend(obj: anytype, sel_name: [:0]const u8, args: anytype, comptime ReturnType: type) ReturnType {
     const args_meta = @typeInfo(@TypeOf(args)).Struct.fields;
 
     const FnType = switch (args_meta.len) {
         0 => *const fn (@TypeOf(obj), ?*objc.SEL) callconv(.C) ReturnType,
         1 => *const fn (@TypeOf(obj), ?*objc.SEL, args_meta[0].type) callconv(.C) ReturnType,
         2 => *const fn (@TypeOf(obj), ?*objc.SEL, args_meta[0].type, args_meta[1].type) callconv(.C) ReturnType,
         3 => *const fn (@TypeOf(obj), ?*objc.SEL, args_meta[0].type, args_meta[1].type, args_meta[2].type) callconv(.C) ReturnType,
         4 => *const fn (@TypeOf(obj), ?*objc.SEL, args_meta[0].type, args_meta[1].type, args_meta[2].type, args_meta[3].type) callconv(.C) ReturnType,
         else => @compileError("Unsupported number of args"),
     };
 
     const func = @as(FnType, @ptrCast(&objc.objc_msgSend));
     const sel = objc.sel_getUid(@as([*c]const u8, @ptrCast(sel_name)));
 
     return @call(.auto, func, .{ obj, sel } ++ args);
 }
 
 fn glfwKeyCallback(
     window: glfw.Window,
     key: glfw.Key,
     scancode: i32,
     action: glfw.Action,
     mods: glfw.Mods,
 ) void {
     const app = window.getUserPointer(App).?;
     app.keyCallback(.{
         .window = window,
         .key = key,
         .scancode = scancode,
         .action = action,
         .mods = mods,
     });
 }