gpu: correct implementation invocations

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

gpu/src/adapter.zig

@@ -5,40 +5,40 @@ const DeviceDescriptor = @import("device.zig").DeviceDescriptor;
 const FeatureName = @import("types.zig").FeatureName;
 const SupportedLimits = @import("types.zig").SupportedLimits;
 const RequestDeviceStatus = @import("types.zig").RequestDeviceStatus;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Adapter = *opaque {
     pub inline fn createDevice(adapter: Adapter, descriptor: ?*const DeviceDescriptor) ?Device {
-        return impl.createDevice(adapter, descriptor);
+        return Impl.createDevice(adapter, descriptor);
     }
 
     /// Call once with null to determine the array length, and again to fetch the feature list.
     pub inline fn enumerateFeatures(adapter: Adapter, features: ?[*]FeatureName) usize {
-        return impl.adapterEnumerateFeatures(adapter, features);
+        return Impl.adapterEnumerateFeatures(adapter, features);
     }
 
     pub inline fn getLimits(adapter: Adapter, limits: *SupportedLimits) bool {
-        return impl.adapterGetLimits(adapter, limits);
+        return Impl.adapterGetLimits(adapter, limits);
     }
 
     pub inline fn getProperties(adapter: Adapter, properties: *AdapterProperties) void {
-        impl.adapterGetProperties(adapter, properties);
+        Impl.adapterGetProperties(adapter, properties);
     }
 
     pub inline fn hasFeature(adapter: Adapter, feature: FeatureName) bool {
-        return impl.adapterHasFeature(adapter, feature);
+        return Impl.adapterHasFeature(adapter, feature);
     }
 
     pub inline fn requestDevice(adapter: Adapter, descriptor: ?*const DeviceDescriptor, callback: RequestDeviceCallback, userdata: *anyopaque) void {
-        impl.adapterRequestDevice(adapter, descriptor, callback, userdata);
+        Impl.adapterRequestDevice(adapter, descriptor, callback, userdata);
     }
 
     pub inline fn reference(adapter: Adapter) void {
-        impl.adapterReference(adapter);
+        Impl.adapterReference(adapter);
     }
 
     pub inline fn release(adapter: Adapter) void {
-        impl.adapterRelease(adapter);
+        Impl.adapterRelease(adapter);
     }
 };
 

gpu/src/bind_group.zig

@@ -3,19 +3,19 @@ const Sampler = @import("sampler.zig").Sampler;
 const TextureView = @import("texture_view.zig").TextureView;
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const BindGroupLayout = @import("bind_group_layout.zig").BindGroupLayout;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const BindGroup = *opaque {
     pub inline fn setLabel(bind_group: BindGroup, label: [*:0]const u8) void {
-        impl.bindGroupSetLabel(bind_group, label);
+        Impl.bindGroupSetLabel(bind_group, label);
     }
 
     pub inline fn reference(bind_group: BindGroup) void {
-        impl.bindGroupReference(bind_group);
+        Impl.bindGroupReference(bind_group);
     }
 
     pub inline fn release(bind_group: BindGroup) void {
-        impl.bindGroupRelease(bind_group);
+        Impl.bindGroupRelease(bind_group);
     }
 };
 

gpu/src/bind_group_layout.zig

@@ -7,19 +7,19 @@ const SamplerBindingLayout = @import("sampler.zig").SamplerBindingLayout;
 const Texture = @import("texture.zig").Texture;
 const TextureBindingLayout = @import("texture.zig").TextureBindingLayout;
 const StorageTextureBindingLayout = @import("types.zig").StorageTextureBindingLayout;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const BindGroupLayout = *opaque {
     pub inline fn setLabel(bind_group_layout: BindGroupLayout, label: [*:0]const u8) void {
-        impl.bindGroupLayoutSetLabel(bind_group_layout, label);
+        Impl.bindGroupLayoutSetLabel(bind_group_layout, label);
     }
 
     pub inline fn reference(bind_group_layout: BindGroupLayout) void {
-        impl.bindGroupLayoutReference(bind_group_layout);
+        Impl.bindGroupLayoutReference(bind_group_layout);
     }
 
     pub inline fn release(bind_group_layout: BindGroupLayout) void {
-        impl.bindGroupLayoutRelease(bind_group_layout);
+        Impl.bindGroupLayoutRelease(bind_group_layout);
     }
 };
 

gpu/src/buffer.zig

@@ -1,47 +1,47 @@
 const std = @import("std");
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const MapModeFlags = @import("types.zig").MapModeFlags;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Buffer = *opaque {
     pub inline fn destroy(buffer: Buffer) void {
-        impl.bufferDestroy(buffer);
+        Impl.bufferDestroy(buffer);
     }
 
     pub inline fn bufferGetConstMappedRange(buffer: Buffer, offset: usize, size: usize) ?*const anyopaque {
-        return impl.bufferGetConstMappedRange(buffer, offset, size);
+        return Impl.bufferGetConstMappedRange(buffer, offset, size);
     }
 
     pub inline fn bufferGetMappedRange(buffer: Buffer, offset: usize, size: usize) ?*anyopaque {
-        return impl.bufferGetMappedRange(buffer, offset, size);
+        return Impl.bufferGetMappedRange(buffer, offset, size);
     }
 
     pub inline fn bufferGetSize(buffer: Buffer) u64 {
-        return impl.bufferGetSize(buffer);
+        return Impl.bufferGetSize(buffer);
     }
 
     pub inline fn bufferGetUsage(buffer: Buffer) BufferUsage {
-        return impl.bufferGetUsage(buffer);
+        return Impl.bufferGetUsage(buffer);
     }
 
     pub inline fn bufferMapAsync(buffer: Buffer, mode: MapModeFlags, offset: usize, size: usize, callback: BufferMapCallback, userdata: *anyopaque) void {
-        impl.bufferMapAsync(buffer, mode, offset, size, callback, userdata);
+        Impl.bufferMapAsync(buffer, mode, offset, size, callback, userdata);
     }
 
     pub inline fn bufferSetLabel(buffer: Buffer, label: [*:0]const u8) void {
-        impl.bufferSetLabel(buffer, label);
+        Impl.bufferSetLabel(buffer, label);
     }
 
     pub inline fn bufferUnmap(buffer: Buffer) void {
-        impl.bufferUnmap(buffer);
+        Impl.bufferUnmap(buffer);
     }
 
     pub inline fn bufferReference(buffer: Buffer) void {
-        impl.bufferReference(buffer);
+        Impl.bufferReference(buffer);
     }
 
     pub inline fn bufferRelease(buffer: Buffer) void {
-        impl.bufferRelease(buffer);
+        Impl.bufferRelease(buffer);
     }
 };
 

gpu/src/command_buffer.zig

@@ -1,17 +1,17 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const CommandBuffer = *opaque {
     pub inline fn setLabel(command_buffer: CommandBuffer, label: [*:0]const u8) void {
-        impl.commandBufferSetLabel(command_buffer, label);
+        Impl.commandBufferSetLabel(command_buffer, label);
     }
 
     pub inline fn reference(command_buffer: CommandBuffer) void {
-        impl.commandBufferReference(command_buffer);
+        Impl.commandBufferReference(command_buffer);
     }
 
     pub inline fn release(command_buffer: CommandBuffer) void {
-        impl.commandBufferRelease(command_buffer);
+        Impl.commandBufferRelease(command_buffer);
     }
 };
 

gpu/src/command_encoder.zig

