wgpu

package module

Go to main page

Versions in this module

v0

v0.31.0

Aug 2, 2026

Changes in this version

+ const BackendDX12

+ const BackendGL

+ const BackendMetal

+ const BackendVulkan

+ const BackendsAll

+ const BackendsDX12

+ const BackendsGL

+ const BackendsMetal

+ const BackendsPrimary

+ const BackendsVulkan

+ const BufferUsageCopyDst

+ const BufferUsageCopySrc

+ const BufferUsageIndex

+ const BufferUsageIndirect

+ const BufferUsageMapRead

+ const BufferUsageMapWrite

+ const BufferUsageQueryResolve

+ const BufferUsageStorage

+ const BufferUsageUniform

+ const BufferUsageVertex

+ const ErrorFilterInternal — darwin/amd64, linux/amd64, windows/amd64

+ const ErrorFilterOutOfMemory — darwin/amd64, linux/amd64, windows/amd64

+ const ErrorFilterValidation — darwin/amd64, linux/amd64, windows/amd64

+ const MaxBindGroups

+ const MinBindGroups

+ const PowerPreferenceHighPerformance

+ const PowerPreferenceLowPower

+ const PowerPreferenceNone

+ const PresentModeFifo

+ const PresentModeFifoRelaxed

+ const PresentModeImmediate

+ const PresentModeMailbox

+ const ShaderStageCompute

+ const ShaderStageFragment

+ const ShaderStageVertex

+ const StencilOperationDecrementClamp

+ const StencilOperationDecrementWrap

+ const StencilOperationIncrementClamp

+ const StencilOperationIncrementWrap

+ const StencilOperationInvert

+ const StencilOperationKeep

+ const StencilOperationReplace

+ const StencilOperationZero

+ const TextureDimension1D

+ const TextureDimension2D

+ const TextureDimension3D

+ const TextureFormatBGRA8Unorm

+ const TextureFormatBGRA8UnormSrgb

+ const TextureFormatDepth24Plus

+ const TextureFormatDepth32Float

+ const TextureFormatRGBA8Unorm

+ const TextureFormatRGBA8UnormSrgb

+ const TextureUsageCopyDst

+ const TextureUsageCopySrc

+ const TextureUsageRenderAttachment

+ const TextureUsageStorageBinding

+ const TextureUsageTextureBinding

+ var DefaultInstanceDescriptor = gputypes.DefaultInstanceDescriptor

+ var DefaultLimits = gputypes.DefaultLimits

+ var ErrBufferDestroyed = errors.New("wgpu: buffer destroyed")

+ var ErrDeviceLost = errors.New("wgpu: device lost") — js/wasm

+ var ErrDeviceLost = hal.ErrDeviceLost — darwin/amd64, linux/amd64, windows/amd64

+ var ErrDispatchIncompatibleBindGroup = errors.New("wgpu: dispatch called with incompatible bind group layout")

+ var ErrDispatchIndirectBufferOverrun = errors.New("wgpu: indirect dispatch args exceed buffer size")

+ var ErrDispatchIndirectBufferUsage = errors.New("wgpu: indirect dispatch buffer missing INDIRECT usage")

+ var ErrDispatchIndirectOffsetAlignment = errors.New("wgpu: indirect dispatch buffer offset not 4-byte aligned")

+ var ErrDispatchLateBufferTooSmall = errors.New("wgpu: dispatch: bound buffer smaller than shader-required minimum")

+ var ErrDispatchMissingBindGroup = errors.New("wgpu: dispatch called with missing bind group")

+ var ErrDispatchMissingPipeline = errors.New("wgpu: dispatch called without SetPipeline")

+ var ErrDispatchWorkgroupCountExceeded = errors.New("wgpu: dispatch workgroup count exceeds device limit")

+ var ErrDrawIncompatibleBindGroup = errors.New("wgpu: draw called with incompatible bind group layout")

+ var ErrDrawIndexFormatMismatch = errors.New("wgpu: index buffer format does not match pipeline strip index format")

+ var ErrDrawIndirectBufferOverrun = errors.New("wgpu: indirect draw args exceed buffer size")

+ var ErrDrawIndirectBufferUsage = errors.New("wgpu: indirect draw buffer missing INDIRECT usage")

+ var ErrDrawIndirectOffsetAlignment = errors.New("wgpu: indirect draw buffer offset not 4-byte aligned")

