Rendering

Renderer

475 symbols, imported from @driftengine/core.

Explained in Hello world.

Classes

BoltBatch: One draw call for a pool of electrical arcs.
BoltPool
Boom
Camera: Perspective camera. Yaw/pitch convention: yaw 0 looks toward -Z, positive yaw turns right (+X); positive pitch looks up.
CausticsRenderer
CinematicCamera
DebugLines: Debug geometry, as line segments the renderer already knows how to draw.
DecalProjector: A projector a consumer holds and moves.
DistanceFieldScene
FlockRenderer
FrameBudget: Every ceiling a backend imposes, counted for the frame just drawn.
GiFieldPass
Gizmo
GpuDrivenPass
GpuTimer
InstancedMesh
LightField
Mesh
OcclusionBuffer
ParticleBatch
ParticlePool
PickableSet
PlumeRenderer
ProbeGrid
RainField
ReflectiveSurface: A box a consumer declares, inside which surfaces reflect what the frame drew.
ResolutionGovernor
SdfTextLayout
StreamingScene
SurfaceTexture: An image uploaded once and bound per draw.
ThirdPersonCamera: Generic camera mechanism. The caller supplies its already-resolved target height and desired FOV, keeping crouch rules and speed effects in the game.
TrampleField
WaterRenderer: Vertices per side of a bounded body's sheet. A pool is not an ocean.
WebGL2Renderer
WindStreakRenderer
WorldLightField

Interfaces

