From 95810d616325f0b908a50faa231e70c4cc6c27e4 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Tue, 5 May 2026 13:58:01 +0200 Subject: [PATCH] WSI is finally working --- build.zig | 1 + src/soft/SoftInstance.zig | 2 - src/soft/SoftPhysicalDevice.zig | 27 +++++++++++++ src/vulkan/Image.zig | 2 +- src/vulkan/Instance.zig | 2 +- src/vulkan/NonDispatchable.zig | 4 -- src/vulkan/PhysicalDevice.zig | 5 +++ src/vulkan/c_includes.h | 4 ++ src/vulkan/lib_vulkan.zig | 20 +++++----- src/vulkan/wsi/PresentImage.zig | 5 ++- src/vulkan/wsi/SwapchainKHR.zig | 14 +++++-- src/vulkan/wsi/WaylandSurfaceKHR.zig | 35 ++++++++-------- src/vulkan/wsi/clients/wayland.zig | 60 ++++++++++------------------ 13 files changed, 98 insertions(+), 83 deletions(-) diff --git a/build.zig b/build.zig index e8abe2c..811c21d 100644 --- a/build.zig +++ b/build.zig @@ -76,6 +76,7 @@ pub fn build(b: *std.Build) !void { if (builtin.target.os.tag == .linux) { base_c_includes.link_libc = true; + base_c_includes.defineCMacroRaw("STROLL_ENABLE_WAYLAND"); } base_mod.addImport("base_c", base_c_includes.createModule()); diff --git a/src/soft/SoftInstance.zig b/src/soft/SoftInstance.zig index 936d881..3bd62d0 100644 --- a/src/soft/SoftInstance.zig +++ b/src/soft/SoftInstance.zig @@ -25,11 +25,9 @@ fn castExtension(comptime ext: vk.ApiInfo) vk.ExtensionProperties { } pub const EXTENSIONS = [_]vk.ExtensionProperties{ - //castExtension(vk.extensions.lunarg_direct_driver_loading), castExtension(vk.extensions.khr_get_physical_device_properties_2), castExtension(vk.extensions.khr_surface), castExtension(vk.extensions.khr_wayland_surface), - castExtension(vk.extensions.khr_swapchain), }; pub fn create(allocator: std.mem.Allocator, infos: *const vk.InstanceCreateInfo) VkError!*Interface { diff --git a/src/soft/SoftPhysicalDevice.zig b/src/soft/SoftPhysicalDevice.zig index 933b4fb..5a6445b 100644 --- a/src/soft/SoftPhysicalDevice.zig +++ b/src/soft/SoftPhysicalDevice.zig @@ -13,6 +13,19 @@ const SurfaceKHR = base.SurfaceKHR; const Self = @This(); pub const Interface = base.PhysicalDevice; +fn castExtension(comptime ext: vk.ApiInfo) vk.ExtensionProperties { + var props: vk.ExtensionProperties = .{ + .extension_name = @splat(0), + .spec_version = @bitCast(ext.version), + }; + @memcpy(props.extension_name[0..ext.name.len], ext.name); + return props; +} + +const EXTENSIONS = [_]vk.ExtensionProperties{ + castExtension(vk.extensions.khr_swapchain), +}; + // Device name should always be the same so avoid reprocessing it multiple times var device_name: [vk.MAX_PHYSICAL_DEVICE_NAME_SIZE]u8 = @splat(0); @@ -31,6 +44,7 @@ pub fn create(allocator: std.mem.Allocator, instance: *base.Instance) VkError!*S .getFormatProperties = getFormatProperties, .getImageFormatProperties = getImageFormatProperties, .getSparseImageFormatProperties = getSparseImageFormatProperties, + .enumerateExtensionProperties = enumerateExtensionProperties, .release = destroy, // VK_KHR_get_physical_device_properties_2 @@ -234,6 +248,19 @@ pub fn createDevice(interface: *Interface, allocator: std.mem.Allocator, infos: return &device.interface; } +pub fn enumerateExtensionProperties(_: *const Interface, layer_name: ?[]const u8, count: *u32, p_properties: ?[*]vk.ExtensionProperties) VkError!void { + if (layer_name) |_| { + return VkError.LayerNotPresent; + } + + count.* = EXTENSIONS.len; + if (p_properties) |properties| { + for (EXTENSIONS, properties[0..]) |ext, *prop| { + prop.* = ext; + } + } +} + pub fn getFormatProperties(interface: *Interface, format: vk.Format) VkError!vk.FormatProperties { _ = interface; var properties: vk.FormatProperties = .{}; diff --git a/src/vulkan/Image.zig b/src/vulkan/Image.zig index 753cd9e..3f4da74 100644 --- a/src/vulkan/Image.zig +++ b/src/vulkan/Image.zig @@ -72,7 +72,7 @@ pub fn bindMemory(self: *Self, memory: *DeviceMemory, offset: vk.DeviceSize) VkE pub fn getMemoryRequirements(self: *Self, requirements: *vk.MemoryRequirements) VkError!void { requirements.size = try self.getTotalSize(); - requirements.memory_type_bits = self.allowed_memory_types.mask; + requirements.memory_type_bits = 0; try self.vtable.getMemoryRequirements(self, requirements); } diff --git a/src/vulkan/Instance.zig b/src/vulkan/Instance.zig index bbcd540..37466d3 100644 --- a/src/vulkan/Instance.zig +++ b/src/vulkan/Instance.zig @@ -67,7 +67,7 @@ pub fn enumerateExtensionProperties(layer_name: ?[]const u8, count: *u32, p_prop return VkError.LayerNotPresent; } - if (comptime @hasDecl(root, "Instance") and @hasDecl(root.Instance, "EXTENSIONS")) { + if (comptime !builtin.is_test and @hasDecl(root.Instance, "EXTENSIONS")) { count.* = root.Instance.EXTENSIONS.len; if (p_properties) |properties| { for (root.Instance.EXTENSIONS, properties[0..]) |ext, *prop| { diff --git a/src/vulkan/NonDispatchable.zig b/src/vulkan/NonDispatchable.zig index 63a2851..b993840 100644 --- a/src/vulkan/NonDispatchable.zig +++ b/src/vulkan/NonDispatchable.zig @@ -39,10 +39,6 @@ pub fn NonDispatchable(comptime T: type) type { return @enumFromInt(@intFromPtr(self)); } - pub fn fromObject(object: *T) *Self { - return @alignCast(@constCast(@fieldParentPtr("object", &object))); - } - pub fn fromHandle(vk_handle: anytype) VkError!*Self { const handle = @intFromEnum(vk_handle); if (handle == 0) { diff --git a/src/vulkan/PhysicalDevice.zig b/src/vulkan/PhysicalDevice.zig index 9b4544e..5cdf0d3 100644 --- a/src/vulkan/PhysicalDevice.zig +++ b/src/vulkan/PhysicalDevice.zig @@ -22,6 +22,7 @@ pub const DispatchTable = struct { 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.SparseImageFormatProperties) VkError!u32, + enumerateExtensionProperties: *const fn (*const Self, ?[]const u8, *u32, ?[*]vk.ExtensionProperties) VkError!void, release: *const fn (*Self, std.mem.Allocator) VkError!void, // VK_KHR_get_physical_device_properties_2 @@ -66,6 +67,10 @@ pub inline fn getFormatProperties(self: *Self, format: vk.Format) VkError!vk.For return try self.dispatch_table.getFormatProperties(self, format); } +pub inline fn enumerateExtensionProperties(self: *const Self, layer_name: ?[]const u8, count: *u32, p_properties: ?[*]vk.ExtensionProperties) VkError!void { + return try self.dispatch_table.enumerateExtensionProperties(self, layer_name, count, p_properties); +} + pub inline fn getImageFormatProperties( self: *Self, format: vk.Format, diff --git a/src/vulkan/c_includes.h b/src/vulkan/c_includes.h index cdb1bab..174e75a 100644 --- a/src/vulkan/c_includes.h +++ b/src/vulkan/c_includes.h @@ -1,2 +1,6 @@ #include #include + +#ifdef STROLL_ENABLE_WAYLAND + #include +#endif diff --git a/src/vulkan/lib_vulkan.zig b/src/vulkan/lib_vulkan.zig index ee3e4ef..e0d751a 100644 --- a/src/vulkan/lib_vulkan.zig +++ b/src/vulkan/lib_vulkan.zig @@ -382,7 +382,7 @@ pub export fn strollCreateDevice(p_physical_device: vk.PhysicalDevice, info: *co return .success; } -pub export fn strollEnumerateDeviceExtensionProperties(p_physical_device: vk.PhysicalDevice, p_layer_name: ?[*:0]const u8, property_count: *u32, properties: ?*vk.ExtensionProperties) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollEnumerateDeviceExtensionProperties(p_physical_device: vk.PhysicalDevice, p_layer_name: ?[*:0]const u8, property_count: *u32, properties: ?[*]vk.ExtensionProperties) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkEnumerateDeviceExtensionProperties); defer entryPointEndLogTrace(); @@ -390,9 +390,8 @@ pub export fn strollEnumerateDeviceExtensionProperties(p_physical_device: vk.Phy if (p_layer_name) |layer_name| { name = std.mem.span(layer_name); } - _ = p_physical_device; - property_count.* = 0; - _ = properties; + const physical_device = Dispatchable(PhysicalDevice).fromHandleObject(p_physical_device) catch |err| return toVkResult(err); + physical_device.enumerateExtensionProperties(name, property_count, properties) catch |err| return toVkResult(err); return .success; } @@ -2213,8 +2212,8 @@ pub export fn strollAcquireNextImageKHR(p_device: vk.Device, p_swapchain: vk.Swa Dispatchable(Device).checkHandleValidity(p_device) catch |err| return toVkResult(err); const swapchain = NonDispatchable(SwapchainKHR).fromHandleObject(p_swapchain) catch |err| return toVkResult(err); - const semaphore = NonDispatchable(BinarySemaphore).fromHandleObject(p_semaphore) catch |err| return toVkResult(err); - const fence = NonDispatchable(Fence).fromHandleObject(p_fence) catch |err| return toVkResult(err); + const semaphore = if (p_semaphore != .null_handle) NonDispatchable(BinarySemaphore).fromHandleObject(p_semaphore) catch |err| return toVkResult(err) else null; + const fence = if (p_fence != .null_handle) NonDispatchable(Fence).fromHandleObject(p_fence) catch |err| return toVkResult(err) else null; swapchain.getNextImage(timeout, semaphore, fence, image_index) catch |err| return toVkResult(err); return .success; } @@ -2235,9 +2234,7 @@ pub export fn strollCreateSwapchainKHR(p_device: vk.Device, info: *const vk.Swap const allocator = VulkanAllocator.init(callbacks, .object).allocator(); const device = Dispatchable(Device).fromHandleObject(p_device) catch |err| return toVkResult(err); const surface = NonDispatchable(SurfaceKHR).fromHandleObject(info.surface) catch |err| return toVkResult(err); - const swapchain = SwapchainKHR.create(device, allocator, info) catch |err| return toVkResult(err); - swapchain.surface = surface; - surface.swapchain = swapchain; + const swapchain = SwapchainKHR.create(device, allocator, surface, info) catch |err| return toVkResult(err); p_swapchain.* = (NonDispatchable(SwapchainKHR).wrap(allocator, swapchain) catch |err| return toVkResult(err)).toVkHandle(vk.SwapchainKHR); return .success; } @@ -2318,6 +2315,7 @@ pub export fn strollGetPhysicalDeviceSurfaceSupportKHR(p_physical_device: vk.Phy return .success; } +/// TODO: proper implementation when adding new drivers pub export fn strollGetPhysicalDeviceWaylandPresentationSupportKHR(p_physical_device: vk.PhysicalDevice, _: u32, _: *anyopaque) callconv(vk.vulkan_call_conv) vk.Bool32 { entryPointBeginLogTrace(.vkGetPhysicalDeviceWaylandPresentationSupportKHR); defer entryPointEndLogTrace(); @@ -2335,8 +2333,8 @@ pub export fn strollGetSwapchainImagesKHR(p_device: vk.Device, p_swapchain: vk.S const swapchain = NonDispatchable(SwapchainKHR).fromHandleObject(p_swapchain) catch |err| return toVkResult(err); count.* = @intCast(swapchain.images.len); if (p_images) |images| { - for (images[0..], swapchain.images[0..]) |*image, swapchain_image| { - image.* = NonDispatchable(Image).fromObject(swapchain_image.image).toVkHandle(vk.Image); + for (images[0..], swapchain.images[0..]) |*image, *swapchain_image| { + image.* = swapchain_image.non_dispatchable_image.toVkHandle(vk.Image); } } diff --git a/src/vulkan/wsi/PresentImage.zig b/src/vulkan/wsi/PresentImage.zig index 0ce6143..908b8a9 100644 --- a/src/vulkan/wsi/PresentImage.zig +++ b/src/vulkan/wsi/PresentImage.zig @@ -6,6 +6,7 @@ const VkError = @import("../error_set.zig").VkError; const Device = @import("../Device.zig"); const DeviceMemory = @import("../DeviceMemory.zig"); const Image = @import("../Image.zig"); +const NonDispatchable = @import("../NonDispatchable.zig").NonDispatchable; pub const State = enum { Available, @@ -16,6 +17,7 @@ pub const State = enum { const Self = @This(); image: *Image, +non_dispatchable_image: *NonDispatchable(Image), memory: *DeviceMemory, state: State, @@ -36,12 +38,13 @@ pub fn init(device: *Device, allocator: std.mem.Allocator, info: *const vk.Image return .{ .image = image, + .non_dispatchable_image = try NonDispatchable(Image).wrap(allocator, image), .memory = memory, .state = .Available, }; } pub fn deinit(self: *Self, allocator: std.mem.Allocator) void { - self.image.destroy(allocator); + self.non_dispatchable_image.intrusiveDestroy(allocator); self.memory.destroy(allocator); } diff --git a/src/vulkan/wsi/SwapchainKHR.zig b/src/vulkan/wsi/SwapchainKHR.zig index 6b354e9..04063d1 100644 --- a/src/vulkan/wsi/SwapchainKHR.zig +++ b/src/vulkan/wsi/SwapchainKHR.zig @@ -18,7 +18,7 @@ owner: *Device, surface: ?*SurfaceKHR, images: []PresentImage, -pub fn create(device: *Device, allocator: std.mem.Allocator, info: *const vk.SwapchainCreateInfoKHR) VkError!*Self { +pub fn create(device: *Device, allocator: std.mem.Allocator, surface: *SurfaceKHR, info: *const vk.SwapchainCreateInfoKHR) VkError!*Self { const self = allocator.create(Self) catch return VkError.OutOfHostMemory; errdefer allocator.destroy(self); @@ -46,17 +46,22 @@ pub fn create(device: *Device, allocator: std.mem.Allocator, info: *const vk.Swa .queue_family_index_count = info.queue_family_index_count, .initial_layout = .general, }); + + try surface.attachImage(allocator, image); } self.* = .{ .owner = device, - .surface = null, + .surface = surface, .images = images, }; + + surface.swapchain = self; + return self; } -pub fn getNextImage(self: *const Self, timeout: u64, semaphore: *BinarySemaphore, fence: *Fence, index: *u32) VkError!void { +pub fn getNextImage(self: *const Self, timeout: u64, semaphore: ?*BinarySemaphore, fence: ?*Fence, index: *u32) VkError!void { // TODO: handle timeout correctly for (self.images, 0..) |*image, i| { @@ -65,7 +70,8 @@ pub fn getNextImage(self: *const Self, timeout: u64, semaphore: *BinarySemaphore index.* = @intCast(i); // TODO: signal semaphore _ = semaphore; - try fence.signal(); + if (fence) |f| + try f.signal(); return; } } diff --git a/src/vulkan/wsi/WaylandSurfaceKHR.zig b/src/vulkan/wsi/WaylandSurfaceKHR.zig index fa77822..211f39e 100644 --- a/src/vulkan/wsi/WaylandSurfaceKHR.zig +++ b/src/vulkan/wsi/WaylandSurfaceKHR.zig @@ -19,16 +19,16 @@ const WaylandImage = struct { stride: u32, }; -fn wlRegistryHandleGlobal(data: *anyopaque, registry: *wayland.wl_registry, name: c_uint, interface: [*:0]const u8, _: c_uint) callconv(.c) void { - const pshm: **wayland.wl_shm = @ptrCast(@alignCast(data)); +fn wlRegistryHandleGlobal(data: ?*anyopaque, registry: ?*wayland.wl_registry, name: u32, interface: [*c]const u8, _: u32) callconv(.c) void { + const pshm: **wayland.wl_shm = @ptrCast(@alignCast(data orelse return)); if (std.mem.eql(u8, std.mem.span(interface), "wl_shm")) { - if (wayland.wl_registry_bind(registry, name, wayland.wl_shm_interface, 1)) |shm| { + if (wayland.c.wl_registry_bind(registry orelse return, name, wayland.wl_shm_interface, 1)) |shm| { pshm.* = @ptrCast(@alignCast(shm)); } } } -fn wlRegistryHandleGlobalRemove(_: *anyopaque, _: *wayland.wl_registry, _: c_uint) callconv(.c) void {} +fn wlRegistryHandleGlobalRemove(_: ?*anyopaque, _: ?*wayland.wl_registry, _: u32) callconv(.c) void {} const wl_registry_listener: wayland.wl_registry_listener = .{ .global = wlRegistryHandleGlobal, @@ -65,9 +65,9 @@ pub fn create(instance: *Instance, allocator: std.mem.Allocator, info: *const vk .image_map = .empty, }; - const registry = wayland.wl_display_get_registry(self.display) orelse return VkError.Unknown; - _ = wayland.wl_registry_add_listener(registry, &wl_registry_listener, @ptrCast(&self.shm)); - _ = wayland.wl_display_dispatch(self.display); + const registry = wayland.c.wl_display_get_registry(@ptrCast(self.display)) orelse return VkError.Unknown; + _ = wayland.c.wl_registry_add_listener(registry, &wl_registry_listener, @ptrCast(&self.shm)); + _ = wayland.c.wl_display_dispatch(@ptrCast(self.display)); return &self.interface; } @@ -106,11 +106,11 @@ pub fn attachImage(interface: *Interface, allocator: std.mem.Allocator, image: * const data = std.posix.mmap(null, size, .{ .READ = true, .WRITE = true }, .{ .TYPE = .SHARED }, fd, 0) catch return VkError.OutOfHostMemory; errdefer std.posix.munmap(data); - const pool = wayland.wl_shm_create_pool(self.shm, fd, @intCast(size)) orelse return VkError.Unknown; - defer wayland.wl_shm_pool_destroy(pool); + const pool = wayland.c.wl_shm_create_pool(self.shm, fd, @intCast(size)) orelse return VkError.Unknown; + defer wayland.c.wl_shm_pool_destroy(pool); - const buffer = wayland.wl_shm_pool_create_buffer(pool, 0, @intCast(width), @intCast(height), @intCast(stride), wayland.WL_SHM_FORMAT_ARGB8888) orelse return VkError.Unknown; - errdefer wayland.wl_buffer_destroy(buffer); + const buffer = wayland.c.wl_shm_pool_create_buffer(pool, 0, @intCast(width), @intCast(height), @intCast(stride), wayland.WL_SHM_FORMAT_ARGB8888) orelse return VkError.Unknown; + errdefer wayland.c.wl_buffer_destroy(buffer); wl_image.* = .{ .buffer = buffer, @@ -128,7 +128,7 @@ pub fn detachImage(interface: *Interface, allocator: std.mem.Allocator, image: * const entry = self.image_map.fetchRemove(image) orelse return; const wl_image = entry.value; - wayland.wl_buffer_destroy(wl_image.buffer); + wayland.c.wl_buffer_destroy(wl_image.buffer); std.posix.munmap(wl_image.data); allocator.destroy(wl_image); } @@ -146,14 +146,11 @@ pub fn presentImage(interface: *Interface, allocator: std.mem.Allocator, image: .layer_count = 1, }); - wayland.wl_surface_attach(self.surface, wl_image.buffer, 0, 0); - wayland.wl_surface_damage(self.surface, 0, 0, @intCast(wl_image.width), @intCast(wl_image.height)); - wayland.wl_surface_commit(self.surface); + wayland.c.wl_surface_attach(@ptrCast(self.surface), wl_image.buffer, 0, 0); + wayland.c.wl_surface_damage(@ptrCast(self.surface), 0, 0, @intCast(wl_image.width), @intCast(wl_image.height)); + wayland.c.wl_surface_commit(@ptrCast(self.surface)); - // Better: bind wl_display_flush in wayland.zig and call it here. - // With the currently available bindings, roundtrip forces the commit out, - // but it is heavier than necessary. - _ = wayland.wl_display_roundtrip(self.display); + _ = wayland.c.wl_display_flush(@ptrCast(self.display)); image.state = .Available; } diff --git a/src/vulkan/wsi/clients/wayland.zig b/src/vulkan/wsi/clients/wayland.zig index 99cdeed..1522bb1 100644 --- a/src/vulkan/wsi/clients/wayland.zig +++ b/src/vulkan/wsi/clients/wayland.zig @@ -2,37 +2,29 @@ const std = @import("std"); const vk = @import("vulkan"); const lib = @import("../../lib.zig"); +pub const c = lib.c; + const VkError = lib.VkError; -pub const wl_registry_listener = extern struct { - global: *const fn (*anyopaque, *wl_registry, c_uint, [*:0]const u8, c_uint) callconv(.c) void, - global_remove: *const fn (*anyopaque, *wl_registry, c_uint) callconv(.c) void, -}; +pub const wl_registry_listener = c.wl_registry_listener; -pub const WL_SHM_FORMAT_ARGB8888 = 0; +pub const WL_SHM_FORMAT_ARGB8888 = c.WL_SHM_FORMAT_ARGB8888; -pub const wl_buffer = opaque {}; -pub const wl_callback = opaque {}; +pub const wl_buffer = c.wl_buffer; +pub const wl_callback = c.wl_buffer; +pub const wl_interface = c.wl_interface; +pub const wl_registry = c.wl_registry; +pub const wl_shm = c.wl_shm; +pub const wl_shm_pool = c.wl_shm_pool; +pub const wl_proxy = c.wl_proxy; + +// vk.wl_XXX instead of c.wl_XXX to avoid casts with Zig Vulkan bindings functions pub const wl_display = vk.wl_display; -pub const wl_interface = opaque {}; -pub const wl_registry = opaque {}; -pub const wl_shm = opaque {}; -pub const wl_shm_pool = opaque {}; pub const wl_surface = vk.wl_surface; -pub var wl_display_dispatch: *const fn (d: *wl_display) callconv(.c) c_int = undefined; -pub var wl_display_get_registry: *const fn (d: *wl_display) callconv(.c) ?*wl_registry = undefined; -pub var wl_display_roundtrip: *const fn (d: *wl_display) callconv(.c) c_int = undefined; -pub var wl_display_sync: *const fn (d: *wl_display) callconv(.c) ?*wl_callback = undefined; -pub var wl_registry_add_listener: *const fn (r: *wl_registry, l: *const wl_registry_listener, data: *anyopaque) callconv(.c) c_int = undefined; -pub var wl_registry_bind: *const fn (r: *wl_registry, name: u32, i: *const wl_interface, version: u32) callconv(.c) ?*anyopaque = undefined; -pub var wl_buffer_destroy: *const fn (b: *wl_buffer) callconv(.c) void = undefined; -pub var wl_shm_create_pool: *const fn (shm: *wl_shm, fd: i32, size: i32) callconv(.c) ?*wl_shm_pool = undefined; -pub var wl_shm_pool_create_buffer: *const fn (p: *wl_shm_pool, offset: i32, width: i32, height: i32, stride: i32, format: u32) callconv(.c) ?*wl_buffer = undefined; -pub var wl_shm_pool_destroy: *const fn (p: *wl_shm_pool) callconv(.c) void = undefined; -pub var wl_surface_attach: *const fn (s: *wl_surface, b: *wl_buffer, x: i32, y: i32) callconv(.c) void = undefined; -pub var wl_surface_damage: *const fn (s: *wl_surface, x: i32, y: i32, width: i32, height: i32) callconv(.c) void = undefined; -pub var wl_surface_commit: *const fn (s: *wl_surface) callconv(.c) void = undefined; +pub var wl_display_dispatch: *const fn (*wl_display) callconv(.c) c_int = undefined; +pub var wl_proxy_marshal_flags: *const fn (*wl_proxy, u32, *const wl_interface, u32, u32, ...) callconv(.c) ?*wl_proxy = undefined; +pub var wl_display_flush: *const fn (*wl_display) callconv(.c) c_int = undefined; pub var wl_shm_interface: *wl_interface = undefined; @@ -49,23 +41,11 @@ pub fn load() VkError!void { return VkError.Unknown; }; errdefer module.close(); - errdefer std.debug.print("test {s}\n", .{std.c.dlerror().?}); + errdefer std.log.scoped(.WaylandClient).err("Could not open 'libwayland-client.so.0': {s}", .{std.c.dlerror() orelse "unknown error"}); - // zig fmt: off - wl_display_dispatch = module.lookup(@TypeOf(wl_display_dispatch), "wl_display_dispatch" ) orelse return VkError.Unknown; - wl_display_get_registry = module.lookup(@TypeOf(wl_display_get_registry), "wl_display_get_registry" ) orelse return VkError.Unknown; - wl_display_roundtrip = module.lookup(@TypeOf(wl_display_roundtrip), "wl_display_roundtrip" ) orelse return VkError.Unknown; - wl_display_sync = module.lookup(@TypeOf(wl_display_sync), "wl_display_sync" ) orelse return VkError.Unknown; - wl_registry_add_listener = module.lookup(@TypeOf(wl_registry_add_listener), "wl_registry_add_listener" ) orelse return VkError.Unknown; - wl_registry_bind = module.lookup(@TypeOf(wl_registry_bind), "wl_registry_bind" ) orelse return VkError.Unknown; - wl_buffer_destroy = module.lookup(@TypeOf(wl_buffer_destroy), "wl_buffer_destroy" ) orelse return VkError.Unknown; - wl_shm_create_pool = module.lookup(@TypeOf(wl_shm_create_pool), "wl_shm_create_pool" ) orelse return VkError.Unknown; - wl_shm_pool_create_buffer = module.lookup(@TypeOf(wl_shm_pool_create_buffer), "wl_shm_pool_create_buffer") orelse return VkError.Unknown; - wl_shm_pool_destroy = module.lookup(@TypeOf(wl_shm_pool_destroy), "wl_shm_pool_destroy" ) orelse return VkError.Unknown; - wl_surface_attach = module.lookup(@TypeOf(wl_surface_attach), "wl_surface_attach" ) orelse return VkError.Unknown; - wl_surface_damage = module.lookup(@TypeOf(wl_surface_damage), "wl_surface_damage" ) orelse return VkError.Unknown; - wl_surface_commit = module.lookup(@TypeOf(wl_surface_commit), "wl_surface_commit" ) orelse return VkError.Unknown; - // zig fmt: on + wl_display_dispatch = module.lookup(@TypeOf(wl_display_dispatch), "wl_display_dispatch") orelse return VkError.Unknown; + wl_proxy_marshal_flags = module.lookup(@TypeOf(wl_proxy_marshal_flags), "wl_proxy_marshal_flags") orelse return VkError.Unknown; + wl_display_flush = module.lookup(@TypeOf(wl_display_flush), "wl_display_flush") orelse return VkError.Unknown; wl_shm_interface = module.lookup(*wl_interface, "wl_shm_interface") orelse return VkError.Unknown;