Structs

These structs are defined in wgpu.structs.

The sructs in wgpu-py are represented as Python dictionaries. Fields that have default values (as indicated below) may be omitted.

wgpu.structs.BindGroupDescriptor

• label :: str = “”

• layout :: GPUBindGroupLayout

• entries :: List[structs.BindGroupEntry]

wgpu.structs.BindGroupEntry

• binding :: int

• resource :: Union[GPUSampler, GPUTextureView, object, structs.BufferBinding]

wgpu.structs.BindGroupLayoutDescriptor

• label :: str = “”

• entries :: List[structs.BindGroupLayoutEntry]

wgpu.structs.BindGroupLayoutEntry

• binding :: int

• visibility :: flags.ShaderStage

• buffer :: structs.BufferBindingLayout = None

• sampler :: structs.SamplerBindingLayout = None

• texture :: structs.TextureBindingLayout = None

• storageTexture :: structs.StorageTextureBindingLayout = None

• externalTexture :: structs.ExternalTextureBindingLayout = None

wgpu.structs.BlendComponent

• operation :: enums.BlendOperation = “add”

• srcFactor :: enums.BlendFactor = “one”

• dstFactor :: enums.BlendFactor = “zero”

wgpu.structs.BlendState

• color :: structs.BlendComponent

• alpha :: structs.BlendComponent

wgpu.structs.BufferBinding

• buffer :: GPUBuffer

• offset :: int = 0

• size :: int = None

wgpu.structs.BufferBindingLayout

• type :: enums.BufferBindingType = “uniform”

• hasDynamicOffset :: bool = false

• minBindingSize :: int = 0

wgpu.structs.BufferDescriptor

• label :: str = “”

• size :: int

• usage :: flags.BufferUsage

• mappedAtCreation :: bool = false

wgpu.structs.CanvasConfiguration

• device :: GPUDevice

• format :: enums.TextureFormat

• usage :: flags.TextureUsage = 0x10

• viewFormats :: List[enums.TextureFormat] = []

• colorSpace :: str = “srgb”

• alphaMode :: enums.CanvasAlphaMode = “opaque”

wgpu.structs.Color

• r :: float

• g :: float

• b :: float

• a :: float

wgpu.structs.ColorTargetState

• format :: enums.TextureFormat

• blend :: structs.BlendState = None

• writeMask :: flags.ColorWrite = 0xF

wgpu.structs.CommandBufferDescriptor

• label :: str = “”

wgpu.structs.CommandEncoderDescriptor

• label :: str = “”

wgpu.structs.ComputePassDescriptor

• label :: str = “”

• timestampWrites :: structs.ComputePassTimestampWrites = None

wgpu.structs.ComputePassTimestampWrites

• querySet :: GPUQuerySet

• beginningOfPassWriteIndex :: int = None

• endOfPassWriteIndex :: int = None

wgpu.structs.ComputePipelineDescriptor

• label :: str = “”

• layout :: Union[GPUPipelineLayout, enums.AutoLayoutMode]

• compute :: structs.ProgrammableStage

wgpu.structs.DepthStencilState

• format :: enums.TextureFormat

• depthWriteEnabled :: bool = None

• depthCompare :: enums.CompareFunction = None

• stencilFront :: structs.StencilFaceState = {}

• stencilBack :: structs.StencilFaceState = {}

• stencilReadMask :: int = 0xFFFFFFFF

• stencilWriteMask :: int = 0xFFFFFFFF

• depthBias :: int = 0

• depthBiasSlopeScale :: float = 0

• depthBiasClamp :: float = 0

wgpu.structs.DeviceDescriptor

• label :: str = “”

• requiredFeatures :: List[enums.FeatureName] = []

• requiredLimits :: Dict[str, int] = {}

• defaultQueue :: structs.QueueDescriptor = {}

wgpu.structs.Extent3D

• width :: int

• height :: int = 1

• depthOrArrayLayers :: int = 1

