package vendor:wgpu

Source

Adapter :: distinct rawptr

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

AdapterType :: enum i32 {
	DiscreteGPU   = 0x00000001, 
	IntegratedGPU = 0x00000002, 
	CPU           = 0x00000003, 
	Unknown       = 0x00000004, 
}

AddressMode :: enum i32 {
	Undefined     = 0x00000000, 
	ClampToEdge   = 0x00000001, 
	Repeat        = 0x00000002, 
	MirrorRepeat  = 0x00000003, 
	ClampToBorder = 0x00000004, 
}

BackendType :: enum i32 {
	Undefined = 0x00000000, 
	Null      = 0x00000001, 
	WebGPU    = 0x00000002, 
	D3D11     = 0x00000003, 
	D3D12     = 0x00000004, 
	Metal     = 0x00000005, 
	Vulkan    = 0x00000006, 
	OpenGL    = 0x00000007, 
	OpenGLES  = 0x00000008, 
}

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],
	bindingArraySize: 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 {
	Undefined         = 0x00000000, 
	Zero              = 0x00000001, 
	One               = 0x00000002, 
	Src               = 0x00000003, 
	OneMinusSrc       = 0x00000004, 
	SrcAlpha          = 0x00000005, 
	OneMinusSrcAlpha  = 0x00000006, 
	Dst               = 0x00000007, 
	OneMinusDst       = 0x00000008, 
	DstAlpha          = 0x00000009, 
	OneMinusDstAlpha  = 0x0000000A, 
	SrcAlphaSaturated = 0x0000000B, 
	Constant          = 0x0000000C, 
	OneMinusConstant  = 0x0000000D, 
	Src1              = 0x0000000E, 
	OneMinusSrc1      = 0x0000000F, 
	Src1Alpha         = 0x00000010, 
	OneMinusSrc1Alpha = 0x00000011, 
}

BlendOperation :: enum i32 {
	Undefined       = 0x00000000, 
	Add             = 0x00000001, 
	Subtract        = 0x00000002, 
	ReverseSubtract = 0x00000003, 
	Min             = 0x00000004, 
	Max             = 0x00000005, 
}

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

Bool :: b32

Buffer :: distinct rawptr

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

BufferBindingType :: enum i32 {
	BindingNotUsed  = 0x00000000, 
	Undefined       = 0x00000001, 
	Uniform         = 0x00000002, 
	Storage         = 0x00000003, 
	ReadOnlyStorage = 0x00000004, 
}

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 = 0x00000001, 
	Pending  = 0x00000002, 
	Mapped   = 0x00000003, 
}

BufferUsage :: enum i32 {
	MapRead      = 0x00000000, 
	MapWrite     = 0x00000001, 
	CopySrc      = 0x00000002, 
	CopyDst      = 0x00000003, 
	Index        = 0x00000004, 
	Vertex       = 0x00000005, 
	Uniform      = 0x00000006, 
	Storage      = 0x00000007, 
	Indirect     = 0x00000008, 
	QueryResolve = 0x00000009, 
}

BufferUsageFlags :: bit_set[BufferUsage; u64]

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

CallbackMode :: enum i32 {
	WaitAnyOnly        = 0x00000001, 
	AllowProcessEvents = 0x00000002, 
	AllowSpontaneos    = 0x00000003, 
}

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

Color :: [4]f64

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

ColorWriteMask :: enum i32 {
	Red   = 0x00000000, 
	Green = 0x00000001, 
	Blue  = 0x00000002, 
	Alpha = 0x00000003, 
}

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    = 0x00000000, 
	Never        = 0x00000001, 
	Less         = 0x00000002, 
	Equal        = 0x00000003, 
	LessEqual    = 0x00000004, 
	Greater      = 0x00000005, 
	NotEqual     = 0x00000006, 
	GreaterEqual = 0x00000007, 
	Always       = 0x00000008, 
}

CompatibilityModeLimits :: struct {
	using chain:                       ChainedStruct,
	maxStorageBuffersInVertexStage:    u32,
	maxStorageTexturesInVertexStage:   u32,
	maxStorageBuffersInFragmentStage:  u32,
	maxStorageTexturesInFragmentStage: u32,
}

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           = 0x00000001, 
	CallbackCancelled = 0x00000002, 
}

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

