native

package
v0.18.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 15, 2026 License: MIT Imports: 21 Imported by: 0

Documentation

Overview

Package native provides a Pure Go GPU-accelerated rendering backend using gogpu/wgpu.

Package native provides a Pure Go GPU-accelerated rendering backend.

This backend leverages WebGPU for hardware-accelerated 2D graphics rendering. It uses the gogpu/wgpu Pure Go WebGPU implementation (zero CGO), which supports Vulkan, Metal, and DX12 backends depending on the platform.

Architecture Overview

The native backend implements a vello-style GPU rendering pipeline: 

Scene Commands -> Decoder -> HybridPipeline (Flatten → Coarse → Fine) -> GPU -> Composite

Key components:

  • NativeBackend: Main entry point implementing backend.RenderBackend
  • GPUSceneRenderer: Scene-to-GPU pipeline with HybridPipeline rasterization
  • HybridPipeline: 3-stage path rasterization (Flatten, Coarse, Fine)
  • MemoryManager: GPU texture memory with LRU eviction (configurable budget)
  • TextureAtlas: Shelf-packing for efficient GPU memory usage
  • PipelineCache: Pre-compiled GPU pipelines for all 29 blend modes
  • ShaderModules: WGSL compute shaders for tile rasterization and blending

HybridPipeline (vello-style)

Scene rendering uses a 3-stage tile-based pipeline inspired by Linebender's vello:

  1. Flatten: Bezier curves are flattened to line segments using Wang's formula
  2. Coarse: Line segments are binned into 4×4 pixel tiles with winding info
  3. Fine: Each tile's coverage is computed with anti-aliased edges

The pipeline automatically selects GPU or CPU execution per stage based on workload size. This hybrid approach provides optimal performance across different path complexities.

Example tile data for a circle: 

Tile(X=10, Y=5): Coverage[16]=[32, 128, 255, 255, ...]  // 4×4 pixel coverage
Tile(X=11, Y=5): Coverage[16]=[255, 255, 255, 192, ...] // Adjacent tile
... (sparse tiles only where path intersects)

Blend Modes

All 29 standard blend modes are supported via WGSL shaders:

Standard modes:

  • Normal, Multiply, Screen, Overlay
  • Darken, Lighten, ColorDodge, ColorBurn
  • HardLight, SoftLight, Difference, Exclusion

HSL modes:

  • Hue, Saturation, Color, Luminosity

Porter-Duff compositing:

  • Clear, Copy, Destination
  • SourceOver, DestinationOver
  • SourceIn, DestinationIn
  • SourceOut, DestinationOut
  • SourceAtop, DestinationAtop
  • Xor, Plus

Registration and Selection

The native backend is automatically registered when this package is imported: 

import _ "github.com/gogpu/gg/backend/native"

The backend will be preferred over the software backend when available. If GPU initialization fails, the system will fall back to software rendering.

Basic Usage

Automatic backend selection (recommended): 

b := backend.Default()  // Returns native if available, otherwise software
if err := b.Init(); err != nil {
    log.Fatal(err)
}
defer b.Close()

Explicit native backend selection: 

b := backend.Get(backend.BackendNative)
if b == nil {
    log.Fatal("native backend not available")
}
if err := b.Init(); err != nil {
    log.Fatal(err)
}
defer b.Close()

Rendering Scenes

Build and render a scene: 

// Create scene using SceneBuilder
builder := scene.NewSceneBuilder()
builder.FillRect(0, 0, 800, 600, scene.SolidBrush(gg.White))
builder.FillCircle(400, 300, 100, scene.SolidBrush(gg.Red))

// Add a blended layer
builder.Layer(scene.BlendMultiply, 0.8, nil, func(lb *scene.SceneBuilder) {
    lb.FillRect(300, 200, 200, 200, scene.SolidBrush(gg.Blue))
})

s := builder.Build()

// Render to pixmap
pm := gg.NewPixmap(800, 600)
if err := b.RenderScene(pm, s); err != nil {
    log.Printf("Render error: %v", err)
}

// Save result
pm.SavePNG("output.png")

Direct Scene Construction

Lower-level scene construction: 

s := scene.NewScene()
rect := scene.NewRectShape(10, 10, 80, 80)
s.Fill(scene.FillNonZero, scene.IdentityAffine(), scene.SolidBrush(gg.Red), rect)

circle := scene.NewCircleShape(50, 50, 30)
s.Fill(scene.FillNonZero, scene.TranslateAffine(100, 0), scene.SolidBrush(gg.Blue), circle)

pm := gg.NewPixmap(200, 100)
b.RenderScene(pm, s)

Performance Characteristics

The GPU backend excels at:

  • Large canvases (1080p and above)
  • Many shapes with the same blend mode
  • Complex layer compositing
  • Parallel processing of independent draws

Software backend may be faster for:

  • Small canvases (< 256x256)
  • Single shape renders
  • Frequent GPU-CPU data transfers

Memory Management

The backend uses an LRU-based memory manager with configurable budget: 

// Configure via GPUSceneRendererConfig
config := GPUSceneRendererConfig{
    Width:          1920,
    Height:         1080,
    MaxLayers:      16,     // Maximum layer stack depth
    MemoryBudgetMB: 256,    // GPU texture memory budget
}

When memory budget is exceeded, least-recently-used textures are evicted.

Current Status (v0.16.0)

The GPU pipeline uses vello-style HybridPipeline architecture. The following components are fully implemented and tested:

  • HybridPipeline: 3-stage path rasterization (Flatten → Coarse → Fine)
  • Tile-based sparse coverage (4×4 pixel tiles)
  • GPU/CPU automatic selection per stage
  • Fill rule support (NonZero, EvenOdd)
  • Anti-aliased coverage calculation
  • Pipeline cache for all blend modes
  • WGSL compute shaders (flatten.wgsl, coarse.wgsl, fine.wgsl)
  • Memory management with LRU eviction
  • Layer stack management
  • Clip region support

GPU compute shader execution uses CPU fallback until HAL bridge is complete. This will be enabled when core↔HAL device/queue bridge is implemented:

  • HAL device/queue wiring to HybridPipeline
  • Texture readback (for downloading GPU results to CPU)
  • Buffer mapping (for uploading vertex/uniform data)

All data flow through the pipeline is correct and tested.

Requirements

  • Go 1.25+ (for generic features)
  • gogpu/wgpu module (github.com/gogpu/wgpu)
  • A GPU that supports Vulkan, Metal, or DX12 (for actual GPU rendering)

Thread Safety

NativeBackend and GPUSceneRenderer are safe for concurrent use from multiple goroutines. Internal synchronization is handled via mutexes.

Error Handling

Common errors returned by this package:

  • ErrNotInitialized: Backend must be initialized before use
  • ErrNoGPU: No compatible GPU found
  • ErrDeviceLost: GPU device was lost (requires re-initialization)
  • ErrNilTarget: Target pixmap is nil
  • ErrNilScene: Scene is nil
  • ErrRendererClosed: Renderer has been closed
  • ErrEmptyScene: Scene contains no draw commands

Benchmarking

Run benchmarks to compare GPU vs Software performance: 

go test -bench=. ./backend/native/...

Key benchmarks:

  • BenchmarkClear1080p: Full canvas clear comparison
  • BenchmarkRect100: 100 rectangles comparison
  • BenchmarkCircle50: Circle rendering comparison
  • BenchmarkLayers4: Layer compositing comparison
  • BenchmarkPipelineCreation: GPU pipeline cache performance
  • github.com/gogpu/gg: Core 2D graphics library
  • github.com/gogpu/gg/scene: Scene graph and retained mode API
  • github.com/gogpu/gg/backend: Backend interface and registry
  • github.com/gogpu/wgpu: Pure Go WebGPU implementation

References

Package wgpu provides GPU-accelerated rendering using WebGPU.

Package wgpu provides GPU-accelerated rendering using WebGPU.

Package wgpu provides GPU-accelerated rendering using WebGPU.

Package wgpu provides GPU-accelerated rendering backend using WebGPU.

Package wgpu provides GPU-accelerated rendering using WebGPU.

Index

Constants

View Source 
const (
	// DefaultAtlasSize is the default atlas dimension (2048x2048).
	DefaultAtlasSize = 2048

	// MinAtlasSize is the minimum atlas dimension (256x256).
	MinAtlasSize = 256

	// DefaultShelfPadding is the padding between shelves.
	DefaultShelfPadding = 1
)

Default atlas settings.

View Source 
const (
	// DefaultMaxMemoryMB is the default maximum GPU memory budget (256 MB).
	DefaultMaxMemoryMB = 256

	// DefaultEvictionThreshold is when eviction starts (80% of budget).
	DefaultEvictionThreshold = 0.8

	// MinMemoryMB is the minimum allowed memory budget (16 MB).
	MinMemoryMB = 16
)

Default memory limits.

View Source 
const (
	// Standard blend modes (0-11)
	ShaderBlendNormal     uint32 = 0
	ShaderBlendMultiply   uint32 = 1
	ShaderBlendScreen     uint32 = 2
	ShaderBlendOverlay    uint32 = 3
	ShaderBlendDarken     uint32 = 4
	ShaderBlendLighten    uint32 = 5
	ShaderBlendColorDodge uint32 = 6
	ShaderBlendColorBurn  uint32 = 7
	ShaderBlendHardLight  uint32 = 8
	ShaderBlendSoftLight  uint32 = 9
	ShaderBlendDifference uint32 = 10
	ShaderBlendExclusion  uint32 = 11

	// HSL blend modes (12-15)
	ShaderBlendHue        uint32 = 12
	ShaderBlendSaturation uint32 = 13
	ShaderBlendColor      uint32 = 14
	ShaderBlendLuminosity uint32 = 15

	// Porter-Duff modes (16-28)
	ShaderBlendClear           uint32 = 16
	ShaderBlendCopy            uint32 = 17
	ShaderBlendDestination     uint32 = 18
	ShaderBlendSourceOver      uint32 = 19
	ShaderBlendDestinationOver uint32 = 20
	ShaderBlendSourceIn        uint32 = 21
	ShaderBlendDestinationIn   uint32 = 22
	ShaderBlendSourceOut       uint32 = 23
	ShaderBlendDestinationOut  uint32 = 24
	ShaderBlendSourceAtop      uint32 = 25
	ShaderBlendDestinationAtop uint32 = 26
	ShaderBlendXor             uint32 = 27
	ShaderBlendPlus            uint32 = 28
)

Blend mode constants matching scene.BlendMode values. These are used for GPU shader uniform values.

View Source 
const DefaultCoarseThreshold = 100

DefaultCoarseThreshold is the minimum segments for GPU coarse rasterization.

View Source 
const DefaultFineThreshold = 100

DefaultFineThreshold is the minimum tile entries for GPU fine rasterization.

View Source 
const DefaultFlattenThreshold = 50

DefaultFlattenThreshold is the minimum path elements for GPU flattening.

View Source 
const DefaultGPUSegmentThreshold = 100

DefaultGPUSegmentThreshold is the minimum number of segments to use GPU. Below this threshold, CPU is typically faster due to GPU dispatch overhead.

View Source 
const DefaultTextureUsage = types.TextureUsageCopySrc | types.TextureUsageCopyDst | types.TextureUsageTextureBinding

DefaultTextureUsage is the default usage for textures created without specific flags.

View Source 
const FlattenMaxSegmentsPerCurve = 64

FlattenMaxSegmentsPerCurve is the maximum segments generated per curve.

View Source 
const FlattenTolerance = 0.25

FlattenTolerance is the default tolerance for curve flattening. Smaller values produce more accurate curves but more segments.

View Source 
const TileHeight = TileSize

TileHeight is the height of a tile in pixels (matches TileSize).

View Source 
const TileMask = TileSize - 1

TileMask is TileSize - 1 for efficient modulo.

View Source 
const TileShift = 2

TileShift is log2(TileSize) for efficient division.

View Source 
const TileSize = 4

TileSize is the width and height of a tile in pixels. 4×4 is optimal for cache efficiency and SIMD processing.

View Source 
const TileWidth = TileSize

TileWidth is the width of a tile in pixels (matches TileSize).

Variables

View Source 
var (
	// ErrAtlasFull is returned when the atlas cannot fit the requested region.
	ErrAtlasFull = errors.New("wgpu: texture atlas is full")

	// ErrAtlasClosed is returned when operating on a closed atlas.
	ErrAtlasClosed = errors.New("wgpu: texture atlas is closed")

	// ErrRegionOutOfBounds is returned when a region is outside atlas bounds.
	ErrRegionOutOfBounds = errors.New("wgpu: region is outside atlas bounds")
)

Atlas-related errors.

View Source 
var (
	// ErrNotInitialized is returned when operations are called before Init.
	ErrNotInitialized = errors.New("wgpu: backend not initialized")

	// ErrNoGPU is returned when no GPU adapter is available.
	ErrNoGPU = errors.New("wgpu: no GPU adapter available")

	// ErrDeviceLost is returned when the GPU device is lost.
	ErrDeviceLost = errors.New("wgpu: GPU device lost")

	// ErrNotImplemented is returned for stub operations not yet implemented.
	ErrNotImplemented = errors.New("wgpu: operation not implemented")

	// ErrInvalidDimensions is returned when width or height is invalid.
	ErrInvalidDimensions = errors.New("wgpu: invalid dimensions")

	// ErrNilTarget is returned when target pixmap is nil.
	ErrNilTarget = errors.New("wgpu: nil target pixmap")

	// ErrNilScene is returned when scene is nil.
	ErrNilScene = errors.New("wgpu: nil scene")
)

Package errors for wgpu backend.

View Source 
var (
	// ErrMemoryBudgetExceeded is returned when allocation would exceed budget.
	ErrMemoryBudgetExceeded = errors.New("wgpu: memory budget exceeded")

	// ErrMemoryManagerClosed is returned when operating on a closed manager.
	ErrMemoryManagerClosed = errors.New("wgpu: memory manager closed")

	// ErrTextureNotFound is returned when a texture is not found in the manager.
	ErrTextureNotFound = errors.New("wgpu: texture not found in manager")
)

Memory management errors.

View Source 
var (
	// ErrRendererClosed is returned when operating on a closed renderer.
	ErrRendererClosed = errors.New("wgpu: renderer closed")

	// ErrEmptyScene is returned when rendering an empty scene.
	ErrEmptyScene = errors.New("wgpu: empty scene")

	// ErrLayerStackUnderflow is returned when popping more layers than pushed.
	ErrLayerStackUnderflow = errors.New("wgpu: layer stack underflow")
)

Renderer-specific errors.

