gputypes

const (
	// AccelerationStructureCopyModeClone creates a direct duplicate.
	AccelerationStructureCopyModeClone AccelerationStructureCopyMode = iota
	// AccelerationStructureCopyModeCompact duplicates and compacts (20-40% memory reduction).
	AccelerationStructureCopyModeCompact
)

const (
	// ASFlagAllowUpdate enables incremental updates after initial build.
	ASFlagAllowUpdate AccelerationStructureFlags = 0x01
	// ASFlagAllowCompaction enables compaction via copy operation.
	ASFlagAllowCompaction AccelerationStructureFlags = 0x02
	// ASFlagPreferFastTrace optimizes for trace performance (static geometry).
	ASFlagPreferFastTrace AccelerationStructureFlags = 0x04
	// ASFlagPreferFastBuild optimizes for build performance (dynamic geometry).
	ASFlagPreferFastBuild AccelerationStructureFlags = 0x08
	// ASFlagLowMemory optimizes for low memory usage.
	ASFlagLowMemory AccelerationStructureFlags = 0x10
	// ASFlagUseTransform enables the transform buffer in BLAS triangle builds.
	ASFlagUseTransform AccelerationStructureFlags = 0x20
	// ASFlagAllowRayHitVertexReturn enables triangle vertex retrieval on ray hit.
	ASFlagAllowRayHitVertexReturn AccelerationStructureFlags = 0x40
)

const (
	// ASGeometryFlagOpaque marks geometry as opaque (skips any-hit shader).
	ASGeometryFlagOpaque AccelerationStructureGeometryFlags = 0x01
	// ASGeometryFlagNoDuplicateAnyHitInvocation limits any-hit to one invocation per primitive.
	ASGeometryFlagNoDuplicateAnyHitInvocation AccelerationStructureGeometryFlags = 0x02
)

const (
	// AccelerationStructureTypeTriangles contains triangle geometry.
	AccelerationStructureTypeTriangles AccelerationStructureType = iota
	// AccelerationStructureTypeAABBs contains axis-aligned bounding boxes.
	AccelerationStructureTypeAABBs
	// AccelerationStructureTypeInstances contains TLAS instance references to BLASes.
	AccelerationStructureTypeInstances
)

const (
	// AccelerationStructureUpdateModeBuild always performs a full build.
	AccelerationStructureUpdateModeBuild AccelerationStructureUpdateMode = iota
	// AccelerationStructureUpdateModePreferUpdate performs an incremental update
	// if the hardware supports it (e.g. for skinned meshes), otherwise falls back to full build.
	AccelerationStructureUpdateModePreferUpdate
)

const (
	// AddressModeUndefined is an undefined address mode (invalid).
	AddressModeUndefined AddressMode = 0x00000000
	// AddressModeClampToEdge clamps coordinates to the edge texel.
	AddressModeClampToEdge AddressMode = 0x00000001
	// AddressModeRepeat repeats the texture (wrapping).
	AddressModeRepeat AddressMode = 0x00000002
	// AddressModeMirrorRepeat repeats with mirroring.
	AddressModeMirrorRepeat AddressMode = 0x00000003
)

const (
	// BackendEmpty represents no backend (invalid state).
	BackendEmpty Backend = iota
	// BackendVulkan uses the Vulkan API (cross-platform).
	BackendVulkan
	// BackendMetal uses Apple's Metal API (macOS, iOS).
	BackendMetal
	// BackendDX12 uses Microsoft DirectX 12 (Windows).
	BackendDX12
	// BackendGL uses OpenGL/OpenGL ES (legacy fallback).
	BackendGL
	// BackendBrowserWebGPU uses the browser's native WebGPU (WASM).
	BackendBrowserWebGPU
)

const (
	// BackendsNone includes no backends.
	BackendsNone Backends = 0
	// BackendsVulkan includes Vulkan.
	BackendsVulkan Backends = 1 << BackendVulkan
	// BackendsMetal includes Metal.
	BackendsMetal Backends = 1 << BackendMetal
	// BackendsDX12 includes DirectX 12.
	BackendsDX12 Backends = 1 << BackendDX12
	// BackendsGL includes OpenGL/OpenGL ES.
	BackendsGL Backends = 1 << BackendGL
	// BackendsBrowserWebGPU includes browser WebGPU.
	BackendsBrowserWebGPU Backends = 1 << BackendBrowserWebGPU

	// BackendsPrimary includes all primary backends (Vulkan, Metal, DX12, BrowserWebGPU).
	BackendsPrimary = BackendsVulkan | BackendsMetal | BackendsDX12 | BackendsBrowserWebGPU
	// BackendsSecondary includes fallback backends (GL only).
	BackendsSecondary = BackendsGL
	// BackendsAll includes all backends.
	BackendsAll = BackendsPrimary | BackendsSecondary
)

const (
	// BlendFactorUndefined is an undefined blend factor (invalid).
	BlendFactorUndefined BlendFactor = 0x00000000
	// BlendFactorZero uses 0.
	BlendFactorZero BlendFactor = 0x00000001
	// BlendFactorOne uses 1.
	BlendFactorOne BlendFactor = 0x00000002
	// BlendFactorSrc uses the source color.
	BlendFactorSrc BlendFactor = 0x00000003
	// BlendFactorOneMinusSrc uses (1 - source color).
	BlendFactorOneMinusSrc BlendFactor = 0x00000004
	// BlendFactorSrcAlpha uses the source alpha.
	BlendFactorSrcAlpha BlendFactor = 0x00000005
	// BlendFactorOneMinusSrcAlpha uses (1 - source alpha).
	BlendFactorOneMinusSrcAlpha BlendFactor = 0x00000006
	// BlendFactorDst uses the destination color.
	BlendFactorDst BlendFactor = 0x00000007
	// BlendFactorOneMinusDst uses (1 - destination color).
	BlendFactorOneMinusDst BlendFactor = 0x00000008
	// BlendFactorDstAlpha uses the destination alpha.
	BlendFactorDstAlpha BlendFactor = 0x00000009
	// BlendFactorOneMinusDstAlpha uses (1 - destination alpha).
	BlendFactorOneMinusDstAlpha BlendFactor = 0x0000000A
	// BlendFactorSrcAlphaSaturated uses min(source alpha, 1 - destination alpha).
	BlendFactorSrcAlphaSaturated BlendFactor = 0x0000000B
	// BlendFactorConstant uses the constant blend color.
	BlendFactorConstant BlendFactor = 0x0000000C
	// BlendFactorOneMinusConstant uses (1 - constant blend color).
	BlendFactorOneMinusConstant BlendFactor = 0x0000000D
)

const (
	// BlendOperationUndefined is an undefined blend operation (invalid).
	BlendOperationUndefined BlendOperation = 0x00000000
	// BlendOperationAdd computes src + dst.
	BlendOperationAdd BlendOperation = 0x00000001
	// BlendOperationSubtract computes src - dst.
	BlendOperationSubtract BlendOperation = 0x00000002
	// BlendOperationReverseSubtract computes dst - src.
	BlendOperationReverseSubtract BlendOperation = 0x00000003
	// BlendOperationMin computes min(src, dst).
	BlendOperationMin BlendOperation = 0x00000004
	// BlendOperationMax computes max(src, dst).
	BlendOperationMax BlendOperation = 0x00000005
)

