Guides by capability

Every capability of the engine has a page of its own. Each page has three parts: the demo, which runs live on your device, a guide that builds it from nothing in a few steps, and the file that is running. Each is tagged with the version of the engine it appeared in, taken from the CHANGELOG entry that first mentions it.

Open the live showcase to run the demos in your browser, or run it on macOS with flutter run -d macos from apps/flutter3d_showcase. A guide here quotes the same lines the app shows in its Step by step tab, because both are read from the same files.

Shading and materials #

• The six lighting models (since 0.1.0): Unlit, Lambert, Blinn-Phong, PBR, Toon and Normals: one material field picks how a surface answers light.
• PBR metal and rough (since 0.1.0): One material, two numbers, how metallic and how rough, and the light does the rest.
• Normal maps (since 0.1.0 or earlier): Fine relief stored in a texture, so a smooth surface catches light like a bumpy one.
• Alpha modes (since 0.7.0): Opaque, cut-out, blended or hashed: four answers to what a see-through material should do.
• Draw order and depth state (since 0.1.0 or earlier): Draw a surface first, keep it out of the depth buffer, or skip the backs of triangles.
• Anisotropic texture filtering (since 0.4.3): A floor stretching to the horizon keeps its checks sharp instead of turning into a grey band.
• Specular strength (since 0.1.0 or earlier): One scalar turns the whole frame's specular response up or down without touching a single material.
• Manual exposure (since 0.1.0 or earlier): The linear multiplier the composite applies before the tone curve, set by hand instead of metered.
• Wireframe (since 0.1.0 or earlier): Draws the scene's triangles as lines, on the one backend that has a polygon mode for it.
• Identical-draw batching (since 0.7.0): A run of nodes sharing a mesh and a material collapses into one instanced call instead of one draw each.
• Directional, point and spot lights (since 0.2.0): 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.
• Rectangle area lights (since 0.7.0): A rectangle with width and height, so an interior reads as lit by a window instead of by a bright dot behind one.
• Lights in lumens and lux (since 0.7.0): A lamp off a datasheet, in lumens or lux, converted into the engine's own light intensity instead of tuned by eye.
• Light channels (since 0.7.0): A bit mask a light and an object meet on: a light reaches an object only when they share a bit.
• Thirty-two lights and the fade band (since 0.7.0): 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.
• Ambient light (since 0.4.3): The flat colour and strength a surface falls back to wherever no direct light reaches it.
• .fmat material files (since 0.3.0): A material as a file of its own: an artist's unit of work, worn by every mesh that shares the look.
• The material expression language (since 0.7.0): A small GLSL-flavoured source, parsed once into a tree that either emits a fragment shader or is evaluated directly.
• Clear coat (since 0.8.0): 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.
• Sheen (since 0.8.0): The bright rim of velvet and felt, where light grazing the fibres comes back towards you.
• Stretched highlights (since 0.8.0): A highlight drawn out into a streak, the way brushed steel shines, without modelling the grooves.
• Glass that shows the scene (since 0.8.0): Glass that bends and blurs what stands behind it, drawn by reading a copy of the picture made before the glass.
• Transparency without sorting (since 0.8.0): See-through panes that cross each other come out the same from any side, because nothing has to be drawn back to front.
• A texture transform per map (since 0.8.0): 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.
• Rough metals and rough clay (since 0.8.0): Rough gold as bright as polished gold, and rough clay that stops looking like plastic, from two frame settings.

Light and environment #

• Procedural sky (since 0.2.0): A sky with a gradient, a glow and a sun disc, drawn from a few numbers with no image to load.
• Distance fog (since 0.5.1): Things farther from the eye fade toward one colour, so a long view has depth and its far end has no hard edge.
• Clustered lights (since 0.8.0): 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.
• Volumetric fog (since 0.8.0): Air that the lights shine through, so each lamp glows in the haze around it and the air thins out with height.
• Image-based lighting (since 0.3.0): 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.
• Reflection probes (since 0.4.3): 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.
• One bounce of diffuse light (since 0.7.0): 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.
• The field kept current (since 0.8.0): The renderer looks at the room again from a few probes each frame, so the bounced light follows a wall that changes colour.
• Lightmaps (since 0.4.2): Indirect light baked into a texture ahead of time and read through a second coordinate the vertex colour carries.

