kbz_8/VulkanDriver
1
0
Fork 0
Code Issues Pull Requests actions.actions Packages Projects Releases Wiki Activity

cleaning dispatchable handle support

Browse Source
This commit is contained in:
kbz_8
2025-11-02 02:43:38 +01:00
parent 7639c40074
commit 697b67e07a
8 changed files with 74 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/soft/Instance.zig
View File

@@ -9,33 +9,38 @@ 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)
physical_device: vk.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;
const dispatchable_instance = dispatchable.Dispatchable(Self).create(allocator) catch return .error_out_of_host_memory;
const instance = dispatchable_instance.object;
common.Instance.init(&instance.common_instance, p_infos, callbacks) catch return .error_initialization_failed;
dispatchable_object.object.common_instance.vtable = .{
instance.common_instance.vtable = .{
.destroyInstance = destroy,
.enumeratePhysicalDevices = enumeratePhysicalDevices,
.enumerateInstanceVersion = null,
//.enumerateInstanceLayerProperties = null,
.enumerateInstanceExtensionProperties = null,
.getPhysicalDeviceProperties = PhysicalDevice.getProperties,
};
dispatchable_object.object.physical_device.init() catch return .error_initialization_failed;
const dispatchable_physical_device = dispatchable.Dispatchable(PhysicalDevice).create(allocator) catch return .error_out_of_host_memory;
PhysicalDevice.init(dispatchable_physical_device.object) catch return .error_initialization_failed;
instance.physical_device = @enumFromInt(dispatchable_physical_device.toHandle());
p_instance.* = @enumFromInt(dispatchable.toHandle(Self, dispatchable_object));
p_instance.* = @enumFromInt(dispatchable_instance.toHandle());
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;
pub fn enumeratePhysicalDevices(p_instance: vk.Instance, count: *u32, p_devices: ?[*]vk.PhysicalDevice) callconv(vk.vulkan_call_conv) vk.Result {
const instance = dispatchable.fromHandleObject(Self, @intFromEnum(p_instance)) catch return .error_initialization_failed;
count.* = 1;
if (p_devices) |devices| {
devices[0] = instance.physical_device;
}
return .success;
}
@@ -43,6 +48,8 @@ pub fn destroy(p_instance: vk.Instance, callbacks: ?*const vk.AllocationCallback
const allocator = std.heap.c_allocator;
_ = callbacks;
const dispatchable_object = common.dispatchable.fromHandle(Self, @intFromEnum(p_instance)) catch return;
dispatchable_object.destroy(allocator);
const dispatchable_instance = dispatchable.fromHandle(Self, @intFromEnum(p_instance)) catch return;
const dispatchable_physical_device = dispatchable.fromHandle(PhysicalDevice, @intFromEnum(dispatchable_instance.object.physical_device)) catch return;
dispatchable_physical_device.destroy(allocator);
dispatchable_instance.destroy(allocator);
}

29
src/soft/PhysicalDevice.zig
View File

@@ -6,21 +6,28 @@ const common = @import("common");
const dispatchable = common.dispatchable;
const Self = @This();
const ObjectType: vk.ObjectType = .physical_device;
pub 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 = {},
};
.api_version = @bitCast(common.DRIVER_VULKAN_VERSION),
.driver_version = @bitCast(common.DRIVER_VERSION),
.vendor_id = 0x0601,
.device_id = 0x060103,
.device_type = .cpu,
.device_name = [_]u8{0} ** vk.MAX_PHYSICAL_DEVICE_NAME_SIZE,
.pipeline_cache_uuid = undefined,
.limits = undefined,
.sparse_properties = undefined,
};
var writer = std.io.Writer.fixed(&self.common_physical_device.props.device_name);
try writer.print("Software Vulkan Driver", .{});
}
pub fn getProperties(p_physical_device: vk.PhysicalDevice, properties: *vk.PhysicalDeviceProperties) callconv(vk.vulkan_call_conv) void {
const physical_device = dispatchable.fromHandleObject(Self, @intFromEnum(p_physical_device)) catch return;
properties.* = physical_device.common_physical_device.props;
}