package vendor:wgpu

Source

Adapter :: distinct rawptr

AdapterInfo :: struct {
	nextInChain:  ^ChainedStructOut,
	vendor:       string,
	architecture: string,
	device:       string,
	description:  string,
	backendType:  BackendType,
	adapterType:  AdapterType,
	vendorID:     u32,
	deviceID:     u32,
}

AdapterType :: enum i32 {
	DiscreteGPU   = 1, 
	IntegratedGPU = 2, 
	CPU           = 3, 
	Unknown       = 4, 
}

AddressMode :: enum i32 {
	Undefined    = 0, 
	ClampToEdge  = 1, 
	Repeat       = 2, 
	MirrorRepeat = 3, 
}

BackendType :: enum i32 {
	Undefined = 0, 
	Null      = 1, 
	WebGPU    = 2, 
	D3D11     = 3, 
	D3D12     = 4, 
	Metal     = 5, 
	Vulkan    = 6, 
	OpenGL    = 7, 
	OpenGLES  = 8, 
}

BindGroup :: distinct rawptr

BindGroupDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
	layout:      BindGroupLayout,
	entryCount:  uint,
	entries:     [^]BindGroupEntry `fmt:"v,entryCount"`,
}

BindGroupEntry :: struct {
	nextInChain: ^ChainedStruct,
	binding:     u32,
	buffer:      Buffer,
	offset:      u64,
	size:        u64,
	sampler:     Sampler,
	textureView: TextureView,
}

BindGroupEntryExtras :: struct {
	using chain:      ChainedStruct,
	buffers:          [^]Buffer `fmt:"v,bufferCount"`,
	bufferCount:      uint,
	samplers:         [^]Sampler `fmt:"v,samplerCount"`,
	samplerCount:     uint,
	textureViews:     [^]TextureView `fmt:"v,textureViewCount"`,
	textureViewCount: uint,
}

BindGroupLayout :: distinct rawptr

BindGroupLayoutDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
	entryCount:  uint,
	entries:     [^]BindGroupLayoutEntry `fmt:"v,entryCount"`,
}

BindGroupLayoutEntry :: struct {
	nextInChain:    ^ChainedStruct,
	binding:        u32,
	visibility:     bit_set[ShaderStage; u64],
	buffer:         BufferBindingLayout,
	sampler:        SamplerBindingLayout,
	texture:        TextureBindingLayout,
	storageTexture: StorageTextureBindingLayout,
}

BindGroupLayoutEntryExtras :: struct {
	using chain: ChainedStruct,
	count: u32,
}

BlendComponent :: struct {
	operation: BlendOperation,
	srcFactor: BlendFactor,
	dstFactor: BlendFactor,
}

BlendFactor :: enum i32 {
	Undefined         = 0, 
	Zero              = 1, 
	One               = 2, 
	Src               = 3, 
	OneMinusSrc       = 4, 
	SrcAlpha          = 5, 
	OneMinusSrcAlpha  = 6, 
	Dst               = 7, 
	OneMinusDst       = 8, 
	DstAlpha          = 9, 
	OneMinusDstAlpha  = 10, 
	SrcAlphaSaturated = 11, 
	Constant          = 12, 
	OneMinusConstant  = 13, 
	Src1              = 14, 
	OneMinusSrc1      = 15, 
	Src1Alpha         = 16, 
	OneMinusSrc1Alpha = 17, 
}

BlendOperation :: enum i32 {
	Add             = 0, 
	Subtract        = 1, 
	ReverseSubtract = 2, 
	Min             = 3, 
	Max             = 4, 
}

BlendState :: struct {
	color: BlendComponent,
	alpha: BlendComponent,
}

Buffer :: distinct rawptr

BufferBindingLayout :: struct {
	nextInChain:      ^ChainedStruct,
	type:             BufferBindingType,
	hasDynamicOffset: b32,
	minBindingSize:   u64,
}

BufferBindingType :: enum i32 {
	BindingNotUsed  = 0, 
	Undefined       = 1, 
	Uniform         = 2, 
	Storage         = 3, 
	ReadOnlyStorage = 4, 
}

BufferDescriptor :: struct {
	nextInChain:      ^ChainedStruct,
	label:            string,
	usage:            bit_set[BufferUsage; u64],
	size:             u64,
	mappedAtCreation: b32,
}

BufferMapCallback :: proc "c" (status: MapAsyncStatus, message: string, userdata1: rawptr, userdata2: rawptr)

BufferMapCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    BufferMapCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

BufferMapState :: enum i32 {
	Unmapped = 1, 
	Pending  = 2, 
	Mapped   = 3, 
}

BufferUsage :: enum i32 {
	MapRead      = 0, 
	MapWrite     = 1, 
	CopySrc      = 2, 
	CopyDst      = 3, 
	Index        = 4, 
	Vertex       = 5, 
	Uniform      = 6, 
	Storage      = 7, 
	Indirect     = 8, 
	QueryResolve = 9, 
}

BufferUsageFlags :: bit_set[BufferUsage; u64]

BufferWithDataDescriptor :: struct {
	label: string,
	usage: bit_set[BufferUsage; u64],
}

CallbackMode :: enum i32 {
	WaitAnyOnly        = 1, 
	AllowProcessEvents = 2, 
	AllowSpontaneos    = 3, 
}

ChainedStruct :: struct {
	next:  ^ChainedStruct,
	sType: SType,
}

ChainedStructOut :: struct {
	next:  ^ChainedStructOut,
	sType: SType,
}

Color :: [4]f64

ColorTargetState :: struct {
	nextInChain: ^ChainedStruct,
	format:      TextureFormat,
	blend:       ^BlendState,
	writeMask:   bit_set[ColorWriteMask; u64],
}

ColorWriteMask :: enum i32 {
	Red   = 0, 
	Green = 1, 
	Blue  = 2, 
	Alpha = 3, 
}

ColorWriteMaskFlags :: bit_set[ColorWriteMask; u64]

CommandBuffer :: distinct rawptr

CommandBufferDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
}

CommandEncoder :: distinct rawptr

CommandEncoderDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
}

CompareFunction :: enum i32 {
	Undefined    = 0, 
	Never        = 1, 
	Less         = 2, 
	Equal        = 3, 
	LessEqual    = 4, 
	Greater      = 5, 
	NotEqual     = 6, 
	GreaterEqual = 7, 
	Always       = 8, 
}

CompilationInfo :: struct {
	nextInChain:  ^ChainedStruct,
	messageCount: uint,
	messages:     [^]CompilationMessage `fmt:"v,messageCount"`,
}

CompilationInfoCallback :: proc "c" (status: CompilationInfoRequestStatus, compilationInfo: ^CompilationInfo, userdata1: rawptr, userdata2: rawptr)

CompilationInfoCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    CompilationInfoCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

CompilationInfoRequestStatus :: enum i32 {
	Success         = 1, 
	InstanceDropped = 2, 
	Error           = 3, 
	Unknown         = 4, 
}

CompilationMessage :: struct {
	nextInChain: ^ChainedStruct,
	message:     string,
	type:        CompilationMessageType,
	lineNum:     u64,
	linePos:     u64,
	offset:      u64,
	length:      u64,
}

CompilationMessageType :: enum i32 {
	Error   = 1, 
	Warning = 2, 
	Info    = 3, 
}

CompositeAlphaMode :: enum i32 {
	Auto            = 0, 
	Opaque          = 1, 
	Premultiplied   = 2, 
	Unpremultiplied = 3, 
	Inherit         = 4, 
}

ComputePassDescriptor :: struct {
	nextInChain:     ^ChainedStruct,
	label:           string,
	timestampWrites: ^ComputePassTimestampWrites,
}

ComputePassEncoder :: distinct rawptr

ComputePassTimestampWrites :: struct {
	querySet:                  QuerySet,
	beginningOfPassWriteIndex: u32,
	endOfPassWriteIndex:       u32,
}

ComputePipeline :: distinct rawptr

ComputePipelineDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
	layout:      PipelineLayout,
	compute:     ProgrammableStageDescriptor,
}