+ var ErrDrawLateBufferTooSmall = errors.New("wgpu: bound buffer smaller than shader-required minimum")

+ var ErrDrawMissingBindGroup = errors.New("wgpu: draw called with missing bind group")

+ var ErrDrawMissingBlendConstant = errors.New(...)

+ var ErrDrawMissingIndexBuffer = errors.New("wgpu: DrawIndexed called without SetIndexBuffer")

+ var ErrDrawMissingPipeline = errors.New("wgpu: draw called without SetPipeline")

+ var ErrDrawMissingVertexBuffer = errors.New("wgpu: draw called with insufficient vertex buffers")

+ var ErrInvalidSurfaceTarget = errors.New("wgpu: invalid surface target")

+ var ErrMapAlignment = errors.New("wgpu: map offset/size not aligned")

+ var ErrMapAlreadyMapped = errors.New("wgpu: buffer is already mapped")

+ var ErrMapAlreadyPending = errors.New("wgpu: buffer map already pending")

+ var ErrMapCanceled = errors.New("wgpu: map canceled")

+ var ErrMapDeviceLost = errors.New("wgpu: device lost during map")

+ var ErrMapInvalidMode = errors.New("wgpu: buffer not created with required MAP_READ/MAP_WRITE usage")

+ var ErrMapNotMapped = errors.New("wgpu: buffer is not mapped")

+ var ErrMapRangeDetached = errors.New("wgpu: mapped range detached (buffer unmapped)")

+ var ErrMapRangeOverflow = errors.New("wgpu: map range exceeds buffer size")

+ var ErrMapRangeOverlap = errors.New("wgpu: mapped range overlaps existing")

+ var ErrNoAdapters = errors.New("wgpu: no GPU adapters available")

+ var ErrNoBackends = errors.New("wgpu: no backends registered (import a backend package)")

+ var ErrOutOfMemory = errors.New("wgpu: out of memory") — js/wasm

+ var ErrOutOfMemory = hal.ErrDeviceOutOfMemory — darwin/amd64, linux/amd64, windows/amd64

+ var ErrReleased = errors.New("wgpu: resource already released")

+ var ErrSubmitBindGroupDestroyed = errors.New("wgpu: Submit: command buffer references destroyed bind group") — darwin/amd64, linux/amd64, windows/amd64

+ var ErrSubmitBufferDestroyed = errors.New("wgpu: Submit: command buffer references destroyed buffer") — darwin/amd64, linux/amd64, windows/amd64

+ var ErrSubmitBufferMapped = errors.New("wgpu: Submit: command buffer references mapped buffer") — darwin/amd64, linux/amd64, windows/amd64

+ var ErrSubmitCommandBufferInvalid = errors.New(...) — darwin/amd64, linux/amd64, windows/amd64

+ var ErrSubmitTextureDestroyed = errors.New("wgpu: Submit: command buffer references destroyed texture") — darwin/amd64, linux/amd64, windows/amd64

+ var ErrSurfaceLost = errors.New("wgpu: surface lost") — js/wasm

+ var ErrSurfaceLost = hal.ErrSurfaceLost — darwin/amd64, linux/amd64, windows/amd64

+ var ErrSurfaceOutdated = errors.New("wgpu: surface outdated") — js/wasm

+ var ErrSurfaceOutdated = hal.ErrSurfaceOutdated — darwin/amd64, linux/amd64, windows/amd64

+ var ErrTimeout = errors.New("wgpu: timeout") — js/wasm

+ var ErrTimeout = hal.ErrTimeout — darwin/amd64, linux/amd64, windows/amd64

+ var ErrUnsupportedSurfaceTarget = errors.New("wgpu: unsupported surface target")

+ func AdapterToHandle(a *Adapter) gpucontext.Adapter

+ func DeviceToHandle(d *Device) gpucontext.Device

+ func InstanceToHandle(i *Instance) gpucontext.Instance

+ func Logger() *slog.Logger

+ func QueueToHandle(q *Queue) gpucontext.Queue

+ func SetLogger(l *slog.Logger)

+ func SurfaceToHandle(s *Surface) gpucontext.Surface

+ type Adapter struct

+ func AdapterFromHandle(h gpucontext.Adapter) *Adapter

+ func (a *Adapter) Features() Features

+ func (a *Adapter) GetSurfaceCapabilities(surface *Surface) *SurfaceCapabilities

+ func (a *Adapter) Info() AdapterInfo

