What changed, by release

Every release of the engine, newest first. Under each one: the showcase pages whose picture or behaviour it changed, and the pages it added. Each links to the guide that builds it and to the live demo you can run in this browser.

The list is read from the showcase's catalog, and every line in it quotes the package CHANGELOG it came from, so it cannot claim a change the record does not have. The full record, package by package, is in each package's CHANGELOG on pub.dev.

0.8.2 #

Changed

• Cascaded shadows: The sun records both faces of its casters, so where a caster stands on the ground its shadow no longer lets a thread of light through. (live demo)
• Soft shadows: Each tap of the soft edge allows for the slope of the surface it lands on, so a slope the sun lights no longer darkens itself at the edge of its own penumbra. (live demo)
• Cloth: The ball's facets no longer show through the sheet draped over it: the flat triangles between the particles stay clear of the surface too. (live demo)

0.8.1 #

Changed

• Cascaded shadows: The flat part of the normal offset is held to one texel of its cascade, so shadow edges sit about a pixel closer to the pillars that cast them. (live demo)
• Contact shadows: Without a temporal resolve the edge no longer carries a comb: a resolve pass averages the march's fixed pattern. (live demo)
• Cloth: A sheet resists shear, so a quad no longer folds flat into a rhombus, and one part of it no longer passes through another. (live demo)

0.8.0 #

Changed

• Rectangle area lights: The highlight is integrated over the whole panel, so a polished floor reflects the window's shape; the page now has a floor roughness slider to show it. (live demo)
• One bounce of diffuse light: Each pixel reads the eight probes around it, weighed by facing and by a visibility test, and the light is no longer scaled by the ambient strength twice. (live demo)
• Cascaded shadows: A near cascade reaches back to a tall caster standing outside it, and shadows stop bleeding across the atlas tiles. (live demo)
• Soft shadows: The sun's radius is its apparent size in radians, and the penumbra is worked out in metres from the gap between blocker and receiver. (live demo)
• Tone-map curves: A baked display transform can take the curve's place, and the new aces2 curve is the ACES 2.0 tonescale the engine ships as one. (live demo)

New in the showcase

• Clear coat: A thin clear layer over the paint, with a sharp highlight of its own on top of a matte colour, like a car or a varnished table. (live demo)
• Sheen: The bright rim of velvet and felt, where light grazing the fibres comes back towards you. (live demo)
• Stretched highlights: A highlight drawn out into a streak, the way brushed steel shines, without modelling the grooves. (live demo)
• Glass that shows the scene: Glass that bends and blurs what stands behind it, drawn by reading a copy of the picture made before the glass. (live demo)
• Transparency without sorting: See-through panes that cross each other come out the same from any side, because nothing has to be drawn back to front. (live demo)
• A texture transform per map: Each texture of a material moved, tiled or turned on its own, so a colour map and a glow map no longer have to line up. (live demo)
• Rough metals and rough clay: Rough gold as bright as polished gold, and rough clay that stops looking like plastic, from two frame settings. (live demo)
• Clustered lights: The view is cut into small cells that each list the lights reaching them, so one floor under sixty-four lamps is lit by all of them. (live demo)
• Volumetric fog: Air that the lights shine through, so each lamp glows in the haze around it and the air thins out with height. (live demo)
• The field kept current: The renderer looks at the room again from a few probes each frame, so the bounced light follows a wall that changes colour. (live demo)
• EVSM shadows: The sun's shadow map blurred once for the whole frame, so each pixel reads a soft edge with a single lookup. (live demo)
• Cascades that keep what stands still: Blocks that never move go into a sun atlas of their own, so a walking camera draws only the strips that came into view. (live demo)
• Temporal anti-aliasing: Each frame is drawn a fraction of a pixel off and blended with the frames before it, so thin edges stop stair-stepping and flickering. (live demo)
• Motion blur: Whatever moved while the shutter was open is smeared along the way it moved, as a camera would show it. (live demo)
• Spatial upscaling: A frame drawn at a smaller size is brought back up with a filter that follows edges, so outlines stay crisp. (live demo)
• Horizon occlusion and bounced light: Corners darkened by how much sky each point can see between its horizons, and a coloured wall tinting the floor beside it. (live demo)
• Local exposure: Each part of the picture gets its own exposure, so a dark room and the bright window in it can both be seen. (live demo)
• Impostors: Draw a far tree as one card that turns to the eye and shows views baked in advance. (live demo)
• Occlusion culling: Leave out meshes hidden behind a wall marked as an occluder, before they are drawn. (live demo)
• Splats under a budget: Cut a cloud of Gaussians into a tree and draw only as many splats as a budget allows. (live demo)
• Variants and animation pointers: One model that changes its look by name, and a clip that animates a material and a light rather than a node. (live demo)
• Smoke lit by the scene: Puffs of smoke lit from each side by the lights around them, through six pictures of one puff. (live demo)