ConstantEntry :: struct {
	nextInChain: ^ChainedStruct,
	key:         string,
	value:       f64,
}

CreateComputePipelineAsyncCallback :: proc "c" (status: CreatePipelineAsyncStatus, pipeline: ComputePipeline, message: string, userdata1: rawptr, userdata2: rawptr)

CreateComputePipelineAsyncCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    CreateComputePipelineAsyncCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

CreatePipelineAsyncStatus :: enum i32 {
	Success         = 1, 
	InstanceDropped = 2, 
	ValidationError = 3, 
	InternalError   = 4, 
	Unknown         = 5, 
}

CreateRenderPipelineAsyncCallback :: proc "c" (status: CreatePipelineAsyncStatus, pipeline: RenderPipeline, message: string, userdata1: rawptr, userdata2: rawptr)

CreateRenderPipelineAsyncCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    CreateRenderPipelineAsyncCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

CullMode :: enum i32 {
	Undefined = 0, 
	None      = 1, 
	Front     = 2, 
	Back      = 3, 
}

DepthStencilState :: struct {
	nextInChain:         ^ChainedStruct,
	format:              TextureFormat,
	depthWriteEnabled:   OptionalBool,
	depthCompare:        CompareFunction,
	stencilFront:        StencilFaceState,
	stencilBack:         StencilFaceState,
	stencilReadMask:     u32,
	stencilWriteMask:    u32,
	depthBias:           i32,
	depthBiasSlopeScale: f32,
	depthBiasClamp:      f32,
}

Device :: distinct rawptr

DeviceDescriptor :: struct {
	nextInChain:                 ^ChainedStruct,
	label:                       string,
	requiredFeatureCount:        uint,
	requiredFeatures:            [^]FeatureName `fmt:"v,requiredFeatureCount"`,
	requiredLimits:              ^Limits,
	defaultQueue:                QueueDescriptor,
	deviceLostCallbackInfo:      DeviceLostCallbackInfo,
	uncapturedErrorCallbackInfo: UncapturedErrorCallbackInfo,
}

DeviceExtras :: struct {
	using chain: ChainedStruct,
	tracePath: string,
}

DeviceLostCallback :: proc "c" (device: ^Device, reason: DeviceLostReason, message: string, userdata1: rawptr, userdata2: rawptr)

DeviceLostCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    DeviceLostCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

DeviceLostReason :: enum i32 {
	Undefined       = 0, 
	Unknown         = 1, 
	Destroyed       = 2, 
	InstanceDropped = 3, 
	FailedCreation  = 4, 
}

Dx12Compiler :: enum i32 {
	Undefined, 
	Fxc, 
	Dxc, 
}

ErrorFilter :: enum i32 {
	Validation  = 1, 
	OutOfMemory = 2, 
	Internal    = 3, 
}

ErrorType :: enum i32 {
	NoError     = 1, 
	Validation  = 2, 
	OutOfMemory = 3, 
	Internal    = 4, 
	Unknown     = 5, 
}

Extent3D :: struct {
	width:              u32,
	height:             u32,
	depthOrArrayLayers: u32,
}

FeatureLevel :: enum i32 {
	Compatibility = 1, 
	Core          = 2, 
}

FeatureName :: enum i32 {
	// WebGPU.
	Undefined                                             = 0, 
	DepthClipControl                                      = 1, 
	Depth32FloatStencil8                                  = 2, 
	TimestampQuery                                        = 3, 
	TextureCompressionBC                                  = 4, 
	TextureCompressionBCSliced3D                          = 5, 
	TextureCompressionETC2                                = 6, 
	TextureCompressionASTC                                = 7, 
	TextureCompressionASTCSliced3D                        = 8, 
	IndirectFirstInstance                                 = 9, 
	ShaderF16                                             = 10, 
	RG11B10UfloatRenderable                               = 11, 
	BGRA8UnormStorage                                     = 12, 
	Float32Filterable                                     = 13, 
	Float32Blendable                                      = 14, 
	ClipDistances                                         = 15, 
	DualSourceBlending                                    = 16, 
	// Native.
	PushConstants                                         = 196609, 
	TextureAdapterSpecificFormatFeatures, 
	MultiDrawIndirect, 
	MultiDrawIndirectCount, 
	VertexWritableStorage, 
	TextureBindingArray, 
	SampledTextureAndStorageBufferArrayNonUniformIndexing, 
	PipelineStatisticsQuery, 
	StorageResourceBindingArray, 
	PartiallyBoundBindingArray, 
	TextureFormat16bitNorm, 
	TextureCompressionAstcHdr, 
	MappablePrimaryBuffers                                = 196622, 
	BufferBindingArray, 
	UniformBufferAndStorageTextureArrayNonUniformIndexing, 
	// TODO: requires wgpu.h api change
	// AddressModeClampToZero,
	// AddressModeClampToBorder,
	// PolygonModeLine,
	// PolygonModePoint,
	// ConservativeRasterization,
	// ClearTexture,
	SpirvShaderPassthrough                                = 196631, 
	// MultiView,
	VertexAttribute64bit                                  = 196633, 
	TextureFormatNv12, 
	RayTracingAccelarationStructure, 
	RayQuery, 
	ShaderF64, 
	ShaderI16, 
	ShaderPrimitiveIndex, 
	ShaderEarlyDepthTest, 
	Subgroup, 
	SubgroupVertex, 
	SubgroupBarrier, 
	TimestampQueryInsideEncoders, 
	TimestampQueryInsidePasses, 
}

FilterMode :: enum i32 {
	Undefined = 0, 
	Nearest   = 1, 
	Linear    = 2, 
}

Flags :: u64

FragmentState :: struct {
	nextInChain:   ^ChainedStruct,
	module:        ShaderModule,
	entryPoint:    string,
	constantCount: uint,
	constants:     [^]ConstantEntry `fmt:"v,constantCount"`,
	targetCount:   uint,
	targets:       [^]ColorTargetState `fmt:"v,targetCount"`,
}

FrontFace :: enum i32 {
	Undefined = 0, 
	CCW       = 1, 
	CW        = 2, 
}

Future :: struct {
	id: u64,
}

FutureWaitInfo :: struct {
	future:    Future,
	completed: b32,
}

Gles3MinorVersion :: enum i32 {
	Automatic, 
	Version0, 
	Version1, 
	Version2, 
}

GlobalReport :: struct {
	surfaces: RegistryReport,
	hub:      HubReport,
}

HubReport :: struct {
	adapters:         RegistryReport,
	devices:          RegistryReport,
	queues:           RegistryReport,
	pipelineLayouts:  RegistryReport,
	shaderModules:    RegistryReport,
	bindGroupLayouts: RegistryReport,
	bindGroups:       RegistryReport,
	commandBuffers:   RegistryReport,
	renderBundles:    RegistryReport,
	renderPipelines:  RegistryReport,
	computePipelines: RegistryReport,
	pipelineCaches:   RegistryReport,
	querySets:        RegistryReport,
	buffers:          RegistryReport,
	textures:         RegistryReport,
	textureViews:     RegistryReport,
	samplers:         RegistryReport,
}

IndexFormat :: enum i32 {
	Undefined = 0, 
	Uint16    = 1, 
	Uint32    = 2, 
}

Instance :: distinct rawptr

InstanceBackend :: enum i32 {
	Vulkan, 
	GL, 
	Metal, 
	DX12, 
	DX11, 
	BrowserWebGPU, 
}

InstanceBackendFlags :: bit_set[InstanceBackend; u64]

InstanceCapabilities :: struct {
	nextInChain:          ^ChainedStructOut,
	timedWaitAnyEnable:   b32,
	timedWaitAnyMaxCount: uint,
}

InstanceDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	features:    InstanceCapabilities,
}

InstanceEnumerateAdapterOptions :: struct {
	nextInChain: ^ChainedStruct,
	backends:    bit_set[InstanceBackend; u64],
}

