fixing vulkan entrypoints for extensions

src/vulkan/Device.zig

@@ -41,6 +41,8 @@ instance: *Instance,
 physical_device: *const PhysicalDevice,
 queues: std.AutoArrayHashMapUnmanaged(u32, std.ArrayList(*Dispatchable(Queue))),
 host_allocator: VulkanAllocator,
+enabled_khr_swapchain: bool,
+enabled_khr_device_group: bool,
 
 dispatch_table: *const DispatchTable,
 vtable: *const VTable,
@@ -77,12 +79,37 @@ pub const DispatchTable = struct {
     getDeviceGroupSurfacePresentModesKHR: *const fn (*Self, *SurfaceKHR) VkError!vk.DeviceGroupPresentModeFlagsKHR,
 };
 
-pub fn init(allocator: std.mem.Allocator, instance: *Instance, physical_device: *const PhysicalDevice, _: *const vk.DeviceCreateInfo) VkError!Self {
+pub fn isExtensionEnabled(self: *const Self, extension: vk.ApiInfo) bool {
+    if (std.mem.eql(u8, extension.name, vk.extensions.khr_swapchain.name)) {
+        return self.enabled_khr_swapchain;
+    }
+    if (std.mem.eql(u8, extension.name, vk.extensions.khr_device_group.name)) {
+        return self.enabled_khr_device_group;
+    }
+    return false;
+}
+
+pub fn init(allocator: std.mem.Allocator, instance: *Instance, physical_device: *const PhysicalDevice, info: *const vk.DeviceCreateInfo) VkError!Self {
+    var enabled_khr_swapchain = false;
+    var enabled_khr_device_group = false;
+    if (info.pp_enabled_extension_names) |names| {
+        for (0..info.enabled_extension_count) |i| {
+            const name = std.mem.span(names[i]);
+            if (std.mem.eql(u8, name, vk.extensions.khr_swapchain.name)) {
+                enabled_khr_swapchain = true;
+            } else if (std.mem.eql(u8, name, vk.extensions.khr_device_group.name)) {
+                enabled_khr_device_group = true;
+            }
+        }
+    }
+
     return .{
         .instance = instance,
         .physical_device = physical_device,
         .queues = .empty,
         .host_allocator = VulkanAllocator.from(allocator).cloneWithScope(.object),
+        .enabled_khr_swapchain = enabled_khr_swapchain,
+        .enabled_khr_device_group = enabled_khr_device_group,
         .dispatch_table = undefined,
         .vtable = undefined,
     };

src/vulkan/lib_vulkan.zig

@@ -277,6 +277,29 @@ const device_pfn_map = block: {
     });
 };
 
+const DeviceEntryPointRequirement = union(enum) {
+    device_extension: vk.ApiInfo,
+    unsupported_extension,
+};
+
+const device_entry_point_requirements = std.StaticStringMap(DeviceEntryPointRequirement).initComptime(.{
+    .{ "vkAcquireNextImageKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+    .{ "vkAcquireNextImage2KHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+    .{ "vkCreateSwapchainKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+    .{ "vkDestroySwapchainKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+    .{ "vkGetDeviceGroupPresentCapabilitiesKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+    .{ "vkGetDeviceGroupSurfacePresentModesKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+    .{ "vkGetSwapchainImagesKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+    .{ "vkQueuePresentKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_swapchain } },
+
+    .{ "vkCmdDispatchBaseKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_device_group } },
+    .{ "vkCmdSetDeviceMaskKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_device_group } },
+    .{ "vkGetDeviceGroupPeerMemoryFeaturesKHR", DeviceEntryPointRequirement{ .device_extension = vk.extensions.khr_device_group } },
+
+    .{ "vkGetBufferDeviceAddressEXT", DeviceEntryPointRequirement.unsupported_extension },
+    .{ "vkGetBufferDeviceAddressKHR", DeviceEntryPointRequirement.unsupported_extension },
+});
+
 // ICD Interface =============================================================================================================================================
 
 pub export fn ape_icdNegotiateLoaderICDInterfaceVersion(p_version: *u32) callconv(vk.vulkan_call_conv) vk.Result {
@@ -1502,6 +1525,11 @@ pub export fn apeGetDeviceProcAddr(p_device: vk.Device, p_name: ?[*:0]const u8)
     const name = std.mem.span(p_name.?);
 
     if (p_device == .null_handle) return null;
+    const device = Dispatchable(Device).fromHandleObject(p_device) catch return null;
+    if (device_entry_point_requirements.get(name)) |requirement| switch (requirement) {
+        .device_extension => |extension| if (!device.isExtensionEnabled(extension)) return null,
+        .unsupported_extension => return null,
+    };
     if (device_pfn_map.get(name)) |pfn| return pfn;
 
     return null;