@solidrt/3d 0.0.58 → 0.0.60

package/src/scene.ts

@@ -36,31 +36,33 @@
 // and pointer subsystems are scene-shadows.ts / scene-pointer.ts,
 // built here with the scene's seams as their deps.
 
-import { addDraw, createCubeDrawTarget, createDrawTarget, depthTexture, destroyProgram, destroyRenderPipeline, destroyTexture, removeDraw, renderTarget, setDrawBuffers, setDrawOrder, setDrawParams, setDrawTextures, setTargetParams, setTargetRect, setTargetSize, setTargetTextures } from "@solidrt/core/gpu"
+import { addDraw, createCubeDrawTarget, createDrawTarget, depthTexture, destroyProgram, destroyRenderPipeline, destroyTexture, removeDraw, renderTarget, setDrawBuffers, setDrawOrder, setDrawParams, setDrawRange, setDrawTextures, setTargetParams, setTargetRect, setTargetSize, setTargetTextures } from "@solidrt/core/gpu"
 import * as spatial from "flux:spatial"
 import type { Impact as CoreImpact, NodeId, QueryFilter } from "flux:spatial"
-import type { DrawId, FilterMode, ProgramId, RenderPipelineId, ShaderParams, TextureId, WrapMode } from "@solidrt/core/gpu"
+import type { BufferId, DrawId, FilterMode, ProgramId, RenderPipelineId, ShaderParams, TextureBindings, TextureId, WrapMode } from "@solidrt/core/gpu"
 import { getOwner, onCleanup } from "@solidrt/core"
 import type { PointerEvent as ElementPointerEvent, WheelEvent as ElementWheelEvent } from "@solidrt/core"
 import { copy, mat4, transformPoint } from "./math.ts"
-import { linearColor } from "./color.ts"
+import { linearColor, premultipliedColor } from "./color.ts"
 import type { Mat4, Quat, Vec3, Vec4 } from "./math.ts"
 import { MAX_LIGHTS, MAX_SHADOW_MAPS } from "./glsl.ts"
 import { cameraParams, cameraState, ensureCamera, makeCamera, updateCamera } from "./camera.ts"
 import type { Camera, CameraState, CameraUpdate } from "./camera.ts"
 import { makeShadowSystem } from "./scene-shadows.ts"
 import { makePointerInput } from "./scene-pointer.ts"
-import { geometryBounds, geometryTopology, layoutKey, validateGeometry } from "./geometry.ts"
+import { geometryKey, geometryTopology, validateGeometry } from "./geometry.ts"
 import type { Geometry } from "./geometry.ts"
 import { acquireGeometryBuffers, releaseGeometryBuffers } from "./geometry-gpu.ts"
 import { backgroundPipeline, missingAttributes, SKYBOX_FRAGMENT } from "./material.ts"
-import { createEnvironmentPlaceholder, createPrefilter, probeFormat } from "./environment.ts"
+import { disposeResolve, makeResolve, replaceResolve, resizeResolve, setResolveBloom } from "./resolve.ts"
+import type { BloomOptions, ResolveInput, ResolveOptions, ResolveRecord } from "./resolve.ts"
+import { createEnvironmentPlaceholder, createPrefilter, bufferFormat } from "./environment.ts"
 import type { Prefilter } from "./environment.ts"
 import type { Material } from "./material.ts"
 import { orderEntries } from "./order.ts"
-import { fillTransform, leaveScene, makeNode, worldInto } from "./node.ts"
+import { activateMorph, fillTransform, freeLeaving, leaveScene, makeNode, setTransition, worldInto } from "./node.ts"
 import type { SceneHooks, SceneNode, ScenePointerListener } from "./node.ts"
-import { checkInstancePairing, checkMask, instanceBinding, localBounds, publishInstanceStyle } from "./mesh.ts"
+import { checkInstancePairing, checkMask, instanceBinding, localBounds, publishRecords } from "./mesh.ts"
 import type { InstancedMesh, InstanceNode, Mesh } from "./mesh.ts"
 import type { CastingLight, Light } from "./light.ts"
 
@@ -397,25 +399,55 @@ function environmentParams(env: EnvironmentOptions | null): ShaderParams {
   return { uEnvIntensity: k.intensity, uEnvRotation: cubeTurn(k.rotation), uEnvOn: 1 }
 }
 
-/** The output tone mapping (setToneMapping): "none" clamps, "aces" is the
- * filmic curve every engine ships (Three's ACESFilmic, Godot's ACES,
- * Unity's ACES). */
-export type ToneMapping = "none" | "aces"
+export type { BloomOptions, ResolveInput, ResolveOptions } from "./resolve.ts"
 
