Skip to content

v0.105.0

Choose a tag to compare

@github-actions github-actions released this 14 Nov 13:15
· 469 commits to master since this release
08ec6ce

Added

  • A tree is grown in one step. A .esmodel takes a tree step: a height, one of five shapes (round, tall, flat, bush, cone) and a seed grow a trunk that tapers and bends, limbs, twigs and a crown of leaf tufts, a few large cards to a clump cut out by a picture of a tuft of leaves the editor writes beside the model. detail 2, 1 and 0 are the same tree for near, the middle distance and far off, and a land's plants take the three as mesh and lods: such a plant is placed tree by tree where its map lets it stand, each drawn at the detail its distance wants. A model's material takes translucency (0..1) for what is thin, and a tree's leaves have it: a crown glows where the sun is beyond it.
  • A land grows its grass, flowers and trees. A .esland source takes plants: each kind grows as thick as one of the land's maps says, grass from a blade and anything else from a model's mesh, and terrain_apply makes the Foliage for each over the whole land, tinted by the land's wash.
  • An agent can look at a scene from a place. view_from takes an eye and what it looks at and answers the picture the engine draws there in the editor, with the scene's own ground, water, plants and light and no game running: a valley from its floor, a cliff from the far bank, in a few seconds.
  • A Model material lays a repeating detail over what is large. A rock the size of a house has one picture of its own and is a blur from beside it. The Model shader gains u_detailMap, a grey picture of grain laid every u_detailSize world units from the three sides of the world: it varies the colour (u_detailStrength) and tilts the light (u_detailBump), and fades out at a distance so nothing shimmers. A model source writes it as material: { detail: { texture, size, strength?, bump? } }.
  • A sky can bake its clouds for a phone. Sky Atmosphere's Baked Clouds (u_bakedClouds: 1) marches the clouds into a 512 x 512 panorama of the dome, a sixteenth of it a frame, and each sky pixel reads its direction from it instead of marching the layer itself; the dome is new every sixteen frames. Until the panorama is full, and on a planet, the clouds are marched as before. While the panorama is whole, the cloud pass draws with a shader that only reads it. On Wilds at 3840 x 2160 the cloud pass took 3.9-4.4 ms marched and 1.2-2.1 ms baked, plus 0.07 ms for the strip, and the two skies agree on WebGL2 and WebGPU. The clouds are a little softer, as the panorama is eight bits a channel and read through a small blur.
  • A land stands models where ground cannot be the shape. A heightfield is one height at every place: a sheer rock pillar is a saw on its grid and an overhang cannot exist. A .esland source now takes stands: models stood one to a cell where a mask allows, or at places written by hand, each one of several meshes with a size, a turn and a lean of its own, sunk into the ground under it. terrain_apply puts them in the scene with colliders. The pillars step also gains ledges, cluster and tilt.
  • The weather and the clock can be put at any moment. A Weather's sequence and a TimeOfDay's hour are now worked out from where their run began and the scene clock (the game's own seconds of play), not added up a frame at a time: seekSceneClock(t) puts the weather, the hour and the clouds where that moment has them from the next frame, sceneClock() reads the clock, and weatherAt / hourAt answer for any moment without moving anything. The same t is the same sky on every machine. On Bistro, seeking to 40 s gave the hour (16:00) and the weather (rain turning to snow) that stepping 2,400 frames did; the clouds drift where the sky's wind, summed over the weather's changes, carries them. A field a script writes (a weatherTo, an hour) begins a new run from it. The frame-at-a-time weather fell a frame or two behind at every turn, which is gone.
  • A far blade of grass fades instead of breaking into dashes. A blade narrower than u_strandMinPx pixels on screen (1.2 by default) is drawn that wide, and its coverage is cut to the share of that width it really has, so with multisampling on a far blade fades as it shrinks rather than breaking into the dashes the samples catch. The width counts the widening the thinning already gives a blade for its neighbours; 0 leaves blades as wide as they are.
  • The installer is about 220 MB smaller: the large samples download when picked. Bistro, Dusk Fort, Terrain Water and Cyber Rooftop were packed into every editor download; their entries now list from a few kilobytes, and creating a project from one fetches its files from the download mirror, checks their size and digest, and keeps them for next time. The other samples are still bundled.
  • Particles can be lit by the scene. The stock particle is its picture times its colour and takes no light, so mist was the same white at noon and at midnight and, laid over sunlit water, painted it out. A material of the new Lit Particle shader (builtin:particle-lit) lights each particle where it is, by the sun, the sky and the lamps, shadows included; u_translucency is how much of the light goes through a puff. A shader of your own gets the same world position and normal in its particle variant by declaring #pragma feature PARTICLE_WORLD. A particle with a material now takes its depth test from it, so mist is hidden by the hill in front of it. The falls terrain_apply stands use it for their mist.
  • Plants answer a wake and a blast. A WindWake body shoves the air as it moves: a plant it passes is pushed along its path, springs back past upright and rings down within two seconds of it going by. A WindBurst (or emitWindBurst from code) sends a pressure front outward at a finite speed, and each plant is pushed over only when the front reaches it. The Foliage shader and the 2D Sway template both read the field (u_wakeBend, u_wakeMax); windLean is the same arithmetic on the CPU. On the Wilds example a 10 m/s front from in front of the camera leans the near pines and grass from 0.2 s and rings down as it passes, on WebGL2 and WebGPU.
  • A meadow melts into the ground at the end of its draw distance. A Foliage field thinned over the last 15% of its range with every blade whole, which across a valley read as a line; it now fades over the last third and the grass sinks as it goes.
  • The editor can start in safe mode. --safe-mode or ESTELLA_SAFE_MODE=1 starts it with GPU acceleration off, drawing with WebGL2 and without restoring the last workspace; the window-crashed dialog offers it as Restart in Safe Mode.
  • An install of mixed versions says so instead of crashing. An update that could not replace the editor's program left its new data files beside the old program, and every start crashed the window; the editor now finds the mismatch, says so and quits.
  • An agent can shape ground as steps. A .esland source writes a land as the things it is made of — ranges, plateaus, lakes, rivers with the heights their water runs at, streams that find their own way, roads held to a grade, coast, terraces, erosion and brush strokes — and bakes it to a heightmap, layer weights and plant maps. The editor's terrain_write and terrain_edit tools answer with relief, slope and an oblique view, and report how much of the ground is walkable, steep or cliff and each road's steepest stretch. .esland is an editor asset and never ships.
  • A field of plants can be lit as the ground it stands on. The Foliage material's u_groundNormal turns a plant's shading normal toward straight up, so a meadow takes the light as one surface instead of a thousand facets that read dark over a bright ground. 0, the default, leaves each plant its own shape.
  • Snow falls. The Snow weather laid snow on the ground but nothing came down. The Rain effect gains snowfall: soft flakes in the same three layers as the rain, drifting down and swaying, none under a roof, with no wet ground and no rings. The Snow preset sets it to 1, and a transition into or out of snow fades it with the rest of the weather.
  • A terrain's surface can be baked into a runtime virtual texture. Turn on Virtual Texture on a Terrain with layers and each node of ground, from Virtual Texture From (level 1 by default) out, is drawn from a page of its colour, roughness, normal and occlusion baked once on the GPU, as Unreal's Runtime Virtual Texture does, instead of reading every layer at every pixel. Steep ground, and a node whose page is still being baked, is drawn from the layers. On the Terrain & Water example the ground's shading went from 2.1 to 0.8 ms at 1080p. Renderer.bakeMaterial draws a material through another shader into part of a render target.
  • Terrain layers cost less, and a Planet draws its layers as a Terrain does. A point of ground is drawn from the four layers with the most weight there, and a layer not painted there costs nothing: on the Terrain & Water example's lakeside view the ground's shading went from 3.0 to 2.6 ms at 1080p with the picture unchanged. The Planet shader now uses the same layer code as Terrain Layers, so a layer's mask (and its occlusion) darkens the sky's light on a planet too, and the Planet material gains u_heightBlend, u_blendNoise and u_antiTile, 0 by default, which draws a planet as before.
  • Resources carry a revision that changes with their content. A mesh takes a new revision each time it is realized (Mesh::revision), a material whenever its state, a param, a texture or its shader's layout changes (MaterialStore::revisionOf), a texture whenever the device is given new pixels or sampling for it (GfxDevice::textureRevision), and the frame's probe and reflection volumes whenever the set of them, or a probe grid's coefficients, differ from the last frame's (ProbeStore::revision, ReflectionStore::revision). Every kind draws from one counter (core/Revision.hpp, which a probe grid's revision already used), so a revision is never shared, even by a resource that reuses a released one's slot. A texture the GPU itself writes (a render target) does not change revision with what is drawn into it. Nothing reads these yet: with the components' change stamps they are what a renderer that keeps its per-entity work between frames checks before using it.
  • An engine component is stamped whoever writes it. Every write to an engine component now leaves the change stamp the engine's own readers ask for (Registry::changedSince), wherever it is made. A script's write (set, insert, update, a Mut query, markChanged, a compiled system's rows) is stamped in the engine, batched in the World and handed over in one call before the frame's transforms are composed (registry_markComponentsChanged); the physics sync stamps the bodies that moved and no longer rewrites a body that did not; the transform system stamps a transform whose world matrix changed, so a child moved by its parent reads as changed; tweens and the editor's field setters stamp what they set. Changed() queries in scripts mean what they meant: physics motion still stays out of them, as it always has, while the engine's stamps include it. With the change audit on, 28 examples (physics, rigs, tweens, UI, particles, tilemaps, streaming worlds) ran 120 frames each with no write left unstamped; with the physics stamps taken out, the physics examples reported every moving body, 5,000 a frame in one of them.
  • Components carry the tick of their last write. Each component pool keeps, beside every component, the tick at which it was last written, added or replaced, and the latest such tick of the pool. Registry::patch<T>() is mutable access that stamps the write, markChanged<T>() stamps a write made through a reference held from before, and adding or replacing a component stamps it; get<T>() stamps nothing. A reader asks beginChangeRead() for the tick it looks at, and next time changedSince<T>(entity, tick) and anyChangedSince<T>(tick) say what was written after that look, including what was written later in the same frame. Stamps travel with their components through a removal and a re-sort, and are kept within half the counter's range so none reads as new after the tick wraps. Registry::setChangeAudit (World.setChangeAudit from script) keeps a copy of every component each frame and reports each type written without a stamp, which is what a consumer of changes would never see; render-submit-cost.mjs --audit runs it on an example. Nothing reads the stamps yet: this is the ground for a renderer that walks only what changed, and the audit lists what still writes without saying so (an animated rig's bones, the platformer's and the 3D physics example's moving bodies).
  • A playable opens on a start screen. A single-file playable showed an empty page until its first frame: the engine inflated and compiled, the scene loaded, and with quality.prewarmShaders its shaders warmed, twenty-five seconds for one lake scene in a headless browser. It now carries the web export's start screen (the game's title, a bar, what the boot is doing), in markup that is on screen before any script runs, and announces the same esengine:bootprogress and esengine:firstframe events. initPlayableRuntime takes onBeforeRun, called once everything is loaded and warmed, and prewarmShaders.onProgress. A stretch of a boot nothing measures (shaders compiling, then a ground or a field still being made) runs a light along the bar and says which it is, where the bar used to sit still on "Ready"; a web export's start screen does the same.
  • A terrain layer and a field of plants each say how much of the sky reaches them. A .esterrainlayer's occlusion (0 to 1) scales the occlusion its mask holds, and the Foliage material's u_rootOcclusion is the sky's light at a plant's root, rising to all of it at the tip. Both dim only the environment's light, as a material's ambient occlusion does; the sun and other lights are as they were. Left out (1), nothing changes. The terrain layer editor has the field.
  • An ambient light's diffuse has its own scale and tint. diffuseScale and diffuseTint on an Ambient light multiply the light its environment gives surfaces, and leave the reflections and the sky drawn behind them as they were: a sky whose irradiance is too dark or too blue for a look is lifted without brightening every reflection. At 1 and white (the defaults) nothing changes.
  • Things that break. A model can end with a fracture step, { op: "fracture", pieces: 12, at, focus }, which cuts it beforehand into pieces that fit together with no gap, each a closed solid whose cut faces are tagged apart from its skin, smaller round at where it will be struck. It is still drawn whole; the editor also writes a mesh for each piece and a prefab of them, each with a dynamic body and a convex hull, and the reply hands over a Breakable to put beside the MeshRenderer. Raising Breakable.broken hides the whole (its renderer, body and colliders are switched off, not removed), puts the pieces where it stood and throws them out from origin at burst world units a second; lifetime takes them away later, and lowering the flag makes it whole again. Its pieces are loaded while it stands whole, so they appear on the frame it breaks. In the editor a clay pot written by model_write and placed on a floor broke into the 12 pieces asked for, then the 5 asked for after an edit, each of which moved, spread apart and came to rest on the floor, and was whole again when the flag was lowered. Nothing breaks it of itself yet: a script, a graph or a collision handler raises the flag. Physics3D.setLinearVelocity(entity, velocity) is what throws the pieces and is there for anything else that sends a body off. Prefabs.prepare(path) loads a prefab and everything its entities use and holds it, so a later instantiate does not wait on files.
  • A thing breaks when it is hit hard enough. Breakable.breakImpulse breaks it on a contact at least that hard, the speed at which the two came together times the mass they met with, and the pieces leave from where it was hit. It needs a collider of its own, which the editor's reply to a fractured model now hands over as hull (a ConvexCollider3D of its shape); with a dynamic body as well it can be knocked over and break where it lands. Every Physics3DEvents.contactEnters entry now carries speed (how fast the first body was closing on the second along the normal, read before the solver answered), mass (the kilograms they met with, 1 / (1/a + 1/b), a body that does not move counting as none) and impulse, their product, from both the Jolt and PhysX worlds. A sphere of 0.5 m dropped 1.5 m onto a pad reported 5.56 m/s from Jolt and 5.40 from PhysX against the 5.42 the fall gives, and met it with 523.60 kg, its own mass, from both. In the editor a 2 kg stone dropped six metres onto a pot broke it from its rim and took its collider away, and a 50 g pebble dropped from as high onto another left it whole. Native builds carry the new buffers but were only compiled on Windows, not run.
  • A 3D body has a mass of its own. RigidBody3D.mass sets a moving body's mass in kilograms, its inertia scaled with it; 0, the default, keeps the mass its shape gives at the density of water, so scenes made before it weigh what they did. It reaches a body already in play when it changes. Both worlds were given 2 kg and answered 2, and refused a mass that is not a positive number.
  • A script can push a 3D body about. Physics3D answered where things were and could set a velocity, and nothing more: there was no force, no impulse, no torque, and a script could not ask how fast a body was going, while the 2D world had all of it. It now has applyImpulse(entity, impulse, at?) and applyForce(entity, force, at?), at a world point or the centre of mass, applyTorque, applyAngularImpulse, getLinearVelocity, setAngularVelocity and getAngularVelocity, getMass, setAwake and isAwake, and setGravity and getGravity, all in world units, from both the Jolt and PhysX worlds. In each, 4 N s at the centre of a 2 kg sphere gave it 2.000 m/s and no spin; 1 N s half a metre off its centre gave it 2.500 rad/s, which r x J over its inertia says; a force lasted one step; and with gravity set to 2 m/s squared a body fell at 1.000 m/s after half a second.
  • A blast. Physics3D.explode(centre, radius, impulse, { upward }) strikes every moving body within reach away from the centre, less the further it is and none at the edge, and strikes every Breakable it reaches as hard, standing or not, so a grenade breaks the pots round it. In the editor a blast beside a pot broke it and threw the 50 g pebble at its foot away and up.
  • A thing that breaks says so. Broke is sent once a Breakable's pieces stand in its place, with where it was struck in the world and how hard, for the sound, the dust and the score; a thing whose pieces could not be loaded did not break and sends nothing.
  • Box and capsule sweeps, and what a 3D body weighs. Physics3D.boxCast(origin, halfExtents, direction, layers, rotation) and capsuleCast(origin, radius, halfHeight, direction, layers, rotation) sweep a turned box or an upright capsule as sphereCast sweeps a ball, and getMassData(entity) answers a body's mass, its centre of mass in the world and how hard it is to turn about each of its own axes. Swept ten metres down onto a slab, a half-metre box landed at 0.400 of the way, turned an eighth of a turn on its edge at 0.379, a capsule standing at 0.375 and lying at 0.425, as the geometry gives, in both the Jolt and PhysX worlds; a 2 x 1 x 0.5 m block answered 1000 kg and moments of 104.17, 354.17 and 416.67 kg m squared, a block's own, in both.
  • A joint changed while it runs. A 3D hinge's or slider's range and motor limit, and a distance joint's lengths and spring, reach a joint already in the world when gameplay changes them; before, only the motor's speed did, and a door locked from a script by narrowing its range swung on. A door turning at 2 rad/s stopped at 0.30 rad when its range was set to plus or minus 0.3 and went on when it was taken away, and a ball on a three-metre rope rose to one metre when the rope was shortened, in both worlds. A range always holds the pose the joint was made in: one that does not reach 0 is widened to 0, in both worlds alike.
  • A shot through cover. Physics3D.raycastAll(origin, direction, layers, maxHits) names every body on a line, nearest first, each with where the line goes in and comes out and how thick it was there, so a shot can spend its strength on a plaster wall and go on into what is behind it. Along a line through a 0.2 m wall, a 1 m box and a bone-sized sensor, both the Jolt and PhysX worlds named all three with their entry and exit to four places and measured the wall at 0.2000 m; a line that ends inside a body comes out of it at its end.
  • A joint that gives way. Every 3D joint takes a breakForce (N) and breakTorque (N m): held with more than either over a step, it is taken out of the world, its enabled lowered, and the break told in Physics3DEvents.jointBreaks, so a chandelier comes down when its mount is pulled harder than it holds. A 2 kg weight hanging on a rope pulls on it with 19.62 N in both worlds; in the editor a rope rated at 15 N gave way and its weight fell to the floor while one rated at 30 N held.
  • A character that runs into something says so. Physics3DEvents.characterHits tells what a 3D character ran into that it was not already touching, once a meeting, with how fast it closed, the mass they met with and the impulse, as a contact between bodies does; a Breakable a character runs into is struck with it, so a dive through a window breaks it and a lean on it does not. A character dropped 2.1 m onto a floor told it once, at 6.38 m/s against the 6.42 the fall gives and with its own 70 kg, and walking into a 30 kg crate at 3 m/s met it with 21 kg, in both worlds.
  • Telling the parts of a character apart. Hitboxes puts a box on each bone of a skinned character, the size its ragdoll would give it, that follows the animation: a kinematic sensor that nothing walks into or is pushed by and that a ray meets, so a shot names the bone it struck and hitPartOf says whose. While the ragdoll is limp its own bodies stand in. In the editor a character from the character-rig example given Hitboxes had a sensor box on each of its bones, a ray at one of them met that character's bone by name, and three quarters of a second of animation later a ray where the bone had gone still met it.
  • A sound or a piece of music can ship as its recipe. A package shipped every sample of every clip, compressed. An .essound or an .esmusic (the source the sound and music tools write, which until now only the editor read) named where a clip goes is carried as it is and made on the device when it loads, by the same synthesis the editor bakes it with: AudioSource.clip, Audio.playSFX and Audio.playBGM take the path of the source. It is made on a worker thread, a piece of music on one and sound effects on another so a step is never made behind a theme, and kept in the content cache, so a later run reads it back. Importing esengine/sound installs the maker, and an export adds it when a shipped asset is one. A game of four effects and a minute of music packaged 1.7 MB lighter; on a desktop its effects were ready 2.5 s after the page opened and its minute of music after 4 s, the first time only (the music is made at about twenty times the speed it plays). A sound with variants is made as its first, and a backend that plays from an address and not from bytes cannot play one yet.
  • A picture made in the editor is named by its recipe. image_write answered the .png it had drawn, and the material it wrote named its maps as .png files, so a game built from what the tool answered shipped pixels although the engine could draw them from a few hundred bytes. It answers the .esimage as ref and as the texture of meshRenderer now, the material it writes names its maps as recipes, and the drawn file is pngRef. The game the editor plays draws recipes as the edit view does.
  • Viewport keys for moving things quickly. Grid snapping starts on; a tap of Space cycles Move, Rotate and Scale while holding Space still pans; Ctrl/Cmd+backtick switches World and Local; End drops the selection onto the floor beneath it.

Fixed

  • The editor draws a river wherever its eye is. The water's surface keeps its fine cells round the place it is looked at from, and in the editor that was still the scene's camera: a river far from it was drawn by cells wider than the river, and its bed lay dry in the editor while the game showed water. The surface now follows the editor's eye.
  • A WebGPU sky whose clouds cast shadows no longer marches its clouds behind every surface. Every pixel the scene covered ran the whole cloud layer in the cloud pass and threw it away, which the WebGL2 sky had stopped doing when cloud shadows moved to the sun's shadow map. The picture is the same.
  • Opening a 3D scene no longer freezes the editor. The editor viewport compiled every shader in place, so opening a scene held the whole window until the GPU driver had built them all: on Windows the Bistro example froze for 25 s at once. The viewport now compiles shaders in the background and draws each thing once its shader is ready (a post-process effect too), so the editor stays responsive while the picture fills in; textures are decoded off the main thread as well. The Camera preview draws into a target of its own instead of over the editor view, so a refresh no longer redraws the whole view to repair it, and it no longer stalls the editor while it reads its picture back (renderCameraFrame takes a render target; captureTargetPixels reads one back; syncScreenCameras restores the screen camera state without drawing), and render targets are no longer checked with the driver each time they are made. Opening Bistro now holds the editor for at most 0.7 s at a time. Screenshots and agent captures wait for the shaders before they read the viewport. A shipped game is unchanged: it compiles in the background only with quality.asyncShaderCompile.
  • The sea reaches the horizon, and the horizon is not olive. In a world drawn in centimetres, water further than about 655 m read no depth and the sea past that ring was black under the fog; the sky's march also put its first sample behind most of the blue, so the noon horizon came out olive.
  • TAA no longer shakes the picture. Temporal anti-aliasing read the current frame where the jittered camera drew it, so wherever the history was clipped (sharp edges, anything that moved) the output moved with the jitter, up to half a pixel each frame. The current frame is now read back without the jitter; on Bistro a still view went from 0.3–0.5 pixel of frame-to-frame shift to none measurable.
  • Ground no packed layer has a say in is drawn, not black. While a layered ground's pictures are still being drawn, paint that named only the other layers (a path, a cliff) summed to no weight and shaded black; it is now drawn as the first layer.
  • What stands on ground still being made waits for it. A character or a body on a terrain whose heights and collision were still being made fell through and never came back; the 3D physics world now leaves a character unswept and keeps a body asleep there until the ground exists.
  • A ground or a water whose material cannot be made fails once and says why. A shader that did not compile was compiled again every frame and filled the log; Terrains.status now reports the failure and its reason, and it is tried again when the component changes.
  • spawnUIEntity keeps every Text field it is given. letterSpacing and underline were accepted and shown in the inspector but dropped from a label built through spawnUIEntity or a widget.
  • A light's status rows line up with its fields in Details. The Status, Lights in frame and Shadow rows touched the panel's edges in bold; they now sit on the field rows' grid.
  • An editor an agent starts from a stale build says so. The MCP front names what is older than its sources and what to build in its first answer, instead of answering from an engine hours behind the SDK.
  • What an agent writes reaches the scene by the same rules as a hand. A Terrain or Foliage created with its data texture already set is marked as data, a texture read as numbers but imported as a picture is flagged in Details and get_diagnostics, and set_field takes effects.<type>.<name> on a Post Process Volume.
  • A long tool guide reaches the model whole. Clients cut long tool descriptions; each is now held to 12,000 characters and the rest is a topic the model reads with tool_guide.
  • Rain rings only on standing water. The Rain effect drew a ring where every drop landed, a dry or merely wet street included, at 0.4 of a puddle's strength. Rings are now drawn only where a puddle stands; elsewhere a drop splashes — a point where it lands and droplets thrown out from it, gone within a fifth of a second.
  • Icons stay drawn and clickable with "selected entities only". The setting hid the icons of lights, cameras, markers and the like that were not selected, so they could not be clicked; it now limits only the wireframes and handles, as its description says.
  • GPU pass times keep coming in a heavy scene. The per-pass GPU timer (gpu() in a package, the editor's GPU scopes) was opened and closed for every render graph, and a frame runs one per camera and per effect chain; with four frames' worth of slots, a frame of several graphs went through them before the GPU had answered for any, every timed frame was dropped, and the times read stayed those of the first frame for as long as the game ran (Cyber Rooftop read 1.3 seconds of graph forever). A frame is now timed once, across all its graphs, closed when the frame ends; when every slot is still waiting on the GPU the frame is not timed, rather than the oldest unanswered one being thrown away; a slot the GPU never answers is given up on after 120 frames. Without the profiler, the one query spanning a frame's graphs now spans all of them, so the graph time a dynamic-resolution policy reads is the whole frame's and not the last camera's. render.gpuTimer.read, .skipped, .dropped and .disjoint count how the timer is doing. tools/render-submit-cost.mjs --gpu reports each pass's GPU time over 30 frames the GPU answered for, and --gpu-detail the scene pass by shader.- Icons stay drawn and clickable with "selected entities only". The setting hid the icons of lights, cameras, markers and the like that were not selected, so they could not be clicked; it now limits only the wireframes and handles, as its description says.
  • A large image reaches the editor's viewport on a busy machine. The editor served project files without their length, and on a machine whose processor was busy (software rendering) a 10 MB image took 30 s to load and a 4097 heightmap missed its load deadline, leaving the terrain as noise; the same images now load in 8 s and 21 s there, and on a real GPU in well under a second as before.
  • A post-process shader can read more than seven textures. A fullscreen shader's eighth texture parameter found no texture unit and was not bound; units 4 and 5 now take the eighth and ninth. On WebGPU the first validation errors of a run are logged, where before only a refused command buffer reached the console.
  • A Spine skeleton is selected by the character it draws. A skeleton could be picked only on the small icon at its origin, so clicking the character selected nothing. The editor hands the pick box the skeleton's own bounds through the new extentOf option of entityWorldBox and pickEntitiesByRay, and the selection outline follows the same box.
  • Nudging a selection moves each selected root once, so a selected child no longer travels twice. With a parent and its child both selected, an arrow key moved the child by the nudge and again with its parent; each selected root now moves once and what is under it follows.
  • A click selects a shape by its drawn size, and a bare Canvas no longer takes the click. A ShapeRenderer could be selected only on the small icon at its origin, and any scene with a Canvas answered every click in the design screen with the Canvas, so the sprites beneath could not be clicked at all. A shape is picked by its size and its own sorting layer, and a UI node that draws nothing is picked only where nothing else is.
  • An unset texture array reads its default on WebGL. A textureArray param a material left unset was given the plain white texture, which an array sampler cannot read, so on WebGL it read black (WebGPU already drew white). An unset array param now binds layers of its declared default: white, black or a flat normal.
  • Clearing an asset field from automation clears it. set_field on an asset slot stored whatever it was given as text: 0 became the path "0" and null the path "null". The scene kept it, the editor drew nothing there, and an export failed to find an asset called 0. Nothing, however it is said (null, 0, false, the empty string, or "null" and "0" from a transport that sends values as text), now stores what the inspector's clear button stores: 0 in a handle-valued slot and the empty string in a Spine skeleton or atlas, which are string fields. Both ask one function for it (emptyAssetValue). Any other number is refused, since it names nothing a caller could have meant. model_write's text also says what its report holds, to read triangles every time, and that material.texture may name a recipe.
  • A model's picture can be a recipe. A model source's material.texture took a .png, .jpg or .webp and refused an .esimage, the recipe image_write answers as the picture's ref: a tree's branches named the pixels while the foliage material beside them named the layers, and a game shipped whichever was referenced. A recipe is now accepted there. Whether a path names a recipe is asked in one place, sdk/src/asset/textureRecipePath.ts, which reads nothing of the runtime: the registry that draws recipes, the packager deciding what ships and the model source's check each spelled the extension themselves.
  • A model's report is its steps as written, and names a step that undoes a decimate. report.steps of a baked model listed every plain step its repeats came to, by an index among those: a spruce of thirteen rows of branches reported a hundred and thirty-eight steps, most the same line, and none under the index model_edit takes. It is now one entry for each step as written, by that index, a repeat counted once with how many steps it made, and each entry says the triangles the mesh had after it. And a step that splits faces to carry its own detail (a stain by a pattern, a displace, a sculpt) after a decimate took the decimate's triangles back in silence: a rock thinned to 1100 came out at 214,534, under the 300,000 the report calls heavy, and a field of them would have been gigabytes. The report now warns of each such step, with what it was given, what it left and which decimate it undid, and says how to keep the detail (before the decimate, carried by normalBake) or bound it (detail). The test also notes what the advice costs: a pattern stained before a decimate leaves colour seams the decimate will not cross, so it is normalBake's color: true that carries it.
  • A playable's start-screen bar moves through the whole boot. The bar's stages were weighed for a web page, most of whose start is fetching the engine. A playable has the engine inlined, so its bar stood at 82% within a second and crawled to 95% over the twenty-five that followed. A playable now weighs its own stages (the scene's is four fifths of the bar), and that stage is followed in three stretches: assets being read and made (eased by the clock, since nothing counts them), shaders compiled against the most seen compiling, and the world prepared against the most its makers said was left. For that, a hold given to holdShaderWarmup may answer a number (pages, cells) where it answered yes, and warmShaders passes the sum to onProgress; Terrain and Foliage count theirs. One lake scene's bar went from 18% to 95% over its 22 seconds, with one stretch of four seconds standing still. attachSplash takes the weights.
  • An effect chain keeps its uniform buffers from frame to frame. A camera's post-process chain is said again every frame, and each of its passes made a uniform buffer for its parameters and deleted it when the chain was cleared: seventeen buffers created and seventeen deleted every frame for a lake scene with a volume's usual effects, counted in the GL calls of an exported page. The buffers of a cleared chain are now taken over by the passes of the next chain that need one the same size, and one that nothing has taken in eight clears is deleted. The same scene creates none in a steady frame.
  • A light is not worked out where it gives nothing. A lit 3D pixel worked out each light that could reach its tile in full, its shadow included (a soft one searches twenty-one texels of the map before it knows anything), even facing away from the light or past its radius, where every term the light adds is multiplied by zero. Such a pixel now leaves the light at once, unless its surface takes light from behind (a coat, sheen, scattering, hair). The frames of 101 lit scenes are the same bit for bit before and after; on Cyber Rooftop the lit model pass came down by about 6% and its planar reflection by 9%, measured against the frame's own post-processing passes, since this machine's GPU clock moves the absolute numbers by more than that between runs.
  • A lit 3D pixel works out only the lights that can reach it. Every lit 3D surface worked out each of the frame's sixteen loop lights for every pixel, a lamp across the street included, though a point or spot light gives nothing past its radius. The loop's lights are now marked on the screen tiles their spheres cover, as the lights past the sixteen already were (the tile masks' fourth word, upper half: LightStore::markLoopLights), and the view they were marked through goes with the masks (LightConstants::tileView, new): a 3D pixel finds its tile through that view, whichever camera is drawing it (a planar reflection, a probe face), and skips the lights its tile does not name; a point that view does not see skips nothing. The picture is the same, light for light. render.lights3d.tileBits counts the tile and light pairs left to work out. In Cyber Rooftop (twelve lights, most of them reaching much of the view) the render graph's GPU time went from 9.5 to 9.25 ms and the planar reflection's from 2.95 to 2.8 ms at 1280x720; a scene of small lamps saves far more. A new gate, mesh-lamps-apart, puts two small lamps either side of a panel under a perspective camera and pins both the picture and that few tiles are marked; with the tile looked up mirrored it fails.
  • One moving caster redraws only the shadow squares that see it. A shadow map whose content changed was drawn again whole: every light's maps, every face of every point light, every cascade, for one object that moved in view of one of them. Each square of the atlas now has a key of its own (where it is, what it looks through, its draws, and the instance records they read, hashed wherever in the frame's buffer they lie: DrawList::contentHashOfRecords), and while the squares sit where they did, a frame draws only the squares whose key moved, each in a pass that clears its own square (PassDesc::clearViewportOnly, new) and leaves the others as they are. When every square changed, or the layout of the atlas did, one pass clears and draws them all as before. A square whose draws cannot be vouched for (a material that moves its vertices, records a compute pass wrote) is drawn every frame on its own. render.shadow.tilesKept counts the squares a frame kept, render.shadow.squaresKeptTotal and render.shadow.squaresDrawnTotal those kept and drawn on their own since start. In Cyber Rooftop (9 squares) a frame draws 3 and keeps 6. A new gate, point-shadow-pair-square, moves one of two lamps' blockers away and back and checks both shadows; with every square kept it fails, as mesh-shadow-moved does.
  • A still shadow map is not collected again. A frame whose shadow map held what it would draw no longer drew it, but still walked every caster to find that out. Before the walk, each plugin that casts now gives one number for what its walk would read, and the frame adds the shadow views, the camera and the device's state: when that matches the number of the frame that drew the map, the walk is skipped and the map stands. The mesh plugin's number moves when a caster's Transform is written (found by a pass over the Transform stamps, so a camera or a sprite moving does not count), when a MeshRenderer, MeshSkin, MeshMorph, MeshInstances, LODGroup, Billboard, Impostor or MeshLightmap is written, added or removed, when an entity is enabled or disabled, and when a material, a mesh or a mesh program is changed or built (MaterialStore::revision, ResourceManager::meshesRevision, new). A scene with a level-of-detail group always walks: what a group casts follows the levels the camera settled on in its last frames. With the change audit on the walk is always made, and a matching number with a different result is logged and counted (render.shadow.inputsStale); render.shadow.collectSkipped says a frame skipped it. On Bistro at 640x360 the shadow declaration went from 12.7% of the sampled frame to 0.3%, the collect from 0.5 to 0.3 ms and the renderer's CPU time from 1.0 to 0.8 ms. With the audit on, 20 examples found no frame whose inputs matched while its walk differed; Bistro, Dusk Fort, Lighting 3D and Neon Ascension skip it, and where a frame cannot, render.shadow.collectWhy and render.mesh.castChanged say why (a caster that moves, a skin's joints, a level-of-detail group). With the scan of the casters' Transforms taken out, device-quality and cyber-rooftop reported every audited frame.
  • A mesh's draw keeps what no view changes. Every view of every frame derived each mesh's world box, model matrix, normal matrix, material lookups and program facts again, and looked up its motion pose three times in a hash map. What does not depend on the view is now kept per entity and used until something it came from changes: the entity's Transform or MeshRenderer is written (its change stamp), its mesh is realized again (the mesh's revision), its material changes or any material is added or removed (MaterialStore::revision, new), a Billboard, MeshInstances, LODGroup, Impostor, MeshSkin or MeshMorph is added to or taken from it, or the render origin moves. A mesh with one of those components, a parallax, or a view that overrides the look (wireframe, clay, weights) is derived every walk as before. The motion pass now passes over a static mesh that did not move before culling it. With the change audit on, every kept draw is compared with a fresh derivation and a difference is logged (render.mesh.proxy.stale); render.mesh.proxy.kept and .built count the draws kept and derived again. On Bistro (1,143 meshes) the mesh collect's share of the sampled frame went from 23% to 16%, and the motion pass's walk to nothing measurable. With the audit on, 26 examples (Bistro, physics, streaming worlds, terrain, a rig) found no kept draw that differed; with the check of the Transform's stamp taken out, physics-3d reported 365. A renderer that walks another registry (a scene loaded again) keeps nothing from the last one (Registry::identity, new).
  • A run of mesh draws is one call on WebGL2. Consecutive mesh draws that differ only in which range of a shared buffer they draw and which objects they place (the same program, material, textures and state) were each a call of their own, with two blocks bound for each: where its objects' records start, and the light probes its objects stand in. Where the browser offers WEBGL_multi_draw, such a run is now one call: a block staged once for the run says, for each draw, where its records and its instances' probes begin, and the vertex stage finds its own by gl_DrawID. A run of draws that carry probe light shares one probe block, so it holds at most as many objects as that block does. WebGPU, and a browser without the extension, draw as before. On Bistro at 640x360 the instanced draw calls a frame went from 538 to 71 plus 73 multi-draw calls, uniform-range binds from 1,022 to 276, and the WebGL calls from about 3,100 to about 1,920; the renderer's CPU time went from 1.2 to 1.1 ms. render.multiDraw.calls counts the runs drawn.
  • Meshes of one vertex shape share their buffers. Every mesh was given a vertex buffer, an index buffer and a vertex layout of its own, and a layout is part of a pipeline's key: a scene of five hundred meshes switched vertex arrays five hundred times a frame, and pipelines with them, though most of its meshes had the same few shapes of vertex. Meshes loaded from an asset now take ranges of shared pages, one page set per vertex shape (pages start at 1 MB and double, so a small game pays for little), and a run of them is drawn without switching vertex array, buffers or pipeline. Indices are rebased onto the page when a mesh is placed, since WebGL2 has no base vertex; a mesh with morph targets (whose deltas are found by vertex number) and a mesh built in the running game keep buffers of their own. After a lost device a page is rebuilt from its meshes' sources, each into a page of the new device. On Bistro at 640x360 the vertex-array binds a frame went from 540 to 55 and the WebGL calls from 3,627 to 3,102, and the renderer's CPU time from 1.6-1.8 ms to 1.2 ms in three runs each (the frame, which something else bounds at this size, stayed at 6.0 ms). ResourceManager::meshPageCount and meshPageBytes say what the pages hold.
  • A shadow map is drawn again only when what it holds changed. Every shadow-casting mesh was drawn into the shadow atlas every frame for every light, though in most frames nothing in a map had moved: Bistro drew 891 casters a frame for a sun and a scene that were both still. The atlas is now kept from frame to frame, and the frame compares what its squares would draw (where each looks from, the casters, their transforms, bones and shapes, the materials of cut-out casters) with what was last drawn into them, and skips the pass when they are the same. A caster that moves, a light that turns, a camera that walks the sun's cascades on to the next texel, a lost device or geometry rewritten in place draw it again. A material that moves its vertices (wind, a ground's height) is assumed to move them every frame, so a map it casts into is always drawn. On Bistro at 640x360 the WebGL calls a frame went from 7,139 to 3,627 and the renderer's CPU time from 3.3 to 2.3 ms. render.shadow.reused says whether a frame drew the atlas.
  • Walking a frame's meshes costs less, and the profiler says what it costs. Every mesh, in every view, asked its material's layout several questions by name (does it read the picture behind it, is its alpha coverage, does it cut out a shadow), each a string search; they are answered once when the layout is registered, and the last material and layout asked for are kept. A child of a model (most of an imported scene's meshes) was decomposed afresh by every view of every frame though its matrix had not changed; it is decomposed again only when it moves. And the mesh walk read the clock at every phase of every mesh while profiled, which was four in ten samples of a profiled frame and most of the time it reported; it is timed whole (the split by phase is the build option ES_PROFILE_COLLECT_PHASES). On the Bistro scene at 640x360, the best of seven interleaved runs went from 9.97 to 6.83 ms a frame, and a grid of 4096 meshes on one material from 4.08 to 3.09 ms. render-submit-cost.mjs --wall times frames with the profiler off.
  • Sprite and particle shaders compile in the background too. With quality.asyncShaderCompile, mesh and material shaders were compiled without holding a frame, and the batch shader's variants (sprites, text, lit sprites) and the particle shader were not: each was linked in place when first needed, measured at 350 to 490 ms of one frame mid-play under ANGLE. They are deferred the same way now, their texture units set when the link lands. Without the setting nothing changes.
  • A shader warm-up waits for the scene still being made. warmShaders (what quality.prewarmShaders runs behind the loading screen) stopped at the first three frames in which nothing was compiling. A ground still painting its pages or a field still growing its cells draws seconds later, with shaders nothing had asked for yet, so whether a scene opened complete depended on which arrived first: of the runs of one lake scene, about half opened at 13 s and went on compiling for eight more, the rest at 25 s and complete. Terrain and Foliage now hold the warm-up while they are preparing, and every run opens complete; holdShaderWarmup(app, busy) is how a game's own generated content does the same. The wait is still bounded by prewarmTimeoutMs.
  • A ground's layer pictures are read together. A Terrain with layers is not drawn until every layer's albedo, normal and mask have been read, and they were read one after another. A picture that is an .esimage recipe is drawn when it is read, so a ground of four layers with recipes for all three stayed out of sight for as long as twelve drawings took in a row. They are now all asked for at once, and recipes are drawn on as many workers as the device has. How much sooner a ground appears was not timed.
  • A playable waits for its shaders when the project asks it to. quality.prewarmShaders (with asyncShaderCompile) was acted on by the web host alone: a single-file playable opened at once on a scene with most of it missing and filled in over the next seconds. A playable has no splash to draw behind, so its canvas is kept out of sight while the first scene's frames are drawn and its shaders compile, and shown when nothing is compiling any more or after prewarmTimeoutMs. initPlayableRuntime takes it as prewarmShaders.
  • A wide blurred text shadow is one soft shape. Text.shadowBlur was drawn as one ring of eight copies of the label at the blur's own radius, whatever that radius was. At two or three pixels that is a soft edge; at eighteen it is the label nine times over, fourteen pixels apart, and a title set large stood in blocks of dark squares round every stroke. Past three pixels a shadow is now as many rings of copies as keep each within a stroke's thickness of its neighbours (a share of the font size), sixty-four copies at the most, so it reads as one soft shape. A blur of three pixels or less is drawn as it was.
  • A mesh scattered with no material keeps its own colours. A Foliage field with no material is painted, since nothing reads the wind's weights then, and it painted every plant the stock green of grass from root to tip, whatever the mesh's own vertex colours said: a grey rock scattered along a shore came out a smooth green one, and a dark spruce a pale one. A mesh that has colours of its own is now painted in them, each plant a little lighter or darker by its shade; a mesh with no colour channel, or white throughout, is painted as before.
  • A playable samples its textures as their import settings say. A single-file playable was handed no manifest, which is the only way a texture's .meta reaches a package, so its wrap mode, its filter, whether it is colour and its 9-slice border were all lost and every texture took the defaults. A ground or a wall whose picture repeats then drew one copy of it and smeared its last row of pixels over everything past the first tile: cliffs came out one flat colour with level stripes along the waterline, while the same scene was right in the editor and in a web export. The settings of the textures a playable inlines now ride in the page and reach the runtime the way they reach every other package.
  • Drawing a frame costs the CPU a third of what it did. Issuing a frame's draws went through four costs the engine did not need. Every draw staged a light-probe block of its own, up to 16 KB of zeroes filled, copied and uploaded, though no probe lit it; a run no probe lights now reads the zero block. Every draw bound every texture unit its slots named, where the program it drew with read none of some (a shadow caster, most of all); a draw now binds only the units its program samples, read from the program once. The face to cull was set at every change of pipeline though it nearly never changed. And every vertex array bound asked the browser which index buffer it held, through a WebGL emulation (FULL_ES3) nothing in the engine used. Pipelines and other device objects are also found by index rather than searched for. On the Bistro scene at 640x360, where the CPU and not the GPU sets the pace, the renderer's CPU time a frame went from 11 to 14 ms down to 3.3 ms, the frame from 13.4 to 6.7 ms, and the WebGL calls a frame from 17,926 to 7,139; 52 pixel gates on WebGL2 and 23 on WebGPU draw what they did. node tools/render-submit-cost.mjs measures it: a synthetic grid in three spreads of material, or an example such as --scene bistro, with --glcalls and --profile.
  • A cloud's shadow dims the sun, not the sky. Sky Atmosphere's Cloud Shadows and a custom sky's groundShadow multiplied every surface in the frame by the shadow, after it was lit: ambient light, reflections, other lights and emission were dimmed with the sun, and an unlit or emissive object went dark under a cloud. Measured against a reference island lit the same way, its ground came out 25 to 35 levels darker than the reference, and lit by the sky alone it was black. Now the sky draws a cloud shadow map before the scene, into one tile of the sun's shadow atlas (16 km round the camera, u_cloudShadowExtentKm), and the first directional light is dimmed by it where each surface is shaded, as Unreal's atmosphere sun reads its clouds' shadow map; nothing else is. The cloud shadow criteria now light their floor by a sun and add a floor nothing lights, which must keep its colour under the clouds; they and 56 shadow and sun criteria pass on WebGL2 and WebGPU. With the atlas full (High quality's four cascades fill it) the sun gives up its farthest cascade to the map. The map holds the light left at the camera's own height, exact below the cloud layer and an estimate inside it.
  • A package that ships texture recipes draws them. An export carried its .esimage files and drew its ground and its walls with no texture, saying only in the console that nothing there draws recipes. The call that installs the drawer had ended up in a part of the built SDK that was not marked as having an effect, and the bundler dropped it; and a playable ad, whose entry is the whole SDK, never imported the drawer at all. Both are put right, and a check now bundles a game that imports it and looks for it.
  • A cleared asset field no longer stops a game. An empty string in an asset field of an engine component (a material cleared to nothing) was taken for a path to load, came back from the load still a string, was written back as one and asked for again, without end: a field of plants put it on every cell it grew, and the packaged game stopped answering half a minute in. An empty string is no asset now, and a path nothing resolves keeps its placeholder.
  • A Jolt hinge or slider whose motor is switched on in play keeps its limit. Made with its motor off, a joint in the Jolt world took the solver's own motor settings when the motor was turned on later, which push without bound, so a door with a maxMotorTorque of 10 opened as if it had none, where the PhysX world held it to 10. Both now hold every motor to its limit from the start: switched on with a limit of nothing, a door turns nothing in either.