package vendor:wgpu

Source

Adapter :: distinct rawptr

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

AdapterRequestDeviceCallback :: proc "c" (status: RequestDeviceStatus, device: Device, message: cstring, userdata: rawptr)

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

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

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:       cstring,
	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:       cstring,
	entryCount:  uint,
	entries:     [^]BindGroupLayoutEntry `fmt:"v,entryCount"`,
}

BindGroupLayoutEntry :: struct {
	nextInChain:    ^ChainedStruct,
	binding:        u32,
	visibility:     bit_set[ShaderStage; u32],
	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 {
	Zero              = 0, 
	One               = 1, 
	Src               = 2, 
	OneMinusSrc       = 3, 
	SrcAlpha          = 4, 
	OneMinusSrcAlpha  = 5, 
	Dst               = 6, 
	OneMinusDst       = 7, 
	DstAlpha          = 8, 
	OneMinusDstAlpha  = 9, 
	SrcAlphaSaturated = 10, 
	Constant          = 11, 
	OneMinusConstant  = 12, 
}

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 {
	Undefined       = 0, 
	Uniform         = 1, 
	Storage         = 2, 
	ReadOnlyStorage = 3, 
}

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

BufferMapAsyncCallback :: proc "c" (status: BufferMapAsyncStatus, userdata: rawptr)

BufferMapAsyncStatus :: enum i32 {
	Success                 = 0, 
	ValidationError         = 1, 
	Unknown                 = 2, 
	DeviceLost              = 3, 
	DestroyedBeforeCallback = 4, 
	UnmappedBeforeCallback  = 5, 
	MappingAlreadyPending   = 6, 
	OffsetOutOfRange        = 7, 
	SizeOutOfRange          = 8, 
}

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

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; u32]

BufferWithDataDescriptor :: struct {
	label: cstring,
	usage: bit_set[BufferUsage; u32],
}

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; u32],
}

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

ColorWriteMaskFlags :: bit_set[ColorWriteMask; u32]

CommandBuffer :: distinct rawptr

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

CommandEncoder :: distinct rawptr

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

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

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

CompilationInfoRequestStatus :: enum i32 {
	Success    = 0, 
	Error      = 1, 
	DeviceLost = 2, 
	Unknown    = 3, 
}

CompilationMessage :: struct {
	nextInChain:  ^ChainedStruct,
	message:      cstring,
	type:         CompilationMessageType,
	lineNum:      u64,
	linePos:      u64,
	offset:       u64,
	length:       u64,
	utf16LinePos: u64,
	utf16Offset:  u64,
	utf16Length:  u64,
}

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

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

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

ComputePassEncoder :: distinct rawptr

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

ComputePipeline :: distinct rawptr

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

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

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

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

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

Device :: distinct rawptr

DeviceCreateComputePipelineAsyncCallback :: proc "c" (status: CreatePipelineAsyncStatus, pipeline: ComputePipeline, message: cstring, userdata: rawptr)

DeviceCreateRenderPipelineAsyncCallback :: proc "c" (status: CreatePipelineAsyncStatus, pipeline: RenderPipeline, message: cstring, userdata: rawptr)

DeviceDescriptor :: struct {
	nextInChain:                 ^ChainedStruct,
	label:                       cstring,
	requiredFeatureCount:        uint,
	requiredFeatures:            [^]FeatureName `fmt:"v,requiredFeatureCount"`,
	requiredLimits:              ^RequiredLimits,
	defaultQueue:                QueueDescriptor,
	deviceLostCallback:          DeviceLostCallback,
	deviceLostUserdata:          rawptr,
	uncapturedErrorCallbackInfo: UncapturedErrorCallbackInfo,
}

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

DeviceLostCallback :: proc "c" (reason: DeviceLostReason, message: cstring, userdata: rawptr)

DeviceLostReason :: enum i32 {
	Undefined = 0, 
	Unknown   = 1, 
	Destroyed = 2, 
}

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

ErrorCallback :: proc "c" (type: ErrorType, message: cstring, userdata: rawptr)

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

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

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

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

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

Flags :: u32

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

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

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