View Source 
var (
	// ErrNilTextPipeline is returned when operating on a nil pipeline.
	ErrNilTextPipeline = errors.New("wgpu: text pipeline is nil")

	// ErrTextPipelineNotInitialized is returned when pipeline is not initialized.
	ErrTextPipelineNotInitialized = errors.New("wgpu: text pipeline not initialized")

	// ErrNoQuadsToRender is returned when RenderText is called with empty quads.
	ErrNoQuadsToRender = errors.New("wgpu: no quads to render")

	// ErrQuadBufferOverflow is returned when too many quads are submitted.
	ErrQuadBufferOverflow = errors.New("wgpu: quad buffer overflow")

	// ErrInvalidAtlasIndex is returned when referencing invalid atlas.
	ErrInvalidAtlasIndex = errors.New("wgpu: invalid atlas index")
)

Text rendering errors.

View Source 
var (
	// ErrTextureReleased is returned when operating on a released texture.
	ErrTextureReleased = errors.New("wgpu: texture has been released")

	// ErrTextureSizeMismatch is returned when pixmap size doesn't match texture.
	ErrTextureSizeMismatch = errors.New("wgpu: pixmap size does not match texture")

	// ErrNilPixmap is returned when pixmap is nil.
	ErrNilPixmap = errors.New("wgpu: pixmap is nil")

	// ErrTextureReadbackNotSupported is returned when readback is not available.
	ErrTextureReadbackNotSupported = errors.New("wgpu: texture readback not supported (stub)")
)

Texture-related errors.

View Source 
var ErrNilBackend = errors.New("wgpu: backend is nil")

ErrNilBackend is returned when backend is nil.

Functions

func BlendModeToShader 

func BlendModeToShader(mode scene.BlendMode) uint32

BlendModeToShader converts a scene.BlendMode to the shader constant value. The values are designed to match directly, so this is primarily for type safety.

func BlendTileSIMD 

func BlendTileSIMD(
	buffer []uint8,
	bufferStride int,
	baseX, baseY int,
	coverage *TileCoverage16,
	color [4]uint8,
)

BlendTileSIMD performs alpha blending for a 4×4 tile using SIMD. Uses U16x16 for processing all 16 pixels at once.

func CheckDeviceLimits 

func CheckDeviceLimits(deviceID core.DeviceID) error

CheckDeviceLimits verifies that the device meets minimum requirements. This can be used to validate GPU capabilities before rendering.

func CheckGPUComputeSupport 

func CheckGPUComputeSupport(device hal.Device) bool

CheckGPUComputeSupport checks if GPU compute shaders are supported. This can be used to determine if GPU rasterization is viable before creating a rasterizer.

func CompileShaderToSPIRV 

func CompileShaderToSPIRV(wgslSource string) ([]uint32, error)

CompileShaderToSPIRV compiles WGSL source to SPIR-V uint32 slice. This is the common shader compilation logic used by all GPU rasterizers.

func CreateShaderModule 

func CreateShaderModule(device hal.Device, label string, spirvCode []uint32) (hal.ShaderModule, error)

CreateShaderModule creates a HAL shader module from SPIR-V code.

func FillRuleToGPU 

func FillRuleToGPU(rule scene.FillStyle) uint32

FillRuleToGPU converts scene.FillStyle to GPU constant.

func FinalizeTileSIMD 

func FinalizeTileSIMD(
	tileWinding *TileWinding16,
	coverage *TileCoverage16,
	fillRule scene.FillStyle,
)

FinalizeTileSIMD converts winding values to coverage using SIMD. Supports both NonZero and EvenOdd fill rules.

func GetBlendShaderSource 

func GetBlendShaderSource() string

GetBlendShaderSource returns the WGSL source for the blend shader.

func GetBlitShaderSource 

func GetBlitShaderSource() string

GetBlitShaderSource returns the WGSL source for the blit shader.

func GetCompositeShaderSource 

func GetCompositeShaderSource() string

GetCompositeShaderSource returns the WGSL source for the composite shader.

func GetMSDFTextShaderSource 

func GetMSDFTextShaderSource() string

GetMSDFTextShaderSource returns the WGSL source for the MSDF text shader.

func GetStripShaderSource 

func GetStripShaderSource() string

GetStripShaderSource returns the WGSL source for the strip shader.

func InitTileWindingSIMD 

func InitTileWindingSIMD(tileWinding *TileWinding16, backdrop float32)

InitTileWindingSIMD initializes tile winding from backdrop using SIMD.

func PixelToTile 

func PixelToTile(px, py int32) (tx, ty int32)

PixelToTile converts pixel coordinates to tile coordinates. Uses arithmetic shift which provides floor division for negative numbers.

func PixelToTileF 

func PixelToTileF(px, py float32) (tx, ty int32)

PixelToTileF converts float pixel coordinates to tile coordinates. Uses floor semantics for correct handling of negative coordinates.

func ProcessSegmentSIMD 

func ProcessSegmentSIMD(
	line LineSegment,
	tileX, tileY uint16,
	tileWinding *TileWinding16,
)

ProcessSegmentSIMD processes a line segment's contribution to a tile using SIMD. This is a vectorized version of processSegment for the FineRasterizer.

func ShaderToBlendMode 

func ShaderToBlendMode(shaderMode uint32) scene.BlendMode

ShaderToBlendMode converts a shader blend mode constant to scene.BlendMode.

func ValidateBlendModeMapping 

func ValidateBlendModeMapping() error

ValidateBlendModeMapping verifies that shader constants match scene.BlendMode values. Returns an error if any mismatch is found.

Types

type ActiveEdge 

type ActiveEdge struct {
	Edge *Edge
	X    float32 // Current X position at current scanline
}

ActiveEdge holds an edge with its current X position.

type ActiveEdgeTable 

type ActiveEdgeTable struct {
	// contains filtered or unexported fields
}

ActiveEdgeTable manages active edges during scanline conversion.

func NewActiveEdgeTable 

func NewActiveEdgeTable() *ActiveEdgeTable

NewActiveEdgeTable creates a new active edge table.

func (*ActiveEdgeTable) Active 

func (aet *ActiveEdgeTable) Active() []ActiveEdge

Active returns the list of active edges for iteration.

func (*ActiveEdgeTable) InsertEdge 

func (aet *ActiveEdgeTable) InsertEdge(e *Edge, y float32)

InsertEdge adds an edge to the active list.

func (*ActiveEdgeTable) Len 

func (aet *ActiveEdgeTable) Len() int

Len returns the number of active edges.

func (*ActiveEdgeTable) RemoveExpired 

func (aet *ActiveEdgeTable) RemoveExpired(y float32)

RemoveExpired removes edges that end at or before the given Y.

func (*ActiveEdgeTable) Reset 

func (aet *ActiveEdgeTable) Reset()

Reset clears the active edge table.

func (*ActiveEdgeTable) SortByX 

func (aet *ActiveEdgeTable) SortByX()

SortByX sorts active edges by their current X position.

func (*ActiveEdgeTable) UpdateX 

func (aet *ActiveEdgeTable) UpdateX(y float32)

UpdateX updates X positions for all active edges at the new Y.

type AtlasRegion 

type AtlasRegion struct {
	// X is the left edge of the region.
	X int
	// Y is the top edge of the region.
	Y int
	// Width is the region width.
	Width int
	// Height is the region height.
	Height int
}

AtlasRegion represents a rectangular region in a texture atlas.

func (AtlasRegion) Contains 

func (r AtlasRegion) Contains(x, y int) bool

Contains returns true if the point (x, y) is inside the region.

func (AtlasRegion) IsValid 

func (r AtlasRegion) IsValid() bool

IsValid returns true if the region has valid dimensions.

func (AtlasRegion) String 

func (r AtlasRegion) String() string

String returns a string representation of the region.

type BindGroupBuilder 

type BindGroupBuilder struct {
	// contains filtered or unexported fields
}

BindGroupBuilder helps construct bind groups for rendering.

func NewBindGroupBuilder 

func NewBindGroupBuilder(device core.DeviceID, layout StubBindGroupLayoutID) *BindGroupBuilder

NewBindGroupBuilder creates a new bind group builder.

func (*BindGroupBuilder) Build 

func (b *BindGroupBuilder) Build() StubBindGroupID

Build creates the bind group. Currently returns a stub.

type BlendParams 

type BlendParams struct {
	Mode    uint32  // Blend mode enum value
	Alpha   float32 // Layer opacity (0.0 - 1.0)
	Padding [2]float32
}

BlendParams represents the uniform buffer structure for blend shaders. This matches the BlendParams struct in blend.wgsl.

type CoarseRasterizer 

type CoarseRasterizer struct {
	// contains filtered or unexported fields
}

CoarseRasterizer performs coarse rasterization of line segments into tiles. It bins segments into the tiles they intersect and tracks winding information.

func NewCoarseRasterizer 

func NewCoarseRasterizer(width, height uint16) *CoarseRasterizer

NewCoarseRasterizer creates a new coarse rasterizer for the given dimensions.

func (*CoarseRasterizer) CalculateBackdrop 

func (cr *CoarseRasterizer) CalculateBackdrop() []int32

CalculateBackdrop calculates the backdrop winding for fine rasterization. Returns a slice of backdrop values indexed by [y * columns + x].

func (*CoarseRasterizer) Entries 

func (cr *CoarseRasterizer) Entries() []CoarseTileEntry

Entries returns the coarse tile entries.

func (*CoarseRasterizer) EntriesAtLocation 

func (cr *CoarseRasterizer) EntriesAtLocation(x, y uint16) []CoarseTileEntry

EntriesAtLocation returns all entries at the given tile location.

func (*CoarseRasterizer) Grid 

func (cr *CoarseRasterizer) Grid() *TileGrid

Grid returns the tile grid after rasterization.

func (*CoarseRasterizer) NewIterator 

func (cr *CoarseRasterizer) NewIterator() *CoarseTileIterator

NewIterator creates an iterator for the coarse tile entries.

func (*CoarseRasterizer) Rasterize 

func (cr *CoarseRasterizer) Rasterize(segments *SegmentList)

Rasterize performs coarse rasterization of segments into tiles. It determines which tiles each segment intersects and calculates winding.

func (*CoarseRasterizer) Reset 

func (cr *CoarseRasterizer) Reset()

Reset clears the rasterizer state for reuse.

func (*CoarseRasterizer) Segments 

func (cr *CoarseRasterizer) Segments() *SegmentList

Segments returns the segment list.

func (*CoarseRasterizer) SortEntries 

func (cr *CoarseRasterizer) SortEntries()

SortEntries sorts the entries for efficient rendering. Tiles are sorted by Y, then X, then line index.

func (*CoarseRasterizer) TileColumns 

func (cr *CoarseRasterizer) TileColumns() uint16

TileColumns returns the number of tile columns.

func (*CoarseRasterizer) TileRows 

func (cr *CoarseRasterizer) TileRows() uint16

TileRows returns the number of tile rows.

type CoarseTileEntry 

type CoarseTileEntry struct {
	X       uint16 // Tile X coordinate
	Y       uint16 // Tile Y coordinate
	LineIdx uint32 // Index into segment list
	Winding bool   // True if segment contributes winding at this tile
}

CoarseTileEntry represents a tile with its associated line segment. This is used during the coarse rasterization phase before fine rasterization.

type CoarseTileIterator 

type CoarseTileIterator struct {
	// contains filtered or unexported fields
}

CoarseTileIterator provides iteration over coarse tiles in sorted order.

func (*CoarseTileIterator) HasNext 

func (it *CoarseTileIterator) HasNext() bool

HasNext returns true if there are more entries.

func (*CoarseTileIterator) Next 

func (it *CoarseTileIterator) Next() *CoarseTileEntry

Next returns the next tile entry or nil if done.

func (*CoarseTileIterator) Reset 

func (it *CoarseTileIterator) Reset()

Reset resets the iterator to the beginning.

type CommandBuffer 

type CommandBuffer struct {
	// contains filtered or unexported fields
}

CommandBuffer represents a finished command buffer ready for submission.

func NewCommandBuffer 

func NewCommandBuffer(id StubCommandBufferID) *CommandBuffer

NewCommandBuffer wraps a command buffer ID.

func (*CommandBuffer) ID 

func (b *CommandBuffer) ID() StubCommandBufferID

ID returns the underlying command buffer ID.

type CommandEncoder 

type CommandEncoder struct {
	// contains filtered or unexported fields
}

CommandEncoder wraps GPU command encoding operations. It provides a high-level interface for building command buffers that can be submitted to the GPU queue.

CommandEncoder accumulates render passes and compute passes, then produces a command buffer when Finish is called.

func NewCommandEncoder 

func NewCommandEncoder(device core.DeviceID) *CommandEncoder

NewCommandEncoder creates a new command encoder for the given device.

func (*CommandEncoder) BeginComputePass 

func (e *CommandEncoder) BeginComputePass() *ComputePass

BeginComputePass begins a new compute pass.

func (*CommandEncoder) BeginRenderPass 

func (e *CommandEncoder) BeginRenderPass(target *GPUTexture, clearTarget bool) *RenderPass

BeginRenderPass begins a new render pass targeting the specified texture. If clearTarget is true, the texture is cleared to transparent before drawing.

func (*CommandEncoder) CopyTextureToBuffer 

func (e *CommandEncoder) CopyTextureToBuffer(src *GPUTexture, dst StubBufferID, bytesPerRow uint32)

CopyTextureToBuffer copies a texture to a buffer for readback.

func (*CommandEncoder) CopyTextureToTexture 

func (e *CommandEncoder) CopyTextureToTexture(src, dst *GPUTexture, width, height int)

CopyTextureToTexture copies a region from one texture to another.

func (*CommandEncoder) Finish 

func (e *CommandEncoder) Finish() StubCommandBufferID

Finish completes the command encoder and returns the command buffer. The encoder cannot be used after calling Finish.

func (*CommandEncoder) PassCount 

func (e *CommandEncoder) PassCount() int

PassCount returns the number of passes recorded.

type CompositeParams 

type CompositeParams struct {
	LayerCount uint32 // Number of layers to composite
	Width      uint32 // Output width
	Height     uint32 // Output height
	Padding    uint32 // Alignment padding
}

CompositeParams represents the uniform buffer structure for composite shaders. This matches the CompositeParams struct in composite.wgsl.

type ComputeCommandBuilder 

type ComputeCommandBuilder struct {
	// contains filtered or unexported fields
}

ComputeCommandBuilder provides a fluent API for building compute commands.

func NewComputeCommandBuilder 

func NewComputeCommandBuilder(device core.DeviceID) *ComputeCommandBuilder

NewComputeCommandBuilder creates a new compute command builder.

func (*ComputeCommandBuilder) Dispatch 

func (b *ComputeCommandBuilder) Dispatch(x, y, z uint32) *ComputeCommandBuilder

Dispatch dispatches workgroups.

func (*ComputeCommandBuilder) DispatchForSize 

func (b *ComputeCommandBuilder) DispatchForSize(size, groupSize uint32) *ComputeCommandBuilder

DispatchForSize calculates and dispatches for a work size.

