From e9199a0abc326933b8a3df7cc5a7f4d606cf8ef7 Mon Sep 17 00:00:00 2001 From: Patrick O'Connell Date: Sun, 23 Jun 2024 10:22:24 -0700 Subject: [PATCH 1/6] Extract some helper functions --- src/vulkan/render.zig | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/src/vulkan/render.zig b/src/vulkan/render.zig index fe8f0a1..32bca0d 100644 --- a/src/vulkan/render.zig +++ b/src/vulkan/render.zig @@ -1585,15 +1585,12 @@ fn Renderer(comptime WriterType: type) type { proxy, }; - fn renderWrapperPrototype( + fn renderWrapperName( self: *Self, name: []const u8, - command: reg.Command, - returns: []const ReturnValue, dispatch_handle: []const u8, kind: WrapperKind, ) !void { - try self.writer.writeAll("pub fn "); const trimmed_name = switch (kind) { .wrapper => trimVkNamespace(name), .proxy => blk: { @@ -1608,7 +1605,25 @@ fn Renderer(comptime WriterType: type) type { }, }; try self.writeIdentifierWithCase(.camel, trimmed_name); + } + fn renderWrapperParam(self: *Self, param: reg.Command.Param) !void { + try self.writeIdentifierWithCase(.snake, param.name); + try self.writer.writeAll(": "); + try self.renderTypeInfo(param.param_type); + try self.writer.writeAll(", "); + } + + fn renderWrapperPrototype( + self: *Self, + name: []const u8, + command: reg.Command, + returns: []const ReturnValue, + dispatch_handle: []const u8, + kind: WrapperKind, + ) !void { + try self.writer.writeAll("pub fn "); + try self.renderWrapperName(name, dispatch_handle, kind); try self.writer.writeAll("(self: Self, "); for (command.params) |param| { @@ -1623,10 +1638,7 @@ fn Renderer(comptime WriterType: type) type { continue; } - try self.writeIdentifierWithCase(.snake, param.name); - try self.writer.writeAll(": "); - try self.renderTypeInfo(param.param_type); - try self.writer.writeAll(", "); + try self.renderWrapperParam(param); } try self.writer.writeAll(") "); From a2b49336d1fdcd46383cb16627f034900b093af3 Mon Sep 17 00:00:00 2001 From: Patrick O'Connell Date: Sun, 23 Jun 2024 10:54:22 -0700 Subject: [PATCH 2/6] Add `*Alloc()` wrappers --- src/vulkan/render.zig | 116 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) diff --git a/src/vulkan/render.zig b/src/vulkan/render.zig index 32bca0d..18fc3a9 100644 --- a/src/vulkan/render.zig +++ b/src/vulkan/render.zig @@ -14,6 +14,7 @@ const preamble = \\const builtin = @import("builtin"); \\const root = @import("root"); \\const vk = @This(); + \\const Allocator = std.mem.Allocator; \\ \\pub const vulkan_call_conv: std.builtin.CallingConvention = if (builtin.os.tag == .windows and builtin.cpu.arch == .x86) \\ .Stdcall @@ -191,6 +192,13 @@ const dispatch_override_functions = std.StaticStringMap(CommandDispatchType).ini .{ "vkCreateInstance", .base }, }); +// Functions that return an array of objects via a count and data pointer. +const enumerate_functions = std.StaticStringMap(void).initComptime(.{ + .{"vkEnumerateInstanceExtensionProperties"}, + .{"vkEnumeratePhysicalDevices"}, + .{"vkGetPhysicalDeviceQueueFamilyProperties"}, +}); + fn eqlIgnoreCase(lhs: []const u8, rhs: []const u8) bool { if (lhs.len != rhs.len) { return false; @@ -1410,6 +1418,9 @@ fn Renderer(comptime WriterType: type) type { // for newer versions of vulkan can still invoke extension behavior on older // implementations. try self.renderWrapper(decl.name, command); + if (enumerate_functions.has(decl.name)) { + try self.renderWrapperAlloc(decl.name, command); + } } try self.writer.writeAll("};}\n"); @@ -1836,6 +1847,111 @@ fn Renderer(comptime WriterType: type) type { try self.writer.writeAll("}\n"); } + fn renderWrapperAlloc(self: *Self, wrapped_name: []const u8, command: reg.Command) !void { + const returns_vk_result = command.return_type.* == .name and mem.eql(u8, command.return_type.name, "VkResult"); + + const name = try std.mem.concat(self.allocator, u8, &.{ wrapped_name, "Alloc" }); + defer self.allocator.free(name); + + if (command.params.len < 2) { + return error.InvalidRegistry; + } + const params = command.params[0 .. command.params.len - 2]; + + const count_param = command.params[command.params.len - 2]; + if (!count_param.is_buffer_len) { + return error.InvalidRegistry; + } + + const data_param = command.params[command.params.len - 1]; + const data_type = switch (data_param.param_type) { + .pointer => |pointer| pointer.child.*, + else => return error.InvalidRegistry, + }; + + if (returns_vk_result) { + try self.writer.writeAll("pub const "); + try self.renderErrorSetName(name); + try self.writer.writeAll(" =\n "); + try self.renderErrorSetName(wrapped_name); + try self.writer.writeAll(" || Allocator.Error;\n"); + } + + try self.writer.writeAll("pub fn "); + try self.renderWrapperName(name, "", .wrapper); + try self.writer.writeAll("(self: Self, "); + for (params) |param| { + try self.renderWrapperParam(param); + } + try self.writer.writeAll("allocator: Allocator,) "); + + if (returns_vk_result) { + try self.renderErrorSetName(name); + } else { + try self.writer.writeAll("Allocator.Error"); + } + + try self.writer.writeAll("![]"); + try self.renderTypeInfo(data_type); + try self.writer.writeAll( + \\{ + \\ var count: u32 = undefined; + ); + + if (returns_vk_result) { + try self.writer.writeAll("var data: []"); + try self.renderTypeInfo(data_type); + try self.writer.writeAll( + \\ = &.{}; + \\errdefer allocator.free(data); + \\var result = Result.incomplete; + \\while (result == .incomplete) { + \\ _ = try + ); + } + + try self.writer.writeAll(" self."); + try self.renderWrapperName(wrapped_name, "", .wrapper); + try self.writer.writeAll("(\n"); + for (params) |param| { + try self.writeIdentifierWithCase(.snake, param.name); + try self.writer.writeAll(", "); + } + try self.writer.writeAll("&count, null);\n"); + + if (returns_vk_result) { + try self.writer.writeAll( + \\data = try allocator.realloc(data, count); + \\result = try + ); + } else { + try self.writer.writeAll("const data = try allocator.alloc("); + try self.renderTypeInfo(data_type); + try self.writer.writeAll( + \\, count); + \\errdefer allocator.free(data); + ); + } + + try self.writer.writeAll(" self."); + try self.renderWrapperName(wrapped_name, "", .wrapper); + try self.writer.writeAll("(\n"); + for (params) |param| { + try self.writeIdentifierWithCase(.snake, param.name); + try self.writer.writeAll(", "); + } + try self.writer.writeAll("&count, data.ptr);\n"); + + if (returns_vk_result) { + try self.writer.writeAll("}\n"); + } + + try self.writer.writeAll( + \\ return if (count == data.len) data else allocator.realloc(data, count); + \\} + ); + } + fn renderErrorSwitch(self: *Self, result_var: []const u8, command: reg.Command) !void { try self.writer.writeAll("switch ("); try self.writeIdentifier(result_var); From 7a6986fabac0d34361669738419c94c883990c0e Mon Sep 17 00:00:00 2001 From: Patrick O'Connell Date: Sat, 29 Jun 2024 16:53:30 -0700 Subject: [PATCH 3/6] Proxy wrappers for slice functions --- src/vulkan/render.zig | 137 +++++++++++++++++++++++++++++++++--------- 1 file changed, 107 insertions(+), 30 deletions(-) diff --git a/src/vulkan/render.zig b/src/vulkan/render.zig index 18fc3a9..866f6a4 100644 --- a/src/vulkan/render.zig +++ b/src/vulkan/render.zig @@ -199,6 +199,23 @@ const enumerate_functions = std.StaticStringMap(void).initComptime(.{ .{"vkGetPhysicalDeviceQueueFamilyProperties"}, }); +// Given one of the above commands, returns the type of the array elements +// (and performs some basic verification that the command has the expected signature). +fn getEnumerateFunctionDataType(command: reg.Command) !reg.TypeInfo { + if (command.params.len < 2) { + return error.InvalidRegistry; + } + const count_param = command.params[command.params.len - 2]; + if (!count_param.is_buffer_len) { + return error.InvalidRegistry; + } + const data_param = command.params[command.params.len - 1]; + return switch (data_param.param_type) { + .pointer => |pointer| pointer.child.*, + else => error.InvalidRegistry, + }; +} + fn eqlIgnoreCase(lhs: []const u8, rhs: []const u8) bool { if (lhs.len != rhs.len) { return false; @@ -1522,6 +1539,9 @@ fn Renderer(comptime WriterType: type) type { } try self.renderProxyCommand(decl.name, command, dispatch_handle); + if (enumerate_functions.has(decl.name)) { + try self.renderProxyCommandAlloc(decl.name, command, dispatch_handle); + } } try self.writer.writeAll( @@ -1583,6 +1603,56 @@ fn Renderer(comptime WriterType: type) type { ); } + fn renderProxyCommandAlloc(self: *Self, wrapped_name: []const u8, command: reg.Command, dispatch_handle: []const u8) !void { + const returns_vk_result = command.return_type.* == .name and mem.eql(u8, command.return_type.name, "VkResult"); + + const name = try std.mem.concat(self.allocator, u8, &.{ wrapped_name, "Alloc" }); + defer self.allocator.free(name); + + if (command.params.len < 2) { + return error.InvalidRegistry; + } + const params = command.params[0 .. command.params.len - 2]; + const data_type = try getEnumerateFunctionDataType(command); + + try self.writer.writeAll("pub const "); + try self.renderErrorSetName(name); + try self.writer.writeAll(" = Wrapper."); + try self.renderErrorSetName(name); + try self.writer.writeAll(";\n"); + + try self.renderAllocWrapperPrototype(name, params, returns_vk_result, data_type, dispatch_handle, .proxy); + try self.writer.writeAll( + \\{ + \\return self.wrapper. + ); + try self.writeIdentifierWithCase(.camel, trimVkNamespace(name)); + try self.writer.writeByte('('); + + for (params) |param| { + switch (try self.classifyParam(param)) { + .out_pointer => return error.InvalidRegistry, + .dispatch_handle => { + if (mem.eql(u8, param.param_type.name, dispatch_handle)) { + try self.writer.writeAll("self.handle"); + } else { + try self.writeIdentifierWithCase(.snake, param.name); + } + }, + else => { + try self.writeIdentifierWithCase(.snake, param.name); + }, + } + try self.writer.writeAll(", "); + } + + try self.writer.writeAll( + \\allocator,); + \\} + \\ + ); + } + fn derefName(name: []const u8) []const u8 { var it = id_render.SegmentIterator.init(name); return if (mem.eql(u8, it.next().?, "p")) @@ -1847,40 +1917,24 @@ fn Renderer(comptime WriterType: type) type { try self.writer.writeAll("}\n"); } - fn renderWrapperAlloc(self: *Self, wrapped_name: []const u8, command: reg.Command) !void { - const returns_vk_result = command.return_type.* == .name and mem.eql(u8, command.return_type.name, "VkResult"); - - const name = try std.mem.concat(self.allocator, u8, &.{ wrapped_name, "Alloc" }); - defer self.allocator.free(name); - - if (command.params.len < 2) { - return error.InvalidRegistry; - } - const params = command.params[0 .. command.params.len - 2]; - - const count_param = command.params[command.params.len - 2]; - if (!count_param.is_buffer_len) { - return error.InvalidRegistry; - } - - const data_param = command.params[command.params.len - 1]; - const data_type = switch (data_param.param_type) { - .pointer => |pointer| pointer.child.*, - else => return error.InvalidRegistry, - }; - - if (returns_vk_result) { - try self.writer.writeAll("pub const "); - try self.renderErrorSetName(name); - try self.writer.writeAll(" =\n "); - try self.renderErrorSetName(wrapped_name); - try self.writer.writeAll(" || Allocator.Error;\n"); - } - + fn renderAllocWrapperPrototype( + self: *Self, + name: []const u8, + params: []const reg.Command.Param, + returns_vk_result: bool, + data_type: reg.TypeInfo, + dispatch_handle: []const u8, + kind: WrapperKind, + ) !void { try self.writer.writeAll("pub fn "); try self.renderWrapperName(name, "", .wrapper); try self.writer.writeAll("(self: Self, "); for (params) |param| { + const class = try self.classifyParam(param); + // Skip the dispatch type for proxying wrappers + if (kind == .proxy and class == .dispatch_handle and mem.eql(u8, param.param_type.name, dispatch_handle)) { + continue; + } try self.renderWrapperParam(param); } try self.writer.writeAll("allocator: Allocator,) "); @@ -1893,6 +1947,29 @@ fn Renderer(comptime WriterType: type) type { try self.writer.writeAll("![]"); try self.renderTypeInfo(data_type); + } + + fn renderWrapperAlloc(self: *Self, wrapped_name: []const u8, command: reg.Command) !void { + const returns_vk_result = command.return_type.* == .name and mem.eql(u8, command.return_type.name, "VkResult"); + + const name = try std.mem.concat(self.allocator, u8, &.{ wrapped_name, "Alloc" }); + defer self.allocator.free(name); + + if (command.params.len < 2) { + return error.InvalidRegistry; + } + const params = command.params[0 .. command.params.len - 2]; + const data_type = try getEnumerateFunctionDataType(command); + + if (returns_vk_result) { + try self.writer.writeAll("pub const "); + try self.renderErrorSetName(name); + try self.writer.writeAll(" =\n "); + try self.renderErrorSetName(wrapped_name); + try self.writer.writeAll(" || Allocator.Error;\n"); + } + + try self.renderAllocWrapperPrototype(name, params, returns_vk_result, data_type, "", .wrapper); try self.writer.writeAll( \\{ \\ var count: u32 = undefined; From 4707aca68d467035e9b3b800e7bf35491560aa8f Mon Sep 17 00:00:00 2001 From: Patrick O'Connell Date: Sat, 29 Jun 2024 17:13:06 -0700 Subject: [PATCH 4/6] Use `*Alloc()` functions in example --- examples/graphics_context.zig | 20 +++----------------- examples/swapchain.zig | 17 ++++------------- src/vulkan/render.zig | 4 ++++ 3 files changed, 11 insertions(+), 30 deletions(-) diff --git a/examples/graphics_context.zig b/examples/graphics_context.zig index e6f3727..f2d0fef 100644 --- a/examples/graphics_context.zig +++ b/examples/graphics_context.zig @@ -196,14 +196,9 @@ fn pickPhysicalDevice( allocator: Allocator, surface: vk.SurfaceKHR, ) !DeviceCandidate { - var device_count: u32 = undefined; - _ = try instance.enumeratePhysicalDevices(&device_count, null); - - const pdevs = try allocator.alloc(vk.PhysicalDevice, device_count); + const pdevs = try instance.enumeratePhysicalDevicesAlloc(allocator); defer allocator.free(pdevs); - _ = try instance.enumeratePhysicalDevices(&device_count, pdevs.ptr); - for (pdevs) |pdev| { if (try checkSuitable(instance, pdev, allocator, surface)) |candidate| { return candidate; @@ -240,12 +235,8 @@ fn checkSuitable( } fn allocateQueues(instance: Instance, pdev: vk.PhysicalDevice, allocator: Allocator, surface: vk.SurfaceKHR) !?QueueAllocation { - var family_count: u32 = undefined; - instance.getPhysicalDeviceQueueFamilyProperties(pdev, &family_count, null); - - const families = try allocator.alloc(vk.QueueFamilyProperties, family_count); + const families = try instance.getPhysicalDeviceQueueFamilyPropertiesAlloc(pdev, allocator); defer allocator.free(families); - instance.getPhysicalDeviceQueueFamilyProperties(pdev, &family_count, families.ptr); var graphics_family: ?u32 = null; var present_family: ?u32 = null; @@ -287,14 +278,9 @@ fn checkExtensionSupport( pdev: vk.PhysicalDevice, allocator: Allocator, ) !bool { - var count: u32 = undefined; - _ = try instance.enumerateDeviceExtensionProperties(pdev, null, &count, null); - - const propsv = try allocator.alloc(vk.ExtensionProperties, count); + const propsv = try instance.enumerateDeviceExtensionPropertiesAlloc(pdev, null, allocator); defer allocator.free(propsv); - _ = try instance.enumerateDeviceExtensionProperties(pdev, null, &count, propsv.ptr); - for (required_device_extensions) |ext| { for (propsv) |props| { if (std.mem.eql(u8, std.mem.span(ext), std.mem.sliceTo(&props.extension_name, 0))) { diff --git a/examples/swapchain.zig b/examples/swapchain.zig index 1439692..d26f555 100644 --- a/examples/swapchain.zig +++ b/examples/swapchain.zig @@ -247,13 +247,10 @@ const SwapImage = struct { }; fn initSwapchainImages(gc: *const GraphicsContext, swapchain: vk.SwapchainKHR, format: vk.Format, allocator: Allocator) ![]SwapImage { - var count: u32 = undefined; - _ = try gc.dev.getSwapchainImagesKHR(swapchain, &count, null); - const images = try allocator.alloc(vk.Image, count); + const images = try gc.dev.getSwapchainImagesKhrAlloc(swapchain, allocator); defer allocator.free(images); - _ = try gc.dev.getSwapchainImagesKHR(swapchain, &count, images.ptr); - const swap_images = try allocator.alloc(SwapImage, count); + const swap_images = try allocator.alloc(SwapImage, images.len); errdefer allocator.free(swap_images); var i: usize = 0; @@ -273,11 +270,8 @@ fn findSurfaceFormat(gc: *const GraphicsContext, allocator: Allocator) !vk.Surfa .color_space = .srgb_nonlinear_khr, }; - var count: u32 = undefined; - _ = try gc.instance.getPhysicalDeviceSurfaceFormatsKHR(gc.pdev, gc.surface, &count, null); - const surface_formats = try allocator.alloc(vk.SurfaceFormatKHR, count); + const surface_formats = try gc.instance.getPhysicalDeviceSurfaceFormatsKhrAlloc(gc.pdev, gc.surface, allocator); defer allocator.free(surface_formats); - _ = try gc.instance.getPhysicalDeviceSurfaceFormatsKHR(gc.pdev, gc.surface, &count, surface_formats.ptr); for (surface_formats) |sfmt| { if (std.meta.eql(sfmt, preferred)) { @@ -289,11 +283,8 @@ fn findSurfaceFormat(gc: *const GraphicsContext, allocator: Allocator) !vk.Surfa } fn findPresentMode(gc: *const GraphicsContext, allocator: Allocator) !vk.PresentModeKHR { - var count: u32 = undefined; - _ = try gc.instance.getPhysicalDeviceSurfacePresentModesKHR(gc.pdev, gc.surface, &count, null); - const present_modes = try allocator.alloc(vk.PresentModeKHR, count); + const present_modes = try gc.instance.getPhysicalDeviceSurfacePresentModesKhrAlloc(gc.pdev, gc.surface, allocator); defer allocator.free(present_modes); - _ = try gc.instance.getPhysicalDeviceSurfacePresentModesKHR(gc.pdev, gc.surface, &count, present_modes.ptr); const preferred = [_]vk.PresentModeKHR{ .mailbox_khr, diff --git a/src/vulkan/render.zig b/src/vulkan/render.zig index 866f6a4..5bccf52 100644 --- a/src/vulkan/render.zig +++ b/src/vulkan/render.zig @@ -197,6 +197,10 @@ const enumerate_functions = std.StaticStringMap(void).initComptime(.{ .{"vkEnumerateInstanceExtensionProperties"}, .{"vkEnumeratePhysicalDevices"}, .{"vkGetPhysicalDeviceQueueFamilyProperties"}, + .{"vkGetPhysicalDeviceSurfaceFormatsKHR"}, + .{"vkGetPhysicalDeviceSurfacePresentModesKHR"}, + .{"vkEnumerateDeviceExtensionProperties"}, + .{"vkGetSwapchainImagesKHR"}, }); // Given one of the above commands, returns the type of the array elements From b3eb45d6a422cd349bbde995c8bd1bb2523530a1 Mon Sep 17 00:00:00 2001 From: Patrick O'Connell Date: Sun, 30 Jun 2024 13:18:05 -0700 Subject: [PATCH 5/6] Add more "enumerate" functions to list --- src/vulkan/render.zig | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/src/vulkan/render.zig b/src/vulkan/render.zig index 5bccf52..43340a2 100644 --- a/src/vulkan/render.zig +++ b/src/vulkan/render.zig @@ -194,13 +194,30 @@ const dispatch_override_functions = std.StaticStringMap(CommandDispatchType).ini // Functions that return an array of objects via a count and data pointer. const enumerate_functions = std.StaticStringMap(void).initComptime(.{ - .{"vkEnumerateInstanceExtensionProperties"}, .{"vkEnumeratePhysicalDevices"}, + .{"vkEnumeratePhysicalDeviceGroups"}, .{"vkGetPhysicalDeviceQueueFamilyProperties"}, - .{"vkGetPhysicalDeviceSurfaceFormatsKHR"}, - .{"vkGetPhysicalDeviceSurfacePresentModesKHR"}, + .{"vkGetPhysicalDeviceQueueFamilyProperties2"}, + .{"vkEnumerateInstanceLayerProperties"}, + .{"vkEnumerateInstanceExtensionProperties"}, + .{"vkEnumerateDeviceLayerProperties"}, .{"vkEnumerateDeviceExtensionProperties"}, + .{"vkGetImageSparseMemoryRequirements"}, + .{"vkGetImageSparseMemoryRequirements2"}, + .{"vkGetDeviceImageSparseMemoryRequirements"}, + .{"vkGetPhysicalDeviceSparseImageFormatProperties"}, + .{"vkGetPhysicalDeviceSparseImageFormatProperties2"}, + .{"vkGetPhysicalDeviceToolProperties"}, + .{"vkGetPipelineCacheData"}, + + .{"vkGetPhysicalDeviceSurfaceFormatsKHR"}, + .{"vkGetPhysicalDeviceSurfaceFormats2KHR"}, + .{"vkGetPhysicalDeviceSurfacePresentModesKHR"}, + .{"vkGetSwapchainImagesKHR"}, + .{"vkGetPhysicalDevicePresentRectanglesKHR"}, + + .{"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"}, }); // Given one of the above commands, returns the type of the array elements From a2167a79d5a5b8ab85315adf313462a9fd88a8f0 Mon Sep 17 00:00:00 2001 From: Patrick O'Connell Date: Sun, 30 Jun 2024 13:37:51 -0700 Subject: [PATCH 6/6] Author suffix last for alloc functions --- examples/swapchain.zig | 6 +++--- src/vulkan/render.zig | 11 +++++++++-- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/examples/swapchain.zig b/examples/swapchain.zig index d26f555..a8f1c06 100644 --- a/examples/swapchain.zig +++ b/examples/swapchain.zig @@ -247,7 +247,7 @@ const SwapImage = struct { }; fn initSwapchainImages(gc: *const GraphicsContext, swapchain: vk.SwapchainKHR, format: vk.Format, allocator: Allocator) ![]SwapImage { - const images = try gc.dev.getSwapchainImagesKhrAlloc(swapchain, allocator); + const images = try gc.dev.getSwapchainImagesAllocKHR(swapchain, allocator); defer allocator.free(images); const swap_images = try allocator.alloc(SwapImage, images.len); @@ -270,7 +270,7 @@ fn findSurfaceFormat(gc: *const GraphicsContext, allocator: Allocator) !vk.Surfa .color_space = .srgb_nonlinear_khr, }; - const surface_formats = try gc.instance.getPhysicalDeviceSurfaceFormatsKhrAlloc(gc.pdev, gc.surface, allocator); + const surface_formats = try gc.instance.getPhysicalDeviceSurfaceFormatsAllocKHR(gc.pdev, gc.surface, allocator); defer allocator.free(surface_formats); for (surface_formats) |sfmt| { @@ -283,7 +283,7 @@ fn findSurfaceFormat(gc: *const GraphicsContext, allocator: Allocator) !vk.Surfa } fn findPresentMode(gc: *const GraphicsContext, allocator: Allocator) !vk.PresentModeKHR { - const present_modes = try gc.instance.getPhysicalDeviceSurfacePresentModesKhrAlloc(gc.pdev, gc.surface, allocator); + const present_modes = try gc.instance.getPhysicalDeviceSurfacePresentModesAllocKHR(gc.pdev, gc.surface, allocator); defer allocator.free(present_modes); const preferred = [_]vk.PresentModeKHR{ diff --git a/src/vulkan/render.zig b/src/vulkan/render.zig index 43340a2..292d5aa 100644 --- a/src/vulkan/render.zig +++ b/src/vulkan/render.zig @@ -1624,10 +1624,17 @@ fn Renderer(comptime WriterType: type) type { ); } + // vkFooKHR => vkFooAllocKHR + fn makeAllocWrapperName(self: *Self, wrapped_name: []const u8) ![]const u8 { + const tag = self.id_renderer.getAuthorTag(wrapped_name) orelse ""; + const base_len = wrapped_name.len - tag.len; + return std.mem.concat(self.allocator, u8, &.{ wrapped_name[0..base_len], "Alloc", tag }); + } + fn renderProxyCommandAlloc(self: *Self, wrapped_name: []const u8, command: reg.Command, dispatch_handle: []const u8) !void { const returns_vk_result = command.return_type.* == .name and mem.eql(u8, command.return_type.name, "VkResult"); - const name = try std.mem.concat(self.allocator, u8, &.{ wrapped_name, "Alloc" }); + const name = try self.makeAllocWrapperName(wrapped_name); defer self.allocator.free(name); if (command.params.len < 2) { @@ -1973,7 +1980,7 @@ fn Renderer(comptime WriterType: type) type { fn renderWrapperAlloc(self: *Self, wrapped_name: []const u8, command: reg.Command) !void { const returns_vk_result = command.return_type.* == .name and mem.eql(u8, command.return_type.name, "VkResult"); - const name = try std.mem.concat(self.allocator, u8, &.{ wrapped_name, "Alloc" }); + const name = try self.makeAllocWrapperName(wrapped_name); defer self.allocator.free(name); if (command.params.len < 2) {