0.7.4 #

Changed

• Light channels: The sun's shadow survives on a node lit through a channel of its own. (live demo)
• Shadow quality: A double-sided material casts its shadow from every face. (live demo)
• Cascaded shadows: A long shadow no longer ends in a straight line at the far plane, and the normal offset grows with the cascade's texel. (live demo)
• Contact shadows: The march is jittered, and it follows the sun even when the sun casts no shadow map. (live demo)
• The cached shadow map: Hiding a static caster drops it from the bake, and a swapped mesh or a morph redraws its shadow. (live demo)
• Bloom and halation: Halation warms each level once, and a new scatter setting weighs the wide levels against the core. (live demo)
• Tone-map curves: AgX is the whole Minimal AgX and comes out linear; its sigmoid used to be encoded to sRGB twice. (live demo)
• Colour grade: Contrast pivots on mid grey, lift keeps white white, and a centred dither is on by default. (live demo)
• Grade through a LUT: The table is indexed and answered in sRGB, the space a .cube file is written in. (live demo)
• Screen-space reflections: The march starts at a jittered point and refines its hit, so the smeared ghosts are gone. (live demo)
• Ambient occlusion: The blur weighs depth relative to the centre, so a distant floor blurs like a near one. (live demo)
• Light shafts: Shafts scatter the sun's own light through the air, with a density and a forward glow, instead of veiling the frame. (live demo)
• Depth of field: A sharp object no longer bleeds into the blur behind it, and the sky blurs as the far field does. (live demo)
• Cloth: Cloth meets a ball as a ball, stays calm when draped, feels wind as a force and holds on with friction. (live demo)

0.7.0 #

New in the showcase