CompilationMessageType :: enum i32 {
	Error   = 0x00000001, 
	Warning = 0x00000002, 
	Info    = 0x00000003, 
}

ComponentSwizzle :: enum i32 {
	Undefined, 
	Zero, 
	One, 
	R, 
	G, 
	B, 
	A, 
}

CompositeAlphaMode :: enum i32 {
	Auto            = 0x00000000, 
	Opaque          = 0x00000001, 
	Premultiplied   = 0x00000002, 
	Unpremultiplied = 0x00000003, 
	Inherit         = 0x00000004, 
}

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

ComputePassEncoder :: distinct rawptr

ComputePipeline :: distinct rawptr

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

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

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           = 0x00000001, 
	CallbackCancelled = 0x00000002, 
	ValidationError   = 0x00000003, 
	InternalError     = 0x00000004, 
}

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 = 0x00000000, 
	None      = 0x00000001, 
	Front     = 0x00000002, 
	Back      = 0x00000003, 
}

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         = 0x00000000, 
	Unknown           = 0x00000001, 
	Destroyed         = 0x00000002, 
	CallbackCancelled = 0x00000003, 
	FailedCreation    = 0x00000004, 
}

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

Dx12SwapchainKind :: enum i32 {
	Undefined, 
	DxgiFromHwnd, 
	DxgiFromVisual, 
}

DxcMaxShaderModel :: enum i32 {
	V6_0, 
	V6_1, 
	V6_2, 
	V6_3, 
	V6_4, 
	V6_5, 
	V6_6, 
	V6_7, 
}

ErrorFilter :: enum i32 {
	Validation  = 0x00000001, 
	OutOfMemory = 0x00000002, 
	Internal    = 0x00000003, 
}

ErrorType :: enum i32 {
	NoError     = 0x00000001, 
	Validation  = 0x00000002, 
	OutOfMemory = 0x00000003, 
	Internal    = 0x00000004, 
	Unknown     = 0x00000005, 
}

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

ExternalTexture :: distinct rawptr

ExternalTextureBindingEntry :: struct {
	using chain:     ChainedStruct,
	externalTexture: ExternalTexture,
}

ExternalTextureBindingLayout :: struct {
	using chain: ChainedStruct,
}

FeatureLevel :: enum i32 {
	Undefined, 
	Compatibility = 0x00000001, 
	Core          = 0x00000002, 
}