GlobalReport :: struct {
	surfaces:    RegistryReport,
	backendType: BackendType,
	vulkan:      HubReport,
	metal:       HubReport,
	dx12:        HubReport,
	gl:          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,
	querySets:        RegistryReport,
	buffers:          RegistryReport,
	textures:         RegistryReport,
	textureViews:     RegistryReport,
	samplers:         RegistryReport,
}

ImageCopyBuffer :: struct {
	nextInChain: ^ChainedStruct,
	layout:      TextureDataLayout,
	buffer:      Buffer,
}

ImageCopyTexture :: struct {
	nextInChain: ^ChainedStruct,
	texture:     Texture,
	mipLevel:    u32,
	origin:      Origin3D,
	aspect:      TextureAspect,
}

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; u32]

InstanceDescriptor :: struct {
	nextInChain: ^ChainedStruct,
}

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

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

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

InstanceFlags :: bit_set[InstanceFlag; u32]

InstanceRequestAdapterCallback :: proc "c" (status: RequestAdapterStatus, adapter: Adapter, message: cstring, userdata: rawptr)

Limits :: struct {
	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,
	maxInterStageShaderComponents:             u32,
	maxInterStageShaderVariables:              u32,
	maxColorAttachments:                       u32,
	maxColorAttachmentBytesPerSample:          u32,
	maxComputeWorkgroupStorageSize:            u32,
	maxComputeInvocationsPerWorkgroup:         u32,
	maxComputeWorkgroupSizeX:                  u32,
	maxComputeWorkgroupSizeY:                  u32,
	maxComputeWorkgroupSizeZ:                  u32,
	maxComputeWorkgroupsPerDimension:          u32,
}

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

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

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

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

MapModeFlags :: bit_set[MapMode; u32]

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

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

NativeLimits :: struct {
	maxPushConstantSize:   u32,
	maxNonSamplerBindings: u32,
}

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

PipelineLayout :: distinct rawptr

PipelineLayoutDescriptor :: struct {
	nextInChain:          ^ChainedStruct,
	label:                cstring,
	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, 
}

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

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

PrimitiveDepthClipControl :: struct {
	using chain:    ChainedStruct,
	unclippedDepth: b32,
}

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

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

Proc :: distinct rawptr

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

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

QuerySet :: distinct rawptr

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

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

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

Queue :: distinct rawptr

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

QueueOnSubmittedWorkDoneCallback :: proc "c" (status: QueueWorkDoneStatus, userdata: rawptr)

QueueWorkDoneStatus :: enum i32 {
	Success    = 0, 
	Error      = 1, 
	Unknown    = 2, 
	DeviceLost = 3, 
}

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

RenderBundle :: distinct rawptr

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

RenderBundleEncoder :: distinct rawptr

RenderBundleEncoderDescriptor :: struct {
	nextInChain:        ^ChainedStruct,
	label:              cstring,
	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:                  cstring,
	colorAttachmentCount:   uint,
	colorAttachments:       [^]RenderPassColorAttachment `fmt:"v,colorAttachmentCount"`,
	depthStencilAttachment: ^RenderPassDepthStencilAttachment,
	occlusionQuerySet:      QuerySet,
	timestampWrites:        ^RenderPassTimestampWrites,
}

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

RenderPassEncoder :: distinct rawptr

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

RenderPipeline :: distinct rawptr

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

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

RequestAdapterStatus :: enum i32 {
	Success     = 0, 
	Unavailable = 1, 
	Error       = 2, 
	Unknown     = 3, 
}

RequestDeviceStatus :: enum i32 {
	Success = 0, 
	Error   = 1, 
	Unknown = 2, 
}

RequiredLimits :: struct {
	nextInChain: ^ChainedStruct,
	limits:      Limits,
}

RequiredLimitsExtras :: struct {
	using chain: ChainedStruct,
	limits: NativeLimits,
}