const (
	// BufferBindingTypeUndefined is an undefined binding type (invalid).
	BufferBindingTypeUndefined BufferBindingType = 0x00000000
	// BufferBindingTypeUniform binds as a uniform buffer (read-only in shaders).
	BufferBindingTypeUniform BufferBindingType = 0x00000001
	// BufferBindingTypeStorage binds as a storage buffer (read-write in shaders).
	BufferBindingTypeStorage BufferBindingType = 0x00000002
	// BufferBindingTypeReadOnlyStorage binds as a read-only storage buffer.
	BufferBindingTypeReadOnlyStorage BufferBindingType = 0x00000003
)

const (
	// BufferMapStateUnmapped means the buffer is not mapped.
	BufferMapStateUnmapped BufferMapState = iota
	// BufferMapStatePending means a map operation is pending.
	BufferMapStatePending
	// BufferMapStateMapped means the buffer is currently mapped.
	BufferMapStateMapped
)

const (
	// BufferUsageNone indicates no usage (invalid for most operations).
	BufferUsageNone BufferUsage = 0x0000000000000000
	// BufferUsageMapRead allows mapping the buffer for reading.
	BufferUsageMapRead BufferUsage = 0x0000000000000001
	// BufferUsageMapWrite allows mapping the buffer for writing.
	BufferUsageMapWrite BufferUsage = 0x0000000000000002
	// BufferUsageCopySrc allows the buffer to be a copy source.
	BufferUsageCopySrc BufferUsage = 0x0000000000000004
	// BufferUsageCopyDst allows the buffer to be a copy destination.
	BufferUsageCopyDst BufferUsage = 0x0000000000000008
	// BufferUsageIndex allows use as an index buffer.
	BufferUsageIndex BufferUsage = 0x0000000000000010
	// BufferUsageVertex allows use as a vertex buffer.
	BufferUsageVertex BufferUsage = 0x0000000000000020
	// BufferUsageUniform allows use as a uniform buffer.
	BufferUsageUniform BufferUsage = 0x0000000000000040
	// BufferUsageStorage allows use as a storage buffer.
	BufferUsageStorage BufferUsage = 0x0000000000000080
	// BufferUsageIndirect allows use for indirect draw/dispatch commands.
	BufferUsageIndirect BufferUsage = 0x0000000000000100
	// BufferUsageQueryResolve allows use for query result resolution.
	BufferUsageQueryResolve BufferUsage = 0x0000000000000200

	// BufferUsageAccelerationStructureScratch allows use as scratch space during AS build.
	BufferUsageAccelerationStructureScratch BufferUsage = 0x0000000000000800
	// BufferUsageBlasInput allows use as BLAS build input (vertex/index/transform/AABB data).
	BufferUsageBlasInput BufferUsage = 0x0000000000001000
	// BufferUsageTlasInput allows use as TLAS build input (instance data).
	BufferUsageTlasInput BufferUsage = 0x0000000000002000
	// BufferUsageAccelerationStructureQuery allows use for AS compaction size readback.
	BufferUsageAccelerationStructureQuery BufferUsage = 0x0000000000004000
)

const (
	// ColorWriteMaskNone writes no channels.
	ColorWriteMaskNone ColorWriteMask = 0x00000000
	// ColorWriteMaskRed writes the red channel.
	ColorWriteMaskRed ColorWriteMask = 0x00000001
	// ColorWriteMaskGreen writes the green channel.
	ColorWriteMaskGreen ColorWriteMask = 0x00000002
	// ColorWriteMaskBlue writes the blue channel.
	ColorWriteMaskBlue ColorWriteMask = 0x00000004
	// ColorWriteMaskAlpha writes the alpha channel.
	ColorWriteMaskAlpha ColorWriteMask = 0x00000008
	// ColorWriteMaskAll writes all channels.
	ColorWriteMaskAll ColorWriteMask = 0x0000000F
)

const (
	// CompareFunctionUndefined is undefined (no comparison).
	CompareFunctionUndefined CompareFunction = 0x00000000
	// CompareFunctionNever always fails.
	CompareFunctionNever CompareFunction = 0x00000001
	// CompareFunctionLess passes if source < destination.
	CompareFunctionLess CompareFunction = 0x00000002
	// CompareFunctionEqual passes if source == destination.
	CompareFunctionEqual CompareFunction = 0x00000003
	// CompareFunctionLessEqual passes if source <= destination.
	CompareFunctionLessEqual CompareFunction = 0x00000004
	// CompareFunctionGreater passes if source > destination.
	CompareFunctionGreater CompareFunction = 0x00000005
	// CompareFunctionNotEqual passes if source != destination.
	CompareFunctionNotEqual CompareFunction = 0x00000006
	// CompareFunctionGreaterEqual passes if source >= destination.
	CompareFunctionGreaterEqual CompareFunction = 0x00000007
	// CompareFunctionAlways always passes.
	CompareFunctionAlways CompareFunction = 0x00000008
)

const (
	// CompositeAlphaModeAuto chooses Opaque or Inherit automatically.
	CompositeAlphaModeAuto CompositeAlphaMode = 0x00000000

	// CompositeAlphaModeOpaque ignores alpha, treats texture as fully opaque.
	CompositeAlphaModeOpaque CompositeAlphaMode = 0x00000001

	// CompositeAlphaModePremultiplied expects colors to be pre-multiplied by alpha.
	CompositeAlphaModePremultiplied CompositeAlphaMode = 0x00000002

	// CompositeAlphaModeUnpremultiplied has compositor multiply colors by alpha.
	CompositeAlphaModeUnpremultiplied CompositeAlphaMode = 0x00000003

	// CompositeAlphaModeInherit uses platform-specific default.
	CompositeAlphaModeInherit CompositeAlphaMode = 0x00000004
)

const (
	// CullModeNone culls no faces. This is the zero value and WebGPU spec default.
	CullModeNone CullMode = 0
	// CullModeFront culls front faces.
	CullModeFront CullMode = 1
	// CullModeBack culls back faces.
	CullModeBack CullMode = 2
)

const (
	// DeviceTypeOther is an unknown or other device type.
	DeviceTypeOther DeviceType = iota
	// DeviceTypeIntegratedGPU is integrated into the CPU (shared memory).
	DeviceTypeIntegratedGPU
	// DeviceTypeDiscreteGPU is a separate GPU with dedicated memory.
	DeviceTypeDiscreteGPU
	// DeviceTypeVirtualGPU is a virtual GPU (e.g., in a VM).
	DeviceTypeVirtualGPU
	// DeviceTypeCPU is software rendering on the CPU.
	DeviceTypeCPU
)