FeatureName :: enum i32 {
	// WebGPU.
	Undefined                                             = 0x00000000, 
	CoreFeaturesAndLimits                                 = 0x00000001, 
	DepthClipControl                                      = 0x00000002, 
	Depth32FloatStencil8                                  = 0x00000003, 
	TextureCompressionBC                                  = 0x00000004, 
	TextureCompressionBCSliced3D                          = 0x00000005, 
	TextureCompressionETC2                                = 0x00000006, 
	TextureCompressionASTC                                = 0x00000007, 
	TextureCompressionASTCSliced3D                        = 0x00000008, 
	TimestampQuery                                        = 0x00000009, 
	IndirectFirstInstance                                 = 0x0000000A, 
	ShaderF16                                             = 0x0000000B, 
	RG11B10UfloatRenderable                               = 0x0000000C, 
	BGRA8UnormStorage                                     = 0x0000000D, 
	Float32Filterable                                     = 0x0000000E, 
	Float32Blendable                                      = 0x0000000F, 
	ClipDistances                                         = 0x00000010, 
	DualSourceBlending                                    = 0x00000011, 
	Subgroups                                             = 0x00000012, 
	TextureFormatsTier1                                   = 0x00000013, 
	TextureFormatsTier2                                   = 0x00000014, 
	PrimitiveIndex                                        = 0x00000015, 
	TextureComponentSwizzle                               = 0x00000016, 
	// Native.
	Immediates                                            = 0x00030001, 
	TextureAdapterSpecificFormatFeatures, 
	MultiDrawIndirectCount                                = 0x00030004, 
	VertexWritableStorage, 
	TextureBindingArray, 
	SampledTextureAndStorageBufferArrayNonUniformIndexing, 
	PipelineStatisticsQuery, 
	StorageResourceBindingArray, 
	PartiallyBoundBindingArray, 
	TextureFormat16bitNorm, 
	TextureCompressionAstcHdr, 
	MappablePrimaryBuffers                                = 0x0003000E, 
	BufferBindingArray, 
	StorageTextureArrayNonUniformIndexing                 = 0x00030010, 
	AdressModeClampToZero                                 = 0x00030011, 
	AdressModeClampToBorder                               = 0x00030012, 
	PolygonModeLine                                       = 0x00030013, 
	PolygonModePoint, 
	ConservativeRasterization, 
	ClearTexture, 
	MultiView                                             = 0x00030018, 
	VertexAttribute64bit                                  = 0x00030019, 
	TextureFormatNv12, 
	RayQuery                                              = 0x0003001C, 
	ShaderF64, 
	ShaderI16, 
	ShaderEarlyDepthTest                                  = 0x00030020, 
	Subgroup, 
	SubgroupVertex, 
	SubgroupBarrier, 
	TimestampQueryInsideEncoders, 
	TimestampQueryInsidePasses, 
	ShaderInt64, 
	ShaderFloat32Atomic, 
	TextureAtomic, 
	TextureFormatP010, 
	// TODO: requires wgpu.h api change
	// ExternalTexture,
	PipelineCache                                         = 0x0003002B, 
	ShaderInt64AtomicMinMax, 
	ShaderInt64AtomicAllOps, 
	// TODO: requires wgpu.h api change
	// VulkanGoogleDisplayTiming,
	// VulkanExternalMemoryWin32,
	TextureInt64Atomic                                    = 0x00030030, 
	// TODO: not implemented yet, see https://github.com/gfx-rs/wgpu/issues/7149
	UniformBufferBindingArrays, 
	// TODO: requires wgpu.h api change
	// MeshShader,
	// RayHitVertexReturn,
	// MeshShaderMultiview,
	// ExtendedAccelerationStructureVertexFormat,
	// PassThroughShaders,
	ShaderBarycentrics                                    = 0x00030037, 
	SelectiveMultiview, 
	// TODO: requires wgpu.h api change
	// MeshShaderPoints,
	MultisampleArray                                      = 0x0003003A, 
	CooperativeMatrix, 
	ShaderPerVertex, 
	ShaderDrawIndex, 
	AccelerationStructureBindingArray, 
	MemoryDecorationCoherent, 
	MemoryDecorationVolative, 
}

FilterMode :: enum i32 {
	Undefined = 0x00000000, 
	Nearest   = 0x00000001, 
	Linear    = 0x00000002, 
}

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 = 0x00000000, 
	CCW       = 0x00000001, 
	CW        = 0x00000002, 
}

Future :: struct {
	id: u64,
}

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

GLFenceBehaviour :: enum i32 {
	Normal, 
	AutoFinish, 
}

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,
}

ImageSubresourceRange :: struct {
	aspect:          TextureAspect,
	baseMipLevel:    u32,
	mipLevelCount:   u32,
	baseArrayLayer:  u32,
	arrayLayerCount: u32,
}

IndexFormat :: enum i32 {
	Undefined = 0x00000000, 
	Uint16    = 0x00000001, 
	Uint32    = 0x00000002, 
}

Instance :: distinct rawptr

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

InstanceBackendFlags :: bit_set[InstanceBackend; u64]

InstanceDescriptor :: struct {
	nextInChain:          ^ChainedStruct,
	requiredFeatureCount: uint,
	requiredFeatures:     [^]InstanceFeatureName `fmt:"v,requiredFeatureCount"`,
	requiredLimits:       ^InstanceLimits,
}

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,
	glFenceBehaviour:        GLFenceBehaviour,
	dxcPath:                 string,
	dcxMaxShaderModel:       DxcMaxShaderModel,
	dx12PresentationSystem:  Dx12SwapchainKind,
	budgetForDeviceCreation: ^u8,
	budgetForDeviceLoss:     ^u8,
	displayHandle:           NativeDisplayHandle,
}

InstanceFeatureName :: enum i32 {
	TimedWaitAny              = 1, 
	ShaderSourceSPIRV         = 2, 
	MultipleDevicesPerAdapter = 3, 
}