+ func (a *Adapter) Limits() Limits

+ func (a *Adapter) Release()

+ func (a *Adapter) RequestDevice(desc *DeviceDescriptor) (*Device, error)

+ type AdapterInfo = gputypes.AdapterInfo

+ type AddressMode = gputypes.AddressMode

+ type Backend = gputypes.Backend

+ type Backends = gputypes.Backends

+ type BindGroup struct

+ func (g *BindGroup) Release()

+ type BindGroupDescriptor struct

+ Entries []BindGroupEntry

+ Label string

+ Layout *BindGroupLayout

+ type BindGroupEntry struct

+ Binding uint32

+ Buffer *Buffer

+ Offset uint64

+ Sampler *Sampler

+ Size uint64

+ TextureView *TextureView

+ type BindGroupLayout struct

+ func (l *BindGroupLayout) Release()

+ type BindGroupLayoutDescriptor struct

+ Entries []BindGroupLayoutEntry

+ Label string

+ type BindGroupLayoutEntry = gputypes.BindGroupLayoutEntry

+ type Buffer struct

+ func (b *Buffer) Label() string

+ func (b *Buffer) Map(ctx context.Context, mode MapMode, offset, size uint64) error

+ func (b *Buffer) MapAsync(mode MapMode, offset, size uint64) (*MapPending, error)

+ func (b *Buffer) MapState() MapState

+ func (b *Buffer) MappedRange(offset, size uint64) (*MappedRange, error)

+ func (b *Buffer) Release()

+ func (b *Buffer) Size() uint64

+ func (b *Buffer) Unmap() error

+ func (b *Buffer) Usage() BufferUsage

+ type BufferDescriptor struct

+ Label string

+ MappedAtCreation bool

+ Size uint64

+ Usage BufferUsage

+ type BufferTextureCopy struct

+ BufferLayout ImageDataLayout

+ Size Extent3D

+ TextureBase ImageCopyTexture

+ type BufferUsage = gputypes.BufferUsage

+ type Color = gputypes.Color

+ type ColorTargetState = gputypes.ColorTargetState

+ type CommandBuffer struct

+ func (cb *CommandBuffer) Release()

+ type CommandEncoder struct

+ func (e *CommandEncoder) BeginComputePass(desc *ComputePassDescriptor) (*ComputePassEncoder, error)

+ func (e *CommandEncoder) BeginRenderPass(desc *RenderPassDescriptor) (*RenderPassEncoder, error)

+ func (e *CommandEncoder) ClearBuffer(buffer *Buffer, offset, size uint64)

+ func (e *CommandEncoder) CopyBufferToBuffer(src *Buffer, srcOffset uint64, dst *Buffer, dstOffset uint64, size uint64)

+ func (e *CommandEncoder) CopyBufferToTexture(src *Buffer, dst *Texture, regions []BufferTextureCopy)

+ func (e *CommandEncoder) CopyTextureToBuffer(src *Texture, dst *Buffer, regions []BufferTextureCopy)

+ func (e *CommandEncoder) CopyTextureToTexture(src, dst *Texture, regions []TextureCopy)

+ func (e *CommandEncoder) DiscardEncoding()

+ func (e *CommandEncoder) Finish() (*CommandBuffer, error)

+ func (e *CommandEncoder) TransitionTextures(barriers []TextureBarrier)

+ type CommandEncoderDescriptor struct

+ Label string

+ type CompareFunction = gputypes.CompareFunction

+ type CompositeAlphaMode = gputypes.CompositeAlphaMode

+ type ComputePassDescriptor struct

+ Label string

+ type ComputePassEncoder struct

+ func (p *ComputePassEncoder) Dispatch(x, y, z uint32)

+ func (p *ComputePassEncoder) DispatchIndirect(buffer *Buffer, offset uint64)

+ func (p *ComputePassEncoder) End() error

+ func (p *ComputePassEncoder) SetBindGroup(index uint32, group *BindGroup, offsets []uint32)

+ func (p *ComputePassEncoder) SetPipeline(pipeline *ComputePipeline)

+ type ComputePipeline struct

+ func (p *ComputePipeline) GetBindGroupLayout(index uint32) *BindGroupLayout

+ func (p *ComputePipeline) Release()

+ type ComputePipelineDescriptor struct

+ Constants map[string]float64

+ EntryPoint string

+ Label string

+ Layout *PipelineLayout