func (*ComputeCommandBuilder) Finish 

func (b *ComputeCommandBuilder) Finish() StubCommandBufferID

Finish ends the pass and returns the command buffer.

func (*ComputeCommandBuilder) SetBindGroup 

func (b *ComputeCommandBuilder) SetBindGroup(index uint32, bindGroup StubBindGroupID) *ComputeCommandBuilder

SetBindGroup sets a bind group.

func (*ComputeCommandBuilder) SetPipeline 

func (b *ComputeCommandBuilder) SetPipeline(pipeline StubComputePipelineID) *ComputeCommandBuilder

SetPipeline sets the compute pipeline.

type ComputePass 

type ComputePass struct {
	// contains filtered or unexported fields
}

ComputePass represents an active compute pass for dispatch commands.

func (*ComputePass) DispatchWorkgroups 

func (p *ComputePass) DispatchWorkgroups(workgroupCountX, workgroupCountY, workgroupCountZ uint32)

DispatchWorkgroups dispatches compute work. workgroupCountX/Y/Z: number of workgroups in each dimension

func (*ComputePass) DispatchWorkgroupsForSize 

func (p *ComputePass) DispatchWorkgroupsForSize(workSize, workgroupSize uint32)

DispatchWorkgroupsForSize calculates and dispatches workgroups for a given work size. workSize: total number of work items workgroupSize: number of items per workgroup (typically 64 or 256)

func (*ComputePass) End 

func (p *ComputePass) End()

End finishes the compute pass.

func (*ComputePass) SetBindGroup 

func (p *ComputePass) SetBindGroup(index uint32, bindGroup StubBindGroupID)

SetBindGroup sets a bind group at the specified index.

func (*ComputePass) SetPipeline 

func (p *ComputePass) SetPipeline(pipeline StubComputePipelineID)

SetPipeline sets the compute pipeline for subsequent dispatch calls.

type Edge 

type Edge struct {
	// contains filtered or unexported fields
}

Edge represents a line segment for scanline conversion. Edges are derived from path segments (lines, curves flattened to lines) and used by the Active Edge Table algorithm.

func NewEdge 

func NewEdge(x0, y0, x1, y1 float32) *Edge

NewEdge creates a new edge from two points. Returns nil if the edge is horizontal (no Y extent).

func NewEdgeWithWinding 

func NewEdgeWithWinding(x0, y0, x1, y1 float32, winding int8) *Edge

NewEdgeWithWinding creates a new edge with explicit winding.

func (*Edge) ContainsY 

func (e *Edge) ContainsY(y float32) bool

ContainsY returns true if Y is within the edge's Y range (inclusive).

func (*Edge) Height 

func (e *Edge) Height() float32

Height returns the vertical extent of the edge.

func (*Edge) IsActiveAt 

func (e *Edge) IsActiveAt(y float32) bool

IsActiveAt returns true if the edge is active at the given Y coordinate. An edge is active when yMin <= y < yMax.

func (*Edge) XAtY 

func (e *Edge) XAtY(y float32) float32

XAtY calculates the X coordinate at a given Y value. This is the core calculation for scanline intersection.

type EdgeList 

type EdgeList struct {
	// contains filtered or unexported fields
}

EdgeList is a collection of edges with utility methods.

func NewEdgeList 

func NewEdgeList() *EdgeList

NewEdgeList creates a new empty edge list.

func (*EdgeList) Add 

func (el *EdgeList) Add(e *Edge)

Add adds an edge to the list.

func (*EdgeList) AddLine 

func (el *EdgeList) AddLine(x0, y0, x1, y1 float32)

AddLine adds a line segment as an edge.

func (*EdgeList) Bounds 

func (el *EdgeList) Bounds() (minX, minY, maxX, maxY float32)

Bounds returns the bounding rectangle of all edges.

func (*EdgeList) Edges 

func (el *EdgeList) Edges() []Edge

Edges returns the underlying slice.

func (*EdgeList) Len 

func (el *EdgeList) Len() int

Len returns the number of edges.

func (*EdgeList) Reset 

func (el *EdgeList) Reset()

Reset clears the edge list for reuse.

func (*EdgeList) SortByYMin 

func (el *EdgeList) SortByYMin()

SortByYMin sorts edges by their minimum Y coordinate.

type FineRasterizer 

type FineRasterizer struct {
	// contains filtered or unexported fields
}

FineRasterizer performs fine rasterization with analytic anti-aliasing. It calculates exact sub-pixel coverage for each tile based on the segments that cross it and the fill rule.

func NewFineRasterizer 

func NewFineRasterizer(width, height uint16) *FineRasterizer

NewFineRasterizer creates a new fine rasterizer for the given dimensions.

func (*FineRasterizer) FillRule 

func (fr *FineRasterizer) FillRule() scene.FillStyle

FillRule returns the current fill rule.

func (*FineRasterizer) Grid 

func (fr *FineRasterizer) Grid() *TileGrid

Grid returns the tile grid with computed coverage.

func (*FineRasterizer) Rasterize 

func (fr *FineRasterizer) Rasterize(
	coarse *CoarseRasterizer,
	segments *SegmentList,
	backdrop []int32,
)

Rasterize performs fine rasterization on coarse tile entries. It calculates analytic anti-aliased coverage for each pixel.

func (*FineRasterizer) RenderToBuffer 

func (fr *FineRasterizer) RenderToBuffer(
	buffer []uint8,
	width, height int,
	stride int,
	color [4]uint8,
)

RenderToBuffer renders the tile grid to a pixel buffer. The buffer is in RGBA format with the given stride (bytes per row).

func (*FineRasterizer) RenderToBufferSIMD 

func (fr *FineRasterizer) RenderToBufferSIMD(
	buffer []uint8,
	width, height int,
	stride int,
	color [4]uint8,
)

RenderToBufferSIMD renders the tile grid using SIMD-optimized blending.

func (*FineRasterizer) Reset 

func (fr *FineRasterizer) Reset()

Reset clears the rasterizer state for reuse.

func (*FineRasterizer) SetFillRule 

func (fr *FineRasterizer) SetFillRule(rule scene.FillStyle)

SetFillRule sets the fill rule for coverage calculation.

type FlattenContext 

type FlattenContext struct {
	// contains filtered or unexported fields
}

FlattenContext provides reusable state for path flattening. Use this to reduce allocations when flattening multiple paths.

func NewFlattenContext 

func NewFlattenContext() *FlattenContext

NewFlattenContext creates a new flattening context.

func (*FlattenContext) FlattenPathTo 

func (ctx *FlattenContext) FlattenPathTo(path *scene.Path, transform scene.Affine, tolerance float32)

FlattenPathTo flattens a path into the context's segment list.

This avoids allocating a new SegmentList for each path.

func (*FlattenContext) Reset 

func (ctx *FlattenContext) Reset()

Reset clears the context for reuse.

func (*FlattenContext) Segments 

func (ctx *FlattenContext) Segments() *SegmentList

Segments returns the flattened segments.

type GPUAffineTransform 

type GPUAffineTransform struct {
	A        float32 // Scale X
	B        float32 // Shear Y
	C        float32 // Shear X
	D        float32 // Scale Y
	E        float32 // Translate X
	F        float32 // Translate Y
	Padding1 float32
	Padding2 float32
}

GPUAffineTransform represents an affine transform for GPU. Must match AffineTransform in flatten.wgsl. Matrix layout (column-major): | a c e | | b d f | | 0 0 1 |

func ConvertAffineToGPU 

func ConvertAffineToGPU(t scene.Affine) GPUAffineTransform

ConvertAffineToGPU converts a scene.Affine to GPU format.

type GPUCoarseConfig 

type GPUCoarseConfig struct {
	ViewportWidth  uint32 // Viewport width in pixels
	ViewportHeight uint32 // Viewport height in pixels
	TileColumns    uint32 // Number of tile columns
	TileRows       uint32 // Number of tile rows
	SegmentCount   uint32 // Number of segments to process
	MaxEntries     uint32 // Maximum number of tile entries
	Padding1       uint32 // Padding for alignment
	Padding2       uint32 // Padding for alignment
}

GPUCoarseConfig contains GPU coarse rasterization configuration. Must match CoarseConfig in coarse.wgsl.

type GPUCoarseRasterizer 

type GPUCoarseRasterizer struct {
	// contains filtered or unexported fields
}

GPUCoarseRasterizer performs coarse rasterization (tile binning) on the GPU. It creates compute pipelines and manages GPU buffers for segment-to-tile mapping.

func NewGPUCoarseRasterizer 

func NewGPUCoarseRasterizer(device hal.Device, queue hal.Queue, width, height uint16) (*GPUCoarseRasterizer, error)

NewGPUCoarseRasterizer creates a new GPU coarse rasterizer. Returns an error if GPU compute is not supported.

func (*GPUCoarseRasterizer) Destroy 

func (r *GPUCoarseRasterizer) Destroy()

Destroy releases all GPU resources.

func (*GPUCoarseRasterizer) GetTileEntries 

func (r *GPUCoarseRasterizer) GetTileEntries(coarse *CoarseRasterizer) []GPUTileSegmentRef

GetTileEntries returns tile entries from a CoarseRasterizer. This is a convenience method that converts CPU coarse entries to GPU format.

func (*GPUCoarseRasterizer) IsInitialized 

func (r *GPUCoarseRasterizer) IsInitialized() bool

IsInitialized returns whether the rasterizer is initialized.

func (*GPUCoarseRasterizer) IsShaderReady 

func (r *GPUCoarseRasterizer) IsShaderReady() bool

IsShaderReady returns whether the shader compiled successfully.

func (*GPUCoarseRasterizer) Rasterize 

func (r *GPUCoarseRasterizer) Rasterize(segments *SegmentList) ([]GPUTileSegmentRef, error)

Rasterize performs coarse rasterization on the GPU. It takes segments and produces tile entries.

Note: Phase 6.2 implementation. Full GPU dispatch requires buffer binding which needs HAL API extensions. Currently falls back to CPU-computed entries.

func (*GPUCoarseRasterizer) SPIRVCode 

func (r *GPUCoarseRasterizer) SPIRVCode() []uint32

SPIRVCode returns the compiled SPIR-V code (for debugging/verification).

func (*GPUCoarseRasterizer) TileColumns 

func (r *GPUCoarseRasterizer) TileColumns() uint16

TileColumns returns the number of tile columns.

func (*GPUCoarseRasterizer) TileRows 

func (r *GPUCoarseRasterizer) TileRows() uint16

TileRows returns the number of tile rows.

type GPUCursorState 

type GPUCursorState struct {
	CurX   float32 // Current cursor X
	CurY   float32 // Current cursor Y
	StartX float32 // Subpath start X (for Close)
	StartY float32 // Subpath start Y (for Close)
}

GPUCursorState tracks the cursor position per path element. Must match CursorState in flatten.wgsl.

type GPUFineConfig 

type GPUFineConfig struct {
	ViewportWidth  uint32 // Viewport width in pixels
	ViewportHeight uint32 // Viewport height in pixels
	TileColumns    uint32 // Number of tile columns
	TileRows       uint32 // Number of tile rows
	TileCount      uint32 // Number of tiles to process
	FillRule       uint32 // 0 = NonZero, 1 = EvenOdd
	Padding1       uint32 // Padding for alignment
	Padding2       uint32 // Padding for alignment
}

GPUFineConfig contains GPU fine rasterization configuration. Must match Config in fine.wgsl.

type GPUFineRasterizer 

type GPUFineRasterizer struct {
	// contains filtered or unexported fields
}

GPUFineRasterizer performs fine rasterization on the GPU. It creates compute pipelines and manages GPU buffers for coverage calculation.

Note: This is Phase 6.1 implementation. Full GPU buffer binding requires HAL API extensions to expose buffer handles. Currently this serves as infrastructure and data flow verification.

func NewGPUFineRasterizer 

func NewGPUFineRasterizer(device hal.Device, queue hal.Queue, width, height uint16) (*GPUFineRasterizer, error)

NewGPUFineRasterizer creates a new GPU fine rasterizer. Returns an error if GPU compute is not supported.

func (*GPUFineRasterizer) Destroy 

func (r *GPUFineRasterizer) Destroy()

Destroy releases all GPU resources.

func (*GPUFineRasterizer) IsInitialized 

func (r *GPUFineRasterizer) IsInitialized() bool

IsInitialized returns whether the rasterizer is initialized.

func (*GPUFineRasterizer) IsShaderReady 

func (r *GPUFineRasterizer) IsShaderReady() bool

IsShaderReady returns whether the shader compiled successfully.

func (*GPUFineRasterizer) Rasterize 

func (r *GPUFineRasterizer) Rasterize(
	coarse *CoarseRasterizer,
	segments *SegmentList,
	backdrop []int32,
	fillRule scene.FillStyle,
) ([]uint8, error)

Rasterize performs fine rasterization on the GPU. It takes the coarse rasterizer output and produces coverage values.

Note: Phase 6.1 implementation. Full GPU dispatch requires buffer binding which needs HAL API extensions. Currently falls back to CPU-computed coverage.

func (*GPUFineRasterizer) SPIRVCode 

func (r *GPUFineRasterizer) SPIRVCode() []uint32

SPIRVCode returns the compiled SPIR-V code (for debugging/verification).

type GPUFlattenConfig 

type GPUFlattenConfig struct {
	ElementCount   uint32  // Number of path elements
	Tolerance      float32 // Flattening tolerance
	MaxSegments    uint32  // Maximum total segments
	TileSize       uint32  // Tile size in pixels
	ViewportWidth  uint32  // Viewport width
	ViewportHeight uint32  // Viewport height
	Padding1       uint32
	Padding2       uint32
}

GPUFlattenConfig contains GPU flattening configuration. Must match FlattenConfig in flatten.wgsl.

type GPUFlattenRasterizer 

type GPUFlattenRasterizer struct {
	// contains filtered or unexported fields
}

GPUFlattenRasterizer performs curve flattening on the GPU. It converts Bezier curves to monotonic line segments using Wang's formula.

Note: Phase 6.3 implementation. Full GPU dispatch requires additional cursor tracking infrastructure. Currently provides CPU fallback using the existing flatten.go algorithms.

func NewGPUFlattenRasterizer 

func NewGPUFlattenRasterizer(device hal.Device, queue hal.Queue, maxPaths, maxSegments int) (*GPUFlattenRasterizer, error)

NewGPUFlattenRasterizer creates a new GPU flatten rasterizer. maxPaths: Maximum number of path elements to process maxSegments: Maximum number of output segments

func (*GPUFlattenRasterizer) ComputeCursorStates 

func (r *GPUFlattenRasterizer) ComputeCursorStates(path *scene.Path) []GPUCursorState

ComputeCursorStates computes cursor states for each path element. This tracks the cursor position (curX, curY) and subpath start (startX, startY) for each element, which is needed by the GPU shader.