InstanceFlag :: enum i32 {
	Debug, 
	Validation, 
	DiscardHalLabels, 
	AllowUnderlyingNoncompliantAdapter, 
	GPUBasedValidation, 
	ValidationIndirectCall, 
	AutomaticTimestampNormalization, 
	Default                            = 24, 
	Debugging, 
	AdvancedDebugging, 
	WithEnv, 
}

InstanceFlags :: bit_set[InstanceFlag; u64]

InstanceLimits :: struct {
	nextInChain:          ^ChainedStruct,
	timedWaitAnyMaxCount: uint,
}

Limits :: struct {
	nextInChain:                               ^ChainedStruct,
	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,
	maxImmediateSize:                          u32,
}

LoadOp :: enum i32 {
	Undefined = 0x00000000, 
	Load      = 0x00000001, 
	Clear     = 0x00000002, 
}

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

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

MapAsyncStatus :: enum i32 {
	Success           = 0x00000001, 
	CallbackCancelled = 0x00000002, 
	Error             = 0x00000003, 
	Aborted           = 0x00000004, 
}

MapMode :: enum i32 {
	Read  = 0x00000000, 
	Write = 0x00000001, 
}

MapModeFlags :: bit_set[MapMode; u64]

MipmapFilterMode :: enum i32 {
	Undefined = 0x00000000, 
	Nearest   = 0x00000001, 
	Linear    = 0x00000002, 
}

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

NativeDisplayHandle :: struct {
	type: NativeDisplayHandleType,
	using data: struct #raw_union {
		xlib:    XlibDisplayHandle,
		xcb:     XcbDisplayHandle,
		wayland: WaylandDisplayHandle,
	},
}

NativeDisplayHandleType :: enum i32 {
	None, 
	Xlib, 
	Xcb, 
	Wayland, 
}

NativeLimits :: struct {
	using chain:                                  ChainedStruct,
	maxNonSamplerBindings:                        u32,
	maxBindingArrayElementsPerShaderStage:        u32,
	maxBindingArraySamplerElementsPerShaderStage: u32,
	maxMultiviewCount:                            u32,
}

OptionalBool :: enum i32 {
	False     = 0x00000000, 
	True      = 0x00000001, 
	Undefined = 0x00000002, 
}

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

PassTimestampWrites :: struct {
	nextInChain:               ^ChainedStruct,
	querySet:                  QuerySet,
	beginningOfPassWriteIndex: u32,
	endOfPassWriteIndex:       u32,
}

PipelineLayout :: distinct rawptr

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

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

PolygonMode :: enum i32 {
	Fill, 
	Line, 
	Point, 
}

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           = 0x00000001, 
	CallbackCancelled = 0x00000002, 
	Error             = 0x00000003, 
}

PowerPreference :: enum i32 {
	Undefined       = 0x00000000, 
	LowPower        = 0x00000001, 
	HighPerformance = 0x00000002, 
}

PredefinedColorSpace :: enum i32 {
	SRGB      = 1, 
	DisplayP3, 
}

PresentMode :: enum i32 {
	Undefined   = 0x00000000, 
	Fifo        = 0x00000001, 
	FifoRelaxed = 0x00000002, 
	Immediate   = 0x00000003, 
	Mailbox     = 0x00000004, 
}

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

PrimitiveStateExtras :: struct {
	using chain:  ChainedStruct,
	polygonMode:  PolygonMode,
	conservative: b32,
}

PrimitiveTopology :: enum i32 {
	Undefined     = 0x00000000, 
	PointList     = 0x00000001, 
	LineList      = 0x00000002, 
	LineStrip     = 0x00000003, 
	TriangleList  = 0x00000004, 
	TriangleStrip = 0x00000005, 
}

Proc :: distinct rawptr

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          = 0x00000001, 
	Timestamp          = 0x00000002, 
	// Native.
	PipelineStatistics = 0x00030000, 
}

Queue :: distinct rawptr

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

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

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

QueueWorkDoneStatus :: enum i32 {
	Success           = 0x00000001, 
	CallbackCancelled = 0x00000002, 
	Error             = 0x00000003, 
}

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 {
	nextInChain:       ^ChainedStruct,
	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:        ^PassTimestampWrites,
}