const (
	// DownlevelFlagsComputeShaders indicates the device supports compiling and using compute shaders.
	// WebGL2 and GLES 3.0 devices do not support compute.
	DownlevelFlagsComputeShaders DownlevelFlags = 1 << 0

	// DownlevelFlagsFragmentWritableStorage indicates support for binding storage buffers
	// and textures to fragment shaders.
	DownlevelFlagsFragmentWritableStorage DownlevelFlags = 1 << 1

	// DownlevelFlagsIndirectExecution indicates support for indirect drawing and dispatching.
	// DownlevelFlagsComputeShaders must be present for this flag.
	// WebGL2, GLES 3.0, and Metal on Apple1/Apple2 GPUs do not support indirect.
	DownlevelFlagsIndirectExecution DownlevelFlags = 1 << 2

	// DownlevelFlagsBaseVertex indicates support for non-zero base_vertex parameter
	// to direct indexed draw calls.
	// Indirect calls, if supported, always support non-zero base_vertex.
	DownlevelFlagsBaseVertex DownlevelFlags = 1 << 3

	// DownlevelFlagsReadOnlyDepthStencil indicates support for reading from a depth/stencil
	// texture while using it as a read-only depth/stencil attachment.
	// The WebGL2 and GLES backends do not support RODS.
	DownlevelFlagsReadOnlyDepthStencil DownlevelFlags = 1 << 4

	// DownlevelFlagsNonPowerOfTwoMipmappedTextures indicates support for textures with mipmaps
	// which have a non power of two size.
	DownlevelFlagsNonPowerOfTwoMipmappedTextures DownlevelFlags = 1 << 5

	// DownlevelFlagsCubeArrayTextures indicates support for textures that are cube arrays.
	DownlevelFlagsCubeArrayTextures DownlevelFlags = 1 << 6

	// DownlevelFlagsComparisonSamplers indicates support for comparison samplers.
	DownlevelFlagsComparisonSamplers DownlevelFlags = 1 << 7

	// DownlevelFlagsIndependentBlend indicates support for different blend operations
	// per color attachment.
	DownlevelFlagsIndependentBlend DownlevelFlags = 1 << 8

	// DownlevelFlagsVertexStorage indicates support for storage buffers in vertex shaders.
	DownlevelFlagsVertexStorage DownlevelFlags = 1 << 9

	// DownlevelFlagsAnisotropicFiltering indicates support for samplers with anisotropic filtering.
	// Note this isn't actually required by WebGPU; the implementation is allowed to completely
	// ignore aniso clamp. This flag is here for native backends so they can communicate
	// to the user if aniso is enabled.
	// All backends and all devices support anisotropic filtering.
	DownlevelFlagsAnisotropicFiltering DownlevelFlags = 1 << 10

	// DownlevelFlagsFragmentStorage indicates support for storage buffers in fragment shaders.
	DownlevelFlagsFragmentStorage DownlevelFlags = 1 << 11

	// DownlevelFlagsMultisampledShading indicates support for sample-rate shading.
	DownlevelFlagsMultisampledShading DownlevelFlags = 1 << 12

	// DownlevelFlagsDepthTextureAndBufferCopies indicates support for copies between
	// depth textures and buffers.
	// GLES/WebGL don't support this.
	DownlevelFlagsDepthTextureAndBufferCopies DownlevelFlags = 1 << 13

	// DownlevelFlagsWebGPUTextureFormatSupport indicates support for all the texture usages
	// described in WebGPU. If this isn't supported, call GetTextureFormatFeatures to determine
	// how you can use textures of a given format.
	DownlevelFlagsWebGPUTextureFormatSupport DownlevelFlags = 1 << 14

	// DownlevelFlagsBufferBindingsNot16ByteAligned indicates support for buffer bindings
	// with sizes that aren't a multiple of 16.
	// WebGL doesn't support this.
	DownlevelFlagsBufferBindingsNot16ByteAligned DownlevelFlags = 1 << 15

	// DownlevelFlagsUnrestrictedIndexBuffer indicates support for buffers to combine INDEX
	// usage with usages other than COPY_DST and COPY_SRC.
	// WebGL doesn't support this.
	DownlevelFlagsUnrestrictedIndexBuffer DownlevelFlags = 1 << 16

	// DownlevelFlagsFullDrawIndexUint32 indicates support for full 32-bit range indices
	// (2^32-1 as opposed to 2^24-1 without this flag).
	// Corresponds to Vulkan's VkPhysicalDeviceFeatures.fullDrawIndexUint32.
	DownlevelFlagsFullDrawIndexUint32 DownlevelFlags = 1 << 17

	// DownlevelFlagsDepthBiasClamp indicates support for depth bias clamping.
	// Corresponds to Vulkan's VkPhysicalDeviceFeatures.depthBiasClamp.
	DownlevelFlagsDepthBiasClamp DownlevelFlags = 1 << 18

	// DownlevelFlagsViewFormats indicates support for specifying which view format values
	// are allowed when create_view() is called on a texture.
	// The WebGL and GLES backends don't support this.
	DownlevelFlagsViewFormats DownlevelFlags = 1 << 19

	// DownlevelFlagsUnrestrictedExternalTextureCopies indicates support for unrestricted
	// external texture copy operations.
	// WebGL doesn't support this. WebGPU does.
	DownlevelFlagsUnrestrictedExternalTextureCopies DownlevelFlags = 1 << 20

	// DownlevelFlagsSurfaceViewFormats indicates support for specifying which view formats
	// are allowed when calling create_view on the texture returned by Surface.GetCurrentTexture.
	// The GLES/WebGL and Vulkan on Android don't support this.
	DownlevelFlagsSurfaceViewFormats DownlevelFlags = 1 << 21

	// DownlevelFlagsNonblockingQueryResolve indicates that calls to
	// CommandEncoder.ResolveQuerySet will be performed on the queue timeline.
	// If false, resolve will be performed on the device (CPU) timeline and will block
	// until the query has data.
	DownlevelFlagsNonblockingQueryResolve DownlevelFlags = 1 << 22

	// DownlevelFlagsShaderF16InF32 allows shaders to use quantizeToF16, pack2x16float,
	// and unpack2x16float, which operate on f16-precision values stored in f32s.
	// Not supported by Vulkan on Mesa when FeatureShaderF16 is absent.
	DownlevelFlagsShaderF16InF32 DownlevelFlags = 1 << 23

	// DownlevelFlagsMSL21 indicates support for features introduced in MSL 2.1.
	DownlevelFlagsMSL21 DownlevelFlags = 1 << 24

	// DownlevelFlagsTextureCompression indicates the adapter supports the WebGPU texture
	// compression requirement: BC || (ETC2 && ASTC).
	// See https://www.w3.org/TR/webgpu/#adapter-capability-guarantees.
	DownlevelFlagsTextureCompression DownlevelFlags = 1 << 25

	// DownlevelFlagsLinearInterpolation indicates support for @interpolate(linear)
	// (a.k.a. noperspective) on shader inter-stage variables.
	// GLSL ES has no noperspective qualifier, so the GLES backend only supports this
	// on desktop OpenGL, not on GLES/WebGL2.
	DownlevelFlagsLinearInterpolation DownlevelFlags = 1 << 26
)

const (
	// Dx12ShaderCompilerFxc uses the legacy FXC compiler.
	Dx12ShaderCompilerFxc Dx12ShaderCompiler = iota
	// Dx12ShaderCompilerDxc uses the modern DXC compiler.
	Dx12ShaderCompilerDxc
)