AnisotropicModel: Strands of brushed metal, satin or hair-like fibre: a highlight stretched across them.
AreaLightBuffer: The five arrays the shader declares, filled once a frame from whatever a caller supplied.
AreaLightSource: One rectangular emitter, as a consumer describes it.
Atmosphere: Atmosphere fields shared by every visible render pass.
BloomResponse: How a frame's bloom answers the light it is given, beside the strength and threshold setBloom already takes. Absent, or a field absent, is the response every frame had before 4.8.6.
BoltColors: A hot core and an outer glow, as a caller-facing pair.
BoltHandle: A batch of electrical arcs on the device. Opaque for the reason MeshHandle explains.
BoltPoolOptions: A pool of short-lived electrical arcs — lightning, and anything else that strikes between two points and crackles while it lasts.
BoltSegments: The arcs a batch draws, as plain arrays with a live count.
BoneAnimationClip: A clip, as a caller hands it to createBoneAnimation.
BoneAnimationHandle: A clip on the device, from createBoneAnimation. Opaque but for its size.
BoomObstruction: Something that can say how far an arm gets before it hits the world.
BoomTiming: The four numbers above, as something a caller can set.
BoxOccluder: What the batch test asks of an occlusion buffer. OcclusionBuffer and both renderers answer it.
BudgetLine: One ceiling's frame. Updated in place, so holding a reference to it is the intended use.
BufferReuse: Which values of a graph may share one buffer, as one rule both sides plan by: the device's runner beside this file, and @driftengine/texture's reference evaluator.
CausticsHandle: A water-lit surface on the device. Opaque for the reason MeshHandle explains.
CausticSheet: A surface lit by nearby water: the floor of a pool, the bottom of a flooded corridor, the underside of a bridge, an arch, a jetty, a cave mouth.
ClothBindingData: A mesh's cloth binding, one entry a render vertex unless said otherwise.
ClothBindingHandle: A mesh's cloth binding on the device, from createClothBinding: which simulation triangle each vertex follows. Opaque, for the reason MeshHandle gives.
ClothParticlesHandle: One character's cloth particles on the device, from createClothParticles. Opaque likewise.
ClusterSource: What packing needs of one mesh's clusters. MeshletLevel from MSHL satisfies it.
ColourGradeLut: A cube of display values: size on each axis, size ** 3 * 4 bytes, red varying fastest.
CompressedTextureSource: Block-compressed texels with their stored mip chain, level 0 first.
ComputeDefinition
CreatedRenderer: What was built, and which path built it.
CreateRendererOptions
DecalBox: The box a projector occupies. Every field is world space.
DecalProjectorOptions
DecodeTables
DenoiseFrame: One frame's worth of what the filter needs, as flat arrays a pass would upload.
DenseLightVolume
DescribeGpuOptions: The seams a test needs. A caller in a browser passes none of them.
DeviceGraph
DeviceGraphNode
DeviceParticles: Particles a caller's own compute shader wrote into a buffer of its own (registerCompute), drawn where they lie by drawDeviceParticles rather than read back and uploaded again. WebGPU only.
DirtySpan: One buffer's changed run, in units of that buffer's record.
DistanceFieldInstance: One placed field. transform is this queue's own copy; source is the consumer's object.
EncodedProgramShape: What encodeMaterial returns, as far as this needs it.
Environment: Lighting and atmosphere for a frame. The game decides what goes in it.
EquirectSource: What a decoded .hdr looks like, restated structurally so this imports no package.
EyeModel: An eye: an iris seen through a cornea, which refracts it, under a mirror-smooth highlight.
FieldHit: Where a march ended. Reused rather than returned, because the chain runs this per ray.
FieldLight: What the bake reads of a light, which a PointLightSource already carries.
FieldMarch: How the march is shaped.
FieldSource: A baked object field, as this package can describe one.
FilmicCurve: A film curve's five numbers, as a grading volume states them.
FilmOptions: What a film should do beyond shimmering, which until now was nothing.
Flame
FlameOptions
FlockHandle: A flock on the device. Opaque for the reason MeshHandle explains.
FlockParams: Ambient sky life. Entirely GPU-side: the geometry is uploaded once and every bird's path is computed in the vertex shader from its index and the clock.
FogOptions
FogTarget: FogOptions with its fields writable, which is what a caller holds and refills a frame at a time.
FrameReflections: How the frame's materials reflect it. Every field optional; see DEFAULT_FRAME_REFLECTIONS.
FrameTimer: What a frame timer has to answer, with no backend in the question.
GeometrySink: Where a scene's vertices and indices go, since it keeps no copy of them.
GiFieldOptions: It no longer composes the field, and that is the whole of what changed on 2026-09-18.
GiResources: Everything the three levels need, gathered so a per-ray call takes one object.
GlassOptions
GlobalField: The composed world, as nested cascades centred on the camera.
GlobalFieldCascade: One level of the clipmap: a grid the composer fills and sampleGlobalField reads.
GlobalFieldInstance
GlobalMediumOptions: How thick the air is, this frame.
GovernorLimits: Hold a frame budget by moving the drawing-buffer scale, and nothing else.
GpuDrivenLatent: A program is DecodeResources with bytes rather than floats, because bytes are what the device array holds. The types are structural: core does not import @driftengine/texture, and what encodeMaterial returns satisfies programFromEncoded as it stands.
GpuDrivenMaterial: What a material tints and emits.
GpuDrivenMesh: One mesh of a GPU-driven scene: its vertices, its clusters, and which material shades it.
GpuDrivenNetwork
GpuDrivenProgram
GpuDrivenScene
GpuDrivenShadowOptions: What the pass is told once, at construction, about the map it renders.
GpuDrivenTextures: The forward path's maps, as decode programs. SurfaceMaterial binds an albedo, a normal and an occlusion-roughness-metallic image, and its scales and strengths mean what they mean there — the ORM map replaces roughness and the scale gives the scaling back, and occlusion strength is a mix from one rather than a multiply. Defaults are SurfaceMaterial's.
GpuDrivenView: What the pass needs told once a frame, before beginFrame.
GpuIdentity: What part this machine has, as far as the browser will say. See describeGpu.
GpuSample: Milliseconds per bracket.
GraphRunner
HairModel: Hair: three lobes along the strand, which is the mesh's tangent, running from root to tip (hairLobes.ts). A model map's green turns each strand's tilt by up to half of it either way and its blue is occlusion.
ImageTexels: One decoded image: 8-bit RGBA, row-major from the top left, unpremultiplied.
IncrementalMeshHandle: A mesh on its way to the device, and the iterator that gets it there.
IndirectRay: One indirect ray, as the shading path hands it over.
IndirectResult
InferenceDevice: A device for running networks, opened from whichever GPU the caller has.
InsetRect: A rectangle of the canvas, in CSS pixels from its top-left corner — i.e. a DOMRect.
InstanceData: One base mesh drawn many times in a single call.
InstancedHandle: A mesh made drawable many times over, held by a consumer and handed back.
InstancedOptions: How a batch made by createInstanced behaves.
LightFieldOptions
LightFieldSource: A light a field sums: a PointLightSource, whose inLightField the field sets.
LightGrid
LightmapModel: A surface whose static light was baked: the standard model, plus a lightmap page's light read at the mesh's second coordinates (MeshData.lightmapUvs). The material's modelMap is the page, from createLightmap; see lightmap.ts for what it adds and what it gives up.
LightmapPage: One page as a consumer decoded it.
LightVolumeDrawOptions: The two things a volume of light can have beyond its shape. See drawLightVolume.
LineHandle: A batch of polyline segments on the device. Opaque for the reason MeshHandle explains.
LineSegments: A polyline as the segments a renderer draws, rewritten in place.
MeshHandle: Geometry on the device, as something a consumer holds and hands back.
MeshInstances: One base mesh's per-instance placement and colour.
MeshOptions: What a mesh needs to be told at creation that its geometry cannot say.
Mover
OcclusionOptions
OverlayRegion: Where an image sits in the atlas: its size and its corner, each in the atlas's uv.
ParticleBatchOptions
ParticleHandle: A particle pool on the device. Opaque for the reason MeshHandle explains.
ParticleInstances: A pool's per-particle stream, as a particle material reads it.
ParticlePoolOptions: A pool of short-lived particles, simulated on the CPU and drawn as instances.
PassAttachmentOptions: A render target a contributed pass owns: it renders into this and samples it later.
PassDefinition
PassTimings: Where a frame's milliseconds went, one row per graph pass.
PhotometricProfile: What a reader produces, restated structurally so core imports no package. See readIesProfile.
PickableSource
PickHit
PlumeHandle: A plume batch on the device. Opaque for the reason MeshHandle explains.
PlumeOptions
PlumePlacement: Batched camera-facing quads for volumetric effects — flames, smoke, steam, dust. Game-agnostic: it knows positions, sizes and time, and nothing about what the plume represents.
PointLightBuffer
PointLightSource
PrepareOptions: Which of a draw's pipelines prepareMesh and prepareInstanced compile beside the opaque ones.
ProbeBakeOptions: What a bake is for, and specifically whether it also replaces the scene's diffuse ambient.
ProbeBlend: The eight probes surrounding a point, and how much of each it takes.
ProbeGridOptions: A lattice, and the reason it is one.
ProbeVerdict: What the probe decided, and why.
ProbeVisibility: What each probe could see, as one octahedral map of depth moments per probe.
RainFieldOptions: Falling rain, as streaks the line batch already draws.
ReflectionOptions
ReflectiveSample: A reflective surface, as a shading path holds one.
ReflectiveSurfaceOptions: What a ReflectiveSurface is made with: its box, which way the surfaces inside it face, and how much and how far they reflect. Every number but the box has a default; see each field.
RenderQuality
ResolvedGlass: A GlassOptions clamped and defaulted, in a caller-owned object so a draw allocates nothing.
ScatterHandle: An instanced batch on the device, held by a consumer and handed back.
SdfFont
SdfGlyph: An SDF font's metrics, parsed once and asked many times.
SdfTextHandle: One SDF text label: a string laid out as flat, textured quads from a distance-field font. Opaque for the reason MeshHandle explains, and for TextHandle's own reason too — the concrete class on each backend holds a WebGL2RenderingContext or a GPUDevice's buffers privately, so no shared type could name one without this.
SdfTextStyle
SeaState: How rough the sea is for a given wind.
ShadowCasterCloth: A skinned caster's cloth: the mesh's binding and the character's particles. See setCloth.
ShadowCasterSink
SheetMesh
SheetSpan: One cross-section: the two ends of a straight edge across the sheet.
ShotParams
SkinModel: Skin: light scattered beneath the surface, reddening its terminator and its thin parts.
SkinnedClothSet: Garments a renderer solves together, from createSkinnedClothSet, each named by its index.
SkinnedClothSolver: A garment a renderer solves, from createSkinnedCloth.
SkyColors
SpatialOptions
StaticDrawsHandle: A list from createStaticDraws. Opaque but for its size.
StreamCapacity: How many units of each axis a scene may hold. Declared once; a claim past it is refused.
StreamHandle: What add hands back, and what remove needs to give the room back.
StreamUpload
SurfaceDissolve: The surface cut away where a noise in its uv falls under threshold, with a glowing band just above it, and a colour laid over the surface through the same noise.
SurfaceLayerEffect
SurfaceLayerLook: One layer's own look, applied to what it reads before the layers are blended. Every field is the identity where it is absent, so a material names only what differs.
SurfaceLayers: Up to five layers, each its own colour, normal and roughness at its own repeat, blended by a mask.
SurfaceMaterial: Everything the flat pass needs to know about a surface, in one call.
SurfaceOverlay: What a draw lays over its surface beyond its material, for setSurfaceOverlay: a rim, a dissolve and wrinkles, each optional, and the atlas their images are regions of.
SurfaceProjection: Texture coordinates from the world rather than from the mesh.
SurfaceRim: Light along the silhouette: the edge (1 - N·V)^falloff, leaning toward normals that face up, raised to a contrast, times a noise laid in screen space, a slow pulse and a mask, in a colour. Added to what the surface emits, and not gated on the night as emission is: it is a glow the surface wears, not light it gives off.
SurfaceTextureHandle: A caller's image on the device. Opaque for the reason MeshHandle explains.
SurfaceTextureOptions
SurfaceWrinkle: A second normal map blended into the surface's by six region weights, read through two masks: the first mask's red, green and blue carry regions 1 to 3, the second's regions 4 to 6. A face's expressions, or veins brought up all over.
TemporalPixel: What a pixel carries between frames. The caller owns one per pixel.
TextHandle: One text object: a string laid out as instanced glyph cubes. Opaque for the reason MeshHandle explains, and opaque at all for a reason the others did not have — it used to be a class holding a WebGL2RenderingContext, which pinned every caller of it to WebGL2.
TextStyle
ThirdPersonCameraOptions
TranslucentMeshOptions: The two things a translucent draw can turn off. See Renderer.drawTranslucentMesh.
UnderwaterAtmosphere: Optional camera medium layered over an environment's ordinary air fog.
WaterBody: A body of water: the sea, a fountain's basin, a tank, a puddle.
WaterBounds: Where a bounded body sits, how far it reaches and which way it faces.
WaterHandle: A body of water on the device: its meshes and the numbers its grid settled.
WindField: The world's wind, as one value passed to everything that moves in it.
WindProfile: One wind, sampled by everything that moves in it.
WindState
WindStreakHandle: A wind-streak lattice on the device. Opaque for the reason MeshHandle explains.
WorldLightFieldOptions