RenderPassEncoder :: distinct rawptr

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

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           = 0x00000001, 
	CallbackCancelled = 0x00000002, 
	Unavailable       = 0x00000003, 
	Error             = 0x00000004, 
}

RequestAdapterWebXROptions :: struct {
	using chain:  ChainedStruct,
	xrCompatible: b32,
}

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           = 0x00000001, 
	CallbackCancelled = 0x00000002, 
	Error             = 0x00000003, 
}

SType :: enum i32 {
	// WebGPU.
	ShaderSourceSPIRV                 = 0x00000001, 
	ShaderSourceWGSL                  = 0x00000002, 
	RenderPassMaxDrawCount            = 0x00000003, 
	SurfaceSourceMetalLayer           = 0x00000004, 
	SurfaceSourceWindowsHWND          = 0x00000005, 
	SurfaceSourceXlibWindow           = 0x00000006, 
	SurfaceSourceWaylandSurface       = 0x00000007, 
	SurfaceSourceAndroidNativeWindow  = 0x00000008, 
	SurfaceSourceXCBWindow            = 0x00000009, 
	SurfaceColorManagement            = 0x0000000A, 
	RequestAdapterWebXROptions        = 0x0000000B, 
	TextureComponentSwizzleDescriptor = 0x0000000C, 
	ExternalTextureBindingLayout      = 0x0000000D, 
	ExternalTextureBindingEntry       = 0x0000000E, 
	CompatibilityModeLimits           = 0x0000000F, 
	TextureBindingViewDimension       = 0x00000010, 
	// Native.
	DeviceExtras                      = 0x00030001, 
	NativeLimits, 
	ShaderSourceGLSL, 
	InstanceExtras, 
	BindGroupEntryExtras, 
	BindGroupLayoutEntryExtras, 
	QuerySetDescriptorExtras, 
	SurfaceConfigurationExtras, 
	SurfaceSourceSwapChainPanel, 
	PrimitiveStateExtras, 
	SamplerDescriptorExtras, 
	// Odin.
	SurfaceSourceCanvasHTMLSelector   = 0x00040001, 
}

Sampler :: distinct rawptr

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

SamplerBindingType :: enum i32 {
	BindingNotUsed = 0x00000000, 
	Undefined      = 0x00000001, 
	Filtering      = 0x00000002, 
	NonFiltering   = 0x00000003, 
	Comparison     = 0x00000004, 
}

SamplerBorderColor :: enum i32 {
	Undefined, 
	TransparentBlack, 
	OpaqueBlack, 
	OpaqueWhite, 
	Zero, 
}

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,
}

SamplerDescriptorExtras :: struct {
	using chain:       ChainedStruct,
	samplerBoderColor: SamplerBorderColor,
}

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"`,
}

ShaderRuntimeCheck :: enum i32 {
	BoundsChecks, 
	ForceLoopBounding, 
	RayQueryInitializationTracking, 
	TaskShaderDispatchTracking, 
	MeshShaderPrimitiveIndicesClamp, 
}

ShaderRuntimeChecks :: bit_set[ShaderRuntimeCheck; u64]

ShaderSourceGLSL :: 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   = 0x00000000, 
	Fragment = 0x00000001, 
	Compute  = 0x00000002, 
}

ShaderStageFlags :: bit_set[ShaderStage; u64]

Status :: enum i32 {
	Success = 0x00000001, 
	Error   = 0x00000002, 
}

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

StencilOperation :: enum i32 {
	Undefined      = 0x00000000, 
	Keep           = 0x00000001, 
	Zero           = 0x00000002, 
	Replace        = 0x00000003, 
	Invert         = 0x00000004, 
	IncrementClamp = 0x00000005, 
	DecrementClamp = 0x00000006, 
	IncrementWrap  = 0x00000007, 
	DecrementWrap  = 0x00000008, 
}

StorageTextureAccess :: enum i32 {
	BindingNotUsed = 0x00000000, 
	Undefined      = 0x00000001, 
	WriteOnly      = 0x00000002, 
	ReadOnly       = 0x00000003, 
	ReadWrite      = 0x00000004, 
}

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

