flutter3d_game library

What a game on flutter3d adds to an application: the devices it is played with, the run being played, the settings and saves a player keeps, and what a level's simulation moves, drawn.

The one facade of the engine. It re-exports flutter3d; from flutter3d_app what a first game opens a window with — Flutter3dView, which opens the device, makes the renderer, runs the loop and owns focus and the lifecycle, the Flutter3dEngine it hands a game, and LevelLoader; and, by name, the level, the step loop and its input from flutter3d_sim, the collision world from flutter3d_physics and the listener and emitters from flutter3d_audio_core — so a first game takes two imports, Flutter's material.dart and this, and no hide. No other package of the engine re-exports another's API to save an import (tool/structure.dart holds the list). The low level under the view (opening a device, presenting a frame, SceneSurface, the frame clock) is flutter3d_app's, for the game that needs it, and is not re-exported here. Everything else in flutter3d_app, flutter3d_sim and the physics stays theirs: a file that needs more imports them, and its package depends on them. The modeller and the lessons use those and never this one, which is the line this package exists to draw.

Input that has forgotten which device it came from: DesktopInput, PadInput and the ActionMap between a device and a GameAction, with Accommodations and GameSettings beside them.
The run. RunSession loads a level, restarts it, moves to the next, saves and resumes; RunTimeline scrubs and branches what a run has recorded, and registerTimelineExtensions lets a tool attached to a running game ask it to.
What a player keeps: GameSettings and the GameSettingsController that writes it, Rebinding, and the files SaveFile, SettingsFile and DemoFile.
What a level's simulation moves, drawn: ActorVisuals and FixtureVisuals, with the look decided by the game through ActorAppearance and FixtureAppearance, and SoundOcclusion for a wall between a listener and a source.
The walk a level starts with: LevelWalk, a body that collides, jumps and runs, turns where it is dragged and carries a camera at eye height, and registryFor, which accepts every type a level names before a game has taught it any.

What is deliberately not here: widgets. The touch controls, the settings panel, the credits, the automap and every screen around a game are flutter3d_game_ui's, which stands on this package; this one names none of them, so a test or a replaying server that reads the settings and the run resolves no screen. Nor is there a state-management choice for the run — RunSession is an ordinary class.

Classes

