Feature/resource manager

build.zig

@@ -15,6 +15,7 @@ const Dependencies = struct {
     rshc: *Module,
     vulkan: *Module,
     glfw: *Module,
+    common: *Module,
 };
 
 fn resolveGLFWSystemDeps(m: *Module) void {
@@ -48,10 +49,17 @@ fn buildDeps(b: *Build, opts: BuildOpts) Dependencies {
 
     resolveGLFWSystemDeps(glfw_mod);
 
+    const common_mod = b.createModule(.{
+        .optimize = opts.optimize,
+        .target = opts.target,
+        .root_source_file = b.path("src/common/common.zig"),
+    });
+
     return .{
         .rshc = rshc_mod,
         .vulkan = vulkan_mod,
         .glfw = glfw_mod,
+        .common = common_mod,
     };
 }
 
@@ -69,6 +77,9 @@ fn buildLibrary(
     });
 
     lib_mod.addImport("vulkan", deps.vulkan);
+    lib_mod.addImport("common", deps.common);
+
+    // Temporary for development
     lib_mod.addImport("rshc", deps.rshc);
     lib_mod.addImport("glfw", deps.glfw);
 
@@ -85,16 +96,34 @@ fn buildLibrary(
 
 const SampleEntry = struct {
     name: []const u8,
-    path: []const u8,
+    desc: []const u8,
+    path: []const u8 = "(no description)",
 
     // these get populated later
     mod: *Module = undefined,
     exe: *Compile = undefined,
 };
 var sample_files = [_]SampleEntry{
-    .{ .name = "basic_planes", .path = "basic_planes.zig" },
-    .{ .name = "compute_drawing", .path = "compute_drawing/main.zig" },
-    .{ .name = "test_sample", .path = "test_sample.zig" },
+    .{
+        .name = "basic-planes",
+        .path = "basic_planes.zig",
+        .desc = "basic showcase of bootstrapping vulkan up to 3d rendering",
+    },
+    .{
+        .name = "compute-drawing",
+        .path = "compute_drawing/main.zig",
+        .desc = "drawing using compute shaders",
+    },
+    .{
+        .name = "test-sample",
+        .path = "test_sample.zig",
+        .desc = "test to see if the sample build steps work correctly",
+    },
+    .{
+        .name = "raymarch-fractals",
+        .path = "raymarch_fractals/main.zig",
+        .desc = "pick from a selection of raymarched fractals, all programmed within fragment shaders",
+    },
 };
 
 fn populateSampleModules(
@@ -149,39 +178,48 @@ fn buildSamples(
 ) void {
     populateSampleModules(b, lib_mod, deps, opts);
 
-    const build_sample = b.option(
-        []const u8,
-        "sample",
-        "specify sample to build and run",
-    );
-    if (build_sample) |sample_name| {
-        var entry: ?*SampleEntry = null;
-
-        for (&sample_files) |*f| {
-            if (std.mem.order(u8, sample_name, f.name) == .eq) {
-                entry = f;
-                break;
-            }
-        }
-
-        if (entry == null) return;
+    for (sample_files) |entry| {
+        b.installArtifact(entry.exe);
 
-        b.installArtifact(entry.?.exe);
+        const run_step = b.addRunArtifact(entry.exe);
+        run_step.addArgs(b.args orelse &.{});
 
-        const run_step = b.addRunArtifact(entry.?.exe);
         run_step.step.dependOn(b.getInstallStep());
 
-        const run_cmd = b.step("run", "run a sample executable");
+        const step_name = std.fmt.allocPrint(
+            b.allocator,
+            "run-{s}",
+            .{entry.name},
+        ) catch @panic("Achievement Get: How did we get here?");
+
+        const run_cmd = b.step(step_name, entry.desc);
         run_cmd.dependOn(&run_step.step);
     }
 }
 
 /// adds a single module and compile step containing
 /// all included tests (based on specified options)
-fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies) void {
-    _ = b;
-    _ = lib_mod;
-    _ = deps;
+fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies, opts: BuildOpts) void {
+    const test_comp = b.addTest(.{
+        .name = "unit_tests",
+        .root_module = lib_mod,
+        .target = opts.target,
+    });
+
+    const common_tests = b.addTest(.{
+        .name = "common_unit_tests",
+        .root_module = deps.common,
+        .target = opts.target,
+    });
+    b.installArtifact(test_comp);
+    b.installArtifact(common_tests);
+
+    const test_step = b.addRunArtifact(test_comp);
+    const common_test_step = b.addRunArtifact(common_tests);
+    const test_cmd = b.step("test", "run all unit tests");
+
+    test_cmd.dependOn(&test_step.step);
+    test_cmd.dependOn(&common_test_step.step);
 }
 // Although this function looks imperative, note that its job is to
 // declaratively construct a build graph that will be executed by an external
@@ -192,12 +230,24 @@ pub fn build(b: *Build) void {
         .optimize = b.standardOptimizeOption(.{}),
     };
 
+    const opt_build_samples = b.option(
+        bool,
+        "build_samples",
+        "whether or not to build sample executables (defaults: true)",
+    ) orelse true;
+
+    const opt_build_tests = b.option(
+        bool,
+        "build_tests",
+        "whether or not to build sample executables (defaults: true)",
+    ) orelse true;
+
     const deps = buildDeps(b, opts);
     const lib_mod, const lib_exe = buildLibrary(b, deps, opts);
 
     // handle samples and testing if specified
-    buildSamples(b, lib_mod, deps, opts);
-    buildTests(b, lib_mod, deps);
+    if (opt_build_samples) buildSamples(b, lib_mod, deps, opts);
+    if (opt_build_tests) buildTests(b, lib_mod, deps, opts);
 
     // zls-friendly check step
     // (which made all the rest of the code way grosser)

samples/basic_planes.zig

@@ -381,7 +381,7 @@ pub fn main() !void {
     defer window.destroy();
 
     glfw.vulkanSupported() catch |err| {
-        std.debug.print("Could not load Vulkan\n", .{});
+        std.log.err("Could not load Vulkan", .{});
         return err;
     };
 
@@ -400,5 +400,5 @@ pub fn main() !void {
         try mainLoop();
     }
 
-    std.debug.print("You win!\n", .{});
+    std.log.info("You win!\n", .{});
 }

samples/common/render_quad.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const ray = @import("ray");
 const api = ray.api;
+const math = ray.math;
 
 const Allocator = std.mem.Allocator;
 
@@ -81,7 +82,7 @@ pub fn initSelf(self: *Self, ctx: *const Context, allocator: Allocator, config:
         },
         .viewport = .{ .Swapchain = config.swapchain },
         .descriptors = if (config.frag_descriptors) |fd| &.{
-            fd.h_desc_layout,
+            fd.vkLayout(),
         } else &.{},
     });
     defer fixed_functions_config.deinit();