+ Module *ShaderModule

+ ZeroInitializeWorkgroupMemory *bool

+ type CullMode = gputypes.CullMode

+ type DepthStencilState struct

+ DepthBias int32

+ DepthBiasClamp float32

+ DepthBiasSlopeScale float32

+ DepthCompare CompareFunction

+ DepthWriteEnabled bool

+ Format TextureFormat

+ StencilBack StencilFaceState

+ StencilFront StencilFaceState

+ StencilReadMask uint32

+ StencilWriteMask uint32

+ type Device struct

+ func DeviceFromHandle(h gpucontext.Device) *Device

+ func NewDeviceFromHAL(_ any, _ any, _ Features, _ Limits, _ string) (*Device, error)

+ func NewDeviceFromHAL(halDevice hal.Device, halQueue hal.Queue, features Features, limits Limits, ...) (*Device, error)

+ func (d *Device) CreateBindGroup(desc *BindGroupDescriptor) (*BindGroup, error)

+ func (d *Device) CreateBindGroupLayout(desc *BindGroupLayoutDescriptor) (*BindGroupLayout, error)

+ func (d *Device) CreateBuffer(desc *BufferDescriptor) (*Buffer, error)

+ func (d *Device) CreateCommandEncoder(desc *CommandEncoderDescriptor) (*CommandEncoder, error)

+ func (d *Device) CreateComputePipeline(desc *ComputePipelineDescriptor) (*ComputePipeline, error)

+ func (d *Device) CreateFence() (*Fence, error)

+ func (d *Device) CreatePipelineLayout(desc *PipelineLayoutDescriptor) (*PipelineLayout, error)

+ func (d *Device) CreateRenderPipeline(desc *RenderPipelineDescriptor) (*RenderPipeline, error)

+ func (d *Device) CreateSampler(desc *SamplerDescriptor) (*Sampler, error)

+ func (d *Device) CreateShaderModule(desc *ShaderModuleDescriptor) (*ShaderModule, error)

+ func (d *Device) CreateTexture(desc *TextureDescriptor) (*Texture, error)

+ func (d *Device) CreateTextureView(texture *Texture, desc *TextureViewDescriptor) (*TextureView, error)

+ func (d *Device) DestroyFence(f *Fence)

+ func (d *Device) Features() Features

+ func (d *Device) FreeCommandBuffer(_ *CommandBuffer)

+ func (d *Device) FreeCommandBuffer(cb *CommandBuffer)

+ func (d *Device) GetFenceStatus(_ *Fence) (bool, error)

+ func (d *Device) GetFenceStatus(f *Fence) (bool, error)

+ func (d *Device) HalDevice() any

+ func (d *Device) HalDevice() hal.Device

+ func (d *Device) Limits() Limits

+ func (d *Device) Poll(pollType PollType) bool

+ func (d *Device) PopErrorScope() *GPUError

+ func (d *Device) PushErrorScope(filter ErrorFilter)

+ func (d *Device) Queue() *Queue

+ func (d *Device) Release()

+ func (d *Device) ResetFence(_ *Fence) error

+ func (d *Device) ResetFence(f *Fence) error

+ func (d *Device) WaitForFence(_ *Fence, _ uint64, _ time.Duration) (bool, error)

+ func (d *Device) WaitForFence(f *Fence, value uint64, timeout time.Duration) (bool, error)

+ func (d *Device) WaitIdle() error

+ type DeviceDescriptor struct

+ Label string

+ RequiredFeatures Features

+ RequiredLimits Limits

+ type DeviceType = gputypes.DeviceType

+ type ErrorFilter = core.ErrorFilter — darwin/amd64, linux/amd64, windows/amd64

+ type ErrorFilter int — js/wasm

+ const ErrorFilterInternal

+ const ErrorFilterOutOfMemory

+ const ErrorFilterValidation

+ type Extent3D struct

+ DepthOrArrayLayers uint32

+ Height uint32

+ Width uint32

+ type Features = gputypes.Features

+ type Fence struct

+ func (f *Fence) Release()

+ type FilterMode = gputypes.FilterMode

+ type FragmentState struct

+ EntryPoint string

+ Module *ShaderModule

+ Targets []ColorTargetState

+ type FrontFace = gputypes.FrontFace

+ type GPUError = core.GPUError — darwin/amd64, linux/amd64, windows/amd64

+ type GPUError struct — js/wasm

