From 0547d84ad1a8fd5b526eb1a17e01332156d9b836 Mon Sep 17 00:00:00 2001 From: richerfu Date: Tue, 28 Jul 2026 09:27:47 +0800 Subject: [PATCH] refactor: bind wrapper calls from wgpu headers --- README.md | 9 +- build/Library.zig | 1 + src/adapter.zig | 43 ++----- src/bind_group.zig | 36 ++---- src/buffer.zig | 45 ++----- src/command_encoder.zig | 267 +++++++++------------------------------- src/device.zig | 109 ++++------------ src/instance.zig | 70 +++-------- src/log.zig | 8 +- src/misc.zig | 12 +- src/pipeline.zig | 51 ++------ src/query_set.zig | 27 +--- src/queue.zig | 37 ++---- src/raw.zig | 109 ++++++++++++++++ src/render_bundle.zig | 80 +++--------- src/root.zig | 27 +--- src/sampler.zig | 15 +-- src/shader.zig | 17 +-- src/surface.zig | 43 ++----- src/texture.zig | 69 +++-------- tests/abi.zig | 17 +++ tests/build.zig | 2 + 22 files changed, 338 insertions(+), 756 deletions(-) create mode 100644 src/raw.zig diff --git a/README.md b/README.md index 3e5228b..0e22644 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,9 @@ This package exposes two modules: `wgpu-c` and `wgpu`. `wgpu-c` is just `wgpu.h` (and by extension `webgpu.h`) run through `translate-c`, so as close to wgpu-native's original C API as is possible in Zig. -`wgpu` is a module full of pure Zig bindings for `libwgpu_native`, it does not import any C code and instead relies on `extern fn` declarations to hook up to `wgpu-native`. +`wgpu` is a Zig-friendly wrapper over the bindings generated directly from `wgpu.h` and +`webgpu.h`. The generated declarations are also available through `wgpu.raw`; wrapper +methods and raw calls therefore share the headers as their single ABI source of truth. ## Adding this package to your build Add the package to your dependencies, either with: @@ -294,15 +296,12 @@ both link modes and the matching headers. }).withDesiredMaxFrameLatency(2); ``` * `WGPUBool` is replaced with `bool` whenever possible. - * This pretty much means, it is replaced with `bool` in the parameters and return values of methods, but not in structs or the parameters/return values of procs (which are supposed to be function pointers to things returned by `wgpuGetProcAddress`). + * This means it is replaced with `bool` in wrapper method parameters and return values, but not in structs that preserve the C ABI. ## TODO * Cleanup/organization: * If types are only tied to a specific opaque struct, they should be decls inside that struct. - * The associated Procs struct should probably be a decl of the opaque struct as well. * There are many things that seem to be in the wrong file. * For example a lot of what is in `pipeline.zig` is actually only used by `Device`, and should probably be in `device.zig` instead. * Since pointers to opaque structs are made explicit, it would be more consistent if pointers to callback functions are explicit as well. * Port [wgpu-native-examples](https://github.com/samdauwe/webgpu-native-examples) using wrapper code, as a basic form of documentation. -* Bindgen using [the webgpu-headers yaml](https://github.com/webgpu-native/webgpu-headers/blob/main/webgpu.yml)? -* The proc definitions are mainly there since they are also present in the webgpu headers and I didn't fully understand what they were for when I started working on this project. However, I know better now and they aren't really used for anything currently. They're supposed to be used with `wgpuGetProcAddress` but it's [unimplemented in `wgpu-native`](https://github.com/gfx-rs/wgpu-native/issues/223). They are a pain to update by hand, so maybe they should be removed for now and made optional once we have a working bindings generator? Like the bindgen could put them in a separate `wgpu-procs` module. diff --git a/build/Library.zig b/build/Library.zig index 3f68b16..61e2f53 100644 --- a/build/Library.zig +++ b/build/Library.zig @@ -114,6 +114,7 @@ pub fn build(b: *std.Build, options: Options) ?Result { Platform.configureTranslateC(platform, translate_step); const wgpu_c_mod = translate_step.addModule("wgpu-c"); wgpu_c_mod.resolved_target = options.target; + wgpu_mod.addImport("wgpu-header", wgpu_c_mod); var result: Result = .{ .target = options.target, diff --git a/src/adapter.zig b/src/adapter.zig index 3ff62d3..1b4fdb9 100644 --- a/src/adapter.zig +++ b/src/adapter.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const std = @import("std"); const _chained_struct = @import("chained_struct.zig"); @@ -125,12 +126,6 @@ pub const RequestAdapterResponse = struct { adapter: ?*Adapter, }; -pub const AdapterInfoProcs = struct { - pub const FreeMembers = *const fn (AdapterInfo) callconv(.c) void; -}; - -extern fn wgpuAdapterInfoFreeMembers(adapter_info: AdapterInfo) void; - pub const AdapterInfo = extern struct { next_in_chain: ?*ChainedStructOut = null, vendor: StringView, @@ -145,40 +140,22 @@ pub const AdapterInfo = extern struct { subgroup_max_size: u32, pub inline fn freeMembers(self: AdapterInfo) void { - wgpuAdapterInfoFreeMembers(self); + raw.call(void, "wgpuAdapterInfoFreeMembers", .{self}); } }; -pub const AdapterProcs = struct { - pub const GetFeatures = *const fn (*Adapter, *SupportedFeatures) callconv(.c) void; - pub const GetLimits = *const fn (*Adapter, *Limits) callconv(.c) Status; - pub const GetInfo = *const fn (*Adapter, *AdapterInfo) callconv(.c) Status; - pub const HasFeature = *const fn (*Adapter, FeatureName) callconv(.c) WGPUBool; - pub const RequestDevice = *const fn (*Adapter, ?*const DeviceDescriptor, RequestDeviceCallbackInfo) callconv(.c) Future; - pub const AddRef = *const fn (*Adapter) callconv(.c) void; - pub const Release = *const fn (*Adapter) callconv(.c) void; -}; - -extern fn wgpuAdapterGetFeatures(adapter: *Adapter, features: *SupportedFeatures) void; -extern fn wgpuAdapterGetLimits(adapter: *Adapter, limits: *Limits) Status; -extern fn wgpuAdapterGetInfo(adapter: *Adapter, info: *AdapterInfo) Status; -extern fn wgpuAdapterHasFeature(adapter: *Adapter, feature: FeatureName) WGPUBool; -extern fn wgpuAdapterRequestDevice(adapter: *Adapter, descriptor: ?*const DeviceDescriptor, callback_info: RequestDeviceCallbackInfo) Future; -extern fn wgpuAdapterAddRef(adapter: *Adapter) void; -extern fn wgpuAdapterRelease(adapter: *Adapter) void; - pub const Adapter = opaque { pub inline fn getFeatures(self: *Adapter, features: *SupportedFeatures) void { - wgpuAdapterGetFeatures(self, features); + raw.call(void, "wgpuAdapterGetFeatures", .{ self, features }); } pub inline fn getLimits(self: *Adapter, limits: *Limits) Status { - return wgpuAdapterGetLimits(self, limits); + return raw.call(Status, "wgpuAdapterGetLimits", .{ self, limits }); } pub inline fn getInfo(self: *Adapter, info: *AdapterInfo) Status { - return wgpuAdapterGetInfo(self, info); + return raw.call(Status, "wgpuAdapterGetInfo", .{ self, info }); } pub inline fn hasFeature(self: *Adapter, feature: FeatureName) bool { - return wgpuAdapterHasFeature(self, feature) != 0; + return raw.call(WGPUBool, "wgpuAdapterHasFeature", .{ self, feature }) != 0; } fn defaultDeviceCallback(status: RequestDeviceStatus, device: ?*Device, message: StringView, userdata1: ?*anyopaque, userdata2: ?*anyopaque) callconv(.c) void { @@ -209,7 +186,7 @@ pub const Adapter = opaque { .userdata1 = @ptrCast(&response), .userdata2 = @ptrCast(&completed), }; - const device_future = wgpuAdapterRequestDevice(self, descriptor, callback_info); + const device_future = raw.call(Future, "wgpuAdapterRequestDevice", .{ self, descriptor, callback_info }); // TODO: Revisit once Instance.waitAny() is implemented in wgpu-native, // it takes in futures and returns when one of them completes. @@ -224,13 +201,13 @@ pub const Adapter = opaque { } pub inline fn requestDevice(self: *Adapter, descriptor: ?*const DeviceDescriptor, callback_info: RequestDeviceCallbackInfo) Future { - return wgpuAdapterRequestDevice(self, descriptor, callback_info); + return raw.call(Future, "wgpuAdapterRequestDevice", .{ self, descriptor, callback_info }); } pub inline fn addRef(self: *Adapter) void { - wgpuAdapterAddRef(self); + raw.call(void, "wgpuAdapterAddRef", .{self}); } pub inline fn release(self: *Adapter) void { - wgpuAdapterRelease(self); + raw.call(void, "wgpuAdapterRelease", .{self}); } }; diff --git a/src/bind_group.zig b/src/bind_group.zig index e1b6c83..c10ebd3 100644 --- a/src/bind_group.zig +++ b/src/bind_group.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const _chained_struct = @import("chained_struct.zig"); const ChainedStruct = _chained_struct.ChainedStruct; const SType = _chained_struct.SType; @@ -27,17 +28,14 @@ const StringView = _misc.StringView; pub const ExternalTexture = opaque { pub inline fn addRef(self: *ExternalTexture) void { - wgpuExternalTextureAddRef(self); + raw.call(void, "wgpuExternalTextureAddRef", .{self}); } pub inline fn release(self: *ExternalTexture) void { - wgpuExternalTextureRelease(self); + raw.call(void, "wgpuExternalTextureRelease", .{self}); } }; -extern fn wgpuExternalTextureAddRef(external_texture: *ExternalTexture) void; -extern fn wgpuExternalTextureRelease(external_texture: *ExternalTexture) void; - pub const ExternalTextureBindingLayout = extern struct { chain: ChainedStruct = .{ .s_type = .external_texture_binding_layout, @@ -94,16 +92,6 @@ pub const BindGroupLayoutDescriptor = extern struct { entries: [*]const BindGroupLayoutEntry, }; -pub const BindGroupLayoutProcs = struct { - pub const SetLabel = *const fn (*BindGroupLayout, StringView) callconv(.c) void; - pub const AddRef = *const fn (*BindGroupLayout) callconv(.c) void; - pub const Release = *const fn (*BindGroupLayout) callconv(.c) void; -}; - -extern fn wgpuBindGroupLayoutSetLabel(bind_group_layout: *BindGroupLayout, label: StringView) void; -extern fn wgpuBindGroupLayoutAddRef(bind_group_layout: *BindGroupLayout) void; -extern fn wgpuBindGroupLayoutRelease(bind_group_layout: *BindGroupLayout) void; - pub const BindGroupLayout = opaque { // Unimplemented as of wgpu-native v29.0.0.0, // see https://github.com/gfx-rs/wgpu-native/blob/d2e3330ade4ae1bb238d76b485926f067e7ee64c/src/unimplemented.rs @@ -112,10 +100,10 @@ pub const BindGroupLayout = opaque { // } pub inline fn addRef(self: *BindGroupLayout) void { - wgpuBindGroupLayoutAddRef(self); + raw.call(void, "wgpuBindGroupLayoutAddRef", .{self}); } pub inline fn release(self: *BindGroupLayout) void { - wgpuBindGroupLayoutRelease(self); + raw.call(void, "wgpuBindGroupLayoutRelease", .{self}); } }; @@ -155,16 +143,6 @@ pub const BindGroupDescriptor = extern struct { entries: [*]const BindGroupEntry, }; -pub const BindGroupProcs = struct { - pub const SetLabel = *const fn (*BindGroup, StringView) callconv(.c) void; - pub const AddRef = *const fn (*BindGroup) callconv(.c) void; - pub const Release = *const fn (*BindGroup) callconv(.c) void; -}; - -extern fn wgpuBindGroupSetLabel(bind_group: *BindGroup, label: StringView) void; -extern fn wgpuBindGroupAddRef(bind_group: *BindGroup) void; -extern fn wgpuBindGroupRelease(bind_group: *BindGroup) void; - pub const BindGroup = opaque { // Unimplemented as of wgpu-native v29.0.0.0, // see https://github.com/gfx-rs/wgpu-native/blob/d2e3330ade4ae1bb238d76b485926f067e7ee64c/src/unimplemented.rs @@ -173,9 +151,9 @@ pub const BindGroup = opaque { // } pub inline fn addRef(self: *BindGroup) void { - wgpuBindGroupAddRef(self); + raw.call(void, "wgpuBindGroupAddRef", .{self}); } pub inline fn release(self: *BindGroup) void { - wgpuBindGroupRelease(self); + raw.call(void, "wgpuBindGroupRelease", .{self}); } }; diff --git a/src/buffer.zig b/src/buffer.zig index edd0d67..9645e55 100644 --- a/src/buffer.zig +++ b/src/buffer.zig @@ -11,6 +11,7 @@ const CallbackMode = _async.CallbackMode; const Future = _async.Future; const ChainedStruct = @import("chained_struct.zig").ChainedStruct; +const raw = @import("raw.zig"); pub const BufferBindingType = enum(u32) { binding_not_used = 0x00000000, // Indicates that this BufferBindingLayout member of its parent BindGroupLayoutEntry is not used. @@ -83,35 +84,9 @@ pub const BufferDescriptor = extern struct { mapped_at_creation: WGPUBool = @intFromBool(false), }; -pub const BufferProcs = struct { - pub const Destroy = *const fn (*Buffer) callconv(.c) void; - pub const GetConstMappedRange = *const fn (*Buffer, usize, usize) callconv(.c) ?*const anyopaque; - pub const GetMapState = *const fn (*Buffer) callconv(.c) BufferMapState; - pub const GetMappedRange = *const fn (*Buffer, usize, usize) callconv(.c) ?*anyopaque; - pub const GetSize = *const fn (*Buffer) callconv(.c) u64; - pub const GetUsage = *const fn (*Buffer) callconv(.c) BufferUsage; - pub const MapAsync = *const fn (*Buffer, MapMode, usize, usize, BufferMapCallbackInfo) callconv(.c) Future; - pub const SetLabel = *const fn (*Buffer, StringView) callconv(.c) void; - pub const Unmap = *const fn (*Buffer) callconv(.c) void; - pub const AddRef = *const fn (*Buffer) callconv(.c) void; - pub const Release = *const fn (*Buffer) callconv(.c) void; -}; - -extern fn wgpuBufferDestroy(buffer: *Buffer) void; -extern fn wgpuBufferGetConstMappedRange(buffer: *Buffer, offset: usize, size: usize) ?*const anyopaque; -extern fn wgpuBufferGetMapState(buffer: *Buffer) BufferMapState; -extern fn wgpuBufferGetMappedRange(buffer: *Buffer, offset: usize, size: usize) ?*anyopaque; -extern fn wgpuBufferGetSize(buffer: *Buffer) u64; -extern fn wgpuBufferGetUsage(buffer: *Buffer) BufferUsage; -extern fn wgpuBufferMapAsync(buffer: *Buffer, mode: MapMode, offset: usize, size: usize, callback_info: BufferMapCallbackInfo) Future; -extern fn wgpuBufferSetLabel(buffer: *Buffer, label: StringView) void; -extern fn wgpuBufferUnmap(buffer: *Buffer) void; -extern fn wgpuBufferAddRef(buffer: *Buffer) void; -extern fn wgpuBufferRelease(buffer: *Buffer) void; - pub const Buffer = opaque { pub inline fn destroy(self: *Buffer) void { - wgpuBufferDestroy(self); + raw.call(void, "wgpuBufferDestroy", .{self}); } // offset @@ -130,7 +105,7 @@ pub const Buffer = opaque { // // wgpu-native translates a size of WGPU_WHOLE_MAP_SIZE to "None" internally pub inline fn getConstMappedRange(self: *Buffer, offset: usize, size: usize) ?*const anyopaque { - return wgpuBufferGetConstMappedRange(self, offset, size); + return raw.call(?*const anyopaque, "wgpuBufferGetConstMappedRange", .{ self, offset, size }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -153,18 +128,18 @@ pub const Buffer = opaque { // // wgpu-native translates a size of WGPU_WHOLE_MAP_SIZE to "None" internally pub inline fn getMappedRange(self: *Buffer, offset: usize, size: usize) ?*anyopaque { - return wgpuBufferGetMappedRange(self, offset, size); + return raw.call(?*anyopaque, "wgpuBufferGetMappedRange", .{ self, offset, size }); } pub inline fn getSize(self: *Buffer) u64 { - return wgpuBufferGetSize(self); + return raw.call(u64, "wgpuBufferGetSize", .{self}); } pub inline fn getUsage(self: *Buffer) BufferUsage { - return wgpuBufferGetUsage(self); + return raw.call(BufferUsage, "wgpuBufferGetUsage", .{self}); } pub inline fn mapAsync(self: *Buffer, mode: MapMode, offset: usize, size: usize, callback_info: BufferMapCallbackInfo) Future { - return wgpuBufferMapAsync(self, mode, offset, size, callback_info); + return raw.call(Future, "wgpuBufferMapAsync", .{ self, mode, offset, size, callback_info }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -174,12 +149,12 @@ pub const Buffer = opaque { // } pub inline fn unmap(self: *Buffer) void { - wgpuBufferUnmap(self); + raw.call(void, "wgpuBufferUnmap", .{self}); } pub inline fn addRef(self: *Buffer) void { - wgpuBufferAddRef(self); + raw.call(void, "wgpuBufferAddRef", .{self}); } pub inline fn release(self: *Buffer) void { - wgpuBufferRelease(self); + raw.call(void, "wgpuBufferRelease", .{self}); } }; diff --git a/src/command_encoder.zig b/src/command_encoder.zig index f8ab0c2..9997622 100644 --- a/src/command_encoder.zig +++ b/src/command_encoder.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const std = @import("std"); const _chained_struct = @import("chained_struct.zig"); @@ -48,64 +49,29 @@ pub const CommandEncoderDescriptor = extern struct { label: StringView = StringView{}, }; -const ComputePassEncoderProcs = struct { - pub const DispatchWorkgroups = *const fn (*ComputePassEncoder, u32, u32, u32) callconv(.c) void; - pub const DispatchWorkgroupsIndirect = *const fn (*ComputePassEncoder, *Buffer, u64) callconv(.c) void; - pub const End = *const fn (*ComputePassEncoder) callconv(.c) void; - pub const InsertDebugMarker = *const fn (*ComputePassEncoder, StringView) callconv(.c) void; - pub const PopDebugGroup = *const fn (*ComputePassEncoder) callconv(.c) void; - pub const PushDebugGroup = *const fn (*ComputePassEncoder, StringView) callconv(.c) void; - pub const SetBindGroup = *const fn (*ComputePassEncoder, u32, *BindGroup, usize, ?[*]const u32) callconv(.c) void; - pub const SetLabel = *const fn (*ComputePassEncoder, StringView) callconv(.c) void; - pub const SetPipeline = *const fn (*ComputePassEncoder, *ComputePipeline) callconv(.c) void; - pub const AddRef = *const fn (*ComputePassEncoder) callconv(.c) void; - pub const Release = *const fn (*ComputePassEncoder) callconv(.c) void; - - // wgpu-native procs? - // pub const BeginPipelineStatisticsQuery = *const fn(*ComputePassEncoder, *QuerySet, u32) callconv(.c) void; - // pub const EndPipelineStatisticsQuery = *const fn(*ComputePassEncoder) callconv(.c) void; - // pub const WriteTimestamp = *const fn(*ComputePassEncoder, *QuerySet, u32) callconv(.c) void; -}; - -extern fn wgpuComputePassEncoderDispatchWorkgroups(compute_pass_encoder: *ComputePassEncoder, workgroup_count_x: u32, workgroup_count_y: u32, workgroup_count_z: u32) void; -extern fn wgpuComputePassEncoderDispatchWorkgroupsIndirect(compute_pass_encoder: *ComputePassEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void; -extern fn wgpuComputePassEncoderEnd(compute_pass_encoder: *ComputePassEncoder) void; -extern fn wgpuComputePassEncoderInsertDebugMarker(compute_pass_encoder: *ComputePassEncoder, marker_label: StringView) void; -extern fn wgpuComputePassEncoderPopDebugGroup(compute_pass_encoder: *ComputePassEncoder) void; -extern fn wgpuComputePassEncoderPushDebugGroup(compute_pass_encoder: *ComputePassEncoder, group_label: StringView) void; -extern fn wgpuComputePassEncoderSetBindGroup(compute_pass_encoder: *ComputePassEncoder, group_index: u32, group: *BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void; -extern fn wgpuComputePassEncoderSetLabel(compute_pass_encoder: *ComputePassEncoder, label: StringView) void; -extern fn wgpuComputePassEncoderSetPipeline(compute_pass_encoder: *ComputePassEncoder, pipeline: *ComputePipeline) void; -extern fn wgpuComputePassEncoderAddRef(compute_pass_encoder: *ComputePassEncoder) void; -extern fn wgpuComputePassEncoderRelease(compute_pass_encoder: *ComputePassEncoder) void; - // wgpu-native -extern fn wgpuComputePassEncoderSetImmediates(compute_pass_encoder: *ComputePassEncoder, offset: u32, size_bytes: u32, data: *const anyopaque) void; -extern fn wgpuComputePassEncoderBeginPipelineStatisticsQuery(compute_pass_encoder: *ComputePassEncoder, query_set: *QuerySet, query_index: u32) void; -extern fn wgpuComputePassEncoderEndPipelineStatisticsQuery(compute_pass_encoder: *ComputePassEncoder) void; -extern fn wgpuComputePassEncoderWriteTimestamp(compute_pass_encoder: *ComputePassEncoder, query_set: *QuerySet, query_index: u32) void; pub const ComputePassEncoder = opaque { pub inline fn dispatchWorkgroups(self: *ComputePassEncoder, workgroup_count_x: u32, workgroup_count_y: u32, workgroup_count_z: u32) void { - wgpuComputePassEncoderDispatchWorkgroups(self, workgroup_count_x, workgroup_count_y, workgroup_count_z); + raw.call(void, "wgpuComputePassEncoderDispatchWorkgroups", .{ self, workgroup_count_x, workgroup_count_y, workgroup_count_z }); } pub inline fn dispatchWorkgroupsIndirect(self: *ComputePassEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void { - wgpuComputePassEncoderDispatchWorkgroupsIndirect(self, indirect_buffer, indirect_offset); + raw.call(void, "wgpuComputePassEncoderDispatchWorkgroupsIndirect", .{ self, indirect_buffer, indirect_offset }); } pub inline fn end(self: *ComputePassEncoder) void { - wgpuComputePassEncoderEnd(self); + raw.call(void, "wgpuComputePassEncoderEnd", .{self}); } pub inline fn insertDebugMarker(self: *ComputePassEncoder, marker_label: []const u8) void { - wgpuComputePassEncoderInsertDebugMarker(self, StringView.fromSlice(marker_label)); + raw.call(void, "wgpuComputePassEncoderInsertDebugMarker", .{ self, StringView.fromSlice(marker_label) }); } pub inline fn popDebugGroup(self: *ComputePassEncoder) void { - wgpuComputePassEncoderPopDebugGroup(self); + raw.call(void, "wgpuComputePassEncoderPopDebugGroup", .{self}); } pub inline fn pushDebugGroup(self: *ComputePassEncoder, group_label: []const u8) void { - wgpuComputePassEncoderPushDebugGroup(self, StringView.fromSlice(group_label)); + raw.call(void, "wgpuComputePassEncoderPushDebugGroup", .{ self, StringView.fromSlice(group_label) }); } pub inline fn setBindGroup(self: *ComputePassEncoder, group_index: u32, group: *BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void { - wgpuComputePassEncoderSetBindGroup(self, group_index, group, dynamic_offset_count, dynamic_offsets); + raw.call(void, "wgpuComputePassEncoderSetBindGroup", .{ self, group_index, group, dynamic_offset_count, dynamic_offsets }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -115,27 +81,27 @@ pub const ComputePassEncoder = opaque { // } pub inline fn setPipeline(self: *ComputePassEncoder, pipeline: *ComputePipeline) void { - wgpuComputePassEncoderSetPipeline(self, pipeline); + raw.call(void, "wgpuComputePassEncoderSetPipeline", .{ self, pipeline }); } pub inline fn addRef(self: *ComputePassEncoder) void { - wgpuComputePassEncoderAddRef(self); + raw.call(void, "wgpuComputePassEncoderAddRef", .{self}); } pub inline fn release(self: *ComputePassEncoder) void { - wgpuComputePassEncoderRelease(self); + raw.call(void, "wgpuComputePassEncoderRelease", .{self}); } // wgpu-native pub inline fn setImmediates(self: *ComputePassEncoder, offset: u32, size_bytes: u32, data: *const anyopaque) void { - wgpuComputePassEncoderSetImmediates(self, offset, size_bytes, data); + raw.call(void, "wgpuComputePassEncoderSetImmediates", .{ self, offset, size_bytes, data }); } pub inline fn beginPipelineStatisticsQuery(self: *ComputePassEncoder, query_set: *QuerySet, query_index: u32) void { - wgpuComputePassEncoderBeginPipelineStatisticsQuery(self, query_set, query_index); + raw.call(void, "wgpuComputePassEncoderBeginPipelineStatisticsQuery", .{ self, query_set, query_index }); } pub inline fn endPipelineStatisticsQuery(self: *ComputePassEncoder) void { - wgpuComputePassEncoderEndPipelineStatisticsQuery(self); + raw.call(void, "wgpuComputePassEncoderEndPipelineStatisticsQuery", .{self}); } pub inline fn writeTimestamp(self: *ComputePassEncoder, query_set: *QuerySet, query_index: u32) void { - wgpuComputePassEncoderWriteTimestamp(self, query_set, query_index); + raw.call(void, "wgpuComputePassEncoderWriteTimestamp", .{ self, query_set, query_index }); } }; @@ -205,115 +171,50 @@ pub const RenderPassDescriptor = extern struct { } }; -pub const RenderPassEncoderProcs = struct { - pub const BeginOcclusionQuery = *const fn (*RenderPassEncoder, u32) callconv(.c) void; - pub const Draw = *const fn (*RenderPassEncoder, u32, u32, u32, u32) callconv(.c) void; - pub const DrawIndexed = *const fn (*RenderPassEncoder, u32, u32, u32, i32, u32) callconv(.c) void; - pub const DrawIndexedIndirect = *const fn (*RenderPassEncoder, *Buffer, u64) callconv(.c) void; - pub const DrawIndirect = *const fn (*RenderPassEncoder, *Buffer, u64) callconv(.c) void; - pub const End = *const fn (*RenderPassEncoder) callconv(.c) void; - pub const EndOcclusionQuery = *const fn (*RenderPassEncoder) callconv(.c) void; - pub const ExecuteBundles = *const fn (*RenderPassEncoder, usize, [*]const *const RenderBundle) callconv(.c) void; - pub const InsertDebugMarker = *const fn (*RenderPassEncoder, StringView) callconv(.c) void; - pub const PopDebugGroup = *const fn (*RenderPassEncoder) callconv(.c) void; - pub const PushDebugGroup = *const fn (*RenderPassEncoder, StringView) callconv(.c) void; - pub const SetBindGroup = *const fn (*RenderPassEncoder, u32, *BindGroup, usize, ?[*]const u32) callconv(.c) void; - pub const SetBlendConstant = *const fn (*RenderPassEncoder, *const Color) callconv(.c) void; - pub const SetIndexBuffer = *const fn (*RenderPassEncoder, *Buffer, IndexFormat, u64, u64) callconv(.c) void; - pub const SetLabel = *const fn (*RenderPassEncoder, StringView) callconv(.c) void; - pub const SetPipeline = *const fn (*RenderPassEncoder, *RenderPipeline) callconv(.c) void; - pub const SetScissorRect = *const fn (*RenderPassEncoder, u32, u32, u32, u32) callconv(.c) void; - pub const SetStencilReference = *const fn (*RenderPassEncoder, u32) callconv(.c) void; - pub const SetVertexBuffer = *const fn (*RenderPassEncoder, u32, *Buffer, u64, u64) callconv(.c) void; - pub const SetViewport = *const fn (*RenderPassEncoder, f32, f32, f32, f32, f32, f32) callconv(.c) void; - pub const AddRef = *const fn (*RenderPassEncoder) callconv(.c) void; - pub const Release = *const fn (*RenderPassEncoder) callconv(.c) void; - - // wgpu-native procs? - // pub const MultiDrawIndirect = *const fn(*RenderPassEncoder, *Buffer, u64, u32) callconv(.c) void; - // pub const MultiDrawIndexedIndirect = *const fn(*RenderPassEncoder, *Buffer, u64, u32) callconv(.c) void; - // pub const MultiDrawIndirectCount = *const fn(*RenderPassEncoder, *Buffer, u64, *Buffer, u64, u32) callconv(.c) void; - // pub const MultiDrawIndexedIndirectCount = *const fn(*RenderPassEncoder, *Buffer, u64, *Buffer, u64, u32) callconv(.c) void; - // pub const BeginPipelineStatisticsQuery = *const fn(*RenderPassEncoder, *QuerySet, u32) callconv(.c) void; - // pub const EndPipelineStatisticsQuery = *const fn(*RenderPassEncoder) callconv(.c) void; - // pub const WriteTimestamp = *const fn(*RenderPassEncoder, *QuerySet, u32) callconv(.c) void; -}; - -extern fn wgpuRenderPassEncoderBeginOcclusionQuery(render_pass_encoder: *RenderPassEncoder, query_index: u32) void; -extern fn wgpuRenderPassEncoderDraw(render_pass_encoder: *RenderPassEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void; -extern fn wgpuRenderPassEncoderDrawIndexed(render_pass_encoder: *RenderPassEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: i32, first_instance: u32) void; -extern fn wgpuRenderPassEncoderDrawIndexedIndirect(render_pass_encoder: *RenderPassEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void; -extern fn wgpuRenderPassEncoderDrawIndirect(render_pass_encoder: *RenderPassEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void; -extern fn wgpuRenderPassEncoderEnd(render_pass_encoder: *RenderPassEncoder) void; -extern fn wgpuRenderPassEncoderEndOcclusionQuery(render_pass_encoder: *RenderPassEncoder) void; -extern fn wgpuRenderPassEncoderExecuteBundles(render_pass_encoder: *RenderPassEncoder, bundle_count: usize, bundles: [*]const *const RenderBundle) void; -extern fn wgpuRenderPassEncoderInsertDebugMarker(render_pass_encoder: *RenderPassEncoder, marker_label: StringView) void; -extern fn wgpuRenderPassEncoderPopDebugGroup(render_pass_encoder: *RenderPassEncoder) void; -extern fn wgpuRenderPassEncoderPushDebugGroup(render_pass_encoder: *RenderPassEncoder, group_label: StringView) void; -extern fn wgpuRenderPassEncoderSetBindGroup(render_pass_encoder: *RenderPassEncoder, group_index: u32, group: *BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void; -extern fn wgpuRenderPassEncoderSetBlendConstant(render_pass_encoder: *RenderPassEncoder, color: *const Color) void; -extern fn wgpuRenderPassEncoderSetIndexBuffer(render_pass_encoder: *RenderPassEncoder, buffer: *Buffer, format: IndexFormat, offset: u64, size: u64) void; -extern fn wgpuRenderPassEncoderSetLabel(render_pass_encoder: *RenderPassEncoder, label: StringView) void; -extern fn wgpuRenderPassEncoderSetPipeline(render_pass_encoder: *RenderPassEncoder, pipeline: *RenderPipeline) void; -extern fn wgpuRenderPassEncoderSetScissorRect(render_pass_encoder: *RenderPassEncoder, x: u32, y: u32, width: u32, height: u32) void; -extern fn wgpuRenderPassEncoderSetStencilReference(render_pass_encoder: *RenderPassEncoder, stencil_reference: u32) void; -extern fn wgpuRenderPassEncoderSetVertexBuffer(render_pass_encoder: *RenderPassEncoder, slot: u32, buffer: *Buffer, offset: u64, size: u64) void; -extern fn wgpuRenderPassEncoderSetViewport(render_pass_encoder: *RenderPassEncoder, x: f32, y: f32, width: f32, height: f32, min_depth: f32, max_depth: f32) void; -extern fn wgpuRenderPassEncoderAddRef(render_pass_encoder: *RenderPassEncoder) void; -extern fn wgpuRenderPassEncoderRelease(render_pass_encoder: *RenderPassEncoder) void; - // wgpu-native -extern fn wgpuRenderPassEncoderSetImmediates(render_pass_encoder: *RenderPassEncoder, offset: u32, size_bytes: u32, data: *const anyopaque) void; -extern fn wgpuRenderPassEncoderMultiDrawIndirect(render_pass_encoder: *RenderPassEncoder, buffer: *Buffer, offset: u64, count: u32) void; -extern fn wgpuRenderPassEncoderMultiDrawIndexedIndirect(render_pass_encoder: *RenderPassEncoder, buffer: *Buffer, offset: u64, count: u32) void; -extern fn wgpuRenderPassEncoderMultiDrawIndirectCount(render_pass_encoder: *RenderPassEncoder, buffer: *Buffer, offset: u64, count_buffer: *Buffer, count_buffer_offset: u64, max_count: u32) void; -extern fn wgpuRenderPassEncoderMultiDrawIndexedIndirectCount(render_pass_encoder: *RenderPassEncoder, buffer: *Buffer, offset: u64, count_buffer: *Buffer, count_buffer_offset: u64, max_count: u32) void; -extern fn wgpuRenderPassEncoderBeginPipelineStatisticsQuery(render_pass_encoder: *RenderPassEncoder, query_set: *QuerySet, query_index: u32) void; -extern fn wgpuRenderPassEncoderEndPipelineStatisticsQuery(render_pass_encoder: *RenderPassEncoder) void; -extern fn wgpuRenderPassEncoderWriteTimestamp(render_pass_encoder: *RenderPassEncoder, query_set: *QuerySet, query_index: u32) void; pub const RenderPassEncoder = opaque { pub inline fn beginOcclusionQuery(self: *RenderPassEncoder, query_index: u32) void { - wgpuRenderPassEncoderBeginOcclusionQuery(self, query_index); + raw.call(void, "wgpuRenderPassEncoderBeginOcclusionQuery", .{ self, query_index }); } pub inline fn draw(self: *RenderPassEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void { - wgpuRenderPassEncoderDraw(self, vertex_count, instance_count, first_vertex, first_instance); + raw.call(void, "wgpuRenderPassEncoderDraw", .{ self, vertex_count, instance_count, first_vertex, first_instance }); } pub inline fn drawIndexed(self: *RenderPassEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: i32, first_instance: u32) void { - wgpuRenderPassEncoderDrawIndexed(self, index_count, instance_count, first_index, base_vertex, first_instance); + raw.call(void, "wgpuRenderPassEncoderDrawIndexed", .{ self, index_count, instance_count, first_index, base_vertex, first_instance }); } pub inline fn drawIndexedIndirect(self: *RenderPassEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void { - wgpuRenderPassEncoderDrawIndexedIndirect(self, indirect_buffer, indirect_offset); + raw.call(void, "wgpuRenderPassEncoderDrawIndexedIndirect", .{ self, indirect_buffer, indirect_offset }); } pub inline fn drawIndirect(self: *RenderPassEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void { - wgpuRenderPassEncoderDrawIndirect(self, indirect_buffer, indirect_offset); + raw.call(void, "wgpuRenderPassEncoderDrawIndirect", .{ self, indirect_buffer, indirect_offset }); } pub inline fn end(self: *RenderPassEncoder) void { - wgpuRenderPassEncoderEnd(self); + raw.call(void, "wgpuRenderPassEncoderEnd", .{self}); } pub inline fn endOcclusionQuery(self: *RenderPassEncoder) void { - wgpuRenderPassEncoderEndOcclusionQuery(self); + raw.call(void, "wgpuRenderPassEncoderEndOcclusionQuery", .{self}); } pub inline fn executeBundles(self: *RenderPassEncoder, bundles: []const *const RenderBundle) void { - wgpuRenderPassEncoderExecuteBundles(self, bundles.len, bundles.ptr); + raw.call(void, "wgpuRenderPassEncoderExecuteBundles", .{ self, bundles.len, bundles.ptr }); } pub inline fn insertDebugMarker(self: *RenderPassEncoder, marker_label: []const u8) void { - wgpuRenderPassEncoderInsertDebugMarker(self, StringView.fromSlice(marker_label)); + raw.call(void, "wgpuRenderPassEncoderInsertDebugMarker", .{ self, StringView.fromSlice(marker_label) }); } pub inline fn popDebugGroup(self: *RenderPassEncoder) void { - wgpuRenderPassEncoderPopDebugGroup(self); + raw.call(void, "wgpuRenderPassEncoderPopDebugGroup", .{self}); } pub inline fn pushDebugGroup(self: *RenderPassEncoder, group_label: []const u8) void { - wgpuRenderPassEncoderPushDebugGroup(self, StringView.fromSlice(group_label)); + raw.call(void, "wgpuRenderPassEncoderPushDebugGroup", .{ self, StringView.fromSlice(group_label) }); } pub inline fn setBindGroup(self: *RenderPassEncoder, group_index: u32, group: *BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void { - wgpuRenderPassEncoderSetBindGroup(self, group_index, group, dynamic_offset_count, dynamic_offsets); + raw.call(void, "wgpuRenderPassEncoderSetBindGroup", .{ self, group_index, group, dynamic_offset_count, dynamic_offsets }); } pub inline fn setBlendConstant(self: *RenderPassEncoder, color: *const Color) void { - wgpuRenderPassEncoderSetBlendConstant(self, color); + raw.call(void, "wgpuRenderPassEncoderSetBlendConstant", .{ self, color }); } pub inline fn setIndexBuffer(self: *RenderPassEncoder, buffer: *Buffer, format: IndexFormat, offset: u64, size: u64) void { - wgpuRenderPassEncoderSetIndexBuffer(self, buffer, format, offset, size); + raw.call(void, "wgpuRenderPassEncoderSetIndexBuffer", .{ self, buffer, format, offset, size }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -323,51 +224,51 @@ pub const RenderPassEncoder = opaque { // } pub inline fn setPipeline(self: *RenderPassEncoder, pipeline: *RenderPipeline) void { - wgpuRenderPassEncoderSetPipeline(self, pipeline); + raw.call(void, "wgpuRenderPassEncoderSetPipeline", .{ self, pipeline }); } pub inline fn setScissorRect(self: *RenderPassEncoder, x: u32, y: u32, width: u32, height: u32) void { - wgpuRenderPassEncoderSetScissorRect(self, x, y, width, height); + raw.call(void, "wgpuRenderPassEncoderSetScissorRect", .{ self, x, y, width, height }); } pub inline fn setStencilReference(self: *RenderPassEncoder, stencil_reference: u32) void { - wgpuRenderPassEncoderSetStencilReference(self, stencil_reference); + raw.call(void, "wgpuRenderPassEncoderSetStencilReference", .{ self, stencil_reference }); } pub inline fn setVertexBuffer(self: *RenderPassEncoder, slot: u32, buffer: *Buffer, offset: u64, size: u64) void { - wgpuRenderPassEncoderSetVertexBuffer(self, slot, buffer, offset, size); + raw.call(void, "wgpuRenderPassEncoderSetVertexBuffer", .{ self, slot, buffer, offset, size }); } pub inline fn setViewport(self: *RenderPassEncoder, x: f32, y: f32, width: f32, height: f32, min_depth: f32, max_depth: f32) void { - wgpuRenderPassEncoderSetViewport(self, x, y, width, height, min_depth, max_depth); + raw.call(void, "wgpuRenderPassEncoderSetViewport", .{ self, x, y, width, height, min_depth, max_depth }); } pub inline fn addRef(self: *RenderPassEncoder) void { - wgpuRenderPassEncoderAddRef(self); + raw.call(void, "wgpuRenderPassEncoderAddRef", .{self}); } pub inline fn release(self: *RenderPassEncoder) void { - wgpuRenderPassEncoderRelease(self); + raw.call(void, "wgpuRenderPassEncoderRelease", .{self}); } // wgpu-native pub inline fn setImmediates(self: *RenderPassEncoder, offset: u32, size_bytes: u32, data: *const anyopaque) void { - wgpuRenderPassEncoderSetImmediates(self, offset, size_bytes, data); + raw.call(void, "wgpuRenderPassEncoderSetImmediates", .{ self, offset, size_bytes, data }); } pub inline fn multiDrawIndirect(self: *RenderPassEncoder, buffer: *Buffer, offset: u64, count: u32) void { - wgpuRenderPassEncoderMultiDrawIndirect(self, buffer, offset, count); + raw.call(void, "wgpuRenderPassEncoderMultiDrawIndirect", .{ self, buffer, offset, count }); } pub inline fn multiDrawIndexedIndirect(self: *RenderPassEncoder, buffer: *Buffer, offset: u64, count: u32) void { - wgpuRenderPassEncoderMultiDrawIndexedIndirect(self, buffer, offset, count); + raw.call(void, "wgpuRenderPassEncoderMultiDrawIndexedIndirect", .{ self, buffer, offset, count }); } pub inline fn multiDrawIndirectCount(self: *RenderPassEncoder, buffer: *Buffer, offset: u64, count_buffer: *Buffer, count_buffer_offset: u64, max_count: u32) void { - wgpuRenderPassEncoderMultiDrawIndirectCount(self, buffer, offset, count_buffer, count_buffer_offset, max_count); + raw.call(void, "wgpuRenderPassEncoderMultiDrawIndirectCount", .{ self, buffer, offset, count_buffer, count_buffer_offset, max_count }); } pub inline fn multiDrawIndexedIndirectCount(self: *RenderPassEncoder, buffer: *Buffer, offset: u64, count_buffer: *Buffer, count_buffer_offset: u64, max_count: u32) void { - wgpuRenderPassEncoderMultiDrawIndexedIndirectCount(self, buffer, offset, count_buffer, count_buffer_offset, max_count); + raw.call(void, "wgpuRenderPassEncoderMultiDrawIndexedIndirectCount", .{ self, buffer, offset, count_buffer, count_buffer_offset, max_count }); } pub inline fn beginPipelineStatisticsQuery(self: *RenderPassEncoder, query_set: *QuerySet, query_index: u32) void { - wgpuRenderPassEncoderBeginPipelineStatisticsQuery(self, query_set, query_index); + raw.call(void, "wgpuRenderPassEncoderBeginPipelineStatisticsQuery", .{ self, query_set, query_index }); } pub inline fn endPipelineStatisticsQuery(self: *RenderPassEncoder) void { - wgpuRenderPassEncoderEndPipelineStatisticsQuery(self); + raw.call(void, "wgpuRenderPassEncoderEndPipelineStatisticsQuery", .{self}); } pub inline fn writeTimestamp(self: *RenderPassEncoder, query_set: *QuerySet, query_index: u32) void { - wgpuRenderPassEncoderWriteTimestamp(self, query_set, query_index); + raw.call(void, "wgpuRenderPassEncoderWriteTimestamp", .{ self, query_set, query_index }); } }; @@ -376,16 +277,6 @@ pub const CommandBufferDescriptor = extern struct { label: StringView = StringView{}, }; -pub const CommandBufferProcs = struct { - pub const SetLabel = *const fn (*CommandBuffer, StringView) callconv(.c) void; - pub const AddRef = *const fn (*CommandBuffer) callconv(.c) void; - pub const Release = *const fn (*CommandBuffer) callconv(.c) void; -}; - -extern fn wgpuCommandBufferSetLabel(command_buffer: *CommandBuffer, label: StringView) void; -extern fn wgpuCommandBufferAddRef(command_buffer: *CommandBuffer) void; -extern fn wgpuCommandBufferRelease(command_buffer: *CommandBuffer) void; - pub const CommandBuffer = opaque { // Unimplemented as of wgpu-native v29.0.0.0, // see https://github.com/gfx-rs/wgpu-native/blob/d2e3330ade4ae1bb238d76b485926f067e7ee64c/src/unimplemented.rs @@ -394,85 +285,49 @@ pub const CommandBuffer = opaque { // } pub inline fn addRef(self: *CommandBuffer) void { - wgpuCommandBufferAddRef(self); + raw.call(void, "wgpuCommandBufferAddRef", .{self}); } pub inline fn release(self: *CommandBuffer) void { - wgpuCommandBufferRelease(self); + raw.call(void, "wgpuCommandBufferRelease", .{self}); } }; -pub const CommandEncoderProcs = struct { - pub const BeginComputePass = *const fn (*CommandEncoder, ?*const ComputePassDescriptor) callconv(.c) ?*ComputePassEncoder; - pub const BeginRenderPass = *const fn (*CommandEncoder, *const RenderPassDescriptor) callconv(.c) ?*RenderPassEncoder; - pub const ClearBuffer = *const fn (*CommandEncoder, *Buffer, u64, u64) callconv(.c) void; - pub const CopyBufferToBuffer = *const fn (*CommandEncoder, *Buffer, u64, *Buffer, u64, u64) callconv(.c) void; - pub const CopyBufferToTexture = *const fn (*CommandEncoder, *const TexelCopyBufferInfo, *const TexelCopyTextureInfo, *const Extent3D) callconv(.c) void; - pub const CopyTextureToBuffer = *const fn (*CommandEncoder, *const TexelCopyTextureInfo, *const TexelCopyBufferInfo, *const Extent3D) callconv(.c) void; - pub const CopyTextureToTexture = *const fn (*CommandEncoder, *const TexelCopyTextureInfo, *const TexelCopyTextureInfo, *const Extent3D) callconv(.c) void; - pub const Finish = *const fn (*CommandEncoder, ?*const CommandBufferDescriptor) callconv(.c) ?*CommandBuffer; - pub const InsertDebugMarker = *const fn (*CommandEncoder, StringView) callconv(.c) void; - pub const PopDebugGroup = *const fn (*CommandEncoder) callconv(.c) void; - pub const PushDebugGroup = *const fn (*CommandEncoder, StringView) callconv(.c) void; - pub const ResolveQuerySet = *const fn (*CommandEncoder, *QuerySet, u32, u32, *Buffer, u64) callconv(.c) void; - pub const SetLabel = *const fn (*CommandEncoder, StringView) callconv(.c) void; - pub const WriteTimestamp = *const fn (*CommandEncoder, *QuerySet, u32) callconv(.c) void; - pub const AddRef = *const fn (*CommandEncoder) callconv(.c) void; - pub const Release = *const fn (*CommandEncoder) callconv(.c) void; -}; - -extern fn wgpuCommandEncoderBeginComputePass(command_encoder: *CommandEncoder, descriptor: ?*const ComputePassDescriptor) ?*ComputePassEncoder; -extern fn wgpuCommandEncoderBeginRenderPass(command_encoder: *CommandEncoder, descriptor: *const RenderPassDescriptor) ?*RenderPassEncoder; -extern fn wgpuCommandEncoderClearBuffer(command_encoder: *CommandEncoder, buffer: *Buffer, offset: u64, size: u64) void; -extern fn wgpuCommandEncoderCopyBufferToBuffer(command_encoder: *CommandEncoder, source: *Buffer, source_offset: u64, destination: *Buffer, destination_offset: u64, size: u64) void; -extern fn wgpuCommandEncoderCopyBufferToTexture(command_encoder: *CommandEncoder, source: *const TexelCopyBufferInfo, destination: *const TexelCopyTextureInfo, copy_size: *const Extent3D) void; -extern fn wgpuCommandEncoderCopyTextureToBuffer(command_encoder: *CommandEncoder, source: *const TexelCopyTextureInfo, destination: *const TexelCopyBufferInfo, copy_size: *const Extent3D) void; -extern fn wgpuCommandEncoderCopyTextureToTexture(command_encoder: *CommandEncoder, source: *const TexelCopyTextureInfo, destination: *const TexelCopyTextureInfo, copy_size: *const Extent3D) void; -extern fn wgpuCommandEncoderFinish(command_encoder: *CommandEncoder, descriptor: ?*const CommandBufferDescriptor) ?*CommandBuffer; -extern fn wgpuCommandEncoderInsertDebugMarker(command_encoder: *CommandEncoder, marker_label: StringView) void; -extern fn wgpuCommandEncoderPopDebugGroup(command_encoder: *CommandEncoder) void; -extern fn wgpuCommandEncoderPushDebugGroup(command_encoder: *CommandEncoder, group_label: StringView) void; -extern fn wgpuCommandEncoderResolveQuerySet(command_encoder: *CommandEncoder, query_set: *QuerySet, first_query: u32, query_count: u32, destination: *Buffer, destination_offset: u64) void; -extern fn wgpuCommandEncoderSetLabel(command_encoder: *CommandEncoder, label: StringView) void; -extern fn wgpuCommandEncoderWriteTimestamp(command_encoder: *CommandEncoder, query_set: *QuerySet, query_index: u32) void; -extern fn wgpuCommandEncoderAddRef(command_encoder: *CommandEncoder) void; -extern fn wgpuCommandEncoderRelease(command_encoder: *CommandEncoder) void; - pub const CommandEncoder = opaque { pub inline fn beginComputePass(self: *CommandEncoder, descriptor: ?*const ComputePassDescriptor) ?*ComputePassEncoder { - return wgpuCommandEncoderBeginComputePass(self, descriptor); + return raw.call(?*ComputePassEncoder, "wgpuCommandEncoderBeginComputePass", .{ self, descriptor }); } pub inline fn beginRenderPass(self: *CommandEncoder, descriptor: *const RenderPassDescriptor) ?*RenderPassEncoder { - return wgpuCommandEncoderBeginRenderPass(self, descriptor); + return raw.call(?*RenderPassEncoder, "wgpuCommandEncoderBeginRenderPass", .{ self, descriptor }); } pub inline fn clearBuffer(self: *CommandEncoder, buffer: *Buffer, offset: u64, size: u64) void { - wgpuCommandEncoderClearBuffer(self, buffer, offset, size); + raw.call(void, "wgpuCommandEncoderClearBuffer", .{ self, buffer, offset, size }); } pub inline fn copyBufferToBuffer(self: *CommandEncoder, source: *Buffer, source_offset: u64, destination: *Buffer, destination_offset: u64, size: u64) void { - wgpuCommandEncoderCopyBufferToBuffer(self, source, source_offset, destination, destination_offset, size); + raw.call(void, "wgpuCommandEncoderCopyBufferToBuffer", .{ self, source, source_offset, destination, destination_offset, size }); } pub inline fn copyBufferToTexture(self: *CommandEncoder, source: *const TexelCopyBufferInfo, destination: *const TexelCopyTextureInfo, copy_size: *const Extent3D) void { - wgpuCommandEncoderCopyBufferToTexture(self, source, destination, copy_size); + raw.call(void, "wgpuCommandEncoderCopyBufferToTexture", .{ self, source, destination, copy_size }); } pub inline fn copyTextureToBuffer(self: *CommandEncoder, source: *const TexelCopyTextureInfo, destination: *const TexelCopyBufferInfo, copy_size: *const Extent3D) void { - wgpuCommandEncoderCopyTextureToBuffer(self, source, destination, copy_size); + raw.call(void, "wgpuCommandEncoderCopyTextureToBuffer", .{ self, source, destination, copy_size }); } pub inline fn copyTextureToTexture(self: *CommandEncoder, source: *const TexelCopyTextureInfo, destination: *const TexelCopyTextureInfo, copy_size: *const Extent3D) void { - wgpuCommandEncoderCopyTextureToTexture(self, source, destination, copy_size); + raw.call(void, "wgpuCommandEncoderCopyTextureToTexture", .{ self, source, destination, copy_size }); } pub inline fn finish(self: *CommandEncoder, descriptor: ?*const CommandBufferDescriptor) ?*CommandBuffer { - return wgpuCommandEncoderFinish(self, descriptor); + return raw.call(?*CommandBuffer, "wgpuCommandEncoderFinish", .{ self, descriptor }); } pub inline fn insertDebugMarker(self: *CommandEncoder, marker_label: []const u8) void { - wgpuCommandEncoderInsertDebugMarker(self, StringView.fromSlice(marker_label)); + raw.call(void, "wgpuCommandEncoderInsertDebugMarker", .{ self, StringView.fromSlice(marker_label) }); } pub inline fn popDebugGroup(self: *CommandEncoder) void { - wgpuCommandEncoderPopDebugGroup(self); + raw.call(void, "wgpuCommandEncoderPopDebugGroup", .{self}); } pub inline fn pushDebugGroup(self: *CommandEncoder, group_label: []const u8) void { - wgpuCommandEncoderPushDebugGroup(self, StringView.fromSlice(group_label)); + raw.call(void, "wgpuCommandEncoderPushDebugGroup", .{ self, StringView.fromSlice(group_label) }); } pub inline fn resolveQuerySet(self: *CommandEncoder, query_set: *QuerySet, first_query: u32, query_count: u32, destination: *Buffer, destination_offset: u64) void { - wgpuCommandEncoderResolveQuerySet(self, query_set, first_query, query_count, destination, destination_offset); + raw.call(void, "wgpuCommandEncoderResolveQuerySet", .{ self, query_set, first_query, query_count, destination, destination_offset }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -482,12 +337,12 @@ pub const CommandEncoder = opaque { // } pub inline fn writeTimestamp(self: *CommandEncoder, query_set: *QuerySet, query_index: u32) void { - wgpuCommandEncoderWriteTimestamp(self, query_set, query_index); + raw.call(void, "wgpuCommandEncoderWriteTimestamp", .{ self, query_set, query_index }); } pub inline fn addRef(self: *CommandEncoder) void { - wgpuCommandEncoderAddRef(self); + raw.call(void, "wgpuCommandEncoderAddRef", .{self}); } pub inline fn release(self: *CommandEncoder) void { - wgpuCommandEncoderRelease(self); + raw.call(void, "wgpuCommandEncoderRelease", .{self}); } }; diff --git a/src/device.zig b/src/device.zig index 88bc43c..c9ab8ff 100644 --- a/src/device.zig +++ b/src/device.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const std = @import("std"); const _chained_struct = @import("chained_struct.zig"); @@ -216,85 +217,23 @@ pub const PopErrorScopeCallbackInfo = extern struct { userdata2: ?*anyopaque = null, }; -pub const DeviceProcs = struct { - pub const CreateBindGroup = *const fn (*Device, *const BindGroupDescriptor) callconv(.c) ?*BindGroup; - pub const CreateBindGroupLayout = *const fn (*Device, *const BindGroupLayoutDescriptor) callconv(.c) ?*BindGroupLayout; - pub const CreateBuffer = *const fn (*Device, *const BufferDescriptor) callconv(.c) ?*Buffer; - pub const CreateCommandEncoder = *const fn (*Device, *const CommandEncoderDescriptor) callconv(.c) ?*CommandEncoder; - pub const CreateComputePipeline = *const fn (*Device, *const ComputePipelineDescriptor) callconv(.c) ?*ComputePipeline; - pub const CreateComputePipelineAsync = *const fn (*Device, *const ComputePipelineDescriptor, CreateComputePipelineAsyncCallbackInfo) callconv(.c) Future; - pub const CreatePipelineLayout = *const fn (*Device, *const PipelineLayoutDescriptor) callconv(.c) ?*PipelineLayout; - pub const CreateQuerySet = *const fn (*Device, *const QuerySetDescriptor) callconv(.c) ?*QuerySet; - pub const CreateRenderBundleEncoder = *const fn (*Device, *const RenderBundleEncoderDescriptor) callconv(.c) ?*RenderBundleEncoder; - pub const CreateRenderPipeline = *const fn (*Device, *const RenderPipelineDescriptor) callconv(.c) ?*RenderPipeline; - pub const CreateRenderPipelineAsync = *const fn (*Device, *const RenderPipelineDescriptor, CreateRenderPipelineAsyncCallbackInfo) callconv(.c) Future; - pub const CreateSampler = *const fn (*Device, *const SamplerDescriptor) callconv(.c) ?*Sampler; - pub const CreateShaderModule = *const fn (*Device, *const ShaderModuleDescriptor) callconv(.c) ?*ShaderModule; - pub const CreateTexture = *const fn (*Device, *const TextureDescriptor) callconv(.c) ?*Texture; - pub const Destroy = *const fn (*Device) callconv(.c) void; - pub const GetAdapterInfo = *const fn (*Device) callconv(.c) AdapterInfo; - pub const GetFeatures = *const fn (*Device, *SupportedFeatures) callconv(.c) void; - pub const GetLimits = *const fn (*Device, *Limits) callconv(.c) Status; - pub const GetLostFuture = *const fn (*Device) callconv(.c) Future; - pub const GetQueue = *const fn (*Device) callconv(.c) ?*Queue; - pub const HasFeature = *const fn (*Device, FeatureName) callconv(.c) WGPUBool; - pub const PopErrorScope = *const fn (*Device, PopErrorScopeCallbackInfo) callconv(.c) Future; - pub const PushErrorScope = *const fn (*Device, ErrorFilter) callconv(.c) void; - pub const SetLabel = *const fn (*Device, StringView) callconv(.c) void; - pub const AddRef = *const fn (*Device) callconv(.c) void; - pub const Release = *const fn (*Device) callconv(.c) void; - - // wgpu-native procs? - // pub const Poll = *const fn(*Device, WGPUBool, ?*const SubmissionIndex) callconv(.c) WGPUBool; - // pub const CreateShaderModuleSpirV = *const fn(*Device, *const ShaderModuleDescriptorSpirV) callconv(.c) ?*ShaderModule; -}; - -extern fn wgpuDeviceCreateBindGroup(device: *Device, descriptor: *const BindGroupDescriptor) ?*BindGroup; -extern fn wgpuDeviceCreateBindGroupLayout(device: *Device, descriptor: *const BindGroupLayoutDescriptor) ?*BindGroupLayout; -extern fn wgpuDeviceCreateBuffer(device: *Device, descriptor: *const BufferDescriptor) ?*Buffer; -extern fn wgpuDeviceCreateCommandEncoder(device: *Device, descriptor: *const CommandEncoderDescriptor) ?*CommandEncoder; -extern fn wgpuDeviceCreateComputePipeline(device: *Device, descriptor: *const ComputePipelineDescriptor) ?*ComputePipeline; -extern fn wgpuDeviceCreateComputePipelineAsync(device: *Device, descriptor: *const ComputePipelineDescriptor, callback_info: CreateComputePipelineAsyncCallbackInfo) Future; -extern fn wgpuDeviceCreatePipelineLayout(device: *Device, descriptor: *const PipelineLayoutDescriptor) ?*PipelineLayout; -extern fn wgpuDeviceCreateQuerySet(device: *Device, descriptor: *const QuerySetDescriptor) ?*QuerySet; -extern fn wgpuDeviceCreateRenderBundleEncoder(device: *Device, descriptor: *const RenderBundleEncoderDescriptor) ?*RenderBundleEncoder; -extern fn wgpuDeviceCreateRenderPipeline(device: *Device, descriptor: *const RenderPipelineDescriptor) ?*RenderPipeline; -extern fn wgpuDeviceCreateRenderPipelineAsync(device: *Device, descriptor: *const RenderPipelineDescriptor, callback_info: CreateRenderPipelineAsyncCallbackInfo) Future; -extern fn wgpuDeviceCreateSampler(device: *Device, descriptor: *const SamplerDescriptor) ?*Sampler; -extern fn wgpuDeviceCreateShaderModule(device: *Device, descriptor: *const ShaderModuleDescriptor) ?*ShaderModule; -extern fn wgpuDeviceCreateTexture(device: *Device, descriptor: *const TextureDescriptor) ?*Texture; -extern fn wgpuDeviceDestroy(device: *Device) void; -extern fn wgpuDeviceGetAdapterInfo(device: *Device, adapter_info: *AdapterInfo) Status; -extern fn wgpuDeviceGetFeatures(device: *Device, features: *SupportedFeatures) void; -extern fn wgpuDeviceGetLimits(device: *Device, limits: *Limits) Status; -extern fn wgpuDeviceGetLostFuture(device: *Device) Future; -extern fn wgpuDeviceGetQueue(device: *Device) ?*Queue; -extern fn wgpuDeviceHasFeature(device: *Device, feature: FeatureName) WGPUBool; -extern fn wgpuDevicePopErrorScope(device: *Device, callback_info: PopErrorScopeCallbackInfo) Future; -extern fn wgpuDevicePushErrorScope(device: *Device, filter: ErrorFilter) void; -extern fn wgpuDeviceSetLabel(device: *Device, label: StringView) void; -extern fn wgpuDeviceAddRef(device: *Device) void; -extern fn wgpuDeviceRelease(device: *Device) void; - // wgpu-native -extern fn wgpuDevicePoll(device: *Device, wait: WGPUBool, submission_index: ?*const SubmissionIndex) WGPUBool; -extern fn wgpuDeviceCreateShaderModuleSpirV(device: *Device, descriptor: *const ShaderModuleDescriptorSpirV) ?*ShaderModule; pub const Device = opaque { pub inline fn createBindGroup(self: *Device, descriptor: *const BindGroupDescriptor) ?*BindGroup { - return wgpuDeviceCreateBindGroup(self, descriptor); + return raw.call(?*BindGroup, "wgpuDeviceCreateBindGroup", .{ self, descriptor }); } pub inline fn createBindGroupLayout(self: *Device, descriptor: *const BindGroupLayoutDescriptor) ?*BindGroupLayout { - return wgpuDeviceCreateBindGroupLayout(self, descriptor); + return raw.call(?*BindGroupLayout, "wgpuDeviceCreateBindGroupLayout", .{ self, descriptor }); } pub inline fn createBuffer(self: *Device, descriptor: *const BufferDescriptor) ?*Buffer { - return wgpuDeviceCreateBuffer(self, descriptor); + return raw.call(?*Buffer, "wgpuDeviceCreateBuffer", .{ self, descriptor }); } pub inline fn createCommandEncoder(self: *Device, descriptor: *const CommandEncoderDescriptor) ?*CommandEncoder { - return wgpuDeviceCreateCommandEncoder(self, descriptor); + return raw.call(?*CommandEncoder, "wgpuDeviceCreateCommandEncoder", .{ self, descriptor }); } pub inline fn createComputePipeline(self: *Device, descriptor: *const ComputePipelineDescriptor) ?*ComputePipeline { - return wgpuDeviceCreateComputePipeline(self, descriptor); + return raw.call(?*ComputePipeline, "wgpuDeviceCreateComputePipeline", .{ self, descriptor }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -304,16 +243,16 @@ pub const Device = opaque { // } pub inline fn createPipelineLayout(self: *Device, descriptor: *const PipelineLayoutDescriptor) ?*PipelineLayout { - return wgpuDeviceCreatePipelineLayout(self, descriptor); + return raw.call(?*PipelineLayout, "wgpuDeviceCreatePipelineLayout", .{ self, descriptor }); } pub inline fn createQuerySet(self: *Device, descriptor: *const QuerySetDescriptor) ?*QuerySet { - return wgpuDeviceCreateQuerySet(self, descriptor); + return raw.call(?*QuerySet, "wgpuDeviceCreateQuerySet", .{ self, descriptor }); } pub inline fn createRenderBundleEncoder(self: *Device, descriptor: *const RenderBundleEncoderDescriptor) ?*RenderBundleEncoder { - return wgpuDeviceCreateRenderBundleEncoder(self, descriptor); + return raw.call(?*RenderBundleEncoder, "wgpuDeviceCreateRenderBundleEncoder", .{ self, descriptor }); } pub inline fn createRenderPipeline(self: *Device, descriptor: *const RenderPipelineDescriptor) ?*RenderPipeline { - return wgpuDeviceCreateRenderPipeline(self, descriptor); + return raw.call(?*RenderPipeline, "wgpuDeviceCreateRenderPipeline", .{ self, descriptor }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -323,16 +262,16 @@ pub const Device = opaque { // } pub inline fn createSampler(self: *Device, descriptor: *const SamplerDescriptor) ?*Sampler { - return wgpuDeviceCreateSampler(self, descriptor); + return raw.call(?*Sampler, "wgpuDeviceCreateSampler", .{ self, descriptor }); } pub inline fn createShaderModule(self: *Device, descriptor: *const ShaderModuleDescriptor) ?*ShaderModule { - return wgpuDeviceCreateShaderModule(self, descriptor); + return raw.call(?*ShaderModule, "wgpuDeviceCreateShaderModule", .{ self, descriptor }); } pub inline fn createTexture(self: *Device, descriptor: *const TextureDescriptor) ?*Texture { - return wgpuDeviceCreateTexture(self, descriptor); + return raw.call(?*Texture, "wgpuDeviceCreateTexture", .{ self, descriptor }); } pub inline fn destroy(self: *Device) void { - wgpuDeviceDestroy(self); + raw.call(void, "wgpuDeviceDestroy", .{self}); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -342,10 +281,10 @@ pub const Device = opaque { // } pub inline fn getFeatures(self: *Device, features: *SupportedFeatures) void { - wgpuDeviceGetFeatures(self, features); + raw.call(void, "wgpuDeviceGetFeatures", .{ self, features }); } pub inline fn getLimits(self: *Device, limits: *Limits) Status { - return wgpuDeviceGetLimits(self, limits); + return raw.call(Status, "wgpuDeviceGetLimits", .{ self, limits }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -356,17 +295,17 @@ pub const Device = opaque { // } pub inline fn getQueue(self: *Device) ?*Queue { - return wgpuDeviceGetQueue(self); + return raw.call(?*Queue, "wgpuDeviceGetQueue", .{self}); } pub inline fn hasFeature(self: *Device, feature: FeatureName) WGPUBool { - return wgpuDeviceHasFeature(self, feature); + return raw.call(WGPUBool, "wgpuDeviceHasFeature", .{ self, feature }); } pub inline fn popErrorScope(self: *Device, callback_info: PopErrorScopeCallbackInfo) Future { - return wgpuDevicePopErrorScope(self, callback_info); + return raw.call(Future, "wgpuDevicePopErrorScope", .{ self, callback_info }); } pub inline fn pushErrorScope(self: *Device, filter: ErrorFilter) void { - wgpuDevicePushErrorScope(self, filter); + raw.call(void, "wgpuDevicePushErrorScope", .{ self, filter }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -376,18 +315,18 @@ pub const Device = opaque { // } pub inline fn addRef(self: *Device) void { - wgpuDeviceAddRef(self); + raw.call(void, "wgpuDeviceAddRef", .{self}); } pub inline fn release(self: *Device) void { - wgpuDeviceRelease(self); + raw.call(void, "wgpuDeviceRelease", .{self}); } // wgpu-native pub inline fn poll(self: *Device, wait: bool, submission_index: ?*const SubmissionIndex) bool { - return wgpuDevicePoll(self, @intFromBool(wait), submission_index) != 0; + return raw.call(WGPUBool, "wgpuDevicePoll", .{ self, @intFromBool(wait), submission_index }) != 0; } pub inline fn createShaderModuleSpirV(self: *Device, descriptor: *const ShaderModuleDescriptorSpirV) ?*ShaderModule { - return wgpuDeviceCreateShaderModuleSpirV(self, descriptor); + return raw.call(?*ShaderModule, "wgpuDeviceCreateShaderModuleSpirV", .{ self, descriptor }); } }; diff --git a/src/instance.zig b/src/instance.zig index 0d8c1da..aec5ad2 100644 --- a/src/instance.zig +++ b/src/instance.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const std = @import("std"); const _chained_struct = @import("chained_struct.zig"); @@ -146,7 +147,7 @@ pub const SupportedInstanceFeatures = extern struct { features: [*]const InstanceFeatureName = &[0]InstanceFeatureName{}, pub inline fn freeMembers(self: SupportedInstanceFeatures) void { - wgpuSupportedInstanceFeaturesFreeMembers(self); + raw.call(void, "wgpuSupportedInstanceFeaturesFreeMembers", .{self}); } }; @@ -180,12 +181,6 @@ pub const WGSLLanguageFeatureName = enum(u32) { texture_formats_tier_1 = 0x00000009, }; -pub const SupportedWGSLLanguageFeaturesProcs = struct { - pub const FreeMembers = *const fn (SupportedWGSLLanguageFeatures) callconv(.c) void; -}; - -extern fn wgpuSupportedWGSLLanguageFeaturesFreeMembers(supported_wgsl_language_features: SupportedWGSLLanguageFeatures) void; - pub const SupportedWGSLLanguageFeatures = extern struct { feature_count: usize, features: [*]const WGSLLanguageFeatureName, @@ -197,41 +192,6 @@ pub const SupportedWGSLLanguageFeatures = extern struct { // } }; -pub const InstanceProcs = struct { - pub const CreateInstance = *const fn (?*const InstanceDescriptor) callconv(.c) ?*Instance; - pub const GetInstanceFeatures = *const fn (*SupportedInstanceFeatures) callconv(.c) void; - pub const GetInstanceLimits = *const fn (*InstanceLimits) callconv(.c) Status; - pub const HasInstanceFeature = *const fn (InstanceFeatureName) callconv(.c) WGPUBool; - - pub const CreateSurface = *const fn (*Instance, *const SurfaceDescriptor) callconv(.c) ?*Surface; - pub const GetWGSLLanguageFeatures = *const fn (*Instance, *SupportedWGSLLanguageFeatures) callconv(.c) void; - pub const HasWGSLLanguageFeature = *const fn (*Instance, WGSLLanguageFeatureName) callconv(.c) WGPUBool; - pub const ProcessEvents = *const fn (*Instance) callconv(.c) void; - pub const RequestAdapter = *const fn (*Instance, ?*const RequestAdapterOptions, RequestAdapterCallbackInfo) callconv(.c) Future; - pub const WaitAny = *const fn (*Instance, usize, ?[*]FutureWaitInfo, u64) callconv(.c) WaitStatus; - pub const InstanceAddRef = *const fn (*Instance) callconv(.c) void; - pub const InstanceRelease = *const fn (*Instance) callconv(.c) void; - - // wgpu-native procs? - // pub const GenerateReport = *const fn(*Instance, *GlobalReport) callconv(.c) void; - // pub const EnumerateAdapters = *const fn(*Instance, ?*const EnumerateAdapterOptions, ?[*]Adapter) callconv(.c) usize; -}; - -extern fn wgpuGetInstanceFeatures(features: *SupportedInstanceFeatures) void; -extern fn wgpuGetInstanceLimits(limits: *InstanceLimits) Status; -extern fn wgpuHasInstanceFeature(feature: InstanceFeatureName) WGPUBool; -extern fn wgpuSupportedInstanceFeaturesFreeMembers(features: SupportedInstanceFeatures) void; - -extern fn wgpuCreateInstance(descriptor: ?*const InstanceDescriptor) ?*Instance; -extern fn wgpuInstanceCreateSurface(instance: *Instance, descriptor: *const SurfaceDescriptor) ?*Surface; -extern fn wgpuInstanceGetWGSLLanguageFeatures(instance: *Instance, features: *SupportedWGSLLanguageFeatures) void; -extern fn wgpuInstanceHasWGSLLanguageFeature(instance: *Instance, feature: WGSLLanguageFeatureName) WGPUBool; -extern fn wgpuInstanceProcessEvents(instance: *Instance) void; -extern fn wgpuInstanceRequestAdapter(instance: *Instance, options: ?*const RequestAdapterOptions, callback_info: RequestAdapterCallbackInfo) Future; -extern fn wgpuInstanceWaitAny(instance: *Instance, future_count: usize, futures: ?[*]FutureWaitInfo, timeout_ns: u64) WaitStatus; -extern fn wgpuInstanceAddRef(instance: *Instance) void; -extern fn wgpuInstanceRelease(instance: *Instance) void; - pub const RegistryReport = extern struct { num_allocated: usize, num_kept_from_user: usize, @@ -270,29 +230,27 @@ pub const EnumerateAdapterOptions = extern struct { }; // wgpu-native -extern fn wgpuGenerateReport(instance: *Instance, report: *GlobalReport) void; -extern fn wgpuInstanceEnumerateAdapters(instance: *Instance, options: ?*EnumerateAdapterOptions, adapters: ?[*]*Adapter) usize; pub const Instance = opaque { // This is a global function, but it creates an instance so I put it here. pub inline fn create(descriptor: ?*const InstanceDescriptor) ?*Instance { - return wgpuCreateInstance(descriptor); + return raw.call(?*Instance, "wgpuCreateInstance", .{descriptor}); } pub inline fn getFeatures(features: *SupportedInstanceFeatures) void { - wgpuGetInstanceFeatures(features); + raw.call(void, "wgpuGetInstanceFeatures", .{features}); } pub inline fn getLimits(limits: *InstanceLimits) Status { - return wgpuGetInstanceLimits(limits); + return raw.call(Status, "wgpuGetInstanceLimits", .{limits}); } pub inline fn hasFeature(feature: InstanceFeatureName) bool { - return wgpuHasInstanceFeature(feature) != 0; + return raw.call(WGPUBool, "wgpuHasInstanceFeature", .{feature}) != 0; } pub inline fn createSurface(self: *Instance, descriptor: *const SurfaceDescriptor) ?*Surface { - return wgpuInstanceCreateSurface(self, descriptor); + return raw.call(?*Surface, "wgpuInstanceCreateSurface", .{ self, descriptor }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -309,7 +267,7 @@ pub const Instance = opaque { // Processes asynchronous events on this Instance, calling any callbacks for asynchronous operations created with `CallbackMode.allow_process_events`. pub inline fn processEvents(self: *Instance) void { - wgpuInstanceProcessEvents(self); + raw.call(void, "wgpuInstanceProcessEvents", .{self}); } fn defaultAdapterCallback(status: RequestAdapterStatus, adapter: ?*Adapter, message: StringView, userdata1: ?*anyopaque, userdata2: ?*anyopaque) callconv(.c) void { @@ -339,7 +297,7 @@ pub const Instance = opaque { .userdata1 = @ptrCast(&response), .userdata2 = @ptrCast(&completed), }; - const adapter_future = wgpuInstanceRequestAdapter(self, options, callback_info); + const adapter_future = raw.call(Future, "wgpuInstanceRequestAdapter", .{ self, options, callback_info }); // TODO: Revisit once Instance.waitAny() is implemented in wgpu-native, // it takes in futures and returns when one of them completes. @@ -354,7 +312,7 @@ pub const Instance = opaque { } pub inline fn requestAdapter(self: *Instance, options: ?*const RequestAdapterOptions, callback_info: RequestAdapterCallbackInfo) Future { - return wgpuInstanceRequestAdapter(self, options, callback_info); + return raw.call(Future, "wgpuInstanceRequestAdapter", .{ self, options, callback_info }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -365,19 +323,19 @@ pub const Instance = opaque { // } pub inline fn addRef(self: *Instance) void { - wgpuInstanceAddRef(self); + raw.call(void, "wgpuInstanceAddRef", .{self}); } pub inline fn release(self: *Instance) void { - wgpuInstanceRelease(self); + raw.call(void, "wgpuInstanceRelease", .{self}); } // wgpu-native pub inline fn generateReport(self: *Instance, report: *GlobalReport) void { - wgpuGenerateReport(self, report); + raw.call(void, "wgpuGenerateReport", .{ self, report }); } pub inline fn enumerateAdapters(self: *Instance, options: ?*EnumerateAdapterOptions, adapters: ?[*]*Adapter) usize { - return wgpuInstanceEnumerateAdapters(self, options, adapters); + return raw.call(usize, "wgpuInstanceEnumerateAdapters", .{ self, options, adapters }); } }; diff --git a/src/log.zig b/src/log.zig index 9ef16fb..35afb1e 100644 --- a/src/log.zig +++ b/src/log.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const StringView = @import("misc.zig").StringView; pub const LogLevel = enum(u32) { @@ -11,12 +12,9 @@ pub const LogLevel = enum(u32) { pub const LogCallback = *const fn (level: LogLevel, message: StringView, userdata: ?*anyopaque) callconv(.c) void; -extern fn wgpuSetLogCallback(callback: LogCallback, userdata: ?*anyopaque) void; -extern fn wgpuSetLogLevel(level: LogLevel) void; - pub inline fn setLogCallback(callback: LogCallback, userdata: ?*anyopaque) void { - wgpuSetLogCallback(callback, userdata); + raw.call(void, "wgpuSetLogCallback", .{ callback, userdata }); } pub inline fn setLogLevel(level: LogLevel) void { - wgpuSetLogLevel(level); + raw.call(void, "wgpuSetLogLevel", .{level}); } diff --git a/src/misc.zig b/src/misc.zig index 4b94b35..8a7ce1d 100644 --- a/src/misc.zig +++ b/src/misc.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const std = @import("std"); pub const U32_MAX: u32 = std.math.maxInt(u32); @@ -83,19 +84,13 @@ pub const FeatureName = enum(u32) { shader_int64 = 0x00030026, }; -pub const SupportedFeaturesProcs = struct { - pub const FreeMembers = *const fn (SupportedFeatures) callconv(.c) void; -}; - -extern fn wgpuSupportedFeaturesFreeMembers(supported_features: SupportedFeatures) void; - pub const SupportedFeatures = extern struct { feature_count: usize, features: [*]const FeatureName, // Frees array members of SupportedFeatures which were allocated by the API. pub inline fn freeMembers(self: SupportedFeatures) void { - wgpuSupportedFeaturesFreeMembers(self); + raw.call(void, "wgpuSupportedFeaturesFreeMembers", .{self}); } }; @@ -117,9 +112,8 @@ pub const CompareFunction = enum(u32) { always = 0x00000008, }; -extern fn wgpuGetVersion() u32; pub inline fn getVersion() u32 { - return wgpuGetVersion(); + return raw.call(u32, "wgpuGetVersion", .{}); } // Max of usize diff --git a/src/pipeline.zig b/src/pipeline.zig index 60c0cac..2ef9164 100644 --- a/src/pipeline.zig +++ b/src/pipeline.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const _chained_struct = @import("chained_struct.zig"); const ChainedStruct = _chained_struct.ChainedStruct; const SType = _chained_struct.SType; @@ -43,16 +44,6 @@ pub const PipelineLayoutDescriptor = extern struct { } }; -pub const PipelineLayoutProcs = struct { - pub const SetLabel = *const fn (*PipelineLayout, StringView) callconv(.c) void; - pub const AddRef = *const fn (*PipelineLayout) callconv(.c) void; - pub const Release = *const fn (*PipelineLayout) callconv(.c) void; -}; - -extern fn wgpuPipelineLayoutSetLabel(pipeline_layout: *PipelineLayout, label: StringView) void; -extern fn wgpuPipelineLayoutAddRef(pipeline_layout: *PipelineLayout) void; -extern fn wgpuPipelineLayoutRelease(pipeline_layout: *PipelineLayout) void; - pub const PipelineLayout = opaque { // Unimplemented as of wgpu-native v29.0.0.0, @@ -62,10 +53,10 @@ pub const PipelineLayout = opaque { // } pub inline fn addRef(self: *PipelineLayout) void { - wgpuPipelineLayoutAddRef(self); + raw.call(void, "wgpuPipelineLayoutAddRef", .{self}); } pub inline fn release(self: *PipelineLayout) void { - wgpuPipelineLayoutRelease(self); + raw.call(void, "wgpuPipelineLayoutRelease", .{self}); } }; @@ -117,21 +108,9 @@ pub const CreateComputePipelineAsyncCallback = *const fn ( userdata2: ?*anyopaque, ) callconv(.c) void; -pub const ComputePipelineProcs = struct { - pub const GetBindGroupLayout = *const fn (*ComputePipeline, u32) callconv(.c) ?*BindGroupLayout; - pub const SetLabel = *const fn (*ComputePipeline, StringView) callconv(.c) void; - pub const AddRef = *const fn (*ComputePipeline) callconv(.c) void; - pub const Release = *const fn (*ComputePipeline) callconv(.c) void; -}; - -extern fn wgpuComputePipelineGetBindGroupLayout(compute_pipeline: *ComputePipeline, group_index: u32) ?*BindGroupLayout; -extern fn wgpuComputePipelineSetLabel(compute_pipeline: *ComputePipeline, label: StringView) void; -extern fn wgpuComputePipelineAddRef(compute_pipeline: *ComputePipeline) void; -extern fn wgpuComputePipelineRelease(compute_pipeline: *ComputePipeline) void; - pub const ComputePipeline = opaque { pub inline fn getBindGroupLayout(self: *ComputePipeline, group_index: u32) ?*BindGroupLayout { - return wgpuComputePipelineGetBindGroupLayout(self, group_index); + return raw.call(?*BindGroupLayout, "wgpuComputePipelineGetBindGroupLayout", .{ self, group_index }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -141,10 +120,10 @@ pub const ComputePipeline = opaque { // } pub inline fn addRef(self: *ComputePipeline) void { - wgpuComputePipelineAddRef(self); + raw.call(void, "wgpuComputePipelineAddRef", .{self}); } pub inline fn release(self: *ComputePipeline) void { - wgpuComputePipelineRelease(self); + raw.call(void, "wgpuComputePipelineRelease", .{self}); } }; @@ -427,21 +406,9 @@ pub const RenderPipelineDescriptor = extern struct { fragment: ?*const FragmentState = null, }; -pub const RenderPipelineProcs = struct { - pub const GetBindGroupLayout = *const fn (*RenderPipeline, u32) callconv(.c) ?*BindGroupLayout; - pub const SetLabel = *const fn (*RenderPipeline, StringView) callconv(.c) void; - pub const AddRef = *const fn (*RenderPipeline) callconv(.c) void; - pub const Release = *const fn (*RenderPipeline) callconv(.c) void; -}; - -extern fn wgpuRenderPipelineGetBindGroupLayout(render_pipeline: *RenderPipeline, group_index: u32) ?*BindGroupLayout; -extern fn wgpuRenderPipelineSetLabel(render_pipeline: *RenderPipeline, label: StringView) void; -extern fn wgpuRenderPipelineAddRef(render_pipeline: *RenderPipeline) void; -extern fn wgpuRenderPipelineRelease(render_pipeline: *RenderPipeline) void; - pub const RenderPipeline = opaque { pub inline fn getBindGroupLayout(self: *RenderPipeline, group_index: u32) ?*BindGroupLayout { - return wgpuRenderPipelineGetBindGroupLayout(self, group_index); + return raw.call(?*BindGroupLayout, "wgpuRenderPipelineGetBindGroupLayout", .{ self, group_index }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -451,10 +418,10 @@ pub const RenderPipeline = opaque { // } pub inline fn addRef(self: *RenderPipeline) void { - wgpuRenderPipelineAddRef(self); + raw.call(void, "wgpuRenderPipelineAddRef", .{self}); } pub inline fn release(self: *RenderPipeline) void { - wgpuRenderPipelineRelease(self); + raw.call(void, "wgpuRenderPipelineRelease", .{self}); } }; diff --git a/src/query_set.zig b/src/query_set.zig index 3c4eaa3..ff607fc 100644 --- a/src/query_set.zig +++ b/src/query_set.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const _chained_struct = @import("chained_struct.zig"); const ChainedStruct = _chained_struct.ChainedStruct; const SType = _chained_struct.SType; @@ -44,31 +45,15 @@ pub const QuerySetDescriptor = extern struct { } }; -pub const QuerySetProcs = struct { - pub const Destroy = *const fn (*QuerySet) callconv(.c) void; - pub const GetCount = *const fn (*QuerySet) callconv(.c) u32; - pub const GetType = *const fn (*QuerySet) callconv(.c) QueryType; - pub const SetLabel = *const fn (*QuerySet, StringView) callconv(.c) void; - pub const AddRef = *const fn (*QuerySet) callconv(.c) void; - pub const Release = *const fn (*QuerySet) callconv(.c) void; -}; - -extern fn wgpuQuerySetDestroy(query_set: *QuerySet) void; -extern fn wgpuQuerySetGetCount(query_set: *QuerySet) u32; -extern fn wgpuQuerySetGetType(query_set: *QuerySet) QueryType; -extern fn wgpuQuerySetSetLabel(query_set: *QuerySet, label: StringView) void; -extern fn wgpuQuerySetAddRef(query_set: *QuerySet) void; -extern fn wgpuQuerySetRelease(query_set: *QuerySet) void; - pub const QuerySet = opaque { pub inline fn destroy(self: *QuerySet) void { - wgpuQuerySetDestroy(self); + raw.call(void, "wgpuQuerySetDestroy", .{self}); } pub inline fn getCount(self: *QuerySet) u32 { - return wgpuQuerySetGetCount(self); + return raw.call(u32, "wgpuQuerySetGetCount", .{self}); } pub inline fn getType(self: *QuerySet) QueryType { - return wgpuQuerySetGetType(self); + return raw.call(QueryType, "wgpuQuerySetGetType", .{self}); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -78,9 +63,9 @@ pub const QuerySet = opaque { // } pub inline fn addRef(self: *QuerySet) void { - wgpuQuerySetAddRef(self); + raw.call(void, "wgpuQuerySetAddRef", .{self}); } pub inline fn release(self: *QuerySet) void { - wgpuQuerySetRelease(self); + raw.call(void, "wgpuQuerySetRelease", .{self}); } }; diff --git a/src/queue.zig b/src/queue.zig index bc2edd2..a3729f8 100644 --- a/src/queue.zig +++ b/src/queue.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const ChainedStruct = @import("chained_struct.zig").ChainedStruct; const CommandBuffer = @import("command_encoder.zig").CommandBuffer; const Buffer = @import("buffer.zig").Buffer; @@ -39,33 +40,11 @@ pub const QueueWorkDoneCallbackInfo = extern struct { pub const QueueWorkDoneCallback = *const fn (status: WorkDoneStatus, message: StringView, userdata1: ?*anyopaque, userdata2: ?*anyopaque) callconv(.c) void; -pub const QueueProcs = struct { - pub const OnSubmittedWorkDone = *const fn (*Queue, QueueWorkDoneCallbackInfo) callconv(.c) Future; - pub const SetLabel = *const fn (*Queue, StringView) callconv(.c) void; - pub const Submit = *const fn (*Queue, usize, [*]const *const CommandBuffer) callconv(.c) void; - pub const WriteBuffer = *const fn (*Queue, Buffer, u64, *const anyopaque, usize) callconv(.c) void; - pub const WriteTexture = *const fn (*Queue, *const TexelCopyTextureInfo, *const anyopaque, usize, *const TexelCopyBufferLayout, *const Extent3D) callconv(.c) void; - pub const AddRef = *const fn (*Queue) callconv(.c) void; - pub const Release = *const fn (*Queue) callconv(.c) void; - - // wgpu-native procs? - // pub const SubmitForIndex = *const fn(*Queue, usize, [*]const *const CommandBuffer) callconv(.c) SubmissionIndex; -}; - -extern fn wgpuQueueOnSubmittedWorkDone(queue: *Queue, callback_info: QueueWorkDoneCallbackInfo) Future; -extern fn wgpuQueueSetLabel(queue: *Queue, label: StringView) void; -extern fn wgpuQueueSubmit(queue: *Queue, command_count: usize, commands: [*]const *const CommandBuffer) void; -extern fn wgpuQueueWriteBuffer(queue: *Queue, buffer: *Buffer, buffer_offset: u64, data: *const anyopaque, size: usize) void; -extern fn wgpuQueueWriteTexture(queue: *Queue, destination: *const TexelCopyTextureInfo, data: *const anyopaque, data_size: usize, data_layout: *const TexelCopyBufferLayout, write_size: *const Extent3D) void; -extern fn wgpuQueueAddRef(queue: *Queue) void; -extern fn wgpuQueueRelease(queue: *Queue) void; - // wgpu-native -extern fn wgpuQueueSubmitForIndex(queue: *Queue, command_count: usize, commands: [*]const *const CommandBuffer) SubmissionIndex; pub const Queue = opaque { pub inline fn onSubmittedWorkDone(self: *Queue, callback_info: QueueWorkDoneCallbackInfo) Future { - return wgpuQueueOnSubmittedWorkDone(self, callback_info); + return raw.call(Future, "wgpuQueueOnSubmittedWorkDone", .{ self, callback_info }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -75,25 +54,25 @@ pub const Queue = opaque { // } pub inline fn submit(self: *Queue, commands: []const *const CommandBuffer) void { - wgpuQueueSubmit(self, commands.len, commands.ptr); + raw.call(void, "wgpuQueueSubmit", .{ self, commands.len, commands.ptr }); } pub inline fn writeBuffer(self: *Queue, buffer: *Buffer, buffer_offset: u64, data: *const anyopaque, size: usize) void { - wgpuQueueWriteBuffer(self, buffer, buffer_offset, data, size); + raw.call(void, "wgpuQueueWriteBuffer", .{ self, buffer, buffer_offset, data, size }); } pub inline fn writeTexture(self: *Queue, destination: *const TexelCopyTextureInfo, data: *const anyopaque, data_size: usize, data_layout: *const TexelCopyBufferLayout, write_size: *const Extent3D) void { - wgpuQueueWriteTexture(self, destination, data, data_size, data_layout, write_size); + raw.call(void, "wgpuQueueWriteTexture", .{ self, destination, data, data_size, data_layout, write_size }); } pub inline fn addRef(self: *Queue) void { - wgpuQueueAddRef(self); + raw.call(void, "wgpuQueueAddRef", .{self}); } pub inline fn release(self: *Queue) void { - wgpuQueueRelease(self); + raw.call(void, "wgpuQueueRelease", .{self}); } // wgpu-native pub inline fn submitForIndex(self: *Queue, commands: []const *const CommandBuffer) SubmissionIndex { - return wgpuQueueSubmitForIndex(self, commands.len, commands.ptr); + return raw.call(SubmissionIndex, "wgpuQueueSubmitForIndex", .{ self, commands.len, commands.ptr }); } }; diff --git a/src/raw.zig b/src/raw.zig new file mode 100644 index 0000000..2488cd2 --- /dev/null +++ b/src/raw.zig @@ -0,0 +1,109 @@ +const std = @import("std"); + +pub const header = @import("wgpu-header"); + +pub inline fn call( + comptime Return: type, + comptime name: []const u8, + args: anytype, +) Return { + const function = @field(header, name); + const Function = @TypeOf(function); + const function_info = @typeInfo(Function).@"fn"; + const Args = std.meta.ArgsTuple(Function); + const args_info = @typeInfo(@TypeOf(args)).@"struct"; + + comptime std.debug.assert(args_info.fields.len == function_info.params.len); + + var converted: Args = undefined; + inline for (args_info.fields, 0..) |field, index| { + converted[index] = convert( + function_info.params[index].type.?, + @field(args, field.name), + ); + } + + if (Return == void) { + @call(.auto, function, converted); + return; + } + return convert(Return, @call(.auto, function, converted)); +} + +fn convert(comptime To: type, value: anytype) To { + const From = @TypeOf(value); + if (To == From) return value; + if (From == @TypeOf(null)) return null; + + return switch (@typeInfo(To)) { + .optional, .pointer => @ptrCast(value), + .@"enum" => switch (@typeInfo(From)) { + .@"enum" => @enumFromInt(@intFromEnum(value)), + .int, .comptime_int => @enumFromInt(value), + else => conversionError(To, From), + }, + .int => switch (@typeInfo(From)) { + .@"enum" => @intFromEnum(value), + .int, .comptime_int => @intCast(value), + else => conversionError(To, From), + }, + .@"struct", .@"union" => @bitCast(value), + else => conversionError(To, From), + }; +} + +fn conversionError(comptime To: type, comptime From: type) noreturn { + @compileError(std.fmt.comptimePrint( + "cannot convert wgpu header argument from {s} to {s}", + .{ @typeName(From), @typeName(To) }, + )); +} + +const wrapper_sources = .{ + .{ "adapter.zig", @embedFile("adapter.zig") }, + .{ "bind_group.zig", @embedFile("bind_group.zig") }, + .{ "buffer.zig", @embedFile("buffer.zig") }, + .{ "command_encoder.zig", @embedFile("command_encoder.zig") }, + .{ "device.zig", @embedFile("device.zig") }, + .{ "instance.zig", @embedFile("instance.zig") }, + .{ "log.zig", @embedFile("log.zig") }, + .{ "misc.zig", @embedFile("misc.zig") }, + .{ "pipeline.zig", @embedFile("pipeline.zig") }, + .{ "query_set.zig", @embedFile("query_set.zig") }, + .{ "queue.zig", @embedFile("queue.zig") }, + .{ "render_bundle.zig", @embedFile("render_bundle.zig") }, + .{ "sampler.zig", @embedFile("sampler.zig") }, + .{ "shader.zig", @embedFile("shader.zig") }, + .{ "surface.zig", @embedFile("surface.zig") }, + .{ "texture.zig", @embedFile("texture.zig") }, +}; + +test "all wrapper calls are declared by wgpu headers" { + comptime { + @setEvalBranchQuota(10_000_000); + for (wrapper_sources) |source| validateWrapperSource(source[0], source[1]); + } +} + +fn validateWrapperSource(comptime file_name: []const u8, comptime source: []const u8) void { + if (std.mem.indexOf(u8, source, "extern fn wgpu") != null) { + @compileError(file_name ++ " contains a handwritten wgpu extern"); + } + + var cursor: usize = 0; + while (std.mem.indexOfPos(u8, source, cursor, "raw.call(")) |call_start| { + const name_start = std.mem.indexOfPos(u8, source, call_start, "\"wgpu") orelse + @compileError(file_name ++ " contains an invalid raw.call"); + const name_end = std.mem.indexOfScalarPos( + u8, + source, + name_start + 1, + '"', + ) orelse @compileError(file_name ++ " contains an unterminated function name"); + const name = source[name_start + 1 .. name_end]; + if (!@hasDecl(header, name)) { + @compileError(file_name ++ " references missing header function " ++ name); + } + cursor = name_end + 1; + } +} diff --git a/src/render_bundle.zig b/src/render_bundle.zig index 47e0629..ab8d422 100644 --- a/src/render_bundle.zig +++ b/src/render_bundle.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const _misc = @import("misc.zig"); const WGPUBool = _misc.WGPUBool; const IndexFormat = _misc.IndexFormat; @@ -19,74 +20,39 @@ pub const RenderBundleEncoderDescriptor = extern struct { stencil_read_only: WGPUBool = @intFromBool(false), }; -pub const RenderBundleEncoderProcs = struct { - pub const Draw = *const fn (*RenderBundleEncoder, u32, u32, u32, u32) callconv(.c) void; - pub const DrawIndexed = *const fn (*RenderBundleEncoder, u32, u32, u32, i32, u32) callconv(.c) void; - pub const DrawIndexedIndirect = *const fn (*RenderBundleEncoder, *Buffer, u64) callconv(.c) void; - pub const DrawIndirect = *const fn (*RenderBundleEncoder, *Buffer, u64) callconv(.c) void; - pub const Finish = *const fn (*RenderBundleEncoder, *const RenderBundleDescriptor) callconv(.c) ?*RenderBundle; - pub const InsertDebugMarker = *const fn (*RenderBundleEncoder, StringView) callconv(.c) void; - pub const PopDebugGroup = *const fn (*RenderBundleEncoder) callconv(.c) void; - pub const PushDebugGroup = *const fn (*RenderBundleEncoder, StringView) callconv(.c) void; - pub const SetBindGroup = *const fn (*RenderBundleEncoder, u32, *BindGroup, usize, ?[*]const u32) callconv(.c) void; - pub const SetIndexBuffer = *const fn (*RenderBundleEncoder, *Buffer, IndexFormat, u64, u64) callconv(.c) void; - pub const SetLabel = *const fn (*RenderBundleEncoder, StringView) callconv(.c) void; - pub const SetPipeline = *const fn (*RenderBundleEncoder, *RenderPipeline) callconv(.c) void; - pub const SetVertexBuffer = *const fn (*RenderBundleEncoder, u32, *Buffer, u64, u64) callconv(.c) void; - pub const AddRef = *const fn (*RenderBundleEncoder) callconv(.c) void; - pub const Release = *const fn (*RenderBundleEncoder) callconv(.c) void; -}; - -extern fn wgpuRenderBundleEncoderDraw(render_bundle_encoder: *RenderBundleEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void; -extern fn wgpuRenderBundleEncoderDrawIndexed(render_bundle_encoder: *RenderBundleEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: i32, first_instance: u32) void; -extern fn wgpuRenderBundleEncoderDrawIndexedIndirect(render_bundle_encoder: *RenderBundleEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void; -extern fn wgpuRenderBundleEncoderDrawIndirect(render_bundle_encoder: *RenderBundleEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void; -extern fn wgpuRenderBundleEncoderFinish(render_bundle_encoder: *RenderBundleEncoder, descriptor: *const RenderBundleDescriptor) ?*RenderBundle; -extern fn wgpuRenderBundleEncoderInsertDebugMarker(render_bundle_encoder: *RenderBundleEncoder, marker_label: StringView) void; -extern fn wgpuRenderBundleEncoderPopDebugGroup(render_bundle_encoder: *RenderBundleEncoder) void; -extern fn wgpuRenderBundleEncoderPushDebugGroup(render_bundle_encoder: *RenderBundleEncoder, group_label: StringView) void; -extern fn wgpuRenderBundleEncoderSetBindGroup(render_bundle_encoder: *RenderBundleEncoder, group_index: u32, group: *BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void; -extern fn wgpuRenderBundleEncoderSetIndexBuffer(render_bundle_encoder: *RenderBundleEncoder, buffer: *Buffer, format: IndexFormat, offset: u64, size: u64) void; -extern fn wgpuRenderBundleEncoderSetLabel(render_bundle_encoder: *RenderBundleEncoder, label: StringView) void; -extern fn wgpuRenderBundleEncoderSetPipeline(render_bundle_encoder: *RenderBundleEncoder, pipeline: *RenderPipeline) void; -extern fn wgpuRenderBundleEncoderSetVertexBuffer(render_bundle_encoder: *RenderBundleEncoder, slot: u32, buffer: *Buffer, offset: u64, size: u64) void; -extern fn wgpuRenderBundleEncoderAddRef(render_bundle_encoder: *RenderBundleEncoder) void; -extern fn wgpuRenderBundleEncoderRelease(render_bundle_encoder: *RenderBundleEncoder) void; - // wgpu-native -extern fn wgpuRenderBundleEncoderSetImmediates(render_bundle_encoder: *RenderBundleEncoder, offset: u32, size_bytes: u32, data: *const anyopaque) void; // TODO: This is very similar to CommandEncoder; should it go in the same file? There's a lot of duplicated import code. pub const RenderBundleEncoder = opaque { pub inline fn draw(self: *RenderBundleEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void { - wgpuRenderBundleEncoderDraw(self, vertex_count, instance_count, first_vertex, first_instance); + raw.call(void, "wgpuRenderBundleEncoderDraw", .{ self, vertex_count, instance_count, first_vertex, first_instance }); } pub inline fn drawIndexed(self: *RenderBundleEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: i32, first_instance: u32) void { - wgpuRenderBundleEncoderDrawIndexed(self, index_count, instance_count, first_index, base_vertex, first_instance); + raw.call(void, "wgpuRenderBundleEncoderDrawIndexed", .{ self, index_count, instance_count, first_index, base_vertex, first_instance }); } pub inline fn drawIndexedIndirect(self: *RenderBundleEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void { - wgpuRenderBundleEncoderDrawIndexedIndirect(self, indirect_buffer, indirect_offset); + raw.call(void, "wgpuRenderBundleEncoderDrawIndexedIndirect", .{ self, indirect_buffer, indirect_offset }); } pub inline fn drawIndirect(self: *RenderBundleEncoder, indirect_buffer: *Buffer, indirect_offset: u64) void { - wgpuRenderBundleEncoderDrawIndirect(self, indirect_buffer, indirect_offset); + raw.call(void, "wgpuRenderBundleEncoderDrawIndirect", .{ self, indirect_buffer, indirect_offset }); } pub inline fn finish(self: *RenderBundleEncoder, descriptor: *const RenderBundleDescriptor) ?*RenderBundle { - return wgpuRenderBundleEncoderFinish(self, descriptor); + return raw.call(?*RenderBundle, "wgpuRenderBundleEncoderFinish", .{ self, descriptor }); } pub inline fn insertDebugMarker(self: *RenderBundleEncoder, marker_label: []const u8) void { - wgpuRenderBundleEncoderInsertDebugMarker(self, StringView.fromSlice(marker_label)); + raw.call(void, "wgpuRenderBundleEncoderInsertDebugMarker", .{ self, StringView.fromSlice(marker_label) }); } pub inline fn popDebugGroup(self: *RenderBundleEncoder) void { - wgpuRenderBundleEncoderPopDebugGroup(self); + raw.call(void, "wgpuRenderBundleEncoderPopDebugGroup", .{self}); } pub inline fn pushDebugGroup(self: *RenderBundleEncoder, group_label: []const u8) void { - wgpuRenderBundleEncoderPushDebugGroup(self, StringView.fromSlice(group_label)); + raw.call(void, "wgpuRenderBundleEncoderPushDebugGroup", .{ self, StringView.fromSlice(group_label) }); } pub inline fn setBindGroup(self: *RenderBundleEncoder, group_index: u32, group: *BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void { - wgpuRenderBundleEncoderSetBindGroup(self, group_index, group, dynamic_offset_count, dynamic_offsets); + raw.call(void, "wgpuRenderBundleEncoderSetBindGroup", .{ self, group_index, group, dynamic_offset_count, dynamic_offsets }); } pub inline fn setIndexBuffer(self: *RenderBundleEncoder, buffer: *Buffer, format: IndexFormat, offset: u64, size: u64) void { - wgpuRenderBundleEncoderSetIndexBuffer(self, buffer, format, offset, size); + raw.call(void, "wgpuRenderBundleEncoderSetIndexBuffer", .{ self, buffer, format, offset, size }); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -96,21 +62,21 @@ pub const RenderBundleEncoder = opaque { // } pub inline fn setPipeline(self: *RenderBundleEncoder, pipeline: *RenderPipeline) void { - wgpuRenderBundleEncoderSetPipeline(self, pipeline); + raw.call(void, "wgpuRenderBundleEncoderSetPipeline", .{ self, pipeline }); } pub inline fn setVertexBuffer(self: *RenderBundleEncoder, slot: u32, buffer: *Buffer, offset: u64, size: u64) void { - wgpuRenderBundleEncoderSetVertexBuffer(self, slot, buffer, offset, size); + raw.call(void, "wgpuRenderBundleEncoderSetVertexBuffer", .{ self, slot, buffer, offset, size }); } pub inline fn addRef(self: *RenderBundleEncoder) void { - wgpuRenderBundleEncoderAddRef(self); + raw.call(void, "wgpuRenderBundleEncoderAddRef", .{self}); } pub inline fn release(self: *RenderBundleEncoder) void { - wgpuRenderBundleEncoderRelease(self); + raw.call(void, "wgpuRenderBundleEncoderRelease", .{self}); } // wgpu-native pub inline fn setImmediates(self: *RenderBundleEncoder, offset: u32, size_bytes: u32, data: *const anyopaque) void { - wgpuRenderBundleEncoderSetImmediates(self, offset, size_bytes, data); + raw.call(void, "wgpuRenderBundleEncoderSetImmediates", .{ self, offset, size_bytes, data }); } }; @@ -119,16 +85,6 @@ pub const RenderBundleDescriptor = extern struct { label: StringView = StringView{}, }; -pub const RenderBundleProcs = struct { - pub const SetLabel = *const fn (*RenderBundle, StringView) callconv(.c) void; - pub const AddRef = *const fn (*RenderBundle) callconv(.c) void; - pub const Release = *const fn (*RenderBundle) callconv(.c) void; -}; - -extern fn wgpuRenderBundleSetLabel(render_bundle: *RenderBundle, label: StringView) void; -extern fn wgpuRenderBundleAddRef(render_bundle: *RenderBundle) void; -extern fn wgpuRenderBundleRelease(render_bundle: *RenderBundle) void; - pub const RenderBundle = opaque { // Unimplemented as of wgpu-native v29.0.0.0, // see https://github.com/gfx-rs/wgpu-native/blob/d2e3330ade4ae1bb238d76b485926f067e7ee64c/src/unimplemented.rs @@ -137,9 +93,9 @@ pub const RenderBundle = opaque { // } pub inline fn addRef(self: *RenderBundle) void { - wgpuRenderBundleAddRef(self); + raw.call(void, "wgpuRenderBundleAddRef", .{self}); } pub inline fn release(self: *RenderBundle) void { - wgpuRenderBundleRelease(self); + raw.call(void, "wgpuRenderBundleRelease", .{self}); } }; diff --git a/src/root.zig b/src/root.zig index 4a954db..2ffb104 100644 --- a/src/root.zig +++ b/src/root.zig @@ -1,3 +1,5 @@ +pub const raw = @import("raw.zig").header; + const _misc = @import("misc.zig"); pub const U32_MAX = _misc.U32_MAX; pub const U64_MAX = _misc.U64_MAX; @@ -8,7 +10,6 @@ pub const WGPUFlags = _misc.WGPUFlags; pub const Status = _misc.Status; pub const OptionalBool = _misc.OptionalBool; pub const FeatureName = _misc.FeatureName; -pub const SupportedFeaturesProcs = _misc.SupportedFeaturesProcs; pub const SupportedFeatures = _misc.SupportedFeatures; pub const IndexFormat = _misc.IndexFormat; pub const CompareFunction = _misc.CompareFunction; @@ -27,9 +28,7 @@ pub const RequestAdapterStatus = _adapter.RequestAdapterStatus; pub const RequestAdapterCallbackInfo = _adapter.RequestAdapterCallbackInfo; pub const RequestAdapterCallback = _adapter.RequestAdapterCallback; pub const RequestAdapterResponse = _adapter.RequestAdapterResponse; -pub const AdapterInfoProcs = _adapter.AdapterInfoProcs; pub const AdapterInfo = _adapter.AdapterInfo; -pub const AdapterProcs = _adapter.AdapterProcs; pub const Adapter = _adapter.Adapter; const _bind_group = @import("bind_group.zig"); @@ -39,12 +38,10 @@ pub const ExternalTextureBindingEntry = _bind_group.ExternalTextureBindingEntry; pub const BindGroupLayoutEntryExtras = _bind_group.BindGroupLayoutEntryExtras; pub const BindGroupLayoutEntry = _bind_group.BindGroupLayoutEntry; pub const BindGroupLayoutDescriptor = _bind_group.BindGroupLayoutDescriptor; -pub const BindGroupLayoutProcs = _bind_group.BindGroupLayoutProcs; pub const BindGroupLayout = _bind_group.BindGroupLayout; pub const BindGroupEntryExtras = _bind_group.BindGroupEntryExtras; pub const BindGroupEntry = _bind_group.BindGroupEntry; pub const BindGroupDescriptor = _bind_group.BindGroupDescriptor; -pub const BindGroupProcs = _bind_group.BindGroupProcs; pub const BindGroup = _bind_group.BindGroup; const _buffer = @import("buffer.zig"); @@ -60,7 +57,6 @@ pub const MapAsyncStatus = _buffer.MapAsyncStatus; pub const BufferMapCallbackInfo = _buffer.BufferMapCallbackInfo; pub const BufferMapCallback = _buffer.BufferMapCallback; pub const BufferDescriptor = _buffer.BufferDescriptor; -pub const BufferProcs = _buffer.BufferProcs; pub const Buffer = _buffer.Buffer; const _chained_struct = @import("chained_struct.zig"); @@ -82,12 +78,9 @@ pub const ColorAttachment = _command_encoder.ColorAttachment; pub const DepthStencilAttachment = _command_encoder.DepthStencilAttachment; pub const RenderPassMaxDrawCount = _command_encoder.RenderPassMaxDrawCount; pub const RenderPassDescriptor = _command_encoder.RenderPassDescriptor; -pub const RenderPassEncoderProcs = _command_encoder.RenderPassEncoderProcs; pub const RenderPassEncoder = _command_encoder.RenderPassEncoder; pub const CommandBufferDescriptor = _command_encoder.CommandBufferDescriptor; -pub const CommandBufferProcs = _command_encoder.CommandBufferProcs; pub const CommandBuffer = _command_encoder.CommandBuffer; -pub const CommandEncoderProcs = _command_encoder.CommandEncoderProcs; pub const CommandEncoder = _command_encoder.CommandEncoder; const _device = @import("device.zig"); @@ -108,7 +101,6 @@ pub const RequestDeviceCallbackInfo = _device.RequestDeviceCallbackInfo; pub const PopErrorScopeStatus = _device.PopErrorScopeStatus; pub const PopErrorScopeCallback = _device.PopErrorScopeCallback; pub const PopErrorScopeCallbackInfo = _device.PopErrorScopeCallbackInfo; -pub const DeviceProcs = _device.DeviceProcs; pub const Device = _device.Device; const _instance = @import("instance.zig"); @@ -133,9 +125,7 @@ pub const SupportedInstanceFeatures = _instance.SupportedInstanceFeatures; pub const InstanceLimits = _instance.InstanceLimits; pub const InstanceDescriptor = _instance.InstanceDescriptor; pub const WGSLLanguageFeatureName = _instance.WGSLLanguageFeatureName; -pub const SupportedWGSLLanguageFeaturesProcs = _instance.SupportedWGSLLanguageFeaturesProcs; pub const SupportedWGSLLanguageFeatures = _instance.SupportedWGSLLanguageFeatures; -pub const InstanceProcs = _instance.InstanceProcs; pub const RegistryReport = _instance.RegistryReport; pub const HubReport = _instance.HubReport; pub const GlobalReport = _instance.GlobalReport; @@ -158,7 +148,6 @@ pub const setLogLevel = _log.setLogLevel; const _pipeline = @import("pipeline.zig"); pub const PipelineLayoutExtras = _pipeline.PipelineLayoutExtras; pub const PipelineLayoutDescriptor = _pipeline.PipelineLayoutDescriptor; -pub const PipelineLayoutProcs = _pipeline.PipelineLayoutProcs; pub const PipelineLayout = _pipeline.PipelineLayout; pub const ConstantEntry = _pipeline.ConstantEntry; pub const ComputeState = _pipeline.ComputeState; @@ -166,7 +155,6 @@ pub const ComputePipelineDescriptor = _pipeline.ComputePipelineDescriptor; pub const CreatePipelineAsyncStatus = _pipeline.CreatePipelineAsyncStatus; pub const CreateComputePipelineAsyncCallbackInfo = _pipeline.CreateComputePipelineAsyncCallbackInfo; pub const CreateComputePipelineAsyncCallback = _pipeline.CreateComputePipelineAsyncCallback; -pub const ComputePipelineProcs = _pipeline.ComputePipelineProcs; pub const ComputePipeline = _pipeline.ComputePipeline; pub const VertexStepMode = _pipeline.VertexStepMode; pub const VertexFormat = _pipeline.VertexFormat; @@ -192,7 +180,6 @@ pub const ColorWriteMasks = _pipeline.ColorWriteMasks; pub const ColorTargetState = _pipeline.ColorTargetState; pub const FragmentState = _pipeline.FragmentState; pub const RenderPipelineDescriptor = _pipeline.RenderPipelineDescriptor; -pub const RenderPipelineProcs = _pipeline.RenderPipelineProcs; pub const RenderPipeline = _pipeline.RenderPipeline; pub const CreateRenderPipelineAsyncCallbackInfo = _pipeline.CreateRenderPipelineAsyncCallbackInfo; pub const CreateRenderPipelineAsyncCallback = _pipeline.CreateRenderPipelineAsyncCallback; @@ -202,7 +189,6 @@ pub const QueryType = _query_set.QueryType; pub const PipelineStatisticName = _query_set.PipelineStatisticName; pub const QuerySetDescriptorExtras = _query_set.QuerySetDescriptorExtras; pub const QuerySetDescriptor = _query_set.QuerySetDescriptor; -pub const QuerySetProcs = _query_set.QuerySetProcs; pub const QuerySet = _query_set.QuerySet; const _queue = @import("queue.zig"); @@ -211,15 +197,12 @@ pub const QueueDescriptor = _queue.QueueDescriptor; pub const WorkDoneStatus = _queue.WorkDoneStatus; pub const QueueWorkDoneCallbackInfo = _queue.QueueWorkDoneCallbackInfo; pub const QueueWorkDoneCallback = _queue.QueueWorkDoneCallback; -pub const QueueProcs = _queue.QueueProcs; pub const Queue = _queue.Queue; const _render_bundle = @import("render_bundle.zig"); pub const RenderBundleEncoderDescriptor = _render_bundle.RenderBundleEncoderDescriptor; -pub const RenderBundleEncoderProcs = _render_bundle.RenderBundleEncoderProcs; pub const RenderBundleEncoder = _render_bundle.RenderBundleEncoder; pub const RenderBundleDescriptor = _render_bundle.RenderBundleDescriptor; -pub const RenderBundleProcs = _render_bundle.RenderBundleProcs; pub const RenderBundle = _render_bundle.RenderBundle; const _sampler = @import("sampler.zig"); @@ -229,7 +212,6 @@ pub const AddressMode = _sampler.AddressMode; pub const FilterMode = _sampler.FilterMode; pub const MipmapFilterMode = _sampler.MipmapFilterMode; pub const SamplerDescriptor = _sampler.SamplerDescriptor; -pub const SamplerProcs = _sampler.SamplerProcs; pub const Sampler = _sampler.Sampler; const _shader = @import("shader.zig"); @@ -253,7 +235,6 @@ pub const CompilationMessage = _shader.CompilationMessage; pub const CompilationInfo = _shader.CompilationInfo; pub const CompilationInfoCallback = _shader.CompilationInfoCallback; pub const CompilationInfoCallbackInfo = _shader.CompilationInfoCallbackInfo; -pub const ShaderModuleProcs = _shader.ShaderModuleProcs; pub const ShaderModule = _shader.ShaderModule; const _surface = @import("surface.zig"); @@ -284,11 +265,9 @@ pub const ToneMappingMode = _surface.ToneMappingMode; pub const SurfaceColorManagement = _surface.SurfaceColorManagement; pub const SurfaceConfigurationExtras = _surface.SurfaceConfigurationExtras; pub const SurfaceConfiguration = _surface.SurfaceConfiguration; -pub const SurfaceCapabilitiesProcs = _surface.SurfaceCapabilitiesProcs; pub const SurfaceCapabilities = _surface.SurfaceCapabilities; pub const GetCurrentTextureStatus = _surface.GetCurrentTextureStatus; pub const SurfaceTexture = _surface.SurfaceTexture; -pub const SurfaceProcs = _surface.SurfaceProcs; pub const Surface = _surface.Surface; const _texture = @import("texture.zig"); @@ -303,7 +282,6 @@ pub const TextureViewDescriptor = _texture.TextureViewDescriptor; pub const ComponentSwizzle = _texture.ComponentSwizzle; pub const TextureComponentSwizzle = _texture.TextureComponentSwizzle; pub const TextureComponentSwizzleDescriptor = _texture.TextureComponentSwizzleDescriptor; -pub const TextureViewProcs = _texture.TextureViewProcs; pub const TextureView = _texture.TextureView; pub const SampleType = _texture.SampleType; pub const ViewDimension = _texture.ViewDimension; @@ -314,7 +292,6 @@ pub const StorageTextureBindingLayout = _texture.StorageTextureBindingLayout; pub const TextureDimension = _texture.TextureDimension; pub const Extent3D = _texture.Extent3D; pub const TextureDescriptor = _texture.TextureDescriptor; -pub const TextureProcs = _texture.TextureProcs; pub const Texture = _texture.Texture; pub const Origin3D = _texture.Origin3D; pub const TexelCopyTextureInfo = _texture.TexelCopyTextureInfo; diff --git a/src/sampler.zig b/src/sampler.zig index 932a54b..bc178d5 100644 --- a/src/sampler.zig +++ b/src/sampler.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const ChainedStruct = @import("chained_struct.zig").ChainedStruct; const _misc = @import("misc.zig"); @@ -55,16 +56,6 @@ pub const SamplerDescriptor = extern struct { max_anisotropy: u16 = 1, }; -pub const SamplerProcs = struct { - pub const SetLabel = *const fn (*Sampler, StringView) callconv(.c) void; - pub const AddRef = *const fn (*Sampler) callconv(.c) void; - pub const Release = *const fn (*Sampler) callconv(.c) void; -}; - -extern fn wgpuSamplerSetLabel(sampler: *Sampler, label: StringView) void; -extern fn wgpuSamplerAddRef(sampler: *Sampler) void; -extern fn wgpuSamplerRelease(sampler: *Sampler) void; - pub const Sampler = opaque { // Unimplemented as of wgpu-native v29.0.0.0, // see https://github.com/gfx-rs/wgpu-native/blob/d2e3330ade4ae1bb238d76b485926f067e7ee64c/src/unimplemented.rs @@ -73,9 +64,9 @@ pub const Sampler = opaque { // } pub inline fn addRef(self: *Sampler) void { - wgpuSamplerAddRef(self); + raw.call(void, "wgpuSamplerAddRef", .{self}); } pub inline fn release(self: *Sampler) void { - wgpuSamplerRelease(self); + raw.call(void, "wgpuSamplerRelease", .{self}); } }; diff --git a/src/shader.zig b/src/shader.zig index 29585e1..aa73d33 100644 --- a/src/shader.zig +++ b/src/shader.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const _chained_struct = @import("chained_struct.zig"); const ChainedStruct = _chained_struct.ChainedStruct; const SType = _chained_struct.SType; @@ -156,18 +157,6 @@ pub const CompilationInfoCallbackInfo = extern struct { userdata2: ?*anyopaque = null, }; -pub const ShaderModuleProcs = struct { - pub const GetCompilationInfo = *const fn (*ShaderModule, CompilationInfoCallbackInfo) callconv(.c) Future; - pub const SetLabel = *const fn (*ShaderModule, StringView) callconv(.c) void; - pub const AddRef = *const fn (*ShaderModule) callconv(.c) void; - pub const Release = *const fn (*ShaderModule) callconv(.c) void; -}; - -extern fn wgpuShaderModuleGetCompilationInfo(shader_module: *ShaderModule, callback_info: CompilationInfoCallbackInfo) Future; -extern fn wgpuShaderModuleSetLabel(shader_module: *ShaderModule, label: StringView) void; -extern fn wgpuShaderModuleAddRef(shader_module: *ShaderModule) void; -extern fn wgpuShaderModuleRelease(shader_module: *ShaderModule) void; - pub const ShaderModule = opaque { // Unimplemented as of wgpu-native v29.0.0.0, // see https://github.com/gfx-rs/wgpu-native/blob/d2e3330ade4ae1bb238d76b485926f067e7ee64c/src/unimplemented.rs @@ -182,9 +171,9 @@ pub const ShaderModule = opaque { // } pub inline fn addRef(self: *ShaderModule) void { - wgpuShaderModuleAddRef(self); + raw.call(void, "wgpuShaderModuleAddRef", .{self}); } pub inline fn release(self: *ShaderModule) void { - wgpuShaderModuleRelease(self); + raw.call(void, "wgpuShaderModuleRelease", .{self}); } }; diff --git a/src/surface.zig b/src/surface.zig index 0f80b52..e269275 100644 --- a/src/surface.zig +++ b/src/surface.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const _chained_struct = @import("chained_struct.zig"); const SType = _chained_struct.SType; const ChainedStruct = _chained_struct.ChainedStruct; @@ -298,12 +299,6 @@ pub const SurfaceConfiguration = extern struct { } }; -pub const SurfaceCapabilitiesProcs = struct { - pub const FreeMembers = *const fn (SurfaceCapabilities) callconv(.c) void; -}; - -extern fn wgpuSurfaceCapabilitiesFreeMembers(surface_capabilities: SurfaceCapabilities) void; - // Filled by Surface.getCapabilities() with what's supported for Surface.configure() for a pair of Surface and Adapter. pub const SurfaceCapabilities = extern struct { next_in_chain: ?*ChainedStructOut = null, @@ -328,7 +323,7 @@ pub const SurfaceCapabilities = extern struct { // Frees array members of SurfaceCapabilities which were allocated by the API. pub inline fn freeMembers(self: SurfaceCapabilities) void { - wgpuSurfaceCapabilitiesFreeMembers(self); + raw.call(void, "wgpuSurfaceCapabilitiesFreeMembers", .{self}); } }; @@ -369,29 +364,9 @@ pub const SurfaceTexture = extern struct { status: GetCurrentTextureStatus, }; -pub const SurfaceProcs = struct { - pub const Configure = *const fn (*Surface, *const SurfaceConfiguration) callconv(.c) void; - pub const GetCapabilities = *const fn (*Surface, *Adapter, *SurfaceCapabilities) callconv(.c) Status; - pub const GetCurrentTexture = *const fn (*Surface, *SurfaceTexture) callconv(.c) void; - pub const Present = *const fn (*Surface) callconv(.c) Status; - pub const SetLabel = *const fn (*Surface, StringView) void; - pub const Unconfigure = *const fn (*Surface) callconv(.c) void; - pub const AddRef = *const fn (*Surface) callconv(.c) void; - pub const Release = *const fn (*Surface) callconv(.c) void; -}; - -extern fn wgpuSurfaceConfigure(surface: *Surface, config: *const SurfaceConfiguration) void; -extern fn wgpuSurfaceGetCapabilities(surface: *Surface, adapter: *Adapter, capabilities: *SurfaceCapabilities) Status; -extern fn wgpuSurfaceGetCurrentTexture(surface: *Surface, surface_texture: *SurfaceTexture) void; -extern fn wgpuSurfacePresent(surface: *Surface) Status; -extern fn wgpuSurfaceSetLabel(surface: *Surface, label: StringView) void; -extern fn wgpuSurfaceUnconfigure(surface: *Surface) void; -extern fn wgpuSurfaceAddRef(surface: *Surface) void; -extern fn wgpuSurfaceRelease(surface: *Surface) void; - pub const Surface = opaque { pub inline fn configure(self: *Surface, config: *const SurfaceConfiguration) void { - wgpuSurfaceConfigure(self, config); + raw.call(void, "wgpuSurfaceConfigure", .{ self, config }); } // Provides information on how `adapter` is able to use `surface`. @@ -406,7 +381,7 @@ pub const Surface = opaque { // Return value indicates if there was an OutStructChainError. // pub inline fn getCapabilities(self: *Surface, adapter: *Adapter, capabilities: *SurfaceCapabilities) Status { - return wgpuSurfaceGetCapabilities(self, adapter, capabilities); + return raw.call(Status, "wgpuSurfaceGetCapabilities", .{ self, adapter, capabilities }); } // Retrieves the Texture to render to `surface` this frame along with metadata on the frame. @@ -416,7 +391,7 @@ pub const Surface = opaque { // The structure to fill the Texture and metadata in. // pub inline fn getCurrentTexture(self: *Surface, surface_texture: *SurfaceTexture) void { - wgpuSurfaceGetCurrentTexture(self, surface_texture); + raw.call(void, "wgpuSurfaceGetCurrentTexture", .{ self, surface_texture }); } // Shows `surface`'s current texture to the user. @@ -424,7 +399,7 @@ pub const Surface = opaque { // Returns Status.@"error" if the surface doesn't have a current texture. // pub inline fn present(self: *Surface) Status { - return wgpuSurfacePresent(self); + return raw.call(Status, "wgpuSurfacePresent", .{self}); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -435,13 +410,13 @@ pub const Surface = opaque { // Removes the configuration for `surface`. pub inline fn unconfigure(self: *Surface) void { - wgpuSurfaceUnconfigure(self); + raw.call(void, "wgpuSurfaceUnconfigure", .{self}); } pub inline fn addRef(self: *Surface) void { - wgpuSurfaceAddRef(self); + raw.call(void, "wgpuSurfaceAddRef", .{self}); } pub inline fn release(self: *Surface) void { - wgpuSurfaceRelease(self); + raw.call(void, "wgpuSurfaceRelease", .{self}); } }; diff --git a/src/texture.zig b/src/texture.zig index 4629532..0de3e89 100644 --- a/src/texture.zig +++ b/src/texture.zig @@ -1,3 +1,4 @@ +const raw = @import("raw.zig"); const ChainedStruct = @import("chained_struct.zig").ChainedStruct; const _misc = @import("misc.zig"); @@ -185,16 +186,6 @@ pub const TextureComponentSwizzleDescriptor = extern struct { swizzle: TextureComponentSwizzle = .{}, }; -pub const TextureViewProcs = struct { - pub const SetLabel = *const fn (*TextureView, StringView) callconv(.c) void; - pub const AddRef = *const fn (*TextureView) callconv(.c) void; - pub const Release = *const fn (*TextureView) callconv(.c) void; -}; - -extern fn wgpuTextureViewSetLabel(texture_view: *TextureView, label: StringView) void; -extern fn wgpuTextureViewAddRef(texture_view: *TextureView) void; -extern fn wgpuTextureViewRelease(texture_view: *TextureView) void; - pub const TextureView = opaque { // Unimplemented as of wgpu-native v29.0.0.0, // see https://github.com/gfx-rs/wgpu-native/blob/d2e3330ade4ae1bb238d76b485926f067e7ee64c/src/unimplemented.rs @@ -203,10 +194,10 @@ pub const TextureView = opaque { // } pub inline fn addRef(self: *TextureView) void { - wgpuTextureViewAddRef(self); + raw.call(void, "wgpuTextureViewAddRef", .{self}); } pub inline fn release(self: *TextureView) void { - wgpuTextureViewRelease(self); + raw.call(void, "wgpuTextureViewRelease", .{self}); } }; @@ -294,66 +285,36 @@ pub const TextureDescriptor = extern struct { view_formats: [*]const TextureFormat = &[_]TextureFormat{}, }; -pub const TextureProcs = struct { - pub const CreateView = *const fn (*Texture, ?*const TextureViewDescriptor) callconv(.c) ?*TextureView; - pub const Destroy = *const fn (*Texture) callconv(.c) void; - pub const GetDepthOrArrayLayers = *const fn (*Texture) callconv(.c) u32; - pub const GetDimension = *const fn (*Texture) callconv(.c) TextureDimension; - pub const GetFormat = *const fn (*Texture) callconv(.c) TextureFormat; - pub const GetHeight = *const fn (*Texture) callconv(.c) u32; - pub const GetMipLevelCount = *const fn (*Texture) callconv(.c) u32; - pub const GetSampleCount = *const fn (*Texture) callconv(.c) u32; - pub const GetUsage = *const fn (*Texture) callconv(.c) TextureUsage; - pub const GetWidth = *const fn (*Texture) callconv(.c) u32; - pub const SetLabel = *const fn (*Texture, StringView) callconv(.c) void; - pub const AddRef = *const fn (*Texture) callconv(.c) void; - pub const Release = *const fn (*Texture) callconv(.c) void; -}; - -extern fn wgpuTextureCreateView(texture: *Texture, descriptor: ?*const TextureViewDescriptor) ?*TextureView; -extern fn wgpuTextureDestroy(texture: *Texture) void; -extern fn wgpuTextureGetDepthOrArrayLayers(texture: *Texture) u32; -extern fn wgpuTextureGetDimension(texture: *Texture) TextureDimension; -extern fn wgpuTextureGetFormat(texture: *Texture) TextureFormat; -extern fn wgpuTextureGetHeight(texture: *Texture) u32; -extern fn wgpuTextureGetMipLevelCount(texture: *Texture) u32; -extern fn wgpuTextureGetSampleCount(texture: *Texture) u32; -extern fn wgpuTextureGetUsage(texture: *Texture) TextureUsage; -extern fn wgpuTextureGetWidth(texture: *Texture) u32; -extern fn wgpuTextureSetLabel(texture: *Texture, label: StringView) void; -extern fn wgpuTextureAddRef(texture: *Texture) void; -extern fn wgpuTextureRelease(texture: *Texture) void; - pub const Texture = opaque { pub inline fn createView(self: *Texture, descriptor: ?*const TextureViewDescriptor) ?*TextureView { - return wgpuTextureCreateView(self, descriptor); + return raw.call(?*TextureView, "wgpuTextureCreateView", .{ self, descriptor }); } pub inline fn destroy(self: *Texture) void { - wgpuTextureDestroy(self); + raw.call(void, "wgpuTextureDestroy", .{self}); } pub inline fn getDepthOrArrayLayers(self: *Texture) u32 { - return wgpuTextureGetDepthOrArrayLayers(self); + return raw.call(u32, "wgpuTextureGetDepthOrArrayLayers", .{self}); } pub inline fn getDimension(self: *Texture) TextureDimension { - return wgpuTextureGetDimension(self); + return raw.call(TextureDimension, "wgpuTextureGetDimension", .{self}); } pub inline fn getFormat(self: *Texture) TextureFormat { - return wgpuTextureGetFormat(self); + return raw.call(TextureFormat, "wgpuTextureGetFormat", .{self}); } pub inline fn getHeight(self: *Texture) u32 { - return wgpuTextureGetHeight(self); + return raw.call(u32, "wgpuTextureGetHeight", .{self}); } pub inline fn getMipLevelCount(self: *Texture) u32 { - return wgpuTextureGetMipLevelCount(self); + return raw.call(u32, "wgpuTextureGetMipLevelCount", .{self}); } pub inline fn getSampleCount(self: *Texture) u32 { - return wgpuTextureGetSampleCount(self); + return raw.call(u32, "wgpuTextureGetSampleCount", .{self}); } pub inline fn getUsage(self: *Texture) TextureUsage { - return wgpuTextureGetUsage(self); + return raw.call(TextureUsage, "wgpuTextureGetUsage", .{self}); } pub inline fn getWidth(self: *Texture) u32 { - return wgpuTextureGetWidth(self); + return raw.call(u32, "wgpuTextureGetWidth", .{self}); } // Unimplemented as of wgpu-native v29.0.0.0, @@ -363,10 +324,10 @@ pub const Texture = opaque { // } pub inline fn addRef(self: *Texture) void { - wgpuTextureAddRef(self); + raw.call(void, "wgpuTextureAddRef", .{self}); } pub inline fn release(self: *Texture) void { - wgpuTextureRelease(self); + raw.call(void, "wgpuTextureRelease", .{self}); } }; diff --git a/tests/abi.zig b/tests/abi.zig index e10f274..5e99d9e 100644 --- a/tests/abi.zig +++ b/tests/abi.zig @@ -47,6 +47,23 @@ fn isEnumConstant( return false; } +test "all wrapper methods compile against the C headers" { + comptime { + @setEvalBranchQuota(10_000_000); + for (std.meta.declarations(wgpu)) |declaration| { + if (std.mem.eql(u8, declaration.name, "raw")) continue; + + const value = @field(wgpu, declaration.name); + if (@TypeOf(value) != type) continue; + switch (@typeInfo(value)) { + .@"struct", .@"union", .@"enum", .@"opaque" => {}, + else => continue, + } + std.testing.refAllDecls(value); + } + } +} + test "pure Zig structs match the C ABI" { comptime { @setEvalBranchQuota(10_000_000); diff --git a/tests/build.zig b/tests/build.zig index 5b6806f..8e89e0b 100644 --- a/tests/build.zig +++ b/tests/build.zig @@ -45,6 +45,7 @@ fn unitTests( ) void { const unit_test_step = b.step("test", "Run unit tests"); const test_files = [_][:0]const u8{ + "src/raw.zig", "src/instance.zig", "src/adapter.zig", "src/pipeline.zig", @@ -60,6 +61,7 @@ fn unitTests( .target = library.target, .optimize = library.optimize, }); + test_mod.addImport("wgpu-header", library.wgpu_c_mod); library.linkTestModule(b, test_mod); const test_exe = b.addTest(.{ .name = test_name,