implementing proper graphics pipeline creations

src/soft/device/ComputeDispatcher.zig

@@ -63,33 +63,21 @@ pub fn dispatch(self: *Self, group_count_x: u32, group_count_y: u32, group_count
 
     var wg: std.Io.Group = .init;
     for (0..@min(self.batch_size, group_count)) |batch_id| {
-        if (comptime base.config.single_threaded_compute) {
-            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,
-                },
-            );
-        } else {
-            wg.async(self.device.interface.io(), 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,
-                },
-            });
-        }
+        const run_data: 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,
+        };
+
+        if (comptime base.config.single_threaded_compute)
+            runWrapper(run_data)
+        else
+            wg.async(self.device.interface.io(), runWrapper, .{run_data});
     }
     wg.await(self.device.interface.io()) catch return VkError.DeviceLost;
 }

src/soft/device/Device.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const vk = @import("vulkan");
 const base = @import("base");
+const lib = @import("../lib.zig");
 
 const SoftDescriptorSet = @import("../SoftDescriptorSet.zig");
 const SoftDevice = @import("../SoftDevice.zig");
@@ -15,29 +16,45 @@ const VkError = base.VkError;
 
 const Self = @This();
 
+pub const GRAPHICS_PIPELINE_STATE = 0;
+pub const COMPUTE_PIPELINE_STATE = 1;
+
 pub const PipelineState = struct {
     pipeline: ?*SoftPipeline,
     sets: [base.VULKAN_MAX_DESCRIPTOR_SETS]?*SoftDescriptorSet,
+    data: union {
+        compute: struct {},
+        graphics: struct {
+            vertex_buffers: [lib.MAX_VERTEX_INPUT_BINDINGS]Renderer.VertexBuffer,
+        },
+    },
 };
 
 compute: ComputeDispatcher,
 renderer: Renderer,
 
-/// .graphics = 0
-/// .compute = 1
 pipeline_states: [2]PipelineState,
 
 /// Initializating an execution device and
 /// not creating one to avoid dangling pointers
 pub fn init(self: *Self, device: *SoftDevice) void {
-    for (self.pipeline_states[0..]) |*state| {
+    for (self.pipeline_states[0..], 0..) |*state, i| {
         state.* = .{
             .pipeline = null,
             .sets = [_]?*SoftDescriptorSet{null} ** base.VULKAN_MAX_DESCRIPTOR_SETS,
+            .data = switch (i) {
+                GRAPHICS_PIPELINE_STATE => .{
+                    .graphics = .{
+                        .vertex_buffers = undefined,
+                    },
+                },
+                COMPUTE_PIPELINE_STATE => .{ .compute = .{} },
+                else => unreachable,
+            },
         };
     }
     self.compute = .init(device, &self.pipeline_states[@intFromEnum(vk.PipelineBindPoint.compute)]);
-    self.renderer = .init();
+    self.renderer = .init(device, &self.pipeline_states[@intFromEnum(vk.PipelineBindPoint.compute)]);
 }
 
 pub fn deinit(self: *Self) void {

src/soft/device/Renderer.zig

@@ -1,8 +1,13 @@
 const std = @import("std");
 const vk = @import("vulkan");
 const base = @import("base");
+const zm = @import("zmath");
 const lib = @import("../lib.zig");
 
+const F32x4 = zm.F32x4;
+
+const PipelineState = @import("Device.zig").PipelineState;
+
 const SoftBuffer = @import("../SoftBuffer.zig");
 const SoftDescriptorSet = @import("../SoftDescriptorSet.zig");
 const SoftDevice = @import("../SoftDevice.zig");
@@ -42,22 +47,48 @@ pub const DynamicState = struct {
 
     vertex_input_bindings: [lib.MAX_VERTEX_INPUT_BINDINGS]VertexInputBindingState,
     vertex_input_attributes: [lib.MAX_VERTEX_INPUT_ATTRIBUTES]VertexInputAttributeState,
-
-    vertex_buffers: [lib.MAX_VERTEX_INPUT_BINDINGS]VertexBuffer,
 };
 
+const Vertex = struct {
+    position: F32x4,
+    point_size: f32,
+    index: usize,
+};
+
+device: *SoftDevice,
+state: *PipelineState,
+
 render_pass: ?*SoftRenderPass,
 framebuffer: ?*SoftFramebuffer,
 dynamic_state: DynamicState,
 
-pub fn init() Self {
+pub fn init(device: *SoftDevice, state: *PipelineState) Self {
     return .{
+        .device = device,
+        .state = state,
         .render_pass = null,
         .framebuffer = null,
         .dynamic_state = undefined,
     };
 }
 
+pub fn drawPrimitive(self: *Self, vertex_count: usize, instance_count: usize, first_vertex: usize, first_instance: usize) void {
+    const allocator = self.device.device_allocator.allocator();
+
+    const vertices = self.fetchVertexInput(allocator, vertex_count, instance_count, first_vertex, first_instance);
+    _ = vertices;
+}
+
 pub fn deinit(self: *Self) void {
     _ = self;
 }
+
+fn fetchVertexInput(self: *const Self, allocator: std.mem.Allocator, vertex_count: usize, instance_count: usize, first_vertex: usize, first_instance: usize) []Vertex {
+    _ = self;
+    _ = allocator;
+    _ = vertex_count;
+    _ = instance_count;
+    _ = first_vertex;
+    _ = first_instance;
+    return undefined;
+}