SType :: enum i32 {
	// WebGPU.
	Invalid                                  = 0, 
	SurfaceDescriptorFromMetalLayer          = 1, 
	SurfaceDescriptorFromWindowsHWND         = 2, 
	SurfaceDescriptorFromXlibWindow          = 3, 
	SurfaceDescriptorFromCanvasHTMLSelector  = 4, 
	ShaderModuleSPIRVDescriptor              = 5, 
	ShaderModuleWGSLDescriptor               = 6, 
	PrimitiveDepthClipControl                = 7, 
	SurfaceDescriptorFromWaylandSurface      = 8, 
	SurfaceDescriptorFromAndroidNativeWindow = 9, 
	SurfaceDescriptorFromXcbWindow           = 10, 
	RenderPassDescriptorMaxDrawCount         = 15, 
	// Native.
	DeviceExtras                             = 196609, 
	RequiredLimitsExtras, 
	PipelineLayoutExtras, 
	ShaderModuleGLSLDescriptor, 
	SupportedLimitsExtras, 
	InstanceExtras, 
	BindGroupEntryExtras, 
	BindGroupLayoutEntryExtras, 
	QuerySetDescriptorExtras, 
	SurfaceConfigurationExtras, 
}

Sampler :: distinct rawptr

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

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

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

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

ShaderModule :: distinct rawptr

ShaderModuleCompilationHint :: struct {
	nextInChain: ^ChainedStruct,
	entryPoint:  cstring,
	layout:      PipelineLayout,
}

ShaderModuleDescriptor :: struct {
	nextInChain: ^ChainedStruct,
	label:       cstring,
	hintCount:   uint,
	hints:       [^]ShaderModuleCompilationHint `fmt:"v,hintCount"`,
}

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

ShaderModuleGetCompilationInfoCallback :: proc "c" (status: CompilationInfoRequestStatus, compilationInfo: ^CompilationInfo, userdata: rawptr)

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

ShaderModuleWGSLDescriptor :: struct {
	using chain: ChainedStruct,
	code:  cstring,
}

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

ShaderStageFlags :: bit_set[ShaderStage; u32]

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

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

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

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

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

SubmissionIndex :: distinct u64

SupportedLimits :: struct {
	nextInChain: ^ChainedStructOut,
	limits:      Limits,
}

SupportedLimitsExtras :: struct {
	using chain: ChainedStructOut,
	limits: NativeLimits,
}

Surface :: distinct rawptr

SurfaceCapabilities :: struct {
	nextInChain:      ^ChainedStructOut,
	usages:           bit_set[TextureUsage; u32],
	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; u32],
	viewFormatCount: uint,
	viewFormats:     [^]TextureFormat `fmt:"v,viewFormatCount"`,
	alphaMode:       CompositeAlphaMode,
	width:           u32,
	height:          u32,
	presentMode:     PresentMode,
}

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

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

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

SurfaceDescriptorFromCanvasHTMLSelector :: struct {
	using chain: ChainedStruct,
	selector: cstring,
}

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

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

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

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

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

SurfaceGetCurrentTextureStatus :: enum i32 {
	Success     = 0, 
	Timeout     = 1, 
	Outdated    = 2, 
	Lost        = 3, 
	OutOfMemory = 4, 
	DeviceLost  = 5, 
}

SurfaceTexture :: struct {
	texture:    Texture,
	suboptimal: b32,
	status:     SurfaceGetCurrentTextureStatus,
}

Texture :: distinct rawptr

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

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

TextureDataLayout :: struct {
	nextInChain:  ^ChainedStruct,
	offset:       u64,
	bytesPerRow:  u32,
	rowsPerImage: u32,
}

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

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

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 {
	Undefined         = 0, 
	Float             = 1, 
	UnfilterableFloat = 2, 
	Depth             = 3, 
	Sint              = 4, 
	Uint              = 5, 
}

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

TextureUsageFlags :: bit_set[TextureUsage; u32]

TextureView :: distinct rawptr

TextureViewDescriptor :: struct {
	nextInChain:     ^ChainedStruct,
	label:           cstring,
	format:          TextureFormat,
	dimension:       TextureViewDimension,
	baseMipLevel:    u32,
	mipLevelCount:   u32,
	baseArrayLayer:  u32,
	arrayLayerCount: u32,
	aspect:          TextureAspect,
}

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

UncapturedErrorCallbackInfo :: struct {
	nextInChain: ^ChainedStruct,
	callback:    ErrorCallback,
	userdata:    rawptr,
}

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

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