StoreOp :: enum i32 {
	Undefined = 0x00000000, 
	Store     = 0x00000001, 
	Discard   = 0x00000002, 
}

StringView :: string

SubmissionIndex :: distinct u64

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

SupportedInstanceFeatures :: struct {
	featureCount: uint,
	features:     [^]InstanceFeatureName `fmt:"v,featureCount"`,
}

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

Surface :: distinct rawptr

SurfaceCapabilities :: struct {
	nextInChain:      ^ChainedStruct,
	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"`,
}

SurfaceColorManagement :: struct {
	using chain:     ChainedStruct,
	colorSpace:      PredefinedColorSpace,
	toneMappingMode: ToneMappingMode,
}

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    = 0x00000001, 
	SuccessSuboptimal = 0x00000002, 
	Timeout           = 0x00000003, 
	Outdated          = 0x00000004, 
	Lost              = 0x00000005, 
	Error             = 0x00000006, 
	// Native.
	Occluded          = 0x00030001, 
}

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

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

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

SurfaceSourceSwapChainPanel :: struct {
	using chain: ChainedStruct,
	// *
	//      * A pointer to the [[ ISwapChainPanelNative ; https://learn.microsoft.com/en-us/windows/windows-app-sdk/api/win32/microsoft.ui.xaml.media.dxinterop/nn-microsoft-ui-xaml-media-dxinterop-iswapchainpanelnative ]]
	//      * interface of the `SwapChainPanel` that will be wrapped by the `Surface`.
	panelNative: 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: ^ChainedStruct,
	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   = 0x00000000, 
	All         = 0x00000001, 
	StencilOnly = 0x00000002, 
	DepthOnly   = 0x00000003, 
}

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

TextureBindingViewDimension :: struct {
	using chain:                 ChainedStruct,
	textureBindingViewDimension: TextureViewDimension,
}

TextureComponentSwizzle :: struct {
	r: ComponentSwizzle,
	g: ComponentSwizzle,
	b: ComponentSwizzle,
	a: ComponentSwizzle,
}

TextureComponentSwizzleDescriptor :: struct {
	using chain: ChainedStruct,
	swizzle: TextureComponentSwizzle,
}

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 = 0x00000000, 
	_1D       = 0x00000001, 
	_2D       = 0x00000002, 
	_3D       = 0x00000003, 
}