const (
	// FeatureDepthClipControl enables depth clip control (unclipped depth).
	FeatureDepthClipControl Feature = 1 << iota
	// FeatureDepth32FloatStencil8 enables the depth32float-stencil8 texture format.
	FeatureDepth32FloatStencil8
	// FeatureTextureCompressionBC enables BC texture compression formats.
	FeatureTextureCompressionBC
	// FeatureTextureCompressionETC2 enables ETC2 texture compression formats.
	FeatureTextureCompressionETC2
	// FeatureTextureCompressionASTC enables ASTC texture compression formats.
	FeatureTextureCompressionASTC
	// FeatureIndirectFirstInstance enables first instance parameter in indirect draws.
	FeatureIndirectFirstInstance
	// FeatureShaderF16 enables f16 (half-precision float) in shaders.
	FeatureShaderF16
	// FeatureRG11B10UfloatRenderable enables RG11B10Ufloat as a render target format.
	FeatureRG11B10UfloatRenderable
	// FeatureBGRA8UnormStorage enables BGRA8Unorm as a storage texture format.
	FeatureBGRA8UnormStorage
	// FeatureFloat32Filterable enables filtering of float32 textures.
	FeatureFloat32Filterable
	// FeatureTimestampQuery enables timestamp queries.
	FeatureTimestampQuery
	// FeaturePipelineStatisticsQuery enables pipeline statistics queries.
	FeaturePipelineStatisticsQuery
	// FeatureMultiDrawIndirect enables multi-draw indirect commands.
	FeatureMultiDrawIndirect
	// FeatureMultiDrawIndirectCount enables multi-draw indirect with count.
	FeatureMultiDrawIndirectCount
	// FeaturePushConstants enables push constants (non-standard extension).
	FeaturePushConstants
	// FeatureTextureAdapterSpecificFormatFeatures enables adapter-specific texture formats.
	FeatureTextureAdapterSpecificFormatFeatures
	// FeatureShaderFloat64 enables f64 (double-precision float) in shaders.
	FeatureShaderFloat64
	// FeatureVertexAttribute64bit enables 64-bit vertex attributes.
	FeatureVertexAttribute64bit
	// FeatureSubgroupOperations enables subgroup operations in shaders.
	FeatureSubgroupOperations
	// FeatureSubgroupBarrier enables subgroup barriers in shaders.
	FeatureSubgroupBarrier

	// FeatureRayQuery enables inline ray queries in compute and fragment shaders.
	// Experimental — not in W3C WebGPU spec (Milestone 4+).
	FeatureRayQuery
	// FeatureRayHitVertexReturn enables triangle vertex data retrieval on ray hit.
	FeatureRayHitVertexReturn
	// FeatureExtendedASVertexFormats enables Float32x2, Float16x2, Float16x4
	// as valid vertex formats for acceleration structure geometry.
	FeatureExtendedASVertexFormats
	// FeatureASBindingArray enables arrays of acceleration structures in shaders.
	FeatureASBindingArray
	// FeatureRayTracingPipelines enables dedicated ray tracing pipelines.
	FeatureRayTracingPipelines
)

const (
	// FilterModeUndefined is an undefined filter mode (invalid).
	FilterModeUndefined FilterMode = 0x00000000
	// FilterModeNearest uses nearest-neighbor filtering (pixelated).
	FilterModeNearest FilterMode = 0x00000001
	// FilterModeLinear uses linear interpolation (smooth).
	FilterModeLinear FilterMode = 0x00000002
)

const (
	// FrontFaceCCW treats counter-clockwise vertices as front-facing.
	// This is the zero value and WebGPU spec default.
	FrontFaceCCW FrontFace = 0
	// FrontFaceCW treats clockwise vertices as front-facing.
	FrontFaceCW FrontFace = 1
)

const (
	// GLBackendGL uses desktop OpenGL.
	GLBackendGL GLBackend = iota
	// GLBackendGLES uses OpenGL ES.
	GLBackendGLES
)

const (
	// IndexFormatUndefined is an undefined index format (invalid).
	IndexFormatUndefined IndexFormat = 0x00000000
	// IndexFormatUint16 uses 16-bit unsigned integers (max 65535 indices).
	IndexFormatUint16 IndexFormat = 0x00000001
	// IndexFormatUint32 uses 32-bit unsigned integers.
	IndexFormatUint32 IndexFormat = 0x00000002
)

const (
	// InstanceFlagsNone uses default behavior.
	InstanceFlagsNone InstanceFlags = 0
	// InstanceFlagsDebug enables debug layers when available.
	InstanceFlagsDebug InstanceFlags = 1 << iota
	// InstanceFlagsValidation enables validation layers.
	InstanceFlagsValidation
	// InstanceFlagsGPUBasedValidation enables GPU-based validation (slower).
	InstanceFlagsGPUBasedValidation
	// InstanceFlagsDiscardHalLabels discards HAL debug labels.
	InstanceFlagsDiscardHalLabels
)

const (
	// LoadOpUndefined is an undefined load operation (invalid).
	LoadOpUndefined LoadOp = 0x00000000
	// LoadOpLoad loads the existing contents.
	LoadOpLoad LoadOp = 0x00000001
	// LoadOpClear clears the attachment to a specified value.
	LoadOpClear LoadOp = 0x00000002
)

const (
	// MapModeNone indicates no mapping (invalid for map operations).
	MapModeNone MapMode = 0x00000000
	// MapModeRead maps the buffer for reading.
	MapModeRead MapMode = 0x00000001
	// MapModeWrite maps the buffer for writing.
	MapModeWrite MapMode = 0x00000002
)

const (
	// MemoryHintsPerformance optimizes for performance (may use more memory).
	MemoryHintsPerformance MemoryHints = iota
	// MemoryHintsMemoryUsage optimizes for low memory usage.
	MemoryHintsMemoryUsage
)

const (
	// MipmapFilterModeUndefined is an undefined mipmap filter mode (invalid).
	MipmapFilterModeUndefined MipmapFilterMode = 0x00000000
	// MipmapFilterModeNearest selects the nearest mip level.
	MipmapFilterModeNearest MipmapFilterMode = 0x00000001
	// MipmapFilterModeLinear interpolates between mip levels.
	MipmapFilterModeLinear MipmapFilterMode = 0x00000002
)

const (
	// PowerPreferenceNone has no preference (system default).
	PowerPreferenceNone PowerPreference = iota
	// PowerPreferenceLowPower prefers low power consumption (typically integrated GPU).
	PowerPreferenceLowPower
	// PowerPreferenceHighPerformance prefers high performance (typically discrete GPU).
	PowerPreferenceHighPerformance
)

const (
	// PresentModeUndefined is an undefined present mode (invalid).
	PresentModeUndefined PresentMode = 0x00000000

	// PresentModeFifo presents frames in FIFO order with VSync.
	// No tearing. Supported on all platforms.
	// Also known as "VSync On".
	PresentModeFifo PresentMode = 0x00000001

	// PresentModeFifoRelaxed is like Fifo but allows tearing if frames
	// take longer than one vblank.
	// Also known as "Adaptive VSync".
	PresentModeFifoRelaxed PresentMode = 0x00000002

	// PresentModeImmediate presents frames immediately without waiting for vblank.
	// May cause tearing. Also known as "VSync Off".
	PresentModeImmediate PresentMode = 0x00000003

	// PresentModeMailbox uses a single-frame queue, replacing old frames.
	// No tearing. Also known as "Fast VSync".
	PresentModeMailbox PresentMode = 0x00000004
)

const (
	// PrimitiveTopologyTriangleList renders groups of 3 vertices as triangles.
	// This is the zero value and WebGPU spec default.
	PrimitiveTopologyTriangleList PrimitiveTopology = 0
	// PrimitiveTopologyPointList renders each vertex as a point.
	PrimitiveTopologyPointList PrimitiveTopology = 1
	// PrimitiveTopologyLineList renders pairs of vertices as lines.
	PrimitiveTopologyLineList PrimitiveTopology = 2
	// PrimitiveTopologyLineStrip renders connected lines.
	PrimitiveTopologyLineStrip PrimitiveTopology = 3
	// PrimitiveTopologyTriangleStrip renders connected triangles.
	PrimitiveTopologyTriangleStrip PrimitiveTopology = 4
)

const (
	// SamplerBindingTypeUndefined is undefined (invalid).
	SamplerBindingTypeUndefined SamplerBindingType = 0x00000000
	// SamplerBindingTypeFiltering supports filtered texture sampling.
	SamplerBindingTypeFiltering SamplerBindingType = 0x00000001
	// SamplerBindingTypeNonFiltering does not support filtering.
	SamplerBindingTypeNonFiltering SamplerBindingType = 0x00000002
	// SamplerBindingTypeComparison is for depth comparison sampling.
	SamplerBindingTypeComparison SamplerBindingType = 0x00000003
)