VertexFormat :: enum i32 {
	Undefined = 0, 
	Uint8x2   = 1, 
	Uint8x4   = 2, 
	Sint8x2   = 3, 
	Sint8x4   = 4, 
	Unorm8x2  = 5, 
	Unorm8x4  = 6, 
	Snorm8x2  = 7, 
	Snorm8x4  = 8, 
	Uint16x2  = 9, 
	Uint16x4  = 10, 
	Sint16x2  = 11, 
	Sint16x4  = 12, 
	Unorm16x2 = 13, 
	Unorm16x4 = 14, 
	Snorm16x2 = 15, 
	Snorm16x4 = 16, 
	Float16x2 = 17, 
	Float16x4 = 18, 
	Float32   = 19, 
	Float32x2 = 20, 
	Float32x3 = 21, 
	Float32x4 = 22, 
	Uint32    = 23, 
	Uint32x2  = 24, 
	Uint32x3  = 25, 
	Uint32x4  = 26, 
	Sint32    = 27, 
	Sint32x2  = 28, 
	Sint32x3  = 29, 
	Sint32x4  = 30, 
}

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

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

WGSLFeatureName :: enum i32 {
	Undefined                           = 0, 
	ReadonlyAndReadwriteStorageTextures = 1, 
	Packed4x8IntegerDotProduct          = 2, 
	UnrestrictedPointerParameters       = 3, 
	PointerCompositeAccess              = 4, 
}

WrappedSubmissionIndex :: struct {
	queue:           Queue,
	submissionIndex: SubmissionIndex,
}

ARRAY_LAYER_COUNT_UNDEFINED: u32 : max(u32)

BINDINGS_VERSION: [4]u8 : [4]u8{22, 1, 0, 1}

BINDINGS_VERSION_STRING :: "22.1.0.1"

COPY_STRIDE_UNDEFINED: u32 : max(u32)

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

DEPTH_SLICE_UNDEFINED: u32 : max(u32)

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

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

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

InstanceFlags_Default: bit_set[InstanceFlag; u32] : 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)

WGPU_DEBUG :: #config(WGPU_DEBUG, false)

WGPU_SHARED :: #config(WGPU_SHARED, false)

WHOLE_MAP_SIZE: uint : max(uint)

WHOLE_SIZE: u64 : max(u64)

AdapterEnumerateFeatures :: proc(adapter: Adapter, allocator := context.allocator) -> []FeatureName {…}

AdapterGetInfo :: proc(adapter: Adapter) -> (info: AdapterInfo) {…}

AdapterGetLimits :: proc(adapter: Adapter) -> (limits: SupportedLimits, ok: bool) {…}

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

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

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

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

AdapterRequestDevice :: proc "c" (adapter: Adapter, descriptor: ^DeviceDescriptor, callback: AdapterRequestDeviceCallback, userdata: rawptr = nil) ---

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

BufferMapAsync :: proc "c" (
	buffer:   Buffer, 
	mode:     bit_set[MapMode; u32], 
	offset:   uint, 
	size:     uint, 
	callback: BufferMapAsyncCallback, 
	userdata: rawptr = nil, 
) ---

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

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

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

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

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

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

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

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: ^ImageCopyBuffer, destination: ^ImageCopyTexture, copySize: ^Extent3D) ---

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

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

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

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

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

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

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

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: cstring) ---

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

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: cstring) ---

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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(device: Device, descriptor: ^BufferWithDataDescriptor, data: []$T) -> (buf: Buffer) {…}

DeviceCreateBufferWithDataTyped :: proc(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, callback: DeviceCreateComputePipelineAsyncCallback, userdata: rawptr = nil) ---

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, callback: DeviceCreateRenderPipelineAsyncCallback, userdata: rawptr = nil) ---

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

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

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

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

DeviceEnumerateFeatures :: proc(device: Device, allocator := context.allocator) -> []FeatureName {…}

DeviceGetLimits :: proc(device: Device) -> (limits: SupportedLimits, ok: bool) {…}

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

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

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

DevicePopErrorScope :: proc "c" (device: Device, callback: ErrorCallback, userdata: rawptr) ---

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

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

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

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

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