@@ -10,85 +10,85 @@ const ChainedStruct = @import("types.zig").ChainedStruct;
 const ImageCopyBuffer = @import("types.zig").ImageCopyBuffer;
 const ImageCopyTexture = @import("types.zig").ImageCopyTexture;
 const Extent3D = @import("types.zig").Extent3D;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const CommandEncoder = *opaque {
     pub inline fn beginComputePass(command_encoder: CommandEncoder, descriptor: ?*const ComputePassDescriptor) ComputePassEncoder {
-        return impl.commandEncoderBeginComputePass(command_encoder, descriptor);
+        return Impl.commandEncoderBeginComputePass(command_encoder, descriptor);
     }
 
     pub inline fn beginRenderPass(command_encoder: CommandEncoder, descriptor: *const RenderPassDescriptor) RenderPassEncoder {
-        return impl.commandEncoderBeginRenderPass(command_encoder, descriptor);
+        return Impl.commandEncoderBeginRenderPass(command_encoder, descriptor);
     }
 
     pub inline fn clearBuffer(command_encoder: CommandEncoder, buffer: Buffer, offset: u64, size: u64) void {
-        impl.commandEncoderClearBuffer(command_encoder, buffer, offset, size);
+        Impl.commandEncoderClearBuffer(command_encoder, buffer, offset, size);
     }
 
     pub inline fn copyBufferToBuffer(command_encoder: CommandEncoder, source: Buffer, source_offset: u64, destination: Buffer, destination_offset: u64, size: u64) void {
-        impl.commandEncoderCopyBufferToBuffer(command_encoder, source, source_offset, destination, destination_offset, size);
+        Impl.commandEncoderCopyBufferToBuffer(command_encoder, source, source_offset, destination, destination_offset, size);
     }
 
     pub inline fn copyBufferToTexture(command_encoder: CommandEncoder, source: *const ImageCopyBuffer, destination: *const ImageCopyTexture, copy_size: *const Extent3D) void {
-        impl.commandEncoderCopyBufferToTexture(command_encoder, source, destination, copy_size);
+        Impl.commandEncoderCopyBufferToTexture(command_encoder, source, destination, copy_size);
     }
 
     pub inline fn copyTextureToBuffer(command_encoder: CommandEncoder, source: *const ImageCopyTexture, destination: *const ImageCopyBuffer, copy_size: *const Extent3D) void {
-        impl.commandEncoderCopyTextureToBuffer(command_encoder, source, destination, copy_size);
+        Impl.commandEncoderCopyTextureToBuffer(command_encoder, source, destination, copy_size);
     }
 
     pub inline fn copyTextureToTexture(command_encoder: CommandEncoder, source: *const ImageCopyTexture, destination: *const ImageCopyTexture, copy_size: *const Extent3D) void {
-        impl.commandEncoderCopyTextureToTexture(command_encoder, source, destination, copy_size);
+        Impl.commandEncoderCopyTextureToTexture(command_encoder, source, destination, copy_size);
     }
 
     // Note: the only difference between this and the non-internal variant is that this one checks
     // internal usage.
     pub inline fn copyTextureToTextureInternal(command_encoder: CommandEncoder, source: *const ImageCopyTexture, destination: *const ImageCopyTexture, copy_size: *const Extent3D) void {
-        impl.commandEncoderCopyTextureToTextureInternal(command_encoder, source, destination, copy_size);
+        Impl.commandEncoderCopyTextureToTextureInternal(command_encoder, source, destination, copy_size);
     }
 
     pub inline fn finish(command_encoder: CommandEncoder, descriptor: ?*const CommandBufferDescriptor) CommandBuffer {
-        return impl.commandEncoderFinish(command_encoder, descriptor);
+        return Impl.commandEncoderFinish(command_encoder, descriptor);
     }
 
     pub inline fn injectValidationError(command_encoder: CommandEncoder, message: [*:0]const u8) void {
-        impl.commandEncoderInjectValidationError(command_encoder, message);
+        Impl.commandEncoderInjectValidationError(command_encoder, message);
     }
 
     pub inline fn insertDebugMarker(command_encoder: CommandEncoder, marker_label: [*:0]const u8) void {
-        impl.commandEncoderInsertDebugMarker(command_encoder, marker_label);
+        Impl.commandEncoderInsertDebugMarker(command_encoder, marker_label);
     }
 
     pub inline fn popDebugGroup(command_encoder: CommandEncoder) void {
-        impl.commandEncoderPopDebugGroup(command_encoder);
+        Impl.commandEncoderPopDebugGroup(command_encoder);
     }
 
     pub inline fn pushDebugGroup(command_encoder: CommandEncoder, group_label: [*:0]const u8) void {
-        impl.commandEncoderPushDebugGroup(command_encoder, group_label);
+        Impl.commandEncoderPushDebugGroup(command_encoder, group_label);
     }
 
     pub inline fn resolveQuerySet(command_encoder: CommandEncoder, query_set: QuerySet, first_query: u32, query_count: u32, destination: Buffer, destination_offset: u64) void {
-        impl.commandEncoderResolveQuerySet(command_encoder, query_set, first_query, query_count, destination, destination_offset);
+        Impl.commandEncoderResolveQuerySet(command_encoder, query_set, first_query, query_count, destination, destination_offset);
     }
 
     pub inline fn setLabel(command_encoder: CommandEncoder, label: [*:0]const u8) void {
-        impl.commandEncoderSetLabel(command_encoder, label);
+        Impl.commandEncoderSetLabel(command_encoder, label);
     }
 
     pub inline fn writeBuffer(command_encoder: CommandEncoder, buffer: Buffer, buffer_offset: u64, data: [*]const u8, size: u64) void {
-        impl.commandEncoderWriteBuffer(command_encoder, buffer, buffer_offset, data, size);
+        Impl.commandEncoderWriteBuffer(command_encoder, buffer, buffer_offset, data, size);
     }
 
     pub inline fn writeTimestamp(command_encoder: CommandEncoder, query_set: QuerySet, query_index: u32) void {
-        impl.commandEncoderWriteTimestamp(command_encoder, query_set, query_index);
+        Impl.commandEncoderWriteTimestamp(command_encoder, query_set, query_index);
     }
 
     pub inline fn reference(command_encoder: CommandEncoder) void {
-        impl.commandEncoderReference(command_encoder);
+        Impl.commandEncoderReference(command_encoder);
     }
 
     pub inline fn release(command_encoder: CommandEncoder) void {
-        impl.commandEncoderRelease(command_encoder);
+        Impl.commandEncoderRelease(command_encoder);
     }
 };
 

gpu/src/compute_pass_encoder.zig

