Docs / Reference
Reference
Every public type in the Ductane module, with the first line of its documentation and the guide that explains it.
Types
| Type | Kind | What it is | Guide |
|---|---|---|---|
AnimationBinding | struct | Which of a rig's joints each of a clip's joints drives, worked out once. | Skeletons and clips |
AnimationClip | struct | A named stretch of animation: what each joint does, and for how long. | Skeletons and clips |
AnimationClipError | enum | Why a JointTrack or an AnimationClip could not be made from the data it was given. | — |
AnimationPlayhead | struct | Where a character is in a clip: the clip, its mapping onto a rig, and the time. | Skeletons and clips |
AssetOrientation | struct | What space an asset was authored in, and the one matrix that brings it into this engine's. | Loading meshes |
AudioEngine | class | Positional one-shot audio. | Audio |
AudioEngineError | enum | Why an AudioEngine could not be made, or a sound could not be loaded into one. | — |
BindingOutcome | enum | What putting an action on a key or a button did — see InputBindings/bind(_:to:reserving:) and PadBindings/bind(_:to:reserving:). | — |
BoundaryRenderer | class | Draws a WorldBoundary in its WorldBoundary/Look — a lattice, a grid, an energy field or a wall of haze — into the scene. | The edge of the world |
BoundaryRendererError | enum | Why a BoundaryRenderer could not be made. | — |
BoundingBox | struct | An axis-aligned box, and the ray test that goes with it. | Culling |
Camera | struct | A first-person camera, in meters. | Camera |
CameraShake | struct | What the camera does when something lands, as trauma that decays rather than a shake that is switched on and off. | — |
CharacterController | struct | A body with feet: walking across the ground, standing on things, stepping up, falling off, and crouching. | CharacterController |
CharacterFacing | struct | Which way a third-person character faces as it moves: toward where it is going, except backwards. | — |
CloudLayer | struct | The clouds overhead at a moment (2026-11-16): how much of the sky they cover and how dark they are — the weather's — where their layer is and how far the wind has carried them. | — |
CloudPass | class | Draws the clouds volumetric (2026-11-16): a raymarch through the CloudLayer from its base to its top, into a picture at half the screen's width and height (GraphicsSettings/CloudQuality/high) or a quarter (GraphicsSettings/CloudQuality/medium), which SkyPass lays over the sky — the light the clouds send toward the eye, and how much sky still shows through them. | — |
CloudShape | struct | A world's own clouds (2026-11-16): how high their base is, how thick they are, how fast the wind aloft carries them. | — |
ClusteredLights | struct | Which lights reach each cluster, as the two arrays a shader reads. | Clustered lights |
ClusterGrid | struct | The view frustum cut into a grid of cells, so a fragment can ask which lights reach it rather than inheriting a list chosen for the whole mesh it belongs to. | Clustered lights |
CollisionMesh | struct | Things to stand on and walk into, as triangles in the world — a bridge's deck, a cave's floor and walls, a boulder — for a CharacterController (CharacterController/Surroundings/meshes) and a camera. | — |
CompressedTextures | enum | Textures compressed for the GPU — ASTC 4×4 — made once and kept in a cache folder. A texture loaded from a PNG is held uncompressed: four bytes a pixel, a third more for its mips. | — |
DaySky | struct | A sky set by the time of day: one number, and the sun's direction, its light, the sky's colours and the eye's adjustment to the dark all follow from it — lighting. | — |
Decal | struct | One mark on a surface: where, which way the surface faces, and which part of an atlas it shows. | — |
DecalAtlas | struct | A sheet of marks cut into equal cells, columns across and rows down. | — |
DecalRenderer | class | Draws a DecalSet as quads lying on their surfaces, each showing one cell of an atlas. | — |
DecalRendererError | enum | Why a DecalRenderer could not be made. | — |
DecalSet | struct | Marks left on surfaces: bullet holes, scorches, footprints, splashes — the things a world keeps for a while after something happened in it. | — |
Engine | enum | Identifying information for the engine itself. | Your first game |
EngineMark | enum | The engine's own mark: a tile from the periodic table, the element Du. | The mark |
EnvironmentMap | class | The lighting an environment contributes: what it looks like reflected, and what it looks like scattered. | Sky and environment |
EnvironmentMapError | enum | Why an EnvironmentMap could not be made: which of its two cube textures the device would not create. | — |
FallColors | struct | Foliage through the year (2026-11-16): through autumn every tree turns at its own pace and to its own colour — yellow, orange, red — and grass goes straw; late in autumn the leaves thin until broadleaf trees stand bare, a carpet of leaves gathers under them, and in spring they green again. | — |
FigureMotion | struct | How a figure is moving, as the clips to play, where in each, and how much of each: the clips LocomotionBlend picks, eased in and out, every stride on one phase, a jump played from take-off, and one-shots — a swing, a flinch, a fall — laid over the lot. | — |
Findable | struct | One thing a scan can find: what kind it is, where it is, how high over that its icon floats, and what shape to outline. | Showing the way |
Findables | struct | A game's things a scan can find, registered by kind — Unity's and Unreal's "scannable" component: added when one appears, moved as it moves, removed when it is gone. | Showing the way |
FixedTimestep | struct | Advances simulation in fixed increments, independently of how often — or how irregularly — frames arrive. | Fixed timestep |
Flythrough | struct | A fixed camera route through a world, timed the same way every run (2026-10-27). | — |
FlythroughReport | struct | What a flythrough measured: per pass, per leg and for the whole route — the mean as the headline, because with frames queued the median describes the near-empty frames the CPU returns from while the queue has room and only the mean is throughput; the 95th percentile and the worst beside it. | — |
FlythroughRun | struct | A flythrough under way — the route flown once, or once per pass when costs are being attributed (FlythroughReport/attribution). | — |
FogFloor | struct | Where ground fog pools (2026-11-16): the ground smoothed over tens of metres, so fog lies GroundFog/height over the smoothed ground — deeper in a hollow, whose floor is below it, thinner on a rise above it — and thicker over water. | — |
FogSkyPass | class | Lays the fog volume over the sky — VolumetricFog/Drawn/sky, the light the air in front sends toward the eye and how much of the sky shows through it — so ground fog and the light in the haze stand in front of the sky too, where nothing solid was drawn. | — |
Foliage | enum | What a prop does through the year (2026-11-16) — which parts of a scene FallColors changes. | — |
FontAtlas | class | A rasterized glyph sheet, built at launch from an installed font. | The HUD |
FontAtlasError | enum | Why a FontAtlas could not be built. | The HUD |
FootprintGrid | class | The prints round the eye, for a shader to find: FootprintTrail's prints near the eye in one buffer, and a grid of cellSize-metre cells over halfExtent metres either way saying which prints touch each — so a pixel looks at the few in its cell and works out each print's shape exactly (Shape's press(at:), which a shader copies), sharp at any distance, for well under a megabyte. | — |
FootprintGridError | enum | Why a FootprintGrid could not be made. | — |
FootprintTrail | struct | Where feet have pressed: a print for each step of each character a game reports — left, right, turned the way the foot went, spaced by how fast it went — and how much of each the weather has wiped since. | — |
FrameRateReadout | struct | A frame rate a person can read: the average frame time and the worst frame since the last reading, put out a few times a second. | — |
FrameRenderer | class | Drives frames, owns the Metal 4 objects every renderer needs, and enforces the engine's reversed-Z depth convention. | GameLoop |
FrameRendererError | enum | Why a FrameRenderer could not be made. | GameLoop |
FrameTimes | struct | What one frame cost — three numbers, because one cannot say it (2026-10-27). | — |
FrameTimesAverage | struct | Frame times averaged over a stretch of frames, for a readout that a person can read: one frame's numbers change faster than the eye, and the frame a readout happens to sample is as likely to be the odd one as not. | — |
FrozenStickWatch | struct | A pad that has stopped sending, told from a stick being held. Measured, not imagined: an Xbox Wireless Controller reported the bit-identical pair (0.0146, 0.6082) for 11,751 consecutive samples over thirty seconds with nobody touching it. | — |
Frustum | struct | The planes of a view-projection, and whether a box is worth drawing. | Culling |
GameLoop | protocol | What a game supplies to the engine's frame loop. | GameLoop |
GLTFError | enum | Why a glTF file could not be read. | — |
GraphicsSettings | struct | How much a game draws — a player's trade of looks for speed. The settings every 3D game's graphics menu has, each one something the engine really does: shadows (ShadowMap/ShadowCascades), how far and how thickly scattered things are drawn, the scene's size against the window (SceneScaling), anti-aliasing (FrameRenderer/sampleCount) and the frame rate asked of the display. | — |
GroundFog | struct | Fog that lies on the ground (2026-11-16): mist pooling low in hollows and over water, thinning with height — thick in fog weather, rising through the night to be thickest just after sunrise and burnt off by late morning, more after rain, blown away by a strong wind. | — |
HoldPress | struct | A button held down for a moment, acting once: holster a weapon, open a door, revive a friend. | — |
HUDRenderer | class | — | The HUD |
HUDRendererError | enum | Draws the interface, after the scene has been tone mapped. | The HUD |
ImportedMaterial | struct | How a surface looks: glTF 2.0's metallic-roughness model, which USD's UsdPreviewSurface also speaks. | — |
ImportedMesh | struct | One mesh: its vertices, where it sits, and its triangles grouped by material. | — |
ImportedModel | struct | A model read from a file, as plain values: meshes, the materials they use, and their images. | — |
ImportedSubmesh | struct | Triangles drawn with one material: three indices into the mesh's vertices per triangle. | — |
ImportedTexture | class | An image, kept both as the file it came from and as pixels. | — |
ImportedTextureReference | struct | A texture as a material uses it: the image, how it is sampled, and how its coordinates are moved. | — |
InputAction | struct | Something a player does, which a key or a pad button can be bound to. | — |
InputBindings | struct | Which key does what, and the rules for changing it. | Input and settings |
InputState | class | Collects keyboard, mouse and gamepad into something the simulation can read. | Input and settings |
InstanceBatches | struct | Many copies of the same meshes, grouped so each mesh is drawn once with an instance count. | Many copies |
InstanceBuffer | class | The GPU half: a frame's instance transforms, in a buffer a vertex shader indexes with [[instance_id]]. | Many copies |
InterfaceColor | struct | A color authored for the interface, not for the scene. | The HUD |
InterfaceImage | struct | How an interface image is cut and how much of it is drawn — the three things interface art is made for, beyond being stretched over a rectangle: - Sliced (nine-slice): the corners keep their size, the edges stretch along their length, the middle stretches both ways — so one frame or bar sprite fits a panel of any size without its bezel smearing. | — |
JointTrack | struct | Keyframes for one channel across every joint the clip touches. | Skeletons and clips |
JointTransform | struct | One joint's placement relative to its parent, kept as translation, rotation and scale rather than as a matrix. | Skeletons and clips |
KeyCode | struct | A physical key, by its macOS virtual key code. | Input and settings |
Level | struct | A level, as data rather than code. | Levels and the editor |
LevelEditor | struct | Editing a level, without a window. | Levels and the editor |
LevelError | enum | Why a level could not be loaded. | — |
LightningBolt | struct | The shape of a lightning strike (2026-11-16): a jagged trunk from the cloud base to where it lands — or, for one that stays in the clouds, along under them — with thinner branches forking off it, made from the strike's own number so every player sees the same bolt. | — |
LightSet | struct | Which lights reach a point, when there is more than one and it is not the sun. | Clustered lights |
LoadedMesh | struct | A mesh, the box that contains it in its own space, and what its surfaces are made of. | Loading meshes |
LoadingScreen | struct | What stands in front of a world while it loads, so a player is never put into one that is half there. | — |
LocomotionBlend | struct | Which animation clips a character is playing this frame, and how much of each: an idle standing still, one gait while moving — its two directions either side of the way the character travels, for a gait that has directions — a rise and a fall off the ground. | — |
Material | struct | How a surface responds to light: the metallic-roughness parameter set. | Materials and textures |
MemoryUse | struct | What the app holds in memory, measured from inside it — for a statistics readout, so that turning a setting down shows what it saved rather than what it was guessed to. | — |
MeshDetail | enum | Level of detail: simpler versions of a mesh, made when it loads, and the rule that picks one for how far away a copy stands. | Level of detail |
MeshLoader | enum | Loads geometry from disk. | Loading meshes |
MeshLoaderError | enum | — | Loading meshes |
MovementInput | struct | What the player is asking the camera to do this step. | CharacterController |
MusicPlayer | class | A game's score: one track at a time, looped — or a list of them in turn — faded in and out. | — |
NavigationGrid | struct | Where a body can walk, and the way there (2026-10-31): standing places on a grid over the ground and the floors a CollisionMesh makes — decks, stairs, ramps, a road — each joined to the eight round it when a body could walk from one to the other, and a search over them that gives a path. | Finding a way |
NightSky | struct | The sky at night (2026-11-16): the stars and the Milky Way, turning about the pole as the hours pass, and the moon with its phase — what SkyPass draws over the sky. | — |
OpaqueTextures | struct | The solid scene as drawn, for what is drawn over it to read (GameLoop/wantsOpaqueTextures): its colour, in the scene's HDR format, and its depth — reversed-Z, 1 near, 0 at the far plane — both one sample a pixel whatever the scene's anti-aliasing, at the scene's size. | — |
OrbitCamera | struct | A third-person camera: it orbits a point on a character, follows it, keeps out of the scenery, and eases itself back behind the character while the player runs and does not steer. | — |
PadBindings | struct | Which controller button does what. | Input and settings |
PadButton | enum | A button on a controller, by where it is rather than what it is called. The bottom face button is A on an Xbox pad, Cross on a DualSense and B on a Nintendo one — three names for the same thumb position, and the position is what a player's hand learned. | Input and settings |
PadCalibration | struct | Both sticks' measurements — the left moves, the right looks. | — |
PadMeasurement | struct | Measuring both sticks over a few seconds of nobody touching them, as a settings screen does it. | — |
ParticleEmitter | struct | Particles at a steady rate rather than in a burst. | Particles |
ParticleRecipe | struct | What one kind of particle is: how many a burst throws, how they move, how long they last and what they look like while they do. | Particles |
ParticleRenderer | class | — | Particles |
ParticleRendererError | enum | Draws whatever a ParticleSystem says is alive, as camera-facing quads, into the scene. | — |
ParticleSystem | struct | Dust, sparks and embers: the things that say something just happened. | Particles |
PlayerSettings | struct | What a player sets once and expects to find set again. | Input and settings |
ProceduralSky | struct | A sky as a function of direction: radiance arriving from anywhere you point. | Sky and environment |
PropLevels | enum | A prop's own coarser levels of detail, as files beside it: Tree.usda is the prop, and Tree.LOD1.usda, Tree.LOD2.usda… are its maker's simpler versions of it, finest first. | — |
PunctualLight | struct | A light at a point, radiating in every direction. | Clustered lights |
Rig | struct | A rig and everything it can do: one skeleton, and the clips authored against it. | Skeletons and clips |
RigLoader | enum | Reads a skeleton and its clips out of a USD file. | Skeletons and clips |
RigLoaderError | enum | — | Skeletons and clips |
SaveStore | struct | Somewhere to keep what a game remembers between runs. | Saving |
SceneObject | struct | One thing to draw: a mesh and where it sits. | Hanging things off joints |
SceneScaling | enum | How large the scene is drawn, against the drawable it is shown in. A base M2 filling a 4K display draws 8.3 million pixels a frame, and alpha-tested foliage makes every one of them expensive; past a width where a frame can no longer be afforded, the scene is drawn smaller and the tone-map pass scales it up with linear filtering. | — |
SemanticVersion | struct | A semantic version, comparable so a consumer can check what it is building against. | Saving |
ShaderLibrary | enum | Gets a Metal library, whether or not anything compiled one at build time. | Your first game |
ShaderLibraryError | enum | Why ShaderLibrary could not supply a library. | Your first game |
ShadowAtlas | class | Shadow maps for the lights that are not the sun, packed into one texture. | Shadows |
ShadowAtlasError | enum | Why a ShadowAtlas could not be made: which of its objects the device would not create. | — |
ShadowBatch | struct | One kind of geometry for a shadow pass: a pipeline, and how to reach each thing drawn with it. | — |
ShadowBias | struct | The rasterizer's depth bias for a shadow pass: a constant part and a part scaled by the surface's slope to the light. | — |
ShadowBufferIndex | enum | Where a shadow pass's argument table puts each thing, and therefore what a game's shadow vertex function must declare. | — |
ShadowCascades | struct | Where the shadow cascades begin, end, and hand over to each other. | Shadows |
ShadowCubes | class | Shadow maps for lights that radiate in every direction: a cube per light, six faces each. | Shadows |
ShadowCubesError | enum | Why a ShadowCubes could not be made: which of its objects the device would not create. | — |
ShadowMap | class | The sun's shadow pass: the scene recorded from the light's point of view, once per cascade. | Shadows |
ShadowMapError | enum | Why a ShadowMap could not be made: which of its objects the device would not create. | — |
ShadowPass | struct | Which pass a self-encoding ShadowBatch is being asked to draw into: so it can draw only what that pass can see. A sun cascade near the eye covers a few meters; drawing a whole wood into it was three quarters of a measured frame. | — |
Skeleton | struct | A rig: named joints, who each joint hangs off, and where the mesh was bound to them. | Skeletons and clips |
SkeletonError | enum | — | Skeletons and clips |
SkeletonPose | struct | A rig with a pose on it, and the matrices a vertex shader needs to wear it. | Skeletons and clips |
SkinnedGeometry | struct | A character's geometry at rest, every skinned mesh in its file merged into one, read with no GPU. | — |
SkinnedInstance | class | One character drawn from a SkinnedModel: its pose, and the GPU memory that pose is drawn from. | — |
SkinnedModel | class | A skinned character as the GPU holds it at rest — one per character file, shared by every character drawn from it. | — |
SkinnedModelError | enum | — | — |
SkinningPass | class | Skins characters once a frame: one compute dispatch each, before anything draws them. | — |
SkyPass | class | Draws a DaySky behind a scene: a full-screen triangle at the far plane, the zenith fading to the horizon, the ground's colour below it and the sun's disc — and, when given them (2026-11-16), the night's stars, Milky Way and moon with its phase (NightSky), and the clouds over all of it: CloudPass's volumetric picture, or a flat layer. | — |
SnowCap | enum | Snow that builds up on roofs and props (2026-11-16): a cap made from a prop's upward-facing surfaces when it loads, which a renderer raises with the lying snow — a dusting to a thick, rounded slab on a roof, a rail or a rock. | — |
SoundArea | enum | An area's outline on the ground: whether a point is inside, and how far it is from the edge — what ambience fades by and where a scattered sound may land. | — |
SoundReach | enum | How far a sound carries, set per sound: full near it, fading to silence at its reach. | — |
Soundscape | class | A world's sounds, played as its editor laid them out (WorldFile/Sounds): loops at places that start as the listener comes within their reach and stop when they are left behind, ambience that rises and falls by area — and gives way to its night loop as the light goes — sounds now and then, by day, by night or always, and the world's music. | — |
SoundVariation | struct | Which take of a sound to play, and how to vary it. One take played five hundred times is the commonest way game audio grates. | — |
SplashScreen | struct | The engine saying its own name: a lockup of EngineMark and the name over a ground, for as long as a game wants and no longer. | The splash |
StaticVolumes | struct | Many volumes that never move — a level's scenery — that a shot can be tested against without visiting them all. Volume/firstHit(segmentFrom:to:against:) tests every volume it is given and recomputes each one's world bounds as it goes, which is right for things that move and right for a few hundred of anything. | — |
StickCalibration | struct | What a particular thumbstick actually does when nobody is touching it. Every stick rests somewhere other than zero, and a worn one rests further out. | — |
StickResponse | enum | Turns a raw thumbstick reading into something usable. | Input and settings |
StickRest | struct | Watching one stick sit still, and deciding what that means. Two different faults look the same from the sofa and are not the same. | — |
StrideAlignment | struct | Where in its own cycle each gait reaches the same moment of the stride, so gaits blended at one phase blend one stride. | — |
StrideClock | struct | One phase for every stride clip: the walk, the run and each of their directions sampled at the same moment of the stride, so a blend of two of them — neighbouring directions, or a gait handing over to the next — is a blend of one stride, and a clip easing in starts with its feet where the others' are. | — |
Sway | enum | How a prop moves in the wind (2026-11-16): a tree bends from its trunk with its leaves fluttering, a plant — grass, reeds, a bush — bends harder, cloth — a flag, a banner, a tarp — ripples, and anything else stands still. | — |
TextureOrigin | enum | Which corner of the image the mesh's v = 0 is meant to land on. | Materials and textures |
TextureSlot | enum | Which map a texture is, and therefore how it must be read. | Materials and textures |
TextureSource | enum | Where a texture comes from, before anything has loaded it. | Materials and textures |
TextureStore | class | Loads textures once and hands the same one back after that. | Materials and textures |
TextureStoreError | enum | — | Materials and textures |
ToneMapping | struct | How radiance becomes a picture: an exposure, and a curve that fits an unbounded range into the zero-to-one a display can show. | Tone mapping |
TransformHierarchy | struct | Things that hang off other things: a lamp on a hand, a turret on a hull, a sight on a rifle. | Hanging things off joints |
TransformHierarchyError | enum | What is wrong with a TransformHierarchy that could not be built, or with local transforms it was given. | — |
Volume | struct | Something a round can hit: an extent, and where it currently is. | Hanging things off joints |
VolumetricFog | class | Volumetric fog and sun shafts (2026-11-16): the air in front of the eye as a grid of cells — a column every GraphicsSettings/FogQuality pixels, sliced deeper the farther they are, out to far — lit by the sun through the shadow map, so it throws shafts through gaps in trees, clouds and doorways and shadows fall through the haze; by the clouds' shadows; and by the world's lights, which glow in it. | — |
Waymark | struct | The way to a place, shown for a few seconds: a line over the ground from where a player stands, along the way they can walk, and a beam of light standing up from the place itself — what a player asks for when they press a button to find where to go next. | Showing the way |
WaymarkRenderer | class | Draws a Waymark in its Waymark/Look: floating marks each a square turned to face the view — a dot stays round from any angle, an arrow points along the line on screen — or marks on the ground as a ribbon lying flat over it, as paint; a floating line as a ribbon facing the view. | Showing the way |
WaymarkRendererError | enum | Why a WaymarkRenderer could not be made. | — |
WaymarkScan | struct | A scan sent out from where a player stands: a ring sweeping out over the ground to its reach, and every thing it passes outlined, seen through walls, with an icon and its distance over it for a few seconds — the icon a little longer, so it can be walked to. | Showing the way |
WaymarkScanRenderer | class | Draws a WaymarkScan: the ring as a band over the ground with a faint curtain of light above it, seen through walls; an outline round each found thing, seen through walls, from a mask of their shapes (encodeMask(_:viewProjection:width:height:frameSlot:into:)) — Unreal's custom-depth outline, a band round each shape and a faint fill inside it; and an icon over each in its kind's colour, with its distance beneath, a fixed size on screen and over everything. | Showing the way |
WaymarkSound | enum | What a Waymark sounds like as it appears (Waymark/Look/sound): made here, not recorded, so a game ships nothing for it and an editor can play it. | Showing the way |
Weather | struct | A world's weather: cloud, rain or snow, wind, fog and lightning, as a few numbers a game draws and hears the same way an editor showed them. | — |
WeatherCover | class | What is overhead, around the eye: the world drawn from straight above into a depth texture, so WeatherRenderer keeps rain and snow out from under a roof, a bridge or a tree, and lands its splashes on whatever is uppermost. | — |
WeatherCoverError | enum | Why a WeatherCover could not be made. | — |
WeatherRenderer | class | Draws a Weather's rain or snow, falling round the eye, pushed by its wind, kept out from under a roof by a WeatherCover, and — for rain — splashing where it lands. | — |
WeatherRendererError | enum | Why a WeatherRenderer could not be made. | — |
WeatherSchedule | struct | Weather that changes by itself: spells of one kind after another — clear for a while, cloud, a shower, clear again — each as heavy as a pick within a range, the wind turning a little each time, one spell blending into the next. | — |
WeatherSurface | struct | The frame's weather, as a game's own shaders read it — DUWeatherSurface in DuctaneWeather.h, field for field. | — |
WorldBoundary | struct | The edge of a world: a shell round the whole map that nothing in it leaves — a dome, or walls with a ceiling — and, under its floor, a net that catches anything that falls out. | The edge of the world |
WorldClock | struct | A world's clock (owner, 2026-11-16): the time of day running by itself, the season turning on a game calendar, and the latitude the sun moves at — all from one shared time, so every player sees the same hour and season. | — |
WorldFile | struct | A world as a game reads it: what a world editor writes beside a scene's props so a game can draw it and walk it without the editor — every prop placed and what it wears, the ground, the sky and lights, water, streams and living effects, the world's edge, what a walker passes through and what it meets, and the scene's markers. | — |
WorldGround | struct | A world's ground, read from the files WorldFile/Ground names: heights to stand on and a mesh to draw, both from the same grid, so what the player stands on is what they see. | — |
WorldGroundError | enum | — | — |
WorldGroundRegion | struct | A patch of a ground's grid points: what an edit changed, and so what has to be written again. | — |
WorldGroundSource | protocol | The ground a WorldRenderer draws: a square grid centred on the origin, resolution cells a side, size metres across, written into the renderer's vertices a patch at a time — so an editor's brush stroke writes only the patch it touched, sixty times a second, and the renderer never keeps the ground itself (keeping it would make every edit copy it). | — |
WorldPackage | struct | A scene package, opened for a game: a .usdz holding a scene, every prop it places with its textures, and the world description a game reads (WorldFile, at descriptionPath), with the ground and collision shapes beside it. | — |
WorldPackageGround | struct | A scene package's ground, as a WorldRenderer draws it: the heights, painted colours and holes of WorldPackage/ground(), how soft each point is from its painted layers, and where puddles gather as the editor worked it out. | — |
WorldRenderer | class | Draws a world: the ground, painted, with its holes, puddles and fallen leaves; every placed prop and scattered copy, instanced, culled and levelled by their size on screen — far ones as their far pictures; the sky, the night sky and the clouds; the sun's shadows; point lights; still water and streams; living effects; the weather — rain, snow lying and built up on props, wet ground, footprints, lightning; volumetric and ground fog; the seasons' colours and the wind in what moves. | — |
WorldRendererError | enum | Why a WorldRenderer could not be made. | — |
WorldScene | struct | What a WorldRenderer draws: every prop placed and scattered, by file, with the materials it wears; the sky, the weather and the world's clock; water, streams, living effects and lights; the world's edge; and what each prop does in the wind and through the year. | — |
WorldWaterGrid | struct | Whether a point is under a scene's water, without asking every rectangle (2026-11-01). | — |