GetProcAddress :: proc "c" (device: Device, procName: cstring) -> Proc ---

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

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

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

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

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

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

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

InstanceRequestAdapter :: proc "c" (instance: Instance, options: ^RequestAdapterOptions, callback: InstanceRequestAdapterCallback, userdata: rawptr = nil) ---

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

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

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

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

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

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

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

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

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

QueueOnSubmittedWorkDone :: proc "c" (queue: Queue, callback: QueueOnSubmittedWorkDoneCallback, userdata: rawptr = nil) ---

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

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

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

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

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

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

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

RawAdapterEnumerateFeatures :: proc "c" (adapter: Adapter, features: [^]FeatureName) -> uint ---

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

RawAdapterGetLimits :: proc "c" (adapter: Adapter, limits: ^SupportedLimits) -> b32 ---

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) ---

RawDeviceEnumerateFeatures :: proc "c" (device: Device, features: ^FeatureName) -> uint ---

RawDeviceGetLimits :: proc "c" (device: Device, limits: ^SupportedLimits) -> b32 ---

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

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

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) ---

RawRenderPassEncoderSetBindGroup :: proc "c" (renderPassEncoder: RenderPassEncoder, groupIndex: u32, group: BindGroup, dynamicOffsetCount: uint, dynamicOffsets: [^]u32) ---

RawSurfaceGetCapabilities :: proc "c" (surface: Surface, adapter: Adapter, capabilities: ^SurfaceCapabilities) ---

RawSurfaceGetCurrentTexture :: proc "c" (surface: Surface, surfaceTexture: ^SurfaceTexture) ---

RenderBundleEncoderDraw :: proc "c" (renderBundleEncoder: RenderBundleEncoder, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) ---

RenderBundleEncoderDrawIndexed :: proc "c" (
	renderBundleEncoder: RenderBundleEncoder, 
	indexCount:          u32, 
	instanceCount:       u32, 
	firstIndex:          u32, 
	baseVertex:          i32, 
	firstInstance:       u32, 
) ---

RenderBundleEncoderDrawIndexedIndirect :: proc "c" (renderBundleEncoder: RenderBundleEncoder, indirectBuffer: Buffer, indirectOffset: u64) ---

RenderBundleEncoderDrawIndirect :: proc "c" (renderBundleEncoder: RenderBundleEncoder, indirectBuffer: Buffer, indirectOffset: u64) ---

RenderBundleEncoderFinish :: proc "c" (renderBundleEncoder: RenderBundleEncoder, descriptor: ^RenderBundleDescriptor = nil) -> RenderBundle ---

RenderBundleEncoderInsertDebugMarker :: proc "c" (renderBundleEncoder: RenderBundleEncoder, markerLabel: cstring) ---

RenderBundleEncoderPopDebugGroup :: proc "c" (renderBundleEncoder: RenderBundleEncoder) ---

RenderBundleEncoderPushDebugGroup :: proc "c" (renderBundleEncoder: RenderBundleEncoder, groupLabel: cstring) ---

RenderBundleEncoderReference :: proc "c" (renderBundleEncoder: RenderBundleEncoder) ---

RenderBundleEncoderRelease :: proc "c" (renderBundleEncoder: RenderBundleEncoder) ---

RenderBundleEncoderSetBindGroup :: proc(renderBundleEncoder: RenderBundleEncoder, groupIndex: u32, group: BindGroup, dynamicOffsets: []u32 = nil) {…}

RenderBundleEncoderSetIndexBuffer :: proc "c" (renderBundleEncoder: RenderBundleEncoder, buffer: Buffer, format: IndexFormat, offset: u64, size: u64) ---

RenderBundleEncoderSetLabel :: proc "c" (renderBundleEncoder: RenderBundleEncoder, label: cstring) ---

RenderBundleEncoderSetPipeline :: proc "c" (renderBundleEncoder: RenderBundleEncoder, pipeline: RenderPipeline) ---

RenderBundleEncoderSetVertexBuffer :: proc "c" (renderBundleEncoder: RenderBundleEncoder, slot: u32, buffer: Buffer, offset: u64, size: u64) ---

RenderBundleReference :: proc "c" (renderBundle: RenderBundle) ---

