Cleartype#

type Clear = {
    r: number,
    g: number,
    b: number,
    a: number
}

A color a target or a pass clears to.

Every channel runs zero to one and must be finite.

DepthModetype#

type DepthMode = "none" | "testWrite" | "test"

Says how a pass uses the shared depth attachment.

none attaches no depth, so nothing rejects a fragment and nothing is written. testWrite is what geometry asks for. test rejects a fragment against what geometry already wrote without writing itself, which is what blended content that must sort against opaque geometry asks for.

Formattype#

type Format = "rgba8" | "rgba16f" | "r8" | "r16f"

Selects the pixel format the backend allocates a target in.

These identifiers reach the wire and a game's own declarations, so they are a compatibility surface.

Passrecord#

record Pass
    shader: string?
    parameters: {number}
    name: string
    inputs: {string}
    outputs: {string}
    depth: DepthMode
    depthClear: number?
    load: boolean
    clear: Clear?
end

One render pass, as the graph holds it.

Fields

shader: string?

parameters: {number}

name: string

inputs: {string}

outputs: {string}

depth: DepthMode

depthClear: number?

load: boolean

clear: Clear?

PassSpectype#

type PassSpec = {
    shader: string?,
    parameters: {number}?,
    name: string,
    inputs: {string}?,
    outputs: {string}?,
    depth: DepthMode?,
    depthClear: number?,
    load: boolean?,
    clear: Clear?
}

What a caller passes to declarePass or insertPassBefore.

The module copies every field and every list, so the tables a caller builds are theirs to reuse. inputs names the targets the pass samples, in binding order, and tecs.gpu.passes.DEPTH among them reads the shared depth attachment. outputs names the targets it writes, and an omitted or empty list renders to the swapchain. depth defaults to "none" and depthClear omitted loads what is already there. load makes the pass load every output rather than clear it, and clear overrides every output's own clear with one color.

Targetrecord#

record Target
    name: string
    format: Format
    scale: number
    clear: Clear?
end

A target the backend allocates, sizes with the frame, and owns.

Fields

name: string

format: Format

scale: number

clear: Clear?

TargetSpectype#

type TargetSpec = {
    name: string,
    format: Format?,
    scale: number?,
    clear: Clear?
}

What a caller passes to declareTarget.

The module copies every field, so the table a caller builds is theirs to reuse. format defaults to "rgba8" and scale to one, and an omitted clear loads what is already in the target.

declarePassfunction#

function declarePass(spec: PassSpec): nil

Declares a pass that runs after every pass declared so far.

Arguments

Returns

Raises

• when the name is already declared, when an input is undeclared or is not written by an earlier pass, when an output is undeclared, or when a pass using depth writes a target below frame scale

declareTargetfunction#

function declareTarget(spec: TargetSpec): nil

Declares a target the backend allocates and owns.

Nothing is allocated here. The backend sizes the target on the first frame after the declaration reaches it.

Arguments

Returns

Raises

• when the name is already declared, when it is the reserved depth name, when the format is unknown, or when the scale is outside zero exclusive to one inclusive

formatOffunction#

function formatOf(name: string): Format?

Returns the format a target was declared with.

Arguments

Returns

insertPassBeforefunction#

function insertPassBefore(before: string, spec: PassSpec): nil

Declares a pass that runs immediately before an already declared one.

This is how a game places a pass of its own at a named seam without knowing what else the graph holds.

Arguments

Returns

Raises

• when no pass carries the before name, and for every reason declarePass raises

passesfunction#

function passes(): {Pass}

Returns the declared passes in execution order.

Returns

resetfunction#

function reset(): nil

Forgets every declaration and declares the built-in graph again.

A test uses this to start from the engine's own graph. It raises the revision, so a backend rebuilds rather than keeping what it held.

Returns

revisionfunction#

function revision(): integer

Returns how many declarations have been made.

The backend rebuilds its graph when this changes, so it counts every declaration rather than describing the graph's contents.

Returns

sectionfunction#

function section(): string

Encodes the graph for the frame packet.

The encoding is cached and rebuilt only when a declaration changes it, so a steady graph costs one string for the life of the process.

The section holds a name table, then the targets, then the passes. Names appear once and every record indexes into the table, because a target name appears once as a declaration and again in every pass that reads or writes it.

A target record is nameIndex, format, scale, clearPresent, and four clear channels. A pass record is nameIndex, depthMode, depthClearPresent, depthClear, clearMode, four clear channels, inputCount, outputCount, then that many name indices of each. Name indices count from zero.

Returns

setParametersfunction#

function setParameters(name: string, values: {number}): nil

Changes one pass's uniform parameters without recompiling its pipeline.

Arguments

Returns

Raises

• When the pass has no custom shader or any scalar is invalid.

setShaderfunction#

function setShader(name: string, source: string): nil

Replaces a pass's custom WGSL body while preserving its inputs and outputs.

Arguments

Returns

Raises

• When the source is empty, too large, or the pass writes multiple outputs.

targetsfunction#

function targets(): {Target}

Returns the declared targets in declaration order.

Returns

DEPTHvariable#

const DEPTH: string

Names the shared depth attachment, which is not a declarable target.

A pass naming this as an input samples what an earlier depth-writing pass produced. This string is a compatibility surface.