-// The uToneMapping value per mode; the OUTPUT set branches on it.
-const TONE_MAPPING_CODE: Record<ToneMapping, number> = { none: 0, aces: 1 }
+/** The resolve's tone mapping (setToneMapping): "none" clamps, "aces" is
+ * the filmic curve every engine ships (Three's ACESFilmic, Godot's ACES,
+ * Unity's ACES), "agx" Blender's AgX (Three, Godot 4.3+) and "neutral"
+ * the Khronos PBR Neutral curve (Three, Unity) that keeps product colors
+ * where a filmic curve shifts them. */
+export type ToneMapping = "none" | "aces" | "agx" | "neutral"
+
+// The uToneMapping value per mode; the RESOLVE set branches on it.
+const TONE_MAPPING_CODE: Record<ToneMapping, number> = { none: 0, aces: 1, agx: 2, neutral: 3 }
+
+/** The RESOLVE set's params for a resolve pass of your own (an app-owned
+ * atlas tiled views render into, resolved through `resolveFragment` from
+ * `/glsl`): `uToneMapping` and `uExposure` as the scene's setToneMapping
+ * and setExposure would write them - a shader target validates its
+ * params strictly, so both are always written. */
+export function resolveParams(opts?: { toneMapping?: ToneMapping; exposure?: number }): ShaderParams {
+  let mode = opts?.toneMapping ?? "none"
+  let code = TONE_MAPPING_CODE[mode]
+  if (code === undefined) throw new Error('resolveParams: expected "none", "aces", "agx" or "neutral", got ' + mode)
+  let exposure = opts?.exposure ?? 1
+  if (!Number.isFinite(exposure) || exposure < 0) throw new Error("resolveParams: expected a finite exposure >= 0, got " + exposure)
+  return { uToneMapping: code, uExposure: exposure }
+}
 
 export type SceneOptions = {
-  /** The target's clear, written as given: encoded pixels, untouched by
-   * exposure and tone mapping (a GLSL background or skybox goes through
-   * both). */
+  /** The buffer's clear: an sRGB color like every color option (decoded
+   * to linear light on write), so the backdrop takes the scene's exposure
+   * and tone mapping in the resolve exactly as a background does. */
   clearColor?: [number, number, number, number]
+  /** The resolve fragment (see setResolve), or a function of the buffer
+   * id returning it - the chain over `hdrTexture` is built right there;
+   * absent is DEFAULT_RESOLVE. */
+  resolve?: ResolveInput
+  /** The stock bloom on the resolve; see setBloom. Views follow it
+   * unless they carry a `bloom` of their own. */
+  bloom?: BloomOptions
   /** Scene-wide fog; see setFog. */
   fog?: FogOptions
   /** Output tone mapping, default "none"; see setToneMapping. */
   toneMapping?: ToneMapping
   /** Output exposure, default 1; see setExposure. */
   exposure?: number
+  /** LOD quality knob, default 1: every measured projected size is
+   * multiplied by it before the level select, so below 1 the groups hand
+   * over to their far levels sooner (Unity's lodBias). Live via
+   * scene.setLodBias; views and shadow tiles follow it. */
+  lodBias?: number
   /** The scene target's layer mask (bitmask, default 1): the scene draws
    * the meshes whose `layers` intersect it. Live via scene.setLayers. */
   layers?: number
@@ -431,6 +463,12 @@ export type SceneOptions = {
   /** The cube map reflective materials mirror; see setEnvironment. */
   environment?: EnvironmentOptions
   label?: string
+  /** `stagger` (ms) on the scene's root node - `setTransition(scene.root,
+   * { stagger })` at creation: every node added straight under the root
+   * that enters or leaves in one frame is spaced by `index * stagger`,
+   * the whole-scene form of a Group's stagger (nested groups declaring
+   * their own win for what is under them). */
+  stagger?: number
   /** `autoFree: false` opts out of owner-scoped auto-dispose (then call dispose yourself). */
   autoFree?: boolean
   filter?: FilterMode
@@ -438,6 +476,13 @@ export type SceneOptions = {
   /** Multisample count of the target (1, 2, 4 or 8; default 1). Storage-only
    * anti-aliasing of mesh edges; see createDrawTarget. */
   samples?: 1 | 2 | 4 | 8
+  /** Where a per-scene budget error goes: the light cap and the
+   * shadow-slot budget are checked over the settled set at the sync and
+   * reported once per change of the set, the scene rendering on with
+   * what fits. Without a handler the sync throws it, uncaught (a
+   * microtask): the `<Scene>` component hands one in and rethrows inside
+   * the tree, so the app's error boundary shows it. */
+  onError?: (error: Error) => void
 }
 
 export type ViewOptions = {
@@ -467,17 +512,29 @@ export type ViewOptions = {
    * "texture" for a sampleable one exposed as `view.depthTexture`. Not
    * with `into` (the depth is the parent's). */
   depth?: true | "texture"
+  /** The view buffer's clear, an sRGB color like the scene's. */
   clearColor?: [number, number, number, number]
   samples?: 1 | 2 | 4 | 8
   filter?: FilterMode
   wrap?: WrapMode
   label?: string
+  /** The view's resolve fragment (see Scene.setResolve), or a function
+   * of the view's buffer id; not with `into` (a tile renders linear into
+   * the atlas, which the app resolves once). */
+  resolve?: ResolveInput
+  /** The view's own bloom: BloomOptions overrides the scene's, null turns
+   * it off in this view (a clean minimap). Absent follows the scene's
+   * setBloom, like `fog`. Not with `into`. */
+  bloom?: BloomOptions | null
   /** Render into a rectangle of this draw target (an app-owned atlas)
    * instead of a target of the view's own: every view into one atlas
    * costs ONE pass. `x`/`y` (top-left origin, default 0) place the tile;
    * display it with `<d-texture src={atlas} srcX srcY srcW srcH>`. The
-   * atlas carries depth and samples; `view.texture` is then the tile's id
-   * (a draw target, not a texture) and `view.depthTexture` is null. */
+   * atlas carries depth, samples and the format; `view.texture` is then
+   * the tile's id (a draw target, not a texture), `view.depthTexture` and
+   * `view.hdrTexture` are null, and the tile holds LINEAR light like every
+   * buffer - resolve the atlas once with a DEFAULT_RESOLVE pass over it
+   * (`uScene` bound to the atlas) and display that. */
   into?: TextureId
   x?: number
   y?: number
@@ -485,16 +542,28 @@ export type ViewOptions = {
 
 /** A second rendering of a scene from its own camera; see Scene.createView. */
 export type ViewHandle = {
-  /** The view's output, an ordinary texture id. */
+  /** The view's output, an ordinary texture id: its resolve (or, tiled,
+   * the tile's id). */
   texture: TextureId
-  /** The view target's depth as a sampler-only texture id when created
+  /** The view's buffer, the linear light its resolve reads (sampler-only;
+   * null for a tiled view). */
+  hdrTexture: TextureId | null
+  /** The view buffer's depth as a sampler-only texture id when created
    * with `depth: "texture"` (the shadow-map input), else null. */
   depthTexture: TextureId | null
+  /** Replace the view's resolve fragment; exactly Scene.setResolve. Throws
+   * on a tiled view. */
+  setResolve(resolve: ResolveInput): void
+  /** The view's own bloom from now on (null = off): the scene's setBloom
+   * skips this view afterwards. Throws on a tiled view. */
+  setBloom(bloom: BloomOptions | null): void
   /** Partial camera update, exactly scene.setCamera. */
   setCamera(update: CameraUpdate): void
   /** Current camera state, exactly scene.camera. */
   camera(): CameraState
   setSize(width: number, height: number): void
+  /** The view's target size in pixels, as setSize/setRect last left it. */
+  size(): { width: number; height: number }
   /** Move and resize a view created `into` an atlas (top-left origin);
    * throws on a view with a target of its own. */
   setRect(rect: { x: number; y: number; width: number; height: number }): void
@@ -564,7 +633,10 @@ export type ReflectionProbe = {
    * sampled by the faces it renders (a black environment stands in): one
    * bounce. */
   update(): void
-  /** Destroy the cube (idempotent; probes also die with the scene). */
+  /** Destroy the cube (idempotent; probes also die with the scene). A
+   * scene whose `environment` or `background` names this cube drops it
+   * first (setEnvironment(null), setBackground(null)), so nothing samples
+   * a destroyed texture: set another when the probe's owner leaves. */
   dispose(): void
 }
 
@@ -594,16 +666,17 @@ const PROBE_FACE_UP: Vec3[] = [
 const PROBE_SIZE = 128
 // A cube face spans a quarter turn.
 const PROBE_FOV = 90
-// The output stage of a cube that holds light rather than display pixels
-// (a probe's faces, a baked sky): no sRGB encode, no tone mapping, unit
-// exposure - so the environment lookups read radiance.
-const LINEAR_OUTPUT: ShaderParams = { uOutputEncode: 0, uToneMapping: TONE_MAPPING_CODE.none, uExposure: 1 }
-
 export type Scene = {
-  /** The scene's output: an ordinary texture id (`<texture src>`). */
+  /** The scene's output: an ordinary texture id (`<texture src>`) - the
+   * resolve of the buffer, encoded display pixels. */
   texture: TextureId
-  /** The scene target's depth as a sampler-only texture id when created
-   * with `depth: "texture"`, else null. */
+  /** The scene's BUFFER: the target the meshes draw into, premultiplied
+   * linear light (half float where the device renders it, see
+   * bufferFormat), sampler-only - the input of a radiance-reading pass (a
+   * bloom chain) whose result a custom resolve adds back in. */
+  hdrTexture: TextureId
+  /** The buffer's depth as a sampler-only texture id when created with
+   * `depth: "texture"`, else null. */
   depthTexture: TextureId | null
   /** The tree root; add(scene.root, node) attaches top-level nodes. */
   root: SceneNode
@@ -614,6 +687,11 @@ export type Scene = {
    * back through setCamera). Reflects a pending setCamera immediately. */
   camera(): CameraState
   setSize(width: number, height: number): void
+  /** The target size in pixels, as setSize last left it (a fill-mode
+   * `<Scene>` sets it from its layout box, so before the first layout
+   * this is the creation size). The aspect a camera control's fit()
+   * frames against. */
+  size(): { width: number; height: number }
   /**
    * Scene-wide uniforms: merge app-owned names into the target's SHARED
    * params, beside the standard uViewProj/uCamPos/uCamRight/uCamUp the
@@ -680,24 +758,55 @@ export type Scene = {
    */
   setEnvironment(env: EnvironmentOptions | null): void
   /**
-   * The output stage's tone mapping, applied by every library material,
-   * the skybox and a GLSL background that ends with outputColor: "none"
+   * The resolve's tone mapping, applied once per pixel to the buffer -
+   * every material, the background, the clearColor alike: "none"
    * (default) clamps the linear result, "aces" compresses highlights on
-   * the filmic curve. One shared-params write (`uToneMapping`, the OUTPUT
-   * set in `@solidrt/3d/glsl` declares), like Three's
-   * renderer.toneMapping and Godot's Environment tonemap; a custom
-   * fragment that writes fragColor directly is untouched. The clearColor
-   * is not tone mapped: with a curve on, draw the backdrop as a
-   * background.
+   * the filmic curve. One shared-params write (`uToneMapping`, the
+   * RESOLVE set in `@solidrt/3d/glsl` declares), like Three's
+   * renderer.toneMapping and Godot's Environment tonemap.
    */
   setToneMapping(mode: ToneMapping): void
   /**
-   * The output stage's exposure (default 1): the linear result is scaled
-   * by it before tone mapping, so a scene lit in physical-ish units is
-   * brought into range here rather than by dimming every light. One
-   * shared-params write (`uExposure`), like Three's toneMappingExposure.
+   * The resolve's exposure (default 1): the buffer is scaled by it before
+   * tone mapping, so a scene lit in physical-ish units is brought into
+   * range here rather than by dimming every light. One shared-params
+   * write (`uExposure`), like Three's toneMappingExposure.
    */
   setExposure(exposure: number): void
+  /**
+   * Replace the scene's RESOLVE: the one full-screen pass that turns the
+   * buffer (`hdrTexture`, premultiplied linear light) into `texture`
+   * (display pixels) - the place a post effect that needs radiance
+   * lives (Godot's glow sits in its tonemap pass; Three's bloom reads the
+   * HDR render before OutputPass). Fragment GLSL with the shader-target
+   * contract (vUV 0..1 top-left origin, iResolution, fragColor; no
+   * `#version` line means the standard preamble), `uniform sampler2D
+   * uScene` (the buffer) and the RESOLVE set declared: end with
+   * `fragColor = resolveColor(rgb, alpha)` for the scene's exposure, tone
+   * mapping and encode. The object form binds extra textures the source
+   * declares (a bloom chain's result). Any name written through
+   * scene.setParams is readable. The default is DEFAULT_RESOLVE (one
+   * sample through resolveColor). A textures-only change rebinds in
+   * place; a source change recompiles. A function form receives the
+   * buffer id, like the option.
+   */
+  setResolve(resolve: ResolveInput): void
+  /**
+   * The stock bloom, or null for none (default): radiance above
+   * `threshold` (default 1) blurred over `radius` rounds (default 2) at a
+   * quarter of the target's size and added back at `intensity` (default
+   * 0.5) - Godot's glow, Unity's Bloom, Three's UnrealBloomPass. A chain
+   * of small passes per resolving target, re-rendered when the buffer
+   * is; the default resolve composes it, and a custom one does by
+   * declaring `uBloom` / `uBloomIntensity` (start from BLOOM_RESOLVE in
+   * `@solidrt/3d/glsl`). Fans out to every view that has not set a
+   * bloom of its own, like setFog.
+   */
+  setBloom(bloom: BloomOptions | null): void
+  /** The LOD quality knob (SceneOptions.lodBias): a multiplier on every
+   * measured projected size, for the scene, its views and its shadow
+   * tiles. Below 1 switches to far levels sooner. */
+  setLodBias(bias: number): void
   /**
    * Project a world point to scene pixels: origin top-left, y down - the
    * output texture's own coordinate space, ready for overlay layout (HUD
@@ -865,9 +974,9 @@ export type Scene = {
    * Bake the background into an environment: a reflection probe at the
    * origin that sees no mesh (layer mask 0), so its six `size` faces
    * (default 128) hold the background alone - the GLSL sky or the skybox,
-   * exactly as the scene draws it, written LINEAR (uOutputEncode 0, no tone mapping, unit exposure,
-   * so a sky ending in outputColor bakes its light; one writing fragColor
-   * raw bakes those bytes as light) - then GGX-prefiltered into the chain
+   * exactly as the scene draws it, LINEAR like every buffer (a sky
+   * fragment writes light, never display pixels) - then GGX-prefiltered
+   * into the chain
    * `standard` samples by roughness: Godot's sky-to-radiance bake, a
    * procedural sky lighting the scene, or a hi-res LDR skybox reduced to
    * an environment. A snapshot: bake again when the sky changed. Returns
@@ -889,23 +998,96 @@ export type Scene = {
 // missing channel would have no home) - an error, like the rest of the
 // strict entry path. Extra channels are fine.
 function checkLayout(material: Material, geometry: Geometry, what: string): void {
-  let missing = missingAttributes(material, geometry.layout)
+  let missing = missingAttributes(material, geometry)
   if (missing.length > 0) {
     throw new Error(
-      what + " reads attributes the geometry layout (" + layoutKey(geometry.layout) + ") lacks: " +
+      what + " reads attributes the geometry layout (" + geometryKey(geometry) + ") lacks: " +
         missing.map(a => a.name + " " + a.format).join(", ") +
         " - add the channel with withAttribute()/withColors(), or use a material that does not read it",
     )
   }
 }
 
+// The index range a mesh's entries draw: its own (setDrawRange) or the
+// whole index list.
+function meshRange(mesh: Mesh): { firstIndex: number; indexCount: number } {
+  return mesh._range === null ? { firstIndex: 0, indexCount: mesh.geometry.indices.length } : { firstIndex: mesh._range.first, indexCount: mesh._range.count }
+}
+
 // An entry's initial params. The uNormal seed keys off the material flag
 // because entry params validate strictly - and a material declaring
 // uNormal without using it therefore throws right here, at add().
+// The solid uLodFade: a fresh entry draws whole until the core writes a
+// band position (a GL uniform reads zero until written, which would
+// discard everything).
+const LOD_SOLID = [1, 1]
+
 function entrySeed(material: Material, params: ShaderParams | null): ShaderParams {
-  return material.normalMatrix
-    ? { uModel: IDENTITY, uNormal: IDENTITY, ...material.params, ...params }
-    : { uModel: IDENTITY, ...material.params, ...params }
+  let seed: ShaderParams = { uModel: IDENTITY }
+  if (material.normalMatrix) seed.uNormal = IDENTITY
+  if (material.lodFade) seed.uLodFade = LOD_SOLID
+  return { ...seed, ...material.params, ...params }
+}
+
+// A morphing entry's bindings: the geometry's packed targets (uMorphs and
+// its width) and the weights texture (uMorphWeights): the mesh's owner's
+// one row, or the population's row-per-slot texture on an instanced mesh
+// (the shader reads row uMorphRow + gl_InstanceID). Only for a material
+// whose program declares them (Material.morphed - the mesh's own, a
+// morphed shadow stand-in); any other validates its bindings strictly.
+// A plain owner's register is bound here if it was not yet (a mesh owner
+// nothing wrote before its first morphing entry).
+type MorphEntry = { textures: TextureBindings; params: ShaderParams }
+function morphEntry(material: Material, mesh: Mesh): MorphEntry | null {
+  if (material.morphed !== true) return null
+  let packed = mesh._buffers?.morphs
+  if (packed === null || packed === undefined) return null
+  let weights = morphWeightsTexture(mesh)
+  if (weights === null) return null
+  return {
+    textures: { uMorphs: packed.texture, uMorphWeights: weights },
+    params: { uMorphWidth: packed.width, uMorphRow: 0 },
+  }
+}
+
+// The weights texture a mesh's morphing entries bind, activating a plain
+// owner's register on the way; null when nothing owns weights.
+function morphWeightsTexture(mesh: Mesh): TextureId | null {
+  let inst = mesh._instances
+  if (inst !== null) return inst.morph?.texture ?? null
+  return mesh._morphOwner === null ? null : activateMorph(mesh._morphOwner).texture
+}
+
+// An entry's sampler bindings: the material's, the mesh's own (a skin's
+// uBones) when the material is the mesh's or a skinned stand-in (a
+// skinned shadow variant declares uBones and needs the mesh's palette;
+// other override programs may not declare the names, and per-entry
+// bindings validate strictly), and the morph bindings when it morphs.
+// A morphing material over geometry without targets has nothing to walk
+// (and its uMorphs binding nothing to bind): rejected at add(), like a
+// layout mismatch. A record mesh has no instance nodes to own weights,
+// so its records cannot morph; an instanced mesh morphs per instance.
+function checkMorph(material: Material, mesh: Mesh, site: string): void {
+  if (material.morphed !== true) return
+  if (mesh.geometry.morphs === undefined) throw new Error(site + " morphs (morph: true) but the geometry carries no morph targets")
+  let inst = mesh._instances
+  if (inst !== null && inst.nodes === null) throw new Error(site + " morphs, but a record mesh has no instance nodes to own weights (createInstancedMesh morphs per instance)")
+  if (inst === null && mesh._morphOwner === null) throw new Error(site + " morphs but the mesh has no morph owner")
+}
+
+function entryTextures(material: Material, mesh: Mesh, morph: MorphEntry | null): TextureBindings | undefined {
+  let textures = material.textures
+  if ((material === mesh.material || material.skinned === true) && mesh._textures !== null) textures = { ...textures, ...mesh._textures }
+  if (morph !== null) textures = { ...textures, ...morph.textures }
+  return textures
+}
+
+// A buffer's clear color: the sRGB option decoded to premultiplied linear
+// light, what the buffer holds and the resolve tone maps.
+function bufferClear(color: [number, number, number, number] | undefined): [number, number, number, number] | undefined {
+  if (color === undefined) return undefined
+  let c = premultipliedColor(color)
+  return [c[0]!, c[1]!, c[2]!, c[3]!]
 }
 
 /**
@@ -922,15 +1104,19 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // The scene target's layer mask; shadow views follow it (a mesh the
   // scene cannot see must not darken it).
   let sceneMask = checkMask(opts?.layers ?? 1, "createScene")
+  let label = opts?.label ?? "scene"
+  // `texture` is the scene's BUFFER throughout this file: the draw target
+  // every entry, sink, sort and param write names. The handle's `texture`
+  // is its resolve (below), the displayable id.
   let texture = createDrawTarget(width, height, null, {
     depth: depthMode,
-    clearColor: opts?.clearColor,
-    filter: opts?.filter,
-    wrap: opts?.wrap,
+    format: bufferFormat(),
+    clearColor: bufferClear(opts?.clearColor),
     samples: opts?.samples,
-    label: opts?.label ?? "scene",
+    label,
     autoFree: false,
   })
+  let resolve = makeResolve(texture, width, height, opts?.resolve, { filter: opts?.filter, wrap: opts?.wrap }, label)
   let disposed = false
   let scheduled = false
 
@@ -946,8 +1132,11 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // One filter object per scene, refilled per query (the bindings read it
   // synchronously), so a query allocates nothing but its hits.
   let filter: QueryFilter = {}
-  let queryFilter = (qopts: QueryOptions | undefined, site: string): QueryFilter => {
+  // `target` names the draw target whose LOD levels the query sees: the
+  // scene's for its own queries, a view's for view.pick.
+  let queryFilter = (qopts: QueryOptions | undefined, site: string, target: TextureId = texture): QueryFilter => {
     filter.root = root._node!
+    filter.target = target
     filter.layers = qopts?.layers !== undefined ? checkMask(qopts.layers, site) : sceneMask
     if (qopts?.meshes === undefined) {
       filter.nodes = undefined
@@ -981,12 +1170,14 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // _moved flag): what the light and transparent-order bookkeeping
   // reacts to, since which meshes moved is the core's knowledge now.
   let moved: SceneNode[] = []
-  // Instanced meshes with style writes to publish at the next sync.
-  let styleDirty = new Set<InstancedMesh>()
+  // Populated meshes with record writes to publish at the next sync.
+  let recordsDirty = new Set<Mesh>()
   // Instanced meshes whose cull group - their live instance nodes - changed
   // since the last sync: one setCullGroup per mesh however many entered
   // or left.
   let groupDirty = new Set<InstancedMesh>()
+  // bindMatrixRecord's buffer list, refilled per instance.
+  let instanceBuffers: BufferId[] = []
   let instanceGroup = (mesh: InstancedMesh): NodeId[] => {
     let members: NodeId[] = []
     for (let n of mesh._instances.nodes.slots) if (n !== null && n._node !== null) members.push(n._node)
@@ -1005,6 +1196,9 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // light params at the end of the sync - one write, however many meshes.
   let lights: Light[] = []
   let lightsDirty = false
+  // The list changed shape (attach, detach) since sync last checked the
+  // light cap.
+  let lightSetDirty = false
   // uLightDir and uLightPos are CORE-DRIVEN: each light's slots are
   // shared-slot sinks following the node's world transform - the
   // direction slot (bindDirectionSlot) with -direction as the local
@@ -1039,6 +1233,9 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
         ground = [g[0]! * k, g[1]! * k, g[2]! * k]
         continue
       }
+      // A light past the cap is not lit (sync reports the set once): its
+      // slots would overrun the MAX_LIGHTS arrays.
+      if (count >= MAX_LIGHTS) continue
       if (light.type !== "point") {
         vecScratch[0] = -light.direction[0]
         vecScratch[1] = -light.direction[1]
@@ -1147,7 +1344,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // light rewrite seeds it on new targets); null binds the placeholder,
   // the scene's own 1x1 black cube.
   let environment: TextureId | null = null
-  let envPlaceholder = createEnvironmentPlaceholder((opts?.label ?? "scene") + "-env-none")
+  let envPlaceholder = createEnvironmentPlaceholder(label + "-env-none")
   let sortEntries = () => {
     orderDirty = false
     let order = orderEntries(meshes, camera.view, background?.entries.get(texture))
@@ -1228,10 +1425,25 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // scene (view-space keys from the view's own camera); an overridden
   // view is not sorted at all.
   type ViewRecord = {
+    /** The view's BUFFER (a 2D draw target, a tile, or a cube). */
     texture: TextureId
+    /** The view's resolve, the displayable output; null for a shadow
+     * view, a probe and a tile (the atlas is the app's to resolve). */
+    resolve: ResolveRecord | null
+    /** Whether the view set its own bloom (the `bloom` option or
+     * view.setBloom): the scene's setBloom then skips it. */
+    ownBloom: boolean
     width: number
     height: number
+    /** Debug label: the option, else the scene's plus -view/-probe. */
+    label: string
     override: Material | null
+    /** The instanced meshes an override view leaves out: the override
+     * declares no instanceBuffers, so it cannot place their records
+     * (ViewOptions.overrideMaterial). Kept so sync() reports them once
+     * per view, over the settled set. */
+    skipped: Set<Mesh>
+    skippedReported: boolean
     /** Non-null marks a SHADOW view and names its caster set (m =>
      * m.castShadow). Re-evaluated per mesh by _setCast; also picks the
      * caster's own shadow material variant over the depth override. */
@@ -1247,6 +1459,9 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     entries: Map<Mesh, DrawId>
     orderDirty: boolean
     lastOrder: DrawId[]
+    /** A shadow tile measures LOD by the SCENE camera: set once at
+     * creation, then on every scene camera move. */
+    lodViewSet: boolean
     /** A reflection probe's target is a cube draw target of this face
      * edge, rendered face by face through probe.update(); null for a
      * 2D view. */
@@ -1264,6 +1479,9 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   let views: ViewRecord[] = []
   // Every name scene.setParams has merged so far, replayed on a new view.
   let sceneParams: ShaderParams = {}
+  // The scene's bloom (setBloom), applied to every resolving view that
+  // has not set its own.
+  let sceneBloom: BloomOptions | null = null
   // Every target a receiving material can draw into: the scene's and each
   // view's but the shadow views (binding a target's own depth into it
   // would be same-pass feedback).
@@ -1289,17 +1507,18 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     // so added live it would draw at the seeded identity until then. The
     // mismatch branch in sync() turns it on in the same pass that writes
     // uModel.
-    mesh._entry = addDraw(texture, mesh.material.pipeline(mesh.geometry.layout, geometryTopology(mesh.geometry)), entrySeed(mesh.material, mesh._params), {
-      buffer: bufs.buffer,
+    let morph = morphEntry(mesh.material, mesh)
+    mesh._entry = addDraw(texture, mesh.material.pipeline(mesh.geometry, geometryTopology(mesh.geometry)), entrySeed(mesh.material, morph === null ? mesh._params : { ...morph.params, ...mesh._params }), {
+      buffers: [...bufs.buffers, ...(inst !== null ? instanceBinding(mesh.material, inst) : [])],
       indexBuffer: bufs.index,
       indexFormat: bufs.indexFormat,
-      textures: mesh._textures !== null ? { ...mesh.material.textures, ...mesh._textures } : mesh.material.textures,
-      ...(inst !== null ? instanceBinding(mesh.material, inst) : {}),
+      ...meshRange(mesh),
+      textures: entryTextures(mesh.material, mesh, morph),
       instanceCount: 0,
     })
     // The core turns the entry on (with the world matrix) at the next
     // flush, and off again whenever the node or an ancestor hides.
-    spatial.bindDraw(mesh._node!, texture, mesh._entry, mesh.material.normalMatrix === true, inst !== null ? inst.count : 1)
+    spatial.bindDraw(mesh._node!, texture, mesh._entry, mesh.material.normalMatrix === true, inst !== null ? inst.count : 1, mesh.material.lodFade === true)
     orderDirty = true
   }
   let detachScene = (mesh: Mesh) => {
@@ -1330,27 +1549,32 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     // instanced depth pass), whose attributes must fit the records like
     // the main material's did at add().
     if (v.override !== null && inst !== null) {
-      if (material.instanceAttributes === undefined) return
+      if (material.instanceBuffers === undefined) {
+        // A caster without an instanced shadow variant casts none by
+        // that rule; an app's override view dropping a mesh is invisible
+        // in its output, so it is recorded for sync() to report.
+        if (v.shadowFilter === null) v.skipped.add(mesh)
+        return
+      }
       checkInstancePairing(material, inst, "Shadow material")
     }
     let bufs = mesh._buffers!
-    let entry = addDraw(v.texture, material.pipeline(mesh.geometry.layout, geometryTopology(mesh.geometry)), entrySeed(material, v.override !== null ? null : mesh._params), {
-      buffer: bufs.buffer,
+    let morph = morphEntry(material, mesh)
+    let params = v.override !== null ? (morph === null ? null : morph.params) : morph === null ? mesh._params : { ...morph.params, ...mesh._params }
+    let entry = addDraw(v.texture, material.pipeline(mesh.geometry, geometryTopology(mesh.geometry)), entrySeed(material, params), {
+      buffers: [...bufs.buffers, ...(inst !== null ? instanceBinding(material, inst) : [])],
       indexBuffer: bufs.index,
       indexFormat: bufs.indexFormat,
-      // The mesh's own bindings ride with its own material and with any
-      // skinned stand-in (a skinned shadow variant declares uBones and
-      // needs the mesh's palette); other override programs may not
-      // declare the names, and per-entry bindings validate strictly.
-      textures: (material === mesh.material || material.skinned === true) && mesh._textures !== null ? { ...material.textures, ...mesh._textures } : material.textures,
-      ...(inst !== null ? instanceBinding(material, inst) : {}),
+      ...meshRange(mesh),
+      textures: entryTextures(material, mesh, morph),
       instanceCount: 0,
     })
-    spatial.bindDraw(mesh._node!, v.texture, entry, material.normalMatrix === true, inst !== null ? inst.count : 1)
+    spatial.bindDraw(mesh._node!, v.texture, entry, material.normalMatrix === true, inst !== null ? inst.count : 1, material.lodFade === true)
     v.entries.set(mesh, entry)
     v.orderDirty = true
   }
   let detachView = (v: ViewRecord, mesh: Mesh) => {
+    v.skipped.delete(mesh)
     let entry = v.entries.get(mesh)
     if (entry === undefined) return
     v.entries.delete(mesh)
@@ -1374,8 +1598,10 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     v.entries.clear()
     for (let light of lights) if (light.type === "directional" && light._node !== null) spatial.unbindSlot(light._node, v.texture)
     spatial.setFrustum(v.texture, null)
+    spatial.setLodView(v.texture, null)
     // Drain the zeroed direction slots while the target still exists.
     spatial.flush()
+    if (v.resolve !== null) disposeResolve(v.resolve)
     destroyTexture(v.texture)
     let i = views.indexOf(v)
     if (i >= 0) views.splice(i, 1)
@@ -1418,35 +1644,47 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       for (let mesh of meshes) if (mesh._instances === null) checkLayout(override, mesh.geometry, "View override material")
     }
     let tiled = vopts.into !== undefined
+    if (tiled && vopts.resolve !== undefined) throw new Error("createView: a tiled view (into) has no resolve of its own - resolve the atlas")
+    if (tiled && vopts.bloom !== undefined) throw new Error("createView: a tiled view (into) has no resolve to bloom on - resolve the atlas")
+    let viewLabel = vopts.label ?? label + (cube !== null ? "-probe" : "-view")
+    let buffer =
+      cube !== null
+        ? createCubeDrawTarget(cube, null, {
+            depth: true,
+            // The prefilter reads the faces at the lod of each sample's
+            // solid angle: a generated chain, refreshed per face render.
+            mipmap,
+            format: bufferFormat(),
+            clearColor: bufferClear(vopts.clearColor),
+            label: viewLabel,
+            autoFree: false,
+          })
+        : createDrawTarget(vopts.width, vopts.height, null, {
+            depth: tiled ? undefined : (vopts.depth ?? true),
+            format: tiled ? undefined : bufferFormat(),
+            clearColor: bufferClear(vopts.clearColor),
+            samples: vopts.samples,
+            label: viewLabel,
+            autoFree: false,
+            into: vopts.into,
+            x: vopts.x,
+            y: vopts.y,
+          })
     let v: ViewRecord = {
-      texture:
-        cube !== null
-          ? createCubeDrawTarget(cube, null, {
-              depth: true,
-              // The prefilter reads the faces at the lod of each sample's
-              // solid angle: a generated chain, refreshed per face render.
-              mipmap,
-              // Linear radiance, HDR where the device renders half float.
-              format: probeFormat(),
-              clearColor: vopts.clearColor,
-              label: vopts.label ?? (opts?.label ?? "scene") + "-probe",
-              autoFree: false,
-            })
-          : createDrawTarget(vopts.width, vopts.height, null, {
-              depth: tiled ? undefined : (vopts.depth ?? true),
-              clearColor: vopts.clearColor,
-              filter: vopts.filter,
-              wrap: vopts.wrap,
-              samples: vopts.samples,
-              label: vopts.label ?? (opts?.label ?? "scene") + "-view",
-              autoFree: false,
-              into: vopts.into,
-              x: vopts.x,
-              y: vopts.y,
-            }),
+      texture: buffer,
+      // A shadow view is depth only, a probe's faces are read as a cube,
+      // a tile is the atlas's: none of them displays, so none resolves.
+      resolve:
+        cube === null && shadowFilter === null && !tiled
+          ? makeResolve(buffer, vopts.width, vopts.height, vopts.resolve, { filter: vopts.filter, wrap: vopts.wrap }, viewLabel)
+          : null,
+      ownBloom: vopts.bloom !== undefined,
       width: vopts.width,
       height: vopts.height,
+      label: viewLabel,
       override,
+      skipped: new Set(),
+      skippedReported: false,
       shadowFilter,
       mask: shadowFilter !== null ? sceneMask : checkMask(vopts.layers ?? 1, "createView"),
       ownNames: new Set(),
@@ -1454,6 +1692,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       entries: new Map(),
       orderDirty: true,
       lastOrder: [],
+      lodViewSet: false,
       cube,
       probeCube: null,
       sky,
@@ -1472,6 +1711,11 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     if (ownFog !== null) for (let k of Object.keys(ownFog)) v.ownNames.add(k)
     setTargetParams(v.texture, ownFog === null ? sceneParams : withoutNames(sceneParams, v.ownNames))
     if (ownFog !== null) setTargetParams(v.texture, ownFog)
+    if (v.resolve !== null) {
+      setTargetParams(v.resolve.target, sceneParams)
+      let bloom = vopts.bloom !== undefined ? vopts.bloom : sceneBloom
+      if (bloom !== null) setResolveBloom(v.resolve, v.texture, vopts.width, vopts.height, bloom)
+    }
     for (let mesh of meshes) attachView(v, mesh)
     hooks._schedule()
     return v
@@ -1484,7 +1728,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     lights,
     camera,
     targetSize: () => ({ width, height }),
-    label: opts?.label ?? "scene",
+    label,
     makeView,
     disposeView,
     markLightsDirty: () => {
@@ -1503,36 +1747,101 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     frustumScratch.set(cam.viewProj)
     spatial.setFrustum(target, frustumScratch)
   }
+  // A camera write is also the target's LOD view - eye, vertical focal
+  // factor (the magnitude of proj[5] under either projection: the
+  // projections bake in a y-down clip flip, so the element is negative),
+  // the ortho flag and the scene's bias - what the core measures
+  // projected size with. The scene and each view measure by their own
+  // camera; a shadow tile by the SCENE camera, so a caster draws the
+  // level the camera sees and its shadow matches.
+  let lodBias = opts?.lodBias ?? 1
+  if (!(lodBias > 0 && Number.isFinite(lodBias))) throw new Error("createScene: lodBias must be a positive number, got " + lodBias)
+  let lodBiasDirty = false
+  let lodScratch = new Float32Array(6)
+  let setLodView = (target: TextureId, cam: Camera) => {
+    lodScratch[0] = cam.eye[0]
+    lodScratch[1] = cam.eye[1]
+    lodScratch[2] = cam.eye[2]
+    lodScratch[3] = Math.abs(cam.proj[5]!)
+    lodScratch[4] = cam.ortho !== null ? 1 : 0
+    lodScratch[5] = lodBias
+    spatial.setLodView(target, lodScratch)
+  }
   let sync = () => {
     scheduled = false
     if (disposed) return
+    // An override view's skipped instanced meshes (attachView), reported
+    // once per view over the settled set, as the budgets below are: the
+    // meshes of one flush are all in by this microtask, so the count is
+    // the whole set, not the first arrival.
+    for (let v of views) {
+      if (v.skippedReported || v.skipped.size === 0) continue
+      v.skippedReported = true
+      let n = v.skipped.size
+      console.warn(
+        `View '${v.label}' override material skips ${n} instanced ${n === 1 ? "mesh" : "meshes"}: it declares no instanceBuffers, so it cannot place their records, and they draw in no pass of this view; give it an instanced variant to include them`,
+      )
+    }
+    // A per-scene budget - the light cap, the shadow slots - is tested
+    // here over the settled set, never at attach: a declarative swap
+    // (<Show>, <Switch>) attaches the incoming branch before the outgoing
+    // one detaches, inside one Solid flush, and both are gone by this
+    // microtask. A set past a budget is reported once, at the end, after
+    // every write below, so the scene is never left half-written.
+    let budgetError: Error | null = null
+    if (lightSetDirty) {
+      lightSetDirty = false
+      let n = lights.filter(l => l.type !== "hemisphere").length
+      if (n > MAX_LIGHTS) {
+        budgetError = new Error(
+          "A scene takes at most " + MAX_LIGHTS + " lights (directional, spot and point together): " + n + " attached, the lights past the cap are not lit",
+        )
+      }
+    }
+    let shadowError = shadowSys.settle()
+    if (budgetError === null) budgetError = shadowError
     ensureCamera(camera, width, height)
     let cameraMoved = camera.pending
+    let biasChanged = lodBiasDirty
+    lodBiasDirty = false
     if (camera.pending) {
       camera.pending = false
       setTargetParams(texture, cameraParams(camera))
       setFrustum(texture, camera)
       if (transparentCount > 1) orderDirty = true
     }
+    if (cameraMoved || biasChanged) setLodView(texture, camera)
     shadowSys.placeCameras(cameraMoved)
     for (let v of views) {
       ensureCamera(v.camera, v.width, v.height)
-      if (v.camera.pending) {
+      let viewMoved = v.camera.pending
+      if (viewMoved) {
         v.camera.pending = false
         setTargetParams(v.texture, cameraParams(v.camera))
         setFrustum(v.texture, v.camera)
         if (transparentCount > 1) v.orderDirty = true
         if (v.shadowFilter !== null) shadowSys.markMatricesDirty()
       }
+      // Probe faces measure nothing (six cameras, one target), like their
+      // frustum.
+      if (v.cube !== null) continue
+      if (v.shadowFilter !== null) {
+        if (cameraMoved || biasChanged || !v.lodViewSet) {
+          v.lodViewSet = true
+          setLodView(v.texture, camera)
+        }
+      } else if (viewMoved || biasChanged) {
+        setLodView(v.texture, v.camera)
+      }
     }
     // Light bookkeeping first, so a fresh direction-slot bind is seeded
     // by the flush below in the same sync.
     if (lightsDirty) writeLights()
-    // The instanced meshes' style writes since the last sync: one
-    // coalesced buffer write per mesh.
-    if (styleDirty.size > 0) {
-      for (let m of styleDirty) if (m._instances !== null) publishInstanceStyle(m)
-      styleDirty.clear()
+    // The populated meshes' record writes since the last sync: one
+    // coalesced buffer write per dirty stream.
+    if (recordsDirty.size > 0) {
+      for (let m of recordsDirty) publishRecords(m)
+      recordsDirty.clear()
     }
     // An instanced mesh without explicit bounds is culled by the union of
     // its instances' boxes: the core's cull group (a skinned part's joint
@@ -1563,6 +1872,10 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     if (orderDirty || views.some(v => v.orderDirty)) refreshCenters()
     if (orderDirty) sortEntries()
     for (let v of views) if (v.orderDirty) sortView(v)
+    if (budgetError !== null) {
+      if (opts?.onError !== undefined) opts.onError(budgetError)
+      else throw budgetError
+    }
   }
 
   let hooks: SceneHooks = {
@@ -1573,23 +1886,25 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     },
     _attachLight(light) {
       if (disposed) return
-      if (light.type !== "hemisphere" && lights.filter(l => l.type !== "hemisphere").length >= MAX_LIGHTS) {
-        throw new Error("A scene takes at most " + MAX_LIGHTS + " lights (directional, spot and point together)")
-      }
       lights.push(light)
       lightsDirty = true
-      if (light.type !== "hemisphere" && light.castShadow) shadowSys.createShadow(light)
+      if (light.type === "hemisphere") return
+      lightSetDirty = true
+      if (light.castShadow) shadowSys.invalidate(light)
     },
     _detachLight(light) {
       let i = lights.indexOf(light)
       if (i >= 0) lights.splice(i, 1)
       lightsDirty = true
-      if (light.type !== "hemisphere") shadowSys.destroyShadow(light)
+      if (light.type !== "hemisphere") {
+        lightSetDirty = true
+        shadowSys.invalidate(light)
+      }
       hooks._schedule()
     },
     _shadowChanged(light) {
       if (disposed) return
-      shadowSys.shadowChanged(light)
+      shadowSys.invalidate(light)
     },
     _setCast(mesh) {
       if (mesh._buffers === null || disposed) return
@@ -1622,19 +1937,23 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       if (disposed) return
       validateGeometry(mesh.geometry)
       checkLayout(mesh.material, mesh.geometry, "Mesh material")
+      checkMorph(mesh.material, mesh, "Mesh material")
       // Every check before any mutation, so a rejected mesh is attached
       // nowhere - the views' override materials included.
       for (let v of views) {
-        if (v.override !== null && mesh._instances === null) checkLayout(v.override, mesh.geometry, "View override material")
+        if (v.override !== null && mesh._instances === null) {
+          checkLayout(v.override, mesh.geometry, "View override material")
+          checkMorph(v.override, mesh, "View override material")
+        }
       }
       // Instancing pairs the same way layout does: the pipeline's instance
       // attributes describe the mesh's record buffers, so one without the
       // other (or a record stride from a different attribute list) would
       // bind garbage - errors here, at add().
       let inst = mesh._instances
-      if (mesh.material.instanceAttributes !== undefined && inst === null) {
+      if (mesh.material.instanceBuffers !== undefined && inst === null) {
         throw new Error(
-          "Material declares instanceAttributes - create its meshes with createInstancedMesh or createRecordMesh, not createMesh",
+          "Material declares instanceBuffers - create its meshes with createInstancedMesh or createRecordMesh, not createMesh",
         )
       }
       if (inst !== null) checkInstancePairing(mesh.material, inst, "Mesh material")
@@ -1642,30 +1961,25 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       mesh._buffers = bufs
       attachScene(mesh)
       for (let v of views) attachView(v, mesh)
-      // The style mirror may have been written while the mesh was out of
-      // a scene (or into a buffer this scene never saw): republish it.
-      if (inst !== null && inst.style !== null) {
-        inst.style.dirty = inst.count > 0 ? [0, inst.count * inst.style.stride] : null
-        if (inst.style.dirty !== null) styleDirty.add(mesh as InstancedMesh)
-      }
-      // Picking: the local box puts the node in the core index; an
-      // ordinary mesh also gets its geometry's triangle shape, a
-      // populated one is box-only (its instances are the leaves that
-      // pick, each with the shape; a record mesh's records are opaque, so
-      // without explicit bounds it is not picked at all), as is a sprite
-      // (its triangles lie wherever the camera is, not where the geometry
-      // says).
-      spatial.setBounds(mesh._node!, localBounds(mesh))
-      spatial.setShape(mesh._node!, inst === null && !mesh._sprite ? bufs.shape : null)
-      // A rebuilt entry (setGeometry) re-boxes the live instances to the
+      // Record writes made while the mesh was out of a scene kept their
+      // dirty ranges: publish them now.
+      if (inst !== null && inst.streams.some(s => s.dirty !== null)) recordsDirty.add(mesh)
+      // Picking: an ordinary mesh's node carries its geometry's shape,
+      // which is its box in the core index (following every
+      // updateVertices) and its triangle narrowphase. A populated mesh is
+      // box-only by its explicit population bounds (its instances are the
+      // leaves that pick, each with the shape; a record mesh's records are
+      // opaque, so without explicit bounds it is not picked at all), as is
+      // a sprite by the unit box (its triangles lie wherever the camera
+      // is, not where the geometry says).
+      if (inst === null && !mesh._sprite) spatial.setShape(mesh._node!, bufs.shape)
+      else spatial.setBounds(mesh._node!, localBounds(mesh))
+      // A rebuilt entry (setGeometry) re-shapes the live instances to the
       // new geometry; their record bindings are untouched. On a first
       // entry none has a core node yet - they enter after the mesh.
       if (inst !== null && inst.nodes !== null) {
         for (let n of inst.nodes.slots) {
-          if (n !== null && n._node !== null) {
-            spatial.setBounds(n._node, geometryBounds(mesh.geometry))
-            spatial.setShape(n._node, bufs.shape)
-          }
+          if (n !== null && n._node !== null) spatial.setShape(n._node, bufs.shape)
         }
       }
       // Culling: the gate and margin only when off the defaults, and a
@@ -1690,7 +2004,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     },
     _detach(mesh) {
       if (mesh._buffers !== null) {
-        styleDirty.delete(mesh as InstancedMesh)
+        recordsDirty.delete(mesh)
         groupDirty.delete(mesh as InstancedMesh)
         for (let v of views) detachView(v, mesh)
         detachScene(mesh)
@@ -1715,21 +2029,33 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       // geometry buffers and core node are live - a mesh masked out of
       // the scene included, whose instances still pick.
       if (mesh === null || mesh._buffers === null || mesh._node === null || instance._node === null) return
-      spatial.setBounds(instance._node, geometryBounds(mesh.geometry))
       spatial.setShape(instance._node, mesh._buffers.shape)
       spatial.setLayers(instance._node, mesh.layers)
       // The record is the instance's placement inside the mesh (the mesh
       // node is the anchor), staged by the core at the next flush.
-      spatial.bindMatrixRecord(instance._node, mesh._instances.buffer, instance._slot, mesh._node)
+      // One buffer per LOD level of an instanced LOD (the population is
+      // the group and the anchor, its levels its children at identity).
+      let levels = mesh._instances.levels
+      instanceBuffers.length = 0
+      if (levels === null) instanceBuffers.push(mesh._instances.matrix)
+      else for (let l of levels) instanceBuffers.push(l._instances.matrix)
+      spatial.bindMatrixRecord(instance._node, instanceBuffers, instance._slot, mesh._node)
+      // A morphing population: the instance's register takes its slot's
+      // row now (a recycled slot's row is overwritten, not inherited).
+      if (mesh._instances.morph !== null) activateMorph(instance)
       byNode.set(instance._node, instance)
       if (mesh._instances.bounds === null) groupDirty.add(mesh)
       this._schedule()
     },
+    _exiting(mesh) {
+      if (mesh._node !== null) byNode.delete(mesh._node)
+    },
     _detachInstance(instance) {
-      // The core node is destroyed right after: its box, shape and record
-      // binding go with it, and the slot hides at the next flush. The
-      // mesh's group loses the member at the sync (a mesh leaving with
-      // its instances is skipped there: its node is gone by then).
+      // The core node is destroyed right after (or animates out, picked
+      // by nothing): its box, shape and record binding go with it, and
+      // the slot hides at the next flush. The mesh's group loses the
+      // member at the sync (a mesh leaving with its instances is skipped
+      // there: its node is gone by then).
       if (instance._node !== null) byNode.delete(instance._node)
       let mesh = instance.mesh
       if (mesh !== null && mesh._instances !== null && mesh._instances.bounds === null) groupDirty.add(mesh)
@@ -1756,19 +2082,46 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       // The entries keep their range (at most the old capacity, so the
       // larger buffers always pass the swap's bounds check); the caller
       // destroys the old buffers after this, which the entries held alive
-      // until now. Each entry swaps the slots its own material binds.
+      // until now. Each entry swaps the buffers its own material binds
+      // (the full list: the geometry's buffer stays, the instance
+      // buffers follow the population).
       let inst = mesh._instances
-      if (mesh._buffers !== null && !disposed && inst !== null) {
-        if (mesh._entry !== null) setDrawBuffers(texture, mesh._entry, instanceBinding(mesh.material, inst))
+      let bufs = mesh._buffers
+      if (bufs !== null && !disposed && inst !== null) {
+        if (mesh._entry !== null) setDrawBuffers(texture, mesh._entry, { buffers: [...bufs.buffers, ...instanceBinding(mesh.material, inst)] })
         for (let v of views) {
           let entry = v.entries.get(mesh)
-          if (entry !== undefined) setDrawBuffers(v.texture, entry, instanceBinding(viewMaterial(v, mesh), inst))
+          if (entry !== undefined) setDrawBuffers(v.texture, entry, { buffers: [...bufs.buffers, ...instanceBinding(viewMaterial(v, mesh), inst)] })
         }
       }
     },
-    _setStyle(mesh) {
+    _setMorphTexture(mesh) {
+      // The replaced population texture goes to every morphing entry of
+      // the mesh (its own, a morphed shadow stand-in's); the caller
+      // destroys the old texture after this.
+      let weights = mesh._instances?.morph?.texture
+      if (weights === undefined || mesh._buffers === null || disposed) return
+      if (mesh._entry !== null && mesh.material.morphed === true) setDrawTextures(texture, mesh._entry, { uMorphWeights: weights })
+      for (let v of views) {
+        let entry = v.entries.get(mesh)
+        if (entry !== undefined && viewMaterial(v, mesh).morphed === true) setDrawTextures(v.texture, entry, { uMorphWeights: weights })
+      }
+    },
+    _setRange(mesh) {
+      // The index range travels to every entry of the mesh; the instance
+      // count (the core's visibility switch) is not in the update, so it
+      // keeps whatever the core last wrote.
+      if (mesh._buffers === null || disposed) return
+      let range = meshRange(mesh)
+      if (mesh._entry !== null) setDrawRange(texture, mesh._entry, range)
+      for (let v of views) {
+        let entry = v.entries.get(mesh)
+        if (entry !== undefined) setDrawRange(v.texture, entry, range)
+      }
+    },
+    _setRecords(mesh) {
       if (disposed || mesh._buffers === null) return
-      styleDirty.add(mesh)
+      recordsDirty.add(mesh)
       this._schedule()
     },
     _reorder() {
@@ -1783,11 +2136,25 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       }
       this._schedule()
     },
+    _bindLod(node) {
+      if (disposed || node._node === null) return
+      let config = node._lod
+      let levels: { node?: NodeId; size: number }[] = []
+      if (config !== null) {
+        for (let l of config.levels) {
+          if (l.node === null) levels.push({ size: l.size })
+          else if (l.node._node !== null) levels.push({ node: l.node._node, size: l.size })
+        }
+      }
+      spatial.setLod(node._node, levels, config?.fade ?? 0, texture)
+      this._schedule()
+    },
   }
 
   let root = makeNode("group")
   root._scene = hooks
   root._node = spatial.createNode(fillTransform(root), true)
+  if (opts?.stagger !== undefined) setTransition(root, { stagger: opts.stagger })
   // The first light rewrite seeds the (empty) light set and the shadow
   // slots - placeholders, no casts - so receivers draw plain from the
   // first frame.
@@ -1798,8 +2165,37 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // pointer walk scene-pointer.ts runs behind scene.handlers.
   let listeners = new Set<ScenePointerListener>()
 
+  // The raycast every pick shares: `target` names the draw target whose
+  // LOD levels the query sees (the scene's own, or a view's).
+  let raycastAs = (target: TextureId, origin: Vec3, direction: Vec3, rayOpts: QueryOptions | undefined): Hit[] => {
+    // Flush pending writes: picking sees the tree as the app just wrote
+    // it, the same immediacy contract as lookAt()/project(). (The queued
+    // microtask still runs and finds nothing dirty - harmless.)
+    if (scheduled) sync()
+    if (disposed) return []
+    let f = queryFilter(rayOpts, "raycast", target)
+    let hits: Hit[] = []
+    rayOriginScratch[0] = origin[0]
+    rayOriginScratch[1] = origin[1]
+    rayOriginScratch[2] = origin[2]
+    rayDirScratch[0] = direction[0]
+    rayDirScratch[1] = direction[1]
+    rayDirScratch[2] = direction[2]
+    for (let h of spatial.raycast(rayOriginScratch, rayDirScratch, f)) {
+      let leaf = leafOf(h.node)
+      if (leaf === null) continue
+      let hit: Hit = { mesh: leaf.mesh, distance: h.distance, point: h.point, normal: h.normal }
+      if (leaf.instance !== null) hit.instance = leaf.instance
+      if (h.face !== undefined) hit.face = h.face
+      if (h.uv !== undefined) hit.uv = h.uv
+      hits.push(hit)
+    }
+    return hits
+  }
+
   let scene: Scene = {
-    texture,
+    texture: resolve.target,
+    hdrTexture: texture,
     depthTexture: depthMode === "texture" ? depthTexture(texture) : null,
     root,
     setCamera(update) {
@@ -1812,24 +2208,35 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       width = w
       height = h
       setTargetSize(texture, w, h)
+      resizeResolve(resolve, w, h)
       camera.dirty = true
       hooks._schedule()
     },
+    size: () => ({ width, height }),
     setParams(params) {
       if (disposed) return
       Object.assign(sceneParams, params)
       setTargetParams(texture, params)
+      setTargetParams(resolve.target, params)
       for (let v of views) {
         // A view's own names (view.setParams, its fog) win over the
         // scene-wide fan-out.
         let fanned = v.ownNames.size === 0 ? params : withoutNames(params, v.ownNames)
         if (fanned !== params && Object.keys(fanned).length === 0) continue
         setTargetParams(v.texture, fanned)
+        if (v.resolve !== null) setTargetParams(v.resolve.target, fanned)
       }
     },
     setFog(fog) {
       scene.setParams(fogParams(fog))
     },
+    setLodBias(bias) {
+      if (!(bias > 0 && Number.isFinite(bias))) throw new Error("scene.setLodBias: bias must be a positive number, got " + bias)
+      if (disposed || bias === lodBias) return
+      lodBias = bias
+      lodBiasDirty = true
+      hooks._schedule()
+    },
     setLayers(mask) {
       checkMask(mask, "scene.setLayers")
       if (disposed || sceneMask === mask) return
@@ -1872,7 +2279,6 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
         background = null
       }
       if (source === null) return
-      let label = opts?.label ?? "scene"
       let built = sky === null ? backgroundPipeline(source as string, label + "-background") : backgroundPipeline(SKYBOX_FRAGMENT, label + "-skybox")
       background = { pipeline: built.pipeline, program: built.program, sky, entries: new Map() }
       // First in list order on every target that draws it: inserted before
@@ -1892,13 +2298,25 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     },
     setToneMapping(mode) {
       let code = TONE_MAPPING_CODE[mode]
-      if (code === undefined) throw new Error('scene.setToneMapping: expected "none" or "aces", got ' + mode)
+      if (code === undefined) throw new Error('scene.setToneMapping: expected "none", "aces", "agx" or "neutral", got ' + mode)
       scene.setParams({ uToneMapping: code })
     },
     setExposure(exposure) {
       if (!Number.isFinite(exposure) || exposure < 0) throw new Error("scene.setExposure: expected a finite number >= 0, got " + exposure)
       scene.setParams({ uExposure: exposure })
     },
+    setResolve(r) {
+      if (disposed) return
+      replaceResolve(resolve, texture, r)
+      hooks._schedule()
+    },
+    setBloom(bloom) {
+      if (disposed) return
+      sceneBloom = bloom
+      setResolveBloom(resolve, texture, width, height, bloom)
+      for (let v of views) if (v.resolve !== null && !v.ownBloom) setResolveBloom(v.resolve, v.texture, v.width, v.height, bloom)
+      hooks._schedule()
+    },
     project(point) {
       ensureCamera(camera, width, height)
       transformPoint(clip, camera.viewProj, point)
@@ -1924,7 +2342,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     },
     pick(x, y) {
       pixelRay(x, y)
-      return scene.raycast(pickOrigin, pickDir)
+      return raycastAs(texture, pickOrigin, pickDir, undefined)
     },
     unproject(x, y, w, out = [0, 0, 0]) {
       pixelRay(x, y)
@@ -1941,29 +2359,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       }
     },
     raycast(origin, direction, rayOpts) {
-      // Flush pending writes: picking sees the tree as the app just wrote
-      // it, the same immediacy contract as lookAt()/project(). (The queued
-      // microtask still runs and finds nothing dirty - harmless.)
-      if (scheduled) sync()
-      if (disposed) return []
-      let f = queryFilter(rayOpts, "raycast")
-      let hits: Hit[] = []
-      rayOriginScratch[0] = origin[0]
-      rayOriginScratch[1] = origin[1]
-      rayOriginScratch[2] = origin[2]
-      rayDirScratch[0] = direction[0]
-      rayDirScratch[1] = direction[1]
-      rayDirScratch[2] = direction[2]
-      for (let h of spatial.raycast(rayOriginScratch, rayDirScratch, f)) {
-        let leaf = leafOf(h.node)
-        if (leaf === null) continue
-        let hit: Hit = { mesh: leaf.mesh, distance: h.distance, point: h.point, normal: h.normal }
-        if (leaf.instance !== null) hit.instance = leaf.instance
-        if (h.face !== undefined) hit.face = h.face
-        if (h.uv !== undefined) hit.uv = h.uv
-        hits.push(hit)
-      }
-      return hits
+      return raycastAs(texture, origin, direction, rayOpts)
     },
     overlap(volume, qopts) {
       if (scheduled) sync()
@@ -2030,7 +2426,8 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       // dispatch with its own capture and hover bookkeeping.
       let viewListeners = new Set<ScenePointerListener>()
       let handle: ViewHandle = {
-        texture: v.texture,
+        texture: v.resolve !== null ? v.resolve.target : v.texture,
+        hdrTexture: v.resolve !== null ? v.texture : null,
         depthTexture: vopts.depth === "texture" && vopts.into === undefined ? depthTexture(v.texture) : null,
         setCamera(update) {
           updateCamera(v.camera, update)
@@ -2042,9 +2439,24 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
           v.width = w
           v.height = h
           setTargetSize(v.texture, w, h)
+          if (v.resolve !== null) resizeResolve(v.resolve, w, h)
           v.camera.dirty = true
           hooks._schedule()
         },
+        size: () => ({ width: v.width, height: v.height }),
+        setResolve(r) {
+          if (v.resolve === null) throw new Error("view.setResolve: a tiled view has no resolve of its own - resolve the atlas")
+          if (v.disposed) return
+          replaceResolve(v.resolve, v.texture, r)
+          hooks._schedule()
+        },
+        setBloom(bloom) {
+          if (v.resolve === null) throw new Error("view.setBloom: a tiled view has no resolve to bloom on - resolve the atlas")
+          if (v.disposed) return
+          v.ownBloom = true
+          setResolveBloom(v.resolve, v.texture, v.width, v.height, bloom)
+          hooks._schedule()
+        },
         setRect(rect) {
           if (v.disposed) return
           setTargetRect(v.texture, rect)
@@ -2058,6 +2470,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
           if (v.disposed) return
           for (let k of Object.keys(params)) v.ownNames.add(k)
           setTargetParams(v.texture, params)
+          if (v.resolve !== null) setTargetParams(v.resolve.target, params)
         },
         setLayers(mask) {
           checkMask(mask, "view.setLayers")
@@ -2072,7 +2485,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
         pick(x, y) {
           if (v.disposed) return []
           pixelRayOf(v.camera, v.width, v.height, x, y)
-          return scene.raycast(pickOrigin, pickDir)
+          return raycastAs(v.texture, pickOrigin, pickDir, undefined)
         },
         get handlers() {
           return viewPointer.handlers
@@ -2110,7 +2523,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       if (!Number.isInteger(size) || size < 1) throw new Error("scene.bakeBackground: size must be a positive integer, got " + size)
       // A probe that sees no mesh (mask 0) draws the background alone: the
       // same face cameras, linear output and prefilter as any probe.
-      let probe = makeProbe({ position: [0, 0, 0], size, label: (opts?.label ?? "scene") + "-sky" }, 0)
+      let probe = makeProbe({ position: [0, 0, 0], size, label: label + "-sky" }, 0)
       probe.update()
       return probe.finish()
     },
@@ -2122,6 +2535,9 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       // the scene (entries' geometry-buffer references and pick leaves
       // dropped, core nodes freed), so a disposed scene leaves no
       // bookkeeping behind and the JS tree survives as plain data.
+      // Destroyed nodes still animating out are no longer in the tree:
+      // they free on the spot first.
+      freeLeaving((_, s) => s === hooks)
       for (let c of root.children.slice()) leaveScene(c)
       root._scene = null
       if (root._node !== null) {
@@ -2129,9 +2545,11 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
         root._node = null
       }
       spatial.setFrustum(texture, null)
+      spatial.setLodView(texture, null)
       // Drain the zeroed direction slots the teardown queued while the
       // targets still exist; afterwards their groups are gone.
       spatial.flush()
+      disposeResolve(resolve)
       destroyTexture(texture)
       for (let v of views.slice()) disposeView(v)
       shadowSys.dispose()
@@ -2170,12 +2588,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       )
       v.camera.mirror = true
       updateCamera(v.camera, { fov: PROBE_FOV, near: popts.near, far: popts.far })
-      // The faces hold LINEAR radiance, untouched by the scene's output
-      // stage: no sRGB encode, no tone mapping, unit exposure - the
-      // probe's own names, so the scene's fan-out leaves them alone.
-      for (let k of Object.keys(LINEAR_OUTPUT)) v.ownNames.add(k)
-      setTargetParams(v.texture, LINEAR_OUTPUT)
-      let chain = prefilter ? createPrefilter(size, v.texture, probeFormat(), (popts.label ?? (opts?.label ?? "scene") + "-probe") + "-chain") : null
+      let chain = prefilter ? createPrefilter(size, v.texture, bufferFormat(), (popts.label ?? label + "-probe") + "-chain") : null
       v.probeCube = chain?.cube ?? v.texture
       let position: Vec3 = [popts.position[0], popts.position[1], popts.position[2]]
       return {
@@ -2196,6 +2609,13 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
           chain?.run()
         },
         dispose() {
+          if (v.disposed) return
+          // The scene may sample this very cube - `environment={{ cube }}`,
+          // a skybox `background` - so those drop first: a subtree that
+          // owned the environment leaves the scene unlit by it, never
+          // sampling a destroyed texture until something re-bakes.
+          if (environment === v.probeCube) scene.setEnvironment(null)
+          if (background !== null && background.sky !== null && background.sky.cube === v.probeCube) scene.setBackground(null)
           chain?.dispose()
           disposeView(v)
         },
@@ -2215,12 +2635,12 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
   // Likewise the environment set starts at "none" (uEnvOn 0), so a
   // reflective material has coverage before setEnvironment.
   scene.setParams(environmentParams(null))
-  // And the output stage at its defaults (exposure 1, no tone mapping),
-  // which every library fragment declares.
-  scene.setParams({ uExposure: 1, uToneMapping: TONE_MAPPING_CODE.none, uOutputEncode: 1 })
+  // And the resolve at its defaults (exposure 1, no tone mapping).
+  scene.setParams({ uExposure: 1, uToneMapping: TONE_MAPPING_CODE.none })
   if (opts?.fog !== undefined) scene.setFog(opts.fog)
   if (opts?.toneMapping !== undefined) scene.setToneMapping(opts.toneMapping)
   if (opts?.exposure !== undefined) scene.setExposure(opts.exposure)
+  if (opts?.bloom !== undefined) scene.setBloom(opts.bloom)
   if (opts?.background !== undefined) scene.setBackground(opts.background)
   if (opts?.environment !== undefined) scene.setEnvironment(opts.environment)
   if (opts?.autoFree !== false && getOwner()) onCleanup(() => scene.dispose())