TextureFormat :: enum i32 {
	Undefined            = 0x00000000, 
	R8Unorm              = 0x00000001, 
	R8Snorm              = 0x00000002, 
	R8Uint               = 0x00000003, 
	R8Sint               = 0x00000004, 
	R16Unorm             = 0x00000005, 
	R16Snorm             = 0x00000006, 
	R16Uint              = 0x00000007, 
	R16Sint              = 0x00000008, 
	R16Float             = 0x00000009, 
	RG8Unorm             = 0x0000000A, 
	RG8Snorm             = 0x0000000B, 
	RG8Uint              = 0x0000000C, 
	RG8Sint              = 0x0000000D, 
	R32Float             = 0x0000000E, 
	R32Uint              = 0x0000000F, 
	R32Sint              = 0x00000010, 
	RG16Unorm            = 0x00000011, 
	RG16Snorm            = 0x00000012, 
	RG16Uint             = 0x00000013, 
	RG16Sint             = 0x00000014, 
	RG16Float            = 0x00000015, 
	RGBA8Unorm           = 0x00000016, 
	RGBA8UnormSrgb       = 0x00000017, 
	RGBA8Snorm           = 0x00000018, 
	RGBA8Uint            = 0x00000019, 
	RGBA8Sint            = 0x0000001A, 
	BGRA8Unorm           = 0x0000001B, 
	BGRA8UnormSrgb       = 0x0000001C, 
	RGB10A2Uint          = 0x0000001D, 
	RGB10A2Unorm         = 0x0000001E, 
	RG11B10Ufloat        = 0x0000001F, 
	RGB9E5Ufloat         = 0x00000020, 
	RG32Float            = 0x00000021, 
	RG32Uint             = 0x00000022, 
	RG32Sint             = 0x00000023, 
	RGBA16Unorm          = 0x00000024, 
	RGBA16Snorm          = 0x00000025, 
	RGBA16Uint           = 0x00000026, 
	RGBA16Sint           = 0x00000027, 
	RGBA16Float          = 0x00000028, 
	RGBA32Float          = 0x00000029, 
	RGBA32Uint           = 0x0000002A, 
	RGBA32Sint           = 0x0000002B, 
	Stencil8             = 0x0000002C, 
	Depth16Unorm         = 0x0000002D, 
	Depth24Plus          = 0x0000002E, 
	Depth24PlusStencil8  = 0x0000002F, 
	Depth32Float         = 0x00000030, 
	Depth32FloatStencil8 = 0x00000031, 
	BC1RGBAUnorm         = 0x00000032, 
	BC1RGBAUnormSrgb     = 0x00000033, 
	BC2RGBAUnorm         = 0x00000034, 
	BC2RGBAUnormSrgb     = 0x00000035, 
	BC3RGBAUnorm         = 0x00000036, 
	BC3RGBAUnormSrgb     = 0x00000037, 
	BC4RUnorm            = 0x00000038, 
	BC4RSnorm            = 0x00000039, 
	BC5RGUnorm           = 0x0000003A, 
	BC5RGSnorm           = 0x0000003B, 
	BC6HRGBUfloat        = 0x0000003C, 
	BC6HRGBFloat         = 0x0000003D, 
	BC7RGBAUnorm         = 0x0000003E, 
	BC7RGBAUnormSrgb     = 0x0000003F, 
	ETC2RGB8Unorm        = 0x00000040, 
	ETC2RGB8UnormSrgb    = 0x00000041, 
	ETC2RGB8A1Unorm      = 0x00000042, 
	ETC2RGB8A1UnormSrgb  = 0x00000043, 
	ETC2RGBA8Unorm       = 0x00000044, 
	ETC2RGBA8UnormSrgb   = 0x00000045, 
	EACR11Unorm          = 0x00000046, 
	EACR11Snorm          = 0x00000047, 
	EACRG11Unorm         = 0x00000048, 
	EACRG11Snorm         = 0x00000049, 
	ASTC4x4Unorm         = 0x0000004A, 
	ASTC4x4UnormSrgb     = 0x0000004B, 
	ASTC5x4Unorm         = 0x0000004C, 
	ASTC5x4UnormSrgb     = 0x0000004D, 
	ASTC5x5Unorm         = 0x0000004E, 
	ASTC5x5UnormSrgb     = 0x0000004F, 
	ASTC6x5Unorm         = 0x00000050, 
	ASTC6x5UnormSrgb     = 0x00000051, 
	ASTC6x6Unorm         = 0x00000052, 
	ASTC6x6UnormSrgb     = 0x00000053, 
	ASTC8x5Unorm         = 0x00000054, 
	ASTC8x5UnormSrgb     = 0x00000055, 
	ASTC8x6Unorm         = 0x00000056, 
	ASTC8x6UnormSrgb     = 0x00000057, 
	ASTC8x8Unorm         = 0x00000058, 
	ASTC8x8UnormSrgb     = 0x00000059, 
	ASTC10x5Unorm        = 0x0000005A, 
	ASTC10x5UnormSrgb    = 0x0000005B, 
	ASTC10x6Unorm        = 0x0000005C, 
	ASTC10x6UnormSrgb    = 0x0000005D, 
	ASTC10x8Unorm        = 0x0000005E, 
	ASTC10x8UnormSrgb    = 0x0000005F, 
	ASTC10x10Unorm       = 0x00000060, 
	ASTC10x10UnormSrgb   = 0x00000061, 
	ASTC12x10Unorm       = 0x00000062, 
	ASTC12x10UnormSrgb   = 0x00000063, 
	ASTC12x12Unorm       = 0x00000064, 
	ASTC12x12UnormSrgb   = 0x00000065, 
	NV12, 
	P010, 
}

TextureSampleType :: enum i32 {
	BindingNotUsed    = 0x00000000, 
	Undefined         = 0x00000001, 
	Float             = 0x00000002, 
	UnfilterableFloat = 0x00000003, 
	Depth             = 0x00000004, 
	Sint              = 0x00000005, 
	Uint              = 0x00000006, 
}

TextureUsage :: enum i32 {
	CopySrc, 
	CopyDst, 
	TextureBinding, 
	StorageBinding, 
	RenderAttachment, 
	TransientAttachment, 
}

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 = 0x00000000, 
	_1D       = 0x00000001, 
	_2D       = 0x00000002, 
	_2DArray  = 0x00000003, 
	Cube      = 0x00000004, 
	CubeArray = 0x00000005, 
	_3D       = 0x00000006, 
}

ToneMappingMode :: enum i32 {
	Standard = 1, 
	Extended, 
}

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 {
	nextInChain:    ^ChainedStruct,
	format:         VertexFormat,
	offset:         u64,
	shaderLocation: u32,
}

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

VertexFormat :: enum i32 {
	Uint8           = 0x00000001, 
	Uint8x2         = 0x00000002, 
	Uint8x4         = 0x00000003, 
	Sint8           = 0x00000004, 
	Sint8x2         = 0x00000005, 
	Sint8x4         = 0x00000006, 
	Unorm8          = 0x00000007, 
	Unorm8x2        = 0x00000008, 
	Unorm8x4        = 0x00000009, 
	Snorm8          = 0x0000000A, 
	Snorm8x2        = 0x0000000B, 
	Snorm8x4        = 0x0000000C, 
	Uint16          = 0x0000000D, 
	Uint16x2        = 0x0000000E, 
	Uint16x4        = 0x0000000F, 
	Sint16          = 0x00000010, 
	Sint16x2        = 0x00000011, 
	Sint16x4        = 0x00000012, 
	Unorm16         = 0x00000013, 
	Unorm16x2       = 0x00000014, 
	Unorm16x4       = 0x00000015, 
	Snorm16         = 0x00000016, 
	Snorm16x2       = 0x00000017, 
	Snorm16x4       = 0x00000018, 
	Float16         = 0x00000019, 
	Float16x2       = 0x0000001A, 
	Float16x4       = 0x0000001B, 
	Float32         = 0x0000001C, 
	Float32x2       = 0x0000001D, 
	Float32x3       = 0x0000001E, 
	Float32x4       = 0x0000001F, 
	Uint32          = 0x00000020, 
	Uint32x2        = 0x00000021, 
	Uint32x3        = 0x00000022, 
	Uint32x4        = 0x00000023, 
	Sint32          = 0x00000024, 
	Sint32x2        = 0x00000025, 
	Sint32x3        = 0x00000026, 
	Sint32x4        = 0x00000027, 
	Unorm10_10_10_2 = 0x00000028, 
	Unorm8x4BGRA    = 0x00000029, 
}

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 {
	Undefined = 0x00000000, 
	Vertex    = 0x00000001, 
	Instance  = 0x00000002, 
}

WGSLLanguageFeatureName :: enum i32 {
	ReadonlyAndReadwriteStorageTextures = 0x00000001, 
	Packed4x8IntegerDotProduct          = 0x00000002, 
	UnrestrictedPointerParameters       = 0x00000003, 
	PointerCompositeAccess              = 0x00000004, 
	UniformBufferStandardLayout         = 0x00000005, 
	SubgroupId                          = 0x00000006, 
	TextureAndSamplerLet                = 0x00000007, 
	SubgroupUniformity                  = 0x00000008, 
	TextureFormatsTier1                 = 0x00000009, 
	LinearIndexing                      = 0x0000000A, 
}

WaitStatus :: enum i32 {
	Success  = 0x00000001, 
	TimedOut = 0x00000002, 
	Error    = 0x00000003, 
}

WaylandDisplayHandle :: struct {
	display: rawptr,
}

XcbDisplayHandle :: struct {
	connection: rawptr,
	screen:     i32,
}

XlibDisplayHandle :: struct {
	display: rawptr,
	screen:  i32,
}

ARRAY_LAYER_COUNT_UNDEFINED: u32 : max(u32)

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

BINDINGS_VERSION_STRING :: "29.0.1.1"

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}

InstanceFlags_Empty: 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 :: #config(WGPU_DEBUG, false)

-define:WGPU_DEBUG=false

WGPU_SHARED :: #config(WGPU_SHARED, false)

-define: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 ---