const (
	// ShaderModelSm2 represents extremely limited shaders, including a total instruction limit.
	ShaderModelSm2 ShaderModel = 2
	// ShaderModelSm4 represents shaders missing minor features and storage images.
	ShaderModelSm4 ShaderModel = 4
	// ShaderModelSm5 represents WebGPU-level shader support (shader model 5).
	ShaderModelSm5 ShaderModel = 5
)

const (
	// ShaderStageNone represents no shader stage.
	ShaderStageNone ShaderStage = 0x00000000
	// ShaderStageVertex is the vertex shader stage.
	ShaderStageVertex ShaderStage = 0x00000001
	// ShaderStageFragment is the fragment (pixel) shader stage.
	ShaderStageFragment ShaderStage = 0x00000002
	// ShaderStageCompute is the compute shader stage.
	ShaderStageCompute ShaderStage = 0x00000004
)

const (
	// StencilOperationUndefined is an undefined stencil operation (invalid).
	StencilOperationUndefined StencilOperation = 0x00000000
	// StencilOperationKeep keeps the current value.
	StencilOperationKeep StencilOperation = 0x00000001
	// StencilOperationZero sets to zero.
	StencilOperationZero StencilOperation = 0x00000002
	// StencilOperationReplace replaces with reference value.
	StencilOperationReplace StencilOperation = 0x00000003
	// StencilOperationInvert inverts all bits.
	StencilOperationInvert StencilOperation = 0x00000004
	// StencilOperationIncrementClamp increments and clamps to maximum.
	StencilOperationIncrementClamp StencilOperation = 0x00000005
	// StencilOperationDecrementClamp decrements and clamps to zero.
	StencilOperationDecrementClamp StencilOperation = 0x00000006
	// StencilOperationIncrementWrap increments and wraps to zero.
	StencilOperationIncrementWrap StencilOperation = 0x00000007
	// StencilOperationDecrementWrap decrements and wraps to maximum.
	StencilOperationDecrementWrap StencilOperation = 0x00000008
)

const (
	// StorageTextureAccessUndefined is an undefined access mode (invalid).
	StorageTextureAccessUndefined StorageTextureAccess = 0x00000000
	// StorageTextureAccessWriteOnly allows write-only access.
	StorageTextureAccessWriteOnly StorageTextureAccess = 0x00000001
	// StorageTextureAccessReadOnly allows read-only access.
	StorageTextureAccessReadOnly StorageTextureAccess = 0x00000002
	// StorageTextureAccessReadWrite allows read-write access.
	StorageTextureAccessReadWrite StorageTextureAccess = 0x00000003
)

const (
	// StoreOpUndefined is an undefined store operation (invalid).
	StoreOpUndefined StoreOp = 0x00000000
	// StoreOpStore stores the contents to memory.
	StoreOpStore StoreOp = 0x00000001
	// StoreOpDiscard discards the contents (for performance when not needed).
	StoreOpDiscard StoreOp = 0x00000002
)

const (
	// SurfaceStatusGood indicates no issues.
	SurfaceStatusGood SurfaceStatus = iota

	// SurfaceStatusSuboptimal indicates the surface works but should be reconfigured.
	SurfaceStatusSuboptimal

	// SurfaceStatusTimeout indicates texture acquisition timed out.
	SurfaceStatusTimeout

	// SurfaceStatusOutdated indicates the underlying surface changed.
	SurfaceStatusOutdated

	// SurfaceStatusLost indicates the surface was lost.
	SurfaceStatusLost

	// SurfaceStatusUnknown indicates status is unknown due to previous failure.
	SurfaceStatusUnknown
)

const (
	// TextureAspectUndefined is an undefined texture aspect (invalid).
	TextureAspectUndefined TextureAspect = 0x00000000
	// TextureAspectAll accesses all aspects (default).
	TextureAspectAll TextureAspect = 0x00000001
	// TextureAspectStencilOnly accesses only the stencil aspect.
	TextureAspectStencilOnly TextureAspect = 0x00000002
	// TextureAspectDepthOnly accesses only the depth aspect.
	TextureAspectDepthOnly TextureAspect = 0x00000003
)

const (
	// TextureDimensionUndefined is an undefined texture dimension (invalid).
	TextureDimensionUndefined TextureDimension = 0x00000000
	// TextureDimension1D is a 1D texture.
	TextureDimension1D TextureDimension = 0x00000001
	// TextureDimension2D is a 2D texture.
	TextureDimension2D TextureDimension = 0x00000002
	// TextureDimension3D is a 3D texture.
	TextureDimension3D TextureDimension = 0x00000003
)