InstanceExtras :: struct {
	using chain:        ChainedStruct,
	backends:           bit_set[InstanceBackend; u64],
	flags:              bit_set[InstanceFlag; u64],
	dx12ShaderCompiler: Dx12Compiler,
	gles3MinorVersion:  Gles3MinorVersion,
	dxilPath:           string,
	dxcPath:            string,
}

InstanceFlag :: enum i32 {
	Debug, 
	Validation, 
	DiscardHalLabels, 
}

InstanceFlags :: bit_set[InstanceFlag; u64]

Limits :: struct {
	nextInChain:                               ^ChainedStructOut,
	maxTextureDimension1D:                     u32,
	maxTextureDimension2D:                     u32,
	maxTextureDimension3D:                     u32,
	maxTextureArrayLayers:                     u32,
	maxBindGroups:                             u32,
	maxBindGroupsPlusVertexBuffers:            u32,
	maxBindingsPerBindGroup:                   u32,
	maxDynamicUniformBuffersPerPipelineLayout: u32,
	maxDynamicStorageBuffersPerPipelineLayout: u32,
	maxSampledTexturesPerShaderStage:          u32,
	maxSamplersPerShaderStage:                 u32,
	maxStorageBuffersPerShaderStage:           u32,
	maxStorageTexturesPerShaderStage:          u32,
	maxUniformBuffersPerShaderStage:           u32,
	maxUniformBufferBindingSize:               u64,
	maxStorageBufferBindingSize:               u64,
	minUniformBufferOffsetAlignment:           u32,
	minStorageBufferOffsetAlignment:           u32,
	maxVertexBuffers:                          u32,
	maxBufferSize:                             u64,
	maxVertexAttributes:                       u32,
	maxVertexBufferArrayStride:                u32,
	maxInterStageShaderVariables:              u32,
	maxColorAttachments:                       u32,
	maxColorAttachmentBytesPerSample:          u32,
	maxComputeWorkgroupStorageSize:            u32,
	maxComputeInvocationsPerWorkgroup:         u32,
	maxComputeWorkgroupSizeX:                  u32,
	maxComputeWorkgroupSizeY:                  u32,
	maxComputeWorkgroupSizeZ:                  u32,
	maxComputeWorkgroupsPerDimension:          u32,
}

LoadOp :: enum i32 {
	Undefined = 0, 
	Load      = 1, 
	Clear     = 2, 
}

LogCallback :: proc "c" (level: LogLevel, message: string, userdata: rawptr)

LogLevel :: enum i32 {
	Off, 
	Error, 
	Warn, 
	Info, 
	Debug, 
	Trace, 
}

MapAsyncStatus :: enum i32 {
	Success         = 1, 
	InstanceDropped = 2, 
	Error           = 3, 
	Aborted         = 4, 
	Unknown         = 5, 
}

MapMode :: enum i32 {
	Read  = 0, 
	Write = 1, 
}

MapModeFlags :: bit_set[MapMode; u64]

MipmapFilterMode :: enum i32 {
	Undefined = 0, 
	Nearest   = 1, 
	Linear    = 2, 
}

MultisampleState :: struct {
	nextInChain:            ^ChainedStruct,
	count:                  u32,
	mask:                   u32,
	alphaToCoverageEnabled: b32,
}

NativeLimits :: struct {
	using chain:           ChainedStructOut,
	maxPushConstantSize:   u32,
	maxNonSamplerBindings: u32,
}

OptionalBool :: enum i32 {
	False     = 0, 
	True      = 1, 
	Undefined = 2, 
}

Origin3D :: struct {
	x: u32,
	y: u32,
	z: u32,
}

PipelineLayout :: distinct rawptr

PipelineLayoutDescriptor :: struct {
	nextInChain:          ^ChainedStruct,
	label:                string,
	bindGroupLayoutCount: uint,
	bindGroupLayouts:     [^]BindGroupLayout `fmt:"v,bindGroupLayoutCount"`,
}

PipelineLayoutExtras :: struct {
	using chain:            ChainedStruct,
	pushConstantRangeCount: uint,
	pushConstantRanges:     [^]PushConstantRange `fmt:"v,pushConstantRangeCount"`,
}

PipelineStatisticName :: enum i32 {
	VertexShaderInvocations, 
	ClipperInvocations, 
	ClipperPrimitivesOut, 
	FragmentShaderInvocations, 
	ComputeShaderInvocations, 
}

PopErrorScopeCallback :: proc "c" (status: PopErrorScopeStatus, type: ErrorType, message: string, userdata1: rawptr, userdata2: rawptr)

PopErrorScopeCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    PopErrorScopeCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

PopErrorScopeStatus :: enum i32 {
	Success         = 1, 
	InstanceDropped = 2, 
	EmptyStack      = 3, 
}

PowerPreference :: enum i32 {
	Undefined       = 0, 
	LowPower        = 1, 
	HighPerformance = 2, 
}

PresentMode :: enum i32 {
	Undefined   = 0, 
	Fifo        = 1, 
	FifoRelaxed = 2, 
	Immediate   = 3, 
	Mailbox     = 4, 
}

PrimitiveState :: struct {
	nextInChain:      ^ChainedStruct,
	topology:         PrimitiveTopology,
	stripIndexFormat: IndexFormat,
	frontFace:        FrontFace,
	cullMode:         CullMode,
	unclippedDepth:   b32,
}

PrimitiveTopology :: enum i32 {
	Undefined     = 0, 
	PointList     = 1, 
	LineList      = 2, 
	LineStrip     = 3, 
	TriangleList  = 4, 
	TriangleStrip = 5, 
}

Proc :: distinct rawptr

ProgrammableStageDescriptor :: struct {
	nextInChain:   ^ChainedStruct,
	module:        ShaderModule,
	entryPoint:    string,
	constantCount: uint,
	constants:     [^]ConstantEntry `fmt:"v,constantCount"`,
}

PushConstantRange :: struct {
	stages: bit_set[ShaderStage; u64],
	start:  u32,
	end:    u32,
}

QuerySet :: distinct rawptr

QuerySetDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
	type:        QueryType,
	count:       u32,
}

QuerySetDescriptorExtras :: struct {
	using chain:            ChainedStruct,
	pipelineStatistics:     [^]PipelineStatisticName `fmt:"v,pipelineStatisticCount"`,
	pipelineStatisticCount: uint,
}

QueryType :: enum i32 {
	// WebGPU.
	Occlusion          = 1, 
	Timestamp          = 2, 
	// Native.
	PipelineStatistics = 196608, 
}

Queue :: distinct rawptr

QueueDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
}

QueueWorkDoneCallback :: proc "c" (status: QueueWorkDoneStatus, userdata1: rawptr, userdata2: rawptr)

QueueWorkDoneCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    QueueWorkDoneCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

QueueWorkDoneStatus :: enum i32 {
	Success         = 1, 
	InstanceDropped = 2, 
	Error           = 3, 
	Unknown         = 4, 
}

RegistryReport :: struct {
	numAllocated:        uint,
	numKeptFromUser:     uint,
	numReleasedFromUser: uint,
	elementSize:         uint,
}

RenderBundle :: distinct rawptr

RenderBundleDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
}

RenderBundleEncoder :: distinct rawptr

RenderBundleEncoderDescriptor :: struct {
	nextInChain:        ^ChainedStruct,
	label:              string,
	colorFormatCount:   uint,
	colorFormats:       [^]TextureFormat `fmt:"v,colorFormatCount"`,
	depthStencilFormat: TextureFormat,
	sampleCount:        u32,
	depthReadOnly:      b32,
	stencilReadOnly:    b32,
}

RenderPassColorAttachment :: struct {
	nextInChain:   ^ChainedStruct,
	view:          TextureView,
	depthSlice:    u32,
	resolveTarget: TextureView,
	loadOp:        LoadOp,
	storeOp:       StoreOp,
	clearValue:    [4]f64,
}