Functions

advanceWindField: Advance the field one frame. driftScale converts wind speed into travel for whatever the drift is positioning.
anisotropicModel: Brushed metal and the like, after glTF's KHR_materials_anisotropy: a strength and a turn.
apparentSize: The angular radius of a bounded object, in radians, as seen from a point.
areaShadowLayerCount: How many layers of the shared array a world's rectangles will take.
atmosphereFog: The haze an Environment makes at a camera's height, as GpuDrivenView.fog takes it.
bakeDenseField: Sum lights over the box bounds (min xyz, max xyz) at spacing metres. distance occludes, or null for none. The first sample stands on the box's min corner.
bakeProbeVisibility: Fill one probe's map from what it can see.
batchBoxVisible: Whether a batch's box (instancesBox) can be seen at all: inside the frustum, and not behind the declared occluders. One test for a whole region's props, run before any instance is looked at.
billboardMatrix: Face the camera on every axis, for geometry with no up of its own.
billboardMatrixY: Orient a mesh so its +Z faces the camera, writing the model matrix in place.
blendCovering: The same three on WebGL2, as the alpha half of blendFuncSeparate beside the colour half a caller already had. src and dst are the colour factors.
blendKeeping: SCENE_ALPHA_KEEPS on WebGL2, beside the colour factors src and dst.
blendTransmitting: SCENE_ALPHA_TRANSMITS on WebGL2, beside the colour factors src and dst.
boundsVisible: Whether a mesh placed by a model matrix is anywhere inside a frustum.
buildGpuDrivenScene: Pack a scene.
buildSheets: Cover each sheet in cells no coarser than cellM.
castingRange: The range a rectangle will actually cast over, or 0 for one that will not.
composeGlobalField: Fill every cascade from the instances standing near the camera.
compressedFormatName: The format a device would have to offer, or null for one with no sRGB form.
computeLightMatrix
coneRadiusAt: The cone's radius after travelling distance, for a cone of this half-angle.
conventionalDepth: Turn a depth read out of the buffer back into the [0, 1] a conventional one would have held.
countSplatTiles: How many splats each tile holds, and how many entries the lists need in total.
createAreaLightBuffer
createEnvironment: A complete Environment, with every field at a value that means "nothing special".
createFlame
createFogTarget: A target for atmosphereFog, allocated once, outside the frame loop.
createGlobalField: Allocate a field. Called once; composeGlobalField fills it and allocates nothing.
createGraphRunner
createImageTexelDecoder: A decoder that reads texels back exactly, over a context of its own.
createInstanceData
createLightGrid: Bucket sources into cells of cell metres. Built once; not a frame path.
createLineSegments: Room for capacity segments, which is one fewer than the points that fill them.
createMeshInstances: Allocate both arrays at capacity, empty.
createMover
createPassAttachment: Build one. Called from a pass's init, or from its prepare when the size has changed.
createPassTimings
createPointLightBuffer: A buffer for the selection to fill, sized to what the caller can actually bind.
createProbeBlend: A blend a caller owns and reuses.
createProbeVisibility
createRenderer: Build a renderer on the best backend this browser will actually give us.
createSkinnedCloth: A garment for renderer, from a set-up checked by name.
createSkinnedClothSet: Garments for renderer stepped together, from set-ups checked by name: one pass, one submit and one garment's dispatches a step on the device, whatever the count. They must agree on step, substeps, iterations and maxSteps, and are refused by the first they disagree on.
createWindField
createWindState
cullInstances: Keep the instances of data whose spheres meet frustum, compacted in order into out, and return how many. out must hold as many as data does; its count is set.
describeGpu: Ask what part this machine has, before building a renderer.
deviceSnappedCellSize: The cell size to draw at, so every cell of a bitmap glyph covers whole device pixels.
equirectToCubeFaces: Resample an equirectangular environment onto six cube faces.
eyeModel: An eye. The defaults are a human eye's, its axis along the mesh's +Z.
fillSplatTiles: Every splat written into the list of each tile it touches, in the order the splats are given.
filterStepFor: How far apart the taps go, for light that came from each level of the chain.
firstAreaShadowLayer: Where the area layers begin, given how many point lights the world has.
flameFrequencyHz: The puffing rate of a flame burning from diameterM metres across.
gatherLights: Gather into grid.gathered, cell by cell, every light whose cell lies within reach metres of (x, y, z) on each axis, and answer how many.
generateMipChain: Fill every level of a texture from the one above it, which is what WebGPU asks for instead of a call.
ggxMaxLevelFor: The coarsest level the GGX chain reaches, which is one below the irradiance level.
gizmoScaleFor: The world size that covers pixels screen pixels at the target's distance.
hairModel: Hair, along the mesh's tangent from root to tip. A tilt of 3°, within the 2.5° to 5° measured.
identityGradeLut: A table that changes nothing.
instancesBox: The world box around every instance's sphere, for testing a whole batch at once: (minX, minY, minZ, maxX, maxY, maxZ) into out. A batch holding nothing writes a min above its max.
irradianceLevelFor: Which level of a chain holds the cosine convolution.
isCompressedSource: Whether source is a compressed source rather than an image.
isWeakGpuFamily: Whether this renderer string names a part known to struggle with the good profile.
jitterClip: source moved in clip space by jitter, which is what a contributed pass does with the frame's jitter (PrepareContext.jitter) to draw where the renderer's own verbs drew this frame.
levelBytes: The bytes level level of a width by height image takes: whole blocks, one at least.
lightmapModel: A baked surface, reading its region of a lightmap page: the whole page where none is named. An instanced batch's regions compose with this one, each instance's applied first: see MeshInstances.lightmapRegions.
lodForBounds: The index of the level this object has earned.
mipLevelCount: How many levels an image of this size has, counting the one it arrives with.
morphTexelIndex: Where one target's delta for one vertex sits in the delta texture.
nearestProbes: The eight probes around a world position, with trilinear weights that sum to one.
newFieldHit
newIndirectResult
newTemporalPixel
octahedralEdgeFor: The octahedral edge a probe of a given cube face size gets.
openInferenceDevice
packDecodeTables
packIesAtlas: planes rows of intensity per profile, normalised to the profile's peak, indexed by angle.
packInstances: Interleave count instances into out, matrix, tint and opacity, at INSTANCE_FLOATS apart.
packSurfaceEffects: The table for effects, one entry a layer (undefined for a layer with none), as floats: six RGBA texels a layer, a row a layer.
paletteTextureWidth: How wide the palette texture is for a rig of this many joints.
parseSdfFont: Validate and index a metrics document.
passLabel
passMs: Milliseconds this pass cost, or null where nothing measured it. Null is not zero.
placeCascade: Put one cascade where the camera is, and answer its half-extent.
planReuse
probeDevice
probeUpdateSchedule: Which probes to rebake on this frame.
probeVisibilityWeight: How much a probe's answer is trusted at a point this far away in this direction.
programFromEncoded
recordPassLabel
recordPassSample: Add one sample to a pass.
reflectDirection: Mirror a direction about a normal.
reflectionCone: The cone half-angle a roughness reflects through.
resetPassTimings: Start a frame: timings go, labels stay. See the header for why they are treated differently.
resolveGlass: Resolve options into out, and say whether it is glass at all.
resolveGlobalMedium: A caller's numbers, clamped to what the shader can be handed.
resolveRenderQuality
roughnessForLevel: The roughness mip level level is convolved for.
sampleGlobalField: The field at a world point, from the finest cascade that holds it.
sampleProbeVolume: Blend what the probes carry, channels floats each, into a target the caller owns.
sampleWind: Sample the profile at a time. Writes into out and allocates nothing — this runs every frame for every system that cares about weather.
screenRayOrigin: Lift a point off the surface it stands on, along that surface's normal.
seaStateForAgitation: The same surface state, asked for directly instead of derived from wind.
seaStateForWind
selectAreaLights: Fill the buffer from a caller's list, normalising the axes and orthogonalising them.
selectGridLights: selectPointLights over a grid's sources, looking only at the lights near the eye: the same choice, tie for tie, for a world of thousands of fixed lights that the plain scan would visit every frame. See lightGrid.ts for why the result is the scan's exactly.
selectPointLights: Select nearest lights whose influence may still be visible and pack them in shader order. The caller owns out; no sort arrays or temporary objects are created in this per-frame path.
setPolyline: Rewrite a polyline from a flat point list, three floats a point.
setUniformStrictMode
skinModel: Skin. The defaults are a fair skin's: red light leaving a little over a centimetre away.
spatialDenoise: One separable, edge-stopping pass over a frame.
splatPixelBox: The pixel box a splat covers, clamped to the frame, into out as left, top, right, bottom — or false where it covers nothing.
splatTileGrid: How many tiles a frame of this size is cut into, across and down.
splatTileOffsets: Where each tile's list begins: the exclusive prefix sum of the counts. Answers the total.
streamingScene: A scene filled once from a list of meshes, which is the static case.
temporalDenoise: Blend this frame into the history a caller reprojected, and answer how much history there is.
textHeightPx
textWidthPx: Width of a string in pixels at a given cell size, without laying it out.
traceField: March a ray through the composed world field.
traceIndirect: Trace one indirect ray down the chain, and always answer.
traceReflection: Trace a reflection down the chain, or down its first level alone.
traceScreen: Trace an indirect ray against the frame the renderer has already drawn.
updateFlame: Where the flame's light is and how bright, at timeSeconds. Writes flame.light in place.
uploadsCompressed: Whether a width by height source in format uploads as blocks on a device offering available. Level 0 must be whole blocks each way: WebGPU refuses any other size for a block texture, and WebGL2's extensions say the same, so a 6x6 image in 4x4 blocks is decoded rather than refused. What would make that wrong is a device that pads; none is relied on here.
visibleProbes: The eight probes around a point, weighted by what each of them can actually see.
writeInstance