wgpu.structs.ExternalTextureDescriptor

• label :: str = “”

• source :: Union[memoryview, object]

• colorSpace :: str = “srgb”

wgpu.structs.FragmentState

• module :: GPUShaderModule

• entryPoint :: str = None

• constants :: Dict[str, float] = None

• targets :: List[structs.ColorTargetState]

wgpu.structs.ImageCopyBuffer

• offset :: int = 0

• bytesPerRow :: int = None

• rowsPerImage :: int = None

• buffer :: GPUBuffer

wgpu.structs.ImageCopyExternalImage

• source :: Union[memoryview, object]

• origin :: Union[List[int], structs.Origin2D] = {}

• flipY :: bool = false

wgpu.structs.ImageCopyTexture

• texture :: GPUTexture

• mipLevel :: int = 0

• origin :: Union[List[int], structs.Origin3D] = {}

• aspect :: enums.TextureAspect = “all”

wgpu.structs.ImageDataLayout

• offset :: int = 0

• bytesPerRow :: int = None

• rowsPerImage :: int = None

wgpu.structs.MultisampleState

• count :: int = 1

• mask :: int = 0xFFFFFFFF

• alphaToCoverageEnabled :: bool = false

wgpu.structs.Origin2D

• x :: int = 0

• y :: int = 0

wgpu.structs.Origin3D

• x :: int = 0

• y :: int = 0

• z :: int = 0

wgpu.structs.PipelineErrorInit

• reason :: enums.PipelineErrorReason

wgpu.structs.PipelineLayoutDescriptor

• label :: str = “”

• bindGroupLayouts :: List[GPUBindGroupLayout]

wgpu.structs.PrimitiveState

• topology :: enums.PrimitiveTopology = “triangle-list”

• stripIndexFormat :: enums.IndexFormat = None

• frontFace :: enums.FrontFace = “ccw”

• cullMode :: enums.CullMode = “none”

• unclippedDepth :: bool = false

wgpu.structs.ProgrammableStage

• module :: GPUShaderModule

• entryPoint :: str = None

• constants :: Dict[str, float] = None

wgpu.structs.QuerySetDescriptor

• label :: str = “”

• type :: enums.QueryType

• count :: int

wgpu.structs.QueueDescriptor

• label :: str = “”

wgpu.structs.RenderBundleDescriptor

• label :: str = “”

wgpu.structs.RenderBundleEncoderDescriptor

• label :: str = “”

• colorFormats :: List[enums.TextureFormat]

• depthStencilFormat :: enums.TextureFormat = None

• sampleCount :: int = 1

• depthReadOnly :: bool = false

• stencilReadOnly :: bool = false

wgpu.structs.RenderPassColorAttachment

• view :: GPUTextureView

• depthSlice :: int = None

• resolveTarget :: GPUTextureView = None

• clearValue :: Union[List[float], structs.Color] = None

• loadOp :: enums.LoadOp

• storeOp :: enums.StoreOp

wgpu.structs.RenderPassDepthStencilAttachment

• view :: GPUTextureView

• depthClearValue :: float = None

• depthLoadOp :: enums.LoadOp = None

• depthStoreOp :: enums.StoreOp = None

• depthReadOnly :: bool = false

• stencilClearValue :: int = 0

• stencilLoadOp :: enums.LoadOp = None

• stencilStoreOp :: enums.StoreOp = None

• stencilReadOnly :: bool = false

wgpu.structs.RenderPassDescriptor

• label :: str = “”

• colorAttachments :: List[structs.RenderPassColorAttachment]

• depthStencilAttachment :: structs.RenderPassDepthStencilAttachment = None

• occlusionQuerySet :: GPUQuerySet = None

• timestampWrites :: structs.RenderPassTimestampWrites = None

• maxDrawCount :: int = 50000000

wgpu.structs.RenderPassLayout

• label :: str = “”