• Alpha modes: Opaque, cut-out, blended or hashed: four answers to what a see-through material should do. (live demo)
• Identical-draw batching: A run of nodes sharing a mesh and a material collapses into one instanced call instead of one draw each. (live demo)
• Rectangle area lights: A rectangle with width and height, so an interior reads as lit by a window instead of by a bright dot behind one. (live demo)
• Lights in lumens and lux: A lamp off a datasheet, in lumens or lux, converted into the engine's own light intensity instead of tuned by eye. (live demo)
• Light channels: A bit mask a light and an object meet on: a light reaches an object only when they share a bit. (live demo)
• Thirty-two lights and the fade band: Eight lights in the shader's own slots and twenty-four more through a light list, with a ramp instead of a cliff where the list ends. (live demo)
• The material expression language: A small GLSL-flavoured source, parsed once into a tree that either emits a fragment shader or is evaluated directly. (live demo)
• One bounce of diffuse light: A grid of probes, each filled by casting rays out from it and recording what colour comes back, so a red wall tints the light reaching what faces it. (live demo)
• Soft shadows: A shadow that is sharp where it starts and blurs the farther it travels, like one from a light with a size. (live demo)
• Contact shadows: A short march toward the sun that darkens the crease where an object meets the ground. (live demo)
• Shadows of cut-out leaves: A leaf or a fence with holes in its texture throws a shadow with the same holes. (live demo)
• Tone-map curves: Every tone curve the engine has, and a display transform table, squeezing light of any brightness into what a display can show, side by side on one scene. (live demo)
• Grade through a LUT: A grade written down as a small texture: every colour that comes in has one colour it comes out as. (live demo)
• Post effects on your own image: Hand the renderer any picture and get it back bloomed, exposed and tone mapped, with no scene behind it. (live demo)
• Switching passes off: Leave a pass out of a frame by its name, and read back that the frame did as it was told. (live demo)
• Automatic multisampling: The scene pass smooths its own edges when the device offers it and nothing in the frame needs the picture read back first. (live demo)
• Light shafts: A view ray marched through the sun's own shadow map, so a beam through a doorway keeps the doorway's shape. (live demo)
• FXAA and sharpen: One pass over the finished picture that softens a hard contrast step, with a sharpen riding the same taps. (live demo)
• Depth of field: A thin-lens blur from a focus distance, a focal length and an f-number, the numbers a photographer already knows. (live demo)
• Viewport shading: Normals, clay, outline and curvature, each read out of the second buffer the scene pass already writes. (live demo)
• Adaptive resolution: The whole frame drawn smaller when nothing else is left to trade, at a scale a plain object works out from recent frame costs. (live demo)
• Generate tangent frames: Derive render-ready tangents and handedness from positions, normals, and UVs. (live demo)
• Vertex cache ordering: Reorder triangles and vertices so the GPU can reuse recent work. (live demo)
• BVH and frustum culling: Skip hundreds of meshes whose world-space boxes miss the current view. (live demo)
• Debug drawing: Inspect bounds, normals, axes, lights, and a skeleton over the scene. (live demo)
• Levels of detail: Choose a finer or coarser mesh from how much of the view it covers. (live demo)
• Mesh editing overlays: Draw edges, vertex handles, a face wash, and a through-mesh gizmo. (live demo)
• Build a mesh in code: Write a coloured pyramid as vertices and indexed triangles in Dart. (live demo)
• Polylines in screen pixels: Draw joined routes whose width stays steady as the camera moves. (live demo)
• Gaussian splats: Decode a binary PLY cloud and draw its translucent ellipses back to front. (live demo)
• What a frame reports: Read draw, triangle, instance, culling, and per-pass counts after a frame. (live demo)
• Plan a frame before drawing: Compile the render graph without drawing and compare it with the frame. (live demo)
• Several views in one frame: Crop a view to a rectangle and combine two of them in one render call. (live demo)
• Capturing a frame: Record every pass of one frame, with the pixels each pass wrote. (live demo)
• Step, linear and cubic tracks: The same keyframes read three ways: a snap, a straight line and a curve with tangents. (live demo)
• Additive layers: A layer that adds its own clip's distance from its rest frame on top of the base, instead of replacing the base outright. (live demo)
• Root motion: The forward step a walk cycle already had, extracted out of its own track and handed back a frame at a time. (live demo)
• Two-bone IK: An arm or a leg bent so its tip reaches a point, solved on a pose with no scene behind it. (live demo)
• A chain of any length: A rope or a tail bent to reach a point, solved by walking the chain backward and forward until it does. (live demo)
• A pose with no scene: A hierarchy of local transforms sampled straight from a clip, with no scene node anywhere in the arithmetic. (live demo)
• The skeleton drawn: The joints under a skinned mesh, drawn as a bone per pair and a cross at every joint with no child. (live demo)
• A crowd from a baked clip (here or earlier): Every clip a crowd wears sampled once into a table, so an instance needs only which clip and how far into it. (live demo)
• Off-axis frustum: A frustum whose axis is not down the middle, for a headset lens or a portal window. (live demo)
• Rendering in tiles: Drawing a picture larger than any single render target, one square of it at a time. (live demo)
• Orbit: Framing a model automatically and swinging the view to a new angle instead of jumping to it. (live demo)
• Free-look and walking: Turning the head from where the camera stands and walking it there, instead of orbiting a point somebody else chose. (live demo)
• Screen-space bounds: The rectangle a box in the world covers on the glass, for a focus ring, a tooltip or a label to use. (live demo)
• Cameras and lights from a file: A camera and a punctual light, held on a document the same way a mesh is, written into a GLB and read back. (live demo)
• Writing GLB: Any decoded document, written out as a self-contained GLB, optionally quantized and reordered for a smaller file. (live demo)
• Export, read back, compare: Write a document, read the file back, and report what a real round trip changed or could not carry. (live demo)
• STL: A flat triangle soup with no shared vertices, told apart from ASCII by the file's own size arithmetic. (live demo)
• USDZ export: Geometry written into the ZIP archive Quick Look opens, one Mesh prim a surface, no materials yet. (live demo)
• Compressing a texture: Four block encoders, a mip chain, and a KTX2 container to write the result into. (live demo)
• Draco meshes: A compressed mesh format read all the way, both connectivity methods and every prediction scheme a current encoder writes. (live demo)
• Meshopt compression: A mesh's vertex and index buffers, packed by EXT_meshopt_compression and decoded again on the way back in. (live demo)
• Image decoding without dart:ui: PNG, JPEG and Radiance .hdr, each read by a decoder that needs no window and no Flutter binding. (live demo)
• Texture transform: A material's texture coordinates, scaled, rotated or moved without touching the texture itself. (live demo)
• The build-time converter: The command line tool that turns a glTF, OBJ or STL model into this engine's own .f3d container ahead of time. (live demo)
• A burst that lights the room: ParticleSystem.burst takes a light source, so an explosion or a muzzle flash lights whatever is standing near it. (live demo)
• Cloth: A pinned grid of particles, solved with XPBD, draped around whatever collision shapes it is told not to pass through. (live demo)
• The ECS world: Entities and components, saved as one document and carried across a level that has since been edited. (live demo)
• Replays and digests: A checkpoint trace that names the first step two runs of the same tape stop agreeing at. (live demo)
• Rewinding: The last few seconds of a run, kept as a snapshot a second and the raw inputs between them, for a kill camera or a rewind mechanic. (live demo)
• Running without a screen: The interface a tool that plays a game blind is written against: a step, a save, and a sentence about how things stand. (live demo)
• Baked visibility: Which parts of a brush level can be seen from where, baked once and applied every frame by hiding what the eye cannot see. (live demo)
• Terrain in tiles: Ground cut into tiles buildable at more than one resolution, and a level chosen by distance, with a skirt closing the seam. (live demo)
• The virtual pendulum lab: A worked example small enough that one changed number visibly changes a run, and a digest that finds exactly where two runs part. (live demo)
• A lesson through the rig: The same lesson document a step panel authors, played back through a stereo rig with a button instead of a keyboard. (live demo)
• Widgets in the scene: A live Flutter widget drawn as a mesh in the scene, redrawn when the widget changes. (live demo)
• Describing the scene to a screen reader: One accessibility node per object, positioned where the camera actually projects it, instead of one opaque rectangle. (live demo)
• The scene surface and its status screens: The widget every viewport is built from, and the screen an application shows when a renderer never opened at all. (live demo)
• Loading a level: The bridge between a level document and something drawable, and a cache that uploads each repeated shape once. (live demo)
• Storage on every platform: Small documents a player's choices live in, kept the right way on whichever platform is running, and never throwing. (live demo)
• Frame timing and memory pressure: How long the last frame took, what a window of frames cost, and giving pooled render targets back when memory runs short. (live demo)
• Reduce motion (here or earlier): What the player has already told the operating system, read as a default for a camera's own involuntary movement. (live demo)
• Settings, config and saves: What a player has changed about how the game behaves for them, and where a run in progress is kept between launches. (live demo)
• Pausing and stepping a running game: Pause, step one fixed frame at a time, preview a rewind and release into the past so the run continues from there. (live demo)
• Two engines, one Stack: The Flame and flutter3d layers composited in one widget, nothing bridged between them yet. (live demo)
• Keeping a Flame position and a flutter3d node in step: A Flame component and a flutter3d node kept at the same place, either side free to be the one that moves. (live demo)
• Bridging a flutter3d_sim actor: A simulated actor's own body driving a Flame position and the mesh that follows it. (live demo)
• Bridging a falling rigid body and its collision: A physics body falling through a real collision world, its contact with the floor relayed as a Flame collision callback. (live demo)
• One key, read by both engines: A Flame key event translated into the same Bindings/InputState a native flutter3d_game reads. (live demo)
• Reconciling an orthographic camera and a Flame viewfinder: A flutter3d camera and a Flame viewfinder framed the same, either side free to lead. (live demo)