const (
	// TextureFormatUndefined is an undefined format (invalid).
	// webgpu.h: WGPUTextureFormat_Undefined = 0x00000000
	TextureFormatUndefined TextureFormat = 0x00000000

	// 8-bit formats
	// TextureFormatR8Unorm is a single 8-bit normalized unsigned integer.
	TextureFormatR8Unorm TextureFormat = 0x00000001
	// TextureFormatR8Snorm is a single 8-bit normalized signed integer.
	TextureFormatR8Snorm TextureFormat = 0x00000002
	// TextureFormatR8Uint is a single 8-bit unsigned integer.
	TextureFormatR8Uint TextureFormat = 0x00000003
	// TextureFormatR8Sint is a single 8-bit signed integer.
	TextureFormatR8Sint TextureFormat = 0x00000004

	// 16-bit formats
	// TextureFormatR16Unorm is a single 16-bit normalized unsigned integer.
	TextureFormatR16Unorm TextureFormat = 0x00000005
	// TextureFormatR16Snorm is a single 16-bit normalized signed integer.
	TextureFormatR16Snorm TextureFormat = 0x00000006
	// TextureFormatR16Uint is a single 16-bit unsigned integer.
	TextureFormatR16Uint TextureFormat = 0x00000007
	// TextureFormatR16Sint is a single 16-bit signed integer.
	TextureFormatR16Sint TextureFormat = 0x00000008
	// TextureFormatR16Float is a single 16-bit float.
	TextureFormatR16Float TextureFormat = 0x00000009
	// TextureFormatRG8Unorm is two 8-bit normalized unsigned integers.
	TextureFormatRG8Unorm TextureFormat = 0x0000000A
	// TextureFormatRG8Snorm is two 8-bit normalized signed integers.
	TextureFormatRG8Snorm TextureFormat = 0x0000000B
	// TextureFormatRG8Uint is two 8-bit unsigned integers.
	TextureFormatRG8Uint TextureFormat = 0x0000000C
	// TextureFormatRG8Sint is two 8-bit signed integers.
	TextureFormatRG8Sint TextureFormat = 0x0000000D

	// 32-bit formats
	// TextureFormatR32Float is a single 32-bit float.
	TextureFormatR32Float TextureFormat = 0x0000000E
	// TextureFormatR32Uint is a single 32-bit unsigned integer.
	TextureFormatR32Uint TextureFormat = 0x0000000F
	// TextureFormatR32Sint is a single 32-bit signed integer.
	TextureFormatR32Sint TextureFormat = 0x00000010
	// TextureFormatRG16Unorm is two 16-bit normalized unsigned integers.
	TextureFormatRG16Unorm TextureFormat = 0x00000011
	// TextureFormatRG16Snorm is two 16-bit normalized signed integers.
	TextureFormatRG16Snorm TextureFormat = 0x00000012
	// TextureFormatRG16Uint is two 16-bit unsigned integers.
	TextureFormatRG16Uint TextureFormat = 0x00000013
	// TextureFormatRG16Sint is two 16-bit signed integers.
	TextureFormatRG16Sint TextureFormat = 0x00000014
	// TextureFormatRG16Float is two 16-bit floats.
	TextureFormatRG16Float TextureFormat = 0x00000015
	// TextureFormatRGBA8Unorm is four 8-bit normalized unsigned integers.
	TextureFormatRGBA8Unorm TextureFormat = 0x00000016
	// TextureFormatRGBA8UnormSrgb is four 8-bit normalized unsigned integers in sRGB.
	TextureFormatRGBA8UnormSrgb TextureFormat = 0x00000017
	// TextureFormatRGBA8Snorm is four 8-bit normalized signed integers.
	TextureFormatRGBA8Snorm TextureFormat = 0x00000018
	// TextureFormatRGBA8Uint is four 8-bit unsigned integers.
	TextureFormatRGBA8Uint TextureFormat = 0x00000019
	// TextureFormatRGBA8Sint is four 8-bit signed integers.
	TextureFormatRGBA8Sint TextureFormat = 0x0000001A
	// TextureFormatBGRA8Unorm is four 8-bit normalized unsigned integers (BGRA order).
	TextureFormatBGRA8Unorm TextureFormat = 0x0000001B
	// TextureFormatBGRA8UnormSrgb is four 8-bit normalized unsigned integers in sRGB (BGRA order).
	TextureFormatBGRA8UnormSrgb TextureFormat = 0x0000001C

	// Packed 32-bit formats
	// TextureFormatRGB10A2Uint is a packed 10-10-10-2 unsigned integer format.
	TextureFormatRGB10A2Uint TextureFormat = 0x0000001D
	// TextureFormatRGB10A2Unorm is a packed 10-10-10-2 normalized unsigned format.
	TextureFormatRGB10A2Unorm TextureFormat = 0x0000001E
	// TextureFormatRG11B10Ufloat is a packed 11-11-10 unsigned float format.
	TextureFormatRG11B10Ufloat TextureFormat = 0x0000001F
	// TextureFormatRGB9E5Ufloat is a packed 9-9-9-5 unsigned float format.
	TextureFormatRGB9E5Ufloat TextureFormat = 0x00000020

	// 64-bit formats
	// TextureFormatRG32Float is two 32-bit floats.
	TextureFormatRG32Float TextureFormat = 0x00000021
	// TextureFormatRG32Uint is two 32-bit unsigned integers.
	TextureFormatRG32Uint TextureFormat = 0x00000022
	// TextureFormatRG32Sint is two 32-bit signed integers.
	TextureFormatRG32Sint TextureFormat = 0x00000023
	// TextureFormatRGBA16Unorm is four 16-bit normalized unsigned integers.
	TextureFormatRGBA16Unorm TextureFormat = 0x00000024
	// TextureFormatRGBA16Snorm is four 16-bit normalized signed integers.
	TextureFormatRGBA16Snorm TextureFormat = 0x00000025
	// TextureFormatRGBA16Uint is four 16-bit unsigned integers.
	TextureFormatRGBA16Uint TextureFormat = 0x00000026
	// TextureFormatRGBA16Sint is four 16-bit signed integers.
	TextureFormatRGBA16Sint TextureFormat = 0x00000027
	// TextureFormatRGBA16Float is four 16-bit floats.
	TextureFormatRGBA16Float TextureFormat = 0x00000028

	// 128-bit formats
	// TextureFormatRGBA32Float is four 32-bit floats.
	TextureFormatRGBA32Float TextureFormat = 0x00000029
	// TextureFormatRGBA32Uint is four 32-bit unsigned integers.
	TextureFormatRGBA32Uint TextureFormat = 0x0000002A
	// TextureFormatRGBA32Sint is four 32-bit signed integers.
	TextureFormatRGBA32Sint TextureFormat = 0x0000002B

	// Depth/stencil formats
	// TextureFormatStencil8 is an 8-bit stencil format.
	TextureFormatStencil8 TextureFormat = 0x0000002C
	// TextureFormatDepth16Unorm is a 16-bit normalized depth format.
	TextureFormatDepth16Unorm TextureFormat = 0x0000002D
	// TextureFormatDepth24Plus is a 24-bit depth format (may be 32-bit internally).
	TextureFormatDepth24Plus TextureFormat = 0x0000002E
	// TextureFormatDepth24PlusStencil8 is a 24-bit depth + 8-bit stencil format.
	TextureFormatDepth24PlusStencil8 TextureFormat = 0x0000002F
	// TextureFormatDepth32Float is a 32-bit float depth format.
	TextureFormatDepth32Float TextureFormat = 0x00000030
	// TextureFormatDepth32FloatStencil8 is a 32-bit float depth + 8-bit stencil format.
	TextureFormatDepth32FloatStencil8 TextureFormat = 0x00000031

	// BC compressed formats (requires TextureCompressionBC feature)
	// webgpu.h: BC formats start at 0x32 (after depth/stencil formats)
	// TextureFormatBC1RGBAUnorm is BC1 RGBA normalized unsigned format.
	TextureFormatBC1RGBAUnorm TextureFormat = 0x00000032
	// TextureFormatBC1RGBAUnormSrgb is BC1 RGBA normalized unsigned sRGB format.
	TextureFormatBC1RGBAUnormSrgb TextureFormat = 0x00000033
	// TextureFormatBC2RGBAUnorm is BC2 RGBA normalized unsigned format.
	TextureFormatBC2RGBAUnorm TextureFormat = 0x00000034
	// TextureFormatBC2RGBAUnormSrgb is BC2 RGBA normalized unsigned sRGB format.
	TextureFormatBC2RGBAUnormSrgb TextureFormat = 0x00000035
	// TextureFormatBC3RGBAUnorm is BC3 RGBA normalized unsigned format.
	TextureFormatBC3RGBAUnorm TextureFormat = 0x00000036
	// TextureFormatBC3RGBAUnormSrgb is BC3 RGBA normalized unsigned sRGB format.
	TextureFormatBC3RGBAUnormSrgb TextureFormat = 0x00000037
	// TextureFormatBC4RUnorm is BC4 R normalized unsigned format.
	TextureFormatBC4RUnorm TextureFormat = 0x00000038
	// TextureFormatBC4RSnorm is BC4 R normalized signed format.
	TextureFormatBC4RSnorm TextureFormat = 0x00000039
	// TextureFormatBC5RGUnorm is BC5 RG normalized unsigned format.
	TextureFormatBC5RGUnorm TextureFormat = 0x0000003A
	// TextureFormatBC5RGSnorm is BC5 RG normalized signed format.
	TextureFormatBC5RGSnorm TextureFormat = 0x0000003B
	// TextureFormatBC6HRGBUfloat is BC6H RGB unsigned float format.
	TextureFormatBC6HRGBUfloat TextureFormat = 0x0000003C
	// TextureFormatBC6HRGBFloat is BC6H RGB signed float format.
	TextureFormatBC6HRGBFloat TextureFormat = 0x0000003D
	// TextureFormatBC7RGBAUnorm is BC7 RGBA normalized unsigned format.
	TextureFormatBC7RGBAUnorm TextureFormat = 0x0000003E
	// TextureFormatBC7RGBAUnormSrgb is BC7 RGBA normalized unsigned sRGB format.
	TextureFormatBC7RGBAUnormSrgb TextureFormat = 0x0000003F

	// ETC2 compressed formats (requires TextureCompressionETC2 feature)
	// webgpu.h: ETC2 formats start at 0x40 (after BC formats)
	// TextureFormatETC2RGB8Unorm is ETC2 RGB normalized unsigned format.
	TextureFormatETC2RGB8Unorm TextureFormat = 0x00000040
	// TextureFormatETC2RGB8UnormSrgb is ETC2 RGB normalized unsigned sRGB format.
	TextureFormatETC2RGB8UnormSrgb TextureFormat = 0x00000041
	// TextureFormatETC2RGB8A1Unorm is ETC2 RGB with 1-bit alpha normalized unsigned format.
	TextureFormatETC2RGB8A1Unorm TextureFormat = 0x00000042
	// TextureFormatETC2RGB8A1UnormSrgb is ETC2 RGB with 1-bit alpha normalized unsigned sRGB format.
	TextureFormatETC2RGB8A1UnormSrgb TextureFormat = 0x00000043
	// TextureFormatETC2RGBA8Unorm is ETC2 RGBA normalized unsigned format.
	TextureFormatETC2RGBA8Unorm TextureFormat = 0x00000044
	// TextureFormatETC2RGBA8UnormSrgb is ETC2 RGBA normalized unsigned sRGB format.
	TextureFormatETC2RGBA8UnormSrgb TextureFormat = 0x00000045
	// TextureFormatEACR11Unorm is EAC R normalized unsigned format.
	TextureFormatEACR11Unorm TextureFormat = 0x00000046
	// TextureFormatEACR11Snorm is EAC R normalized signed format.
	TextureFormatEACR11Snorm TextureFormat = 0x00000047
	// TextureFormatEACRG11Unorm is EAC RG normalized unsigned format.
	TextureFormatEACRG11Unorm TextureFormat = 0x00000048
	// TextureFormatEACRG11Snorm is EAC RG normalized signed format.
	TextureFormatEACRG11Snorm TextureFormat = 0x00000049

	// ASTC compressed formats (requires TextureCompressionASTC feature)
	// webgpu.h: ASTC formats start at 0x4A (after ETC2 formats)
	// TextureFormatASTC4x4Unorm is ASTC 4x4 normalized unsigned format.
	TextureFormatASTC4x4Unorm TextureFormat = 0x0000004A
	// TextureFormatASTC4x4UnormSrgb is ASTC 4x4 normalized unsigned sRGB format.
	TextureFormatASTC4x4UnormSrgb TextureFormat = 0x0000004B
	// TextureFormatASTC5x4Unorm is ASTC 5x4 normalized unsigned format.
	TextureFormatASTC5x4Unorm TextureFormat = 0x0000004C
	// TextureFormatASTC5x4UnormSrgb is ASTC 5x4 normalized unsigned sRGB format.
	TextureFormatASTC5x4UnormSrgb TextureFormat = 0x0000004D
	// TextureFormatASTC5x5Unorm is ASTC 5x5 normalized unsigned format.
	TextureFormatASTC5x5Unorm TextureFormat = 0x0000004E
	// TextureFormatASTC5x5UnormSrgb is ASTC 5x5 normalized unsigned sRGB format.
	TextureFormatASTC5x5UnormSrgb TextureFormat = 0x0000004F
	// TextureFormatASTC6x5Unorm is ASTC 6x5 normalized unsigned format.
	TextureFormatASTC6x5Unorm TextureFormat = 0x00000050
	// TextureFormatASTC6x5UnormSrgb is ASTC 6x5 normalized unsigned sRGB format.
	TextureFormatASTC6x5UnormSrgb TextureFormat = 0x00000051
	// TextureFormatASTC6x6Unorm is ASTC 6x6 normalized unsigned format.
	TextureFormatASTC6x6Unorm TextureFormat = 0x00000052
	// TextureFormatASTC6x6UnormSrgb is ASTC 6x6 normalized unsigned sRGB format.
	TextureFormatASTC6x6UnormSrgb TextureFormat = 0x00000053
	// TextureFormatASTC8x5Unorm is ASTC 8x5 normalized unsigned format.
	TextureFormatASTC8x5Unorm TextureFormat = 0x00000054
	// TextureFormatASTC8x5UnormSrgb is ASTC 8x5 normalized unsigned sRGB format.
	TextureFormatASTC8x5UnormSrgb TextureFormat = 0x00000055
	// TextureFormatASTC8x6Unorm is ASTC 8x6 normalized unsigned format.
	TextureFormatASTC8x6Unorm TextureFormat = 0x00000056
	// TextureFormatASTC8x6UnormSrgb is ASTC 8x6 normalized unsigned sRGB format.
	TextureFormatASTC8x6UnormSrgb TextureFormat = 0x00000057
	// TextureFormatASTC8x8Unorm is ASTC 8x8 normalized unsigned format.
	TextureFormatASTC8x8Unorm TextureFormat = 0x00000058
	// TextureFormatASTC8x8UnormSrgb is ASTC 8x8 normalized unsigned sRGB format.
	TextureFormatASTC8x8UnormSrgb TextureFormat = 0x00000059
	// TextureFormatASTC10x5Unorm is ASTC 10x5 normalized unsigned format.
	TextureFormatASTC10x5Unorm TextureFormat = 0x0000005A
	// TextureFormatASTC10x5UnormSrgb is ASTC 10x5 normalized unsigned sRGB format.
	TextureFormatASTC10x5UnormSrgb TextureFormat = 0x0000005B
	// TextureFormatASTC10x6Unorm is ASTC 10x6 normalized unsigned format.
	TextureFormatASTC10x6Unorm TextureFormat = 0x0000005C
	// TextureFormatASTC10x6UnormSrgb is ASTC 10x6 normalized unsigned sRGB format.
	TextureFormatASTC10x6UnormSrgb TextureFormat = 0x0000005D
	// TextureFormatASTC10x8Unorm is ASTC 10x8 normalized unsigned format.
	TextureFormatASTC10x8Unorm TextureFormat = 0x0000005E
	// TextureFormatASTC10x8UnormSrgb is ASTC 10x8 normalized unsigned sRGB format.
	TextureFormatASTC10x8UnormSrgb TextureFormat = 0x0000005F
	// TextureFormatASTC10x10Unorm is ASTC 10x10 normalized unsigned format.
	TextureFormatASTC10x10Unorm TextureFormat = 0x00000060
	// TextureFormatASTC10x10UnormSrgb is ASTC 10x10 normalized unsigned sRGB format.
	TextureFormatASTC10x10UnormSrgb TextureFormat = 0x00000061
	// TextureFormatASTC12x10Unorm is ASTC 12x10 normalized unsigned format.
	TextureFormatASTC12x10Unorm TextureFormat = 0x00000062
	// TextureFormatASTC12x10UnormSrgb is ASTC 12x10 normalized unsigned sRGB format.
	TextureFormatASTC12x10UnormSrgb TextureFormat = 0x00000063
	// TextureFormatASTC12x12Unorm is ASTC 12x12 normalized unsigned format.
	TextureFormatASTC12x12Unorm TextureFormat = 0x00000064
	// TextureFormatASTC12x12UnormSrgb is ASTC 12x12 normalized unsigned sRGB format.
	TextureFormatASTC12x12UnormSrgb TextureFormat = 0x00000065
)

