[Soft] fixing 32bits support because I have free will

src/vulkan/NonDispatchable.zig

@@ -44,7 +44,8 @@ pub fn NonDispatchable(comptime T: type) type {
             if (handle == 0) {
                 return VkError.InvalidHandleDrv;
             }
-            const non_dispatchable: *Self = @ptrFromInt(handle);
+            const address = std.math.cast(usize, handle) orelse return VkError.InvalidHandleDrv;
+            const non_dispatchable: *Self = @ptrFromInt(address);
             if (non_dispatchable.object_type != T.ObjectType) {
                 return VkError.InvalidHandleDrv;
             }

src/vulkan/QueryPool.zig

@@ -14,8 +14,51 @@ queries: []Query,
 
 vtable: *const VTable,
 
+/// 32 bits platforms only supportss atomics up to 32 bits,
+/// so serialize 64-bit query access with a 32-bit lock.
+const LockedU64 = struct {
+    mutex: std.atomic.Value(u32) = std.atomic.Value(u32).init(0),
+    raw: u64,
+
+    fn init(value: u64) LockedU64 {
+        return .{ .raw = value };
+    }
+
+    fn lock(self: *LockedU64) void {
+        while (self.mutex.cmpxchgWeak(0, 1, .acquire, .monotonic) != null) {
+            std.atomic.spinLoopHint();
+        }
+    }
+
+    fn unlock(self: *LockedU64) void {
+        self.mutex.store(0, .release);
+    }
+
+    fn load(self: *LockedU64, comptime _: std.builtin.AtomicOrder) u64 {
+        self.lock();
+        defer self.unlock();
+        return self.raw;
+    }
+
+    fn store(self: *LockedU64, value: u64, comptime _: std.builtin.AtomicOrder) void {
+        self.lock();
+        defer self.unlock();
+        self.raw = value;
+    }
+
+    fn fetchAdd(self: *LockedU64, value: u64, comptime _: std.builtin.AtomicOrder) u64 {
+        self.lock();
+        defer self.unlock();
+        const previous = self.raw;
+        self.raw +%= value;
+        return previous;
+    }
+};
+
+const QueryValue = if (@bitSizeOf(usize) >= 64) std.atomic.Value(u64) else LockedU64;
+
 const Query = struct {
-    value: std.atomic.Value(u64) = std.atomic.Value(u64).init(0),
+    value: QueryValue = QueryValue.init(0),
     available: bool = false,
     active: bool = false,
 };

src/vulkan/lib_vulkan.zig

@@ -1860,7 +1860,8 @@ pub export fn apeCmdBindIndexBuffer(p_cmd: vk.CommandBuffer, p_buffer: vk.Buffer
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
     const buffer = NonDispatchable(Buffer).fromHandleObject(p_buffer) catch |err| return errorLogger(err);
-    cmd.bindIndexBuffer(buffer, offset, index_type) catch |err| return errorLogger(err);
+    const host_offset = std.math.cast(usize, offset) orelse return errorLogger(VkError.ValidationFailed);
+    cmd.bindIndexBuffer(buffer, host_offset, index_type) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdBindPipeline(p_cmd: vk.CommandBuffer, bind_point: vk.PipelineBindPoint, p_pipeline: vk.Pipeline) callconv(vk.vulkan_call_conv) void {
@@ -1879,7 +1880,8 @@ pub export fn apeCmdBindVertexBuffers(p_cmd: vk.CommandBuffer, first: u32, count
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
     for (p_buffers, offsets, 0..count) |p_buffer, offset, i| {
         const buffer = NonDispatchable(Buffer).fromHandleObject(p_buffer) catch |err| return errorLogger(err);
-        cmd.bindVertexBuffer(first + i, buffer, offset) catch |err| return errorLogger(err);
+        const host_offset = std.math.cast(usize, offset) orelse return errorLogger(VkError.ValidationFailed);
+        cmd.bindVertexBuffer(first + i, buffer, host_offset) catch |err| return errorLogger(err);
     }
 }
 
@@ -2035,7 +2037,8 @@ pub export fn apeCmdDrawIndexedIndirect(p_cmd: vk.CommandBuffer, p_buffer: vk.Bu
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
     const buffer = NonDispatchable(Buffer).fromHandleObject(p_buffer) catch |err| return errorLogger(err);
-    cmd.drawIndexedIndirect(buffer, offset, count, stride) catch |err| return errorLogger(err);
+    const host_offset = std.math.cast(usize, offset) orelse return errorLogger(VkError.ValidationFailed);
+    cmd.drawIndexedIndirect(buffer, host_offset, count, stride) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdDrawIndirect(p_cmd: vk.CommandBuffer, p_buffer: vk.Buffer, offset: vk.DeviceSize, count: u32, stride: u32) callconv(vk.vulkan_call_conv) void {
@@ -2044,7 +2047,8 @@ pub export fn apeCmdDrawIndirect(p_cmd: vk.CommandBuffer, p_buffer: vk.Buffer, o
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
     const buffer = NonDispatchable(Buffer).fromHandleObject(p_buffer) catch |err| return errorLogger(err);
-    cmd.drawIndirect(buffer, offset, count, stride) catch |err| return errorLogger(err);
+    const host_offset = std.math.cast(usize, offset) orelse return errorLogger(VkError.ValidationFailed);
+    cmd.drawIndirect(buffer, host_offset, count, stride) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdEndQuery(p_cmd: vk.CommandBuffer, p_pool: vk.QueryPool, query: u32) callconv(vk.vulkan_call_conv) void {
@@ -2265,8 +2269,9 @@ pub export fn apeCmdUpdateBuffer(p_cmd: vk.CommandBuffer, p_buffer: vk.Buffer, o
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
     const buffer = NonDispatchable(Buffer).fromHandleObject(p_buffer) catch |err| return errorLogger(err);
+    const data_size = std.math.cast(usize, size) orelse return errorLogger(VkError.ValidationFailed);
     const data_bytes: [*]const u8 = @ptrCast(data);
-    cmd.updateBuffer(buffer, offset, data_bytes[0..size]) catch |err| return errorLogger(err);
+    cmd.updateBuffer(buffer, offset, data_bytes[0..data_size]) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdWaitEvents(