package vendor:wgpu

⌘K
Ctrl+K
or
/

    Index

    Types (189)
    Variables (0)

    This section is empty.

    Procedures (223)

    Types

    AdapterProperties ¶

    AdapterProperties :: struct {
    	nextInChain:       ^ChainedStructOut,
    	vendorID:          u32,
    	vendorName:        cstring,
    	architecture:      cstring,
    	deviceID:          u32,
    	name:              cstring,
    	driverDescription: cstring,
    	adapterType:       AdapterType,
    	backendType:       BackendType,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    AdapterRequestDeviceCallback ¶

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

    AdapterType ¶

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

    AddressMode ¶

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

    BackendType ¶

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

    BindGroupDescriptor ¶

    BindGroupDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    	layout:      BindGroupLayout,
    	entryCount:  uint,
    	entries:     [^]BindGroupEntry "fmt:\"v,entryCount\"",
    }
    Related Procedures With Parameters

    BindGroupEntry ¶

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

    BindGroupEntryExtras ¶

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

    BindGroupLayoutDescriptor ¶

    BindGroupLayoutDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    	entryCount:  uint,
    	entries:     [^]BindGroupLayoutEntry "fmt:\"v,entryCount\"",
    }
    Related Procedures With Parameters

    BindGroupLayoutEntry ¶

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

    BindGroupLayoutEntryExtras ¶

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

    BlendComponent ¶

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

    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 ¶

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

    BlendState ¶

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

    BufferBindingLayout ¶

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

    BufferBindingType ¶

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

    BufferDescriptor ¶

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

    BufferMapAsyncCallback ¶

    BufferMapAsyncCallback :: proc "c" (status: BufferMapAsyncStatus, userdata: rawptr)
    Related Procedures With Parameters

    BufferMapAsyncStatus ¶

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

    BufferMapState ¶

    BufferMapState :: enum i32 {
    	Unmapped = 0, 
    	Pending  = 1, 
    	Mapped   = 2, 
    }
    Related Procedures With Returns

    BufferUsage ¶

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

    BufferUsageFlags ¶

    BufferUsageFlags :: bit_set[BufferUsage; u32]

    BufferWithDataDescriptor ¶

    BufferWithDataDescriptor :: struct {
    	label: cstring,
    	usage: bit_set[BufferUsage; u32],
    }
    Related Procedures With Parameters

    ChainedStruct ¶

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

    ChainedStructOut ¶

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

    Color ¶

    Color :: struct {
    	r: f64,
    	g: f64,
    	b: f64,
    	a: f64,
    }
    Related Procedures With Parameters

    ColorTargetState ¶

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

    ColorWriteMask ¶

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

    ColorWriteMaskFlags ¶

    ColorWriteMaskFlags :: bit_set[ColorWriteMask; u32]
    Related Constants

    CommandBuffer ¶

    CommandBuffer :: distinct rawptr
    Related Procedures With Parameters
    Related Procedures With Returns

    CommandBufferDescriptor ¶

    CommandBufferDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    }
    Related Procedures With Parameters

    CommandEncoderDescriptor ¶

    CommandEncoderDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    }
    Related Procedures With Parameters

    CompareFunction ¶

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

    CompilationInfo ¶

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

    CompilationInfoRequestStatus ¶

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

    CompilationMessage ¶

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

    CompilationMessageType ¶

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

    CompositeAlphaMode ¶

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

    ComputePassDescriptor ¶

    ComputePassDescriptor :: struct {
    	nextInChain:     ^ChainedStruct,
    	label:           cstring,
    	timestampWrites: ^ComputePassTimestampWrites,
    }
    Related Procedures With Parameters

    ComputePassTimestampWrites ¶

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

    ComputePipelineDescriptor ¶

    ComputePipelineDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    	layout:      PipelineLayout,
    	compute:     ProgrammableStageDescriptor,
    }
    Related Procedures With Parameters

    ConstantEntry ¶

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

    CreatePipelineAsyncStatus ¶

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

    CullMode ¶

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

    DepthStencilState ¶

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

    DeviceCreateComputePipelineAsyncCallback ¶

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

    DeviceCreateRenderPipelineAsyncCallback ¶

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

    DeviceDescriptor ¶

    DeviceDescriptor :: struct {
    	nextInChain:          ^ChainedStruct,
    	label:                cstring,
    	requiredFeatureCount: uint,
    	requiredFeatures:     [^]FeatureName "fmt:\"v,requiredFeatureCount\"",
    	requiredLimits:       ^RequiredLimits,
    	defaultQueue:         QueueDescriptor,
    	deviceLostCallback:   DeviceLostCallback,
    	deviceLostUserdata:   rawptr,
    }
    Related Procedures With Parameters

    DeviceExtras ¶

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

    DeviceLostCallback ¶

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

    DeviceLostReason ¶

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

    Dx12Compiler ¶

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

    ErrorCallback ¶

    ErrorCallback :: proc "c" (type: ErrorType, message: cstring, userdata: rawptr)
    Related Procedures With Parameters

    ErrorFilter ¶

    ErrorFilter :: enum i32 {
    	Validation  = 0, 
    	OutOfMemory = 1, 
    	Internal    = 2, 
    }
    Related Procedures With Parameters

    ErrorType ¶

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

    Extent3D ¶

    Extent3D :: struct {
    	width:              u32,
    	height:             u32,
    	depthOrArrayLayers: u32,
    }
    Related Procedures With Parameters

    FeatureName ¶

    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, 
    }
    Related Procedures With Parameters

    FilterMode ¶

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

    Flags ¶

    Flags :: u32

    FragmentState ¶

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

    FrontFace ¶

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

    Gles3MinorVersion ¶

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

    GlobalReport ¶

    GlobalReport :: struct {
    	surfaces:    RegistryReport,
    	backendType: BackendType,
    	vulkan:      HubReport,
    	metal:       HubReport,
    	dx12:        HubReport,
    	gl:          HubReport,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    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 ¶

    ImageCopyBuffer :: struct {
    	nextInChain: ^ChainedStruct,
    	layout:      TextureDataLayout,
    	buffer:      Buffer,
    }
    Related Procedures With Parameters

    ImageCopyTexture ¶

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

    IndexFormat ¶

    IndexFormat :: enum i32 {
    	Undefined = 0, 
    	Uint16    = 1, 
    	Uint32    = 2, 
    }
    Related Procedures With Parameters

    InstanceBackend ¶

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

    InstanceDescriptor ¶

    InstanceDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    }
    Related Procedures With Parameters

    InstanceEnumerateAdapterOptions ¶

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

    InstanceExtras ¶

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

    InstanceFlag ¶

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

    InstanceFlags ¶

    InstanceFlags :: bit_set[InstanceFlag; u32]
    Related Constants

    InstanceRequestAdapterCallback ¶

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

    Limits ¶

    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 ¶

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

    LogCallback ¶

    LogCallback :: proc "c" (level: LogLevel, message: cstring, userdata: rawptr)
    Related Procedures With Parameters

    LogLevel ¶

    LogLevel :: enum i32 {
    	Off, 
    	Error, 
    	Warn, 
    	Info, 
    	Debug, 
    	Trace, 
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    MapMode ¶

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

    MapModeFlags ¶

    MapModeFlags :: bit_set[MapMode; u32]

    MipmapFilterMode ¶

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

    MultisampleState ¶

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

    NativeLimits ¶

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

    Origin3D ¶

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

    PipelineLayout ¶

    PipelineLayout :: distinct rawptr
    Related Procedures With Parameters
    Related Procedures With Returns

    PipelineLayoutDescriptor ¶

    PipelineLayoutDescriptor :: struct {
    	nextInChain:          ^ChainedStruct,
    	label:                cstring,
    	bindGroupLayoutCount: uint,
    	bindGroupLayouts:     [^]BindGroupLayout "fmt:\"v,bindGroupLayoutCount\"",
    }
    Related Procedures With Parameters

    PipelineLayoutExtras ¶

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

    PipelineStatisticName ¶

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

    PowerPreference ¶

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

    PresentMode ¶

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

    PrimitiveDepthClipControl ¶

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

    PrimitiveState ¶

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

    PrimitiveTopology ¶

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

    Proc ¶

    Proc :: distinct rawptr
    Related Procedures With Returns

    ProgrammableStageDescriptor ¶

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

    PushConstantRange ¶

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

    QuerySetDescriptor ¶

    QuerySetDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    	type:        QueryType,
    	count:       u32,
    }
    Related Procedures With Parameters

    QuerySetDescriptorExtras ¶

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

    QueryType ¶

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

    QueueDescriptor ¶

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

    QueueOnSubmittedWorkDoneCallback ¶

    QueueOnSubmittedWorkDoneCallback :: proc "c" (status: QueueWorkDoneStatus, userdata: rawptr)
    Related Procedures With Parameters

    QueueWorkDoneStatus ¶

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

    RegistryReport ¶

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

    RenderBundle ¶

    RenderBundle :: distinct rawptr
    Related Procedures With Parameters
    Related Procedures With Returns

    RenderBundleDescriptor ¶

    RenderBundleDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    }
    Related Procedures With Parameters

    RenderBundleEncoderDescriptor ¶

    RenderBundleEncoderDescriptor :: struct {
    	nextInChain:        ^ChainedStruct,
    	label:              cstring,
    	colorFormatCount:   uint,
    	colorFormats:       [^]TextureFormat "fmt:\"v,colorFormatCount\"",
    	depthStencilFormat: TextureFormat,
    	sampleCount:        u32,
    	depthReadOnly:      b32,
    	stencilReadOnly:    b32,
    }
    Related Procedures With Parameters

    RenderPassColorAttachment ¶

    RenderPassColorAttachment :: struct {
    	nextInChain:   ^ChainedStruct,
    	view:          TextureView,
    	resolveTarget: TextureView,
    	loadOp:        LoadOp,
    	storeOp:       StoreOp,
    	clearValue:    Color,
    }

    RenderPassDepthStencilAttachment ¶

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

    RenderPassDescriptor ¶

    RenderPassDescriptor :: struct {
    	nextInChain:            ^ChainedStruct,
    	label:                  cstring,
    	colorAttachmentCount:   uint,
    	colorAttachments:       [^]RenderPassColorAttachment "fmt:\"v,colorAttachmentCount\"",
    	depthStencilAttachment: ^RenderPassDepthStencilAttachment,
    	occlusionQuerySet:      QuerySet,
    	timestampWrites:        ^RenderPassTimestampWrites,
    }
    Related Procedures With Parameters

    RenderPassDescriptorMaxDrawCount ¶

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

    RenderPassTimestampWrites ¶

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

    RenderPipelineDescriptor ¶

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

    RequestAdapterOptions ¶

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

    RequestAdapterStatus ¶

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

    RequestDeviceStatus ¶

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

    RequiredLimits ¶

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

    RequiredLimitsExtras ¶

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

    SType ¶

    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 ¶

    Sampler :: distinct rawptr
    Related Procedures With Parameters
    Related Procedures With Returns

    SamplerBindingLayout ¶

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

    SamplerBindingType ¶

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

    SamplerDescriptor ¶

    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,
    }
    Related Procedures With Parameters

    ShaderDefine ¶

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

    ShaderModule ¶

    ShaderModule :: distinct rawptr
    Related Procedures With Parameters
    Related Procedures With Returns

    ShaderModuleCompilationHint ¶

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

    ShaderModuleDescriptor ¶

    ShaderModuleDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    	hintCount:   uint,
    	hints:       [^]ShaderModuleCompilationHint "fmt:\"v,hintCount\"",
    }
    Related Procedures With Parameters

    ShaderModuleGLSLDescriptor ¶

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

    ShaderModuleGetCompilationInfoCallback ¶

    ShaderModuleGetCompilationInfoCallback :: proc "c" (status: CompilationInfoRequestStatus, compilationInfo: ^CompilationInfo, userdata: rawptr)
    Related Procedures With Parameters

    ShaderModuleSPIRVDescriptor ¶

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

    ShaderModuleWGSLDescriptor ¶

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

    ShaderStage ¶

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

    ShaderStageFlags ¶

    ShaderStageFlags :: bit_set[ShaderStage; u32]

    StencilFaceState ¶

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

    StencilOperation ¶

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

    StorageTextureAccess ¶

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

    StorageTextureBindingLayout ¶

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

    StoreOp ¶

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

    SubmissionIndex ¶

    SubmissionIndex :: distinct u64
    Related Procedures With Returns

    SupportedLimits ¶

    SupportedLimits :: struct {
    	nextInChain: ^ChainedStructOut,
    	limits:      Limits,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    SupportedLimitsExtras ¶

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

    SurfaceCapabilities ¶

    SurfaceCapabilities :: struct {
    	nextInChain:      ^ChainedStructOut,
    	formatCount:      uint,
    	formats:          [^]TextureFormat "fmt:\"v,formatCount\"",
    	presentModeCount: uint,
    	presentModes:     [^]PresentMode "fmt:\"v,presentModeCount\"",
    	alphaModeCount:   uint,
    	alphaModes:       [^]CompositeAlphaMode "fmt:\"v,alphaModeCount\"",
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    SurfaceConfiguration ¶

    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,
    }
    Related Procedures With Parameters

    SurfaceConfigurationExtras ¶

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

    SurfaceDescriptor ¶

    SurfaceDescriptor :: struct {
    	nextInChain: ^ChainedStruct,
    	label:       cstring,
    }
    Related Procedures With Parameters

    SurfaceDescriptorFromAndroidNativeWindow ¶

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

    SurfaceDescriptorFromCanvasHTMLSelector ¶

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

    SurfaceDescriptorFromMetalLayer ¶

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

    SurfaceDescriptorFromWaylandSurface ¶

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

    SurfaceDescriptorFromWindowsHWND ¶

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

    SurfaceDescriptorFromXcbWindow ¶

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

    SurfaceDescriptorFromXlibWindow ¶

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

    SurfaceGetCurrentTextureStatus ¶

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

    SurfaceTexture ¶

    SurfaceTexture :: struct {
    	texture:    Texture,
    	suboptimal: b32,
    	status:     SurfaceGetCurrentTextureStatus,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    TextureAspect ¶

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

    TextureBindingLayout ¶

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

    TextureDataLayout ¶

    TextureDataLayout :: struct {
    	nextInChain:  ^ChainedStruct,
    	offset:       u64,
    	bytesPerRow:  u32,
    	rowsPerImage: u32,
    }
    Related Procedures With Parameters

    TextureDescriptor ¶

    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\"",
    }
    Related Procedures With Parameters

    TextureDimension ¶

    TextureDimension :: enum i32 {
    	_1D = 0, 
    	_2D = 1, 
    	_3D = 2, 
    }
    Related Procedures With Returns

    TextureFormat ¶

    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, 
    }
    Related Procedures With Returns

    TextureSampleType ¶

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

    TextureUsage ¶

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

    TextureUsageFlags ¶

    TextureUsageFlags :: bit_set[TextureUsage; u32]

    TextureView ¶

    TextureView :: distinct rawptr
    Related Procedures With Parameters
    Related Procedures With Returns

    TextureViewDescriptor ¶

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

    TextureViewDimension ¶

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

    VertexAttribute ¶

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

    VertexBufferLayout ¶

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

    VertexFormat ¶

    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 ¶

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

    VertexStepMode ¶

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

    WrappedSubmissionIndex ¶

    WrappedSubmissionIndex :: struct {
    	queue:           Queue,
    	submissionIndex: SubmissionIndex,
    }
    Related Procedures With Parameters

    Constants

    ARRAY_LAYER_COUNT_UNDEFINED ¶

    ARRAY_LAYER_COUNT_UNDEFINED: u32 : max(u32)

    BINDINGS_VERSION ¶

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

    BINDINGS_VERSION_STRING ¶

    BINDINGS_VERSION_STRING :: "0.19.4.1"

    COPY_STRIDE_UNDEFINED ¶

    COPY_STRIDE_UNDEFINED: u32 : max(u32)

    ColorWriteMaskFlags_All ¶

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

    DEPTH_SLICE_UNDEFINED ¶

    DEPTH_SLICE_UNDEFINED: u32 : max(u32)

    InstanceBackendFlags_All ¶

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

    InstanceBackendFlags_Primary ¶

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

    InstanceBackendFlags_Secondary ¶

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

    InstanceFlags_Default ¶

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

    LIMIT_U32_UNDEFINED ¶

    LIMIT_U32_UNDEFINED: u32 : max(u32)

    LIMIT_U64_UNDEFINED ¶

    LIMIT_U64_UNDEFINED: u64 : max(u64)

    MIP_LEVEL_COUNT_UNDEFINED ¶

    MIP_LEVEL_COUNT_UNDEFINED: u32 : max(u32)

    QUERY_SET_INDEX_UNDEFINED ¶

    QUERY_SET_INDEX_UNDEFINED: u32 : max(u32)

    WGPU_DEBUG ¶

    WGPU_DEBUG :: #config(WGPU_DEBUG, false)

    WGPU_SHARED ¶

    WGPU_SHARED :: #config(WGPU_SHARED, false)

    WHOLE_MAP_SIZE ¶

    WHOLE_MAP_SIZE: uint : max(uint)

    WHOLE_SIZE ¶

    WHOLE_SIZE: u64 : max(u64)

    Variables

    This section is empty.

    Procedures

    AdapterEnumerateFeatures ¶

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

    AdapterGetLimits ¶

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

    AdapterGetProperties ¶

    AdapterGetProperties :: proc(adapter: Adapter) -> (properties: AdapterProperties) {…}

    AdapterHasFeature ¶

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

    AdapterReference ¶

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

    AdapterRelease ¶

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

    AdapterRequestDevice ¶

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

    AdapterRequestAdapterInfo :: proc(adapter: Adapter, callback: AdapterRequestAdapterInfoCallback, / NULLABLE / userdata: rawptr) ---

    BindGroupLayoutReference ¶

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

    BindGroupLayoutRelease ¶

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

    BindGroupLayoutSetLabel ¶

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

    Methods of BindGroupLayout

    BindGroupReference ¶

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

    BindGroupRelease ¶

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

    BindGroupSetLabel ¶

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

    Methods of BindGroup

    BufferDestroy ¶

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

    Methods of Buffer

    BufferGetConstMappedRange ¶

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

    BufferGetConstMappedRangeSlice ¶

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

    BufferGetConstMappedRangeTyped ¶

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

    BufferGetMapState ¶

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

    BufferGetMappedRange ¶

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

    BufferGetMappedRangeSlice ¶

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

    BufferGetMappedRangeTyped ¶

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

    BufferGetSize ¶

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

    BufferGetUsage ¶

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

    BufferMapAsync ¶

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

    BufferReference ¶

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

    BufferRelease ¶

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

    BufferSetLabel ¶

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

    BufferUnmap ¶

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

    CommandBufferReference ¶

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

    CommandBufferRelease ¶

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

    CommandBufferSetLabel ¶

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

    Methods of CommandBuffer

    CommandEncoderBeginComputePass ¶

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

    Methods of CommandEncoder

    CommandEncoderBeginRenderPass ¶

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

    CommandEncoderClearBuffer ¶

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

    CommandEncoderCopyBufferToBuffer ¶

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

    CommandEncoderCopyBufferToTexture ¶

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

    CommandEncoderCopyTextureToBuffer ¶

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

    CommandEncoderCopyTextureToTexture ¶

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

    CommandEncoderFinish ¶

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

    CommandEncoderInsertDebugMarker ¶

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

    CommandEncoderPopDebugGroup ¶

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

    CommandEncoderPushDebugGroup ¶

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

    CommandEncoderReference ¶

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

    CommandEncoderRelease ¶

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

    CommandEncoderResolveQuerySet ¶

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

    CommandEncoderSetLabel ¶

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

    CommandEncoderWriteTimestamp ¶

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

    ComputePassEncoderBeginPipelineStatisticsQuery ¶

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

    ComputePassEncoderDispatchWorkgroups ¶

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

    Methods of ComputePassEncoder

    ComputePassEncoderDispatchWorkgroupsIndirect ¶

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

    ComputePassEncoderEnd ¶

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

    ComputePassEncoderEndPipelineStatisticsQuery ¶

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

    ComputePassEncoderInsertDebugMarker ¶

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

    ComputePassEncoderPopDebugGroup ¶

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

    ComputePassEncoderPushDebugGroup ¶

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

    ComputePassEncoderReference ¶

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

    ComputePassEncoderRelease ¶

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

    ComputePassEncoderSetBindGroup ¶

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

    ComputePassEncoderSetLabel ¶

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

    ComputePassEncoderSetPipeline ¶

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

    ComputePipelineGetBindGroupLayout ¶

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

    Methods of ComputePipeline

    ComputePipelineReference ¶

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

    ComputePipelineRelease ¶

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

    ComputePipelineSetLabel ¶

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

    ConvertOdinToWGPULogLevel ¶

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

    ConvertWGPUToOdinLogLevel ¶

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

    CreateInstance ¶

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

    DeviceCreateBindGroup ¶

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

    Methods of Device

    DeviceCreateBindGroupLayout ¶

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

    DeviceCreateBuffer ¶

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

    DeviceCreateBufferWithDataSlice ¶

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

    DeviceCreateBufferWithDataTyped ¶

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

    DeviceCreateCommandEncoder ¶

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

    DeviceCreateComputePipeline ¶

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

    DeviceCreateComputePipelineAsync ¶

    DeviceCreateComputePipelineAsync :: proc "c" (device: Device, descriptor: ^ComputePipelineDescriptor, callback: DeviceCreateComputePipelineAsyncCallback, userdata: rawptr = nil) ---

    DeviceCreatePipelineLayout ¶

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

    DeviceCreateQuerySet ¶

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

    DeviceCreateRenderBundleEncoder ¶

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

    DeviceCreateRenderPipeline ¶

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

    DeviceCreateRenderPipelineAsync ¶

    DeviceCreateRenderPipelineAsync :: proc "c" (device: Device, descriptor: ^RenderPipelineDescriptor, callback: DeviceCreateRenderPipelineAsyncCallback, userdata: rawptr = nil) ---

    DeviceCreateSampler ¶

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

    DeviceCreateShaderModule ¶

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

    DeviceCreateTexture ¶

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

    DeviceDestroy ¶

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

    DeviceEnumerateFeatures ¶

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

    DeviceGetLimits ¶

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

    DeviceGetQueue ¶

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

    DeviceHasFeature ¶

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

    DevicePoll ¶

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

    Returns true if the queue is empty, or false if there are more queue submissions still in flight.

    DevicePopErrorScope ¶

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

    DevicePushErrorScope ¶

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

    DeviceReference ¶

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

    DeviceRelease ¶

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

    DeviceSetLabel ¶

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

    DeviceSetUncapturedErrorCallback ¶

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

    GenerateReport ¶

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

    GetProcAddress ¶

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

    GetVersion ¶

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

    InstanceCreateSurface ¶

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

    Methods of Instance

    InstanceEnumerateAdapters ¶

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

    InstanceProcessEvents ¶

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

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

    InstanceReference ¶

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

    InstanceRelease ¶

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

    InstanceRequestAdapter ¶

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

    PipelineLayoutReference ¶

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

    PipelineLayoutRelease ¶

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

    PipelineLayoutSetLabel ¶

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

    Methods of PipelineLayout

    QuerySetDestroy ¶

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

    Methods of QuerySet

    QuerySetGetCount ¶

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

    QuerySetGetType ¶

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

    QuerySetReference ¶

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

    QuerySetRelease ¶

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

    QuerySetSetLabel ¶

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

    QueueOnSubmittedWorkDone ¶

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

    Methods of Queue

    QueueReference ¶

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

    QueueRelease ¶

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

    QueueSetLabel ¶

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

    QueueSubmit ¶

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

    QueueSubmitForIndex ¶

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

    QueueWriteBuffer ¶

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

    QueueWriteTexture ¶

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

    RawAdapterEnumerateFeatures ¶

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

    Methods of Adapter

    RawAdapterGetLimits ¶

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

    RawAdapterGetProperties ¶

    RawAdapterGetProperties :: proc "c" (adapter: Adapter, properties: ^AdapterProperties) ---

    RawBufferGetConstMappedRange ¶

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

    RawBufferGetMappedRange ¶

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

    RawComputePassEncoderSetBindGroup ¶

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

    RawDeviceEnumerateFeatures ¶

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

    RawDeviceGetLimits ¶

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

    RawGenerateReport ¶

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

    RawInstanceEnumerateAdapters ¶

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

    RawQueueSubmit ¶

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

    RawQueueSubmitForIndex ¶

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

    RawRenderBundleEncoderSetBindGroup ¶

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

    RawRenderPassEncoderExecuteBundles ¶

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

    RawRenderPassEncoderSetBindGroup ¶

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

    RawSurfaceGetCapabilities ¶

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

    RawSurfaceGetCurrentTexture ¶

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

    RenderBundleEncoderDraw ¶

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

    Methods of RenderBundleEncoder

    RenderBundleEncoderDrawIndexed ¶

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

    RenderBundleEncoderDrawIndexedIndirect ¶

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

    RenderBundleEncoderDrawIndirect ¶

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

    RenderBundleEncoderFinish ¶

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

    RenderBundleEncoderInsertDebugMarker ¶

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

    RenderBundleEncoderPopDebugGroup ¶

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

    RenderBundleEncoderPushDebugGroup ¶

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

    RenderBundleEncoderReference ¶

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

    RenderBundleEncoderRelease ¶

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

    RenderBundleEncoderSetBindGroup ¶

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

    RenderBundleEncoderSetIndexBuffer ¶

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

    RenderBundleEncoderSetLabel ¶

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

    RenderBundleEncoderSetPipeline ¶

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

    RenderBundleEncoderSetVertexBuffer ¶

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

    RenderBundleReference ¶

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

    RenderBundleRelease ¶

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

    RenderBundleSetLabel ¶

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

    Methods of RenderBundle

    RenderPassEncoderBeginOcclusionQuery ¶

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

    Methods of RenderPassEncoder

    RenderPassEncoderBeginPipelineStatisticsQuery ¶

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

    RenderPassEncoderDraw ¶

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

    RenderPassEncoderDrawIndexed ¶

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

    RenderPassEncoderDrawIndexedIndirect ¶

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

    RenderPassEncoderDrawIndirect ¶

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

    RenderPassEncoderEnd ¶

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

    RenderPassEncoderEndOcclusionQuery ¶

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

    RenderPassEncoderEndPipelineStatisticsQuery ¶

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

    RenderPassEncoderExecuteBundles ¶

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

    RenderPassEncoderInsertDebugMarker ¶

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

    RenderPassEncoderMultiDrawIndexedIndirect ¶

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

    RenderPassEncoderMultiDrawIndexedIndirectCount ¶

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

    RenderPassEncoderMultiDrawIndirect ¶

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

    RenderPassEncoderMultiDrawIndirectCount ¶

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

    RenderPassEncoderPopDebugGroup ¶

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

    RenderPassEncoderPushDebugGroup ¶

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

    RenderPassEncoderReference ¶

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

    RenderPassEncoderRelease ¶

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

    RenderPassEncoderSetBindGroup ¶

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

    RenderPassEncoderSetBlendConstant ¶

    RenderPassEncoderSetBlendConstant :: proc "c" (renderPassEncoder: RenderPassEncoder, color: ^Color) ---

    RenderPassEncoderSetIndexBuffer ¶

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

    RenderPassEncoderSetLabel ¶

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

    RenderPassEncoderSetPipeline ¶

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

    RenderPassEncoderSetPushConstants ¶

    RenderPassEncoderSetPushConstants :: proc "c" (encoder: RenderPassEncoder, stages: bit_set[ShaderStage; u32], offset: u32, sizeBytes: u32, data: rawptr) ---

    RenderPassEncoderSetScissorRect ¶

    RenderPassEncoderSetScissorRect :: proc "c" (renderPassEncoder: RenderPassEncoder, x: u32, y: u32, width: u32, height: u32) ---

    RenderPassEncoderSetStencilReference ¶

    RenderPassEncoderSetStencilReference :: proc "c" (renderPassEncoder: RenderPassEncoder, reference: u32) ---

    RenderPassEncoderSetVertexBuffer ¶

    RenderPassEncoderSetVertexBuffer :: proc "c" (renderPassEncoder: RenderPassEncoder, slot: u32, buffer: Buffer, offset: u64, size: u64) ---

    RenderPassEncoderSetViewport ¶

    RenderPassEncoderSetViewport :: proc "c" (
    	renderPassEncoder: RenderPassEncoder, 
    	x:                 f32, 
    	y:                 f32, 
    	width:             f32, 
    	height:            f32, 
    	minDepth:          f32, 
    	maxDepth:          f32, 
    ) ---

    RenderPipelineGetBindGroupLayout ¶

    RenderPipelineGetBindGroupLayout :: proc "c" (renderPipeline: RenderPipeline, groupIndex: u32) -> BindGroupLayout ---
     

    Methods of RenderPipeline

    RenderPipelineReference ¶

    RenderPipelineReference :: proc "c" (renderPipeline: RenderPipeline) ---

    RenderPipelineRelease ¶

    RenderPipelineRelease :: proc "c" (renderPipeline: RenderPipeline) ---

    RenderPipelineSetLabel ¶

    RenderPipelineSetLabel :: proc "c" (renderPipeline: RenderPipeline, label: cstring) ---

    SamplerReference ¶

    SamplerReference :: proc "c" (sampler: Sampler) ---

    SamplerRelease ¶

    SamplerRelease :: proc "c" (sampler: Sampler) ---

    SamplerSetLabel ¶

    SamplerSetLabel :: proc "c" (sampler: Sampler, label: cstring) ---
     

    Methods of Sampler

    SetLogCallback ¶

    SetLogCallback :: proc "c" (callback: LogCallback, userdata: rawptr) ---

    SetLogLevel ¶

    SetLogLevel :: proc "c" (level: LogLevel) ---

    ShaderModuleGetCompilationInfo ¶

    ShaderModuleGetCompilationInfo :: proc "c" (shaderModule: ShaderModule, callback: ShaderModuleGetCompilationInfoCallback, userdata: rawptr = nil) ---
     

    Methods of ShaderModule

    ShaderModuleReference ¶

    ShaderModuleReference :: proc "c" (shaderModule: ShaderModule) ---

    ShaderModuleRelease ¶

    ShaderModuleRelease :: proc "c" (shaderModule: ShaderModule) ---

    ShaderModuleSetLabel ¶

    ShaderModuleSetLabel :: proc "c" (shaderModule: ShaderModule, label: cstring) ---

    SurfaceCapabilitiesFreeMembers ¶

    SurfaceCapabilitiesFreeMembers :: proc "c" (surfaceCapabilities: SurfaceCapabilities) ---
     

    Methods of SurfaceCapabilities

    SurfaceConfigure ¶

    SurfaceConfigure :: proc "c" (surface: Surface, config: ^SurfaceConfiguration) ---
     

    Methods of Surface

    SurfaceGetCapabilities ¶

    SurfaceGetCapabilities :: proc(surface: Surface, adapter: Adapter) -> (capabilities: SurfaceCapabilities) {…}

    SurfaceGetCurrentTexture ¶

    SurfaceGetCurrentTexture :: proc(surface: Surface) -> (surface_texture: SurfaceTexture) {…}

    SurfaceGetPreferredFormat ¶

    SurfaceGetPreferredFormat :: proc "c" (surface: Surface, adapter: Adapter) -> TextureFormat ---

    SurfacePresent ¶

    SurfacePresent :: proc "c" (surface: Surface) ---

    SurfaceReference ¶

    SurfaceReference :: proc "c" (surface: Surface) ---

    SurfaceRelease ¶

    SurfaceRelease :: proc "c" (surface: Surface) ---

    SurfaceUnconfigure ¶

    SurfaceUnconfigure :: proc "c" (surface: Surface) ---
     

    SurfaceSetLabel :: proc(surface: Surface, label: cstring) ---

    TextureCreateView ¶

    TextureCreateView :: proc "c" (texture: Texture, descriptor: ^TextureViewDescriptor = nil) -> TextureView ---
     

    Methods of Texture

    TextureDestroy ¶

    TextureDestroy :: proc "c" (texture: Texture) ---

    TextureGetDepthOrArrayLayers ¶

    TextureGetDepthOrArrayLayers :: proc "c" (texture: Texture) -> u32 ---

    TextureGetDimension ¶

    TextureGetDimension :: proc "c" (texture: Texture) -> TextureDimension ---

    TextureGetFormat ¶

    TextureGetFormat :: proc "c" (texture: Texture) -> TextureFormat ---

    TextureGetHeight ¶

    TextureGetHeight :: proc "c" (texture: Texture) -> u32 ---

    TextureGetMipLevelCount ¶

    TextureGetMipLevelCount :: proc "c" (texture: Texture) -> u32 ---

    TextureGetSampleCount ¶

    TextureGetSampleCount :: proc "c" (texture: Texture) -> u32 ---

    TextureGetUsage ¶

    TextureGetUsage :: proc "c" (texture: Texture) -> bit_set[TextureUsage; u32] ---

    TextureGetWidth ¶

    TextureGetWidth :: proc "c" (texture: Texture) -> u32 ---

    TextureReference ¶

    TextureReference :: proc "c" (texture: Texture) ---

    TextureRelease ¶

    TextureRelease :: proc "c" (texture: Texture) ---

    TextureSetLabel ¶

    TextureSetLabel :: proc "c" (texture: Texture, label: cstring) ---

    TextureViewReference ¶

    TextureViewReference :: proc "c" (textureView: TextureView) ---

    TextureViewRelease ¶

    TextureViewRelease :: proc "c" (textureView: TextureView) ---

    TextureViewSetLabel ¶

    TextureViewSetLabel :: proc "c" (textureView: TextureView, label: cstring) ---
     

    Methods of TextureView

    Procedure Groups

    Source Files

    Generation Information

    Generated with odin version dev-2024-07 (vendor "odin") Windows_amd64 @ 2024-07-18 21:09:44.026772200 +0000 UTC