@@ -1,66 +1,66 @@
 const Buffer = @import("buffer.zig").Buffer;
 const BindGroup = @import("bind_group.zig").BindGroup;
 const ComputePipeline = @import("compute_pipeline.zig").ComputePipeline;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const ComputePassEncoder = *opaque {
     pub inline fn dispatch(compute_pass_encoder: ComputePassEncoder, workgroup_count_x: u32, workgroup_count_y: u32, workgroup_count_z: u32) void {
-        impl.computePassEncoderDispatch(compute_pass_encoder, workgroup_count_x, workgroup_count_y, workgroup_count_z);
+        Impl.computePassEncoderDispatch(compute_pass_encoder, workgroup_count_x, workgroup_count_y, workgroup_count_z);
     }
 
     pub inline fn dispatchIndirect(compute_pass_encoder: ComputePassEncoder, indirect_buffer: Buffer, indirect_offset: u64) void {
-        impl.computePassEncoderDispatchIndirect(compute_pass_encoder, indirect_buffer, indirect_offset);
+        Impl.computePassEncoderDispatchIndirect(compute_pass_encoder, indirect_buffer, indirect_offset);
     }
 
     pub inline fn dispatchWorkgroups(compute_pass_encoder: ComputePassEncoder, workgroup_count_x: u32, workgroup_count_y: u32, workgroup_count_z: u32) void {
-        impl.computePassEncoderDispatchWorkgroups(compute_pass_encoder, workgroup_count_x, workgroup_count_y, workgroup_count_z);
+        Impl.computePassEncoderDispatchWorkgroups(compute_pass_encoder, workgroup_count_x, workgroup_count_y, workgroup_count_z);
     }
 
     pub inline fn dispatchWorkgroupsIndirect(compute_pass_encoder: ComputePassEncoder, indirect_buffer: Buffer, indirect_offset: u64) void {
-        impl.computePassEncoderDispatchWorkgroupsIndirect(compute_pass_encoder, indirect_buffer, indirect_offset);
+        Impl.computePassEncoderDispatchWorkgroupsIndirect(compute_pass_encoder, indirect_buffer, indirect_offset);
     }
 
     pub inline fn end(compute_pass_encoder: ComputePassEncoder) void {
-        impl.computePassEncoderEnd(compute_pass_encoder);
+        Impl.computePassEncoderEnd(compute_pass_encoder);
     }
 
     pub inline fn endPass(compute_pass_encoder: ComputePassEncoder) void {
-        impl.computePassEncoderEndPass(compute_pass_encoder);
+        Impl.computePassEncoderEndPass(compute_pass_encoder);
     }
 
     pub inline fn insertDebugMarker(compute_pass_encoder: ComputePassEncoder, marker_label: [*:0]const u8) void {
-        impl.computePassEncoderInsertDebugMarker(compute_pass_encoder, marker_label);
+        Impl.computePassEncoderInsertDebugMarker(compute_pass_encoder, marker_label);
     }
 
     pub inline fn popDebugGroup(compute_pass_encoder: ComputePassEncoder) void {
-        impl.computePassEncoderPopDebugGroup(compute_pass_encoder);
+        Impl.computePassEncoderPopDebugGroup(compute_pass_encoder);
     }
 
     pub inline fn pushDebugGroup(compute_pass_encoder: ComputePassEncoder, group_label: [*:0]const u8) void {
-        impl.computePassEncoderPushDebugGroup(compute_pass_encoder, group_label);
+        Impl.computePassEncoderPushDebugGroup(compute_pass_encoder, group_label);
     }
 
     pub inline fn setBindGroup(compute_pass_encoder: ComputePassEncoder, group_index: u32, group: BindGroup, dynamic_offset_count: u32, dynamic_offsets: [*]const u32) void {
-        impl.computePassEncoderSetBindGroup(compute_pass_encoder, group_index, group, dynamic_offset_count, dynamic_offsets);
+        Impl.computePassEncoderSetBindGroup(compute_pass_encoder, group_index, group, dynamic_offset_count, dynamic_offsets);
     }
 
     pub inline fn setLabel(compute_pass_encoder: ComputePassEncoder, label: [*:0]const u8) void {
-        impl.computePassEncoderSetLabel(compute_pass_encoder, label);
+        Impl.computePassEncoderSetLabel(compute_pass_encoder, label);
     }
 
     pub inline fn setPipeline(compute_pass_encoder: ComputePassEncoder, pipeline: ComputePipeline) void {
-        impl.computePassEncoderSetPipeline(compute_pass_encoder, pipeline);
+        Impl.computePassEncoderSetPipeline(compute_pass_encoder, pipeline);
     }
 
     pub inline fn writeTimestamp(compute_pass_encoder: ComputePassEncoder, pipeline: ComputePipeline) void {
-        impl.computePassEncoderWriteTimestamp(compute_pass_encoder, pipeline);
+        Impl.computePassEncoderWriteTimestamp(compute_pass_encoder, pipeline);
     }
 
     pub inline fn reference(compute_pass_encoder: ComputePassEncoder) void {
-        impl.computePassEncoderReference(compute_pass_encoder);
+        Impl.computePassEncoderReference(compute_pass_encoder);
     }
 
     pub inline fn release(compute_pass_encoder: ComputePassEncoder) void {
-        impl.computePassEncoderRelease(compute_pass_encoder);
+        Impl.computePassEncoderRelease(compute_pass_encoder);
     }
 };

gpu/src/compute_pipeline.zig

@@ -2,23 +2,23 @@ const ChainedStruct = @import("types.zig").ChainedStruct;
 const ProgrammableStageDescriptor = @import("types.zig").ProgrammableStageDescriptor;
 const PipelineLayout = @import("pipeline_layout.zig").PipelineLayout;
 const BindGroupLayout = @import("bind_group_layout.zig").BindGroupLayout;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const ComputePipeline = *opaque {
     pub inline fn getBindGroupLayout(compute_pipeline: ComputePipeline, group_index: u32) BindGroupLayout {
-        return impl.computePipelineGetBindGroupLayout(compute_pipeline, group_index);
+        return Impl.computePipelineGetBindGroupLayout(compute_pipeline, group_index);
     }
 
     pub inline fn setLabel(compute_pipeline: ComputePipeline, label: [*:0]const u8) void {
-        impl.computePipelineSetLabel(compute_pipeline, label);
+        Impl.computePipelineSetLabel(compute_pipeline, label);
     }
 
     pub inline fn reference(compute_pipeline: ComputePipeline) void {
-        impl.computePipelineReference(compute_pipeline);
+        Impl.computePipelineReference(compute_pipeline);
     }
 
     pub inline fn release(compute_pipeline: ComputePipeline) void {
-        impl.computePipelineRelease(compute_pipeline);
+        Impl.computePipelineRelease(compute_pipeline);
     }
 };
 

gpu/src/device.zig

