Refactor literally everything

src/engine/StagingBuffer.zig

@@ -4,51 +4,69 @@ const std = @import("std");
 const vk = @import("vulkan");
 
 const Engine = @import("Engine.zig");
-const QSM = @import("QueueSharingMode.zig");
+const TargetQueue = @import("TargetQueue.zig").TargetQueue;
 
 buffer: vk.Buffer,
-memory: vk.DeviceMemory,
+device_memory: vk.DeviceMemory,
+capacity: u32,
 
-pub fn init(engine: *Engine, data: []const u8, destination_queue_family: u32) !StagingBuffer {
+pub const InitInfo = struct {
+    target_queue: TargetQueue,
+    capacity: u32,
+};
+
+pub fn init(engine: *Engine, init_info: InitInfo) !StagingBuffer {
+    const target_queue_family = switch (init_info.target_queue) {
+        .graphics => engine.graphics_queue.allocation.family,
+        .compute => engine.compute_queue.allocation.family,
+    };
     const transfer_queue_family = engine.transfer_queue.allocation.family;
 
-    const qsm = QSM.resolve(destination_queue_family, transfer_queue_family);
-    const buffer = try engine.device.createBuffer(&.{
-        .size = data.len,
+    const buffer = try engine.createBuffer(.{
+        .size = init_info.capacity,
         .usage = .{
             .transfer_src_bit = true,
         },
-        .sharing_mode = qsm.sharing_mode,
-        .queue_family_index_count = qsm.queue_family_index_count,
-        .p_queue_family_indices = qsm.p_queue_family_indices,
-    }, &engine.vk_allocator.interface);
-    errdefer engine.device.destroyBuffer(buffer, &engine.vk_allocator.interface);
+        .queue_family_indices = &.{ target_queue_family, transfer_queue_family },
+    });
+    errdefer engine.destroyBuffer(buffer);
 
     const memory_requirements = engine.device.getBufferMemoryRequirements(buffer);
-    const memory = try engine.allocate(
+    const device_memory = try engine.allocate(
         memory_requirements,
         .{
             .host_visible_bit = true,
             .host_coherent_bit = true,
         },
     );
-    errdefer engine.device.freeMemory(memory, &engine.vk_allocator.interface);
+    errdefer engine.freeMemory(device_memory);
 
-    try engine.device.bindBufferMemory(buffer, memory, 0);
-
-    const mapped_memory: [*]u8 = @ptrCast(try engine.device.mapMemory(memory, 0, data.len, .{}) orelse return error.OutOfMemory);
-    defer engine.device.unmapMemory(memory);
-    @memcpy(mapped_memory, data);
+    try engine.device.bindBufferMemory(buffer, device_memory, 0);
 
     return .{
         .buffer = buffer,
-        .memory = memory,
+        .device_memory = device_memory,
+        .capacity = init_info.capacity,
     };
 }
 
 pub fn deinit(self: *StagingBuffer, engine: *Engine) void {
-    engine.device.freeMemory(self.memory, &engine.vk_allocator.interface);
-    engine.device.destroyBuffer(self.buffer, &engine.vk_allocator.interface);
+    engine.freeMemory(self.device_memory);
+    engine.destroyBuffer(self.buffer);
 
     self.* = undefined;
 }
+
+pub fn map(self: StagingBuffer, engine: *Engine) ![]u8 {
+    const mapped_memory = try self.mapPartial(engine, 0, self.capacity);
+    return mapped_memory;
+}
+
+pub fn mapPartial(self: StagingBuffer, engine: *Engine, offset: u32, len: u32) ![]u8 {
+    const mapped_memory = try engine.device.mapMemory(self.device_memory, offset, len, .{});
+    return @as([*]u8, @ptrCast(mapped_memory))[0..len];
+}
+
+pub fn unmap(self: StagingBuffer, engine: *Engine) void {
+    engine.device.unmapMemory(self.device_memory);
+}