0.6.0 #

New in the showcase

• WebGPU: The fourth backend, tried before WebGL2 only when a web build asks for it by name at compile time. (live demo)
• Rollback netcode over a loopback: Two players' worth of a fixed-step simulation kept in step across a delayed, lossy connection, with prediction and rollback. (live demo)

0.5.2 #

New in the showcase

• Morph targets: A shape a mesh can blend towards, packed as a texture and dialled in by a weight from nought to one. (live demo)
• A face per copy: One batched draw where every copy wears its own morph weights instead of the one shape a uniform would give them all. (live demo)
• Layers and masks: A second clip over part of a skeleton, while the base keeps playing over the rest of it. (live demo)

0.5.1 #

New in the showcase

• Distance fog: Things farther from the eye fade toward one colour, so a long view has depth and its far end has no hard edge. (live demo)
• Perspective and orthographic: The two ways a camera turns the world into a flat picture, and the one number in the matrix that tells them apart. (live demo)
• Collision shapes: Five shapes, box, sphere, capsule, wedge and heightfield, each with a closed-form overlap test against every other one. (live demo)
• Walking on terrain: Ground as a grid of sampled heights, walked by the same character controller that walks a flat floor. (live demo)
• Portable determinism: Transcendental functions and a random generator that give the same bits on every platform, and a random state a snapshot can carry. (live demo)