const (
	// TextureSampleTypeUndefined is an undefined sample type (invalid).
	TextureSampleTypeUndefined TextureSampleType = 0x00000000
	// TextureSampleTypeFloat samples as filterable floating-point.
	TextureSampleTypeFloat TextureSampleType = 0x00000001
	// TextureSampleTypeUnfilterableFloat samples as unfilterable floating-point.
	TextureSampleTypeUnfilterableFloat TextureSampleType = 0x00000002
	// TextureSampleTypeDepth samples as depth comparison.
	TextureSampleTypeDepth TextureSampleType = 0x00000003
	// TextureSampleTypeSint samples as signed integer.
	TextureSampleTypeSint TextureSampleType = 0x00000004
	// TextureSampleTypeUint samples as unsigned integer.
	TextureSampleTypeUint TextureSampleType = 0x00000005
)

const (
	// TextureUsageNone indicates no usage (invalid for most operations).
	TextureUsageNone TextureUsage = 0x0000000000000000
	// TextureUsageCopySrc allows the texture to be a copy source.
	TextureUsageCopySrc TextureUsage = 0x0000000000000001
	// TextureUsageCopyDst allows the texture to be a copy destination.
	TextureUsageCopyDst TextureUsage = 0x0000000000000002
	// TextureUsageTextureBinding allows the texture to be bound as a sampled texture.
	TextureUsageTextureBinding TextureUsage = 0x0000000000000004
	// TextureUsageStorageBinding allows the texture to be bound as a storage texture.
	TextureUsageStorageBinding TextureUsage = 0x0000000000000008
	// TextureUsageRenderAttachment allows the texture to be used as a render attachment.
	TextureUsageRenderAttachment TextureUsage = 0x0000000000000010
)

