zig/mach
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gpu: correct implementation invocations

Browse source 
Signed-off-by: Stephen Gutekanst <stephen@hexops.com>
This commit is contained in:
Stephen Gutekanst 2022-07-26 23:03:54 -07:00 • committed by Stephen Gutekanst
parent 4f91682bc2
commit 39ed9b5822
25 changed files with 638 additions and 638 deletions
Download patch file Download diff file Expand all files Collapse all files

18
gpu/src/adapter.zig
View file

@ -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);
}
};

8
gpu/src/bind_group.zig
View file

@ -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);
}
};

8
gpu/src/bind_group_layout.zig
View file

@ -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);
}
};

22
gpu/src/buffer.zig
View file

@ -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);
}
};

8
gpu/src/command_buffer.zig
View file

@ -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);
}
};

40
gpu/src/command_encoder.zig
View file

@ -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);
}
};

32
gpu/src/compute_pass_encoder.zig
View file

@ -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);
}
};

10
gpu/src/compute_pipeline.zig
View file

@ -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);
}
};

70
gpu/src/device.zig
View file

@ -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);
}
};

10
gpu/src/external_texture.zig
View file

@ -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);
}
};

10
gpu/src/instance.zig
View file

@ -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);
}
};

830
gpu/src/interface.zig
View file

File diff suppressed because it is too large Load diff

8
gpu/src/pipeline_layout.zig
View file

@ -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);
}
};

14
gpu/src/query_set.zig
View file

@ -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);
}
};

18
gpu/src/queue.zig
View file

@ -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);
}
};

6
gpu/src/render_bundle.zig
View file

@ -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);
}
};

32
gpu/src/render_bundle_encoder.zig
View file

@ -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);
}
};

50
gpu/src/render_pass_encoder.zig
View file

@ -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);
}
};

10
gpu/src/render_pipeline.zig
View file

@ -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);
}
};

8
gpu/src/sampler.zig
View file

@ -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);
}
};

10
gpu/src/shader_module.zig
View file

@ -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);
}
};

6
gpu/src/surface.zig
View file

@ -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);
}
};

12
gpu/src/swap_chain.zig
View file

@ -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);
}
};

28
gpu/src/texture.zig
View file

@ -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);
}
};

8
gpu/src/texture_view.zig
View file

@ -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);
}
};