fixing sneaky bug in blitter clear

src/soft/SoftBuffer.zig

@@ -97,18 +97,18 @@ pub inline fn mapAsSliceWithAddedOffset(self: *const Self, comptime T: type, off
 
 pub fn mapAsWithOffset(self: *const Self, comptime T: type, offset: usize) VkError!*T {
     const memory = if (self.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-    const map = @as([*]u8, @ptrCast(@alignCast(try memory.map(offset, @sizeOf(T)))))[0..@sizeOf(T)];
+    const map = try memory.map(offset, @sizeOf(T));
     return @alignCast(std.mem.bytesAsValue(T, map));
 }
 
 pub fn mapToWithOffset(self: *const Self, comptime T: type, offset: usize) VkError!T {
     const memory = if (self.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-    const map = @as([*]u8, @ptrCast(@alignCast(try memory.map(offset, @sizeOf(T)))))[0..@sizeOf(T)];
+    const map = try memory.map(offset, @sizeOf(T));
     return std.mem.bytesToValue(T, map);
 }
 
 pub fn mapAsSliceWithOffset(self: *const Self, comptime T: type, offset: usize, size: usize) VkError![]T {
     const memory = if (self.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-    const map = @as([*]u8, @ptrCast(@alignCast(try memory.map(offset, size))))[0..size];
+    const map = try memory.map(offset, size);
     return @alignCast(std.mem.bytesAsSlice(T, map));
 }

src/soft/SoftCommandBuffer.zig

@@ -53,6 +53,7 @@ pub fn create(device: *base.Device, allocator: std.mem.Allocator, info: *const v
         .blitImage = blitImage,
         .clearAttachment = clearAttachment,
         .clearColorImage = clearColorImage,
+        .clearDepthStencilImage = clearDepthStencilImage,
         .copyBuffer = copyBuffer,
         .copyBufferToImage = copyBufferToImage,
         .copyImage = copyImage,
@@ -431,6 +432,34 @@ pub fn clearColorImage(interface: *Interface, image: *base.Image, _: vk.ImageLay
     self.commands.append(allocator, .{ .ptr = cmd, .vtable = &.{ .execute = CommandImpl.execute } }) catch return VkError.OutOfHostMemory;
 }
 
+pub fn clearDepthStencilImage(interface: *Interface, image: *base.Image, _: vk.ImageLayout, value: *const vk.ClearDepthStencilValue, range: vk.ImageSubresourceRange) VkError!void {
+    const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
+    const allocator = self.command_allocator.allocator();
+
+    const CommandImpl = struct {
+        const Impl = @This();
+
+        image: *SoftImage,
+        value: vk.ClearDepthStencilValue,
+        range: vk.ImageSubresourceRange,
+
+        pub fn execute(context: *anyopaque, _: *ExecutionDevice) VkError!void {
+            const impl: *Impl = @ptrCast(@alignCast(context));
+            const clear_format = try impl.image.getClearFormat();
+            try blitter.clear(.{ .depth_stencil = impl.value }, clear_format, impl.image, impl.image.interface.format, impl.range, null);
+        }
+    };
+
+    const cmd = allocator.create(CommandImpl) catch return VkError.OutOfHostMemory;
+    errdefer allocator.destroy(cmd);
+    cmd.* = .{
+        .image = @alignCast(@fieldParentPtr("interface", image)),
+        .value = value.*,
+        .range = range,
+    };
+    self.commands.append(allocator, .{ .ptr = cmd, .vtable = &.{ .execute = CommandImpl.execute } }) catch return VkError.OutOfHostMemory;
+}
+
 pub fn copyBuffer(interface: *Interface, src: *base.Buffer, dst: *base.Buffer, regions: []const vk.BufferCopy) VkError!void {
     const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
     const allocator = self.command_allocator.allocator();

src/soft/SoftDeviceMemory.zig

@@ -54,12 +54,12 @@ pub fn invalidateRange(interface: *Interface, offset: vk.DeviceSize, size: vk.De
     _ = size;
 }
 
-pub fn map(interface: *Interface, offset: vk.DeviceSize, size: vk.DeviceSize) VkError!?*anyopaque {
+pub fn map(interface: *Interface, offset: vk.DeviceSize, size: vk.DeviceSize) VkError![]u8 {
     const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
     if (offset >= self.data.len or (size != vk.WHOLE_SIZE and offset + size > self.data.len)) {
         return VkError.MemoryMapFailed;
     }
-    return @ptrCast(&self.data[offset]);
+    return if (size == vk.WHOLE_SIZE) self.data[offset..] else self.data[offset..(offset + size)];
 }
 
 pub fn unmap(_: *Interface) void {

src/soft/SoftImage.zig

@@ -553,18 +553,18 @@ pub inline fn mapAsSliceWithAddedOffset(self: *const Self, comptime T: type, off
 
 pub fn mapAsWithOffset(self: *const Self, comptime T: type, offset: usize) VkError!*T {
     const memory = if (self.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-    const map = @as([*]u8, @ptrCast(@alignCast(try memory.map(offset, @sizeOf(T)))))[0..@sizeOf(T)];
+    const map = try memory.map(offset, @sizeOf(T));
     return @alignCast(std.mem.bytesAsValue(T, map));
 }
 
 pub fn mapToWithOffset(self: *const Self, comptime T: type, offset: usize) VkError!T {
     const memory = if (self.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-    const map = @as([*]u8, @ptrCast(@alignCast(try memory.map(offset, @sizeOf(T)))))[0..@sizeOf(T)];
+    const map = try memory.map(offset, @sizeOf(T));
     return std.mem.bytesToValue(T, map);
 }
 
 pub fn mapAsSliceWithOffset(self: *const Self, comptime T: type, offset: usize, size: usize) VkError![]T {
     const memory = if (self.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-    const map = @as([*]u8, @ptrCast(@alignCast(try memory.map(offset, size))))[0..size];
+    const map = try memory.map(offset, size);
     return @alignCast(std.mem.bytesAsSlice(T, map));
 }

src/soft/device/Renderer.zig

@@ -244,7 +244,7 @@ fn readIndexBuffer(self: *Self, allocator: std.mem.Allocator, index_count: usize
 
     const byte_offset = buffer.interface.offset + index_buffer.offset + (first_index * index_size);
     const byte_size = index_count * index_size;
-    const index_memory: []const u8 = @as([*]const u8, @ptrCast(@alignCast(try buffer_memory.map(byte_offset, byte_size))))[0..byte_size];
+    const index_memory: []const u8 = try buffer_memory.map(byte_offset, byte_size);
 
     const indices = allocator.alloc(i32, index_count) catch return VkError.OutOfDeviceMemory;
     for (indices, 0..) |*index, i| {

src/soft/device/blitter.zig

@@ -97,9 +97,6 @@ pub fn clear(pixel: vk.ClearValue, format: vk.Format, dst: *SoftImage, view_form
         .array_layer = range.base_array_layer,
     };
 
-    const dst_slice_pitch_bytes = dst.interface.getSliceMemSizeForMipLevel(subresource.aspect_mask, subresource.mip_level);
-    const dst_row_pitch_bytes = dst.interface.getRowPitchMemSizeForMipLevel(subresource.aspect_mask, subresource.mip_level);
-
     const last_mip_level = dst.interface.getLastMipLevel(range);
     const last_layer = dst.interface.getLastLayerIndex(range);
 
@@ -128,8 +125,8 @@ pub fn clear(pixel: vk.ClearValue, format: vk.Format, dst: *SoftImage, view_form
 
                     .src_slice_pitch_bytes = base.format.texelSize(format),
                     .src_row_pitch_bytes = 0,
-                    .dst_slice_pitch_bytes = dst_slice_pitch_bytes,
+                    .dst_slice_pitch_bytes = dst.interface.getSliceMemSizeForMipLevel(subresource.aspect_mask, subresource.mip_level),
-                    .dst_row_pitch_bytes = dst_row_pitch_bytes,
+                    .dst_row_pitch_bytes = dst.interface.getRowPitchMemSizeForMipLevel(subresource.aspect_mask, subresource.mip_level),
 
                     .pos = zm.f32x4s(0.5),
                     .dim = zm.f32x4s(0.0),
@@ -355,11 +352,11 @@ pub fn blitRegion(src: *const SoftImage, dst: *SoftImage, region: vk.ImageBlit,
     }) {
         const src_texel_offset = try src.getTexelMemoryOffset(.{ .x = 0, .y = 0, .z = 0 }, src_subresource);
         const src_size = try src.interface.getTotalSizeForAspect(src_subresource.aspect_mask) - src_texel_offset;
-        const src_map: []u8 = @as([*]u8, @ptrCast(try src_memory.map(src.interface.memory_offset + src_texel_offset, src_size)))[0..src_size];
+        const src_map: []u8 = try src_memory.map(src.interface.memory_offset + src_texel_offset, src_size);
 
         const dst_texel_offset = try dst.getTexelMemoryOffset(.{ .x = 0, .y = 0, .z = 0 }, dst_subresource);
         const dst_size = try dst.interface.getTotalSizeForAspect(dst_subresource.aspect_mask) - dst_texel_offset;
-        const dst_map: []u8 = @as([*]u8, @ptrCast(try dst_memory.map(dst.interface.memory_offset + dst_texel_offset, dst_size)))[0..dst_size];
+        const dst_map: []u8 = try dst_memory.map(dst.interface.memory_offset + dst_texel_offset, dst_size);
 
         blit(state, .{
             .src_map = src_map,
@@ -400,15 +397,24 @@ fn blit(state: State, data: BlitData) void {
 
     for (@intCast(data.dst_offset_0.z)..@intCast(data.dst_offset_1.z)) |k| {
         const z = if (state.clear) data.pos[2] else data.pos[2] + @as(f32, @floatFromInt(k)) * data.depth_ratio;
-        var dst_slice = data.dst_map[(k * data.dst_slice_pitch_bytes)..];
+        const z_offset = k * data.dst_slice_pitch_bytes;
+        if (z_offset > data.dst_map.len)
+            break;
+        var dst_slice = data.dst_map[z_offset..];
 
         for (@intCast(data.dst_offset_0.y)..@intCast(data.dst_offset_1.y)) |j| {
             const y = if (state.clear) data.pos[1] else data.pos[1] + @as(f32, @floatFromInt(j)) * data.height_ratio;
-            var dst_line = dst_slice[(j * data.dst_row_pitch_bytes)..];
+            const y_offset = j * data.dst_row_pitch_bytes;
+            if (y_offset > dst_slice.len)
+                break;
+            var dst_line = dst_slice[y_offset..];
 
             for (@intCast(data.dst_offset_0.x)..@intCast(data.dst_offset_1.x)) |i| {
                 const x = if (state.clear) data.pos[0] else data.pos[0] + @as(f32, @floatFromInt(i)) * data.width_ratio;
-                var dst_pixel = dst_line[(i * base.format.texelSize(state.dst_format))..];
+                const x_offset = i * base.format.texelSize(state.dst_format);
+                if (x_offset > dst_line.len)
+                    break;
+                var dst_pixel = dst_line[x_offset..];
 
                 if (clear_color_i) |color| {
                     for (0..state.dst_samples) |_| {
@@ -763,11 +769,13 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
 
         .r16_sint,
         .r16_uint,
-        .d16_unorm,
         => std.mem.bytesAsValue(u16, map).* = @intFromFloat(@round(color[0])),
 
         .r16_snorm => std.mem.bytesAsValue(u16, map).* = @intFromFloat(@round(color[0] * std.math.maxInt(i16))),
-        .r16_unorm => std.mem.bytesAsValue(u16, map).* = @intFromFloat(@round(color[0] * std.math.maxInt(u16))),
+
+        .r16_unorm,
+        .d16_unorm,
+        => std.mem.bytesAsValue(u16, map).* = @intFromFloat(@round(color[0] * std.math.maxInt(u16))),
 
         .r16_sfloat => std.mem.bytesAsValue(f16, map).* = @floatCast(color[0]),
 
@@ -1181,6 +1189,7 @@ pub fn writeInt4(c: U32x4, map: []u8, dst_format: vk.Format) void {
     switch (dst_format) {
         .r8_sint,
         .r8_uint,
+        .s8_uint,
         => map[0] = @truncate(color[0]),
 
         .r8g8_sint,

src/soft/device/rasterizer/edge_function.zig

@@ -103,7 +103,8 @@ pub fn drawTriangle(
         }
     }
 
-    // To avoid mess with pixel render order without depth buffer to sort them
+    // Not syncing workers between triangles when rendering without depth buffer
+    // will lead to pixel rendering order issues between triangles.
     if (depth_attachment_access == null)
         draw_call.rasterizer_wait_group.await(io) catch return VkError.DeviceLost;
 }

src/soft/device/vertex_dispatcher.zig

@@ -64,7 +64,7 @@ inline fn run(data: RunData) !void {
                 const buffer_memory = if (buffer.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
                 const offset = buffer.interface.offset + vertex_buffer.offset + (binding_info.stride * vertex_index) + attribute.offset;
 
-                const buffer_memory_map: []u8 = @as([*]u8, @ptrCast(@alignCast(try buffer_memory.map(offset, buffer_memory_size))))[0..buffer_memory_size];
+                const buffer_memory_map: []u8 = try buffer_memory.map(offset, buffer_memory_size);
 
                 try rt.writeInput(buffer_memory_map, location_result);
             }

src/vulkan/CommandBuffer.zig

@@ -47,6 +47,7 @@ pub const DispatchTable = struct {
     blitImage: *const fn (*Self, *Image, vk.ImageLayout, *Image, vk.ImageLayout, []const vk.ImageBlit, vk.Filter) VkError!void,
     clearAttachment: *const fn (*Self, vk.ClearAttachment, vk.ClearRect) VkError!void,
     clearColorImage: *const fn (*Self, *Image, vk.ImageLayout, *const vk.ClearColorValue, vk.ImageSubresourceRange) VkError!void,
+    clearDepthStencilImage: *const fn (*Self, *Image, vk.ImageLayout, *const vk.ClearDepthStencilValue, vk.ImageSubresourceRange) VkError!void,
     copyBuffer: *const fn (*Self, *Buffer, *Buffer, []const vk.BufferCopy) VkError!void,
     copyBufferToImage: *const fn (*Self, *Buffer, *Image, vk.ImageLayout, []const vk.BufferImageCopy) VkError!void,
     copyImage: *const fn (*Self, *Image, vk.ImageLayout, *Image, vk.ImageLayout, []const vk.ImageCopy) VkError!void,
@@ -191,6 +192,12 @@ pub fn clearColorImage(self: *Self, image: *Image, layout: vk.ImageLayout, color
     }
 }
 
+pub fn clearDepthStencilImage(self: *Self, image: *Image, layout: vk.ImageLayout, value: *const vk.ClearDepthStencilValue, ranges: []const vk.ImageSubresourceRange) VkError!void {
+    for (ranges) |range| {
+        try self.dispatch_table.clearDepthStencilImage(self, image, layout, value, range);
+    }
+}
+
 pub inline fn copyBuffer(self: *Self, src: *Buffer, dst: *Buffer, regions: []const vk.BufferCopy) VkError!void {
     try self.dispatch_table.copyBuffer(self, src, dst, regions);
 }

src/vulkan/DeviceMemory.zig

@@ -18,7 +18,7 @@ pub const VTable = struct {
     destroy: *const fn (*Self, std.mem.Allocator) void,
     flushRange: *const fn (*Self, vk.DeviceSize, vk.DeviceSize) VkError!void,
     invalidateRange: *const fn (*Self, vk.DeviceSize, vk.DeviceSize) VkError!void,
-    map: *const fn (*Self, vk.DeviceSize, vk.DeviceSize) VkError!?*anyopaque,
+    map: *const fn (*Self, vk.DeviceSize, vk.DeviceSize) VkError![]u8,
     unmap: *const fn (*Self) void,
 };
 
@@ -44,7 +44,7 @@ pub inline fn invalidateRange(self: *Self, offset: vk.DeviceSize, size: vk.Devic
     try self.vtable.invalidateRange(self, offset, size);
 }
 
-pub inline fn map(self: *Self, offset: vk.DeviceSize, size: vk.DeviceSize) VkError!?*anyopaque {
+pub inline fn map(self: *Self, offset: vk.DeviceSize, size: vk.DeviceSize) VkError![]u8 {
     return self.vtable.map(self, offset, size);
 }
 

src/vulkan/lib_vulkan.zig

@@ -1497,7 +1497,7 @@ pub export fn strollMapMemory(p_device: vk.Device, p_memory: vk.DeviceMemory, of
     Dispatchable(Device).checkHandleValidity(p_device) catch |err| return toVkResult(err);
 
     const device_memory = NonDispatchable(DeviceMemory).fromHandleObject(p_memory) catch |err| return toVkResult(err);
-    pp_data.* = device_memory.map(offset, size) catch |err| return toVkResult(err);
+    pp_data.* = @ptrCast((device_memory.map(offset, size) catch |err| return toVkResult(err)).ptr);
     return .success;
 }
 
@@ -1746,21 +1746,13 @@ pub export fn strollCmdClearColorImage(p_cmd: vk.CommandBuffer, p_image: vk.Imag
     cmd.clearColorImage(image, layout, color, ranges[0..count]) catch |err| return errorLogger(err);
 }
 
-pub export fn strollCmdClearDepthStencilImage(p_cmd: vk.CommandBuffer, p_image: vk.Image, layout: vk.ImageLayout, stencil: *const vk.ClearDepthStencilValue, count: u32, ranges: [*]const vk.ImageSubresourceRange) callconv(vk.vulkan_call_conv) void {
+pub export fn strollCmdClearDepthStencilImage(p_cmd: vk.CommandBuffer, p_image: vk.Image, layout: vk.ImageLayout, value: *const vk.ClearDepthStencilValue, count: u32, ranges: [*]const vk.ImageSubresourceRange) callconv(vk.vulkan_call_conv) void {
     entryPointBeginLogTrace(.vkCmdClearDepthStencilImage);
     defer entryPointEndLogTrace();
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
     const image = NonDispatchable(Image).fromHandleObject(p_image) catch |err| return errorLogger(err);
-
+    cmd.clearDepthStencilImage(image, layout, value, ranges[0..count]) catch |err| return errorLogger(err);
-    notImplementedWarning();
-
-    _ = cmd;
-    _ = image;
-    _ = layout;
-    _ = stencil;
-    _ = count;
-    _ = ranges;
 }
 
 pub export fn strollCmdCopyBuffer(p_cmd: vk.CommandBuffer, p_src: vk.Buffer, p_dst: vk.Buffer, count: u32, regions: [*]const vk.BufferCopy) callconv(vk.vulkan_call_conv) void {