func (*GPUFlattenRasterizer) ConvertPathToGPU 

func (r *GPUFlattenRasterizer) ConvertPathToGPU(path *scene.Path) ([]GPUPathElement, []float32)

ConvertPathToGPU converts a scene.Path to GPU buffer format. Returns elements and points arrays suitable for GPU upload.

func (*GPUFlattenRasterizer) Destroy 

func (r *GPUFlattenRasterizer) Destroy()

Destroy releases all GPU resources.

func (*GPUFlattenRasterizer) EstimateSegmentCount 

func (r *GPUFlattenRasterizer) EstimateSegmentCount(path *scene.Path, transform scene.Affine, tolerance float32) int

EstimateSegmentCount estimates the number of segments for a path. Uses Wang's formula to estimate without actually flattening.

func (*GPUFlattenRasterizer) Flatten 

func (r *GPUFlattenRasterizer) Flatten(path *scene.Path, transform scene.Affine, tolerance float32) (*SegmentList, error)

Flatten flattens a path to monotonic line segments. Uses CPU fallback (matching existing flatten.go algorithm).

Parameters:

  • path: The input path to flatten
  • transform: Affine transformation to apply to all points
  • tolerance: Flattening tolerance (use 0 for default)

Returns a SegmentList containing all flattened line segments.

func (*GPUFlattenRasterizer) FlattenWithContext 

func (r *GPUFlattenRasterizer) FlattenWithContext(
	path *scene.Path,
	transform scene.Affine,
	tolerance float32,
) *SegmentList

FlattenWithContext flattens a path using a provided context for efficiency. This avoids allocating a new SegmentList for each path.

func (*GPUFlattenRasterizer) IsInitialized 

func (r *GPUFlattenRasterizer) IsInitialized() bool

IsInitialized returns whether the rasterizer is initialized.

func (*GPUFlattenRasterizer) IsShaderReady 

func (r *GPUFlattenRasterizer) IsShaderReady() bool

IsShaderReady returns whether the shader compiled successfully.

func (*GPUFlattenRasterizer) MaxPaths 

func (r *GPUFlattenRasterizer) MaxPaths() int

MaxPaths returns the maximum number of path elements.

func (*GPUFlattenRasterizer) MaxSegments 

func (r *GPUFlattenRasterizer) MaxSegments() int

MaxSegments returns the maximum number of output segments.

func (*GPUFlattenRasterizer) SPIRVCode 

func (r *GPUFlattenRasterizer) SPIRVCode() []uint32

SPIRVCode returns the compiled SPIR-V code (for debugging/verification).

func (*GPUFlattenRasterizer) SetTolerance 

func (r *GPUFlattenRasterizer) SetTolerance(tolerance float32)

SetTolerance sets the flattening tolerance.

func (*GPUFlattenRasterizer) Tolerance 

func (r *GPUFlattenRasterizer) Tolerance() float32

Tolerance returns the current flattening tolerance.

type GPUInfo 

type GPUInfo struct {
	// Name is the GPU name (e.g., "NVIDIA GeForce RTX 3080").
	Name string
	// Vendor is the GPU vendor.
	Vendor string
	// DeviceType is the type of GPU (discrete, integrated, etc.).
	DeviceType types.DeviceType
	// Backend is the graphics API in use (Vulkan, Metal, DX12).
	Backend types.Backend
	// Driver is the driver version string.
	Driver string
}

GPUInfo contains information about the selected GPU.

func (*GPUInfo) String 

func (g *GPUInfo) String() string

String returns a human-readable description of the GPU.

type GPUPathElement 

type GPUPathElement struct {
	Verb       uint32 // Path verb type (0=MoveTo, 1=LineTo, 2=QuadTo, 3=CubicTo, 4=Close)
	PointStart uint32 // Start index in points array
	PointCount uint32 // Number of points for this element
	Padding    uint32
}

GPUPathElement represents a path element for GPU processing. Must match PathElement in flatten.wgsl.

type GPURasterizer 

type GPURasterizer interface {
	// Rasterize performs fine rasterization and returns coverage values.
	Rasterize(
		coarse *CoarseRasterizer,
		segments *SegmentList,
		backdrop []int32,
		fillRule scene.FillStyle,
	) ([]uint8, error)

	// Destroy releases GPU resources.
	Destroy()
}

GPURasterizer is the interface for GPU-accelerated rasterization.

type GPURasterizerStats 

type GPURasterizerStats struct {
	// GPUAvailable indicates if GPU is available
	GPUAvailable bool

	// TotalCalls is the total number of rasterization calls
	TotalCalls uint64

	// GPUCalls is the number of calls that used GPU
	GPUCalls uint64

	// CPUCalls is the number of calls that used CPU
	CPUCalls uint64

	// SegmentThreshold is the threshold for GPU usage
	SegmentThreshold int
}

GPURasterizerStats contains statistics about GPU rasterization.

type GPURenderer 

type GPURenderer struct {
	// contains filtered or unexported fields
}

GPURenderer is a GPU-backed renderer for immediate mode drawing. It implements the gg.Renderer interface.

Note: This is a stub implementation. The actual GPU rendering will be implemented in TASK-110.

func (*GPURenderer) Close 

func (r *GPURenderer) Close()

Close releases renderer resources. Note: This is a stub implementation.

func (*GPURenderer) Fill 

func (r *GPURenderer) Fill(pixmap *gg.Pixmap, path *gg.Path, paint *gg.Paint) error

Fill fills a path with the given paint.

Phase 1 Implementation: Uses software rasterization via SoftwareRenderer. Future phases will add GPU texture upload and native GPU path rendering.

func (*GPURenderer) Height 

func (r *GPURenderer) Height() int

Height returns the renderer height.

func (*GPURenderer) Stroke 

func (r *GPURenderer) Stroke(pixmap *gg.Pixmap, path *gg.Path, paint *gg.Paint) error

Stroke strokes a path with the given paint.

Phase 1 Implementation: Uses software rasterization via SoftwareRenderer. Future phases will add GPU texture upload and native GPU stroke expansion.

func (*GPURenderer) Width 

func (r *GPURenderer) Width() int

Width returns the renderer width.

type GPUResources 

type GPUResources struct {
	Device         hal.Device
	ShaderModule   hal.ShaderModule
	PipelineLayout hal.PipelineLayout
	BindLayouts    []hal.BindGroupLayout
	Pipelines      []hal.ComputePipeline
}

DestroyGPUResources safely destroys common GPU resources. This is a helper for the cleanup pattern used by all GPU rasterizers.

func (*GPUResources) Destroy 

func (r *GPUResources) Destroy()

Destroy cleans up all GPU resources in the correct order.

type GPUSceneRenderer 

type GPUSceneRenderer struct {
	// contains filtered or unexported fields
}

GPUSceneRenderer renders scenes using GPU acceleration. It implements the full render pipeline: scene decoding, path rasterization, coverage calculation, and layer compositing.

The renderer uses HybridPipeline which automatically selects between GPU and CPU execution for each stage based on workload size.

GPUSceneRenderer is safe for concurrent use from multiple goroutines.

func NewGPUSceneRenderer 

func NewGPUSceneRenderer(backend *NativeBackend, config GPUSceneRendererConfig) (*GPUSceneRenderer, error)

NewGPUSceneRenderer creates a new GPU scene renderer. The renderer is configured for the specified dimensions.

Returns an error if the backend is not initialized or configuration is invalid.

func (*GPUSceneRenderer) Close 

func (r *GPUSceneRenderer) Close()

Close releases all renderer resources.

func (*GPUSceneRenderer) Height 

func (r *GPUSceneRenderer) Height() int

Height returns the renderer height.

func (*GPUSceneRenderer) LayerDepth 

func (r *GPUSceneRenderer) LayerDepth() int

LayerDepth returns the current layer stack depth.

func (*GPUSceneRenderer) MemoryStats 

func (r *GPUSceneRenderer) MemoryStats() MemoryStats

MemoryStats returns GPU memory usage statistics.

func (*GPUSceneRenderer) RenderScene 

func (r *GPUSceneRenderer) RenderScene(s *scene.Scene) error

RenderScene renders a complete scene to the internal target texture. After rendering, use DownloadPixmap to retrieve the result.

For cancellable rendering, use RenderSceneWithContext.

func (*GPUSceneRenderer) RenderSceneWithContext 

func (r *GPUSceneRenderer) RenderSceneWithContext(ctx context.Context, s *scene.Scene) error

RenderSceneWithContext renders a complete scene to the internal target texture with cancellation support.

The context can be used to cancel long-running renders. When canceled, the function returns ctx.Err() and the texture may contain partial results.

func (*GPUSceneRenderer) RenderToPixmap 

func (r *GPUSceneRenderer) RenderToPixmap(target *gg.Pixmap, s *scene.Scene) error

RenderToPixmap renders a scene directly to a pixmap. This is a convenience method that renders and downloads in one call.

For cancellable rendering, use RenderToPixmapWithContext.

func (*GPUSceneRenderer) RenderToPixmapWithContext 

func (r *GPUSceneRenderer) RenderToPixmapWithContext(ctx context.Context, target *gg.Pixmap, s *scene.Scene) error

RenderToPixmapWithContext renders a scene directly to a pixmap with cancellation support. This is a convenience method that renders and downloads in one call.

The context can be used to cancel long-running renders. When canceled, the function returns ctx.Err() and the target may contain partial results.

func (*GPUSceneRenderer) Resize 

func (r *GPUSceneRenderer) Resize(width, height int) error

Resize resizes the renderer to new dimensions. All layer textures are released and the target texture is reallocated.

func (*GPUSceneRenderer) Width 

func (r *GPUSceneRenderer) Width() int

Width returns the renderer width.

type GPUSceneRendererConfig 

type GPUSceneRendererConfig struct {
	// Width is the render target width in pixels.
	Width int

	// Height is the render target height in pixels.
	Height int

	// MaxLayers is the maximum layer stack depth (default: 16).
	MaxLayers int

	// MemoryBudgetMB is the texture memory budget in MB (default: 128).
	MemoryBudgetMB int
}

GPUSceneRendererConfig holds configuration for creating a GPUSceneRenderer.

type GPUSegment 

type GPUSegment struct {
	X0      float32 // Start X coordinate
	Y0      float32 // Start Y coordinate
	X1      float32 // End X coordinate
	Y1      float32 // End Y coordinate
	Winding int32   // Winding direction: +1 or -1
	TileY0  int32   // Starting tile Y (precomputed)
	TileY1  int32   // Ending tile Y (precomputed)
	Padding int32   // Padding for alignment
}

GPUSegment is the GPU-compatible layout of LineSegment. Must match the Segment struct in fine.wgsl.

type GPUSegmentCount 

type GPUSegmentCount struct {
	Count    uint32 // Number of segments for this element
	Offset   uint32 // Prefix sum offset
	Padding1 uint32
	Padding2 uint32
}

GPUSegmentCount holds segment count per path element. Must match SegmentCount in flatten.wgsl.

type GPUTexture 

type GPUTexture struct {
	// contains filtered or unexported fields
}

GPUTexture represents a GPU texture resource. It wraps the underlying wgpu texture and provides a high-level interface for texture operations including upload and download.

GPUTexture is safe for concurrent read access. Write operations (Upload, Close) should be synchronized externally.

func CreateTexture 

func CreateTexture(backend *NativeBackend, config TextureConfig) (*GPUTexture, error)

CreateTexture creates a new GPU texture with the given configuration. The texture is uninitialized and should be filled with UploadPixmap.

Note: This is a stub implementation. The actual GPU texture creation will be implemented when wgpu texture support is complete.

func CreateTextureFromPixmap 

func CreateTextureFromPixmap(backend *NativeBackend, pixmap *gg.Pixmap, label string) (*GPUTexture, error)

CreateTextureFromPixmap creates a GPU texture from a pixmap, uploading the pixel data immediately.

func (*GPUTexture) Close 

func (t *GPUTexture) Close()

Close releases the GPU texture resources. The texture should not be used after Close is called.

func (*GPUTexture) DownloadPixmap 

func (t *GPUTexture) DownloadPixmap() (*gg.Pixmap, error)

DownloadPixmap downloads pixel data from GPU to a new Pixmap. This operation requires the texture to have CopySrc usage.

Note: This is a stub implementation that returns an error. GPU readback requires staging buffers and synchronization.

func (*GPUTexture) Format 

func (t *GPUTexture) Format() TextureFormat

Format returns the texture format.

func (*GPUTexture) Height 

func (t *GPUTexture) Height() int

Height returns the texture height in pixels.

func (*GPUTexture) IsReleased 

func (t *GPUTexture) IsReleased() bool

IsReleased returns true if the texture has been released.

func (*GPUTexture) Label 

func (t *GPUTexture) Label() string

Label returns the debug label.

func (*GPUTexture) SetMemoryManager 

func (t *GPUTexture) SetMemoryManager(m *MemoryManager)

SetMemoryManager sets the memory manager for tracking. This is called internally when allocating through MemoryManager.

func (*GPUTexture) SizeBytes 

func (t *GPUTexture) SizeBytes() uint64

SizeBytes returns the texture size in bytes.

func (*GPUTexture) String 

func (t *GPUTexture) String() string

String returns a string representation of the texture.

func (*GPUTexture) TextureID 

func (t *GPUTexture) TextureID() core.TextureID

TextureID returns the underlying wgpu texture ID. Returns a zero ID for stub textures.

func (*GPUTexture) UploadPixmap 

func (t *GPUTexture) UploadPixmap(pixmap *gg.Pixmap) error

UploadPixmap uploads pixel data from a Pixmap to the GPU texture. The pixmap dimensions must match the texture dimensions.

Note: This is a stub implementation. The actual GPU upload will be implemented when wgpu queue.WriteTexture is available.

func (*GPUTexture) UploadRegion 

func (t *GPUTexture) UploadRegion(x, y int, pixmap *gg.Pixmap) error

UploadRegion uploads pixel data to a region of the texture. This is useful for texture atlas updates.

Note: This is a stub implementation.

func (*GPUTexture) ViewID 

func (t *GPUTexture) ViewID() core.TextureViewID

ViewID returns the texture view ID. Returns a zero ID for stub textures.

func (*GPUTexture) Width 

func (t *GPUTexture) Width() int

Width returns the texture width in pixels.

type GPUTileInfo 

type GPUTileInfo struct {
	TileX    uint32 // Tile X coordinate
	TileY    uint32 // Tile Y coordinate
	StartIdx uint32 // Start index in tile_segments
	Count    uint32 // Number of segments for this tile
	Backdrop int32  // Accumulated winding from left
	Padding1 uint32 // Padding for alignment
	Padding2 uint32 // Padding for alignment
	Padding3 uint32 // Padding for alignment
}

GPUTileInfo contains tile processing information. Must match TileInfo in fine.wgsl.