RenderBundleRelease :: proc "c" (renderBundle: RenderBundle) ---

RenderBundleSetLabel :: proc "c" (renderBundle: RenderBundle, label: cstring) ---

RenderPassEncoderBeginOcclusionQuery :: proc "c" (renderPassEncoder: RenderPassEncoder, queryIndex: u32) ---

RenderPassEncoderBeginPipelineStatisticsQuery :: proc "c" (renderPassEncoder: RenderPassEncoder, querySet: QuerySet, queryIndex: u32) ---

RenderPassEncoderDraw :: proc "c" (renderPassEncoder: RenderPassEncoder, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32) ---

RenderPassEncoderDrawIndexed :: proc "c" (
	renderPassEncoder: RenderPassEncoder, 
	indexCount:        u32, 
	instanceCount:     u32, 
	firstIndex:        u32, 
	baseVertex:        i32, 
	firstInstance:     u32, 
) ---

RenderPassEncoderDrawIndexedIndirect :: proc "c" (renderPassEncoder: RenderPassEncoder, indirectBuffer: Buffer, indirectOffset: u64) ---

RenderPassEncoderDrawIndirect :: proc "c" (renderPassEncoder: RenderPassEncoder, indirectBuffer: Buffer, indirectOffset: u64) ---

RenderPassEncoderEnd :: proc "c" (renderPassEncoder: RenderPassEncoder) ---

RenderPassEncoderEndOcclusionQuery :: proc "c" (renderPassEncoder: RenderPassEncoder) ---

RenderPassEncoderEndPipelineStatisticsQuery :: proc "c" (renderPassEncoder: RenderPassEncoder) ---

RenderPassEncoderExecuteBundles :: proc(renderPassEncoder: RenderPassEncoder, bundles: []RenderBundle) {…}

RenderPassEncoderInsertDebugMarker :: proc "c" (renderPassEncoder: RenderPassEncoder, markerLabel: cstring) ---

RenderPassEncoderMultiDrawIndexedIndirect :: proc "c" (encoder: RenderPassEncoder, buffer: Buffer, offset: u64, count: u32) ---

RenderPassEncoderMultiDrawIndexedIndirectCount :: proc "c" (
	encoder:             RenderPassEncoder, 
	buffer:              Buffer, 
	offset:              u64, 
	count_buffer:        Buffer, 
	count_buffer_offset: u64, 
	max_count:           u32, 
) ---

RenderPassEncoderMultiDrawIndirect :: proc "c" (encoder: RenderPassEncoder, buffer: Buffer, offset: u64, count: u32) ---

RenderPassEncoderMultiDrawIndirectCount :: proc "c" (
	encoder:             RenderPassEncoder, 
	buffer:              Buffer, 
	offset:              u64, 
	count_buffer:        Buffer, 
	count_buffer_offset: u64, 
	max_count:           u32, 
) ---

RenderPassEncoderPopDebugGroup :: proc "c" (renderPassEncoder: RenderPassEncoder) ---

RenderPassEncoderPushDebugGroup :: proc "c" (renderPassEncoder: RenderPassEncoder, groupLabel: cstring) ---

RenderPassEncoderReference :: proc "c" (renderPassEncoder: RenderPassEncoder) ---

RenderPassEncoderRelease :: proc "c" (renderPassEncoder: RenderPassEncoder) ---

RenderPassEncoderSetBindGroup :: proc(renderPassEncoder: RenderPassEncoder, groupIndex: u32, group: BindGroup, dynamicOffsets: []u32 = nil) {…}

RenderPassEncoderSetBlendConstant :: proc "c" (renderPassEncoder: RenderPassEncoder, color: ^[4]f64) ---

RenderPassEncoderSetIndexBuffer :: proc "c" (renderPassEncoder: RenderPassEncoder, buffer: Buffer, format: IndexFormat, offset: u64, size: u64) ---

RenderPassEncoderSetLabel :: proc "c" (renderPassEncoder: RenderPassEncoder, label: cstring) ---

RenderPassEncoderSetPipeline :: proc "c" (renderPassEncoder: RenderPassEncoder, pipeline: RenderPipeline) ---