improving descriptor sets push to shaders

src/soft/device/ComputeDispatcher.zig

@@ -4,7 +4,8 @@ const base = @import("base");
 const spv = @import("spv");
 const lib = @import("../lib.zig");
 
-const PipelineState = @import("Device.zig").PipelineState;
+const ExecutionDevice = @import("Device.zig");
+const PipelineState = ExecutionDevice.PipelineState;
 
 const SoftDevice = @import("../SoftDevice.zig");
 const SoftPipeline = @import("../SoftPipeline.zig");
@@ -96,7 +97,7 @@ inline fn run(data: RunData) !void {
 
     const entry = try rt.getEntryPointByName(shader.entry);
 
-    try data.self.writeDescriptorSets(rt);
+    try ExecutionDevice.writeDescriptorSets(data.self.state, rt);
 
     var group_index: usize = data.batch_id;
     while (group_index < data.group_count) : (group_index += data.self.batch_size) {
@@ -165,52 +166,6 @@ inline fn dumpResultsTable(allocator: std.mem.Allocator, io: std.Io, rt: *spv.Ru
     try rt.dumpResultsTable(allocator, &writer.interface);
 }
 
-fn writeDescriptorSets(self: *Self, rt: *spv.Runtime) !void {
-    sets: for (self.state.sets[0..], 0..) |set, set_index| {
-        if (set == null)
-            continue :sets;
-
-        bindings: for (set.?.descriptors[0..], 0..) |binding, binding_index| {
-            switch (binding) {
-                .buffer => |buffer_data_array| for (buffer_data_array, 0..) |buffer_data, descriptor_index| {
-                    if (buffer_data.object) |buffer| {
-                        const map = buffer.mapAsSliceWithOffset(u8, buffer_data.offset, buffer_data.size) catch continue :bindings;
-                        try rt.writeDescriptorSet(
-                            map,
-                            @as(u32, @intCast(set_index)),
-                            @as(u32, @intCast(binding_index)),
-                            @as(u32, @intCast(descriptor_index)),
-                        );
-                    }
-                },
-                .image => |image_data_array| for (image_data_array, 0..) |image_data, descriptor_index| {
-                    if (image_data.object) |image_view| {
-                        const addr: usize = @intFromPtr(image_view);
-                        try rt.writeDescriptorSet(
-                            std.mem.asBytes(&addr),
-                            @as(u32, @intCast(set_index)),
-                            @as(u32, @intCast(binding_index)),
-                            @as(u32, @intCast(descriptor_index)),
-                        );
-                    }
-                },
-                .texel_buffer => |texel_data_array| for (texel_data_array, 0..) |texel_data, descriptor_index| {
-                    if (texel_data.object) |buffer_view| {
-                        const addr: usize = @intFromPtr(buffer_view);
-                        try rt.writeDescriptorSet(
-                            std.mem.asBytes(&addr),
-                            @as(u32, @intCast(set_index)),
-                            @as(u32, @intCast(binding_index)),
-                            @as(u32, @intCast(descriptor_index)),
-                        );
-                    }
-                },
-                else => {},
-            }
-        }
-    }
-}
-
 fn setupWorkgroupBuiltins(
     self: *Self,
     rt: *spv.Runtime,

src/soft/device/Device.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const vk = @import("vulkan");
 const base = @import("base");
 const lib = @import("../lib.zig");
+const spv = @import("spv");
 
 const SoftDescriptorSet = @import("../SoftDescriptorSet.zig");
 const SoftDevice = @import("../SoftDevice.zig");
@@ -60,3 +61,49 @@ pub fn setup(self: *Self, device: *SoftDevice) void {
     self.compute = .init(device, &self.pipeline_states[@intFromEnum(vk.PipelineBindPoint.compute)]);
     self.renderer = .init(device, &self.pipeline_states[@intFromEnum(vk.PipelineBindPoint.graphics)]);
 }
+
+pub fn writeDescriptorSets(state: *PipelineState, rt: *spv.Runtime) !void {
+    sets: for (state.sets[0..], 0..) |set, set_index| {
+        if (set == null)
+            continue :sets;
+
+        bindings: for (set.?.descriptors[0..], 0..) |binding, binding_index| {
+            switch (binding) {
+                .buffer => |buffer_data_array| for (buffer_data_array, 0..) |buffer_data, descriptor_index| {
+                    if (buffer_data.object) |buffer| {
+                        const map = buffer.mapAsSliceWithOffset(u8, buffer_data.offset, buffer_data.size) catch continue :bindings;
+                        try rt.writeDescriptorSet(
+                            map,
+                            @as(u32, @intCast(set_index)),
+                            @as(u32, @intCast(binding_index)),
+                            @as(u32, @intCast(descriptor_index)),
+                        );
+                    }
+                },
+                .image => |image_data_array| for (image_data_array, 0..) |image_data, descriptor_index| {
+                    if (image_data.object) |image_view| {
+                        const addr: usize = @intFromPtr(image_view);
+                        try rt.writeDescriptorSet(
+                            std.mem.asBytes(&addr),
+                            @as(u32, @intCast(set_index)),
+                            @as(u32, @intCast(binding_index)),
+                            @as(u32, @intCast(descriptor_index)),
+                        );
+                    }
+                },
+                .texel_buffer => |texel_data_array| for (texel_data_array, 0..) |texel_data, descriptor_index| {
+                    if (texel_data.object) |buffer_view| {
+                        const addr: usize = @intFromPtr(buffer_view);
+                        try rt.writeDescriptorSet(
+                            std.mem.asBytes(&addr),
+                            @as(u32, @intCast(set_index)),
+                            @as(u32, @intCast(binding_index)),
+                            @as(u32, @intCast(descriptor_index)),
+                        );
+                    }
+                },
+                else => {},
+            }
+        }
+    }
+}

src/soft/device/Renderer.zig

@@ -4,7 +4,8 @@ const base = @import("base");
 const zm = base.zm;
 const spv = @import("spv");
 
-const PipelineState = @import("Device.zig").PipelineState;
+const ExecutionDevice = @import("Device.zig");
+const PipelineState = ExecutionDevice.PipelineState;
 const BoundedAllocator = @import("BoundedAllocator.zig");
 
 const SoftBuffer = @import("../SoftBuffer.zig");
@@ -182,11 +183,11 @@ fn drawCall(self: *Self, bounded_allocator: *BoundedAllocator, vertex_count: usi
     const pipeline = self.state.pipeline orelse return VkError.InvalidPipelineDrv;
     const vertex_shader = pipeline.stages.getPtrAssertContains(.vertex);
     for (vertex_shader.runtimes[0..]) |*runtime| {
-        writeDescriptorSets(&draw_call, &runtime.rt) catch return VkError.Unknown;
+        ExecutionDevice.writeDescriptorSets(self.state, &runtime.rt) catch return VkError.Unknown;
     }
     const fragment_shader = pipeline.stages.getPtrAssertContains(.fragment);
     for (fragment_shader.runtimes[0..]) |*runtime| {
-        writeDescriptorSets(&draw_call, &runtime.rt) catch return VkError.Unknown;
+        ExecutionDevice.writeDescriptorSets(self.state, &runtime.rt) catch return VkError.Unknown;
     }
 
     self.vertexShaderStage(allocator, &draw_call, vertex_count, instance_count, first_vertex, first_instance, indices) catch |err| {
@@ -307,38 +308,3 @@ fn resolveScissor(self: *Self, scissor_index: usize) VkError!vk.Rect2D {
 
     return VkError.Unknown;
 }
-
-fn writeDescriptorSets(draw_call: *DrawCall, rt: *spv.Runtime) !void {
-    sets: for (draw_call.renderer.state.sets[0..], 0..) |set, set_index| {
-        if (set == null)
-            continue :sets;
-
-        bindings: for (set.?.descriptors[0..], 0..) |binding, binding_index| {
-            switch (binding) {
-                .buffer => |buffer_data_array| for (buffer_data_array, 0..) |buffer_data, descriptor_index| {
-                    if (buffer_data.object) |buffer| {
-                        const map = buffer.mapAsSliceWithOffset(u8, buffer_data.offset, buffer_data.size) catch continue :bindings;
-                        try rt.writeDescriptorSet(
-                            map,
-                            @as(u32, @intCast(set_index)),
-                            @as(u32, @intCast(binding_index)),
-                            @as(u32, @intCast(descriptor_index)),
-                        );
-                    }
-                },
-                .image => |image_data_array| for (image_data_array, 0..) |image_data, descriptor_index| {
-                    if (image_data.object) |image_view| {
-                        const addr: usize = @intFromPtr(image_view);
-                        try rt.writeDescriptorSet(
-                            std.mem.asBytes(&addr),
-                            @as(u32, @intCast(set_index)),
-                            @as(u32, @intCast(binding_index)),
-                            @as(u32, @intCast(descriptor_index)),
-                        );
-                    }
-                },
-                else => {},
-            }
-        }
-    }
-}

src/soft/device/blitter.zig

@@ -649,7 +649,7 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
         .r8_snorm,
         .r8_unorm,
         .s8_uint,
-        => map[0] = @intFromFloat(@round(color[0] * 255.0)),
+        => map[0] = @intFromFloat(@round(color[0] * std.math.maxInt(u8))),
 
         .r16_sint,
         .r16_uint,
@@ -692,6 +692,13 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
 
         .r32g32b32a32_sfloat => std.mem.bytesAsValue(F32x4, map).* = color,
 
+        .r5g6b5_unorm_pack16 => {
+            const r: u5 = @intFromFloat(@round(color[0] * std.math.maxInt(u5)));
+            const g: u6 = @intFromFloat(@round(color[1] * std.math.maxInt(u6)));
+            const b: u5 = @intFromFloat(@round(color[2] * std.math.maxInt(u5)));
+            std.mem.bytesAsValue(u16, map[0..]).* = (@as(u16, r) << 11) | (@as(u16, g) << 5) | @as(u16, b);
+        },
+
         else => base.unsupported("Blitter: write float to destination format {any}", .{dst_format}),
     }
 }

src/soft/device/fragment.zig

@@ -4,7 +4,7 @@ const base = @import("base");
 const zm = base.zm;
 const spv = @import("spv");
 
-const lib = @import("../lib.zig");
+const VertexInterpolation = @import("rasterizer/common.zig").VertexInterpolation;
 
 const Renderer = @import("Renderer.zig");
 const SoftImage = @import("../SoftImage.zig");
@@ -12,7 +12,13 @@ const SoftImage = @import("../SoftImage.zig");
 const VkError = base.VkError;
 const SpvRuntimeError = spv.Runtime.RuntimeError;
 
-pub fn shaderInvocation(allocator: std.mem.Allocator, draw_call: *Renderer.DrawCall, batch_id: usize, position: zm.F32x4, inputs: [spv.SPIRV_MAX_OUTPUT_LOCATIONS][]const u8) SpvRuntimeError!zm.F32x4 {
+pub fn shaderInvocation(
+    allocator: std.mem.Allocator,
+    draw_call: *Renderer.DrawCall,
+    batch_id: usize,
+    position: zm.F32x4,
+    inputs: [spv.SPIRV_MAX_OUTPUT_LOCATIONS]VertexInterpolation,
+) SpvRuntimeError!zm.F32x4 {
     const io = draw_call.renderer.device.interface.io();
 
     _ = position;
@@ -34,8 +40,9 @@ pub fn shaderInvocation(allocator: std.mem.Allocator, draw_call: *Renderer.DrawC
             SpvRuntimeError.NotFound => continue,
             else => return err,
         };
-        try rt.writeInput(inputs[location], result_word);
-        allocator.free(inputs[location]);
+        try rt.writeInput(inputs[location].blob, result_word);
+        if (inputs[location].free_responsability)
+            allocator.free(inputs[location].blob);
     }
 
     rt.callEntryPoint(allocator, entry) catch |err| switch (err) {

src/soft/device/rasterizer/common.zig

@@ -17,6 +17,11 @@ pub const RenderTargetAccess = struct {
     format: vk.Format,
 };
 
+pub const VertexInterpolation = struct {
+    blob: []const u8,
+    free_responsability: bool,
+};
+
 pub fn scissorContainsPixel(scissor: vk.Rect2D, x: i32, y: i32) bool {
     const min_x: i64 = @as(i64, scissor.offset.x);
     const min_y: i64 = @as(i64, scissor.offset.y);
@@ -41,8 +46,8 @@ pub fn interpolateVertexOutputs(
     b0: f32,
     b1: f32,
     b2: f32,
-) VkError![spv.SPIRV_MAX_OUTPUT_LOCATIONS][]u8 {
-    var inputs: [spv.SPIRV_MAX_OUTPUT_LOCATIONS][]u8 = undefined;
+) VkError![spv.SPIRV_MAX_OUTPUT_LOCATIONS]VertexInterpolation {
+    var inputs: [spv.SPIRV_MAX_OUTPUT_LOCATIONS]VertexInterpolation = undefined;
 
     for (0..spv.SPIRV_MAX_OUTPUT_LOCATIONS) |location| {
         const out0 = v0.outputs[location] orelse continue;
@@ -50,7 +55,7 @@ pub fn interpolateVertexOutputs(
         const out2 = v2.outputs[location] orelse continue;
 
         if (out0.interpolation_type == .flat or out0.blob.len == 0) {
-            inputs[location] = out0.blob;
+            inputs[location] = .{ .blob = out0.blob, .free_responsability = false };
             continue;
         }
 
@@ -75,13 +80,18 @@ pub fn interpolateVertexOutputs(
         if (byte_index < len)
             @memcpy(input[byte_index..], out0.blob[byte_index..len]);
 
-        inputs[location] = input;
+        inputs[location] = .{ .blob = input, .free_responsability = true };
     }
 
     return inputs;
 }
 
-pub fn interpolateLineOutputs(allocator: std.mem.Allocator, v0: *const Renderer.Vertex, v1: *const Renderer.Vertex, t: f32) VkError![spv.SPIRV_MAX_OUTPUT_LOCATIONS][]u8 {
+pub fn interpolateLineOutputs(
+    allocator: std.mem.Allocator,
+    v0: *const Renderer.Vertex,
+    v1: *const Renderer.Vertex,
+    t: f32,
+) VkError![spv.SPIRV_MAX_OUTPUT_LOCATIONS]VertexInterpolation {
     return interpolateVertexOutputs(allocator, v0, v1, v0, 1.0 - t, t, 0.0);
 }