type GPUTileSegmentRef 

type GPUTileSegmentRef struct {
	TileX       uint32 // Tile X coordinate
	TileY       uint32 // Tile Y coordinate
	SegmentIdx  uint32 // Index into segments array
	WindingFlag uint32 // Whether this contributes winding (0 or 1)
}

GPUTileSegmentRef maps a segment to a tile. Must match TileSegmentRef in fine.wgsl.

type GridRasterParams 

type GridRasterParams struct {
	Color        [4]float32 // Fill color (RGBA normalized)
	TargetWidth  int32      // Target texture width
	TargetHeight int32      // Target texture height
	TileCount    int32      // Number of tiles in grid
}

GridRasterParams contains parameters for tile grid rasterization.

type HALAdapter 

type HALAdapter struct {
	// contains filtered or unexported fields
}

HALAdapter implements gpucore.GPUAdapter using gogpu/wgpu/hal directly. It provides a bridge between the gpucore abstraction and the HAL layer.

Thread Safety: HALAdapter is safe for concurrent use from multiple goroutines. All resource operations are protected by a mutex.

func NewHALAdapter 

func NewHALAdapter(device hal.Device, queue hal.Queue, limits *types.Limits) *HALAdapter

NewHALAdapter creates a new HALAdapter wrapping the given device and queue. The limits parameter provides the adapter's capability limits. If limits is nil, default limits are used.

func (*HALAdapter) BeginComputePass 

func (a *HALAdapter) BeginComputePass() gpucore.ComputePassEncoder

BeginComputePass begins a compute pass.

func (*HALAdapter) CreateBindGroup 

func (a *HALAdapter) CreateBindGroup(layout gpucore.BindGroupLayoutID, entries []gpucore.BindGroupEntry) (gpucore.BindGroupID, error)

CreateBindGroup creates a bind group.

func (*HALAdapter) CreateBindGroupLayout 

func (a *HALAdapter) CreateBindGroupLayout(desc *gpucore.BindGroupLayoutDesc) (gpucore.BindGroupLayoutID, error)

CreateBindGroupLayout creates a bind group layout.

func (*HALAdapter) CreateBuffer 

func (a *HALAdapter) CreateBuffer(size int, usage gpucore.BufferUsage) (gpucore.BufferID, error)

CreateBuffer creates a GPU buffer.

func (*HALAdapter) CreateComputePipeline 

func (a *HALAdapter) CreateComputePipeline(desc *gpucore.ComputePipelineDesc) (gpucore.ComputePipelineID, error)

CreateComputePipeline creates a compute pipeline.

func (*HALAdapter) CreatePipelineLayout 

func (a *HALAdapter) CreatePipelineLayout(layouts []gpucore.BindGroupLayoutID) (gpucore.PipelineLayoutID, error)

CreatePipelineLayout creates a pipeline layout.

func (*HALAdapter) CreateShaderModule 

func (a *HALAdapter) CreateShaderModule(spirv []uint32, label string) (gpucore.ShaderModuleID, error)

CreateShaderModule creates a shader module from SPIR-V bytecode.

func (*HALAdapter) CreateTexture 

func (a *HALAdapter) CreateTexture(width, height int, format gpucore.TextureFormat) (gpucore.TextureID, error)

CreateTexture creates a GPU texture.

func (*HALAdapter) DestroyBindGroup 

func (a *HALAdapter) DestroyBindGroup(id gpucore.BindGroupID)

DestroyBindGroup releases a bind group.

func (*HALAdapter) DestroyBindGroupLayout 

func (a *HALAdapter) DestroyBindGroupLayout(id gpucore.BindGroupLayoutID)

DestroyBindGroupLayout releases a bind group layout.

func (*HALAdapter) DestroyBuffer 

func (a *HALAdapter) DestroyBuffer(id gpucore.BufferID)

DestroyBuffer releases a GPU buffer.

func (*HALAdapter) DestroyComputePipeline 

func (a *HALAdapter) DestroyComputePipeline(id gpucore.ComputePipelineID)

DestroyComputePipeline releases a compute pipeline.

func (*HALAdapter) DestroyPipelineLayout 

func (a *HALAdapter) DestroyPipelineLayout(id gpucore.PipelineLayoutID)

DestroyPipelineLayout releases a pipeline layout.

func (*HALAdapter) DestroyShaderModule 

func (a *HALAdapter) DestroyShaderModule(id gpucore.ShaderModuleID)

DestroyShaderModule releases a shader module.

func (*HALAdapter) DestroyTexture 

func (a *HALAdapter) DestroyTexture(id gpucore.TextureID)

DestroyTexture releases a GPU texture.

func (*HALAdapter) MaxBufferSize 

func (a *HALAdapter) MaxBufferSize() uint64

MaxBufferSize returns the maximum buffer size in bytes.

func (*HALAdapter) MaxWorkgroupSize 

func (a *HALAdapter) MaxWorkgroupSize() [3]uint32

MaxWorkgroupSize returns the maximum workgroup size in each dimension.

func (*HALAdapter) ReadBuffer 

func (a *HALAdapter) ReadBuffer(id gpucore.BufferID, offset, size uint64) ([]byte, error)

ReadBuffer reads data from a buffer. This operation requires a staging buffer and GPU-CPU synchronization.

func (*HALAdapter) ReadTexture 

func (a *HALAdapter) ReadTexture(id gpucore.TextureID) ([]byte, error)

ReadTexture reads data from a texture.

func (*HALAdapter) Submit 

func (a *HALAdapter) Submit()

Submit submits recorded commands to the GPU.

func (*HALAdapter) SupportsCompute 

func (a *HALAdapter) SupportsCompute() bool

SupportsCompute returns whether compute shaders are supported.

func (*HALAdapter) WaitIdle 

func (a *HALAdapter) WaitIdle()

WaitIdle waits for all GPU operations to complete.

func (*HALAdapter) WriteBuffer 

func (a *HALAdapter) WriteBuffer(id gpucore.BufferID, offset uint64, data []byte)

WriteBuffer writes data to a buffer.

func (*HALAdapter) WriteTexture 

func (a *HALAdapter) WriteTexture(id gpucore.TextureID, data []byte)

WriteTexture writes data to a texture.

type HybridFineRasterizer 

type HybridFineRasterizer struct {
	// contains filtered or unexported fields
}

HybridFineRasterizer automatically selects between GPU and CPU rasterization based on workload size and GPU availability.

func NewHybridFineRasterizer 

func NewHybridFineRasterizer(width, height uint16, config HybridFineRasterizerConfig) *HybridFineRasterizer

NewHybridFineRasterizer creates a hybrid rasterizer that automatically selects between GPU and CPU based on workload.

func (*HybridFineRasterizer) Destroy 

func (h *HybridFineRasterizer) Destroy()

Destroy releases all resources.

func (*HybridFineRasterizer) FillRule 

func (h *HybridFineRasterizer) FillRule() scene.FillStyle

FillRule returns the current fill rule.

func (*HybridFineRasterizer) Grid 

func (h *HybridFineRasterizer) Grid() *TileGrid

Grid returns the tile grid with computed coverage.

func (*HybridFineRasterizer) IsGPUAvailable 

func (h *HybridFineRasterizer) IsGPUAvailable() bool

IsGPUAvailable returns whether GPU rasterization is available.

func (*HybridFineRasterizer) Rasterize 

func (h *HybridFineRasterizer) Rasterize(
	coarse *CoarseRasterizer,
	segments *SegmentList,
	backdrop []int32,
)

Rasterize performs fine rasterization, automatically selecting GPU or CPU.

func (*HybridFineRasterizer) Reset 

func (h *HybridFineRasterizer) Reset()

Reset clears the rasterizer state for reuse.

func (*HybridFineRasterizer) SetFillRule 

func (h *HybridFineRasterizer) SetFillRule(rule scene.FillStyle)

SetFillRule sets the fill rule for coverage calculation.

func (*HybridFineRasterizer) Stats 

func (h *HybridFineRasterizer) Stats() GPURasterizerStats

Stats returns statistics about rasterization calls. Note: Currently returns static info; could track actual call counts.

type HybridFineRasterizerConfig 

type HybridFineRasterizerConfig struct {
	// Device and Queue for GPU operations (nil to use CPU only)
	Device hal.Device
	Queue  hal.Queue

	// SegmentThreshold is the minimum segments to use GPU (0 = use default)
	SegmentThreshold int

	// ForceGPU forces GPU even for small workloads (for testing)
	ForceGPU bool

	// ForceCPU disables GPU entirely (for testing/fallback)
	ForceCPU bool
}

HybridFineRasterizerConfig configures the hybrid rasterizer.

type HybridPipeline 

type HybridPipeline struct {
	// contains filtered or unexported fields
}

HybridPipeline integrates all three GPU shaders into a unified pipeline: Flatten (path -> segments) -> Coarse (segments -> tile bins) -> Fine (tile bins -> coverage)

The pipeline automatically selects GPU or CPU for each stage based on workload size and GPU availability.

func NewHybridPipeline 

func NewHybridPipeline(width, height uint16, config HybridPipelineConfig) *HybridPipeline

NewHybridPipeline creates a new hybrid pipeline that integrates all GPU stages.

func (*HybridPipeline) Destroy 

func (p *HybridPipeline) Destroy()

Destroy releases all GPU resources.

func (*HybridPipeline) Grid 

func (p *HybridPipeline) Grid() *TileGrid

Grid returns the tile grid with computed coverage.

func (*HybridPipeline) IsGPUAvailable 

func (p *HybridPipeline) IsGPUAvailable() bool

IsGPUAvailable returns whether any GPU stage is available.

func (*HybridPipeline) IsStageGPUAvailable 

func (p *HybridPipeline) IsStageGPUAvailable(stage PipelineStage) bool

IsStageGPUAvailable returns whether a specific stage has GPU available.

func (*HybridPipeline) RasterizePath 

func (p *HybridPipeline) RasterizePath(
	path *scene.Path,
	transform scene.Affine,
	fillRule scene.FillStyle,
) *TileGrid

RasterizePath runs the full pipeline: path -> segments -> tile bins -> coverage.

Parameters:

  • path: The input path to rasterize
  • transform: Affine transformation to apply
  • fillRule: Fill rule for coverage calculation

Returns the tile grid with computed coverage.

func (*HybridPipeline) Reset 

func (p *HybridPipeline) Reset()

Reset clears all rasterizer state for reuse.

func (*HybridPipeline) ResetStats 

func (p *HybridPipeline) ResetStats()

ResetStats resets all statistics counters.

func (*HybridPipeline) SetFillRule 

func (p *HybridPipeline) SetFillRule(rule scene.FillStyle)

SetFillRule sets the fill rule for coverage calculation.

func (*HybridPipeline) SetTolerance 

func (p *HybridPipeline) SetTolerance(tolerance float32)

SetTolerance sets the flattening tolerance.

func (*HybridPipeline) Stats 

func (p *HybridPipeline) Stats() HybridPipelineStats

Stats returns statistics about pipeline execution.

type HybridPipelineConfig 

type HybridPipelineConfig struct {
	// Device and Queue for GPU operations (nil to use CPU only)
	Device hal.Device
	Queue  hal.Queue

	// Stage-specific thresholds (0 = use defaults)
	FlattenThreshold int // Min path elements for GPU flatten
	CoarseThreshold  int // Min segments for GPU coarse
	FineThreshold    int // Min tile entries for GPU fine

	// MaxPaths is the maximum path elements for flatten (0 = default 1024)
	MaxPaths int

	// MaxSegments is the maximum segments for flatten (0 = default MaxPaths * 64)
	MaxSegments int

	// Force flags for testing
	ForceGPU bool // Force GPU for all stages (ignores thresholds)
	ForceCPU bool // Force CPU for all stages (disables GPU)

	// Tolerance for curve flattening (0 = use default)
	Tolerance float32
}

HybridPipelineConfig configures the hybrid pipeline.

type HybridPipelineStats 

type HybridPipelineStats struct {
	// GPU availability per stage
	FlattenGPUAvailable bool
	CoarseGPUAvailable  bool
	FineGPUAvailable    bool

	// Call counts per stage
	FlattenTotalCalls uint64
	FlattenGPUCalls   uint64
	FlattenCPUCalls   uint64

	CoarseTotalCalls uint64
	CoarseGPUCalls   uint64
	CoarseCPUCalls   uint64

	FineTotalCalls uint64
	FineGPUCalls   uint64
	FineCPUCalls   uint64

	// Thresholds
	FlattenThreshold int
	CoarseThreshold  int
	FineThreshold    int

	// Last operation details
	LastPathElements   int
	LastSegmentCount   int
	LastTileEntryCount int
	LastFlattenUsedGPU bool
	LastCoarseUsedGPU  bool
	LastFineUsedGPU    bool
}

HybridPipelineStats contains statistics about pipeline execution.

type IndexFormat 

type IndexFormat uint32

IndexFormat specifies the format of index buffer elements. 

const (
	// IndexFormatUint16 uses 16-bit unsigned integers.
	IndexFormatUint16 IndexFormat = 0

	// IndexFormatUint32 uses 32-bit unsigned integers.
	IndexFormatUint32 IndexFormat = 1
)

type LayerDescriptor 

type LayerDescriptor struct {
	TextureIdx uint32  // Index into layer textures
	BlendMode  uint32  // Blend mode for this layer
	Alpha      float32 // Layer opacity
	Padding    float32 // Alignment padding
}

LayerDescriptor represents a single layer for compositing. This matches the Layer struct in composite.wgsl.

type LineSegment 

type LineSegment struct {
	// Start point (X0, Y0) and end point (X1, Y1).
	// For monotonic segments, Y0 <= Y1 (always going down).
	X0, Y0, X1, Y1 float32

	// Winding direction: +1 for left-to-right, -1 for right-to-left.
	// Determined by original path direction before monotonic split.
	Winding int8

	// TileY0, TileY1 are the tile row range this segment spans.
	// Precomputed for efficient coarse rasterization.
	TileY0, TileY1 int32
}

LineSegment represents a monotonic line segment for tile processing. A monotonic segment has consistent Y direction (always going down or up). This simplifies tile intersection calculations.

func NewLineSegment 

func NewLineSegment(x0, y0, x1, y1 float32, winding int8) LineSegment

NewLineSegment creates a new line segment, ensuring Y0 <= Y1. The winding is adjusted if the segment is flipped.

func (*LineSegment) Bounds 

func (s *LineSegment) Bounds() (minX, minY, maxX, maxY float32)

Bounds returns the bounding box of the segment.

func (*LineSegment) CrossesTileRow 

func (s *LineSegment) CrossesTileRow(tileY int32) bool

CrossesTileRow returns true if the segment crosses the given tile row.

func (*LineSegment) DeltaX 

func (s *LineSegment) DeltaX() float32

DeltaX returns the X distance of the segment.

