ray tracing

src/foundations/lighting/Light.zig

@@ -13,8 +13,15 @@ light_kind: light_type,
 padding_1: f32 = 0,
 padding_2: f32 = 0,
 
+const Light = @This();
+
 pub const light_type = enum(u32) {
     direction,
     positional,
     spotlight,
 };
+
+pub const SSBO = rhi.storage_buffer.Buffer([]const Light, rhi.storage_buffer.bbp_lights, c.GL_STATIC_DRAW);
+
+const c = @import("../c.zig").c;
+const rhi = @import("../rhi/rhi.zig");

src/foundations/lighting/Material.zig

@@ -5,3 +5,10 @@ shininess: f32,
 padding_1: f32 = 0,
 padding_2: f32 = 0,
 padding_3: f32 = 0,
+
+const Material = @This();
+
+pub const SSBO = rhi.storage_buffer.Buffer([]const Material, rhi.storage_buffer.bbp_materials, c.GL_STATIC_DRAW);
+
+const c = @import("../c.zig").c;
+const rhi = @import("../rhi/rhi.zig");

src/foundations/physics/camera.zig

@@ -8,6 +8,8 @@ pub const world_up: math.vector.vec3 = .{ 1, 0, 0 };
 pub const world_right: math.vector.vec3 = .{ 0, 0, 1 };
 pub const world_forward: math.vector.vec3 = .{ 0, 1, 0 };
 