@@ -39,143 +39,143 @@ const ErrorCallback = @import("types.zig").ErrorCallback;
 const LoggingCallback = @import("types.zig").LoggingCallback;
 const CreateComputePipelineAsyncCallback = @import("types.zig").CreateComputePipelineAsyncCallback;
 const CreateRenderPipelineAsyncCallback = @import("types.zig").CreateRenderPipelineAsyncCallback;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Device = *opaque {
     pub inline fn createBindGroup(device: Device, descriptor: *const BindGroupDescriptor) BindGroup {
-        return impl.deviceCreateBindGroup(device, descriptor);
+        return Impl.deviceCreateBindGroup(device, descriptor);
     }
 
     pub inline fn createBindGroupLayout(device: Device, descriptor: *const BindGroupLayoutDescriptor) BindGroupLayout {
-        return impl.deviceCreateBindGroupLayout(device, descriptor);
+        return Impl.deviceCreateBindGroupLayout(device, descriptor);
     }
 
     pub inline fn createBuffer(device: Device, descriptor: *const BufferDescriptor) Buffer {
-        return impl.deviceCreateBuffer(device, descriptor);
+        return Impl.deviceCreateBuffer(device, descriptor);
     }
 
     pub inline fn createCommandEncoder(device: Device, descriptor: ?*const CommandEncoderDescriptor) CommandEncoder {
-        return impl.deviceCreateCommandEncoder(device, descriptor);
+        return Impl.deviceCreateCommandEncoder(device, descriptor);
     }
 
     pub inline fn createComputePipeline(device: Device, descriptor: *const ComputePipelineDescriptor) ComputePipeline {
-        return impl.deviceCreateComputePipeline(device, descriptor);
+        return Impl.deviceCreateComputePipeline(device, descriptor);
     }
 
     pub inline fn createComputePipelineAsync(device: Device, descriptor: *const ComputePipelineDescriptor, callback: CreateComputePipelineAsyncCallback, userdata: *anyopaque) void {
-        impl.deviceCreateComputePipelineAsync(device, descriptor, callback, userdata);
+        Impl.deviceCreateComputePipelineAsync(device, descriptor, callback, userdata);
     }
 
     pub inline fn createErrorBuffer(device: Device) Buffer {
-        return impl.deviceCreateErrorBuffer(device);
+        return Impl.deviceCreateErrorBuffer(device);
     }
 
     pub inline fn createErrorExternalTexture(device: Device) ExternalTexture {
-        return impl.deviceCreateErrorExternalTexture(device);
+        return Impl.deviceCreateErrorExternalTexture(device);
     }
 
     pub inline fn createExternalTexture(device: Device, external_texture_descriptor: *const ExternalTextureDescriptor) ExternalTexture {
-        return impl.deviceCreateExternalTexture(device, external_texture_descriptor);
+        return Impl.deviceCreateExternalTexture(device, external_texture_descriptor);
     }
 
     pub inline fn createPipelineLayout(device: Device, pipeline_layout_descriptor: *const PipelineLayoutDescriptor) PipelineLayout {
-        return impl.deviceCreatePipelineLayout(device, pipeline_layout_descriptor);
+        return Impl.deviceCreatePipelineLayout(device, pipeline_layout_descriptor);
     }
 
     pub inline fn createQuerySet(device: Device, descriptor: *const QuerySetDescriptor) QuerySet {
-        return impl.deviceCreateQuerySet(device, descriptor);
+        return Impl.deviceCreateQuerySet(device, descriptor);
     }
 
     pub inline fn createRenderBundleEncoder(device: Device, descriptor: *const RenderBundleEncoderDescriptor) RenderBundleEncoder {
-        return impl.deviceCreateRenderBundleEncoder(device, descriptor);
+        return Impl.deviceCreateRenderBundleEncoder(device, descriptor);
     }
 
     pub inline fn createRenderPipeline(device: Device, descriptor: *const RenderPipelineDescriptor) RenderPipeline {
-        return impl.deviceCreateRenderPipeline(device, descriptor);
+        return Impl.deviceCreateRenderPipeline(device, descriptor);
     }
 
     pub inline fn createRenderPipelineAsync(device: Device, descriptor: *const RenderPipelineDescriptor, callback: CreateRenderPipelineAsyncCallback, userdata: *anyopaque) void {
-        impl.deviceCreateRenderPipelineAsync(device, descriptor, callback, userdata);
+        Impl.deviceCreateRenderPipelineAsync(device, descriptor, callback, userdata);
     }
 
     pub inline fn createSampler(device: Device, descriptor: ?*const SamplerDescriptor) Sampler {
-        return impl.deviceCreateSampler(device, descriptor);
+        return Impl.deviceCreateSampler(device, descriptor);
     }
 
     pub inline fn createShaderModule(device: Device, descriptor: *const ShaderModuleDescriptor) ShaderModule {
-        return impl.deviceCreateShaderModule(device, descriptor);
+        return Impl.deviceCreateShaderModule(device, descriptor);
     }
 
     pub inline fn createSwapChain(device: Device, surface: ?Surface, descriptor: *const SwapChainDescriptor) SwapChain {
-        return impl.deviceCreateSwapChain(device, surface, descriptor);
+        return Impl.deviceCreateSwapChain(device, surface, descriptor);
     }
 
     pub inline fn createTexture(device: Device, descriptor: *const TextureDescriptor) Texture {
-        return impl.deviceCreateTexture(device, descriptor);
+        return Impl.deviceCreateTexture(device, descriptor);
     }
 
     pub inline fn destroy(device: Device) void {
-        impl.deviceDestroy(device);
+        Impl.deviceDestroy(device);
     }
 
     pub inline fn enumerateFeatures(device: Device, features: [*]FeatureName) usize {
-        return impl.deviceEnumerateFeatures(device, features);
+        return Impl.deviceEnumerateFeatures(device, features);
     }
 
     pub inline fn getLimits(device: Device, limits: *SupportedLimits) bool {
-        return impl.deviceGetLimits(device, limits);
+        return Impl.deviceGetLimits(device, limits);
     }
 
     pub inline fn getQueue(device: Device) Queue {
-        return impl.deviceGetQueue(device);
+        return Impl.deviceGetQueue(device);
     }
 
     pub inline fn hasFeature(device: Device, feature: FeatureName) bool {
-        return impl.deviceHasFeature(device, feature);
+        return Impl.deviceHasFeature(device, feature);
     }
 
     pub inline fn injectError(device: Device, typ: ErrorType, message: [*:0]const u8) void {
-        impl.deviceInjectError(device, typ, message);
+        Impl.deviceInjectError(device, typ, message);
     }
 
     pub inline fn loseForTesting(device: Device) void {
-        impl.deviceLoseForTesting(device);
+        Impl.deviceLoseForTesting(device);
     }
 
     pub inline fn popErrorScope(device: Device, callback: ErrorCallback, userdata: *anyopaque) bool {
-        return impl.devicePopErrorScope(device, callback, userdata);
+        return Impl.devicePopErrorScope(device, callback, userdata);
     }
 
     pub inline fn pushErrorScope(device: Device, filter: ErrorFilter) void {
-        impl.devicePushErrorScope(device, filter);
+        Impl.devicePushErrorScope(device, filter);
     }
 
     pub inline fn setDeviceLostCallback(device: Device, callback: DeviceLostCallback, userdata: *anyopaque) void {
-        impl.deviceSetDeviceLostCallback(device, callback, userdata);
+        Impl.deviceSetDeviceLostCallback(device, callback, userdata);
     }
 
     pub inline fn setLabel(device: Device, label: [*:0]const u8) void {
-        impl.deviceSetLabel(device, label);
+        Impl.deviceSetLabel(device, label);
     }
 
     pub inline fn setLoggingCallback(device: Device, callback: LoggingCallback, userdata: *anyopaque) void {
-        impl.deviceSetLoggingCallback(device, callback, userdata);
+        Impl.deviceSetLoggingCallback(device, callback, userdata);
     }
 
     pub inline fn setUncapturedErrorCallback(device: Device, callback: ErrorCallback, userdata: *anyopaque) void {
-        impl.deviceSetUncapturedErrorCallback(device, callback, userdata);
+        Impl.deviceSetUncapturedErrorCallback(device, callback, userdata);
     }
 
     pub inline fn tick(device: Device) void {
-        impl.deviceTick(device);
+        Impl.deviceTick(device);
     }
 
     pub inline fn reference(device: Device) void {
-        impl.deviceReference(device);
+        Impl.deviceReference(device);
     }
 
     pub inline fn release(device: Device) void {
-        impl.deviceRelease(device);
+        Impl.deviceRelease(device);
     }
 };
 

gpu/src/external_texture.zig