func (*LineSegment) DeltaY 

func (s *LineSegment) DeltaY() float32

DeltaY returns the Y distance of the segment.

func (*LineSegment) InverseSlope 

func (s *LineSegment) InverseSlope() float32

InverseSlope returns dy/dx. Returns a large value for vertical segments.

func (*LineSegment) IsHorizontal 

func (s *LineSegment) IsHorizontal() bool

IsHorizontal returns true if the segment is approximately horizontal.

func (*LineSegment) IsVertical 

func (s *LineSegment) IsVertical() bool

IsVertical returns true if the segment is approximately vertical.

func (*LineSegment) Slope 

func (s *LineSegment) Slope() float32

Slope returns the slope (dx/dy) of the segment. Returns 0 for horizontal segments.

func (*LineSegment) TileXRange 

func (s *LineSegment) TileXRange(tileY int32) (minTileX, maxTileX int32)

TileXRange returns the range of tile columns this segment touches at a given tile row.

func (*LineSegment) XAtY 

func (s *LineSegment) XAtY(y float32) float32

XAtY returns the X coordinate at a given Y. Assumes Y is within the segment's Y range.

func (*LineSegment) YAtX 

func (s *LineSegment) YAtX(x float32) float32

YAtX returns the Y coordinate at a given X. Assumes X is within the segment's X range.

type MemoryManager 

type MemoryManager struct {
	// contains filtered or unexported fields
}

MemoryManager tracks GPU memory allocations and enforces budget limits. It provides LRU eviction when the memory budget is exceeded.

MemoryManager is safe for concurrent use.

func NewMemoryManager 

func NewMemoryManager(backend *NativeBackend, config MemoryManagerConfig) *MemoryManager

NewMemoryManager creates a new memory manager for GPU memory tracking. The backend parameter is used for texture creation operations.

func (*MemoryManager) AllocTexture 

func (m *MemoryManager) AllocTexture(config TextureConfig) (*GPUTexture, error)

AllocTexture allocates a new texture with the given configuration. If the allocation would exceed the memory budget, LRU eviction is triggered. Returns an error if the allocation cannot be satisfied even after eviction.

func (*MemoryManager) Close 

func (m *MemoryManager) Close()

Close releases all managed textures and closes the memory manager. The manager should not be used after Close is called.

func (*MemoryManager) Contains 

func (m *MemoryManager) Contains(tex *GPUTexture) bool

Contains returns true if the texture is managed by this manager.

func (*MemoryManager) FreeTexture 

func (m *MemoryManager) FreeTexture(tex *GPUTexture) error

FreeTexture releases a texture and returns its memory to the pool. The texture is closed and should not be used after this call.

func (*MemoryManager) SetBudget 

func (m *MemoryManager) SetBudget(megabytes int) error

SetBudget updates the memory budget. If the new budget is lower than current usage, eviction may be triggered.

func (*MemoryManager) Stats 

func (m *MemoryManager) Stats() MemoryStats

Stats returns current memory usage statistics.

func (*MemoryManager) Textures 

func (m *MemoryManager) Textures() []*GPUTexture

Textures returns a slice of all managed textures. The returned slice is a copy and can be safely modified.

func (*MemoryManager) TouchTexture 

func (m *MemoryManager) TouchTexture(tex *GPUTexture)

TouchTexture updates the last-used time of a texture, moving it to the front of the LRU list. Call this when a texture is used for rendering.

type MemoryManagerConfig 

type MemoryManagerConfig struct {
	// MaxMemoryMB is the maximum memory budget in megabytes.
	// Defaults to DefaultMaxMemoryMB if <= 0.
	MaxMemoryMB int

	// EvictionThreshold is the usage fraction at which eviction starts.
	// Defaults to DefaultEvictionThreshold if <= 0.
	EvictionThreshold float64
}

MemoryManagerConfig holds configuration for creating a MemoryManager.

type MemoryStats 

type MemoryStats struct {
	// TotalBytes is the total memory budget in bytes.
	TotalBytes uint64

	// UsedBytes is the currently allocated memory in bytes.
	UsedBytes uint64

	// AvailableBytes is the remaining memory budget.
	AvailableBytes uint64

	// TextureCount is the number of allocated textures.
	TextureCount int

	// EvictionCount is the total number of textures evicted.
	EvictionCount uint64

	// Utilization is the percentage of budget used (0.0 to 1.0).
	Utilization float64
}

MemoryStats contains GPU memory usage statistics.

func (MemoryStats) String 

func (s MemoryStats) String() string

String returns a human-readable string of memory stats.

type NativeBackend 

type NativeBackend struct {
	// contains filtered or unexported fields
}

NativeBackend is a GPU-accelerated rendering backend using gogpu/wgpu. It implements the backend.RenderBackend interface.

The backend manages GPU resources including instance, adapter, device, and queue. It supports both immediate mode rendering (via NewRenderer) and retained mode rendering (via RenderScene).

func NewNativeBackend 

func NewNativeBackend() *NativeBackend

NewNativeBackend creates a new Pure Go GPU rendering backend. The backend must be initialized with Init() before use.

func (*NativeBackend) Close 

func (b *NativeBackend) Close()

Close releases all backend resources. The backend should not be used after Close is called.

func (*NativeBackend) Device 

func (b *NativeBackend) Device() core.DeviceID

Device returns the GPU device ID. Returns a zero ID if the backend is not initialized.

func (*NativeBackend) GPUInfo 

func (b *NativeBackend) GPUInfo() *GPUInfo

GPUInfo returns information about the selected GPU. Returns nil if the backend is not initialized.

func (*NativeBackend) Init 

func (b *NativeBackend) Init() error

Init initializes the backend by creating GPU resources. This includes creating an instance, requesting an adapter, creating a device, and getting the command queue.

Returns an error if GPU initialization fails.

func (*NativeBackend) IsInitialized 

func (b *NativeBackend) IsInitialized() bool

IsInitialized returns true if the backend has been initialized.

func (*NativeBackend) Name 

func (b *NativeBackend) Name() string

Name returns the backend identifier.

func (*NativeBackend) NewRenderer 

func (b *NativeBackend) NewRenderer(width, height int) gg.Renderer

NewRenderer creates a renderer for immediate mode rendering. The renderer is sized for the given dimensions.

Note: This is a stub implementation that returns a GPURenderer. The actual GPU rendering will be implemented in TASK-110.

func (*NativeBackend) Queue 

func (b *NativeBackend) Queue() core.QueueID

Queue returns the GPU queue ID. Returns a zero ID if the backend is not initialized.

func (*NativeBackend) RenderScene 

func (b *NativeBackend) RenderScene(target *gg.Pixmap, s *scene.Scene) error

RenderScene renders a scene to the target pixmap using retained mode. This method is optimized for complex scenes with many draw operations.

The implementation uses GPUSceneRenderer for tessellation, strip rasterization, and layer compositing on the GPU. When wgpu texture readback is fully implemented, results will be downloaded to the target pixmap. Currently, data flows through the GPU pipeline as stubs.

type PipelineCache 

type PipelineCache struct {
	// contains filtered or unexported fields
}

PipelineCache caches compiled GPU pipelines for rendering operations. It manages bind group layouts and pipelines for blit, blend, strip rasterization, and compositing operations.

PipelineCache is safe for concurrent read access. Pipeline creation is synchronized internally.

func NewPipelineCache 

func NewPipelineCache(device core.DeviceID, shaders *ShaderModules) (*PipelineCache, error)

NewPipelineCache creates a new pipeline cache for the given device. It initializes all base pipelines using the provided shader modules.

Returns an error if pipeline creation fails.

func (*PipelineCache) BlendPipelineCount 

func (pc *PipelineCache) BlendPipelineCount() int

BlendPipelineCount returns the number of cached blend pipelines. Useful for debugging and monitoring.

func (*PipelineCache) Close 

func (pc *PipelineCache) Close()

Close releases all pipeline resources.

func (*PipelineCache) CreateBlendBindGroup 

func (pc *PipelineCache) CreateBlendBindGroup(tex *GPUTexture, params *BlendParams) StubBindGroupID

CreateBlendBindGroup creates a bind group for blend operations.

func (*PipelineCache) CreateBlitBindGroup 

func (pc *PipelineCache) CreateBlitBindGroup(tex *GPUTexture) StubBindGroupID

CreateBlitBindGroup creates a bind group for blit operations.

func (*PipelineCache) CreateStripBindGroup 

func (pc *PipelineCache) CreateStripBindGroup(
	headerBuffer StubBufferID,
	coverageBuffer StubBufferID,
	outputTex *GPUTexture,
	params *StripParams,
) StubBindGroupID

CreateStripBindGroup creates a bind group for strip compute operations.

func (*PipelineCache) GetBlendLayout 

func (pc *PipelineCache) GetBlendLayout() StubBindGroupLayoutID

GetBlendLayout returns the bind group layout for blend operations.

func (*PipelineCache) GetBlendPipeline 

func (pc *PipelineCache) GetBlendPipeline(mode scene.BlendMode) StubPipelineID

GetBlendPipeline returns the pipeline for the specified blend mode. Pipelines are created on demand and cached.

func (*PipelineCache) GetBlitLayout 

func (pc *PipelineCache) GetBlitLayout() StubBindGroupLayoutID

GetBlitLayout returns the bind group layout for blit operations.

func (*PipelineCache) GetBlitPipeline 

func (pc *PipelineCache) GetBlitPipeline() StubPipelineID

GetBlitPipeline returns the blit pipeline.

func (*PipelineCache) GetCompositePipeline 

func (pc *PipelineCache) GetCompositePipeline() StubPipelineID

GetCompositePipeline returns the compositing pipeline.

func (*PipelineCache) GetStripLayout 

func (pc *PipelineCache) GetStripLayout() StubBindGroupLayoutID

GetStripLayout returns the bind group layout for strip compute.

func (*PipelineCache) GetStripPipeline 

func (pc *PipelineCache) GetStripPipeline() StubComputePipelineID

GetStripPipeline returns the strip rasterization compute pipeline.

func (*PipelineCache) IsInitialized 

func (pc *PipelineCache) IsInitialized() bool

IsInitialized returns true if the cache has been initialized.

func (*PipelineCache) WarmupBlendPipelines 

func (pc *PipelineCache) WarmupBlendPipelines()

WarmupBlendPipelines pre-creates pipelines for commonly used blend modes. This avoids pipeline compilation stutter during first use.

type PipelineStage 

type PipelineStage uint8

PipelineStage represents which stage of the pipeline is being executed. 

const (
	// StageFlatten is the path flattening stage (path -> segments).
	StageFlatten PipelineStage = iota
	// StageCoarse is the coarse rasterization stage (segments -> tile bins).
	StageCoarse
	// StageFine is the fine rasterization stage (tile bins -> coverage).
	StageFine
)

func (PipelineStage) String 

func (s PipelineStage) String() string

String returns a human-readable name for the pipeline stage.

type QueueSubmitter 

type QueueSubmitter struct {
	// contains filtered or unexported fields
}

QueueSubmitter submits command buffers to a GPU queue.

func NewQueueSubmitter 

func NewQueueSubmitter(queue core.QueueID) *QueueSubmitter

NewQueueSubmitter creates a new queue submitter.

func (*QueueSubmitter) Submit 

func (s *QueueSubmitter) Submit(buffers ...*CommandBuffer)

Submit submits command buffers to the queue.

func (*QueueSubmitter) WriteBuffer 

func (s *QueueSubmitter) WriteBuffer(buffer StubBufferID, offset uint64, data []byte)

WriteBuffer writes data to a GPU buffer.

func (*QueueSubmitter) WriteTexture 

func (s *QueueSubmitter) WriteTexture(texture *GPUTexture, data []byte)

WriteTexture writes data to a GPU texture.

type RectAllocator 

type RectAllocator struct {
	// contains filtered or unexported fields
}

RectAllocator implements a simple shelf-packing algorithm for allocating rectangular regions within a fixed-size area.

The shelf-packing algorithm works by dividing the atlas into horizontal "shelves". Each new rectangle is placed on the current shelf if it fits, or a new shelf is created below.

func NewRectAllocator 

func NewRectAllocator(width, height, padding int) *RectAllocator

NewRectAllocator creates a new rectangular region allocator.

func (*RectAllocator) AllocCount 

func (a *RectAllocator) AllocCount() int

AllocCount returns the number of successful allocations.

func (*RectAllocator) Allocate 

func (a *RectAllocator) Allocate(width, height int) AtlasRegion

Allocate finds space for a rectangle of the given size. Returns an invalid region if the rectangle cannot be allocated.

func (*RectAllocator) Reset 

func (a *RectAllocator) Reset()

Reset clears all allocations, making the entire area available again.

func (*RectAllocator) UsedArea 

func (a *RectAllocator) UsedArea() int

UsedArea returns the total area of allocated rectangles.

func (*RectAllocator) Utilization 

func (a *RectAllocator) Utilization() float64

Utilization returns the fraction of area used (0.0 to 1.0).

type RenderCommandBuilder 

type RenderCommandBuilder struct {
	// contains filtered or unexported fields
}

RenderCommandBuilder provides a fluent API for building render commands.

func NewRenderCommandBuilder 

func NewRenderCommandBuilder(device core.DeviceID, target *GPUTexture, clearTarget bool) *RenderCommandBuilder

NewRenderCommandBuilder creates a new render command builder.

func (*RenderCommandBuilder) Draw 

func (b *RenderCommandBuilder) Draw(vertexCount, instanceCount uint32) *RenderCommandBuilder

Draw issues a draw call.

func (*RenderCommandBuilder) DrawFullScreen 

func (b *RenderCommandBuilder) DrawFullScreen() *RenderCommandBuilder

DrawFullScreen draws a full-screen triangle.

func (*RenderCommandBuilder) Finish 

func (b *RenderCommandBuilder) Finish() StubCommandBufferID

Finish ends the pass and returns the command buffer.

func (*RenderCommandBuilder) SetBindGroup 

func (b *RenderCommandBuilder) SetBindGroup(index uint32, bindGroup StubBindGroupID) *RenderCommandBuilder

SetBindGroup sets a bind group.

func (*RenderCommandBuilder) SetPipeline 

func (b *RenderCommandBuilder) SetPipeline(pipeline StubPipelineID) *RenderCommandBuilder

SetPipeline sets the render pipeline.

type RenderPass 

type RenderPass struct {
	// contains filtered or unexported fields
}

RenderPass represents an active render pass for draw commands. Draw commands can only be issued while a render pass is active.

func (*RenderPass) Draw 

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

Draw issues a non-indexed draw call. vertexCount: number of vertices to draw instanceCount: number of instances to draw firstVertex: offset into the vertex buffer firstInstance: instance ID offset

func (*RenderPass) DrawFullScreenTriangle 

func (p *RenderPass) DrawFullScreenTriangle()