+ Message string

+ func (e *GPUError) Error() string

+ type HeadlessSurfaceTarget struct

+ func (HeadlessSurfaceTarget) SurfaceTarget() (SurfaceTargetUnsafe, error)

+ type ImageCopyTexture struct

+ Aspect TextureAspect

+ MipLevel uint32

+ Origin Origin3D

+ Texture *Texture

+ type ImageDataLayout struct

+ BytesPerRow uint32

+ Offset uint64

+ RowsPerImage uint32

+ type IndexFormat = gputypes.IndexFormat

+ type Instance struct

+ func CreateInstance(desc *InstanceDescriptor) (*Instance, error)

+ func InstanceFromHandle(h gpucontext.Instance) *Instance

+ func (i *Instance) CreateSurface(displayHandle, windowHandle uintptr) (*Surface, error)

+ func (i *Instance) CreateSurfaceFromCanvas(canvas js.Value) (*Surface, error)

+ func (i *Instance) CreateSurfaceFromTarget(target SurfaceTarget) (*Surface, error)

+ func (i *Instance) CreateSurfaceUnsafe(target SurfaceTargetUnsafe) (*Surface, error)

+ func (i *Instance) Release()

+ func (i *Instance) RequestAdapter(opts *RequestAdapterOptions) (*Adapter, error)

+ type InstanceDescriptor struct

+ Backends Backends

+ Flags gputypes.InstanceFlags

+ type LateBufferBindingInfo struct

+ BindingIndex uint32

+ Size uint64

+ type LateSizedBufferGroup struct

+ ShaderSizes []uint64

+ type Limits = gputypes.Limits

+ type LoadOp = gputypes.LoadOp

+ type MapMode uint32

+ const MapModeRead

+ const MapModeWrite

+ type MapPending struct

+ func (p *MapPending) Release()

+ func (p *MapPending) Status() (ready bool, err error)

+ func (p *MapPending) Wait(ctx context.Context) error

+ type MapState uint8

+ const MapStateDestroyed

+ const MapStateMapped

+ const MapStatePending

+ const MapStateUnmapped

+ type MappedRange struct

+ func (m *MappedRange) Bytes() []byte

+ func (m *MappedRange) BytesMut() []byte

+ func (m *MappedRange) Flush() error

+ func (m *MappedRange) Len() int

+ func (m *MappedRange) Offset() uint64

+ func (m *MappedRange) Release()

+ type MultisampleState = gputypes.MultisampleState

+ type Origin3D struct

+ X uint32

+ Y uint32

+ Z uint32

+ type PipelineLayout struct

+ func (l *PipelineLayout) Release()

+ type PipelineLayoutDescriptor struct

+ BindGroupLayouts []*BindGroupLayout

+ Label string

+ type PollType uint8

+ const PollPoll

+ const PollWait

+ type PowerPreference = gputypes.PowerPreference

+ type PresentMode = gputypes.PresentMode

+ type PrimitiveState = gputypes.PrimitiveState

+ type PrimitiveTopology = gputypes.PrimitiveTopology

+ type Queue struct

+ func QueueFromHandle(h gpucontext.Queue) *Queue

+ func (q *Queue) LastSubmissionIndex() uint64

+ func (q *Queue) Poll() uint64

+ func (q *Queue) SetSwapchainSuppressed(_ bool)

+ func (q *Queue) SetSwapchainSuppressed(suppressed bool)

+ func (q *Queue) Submit(commandBuffers ...*CommandBuffer) (uint64, error)

+ func (q *Queue) WriteBuffer(buffer *Buffer, offset uint64, data []byte) error

+ func (q *Queue) WriteTexture(dst *ImageCopyTexture, data []byte, layout *ImageDataLayout, size *Extent3D) error

+ type RenderPassColorAttachment struct

+ ClearValue Color

+ LoadOp LoadOp

+ ResolveTarget *TextureView

+ StoreOp StoreOp

+ View *TextureView

+ type RenderPassDepthStencilAttachment struct

+ DepthClearValue float32

+ DepthLoadOp LoadOp

+ DepthReadOnly bool

+ DepthStoreOp StoreOp

+ StencilClearValue uint32

+ StencilLoadOp LoadOp

+ StencilReadOnly bool

+ StencilStoreOp StoreOp

+ View *TextureView

+ type RenderPassDescriptor struct

+ ColorAttachments []RenderPassColorAttachment