+pub const UBO = rhi.storage_buffer.Buffer(CameraData, rhi.storage_buffer.bbp_camera, c.GL_DYNAMIC_DRAW);
+
 pub const CameraData = struct {
     f_mvp: [16]f32,
     v_matrix: [16]f32,
@@ -38,7 +40,7 @@ pub fn Camera(comptime T: type, comptime IntegratorT: type) type {
         input_inactive: bool = false,
         perspective_plane_distance_g: f32 = 0,
         aspect_ratio_s: f32 = 0,
-        camera_buffer: rhi.Buffer,
+        camera_buffer: UBO,
         global_ambient: [4]f32,
         name: []const u8 = "main camera",
         owns_buffer: bool,
@@ -78,14 +80,15 @@ pub fn Camera(comptime T: type, comptime IntegratorT: type) type {
             const global_ambient: [4]f32 = .{ 0.7, 0.7, 0.7, 1.0 };
             const P = initPerspective(cfg);
             const v_matrix = math.matrix.identity();
-            const cd: rhi.Buffer.buffer_data = .{ .camera = .{
+            const cd: CameraData = .{
                 .f_mvp = P.array(),
                 .v_matrix = v_matrix.array(),
                 .f_camera_pos = .{ pos[0], pos[1], pos[2], 1 },
                 .f_global_ambient = global_ambient,
                 .f_shadow_view_m = math.matrix.identity().array(),
-            } };
-            var camera_buffer = rhi.Buffer.init(cd, "camera");
+            };
+
+            var camera_buffer: UBO = UBO.init(cd, "camera");
             errdefer camera_buffer.deinit();
             return initInternal(allocator, cfg, scene, integrator, pos, heading, camera_buffer, false);
         }
@@ -97,7 +100,7 @@ pub fn Camera(comptime T: type, comptime IntegratorT: type) type {
             integrator: IntegratorT,
             pos: math.vector.vec3,
             heading: ?f32,
-            camera_buffer: rhi.Buffer,
+            camera_buffer: UBO,
         ) *Self {
             return initInternal(allocator, cfg, scene, integrator, pos, heading, camera_buffer, false);
         }
@@ -109,7 +112,7 @@ pub fn Camera(comptime T: type, comptime IntegratorT: type) type {
             integrator: IntegratorT,
             pos: math.vector.vec3,
             heading: ?f32,
-            camera_buffer: rhi.Buffer,
+            camera_buffer: UBO,
             owns_buffer: bool,
         ) *Self {
             const cam = allocator.create(Self) catch @panic("OOM");
@@ -487,7 +490,7 @@ pub fn Camera(comptime T: type, comptime IntegratorT: type) type {
             if (!self.emit_matrix) {
                 return;
             }
-            self.camera_buffer.update(.{ .camera = .{
+            self.camera_buffer.update(.{
                 .f_mvp = self.mvp.array(),
                 .v_matrix = self.view_m.array(),
                 .f_camera_pos = .{
@@ -498,7 +501,7 @@ pub fn Camera(comptime T: type, comptime IntegratorT: type) type {
                 },
                 .f_global_ambient = self.global_ambient,
                 .f_shadow_view_m = self.f_shadow_view_m.array(),
-            } });
+            });
             self.scene.updateCamera();
         }
     };

src/foundations/rhi/Texture.zig

@@ -183,6 +183,67 @@ pub fn setup(self: *Texture, image: ?*assets.Image, program: u32, uniform_name:
     return;
 }
 
+pub fn setupWriteable(
+    self: *Texture,
+    data: []u8,
+    program: u32,
+    uniform_name: []const u8,
+    label: [:0]const u8,
+    width: usize,
+    height: usize,
+) TextureError!void {
+    var name: u32 = undefined;
+    c.glCreateTextures(c.GL_TEXTURE_2D, 1, @ptrCast(&name));
+    var buf: [500]u8 = undefined;
+    const label_text = std.fmt.bufPrintZ(&buf, "✍️writeable_texture_{s}", .{label}) catch @panic("bufsize too small");
+    c.glObjectLabel(c.GL_TEXTURE, name, -1, label_text);
+    c.glTextureParameteri(name, c.GL_TEXTURE_WRAP_S, self.wrap_s);
+    c.glTextureParameteri(name, c.GL_TEXTURE_WRAP_T, self.wrap_t);
+    c.glTextureParameteri(name, c.GL_TEXTURE_MIN_FILTER, c.GL_NEAREST);
+    c.glTextureParameteri(name, c.GL_TEXTURE_MAG_FILTER, c.GL_NEAREST);
+
+    c.glTextureStorage2D(name, 1, c.GL_RGBA8, @intCast(width), @intCast(height));
+    c.glTextureSubImage2D(
+        name,
+        0,
+        0,
+        0,
+        @intCast(width),
+        @intCast(height),
+        c.GL_RGBA,
+        c.GL_UNSIGNED_BYTE,
+        data.ptr,
+    );
+
+    c.glGenerateTextureMipmap(name);
+    if (c.glfwExtensionSupported("GL_EXT_texture_filter_anisotropic") == 1) {
+        var ansio_setting: f32 = 0;
+        c.glGetFloatv(c.GL_MAX_TEXTURE_MAX_ANISOTROPY, &ansio_setting);
+        c.glTextureParameterf(name, c.GL_TEXTURE_MAX_ANISOTROPY, ansio_setting);
+    }
+
+    self.name = name;
+
+    self.uniforms[0] = Uniform.init(program, uniform_name) catch {
+        return TextureError.UniformCreationFailed;
+    };
+    self.num_uniforms += 1;
+
+    if (self.disable_bindless) {
+        return;
+    }
+    // Generate bindless handle
+    self.handle = c.glGetTextureHandleARB(self.name);
+    if (self.handle == 0) {
+        return TextureError.BindlessHandleCreationFailed;
+    }
+
+    // Make the texture resident
+    c.glMakeTextureHandleResidentARB(self.handle);
+
+    return;
+}
+
 pub fn setupCubemap(self: *Texture, images: ?[6]*assets.Image, program: u32, uniform_name: []const u8, label: [:0]const u8) TextureError!void {
     var name: u32 = undefined;
     c.glCreateTextures(c.GL_TEXTURE_CUBE_MAP, 1, @ptrCast(&name));
@@ -352,6 +413,10 @@ pub fn addUniform(self: *Texture, program: u32, uniform_name: []const u8) Textur
     self.num_uniforms += 1;
 }
 
+pub fn bindWritableImage(self: Texture) void {
+    c.glBindImageTexture(self.texture_unit, self.name, 0, c.GL_FALSE, 0, c.GL_WRITE_ONLY, c.GL_RGBA8);
+}
+
 pub fn bind(self: Texture) void {
     if (self.disable_bindless) {
         c.glBindTextureUnit(self.texture_unit, self.name);