Types

BlockFormat: BC1 to BC5 and BC7; ETC2's three and EAC's two; and ASTC at every block size the LDR profile has. BC6H, ASTC HDR and the signed forms are not among them.
CompressedTextureFormat: A format as a device offers it: the colour space is part of the name, as WebGPU's are.
ComputeContext: What it is handed at each dispatch.
ComputeDevice: What a registered definition is handed once, at registration, to build its resources.
ComputeHandle: A registered definition, as the caller holds it.
DeviceAttribute: A network graph as the device runs it: the structure @driftengine/texture validated, and the shape of every value it inferred.
DirectionalShadowDepthLayers
FrameResource
GiSource
GizmoMode
GizmoSpace
GlassShadows: How light through glass is coloured: see RenderQuality.glassShadows.
GpuDrivenList
GpuSlot
ImageTexelDecoder: What turns an encoded image's bytes into texels.
LightmapRegion: Where a surface's region of its page is: lightmapUv = uv2 * scale + bias, as [scaleU, scaleV, biasU, biasV]. The whole page is the identity.
OutputTransform: What happens to a shaded colour on its way to the framebuffer.
ParticleBlend: One draw call for a live particle pool: one camera-facing quad per particle, or a crossed pair of world-fixed ones when facing asks for them.
ParticleFacing: How a particle's quads are turned.
ParticleMaterial: Which particle material a caller wants, by name rather than by source.
PassContext: What it is handed each frame, at the point the caller asked for it.
PassDevice: What a registered pass is handed once, at registration, to build its resources.
PassHandle: A registered pass, as the caller holds it.
PassTarget
PipelineCompile: What a draw does when its pipeline has not compiled yet: see RenderQuality.pipelineCompile.
PlumeBlend
PlumeMaterial: Which plume material a caller wants, by name rather than by source.
PrefilterQuality: The tier names, so a quality option can take one without restating them.
PrepareContext: What a pass is handed once a frame, before the frame's own target exists.
QualityForBackend: The quality to build with, or a function of the backend createRenderer chose.
RenderBackend: Which backend is actually drawing. Reported, never inferred.
RendererApi
RenderPipeline: Which of the two pipelines is drawing.
RenderQualityOptions: Callers override only the levers selected by a future settings profile.
SceneCasterMaterial: What a shadow-caster enumeration may hand to a depth pass.
SceneCasters: Replay a caster enumeration into the colour pass that is open, materials and all.
ShadowCasters: A caller-supplied enumeration of everything that casts.
ShadowFilterTaps: The three settings whose accepted values are a closed set, written as one.
ShotKind: Where a shot puts the camera, and what it frames.
SkinScattering: How light scattered beneath skin is drawn: see RenderQuality.skinScattering.
SurfaceModel: Every model a material can name, by its kind: see SurfaceMaterial.model.
SurfaceModelKind: A model's name, which also picks its pipeline switch: SURFACE_MODEL_SWITCH.
SurfaceSource: What createSurfaceTexture takes: an image, or blocks.
WaterReflectionFilterTaps
WaterSettings: @deprecated The old name for an unbounded {@link WaterBody}.
WindStreakOptions: Makes the wind visible once it is strong enough to be worth seeing.