DrawFullScreenTriangle is a convenience method for drawing a full-screen triangle. This is commonly used for post-processing effects and texture blits. Uses 3 vertices with no instance or offset.

func (*RenderPass) DrawIndexed 

func (p *RenderPass) DrawIndexed(indexCount, instanceCount, firstIndex uint32, baseVertex int32, firstInstance uint32)

DrawIndexed issues an indexed draw call.

func (*RenderPass) End 

func (p *RenderPass) End()

End finishes the render pass. No more draw calls can be issued after this.

func (*RenderPass) SetBindGroup 

func (p *RenderPass) SetBindGroup(index uint32, bindGroup StubBindGroupID)

SetBindGroup sets a bind group at the specified index.

func (*RenderPass) SetIndexBuffer 

func (p *RenderPass) SetIndexBuffer(buffer StubBufferID, format IndexFormat)

SetIndexBuffer sets the index buffer for indexed drawing.

func (*RenderPass) SetPipeline 

func (p *RenderPass) SetPipeline(pipeline StubPipelineID)

SetPipeline sets the render pipeline for subsequent draw calls.

func (*RenderPass) SetVertexBuffer 

func (p *RenderPass) SetVertexBuffer(slot uint32, buffer StubBufferID)

SetVertexBuffer sets a vertex buffer at the specified slot.

func (*RenderPass) Target 

func (p *RenderPass) Target() *GPUTexture

Target returns the render target texture.

type SegmentList 

type SegmentList struct {
	// contains filtered or unexported fields
}

SegmentList is a collection of line segments.

func FlattenPath 

func FlattenPath(path *scene.Path, transform scene.Affine, tolerance float32) *SegmentList

FlattenPath flattens a path to monotonic line segments. It converts Bezier curves to line segments and ensures all segments are monotonic in Y (Y0 <= Y1).

Parameters:

  • path: The input path to flatten
  • transform: Affine transformation to apply to all points
  • tolerance: Flattening tolerance (use FlattenTolerance for default)

Returns a SegmentList containing all flattened line segments.

func NewSegmentList 

func NewSegmentList() *SegmentList

NewSegmentList creates a new empty segment list.

func (*SegmentList) Add 

func (sl *SegmentList) Add(seg LineSegment)

Add adds a segment to the list.

func (*SegmentList) AddLine 

func (sl *SegmentList) AddLine(x0, y0, x1, y1 float32, winding int8)

AddLine adds a line segment from (x0,y0) to (x1,y1).

func (*SegmentList) Bounds 

func (sl *SegmentList) Bounds() (minX, minY, maxX, maxY float32)

Bounds returns the bounding box of all segments.

func (*SegmentList) Len 

func (sl *SegmentList) Len() int

Len returns the number of segments.

func (*SegmentList) Reset 

func (sl *SegmentList) Reset()

Reset clears the list for reuse.

func (*SegmentList) Segments 

func (sl *SegmentList) Segments() []LineSegment

Segments returns the slice of segments.

func (*SegmentList) SegmentsInTileRow 

func (sl *SegmentList) SegmentsInTileRow(tileY int32) []LineSegment

SegmentsInTileRow returns segments that cross a given tile row. The list should be sorted by TileY0 for efficient access.

func (*SegmentList) SortByTileY 

func (sl *SegmentList) SortByTileY()

SortByTileY sorts segments by their starting tile Y coordinate. This enables efficient row-by-row processing.

func (*SegmentList) TileYRange 

func (sl *SegmentList) TileYRange() (minTileY, maxTileY int32)

TileYRange returns the range of tile rows that segments span.

type ShaderModuleID 

type ShaderModuleID uint64

ShaderModuleID represents a compiled shader module handle. This is a placeholder type that will be replaced with the actual wgpu core.ShaderModuleID once shader compilation is implemented. 

const InvalidShaderModule ShaderModuleID = 0

InvalidShaderModule represents an invalid/uninitialized shader module.

type ShaderModules 

type ShaderModules struct {
	// Blit is the simple texture copy shader
	Blit ShaderModuleID

	// Blend is the 29-mode blend shader
	Blend ShaderModuleID

	// Strip is the strip rasterization compute shader
	Strip ShaderModuleID

	// Composite is the final layer compositing shader
	Composite ShaderModuleID
}

ShaderModules holds compiled shader modules for all rendering operations.

func CompileShaders 

func CompileShaders(deviceID uint64) (*ShaderModules, error)

CompileShaders compiles all WGSL shaders and returns the shader modules. This function currently returns stub module IDs since gogpu/wgpu shader compilation is not yet fully implemented. The WGSL sources are validated for correct syntax.

Parameters:

  • deviceID: The GPU device ID to use for compilation (currently unused)

Returns:

  • *ShaderModules: Compiled shader module handles
  • error: Compilation error if shader sources are invalid

func (*ShaderModules) IsValid 

func (s *ShaderModules) IsValid() bool

IsValid returns true if all shader modules are initialized.

type SparseStrip 

type SparseStrip struct {
	X        uint16 // X coordinate in pixels
	Y        uint16 // Y coordinate in pixels
	AlphaIdx uint32 // Index into alpha buffer
	FillGap  bool   // Whether to fill gap before this strip
}

SparseStrip represents a sparse strip for efficient rendering. A strip is a horizontal run of tiles with the same Y coordinate. This is different from the legacy Strip type in strips.go.

type SparseStripsConfig 

type SparseStripsConfig struct {
	Width     uint16
	Height    uint16
	FillRule  scene.FillStyle
	Tolerance float32 // Flattening tolerance (0 uses default)
}

SparseStripsConfig configures the sparse strips rasterizer.

func DefaultConfig 

func DefaultConfig(width, height uint16) SparseStripsConfig

DefaultConfig returns a default configuration.

type SparseStripsPool 

type SparseStripsPool struct {
	// contains filtered or unexported fields
}

SparseStripsPool manages pooled rasterizers for reuse.

func NewSparseStripsPool 

func NewSparseStripsPool() *SparseStripsPool

NewSparseStripsPool creates a new pool.

func (*SparseStripsPool) Get 

func (p *SparseStripsPool) Get(config SparseStripsConfig) *SparseStripsRasterizer

Get retrieves a rasterizer from the pool or creates a new one.

func (*SparseStripsPool) Put 

func (p *SparseStripsPool) Put(ssr *SparseStripsRasterizer)

Put returns a rasterizer to the pool.

type SparseStripsRasterizer 

type SparseStripsRasterizer struct {
	// contains filtered or unexported fields
}

SparseStripsRasterizer is the main entry point for vello-style sparse strips rendering. It orchestrates the complete pipeline: flatten -> coarse -> fine -> render.

The sparse strips algorithm works by: 1. Flattening Bezier curves to monotonic line segments 2. Coarse rasterization: binning segments into tiles they intersect 3. Fine rasterization: calculating analytic anti-aliased coverage per pixel 4. Rendering: outputting coverage as strips for efficient GPU rendering

func NewSparseStripsRasterizer 

func NewSparseStripsRasterizer(config SparseStripsConfig) *SparseStripsRasterizer

NewSparseStripsRasterizer creates a new sparse strips rasterizer.

func (*SparseStripsRasterizer) FillRule 

func (ssr *SparseStripsRasterizer) FillRule() scene.FillStyle

FillRule returns the current fill rule.

func (*SparseStripsRasterizer) GetStats 

func (ssr *SparseStripsRasterizer) GetStats() Stats

GetStats returns statistics about the current rasterization state.

func (*SparseStripsRasterizer) Grid 

func (ssr *SparseStripsRasterizer) Grid() *TileGrid

Grid returns the tile grid with computed coverage.

func (*SparseStripsRasterizer) Height 

func (ssr *SparseStripsRasterizer) Height() uint16

Height returns the viewport height.

func (*SparseStripsRasterizer) RasterizePath 

func (ssr *SparseStripsRasterizer) RasterizePath(
	path *scene.Path,
	transform scene.Affine,
	tolerance float32,
)

RasterizePath rasterizes a single path to the tile grid.

func (*SparseStripsRasterizer) RasterizeToStrips 

func (ssr *SparseStripsRasterizer) RasterizeToStrips(
	path *scene.Path,
	transform scene.Affine,
	tolerance float32,
)

RasterizeToStrips rasterizes a path and generates sparse strips.

func (*SparseStripsRasterizer) RenderStripsToBuffer 

func (ssr *SparseStripsRasterizer) RenderStripsToBuffer(
	buffer []uint8,
	stride int,
	color [4]uint8,
)

RenderStripsToBuffer renders strips to a pixel buffer.

func (*SparseStripsRasterizer) RenderToBuffer 

func (ssr *SparseStripsRasterizer) RenderToBuffer(
	buffer []uint8,
	stride int,
	color [4]uint8,
)

RenderToBuffer renders the rasterized coverage to a pixel buffer.

func (*SparseStripsRasterizer) Reset 

func (ssr *SparseStripsRasterizer) Reset()

Reset clears the rasterizer state for reuse with new geometry.

func (*SparseStripsRasterizer) Segments 

func (ssr *SparseStripsRasterizer) Segments() *SegmentList

Segments returns the flattened segments.

func (*SparseStripsRasterizer) SetFillRule 

func (ssr *SparseStripsRasterizer) SetFillRule(rule scene.FillStyle)

SetFillRule sets the fill rule for rendering.

func (*SparseStripsRasterizer) SetSize 

func (ssr *SparseStripsRasterizer) SetSize(width, height uint16)

SetSize changes the rasterizer viewport dimensions.

func (*SparseStripsRasterizer) Strips 

func (ssr *SparseStripsRasterizer) Strips() *StripRenderer

Strips returns the strip renderer with generated strips.

func (*SparseStripsRasterizer) Width 

func (ssr *SparseStripsRasterizer) Width() uint16

Width returns the viewport width.

type Stats 

type Stats struct {
	SegmentCount    int
	TileEntryCount  int
	ActiveTileCount int
	StripCount      int
	AlphaByteCount  int
}

Stats contains statistics about the rasterization process.

type StripParams 

type StripParams struct {
	Color        [4]float32 // Fill color (premultiplied RGBA)
	TargetWidth  int32      // Output texture width
	TargetHeight int32      // Output texture height
	StripCount   int32      // Number of strips to process
	Padding      int32      // Alignment padding
}

StripParams represents the uniform buffer structure for strip shaders. This matches the StripParams struct in strip.wgsl.

type StripRenderer 

type StripRenderer struct {
	// contains filtered or unexported fields
}

StripRenderer renders tiles as sparse strips.

func NewStripRenderer 

func NewStripRenderer() *StripRenderer

NewStripRenderer creates a new strip renderer.

func (*StripRenderer) Alphas 

func (sr *StripRenderer) Alphas() []uint8

Alphas returns the alpha buffer.

func (*StripRenderer) RenderTiles 

func (sr *StripRenderer) RenderTiles(
	coarse *CoarseRasterizer,
	segments *SegmentList,
	backdrop []int32,
)

RenderTiles converts tiles to strips for efficient rendering.

func (*StripRenderer) Reset 

func (sr *StripRenderer) Reset()

Reset clears the renderer state for reuse.

func (*StripRenderer) SetAliasMode 

func (sr *StripRenderer) SetAliasMode(enabled bool)

SetAliasMode enables or disables aliased (non-anti-aliased) rendering.

func (*StripRenderer) SetFillRule 

func (sr *StripRenderer) SetFillRule(rule scene.FillStyle)

SetFillRule sets the fill rule.

func (*StripRenderer) Strips 

func (sr *StripRenderer) Strips() []SparseStrip

Strips returns the strips.

type StubBindGroupID 

type StubBindGroupID uint64

StubBindGroupID is a placeholder for actual wgpu BindGroupID.

type StubBindGroupLayoutID 

type StubBindGroupLayoutID uint64

StubBindGroupLayoutID is a placeholder for actual wgpu BindGroupLayoutID.

type StubBufferID 

type StubBufferID uint64

StubBufferID is a placeholder for actual wgpu BufferID.

type StubCommandBufferID 

type StubCommandBufferID uint64

StubCommandBufferID is a placeholder for actual wgpu CommandBufferID.

type StubCommandEncoderID 

type StubCommandEncoderID uint64

StubCommandEncoderID is a placeholder for actual wgpu CommandEncoderID.

type StubComputePassID 

type StubComputePassID uint64

StubComputePassID is a placeholder for actual wgpu ComputePassID.

type StubComputePipelineID 

type StubComputePipelineID uint64

StubComputePipelineID is a placeholder for actual wgpu ComputePipelineID.

type StubPipelineID 

type StubPipelineID uint64

StubPipelineID is a placeholder for actual wgpu RenderPipelineID. This will be replaced with core.RenderPipelineID when wgpu support is complete. 

const InvalidPipelineID StubPipelineID = 0

InvalidPipelineID represents an invalid/uninitialized pipeline.

type StubRenderPassID 

type StubRenderPassID uint64

StubRenderPassID is a placeholder for actual wgpu RenderPassID.

type StubSamplerID 

type StubSamplerID uint64

StubSamplerID is a placeholder for actual wgpu SamplerID.

type TextBatch 

type TextBatch struct {
	Quads     []TextQuad
	Color     gg.RGBA
	Transform gg.Matrix
}

TextBatch represents a batch of text quads with shared rendering parameters.

type TextPipeline 

type TextPipeline struct {
	// contains filtered or unexported fields
}

TextPipeline handles GPU-accelerated MSDF text rendering. It manages the render pipeline, bind groups, and vertex buffers for rendering text using multi-channel signed distance fields.

TextPipeline is safe for concurrent use after initialization.

func NewTextPipeline 

func NewTextPipeline(device core.DeviceID, config TextPipelineConfig) (*TextPipeline, error)

NewTextPipeline creates a new text rendering pipeline. The pipeline must be initialized before use.

func NewTextPipelineDefault 

func NewTextPipelineDefault(device core.DeviceID) (*TextPipeline, error)

NewTextPipelineDefault creates a text pipeline with default configuration.

func (*TextPipeline) Close 

func (p *TextPipeline) Close()

Close releases all pipeline resources.

func (*TextPipeline) Config 

func (p *TextPipeline) Config() TextPipelineConfig

Config returns the pipeline configuration.

func (*TextPipeline) GetOrCreateAtlasBindGroup 

func (p *TextPipeline) GetOrCreateAtlasBindGroup(atlasIndex int, atlasTexture *GPUTexture) (StubBindGroupID, error)

GetOrCreateAtlasBindGroup gets or creates a bind group for an atlas texture.

func (*TextPipeline) Init 

func (p *TextPipeline) Init() error

Init initializes the text pipeline, compiling shaders and creating GPU resources.

func (*TextPipeline) InvalidateAllAtlasBindGroups 

func (p *TextPipeline) InvalidateAllAtlasBindGroups()