@@ -119,7 +120,7 @@ pub fn drawOneShot(self: *const Self, cmd_buf: *const CommandBuffer, framebuffer
     self.renderpass.begin(cmd_buf, framebuffer, image_index);
 
     if (self.desc) |d| {
-        d.bind(cmd_buf, self.pipeline.h_pipeline_layout, .{});
+        d.use(cmd_buf, self.pipeline.h_pipeline_layout, .{});
     }
 
     self.dev.draw(cmd_buf, 6, 1, 0, 0);

samples/compute_drawing/main.zig

@@ -25,7 +25,7 @@ const GraphicsPipeline = api.GraphicsPipeline;
 const RenderPass = api.RenderPass;
 const FixedFunctionState = api.FixedFunctionState;
 const Descriptor = api.Descriptor;
-const DescriptorBinding = api.ResolvedDescriptorBinding;
+const DescriptorLayout = api.DescriptorLayout;
 const CommandBuffer = api.CommandBuffer;
 
 const Semaphore = api.Semaphore;
@@ -141,6 +141,10 @@ const SampleState = struct {
             .inst_extensions = helpers.glfwInstanceExtensions(),
             .loader = glfw.glfwGetInstanceProcAddress,
             .window = &self.window,
+            .management = .{
+                .allocator = self.allocator,
+                .pool_sizes = 1024,
+            },
         });
     }
 