RenderPassDepthStencilAttachment :: struct {
	view:              TextureView,
	depthLoadOp:       LoadOp,
	depthStoreOp:      StoreOp,
	depthClearValue:   f32,
	depthReadOnly:     b32,
	stencilLoadOp:     LoadOp,
	stencilStoreOp:    StoreOp,
	stencilClearValue: u32,
	stencilReadOnly:   b32,
}

RenderPassDescriptor :: struct {
	nextInChain:            ^ChainedStruct,
	label:                  string,
	colorAttachmentCount:   uint,
	colorAttachments:       [^]RenderPassColorAttachment `fmt:"v,colorAttachmentCount"`,
	depthStencilAttachment: ^RenderPassDepthStencilAttachment,
	occlusionQuerySet:      QuerySet,
	timestampWrites:        ^RenderPassTimestampWrites,
}

RenderPassEncoder :: distinct rawptr

RenderPassMaxDrawCount :: struct {
	using chain:  ChainedStruct,
	maxDrawCount: u64,
}

RenderPassTimestampWrites :: struct {
	querySet:                  QuerySet,
	beginningOfPassWriteIndex: u32,
	endOfPassWriteIndex:       u32,
}

RenderPipeline :: distinct rawptr

RenderPipelineDescriptor :: struct {
	nextInChain:  ^ChainedStruct,
	label:        string,
	layout:       PipelineLayout,
	vertex:       VertexState,
	primitive:    PrimitiveState,
	depthStencil: ^DepthStencilState,
	multisample:  MultisampleState,
	fragment:     ^FragmentState,
}

RequestAdapterCallback :: proc "c" (status: RequestAdapterStatus, adapter: Adapter, message: string, userdata1: rawptr, userdata2: rawptr)

RequestAdapterCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    RequestAdapterCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

RequestAdapterOptions :: struct {
	nextInChain:          ^ChainedStruct,
	featureLevel:         FeatureLevel,
	powerPreference:      PowerPreference,
	forceFallbackAdapter: b32,
	backendType:          BackendType,
	compatibleSurface:    Surface,
}

RequestAdapterStatus :: enum i32 {
	Success         = 1, 
	InstanceDropped = 2, 
	Unavailable     = 3, 
	Error           = 4, 
	Unknown         = 5, 
}

RequestDeviceCallback :: proc "c" (status: RequestDeviceStatus, adapter: Device, message: string, userdata1: rawptr, userdata2: rawptr)

RequestDeviceCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	mode:        CallbackMode,
	callback:    RequestDeviceCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

RequestDeviceStatus :: enum i32 {
	Success         = 1, 
	InstanceDropped = 2, 
	Error           = 3, 
	Unknown         = 4, 
}

SType :: enum i32 {
	// WebGPU.
	ShaderSourceSPIRV                = 1, 
	ShaderSourceWGSL                 = 2, 
	RenderPassMaxDrawCount           = 3, 
	SurfaceSourceMetalLayer          = 4, 
	SurfaceSourceWindowsHWND         = 5, 
	SurfaceSourceXlibWindow          = 6, 
	SurfaceSourceWaylandSurface      = 7, 
	SurfaceSourceAndroidNativeWindow = 8, 
	SurfaceSourceXCBWindow           = 9, 
	// Native.
	DeviceExtras                     = 196609, 
	NativeLimits, 
	PipelineLayoutExtras, 
	ShaderModuleGLSLDescriptor, 
	SupportedLimitsExtras, 
	InstanceExtras, 
	BindGroupEntryExtras, 
	BindGroupLayoutEntryExtras, 
	QuerySetDescriptorExtras, 
	SurfaceConfigurationExtras, 
	// Odin.
	SurfaceSourceCanvasHTMLSelector  = 262145, 
}

Sampler :: distinct rawptr

SamplerBindingLayout :: struct {
	nextInChain: ^ChainedStruct,
	type:        SamplerBindingType,
}

SamplerBindingType :: enum i32 {
	BindingNotUsed = 0, 
	Undefined      = 1, 
	Filtering      = 2, 
	NonFiltering   = 3, 
	Comparison     = 4, 
}

SamplerDescriptor :: struct {
	nextInChain:   ^ChainedStruct,
	label:         string,
	addressModeU:  AddressMode,
	addressModeV:  AddressMode,
	addressModeW:  AddressMode,
	magFilter:     FilterMode,
	minFilter:     FilterMode,
	mipmapFilter:  MipmapFilterMode,
	lodMinClamp:   f32,
	lodMaxClamp:   f32,
	compare:       CompareFunction,
	maxAnisotropy: u16,
}

ShaderDefine :: struct {
	name:  string,
	value: string,
}

ShaderModule :: distinct rawptr

ShaderModuleDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
}

ShaderModuleDescriptorSpirV :: struct {
	label:      string,
	sourceSize: u32,
	source:     [^]u32 `fmt:"v,sourceSize"`,
}

ShaderModuleGLSLDescriptor :: struct {
	using chain: ChainedStruct,
	stage:       ShaderStage,
	code:        string,
	defineCount: uint,
	defines:     [^]ShaderDefine `fmt:"v,defineCount"`,
}

ShaderSourceSPIRV :: struct {
	using chain: ChainedStruct,
	codeSize: u32,
	code:     [^]u32 `fmt:"v,codeSize"`,
}

ShaderSourceWGSL :: struct {
	using chain: ChainedStruct,
	code:  string,
}

ShaderStage :: enum i32 {
	Vertex   = 0, 
	Fragment = 1, 
	Compute  = 2, 
}

ShaderStageFlags :: bit_set[ShaderStage; u64]

Status :: enum i32 {
	Success = 1, 
	Error   = 2, 
}

StencilFaceState :: struct {
	compare:     CompareFunction,
	failOp:      StencilOperation,
	depthFailOp: StencilOperation,
	passOp:      StencilOperation,
}

StencilOperation :: enum i32 {
	Undefined      = 0, 
	Keep           = 1, 
	Zero           = 2, 
	Replace        = 3, 
	Invert         = 4, 
	IncrementClamp = 5, 
	DecrementClamp = 6, 
	IncrementWrap  = 7, 
	DecrementWrap  = 8, 
}

StorageTextureAccess :: enum i32 {
	BindingNotUsed = 0, 
	Undefined      = 1, 
	WriteOnly      = 2, 
	ReadOnly       = 3, 
	ReadWrite      = 4, 
}

StorageTextureBindingLayout :: struct {
	nextInChain:   ^ChainedStruct,
	access:        StorageTextureAccess,
	format:        TextureFormat,
	viewDimension: TextureViewDimension,
}

StoreOp :: enum i32 {
	Undefined = 0, 
	Store     = 1, 
	Discard   = 2, 
}

StringView :: string

SubmissionIndex :: distinct u64

SupportedFeatures :: struct {
	featureCount: uint,
	features:     [^]FeatureName `fmt:"v,featureCount"`,
}

SupportedWGSLLanguageFeatures :: struct {
	featureCount: uint,
	features:     [^]WGSLLanguageFeatureName `fmt:"v,featureCount"`,
}

Surface :: distinct rawptr

SurfaceCapabilities :: struct {
	nextInChain:      ^ChainedStructOut,
	usages:           bit_set[TextureUsage; u64],
	formatCount:      uint,
	formats:          [^]TextureFormat `fmt:"v,formatCount"`,
	presentModeCount: uint,
	presentModes:     [^]PresentMode `fmt:"v,presentModeCount"`,
	alphaModeCount:   uint,
	alphaModes:       [^]CompositeAlphaMode `fmt:"v,alphaModeCount"`,
}

SurfaceConfiguration :: struct {
	nextInChain:     ^ChainedStruct,
	device:          Device,
	format:          TextureFormat,
	usage:           bit_set[TextureUsage; u64],
	width:           u32,
	height:          u32,
	viewFormatCount: uint,
	viewFormats:     [^]TextureFormat `fmt:"v,viewFormatCount"`,
	alphaMode:       CompositeAlphaMode,
	presentMode:     PresentMode,
}

SurfaceConfigurationExtras :: struct {
	using chain:                ChainedStruct,
	desiredMaximumFrameLatency: u32,
}

SurfaceDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       string,
}

SurfaceGetCurrentTextureStatus :: enum i32 {
	SuccessOptimal    = 1, 
	SuccessSuboptimal = 2, 
	Timeout           = 3, 
	Outdated          = 4, 
	Lost              = 5, 
	OutOfMemory       = 6, 
	DeviceLost        = 7, 
	Error             = 8, 
}

SurfaceSourceAndroidNativeWindow :: struct {
	using chain: ChainedStruct,
	window: rawptr,
}

SurfaceSourceCanvasHTMLSelector :: struct {
	using chain: ChainedStruct,
	selector: string,
}

SurfaceSourceMetalLayer :: struct {
	using chain: ChainedStruct,
	layer: rawptr,
}

SurfaceSourceWaylandSurface :: struct {
	using chain: ChainedStruct,
	display: rawptr,
	surface: rawptr,
}

SurfaceSourceWindowsHWND :: struct {
	using chain: ChainedStruct,
	hinstance: rawptr,
	hwnd:      rawptr,
}

SurfaceSourceXcbWindow :: struct {
	using chain: ChainedStruct,
	connection: rawptr,
	window:     u32,
}

SurfaceSourceXlibWindow :: struct {
	using chain: ChainedStruct,
	display: rawptr,
	window:  u64,
}

SurfaceTexture :: struct {
	nextInChain: ^ChainedStructOut,
	texture:     Texture,
	status:      SurfaceGetCurrentTextureStatus,
}

TexelCopyBufferInfo :: struct {
	layout: TexelCopyBufferLayout,
	buffer: Buffer,
}

TexelCopyBufferLayout :: struct {
	offset:       u64,
	bytesPerRow:  u32,
	rowsPerImage: u32,
}

TexelCopyTextureInfo :: struct {
	texture:  Texture,
	mipLevel: u32,
	origin:   Origin3D,
	aspect:   TextureAspect,
}

Texture :: distinct rawptr

TextureAspect :: enum i32 {
	Undefined   = 0, 
	All         = 1, 
	StencilOnly = 2, 
	DepthOnly   = 3, 
}

TextureBindingLayout :: struct {
	nextInChain:   ^ChainedStruct,
	sampleType:    TextureSampleType,
	viewDimension: TextureViewDimension,
	multisampled:  b32,
}

TextureDescriptor :: struct {
	nextInChain:     ^ChainedStruct,
	label:           string,
	usage:           bit_set[TextureUsage; u64],
	dimension:       TextureDimension,
	size:            Extent3D,
	format:          TextureFormat,
	mipLevelCount:   u32,
	sampleCount:     u32,
	viewFormatCount: uint,
	viewFormats:     [^]TextureFormat `fmt:"v,viewFormatCount"`,
}

TextureDimension :: enum i32 {
	Undefined = 0, 
	_1D       = 1, 
	_2D       = 2, 
	_3D       = 3, 
}

TextureFormat :: enum i32 {
	Undefined            = 0, 
	R8Unorm              = 1, 
	R8Snorm              = 2, 
	R8Uint               = 3, 
	R8Sint               = 4, 
	R16Uint              = 5, 
	R16Sint              = 6, 
	R16Float             = 7, 
	RG8Unorm             = 8, 
	RG8Snorm             = 9, 
	RG8Uint              = 10, 
	RG8Sint              = 11, 
	R32Float             = 12, 
	R32Uint              = 13, 
	R32Sint              = 14, 
	RG16Uint             = 15, 
	RG16Sint             = 16, 
	RG16Float            = 17, 
	RGBA8Unorm           = 18, 
	RGBA8UnormSrgb       = 19, 
	RGBA8Snorm           = 20, 
	RGBA8Uint            = 21, 
	RGBA8Sint            = 22, 
	BGRA8Unorm           = 23, 
	BGRA8UnormSrgb       = 24, 
	RGB10A2Uint          = 25, 
	RGB10A2Unorm         = 26, 
	RG11B10Ufloat        = 27, 
	RGB9E5Ufloat         = 28, 
	RG32Float            = 29, 
	RG32Uint             = 30, 
	RG32Sint             = 31, 
	RGBA16Uint           = 32, 
	RGBA16Sint           = 33, 
	RGBA16Float          = 34, 
	RGBA32Float          = 35, 
	RGBA32Uint           = 36, 
	RGBA32Sint           = 37, 
	Stencil8             = 38, 
	Depth16Unorm         = 39, 
	Depth24Plus          = 40, 
	Depth24PlusStencil8  = 41, 
	Depth32Float         = 42, 
	Depth32FloatStencil8 = 43, 
	BC1RGBAUnorm         = 44, 
	BC1RGBAUnormSrgb     = 45, 
	BC2RGBAUnorm         = 46, 
	BC2RGBAUnormSrgb     = 47, 
	BC3RGBAUnorm         = 48, 
	BC3RGBAUnormSrgb     = 49, 
	BC4RUnorm            = 50, 
	BC4RSnorm            = 51, 
	BC5RGUnorm           = 52, 
	BC5RGSnorm           = 53, 
	BC6HRGBUfloat        = 54, 
	BC6HRGBFloat         = 55, 
	BC7RGBAUnorm         = 56, 
	BC7RGBAUnormSrgb     = 57, 
	ETC2RGB8Unorm        = 58, 
	ETC2RGB8UnormSrgb    = 59, 
	ETC2RGB8A1Unorm      = 60, 
	ETC2RGB8A1UnormSrgb  = 61, 
	ETC2RGBA8Unorm       = 62, 
	ETC2RGBA8UnormSrgb   = 63, 
	EACR11Unorm          = 64, 
	EACR11Snorm          = 65, 
	EACRG11Unorm         = 66, 
	EACRG11Snorm         = 67, 
	ASTC4x4Unorm         = 68, 
	ASTC4x4UnormSrgb     = 69, 
	ASTC5x4Unorm         = 70, 
	ASTC5x4UnormSrgb     = 71, 
	ASTC5x5Unorm         = 72, 
	ASTC5x5UnormSrgb     = 73, 
	ASTC6x5Unorm         = 74, 
	ASTC6x5UnormSrgb     = 75, 
	ASTC6x6Unorm         = 76, 
	ASTC6x6UnormSrgb     = 77, 
	ASTC8x5Unorm         = 78, 
	ASTC8x5UnormSrgb     = 79, 
	ASTC8x6Unorm         = 80, 
	ASTC8x6UnormSrgb     = 81, 
	ASTC8x8Unorm         = 82, 
	ASTC8x8UnormSrgb     = 83, 
	ASTC10x5Unorm        = 84, 
	ASTC10x5UnormSrgb    = 85, 
	ASTC10x6Unorm        = 86, 
	ASTC10x6UnormSrgb    = 87, 
	ASTC10x8Unorm        = 88, 
	ASTC10x8UnormSrgb    = 89, 
	ASTC10x10Unorm       = 90, 
	ASTC10x10UnormSrgb   = 91, 
	ASTC12x10Unorm       = 92, 
	ASTC12x10UnormSrgb   = 93, 
	ASTC12x12Unorm       = 94, 
	ASTC12x12UnormSrgb   = 95, 
	// From FeatureName.TextureFormat16bitNorm
	R16Unorm             = 196609, 
	R16Snorm, 
	Rg16Unorm, 
	Rg16Snorm, 
	Rgba16Unorm, 
	Rgba16Snorm, 
	// From FeatureName.TextureFormatNv12
	NV12, 
}

TextureSampleType :: enum i32 {
	BindingNotUsed    = 0, 
	Undefined         = 1, 
	Float             = 2, 
	UnfilterableFloat = 3, 
	Depth             = 4, 
	Sint              = 5, 
	Uint              = 6, 
}

TextureUsage :: enum i32 {
	CopySrc          = 0, 
	CopyDst          = 1, 
	TextureBinding   = 2, 
	StorageBinding   = 3, 
	RenderAttachment = 4, 
}

TextureUsageFlags :: bit_set[TextureUsage; u64]