Shadows #

• Shadow quality (since 0.1.0): How big the shadow map is, how much slack it leaves and how dark it paints, on one page.
• Cascaded shadows (since 0.2.0): The sun's shadow in slices, so it is sharp near you and still reaches the horizon.
• Point and spot shadows (since 0.2.0): A lamp or a spotlight throws shadows in every direction it lights, through a cube map.
• Soft shadows (since 0.7.0): A shadow that is sharp where it starts and blurs the farther it travels, like one from a light with a size.
• EVSM shadows (since 0.8.0): The sun's shadow map blurred once for the whole frame, so each pixel reads a soft edge with a single lookup.
• Contact shadows (since 0.7.0): A short march toward the sun that darkens the crease where an object meets the ground.
• The cached shadow map (since 0.3.0): Walls that never move are drawn into the lamp's shadow map once, so each frame only redraws what moved.
• Cascades that keep what stands still (since 0.8.0): Blocks that never move go into a sun atlas of their own, so a walking camera draws only the strips that came into view.
• Shadows of cut-out leaves (since 0.7.0): A leaf or a fence with holes in its texture throws a shadow with the same holes.

Post-processing #

• Bloom and halation (since 0.1.0): Light brighter than the display can show spills over the edge of what gives it off, and can turn red at the rim.
• Tone-map curves (since 0.7.0): 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.
• Colour grade (since 0.3.0): Contrast, saturation and warmth for the whole picture, separate tints for the shadows and the highlights, and the marks a lens leaves.
• Grade through a LUT (since 0.7.0): A grade written down as a small texture: every colour that comes in has one colour it comes out as.
• Post effects on your own image (since 0.7.0): Hand the renderer any picture and get it back bloomed, exposed and tone mapped, with no scene behind it.
• Switching passes off (since 0.7.0): Leave a pass out of a frame by its name, and read back that the frame did as it was told.
• Auto exposure (since 0.4.3): A meter reads the frame's own brightness and moves the exposure toward a chosen grey, the way a camera's own metering does.
• Screen-space reflections (since 0.2.0): A ray marched through the picture already drawn, so a polished floor shows what stands on it.
• Ambient occlusion (since 0.2.0): The ambient term darkened wherever a surface cannot see much of the sky, from nothing but the shapes already in the frame.
• Automatic multisampling (since 0.7.0): The scene pass smooths its own edges when the device offers it and nothing in the frame needs the picture read back first.
• Light shafts (since 0.7.0): A view ray marched through the sun's own shadow map, so a beam through a doorway keeps the doorway's shape.
• FXAA and sharpen (since 0.7.0): One pass over the finished picture that softens a hard contrast step, with a sharpen riding the same taps.
• Depth of field (since 0.7.0): A thin-lens blur from a focus distance, a focal length and an f-number, the numbers a photographer already knows.
• Viewport shading (since 0.7.0): Normals, clay, outline and curvature, each read out of the second buffer the scene pass already writes.
• The surface buffer (since 0.4.3): The world normal and view-axis depth the scene pass writes once, for every screen-space effect to share, seen raw.
• Adaptive resolution (since 0.7.0): The whole frame drawn smaller when nothing else is left to trade, at a scale a plain object works out from recent frame costs.
• X-ray silhouettes (since 0.4.3): The outline of whatever a wall hides, painted flat over the wall, while the visible part stays lit.
• Temporal anti-aliasing (since 0.8.0): 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.
• Motion blur (since 0.8.0): Whatever moved while the shutter was open is smeared along the way it moved, as a camera would show it.
• Spatial upscaling (since 0.8.0): A frame drawn at a smaller size is brought back up with a filter that follows edges, so outlines stay crisp.
• Horizon occlusion and bounced light (since 0.8.0): Corners darkened by how much sky each point can see between its horizons, and a coloured wall tinting the floor beside it.
• Local exposure (since 0.8.0): Each part of the picture gets its own exposure, so a dark room and the bright window in it can both be seen.

Scene and geometry #

• The scene graph (since 0.1.0): Arrange an orbiting planet and moon with inherited transforms.
• Generate tangent frames (since 0.7.0): Derive render-ready tangents and handedness from positions, normals, and UVs.
• Vertex cache ordering (since 0.7.0): Reorder triangles and vertices so the GPU can reuse recent work.
• BVH and frustum culling (since 0.7.0): Skip hundreds of meshes whose world-space boxes miss the current view.
• Impostors (since 0.8.0): Draw a far tree as one card that turns to the eye and shows views baked in advance.
• Occlusion culling (since 0.8.0): Leave out meshes hidden behind a wall marked as an occluder, before they are drawn.
• Debug drawing (since 0.7.0): Inspect bounds, normals, axes, lights, and a skeleton over the scene.
• Many copies in one draw (since 0.2.0): Draw a field of coloured meshes from one instanced vertex buffer.
• Levels of detail (since 0.7.0): Choose a finer or coarser mesh from how much of the view it covers.
• Mesh editing overlays (since 0.7.0): Draw edges, vertex handles, a face wash, and a through-mesh gizmo.
• Build a mesh in code (since 0.7.0): Write a coloured pyramid as vertices and indexed triangles in Dart.
• Polylines in screen pixels (since 0.7.0): Draw joined routes whose width stays steady as the camera moves.
• Gaussian splats (since 0.7.0): Decode a binary PLY cloud and draw its translucent ellipses back to front.
• Splats under a budget (since 0.8.0): Cut a cloud of Gaussians into a tree and draw only as many splats as a budget allows.
• Procedural shapes (since 0.1.0): Build a cuboid, sphere, torus, capsule, and disc directly in Dart.
• Surfaces of revolution (since 0.1.0): Sweep a two-dimensional profile around an axis to make a vessel.
• Procedural textures (since 0.5.0): Generate a solid colour and checkerboard as RGBA pixels in code.
• What a frame reports (since 0.7.0): Read draw, triangle, instance, culling, and per-pass counts after a frame.
• Plan a frame before drawing (since 0.7.0): Compile the render graph without drawing and compare it with the frame.
• The held item's own pass (since 0.4.0): Draw a held item over the finished world, with its own depth.
• Several views in one frame (since 0.7.0): Crop a view to a rectangle and combine two of them in one render call.
• Capturing a frame (since 0.7.0): Record every pass of one frame, with the pixels each pass wrote.

Animation #

• Skinned meshes (since 0.1.0): A mesh whose vertices follow a chain of joints, blended smoothly where two joints share a vertex.
• Clips and crossfades (since 0.1.0): A player that plays one clip, fades smoothly to another, and answers to a speed and a wrap mode.
• Step, linear and cubic tracks (since 0.7.0): The same keyframes read three ways: a snap, a straight line and a curve with tangents.
• Morph targets (since 0.5.2): A shape a mesh can blend towards, packed as a texture and dialled in by a weight from nought to one.
• A face per copy (since 0.5.2): One batched draw where every copy wears its own morph weights instead of the one shape a uniform would give them all.
• Layers and masks (since 0.5.2): A second clip over part of a skeleton, while the base keeps playing over the rest of it.
• Additive layers (since 0.7.0): A layer that adds its own clip's distance from its rest frame on top of the base, instead of replacing the base outright.
• Root motion (since 0.7.0): The forward step a walk cycle already had, extracted out of its own track and handed back a frame at a time.
• Two-bone IK (since 0.7.0): An arm or a leg bent so its tip reaches a point, solved on a pose with no scene behind it.
• A chain of any length (since 0.7.0): A rope or a tail bent to reach a point, solved by walking the chain backward and forward until it does.
• A pose with no scene (since 0.7.0): A hierarchy of local transforms sampled straight from a clip, with no scene node anywhere in the arithmetic.
• The skeleton drawn (since 0.7.0): The joints under a skinned mesh, drawn as a bone per pair and a cross at every joint with no child.
• A crowd from a baked clip (since 0.7.0 or earlier): Every clip a crowd wears sampled once into a table, so an instance needs only which clip and how far into it.

Views, picking and input #

• Perspective and orthographic (since 0.5.1): The two ways a camera turns the world into a flat picture, and the one number in the matrix that tells them apart.
• Off-axis frustum (since 0.7.0): A frustum whose axis is not down the middle, for a headset lens or a portal window.
• Rendering in tiles (since 0.7.0): Drawing a picture larger than any single render target, one square of it at a time.
• Orbit (since 0.7.0): Framing a model automatically and swinging the view to a new angle instead of jumping to it.
• Free-look and walking (since 0.7.0): Turning the head from where the camera stands and walking it there, instead of orbiting a point somebody else chose.
• CPU raycasting (since 0.1.0): Finding which mesh a ray hits, entirely on the CPU, with an answer the moment it is asked and no frame drawn.
• Picking by pixel (since 0.4.3): Asking the renderer which mesh is drawn at a point, exact by construction because the rasteriser already decided.
• Screen-space bounds (since 0.7.0): The rectangle a box in the world covers on the glass, for a focus ring, a tooltip or a label to use.

Formats and I/O #

• glTF and GLB (since 0.1.0): The format most tools export to, read down to meshes and materials this engine can draw.
• Cameras and lights from a file (since 0.7.0): A camera and a punctual light, held on a document the same way a mesh is, written into a GLB and read back.
• Writing GLB (since 0.7.0): Any decoded document, written out as a self-contained GLB, optionally quantized and reordered for a smaller file.
• Variants and animation pointers (since 0.8.0): One model that changes its look by name, and a clip that animates a material and a light rather than a node.
• Export, read back, compare (since 0.7.0): Write a document, read the file back, and report what a real round trip changed or could not carry.
• OBJ and MTL (since 0.1.0): Plain-text geometry, older than glTF, with normals filled in when the file leaves them out.
• STL (since 0.7.0): A flat triangle soup with no shared vertices, told apart from ASCII by the file's own size arithmetic.
• USDZ export (since 0.7.0): Geometry written into the ZIP archive Quick Look opens, one Mesh prim a surface, no materials yet.
• The .f3d container (since 0.1.0): The engine's own container, converted offline so loading it is almost no work at all.
• KTX2 and Basis textures (since 0.4.2): A compressed-texture container, including Basis Universal files transcoded to plain RGBA8 at load time.
• Compressing a texture (since 0.7.0): Four block encoders, a mip chain, and a KTX2 container to write the result into.
• Draco meshes (since 0.7.0): A compressed mesh format read all the way, both connectivity methods and every prediction scheme a current encoder writes.
• Meshopt compression (since 0.7.0): A mesh's vertex and index buffers, packed by EXT_meshopt_compression and decoded again on the way back in.
• Image decoding without dart:ui (since 0.7.0): PNG, JPEG and Radiance .hdr, each read by a decoder that needs no window and no Flutter binding.
• A decoder of your own (since 0.5.0 or earlier): A studio's own format, read through the same plugin boundary a built-in reader goes through.
• Loading into a scene (since 0.4.0 or earlier): A decoded document uploaded once and placed as many times as a scene wants, whatever format it came from.
• Texture transform (since 0.7.0): A material's texture coordinates, scaled, rotated or moved without touching the texture itself.
• The build-time converter (since 0.7.0): The command line tool that turns a glTF, OBJ or STL model into this engine's own .f3d container ahead of time.

Backends #

• Impeller (since 0.1.0): The desktop and mobile path: flutter_gpu through Impeller, read by its capabilities rather than by its name.
• WebGL2 (since 0.1.0): The browser path this engine draws through by default, read by its capabilities rather than by its name.
• WebGPU (since 0.6.0): The fourth backend, tried before WebGL2 only when a web build asks for it by name at compile time.
• The software rasteriser (since 0.2.0): A device with no GPU behind it: what the golden pictures are drawn with, and every page in this showcase besides.
• What differs between them (since 0.2.0): A live table of what the device open right now can do, read from GraphicsDevice.supports* rather than from a name.

Physics and particles #

• A particle pool in one draw call (since 0.2.0): One pool of particles, drawn in one instanced call however many effects are bursting out of it.
• Emitter shapes (since 0.2.0): Sphere, cone, box and drift: where a particle starts and which way it leaves.
• Forces (since 0.2.0): Gravity, drag, wind, turbulence and spin, stacked on the same burst.
• Over-life curves (since 0.5.0): Size and colour described as a handful of keys over a particle's life, instead of one number turning into another.
• Particles that light (since 0.2.0): A torch measured from its own particles, so the light it casts cannot disagree with the flame that is supposed to be making it.
• A burst that lights the room (since 0.7.0): ParticleSystem.burst takes a light source, so an explosion or a muzzle flash lights whatever is standing near it.
• Smoke lit by the scene (since 0.8.0): Puffs of smoke lit from each side by the lights around them, through six pictures of one puff.
• Textured billboards (since 0.2.0): A sprite on every billboard instead of the procedural disc, which is what turns a particle into any shape you can paint.
• Sprite-sheet animation (since 0.2.0 or earlier): A grid of frames played across a particle's life, driven by how far through it is rather than by a clock.
• Mesh particles (since 0.2.0 or earlier): Every live particle drawn as a copy of a real mesh instead of a camera-facing quad, in one instanced call.
• Collision shapes (since 0.5.1): Five shapes, box, sphere, capsule, wedge and heightfield, each with a closed-form overlap test against every other one.
• Raycast, sweep and overlap (since 0.5.0): A ray, a moving shape and a still one, all answered by the same broadphase grid.
• Layers and contact callbacks (since 0.2.0 or earlier): Two colliders are tested against each other only when each is in the other's mask.
• A character controller (since 0.5.0): A kinematic walker that slides along what it meets instead of bouncing off it, and reports the ground it lands on.
• Rigid bodies (since 0.2.0): Mass, gravity, impulses and rest, with no rotation: a box that never tips stays cheap to test against another box.
• Walking on terrain (since 0.5.1): Ground as a grid of sampled heights, walked by the same character controller that walks a flat floor.
• Cloth (since 0.7.0): A pinned grid of particles, solved with XPBD, draped around whatever collision shapes it is told not to pass through.

Simulation, audio and XR #

• Fixed step and interpolation (since 0.4.0 or earlier): A simulation that always advances by the same amount, smoothed for a screen that draws at a different rate.
• The ECS world (since 0.7.0): Entities and components, saved as one document and carried across a level that has since been edited.
• Systems and events (since 0.5.0): 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.
• Replays and digests (since 0.7.0): A checkpoint trace that names the first step two runs of the same tape stop agreeing at.
• Portable determinism (since 0.5.1): Transcendental functions and a random generator that give the same bits on every platform, and a random state a snapshot can carry.
• Rewinding (since 0.7.0): 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.
• Running without a screen (since 0.7.0): The interface a tool that plays a game blind is written against: a step, a save, and a sentence about how things stand.
• Path-finding (since 0.4.1): Where an agent can stand, baked once from the level into a lattice a step can query in one array lookup.
• A flow field (since 0.4.1 or earlier): One sweep from a goal, read by every agent as the direction to walk from wherever it stands.
• An automap (since 0.4.1 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.
• Baking a lightmap (since 0.4.1): Unwrapping a level's brush faces onto an atlas, then gathering the light the walls throw on each other into it.
• Baked visibility (since 0.7.0): Which parts of a brush level can be seen from where, baked once and applied every frame by hiding what the eye cannot see.
• Terrain in tiles (since 0.7.0): Ground cut into tiles buildable at more than one resolution, and a level chosen by distance, with a skirt closing the seam.
• The level format (since 0.4.2): A level as a document: brushes, entities and lights, round-tripped through JSON and checked by a validator before anyone plays it.
• Doors, lifts and buttons (since 0.4.0 or earlier): One machine that travels between two places, and a switch that relays an activation to it by name.
• Flickering lights (since 0.4.0 or earlier): A light that flickers like fire or pulses like something magical, with one brightness number driving both the glow and the light.
• Actors, brains and health (since 0.4.0 or earlier): A thin handle onto an entity's components: health that can run out, and a brain a game writes for itself.
• The shared camera rig (since 0.4.0 or earlier): Easing towards where a chasing view should be, carrying a knock or a shake that fades, and staying out of the walls.
• A Catmull-Rom path (since 0.4.0 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.
• Difficulty axes (since 0.5.0): Four numbers a genre applies where it decides, instead of a name it has to interpret.
• Positional audio (since 0.1.0): A sound placed in the world, heard louder or softer and panned left or right depending on the listener's position and facing.
• Distance rolloff (since 0.1.0): Three curves for how a sound gets quieter with distance, and a shared distance past which it is silent.
• Mixer buses (since 0.2.0): A group of sounds a player can turn down as one, read against a shared master every frame.
• Voice limiting (since 0.1.0): How many sounds may play at once, and which ones win when more than that are asking to be heard.
• Occlusion (since 0.1.0 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.
• A blended engine loop (since 0.1.0 or earlier): Several loops of the same engine, recorded at different revs, crossfaded by one number so the seams do not show.
• The virtual pendulum lab (since 0.7.0): A worked example small enough that one changed number visibly changes a run, and a digest that finds exactly where two runs part.
• The stereo rig (since 0.1.0): Two cameras under a head, under a stage the application moves, drawn side by side into one frame.
• Cardboard viewer profiles (since 0.1.0): The numbers a folded holder and a moulded one differ by, turned into an off-centre frustum per eye.
• A lesson through the rig (since 0.7.0): The same lesson document a step panel authors, played back through a stereo rig with a button instead of a keyboard.
• Head tracking (since 0.1.0): 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.

Widgets and the rest #

• Widgets in the scene (since 0.7.0): A live Flutter widget drawn as a mesh in the scene, redrawn when the widget changes.
• Describing the scene to a screen reader (since 0.7.0): One accessibility node per object, positioned where the camera actually projects it, instead of one opaque rectangle.
• The scene surface and its status screens (since 0.7.0): The widget every viewport is built from, and the screen an application shows when a renderer never opened at all.
• Loading a level (since 0.7.0): The bridge between a level document and something drawable, and a cache that uploads each repeated shape once.
• Storage on every platform (since 0.7.0): Small documents a player's choices live in, kept the right way on whichever platform is running, and never throwing.
• Frame timing and memory pressure (since 0.7.0): How long the last frame took, what a window of frames cost, and giving pooled render targets back when memory runs short.
• Reduce motion (since 0.7.0 or earlier): What the player has already told the operating system, read as a default for a camera's own involuntary movement.
• Settings, config and saves (since 0.7.0): What a player has changed about how the game behaves for them, and where a run in progress is kept between launches.
• Pausing and stepping a running game (since 0.7.0): Pause, step one fixed frame at a time, preview a rewind and release into the past so the run continues from there.
• Rollback netcode over a loopback (since 0.6.0): Two players' worth of a fixed-step simulation kept in step across a delayed, lossy connection, with prediction and rollback.

The Flame bridge #

• Two engines, one Stack (since 0.7.0): The Flame and flutter3d layers composited in one widget, nothing bridged between them yet.
• Keeping a Flame position and a flutter3d node in step (since 0.7.0): A Flame component and a flutter3d node kept at the same place, either side free to be the one that moves.
• Bridging a flutter3d_sim actor (since 0.7.0): A simulated actor's own body driving a Flame position and the mesh that follows it.
• Bridging a falling rigid body and its collision (since 0.7.0): A physics body falling through a real collision world, its contact with the floor relayed as a Flame collision callback.
• One key, read by both engines (since 0.7.0): A Flame key event translated into the same Bindings/InputState a native flutter3d_game reads.
• Reconciling an orthographic camera and a Flame viewfinder (since 0.7.0): A flutter3d camera and a Flame viewfinder framed the same, either side free to lead.