@@ -1,22 +1,22 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const TextureView = @import("texture_view.zig").TextureView;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const ExternalTexture = *opaque {
     pub inline fn destroy(external_texture: ExternalTexture) void {
-        impl.externalTextureDestroy(external_texture);
+        Impl.externalTextureDestroy(external_texture);
     }
 
     pub inline fn setLabel(external_texture: ExternalTexture, label: [*:0]const u8) void {
-        impl.externalTextureSetLabel(external_texture, label);
+        Impl.externalTextureSetLabel(external_texture, label);
     }
 
     pub inline fn reference(external_texture: ExternalTexture) void {
-        impl.externalTextureReference(external_texture);
+        Impl.externalTextureReference(external_texture);
     }
 
     pub inline fn release(external_texture: ExternalTexture) void {
-        impl.externalTextureRelease(external_texture);
+        Impl.externalTextureRelease(external_texture);
     }
 };
 

gpu/src/instance.zig

@@ -4,23 +4,23 @@ const Surface = @import("surface.zig").Surface;
 const SurfaceDescriptor = @import("surface.zig").SurfaceDescriptor;
 const Adapter = @import("adapter.zig").Adapter;
 const RequestAdapterOptions = @import("main.zig").RequestAdapterOptions;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Instance = *opaque {
     pub inline fn createSurface(instance: Instance, descriptor: *const SurfaceDescriptor) Surface {
-        return impl.instanceCreateSurface(instance, descriptor);
+        return Impl.instanceCreateSurface(instance, descriptor);
     }
 
     pub inline fn requestAdapter(instance: Instance, options: *const RequestAdapterOptions, callback: RequestAdapterCallback, userdata: *anyopaque) void {
-        impl.instanceRequestAdapter(instance, options, callback, userdata);
+        Impl.instanceRequestAdapter(instance, options, callback, userdata);
     }
 
     pub inline fn reference(instance: Instance) void {
-        impl.instanceReference(instance);
+        Impl.instanceReference(instance);
     }
 
     pub inline fn release(instance: Instance) void {
-        impl.instanceRelease(instance);
+        Impl.instanceRelease(instance);
     }
 };
 

gpu/src/pipeline_layout.zig

@@ -1,18 +1,18 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const BindGroupLayout = @import("bind_group_layout.zig").BindGroupLayout;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const PipelineLayout = *opaque {
     pub inline fn setLabel(pipeline_layout: PipelineLayout, label: [*:0]const u8) void {
-        impl.pipelineLayoutSetLabel(pipeline_layout, label);
+        Impl.pipelineLayoutSetLabel(pipeline_layout, label);
     }
 
     pub inline fn reference(pipeline_layout: PipelineLayout) void {
-        impl.pipelineLayoutReference(pipeline_layout);
+        Impl.pipelineLayoutReference(pipeline_layout);
     }
 
     pub inline fn release(pipeline_layout: PipelineLayout) void {
-        impl.pipelineLayoutRelease(pipeline_layout);
+        Impl.pipelineLayoutRelease(pipeline_layout);
     }
 };
 

gpu/src/query_set.zig

@@ -1,31 +1,31 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const PipelineStatisticName = @import("types.zig").PipelineStatisticName;
 const QueryType = @import("types.zig").QueryType;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const QuerySet = *opaque {
     pub inline fn destroy(query_set: QuerySet) void {
-        impl.querySetDestroy(query_set);
+        Impl.querySetDestroy(query_set);
     }
 
     pub inline fn getCount(query_set: QuerySet) u32 {
-        return impl.querySetGetCount(query_set);
+        return Impl.querySetGetCount(query_set);
     }
 
     pub inline fn getType(query_set: QuerySet) QueryType {
-        return impl.querySetGetType(query_set);
+        return Impl.querySetGetType(query_set);
     }
 
     pub inline fn setLabel(query_set: QuerySet, label: [*:0]const u8) void {
-        impl.querySetSetLabel(query_set, label);
+        Impl.querySetSetLabel(query_set, label);
     }
 
     pub inline fn reference(query_set: QuerySet) void {
-        impl.querySetReference(query_set);
+        Impl.querySetReference(query_set);
     }
 
     pub inline fn release(query_set: QuerySet) void {
-        impl.querySetRelease(query_set);
+        Impl.querySetRelease(query_set);
     }
 };
 

gpu/src/queue.zig

@@ -5,39 +5,39 @@ const ImageCopyTexture = @import("types.zig").ImageCopyTexture;
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const Extent3D = @import("types.zig").Extent3D;
 const CopyTextureForBrowserOptions = @import("types.zig").CopyTextureForBrowserOptions;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Queue = *opaque {
     pub inline fn copyTextureForBrowser(queue: Queue, source: *const ImageCopyTexture, destination: *const ImageCopyTexture, copy_size: *const Extent3D, options: *const CopyTextureForBrowserOptions) void {
-        impl.queueCopyTextureForBrowser(queue, source, destination, copy_size, options);
+        Impl.queueCopyTextureForBrowser(queue, source, destination, copy_size, options);
     }
 
     pub inline fn onSubmittedWorkDone(queue: Queue, signal_value: u64, callback: QueueWorkDoneCallback, userdata: *anyopaque) void {
-        impl.queueOnSubmittedWorkDone(queue, signal_value, callback, userdata);
+        Impl.queueOnSubmittedWorkDone(queue, signal_value, callback, userdata);
     }
 
     pub inline fn setLabel(queue: Queue, label: [*:0]const u8) void {
-        impl.queueSetLabel(queue, label);
+        Impl.queueSetLabel(queue, label);
     }
 
     pub inline fn submit(queue: Queue, command_count: u32, commands: [*]CommandBuffer) void {
-        impl.queueSubmit(queue, command_count, commands);
+        Impl.queueSubmit(queue, command_count, commands);
     }
 
     pub inline fn writeBuffer(queue: Queue, buffer: Buffer, buffer_offset: u64, data: *anyopaque, size: usize) void {
-        impl.queueWriteBuffer(queue, buffer, buffer_offset, data, size);
+        Impl.queueWriteBuffer(queue, buffer, buffer_offset, data, size);
     }
 
     pub inline fn writeTexture(queue: Queue, data: *anyopaque, data_size: usize, data_layout: *const TextureDataLayout, write_size: *const Extent3D) void {
-        impl.queueWriteTexture(queue, data, data_size, data_layout, write_size);
+        Impl.queueWriteTexture(queue, data, data_size, data_layout, write_size);
     }
 
     pub inline fn reference(queue: Queue) void {
-        impl.queueReference(queue);
+        Impl.queueReference(queue);
     }
 
     pub inline fn release(queue: Queue) void {
-        impl.queueRelease(queue);
+        Impl.queueRelease(queue);
     }
 };
 

gpu/src/render_bundle.zig

@@ -1,13 +1,13 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const RenderBundle = *opaque {
     pub inline fn reference(render_bundle: RenderBundle) void {
-        impl.renderBundleReference(render_bundle);
+        Impl.renderBundleReference(render_bundle);
     }
 
     pub inline fn release(render_bundle: RenderBundle) void {
-        impl.renderBundleRelease(render_bundle);
+        Impl.renderBundleRelease(render_bundle);
     }
 };
 

gpu/src/render_bundle_encoder.zig