+ DepthStencilAttachment *RenderPassDepthStencilAttachment

+ Label string

+ type RenderPassEncoder struct

+ func (p *RenderPassEncoder) Draw(vertexCount, instanceCount, firstVertex, firstInstance uint32)

+ func (p *RenderPassEncoder) DrawIndexed(indexCount, instanceCount, firstIndex uint32, baseVertex int32, ...)

+ func (p *RenderPassEncoder) DrawIndexedIndirect(buffer *Buffer, offset uint64)

+ func (p *RenderPassEncoder) DrawIndirect(buffer *Buffer, offset uint64)

+ func (p *RenderPassEncoder) End() error

+ func (p *RenderPassEncoder) MultiDrawIndexedIndirect(buffer *Buffer, offset uint64, drawCount uint32)

+ func (p *RenderPassEncoder) MultiDrawIndirect(buffer *Buffer, offset uint64, drawCount uint32)

+ func (p *RenderPassEncoder) SetBindGroup(index uint32, group *BindGroup, offsets []uint32)

+ func (p *RenderPassEncoder) SetBlendConstant(color *Color)

+ func (p *RenderPassEncoder) SetIndexBuffer(buffer *Buffer, format IndexFormat, offset uint64)

+ func (p *RenderPassEncoder) SetPipeline(pipeline *RenderPipeline)

+ func (p *RenderPassEncoder) SetScissorRect(x, y, width, height uint32)

+ func (p *RenderPassEncoder) SetStencilReference(reference uint32)

+ func (p *RenderPassEncoder) SetVertexBuffer(slot uint32, buffer *Buffer, offset uint64)

+ func (p *RenderPassEncoder) SetViewport(x, y, width, height, minDepth, maxDepth float32)

+ type RenderPipeline struct

+ func (p *RenderPipeline) GetBindGroupLayout(index uint32) *BindGroupLayout

+ func (p *RenderPipeline) Release()

+ type RenderPipelineDescriptor struct

+ DepthStencil *DepthStencilState

+ Fragment *FragmentState

+ Label string

+ Layout *PipelineLayout

+ Multisample MultisampleState

+ Primitive PrimitiveState

+ Vertex VertexState

+ type RequestAdapterOptions struct

+ CompatibleSurface *Surface

+ ForceFallbackAdapter bool

+ PowerPreference PowerPreference

+ type Sampler struct

+ func NewSamplerFromHAL(_ any, _ *Device) *Sampler

+ func NewSamplerFromHAL(halSampler hal.Sampler, device *Device) *Sampler

+ func (s *Sampler) Release()

+ type SamplerDescriptor struct

+ AddressModeU AddressMode

+ AddressModeV AddressMode

+ AddressModeW AddressMode

+ Anisotropy uint16

+ Compare CompareFunction

+ Label string

+ LodMaxClamp float32

+ LodMinClamp float32

+ MagFilter FilterMode

+ MinFilter FilterMode

+ MipmapFilter FilterMode

+ type ShaderModule struct

+ func (m *ShaderModule) Release()

+ type ShaderModuleDescriptor struct

+ Label string

+ SPIRV []uint32

+ WGSL string

+ type ShaderStages = gputypes.ShaderStages

+ type StencilFaceState struct

+ Compare CompareFunction

+ DepthFailOp StencilOperation

+ FailOp StencilOperation

+ PassOp StencilOperation

+ type StencilOperation = gputypes.StencilOperation

+ type StoreOp = gputypes.StoreOp

+ type Surface struct

+ func NewSurfaceFromHAL(_ any, _ string) *Surface

+ func NewSurfaceFromHAL(halSurface hal.Surface, label string) *Surface

+ func SurfaceFromHandle(h gpucontext.Surface) *Surface

+ func (s *Surface) ActualExtent() (width, height uint32)

+ func (s *Surface) Configure(device *Device, config *SurfaceConfiguration) error

+ func (s *Surface) DiscardTexture()

+ func (s *Surface) GetCurrentTexture() (*SurfaceTexture, bool, error)

+ func (s *Surface) HAL() hal.Surface

+ func (s *Surface) Present(_ *SurfaceTexture) error

+ func (s *Surface) Present(texture *SurfaceTexture) error

+ func (s *Surface) PresentPixels(data []byte, width, height uint32, damageRects []image.Rectangle) error

+ func (s *Surface) PresentWithDamage(st *SurfaceTexture, _ []image.Rectangle) error

