gpu: implement Device.setUncapturedErrorCallback

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

gpu/src/Device.zig

@@ -81,9 +81,7 @@ pub const VTable = struct {
     // TODO: callback
     // setLoggingCallback: fn (ptr: *anyopaque, callback: LoggingCallback) void,
     // WGPU_EXPORT void wgpuDeviceSetLoggingCallback(WGPUDevice device, WGPULoggingCallback callback, void * userdata);
-    // TODO: callback
+    setUncapturedErrorCallback: fn (ptr: *anyopaque, callback: *ErrorCallback) void,
-    // setUncapturedErrorCallback: fn (ptr: *anyopaque, callback: UncapturedErrorCallback) void,
-    // WGPU_EXPORT void wgpuDeviceSetUncapturedErrorCallback(WGPUDevice device, WGPUErrorCallback callback, void * userdata);
     tick: fn (ptr: *anyopaque) void,
 };
 
@@ -198,6 +196,10 @@ pub inline fn createRenderPipelineAsync(
     device.vtable.createRenderPipelineAsync(device.ptr, descriptor, callback);
 }
 
+pub inline fn setUncapturedErrorCallback(device: Device, callback: *ErrorCallback) void {
+    device.vtable.setUncapturedErrorCallback(device.ptr, callback);
+}
+
 pub inline fn tick(device: Device) void {
     device.vtable.tick(device.ptr);
 }

gpu/src/NativeInstance.zig

@@ -675,6 +675,33 @@ const device_vtable = Device.VTable{
             );
         }
     }).createRenderPipelineAsync,
+    .setUncapturedErrorCallback = (struct {
+        pub fn setUncapturedErrorCallback(
+            ptr: *anyopaque,
+            callback: *ErrorCallback,
+        ) void {
+            const cCallback = (struct {
+                pub fn cCallback(
+                    typ: c.WGPUErrorType,
+                    message: [*c]const u8,
+                    userdata: ?*anyopaque,
+                ) callconv(.C) void {
+                    const callback_info = @ptrCast(*ErrorCallback, @alignCast(@alignOf(*ErrorCallback), userdata));
+                    callback_info.type_erased_callback(
+                        callback_info.type_erased_ctx,
+                        @intToEnum(ErrorType, typ),
+                        std.mem.span(message),
+                    );
+                }
+            }).cCallback;
+
+            return c.wgpuDeviceSetUncapturedErrorCallback(
+                @ptrCast(c.WGPUDevice, ptr),
+                cCallback,
+                callback,
+            );
+        }
+    }).setUncapturedErrorCallback,
     .tick = (struct {
         pub fn tick(ptr: *anyopaque) void {
             c.wgpuDeviceTick(@ptrCast(c.WGPUDevice, ptr));