working on copy operations; ci skip

src/soft/SoftCommandBuffer.zig

@@ -43,12 +43,14 @@ pub fn create(device: *base.Device, allocator: std.mem.Allocator, info: *const v
         .bindPipeline = bindPipeline,
         .clearColorImage = clearColorImage,
         .copyBuffer = copyBuffer,
+        .copyBufferToImage = copyBufferToImage,
         .copyImage = copyImage,
         .copyImageToBuffer = copyImageToBuffer,
         .dispatch = dispatch,
         .dispatchIndirect = dispatchIndirect,
         .end = end,
         .fillBuffer = fillBuffer,
+        .pipelineBarrier = pipelineBarrier,
         .reset = reset,
         .resetEvent = resetEvent,
         .setEvent = setEvent,
@@ -74,11 +76,12 @@ pub fn execute(self: *Self, device: *ExecutionDevice) VkError!void {
     for (self.commands.items) |command| {
         try command.vtable.execute(command.ptr, device);
     }
+    try self.interface.finish();
 }
 
 pub fn begin(interface: *Interface, _: *const vk.CommandBufferBeginInfo) VkError!void {
     const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
-    self.command_allocator.deinit();
+    _ = self.command_allocator.reset(.free_all);
 }
 
 pub fn end(interface: *Interface) VkError!void {
@@ -90,8 +93,7 @@ pub fn reset(interface: *Interface, _: vk.CommandBufferResetFlags) VkError!void
     const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
     const allocator = self.command_allocator.allocator();
     self.commands.clearAndFree(allocator);
-    if (!self.command_allocator.reset(.{ .retain_with_limit = 16_384 }))
-        return VkError.OutOfHostMemory;
+    _ = self.command_allocator.reset(.free_all);
 }
 
 // Commands ====================================================================================================
@@ -206,6 +208,36 @@ pub fn copyBuffer(interface: *Interface, src: *base.Buffer, dst: *base.Buffer, r
     self.commands.append(allocator, Command.from(cmd)) catch return VkError.OutOfHostMemory;
 }
 
+pub fn copyBufferToImage(interface: *Interface, src: *base.Buffer, dst: *base.Image, dst_layout: vk.ImageLayout, regions: []const vk.BufferImageCopy) VkError!void {
+    const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
+    const allocator = self.command_allocator.allocator();
+
+    const CommandImpl = struct {
+        const Impl = @This();
+
+        src: *const SoftBuffer,
+        dst: *SoftImage,
+        dst_layout: vk.ImageLayout,
+        regions: []const vk.BufferImageCopy,
+
+        pub fn execute(impl: *const Impl, _: *ExecutionDevice) VkError!void {
+            for (impl.regions[0..]) |region| {
+                try impl.dst.copyFromBuffer(impl.src, region);
+            }
+        }
+    };
+
+    const cmd = allocator.create(CommandImpl) catch return VkError.OutOfHostMemory;
+    errdefer allocator.destroy(cmd);
+    cmd.* = .{
+        .src = @alignCast(@fieldParentPtr("interface", src)),
+        .dst_layout = dst_layout,
+        .dst = @alignCast(@fieldParentPtr("interface", dst)),
+        .regions = allocator.dupe(vk.BufferImageCopy, regions) catch return VkError.OutOfHostMemory, // Will be freed on cmdbuf reset or destroy
+    };
+    self.commands.append(allocator, Command.from(cmd)) catch return VkError.OutOfHostMemory;
+}
+
 pub fn copyImage(interface: *Interface, src: *base.Image, src_layout: vk.ImageLayout, dst: *base.Image, dst_layout: vk.ImageLayout, regions: []const vk.ImageCopy) VkError!void {
     const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
     const allocator = self.command_allocator.allocator();
@@ -249,7 +281,9 @@ pub fn copyImageToBuffer(interface: *Interface, src: *base.Image, src_layout: vk
         regions: []const vk.BufferImageCopy,
 
         pub fn execute(impl: *const Impl, _: *ExecutionDevice) VkError!void {
-            try impl.src.copyImageToBuffer(impl.src_layout, impl.dst, impl.regions);
+            for (impl.regions[0..]) |region| {
+                try impl.dst.copyToBuffer(impl.dst, region);
+            }
         }
     };
 
@@ -348,6 +382,31 @@ pub fn fillBuffer(interface: *Interface, buffer: *base.Buffer, offset: vk.Device
     self.commands.append(allocator, Command.from(cmd)) catch return VkError.OutOfHostMemory;
 }
 
+pub fn pipelineBarrier(interface: *Interface, src_stage: vk.PipelineStageFlags, dst_stage: vk.PipelineStageFlags, dependency: vk.DependencyFlags, memory_barriers: []const vk.MemoryBarrier, buffer_barriers: []const vk.BufferMemoryBarrier, image_barriers: []const vk.ImageMemoryBarrier) VkError!void {
+    const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
+    const allocator = self.command_allocator.allocator();
+
+    const CommandImpl = struct {
+        const Impl = @This();
+
+        pub fn execute(_: *const Impl, _: *ExecutionDevice) VkError!void {
+            // TODO: implement synchronization for rasterizations stages
+        }
+    };
+
+    const cmd = allocator.create(CommandImpl) catch return VkError.OutOfHostMemory;
+    errdefer allocator.destroy(cmd);
+    cmd.* = .{};
+    self.commands.append(allocator, Command.from(cmd)) catch return VkError.OutOfHostMemory;
+
+    _ = src_stage;
+    _ = dst_stage;
+    _ = dependency;
+    _ = memory_barriers;
+    _ = buffer_barriers;
+    _ = image_barriers;
+}
+
 pub fn resetEvent(interface: *Interface, event: *base.Event, stage: vk.PipelineStageFlags) VkError!void {
     // No-op
     _ = interface;

src/soft/SoftImage.zig

@@ -68,39 +68,52 @@ pub fn copyImage(self: *const Self, self_layout: vk.ImageLayout, dst: *Self, dst
     std.log.scoped(.commandExecutor).warn("FIXME: implement image to image copy", .{});
 }
 
-pub fn copyImageToBuffer(self: *const Self, self_layout: vk.ImageLayout, dst: *SoftBuffer, regions: []const vk.BufferImageCopy) VkError!void {
-    _ = self_layout;
-    for (regions) |region| {
-        const src_memory = if (self.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-        const dst_memory = if (dst.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
-
-        const pixel_size: u32 = @intCast(self.interface.getPixelSize());
-        const image_row_pitch: u32 = self.interface.extent.width * pixel_size;
-        const image_size: u32 = @intCast(self.interface.getTotalSize());
-
-        const buffer_row_length: u32 = if (region.buffer_row_length != 0) region.buffer_row_length else region.image_extent.width;
-        const buffer_row_pitch: u32 = buffer_row_length * pixel_size;
-        const buffer_size: u32 = buffer_row_pitch * region.image_extent.height * region.image_extent.depth;
-
-        const src_map: []u8 = @as([*]u8, @ptrCast(try src_memory.map(0, image_size)))[0..image_size];
-        const dst_map: []u8 = @as([*]u8, @ptrCast(try dst_memory.map(region.buffer_offset, buffer_size)))[0..buffer_size];
-
-        const row_size = region.image_extent.width * pixel_size;
-        for (0..self.interface.extent.depth) |z| {
-            for (0..self.interface.extent.height) |y| {
-                const z_as_u32: u32 = @intCast(z);
-                const y_as_u32: u32 = @intCast(y);
-
-                const src_offset = ((@as(u32, @intCast(region.image_offset.z)) + z_as_u32) * self.interface.extent.height + @as(u32, @intCast(region.image_offset.y)) + y_as_u32) * image_row_pitch + @as(u32, @intCast(region.image_offset.x)) * pixel_size;
-                const dst_offset = (z_as_u32 * buffer_row_length * region.image_extent.height + y_as_u32 * buffer_row_length) * pixel_size;
-
-                const src_slice = src_map[src_offset..(src_offset + row_size)];
-                const dst_slice = dst_map[dst_offset..(dst_offset + row_size)];
-                @memcpy(dst_slice, src_slice);
-            }
-        }
-
-        src_memory.unmap();
-        dst_memory.unmap();
-    }
+pub fn copyToBuffer(self: *const Self, dst: *SoftBuffer, region: vk.BufferImageCopy) VkError!void {
+    const dst_size = dst.interface.size - region.buffer_offset;
+    const dst_memory = if (dst.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
+    const dst_map: []u8 = @as([*]u8, @ptrCast(try dst_memory.map(region.buffer_offset, dst_size)))[0..dst_size];
+    try self.copy(
+        null,
+        dst_map,
+        @intCast(region.buffer_row_length),
+        @intCast(region.buffer_image_height),
+        region.image_subresource,
+        region.image_offset,
+        region.image_extent,
+    );
+}
+
+pub fn copyFromBuffer(self: *const Self, src: *SoftBuffer, region: vk.BufferImageCopy) VkError!void {
+    const src_size = src.interface.size - region.buffer_offset;
+    const src_memory = if (src.interface.memory) |memory| memory else return VkError.InvalidDeviceMemoryDrv;
+    const src_map: []u8 = @as([*]u8, @ptrCast(try src_memory.map(region.buffer_offset, src_size)))[0..src_size];
+    try self.copy(
+        src_map,
+        null,
+        @intCast(region.buffer_row_length),
+        @intCast(region.buffer_image_height),
+        region.image_subresource,
+        region.image_offset,
+        region.image_extent,
+    );
+}
+
+pub fn copy(
+    self: *Self,
+    src_memory: ?[]const u8,
+    dst_memory: ?[]u8,
+    row_len: usize,
+    image_height: usize,
+    image_subresource: vk.ImageSubresourceLayers,
+    image_copy_offset: vk.Offset3D,
+    image_copy_extent: vk.Extent3D,
+) VkError!void {
+    _ = self;
+    _ = src_memory;
+    _ = dst_memory;
+    _ = row_len;
+    _ = image_height;
+    _ = image_subresource;
+    _ = image_copy_offset;
+    _ = image_copy_extent;
 }

src/soft/device/ComputeRoutines.zig

@@ -64,18 +64,6 @@ pub fn dispatch(self: *Self, group_count_x: u32, group_count_y: u32, group_count
                 .pipeline = pipeline,
             },
         });
-        //runWrapper(
-        //    RunData{
-        //        .self = self,
-        //        .batch_id = batch_id,
-        //        .group_count = group_count,
-        //        .group_count_x = @as(usize, @intCast(group_count_x)),
-        //        .group_count_y = @as(usize, @intCast(group_count_y)),
-        //        .group_count_z = @as(usize, @intCast(group_count_z)),
-        //        .invocations_per_workgroup = invocations_per_workgroup,
-        //        .pipeline = pipeline,
-        //    },
-        //);
     }
     self.device.workers.waitAndWork(&wg);
 }