TextureView :: distinct rawptr

TextureViewDescriptor :: struct {
	nextInChain:     ^ChainedStruct,
	label:           string,
	format:          TextureFormat,
	dimension:       TextureViewDimension,
	baseMipLevel:    u32,
	mipLevelCount:   u32,
	baseArrayLayer:  u32,
	arrayLayerCount: u32,
	aspect:          TextureAspect,
	usage:           bit_set[TextureUsage; u64],
}

TextureViewDimension :: enum i32 {
	Undefined = 0, 
	_1D       = 1, 
	_2D       = 2, 
	_2DArray  = 3, 
	Cube      = 4, 
	CubeArray = 5, 
	_3D       = 6, 
}

UncapturedErrorCallback :: proc "c" (device: ^Device, type: ErrorType, message: string, userdata1: rawptr, userdata2: rawptr)

UncapturedErrorCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	callback:    UncapturedErrorCallback,
	userdata1:   rawptr,
	userdata2:   rawptr,
}

VertexAttribute :: struct {
	format:         VertexFormat,
	offset:         u64,
	shaderLocation: u32,
}

VertexBufferLayout :: struct {
	stepMode:       VertexStepMode,
	arrayStride:    u64,
	attributeCount: uint,
	attributes:     [^]VertexAttribute `fmt:"v,attributeCount"`,
}

VertexFormat :: enum i32 {
	Uint8           = 1, 
	Uint8x2         = 2, 
	Uint8x4         = 3, 
	Sint8           = 4, 
	Sint8x2         = 5, 
	Sint8x4         = 6, 
	Unorm8          = 7, 
	Unorm8x2        = 8, 
	Unorm8x4        = 9, 
	Snorm8          = 10, 
	Snorm8x2        = 11, 
	Snorm8x4        = 12, 
	Uint16          = 13, 
	Uint16x2        = 14, 
	Uint16x4        = 15, 
	Sint16          = 16, 
	Sint16x2        = 17, 
	Sint16x4        = 18, 
	Unorm16         = 19, 
	Unorm16x2       = 20, 
	Unorm16x4       = 21, 
	Snorm16         = 22, 
	Snorm16x2       = 23, 
	Snorm16x4       = 24, 
	Float16         = 25, 
	Float16x2       = 26, 
	Float16x4       = 27, 
	Float32         = 28, 
	Float32x2       = 29, 
	Float32x3       = 30, 
	Float32x4       = 31, 
	Uint32          = 32, 
	Uint32x2        = 33, 
	Uint32x3        = 34, 
	Uint32x4        = 35, 
	Sint32          = 36, 
	Sint32x2        = 37, 
	Sint32x3        = 38, 
	Sint32x4        = 39, 
	Unorm10_10_10_2 = 40, 
	Unorm8x4BGRA    = 41, 
}

VertexState :: struct {
	nextInChain:   ^ChainedStruct,
	module:        ShaderModule,
	entryPoint:    string,
	constantCount: uint,
	constants:     [^]ConstantEntry `fmt:"v,constantCount"`,
	bufferCount:   uint,
	buffers:       [^]VertexBufferLayout `fmt:"v,bufferCount"`,
}

VertexStepMode :: enum i32 {
	VertexBufferNotUsed = 0, 
	Undefined           = 1, 
	Vertex              = 2, 
	Instance            = 3, 
}

WGSLLanguageFeatureName :: enum i32 {
	ReadonlyAndReadwriteStorageTextures = 1, 
	Packed4x8IntegerDotProduct          = 2, 
	UnrestrictedPointerParameters       = 3, 
	PointerCompositeAccess              = 4, 
}

WaitStatus :: enum i32 {
	Success                = 1, 
	TimedOut               = 2, 
	UnsupportedTimeout     = 3, 
	UnsupportedCount       = 4, 
	UnsupportedMixedSource = 5, 
}

ARRAY_LAYER_COUNT_UNDEFINED: u32 : max(u32)

BINDINGS_VERSION: [4]u8 : [4]u8{24, 0, 0, 2}

BINDINGS_VERSION_STRING: string : "24.0.0.2"

COPY_STRIDE_UNDEFINED: u32 : max(u32)

ColorWriteMaskFlags_All: bit_set[ColorWriteMask; u64] : ColorWriteMaskFlags{.Red, .Green, .Blue, .Alpha}

DEPTH_SLICE_UNDEFINED: u32 : max(u32)

InstanceBackendFlags_All: bit_set[InstanceBackend; u64] : InstanceBackendFlags{}

InstanceBackendFlags_Primary: bit_set[InstanceBackend; u64] : InstanceBackendFlags{.Vulkan, .Metal, .DX12, .BrowserWebGPU}

InstanceBackendFlags_Secondary: bit_set[InstanceBackend; u64] : InstanceBackendFlags{.GL, .DX11}

InstanceFlags_Default: bit_set[InstanceFlag; u64] : InstanceFlags{}

LIMIT_U32_UNDEFINED: u32 : max(u32)

LIMIT_U64_UNDEFINED: u64 : max(u64)

MIP_LEVEL_COUNT_UNDEFINED: u32 : max(u32)

QUERY_SET_INDEX_UNDEFINED: u32 : max(u32)

STRLEN: int : transmute(int)(max(uint))

WGPU_DEBUG: bool : #config(WGPU_DEBUG, false)

WGPU_SHARED: bool : #config(WGPU_SHARED, false)

WHOLE_MAP_SIZE: uint : max(uint)

WHOLE_SIZE: u64 : max(u64)

AdapterAddRef :: proc "c" (adapter: Adapter) ---

AdapterGetFeatures :: proc "c" (adapter: Adapter) -> (features: SupportedFeatures) {…}

AdapterGetInfo :: proc "c" (adapter: Adapter) -> (info: AdapterInfo, status: Status) {…}

AdapterGetLimits :: proc "c" (adapter: Adapter) -> (limits: Limits, status: Status) {…}

AdapterHasFeature :: proc "c" (adapter: Adapter, feature: FeatureName) -> b32 ---

AdapterInfoFreeMembers :: proc "c" (adapterInfo: AdapterInfo) ---

AdapterRelease :: proc "c" (adapter: Adapter) ---

AdapterRequestDevice :: proc "c" (adapter: Adapter, descriptor: ^DeviceDescriptor, callbackInfo: RequestDeviceCallbackInfo) -> Future ---

BindGroupAddRef :: proc "c" (bindGroup: BindGroup) ---

BindGroupLayoutAddRef :: proc "c" (bindGroupLayout: BindGroupLayout) ---

BindGroupLayoutRelease :: proc "c" (bindGroupLayout: BindGroupLayout) ---

BindGroupLayoutSetLabel :: proc "c" (bindGroupLayout: BindGroupLayout, label: cstring) ---

BindGroupRelease :: proc "c" (bindGroup: BindGroup) ---

BindGroupSetLabel :: proc "c" (bindGroup: BindGroup, label: string) ---

BufferAddRef :: proc "c" (buffer: Buffer) ---

BufferDestroy :: proc "c" (buffer: Buffer) ---

BufferGetConstMappedRange :: proc "c" (buffer: Buffer, offset: uint, size: uint) -> []u8 {…}

BufferGetConstMappedRangeSlice :: proc "c" (buffer: Buffer, offset: uint, length: uint, $T: typeid) -> []typeid {…}

BufferGetConstMappedRangeTyped :: proc "c" (buffer: Buffer, offset: uint, $T: typeid) -> ^typeid {…}

BufferGetMapState :: proc "c" (buffer: Buffer) -> BufferMapState ---

BufferGetMappedRange :: proc "c" (buffer: Buffer, offset: uint, size: uint) -> []u8 {…}

BufferGetMappedRangeSlice :: proc "c" (buffer: Buffer, offset: uint, $T: typeid, length: uint) -> []typeid {…}

BufferGetMappedRangeTyped :: proc "c" (buffer: Buffer, offset: uint, $T: typeid) -> ^typeid {…}

BufferGetSize :: proc "c" (buffer: Buffer) -> u64 ---