AbsolutePixels: A fixed size, for anything whose extent is its own business — a shadow atlas is the same size whatever the window is doing.
Accommodations: What the player has already told the operating system.
AcousticProperties: How a material meets sound: what a surface of it absorbs, band by band, and how fast sound crosses it.
ActionBinding: One way a device reaches an action.
ActionDeclaration: One action a game declares, with what a player is shown for it.
ActionInput: Turns what sources are doing into action values, for the bindings of an ActionMap that are not buttons.
ActionKind: What kind of value an InputAction carries.
ActionMap: The actions a game declares and every device's way to each: a game's controls, as one object a player edits and a file keeps.
ActionSet: The actions a game or a genre declares: what a player can ask for, of which kind, in the order a rebinding screen lists them.
Activated: It did what it was asked.
Activation: Who is switching something on, and what they are carrying.
ActivationOutcome: What came of asking a mechanism to do something.
Actor: The handle on one actor's entity: what a collider's userData holds, so a hit, a blast or a lift can ask it is Damageable or is Rider. Every field it answers is a component read.
ActorAnimations: Actors' animation graphs stepped by the simulation — N1: where an animation is part of the game rather than a picture of it.
ActorAnimationWrite: What ActorAnimations.write is handed each step for an actor with a graph: the actor, its graph and where it wished to go.
ActorAppearance: What a monster is made of, which is the one thing the bridge cannot know.
ActorClipsContext: What ActorAppearance.clipsFrom is handed: the actor and what the simulation published of it.
ActorCorpses: What becomes of a modelled actor when it dies, in place of its death clip — N1.
ActorCue: One actor's direction from step until its next: who, what, and where.
ActorCueKind: What a cutscene tells an actor to do.
ActorDeathContext: What ActorCorpses.begin is handed, once per death: the actor, its model, and the motion it died in.
ActorDied: An actor's health reached zero this step.
ActorDirector: Something that takes actors out of their brains' hands for a while — a cutscene's director. See ActorSystem.director.
ActorDressContext: What ActorGraphs.dress is handed, once per graph, for the reason ActorMachineContext gives.
ActorDriveContext: What ActorGraphs.drive is handed, once a frame per actor, for the reason ActorMachineContext gives.
ActorGesture: What ActorStrides.gesture is handed: the actor and the gesture's name.
ActorGraphs: A modelled actor animated by a graph rather than by naming clips — N1.
ActorHurt: An actor took damage this step and survived it.
ActorMachineContext: What ActorGraphs.machineFor is handed: the actor and the clips its model has.
ActorMarkerPassed: A marker an actor's animation graph passed in one ActorVisuals.animate: whose it was, in which state, and its name.
ActorStride: What ActorStrides.strideOf is handed: the actor, the brain's wish and the step's length.
ActorStrides: Where an actor's own animation walks it — the seam root motion comes into the simulation through.
ActorStridesRestore: What ActorStrides.restore is handed: what ActorStrides.save wrote, and the actors as the restore left them.
ActorSystem: Every actor in a level: spawning them, stepping their brains and bodies towards the foci, counting the hurt and the dead, and saving it all.
ActorVisuals: Where the monsters are, and which way they are facing.
AdaptiveQuality: Chooses a QualityRow of table each frame.
AdaptiveQualitySettings: What the controller aims at, and how cautiously.
AdaptiveScale: The scale to draw the next frame at, decided from the ones before it.
AdaptiveScaleSettings: How far the resolution may be pulled, and how fast.
AmbientOcclusionMethod: How the occlusion pass finds what hides a point — L5.
AmbientOcclusionSettings: Screen-space ambient occlusion.
AnimationBlend: How a layer's pose meets the base's — gfx-10n.
AnimationBlendSpace: Clips blended by a parameter — a one-dimensional blend space: a walk at one speed and a run at another, and between them some of each.
AnimationClip: A named set of tracks that play together.
AnimationComparison: How a CompareCondition measures a number parameter against its value.
AnimationCondition: One test a transition makes against the graph's parameters.
AnimationGoal: Where a pose's joints are made to reach or to look, after its states and layers have posed it — the IK nodes of N1.
AnimationGraph: Runs an AnimationStateMachine over a set of clips, one fixed step at a time, into a Pose — N1's core.
AnimationGraphJson: An AnimationStateMachine as JSON, and back — the shape a model file keeps its animation graphs in and an agent's tool builds one from.
AnimationGraphLayer: A graph of its own over part of a skeleton, laid on another's pose — the layers of N1: a reload over a run, a flinch over a walk, a look over whatever the body is doing.
AnimationInterpolation: How a track's values are blended between keyframes.
AnimationLayer: A clip played over part of a skeleton, on top of whatever the base is doing.
AnimationMarker: A named moment in an animation: at seconds into a clip, or a share of a state's cycle — see where it is held.
AnimationMarkerPassed: actor's animation passed marker name in state this step.
AnimationMask: The joints one animation layer writes, by node index.
AnimationParameter: One named parameter in a graph's schema, with the value it starts at.
AnimationParameters: The current values of a graph's parameters, held to its schema.
AnimationParameterSchema: The parameters a graph has, by name and type — the only ones a write may name.
AnimationParameterType: What kind of value an animation graph parameter holds — N1.
AnimationPath: Which node property a track drives.
AnimationPlayer: Plays AnimationClips onto animation targets.
AnimationPointer: One resolved pointer: property of the indexth object of its kind.
AnimationPointerProperty: The property a pointer drives, with the number of floats in one value.
AnimationPointerSink: Where a pointer track's sampled value goes.
AnimationPointerTarget: The kind of object a pointer lands on.
AnimationPose: A flat, scene-graph-free pose: one hierarchy's local TRS, sampled from a clip and composed into world and joint matrices without ever touching a SceneNode — anim-01's own row.
AnimationState: A state: which clip plays while the graph is in it, and how.
AnimationStateMachine: The states, transitions and parameters of one animation graph — what a file stores and an editor edits. AnimationGraph is what runs it.
AnimationTarget: What a player can drive.
AnimationTrack: One animated property of one node.
AnimationTransition: A way out of one state into another.
AnimationWrap: How a clip behaves when it runs off its end.
AntiAliasSettings: Edges smoothed on the finished picture — gfx-04n's own row.
AssetByteRange: The bytes from start up to end of a file, end not included; to the end of the file when end is null.
AssetCancel: A read called off: the signal a reader keeps and a source watches.
AssetProgress: How far a read has come: received bytes of total.
AssetRead: What a reader asks of one AssetSource.read: progress, a way to stop, and the bytes it wants.
AssetRequest: What a resolver is being asked for.
AssetSource: Where a model and its sibling files live.
AssetSources: Which AssetSource a path names, by its scheme.
Assimilation: The place inside the step where outside state meets the model: a twin's Kalman filter, a valve set to what the plant reports, a headset's pose put on the camera rig.
AssimilationContext: What an Assimilation is told about the step it runs in.
AtLeastOne: There should be at least one of a type, or the level is missing something.
Atmosphere: What the air looks like at one moment: the sky behind everything, the fog, the sun and the ambient light.
AtmosphereCycle: Atmospheres keyed by time over a repeating period, blended between the keys either side of a time: a day and night cycle.
AtmosphereKey: One key of an AtmosphereCycle: the air the cycle shows at a time.
Attenuation: How a sound gets quieter with distance.
AudioBackend: What actually makes noise.
AudioBus: A group of sounds that a player can turn down as one.
AudioEmitter: One sound, somewhere, possibly moving: the emitter component of the audio model.
AudioListener: Where the ears are.
AudioScene: Decides what is heard, and how loudly.
AutoExposureSettings: How the frame's own brightness decides its exposure.
Automap: The level as the player has seen it, from above.
Autosave: When a run is written down without the player asking.
Avoidance: How a body picks a velocity that keeps it clear of its neighbours.
AvoidanceNeighbor: One body another steers round: where it is, how it moves, how wide it is, all in plan.
AvoidanceVelocity: The velocity Avoidance.velocity picks for a body, in plan.
AxisAction: One number in [-1, 1] the player asks for: how hard to pull a crane's rope up or let it down, how far to turn a wheel.
AxisBinding: One analogue number on an AxisAction: a trigger, one axis of a stick, a band under a thumb.
AxisComposite: Two buttons as one AxisAction: the axis is one while positive is held, minus one while negative is, and nought for both or neither.
AxisSettings: How an analogue source is shaped on its way to an action: a dead zone, a sensitivity, and which way is up.
BakedPoses: A clip's worth of joint matrices, ready to become a texture.
BehaviorBrain: A brain that is a behaviour tree: it ticks tree over the actor's Blackboard and keeps what it heard and when it was hurt on the board.
BehaviorChildren: The children of a registered BehaviorComposite, as it may tick them.
BehaviorComposite: A composite kind's code: what to do with its children.
BehaviorCompositeTick: What a BehaviorComposite.step is handed: the context it ticks in and its children.
BehaviorContext: What a leaf may look at while it ticks or acts.
BehaviorKinds: The table from a node's kind to its code: leaves, considerations and composites, the standard ones and a game's own.
BehaviorLeaf: One leaf kind's code.
BehaviorOverlay: What every actor running a behaviour tree last decided, drawn where it stands.
BehaviorParameters: A node's own fields, read with the problems written down rather than thrown, so that a document is checked in one pass.
BehaviorPathStep: One node on the running path, for whoever draws or prints it.
BehaviorsRead: A LevelRule a game brings with its own kinds: every tree in Level.behaviors reads, and every entity's property names one of them.
BehaviorStatus: How a node came out of its last tick.
BehaviorTree: A behaviour tree read from a document: shared by every actor running it, each keeping its own state on its Blackboard.
BehaviorTreeRead: What BehaviorTree.read made of a document: a tree, or why not.
BehaviorView: What the overlay may look at outside a step, when there is no mind.
BindingConflict: A source that something else already uses, found by a rebind.
BindingInterpolation: How a bound node follows its component between two simulation steps.
BindingLifetime: When a bound node is made and taken away.
Bindings: What each thing on a device does, and the only place that answers it.
Blackboard: One actor's memory for its behaviour tree: named JSON-shaped values, its own clock, and where in the tree it was, all saved with it.
BlendFactor: One term of a blend equation.
BlendOperation: How the two blend terms are combined.
BlendPoint: One clip of an AnimationBlendSpace, played where its parameter reads at.
BlendState: How a draw is combined with what the attachment already holds.
BloomSettings: How much of the frame's light spills into a glow.
BodyForce: A force on a body that depends on the body's state: a spring to a point, a planet's pull, a field. Added to Dynamics.forces.
BodyForceContext: What a BodyForce is asked at: one body at one state of it.
BodyPose: Where one body was at one recorded step: what PoseRecorder.record is handed. The vectors are copied, so a caller may pass the body's own.
BoolCondition: A boolean parameter being value.
BoxEmitter: Anywhere inside a box. Rain over an area, dust in a shaft of light, embers rising off the whole width of a fire rather than out of one point.
Brain: What decides for an actor: where to go, what to do when hurt, heard or killed. Every hook has a default that does nothing.
BrainHurt: What Brain.onHurt is handed: the actor's mind and how much it was hurt by.
BrainNoise: What Brain.onNoise is handed: the actor's mind and where the noise was.
Breaches: The holes a run has blown in its level, and the level with them in it.
Brush: One axis-aligned block of level geometry.
BufferDescriptor: A general buffer — GraphicsDevice.createBuffer.
BufferLayout: One buffer's worth of attributes, and how far apart its elements are.
BufferTextureLayout: How texel rows sit in a buffer on either side of a buffer–texture copy.
BufferUsage: What a general buffer may be used for, fixed when it is made.
BugReportTape: The state a bug report's tape starts from, and everything since.
BundleAssetSource: A model in the Flutter asset bundle.
BundledMaterials: The lighting models of the materials a bundle was built from, read off the sources the bundle carries — P8.
BusChannel: The two ways an event reaches its subscribers.
BusEffect: Something a mixer bus does to everything routed through it, beyond its volume: a filter, a reverb.
BusEvent: Something that happened, published on the engine's bus.
Button: A panel on a wall that fires its target when the player presses use.
ButtonBinding: A button held or not: a key, a mouse button, a pad button.
ButtonKind: Kinds built on a trigger collider: a button, a trigger volume and an exit. Grouped because all three place a ColliderKind.trigger and drive a Signal or Exit from it, rather than a kinematic body.
ButtonPair: Two buttons an older tape recorded an axis as: the axis is the positive one's value less the negative one's.
CameraBlend: How the view gets from one virtual camera to the next.
CameraFraming: Where a virtual camera wants to be this frame.
CameraKey: One camera key: where the eye is, what it looks at, how wide it sees — the vertical field of view in degrees, forty-five unless the document says, which is the engine's own lens, so a cutscene that names none cuts to it without the picture changing size.
CameraNode: A camera placed in the scene graph.
CameraRig: The part of a chasing camera that every chasing camera has.
CameraShot: What a camera shows this frame: where it is, what it looks at, and how wide.
CameraView: One camera drawing into one target, as an object that lives across frames — item 26 of the 1.0 scope.
CameraViewSettings: The settings of one CameraView that are not its camera, target or rectangle — the object its growing parameters go into, so that adding one in a minor release changes no constructor.
CanvasSize: How big the frames a view draws are, in device pixels — and with them the canvas a browser shows them in: the layout's size times the pixel ratio (CanvasSize.layout, the default), or a size the application fixes (CanvasSize.fixed).
Capability: Something a device, a backend or a platform may or may not do, by a stable name: a graphics device's DeviceFeature, a renderer's or a platform's own.
CapsuleShape: Capsule: a cylinder of height closed by two hemispheres of radius.
CapturedImage: One resource as one pass left it.
CapturedPass: One pass of a captured frame.
CaptureThumbnail: A small copy of a CapturedImage — A5.23: what a capture file keeps of an image when it does not keep the image.
CatchUp: What the loop does when a frame brings more time than it may step.
CatmullRom: A smooth curve through a list of control points, measured in metres.
CellGrid: columns by rows cells, each there or gone: a Space Invaders shield, a wall of bricks, a field of crops.
ChangedBounds: Where a difference lives in the frame, in pixels.
CharacterController: Moves a box through a CollisionWorld the way a player expects.
CharacterMove: What CharacterMover.move is handed: move body from where it is by delta, sliding along what it meets and taking the speed into it out of the body's velocity; standing on ground whose normal's height is at least walkableNormalY; and, when mayStep — it stood on ground — climbing up to stepHeight where that gets further than sliding does.
CharacterMoved: Where a character's move ended, and what it met on the way.
CharacterMover: The geometry of a character's step, done elsewhere — P9: the physics core moves a world's characters through what it mirrors of that world.
CharacterPush: What RigidDynamics.push is handed: who is walking, how fast, and how hard.
ChaseFraming: Behind where a subject is going, looking a little way up the road, and wider the faster it goes.
CheckedModelWriter: A writer whose files this package can also read, so a write can be checked by reading it back — what exportChecked does.
CheckerboardTexture: Two-tone checkerboard.
ClearColor: What a colour attachment is cleared to: four channels of one kind.
ClearColorKind: Which kind of target a ClearColor is for.
ClipAxis: One axis of a TemporalClip's slabs: a unit direction in the weighted YCoCg colour space the temporal resolve clips in.
ClipDistances: A near and a far clip plane, as distances from the camera: what OrbitController.suggestedDepthRange answers.
ClothMesh: A grid of particles and the constraints between them, as flat arrays — the shape every hot loop in this package walks without an allocation.
ClothObstacle: One CollisionShape, positioned, for a cloth to push itself out of.
ClothSettings: How a ClothMesh moves, as values rather than as solver internals.
ClothSimulation: A ClothMesh stepped by a world's physics: backend.cloth(mesh), the core where the run is on it and stepCloth where it is on the reference.
ClothStep: What ClothSimulation.step is handed: the settings, the step's length in seconds and the obstacles where they stand now.
CloudDocument: A copy is kept there: its document and the version the store gave it.
CloudEmpty: Nothing is kept there yet.
CloudFetch: What CloudSaveStore.fetch found.
CloudFetchRequest: What CloudSaveStore.fetch is handed.
CloudMoved: Another device wrote since the version a write meant to replace.
CloudProvider: A platform service a player is already signed in to.
CloudPut: What CloudSaveStore.put did.
CloudPutRequest: What CloudSaveStore.put is handed.
CloudSaveStore: Implementable outside this package, as a base class: a member added in a minor release arrives with a default body, so a store written against 1.0 keeps compiling — extends CloudSaveStore, not implements.
CloudStored: The write was kept, and the version the store gave the new copy.
CloudUnavailable: The store could not be reached, or would not do it, and why.
ClusteredIndices: A mesh's cluster table and the indices it cuts into runs, on the CPU — what DrawableGeometry.clusters hands the culling pass.
CodeReplay: What RunTimeline.replayUnderNewCode did.
Collider: A shape, somewhere, that takes part in collision.
ColliderKind: How a collider takes part in the world.
CollisionBox: An axis-aligned box: level geometry, and the player.
CollisionCapsule: An upright capsule: a segment of length 2 * halfHeight with radius around it.
CollisionContext: What a CollisionListener is told: its own collider and the one it met.
CollisionHeightfield: Ground as a grid of sampled heights: the fifth shape, and the first one that is not convex.
CollisionLayers: What each collision bit means in a game of this shape.
CollisionListener: Told when colliders begin, continue and stop overlapping.
CollisionShape: A collision volume, positioned by whatever owns it.
CollisionSphere: A sphere: pickups, projectiles, blast radii.
CollisionWedge: A box with one edge cut away: a ramp.
CollisionWorld: Everything in the level that can be collided with, and the queries over it.
ColorConfusion: Two named colours that someone missing a cone runs together: one pair ColorVision.confusions answers.
ColorHint: A colour of channels components — three for a tint, four when the fourth is opacity.
ColorRole: A colour that means something: what it is for, what the panel calls it, and what it is until the player says otherwise.
ColorRoles: The colours a game gives meanings to, and the ones a player has chosen in their place.
ColorTarget: One colour attachment of a pass.
ColorVision: A colour transform for colour vision: how the picture looks to someone with a deficiency, or the picture moved so that they tell apart what it would otherwise run together.
ColorVisionDeficiency: A kind of colour blindness: which cone is missing.
ColorVisionLook: The look a frame is drawn with for the player's colour vision.
ColorWriteMask: Which channels of a colour attachment a draw may change.
CompareCondition: A float or integer parameter against a number.
CompiledExpression: An Expression ready to evaluate.
CompiledFrameGraph: The result: the nodes to run, in order, what was dropped, and how long each resource has to stay alive.
ComponentCodec<T extends Object>: How one component type is written down, and read back.
ComponentDecodeContext: What ComponentCodec.decode is handed: a row's data and the version it was written at.
ComponentInfo: One registered component type, as a tool lists it.
ComponentRegistry: The component types a world knows how to write, and which of them the view may read.
ComponentRestoreContext<T extends Object>: What InPlaceCodec.restoreInto is handed: the component already there, the row to write into it, and the version the row was written at.
CompositePart: Which part of a composite binding a source drives.
ComputeContext: What a ComputeStep records its work with: where it was placed, its kernels' stages there, and the frame it is part of.
ComputeEncoder: Records one compute pass: bindings, then dispatches, then submit.
ComputeNodePlacement: Where the frame's placer put a node's ComputePlacementRequest: the site its work is encoded on and each kernel's stage there.
ComputePipelineDescriptor: A compute stage and a name: everything GraphicsDevice.createComputePipelineFrom builds.
ComputePipelineHandle: A compiled compute stage, ready to dispatch.
ComputePlacementRequest: What a node that is not a ComputeStep asks with FrameGraphBuilder.place to have compute of its own: kernels loaded where the hardware layer puts them (FrameCompute.place), and the answer handed to it as RenderFrame.placement, a ComputeNodePlacement.
ComputePrepareContext: What a ComputeStep is told when it is placed (ComputeStep.prepare): one object that can gain members — the resources a device keeps for it, what a device lost and found again asks of it — rather than the device alone, which is the hardware interface's to grow.
ComputeRefusalReason: Why a compute step could not be placed.
ComputeSite: Where one piece of a frame's compute runs, as the hardware layer chose it: the device its work is encoded on — since 1.0.0-rc.1.
ComputeStep: A compute pass in the frame graph, run where prepare placed it.
ConeEmitter: A cone around a direction. Muzzle flashes, sparks off a wall, blood.
ConeShape: Cone with the apex at +Y: a cylinder whose top radius is zero.
Confidence: How a value was come by: measured, read from a handbook, or estimated.
ConflictPolicy: What to do when a rebind meets a source already in use.
Consents: The two things a game asks before anything of the player's leaves the device: may their run be kept in the cloud, and may the runs they play be sent to see where levels are hard.
ConstantLaw: A value the same at every state: the catalogue's number with nothing known of how it changes.
ConstitutiveModel: A constitutive model of how a material gives way past the elastic: its model's name and its parameters, as the paper that fitted it gives them.
ContactEvent: Two bodies met, are still meeting, or parted, in a step: a StepContact of the step's dynamics (RigidDynamics.contacts), on the bus.
ContactPhase: What became of a contact since the step before: it begins, it persists, or it ends.
ContactProperties: What two bodies meeting do: what a solver reads at a contact, and how far to trust it.
ContactShadowSettings: Contact shadows: a short march toward the light, in screen space — gfx-76n.
ContributorBoundsContext: What a PassContributor is told when the frame asks where it will draw (PassContributor.boundsFor): one object that can gain members rather than the application's CameraView, which a contributor has no say in.
ContributorFrame: Everything something drawing into someone else's pass is given.
ContributorLights: The scene's lights, bound to a contributor's own stage — N6.
CpuMesh: A mesh that lives only on the CPU.
CrashContext: What a CrashReporter is told: the error, where it was thrown, and the record the log kept of it.
CropProjection: Any rectangle of a larger virtual frame — N8's photo capture.
CubeLut: A parsed .cube file.
CuboidShape: Axis-aligned box centred on the origin.
CullMode: Which faces the rasteriser discards.
CurveKey: One point on a ParticleCurve.
CustomShape: A convex collision volume described by its support function: the short way to a shape a game or a plugin adds of its own.
Cutscene: A cutscene waiting in a level to be played.
CutsceneKind: A cutscene in a level: an entity with its Sequence document in its sequence property, played when something it is the target of fires.
CylinderShape: Cylinder or truncated cone, centred on the origin, axis along Y.
Damage: What Damageable.applyDamage is handed: how much, and who dealt it.
Damageable: Something a rocket can hurt.
DartCloth: The reference: stepCloth on mesh, nothing held besides.
DartFluid: The reference: each solver in Dart, in double precision, as the pieces stepped themselves before there was a core to step them.
DartPhysics: The reference: everything in Dart, on every platform, from the first line. What a world is made with unless it is given another.
DataSection: One named top-level section of a .f3dplugin document, read and installed by the subsystem that owns what the section declares.
DataSectionContext: What a DataSection is told about the plugin it is reading or installing.
DataSectionInstall: What DataSection.install is handed, for the reason DataSectionRead gives.
DataSectionLoad: What DataSection.load is handed, for the reason DataSectionRead gives.
DataSectionRead: What DataSection.read is handed.
DataSectionRegistry: The sections a data plugin may have beyond the runtime's own, each read by the subsystem that registered it.
DataSourceTrace: What every edu_data_source a run read gave, one fixed step at a time — edu-00 §9's "значение из источника... становится вводом для этого шага ленты", written down the same way InputTape writes down a controller: dense, one entry per step, so a replay reads the exact value a run saw rather than a value recomputed from a clock that has since moved on.
DebugColors: Colours used by the built-in overlays, so a screenshot is readable without a legend.
DebugDraw: Accumulates debug line segments into one reusable interleaved buffer.
DebugDrawSettings: Which debug overlays to build for a frame.
DebugView: What a debug view shows in place of the light — P6.
DebugViewKind: What kind of question a DebugView answers, for a tool that lists them in groups.
DebugViewSettings: A channel shown in place of the light, over all or part of the frame — P6 — and a second one beside it — A5.22.
DebugWipeSide: Which side of a two-channel wipe something is drawn on — A5.22.
DecalNode: A picture projected onto whatever geometry stands inside a box — P3.
DecalSettings: P3's projected decals: every visible DecalNode in the scene painted onto the geometry inside its box.
DecodedImage: A PNG decoded down to plain RGBA8 — top row first, four bytes a pixel, width * height * 4 bytes long.
DecoderRegistry: Model and material decoders, and the schemes a path names a source by: the slot a plugin that reads a format fills.
Decoders: ModelDecoders with material decoders beside the model ones: the DecoderRegistry an application that draws hands the plugin host.
Delivered<T extends BusEvent>: One event as a subscriber receives it.
Demo: A run, as a file somebody can send: where it started and what they did.
DemoFile: Where the last run is kept as what the player did.
DemoFound: The document held a run this build plays.
DemoLevelSwap: One level put under a recorded run: level took effect before step step of the tape, that is, after step of its frames had been played.
DemoNotRead: The document is not a run this build can use, and why.
DemoRead: What DemoFile.read made of a demo that is kept.
DemoRecording: A Demo being written while the run is played: the tape, the checkpoints, and HR3's levels swapped in under it.
DemoReplay: What replayDemoOnLoop found.
DepthBias: A depth offset applied to the draws that follow — what keeps a shadow caster from shadowing itself.
DepthMoments: The two moments a probe of an IrradianceField keeps of the distance to what it sees in one direction: what IrradianceField.readDepth answers.
DepthOfFieldSettings: Depth of field, from a lens rather than from a ramp — gfx-34n.
DepthRange: What a backend's clip space maps depth onto.
DepthTarget: The depth and stencil attachment of a pass.
DerivedShape: A shape defined by delegating to another one.
DesktopInput: Feeds an InputState from a keyboard and a captured mouse.
DeterminismCheck: Steps each step twice from a snapshot, in a debug build, and names the system that made the two runs differ.
DeviceClass: A kind of device a build writes its own assets for.
DeviceClassMemory: Where the chosen class is kept between launches.
DeviceClassPicker: The class this device reads its assets as: picked once, remembered, and overridable by the player.
DeviceClassSelector: Which class a device is, from its DeviceTraits and one measurement.
DeviceError: A refusal the device heard after the call that caused it, and survived — GraphicsDevice.errors, since 1.0.0-rc.1.
DeviceErrorKind: The kinds of DeviceError: WebGPU's three error types, and a stage the compiler refused. An open set: a backend may report a kind a later minor names.
DeviceFeature: One optional capability of a device.
DeviceFeatures: The features one device has: a set that answers has, and that can say what it refuses in words a caller can act on.
DeviceLimits: How much of everything a device has: sizes, counts and alignments.
DeviceLoss: Why a device stopped working — GraphicsDevice.lost.
DeviceLossReason: The reasons a DeviceLoss can give. An open set: a backend may report a reason a later minor names.
DeviceLostEvent: What DeviceSettings.onDeviceLost is told: the engine whose device stopped working, and the loss.
DeviceMesh: A MeshData that has been uploaded to a device.
DeviceRecreation: What one DeviceResources.recreate did: how many resources it made again, and the ones whose recipe threw, with what they threw.
DeviceRecreationFailure: A resource DeviceResources.recreate could not make again.
DeviceRegistry<P extends Object>: The backends one engine may open, in the order it tries them, and the presenters of type P that show their frames.
DeviceRequest: What an application asks of the device it opens — since 1.0.0-rc.1.
DeviceResource<T extends Object>: One resource made on a device, and how to make it again.
DeviceResources: The resources made on one device, each with its recipe.
DeviceSettings: The device a Flutter3dView draws with: one to borrow or where to open one, what shows its frames, and what is done when it is lost.
DeviceTraits: What a device says about itself that bears on its class.
DidNotStart: The screen an application shows when it could not open a renderer.
Difficulty: How hard a game is being, as numbers a genre applies where it decides.
DiffuseModel: The diffuse lobe of the metal-rough models, pbr and pbrLayered — L8.
DigestTrace: The digest of a running simulation, taken every so many steps.
Dimension: What a Unit measures: an exponent for each base dimension.
DiscShape: Flat annulus in the XZ plane facing +Y. An innerRadius of 0 gives a disc.
DisplayTime: The time a headset's runtime says each frame will be shown at: what a frame of an XR session hands the loop.
DisplayTransform: A display transform read in place of the tone curve — L2.
Divergence: Where two runs of the same tape parted company.
DocumentAsset: What the source file said about itself, as opposed to what it contains: the tool that wrote it, and who made it and on what terms.
DocumentDifference: One thing a round trip did not preserve.
Door: Opens when somebody asks, waits, and closes itself.
DoorKind: Kinds that move a kinematic body along a fixed offset: a door, a lift and a platform. Grouped together because they share one mechanism — EntityKind.requireTravel, a kinematic collider and a speed/wait pair — and differ only in which Mover they hand it to.
DracoAttribute: One decoded attribute.
DracoAttributeType: Draco's GeometryAttribute::Type.
DracoMesh: What a decoded primitive carries.
DragLook: Looking around by dragging, where there is no pointer to lock.
DrawableGeometry: A mesh that has reached the device and can therefore be drawn.
DrawJournal: Collects DrawRecords while one frame runs.
DrawListContext: What a DrawListHook is asked about one mesh of one view.
DrawListHook: A plugin's say in a view's draw list (D22b): which meshes it keeps, and the order they are drawn in.
DrawnPart: A mesh node an instance draws, with the part of the asset it was built from.
DrawnView: A view a frame drew, with the view-projection it drew through: what FrameHistory.endFrame records for each view.
DrawRecord: One draw, as the encoder saw it.
DriftEmitter: Straight up, slowly. Smoke and dust.
DualAxisAction: Two numbers the player asks for together: a direction to walk, a view to turn.
DualAxisBinding: A pair of analogue numbers on a DualAxisAction: a whole stick, or the mouse's motion for a delta action such as DualAxisAction.look.
DualAxisComposite: Four buttons as one DualAxisAction — WASD as a direction, never longer than one, so a diagonal is no faster than straight ahead.
DualAxisValue: A DualAxisAction's pair in one InputFrame, as InputFrame.dualAxes holds it.
DuckRule: One bus turned down while another is heard: the music under a line of dialogue, the ambience under an explosion.
Dynamics: The reference RigidDynamics: sequential impulses in Dart doubles.
DynamicsRequest: What PhysicsBackend.dynamics is handed.
EcsWorld: The simulation's world. See the library doc.
EdgeSmoothing: How AntiAliasSettings finds and smooths an edge — P1.
EffectiveAntiAliasing: What smoothed the edges of a frame, as opposed to what was asked for — gfx-20n.
ElectricalProperties: How a material carries a current.
EncodedImage: An image still in its source encoding (PNG, JPEG, …).
EngineFrame: What Flutter3dView.onFrame, Flutter3dView.onBeforeFrame and their Scene3D twins are told each frame: the engine that drew it and the frame.
EngineLog: An engine's log: what the engine says about itself, by level, to whoever listens, and the errors nothing caught, to a crash reporter.
EngineLoop: The engine's frame: input, the fixed steps phase by phase, the post-step, then the frame's phases — animate, audio, camera, render, ui.
EntityCheck: What EntityKind.validate is handed: the entity, the level around it, and the list its problems go in.
EntityComponent: One component of one entity, named as an EntityLayout names them.
EntityDef: Anything in the level that is not geometry: a spawn, a monster, a pickup, a door, a trigger, a note on the wall.
EntityKind: Everything one kind of level entity knows about itself.
EntityKindRegistry: The entities a level may name: the slot EntityKinds fills, whose registry() is the EntityRegistry a level is validated and spawned against.
EntityKinds: The entity kinds one engine knows, filled by the plugins installed in it: the level format's half of the plugin host.
EntityLayout: Where in a snapshot the entities are, and what their components are called.
EntityRegistry: The kinds a build knows about, by name.
EntitySpawn: What EntityKind.spawn is handed: the entity and what it is brought into the world with.
EntityTracks: What every entity's components did over a run, one lane of TrackSamples per component.
EntityTypes: The names a level document uses.
EnumHint: One of values, and nothing else.
EnumHintValue: One choice in an EnumHint: what is written into the file, and what a person reads in the list.
EnvironmentCube: A prefiltered environment cube as EnvironmentMap builds it: the texture, whose mip levels hold the environment convolved by roughness, and how many levels it has, which SkySettings's and a material's environment slots want beside it.
EnvironmentDepth: How far away the real world is, from one view, as an AR runtime measures it: width × height distances in meters, row-major from the top left, for the view at view.
EnvironmentDepthNode: The node that puts the real world's depth in the frame, as a texture under id that a node occluding virtual things with real ones reads.
EnvironmentMap: Builds the cube a surface reflects: one environment, convolved by roughness.
EqualPowerPanner: Distance attenuation, occlusion and an equal-power stereo pan: the audio model's spatialisation today.
EventBus: The engine's event bus: typed, with a step channel and a frame channel.
EventCodec<T extends BusEvent>: How one event type is written down and read back: for a digest, a run file's event trace, a network message, a tool that reads events without playing.
EventDeclaration: An event type, declared so tools can list what a game says.
EventDecodeContext: What EventCodec.decode is handed: an event's data and the version it was written at.
EventDigestSink: Where an event writes its identifying fields. Made by the engine.
EventDivergence: The first step at which two runs' events differed.
EventRegistry: The event bus as plugins see it.
EventTrace: The digest of each step's events, kept while a run is recorded.
ExactlyOne: There must be exactly this many of a type, no more and no fewer.
Exit: A way out of the level: reached when a body walks into its trigger or a mechanism switches it on, unless it wants a key the body lacks.
ExitKind: The way out: a volume only the player sets off, 1.5 by 2.5 by 1.5 metres unless sized, leading to next and locked by an optional key.
ExitReachable: A level whose exit no walk from the player's start reaches is refused: the navigation mesh is baked, and a route asked of it from the start to each exit until one arrives.
ExponentialRolloff: (d / reference) ^ -factor. Steep near the source, long tail after.
ExportReport: One write, read back and checked against what went in.
ExposureAdapter: The exposure as it stands, and where it is going.
ExposureMeter: The other end of luminance.frag's encoding, and the arithmetic that turns a texture of stops into one exposure.
Expression: An expression, typed by the parser rather than by whoever reads it later.
ExpressionBinary: A binary operator: + - * / with GLSL's broadcasting (a float beside a vector spreads), the comparisons < <= > >= == != of two numbers of one dimension, and && and || of two truth values.
ExpressionBuiltin: A function the language knows: its name, its arity, how it is computed (apply) and what its result measures (dimension).
ExpressionCall: A call to an ExpressionBuiltin.
ExpressionConditional: condition ? then : otherwise: one of two values of one type, by a truth value. Only the chosen one is computed.
ExpressionConstant: A literal, in coherent SI units, and the one place a vec3(1.0, 0.0, 0.0) that is entirely constant ends up: the parser folds a constructor, a swizzle and a negation whose operands are all literals.
ExpressionConstruct: vec3(...), vec4(...) and the rest, with arguments that are not all constant.
ExpressionNegate: Unary minus.
ExpressionNot: !, the negation of a truth value.
ExpressionScope: What the names in a source mean: the variables the host binds, the builtins it may call and the units it may write.
ExpressionSwizzle: .x, .rgb, .xy — component indices into the target.
ExpressionType: The type of a value in the expression language: its name, how many numbers it has (components) and the dimension they measure.
ExpressionVariable: A name the host binds: a temperature, a body's speed, a material's input. Its value arrives with each evaluation.
ExpressionVisitor<R>: Something that reads every kind of Expression: a translator, an evaluator, a check.
ExternalIdSpace: The spaces of ids other systems know a substance by (PhysicalMaterial.externalIds), by their names as a material's document writes them.
ExternalStateInput: One piece of state that arrived from outside the simulation for one step: a temperature from a plant's sensor, a valve's position from a log, a headset's pose.
F3dDecoder: .f3d through the same ModelDecoder boundary an application's own formats come through, so every built-in reader is one: see builtInModelDecoder.
F3dDocument: A .f3d file, read as a ModelDocument.
F3dExtraSection: A section of a .f3d as its directory describes it: what F3dDocument.section reads back, and what F3dWriter writes beside the engine's own.
F3dModelWriter: .f3d, the engine's own container.
F3dSectionFlags: The bits of a directory entry's flags word (version 2 and up).
F3dWriter: Serializes any ModelDocument into the .f3d container.
FabrikIk: FABRIK — Forward And Backward Reaching Inverse Kinematics — for a chain of any length, anim-14's other row.
Facing: Which way it faces, how fast it comes round, and where its eye sits.
FadeKey: One fade key: how dark the screen is at a step, nought clear and one black.
FbxDecoder: A ModelDecoder for Autodesk's FBX — the skeleton this package's own pubspec.yaml describes: recognises the format, and says plainly that reading one is not built here yet.
FeatureStability: Whether a DeviceFeature has calls behind it yet.
FieldAccess: One step that writes or reads a field: which side of the engine it is on and its name there.
FieldCoordinate: A point in a field's grid, in cells: (0, 0, 0) is the middle of the first cell, (1.5, 0, 0) halfway between the second and the third.
FieldDeclaration: One field: a 3D grid of a quantity shared by the simulation, the frame and audio, and everything a reader needs to know about it before it reads a value.
FieldGrid: How many cells a field has along each axis, and how many values each cell holds.
FieldPass: Two targets, a current one, and the kernels that step between them.
FieldRefusal: Why a field was refused a residence.
FieldRegistry: The fields one engine has, declared by the application and its plugins: host.registry<FieldRegistry>().
FieldResidence: Where a field's values are held.
FieldSide: Which part of the engine a step that touches a field belongs to.
FieldStorage: Where one field's values are held right now: host memory here, a device's buffer or 3D texture in the renderer's core.
FieldTransform: Where a field's grid stands in the world: the middle of its first cell and the size of a cell, axis-aligned with the world.
FieldUpload: The node that puts a host field on a device every frame, in residence: a buffer on a compute device, or a 3D texture on the device that draws.
FileAssetSource: A model on the filesystem. Unavailable on web, which is why it is a separate source rather than a flag.
FileStorage: Documents kept as files, one per name, in a directory this platform owns.
FirstPersonFraming: Out of a head: the eye where the game says, looking where it says.
Fixture: A piece of level geometry that an entity brought with it.
FixtureAppearance: The half of a fixture's look that only the game can know.
FixtureRefreshContext: What FixtureAppearance.refresh is handed: the fixture and the material it is drawn with.
FixtureVisuals: What the doors, lifts, platforms, buttons, keys and lights look like.
FlameFlicker: Fire.
Flipbook: A grid of frames, played across a particle's life.
FlipbookCell: One cell of the sheet, in texture space.
FloatPush: Floating bodies for FluidSolver.pushBodies: each push, in order, lifts a body by the weight of the liquid it displaces for dt and slows it by the drag of the part of it under, implicitly, with White's sphere coefficient at the Reynolds number of the sphere of its frontal area.
FlowField: The distance to the goal from everywhere, and which way is downhill.
FluidMedium: A liquid, by the properties that decide how it moves: how heavy it is, how thick, how strongly its surface pulls, and how it meets a wall.
FluidProperties: How a liquid or a gas flows: its viscosity, its surface's pull and how hard it is to squeeze. Its density is its MechanicalProperties.density.
FluidSolver: The parts of a FluidWorld that are stepped through time, from the run's physics: a backend's fluid, the core where the run is on it and DartFluid where it is on the reference.
Flutter3dEngine: What a Flutter3dView made, handed to Flutter3dView.onCreated once the device is open: the scene to fill, the camera, the loop to add systems and plugins to, and the renderer's single extension point.
Flutter3dPlugin: One plugin: a manifest, and what it registers when installed.
Flutter3dView: An engine as a widget: it opens a device, makes a renderer, runs an EngineLoop with the plugins of plugins, draws scene through a CameraView, and owns focus, input, lifecycle and teardown — item 25 of the 1.0 scope. SceneSurface stays as the low level it is built on, and Scene3D is sugar over this widget for a scene written as widgets.
Flutter3dViewFailure: Why a Flutter3dView shows its failure instead of a picture: what ViewSettings.errorBuilder is handed.
FocusPoint: One of the things ActorSystem.step is told everything pays attention to: where it is, and the body it belongs to, if any.
FogSettings: Distance fog, and fog that lies on the ground.
FollowFraming: A camera that keeps a fixed offset from a subject: follow and look at it.
FootLeg: One leg FootPlantGoal stands on the ground: root → mid → tip, hip, knee and ankle, bent by TwoBoneIk towards pole.
FootPlantGoal: The feet put on the ground the game says is under them: a stair, a slope, a rubble heap the clip was not made on.
FormatDocument: A document read through a FormatSpec, which keeps every top-level key its reader did not take.
FormatRegistry: The formats an engine reads and writes, by id, suffix and first bytes.
FormatSpec: What one format is: its id, its suffixes, the version this build writes, the chain that lifts older documents, and where the fixtures that prove each version still reads are kept.
FormulaLaw: A value given by a formula of the engine's expression language, over the state's quantities by the symbols inputs binds: T, the temperature in K, and p, the pressure in Pa, unless it says otherwise.
FrameCadence: Which display refreshes a frame is drawn on, so that a capped frame rate is an even one — A1.5.
FrameCapture: A whole frame, pass by pass.
FrameContext: What every node and contributor is told about the frame it is drawing in: the view, its matrices and jitter, the clock, and the device.
FrameDemand: When a Flutter3dView draws a frame: on every display refresh (FrameDemand.continuous), or when one is asked for (FrameDemand.onRequest).
FrameDrawn: A frame was drawn: RenderListener.onDrawn, on the bus. About the picture, never the run.
FramedTarget: One subject of a GroupFraming: where it is, how big, and how much it counts.
FrameFraction: A fraction of the frame: full size at one, half at two.
FrameGraph: Collects nodes, then works out the frame.
FrameGraphBuilder: What a node is handed in FrameGraphNode.setup: where it says what it reads, writes, keeps and makes.
FrameGraphNode: A pass, and the only thing an extension has to implement to become one.
FrameGraphPassSnapshot: One pass that ran, as a FrameGraphSnapshot holds it.
FrameGraphSnapshot: A compiled frame graph written down: every pass that ran, in order, with the version of each resource it read and wrote; every pass that did not, with why and what it declared; and what the frame was asked for.
FrameHeld: A frame was held rather than drawn, the GPU being behind: RenderListener.onHeld, on the bus. Nothing in the digest, since whether the GPU fell behind is the machine's, not the run's.
FrameHistory: What each view's previous frame looked like: every moving mesh's world matrix, joint palette, morph weights and instance bytes, and the view's unjittered view-projection, kept while tracking is on.
FrameInfo: What a frame callback is told about one frame: SceneSurface.onFrame, Scene3D.onFrame, and Flutter3dView.onBeforeFrame and Flutter3dView.onFrame beside their engine.
FrameOverTime: A frame took longer than its budget on the CPU: RenderListener.onOverTime, on the bus.
FramePacing: The renderer's pacing: frames in flight, holding a frame when the GPU is behind, and the threshold above which a pipeline build is a stall.
FramePass: What one node of the frame graph cost — gfx-01n's own row.
FramePassSkipped: A pass did not run, with why: RenderListener.onSkipped, on the bus.
FramePipelineRefused: A pipeline the device would not build, its draws skipped: RenderListener.onRefused, on the bus.
FramePipelineStall: A pipeline build over the stall threshold: RenderListener.onStalled, on the frame channel of the bus.
FramePlacementContext: What a FramePlacer is asked about one node.
FramePlacer: Picks where each node that asked to be placed runs, once per compile.
FrameResourceIds: Everything the frame produces or hands around.
FrameResources: The textures a frame's nodes read and write, acquired late and released early.
FrameResourceUse: What one resource of the frame graph stood on this frame: the texture a version of it held last, and how many versions the frame made of it.
FrameResult: One rendered frame.
FrameSpan: What TimeSource.elapsed is handed: the vsync timestamps of the frame drawn last and of the one about to be.
FrameTextureSource: Where a frame's textures come from, and where they go back to.
FrameView: One view of a frame: a monitor's camera, one eye of a stereo pair, one eye a headset's runtime hands over.
FrameWindow: Where a render target sits in a larger frame: the frame is width × height pixels, and the target's top-left pixel is the frame's pixel (left, top). See CameraViewSettings.window.
FrameWorkBudget: How long a frame may spend on work that can be spread over frames. Irradiance probe updates and point-shadow faces ask it today; anything else a frame can put off is meant to ask it the same way.
FramingStep: What CameraFraming.frame is handed: the shot to write and how long since the last frame.
FreeLook: Looking around from where the camera stands, and walking it there.
FreeSurface: The waves on a liquid's free surface in a vessel of any shape: how far the surface stands off the plane it settles to, and how that moves.
FullscreenDraw: One full-screen pass, described rather than assembled.
FullscreenEffect: One full-screen shader over the picture, as a graph node.
GameAction: Something the player can ask for, named by intent rather than by device.
GameCloud: A game's questions and what answering yes turns on, from one server: Consents, the SaveSync its cloud question governs, and the TelemetryUploader its other question does.
GameEvent: Something a step did, told to whoever is watching.
GameOrder: One verb an OrderedGame takes: what it does, and the numbers it reads.
GamepadAxis: Something on a pad that has a magnitude: a stick's two axes in [-1, 1], Y positive downwards as a screen counts, and a trigger in [0, 1].
GamepadButton: One button on a pad, by the stable id a binding file writes.
GameRandom: A 32-bit xorshift generator whose whole state is one readable number, so a snapshot can hold it and a replay draws the same dice.
GameSettingKeys: The settings the engine's own screens and devices read.
GameSettings: Everything a player has changed about how the game behaves for them.
GameSettingsController: The settings screen as a state machine rather than as setState.
GeneratedTangents: What MeshTangents.generateTangents gives back: the mesh with its tangents, and for each vertex it appended at a mirrored seam, the vertex it copiedFrom.
GenrePlugin<S extends Object>: A genre installed into an engine: its step as one named system, its events on the bus, its entity kinds in the level format, and the run it steps — S, set by the game as levels come and go.
GenrePublishContext<S extends Object>: What GenrePlugin.publishEvents is handed: the run and the bus its events go to.
GenreRestoreContext<S extends Object>: What GenrePlugin.restoreSimulation is handed: the run and the state to put back into it.
GenreStepContext<S extends Object>: What GenrePlugin.stepSimulation is handed: the run and the loop's step.
GeometryBuffer: A range of device memory holding vertices or indices.
GeometryUsage: What a buffer will be bound as.
GeoOrigin: A place on the Earth that a world's origin stands on, and the frame the world's axes keep there.
GhostFrame: Where something was at one moment.
GhostPlayback: Reads a recording back, smoothly.
GhostRecorder: Writes down where something was, a few times a second.
GhostTape: A recording: where something was, over and over.
GlbContainer: A parsed glTF container: the JSON document plus the optional binary chunk.
GlbModelWriter: A self-contained glTF binary.
GltfAsset: The decoded result of a glTF or GLB file.
GltfLoader: Decodes glTF 2.0 and GLB into engine geometry.
GltfWriter: Serializes any ModelDocument into glTF's binary container.
GpuFence: A timeline fence: one device signals a value when the work submitted before it is done, and another waits for that value before the work submitted after it starts — DeviceFeature.sharedFences.
GpuFrameTimings: Every labelled pass of one frame, in the order they were submitted.
GpuPassTiming: One labelled pass and how long the GPU spent in it.
GradientKey: One point on a ParticleGradient.
GraphicsDevice: Everything the engine needs a graphics backend for.
GroupFraming: A camera that keeps several subjects in the picture at once.
HasBehaviorTree: A brain that runs a BehaviorTree over the actor's Blackboard — BehaviorBrain, or a game's own that runs one for part of the time — so that BehaviorBrain.pathOf and BehaviorBrain.goalOf can read it whoever wrote the brain.
HdrImage: A decoded Radiance image: three floats a pixel, row 0 at the top.
HeadlessGame: A game, as a tool that plays it blind needs one.
HeadlessRun: One run of a level, started by a HeadlessGame.
HeadlessStart: What HeadlessGame.start is handed: the level, the world it was added to, and the input the run reads.
Health: How much punishment something can take.
Heard: One sound, and where it happened.
Heightfield: Ground as a grid of sampled heights.
HighContrastSettings: A high-contrast look with outlines, for players who see little contrast or little detail — N9.
HitResult: What a ray hit: the mesh, how far along the ray, and where.
HiZOcclusion: OcclusionMode.hiZ: last frame's depths, read back from the GPU and reprojected into this frame's view — C3.
HostField: A field held in host memory: one Float32List, the cells in x, then y, then z order, each cell's components side by side.
HostSkinningHook: A SkinningHook that computes the skinned vertices on the host, as a list of floats, and has the frame upload them.
HttpCloudSaves: Saves kept on a server the game's makers run, over plain HTTP.
HttpTelemetrySink: Sends uploads to a server's POST /api/telemetry/runs, which the reference server in cloud/ answers.
HubAssetSource: A model on the hub, models.pleion.dev, named by its reference.
HubCachePolicy: How a hub model may be fetched and kept on the device.
HubReference: One version of one model on the hub: <uuid>@<n>, optionally followed by #sha256=<64 lowercase hex digits> to check the bytes against.
ImmediateTextureSource: A source that returns textures to the pool at once.
ImpostorNode: An impostor, drawn — the coarsest level a LodGroup can end in.
ImpostorPart: An impostor level's uploaded card and atlases — see ModelAsset.impostors.
IndexedDraw: One indexed draw with every argument: a window of the bound indices, a base vertex added to each, and an instance range.
IndexType: The width of one index.
InelasticProperties: How a material gives way past the elastic: how much of a vibration it turns to heat each cycle, and the models of its large strains, its creep and its flow.
InMemoryDeviceClassMemory: A DeviceClassMemory that lasts as long as the process — the default, and what a test uses.
InPlaceCodec<T extends Object>: A codec for a component that owns something live — a body in a collision world, a brain that is code as much as data — and so is not rebuilt from its data but has the data written back into it.
InputAction<T extends Object>: A named thing the player can ask for, with the type of its value.
InputAttribute: One input of a vertex stage, and where in its buffer it starts.
InputFrame: One fixed step's worth of intent.
InputSource: Something on a device that can be bound: a key, a mouse button, a pad's face button.
InputState: What the player is asking for, as one object that every input device writes into and the simulation alone reads.
InputTape: A run, as the inputs that produced it.
InputTapePlayback: Plays a tape back into an InputState, one step at a time.
InputTapeRecorder: Writes down what a player did, one entry per step.
InsideWalls: The inside of a LiquidBody's vessel as a wall a stream runs along: for a RevolvedVessel, the side and the floor; another shape has no walls yet, and a stream passes through it.
InstancedMeshNode: One mesh drawn many times in one call, each copy with a transform and a colour of its own.
InstanceHandle: One slot of an InstancedMeshNode, taken with InstancedMeshNode.acquire: it follows its instance when a release elsewhere in the batch moves it.
InverseRolloff: Falls off as 1 / distance, which is what sound actually does.
IrradianceAtlas: An IrradianceField packed into one float texture, as IrradianceField.toAtlas lays it out: width × height texels of four floats in texels, the irradiance tiles in a grid columns across and the depth tiles below them from row momentsTop.
IrradianceField: A grid of probes over a box.
IsolateSimulation: SimulationHandle over an EngineLoop running in an isolate spawned for it — the step off the thread that draws (item 19).
Issue: What a library is reporting.
JetLanding: What JetReceiver.receive is handed: volume cubic metres of medium carrying concentrations, arriving at point moving at velocity.
JetObstacle: Something a stream can run into and along — a wall.
JetReceiver: Something a stream can land in — a vessel's liquid.
JitteredProjection: base moved a fraction of a pixel across the screen — R1.
JsonAnswer: What a server answered a JsonPost: its status and its body as text.
JumpLink: One jump the grid allows: from a cell, to a cell, and what it costs a body.
JumpReach: How far a body can jump, from the three numbers that decide it.
KeyEase: How a value travels from one key to the next.
KeyHolder: Something that might be carrying keys.
KeyRing: The keys one body is carrying, by colour.
Ktx2Texture: A KTX2 file, read down to what a texture upload needs: dimensions, an engine TextureFormat, and each mip level's bytes.
LatheShape: A surface of revolution: a profile polyline swept around the Y axis.
LawInput: One quantity of a MatterState a law reads: its id, its unit, and the range the law is valid over.
Layers: The one layer constant that means the same thing in every game.
LensFlareSettings: The reflections a lens throws from a bright light — P2.
Level: Everything one playable space is made of.
LevelApplied: What one LiveLevel.apply did.
LevelBatching: How a level's brushes are grouped into draws.
LevelCheck: What LevelRule.check is handed: the level, and the list its problems go in.
LevelDiff: What changed between two versions of one level, split by who has to act on it.
LevelExtensionAnswer: What answerLevelApply and answerLevelPatch answered: the result to send back, or why the level was not taken.
LevelIssue: Something wrong with a level, and where to look for it.
LevelLight: A light placed by the level rather than by the renderer.
LevelLoader: Reads a level asset and turns it into something playable.
LevelMaterial: How a surface is shaded, named so brushes can share one.
LevelPresent: What LiveLevel.present is handed: the level to show, and what changed.
LevelRecipe: A piece of a level written down as the instruction that builds it.
LevelRule: A whole-level rule a game brings with it.
LevelRules: What a generated level is made of: a grid of cells, each a room or nothing, joined by corridors where two rooms face each other through a doorway — and what stands in the rooms.
LevelScope: What an entity can see of the level it sits in.
LevelSwapped: What LiveLevel.swapped is told: the level the timeline swapped in, and the step it swapped it in before.
LevelValidator: Reads a level and says what is wrong with it.
LevelVisibility: Which parts of a level can be seen from where, decided before the game runs.
LevelWalk: A body that walks a level: it collides, jumps and runs, turns where it is dragged, and carries a camera at eye height.
Lift: Travels to the far end when called, and comes back.
LiftKind: Travels to the far end when called and back, as a Lift.
LightBehavior: How a light behaves over time.
LightBindRequest: What ContributorLights.bind is handed: where to bind, and the sphere the lights must reach.
LightChannels: The bit masks LightNode.channels and SceneNode.lightChannels meet on.
LightEmitter: Something whose particles are a light source.
LightFixture: Something in the level that gives off light and can be seen doing it.
LightFixtureBuild: Everything the bridge has already decided by the time a silhouette is built.
LightFixtureKind: Anything that gives off light and can be seen doing it.
LightGroup: Lights turned up and down together: a car's headlamps, a street's lamps, a room's.
LightingModel: A lighting model: one pre-built fragment shader and what the engine may bind to it.
LightingModelAddon: A view plugin that registers lighting models, and the stages that draw them, while it is on.
LightingModels: The lighting models a document may name in one engine: the engine's LightingModel.builtIn and every model a plugin registered — the open registry, one per engine (D23, D43).
Lightmap: A level's baked light: one texel of irradiance per LightmapLayout cell.
LightmapFace: One face's place in the atlas and its frame in the world.
LightmapLayout: The atlas: its size, its density, and every face's place in it.
LightmapTexel: A texel of a LightmapFace, counted from the face's own corner: what LightmapLayout.texelOf answers.
LightmapUv: A place in a LightmapLayout's atlas as the second texture coordinate: what LightmapLayout.uvAt, LightmapLayout.uvOfPoint and LightmapLayout.neutralUv answer.
LightNode: A light placed in the scene graph.
LightPackContext: What a LightTypeHook is handed for one light: the light, and the row the lit stages read it from, to fill.
LightShaftSettings: Shafts of sunlight through the air, marched through the directional shadow map: the sun's in-scatter added over the scene, which is left untouched behind it.
LightType: What shape a light is, which decides how its contribution is integrated.
LightTypeHook: A light type of a plugin's own, in the light loop (D22).
LightTypes: The light types of plugins' own a renderer packs, each with its code (D22). Reached by a plugin as host.registry<LightTypes>(), beside the render steps it comes with.
LinearBlendSkinning: The engine's own CPU skinning — SkinBlend, the four-joint linear blend mesh_skinned.vert computes — as a HostSkinningHook: every skinned mesh whose source data was kept, skinned on the host and drawn from the uploaded buffer.
LinearColor: A colour in linear light, with straight (not premultiplied) alpha.
LinearRolloff: Straight line from full to silent. Predictable, and wrong.
LineStripNode: A line that grows a point at a time: a missile's trail, a path drawn as the player walks it, a pen on a whiteboard.
LiquidBody: A liquid in a vessel: its volume, the plane its surface settles to, the waves on it, and what runs over the lip.
LiquidLayer: One liquid in a vessel: a medium, how much of it, and what is dissolved in it.
ListenerPose: Where a view's ears are after a frame: Flutter3dView.onListenerMoved.
LiveLevel: The level a running game is playing, and how to change it under the game.
LoadAction: What happens to an attachment's existing contents when a pass begins.
LoadedLevel: A loaded level, in the two forms the game needs it.
LocalExposureSettings: Local exposure by exposure fusion — R7.
LocalRay: A ray: an origin and a direction.
LocalSimulation: SimulationHandle over an EngineLoop in this isolate.
LodContext: What a LodPolicy is asked about one group for one view.
LodGroup: Picks one of several meshes by how much of the screen the object covers.
LodLevel: One level of detail: a mesh, the screen size below which it takes over, and — when somebody measured it — how far it is from the full mesh.
LodPolicy: Which level of detail a group shows (D22b): the engine's rule by screen fraction and pixel error, or a plugin's own — by distance to a point of interest, by a budget of triangles, by importance.
LogLevel: How much a LogRecord matters, from trace to error.
LogRecord: One thing an EngineLog was told.
LogTime: A recorded log's time: each frame advances to the log's next timestamp, whatever the wall clock did.
LookAtFraming: A camera that stays where it is put and turns to watch a subject.
LookGoal: A joint turned to face target: a head that watches, by turning what faced forward at rest towards it, at most limit radians — beyond that it turns as far as it may and no further, which is a monster glancing over its shoulder rather than wringing its neck.
LookSettings: The look put on the frame after it has been tone mapped.
LoopChange: Something about the loop that changed during a run, at a step boundary, and was written down so a replay changes it at the same step.
LoopContext: What a system is told about the moment it runs in.
LoopPhase: A named stretch of the loop that systems are added to.
LoopPluginChange: A plugin was switched or the plugins reordered: change.
LoopRegistry: The loop's phases and the systems in them.
LoopSettings: How a Flutter3dView's loop runs: its step, its input, its profile, where the simulation is, and when the origin follows the camera.
LoopStepRate: The world's step rate became rate at step.
LoopTimeScale: The time scale became scale at step.
LowPassEffect: Takes the top off everything on the bus above cutoffHz hertz: what "under water" and "through a wall" sound like.
ManualTime: Time a person or a test moves by hand: a laboratory that steps when the student presses "step", a test that knows exactly how much time passed.
MapMode: How a buffer is mapped into host memory — GraphicsDevice.mapBuffer.
MappedBuffer: A range of a buffer mapped into host memory.
MaterialAlphaMode: How a material treats the alpha channel, mirroring glTF's alphaMode.
MaterialBindings: What describeMaterial found, in the shape LightingModel takes.
MaterialBlend: How a surface is combined with what is behind it — a state block's blend — version 2.
MaterialBlendMode: How a blended surface is combined with what is behind it — read only when RenderMaterial.alphaMode is MaterialAlphaMode.blend.
MaterialBlockMember: One member of a uniform block of a material's own, where std140 puts it.
MaterialBlockSlot: One uniform block a material binds: MaterialParams, or a block of its own (uniform(Hair) …), with its members in declaration order.
MaterialCatalog: The physical materials one engine knows, by id, and the pairs measured between them: the engine's own (Materials, under f3d.*) and every plugin's.
MaterialDecodeContext: What MaterialDecoder.decode is handed: the file it claimed.
MaterialDecoder: A reader for a material format the engine does not ship.
MaterialDocument: A material as a file of its own, rather than as part of a model.
MaterialExtensions: What a surface has beyond metal-rough: the KHR_materials_* layers glTF adds on top of the core model — M1.
MaterialFileState: What a material's state block says — version 2: how it is drawn, and which light its stage leaves out.
MaterialHint: A kind with the words that go around it.
MaterialHintKind: What a control for one value should look like.
MaterialInput: One value the fragment body can read.
MaterialLet: let name = expr; — single assignment, so nothing here is a variable.
MaterialMap: The maps of a metal-rough material, in the order the layered stage keeps their transforms — C8, LayerInfo.uv_transform and kMapBaseColor and the rest in lib/surface.glsl.
MaterialOutput: out name = expr; — one of materialVertexOutputs, written by a vertex block — version 2. Each at most once, and the block's only way to say anything: it has no return.
MaterialPair: How two materials meet when the catalogue holds a measurement of the pair itself, in place of MaterialCatalog.contact's rule.
MaterialParameter: One declared parameter: a name, a type and the value a variant that says nothing about it gets.
MaterialParameters: A material's parameter values: set and read by ParameterKey from code and by name from data, checked against a schema when there is one, and held as the floats the uniform block is filled from.
MaterialParameterSchema: What a material declares it takes, in the order its source declares it.
MaterialPhase: What state a material is in at its quoted temperature and pressure.
MaterialProbe: What MaterialDecoder.handles is asked about: a file, by name and bytes.
MaterialProgram: A material read from source: its name, what it declares, and its body.
MaterialRemoveUpdate: 4: remove sheen; — name has no meaning from version on, and an instance's value for it is dropped rather than kept for a parameter that a later version may declare again with another meaning.
MaterialRenameUpdate: 2: rename ink -> inkColor; — the value of from is to's from version on.
MaterialReturn: return expr; — a vec4, rgb being the light the surface emits and a its opacity, which is what WriteSurface takes.
Materials: The engine's built-in materials and the pairs measured between them: what MaterialCatalog.builtIn holds.
MaterialScaleUpdate: 3: scale roughness 0.5; — every component of name's value is multiplied by factor from version on: a parameter whose meaning changed scale (a roughness that became perceptual, a size in another unit).
MaterialSlotTable: What a material binds beyond the engine's own: its uniform blocks and its own textures, in a fixed order (D21).
MaterialStageKind: What a source is — version 2 adds the two kinds after material.
MaterialStatement: One statement of a block: a let, a return, an out.
MaterialStatementVisitor<R>: Something that reads every kind of MaterialStatement. One abstract method per kind 1.0 knows; a kind added later defaults to visitUnknown, as MaterialExpressionVisitor explains.
MaterialTextureSlot: One texture slot the material samples, by the name the engine binds it under.
MaterialTextureSlotEntry: One texture of a material's own, by what the source calls it and what it is bound under. A material that names none for it is drawn with a white texel in its place, as an engine texture slot nobody filled is.
MaterialUpdate: One step of a material's updates block — language version 3: how a parameter value written for a version before version changes on the way to it.
Matrix3: 3D Matrix. Values are stored in column major order.
MatterState: The state one body of a material is in: an open set of quantities, each under a namespaced id, and the phase it is in.
MechanicalProperties: How a material holds together and meets another: its density, its stiffness and strength, and its contact.
Mechanism: Something in the level that can be switched on and that has a life of its own between switchings.
MechanismEvents: What the level's machinery did during one step.
MechanismWorld: Every mechanism in the level, and the wiring between them.
MemoryBudget: How much memory may be held, per MemoryCategory and in all, and what is held now.
MemoryBudgetCrossing: A category, or the whole budget, crossing its limit one way or the other — what MemoryBudget.onCrossed hears.
MemoryCategory: What an entry of a MemoryReport is.
MemoryEntry: One line of a MemoryReport.
MemoryReport: What the renderer holds on the device, line by line and by category — Renderer.memoryReport.
MemoryStorage: A Storage in memory: what a test, a replay with nothing to keep, or a preview hands a document class that needs somewhere to write.
MeshBuilder: Accumulates vertices and indices into growing typed arrays.
MeshClusters: A mesh's index buffer read as consecutive runs of triangles, each with a box and a cone of normals — C9, for the scan or the CAD part too big to draw whole every frame.
MeshData: CPU-side geometry: interleaved vertices plus indices.
MeshGeometry: What the scene needs to know about a mesh, without knowing where it lives.
MeshNode: A node that draws a mesh.
MeshOverlay: What a modeller draws on top of the surface: edges, vertices, the selection.
MeshVessel: A vessel whose inside is any closed triangle mesh: its cavity, closed across the mouth, with the triangles wound counter-clockwise seen from outside the cavity, and the rim of the mouth given as points.
MeterRect: A rectangle of the frame, in fractions — what a view occupies.
Mind: Everything a brain is allowed to know, and the few things it may do.
MinMagFilter: Filtering between texels.
MipFilter: Filtering between mip levels.
Mixer: What each bus is turned to, and the one place a volume setting lives.
MixSnapshot: A named state of the mix — "under water", "paused", "boss fight" — that the mixer blends into and out of.
ModelAsset: An immutable, GPU-resident model that can be placed in a scene any number of times.
ModelCamera: A camera decoded from glTF's own cameras, or held for a writer to encode into it — fmt-28's own row, the other half beside ModelLight.
ModelCameraProjection: How a decoded camera projects — glTF's own two, perspective and orthographic, and no others: the core specification defines exactly these two camera.type values.
ModelDecodeContext: What ModelDecoder.decode is handed.
ModelDecoder: A decoder for a format the engine does not ship.
ModelDecoders: The DecoderRegistry the formats fill: the model decoders and the asset sources plugins bring.
ModelDocument: A decoded model, whatever format it came from.
ModelDressed<K>: What ModelWardrobe.onDressed is told: the model just put on a node, and the key it was worn for.
ModelFormat: Which decoder to use.
ModelImpostor: A node baked into two octahedral atlases — C4.
ModelInstance: One placement of a ModelAsset in a scene.
ModelLight: A punctual light, decoded from KHR_lights_punctual or held for a writer to encode into it — fmt-28's own row.
ModelLoadRequest: Everything a decode needs, in one sendable object.
ModelLod: One level of detail a node offers in place of its own full surface list — pro-eng-06's own row.
ModelLook: How one model is worn: which file, and how it is fitted to the node that wears it. See ModelAssetInstantiate.instantiateFitted for length, axis and onGround.
ModelNode: A node in a decoded model's hierarchy.
ModelOrthographicCamera: camera.orthographic — a view volume's own half-extents, both planes required.
ModelPart: One drawable piece of a model: geometry, appearance, and where it sits relative to the model's own origin.
ModelPerspectiveCamera: camera.perspective — a field of view and a near plane, an aspect ratio and a far plane that both may be absent.
ModelProbe: What ModelDecoder.handles is asked about: a file, by name and bytes.
ModelSkin: A skeleton: which nodes are joints, and how each undoes the bind pose.
ModelSplat: A cloud of Gaussian splats a node of a decoded model carries — C1.
ModelSurface: One drawable piece of a decoded model.
ModelSwap: What one ModelInstance.adopt did, by slot key: a node's name, then / and which of its surfaces (s0, s1, …) or level surfaces (l0, …).
ModelWardrobe<K>: Models loaded once by key and put on any number of nodes, including nodes made before the models have arrived.
ModelWrite: What one write produced.
ModelWriteContext: What ModelWriter.write is handed.
ModelWriteFormat: Which format encodeModel/encodeModelInIsolate writes.
ModelWriter: A format a ModelDocument can be written as.
ModelWriteRequest: What to encode, and as which format — fmt-13's own row, the write-side mirror of ModelLoadRequest.
ModeRinging: A surface's modes for FluidSolver.ringModes: each the damped oscillator it is, stepped exactly for dt under gravity g over a liquid depth deep, then held under Stokes' limit.
MorphBlend: Blends a mesh's morph targets into a copy of its vertices.
MorphSink: A mesh whose morph weights an animation can drive.
MorphState: What one drawn mesh is morphing towards, and by how much.
MorphTarget: One shape a mesh can be blended towards, as deltas from its base vertices.
MorphTexture: A mesh's morph deltas, packed the way lib/morph.glsl reads them.
MotionBlurSettings: R6's motion blur: what moved during the exposure, smeared along the way it moved.
MouseCapture: Taking the pointer, so the mouse reports motion instead of moving a cursor, and giving it back.
MovementSettings: Every number that decides how the player feels, in one place.
Mover: A block of level geometry that travels between two places.
MoverState: Where a mover is in its trip.
MovingPlatform: Goes back and forth for ever, whether or not anyone is watching.
MtlMaterial: A material exactly as written in a .mtl file.
NativeHandle: A native object one device hands another, by kind and address.
NativeHandleKind: What a NativeHandle holds.
NavArea: The surfaces a polygon can be, by number.
NavBody: The size of one kind of body a mesh is baked for, as NavMesh.bakeLevelFor takes a roster of them.
NavGrid: A lattice of standing places, and how much room each one has.
Navigation: Somewhere to walk, and the way there.
NavLattice: The lattice a mesh is baked on: where its corner is and how many cells.
NavMesh: Convex polygons over a level's floors, and which of them touch.
NavMeshLink: A jump from one polygon to another the walk does not join.
NavMeshRoute: The polygons a route crosses and the corners a body walks between.
NavMeshSettings: The numbers a navigation mesh is baked to, in metres and radians.
NoAttenuation: Never gets quieter and never pans. Music, narration, the wind.
NodeDeclarations: What one node declared in FrameGraphNode.setup, as the compile read it.
NodeFailure: A node that threw while it ran, and whose it was: what a frame reports for a quarantined pass (PassSkip.failed).
NodeHistory: One node as it was at the end of the last frame it was recorded in.
NothingToDo: There was nothing to do — already open, still moving, or no such name.
ObjDocument: The decoded contents of an OBJ file.
ObjectIdFrame: Which mesh drew every pixel of one frame — what Renderer.captureObjectIds answers with.
ObjLoader: Decodes Wavefront OBJ, optionally with its .mtl material libraries.
ObjModelWriter: Wavefront OBJ, with its .mtl beside it when the document names a material.
ObjNormals: How to fill in normals that the file does not provide.
ObjWriter: Encodes any ModelDocument as Wavefront OBJ, with its .mtl beside it.
ObstacleTouch: Where a parcel is into a JetObstacle: the way out and how far.
OcclusionAffects: Which light a material's occlusion map darkens under the engine's own lighting models: both by default, or the direct or the indirect half alone.
OcclusionBuffer: A small depth-only rasteriser the scene pass culls against — C2.
OcclusionMode: How the scene pass rejects what is hidden behind something else — C2, C3. RenderSettings.occlusion picks one; none is the default and the frame every golden was recorded from.
OcclusionQueryContext: What an OcclusionTest is asked about: one box, and the view it is asked for, in one object that can gain members — the eye of a stereo pair, the layer a view draws — rather than the box alone, which left an XR view no way to say which eye was asking.
OcclusionTest: Whether anything inside a world-space box may be seen this frame.
OffAxisProjection: A frustum whose four sides are given separately, so the axis need not be in the middle of it.
OpenKind: A kind for a type nobody here has been taught: it accepts the type and gives it no meaning.
OpenPath: A path through points, measured by distance along it: where it is at s metres, which way it runs there, and which way is right.
OpticalProperties: How a material meets light: what it bends, absorbs and reflects.
OrbitController: Turntable controls: orbit a node around a target point.
OrbitFraming: Behind and above a subject, on an orbit the player turns: a third-person camera.
OrderedGame: A HeadlessGame played by orders as well as by the stick — a strategy, where a selection is sent somewhere rather than one body walked there.
OriginShifted: The world origin moved: everything the simulation holds in a float32 local frame was moved by the opposite of offset so it stays near zero.
OrthographicProjection: A parallel projection: a view volume height world units tall whose width follows the aspect, with no foreshortening.
OutputTransform: Volumetric light shafts, marched through the directional shadow map — gfx-33n.
OutsideWalls: The outside of a LiquidBody's vessel, thickness out from its inside, as a wall a stream runs along: what a slow pour clings to below the lip. For a RevolvedVessel; another shape has none yet.
OverheadFraming: A view over a map: it pans, it zooms, and it follows nothing.
OverlayBatch: One buffer of overlay vertices, grown rather than reallocated.
PacingContext: What a PacingPolicy is asked before a frame is drawn.
PacingPolicy: Whether a frame is held — the last picture handed back again, nothing drawn — or drawn (D22b): the engine's rule, or a plugin's own (a frame held only when the GPU is two behind, a cap on frames a second).
PackedIndices: Indices packed for GPU upload.
PackedMapSource: One lane of a packed map: the texture it is read from and the channel of that texture's own image it takes. See MaterialExtensions.coatMapSources.
PadDeadZones: The dead zones a player chose, as PadDevice.setDeadZones is handed them.
PadDevice: Where a PadInput reads a pad from.
PadInput: Feeds an InputState from a gamepad.
PadPresses: The pad, as a screen reads it rather than as the game does.
PadReading: What a pad is doing at one moment.
PagedSplatOctree: A splat tree whose pages arrive on request.
PanGains: The two ears' shares of a panned sound: what EqualPowerPanner.gains answers.
ParameterDeclaration: One parameter a material declares: its name, how many floats it is, its default, whether a draw can set it, and the unit its numbers are in when the source says.
ParameterKey<T extends Object>: One parameter of a material, named as its .f3dmat names it, with the Dart type its value is and the unit that value is in.
ParameterType<T extends Object>: How a Dart value of T is laid out as the floats a uniform block reads.
ParameterWrite: What a parameter write did: written, or refused and why.
ParcelFlight: A stream's parcels for FluidSolver.flyParcels: each falls for dt under gravity, in pieces no longer than its radius against walls, running along what it meets; held to a wall it has come off while it is slower than medium's cling speed for its thickness; its ripples grown while it is in the air. Where it lands and whether it parts is the Jet's to say, after.
Particle: One particle, reused for the life of the system.
ParticleAffector: One thing that happens to a particle while it is alive.
ParticleBirth: What ParticleEmitter.emit is handed: the particle to place, and the burst it is born in.
ParticleColorGradient: Drives a particle's colour from a gradient.
ParticleColorOverLife: Moves the colour from one to another across the particle's life.
ParticleCurve: A scalar over a particle's life.
ParticleDrag: Bleeds off speed, so a burst slows into a drift instead of flying away.
ParticleEffect: A recipe for a burst: what is emitted, and what happens to it.
ParticleEmitter: Decides where a particle starts and which way it is going.
ParticleFade: Fades a particle out towards the end of its life.
ParticleGlow: What a source's particles add up to: how much light they are, and where.
ParticleGradient: A colour over a particle's life.
ParticleGravity: Pulls particles down. Sparks and debris; not smoke.
ParticleMotion: Particles of one liquid for FluidSolver.moveParticles: substeps substeps of dt each, every one of them the ParticleFluid solve — pushed out of the walls, pre-stabilised, gravity, cohesion and curvature on the velocities, a predicted move in pieces against the walls, the density held, and XSPH's viscosity.
ParticlePlaneCollision: Stops particles at a level floor, and throws them back up off it.
ParticleSizeCurve: Drives a particle's size from a curve, as a multiple of its birth size.
ParticleSizeOverLife: Scales a particle across its life.
ParticleSpin: Turns a billboard over its life.
ParticleStep: What ParticleAffector.apply is handed: one particle and the step it is advanced by.
ParticleSystem: Every particle in the world, and the one buffer they are drawn from.
ParticleTurbulence: Swirls particles through a standing flow field, so a column of smoke curls instead of rising in a straight line.
ParticleWind: Pushes everything one way, for a draught or the wake of an explosion.
PassContribution: The difference between two frames of the same size.
PassContributor: Something that draws inside a pass it does not own.
PassedMarker: A marker an AnimationGraph passed in its last step: the state it was in and the marker's name.
PassEncoder: A pass that is open, into which draws are recorded.
PassSkip: Why a pass that was registered did not run — gfx-39n.
PassState: A pass's rasteriser state. Unset fields are not emitted.
PassTimestampWrites: Where a pass writes its start and end timestamps.
PassViewport: Where the rasteriser maps clip space: a rectangle of the target in pixels, which may be fractional, and the window depth range clip depth maps onto — PassEncoder.setViewport.
PerspectiveProjection: A pinhole camera's frustum: a vertical angle, a near plane and a far one.
PhaseKind: Whether a phase runs inside the fixed step or once a frame.
PhotoCamera: The camera a paused game hands the player for taking a picture — N8.
PhotoCaptureReport: What a capture did to the game's settings, and why.
PhotoFilter: A look a player picks in photo mode.
PhotoFinish: The vignette and the grain, put over a finished frame at its own coordinates.
Photometric: Lumens, candela and lux — the units LightNode.intensity is in since 1.0 (decision 8 of the API review, docs/CONTRACTS.md "Light").
PhotoRows: One block of a photo's rows, as capturePhoto hands it to its sink.
PhotoSaved: What happened to a picture.
PhotoTaken: A picture taken: what the capture did, and where the file went.
PhysicalCamera: An aperture, a shutter time and a sensitivity, and the exposure they make.
PhysicalMaterial: A substance and what is known of it: its density, stiffness and contact, its flow, its heat, its sound, its light and its current, each a group that may be absent, each naming its source.
PhysicalSky: The air of a planet, for SkySettings.physical.
PhysicalSkyRay: What PhysicalSky.look sees along one ray: the light the air sends towards the eye, what it lets through along the same ray, and whether the ray ends at the ground.
PhysicsBackend: What simulates a world's physics: the bodies, the characters' moves and the rays and sweeps every query asks — one answer for the whole world.
PickRequest: What Renderer.pick is asked: a point of the frame.
PickResult: What Renderer.pick answers: what is drawn at the point asked.
PipeFlow: Pipes for FluidSolver.flowPipes: the liquid in each, a column of it, accelerated by the pressure across its ends over its inertance — its own length over its section, and the liquid standing over each end over that vessel's surface — and held back, implicitly, by Hagen–Poiseuille's friction and the losses where it enters and leaves. Air cannot be pushed through: an end whose surface is below it gives nothing.
PipelineAnchor: An anchor a pipeline adds: a plugin's own, standing right after another.
PipelineDescriptor: A vertex and a fragment stage, the layout their vertex inputs come from, and a name: everything GraphicsDevice.createPipelineFrom links.
PipelineDocument: A frame's pipeline, written down (D44): what a renderer describes of its own frame (Renderer.describePipeline), what an editor edits, what a .f3dplugin's pipeline: section brings, and what RendererSteps.fromDocument applies.
PipelineGeometry: The kind of geometry a pipeline was built for: which vertex stage the material's fragment stage was linked with.
PipelineHandle: A vertex and a fragment stage, linked into something that can be bound.
PipelineNode: One node of a pipeline: where it stands, what it touches, and — for a node of a plugin's own — which kind makes it.
PipelineNodeContext: What a PipelineNodeKind is handed to make one node: one object that can gain members.
PipelineNodeKind: A kind of node a pipeline document can name (D44): what turns a node written as data — a name, an anchor, its options — into a RenderNode.
PipelineNodeKinds: The kinds of node a renderer's pipeline documents may name (D44): a companion of the render steps.
PipelineRefusalReason: Why a backend refused a pipeline — PipelineRefusedException.reason.
PipelineRefusals: One device's record of the pipelines its backend could not build — GraphicsDevice.pipelineRefusals.
PipelineStall: A pipeline build that took PipelineStall.micros on the frame that asked for it — A1.7.
PixelExtent: A width and a height in whole pixels: what a ResourceSize resolves to, and the size of an image read from its header.
PixelJitter: How far off the pixel centre a frame's scene is drawn: what jitterOffset answers and FrameContext.jitter reports.
PlacementRequest: What a node asks of where it runs: a compute step's wish for the device's own compute, a sidecar, or the CPU.
PlainModelDocument: A ModelDocument assembled by hand, from plain lists.
PlanarReflectionSettings: P4's planar reflections: every visible PlanarReflectorNode gets the world drawn again through a mirrored camera, and its surfaces show it.
PlanarReflectorNode: A flat mirror or a still pool — P4: the world drawn again by a camera mirrored in this node's plane, and laid over the surfaces that lie in it.
PlaneObstacle: A flat surface particles rest on — a bench, a floor: the points with normal · p ≥ offset are clear of it.
PlaneShape: Subdivided plane in the XZ plane, normal pointing at +Y.
PlatformCloudSaves: Saves kept by Play Games or iCloud, through the platform's own side.
PlatformKind: Moves on its own timetable rather than waiting to be called.
PlayerSpawnKind: Where the player starts: a coordinate and a facing a game reads, which spawns nothing and checks nothing of its own.
PlayerStart: Where a level's player starts, and which way they face: what Level.playerStart answers.
Playing: How this build is played.
PluginApiVersion: Which plugin API a plugin was written against, and which one the engine provides.
PluginChange: A plugin switched on, off or moved, at a step boundary.
PluginDependency: One entry of a manifest's dependsOn: a plugin id and the versions of it accepted.
PluginDisabled: plugin was switched off and everything it registered withdrawn.
PluginEnabled: plugin was switched on and installed.
PluginGroup: Plugins that go together, in the order they install, at most one per id, taken whole and adjusted where an application needs it to differ:
PluginHost: What a plugin is handed in install: the engine's registries, as this plugin sees them.
PluginManager: The plugins of one engine: checked, ordered, installed, and switched on and off at step boundaries.
PluginManifest: What a plugin says about itself before it is installed.
PluginPermission: Something a plugin says it will reach for beyond the engine's own API.
PluginRegistry: Something the engine owns and plugins add to: loop phases, event subscriptions, render steps, decoders.
PluginScope: The plugin on whose behalf a registry is being called.
PluginSettings: What a Flutter3dView's loop installs and the registries it hands them.
PluginsReordered: The install order became order: what breaks ties between plugins' systems and subscribers.
PluginsSet: The whole of the plugins' state: the order, and which are on.
PluginStatus: Where one plugin stands.
PluginTouches: Whether a plugin changes what the simulation computes, or only what is shown of it.
PluginVersion: A plugin's release, by semantic versioning: 1.4.2, 2.0.0-dev.3.
PointerTargets: The materials and lights of one model instance, as a place for KHR_animation_pointer tracks to land.
PolygonMode: Whether primitives are filled or drawn as edges.
PosedMesh: Posed positions for one mesh and skeleton, reused while the pose holds.
PoseRecord: Where the run's bodies were, every few steps: the half of a .f3drun that plays on any build.
PoseRecorder: Writes a PoseRecord down as a run is played: every everyth step, whichever bodies the caller hands it.
PoseRecordFrame: One recorded step: the step it was taken after, and each body's place and rotation, in PoseRecord.bodies order — null for a body that was not there at that step.
PostFrameResult: What Renderer.renderPost handed back.
PowerPreference: Which GPU a DeviceRequest prefers where there is a choice: WebGPU's powerPreference.
Powers: What is running on somebody, and for how much longer.
Prefab: A template: a tree of entities a level places as one thing, as often as it likes.
PreparedUpload: What TelemetryUpload.prepare made: the upload, or none and why.
PrimitiveType: How vertices are assembled into primitives.
Probe: An instrument in the simulation: a quantity read at a region every step, published as a ProbeReading and written on the run's tape.
ProbeBody: The body the probe is on: the entity carrying the Probe.
ProbeField: A grid of values a probe read at once: a section's temperatures, a volume's concentrations. values in row-major order over shape, each in unit.
ProbePoint: One point of the world, in its own double-precision frame.
ProbeReading: What one probe read at the end of one step: published to the view (PublishedState.probes) and written on the run's tape.
ProbeRegion: Where a Probe reads: a point of the world, a section through it, or the body the probe is on.
ProbeSample: What a ProbeSampler is told about the reading asked of it.
ProbeSampler: Reads one quantity for a probe: a field's value at a point, a flow through a section, a solver's own number for a body.
ProbeSamplers: The samplers of one engine, by quantity id: a solver that owns a quantity registers what reads it. host.registry<ProbeSamplers>().
ProbeSection: A plane through the world: what crosses it (a flow through a pipe's section) or what lies on it (a temperature map).
ProceduralTexture: A texture generated in code.
Projection: How a camera maps eye space onto clip space.
ProjectionLayerNode: The node that hands each view of a frame to the layer of a runtime's image it belongs in: the projection layer an XR session submits.
ProjectionRequest: What a Projection is asked to build its matrix for: the shape of the target it will be drawn into.
PropertyGroup: What every group of a material's properties has: the source its numbers were read from, and the keys of its file a later version wrote that this one does not know, kept so they are written back.
PropertyInterval: The spread a value is known within: the low and high ends of a range a source gives, in the property's unit.
PropertyLaw: One property of a material as a function of the state a body of it is in: a constant, a table, or a formula of the engine's expression language.
PublishedActor: An actor as the view reads it from PublishedState: where it is, which way it faces, whether it lives — decoded from the rows its published components (ActorCodecs.body, ActorCodecs.facing, ActorCodecs.vitality) left for the step.
PublishedEvent: One step-channel event as the view receives it: encoded by its declared EventCodec, so it crosses an isolate boundary as plain values and nothing the view holds is an object the simulation still owns.
PublishedState: What one step left for the view to read: immutable, built in the publish phase.
PublishedWorlds: The worlds besides EngineLoop.world whose published components go into PublishedState.
PulseLight: A slow swell, for something magical rather than burning.
QualityContext: What a QualityPolicy is asked once a frame's time is recorded.
QualityPolicy: Which quality row the next frame is drawn at (D22b): AdaptiveQuality's rule, or a plugin's own.
QualityRow: One measured row: a setting, what it costs and what it takes away.
QualitySetting: One combination of the levers: a render scale and an effect tier.
QualityTable: The rows of one device class, best picture first.
Quantity: A value in a unit: 9.81 m/s².
Quaternion: Defines a Quaternion (a four-dimensional vector) for efficient rotation calculations.
QuerySet: A set of queries a backend owns — GraphicsDevice.createQuerySet.
QueryType: What a query set counts.
Range: A range a value is drawn from when a particle is born.
RangeHint: A number with two ends and, when it is not continuous, an increment.
Raycaster: Casts rays against a Scene on the CPU.
RayHit: Where a ray met something.
RayQuery: What WorldRays.rayCast is handed: a ray from origin along direction within maxDistance, meeting things on a layer in mask but not ignore, and the hit to write into out.
ReachGoal: An arm or a leg bent to reach target: root → mid → tip by TwoBoneIk, the middle joint on the side of pole. Below a weight of one, the chain's joints are turned that share of the way from where the graph had them.
ReactiveFrame: Everything a contributor is handed to mark its pixels reactive — R4.
ReactiveShape: How a reactive sprite's coverage is worked out — R4, and the shapes post/reactive_sprite.frag knows, in its order.
ReadingKind: How a reading came to be: measured by an instrument, estimated by a model, predicted ahead of its time, or read off the simulation itself.
ReadingQuality: How far a reading can be trusted, as its source says.
Rebinding: Moving a control to somewhere the player can reach.
RebindOutcome: What ActionMap.rebind did.
ReflectionProbeKind: A point the room around it is reflected from.
ReflectionProbeNode: A point the scene is reflected from.
ReflectionSettings: Screen-space reflections.
Refused: It would not, and here is what to tell the player.
Registration: What every registry hands back: the way to take the thing registered out again.
RenderAnchor: A named place in the frame where a plugin's pass goes.
RenderBundle: Draws recorded once and replayed into passes — PassEncoder.executeBundles.
RenderBundleDescriptor: The attachments a render bundle will be replayed against — GraphicsDevice.createRenderBundleEncoder.
Renderer: Draws a Scene through one or more CameraViews.
RendererSteps: The RenderStepRegistry a Renderer fills: a plugin's own render steps, and its passes placed at the engine's anchors.
RenderFrame: Everything a node is given to build its pass from: the FrameContext, and the frame's resources.
RenderHooks: A renderer's hooks into what it draws (D22b): the draw-list hooks, the level-of-detail and sort policies, the skinning hooks, the pacing and quality policies and the shadow techniques plugins registered.
RenderLayers: The render layers a node is on and a view draws: a 32-bit mask, bit 0 the default layer a node is on.
RenderListener: Callbacks a Renderer calls after each frame it draws — subscribed with Renderer.listen.
RenderMaterial: Surface appearance as plain data.
RenderNode: Something that declares what it touches, owns a pass, and draws it — the one kind of pass an application or a plugin adds to a frame, with RendererSteps.addNode.
RenderParameterWrite: What a RenderProgram sets one of its parameters with (RenderProgramFrame.setParameter): which parameter, from which component, to which values.
RenderPassDescriptor: Everything a pass draws into.
RenderProgram: A program a run-time plugin brings that drives one of its render steps frame by frame: what a Wasm render module is, as the renderer sees it.
RenderProgramFrame: What a RenderProgram is handed each frame: what the frame is, and the commands that reach its step.
RenderServices: What the renderer lends a contributor or a node.
RenderSettings: Scene-wide shading knobs that are not per-material.
RenderSettingsPatch: The render settings a level asks for, by settings slot id, and nothing it does not ask for.
RenderStep: One step of the frame that can be switched off — the passes before the scene, the scene's own extras, and the post chain.
RenderStepAddon: A view plugin that provides render steps: while it is on, they are drawn as their settings say; switched off, they are withdrawn from every frame.
RenderStepContext: What a RenderStep's switch is asked with: the settings, and inside a frame the views, the device and the quality it is drawn at.
RenderStepRegistry: Render steps, anchored to the engine's passes. Filled by the renderer.
RenderTargetDescriptor: What makes two render targets interchangeable.
RenderTargetPool: Reuses textures across frames, keyed by what makes them interchangeable.
ReplayDivergence: Where the run new code makes first parts from the one old code made.
ResourceCache<K, V>: A reference-counted cache of asynchronously loaded resources.
ResourceDesc: What a node is asking for when it writes a resource.
ResourceHandle<V>: A borrowed reference to a cached resource.
ResourceOrigin: Where the pixels behind a bound resource came from.
ResourcePriority: How much a resource matters to whoever asked for it: which load starts first when ResourceCache.maxConcurrentLoads holds loads back, and which unheld entry goes last when a MemoryBudget is over.
ResourceRequest<K, V>: One ask for key, as ResourceCache.request makes it: the handle it will hand over, its priority while it waits, and cancel.
ResourceSize: How large a resource is, relative to the frame or in its own right.
ResourceSizeVisitor<R>: Something that reads every kind of ResourceSize: a tool that writes a frame's resources down, an inspector.
ResourceVersion: A resource as it stands between one write of it and the next.
RestorableRun: A HeadlessRun that can be put back to a state it saved — what bisectTapes needs of each side, to step on from a state it kept rather than from the start every time it asks.
ReverbEffect: A room's tail on everything on the bus: wet of the signal sent to a reverb that dies away by 60 dB in decaySeconds seconds.
RevolvedVessel: A vessel whose inside is a surface of revolution about its Y axis — a test tube, a beaker, a flask: a wall profile in the (radius, height) plane, from the middle of the floor up the side to the mouth.
RewindBuffer: The last few seconds of a run, kept so they can be lived again.
RewindPoint: A moment in the recent past, and how to get there.
Rgba8Image: A decoded source image: tightly packed RGBA8, row-major, top row first — exactly what ui.Image.toByteData(format: rawStraightRgba) hands the engine's own texture upload path, and what every encoder in encode/ takes in.
Rgba8Texel: One pixel of eight bits a channel: what a 4x4 block encoder takes sixteen of, and what decodeUniversalBlock answers sixteen of.
RgbTriple: Three channels of a colour, red, green and blue, as a colour table or a colour transform reads and answers them. Whether they are linear or sRGB encoded is the answering member's to say.
RgbValues: Three numbers for the red, green and blue of linear light: a reflectance, or a coefficient per metre — the field that holds one says which.
Rider: Mixed in, not implemented, outside this library: a base type, so a member added in a 1.x release arrives with a body and nothing that mixes it in has to change.
RigidBody: A body with mass that a RigidDynamics pushes around, registered in its CollisionWorld as a kinematic collider.
RigidDynamics: Extended outside this package: an abstract base class (decision 5 of tasks/1.0-api-review.md), so a member added in a minor arrives with a default body and every implementation keeps compiling.
RigidPose: Where a rigid thing is and which way it is turned: a position in metres and an orientation, in whatever space the one who hands it over states.
RigSettings: Where a chasing camera sits, and how fast it gets there.
RoomScatter: What LevelRules.perRoom scatters in a room: an entity row and how many of it.
RunCarryContext<L>: What RunSession.carryFrom is handed: the level being left and the document read next, for the reason RunRestoreContext gives.
RunFailed<L>: Nothing is up, and this is why.
RunLoading<L>: Before the first level, and between one and the next.
RunOutcome: How a run ended, or that it has not.
RunPlaying<L>: A level is up. outcome is the simulation's own answer, republished so a screen can watch one thing.
RunRequest: One HTTP request, as RunService makes it.
RunResponse: What came back: the status and the body as text.
RunRestoreContext<L>: What RunSession.restoreInto is handed: the level just loaded and the run to put back into it.
RunService: The client side of a sharing service — the v1/shares routes of cloud/server in this repository, or anybody's server that speaks them.
RunSession<L>: The run: which level is up, what happened to it, and where to go next.
RunStatus<L>: What a game is doing, as far as a screen is concerned.
RunTimeline: Pause, step, rewind and branch, built on a live RewindBuffer and the EngineLoop it is attached to.
SamplerAddressMode: What sampling outside the 0..1 range does.
SamplerBorderColor: The colour a sampler clamping to its border returns outside the texture.
SamplerDescriptor: How a texture is sampled.
SaveFile: Where a run in progress is kept between launches.
SaveFound: The document held a save, brought up to the game's schema.
SaveNotRead: The document is not a save this build can use, and why.
SaveRead: What SaveRecord.read made of a document.
SaveRecord: One saved run: the level, the snapshot, how far the run got, the schema its fields are at, and a digest to tell two copies apart.
SaveRefused: Why the run cannot be read by this build.
SaveSchema: A game's save schema: the migrations from version 0 to now.
SaveSlots: A game's saves, one per slot: three runs on a title screen, an autosave beside a manual save, a profile per player on one device.
SaveSync: The save on this device and a copy of it in a CloudSaveStore, made one.
SaveUpgrade: What SaveSchema.upgrade made of a run.
SaveUpgraded: The run at the current version, and the version it was written at.
Scene: A scene: a hierarchy of nodes plus flat registries of what is in it.
SceneBinding: A binding as the renderer holds it: its spec, and the kind of node its spec names.
SceneBindingContext: What a SceneNodeKind is told about one entity's component: one object that can gain members — the entity's other components, the view — rather than a list of parameters that grows.
SceneBindingRegistry: Where scene bindings are registered: the data plugin's bindings: section and a Dart plugin alike (D37). Filled by the renderer's SceneBindings in flutter3d_core; an engine that draws nothing has none, and a binding's install notes that rather than failing.
SceneBindings: The scene bindings of one renderer, and the kinds of node they make (D37). The SceneBindingRegistry the plugin API names, filled.
SceneBindingSpec: How a component of the simulation is shown in the scene (D37): which kind of node stands for an entity that has it, with what material, which of its fields drive which of the material's parameters, how the node follows the steps and when it is made.
SceneBvh: A bounding volume hierarchy over bounding spheres.
SceneEncodeRequest: What RenderServices.encodeScene is handed: the scene, the pass it is drawn into, and the camera it is drawn through.
SceneNode: A node in the scene graph: a name, a place in the hierarchy, and a transform.
SceneNodeKind: A kind of node a scene binding makes (D37): f3d.mesh, f3d.light and the engine's other kinds, or a plugin's own, named <namespace>.<kind>.
SceneTurn: One turn at putting something loaded into a scene — Scene.reserveTurn.
Scoring: Points, and the run of them a player is holding.
ScreenBounds: A rectangle on the glass, in logical pixels, with the origin top left.
ScreenPoint: A point on the glass, in logical pixels, with the origin top left: where projectPoint says a point in the scene lands.
ScreenRect: A rectangle of a render target, in whole pixels: the scissor, a readback region, an overwrite's region.
ScrubAnswer: What RunTimeline.scrubTo and RunTimeline.branchHere answered.
ScrubMoved: The live state is now the state before step.
ScrubRefused: Nothing moved, and reason says why and what to do instead.
SeatInput: What a simulation's applyInput is told: one input a game submitted, and the seat it came from.
Sequence: A cutscene, its moments in steps.
SequencePlayer: Where a Sequence has got to, stepped with the simulation.
SequenceRead: What Sequence.read made of a document: the sequence, or every problem with it and where.
SequenceSignal: A cutscene's signal, fired on its step: signal and the document's data for it, for the game to answer — a sound, a clip, a door.
SequenceView: What a cutscene shows: the camera's pose, the fade and the subtitle, read off a Sequence's keys for a frame.
ServiceAnswer<T>: What a call to a service came to.
ServiceDone<T>: Done, with what the service gave back.
ServiceRefused<T>: Not done, and why — in the server's words when it answered.
SettingKey<T extends Object>: One thing a player can change, typed, under a namespaced id.
SettingsExtensions: The values RenderSettings holds in slots that are not its own fields — RenderSettings.extensions.
SettingsFile: Where a game keeps what the player changed.
SettingsSlot<T extends Object>: A kind of settings RenderSettings carries for whoever defined it — the key RenderSettings.extension reads by and RenderSettings.withExtension writes by.
SettingsState: What the settings screen is doing.
Severity: Roughly how much an issue matters: the one severity a mesh check, an export, a level's validation and a library's Issue all speak in.
ShaderBundle: A loadable shader bundle: a name, the SDK it was compiled on, the stages it claims, and a compiled section per backend that needs one.
ShaderBundleStage: One entry point a bundle claims to hold.
ShaderDiagnostic: One error a shader compiler gave, and where: what a tool underlines.
ShaderHandle: One compiled stage of a pipeline — a vertex or a fragment program.
ShaderLibrary: The stages a compiled bundle holds, addressed by name.
ShaderStageKind: What a stage runs as: a vertex, a fragment or a compute program.
ShadowCascades: The directional map as the engine fitted and laid it out for one frame: what a technique's own producer draws into (D22).
ShadowCasting: How a brush takes part in the shadow passes, as a document says it.
ShadowCastingMode: How a mesh takes part in the shadow passes.
ShadowCubeAtlas: The cube atlas of point and spot lights as the engine laid it out and fitted it for one frame: what a technique's own producer draws into (D22).
ShadowCubeLight: One light's row of a ShadowCubeAtlas.
ShadowFilter: How the directional light's shadow map is filtered into a soft edge — S2.
ShadowKernel: The lookup the lit draws make into the directional map, and its parameters.
ShadowPrefilter: The full-screen stage that turns the directional depth atlas into the moments ShadowKernel.moments reads, and how wide it blurs.
ShadowProducerContext: What a ShadowTechnique is told when the frame asks it for a producer of its own (D22): one object that can gain members — the cascades the engine fitted, the atlas rows a cube light holds — rather than a list of parameters that grows.
ShadowSettings: Shadow mapping settings: the directional cascades and the point and spot cube atlas.
ShadowTechnique: How the directional map is drawn, prepared and read: what a ShadowFilter stands for when the renderer draws a frame.
ShadowTechniqueContext: What a ShadowTechnique is told when the frame asks it how the map is split, prefiltered and read: one object that can gain members — the light, the device's features, the quality row — rather than the application's ShadowSettings, which a technique has no say in.
Shape: A parameterized generator of geometry.
ShapedPair: Two numbers of a two-axis source after its AxisSettings shaped them: what AxisSettings.shapePair and AxisSettings.shapeDelta answer.
ShareBundle: A level somebody shares, and optionally a run through it — what a short code stands for.
SharedBundle: A bundle the service has filed: the code to hand out and where it stands.
SharedMeshes: One uploaded mesh per distinct shape, shared by everything that asks for it.
ShareStatus: Where a shared bundle stands with the service's moderation.
Shown: One burst, where it happens, and which way it goes.
Signal: A mechanism that does nothing itself and switches something else on.
SignalCue: One signal: name fired, with data, on step.
SilentBackend: A backend that makes no sound and records everything.
SilentVoice: One recorded voice. Public because a test reads it, and a type a test has to reach for is part of the interface whether or not it looks like one.
SimCommands: Changes to a world made later, at the end of the phase that asked for them, in the order they were asked.
SimQueries: The questions a simulation answers by name, for SimulationHandle.ask.
SimQuery: A query being built: the component types an entity must carry, must not carry, and must have had set recently.
SimSpawned: What a SimCommands.spawn hands its builder: the entity just spawned and the world it is in.
SimulationHandle: What the view holds of a simulation: its published state, a way to hand it input, questions answered asynchronously, and rewinding.
SimulationPlacement: Where a Flutter3dView's simulation runs: in the view's own loop, on the thread that draws (SimulationPlacement.inline), or in an isolate of its own (SimulationPlacement.isolate).
SimulationProfile: What a simulation promises about its numbers, and so what may be done with a run of it.
SimulationQueryRegistry: The questions a simulation answers by name, for a view that asks them through SimulationHandle.ask.
SimulationQuestion: What a SimulationAnswer is handed: the world it answers from and the arguments the question was asked with.
SimulationSetup: What a SimulationFactory builds where the simulation runs: the loop, how a submitted input reaches it, and how much history it keeps.
SimulationVersion: Which simulation a run was played in, or a machine plays: the engine's number, a genre's, and one for every simulation plugin installed.
SimWorld: The world a simulation's systems read and write: entities, components on them, and resources that belong to no entity.
Skeleton: A posed skeleton: joint nodes plus the matrices that undo their bind pose.
SkinBlend: Skins a mesh's positions, normals and tangent directions on the CPU, into a copy of its vertex buffer — anim-02's own row, the skinning half of what MorphBlend already does for morph targets.
SkinningContext: What a SkinningHook is asked about one skinned mesh, and where it writes the answer.
SkinningHook: How a skinned mesh is skinned (D22b), beside the engine's own four-joint linear blend in mesh_skinned.vert.
SkippedPass: A registered pass that did not run, and why.
SkippedPassSnapshot: One pass that did not run, as a FrameGraphSnapshot holds it.
SkyDome: An inside-out sphere, which is a sky the camera sits at the centre of.
SkyGradient: The cheapest description of a sky that still reads as one: three stops and a scattering lobe around the sun.
SkyLook: Where a SkyColor is being asked to look.
SkySettings: What the sky looks like, and whether there is one.
SlotActions: The actions that pick one of a game's numbered slots — a weapon, a hotbar's block — as InputState.requestSlot does.
Snapshot: A saved state: the game's own fields in data, and the plugins it requires, written in the f3d.save envelope.
SnapshotPart: One part of the state a snapshot covers: the world, a plugin's own fields, a Wasm module's memory.
SnapshotRegistry: Every SnapshotPart of one engine, in registration order, and the one way their state is captured, restored and digested.
SnapshotRestoreContext: What SnapshotPart.restore is handed: what the part's SnapshotPart.capture wrote, and the version it wrote it at.
Snapshots: Every SnapshotPart of one engine, and the one way a state is captured, restored and digested.
SoftwareOcclusion: OcclusionMode.software: this frame's occluders rasterised into an OcclusionBuffer before the render list is built — C2.
SolidColorTexture: A single flat colour, or a single flat value.
SortMode: How a sub-list of draws is ordered.
SoundBank: Everything one game can make a noise about, as one list.
SoundDef: A sound the game can ask for, by name and behaviour rather than by file.
SoundOcclusion: How much of a sound survives the walls between its source and the ear.
SpatialQuery: What a SpatialRenderer is asked about one emitter: who hears, what is heard, and what stands between them.
SpatialRenderer: Turns where a sound is into how it is heard.
SpatialResult: What a SpatialRenderer decided about one emitter.
SpatialUpscaleSettings: Bringing a frame drawn below full size up to it without a temporal resolve — R5.
SpawnContext: What an entity is given when it is asked to become real.
SpawnPoint: Where a body starts in a level, and which way it faces: what LevelWalk.spawnIn reads from the level's first spawn.
SphereEmitter: Outwards in every direction. Explosions, and anything that bursts.
SphereShape: UV sphere, a revolved meridian arc.
Spill: What ran over a vessel's lip in one step, in the world.
SplatAxes: Which axes a cloud read by parseSplatSpz comes back in.
SplatCloud: A fitted cloud, in the units the file stored.
SplatColorSpace: The colour space a splat's colours were fitted in, as KHR_gaussian_splatting's colorSpace names it.
SplatComposite: How a cloud's overlapping splats are combined — N5.
SplatContributor: Draws a cloud into the scene pass.
SplatGpuSort: Sorts one cloud's keys on device and keeps the index buffer the draw binds. One per drawn cloud, as SplatSorter is.
SplatLens: What SplatQuads.build needs of a camera beyond its right and up axes: its view axis, and how the projection turns depth into pixels.
SplatLod: Draws a splat tree at a budget — what SplatQuads.lod takes in place of a single cloud.
SplatOctree: A cloud as a tree of levels of detail. Node 0 is the root.
SplatOctreeNode: One box of the tree.
SplatQuads: Builds the vertex data for cloud, back to front, as camera sees it.
SplatSorter: Keeps a cloud's back-to-front order and the scratch the sort needs.
SrgbColor: A colour encoded for display, as LinearColor.toSrgb gives it: what a swatch, a hex code or a file a person edits holds.
StageBindings: What a compiled stage keeps: the uniform blocks and samplers its compiled function has a slot for, by name.
SteadyLight: Steady. A lamp, a stained window with daylight behind it.
StencilOperation: What happens to a stencil value once the stencil and depth tests have decided a fragment's fate.
StencilState: How the stencil test treats the draws that follow, for one face.
StepContact: One contact a step of a RigidDynamics found, as it reports it (RigidDynamics.contacts): two colliders, at least one a body, where and how they met.
StepDivergence: Where two runs of one step parted.
StepEventSummary: What one step published on the step channel, digested.
StepSpan: The first and the last of a run of steps, both included.
StlLoader: Decodes STL, binary or ASCII.
StlModelWriter: STL, binary or ASCII.
StlNormals: How a facet's normal is chosen.
StlWriter: Encodes any ModelDocument as STL, binary or ASCII — fmt-20's own row.
Storage: Where a game keeps the small documents a player's choices live in.
StorageBuffer: A buffer a compute stage reads and writes.
StorageMode: Where an allocation lives and how it may be used.
StoreAction: What happens to an attachment's contents when a pass ends.
Subsystem: A solver of the simulation, registered with what it reads and writes.
SubsystemContext: What a Subsystem is told about the step it runs in, and its way to the fields it declared.
SubsystemDeclaration: What a solver says about itself before it runs: its id and version, the quantities and fields it reads and writes, and its place in the step.
SubsystemRegistry: The subsystems of one engine: host.registry<SubsystemRegistry>().
SubtitleCue: One subtitle: shown from step from up to, not including, step to.
SurfaceAlphaMode: How a surface treats the alpha channel.
SurfaceMaterial: Format-neutral description of how a surface looks.
SurfaceTable<T>: What this game thinks a level's surface words are worth.
SwappableTexture: A texture a game draws, kept so a changed image file reaches every material that samples it — see HotSwap.loadTexture.
SweepHit: Where a swept shape first touched something.
SweepQuery: What WorldSweeps.sweep is handed: shape moved from origin by delta, meeting things on a layer in mask but not ignore, and the hit to write into out.
SweptContact: What a ContactFilter is told about the contact it is judging.
SyncOutcome: How a sync ended.
SyncReport: What SaveSync.sync did, in a sentence, and for SyncOutcome.ask the two runs to choose between.
SystemSettings: How a system added by LoopRegistry.addSystem is ordered and what state it declares.
TableLaw: A value tabulated against one quantity of the state, read between the points on a straight line.
Takeable: Something lying in the world that one toucher can take, once.
Tally: Things counted by name, and kept.
TangentMethod: How MeshTangents.withGeneratedTangents derives a frame from the UVs.
TelemetryConsent: A player's answer to "may we send what you did in a level, to see where levels are hard?", kept with when they gave it and to which wording.
TelemetryLevel: How much of a frame the renderer measures, and what it costs to.
TelemetryReceipt: What a server gave back for an accepted run: its number there, and the key that takes it back out.
TelemetrySent: The answer to sending one run.
TelemetrySink: Where uploads go. The HTTP one is HttpTelemetrySink; a test hands in its own.
TelemetryUpload: What goes over the wire: which game, the run as a Demo, and the consent it was sent under.
TelemetryUploader: Sends a finished run, if and only if the player agreed.
TemporalClip: How the temporal resolve decides which of the history is still true — N4.
TemporalSettings: Edges smoothed across frames — R1, R2.
TexelValue: The four channels a texel of a SolidColorTexture stores, each 0..1 before it is quantised to a byte.
TextureAllocator: Makes a texture. The one thing a pool cannot do on its own.
TextureBinding: A reference from a material to one of the document's images.
TextureBlockLayout: The block footprint and byte cost of a compressed TextureFormat — blockWidth by blockHeight pixels, bytesPerBlock bytes, however many channels or bits per channel the format packs into that block.
TextureCodec: An image format of a plugin's own — DDS, TGA, a game's packed format — read into RGBA8 pixels the engine uploads like a PNG's (D22b).
TextureCodecs: The image formats plugins brought, asked in the order they were registered — the application's first, then each plugin's.
TextureCopyLocation: A texel position in one level of one texture: the corner a copy starts from or lands at.
TextureDecodeContext: What a TextureCodec is handed for one encoded image: one object that can gain members, rather than a list of parameters that grows.
TextureDescriptor: Everything a texture is made from — TextureAllocator.createTexture.
TextureDimension: The shape of a texture, as a view of it is bound.
TextureFormat: The layout of one texel.
TextureFormatSupport: What one TextureFormat can be used for on one device.
TextureHandle: A texture some backend owns, described in the engine's own vocabulary.
TextureHint: A path to an image, and what a file picker should offer.
TextureRegion: A box of texels in one mip level: a rectangle of width by height from (x, y) at the top left, across depthOrArrayLayers layers (or 3D slices) from z.
TextureSampleKind: What kind of value a TextureFormat's texels hold.
TextureSampling: Filtering and wrapping requested for a texture.
TextureTransform: KHR_texture_transform's three fields — see TextureBinding.transform.
TextureType: What shape a texture is.
TextureUsage: What a texture may be used for, fixed when it is made.
ThermalProperties: How a material takes heat, gives it off, changes phase and burns.
ThinLens: A thin lens as DepthOfFieldSettings.lensFor works it out: its focal length and the width of sensor the picture spans, both in metres.
TiledProjection: One tile of a larger virtual frame, out of tilesX × tilesY — pro- eng-04's own row: a tiled screenshot at a resolution no single render target holds, stitched afterwards from tiles rendered one at a time.
TimelineBranch: What RunTimeline.onBranched is told when a branch has cut the future.
TimelineBranched: The run was rewound to step and released — everything after step in the buffer was cut, and the run continues from there.
TimelineCommand: One action taken on a RunTimeline, kept so a caller can show a history: every command is visible in it, and it is the same log an MCP command stream would replay.
TimelineLevelSwapped: The level under the run was replaced, taking effect before step: the run was replayed from there under the level whose document digests to levelDigest (Level.digestHex).
TimelinePaused: The run was paused.
TimelineReplayed: The last seconds were lived again under new code, from fromStep to the present — RunTimeline.replayUnderNewCode.
TimelineResumed: The run was resumed from a pause.
TimelineReturned: A scrub was left, and the present put back as it was.
TimelineScrubbed: The live state was moved to the state before step to be looked at; the tape and the present are kept, and nothing has branched yet.
TimelineStepped: One fixed step was taken while paused.
TimeSource: How many seconds of simulated time a displayed frame brings: the loop's clock.
TonemapCurve: Which curve the composite rolls highlights off with — gfx-17n.
TorchFire: One torch's fire.
TorusShape: Torus: a closed circular profile revolved around Y.
TrackSample: A component's value from step on, until the next sample says otherwise.
TransferEncoder: Records copies; submit hands them to the queue.
TransparencyMode: How the transparent half of a view is composited — R8.
TriangleBvh: A bounding-volume hierarchy over the triangles of one mesh.
TriangleHit: Where a ray met a mesh, as TriangleBvh.rayCast answers it: which triangle, in the mesh's own index order, how far along the ray, and the point.
TriggerCondition: A trigger parameter being set — and consumed when the transition fires.
TriggerKind: An invisible volume that fires its target when the player, or with anyone any body, walks in; once only unless once is false.
TriggerVolume: A volume that fires its target when something walks into it.
TwoBoneIk: Two-bone inverse kinematics — an arm or a leg, bent to reach a point — anim-14's own row.
UniformBlock: A block's members, by name, under the block's own name.
UniformMemberLayout: One member of a uniform block as the compiler lays it out — H1: where it starts, how many bytes it takes, how many elements if it is an array (one if not), and its reflected type name (Vector4, Matrix4, Float, ...).
Unit: A unit of measurement: a dimension, the scale that takes a value in it to the coherent SI unit of that dimension, and the symbol it is written with.
UniversalTarget: What a universal level can be turned into at load.
UnorderedAccess: Two systems of one phase that touch the same state with no order between them: one of them writes it, and neither runs after the other through a constraint or a chain of constraints.
UsdzModelWriter: .usdz — geometry only, the spike UsdzWriter describes. Not a CheckedModelWriter: nothing here reads a .usdz.
UsdzWriter: Encodes a ModelDocument as .usdz — fmt-27's own row, and a spike rather than the feature-complete writer every other format here has: geometry only, no materials, no hierarchy past one Mesh prim per surface. What decides whether it grows past that is stated in the plan as a question — is there demand — and a spike is exactly the size of thing that can answer it without committing to the rest up front.
Vector2: 2D column vector.
Vector3: 3D column vector.
Vector4: 4D column vector.
VersionRange: The versions of a plugin a dependent accepts: any, ^1.2.0, >=1.0.0 <2.0.0, 1.4.2.
VertexAttribute: Describes a single vertex attribute.
VertexFormat: The type of one vertex attribute, and how much room it takes.
VertexLayout: An ordered set of attributes making up an interleaved vertex.
VertexLayoutDescriptor: Every buffer a pipeline reads vertices from, in slot order.
VertexStageVariant: A variant of a material's own vertex stage, for geometry that reads more than the standard vertex (D22b).
VertexStepMode: Whether a buffer advances once per vertex or once per instance.
VesselLip: The lowest point of a vessel's rim along a direction, where liquid leaves first — VesselVolumes.lip.
VesselShape: The inside of a vessel, in its own frame, as far as liquid in it cares: how much it holds below any plane, and the edge of its mouth.
VesselSpan: How far a vessel's inside reaches along a direction — VesselShape.span: the least and greatest up · p over it.
VesselWallDistance: How far a point is from a vessel's wall, and the wall's way out there — RevolvedVessel.wallDistance.
ViewModelNode: Draws the first-person view model over the finished scene.
ViewportRect: Normalized viewport rectangle.
ViewportShading: Which viewport shading a frame is drawn with — gfx-43n, 44n, 45n.
ViewportShadingSettings: Shading read out of the surface buffer instead of out of the materials — gfx-43n, gfx-44n and gfx-45n.
ViewResolution: How many device pixels a Flutter3dView draws per logical pixel — its resolution policy. An open set: a later minor may add a policy.
ViewRuns: How often a frame runs a RenderNode: perView or once.
ViewSettings: What a Flutter3dView draws and how: the frame's settings, the view's own, the resolution, when it draws, and what shows instead.
VirtualCamera: One camera a game could be looking through: a framing, the rig that carries it out, and how much it wants to be the one shown.
VisibilityBatch: One batch of level geometry and the box it fills.
VisibilityCuller: Hides the level's batches a camera cannot see, once a frame.
VmExtensions: The engine's VM service extensions, as a registry plugins add theirs to.
VoiceStart: What AudioBackend.start is handed: the voice to begin.
VoiceUpdate: What AudioBackend.update is handed: a playing voice and what it plays at now.
VolumetricFogSettings: Air with a thickness, lit by the sun and by the torches in it — S4.
WindSettings: A uniform wind field, applied per triangle as drag along its own normal.
WorldMirror: Something that keeps a copy of a world — the physics core's mirror — told at the end of every step, in CollisionWorld.update, to bring its copy to where everything now is.
WorldOffset: How far one WorldPosition is from another, in metres along the world axes and still in double precision: what WorldPosition.relativeTo answers.
WorldPosition: A point in world space: metres, Y up, a right-handed frame, in double precision.
WorldPositionCodec: How a WorldPosition component is written: three doubles, in metres.
WorldProperties: The properties of one world, read by everything in it.
WorldPropertiesPatch: The fields of a WorldProperties something sets, and nothing it does not.
WorldRay: A ray in the world: an origin in double precision and a unit direction — decision 2 and 3 of the API review (Ray collided with vector_math's; the float32 ray of the geometry library is LocalRay).
WorldRays: A world's rays, cast elsewhere — P9: the physics core answers them through what it mirrors of the world.
WorldSweeps: A world's sweeps, cast elsewhere: the physics core moving a shape through what it mirrors of the world.
WorldTiming: How a world is stepped in time: its step rate.
WrittenFile: One file a write produced.
XrAnchor: A point fixed to the real world, which the runtime keeps where it is as it learns the room.
XrAnchorRequest: What an anchor is asked to be fixed at.
XraySettings: Silhouettes of what the walls hide.
XrCapability: What an XR runtime can do: the modes it runs in and the features beside them.
XrControl: A control on a tracked controller or a hand: a trigger, a stick, a face button, a pinch.
XrControlReading: What one XrControl reads in one frame: whether it is pressed or touched, how far it is pulled, and where a stick or a pad is.
XrCylinderLayer: A band of a cylinder around pose, of radius meters, centralAngle radians wide and height meters tall, showing image on its inside: a wide panel that stays the same distance from the eyes.
XrFieldOfView: How wide one view sees, as four angles from its own forward axis in radians: OpenXR's XrFovf. left and down are negative for a view that sees past its axis that way, as they are for every headset.
XrFrame: One frame of a session: when it will be shown, where the eyes and the hands will be, and what the room looks like.
XrFrameEnd: What the engine hands back for a frame: the layers the runtime composes, in order, the first at the back.
XrHand: Which hand a tracked thing is held in or is.
XrHaptic: A pulse a controller plays.
XrInputSource: A controller or a tracked hand, as one frame reads it.
XrLayer: One layer of a frame, composed by the runtime in the order the frame lists them.
XrLightEstimate: The room's light as the runtime measured it, for the frame's environment.
XrPanel: A Flutter widget shown in a headset as a layer of its own: a menu, a readout, a page of a lesson.
XrPanelRequest: What XrDriver.drawPanel is asked to draw: a panel's widget into a texture width by height pixels.
XrPanelShape: The shape a panel is shown in.
XrPlane: A flat surface the runtime found: a rectangle of width by depth meters centered at pose, lying in the pose's x-z plane with its normal along the pose's +y.
XrPlaneOrientation: Which way a detected plane faces.
XrProjectionLayer: The scene, drawn once per view into the layers of image: what a headset shows.
XrQuadLayer: A flat rectangle of width by height meters at pose, showing image: a panel of crisp text, composed by the runtime at the display's own resolution rather than resampled through the scene.
XrSceneMesh: A mesh the runtime made of the room: vertices as x, y, z triples in the space of pose, and indices three to a triangle.
XrSession: The engine's one boundary to an XR runtime.
XrSessionRequest: What a session is asked to start as.
XrSessionState: Where a session is in its life, as the runtime says.
XrSettings: What a Flutter3dView is told to do with an XR session: which session, what to ask it for, what to show beside the scene and how the controls reach the game.
XrSpace: The space a session's poses are stated in: where its origin is and which way is up.
XrSwapchain: A ring of images a runtime shows, one drawn into each frame.
XrSwapchainRequest: The shape of the images a session is asked for.
XrView: One view a runtime wants drawn for a frame: an eye, or a camera of a phone's AR.

Enums

CompareFunction: The test a depth or stencil comparison performs.
FramebufferOrigin: Where a render target's first row of pixels is.
GltfComponentType: glTF componentType values.
ShadowCasterFaces: Which faces of a caster are drawn into a shadow map.
StorageTextureAccess: How a compute or render stage may touch a storage texture.
WedgeUphill: Which way a CollisionWedge climbs.
WindingOrder: Which winding counts as front-facing, wound in clip space: a transform that mirrors reverses the facing without touching the order the vertices arrived in, and every backend decides after the vertex stage rather than before it.

Mixins

CommandEncoder: A pass somebody opened, and must therefore close.
LoadedShaderLibrary: A library a device built from bytes it was handed, and can rebuild.
RenderBundleEncoder: Records draws once, to be replayed into many passes — GraphicsDevice.createRenderBundleEncoder.

Extension Types

BackendId: A backend's id: the short, lower-case name a material compiler, a plugin manifest, a shader section, a conformance report and the device registry match a device by, compared exactly.
Entity: A handle to something in the world, not the thing itself.
ResourceId: Something a node reads or writes, addressed by name.

Extensions

BindUniformBlockObject on PassEncoder: Binds a UniformBlock object in one call.
BlendFactorInfo on BlendFactor: The two 0.9 blend capabilities a BlendState-shaped value can need.
BundledMaterialLooks on BundledMaterials: Ready-made RenderMaterials for the bundled material library.
ColorToLinear on Color: A Flutter Color decoded into linear light.
DebugDrawGizmos on DebugDraw: The shape-level overlays — boxes, axes, normals, frusta, spheres, light gizmos — and buildForScene, which assembles them from a Scene.
JsonLinearColorWriter on LinearColor: Writing a LinearColor the way a level document holds one.
LevelCollision on Level: Building the physical side of a level.
LinearColorToFlutter on LinearColor: A LinearColor encoded as a Flutter Color.
LinearColorVector on LinearColor: A LinearColor in the shapes vector_math and a GPU buffer take.
MeshTangents on MeshData: Tangent generation, split out of MeshData because it is a self-contained algorithm that only ever touches MeshData's public surface — an extension keeps it that way rather than granting it access to private state it does not need.
ModelAssetInstantiate on ModelAsset: instantiate and its helpers, added to ModelAsset.
PassStateApply on PassEncoder: Applies a PassState to an encoder.
TextureFormatCompression on TextureFormat: Whether a TextureFormat is stored in fixed-size blocks rather than one value per texel, and — for the formats where it is — how big those blocks are.
TextureFormatInfo on TextureFormat: Facts about every TextureFormat that do not depend on a device.
TextureFormatStencil on TextureFormat: Whether a TextureFormat carries an eight-bit stencil beside its depth.
Vector3Foundation on Vector3: A float32 Vector3 read back into world space, or as a colour.
Vector4Foundation on Vector4: A float32 Vector4 read as a colour.
VesselVolumes on VesselShape: The questions a VesselShape answers through its volume.
WorldPositionVector on WorldPosition: A WorldPosition narrowed to float32, relative to an origin.
XrPoseInput on RigidPose: A RigidPose as XR input: the seven numbers an ExternalStateInput carries, and back.

Constants

builtInModelExtensions → const Map<String, ModelFormat>: Every file suffix a built-in reader answers to, and which reader.
builtInModelWriters → const List<ModelWriter>: Every writer this package ships, in the order a menu would offer them.
coreFormats → const List<FormatSpec>: Every format flutter3d_core writes and promises to keep reading, for an engine's FormatRegistry: the model and material formats of package:flutter3d_core/formats.dart (modelFormats), the frame capture, and the shader bundle and trace of flutter3d_hardware (hardwareFormats).
f3dVendorKindStart → const int: The first section kind that is never the engine's. Kinds from here up are free for tools and plugins; the engine skips them unless asked to read one.
gameFormats → const List<FormatSpec>: Every format flutter3d_game writes and promises to keep reading, for an engine's FormatRegistry: the settings file, an action map, the index of save slots, the cloud-save state and the telemetry answer. A save itself is flutter3d_sim's (simFormats).
impostorGrid → const int: Views along each side of an impostor atlas: the plan's eight, fixed in 0.8 so no shader block has to carry it.
modelFormats → const List<FormatSpec>: The engine's own model and material formats, for a FormatRegistry: .f3d, .fmat, .f3dmat and .f3dsplat.
rootMotionExtra → const String: The key a clip's own extracted root motion sits under in AnimationClip.extras — anim-16's own flutter3dRootMotion.
settableBuses → const List<AudioBus>: The buses a player is offered, in the order the panel shows them.
toolEventPrefix → const String: What every kind a game posts is prefixed with on the VM service.

Properties

builtInMaterialHints → Map<String, MaterialHint>: Hints for the fields every material has, held here rather than written into every file.
final

Functions

advanceTime({required double seconds, required double deltaSeconds, required double length, required AnimationWrap wrap, required bool reversing}) → PlayheadStep: Where a playhead lands after a step, and what the wrap did to it.
answerLevelApply(LiveLevel live, Map<String, String> parameters) → Future<LevelExtensionAnswer>: Answers ext.flutter3d.level.apply for live: parameters carry the level's whole document, as JSON, and its hash, Level.digestHex.
answerLevelPatch(LiveLevel live, Map<String, String> parameters) → Future<LevelExtensionAnswer>: Answers ext.flutter3d.level.patch for live: parameters carry a LevelPatch as JSON, made against the level the editor last saved.
applySavedVolumes(GameSettings settings, Mixer mixer) → void: Copies every saved volume into mixer: the buses settableBuses lists, and any other the player has a volume for.
assetUriResolver(String baseAssetPath, {AssetBundle? bundle}) → AssetUriResolver: Resolves asset URIs against the Flutter asset bundle.
bindMaterial(MaterialDocument document, {required GraphicsDevice device, required AssetUriResolver resolveUri, String? name, LightingModel lighting = LightingModel.pbr, IssueSink? onIssue, ImageDecoder decodeImage = defaultImageDecoder, Map<String, MaterialProgram> programs = const <String, MaterialProgram>{}, TextureCodecs? codecs}) → Future<RenderMaterial>: Turns a read material into one the renderer can draw with.
bindSurfaceMaterial(SurfaceMaterial source, {LightingModel lighting = LightingModel.pbr, bool transformsAtSampler = false, required Future<TextureHandle?> textureFor(int, TextureSampling), LayerImages? layerImages}) → Future<RenderMaterial>: source as a material the renderer can draw with, uploading what it samples.
bloomLevelsFor(BloomSettings settings, {required int frameHeight}) → int: How many halvings the bloom chain does on a frame frameHeight tall — gfx-31n.
bugReportTape(RewindBuffer rewind, {String? part}) → BugReportTape?: rp-04's game-side half: the last few seconds rewind has kept, as the state and the tape a Demo needs — everything except the checkpoints and the free-text fields, which only the caller can supply.
buildMipChain(Rgba8Image base, {bool srgb = false, bool isNormalMap = false, double? alphaTestThreshold}) → List<Rgba8Image>: Builds a full mip chain from base down to a 1×1 level, each level a proper Kaiser-windowed resample of the one above rather than a box average — ap-08 in doc/asset-pipeline-plan.md.
buildPolyline(List<Vector3> points, {required double width, List<LinearColor>? colors, LinearColor? color, bool closed = false}) → MeshData: points as one band width pixels across, coloured per point.
buildsMipChain(GraphicsDevice device, TextureSampling sampling, int width, int height) → bool: Whether an image of this size, sampled this way, gets a mip chain.
buildSplatOctree(SplatCloud cloud, {int leafCapacity = 512, int grid = 8}) → SplatOctree: Builds the tree over cloud.
builtInModelDecoder(ModelFormat format, ModelLoadRequest request) → ModelDecoder: The decoder this package ships for format, configured from request.
busesIn(Iterable<SoundDef> sounds) → List<AudioBus>: The buses sounds actually reaches, in the order settableBuses lists.
canDecodeFileName(String fileName, {List<ModelDecoder> decoders = const <ModelDecoder>[]}) → bool: Whether a file called fileName is one decodeModelBytes would read on its name alone — a built-in suffix, or one of decoders claiming it.
capturePhoto({required Renderer renderer, required Scene scene, required CameraNode camera, required int width, required int height, required FutureOr<void> onRows(PhotoRows rows), RenderSettings settings = const RenderSettings(), PhotoFilter filter = PhotoFilter.none, LinearColor? clearColor, int layerMask = RenderLayers.all, int tileWidth = 1024, int tileHeight = 1024, int margin = 32, void onProgress(double progress)?}) → Future<PhotoCaptureReport>: Draws scene through camera at width × height and hands it to onRows a row of tiles at a time, top to bottom, finished and opaque.
clockText(double? seconds, {bool thousandths = false, String? none}) → String: Minutes and seconds, which is how a time is read rather than how it is counted.
colorVisionOf(GameSettings settings) → ColorVision?: The correction settings asks for, or null for none.
compareModelDocuments(ModelDocument source, ModelDocument readBack, {double tolerance = 0.0, bool allowVertexReorder = false}) → List<DocumentDifference>: What readBack lost or changed against source. Empty means the round trip held.
contributionBetween(ByteData without, ByteData with_, {required int width, required int height}) → PassContribution: Differences two RGBA frames of width by height.
decodeDataUri(String uri) → Uint8List: Decodes a data: URI payload.
decodeDraco(Uint8List bytes) → DracoMesh: Decodes bytes, the contents of the buffer view a primitive's KHR_draco_mesh_compression extension points at.
decodeJpeg(Uint8List bytes) → DecodedImage: bytes decoded.
decodeModel(ModelLoadRequest request, {AssetRead read = AssetRead.whole}) → Future<ModelDocument>: Decodes a model on the calling isolate.
decodeModelBytes(ModelLoadRequest request, Uint8List bytes, AssetUriResolver resolveUri) → Future<ModelDocument>: Decodes already-read bytes with an explicit resolver.
decodeModelInIsolate(ModelLoadRequest request, {AssetRead read = AssetRead.whole}) → Future<ModelDocument>: Decodes a model on a background isolate — in the browser, on the decode worker where one is running (WebDecodeWorker) and in place where not.
decodePng(Uint8List bytes) → DecodedImage: bytes decoded.
defaultImageDecoder(Uint8List encoded, {int? maxDimension}) → Future<Rgba8Image?>: The ImageDecoder every existing Flutter app gets for free.
describeEmptyFrame(Scene scene, List<CameraView> views) → String?: Why scene drew nothing through views, or null when something did draw.
deviceClassPath(String path, DeviceClass deviceClass) → String: path with deviceClass put before its extension: chair.f3d becomes chair.phone.f3d, crypt.json becomes crypt.phone.json.
encodeModel(ModelWriteRequest request) → Uint8List: Encodes request in place — the same bytes encodeModelInIsolate would produce, run on the calling isolate instead of handed off. What encodeModelInIsolate falls back to on the web, and what a caller with no isolate to spare can call directly.
encodeModelInIsolate(ModelWriteRequest request) → Future<Uint8List>: Encodes a model on a background isolate — the write-side mirror of decodeModelInIsolate (model_loader.dart), for the same reason: writing a real model costs tens of milliseconds, which is jank on the UI isolate however fast the encoder is. See that function's own doc comment for why the web falls back to running in place instead.
exportChecked(ModelDocument document, CheckedModelWriter writer, {String name = 'model'}) → Future<ExportReport>: Writes document through writer, reads the files back through the same writer and compares at CheckedModelWriter.tolerance.
exportToF3d(ModelDocument document, {String name = 'model'}) → ExportReport: Writes document to this engine's own .f3d container, reads the result back and compares. Synchronous, unlike the other three: .f3d is read as a view over its own bytes rather than decoded, and nothing in that path is asynchronous either.
exportToGlb(ModelDocument document, {String name = 'model'}) → Future<ExportReport>: Writes document as glTF, reads the result back and compares — a binary format, so the round trip is held to a tolerance of 0.0.
exportToObj(ModelDocument document, {String name = 'model'}) → Future<ExportReport>: Writes document as OBJ (with its .mtl beside it, when the document names a material), reads the result back and compares — held to ObjWriter.decimals' own precision rather than 0.0, since a decimal text format rounds on the way out by design.
exportToStl(ModelDocument document, {String name = 'model'}) → Future<ExportReport>: Writes document as binary STL, reads the result back and compares.
fileUriResolver(String baseDirectory) → AssetUriResolver: Resolves asset URIs relative to a directory on disk.
followCamera(MeshNode sky, CameraNode camera) → void: Moves sky to where camera is, which is what makes a ten-metre sphere a sky rather than a ball.
gather(IrradianceField field, Scene scene, {int rays = 128, LinearColor sky = LinearColor.black}) → void: Fills every probe of field from scene.
generatedAssetPathFor(String sourcePath) → String: Where the build hook would have written sourcePath's converted output — flutter3d_generated/<same relative path>.f3d, the exact mapping AssetLayout.plan computes in flutter3d_build, reimplemented here in three lines rather than imported: the engine depends on no build-time package, and three lines are not worth the first one.
generatedMaterialPathFor(String sourcePath) → String: Where the build hook wrote sourcePath's compiled material — P8: assets_src/fx/rim.f3dmat is flutter3d_generated/fx/rim.f3dshaders, the mapping AssetLayout.materialPlan computes in flutter3d_build, kept beside generatedAssetPathFor for the reason that one is reimplemented.
highContrastOf(GameSettings settings, Accommodations system, {HighContrastSettings base = const HighContrastSettings()}) → HighContrastSettings: The look a frame is drawn with for this player: base switched on or off by wantsHighContrast.
httpJsonPost(Client client) → JsonPost: JsonPost over client: what HttpTelemetrySink sends with, natively and in a browser alike.
httpRunTransport(Client client) → RunTransport: RunTransport over client: what RunService speaks to a share server with.
impostorCard({required Vector3 center, required double radius}) → MeshData: The card an ImpostorNode draws, in the layout impostor.vert reads.
impostorRight(Vector3 d) → Vector3: The right-hand axis of a card, or a baked view, facing along d: level with the ground, except looking straight up or down, where level has no direction and -Z stands in for up.
impostorViewDirection(int column, int row) → Vector3: The direction view column, row of the grid was baked looking back along: from the middle of the sphere towards the camera that took it.
isF3dFile(Uint8List bytes) → bool: True when bytes begins with the .f3d magic.
isFmat(Uint8List bytes) → bool: Whether bytes look like a .fmat.
isGeneratedAsset(String key) → bool: Whether key is a file the build generates — under flutter3d_generated/, a shader bundle anywhere, or JSON — and so one the web reads with loadRevalidatedAsset. Everything else an application ships by hand.
isMissingFile(Object error) → bool: Whether error is a file that was not there.
loadLevelAsset(String asset, {AssetBundle? bundle}) → Future<Level>: Loads the level document at asset from bundle, the application's own asset bundle unless another is given.
loadMaterial(AssetSource source, {required GraphicsDevice device, List<MaterialDecoder> decoders = const <MaterialDecoder>[], LightingModel lighting = LightingModel.pbr, IssueSink? onIssue, ImageDecoder decodeImage = defaultImageDecoder, Map<String, MaterialProgram> programs = const <String, MaterialProgram>{}, LightingModels? lightingModels, TextureCodecs? codecs}) → Future<RenderMaterial>: Reads and binds in one call, which is what an application usually wants. programs lifts the parameters as bindMaterial says; lightingModels is what the file is read against, as loadMaterialDocument says, and codecs what its images are decoded with, as bindMaterial says.
loadMaterialDocument(AssetSource source, {List<MaterialDecoder> decoders = const <MaterialDecoder>[], AssetRead read = AssetRead.whole, LightingModels? lightingModels}) → Future<MaterialDocument>: Reads the material at source, with no device involved.
loadModelAsset(String sourcePath, {bool debugMode = kDebugMode, DeviceClass? deviceClass, AssetSource generatedSource(String path) = BundleAssetSource.new, AssetSource fallbackSource(String path) = FileAssetSource.new, ModelDecoders? decoders, AssetRead read = AssetRead.whole, LightingModels? lightingModels}) → Future<ModelDocument>: Loads a model by the source path a person actually wrote — loadModelAsset('assets_src/chair.glb') — reading generatedAssetPathFor's own .f3d rather than decoding the source itself, because that is what a project that has run dart run flutter3d_build:init (ap-10) and built at least once ships.
loadModelByPath(String path, {AssetSource bundleSource(String path) = BundleAssetSource.new, ModelDecoders? decoders, DeviceClass? deviceClass, AssetRead read = AssetRead.whole, LightingModels? lightingModels}) → Future<ModelDocument>: A model named by a path somebody else wrote — a level document, a vocabulary file — whichever of the two kinds of path it is.
loadRevalidatedAsset(String key, {String? contentHash}) → Future<ByteData>: key's bytes from the asset bundle, revalidated with the server on the web.
loadRevalidatedAssetString(String key, {String? contentHash}) → Future<String>: key as UTF-8 text, read as loadRevalidatedAsset reads it.
loadShaderBundleAsset(GraphicsDevice device, String key, {String? contentHash}) → Future<LoadedShaderLibrary>: The shader bundle at key, read with loadRevalidatedAsset and loaded onto device through loadShaderBundleBytes.
loadShaderBundleBytes(GraphicsDevice device, ByteData bytes, {required String asset}) → Future<LoadedShaderLibrary>: bytes loaded onto device, with a stale bundle answered rather than passed on as a bare refusal.
lockLandscapeForTouch({Playing? playing}) → void: Locks to landscape and hides the system bars, on a device played by touch — playing says whether this one is, and is the platform's own answer when not given.
measureFrameMicros(FutureOr<void> frame(), {int warmUp = 2, int frames = 8}) → Future<int>: Times frame the way a loading screen can afford to: warmUp calls thrown away (the first frames pay for pipelines and uploads, which is not what is being measured), then the median of frames more, in microseconds.
modelWriterNamed(String asked, {List<ModelWriter> writers = builtInModelWriters}) → ModelWriter?: The writer in writers that asked names — by ModelWriter.name first, then by ModelWriter.suffix, with or without its dot, ignoring case — or null when none does.
outlineColorOf(Color color) → LinearColor: color, a display colour a player picked from a swatch, as MeshNode.outlineColor takes it: linear, like every colour the engine takes. The ring is drawn on the finished picture and encoded back to the display there, so it comes out the colour of the swatch. The alpha is dropped: a ring is opaque.
paintSky(MeshData mesh, SkyColor color) → void: Writes color into every vertex of mesh, by the direction it sits in.
parseSplatPly(Uint8List bytes, {bool keepHigherBands = false, SplatColorSpace colorSpace = SplatColorSpace.srgb}) → SplatCloud: The cloud in bytes, or a thrown SplatPlyException saying why not.
parseSplatSpz(Uint8List bytes, {SplatAxes axes = SplatAxes.rightUpBack, bool keepHigherBands = true, SplatColorSpace colorSpace = SplatColorSpace.srgb}) → SplatCloud: The cloud in bytes, or a thrown SplatSpzException saying why not.
photoSettings(RenderSettings settings, PhotoFilter filter, double exposure) → PhotoPlan: The settings every tile of a photo is drawn with, and what had to change.
postToolEvent(String kind, Map<String, Object?> data) → void: Tells a tool listening on the game's VM service — the editor's Play panel, an agent's play_events — that something happened: a level is up, the player died, a pickup was taken.
projectPoint(Matrix4 viewProjection, Vector3 point, {required double width, required double height}) → ScreenPoint?: Where point lands, or null if it is behind the eye.
rayAabb(LocalRay ray, Aabb3 box) → double: Distance along ray to box, or noHit.
raySphere(LocalRay ray, Vector3 center, double radius) → double: Distance along ray to a sphere, or noHit. Inside counts as 0.
rayTriangle(LocalRay ray, Vector3 a, Vector3 b, Vector3 c, {Vector2? outUv, bool cullBackFace = false}) → double: Möller–Trumbore ray/triangle intersection.
readFmat(Uint8List bytes, {String name = '', LightingModels? lightingModels}) → MaterialDocument: Reads a .fmat material.
readHdr(Uint8List bytes) → HdrImage: bytes as an HDR image.
recognizedModelFormat(String fileName) → ModelFormat?: The format fileName's own extension names, or null when it names none of the four this package reads.
registerLevelExtension(LiveLevel live) → void: Puts live on the VM service as ext.flutter3d.level.apply and ext.flutter3d.level.patch, beside the timeline's own extensions: the editor that saved a level sends it here, to a game on this machine or on a phone, and the running game takes it.
registerTimelineExtensions(RunTimeline timeline, {StepTimeTrace? frameTimes, Map<String, Object?> bugReport()?, EntityLayout? entityLayout, String? trackedPart}) → Registration: Puts a RunTimeline on the VM service, so a running game can be paused, stepped, scrubbed and branched from outside the process it is playing in — a level editor attached over the same channel Flutter DevTools already uses, rather than a simulation embedded inside the editor itself.
registerTuningExtensions(InputState input, Tunables tunables) → void: Puts tunables on the VM service, so an inspector can change them while the game runs: ext.flutter3d.cvar.set {name, value} tunes one through input — so the change is on the tape with the step that takes it — and ext.flutter3d.cvar.list answers {"tunables": {name: {"value", "default"}}}, every tunable with its value and its default. Under one key rather than at the top, so the answer's shape is the same whatever a game names its tunables, and the snapshot can hold it.
registryFor(Level level) → EntityRegistry: A registry that accepts every type level names and gives none of them a meaning, each an OpenKind: a level names things a game does not spawn yet, and they are coordinates with words attached until there is something to spawn them into.
replayAfterHotSwap(RunTimeline timeline, {double seconds = 3.0, void onReplayed(CodeReplay replay)?, HotSwap? hotSwap}) → Registration: Lives the last seconds of timeline again under the new code after every hot reload, and says where the new code parts from the old.
replayDemoOnLoop({required Demo demo, required EngineLoop loop, required String part, void swapLevel(Level level)?, SimulationVersion? simulation, ActionSet? actions}) → DemoReplay: Plays demo through loop from its start: the file's loop changes are made at their steps, and each step's events are compared with the file's as well as its checkpoints.
rewindBufferFromDemo({required Demo demo, required EngineLoop loop, required String part, int? keyframeEvery, double? history, SimulationVersion? simulation}) → RewindBuffer: Rebuilds a RewindBuffer that reaches every step of demo, not only the last few seconds a live RunTimeline keeps — rp-02's "скраббер по всему прогону из .f3drun", built by replaying the whole tape once rather than by teaching RewindBuffer a second way to acquire keyframes.
ribbon(OpenPath path, {required double from, required double to, required double width, double step = 2.0}) → MeshData: The strip of road width metres across laid along path from from to to metres, cut every step metres: a flat mesh facing OpenPath.up, with texture u across the road and v along it in metres, so a repeating texture tiles at the same size on every piece.
safeRelativeAssetPath(String uri) → String: A reference inside a model is always relative to the model. An absolute path or a .. segment means the file is reaching outside its directory, which is worth refusing rather than resolving.
samplerOptionsFor(TextureSampling info) → SamplerDescriptor: Maps decoded sampling settings onto the engine's sampler description.
screenBoundsOfBox(Matrix4 viewProjection, Aabb3 box, {required double width, required double height}) → ScreenBounds?: The axis-aligned rectangle covering box on the glass, or null when none of it is in front of the eye.
screenMotion(Matrix4 previous, Matrix4 current) → double: How far the picture moved between two frames, as a fraction of the screen's width: the mean distance five points spread over the view moved between previous and current, two unjittered view-projections (FrameHistory.viewProjection and CameraNode.viewProjection).
settingsKeys(KeyEvent event, GameSettingsController settings, {required void opening(), bool canOpen = true}) → KeyEventResult?: The keys that belong to the settings rather than to the game.
skyNode(MeshGeometry mesh, {String name = 'sky'}) → MeshNode: A node holding mesh, flagged so that it behaves as a sky.
sniffModelFormat(Uint8List bytes) → ModelFormat: Guesses a format from the leading bytes.
splatBytesReader(Uint8List bytes) → SplatRangeReader: A SplatRangeReader over a file already in memory — for tests, and for a caller that has the whole file but wants the paged path anyway.
toDepthRange(Matrix4 projection, DepthRange range) → Matrix4: projection expressed for range.
toFramebufferOrigin(Matrix4 projection, FramebufferOrigin origin) → Matrix4: projection adjusted for where origin puts row zero.
toReversedDepth(Matrix4 projection) → Matrix4: projection with its depth turned round: the near plane at one and the far plane at nought — reversed depth.
uploadEncodedImage(GraphicsDevice device, Uint8List encoded, {required ImageDecoder decodeImage, TextureSampling sampling = const TextureSampling(), IssueSink? onIssue, int? maxDimension, bool platformDecode = true, TextureCodecs? codecs}) → Future<TextureHandle>: Decodes an encoded image (PNG, JPEG, KTX2, …) and uploads it through device.
uploadRgba8(GraphicsDevice device, Rgba8Image image, {TextureSampling sampling = const TextureSampling()}) → TextureHandle: image uploaded through device, with a mip chain when sampling asks for one — uploadEncodedImage's own tail, for pixels that never were an encoded file: a map packed from several (packed_maps.dart).
validateGltfExport(Uint8List bytes, {AssetUriResolver? resolveUri, double tolerance = 1e-5}) → Future<List<String>>: Reads bytes as glTF/GLB and checks every accessor's declared min/max against the values it actually holds.
viewAxisOf(Matrix4 viewProjection, [Vector3? out]) → Vector3: Which way viewProjection looks, as a unit vector in world space.
wantsHighContrast(GameSettings settings, Accommodations system) → bool: Whether settings asks for the high-contrast look, with system's answer as the fallback.
withDepthPlanes(Matrix4 projection, {required double near, required double far, bool reversed = false}) → Matrix4?: projection with its depth row rebuilt for a near and a far plane — far may be double.infinity — and turned round when reversed; or null when projection is not one whose depth row can be rebuilt.
withTextureTransform(MeshData mesh, TextureTransform transform) → MeshData: mesh with transform applied to its texture coordinates.
writeFmat(MaterialDocument document, {LightingModels? lightingModels}) → String: Writes document back out, so a tool that edits a material can save it.

Typedefs

AssetBytes = Future<ByteData> Function(AssetRequest request): How a level's own files are found.
AssetSourceFactory = AssetSource Function(String path): Makes the AssetSource for path — the path with its scheme taken off.
AssetUriResolver = Future<Uint8List> Function(AssetRequest request): Resolves a URI referenced from inside an asset to its bytes.
BackendOpener = Future<GraphicsDevice> Function(DeviceRequest request): Opens a GraphicsDevice for request, or throws.
BlendCurve = double Function(double t): How a blend's progress, from nought to one in time, becomes how far the shot has moved, from nought to one.
CompositeBuilder = BehaviorComposite Function(BehaviorParameters params): Builds a composite kind's code from a node's fields, once when a tree is read.
ComputeOpener = Future<GraphicsDevice> Function(DeviceRequest request): Opens a compute-only GraphicsDevice for a ComputePlacement, or throws: the wgpu sidecar, a CPU device — 1.0. Its DeviceRequest has no size (DeviceRequest.compute), because it presents nothing.
Consideration = double Function(BehaviorContext context): How much one consideration likes an option, from nought to one.
ConsiderationBuilder = Consideration Function(BehaviorParameters params): Builds a consideration kind's code from a node's fields, once when a tree is read.
ContactFilter = bool Function(SweptContact contact): Whether a contact counts, asked of the collider and the way it faces.
CrashReporter = void Function(CrashContext crash): Told an error nothing caught, with where it was thrown: what a crash reporter (Crashlytics, Sentry, a file of one's own) is wired to.
EventHandler<T extends BusEvent> = void Function(Delivered<T> event): A subscriber to events of type T, handed each delivery of one.
FormatMigration = Map<String, Object?> Function(Map<String, Object?> document): One step of a format's migration chain: a document at one version, as the next version writes it. Handed a copy, so it may change it in place.
FormatRefusal = Flutter3dFormatException Function(String message): Turns a sentence into the format's own exception, so a level reader still throws LevelFormatException when the envelope is what refused.
FramePresenter = Widget Function(GraphicsDevice device, TextureHandle frame, {BoxFit fit, FilterQuality quality}): The shape of presentFrame, and of every presenter a backend registers.
ImageDecoder = Future<Rgba8Image?> Function(Uint8List encoded): Decodes an encoded image — PNG, JPEG, whatever uploadEncodedImage's caller hands it — into straight (not premultiplied) RGBA8 pixels, or null for an image that will not decode.
IssueSink = void Function(Issue issue): Where a library says what it could not do: the application decides what to do with it.
JsonPost = Future<JsonAnswer> Function(Uri url, String json): One POST, as this package needs it: a body out, a status and a body back.
LeafBuilder = BehaviorLeaf Function(BehaviorParameters params): Builds a leaf kind's code from a node's fields, once when a tree is read.
LevelDocumentText = Future<String> Function(AssetRequest request): How a level's own document is found.
LogListener = void Function(LogRecord record): Told every record an EngineLog keeps.
LoopSystem = void Function(LoopContext context): Work added to a phase.
PoseSource = Matrix4 Function(): Where something in the scene is, asked once a mix: a node's world matrix.
RunTransport = Future<RunResponse> Function(RunRequest request): Sends a RunRequest and answers with what the server said.
SaveMigration = Map<String, Object?> Function(Map<String, Object?> run): Turns a game's save data at one version into the next.
SimulationAnswer = Object? Function(SimulationQuestion question): How the simulation answers one named question: SimulationHandle.ask with the question's SimulationQuestion.arguments, run against its SimulationQuestion.world where the world is, between two steps. The answer is plain values only, which is what crosses an isolate.
SimulationFactory = SimulationSetup Function(Object? arguments): Builds a simulation where it runs, from arguments — plain values the caller of IsolateSimulation.open passed.
SizedImageDecoder = Future<Rgba8Image?> Function(Uint8List encoded, {int? maxDimension}): An ImageDecoder that can also scale a large image down while it decodes it — A4.17.
SkyColor = LinearColor Function(SkyLook look): The colour of the sky in the direction asked about.
SplatRangeReader = Future<Uint8List> Function(int offset, int length): Reads length bytes of the tree file starting at offset.
ToolEventPoster = void Function(String kind, Map<String, Object?> data): Posts what happened in a game, to whoever watches it from outside: the shape of postToolEvent, and of what a test hears it through.
VmExtensionHandler = Future<ServiceExtensionResponse> Function(String method, Map<String, String> parameters): What answers a VM service extension: the method's name and its parameters, every one a string, as dart:developer hands them over.
VoiceId = Object: A live voice, as the backend sees it.

Exceptions / Errors

ActionMapFormatException: Thrown when a saved action map cannot be read: a newer build's, or a document that is not one.
AnimationGraphFormatException: An animation graph's JSON (a model's extras) in a shape the reader does not know, naming where in the document it went wrong.
AnimationPointerFormatException: An animation pointer (KHR_animation_pointer) whose path this build does not know how to resolve.
AssetNotFoundException: An asset the program named and the platform does not have: a key missing from the Flutter asset bundle, a file not on disk.
CapabilityException: Something asked of a device, a backend or a platform that it does not do: a feature a backend leaves out of its features, a limit a request exceeds, a check a backend declines.
ComputePlacementException: The typed refusal of a compute step nothing can run: why, and what each executor said.
ConstraintCycleException: Thrown when after/before constraints, or plugin dependencies, go round in a circle.
CubeLutFormatException: A .cube colour lookup table the reader cannot read, naming the line.
DeviceResourceException: A resource a device was asked to make or read and could not: pixels that are not the size their description says, a texture with nothing to read.
DeviceUnavailableException: A device that would not open: a browser without WebGL2 or WebGPU, a GPU the browser has blocklisted, or every backend a DeviceRegistry holds refusing in turn.
DocumentFormatException: A document the envelope refused, when the format has no exception of its own: another format's document, a version from the future, a requires this build does not understand.
DracoException: Thrown when a stream is not one this decodes, with the reason in it.
ExpressionSyntaxException: Text that is not an expression, with where it went wrong.
F3dFormatException: Raised when a file is not a .f3d, is truncated, or claims a version this build does not understand.
FbxFormatException: An FBX file, which this build recognises and does not read yet.
FieldResidenceException: The typed refusal of a field that cannot be held where it asks: which field, which residence, why, and the capability that was missing.
Flutter3dException: The root of every exception flutter3d throws.
Flutter3dFormatException: Bytes or text that are not what they claim to be, or are a version this build cannot read: a level, a model, an image, a trace, a shader source.
FmatFormatException: A .fmat material file that is not one: not a JSON object, no version key, or a version newer than this build reads.
FormatRegistrationException: A format a FormatRegistry would not take: an id, alias or suffix that is another format's, a plugin's id outside its namespace, or a plugin's format with no fixture.
FrameCaptureFormatException: A frame capture (FrameCapture.fromJson) that is not one, or is from a newer build: the message says which, and what to do about it.
FrameGraphException: A graph that failed to compile, with the reason a person can act on.
FrameGraphSnapshotFormatException: A frame graph snapshot that cannot be read: a document of another format, or of a version newer than this build reads.
GameSettingsFormatException: Thrown when a settings file cannot be read at all: a newer build's, or another format's.
GeoOriginFormatException: A geo origin in a document that cannot be read.
GltfFormatException: A glTF or GLB file the reader cannot read: a container that is not GLB, an accessor that runs past its buffer, a component type or mode the specification does not define.
HdrFormatException: What a file that is not a readable .hdr is answered with.
ImageFormatException: An image the pure decoders (PNG, JPEG) cannot read: a signature that is not the format's, a chunk that runs past the end, a feature the decoder does not implement.
Ktx2FormatException: Raised when bytes are not a KTX2 file, are truncated, or use a feature this stage of the loader does not read yet — see the library doc comment for exactly which those are.
LevelFormatException: Raised when a document is not a level, or is one this build cannot read.
MaterialBundleException: A .f3dmat bundle that holds no material, or one that cannot be told apart from another. Syntax errors inside a material are MaterialSyntaxException.
MaterialFormatException: A physical material's document — a PhysicalMaterial's JSON, a data plugin's physicalMaterials entry — that cannot be read: a number that is not one, a group with no source, a phase or an id that is not a word.
MaterialParameterException: A parameter name, a value or a unit a material does not take: a name it does not declare, a value of another width, a param folded into the shader when it was compiled, or a value MaterialParameters.setNamed cannot read as numbers.
MaterialRegistrationException: A material or a pair a MaterialCatalog would not take: an id already taken, a plugin's id outside its namespace, an entry whose numbers PhysicalMaterial.problems finds implausible.
MeshoptFormatException: A meshopt-compressed buffer (EXT_meshopt_compression) that does not decode: truncated, an unknown header, or a count that does not match.
PanoramaFormatException: Bytes EnvironmentMap.fromEncoded was handed that are neither a Radiance .hdr nor an image its decoder reads.
PipelineRefusedException: A pipeline the backend could not build or link.
PluginException: A plugin cannot be discovered, installed, enabled or disabled, or a run-time plugin did something it was not allowed to.
PluginFormatException: Text that should name a version, a range or a manifest and does not.
ResourceException: Something outside the program that the engine needed and did not get: a file, an external tool, a GPU device, a network service, a build artefact that does not match the code reading it.
ShaderBundleException: Raised when a device will not load a bundle, and says which and why.
ShaderCompileException: A shader stage a backend's compiler refused, or a pair of stages its linker would not join.
SplatOctreeException: Thrown when bytes are not a splat tree this can read.
SplatPlyException: Thrown when a file is not a PLY this can read, with the reason in it.
SplatSpzException: Thrown when a file is not an SPZ this can read, with the reason in it.
UnitFormatException: Text that is not a unit, or a document's unit or quantity that is not one.
UnitMismatchException: A conversion between units of different dimensions: a length asked for in seconds, a luminous flux compared with an intensity.
UnknownMaterialException: A material asked for by an id no material in the catalogue has: a level, a world or a save naming a substance a plugin brings, with that plugin not installed.
UnorderedAccessException: Thrown by EngineLoop.validateOrder, and in a debug build when the loop orders its systems, for a step phase with an UnorderedAccess in it.
UnsupportedCapabilityException: The refusal every capability-gated call throws where the capability is missing: a CapabilityException that names what was asked for and who refused it.
WorldPropertiesFormatException: A world's properties in a document — a level's world, a snapshot — that cannot be read.

flutter3d_game library

Classes

Enums

Mixins

Extension Types

Extensions

Constants

Properties

Functions

Typedefs

Exceptions / Errors

flutter3d_game package

flutter3d_game library