0.5.0 #

New in the showcase

• Procedural textures: Generate a solid colour and checkerboard as RGBA pixels in code. (live demo)
• A decoder of your own (here or earlier): A studio's own format, read through the same plugin boundary a built-in reader goes through. (live demo)
• Over-life curves: Size and colour described as a handful of keys over a particle's life, instead of one number turning into another. (live demo)
• Raycast, sweep and overlap: A ray, a moving shape and a still one, all answered by the same broadphase grid. (live demo)
• A character controller: A kinematic walker that slides along what it meets instead of bouncing off it, and reports the ground it lands on. (live demo)
• Systems and events: Work a game hangs off a fixed step it does not own, run in a stated order, and the events a step reports for a frame to read. (live demo)
• Difficulty axes: Four numbers a genre applies where it decides, instead of a name it has to interpret. (live demo)

0.4.3 #

New in the showcase

• Anisotropic texture filtering: A floor stretching to the horizon keeps its checks sharp instead of turning into a grey band. (live demo)
• Ambient light: The flat colour and strength a surface falls back to wherever no direct light reaches it. (live demo)
• Reflection probes: A mirror finish that shows the room it stands in: the scene captured into a cube from one point and blurred once per roughness on the device. (live demo)
• Auto exposure: A meter reads the frame's own brightness and moves the exposure toward a chosen grey, the way a camera's own metering does. (live demo)
• The surface buffer: The world normal and view-axis depth the scene pass writes once, for every screen-space effect to share, seen raw. (live demo)
• X-ray silhouettes: The outline of whatever a wall hides, painted flat over the wall, while the visible part stays lit. (live demo)
• Picking by pixel: Asking the renderer which mesh is drawn at a point, exact by construction because the rasteriser already decided. (live demo)

0.4.2 #

New in the showcase

• Lightmaps: Indirect light baked into a texture ahead of time and read through a second coordinate the vertex colour carries. (live demo)
• KTX2 and Basis textures: A compressed-texture container, including Basis Universal files transcoded to plain RGBA8 at load time. (live demo)
• The level format: A level as a document: brushes, entities and lights, round-tripped through JSON and checked by a validator before anyone plays it. (live demo)