BufferGetUsage :: proc "c" (buffer: Buffer) -> bit_set[BufferUsage; u64] ---

BufferMapAsync :: proc "c" (buffer: Buffer, mode: bit_set[MapMode; u64], offset: uint, size: uint, callbackInfo: BufferMapCallbackInfo) -> Future ---

BufferRelease :: proc "c" (buffer: Buffer) ---

BufferSetLabel :: proc "c" (buffer: Buffer, label: string) ---

BufferUnmap :: proc "c" (buffer: Buffer) ---

CommandBufferAddRef :: proc "c" (commandBuffer: CommandBuffer) ---

CommandBufferRelease :: proc "c" (commandBuffer: CommandBuffer) ---

CommandBufferSetLabel :: proc "c" (commandBuffer: CommandBuffer, label: string) ---

CommandEncoderAddRef :: proc "c" (commandEncoder: CommandEncoder) ---

CommandEncoderBeginComputePass :: proc "c" (commandEncoder: CommandEncoder, descriptor: ^ComputePassDescriptor = nil) -> ComputePassEncoder ---

CommandEncoderBeginRenderPass :: proc "c" (commandEncoder: CommandEncoder, descriptor: ^RenderPassDescriptor) -> RenderPassEncoder ---

CommandEncoderClearBuffer :: proc "c" (commandEncoder: CommandEncoder, buffer: Buffer, offset: u64, size: u64) ---

CommandEncoderCopyBufferToBuffer :: proc "c" (
	commandEncoder:    CommandEncoder, 
	source:            Buffer, 
	sourceOffset:      u64, 
	destination:       Buffer, 
	destinationOffset: u64, 
	size:              u64, 
) ---

CommandEncoderCopyBufferToTexture :: proc "c" (commandEncoder: CommandEncoder, source: ^TexelCopyBufferInfo, destination: ^TexelCopyTextureInfo, copySize: ^Extent3D) ---

CommandEncoderCopyTextureToBuffer :: proc "c" (commandEncoder: CommandEncoder, source: ^TexelCopyTextureInfo, destination: ^TexelCopyBufferInfo, copySize: ^Extent3D) ---

CommandEncoderCopyTextureToTexture :: proc "c" (commandEncoder: CommandEncoder, source: ^TexelCopyTextureInfo, destination: ^TexelCopyTextureInfo, copySize: ^Extent3D) ---

CommandEncoderFinish :: proc "c" (commandEncoder: CommandEncoder, descriptor: ^CommandBufferDescriptor = nil) -> CommandBuffer ---

CommandEncoderInsertDebugMarker :: proc "c" (commandEncoder: CommandEncoder, markerLabel: string) ---

CommandEncoderPopDebugGroup :: proc "c" (commandEncoder: CommandEncoder) ---

CommandEncoderPushDebugGroup :: proc "c" (commandEncoder: CommandEncoder, groupLabel: string) ---

CommandEncoderRelease :: proc "c" (commandEncoder: CommandEncoder) ---

CommandEncoderResolveQuerySet :: proc "c" (
	commandEncoder:    CommandEncoder, 
	querySet:          QuerySet, 
	firstQuery:        u32, 
	queryCount:        u32, 
	destination:       Buffer, 
	destinationOffset: u64, 
) ---

CommandEncoderSetLabel :: proc "c" (commandEncoder: CommandEncoder, label: string) ---

CommandEncoderWriteTimestamp :: proc "c" (commandEncoder: CommandEncoder, querySet: QuerySet, queryIndex: u32) ---

ComputePassEncoderAddRef :: proc "c" (computePassEncoder: ComputePassEncoder) ---

ComputePassEncoderBeginPipelineStatisticsQuery :: proc "c" (computePassEncoder: ComputePassEncoder, querySet: QuerySet, queryIndex: u32) ---

ComputePassEncoderDispatchWorkgroups :: proc "c" (computePassEncoder: ComputePassEncoder, workgroupCountX: u32, workgroupCountY: u32, workgroupCountZ: u32) ---

ComputePassEncoderDispatchWorkgroupsIndirect :: proc "c" (computePassEncoder: ComputePassEncoder, indirectBuffer: Buffer, indirectOffset: u64) ---

ComputePassEncoderEnd :: proc "c" (computePassEncoder: ComputePassEncoder) ---

ComputePassEncoderEndPipelineStatisticsQuery :: proc "c" (computePassEncoder: ComputePassEncoder) ---

ComputePassEncoderInsertDebugMarker :: proc "c" (computePassEncoder: ComputePassEncoder, markerLabel: string) ---

ComputePassEncoderPopDebugGroup :: proc "c" (computePassEncoder: ComputePassEncoder) ---

ComputePassEncoderPushDebugGroup :: proc "c" (computePassEncoder: ComputePassEncoder, groupLabel: string) ---

ComputePassEncoderRelease :: proc "c" (computePassEncoder: ComputePassEncoder) ---

ComputePassEncoderSetBindGroup :: proc "c" (computePassEncoder: ComputePassEncoder, groupIndex: u32, group: BindGroup, dynamicOffsets: []u32 = nil) {…}

ComputePassEncoderSetLabel :: proc "c" (computePassEncoder: ComputePassEncoder, label: string) ---

ComputePassEncoderSetPipeline :: proc "c" (computePassEncoder: ComputePassEncoder, pipeline: ComputePipeline) ---

ComputePassEncoderSetPushConstants :: proc "c" (encoder: ComputePassEncoder, offset: u32, sizeBytes: u32, data: rawptr) ---

ComputePassEncoderWriteTimestamp :: proc "c" (computePassEncoder: ComputePassEncoder, querySet: QuerySet, queryIndex: u32) ---

ComputePipelineAddRef :: proc "c" (computePipeline: ComputePipeline) ---

ComputePipelineGetBindGroupLayout :: proc "c" (computePipeline: ComputePipeline, groupIndex: u32) -> BindGroupLayout ---

ComputePipelineRelease :: proc "c" (computePipeline: ComputePipeline) ---

ComputePipelineSetLabel :: proc "c" (computePipeline: ComputePipeline, label: string) ---

ConvertOdinToWGPULogLevel :: proc(level: runtime.Logger_Level) -> LogLevel {…}

ConvertWGPUToOdinLogLevel :: proc(level: LogLevel) -> runtime.Logger_Level {…}

CreateInstance :: proc "c" (descriptor: ^InstanceDescriptor = nil) -> Instance {…}

DeviceAddRef :: proc "c" (device: Device) ---

DeviceCreateBindGroup :: proc "c" (device: Device, descriptor: ^BindGroupDescriptor) -> BindGroup ---

DeviceCreateBindGroupLayout :: proc "c" (device: Device, descriptor: ^BindGroupLayoutDescriptor) -> BindGroupLayout ---

DeviceCreateBuffer :: proc "c" (device: Device, descriptor: ^BufferDescriptor) -> Buffer ---

DeviceCreateBufferWithDataSlice :: proc "c" (device: Device, descriptor: ^BufferWithDataDescriptor, data: []$T) -> (buf: Buffer) {…}

DeviceCreateBufferWithDataTyped :: proc "c" (device: Device, descriptor: ^BufferWithDataDescriptor, data: $T) -> (buf: Buffer) {…}

DeviceCreateCommandEncoder :: proc "c" (device: Device, descriptor: ^CommandEncoderDescriptor = nil) -> CommandEncoder ---

DeviceCreateComputePipeline :: proc "c" (device: Device, descriptor: ^ComputePipelineDescriptor) -> ComputePipeline ---

DeviceCreateComputePipelineAsync :: proc "c" (device: Device, descriptor: ^ComputePipelineDescriptor, callbackInfo: CreateComputePipelineAsyncCallbackInfo) -> Future ---

DeviceCreatePipelineLayout :: proc "c" (device: Device, descriptor: ^PipelineLayoutDescriptor) -> PipelineLayout ---

DeviceCreateQuerySet :: proc "c" (device: Device, descriptor: ^QuerySetDescriptor) -> QuerySet ---