@@ -177,19 +181,28 @@ const SampleState = struct {
         try self.gpu_state.uniforms.setData(&self.gpu_state.host_uniforms);
 
         // create fragment-specific descriptors
-        self.graphics.descriptor = try Descriptor.init(self.ctx, self.allocator, .{
-            .bindings = &.{ .{
-                .data = .{ .Uniform = self.gpu_state.uniforms.buffer() },
-                .stages = .{ .fragment_bit = true },
-            }, DescriptorBinding{
-                .data = .{ .Sampler = .{
-                    .sampler = self.gpu_state.render_sampler,
-                    .view = self.gpu_state.render_view.h_view,
-                } },
-                .stages = .{ .fragment_bit = true },
-            } },
+        var frag_desc_layout = try DescriptorLayout.init(self.ctx, self.allocator, 2);
+        frag_desc_layout.addDescriptors(&.{
+            .{ 0, "FragUniforms", .Uniform, .{ .fragment_bit = true } },
+            .{ 1, "MainTex", .Sampler, .{ .fragment_bit = true } },
+        });
+        try frag_desc_layout.resolve();
+
+        self.graphics.descriptor = try Descriptor.init(self.ctx, .{
+            .layout = frag_desc_layout,
+            .usage = .{
+                .lifetime_bits = .Static,
+            },
         });
 
+        self.graphics.descriptor.bindUniformsNamed(
+            "FragUniforms",
+            self.gpu_state.uniforms.buffer(),
+        );
+        self.graphics.descriptor.bindSamplerNamed("MainTex", self.gpu_state.render_sampler, self.gpu_state.render_view);
+
+        self.graphics.descriptor.update();
+
         try self.graphics.render_quad.initSelf(self.ctx, self.allocator, .{
             .frag_shader = &frag_shader,
             .frag_descriptors = &self.graphics.descriptor,
@@ -243,26 +256,27 @@ const SampleState = struct {
         self.gpu_state.compute_uniforms = try UniformBuffer(ComputeUniforms).create(self.ctx);
         self.gpu_state.particles = try StorageBuffer(Particle).create(self.ctx, PARTICLE_COUNT);
 
-        const descriptors: []const DescriptorBinding = &.{
-            .{
-                .data = .{ .Uniform = self.gpu_state.compute_uniforms.buffer() },
-                .stages = .{ .compute_bit = true },
-            },
-            .{
-                .data = .{ .StorageBuffer = self.gpu_state.particles.buffer() },
-                .stages = .{ .compute_bit = true },
-            },
-            .{
-                .data = .{ .Image = .{
-                    .img = &self.gpu_state.render_target,
-                    .view = self.gpu_state.render_view.h_view,
-                } },
-                .stages = .{ .compute_bit = true },
-            },
-        };
-        self.compute.pipeline = try Compute.init(self.ctx, self.allocator, .{
+        var compute_desc_layout = try DescriptorLayout.init(self.ctx, self.allocator, 3);
+        compute_desc_layout.addDescriptors(&.{
+            .{ 0, "Uniforms", .Uniform, .{ .compute_bit = true } },
+            .{ 1, "Particles", .StorageBuffer, .{ .compute_bit = true } },
+            .{ 2, "RenderTarget", .Image, .{ .compute_bit = true } },
+        });
+        try compute_desc_layout.resolve();
+
+        var compute_descriptor = try Descriptor.init(self.ctx, .{
+            .layout = compute_desc_layout,
+            .usage = .{ .lifetime_bits = .Static },
+        });
+
+        compute_descriptor.bindUniformsNamed("Uniforms", self.gpu_state.compute_uniforms.buffer());
+        compute_descriptor.bindBufferNamed("Particles", self.gpu_state.particles.buffer());
+        compute_descriptor.bindImageNamed("RenderTarget", &self.gpu_state.render_target, self.gpu_state.render_view);
+        compute_descriptor.update();
+
+        self.compute.pipeline = try Compute.init(self.ctx, .{
             .shader = &shader,
-            .desc_bindings = descriptors,
+            .desc = compute_descriptor,
         });
     }