Constants

ARCANE_FRAG: An arcane aura: the volume a floating object sits inside.
BLOOM_LEVELS: How many halvings the chain may take.
DEFAULT_BOOM_TIMING: What every rig got before the timings could be set, and what one that says nothing still gets.
DEFAULT_FILMIC_CURVE: The defaults the curve ships with where a volume states nothing.
DEFAULT_FRAME_REFLECTIONS: The march ReflectiveSurface defaults to, a ceiling at satin, and a smear of 3% of the frame.
DEFAULT_GLOBAL_MEDIUM: What a renderer starts with: off, and everything else at a value that means "ordinary air".
DEFAULT_GOVERNOR_LIMITS: Deliberately hard to trigger. Work through what a healthy machine has to do to move it.
DEFAULT_POINT_LIGHT_VIEW_RANGE
DEFAULT_RENDER_QUALITY: Current fidelity target. Different shadow projections use different texture dimensions for comparable visible detail: a cubemap spends its allocation six times, while the directional map spends all of it on one focused area.
DEFAULT_SDF_TEXT_STYLE
DEFAULT_TEXT_STYLE
DENOISE_MIN_ALPHA: The least weight this frame may be given, however long a pixel has been accumulating.
DENSE_MAX_AXIS: The most samples along x or z: WebGL2 promises 256 on every axis of a 3D texture.
DENSE_MAX_HEIGHT: The most along y, which holds the light and then the direction: two layers in 256.
DEPTH_CLEAR: What a scene depth attachment is cleared to: the far plane.
DEPTH_COMPARE: The WebGPU compare for "nearer than what is there".
DEPTH_COMPARE_EQUAL: The same, admitting equality.
DEPTH_FORMAT: The scene depth format.
DEPTH_OFFSET_SIGN: Which way a polygon offset has to push to bring a coplanar overlay forward.
DEVICE_PARTICLE_FLOATS: Floats one particle takes in a buffer a caller's own compute writes (DeviceParticles), in this order: position 3, half-width 1, roll 1, colour 3, opacity 1, age 1, seed 1, velocity 3, a sprite's frame 1 and its half-height 1 — ParticleInstances' streams, interleaved as the pool's own upload interleaves them. 64 bytes a particle.
FIELD_FADE_SEC: Seconds the summed light takes to fade in once the field is whole.
FIELD_MARCH: The march an indirect ray takes through the world field.
FIRE_FRAG
GI_SCREEN_MARCH: The march an indirect ray takes, which is not the one a mirror takes.
GI_SOURCE_FIELD
GI_SOURCE_PROBES
GI_SOURCE_SCREEN: Three levels, and the architecture is the fallback rather than any one of them.
GIZMO_GROUP_ACTIVE
GIZMO_GROUP_COLORS: A colour per group, in the order the groups are indexed.
GIZMO_GROUP_COUNT
GIZMO_GROUP_NEUTRAL
GIZMO_GROUP_X: Buffer indices. Three axes, one neutral, one for whatever is highlighted.
GIZMO_GROUP_Y
GIZMO_GROUP_Z
GIZMO_NONE
GIZMO_ROTATE_X
GIZMO_ROTATE_Y
GIZMO_ROTATE_Z
GIZMO_SCALE_UNIFORM
GIZMO_SCALE_X
GIZMO_SCALE_Y
GIZMO_SCALE_Z
GIZMO_TRANSLATE_X
GIZMO_TRANSLATE_XY
GIZMO_TRANSLATE_Y
GIZMO_TRANSLATE_YZ: The plane handles are named for the axes they slide in, so YZ is normal to x.
GIZMO_TRANSLATE_Z
GIZMO_TRANSLATE_ZX
GLOBAL_FIELD_BLEND: How much of a cascade's extent, at each face, fades into the cascade outside it.
GPU_DRIVEN_LISTS: The frame's four draw lists, each counted by the clusters it drew: phase one (what was visible last frame and still is), phase two (what the pyramid found newly visible), the blended half, and the light's map.
GPU_SLOTS
GRADE_PLACEHOLDER_SIZE: The lattice the placeholder is built at, and two is exact rather than merely small.
IES_ATLAS_WIDTH: Columns across the atlas: one row per profile, sampled by vertical angle.
INSTANCE_FLOATS: Floats one instance occupies in the interleaved vertex buffer: sixteen of matrix, the bottom row of which carries the texture cell, three of tint, and the opacity.
INSTANCE_STRIDE: Bytes one instance occupies. See INSTANCE_FLOATS.
IRRADIANCE_EDGE: The irradiance image's edge, and why the diffuse term is a level of the same chain.
LIGHT_GRID_MAX_CELLS: The most cells a grid may span, which keeps a stray light far away from costing a gigabyte.
MATERIAL_FLOATS: Floats a material owns: tint rgb, emissive, roughness, specular, reflectivity, metalness.
MAX_AREA_LIGHTS: How many rectangles the lit pass shades against at once.
MAX_CLUSTERED_LIGHTS: How many lights the clustered path carries at once.
MAX_DEPTH_LAYER: Highest depth layer a caller may ask for.
MAX_DISTANCE_FIELDS: How many placed fields one frame may declare.
MAX_ENV_PROBES: How many layers a grid may hold, and it is a memory limit rather than a binding one.
MAX_GLOBAL_MEDIUM_STEPS: The most steps a march may take, which is the shader's own loop bound.
MAX_GRADE_SIZE: The largest lattice accepted, because the cost is cubic and a caller will not feel it.
MAX_JOINTS: The most joints one palette can hold.
MAX_MORPH_TARGETS: The most morph targets one mesh can carry.
MAX_POINT_LIGHTS: How many point lights the shading pass shades against at once.
OUTPUT_TRANSFORM_GLSL: uOutputTransform and uOutputExposure, the fit, and applyOutputTransform.
PARTICLE_MOTE_FRAG: Dust motes and drifting glints: unlit, alpha blended, and fogged only when the caller asks.
PARTICLE_SMOKE_FRAG: Smoke, grit and dust: a soft body eroded by noise, alpha blended, and lit.
PARTICLE_SPARK_FRAG: Sparks and embers: additive, hot in the middle, and stretched along travel.
PARTICLE_VERT
PLUME_VERT: Shared billboard vertex stage: used by fire, smoke and any future plume.
PREFILTER_SAMPLE_COUNTS: Samples per texel, per quality tier.
PROBE_VISIBILITY_SHARPNESS: How sharply the Chebyshev bound is turned into a weight.
REVERSED_DEPTH: True while the engine renders its scene depth reversed.
SCENE_ALPHA_COVERS: A blended draw that covers the surface by its alpha: share * (1 - a).
SCENE_ALPHA_KEEPS: Light added to the surface, or a layer of it: the share unchanged.
SCENE_ALPHA_TRANSMITS: A draw whose alpha is what gets through it, a transmittance or a revealage: share * a.
SCREEN_TRACE_BIAS_M: How far along the normal an indirect ray starts, in metres.
SKIN_PALETTE_TEXTURE_UNIT: The joint palette, read by the vertex stage.
SMOKE_FRAG: Smoke: a column that rises, expands and dissipates. Shares the plume billboard vertex shader with fire — only the fragment behaviour differs.
SPLAT_BIN_FLOATS: Floats a splat's screen footprint occupies: x, y, radius, depth.
SPLAT_TILE: The side of a tile in pixels; one workgroup covers one tile.
SURFACE_EFFECT_TEXELS: Texels a layer takes in the table.
SURFACE_TEXTURE_UNIT: Where surface colour binds, directly above the shadow units.
TRAMPLE_SLOTS: How many presses are remembered at once.
UPLOAD_BYTES_PER_STEP: How much of a mesh one upload step moves, in bytes.
VERTEX_FLOATS: Floats a vertex in the one interleaved buffer: position, normal, colour, uv.
VIEW_MODEL_DEPTH_SHARE: The share of depth a view model is drawn into when the caller names none: the nearest 1%.
WEAK_GPU_MEDIUM_STEPS: The most steps a part isWeakGpuFamily names gets, whatever the profile asked for.
WHOLE_PAGE: The whole page.