DeviceCreateRenderBundleEncoder :: proc "c" (device: Device, descriptor: ^RenderBundleEncoderDescriptor) -> RenderBundleEncoder ---

DeviceCreateRenderPipeline :: proc "c" (device: Device, descriptor: ^RenderPipelineDescriptor) -> RenderPipeline ---

DeviceCreateRenderPipelineAsync :: proc "c" (device: Device, descriptor: ^RenderPipelineDescriptor, callbackInfo: CreateRenderPipelineAsyncCallbackInfo) -> Future ---

DeviceCreateSampler :: proc "c" (device: Device, descriptor: ^SamplerDescriptor = nil) -> Sampler ---

DeviceCreateShaderModule :: proc "c" (device: Device, descriptor: ^ShaderModuleDescriptor) -> ShaderModule ---

DeviceCreateShaderModuleSpirV :: proc "c" (device: Device, descriptor: ^ShaderModuleDescriptorSpirV) -> ShaderModule ---

DeviceCreateTexture :: proc "c" (device: Device, descriptor: ^TextureDescriptor) -> Texture ---

DeviceDestroy :: proc "c" (device: Device) ---

DeviceGetAdapterInfo :: proc "c" (device: Device) -> (info: AdapterInfo, status: Status) {…}

DeviceGetFeatures :: proc "c" (device: Device) -> (features: SupportedFeatures) {…}

DeviceGetLimits :: proc "c" (device: Device) -> (limits: Limits, status: Status) {…}

DeviceGetLostFuture :: proc "c" (device: Device) -> Future ---

DeviceGetQueue :: proc "c" (device: Device) -> Queue ---

DeviceHasFeature :: proc "c" (device: Device, feature: FeatureName) -> b32 ---

DevicePoll :: proc "c" (device: Device, wait: b32, wrappedSubmissionIndex: ^SubmissionIndex = nil) -> b32 ---

DevicePopErrorScope :: proc "c" (device: Device, callbackInfo: PopErrorScopeCallbackInfo) -> Future ---

DevicePushErrorScope :: proc "c" (device: Device, filter: ErrorFilter) ---

DeviceRelease :: proc "c" (device: Device) ---

DeviceSetLabel :: proc "c" (device: Device, label: string) ---

GenerateReport :: proc "c" (instance: Instance) -> (report: GlobalReport) {…}

GetInstanceCapabilities :: proc "c" () -> (capabilities: InstanceCapabilities, status: Status) {…}

GetProcAddress :: proc "c" (procName: string) -> Proc ---

GetVersion :: proc "c" () -> u32 ---

InstanceAddRef :: proc "c" (instance: Instance) ---

InstanceCreateSurface :: proc "c" (instance: Instance, descriptor: ^SurfaceDescriptor) -> Surface ---

InstanceEnumerateAdapters :: proc(instance: Instance, options: ^InstanceEnumerateAdapterOptions = nil, allocator := context.allocator) -> (adapters: []Adapter) {…}

InstanceGetWGSLLanguageFeatures :: proc "c" (instance: Instance) -> (features: SupportedWGSLLanguageFeatures, status: Status) {…}

InstanceHasWGSLLanguageFeature :: proc "c" (instance: Instance, feature: WGSLLanguageFeatureName) -> b32 ---

InstanceProcessEvents :: proc "c" (instance: Instance) ---

InstanceRelease :: proc "c" (instance: Instance) ---

InstanceRequestAdapter :: proc "c" (instance: Instance, options: ^RequestAdapterOptions, callbackInfo: RequestAdapterCallbackInfo) -> Future ---

InstanceWaitAny :: proc "c" (instance: Instance, futureCount: uint, futures: [^]FutureWaitInfo, timeoutNS: u64) -> WaitStatus ---

PipelineLayoutAddRef :: proc "c" (pipelineLayout: PipelineLayout) ---

PipelineLayoutRelease :: proc "c" (pipelineLayout: PipelineLayout) ---

PipelineLayoutSetLabel :: proc "c" (pipelineLayout: PipelineLayout, label: string) ---

QuerySetAddRef :: proc "c" (querySet: QuerySet) ---

QuerySetDestroy :: proc "c" (querySet: QuerySet) ---

QuerySetGetCount :: proc "c" (querySet: QuerySet) -> u32 ---

QuerySetGetType :: proc "c" (querySet: QuerySet) -> QueryType ---

QuerySetRelease :: proc "c" (querySet: QuerySet) ---

QuerySetSetLabel :: proc "c" (querySet: QuerySet, label: string) ---

QueueAddRef :: proc "c" (queue: Queue) ---

QueueOnSubmittedWorkDone :: proc "c" (queue: Queue, callbackInfo: QueueWorkDoneCallbackInfo) -> Future ---

QueueRelease :: proc "c" (queue: Queue) ---

QueueSetLabel :: proc "c" (queue: Queue, label: string) ---

QueueSubmit :: proc "c" (queue: Queue, commands: []CommandBuffer) {…}

QueueSubmitForIndex :: proc "c" (queue: Queue, commands: []CommandBuffer) -> SubmissionIndex {…}

QueueWriteBuffer :: proc "c" (queue: Queue, buffer: Buffer, bufferOffset: u64, data: rawptr, size: uint) ---

QueueWriteTexture :: proc "c" (
	queue:       Queue, 
	destination: ^TexelCopyTextureInfo, 
	data:        rawptr, 
	dataSize:    uint, 
	dataLayout:  ^TexelCopyBufferLayout, 
	writeSize:   ^Extent3D, 
) ---

RawAdapterGetFeatures :: proc "c" (adapter: Adapter, features: ^SupportedFeatures) ---

RawAdapterGetInfo :: proc "c" (adapter: Adapter, info: ^AdapterInfo) -> Status ---

RawAdapterGetLimits :: proc "c" (adapter: Adapter, limits: ^Limits) -> Status ---

RawBufferGetConstMappedRange :: proc "c" (buffer: Buffer, offset: uint, size: uint) -> rawptr ---

RawBufferGetMappedRange :: proc "c" (buffer: Buffer, offset: uint, size: uint) -> rawptr ---

RawComputePassEncoderSetBindGroup :: proc "c" (computePassEncoder: ComputePassEncoder, groupIndex: u32, group: BindGroup, dynamicOffsetCount: uint, dynamicOffsets: [^]u32) ---

RawCreateInstance :: proc "c" (descriptor: ^InstanceDescriptor = nil) -> Instance ---

RawDeviceGetAdapterInfo :: proc "c" (device: Device, info: ^AdapterInfo) -> Status ---

RawDeviceGetFeatures :: proc "c" (device: Device, features: ^SupportedFeatures) ---

RawDeviceGetLimits :: proc "c" (device: Device, limits: ^Limits) -> Status ---

RawGenerateReport :: proc "c" (instance: Instance, report: ^GlobalReport) ---

RawGetInstanceCapabilities :: proc "c" (capabilities: ^InstanceCapabilities) -> Status ---

RawInstanceEnumerateAdapters :: proc "c" (instance: Instance, options: ^InstanceEnumerateAdapterOptions, adapters: [^]Adapter) -> uint ---

RawInstanceGetWGSLLanguageFeatures :: proc "c" (instance: Instance, features: ^SupportedWGSLLanguageFeatures) -> Status ---

RawQueueSubmit :: proc "c" (queue: Queue, commandCount: uint, commands: [^]CommandBuffer) ---

RawQueueSubmitForIndex :: proc "c" (queue: Queue, commandCount: uint, commands: [^]CommandBuffer) -> SubmissionIndex ---

RawRenderBundleEncoderSetBindGroup :: proc "c" (renderBundleEncoder: RenderBundleEncoder, groupIndex: u32, group: BindGroup, dynamicOffsetCount: uint, dynamicOffsets: [^]u32) ---

RawRenderPassEncoderExecuteBundles :: proc "c" (renderPassEncoder: RenderPassEncoder, bundleCount: uint, bundles: [^]RenderBundle) ---