const (
	// TextureViewDimensionUndefined uses the same dimension as the texture.
	TextureViewDimensionUndefined TextureViewDimension = 0x00000000
	// TextureViewDimension1D is a 1D texture view.
	TextureViewDimension1D TextureViewDimension = 0x00000001
	// TextureViewDimension2D is a 2D texture view.
	TextureViewDimension2D TextureViewDimension = 0x00000002
	// TextureViewDimension2DArray is a 2D array texture view.
	TextureViewDimension2DArray TextureViewDimension = 0x00000003
	// TextureViewDimensionCube is a cube texture view.
	TextureViewDimensionCube TextureViewDimension = 0x00000004
	// TextureViewDimensionCubeArray is a cube array texture view.
	TextureViewDimensionCubeArray TextureViewDimension = 0x00000005
	// TextureViewDimension3D is a 3D texture view.
	TextureViewDimension3D TextureViewDimension = 0x00000006
)

const (
	// VertexFormatUndefined is an undefined vertex format (invalid).
	VertexFormatUndefined VertexFormat = 0x00000000
	// VertexFormatUint8x2 is two 8-bit unsigned integers.
	VertexFormatUint8x2 VertexFormat = 0x00000001
	// VertexFormatUint8x4 is four 8-bit unsigned integers.
	VertexFormatUint8x4 VertexFormat = 0x00000002
	// VertexFormatSint8x2 is two 8-bit signed integers.
	VertexFormatSint8x2 VertexFormat = 0x00000003
	// VertexFormatSint8x4 is four 8-bit signed integers.
	VertexFormatSint8x4 VertexFormat = 0x00000004
	// VertexFormatUnorm8x2 is two 8-bit normalized unsigned integers [0.0, 1.0].
	VertexFormatUnorm8x2 VertexFormat = 0x00000005
	// VertexFormatUnorm8x4 is four 8-bit normalized unsigned integers [0.0, 1.0].
	VertexFormatUnorm8x4 VertexFormat = 0x00000006
	// VertexFormatSnorm8x2 is two 8-bit normalized signed integers [-1.0, 1.0].
	VertexFormatSnorm8x2 VertexFormat = 0x00000007
	// VertexFormatSnorm8x4 is four 8-bit normalized signed integers [-1.0, 1.0].
	VertexFormatSnorm8x4 VertexFormat = 0x00000008
	// VertexFormatUint16x2 is two 16-bit unsigned integers.
	VertexFormatUint16x2 VertexFormat = 0x00000009
	// VertexFormatUint16x4 is four 16-bit unsigned integers.
	VertexFormatUint16x4 VertexFormat = 0x0000000A
	// VertexFormatSint16x2 is two 16-bit signed integers.
	VertexFormatSint16x2 VertexFormat = 0x0000000B
	// VertexFormatSint16x4 is four 16-bit signed integers.
	VertexFormatSint16x4 VertexFormat = 0x0000000C
	// VertexFormatUnorm16x2 is two 16-bit normalized unsigned integers [0.0, 1.0].
	VertexFormatUnorm16x2 VertexFormat = 0x0000000D
	// VertexFormatUnorm16x4 is four 16-bit normalized unsigned integers [0.0, 1.0].
	VertexFormatUnorm16x4 VertexFormat = 0x0000000E
	// VertexFormatSnorm16x2 is two 16-bit normalized signed integers [-1.0, 1.0].
	VertexFormatSnorm16x2 VertexFormat = 0x0000000F
	// VertexFormatSnorm16x4 is four 16-bit normalized signed integers [-1.0, 1.0].
	VertexFormatSnorm16x4 VertexFormat = 0x00000010
	// VertexFormatFloat16x2 is two 16-bit floats.
	VertexFormatFloat16x2 VertexFormat = 0x00000011
	// VertexFormatFloat16x4 is four 16-bit floats.
	VertexFormatFloat16x4 VertexFormat = 0x00000012
	// VertexFormatFloat32 is a single 32-bit float.
	VertexFormatFloat32 VertexFormat = 0x00000013
	// VertexFormatFloat32x2 is two 32-bit floats (vec2).
	VertexFormatFloat32x2 VertexFormat = 0x00000014
	// VertexFormatFloat32x3 is three 32-bit floats (vec3).
	VertexFormatFloat32x3 VertexFormat = 0x00000015
	// VertexFormatFloat32x4 is four 32-bit floats (vec4).
	VertexFormatFloat32x4 VertexFormat = 0x00000016
	// VertexFormatUint32 is a single 32-bit unsigned integer.
	VertexFormatUint32 VertexFormat = 0x00000017
	// VertexFormatUint32x2 is two 32-bit unsigned integers.
	VertexFormatUint32x2 VertexFormat = 0x00000018
	// VertexFormatUint32x3 is three 32-bit unsigned integers.
	VertexFormatUint32x3 VertexFormat = 0x00000019
	// VertexFormatUint32x4 is four 32-bit unsigned integers.
	VertexFormatUint32x4 VertexFormat = 0x0000001A
	// VertexFormatSint32 is a single 32-bit signed integer.
	VertexFormatSint32 VertexFormat = 0x0000001B
	// VertexFormatSint32x2 is two 32-bit signed integers.
	VertexFormatSint32x2 VertexFormat = 0x0000001C
	// VertexFormatSint32x3 is three 32-bit signed integers.
	VertexFormatSint32x3 VertexFormat = 0x0000001D
	// VertexFormatSint32x4 is four 32-bit signed integers.
	VertexFormatSint32x4 VertexFormat = 0x0000001E
	// VertexFormatUnorm1010102 is a packed 10-10-10-2 normalized unsigned format.
	VertexFormatUnorm1010102 VertexFormat = 0x0000001F
)

const (
	// VertexStepModeUndefined is an undefined step mode (invalid).
	VertexStepModeUndefined VertexStepMode = 0x00000000
	// VertexStepModeVertexBufferNotUsed indicates the buffer is not used.
	VertexStepModeVertexBufferNotUsed VertexStepMode = 0x00000001
	// VertexStepModeVertex steps once per vertex.
	VertexStepModeVertex VertexStepMode = 0x00000002
	// VertexStepModeInstance steps once per instance.
	VertexStepModeInstance VertexStepMode = 0x00000003
)