+ func (s *Surface) PresentWithDamage(texture *SurfaceTexture, damageRects []image.Rectangle) error

+ func (s *Surface) ReadPixels() ([]byte, error)

+ func (s *Surface) Release()

+ func (s *Surface) SetPrepareFrame(fn core.PrepareFrameFunc)

+ func (s *Surface) SetPresentsWithTransaction(enabled bool)

+ func (s *Surface) Unconfigure()

+ func (s *Surface) WritePixels(data []byte, width, height uint32) error

+ type SurfaceCapabilities struct

+ AlphaModes []CompositeAlphaMode

+ AlphaModes []gputypes.CompositeAlphaMode

+ Formats []TextureFormat

+ Formats []gputypes.TextureFormat

+ PresentModes []PresentMode

+ PresentModes []gputypes.PresentMode

+ type SurfaceConfiguration struct

+ AlphaMode CompositeAlphaMode

+ Format TextureFormat

+ Height uint32

+ PresentMode PresentMode

+ Usage TextureUsage

+ Width uint32

+ type SurfaceTarget interface

+ SurfaceTarget func() (SurfaceTargetUnsafe, error)

+ type SurfaceTargetUnsafe struct

+ func SurfaceTargetFromAndroidNativeWindow(window uintptr) SurfaceTargetUnsafe

+ func SurfaceTargetFromMetalLayer(layer uintptr) SurfaceTargetUnsafe

+ func SurfaceTargetFromWaylandSurface(display, surface uintptr) SurfaceTargetUnsafe

+ func SurfaceTargetFromWebCanvasID(id uintptr) SurfaceTargetUnsafe

+ func SurfaceTargetFromWindowsHWND(hinstance, hwnd uintptr) SurfaceTargetUnsafe

+ func SurfaceTargetFromXlibWindow(display, window uintptr) SurfaceTargetUnsafe

+ type SurfaceTexture struct

+ func (st *SurfaceTexture) AsTexture() *Texture

+ func (st *SurfaceTexture) CreateView(desc *TextureViewDescriptor) (*TextureView, error)

+ func (st *SurfaceTexture) Texture() *Texture

+ type Texture struct

+ func NewTextureFromHAL(_ any, _ *Device, _ TextureFormat) *Texture

+ func NewTextureFromHAL(halTexture hal.Texture, device *Device, format TextureFormat) *Texture

+ func (t *Texture) Format() TextureFormat

+ func (t *Texture) Release()

+ type TextureAspect = gputypes.TextureAspect

+ type TextureBarrier struct

+ Range TextureRange

+ Texture *Texture

+ Usage TextureUsageTransition

+ type TextureCopy struct

+ Destination ImageCopyTexture

+ Size Extent3D

+ Source ImageCopyTexture

+ type TextureDescriptor struct

+ Dimension TextureDimension

+ Format TextureFormat

+ Label string

+ MipLevelCount uint32

+ SampleCount uint32

+ Size Extent3D

+ Usage TextureUsage

+ ViewFormats []TextureFormat

+ type TextureDimension = gputypes.TextureDimension

+ type TextureFormat = gputypes.TextureFormat

+ type TextureRange struct

+ ArrayLayerCount uint32

+ Aspect TextureAspect

+ BaseArrayLayer uint32

+ BaseMipLevel uint32

+ MipLevelCount uint32

+ type TextureUsage = gputypes.TextureUsage

+ type TextureUsageTransition struct

+ NewUsage TextureUsage

+ OldUsage TextureUsage

+ type TextureView struct

+ func NewTextureViewFromHAL(_ any, _ *Device) *TextureView

+ func NewTextureViewFromHAL(halView hal.TextureView, device *Device) *TextureView

+ func (v *TextureView) Release()

+ func (v *TextureView) Texture() *Texture

+ type TextureViewDescriptor struct

+ ArrayLayerCount uint32

+ Aspect TextureAspect

+ BaseArrayLayer uint32

+ BaseMipLevel uint32

+ Dimension TextureViewDimension

+ Format TextureFormat

+ Label string

+ MipLevelCount uint32

+ type TextureViewDimension = gputypes.TextureViewDimension

+ type VertexBufferLayout = gputypes.VertexBufferLayout

+ type VertexState struct

+ Buffers []VertexBufferLayout

+ EntryPoint string

+ Module *ShaderModule

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL