impriving architecture

src/soft/Instance.zig

@@ -0,0 +1,48 @@
+const std = @import("std");
+const vk = @import("vulkan");
+const common = @import("common");
+const PhysicalDevice = @import("PhysicalDevice.zig");
+
+const dispatchable = common.dispatchable;
+
+const Self = @This();
+pub const ObjectType: vk.ObjectType = .instance;
+
+common_instance: common.Instance,
+physical_device: dispatchable.Dispatchable(PhysicalDevice), // Software driver only has one physical device (CPU)
+
+pub fn create(p_infos: ?*const vk.InstanceCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_instance: *vk.Instance) callconv(vk.vulkan_call_conv) vk.Result {
+    const allocator = std.heap.c_allocator;
+
+    const dispatchable_object = dispatchable.Dispatchable(Self).create(allocator, ObjectType) catch return .error_out_of_host_memory;
+    common.Instance.init(&dispatchable_object.object.common_instance, p_infos, callbacks) catch return .error_initialization_failed;
+
+    dispatchable_object.object.common_instance.vtable = .{
+        .destroyInstance = destroy,
+        .enumeratePhysicalDevices = enumeratePhysicalDevices,
+        .enumerateInstanceVersion = null,
+        //.enumerateInstanceLayerProperties = null,
+        .enumerateInstanceExtensionProperties = null,
+    };
+
+    dispatchable_object.object.physical_device.init() catch return .error_initialization_failed;
+
+    p_instance.* = @enumFromInt(dispatchable.toHandle(Self, dispatchable_object));
+    return .success;
+}
+
+pub fn enumeratePhysicalDevices(p_instance: vk.Instance, count: *u32, devices: *vk.PhysicalDevice) callconv(vk.vulkan_call_conv) vk.Result {
+    const dispatchable_object = common.dispatchable.fromHandle(Self, @intFromEnum(p_instance)) catch return .error_initialization_failed;
+    _ = dispatchable_object;
+    _ = count;
+    _ = devices;
+    return .success;
+}
+
+pub fn destroy(p_instance: vk.Instance, callbacks: ?*const vk.AllocationCallbacks) callconv(vk.vulkan_call_conv) void {
+    const allocator = std.heap.c_allocator;
+    _ = callbacks;
+
+    const dispatchable_object = common.dispatchable.fromHandle(Self, @intFromEnum(p_instance)) catch return;
+    dispatchable_object.destroy(allocator);
+}

src/soft/PhysicalDevice.zig

@@ -0,0 +1,26 @@
+const std = @import("std");
+const vk = @import("vulkan");
+const Instance = @import("Instance.zig");
+const common = @import("common");
+
+const dispatchable = common.dispatchable;
+
+const Self = @This();
+const ObjectType: vk.ObjectType = .physical_device;
+
+instance: *const Instance,
+common_physical_device: common.PhysicalDevice,
+
+pub fn init(self: *Self) !void {
+    self.common_physical_device.props = .{
+			.apiVersion = ,
+			.driverVersion = VKD_DRIVER_VERSION,
+			.vendorID = 0x0601,
+			.deviceID = 0x060103,
+			.deviceType = VK_PHYSICAL_DEVICE_TYPE_CPU,
+			.deviceName = {},
+			.pipelineCacheUUID = {},
+			.limits = {},
+			.sparseProperties = {},
+		};
+}

src/soft/lib.zig

@@ -2,6 +2,17 @@ const std = @import("std");
 const vk = @import("vulkan");
 const common = @import("common");
 
-export fn libVulkanExport() void {
-    _ = common;
+const Instance = @import("Instance.zig");
+
+const global_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{
+    .{ "vkGetInstanceProcAddr", @as(vk.PfnVoidFunction, @ptrCast(&common.icd.getInstanceProcAddr)) },
+    .{ "vkCreateInstance", @as(vk.PfnVoidFunction, @ptrCast(&Instance.create)) },
+});
+
+pub export fn vkGetInstanceProcAddr(p_instance: vk.Instance, pName: ?[*:0]const u8) callconv(vk.vulkan_call_conv) vk.PfnVoidFunction {
+    if (pName == null) {
+        return null;
+    }
+    const name = std.mem.span(pName.?);
+    return common.icd.getInstanceProcAddr(global_pfn_map, p_instance, name);
 }