0.4.1 #

New in the showcase

• Path-finding: Where an agent can stand, baked once from the level into a lattice a step can query in one array lookup. (live demo)
• A flow field (here or earlier): One sweep from a goal, read by every agent as the direction to walk from wherever it stands. (live demo)
• An automap (here or earlier): The level as the player has seen it, floor where they walked and walls where it stopped, built over the same grid the monsters use. (live demo)
• Baking a lightmap: Unwrapping a level's brush faces onto an atlas, then gathering the light the walls throw on each other into it. (live demo)

0.4.0 #

New in the showcase

• The held item's own pass: Draw a held item over the finished world, with its own depth. (live demo)
• Loading into a scene (here or earlier): A decoded document uploaded once and placed as many times as a scene wants, whatever format it came from. (live demo)
• Fixed step and interpolation (here or earlier): A simulation that always advances by the same amount, smoothed for a screen that draws at a different rate. (live demo)
• Doors, lifts and buttons (here or earlier): One machine that travels between two places, and a switch that relays an activation to it by name. (live demo)
• Flickering lights (here or earlier): A light that flickers like fire or pulses like something magical, with one brightness number driving both the glow and the light. (live demo)
• Actors, brains and health (here or earlier): A thin handle onto an entity's components: health that can run out, and a brain a game writes for itself. (live demo)
• The shared camera rig (here or earlier): Easing towards where a chasing view should be, carrying a knock or a shake that fades, and staying out of the walls. (live demo)
• A Catmull-Rom path (here or earlier): A smooth closed curve through a list of points, measured once so everything after that can ask for a point by distance in metres. (live demo)

0.3.0 #

New in the showcase

• .fmat material files: A material as a file of its own: an artist's unit of work, worn by every mesh that shares the look. (live demo)
• Image-based lighting: Light from the surroundings instead of a lamp: a cube map blurred once per roughness, so a mirror and a matte wall read the same picture at different sharpness. (live demo)
• The cached shadow map: Walls that never move are drawn into the lamp's shadow map once, so each frame only redraws what moved. (live demo)
• Colour grade: Contrast, saturation and warmth for the whole picture, separate tints for the shadows and the highlights, and the marks a lens leaves. (live demo)

0.2.0 #

New in the showcase

• Directional, point and spot lights: The three light shapes that leave a single point, so the direction to them is one vector and the falloff is glTF's own attenuation. (live demo)
• Procedural sky: A sky with a gradient, a glow and a sun disc, drawn from a few numbers with no image to load. (live demo)
• Cascaded shadows: The sun's shadow in slices, so it is sharp near you and still reaches the horizon. (live demo)
• Point and spot shadows: A lamp or a spotlight throws shadows in every direction it lights, through a cube map. (live demo)
• Screen-space reflections: A ray marched through the picture already drawn, so a polished floor shows what stands on it. (live demo)
• Ambient occlusion: The ambient term darkened wherever a surface cannot see much of the sky, from nothing but the shapes already in the frame. (live demo)
• Many copies in one draw: Draw a field of coloured meshes from one instanced vertex buffer. (live demo)
• The software rasteriser: A device with no GPU behind it: what the golden pictures are drawn with, and every page in this showcase besides. (live demo)
• What differs between them: A live table of what the device open right now can do, read from GraphicsDevice.supports* rather than from a name. (live demo)
• A particle pool in one draw call: One pool of particles, drawn in one instanced call however many effects are bursting out of it. (live demo)
• Emitter shapes: Sphere, cone, box and drift: where a particle starts and which way it leaves. (live demo)
• Forces: Gravity, drag, wind, turbulence and spin, stacked on the same burst. (live demo)
• Particles that light: A torch measured from its own particles, so the light it casts cannot disagree with the flame that is supposed to be making it. (live demo)
• Textured billboards: A sprite on every billboard instead of the procedural disc, which is what turns a particle into any shape you can paint. (live demo)
• Sprite-sheet animation (here or earlier): A grid of frames played across a particle's life, driven by how far through it is rather than by a clock. (live demo)
• Mesh particles (here or earlier): Every live particle drawn as a copy of a real mesh instead of a camera-facing quad, in one instanced call. (live demo)
• Layers and contact callbacks (here or earlier): Two colliders are tested against each other only when each is in the other's mask. (live demo)
• Rigid bodies: Mass, gravity, impulses and rest, with no rotation: a box that never tips stays cheap to test against another box. (live demo)
• Mixer buses: A group of sounds a player can turn down as one, read against a shared master every frame. (live demo)