InvalidateAllAtlasBindGroups removes all cached bind groups.

func (*TextPipeline) InvalidateAtlasBindGroup 

func (p *TextPipeline) InvalidateAtlasBindGroup(atlasIndex int)

InvalidateAtlasBindGroup removes a cached bind group for an atlas. Call this when an atlas texture is updated.

func (*TextPipeline) IsInitialized 

func (p *TextPipeline) IsInitialized() bool

IsInitialized returns true if the pipeline has been initialized.

func (*TextPipeline) RenderText 

func (p *TextPipeline) RenderText(
	pass *RenderPass,
	quads []TextQuad,
	atlasIndex int,
	color gg.RGBA,
	transform gg.Matrix,
) error

RenderText renders text quads using the specified atlas. All quads are rendered in a single draw call for efficiency.

Parameters:

  • pass: The render pass to record commands into
  • quads: Text quads to render (position and UV for each glyph)
  • atlasIndex: Index of the MSDF atlas texture to use
  • color: Text color (RGBA, will be premultiplied)
  • transform: 2D affine transform matrix (gg.Matrix)

Note: This is a stub implementation that validates inputs and prepares vertex data. Actual GPU rendering will be implemented when wgpu is ready.

func (*TextPipeline) RenderTextBatch 

func (p *TextPipeline) RenderTextBatch(
	pass *RenderPass,
	batches []TextBatch,
	atlasIndex int,
) error

RenderTextBatch renders multiple text batches efficiently. Each batch can have different color and transform but shares the same atlas.

type TextPipelineConfig 

type TextPipelineConfig struct {
	// InitialQuadCapacity is the initial vertex buffer capacity in quads.
	// Default: 256
	InitialQuadCapacity int

	// MaxQuadCapacity is the maximum number of quads per draw call.
	// Default: 16384
	MaxQuadCapacity int

	// DefaultPxRange is the default MSDF pixel range.
	// Default: 4.0
	DefaultPxRange float32
}

TextPipelineConfig holds configuration for the text pipeline.

func DefaultTextPipelineConfig 

func DefaultTextPipelineConfig() TextPipelineConfig

DefaultTextPipelineConfig returns default configuration.

type TextQuad 

type TextQuad struct {
	// Position of quad corners in screen/clip space
	X0, Y0, X1, Y1 float32

	// UV coordinates in MSDF atlas [0, 1]
	U0, V0, U1, V1 float32
}

TextQuad represents a single glyph quad for rendering. Each glyph is rendered as a textured quad with position and UV coordinates.

type TextRenderer 

type TextRenderer struct {
	// contains filtered or unexported fields
}

TextRenderer provides a higher-level API for rendering text. It combines TextPipeline with AtlasManager for convenient text rendering.

func NewTextRenderer 

func NewTextRenderer(backend *NativeBackend, config TextRendererConfig) (*TextRenderer, error)

NewTextRenderer creates a new text renderer.

func (*TextRenderer) AtlasManager 

func (r *TextRenderer) AtlasManager() *msdf.AtlasManager

AtlasManager returns the underlying atlas manager.

func (*TextRenderer) Close 

func (r *TextRenderer) Close()

Close releases all renderer resources.

func (*TextRenderer) Init 

func (r *TextRenderer) Init() error

Init initializes the text renderer.

func (*TextRenderer) Pipeline 

func (r *TextRenderer) Pipeline() *TextPipeline

Pipeline returns the underlying text pipeline.

func (*TextRenderer) SyncAtlases 

func (r *TextRenderer) SyncAtlases() error

SyncAtlases uploads dirty atlases to GPU.

type TextRendererConfig 

type TextRendererConfig struct {
	// PipelineConfig for the underlying text pipeline.
	PipelineConfig TextPipelineConfig

	// AtlasConfig for the MSDF atlas manager.
	AtlasConfig msdf.AtlasConfig
}

TextRendererConfig holds configuration for TextRenderer.

func DefaultTextRendererConfig 

func DefaultTextRendererConfig() TextRendererConfig

DefaultTextRendererConfig returns default configuration.

type TextUniforms 

type TextUniforms struct {
	// Transform matrix (4x4 for alignment, row-major)
	// Maps local coordinates to clip space [-1, 1]
	Transform [16]float32

	// Text color (RGBA, premultiplied alpha)
	Color [4]float32

	// MSDF parameters:
	// [0]: px_range (distance range in pixels)
	// [1]: atlas_size (texture size)
	// [2]: outline_width (for outline effect)
	// [3]: reserved
	MSDFParams [4]float32
}

TextUniforms represents the uniform buffer for text shaders. Matches the TextUniforms struct in msdf_text.wgsl.

type TextVertex 

type TextVertex struct {
	// Position in local/screen space
	X, Y float32

	// UV coordinates in atlas
	U, V float32
}

TextVertex represents a single vertex for text rendering. Matches the VertexInput struct in msdf_text.wgsl.

type TextureAtlas 

type TextureAtlas struct {
	// contains filtered or unexported fields
}

TextureAtlas manages a texture atlas for efficient batching of small images. It combines multiple small textures into a single large GPU texture to reduce draw calls and texture binding changes.

TextureAtlas is safe for concurrent use.

func NewTextureAtlas 

func NewTextureAtlas(backend *NativeBackend, config TextureAtlasConfig) (*TextureAtlas, error)

NewTextureAtlas creates a new texture atlas with the given configuration.

func (*TextureAtlas) AllocCount 

func (a *TextureAtlas) AllocCount() int

AllocCount returns the number of allocated regions.

func (*TextureAtlas) Allocate 

func (a *TextureAtlas) Allocate(width, height int) (AtlasRegion, error)

Allocate finds space for a rectangle of the given size. Returns an invalid region (Width/Height == 0) if the atlas is full.

func (*TextureAtlas) AllocateAndUpload 

func (a *TextureAtlas) AllocateAndUpload(pixmap *gg.Pixmap) (AtlasRegion, error)

AllocateAndUpload combines Allocate and Upload into a single operation. This is a convenience method for adding new images to the atlas.

func (*TextureAtlas) Close 

func (a *TextureAtlas) Close()

Close releases the atlas resources. The atlas should not be used after Close is called.

func (*TextureAtlas) Height 

func (a *TextureAtlas) Height() int

Height returns the atlas height in pixels.

func (*TextureAtlas) IsClosed 

func (a *TextureAtlas) IsClosed() bool

IsClosed returns true if the atlas has been closed.

func (*TextureAtlas) Reset 

func (a *TextureAtlas) Reset()

Reset clears all allocations, making the entire atlas available again. Note: This does not clear the texture data, just the allocation tracking.

func (*TextureAtlas) Texture 

func (a *TextureAtlas) Texture() *GPUTexture

Texture returns the underlying GPU texture.

func (*TextureAtlas) Upload 

func (a *TextureAtlas) Upload(region AtlasRegion, pixmap *gg.Pixmap) error

Upload copies pixel data from a pixmap to a region of the atlas. The pixmap dimensions must match the region dimensions.

func (*TextureAtlas) Utilization 

func (a *TextureAtlas) Utilization() float64

Utilization returns the fraction of atlas area used (0.0 to 1.0).

func (*TextureAtlas) Width 

func (a *TextureAtlas) Width() int

Width returns the atlas width in pixels.

type TextureAtlasConfig 

type TextureAtlasConfig struct {
	// Width is the atlas width in pixels. Defaults to DefaultAtlasSize.
	Width int

	// Height is the atlas height in pixels. Defaults to DefaultAtlasSize.
	Height int

	// Padding is the spacing between regions. Defaults to DefaultShelfPadding.
	Padding int

	// Label is an optional debug label.
	Label string
}

TextureAtlasConfig holds configuration for creating a TextureAtlas.

type TextureConfig 

type TextureConfig struct {
	// Width is the texture width in pixels.
	Width int

	// Height is the texture height in pixels.
	Height int

	// Format is the pixel format.
	Format TextureFormat

	// Label is an optional debug label.
	Label string

	// Usage flags (default: CopySrc | CopyDst | TextureBinding)
	Usage types.TextureUsage
}

TextureConfig holds configuration for creating a new texture.

type TextureFormat 

type TextureFormat uint8

TextureFormat represents the pixel format of a GPU texture. 

const (
	// TextureFormatRGBA8 is the standard RGBA format with 8 bits per channel.
	TextureFormatRGBA8 TextureFormat = iota

	// TextureFormatBGRA8 is BGRA format, often used for surface presentation.
	TextureFormatBGRA8

	// TextureFormatR8 is single-channel 8-bit format, used for masks.
	TextureFormatR8
)

func (TextureFormat) BytesPerPixel 

func (f TextureFormat) BytesPerPixel() int

BytesPerPixel returns the number of bytes per pixel for the format.

func (TextureFormat) String 

func (f TextureFormat) String() string

String returns a human-readable name for the format.

func (TextureFormat) ToWGPUFormat 

func (f TextureFormat) ToWGPUFormat() types.TextureFormat

ToWGPUFormat converts to wgpu types.TextureFormat. This will be used when actual GPU texture creation is implemented.

type Tile 

type Tile struct {
	// X, Y are tile coordinates (not pixel coordinates).
	// Pixel coordinates are (X * TileSize, Y * TileSize).
	X, Y int32

	// Coverage holds 4×4 = 16 anti-aliased coverage values (0-255).
	// Index = row * TileSize + col
	Coverage [TileSize * TileSize]uint8

	// Backdrop is the winding number entering this tile from the left.
	// Used for propagating fill state across tile boundaries.
	Backdrop int16

	// SegmentCount tracks how many segments cross this tile.
	// Used for optimization: tiles with 0 segments use backdrop only.
	SegmentCount int16
}

Tile represents a 4×4 pixel tile with coverage data. This is the core unit of the sparse strips algorithm.

The coverage array stores anti-aliased alpha values for each pixel in row-major order: [row0: 0-3, row1: 4-7, row2: 8-11, row3: 12-15]

func (*Tile) FillSolid 

func (t *Tile) FillSolid(value uint8)

FillSolid fills the entire tile with a single coverage value.

func (*Tile) GetCoverage 

func (t *Tile) GetCoverage(px, py int) uint8

GetCoverage returns the coverage value for a pixel within the tile.

func (*Tile) IsEmpty 

func (t *Tile) IsEmpty() bool

IsEmpty returns true if all coverage values are zero.

func (*Tile) IsSolid 

func (t *Tile) IsSolid() bool

IsSolid returns true if all coverage values are 255 (fully opaque).

func (*Tile) PixelX 

func (t *Tile) PixelX() int32

PixelX returns the pixel X coordinate of the tile's top-left corner.

func (*Tile) PixelY 

func (t *Tile) PixelY() int32

PixelY returns the pixel Y coordinate of the tile's top-left corner.

func (*Tile) Reset 

func (t *Tile) Reset()

Reset clears the tile for reuse.

func (*Tile) SetCoverage 

func (t *Tile) SetCoverage(px, py int, value uint8)

SetCoverage sets the coverage value for a pixel within the tile. px, py are pixel offsets within the tile (0-3).

type TileCoord 

type TileCoord struct {
	X, Y int32
}

TileCoord represents tile coordinates for hashing.

func (TileCoord) Key 

func (tc TileCoord) Key() uint64

Key returns a unique key for the tile coordinate.

type TileCoverage16 

type TileCoverage16 [16]uint8

TileCoverage16 holds coverage values for a 4×4 tile.

func ProcessMultipleSegmentsSIMD 

func ProcessMultipleSegmentsSIMD(
	lines []LineSegment,
	lineIndices []uint32,
	tileX, tileY uint16,
	backdrop float32,
	fillRule scene.FillStyle,
) TileCoverage16

ProcessMultipleSegmentsSIMD processes multiple segments for a single tile. This batches segment processing to maximize SIMD utilization.

type TileGrid 

type TileGrid struct {
	// contains filtered or unexported fields
}

TileGrid is a sparse collection of non-empty tiles. It uses a hashmap for O(1) tile lookup by coordinates.

func NewTileGrid 

func NewTileGrid() *TileGrid

NewTileGrid creates a new empty tile grid.

func RasterizePath 

func RasterizePath(
	path *scene.Path,
	transform scene.Affine,
	width, height uint16,
	fillRule scene.FillStyle,
) *TileGrid

RasterizePath is a convenience function that rasterizes a path using a pooled rasterizer.

func (*TileGrid) Bounds 

func (g *TileGrid) Bounds() (minX, minY, maxX, maxY int32)

Bounds returns the bounding rectangle in tile coordinates.

func (*TileGrid) FillRule 

func (g *TileGrid) FillRule() scene.FillStyle

FillRule returns the current fill rule.

func (*TileGrid) ForEach 

func (g *TileGrid) ForEach(fn func(*Tile))

ForEach iterates over all tiles in unspecified order.

func (*TileGrid) ForEachInRow 

func (g *TileGrid) ForEachInRow(y int32, fn func(*Tile))

ForEachInRow iterates over tiles in a specific row, sorted by X.

func (*TileGrid) ForEachSorted 

func (g *TileGrid) ForEachSorted(fn func(*Tile))

ForEachSorted iterates over tiles sorted by Y, then X. This is important for correct backdrop propagation.

func (*TileGrid) Get 

func (g *TileGrid) Get(x, y int32) *Tile

Get returns the tile at coordinates, or nil if not present.

func (*TileGrid) GetOrCreate 

func (g *TileGrid) GetOrCreate(x, y int32) *Tile

GetOrCreate returns the tile at the given coordinates, creating if needed.

func (*TileGrid) Has 

func (g *TileGrid) Has(x, y int32) bool

Has returns true if a tile exists at the coordinates.

func (*TileGrid) PixelBounds 

func (g *TileGrid) PixelBounds() scene.Rect

PixelBounds returns the bounding rectangle in pixel coordinates.

func (*TileGrid) Reset 

func (g *TileGrid) Reset()

Reset clears the grid for reuse.

func (*TileGrid) SetFillRule 

func (g *TileGrid) SetFillRule(rule scene.FillStyle)

SetFillRule sets the fill rule for coverage calculation.

func (*TileGrid) TileCount 

func (g *TileGrid) TileCount() int

TileCount returns the number of non-empty tiles.

type TilePool 

type TilePool struct {
	// contains filtered or unexported fields
}

TilePool manages a pool of reusable tiles.

func NewTilePool 

func NewTilePool() *TilePool

NewTilePool creates a new tile pool.

func (*TilePool) Get 

func (p *TilePool) Get() *Tile

Get retrieves a tile from the pool or creates a new one.

func (*TilePool) Put 

func (p *TilePool) Put(tile *Tile)

Put returns a tile to the pool.

type TileWinding16 

type TileWinding16 [16]float32

TileWinding16 holds winding values for a 4×4 tile in SIMD-friendly layout. All 16 pixels stored contiguously for vectorized operations.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.