@@ -6,67 +6,67 @@ const BindGroup = @import("bind_group.zig").BindGroup;
 const RenderPipeline = @import("render_pipeline.zig").RenderPipeline;
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const IndexFormat = @import("types.zig").IndexFormat;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const RenderBundleEncoder = *opaque {
     pub inline fn draw(render_bundle_encoder: RenderBundleEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void {
-        impl.renderBundleEncoderDraw(render_bundle_encoder, vertex_count, instance_count, first_vertex, first_instance);
+        Impl.renderBundleEncoderDraw(render_bundle_encoder, vertex_count, instance_count, first_vertex, first_instance);
     }
 
     pub inline fn drawIndexed(render_bundle_encoder: RenderBundleEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: u32, first_instance: u32) void {
-        impl.renderBundleEncoderDrawIndexed(render_bundle_encoder, index_count, instance_count, first_index, base_vertex, first_instance);
+        Impl.renderBundleEncoderDrawIndexed(render_bundle_encoder, index_count, instance_count, first_index, base_vertex, first_instance);
     }
 
     pub inline fn drawIndexedIndirect(render_bundle_encoder: RenderBundleEncoder, indirect_buffer: Buffer, indirect_offset: u64) void {
-        impl.renderBundleEncoderDrawIndexedIndirect(render_bundle_encoder, indirect_buffer, indirect_offset);
+        Impl.renderBundleEncoderDrawIndexedIndirect(render_bundle_encoder, indirect_buffer, indirect_offset);
     }
 
     pub inline fn drawIndirect(render_bundle_encoder: RenderBundleEncoder, indirect_buffer: Buffer, indirect_offset: u64) void {
-        impl.renderBundleEncoderDrawIndirect(render_bundle_encoder, indirect_buffer, indirect_offset);
+        Impl.renderBundleEncoderDrawIndirect(render_bundle_encoder, indirect_buffer, indirect_offset);
     }
 
     pub inline fn finish(render_bundle_encoder: RenderBundleEncoder, descriptor: ?*const RenderBundleDescriptor) void {
-        impl.renderBundleEncoderFinish(render_bundle_encoder, descriptor);
+        Impl.renderBundleEncoderFinish(render_bundle_encoder, descriptor);
     }
 
     pub inline fn insertDebugMarker(render_bundle_encoder: RenderBundleEncoder, marker_label: [*:0]const u8) void {
-        impl.renderBundleEncoderInsertDebugMarker(render_bundle_encoder, marker_label);
+        Impl.renderBundleEncoderInsertDebugMarker(render_bundle_encoder, marker_label);
     }
 
     pub inline fn popDebugGroup(render_bundle_encoder: RenderBundleEncoder) void {
-        impl.renderBundleEncoderPopDebugGroup(render_bundle_encoder);
+        Impl.renderBundleEncoderPopDebugGroup(render_bundle_encoder);
     }
 
     pub inline fn pushDebugGroup(render_bundle_encoder: RenderBundleEncoder, group_label: [*:0]const u8) void {
-        impl.renderBundleEncoderPushDebugGroup(render_bundle_encoder, group_label);
+        Impl.renderBundleEncoderPushDebugGroup(render_bundle_encoder, group_label);
     }
 
     pub inline fn setBindGroup(render_bundle_encoder: RenderBundleEncoder, group_index: u32, group: BindGroup, dynamic_offset_count: u32, dynamic_offsets: [*]const u32) void {
-        impl.renderBundleEncoderSetBindGroup(render_bundle_encoder, group_index, group, dynamic_offset_count, dynamic_offsets);
+        Impl.renderBundleEncoderSetBindGroup(render_bundle_encoder, group_index, group, dynamic_offset_count, dynamic_offsets);
     }
 
     pub inline fn setIndexBuffer(render_bundle_encoder: RenderBundleEncoder, buffer: Buffer, format: IndexFormat, offset: u64, size: u64) void {
-        impl.renderBundleEncoderSetIndexBuffer(render_bundle_encoder, buffer, format, offset, size);
+        Impl.renderBundleEncoderSetIndexBuffer(render_bundle_encoder, buffer, format, offset, size);
     }
 
     pub inline fn setLabel(render_bundle_encoder: RenderBundleEncoder, label: [*:0]const u8) void {
-        impl.renderBundleEncoderSetLabel(render_bundle_encoder, label);
+        Impl.renderBundleEncoderSetLabel(render_bundle_encoder, label);
     }
 
     pub inline fn setPipeline(render_bundle_encoder: RenderBundleEncoder, pipeline: RenderPipeline) void {
-        impl.renderBundleEncoderSetPipeline(render_bundle_encoder, pipeline);
+        Impl.renderBundleEncoderSetPipeline(render_bundle_encoder, pipeline);
     }
 
     pub inline fn setVertexBuffer(render_bundle_encoder: RenderBundleEncoder, slot: u32, buffer: Buffer, offset: u64, size: u64) void {
-        impl.renderBundleEncoderSetVertexBuffer(render_bundle_encoder, slot, buffer, offset, size);
+        Impl.renderBundleEncoderSetVertexBuffer(render_bundle_encoder, slot, buffer, offset, size);
     }
 
     pub inline fn reference(render_bundle_encoder: RenderBundleEncoder) void {
-        impl.renderBundleEncoderReference(render_bundle_encoder);
+        Impl.renderBundleEncoderReference(render_bundle_encoder);
     }
 
     pub inline fn release(render_bundle_encoder: RenderBundleEncoder) void {
-        impl.renderBundleEncoderRelease(render_bundle_encoder);
+        Impl.renderBundleEncoderRelease(render_bundle_encoder);
     }
 };
 

gpu/src/render_pass_encoder.zig

@@ -5,102 +5,102 @@ const RenderPipeline = @import("render_pipeline.zig").RenderPipeline;
 const QuerySet = @import("query_set.zig").QuerySet;
 const Color = @import("types.zig").Color;
 const IndexFormat = @import("types.zig").IndexFormat;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const RenderPassEncoder = *opaque {
     pub inline fn beginOcclusionQuery(render_pass_encoder: RenderPassEncoder, query_index: u32) void {
-        impl.renderPassEncoderBeginOcclusionQuery(render_pass_encoder, query_index);
+        Impl.renderPassEncoderBeginOcclusionQuery(render_pass_encoder, query_index);
     }
 
     pub inline fn draw(render_pass_encoder: RenderPassEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void {
-        impl.renderPassEncoderDraw(render_pass_encoder, vertex_count, instance_count, first_vertex, first_instance);
+        Impl.renderPassEncoderDraw(render_pass_encoder, vertex_count, instance_count, first_vertex, first_instance);
     }
 
     pub inline fn drawIndexed(render_pass_encoder: RenderPassEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: u32, first_instance: u32) void {
-        impl.renderPassEncoderDrawIndexed(render_pass_encoder, index_count, instance_count, first_index, base_vertex, first_instance);
+        Impl.renderPassEncoderDrawIndexed(render_pass_encoder, index_count, instance_count, first_index, base_vertex, first_instance);
     }
 
     pub inline fn drawIndexedIndirect(render_pass_encoder: RenderPassEncoder, indirect_buffer: Buffer, indirect_offset: u64) void {
-        impl.renderPassEncoderDrawIndexedIndirect(render_pass_encoder, indirect_buffer, indirect_offset);
+        Impl.renderPassEncoderDrawIndexedIndirect(render_pass_encoder, indirect_buffer, indirect_offset);
     }
 
     pub inline fn drawIndirect(render_pass_encoder: RenderPassEncoder, indirect_buffer: Buffer, indirect_offset: u64) void {
-        impl.renderPassEncoderDrawIndirect(render_pass_encoder, indirect_buffer, indirect_offset);
+        Impl.renderPassEncoderDrawIndirect(render_pass_encoder, indirect_buffer, indirect_offset);
     }
 
     pub inline fn end(render_pass_encoder: RenderPassEncoder) void {
-        impl.renderPassEncoderEnd(render_pass_encoder);
+        Impl.renderPassEncoderEnd(render_pass_encoder);
     }
 
     pub inline fn endOcclusionQuery(render_pass_encoder: RenderPassEncoder) void {
-        impl.renderPassEncoderEndOcclusionQuery(render_pass_encoder);
+        Impl.renderPassEncoderEndOcclusionQuery(render_pass_encoder);
     }
 
     pub inline fn endPass(render_pass_encoder: RenderPassEncoder) void {
-        impl.renderPassEncoderEndPass(render_pass_encoder);
+        Impl.renderPassEncoderEndPass(render_pass_encoder);
     }
 
     pub inline fn executeBundles(render_pass_encoder: RenderPassEncoder, bundles_count: u32, bundles: [*]const RenderBundle) void {
-        impl.renderPassEncoderExecuteBundles(render_pass_encoder, bundles_count, bundles);
+        Impl.renderPassEncoderExecuteBundles(render_pass_encoder, bundles_count, bundles);
     }
 
     pub inline fn insertDebugMarker(render_pass_encoder: RenderPassEncoder, marker_label: [*:0]const u8) void {
-        impl.renderPassEncoderInsertDebugMarker(render_pass_encoder, marker_label);
+        Impl.renderPassEncoderInsertDebugMarker(render_pass_encoder, marker_label);
     }
 
     pub inline fn popDebugGroup(render_pass_encoder: RenderPassEncoder) void {
-        impl.renderPassEncoderPopDebugGroup(render_pass_encoder);
+        Impl.renderPassEncoderPopDebugGroup(render_pass_encoder);
     }
 
     pub inline fn pushDebugGroup(render_pass_encoder: RenderPassEncoder, group_label: [*:0]const u8) void {
-        impl.renderPassEncoderPushDebugGroup(render_pass_encoder, group_label);
+        Impl.renderPassEncoderPushDebugGroup(render_pass_encoder, group_label);
     }
 
     pub inline fn setBindGroup(render_pass_encoder: RenderPassEncoder, group_index: u32, group: BindGroup, dynamic_offset_count: u32, dynamic_offsets: [*]const u32) void {
-        impl.renderPassEncoderSetBindGroup(render_pass_encoder, group_index, group, dynamic_offset_count, dynamic_offsets);
+        Impl.renderPassEncoderSetBindGroup(render_pass_encoder, group_index, group, dynamic_offset_count, dynamic_offsets);
     }
 
     pub inline fn setBlendConstant(render_pass_encoder: RenderPassEncoder, color: *const Color) void {
-        impl.renderPassEncoderSetBlendConstant(render_pass_encoder, color);
+        Impl.renderPassEncoderSetBlendConstant(render_pass_encoder, color);
     }
 
     pub inline fn setIndexBuffer(render_pass_encoder: RenderPassEncoder, buffer: Buffer, format: IndexFormat, offset: u64, size: u64) void {
-        impl.renderPassEncoderSetIndexBuffer(render_pass_encoder, buffer, format, offset, size);
+        Impl.renderPassEncoderSetIndexBuffer(render_pass_encoder, buffer, format, offset, size);
     }
 
     pub inline fn setLabel(render_pass_encoder: RenderPassEncoder, label: [*:0]const u8) void {
-        impl.renderPassEncoderSetLabel(render_pass_encoder, label);
+        Impl.renderPassEncoderSetLabel(render_pass_encoder, label);
     }
 
     pub inline fn setPipeline(render_pass_encoder: RenderPassEncoder, pipeline: RenderPipeline) void {
-        impl.renderPassEncoderSetPipeline(render_pass_encoder, pipeline);
+        Impl.renderPassEncoderSetPipeline(render_pass_encoder, pipeline);
     }
 
     pub inline fn setScissorRect(render_pass_encoder: RenderPassEncoder, x: u32, y: u32, width: u32, height: u32) void {
-        impl.renderPassEncoderSetScissorRect(render_pass_encoder, x, y, width, height);
+        Impl.renderPassEncoderSetScissorRect(render_pass_encoder, x, y, width, height);
     }
 
     pub inline fn setStencilReference(render_pass_encoder: RenderPassEncoder, _reference: u32) void {
-        impl.renderPassEncoderSetStencilReference(render_pass_encoder, _reference);
+        Impl.renderPassEncoderSetStencilReference(render_pass_encoder, _reference);
     }
 
     pub inline fn setVertexBuffer(render_pass_encoder: RenderPassEncoder, slot: u32, buffer: Buffer, offset: u64, size: u64) void {
-        impl.renderPassEncoderSetVertexBuffer(render_pass_encoder, slot, buffer, offset, size);
+        Impl.renderPassEncoderSetVertexBuffer(render_pass_encoder, slot, buffer, offset, size);
     }
 
     pub inline fn setViewport(render_pass_encoder: RenderPassEncoder, x: f32, y: f32, width: f32, height: f32, min_depth: f32, max_depth: f32) void {
-        impl.renderPassEncoderSetViewport(render_pass_encoder, x, y, width, height, min_depth, max_depth);
+        Impl.renderPassEncoderSetViewport(render_pass_encoder, x, y, width, height, min_depth, max_depth);
     }
 
     pub inline fn writeTimestamp(render_pass_encoder: RenderPassEncoder, query_set: QuerySet, query_index: u32) void {
-        impl.renderPassEncoderWriteTimestamp(render_pass_encoder, query_set, query_index);
+        Impl.renderPassEncoderWriteTimestamp(render_pass_encoder, query_set, query_index);
     }
 
     pub inline fn reference(render_pass_encoder: RenderPassEncoder) void {
-        impl.renderPassEncoderReference(render_pass_encoder);
+        Impl.renderPassEncoderReference(render_pass_encoder);
     }
 
     pub inline fn release(render_pass_encoder: RenderPassEncoder) void {
-        impl.renderPassEncoderRelease(render_pass_encoder);
+        Impl.renderPassEncoderRelease(render_pass_encoder);
     }
 };

gpu/src/render_pipeline.zig

@@ -6,23 +6,23 @@ const PrimitiveState = @import("types.zig").PrimitiveState;
 const FragmentState = @import("types.zig").FragmentState;
 const PipelineLayout = @import("pipeline_layout.zig").PipelineLayout;
 const BindGroupLayout = @import("bind_group_layout.zig").BindGroupLayout;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const RenderPipeline = *opaque {
     pub inline fn getBindGroupLayout(render_pipeline: RenderPipeline, group_index: u32) BindGroupLayout {
-        return impl.renderPipelineGetBindGroupLayout(render_pipeline, group_index);
+        return Impl.renderPipelineGetBindGroupLayout(render_pipeline, group_index);
     }
 
     pub inline fn setLabel(render_pipeline: RenderPipeline, label: [*:0]const u8) void {
-        impl.renderPipelineSetLabel(render_pipeline, label);
+        Impl.renderPipelineSetLabel(render_pipeline, label);
     }
 
     pub inline fn reference(render_pipeline: RenderPipeline) void {
-        impl.renderPipelineReference(render_pipeline);
+        Impl.renderPipelineReference(render_pipeline);
     }
 
     pub inline fn release(render_pipeline: RenderPipeline) void {
-        impl.renderPipelineRelease(render_pipeline);
+        Impl.renderPipelineRelease(render_pipeline);
     }
 };
 

gpu/src/sampler.zig

@@ -1,19 +1,19 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const FilterMode = @import("types.zig").FilterMode;
 const CompareFunction = @import("types.zig").CompareFunction;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Sampler = *opaque {
     pub inline fn setLabel(sampler: Sampler, label: [*:0]const u8) void {
-        impl.samplerSetLabel(sampler, label);
+        Impl.samplerSetLabel(sampler, label);
     }
 
     pub inline fn reference(sampler: Sampler) void {
-        impl.samplerReference(sampler);
+        Impl.samplerReference(sampler);
     }
 
     pub inline fn release(sampler: Sampler) void {
-        impl.samplerRelease(sampler);
+        Impl.samplerRelease(sampler);
     }
 };
 

gpu/src/shader_module.zig

@@ -1,22 +1,22 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
 const CompilationInfoCallback = @import("types.zig").CompilationInfoCallback;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const ShaderModule = *opaque {
     pub inline fn getCompilationInfo(shader_module: ShaderModule, callback: CompilationInfoCallback, userdata: *anyopaque) void {
-        impl.shaderModuleGetCompilationInfo(shader_module, callback, userdata);
+        Impl.shaderModuleGetCompilationInfo(shader_module, callback, userdata);
     }
 
     pub inline fn setLabel(shader_module: ShaderModule, label: [*:0]const u8) void {
-        impl.shaderModuleSetLabel(shader_module, label);
+        Impl.shaderModuleSetLabel(shader_module, label);
     }
 
     pub inline fn reference(shader_module: ShaderModule) void {
-        impl.shaderModuleReference(shader_module);
+        Impl.shaderModuleReference(shader_module);
     }
 
     pub inline fn release(shader_module: ShaderModule) void {
-        impl.shaderModuleRelease(shader_module);
+        Impl.shaderModuleRelease(shader_module);
     }
 };
 

gpu/src/surface.zig

@@ -1,13 +1,13 @@
 const ChainedStruct = @import("types.zig").ChainedStruct;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Surface = *opaque {
     pub inline fn reference(surface: Surface) void {
-        impl.surfaceReference(surface);
+        Impl.surfaceReference(surface);
     }
 
     pub inline fn release(surface: Surface) void {
-        impl.surfaceRelease(surface);
+        Impl.surfaceRelease(surface);
     }
 };
 

gpu/src/swap_chain.zig

@@ -4,27 +4,27 @@ const Texture = @import("texture.zig").Texture;
 const TextureUsageFlags = @import("texture.zig").TextureUsageFlags;
 const TextureFormat = @import("texture.zig").TextureFormat;
 const TextureView = @import("texture_view.zig").TextureView;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const SwapChain = *opaque {
     pub inline fn configure(swap_chain: SwapChain, format: TextureFormat, allowed_usage: TextureUsageFlags, width: u32, height: u32) void {
-        impl.swapChainConfigure(swap_chain, format, allowed_usage, width, height);
+        Impl.swapChainConfigure(swap_chain, format, allowed_usage, width, height);
     }
 
     pub inline fn getCurrentTextureView(swap_chain: SwapChain) TextureView {
-        return impl.swapChainGetCurrentTextureView(swap_chain);
+        return Impl.swapChainGetCurrentTextureView(swap_chain);
     }
 
     pub inline fn present(swap_chain: SwapChain) void {
-        impl.swapChainPresent(swap_chain);
+        Impl.swapChainPresent(swap_chain);
     }
 
     pub inline fn reference(swap_chain: SwapChain) void {
-        impl.swapChainReference(swap_chain);
+        Impl.swapChainReference(swap_chain);
     }
 
     pub inline fn release(swap_chain: SwapChain) void {
-        impl.swapChainRelease(swap_chain);
+        Impl.swapChainRelease(swap_chain);
     }
 };
 

gpu/src/texture.zig

@@ -4,59 +4,59 @@ const TextureView = @import("texture_view.zig").TextureView;
 const TextureViewDimension = @import("texture_view.zig").TextureViewDimension;
 const TextureViewDescriptor = @import("texture_view.zig").TextureViewDescriptor;
 const Extent3D = @import("types.zig").Extent3D;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const Texture = *opaque {
     pub inline fn createView(texture: Texture, descriptor: ?*const TextureViewDescriptor) TextureView {
-        return impl.textureCreateView(texture, descriptor);
+        return Impl.textureCreateView(texture, descriptor);
     }
 
     pub inline fn destroy(texture: Texture) void {
-        impl.textureDestroy(texture);
+        Impl.textureDestroy(texture);
     }
 
     pub inline fn getDepthOrArrayLayers(texture: Texture) u32 {
-        return impl.textureGetDepthOrArrayLayers(texture);
+        return Impl.textureGetDepthOrArrayLayers(texture);
     }
 
     pub inline fn getDimension(texture: Texture) TextureDimension {
-        return impl.textureGetDimension(texture);
+        return Impl.textureGetDimension(texture);
     }
 
     pub inline fn getFormat(texture: Texture) TextureFormat {
-        return impl.textureGetFormat(texture);
+        return Impl.textureGetFormat(texture);
     }
 
     pub inline fn getHeight(texture: Texture) u32 {
-        return impl.textureGetHeight(texture);
+        return Impl.textureGetHeight(texture);
     }
 
     pub inline fn getMipLevelCount(texture: Texture) u32 {
-        return impl.textureGetMipLevelCount(texture);
+        return Impl.textureGetMipLevelCount(texture);
     }
 
     pub inline fn getSampleCount(texture: Texture) u32 {
-        return impl.textureGetSampleCount(texture);
+        return Impl.textureGetSampleCount(texture);
     }
 
     pub inline fn getUsage(texture: Texture) TextureUsageFlags {
-        return impl.textureGetUsage(texture);
+        return Impl.textureGetUsage(texture);
     }
 
     pub inline fn getWidth(texture: Texture) u32 {
-        return impl.textureGetWidth(texture);
+        return Impl.textureGetWidth(texture);
     }
 
     pub inline fn setLabel(texture: Texture, label: [*:0]const u8) void {
-        impl.textureSetLabel(texture, label);
+        Impl.textureSetLabel(texture, label);
     }
 
     pub inline fn reference(texture: Texture) void {
-        impl.textureReference(texture);
+        Impl.textureReference(texture);
     }
 
     pub inline fn release(texture: Texture) void {
-        impl.textureRelease(texture);
+        Impl.textureRelease(texture);
     }
 };
 

gpu/src/texture_view.zig

@@ -2,19 +2,19 @@ const ChainedStruct = @import("types.zig").ChainedStruct;
 const Texture = @import("texture.zig").Texture;
 const TextureFormat = @import("texture.zig").TextureFormat;
 const TextureAspect = @import("texture.zig").TextureAspect;
-const impl = @import("interface.zig").impl;
+const Impl = @import("interface.zig").Impl;
 
 pub const TextureView = *opaque {
     pub inline fn setLabel(texture_view: TextureView, label: [*:0]const u8) void {
-        impl.textureViewSetLabel(texture_view, label);
+        Impl.textureViewSetLabel(texture_view, label);
     }
 
     pub inline fn reference(texture_view: TextureView) void {
-        impl.textureViewReference(texture_view);
+        Impl.textureViewReference(texture_view);
     }
 
     pub inline fn release(texture_view: TextureView) void {
-        impl.textureViewRelease(texture_view);
+        Impl.textureViewRelease(texture_view);
     }
 };