0.1.0 #

New in the showcase

• The six lighting models: Unlit, Lambert, Blinn-Phong, PBR, Toon and Normals: one material field picks how a surface answers light. (live demo)
• PBR metal and rough: One material, two numbers, how metallic and how rough, and the light does the rest. (live demo)
• Normal maps (here or earlier): Fine relief stored in a texture, so a smooth surface catches light like a bumpy one. (live demo)
• Draw order and depth state (here or earlier): Draw a surface first, keep it out of the depth buffer, or skip the backs of triangles. (live demo)
• Specular strength (here or earlier): One scalar turns the whole frame's specular response up or down without touching a single material. (live demo)
• Manual exposure (here or earlier): The linear multiplier the composite applies before the tone curve, set by hand instead of metered. (live demo)
• Wireframe (here or earlier): Draws the scene's triangles as lines, on the one backend that has a polygon mode for it. (live demo)
• Shadow quality: How big the shadow map is, how much slack it leaves and how dark it paints, on one page. (live demo)
• Bloom and halation: Light brighter than the display can show spills over the edge of what gives it off, and can turn red at the rim. (live demo)
• The scene graph: Arrange an orbiting planet and moon with inherited transforms. (live demo)
• Procedural shapes: Build a cuboid, sphere, torus, capsule, and disc directly in Dart. (live demo)
• Surfaces of revolution: Sweep a two-dimensional profile around an axis to make a vessel. (live demo)
• Skinned meshes: A mesh whose vertices follow a chain of joints, blended smoothly where two joints share a vertex. (live demo)
• Clips and crossfades: A player that plays one clip, fades smoothly to another, and answers to a speed and a wrap mode. (live demo)
• CPU raycasting: Finding which mesh a ray hits, entirely on the CPU, with an answer the moment it is asked and no frame drawn. (live demo)
• glTF and GLB: The format most tools export to, read down to meshes and materials this engine can draw. (live demo)
• OBJ and MTL: Plain-text geometry, older than glTF, with normals filled in when the file leaves them out. (live demo)
• The .f3d container: The engine's own container, converted offline so loading it is almost no work at all. (live demo)
• Impeller: The desktop and mobile path: flutter_gpu through Impeller, read by its capabilities rather than by its name. (live demo)
• WebGL2: The browser path this engine draws through by default, read by its capabilities rather than by its name. (live demo)
• Positional audio: A sound placed in the world, heard louder or softer and panned left or right depending on the listener's position and facing. (live demo)
• Distance rolloff: Three curves for how a sound gets quieter with distance, and a shared distance past which it is silent. (live demo)
• Voice limiting: How many sounds may play at once, and which ones win when more than that are asking to be heard. (live demo)
• Occlusion (here or earlier): What the world does to a sound between there and here, as a callback the scene asks and never a wall test of its own. (live demo)
• A blended engine loop (here or earlier): Several loops of the same engine, recorded at different revs, crossfaded by one number so the seams do not show. (live demo)
• The stereo rig: Two cameras under a head, under a stage the application moves, drawn side by side into one frame. (live demo)
• Cardboard viewer profiles: The numbers a folded holder and a moulded one differ by, turned into an off-centre frustum per eye. (live demo)
• Head tracking: A pose that says which way the head is turned, fed to the rig every frame, from a sensor or from a mouse-driven stand-in. (live demo)