adding VK_KHR_get_physical_device_properties2 and bug fixes

Author: Kbz-8

build.zig

@@ -31,6 +31,7 @@ pub fn build(b: *std.Build) !void {
     });
 
     const zdt = b.dependency("zdt", .{}).module("zdt");
+    const zigrc = b.dependency("zigrc", .{}).module("zigrc");
     const vulkan_headers = b.dependency("vulkan_headers", .{});
     const vulkan_utility_libraries = b.dependency("vulkan_utility_libraries", .{});
 
@@ -39,6 +40,7 @@ pub fn build(b: *std.Build) !void {
     }).module("vulkan-zig");
 
     base_mod.addImport("zdt", zdt);
+    base_mod.addImport("zigrc", zigrc);
     base_mod.addImport("vulkan", vulkan);
     base_mod.addSystemIncludePath(vulkan_headers.path("include"));
     base_mod.addSystemIncludePath(vulkan_utility_libraries.path("include"));
@@ -184,7 +186,7 @@ fn addCTS(b: *std.Build, target: std.Build.ResolvedTarget, impl: *const Implemen
     }));
 
     const mustpass = try cts.path(
-        b.fmt("mustpass/{}.{}.0/vk-default.txt", .{
+        b.fmt("mustpass/{}.{}.2/vk-default.txt", .{
             impl.vulkan_version.major,
             impl.vulkan_version.minor,
         }),

build.zig.zon

@@ -29,6 +29,10 @@
             .url = "git+https://github.com/Kbz-8/Vulkan-CTS-bin#19ce2da05f8176348064a9fc6688847e5f76a46e",
             .hash = "N-V-__8AAHDV0xtS93nAGaYd7YWxBLnvHDEplwIpC29izSGa",
         },
+        .zigrc = .{
+            .url = "https://github.com/Aandreba/zigrc/archive/refs/tags/1.1.0.tar.gz",
+            .hash = "zigrc-1.0.0-lENlWzvQAACulrbkL9PVhWjFsWSkYhi7AmfSbCM-2Xlh",
+        },
         .cpuinfo = .{
             .url = "git+https://github.com/Kbz-8/cpuinfo#4883954cfcec3f6c9ca9c4aaddfc26107e08726f",
             .hash = "cpuinfo-0.0.1-RLgIQTLRMgF4dLo8AJ-HvnpFsJe6jmXCJjMWWjil6RF1",

src/soft/SoftCommandBuffer.zig

@@ -89,11 +89,13 @@ pub fn copyBuffer(interface: *Interface, src: *base.Buffer, dst: *base.Buffer, r
     _ = regions;
 }
 
-pub fn copyImage(interface: *Interface, src: *base.Image, dst: *base.Image, regions: []const vk.ImageCopy) VkError!void {
+pub fn copyImage(interface: *Interface, src: *base.Image, src_layout: vk.ImageLayout, dst: *base.Image, dst_layout: vk.ImageLayout, regions: []const vk.ImageCopy) VkError!void {
     // No-op
     _ = interface;
     _ = src;
+    _ = src_layout;
     _ = dst;
+    _ = dst_layout;
     _ = regions;
 }
 

src/soft/SoftInstance.zig

@@ -12,13 +12,26 @@ pub const Interface = base.Instance;
 
 interface: Interface,
 
+fn castExtension(comptime ext: vk.ApiInfo) vk.ExtensionProperties {
+    var props: vk.ExtensionProperties = .{
+        .extension_name = undefined,
+        .spec_version = @bitCast(ext.version),
+    };
+    @memcpy(props.extension_name[0..ext.name.len], ext.name);
+    return props;
+}
+
+pub const EXTENSIONS = [_]vk.ExtensionProperties{
+    castExtension(vk.extensions.khr_get_physical_device_properties_2),
+};
+
 pub fn create(allocator: std.mem.Allocator, infos: *const vk.InstanceCreateInfo) VkError!*Interface {
     const self = allocator.create(Self) catch return VkError.OutOfHostMemory;
     errdefer allocator.destroy(self);
 
     self.interface = try base.Instance.init(allocator, infos);
     self.interface.dispatch_table = &.{
-        .destroyInstance = destroyInstance,
+        .destroy = destroy,
     };
     self.interface.vtable = &.{
         .requestPhysicalDevices = requestPhysicalDevices,
@@ -27,6 +40,11 @@ pub fn create(allocator: std.mem.Allocator, infos: *const vk.InstanceCreateInfo)
     return &self.interface;
 }
 
+fn destroy(interface: *Interface, allocator: std.mem.Allocator) VkError!void {
+    const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
+    allocator.destroy(self);
+}
+
 fn requestPhysicalDevices(interface: *Interface, allocator: std.mem.Allocator) VkError!void {
     // Software driver has only one physical device (the CPU)
     const physical_device = try SoftPhysicalDevice.create(allocator, interface);
@@ -42,8 +60,3 @@ fn releasePhysicalDevices(interface: *Interface, allocator: std.mem.Allocator) V
     interface.physical_devices.deinit(allocator);
     interface.physical_devices = .empty;
 }
-
-fn destroyInstance(interface: *Interface, allocator: std.mem.Allocator) VkError!void {
-    const self: *Self = @alignCast(@fieldParentPtr("interface", interface));
-    allocator.destroy(self);
-}

src/soft/SoftPhysicalDevice.zig

@@ -30,6 +30,7 @@ pub fn create(allocator: std.mem.Allocator, instance: *const base.Instance) VkEr
         .getFormatProperties = getFormatProperties,
         .getImageFormatProperties = getImageFormatProperties,
         .getSparseImageFormatProperties = getSparseImageFormatProperties,
+        .getSparseImageFormatProperties2 = getSparseImageFormatProperties2,
         .release = destroy,
     };
 
@@ -670,21 +671,42 @@ pub fn getImageFormatProperties(
     };
 }
 
+/// Soft does not support sparse images.
 pub fn getSparseImageFormatProperties(
     interface: *Interface,
     format: vk.Format,
     image_type: vk.ImageType,
     samples: vk.SampleCountFlags,
     tiling: vk.ImageTiling,
     usage: vk.ImageUsageFlags,
-    flags: vk.ImageCreateFlags,
-) VkError!vk.SparseImageFormatProperties {
+    properties: ?[*]vk.SparseImageFormatProperties,
+) VkError!u32 {
     _ = interface;
     _ = format;
     _ = image_type;
     _ = samples;
     _ = tiling;
     _ = usage;
-    _ = flags;
-    return undefined;
+    _ = properties;
+    return 0;
+}
+
+/// Soft does not support sparse images.
+pub fn getSparseImageFormatProperties2(
+    interface: *Interface,
+    format: vk.Format,
+    image_type: vk.ImageType,
+    samples: vk.SampleCountFlags,
+    tiling: vk.ImageTiling,
+    usage: vk.ImageUsageFlags,
+    properties: ?[*]vk.SparseImageFormatProperties2,
+) VkError!u32 {
+    _ = interface;
+    _ = format;
+    _ = image_type;
+    _ = samples;
+    _ = tiling;
+    _ = usage;
+    _ = properties;
+    return 0;
 }

src/vulkan/CommandBuffer.zig

@@ -42,7 +42,7 @@ pub const DispatchTable = struct {
     begin: *const fn (*Self, *const vk.CommandBufferBeginInfo) VkError!void,
     clearColorImage: *const fn (*Self, *Image, vk.ImageLayout, *const vk.ClearColorValue, []const vk.ImageSubresourceRange) VkError!void,
     copyBuffer: *const fn (*Self, *Buffer, *Buffer, []const vk.BufferCopy) VkError!void,
-    copyImage: *const fn (*Self, *Image, *Image, []const vk.ImageCopy) VkError!void,
+    copyImage: *const fn (*Self, *Image, vk.ImageLayout, *Image, vk.ImageLayout, []const vk.ImageCopy) VkError!void,
     end: *const fn (*Self) VkError!void,
     fillBuffer: *const fn (*Self, *Buffer, vk.DeviceSize, vk.DeviceSize, u32) VkError!void,
     reset: *const fn (*Self, vk.CommandBufferResetFlags) VkError!void,
@@ -153,14 +153,16 @@ pub inline fn copyBuffer(self: *Self, src: *Buffer, dst: *Buffer, regions: []con
     try self.dispatch_table.copyBuffer(self, src, dst, regions);
 }
 
-pub inline fn copyImage(self: *Self, src: *Image, dst: *Image, regions: []const vk.ImageCopy) VkError!void {
+pub inline fn copyImage(self: *Self, src: *Image, src_layout: vk.ImageLayout, dst: *Image, dst_layout: vk.ImageLayout, regions: []const vk.ImageCopy) VkError!void {
     const allocator = self.host_allocator.allocator();
     self.commands.append(allocator, .{ .CopyImage = .{
         .src = src,
+        .src_layout = src_layout,
         .dst = dst,
+        .dst_layout = dst_layout,
         .regions = allocator.dupe(vk.ImageCopy, regions) catch return VkError.OutOfHostMemory,
     } }) catch return VkError.OutOfHostMemory;
-    try self.dispatch_table.copyImage(self, src, dst, regions);
+    try self.dispatch_table.copyImage(self, src, src_layout, dst, dst_layout, regions);
 }
 
 pub inline fn fillBuffer(self: *Self, buffer: *Buffer, offset: vk.DeviceSize, size: vk.DeviceSize, data: u32) VkError!void {

src/vulkan/Device.zig

@@ -99,8 +99,8 @@ pub fn createQueues(self: *Self, allocator: std.mem.Allocator, info: *const vk.D
 
         const queue = try self.vtable.createQueue(allocator, self, queue_info.queue_family_index, @intCast(family_ptr.items.len), queue_info.flags);
 
-        logger.manager.get().indent();
-        defer logger.manager.get().unindent();
+        logger.getManager().get().indent();
+        defer logger.getManager().get().unindent();
 
         const dispatchable_queue = try Dispatchable(Queue).wrap(allocator, queue);
         family_ptr.append(allocator, dispatchable_queue) catch return VkError.OutOfHostMemory;

src/vulkan/Instance.zig

@@ -15,6 +15,9 @@ comptime {
         if (!@hasDecl(root, "VULKAN_VERSION")) {
             @compileError("Missing VULKAN_VERSION in module root");
         }
+        if (!@hasDecl(root.Instance, "EXTENSIONS")) {
+            @compileError("Missing EXTENSIONS in Instance's implementation");
+        }
     }
 }
 
@@ -31,7 +34,7 @@ pub const VTable = struct {
 };
 
 pub const DispatchTable = struct {
-    destroyInstance: *const fn (*Self, std.mem.Allocator) VkError!void,
+    destroy: *const fn (*Self, std.mem.Allocator) VkError!void,
 };
 
 pub fn init(allocator: std.mem.Allocator, infos: *const vk.InstanceCreateInfo) VkError!Self {
@@ -53,18 +56,19 @@ pub fn create(allocator: std.mem.Allocator, infos: *const vk.InstanceCreateInfo)
 
 pub fn deinit(self: *Self, allocator: std.mem.Allocator) VkError!void {
     try self.releasePhysicalDevices(allocator);
-    try self.dispatch_table.destroyInstance(self, allocator);
+    try self.dispatch_table.destroy(self, allocator);
 }
 
-pub fn enumerateExtensionProperties(layer_name: ?[]const u8, property_count: *u32, properties: ?*vk.ExtensionProperties) VkError!void {
+pub fn enumerateExtensionProperties(layer_name: ?[]const u8, count: *u32, p_properties: ?[*]vk.ExtensionProperties) VkError!void {
     if (layer_name) |_| {
         return VkError.LayerNotPresent;
     }
-
-    _ = properties;
-    _ = std.StaticStringMap(vk.ExtensionProperties).initComptime(.{});
-
-    property_count.* = 0;
+    count.* = root.Instance.EXTENSIONS.len;
+    if (p_properties) |properties| {
+        for (root.Instance.EXTENSIONS, 0..) |ext, i| {
+            properties[i] = ext;
+        }
+    }
 }
 
 pub fn enumerateVersion(version: *u32) VkError!void {
@@ -80,8 +84,8 @@ pub fn releasePhysicalDevices(self: *Self, allocator: std.mem.Allocator) VkError
 }
 
 pub fn requestPhysicalDevices(self: *Self, allocator: std.mem.Allocator) VkError!void {
-    logger.manager.get().indent();
-    defer logger.manager.get().unindent();
+    logger.getManager().get().indent();
+    defer logger.getManager().get().unindent();
 
     try self.vtable.requestPhysicalDevices(self, allocator);
     if (self.physical_devices.items.len == 0) {

src/vulkan/PhysicalDevice.zig

@@ -20,7 +20,8 @@ pub const DispatchTable = struct {
     createDevice: *const fn (*Self, std.mem.Allocator, *const vk.DeviceCreateInfo) VkError!*Device,
     getFormatProperties: *const fn (*Self, vk.Format) VkError!vk.FormatProperties,
     getImageFormatProperties: *const fn (*Self, vk.Format, vk.ImageType, vk.ImageTiling, vk.ImageUsageFlags, vk.ImageCreateFlags) VkError!vk.ImageFormatProperties,
-    getSparseImageFormatProperties: *const fn (*Self, vk.Format, vk.ImageType, vk.SampleCountFlags, vk.ImageTiling, vk.ImageUsageFlags, vk.ImageCreateFlags) VkError!vk.SparseImageFormatProperties,
+    getSparseImageFormatProperties: *const fn (*Self, vk.Format, vk.ImageType, vk.SampleCountFlags, vk.ImageTiling, vk.ImageUsageFlags, ?[*]vk.SparseImageFormatProperties) VkError!u32,
+    getSparseImageFormatProperties2: ?*const fn (*Self, vk.Format, vk.ImageType, vk.SampleCountFlags, vk.ImageTiling, vk.ImageUsageFlags, ?[*]vk.SparseImageFormatProperties2) VkError!u32,
     release: *const fn (*Self, std.mem.Allocator) VkError!void,
 };
 
@@ -67,7 +68,7 @@ pub fn getImageFormatProperties(
     usage: vk.ImageUsageFlags,
     flags: vk.ImageCreateFlags,
 ) VkError!vk.ImageFormatProperties {
-    return try self.dispatch_table.getImageFormatProperties(self, format, image_type, tiling, usage, flags);
+    return self.dispatch_table.getImageFormatProperties(self, format, image_type, tiling, usage, flags);
 }
 
 pub fn getSparseImageFormatProperties(
@@ -77,9 +78,24 @@ pub fn getSparseImageFormatProperties(
     samples: vk.SampleCountFlags,
     tiling: vk.ImageTiling,
     usage: vk.ImageUsageFlags,
-    flags: vk.ImageCreateFlags,
-) VkError!vk.SparseImageFormatProperties {
-    return try self.dispatch_table.getSparseImageFormatProperties(self, format, image_type, samples, tiling, usage, flags);
+    properties: ?[*]vk.SparseImageFormatProperties,
+) VkError!u32 {
+    return self.dispatch_table.getSparseImageFormatProperties(self, format, image_type, samples, tiling, usage, properties);
+}
+
+pub fn getSparseImageFormatProperties2(
+    self: *Self,
+    format: vk.Format,
+    image_type: vk.ImageType,
+    samples: vk.SampleCountFlags,
+    tiling: vk.ImageTiling,
+    usage: vk.ImageUsageFlags,
+    properties: ?[*]vk.SparseImageFormatProperties2,
+) VkError!u32 {
+    return if (self.dispatch_table.getSparseImageFormatProperties2) |pfn|
+        pfn(self, format, image_type, samples, tiling, usage, properties)
+    else
+        0;
 }
 
 pub fn releasePhysicalDevice(self: *Self, allocator: std.mem.Allocator) VkError!void {

src/vulkan/commands.zig

@@ -38,7 +38,9 @@ pub const CommandCopyBuffer = struct {
 };
 pub const CommandCopyImage = struct {
     src: *Image,
+    src_layout: vk.ImageLayout,
     dst: *Image,
+    dst_layout: vk.ImageLayout,
     regions: []const vk.ImageCopy,
 };
 pub const CommandDraw = struct {