• colorFormats :: List[enums.TextureFormat]

• depthStencilFormat :: enums.TextureFormat = None

• sampleCount :: int = 1

wgpu.structs.RenderPassTimestampWrites

• querySet :: GPUQuerySet

• beginningOfPassWriteIndex :: int = None

• endOfPassWriteIndex :: int = None

wgpu.structs.RenderPipelineDescriptor

• label :: str = “”

• layout :: Union[GPUPipelineLayout, enums.AutoLayoutMode]

• vertex :: structs.VertexState

• primitive :: structs.PrimitiveState = {}

• depthStencil :: structs.DepthStencilState = None

• multisample :: structs.MultisampleState = {}

• fragment :: structs.FragmentState = None

wgpu.structs.RequestAdapterOptions

• powerPreference :: enums.PowerPreference = None

• forceFallbackAdapter :: bool = false

wgpu.structs.SamplerBindingLayout

• type :: enums.SamplerBindingType = “filtering”

wgpu.structs.SamplerDescriptor

• label :: str = “”

• addressModeU :: enums.AddressMode = “clamp-to-edge”

• addressModeV :: enums.AddressMode = “clamp-to-edge”

• addressModeW :: enums.AddressMode = “clamp-to-edge”

• magFilter :: enums.FilterMode = “nearest”

• minFilter :: enums.FilterMode = “nearest”

• mipmapFilter :: enums.MipmapFilterMode = “nearest”

• lodMinClamp :: float = 0

• lodMaxClamp :: float = 32

• compare :: enums.CompareFunction = None

• maxAnisotropy :: int = 1

wgpu.structs.ShaderModuleCompilationHint

• entryPoint :: str

• layout :: Union[GPUPipelineLayout, enums.AutoLayoutMode] = None

wgpu.structs.ShaderModuleDescriptor

• label :: str = “”

• code :: str

• sourceMap :: dict = None

• compilationHints :: List[structs.ShaderModuleCompilationHint] = []

wgpu.structs.StencilFaceState

• compare :: enums.CompareFunction = “always”

• failOp :: enums.StencilOperation = “keep”

• depthFailOp :: enums.StencilOperation = “keep”

• passOp :: enums.StencilOperation = “keep”

wgpu.structs.StorageTextureBindingLayout

• access :: enums.StorageTextureAccess = “write-only”

• format :: enums.TextureFormat

• viewDimension :: enums.TextureViewDimension = “2d”

wgpu.structs.TextureBindingLayout

• sampleType :: enums.TextureSampleType = “float”

• viewDimension :: enums.TextureViewDimension = “2d”

• multisampled :: bool = false

wgpu.structs.TextureDescriptor

• label :: str = “”

• size :: Union[List[int], structs.Extent3D]

• mipLevelCount :: int = 1

• sampleCount :: int = 1

• dimension :: enums.TextureDimension = “2d”

• format :: enums.TextureFormat

• usage :: flags.TextureUsage

• viewFormats :: List[enums.TextureFormat] = []

wgpu.structs.TextureViewDescriptor

• label :: str = “”

• format :: enums.TextureFormat = None

• dimension :: enums.TextureViewDimension = None

• aspect :: enums.TextureAspect = “all”

• baseMipLevel :: int = 0

• mipLevelCount :: int = None

• baseArrayLayer :: int = 0

• arrayLayerCount :: int = None

wgpu.structs.UncapturedErrorEventInit

• error :: GPUError

wgpu.structs.VertexAttribute

• format :: enums.VertexFormat

• offset :: int

• shaderLocation :: int

wgpu.structs.VertexBufferLayout

• arrayStride :: int

• stepMode :: enums.VertexStepMode = “vertex”

• attributes :: List[structs.VertexAttribute]

wgpu.structs.VertexState

• module :: GPUShaderModule

• entryPoint :: str = None

• constants :: Dict[str, float] = None

• buffers :: List[structs.VertexBufferLayout] = []