@solidrt/3d 0.0.57 → 0.0.59

package/src/material.ts

@@ -33,7 +33,7 @@ import type {
   BlendMode,
   CullMode,
   ProgramId,
-  InstanceAttribute,
+  VertexBufferLayout,
   RenderPipelineId,
   ShaderParams,
   TextureBindings,
@@ -41,14 +41,15 @@ import type {
   Topology,
   VertexAttribute,
 } from "@solidrt/core/gpu"
-import { layoutAttributes, layoutKey, layoutSlot } from "./geometry.ts"
+import { formatFeeds, geometryKey, geometryLayouts, geometrySlot, VERTEX_FORMATS } from "./geometry.ts"
+import type { Geometry } from "./geometry.ts"
 import type { VertexLayout } from "./geometry.ts"
-import { linearColor } from "./color.ts"
+import { linearColor, premultipliedColor } from "./color.ts"
 import {
   INSTANCE_COLOR_ATTRIBUTES,
   INSTANCE_MATRIX,
   INSTANCE_MATRIX_ATTRIBUTES,
-  litFragment,
+  phongFragment,
   litShadowFragment,
   litVertex,
   SKIN_DECLS,
@@ -59,13 +60,16 @@ import {
   unlitFragment,
   unlitShadowFragment,
   unlitVertex,
-  OUTPUT,
+  resolveFragment,
+  MORPH_APPLY_POSITION,
+  MORPH_DECLS,
 } from "./glsl.ts"
 
 export type Material = {
-  /** The pipeline this material draws with for geometry of `layout`
-   * (lazily created, one per layout met). */
-  pipeline(layout: VertexLayout | undefined): RenderPipelineId
+  /** The pipeline this material draws with for geometry of `layout` and
+   * `topology` (lazily created, one per pair met): the geometry says what
+   * its indices are, the material draws them that way. */
+  pipeline(geometry: Geometry, topology: Topology): RenderPipelineId
   /** Per-entry uniform values this material contributes at addDraw. */
   params: ShaderParams
   /** Per-entry sampler bindings, when the material samples textures. */
@@ -81,20 +85,23 @@ export type Material = {
    * channels in the geometry are fine (inactive attributes keep the
    * stride). */
   attributes(): VertexAttribute[]
-  /** True when the pipeline blends over (blend "alpha", depthWrite off):
+  /** True when the pipeline blends over (its `blend`, "alpha" by default,
+   * with depthWrite off):
    * the scene draws this material's meshes after every opaque one, sorted
    * back-to-front by mesh origin, and re-sorts them when the camera moves. */
   transparent?: boolean
-  /** Per-instance attributes, when the material's pipeline declares them
-   * (shaderMaterialClass's `instanceAttributes`; the stock materials'
-   * `instanced`). Such a material draws populated meshes only - an
-   * instanced mesh binds slot 0 to the core-written matrix records and
-   * slot 1 to its app-written style records, a record mesh binds slot 0
-   * to its records - and createMesh meshes are rejected at add(). */
-  instanceAttributes?: InstanceAttribute[]
-  /** The style record (the slot-1 attributes' floats, in order) every
-   * fresh instance of an instanced mesh starts with; absent = zeros.
-   * White for the stock materials' `instanceColors`. */
+  /** The instance buffers, when the material's pipeline declares them
+   * (shaderMaterialClass's `instanceBuffers`; the stock materials'
+   * `instanced`), one layout per buffer after the geometry's. Such a
+   * material draws populated meshes only - an instanced mesh binds the
+   * first to the core-written matrix records and the second to its
+   * app-written style records, a record mesh binds the first to its
+   * records - and createMesh meshes are rejected at add(). */
+  instanceBuffers?: VertexBufferLayout[]
+  /** The style record (one value per component of the second instance
+   * buffer's attributes, in order) every fresh instance of an instanced
+   * mesh starts with; absent = zeros. White for the stock materials'
+   * `instanceColors`. */
   instanceStyle?: ArrayLike<number>
   /** What a shadow view draws this material's meshes with instead of its
    * default depth override: the depth pass culling the side this material
@@ -114,23 +121,28 @@ export type Material = {
    * so a shadow or override entry for a skinned mesh merges the mesh's
    * own uBones binding even though this material is not the mesh's. */
   skinned?: boolean
+  /** True when the vertex stage declares `uMorphs` (read from the source,
+   * like skinned): the program morphs by the geometry's packed targets
+   * and the mesh's weights row, so a shadow or override entry for a
+   * morphed mesh merges the mesh's morph bindings and params even though
+   * this material is not the mesh's. */
+  morphed?: boolean
+  /** True when the fragment stage declares `uLodFade` (read from the
+   * source, like normalMatrix): the scene then writes the LOD cross-fade
+   * band to entries drawn with this material (every stock material; a
+   * custom class composes LOD_FADE from `@solidrt/3d/glsl`). Without it
+   * an entry under a fading LOD level switches hard at the band's
+   * midpoint. */
+  lodFade?: boolean
   /** Present on materials that own their pipeline (shaderMaterial). */
   dispose?(): void
 }
 
 // One shaderMaterialClass per unlit option combination (map x transparent
-// x cull x alphaTest), cached for the app's lifetime like lit's; one
+// x cull x alphaTest), cached for the app's lifetime like phong's; one
 // pipeline per vertex layout inside each.
 let unlitClasses = new Map<string, ShaderMaterialClass>()
 
-// The uColor a color option compiles to: sRGB decoded to linear light,
-// then premultiplied by its alpha (the target's contract).
-function colorParam(color: readonly number[]): number[] {
-  let a = color.length === 4 ? color[3]! : 1
-  let c = linearColor(color)
-  return [c[0]! * a, c[1]! * a, c[2]! * a, a]
-}
-
 export type UnlitOptions = {
   /** Straight [r, g, b] or [r, g, b, a], 0..1, sRGB - a color picker's
    * values. The library decodes it to linear light for shading and the
@@ -143,16 +155,28 @@ export type UnlitOptions = {
    * linear light like `color`; a plain rgba8 map reads as linear data and
    * shows washed out. */
   map?: TextureId
+  /** Multiply the base by the geometry's per-vertex aColor - the "colored"
+   * layout: withColors geometry, a gridHelper or axesHelper (add() throws
+   * without the channel). Three's vertexColors, Godot's
+   * vertex_color_use_as_albedo. */
+  vertexColors?: boolean
   /** Blend over what is behind (color alpha and map alpha both count).
-   * Without it an alpha below 1 still draws opaque. See Material.transparent. */
+   * Without it an alpha below 1 still draws opaque. See Material.transparent.
+   * Implied by any `blend` but "none". */
   transparent?: boolean
+  /** The blend factors of a transparent draw, "alpha" when absent
+   * (Three's blending, Godot's blend_mode): "add" for glows and additive
+   * particles, "multiply" to darken. Any mode but "none" makes the
+   * material transparent - drawn after the opaques, depthWrite off -
+   * unless `transparent: false` says otherwise, the shaderMaterial rule. */
+  blend?: BlendMode
   /** Which faces to drop; default "back". "none" draws both sides of
    * single-layer geometry (foliage cards, glass, a mirrored part), and
    * lit materials then light a back face with its normal flipped, as
    * Three's DoubleSide and Godot's CULL_DISABLED do. */
   cull?: CullMode
-  /** Cutout: drop a fragment whose final alpha (color x map, and for lit
-   * the vertex color too) is below this, 0..1 (Three's alphaTest, glTF
+  /** Cutout: drop a fragment whose final alpha (color x map, and the
+   * vertex color under vertexColors) is below this, 0..1 (Three's alphaTest, glTF
    * alphaMode MASK with its alphaCutoff). Opaque otherwise:
    * depth-written, not sorted, unlike `transparent`. Foliage cards and
    * fences want it with `cull: "none"`; a mapped cutout casts its cutout
@@ -182,6 +206,15 @@ export type UnlitOptions = {
    * the spatial flush writes it from the joints). The shadow variants
    * (depth and cutout) skin the same way, so a caster casts its pose. */
   skinned?: boolean
+  /** Displace positions (and lit normals) by the geometry's morph targets
+   * (`geometry.morphs` - a glTF's blend shapes, or withMorphTargets)
+   * weighted by the mesh's morph owner (setMorphWeights, a clip's weights
+   * track): the vertex stage walks each vertex's packed entries before
+   * any skinning. The material then requires geometry carrying targets
+   * (a mesh without is rejected at add()); the shadow variants morph the
+   * same way, so a caster casts its shape. Picking and the transparent
+   * sort see the base shape, like skinning. */
+  morph?: boolean
   /** Draw instanced meshes (createInstancedMesh / `<InstancedMesh>`):
    * the vertex stage places each copy by its instance matrix under the
    * mesh's uModel, and the material declares INSTANCE_MATRIX_ATTRIBUTES,
@@ -199,11 +232,20 @@ export type UnlitOptions = {
   instanceColors?: boolean
 }
 
-// The instance attributes a stock instanced material declares: the
-// matrix always, the color record beside it under instanceColors.
-function stockInstanceAttributes(instanced: boolean, instanceColors: boolean): InstanceAttribute[] | undefined {
+// The fog an unlit program composes: none when opted out, the additive
+// form (fading toward black, see FOG) for an additive blend, else the
+// scene's fog.
+function fogForm(fog: boolean | undefined, blend: BlendMode | undefined): boolean | "additive" {
+  if (fog === false) return false
+  return blend === "add" ? "additive" : true
+}
+
+// The instance buffers a stock instanced material declares: the matrix
+// record always, the color record beside it under instanceColors.
+function stockInstanceBuffers(instanced: boolean, instanceColors: boolean): VertexBufferLayout[] | undefined {
   if (!instanced) return undefined
-  return instanceColors ? [...INSTANCE_MATRIX_ATTRIBUTES, ...INSTANCE_COLOR_ATTRIBUTES] : INSTANCE_MATRIX_ATTRIBUTES
+  let matrix = { attributes: INSTANCE_MATRIX_ATTRIBUTES }
+  return instanceColors ? [matrix, { attributes: INSTANCE_COLOR_ATTRIBUTES }] : [matrix]
 }
 // A fresh instance's color: white, the multiplicative identity, so an
 // instance never written shows the material's own color (Godot's default;
@@ -219,32 +261,36 @@ function mapTransformParam(t: { offset?: [number, number]; repeat?: [number, num
 }
 
 /**
- * An unlit material: flat color, textured when `map` is given. Unlit is
- * the complete v1 set - lit materials arrive with uniform arrays (the
- * light list); see the scene-graph research note.
+ * An unlit material: flat color, textured when `map` is given; lines,
+ * the debug helpers and additive glows (`blend: "add"`) all draw with
+ * it.
  */
 export function unlit(opts: UnlitOptions = {}): Material {
-  let uColor = colorParam(opts.color ?? [1, 1, 1])
+  let uColor = premultipliedColor(opts.color ?? [1, 1, 1])
   let map = opts.map !== undefined
-  let transparent = opts.transparent === true
+  let blend = opts.blend
+  let transparent = opts.transparent ?? (blend !== undefined && blend !== "none")
   let cull = opts.cull ?? "back"
   let alphaTest = opts.alphaTest !== undefined
-  let fog = opts.fog !== false
+  let fog = fogForm(opts.fog, blend)
   let mapTransform = opts.mapTransform !== undefined
   let skinned = opts.skinned === true
+  let morph = opts.morph === true
   let instanceColors = opts.instanceColors === true
   let instanced = opts.instanced === true || instanceColors
+  let vertexColors = opts.vertexColors === true
   if (mapTransform && !map) throw new Error("unlit: mapTransform without a map to transform")
-  let key = [map, transparent, cull, alphaTest, fog, mapTransform, skinned, instanced, instanceColors].join("|")
+  let key = [map, vertexColors, transparent, blend, cull, alphaTest, fog, mapTransform, skinned, instanced, instanceColors, morph].join("|")
   let cls = unlitClasses.get(key)
   if (cls === undefined) {
     cls = shaderMaterialClass({
-      vertex: unlitVertex({ skinned, instanced, instanceColors }),
-      fragment: unlitFragment({ map, alphaTest, transparent, fog, mapTransform, instanceColors }),
-      shadowVertex: instanced ? shadowDepthVertex(skinned, true) : undefined,
-      instanceAttributes: stockInstanceAttributes(instanced, instanceColors),
+      vertex: unlitVertex({ vertexColors, skinned, instanced, instanceColors, morph }),
+      fragment: unlitFragment({ map, vertexColors, alphaTest, transparent, fog, mapTransform, instanceColors }),
+      shadowVertex: instanced ? shadowDepthVertex(skinned, true, morph) : undefined,
+      instanceBuffers: stockInstanceBuffers(instanced, instanceColors),
       instanceStyle: instanceColors ? INSTANCE_COLOR_DEFAULT : undefined,
       transparent,
+      blend,
       cull,
       label: "scene-unlit-" + key,
     })
@@ -258,19 +304,15 @@ export function unlit(opts: UnlitOptions = {}): Material {
     textures: map ? { uMap: opts.map! } : undefined,
     shadow:
       alphaTest && map
-        ? unlitShadowMaterial(shadowCull(cull), skinned, instanced, instanceColors, uColor, opts.alphaTest!, opts.map!, mapTransform ? params.uMapTransform as number[] : undefined)
+        ? unlitShadowMaterial(shadowCull(cull), vertexColors, skinned, instanced, instanceColors, morph, uColor, opts.alphaTest!, opts.map!, mapTransform ? params.uMapTransform as number[] : undefined)
         : undefined,
   })
 }
 
+/** The options every lit material takes, `phong` and `standard` alike:
+ * unlit's plus the surface maps, emission, baked light and shadow
+ * receipt the light loop reads. */
 export type LitOptions = UnlitOptions & {
-  /** Multiply the base by the geometry's per-vertex aColor (withColors
-   * geometry; add() throws without it). */
-  vertexColors?: boolean
-  /** Blinn-Phong highlight strength, 0..1 (default 0: pure diffuse). */
-  specular?: number
-  /** Highlight tightness, wide sheen (~8) to mirror dot (~150); default 30. */
-  shininess?: number
   /** Sample `map` by WORLD position instead of UV - the value is the
    * texture repeats per world unit - blended across the three axis planes
    * by the normal. Tiles generated geometry at one density regardless of
@@ -305,21 +347,6 @@ export type LitOptions = UnlitOptions & {
    * nitro glow baked into one map. Sampled at the same uv as `map`;
    * create it with `format: "rgba8-srgb"` like `map`. */
   emissiveMap?: TextureId
-  /** A texture whose RED channel scales `specular` per fragment (Three's
-   * specularMap) - chrome and rubber on one mesh. With it, `specular`
-   * defaults to 1 (the map is the strength). */
-  specularMap?: TextureId
-  /** Mirror the scene's environment (scene.setEnvironment), 0..1: the
-   * face-on reflection weight, rising to 1 at grazing angles (Schlick) -
-   * 1 is chrome, ~0.05 a glossy dielectric with rim reflections. The
-   * reflection blurs with `shininess` (a wide sheen reflects a blurred
-   * sky, a mirror dot a sharp one; the environment cube needs mipmaps
-   * for the blur) and `specularMap`'s red scales it like `specular`.
-   * Three's Phong `reflectivity` with MixOperation and a fresnel weight
-   * (Three's default MultiplyOperation tints instead; not offered). Off
-   * while the scene has no environment. Undefined declares no
-   * environment sampler at all. */
-  reflectivity?: number
   /** A baked-light texture (an offline render, an AO+GI bake), sampled by
    * the geometry's aUV2 channel and ADDED to the light sum like the
    * hemisphere term - a fully baked scene runs with no lights at all
@@ -344,10 +371,34 @@ export type LitOptions = UnlitOptions & {
   receiveShadow?: boolean
 }
 
-// The lit program is built by litFragment in ./glsl - the same builder an
-// app calls to get a lit material with its own GLSL in it, composed from
+/** `phong`'s options: the lit set plus the Blinn-Phong highlight and the
+ * environment mirror. */
+export type PhongOptions = LitOptions & {
+  /** Blinn-Phong highlight strength, 0..1 (default 0: pure diffuse). */
+  specular?: number
+  /** Highlight tightness, wide sheen (~8) to mirror dot (~150); default 30. */
+  shininess?: number
+  /** A texture whose RED channel scales `specular` per fragment (Three's
+   * specularMap) - chrome and rubber on one mesh. With it, `specular`
+   * defaults to 1 (the map is the strength). */
+  specularMap?: TextureId
+  /** Mirror the scene's environment (scene.setEnvironment), 0..1: the
+   * face-on reflection weight, rising to 1 at grazing angles (Schlick) -
+   * 1 is chrome, ~0.05 a glossy dielectric with rim reflections. The
+   * reflection blurs with `shininess` (a wide sheen reflects a blurred
+   * sky, a mirror dot a sharp one; the environment cube needs mipmaps
+   * for the blur) and `specularMap`'s red scales it like `specular`.
+   * Three's Phong `reflectivity` with MixOperation and a fresnel weight
+   * (Three's default MultiplyOperation tints instead; not offered). Off
+   * while the scene has no environment. Undefined declares no
+   * environment sampler at all. */
+  reflectivity?: number
+}
+
+// The phong program is built by phongFragment in ./glsl - the same builder an
+// app calls to get a Blinn-Phong material with its own GLSL in it, composed from
 // the same exported constants. What varies per flag: map x vertexColors x
-// triplanar x receiveShadow x transparent x cull (a class that shows back
+// triplanar x receiveShadow x transparent x blend x cull (a class that shows back
 // faces lights them with the normal flipped, else a double-sided leaf's
 // back is black) x alphaTest (the cutoff itself is a per-entry uniform,
 // one class for every value) x fog (the scene's fog composed last, or
@@ -366,17 +417,18 @@ export type LitOptions = UnlitOptions & {
 // 0 means it does not cast; SHADOW_LOOKUP turns the index into the factor.
 // The option combination that picks a lit class: the class-cache key is
 // its values in this order, and the same object builds the program, so
-// the two cannot drift apart. `lit` fills no slot - an app that does
-// reaches for litFragment directly, and owns the class it builds.
+// the two cannot drift apart. `phong` fills no slot - an app that does
+// reaches for phongFragment directly, and owns the class it builds.
 type LitClass = {
   map: boolean
   vertexColors: boolean
   triplanar: boolean
   transparent: boolean
+  blend: BlendMode | undefined
   receiveShadow: boolean
   cull: CullMode
   alphaTest: boolean
-  fog: boolean
+  fog: boolean | "additive"
   normalMap: boolean
   emissive: boolean
   emissiveMap: boolean
@@ -387,25 +439,27 @@ type LitClass = {
   skinned: boolean
   instanced: boolean
   instanceColors: boolean
+  morph: boolean
 }
 
 function litClassKey(c: LitClass): string {
   return Object.values(c).join("|")
 }
-let litClasses = new Map<string, ShaderMaterialClass>()
+let phongClasses = new Map<string, ShaderMaterialClass>()
 
 /**
- * A lit material: hemisphere ambient plus the scene's directional lights
- * (DirectionalLight nodes), Lambert diffuse, optional
- * Blinn-Phong highlight. Same options as unlit (color, map, transparent,
- * cull, alphaTest) plus vertexColors, specular/shininess and triplanar mapping. One program
- * per option combination, one pipeline per vertex layout met, shared by
- * every instance - a thousand lit meshes still share one pipeline. No
- * lights set means black except for the hemisphere term, which also
- * starts at zero: set at least one of the two.
+ * The Blinn-Phong material (Three's MeshPhongMaterial, Unity URP's Simple
+ * Lit; Godot has no Phong): hemisphere ambient plus the scene's lights,
+ * Lambert diffuse, optional Blinn-Phong highlight. Same options as unlit
+ * (color, map, transparent, cull, alphaTest) plus vertexColors,
+ * specular/shininess and triplanar mapping. One program per option
+ * combination, one pipeline per vertex layout met, shared by every
+ * instance - a thousand phong meshes still share one pipeline. No lights
+ * set means black except for the hemisphere term, which also starts at
+ * zero: set at least one of the two.
  */
-export function lit(opts: LitOptions = {}): Material {
-  let uColor = colorParam(opts.color ?? [1, 1, 1])
+export function phong(opts: PhongOptions = {}): Material {
+  let uColor = premultipliedColor(opts.color ?? [1, 1, 1])
   let map = opts.map !== undefined
   let triplanar = map && opts.triplanar !== undefined
   let alphaTest = opts.alphaTest !== undefined
@@ -418,22 +472,23 @@ export function lit(opts: LitOptions = {}): Material {
   let lightMap = opts.lightMap !== undefined
   let mapTransform = opts.mapTransform !== undefined
   if (env && !(Number.isFinite(opts.reflectivity) && opts.reflectivity! >= 0 && opts.reflectivity! <= 1)) {
-    throw new Error("lit: reflectivity must be a number in 0..1, got " + opts.reflectivity)
+    throw new Error("phong: reflectivity must be a number in 0..1, got " + opts.reflectivity)
   }
-  if (triplanar && normalMap) throw new Error("lit: normalMap cannot combine with triplanar (normal maps sample by uv)")
-  if (triplanar && mapTransform) throw new Error("lit: mapTransform cannot combine with triplanar (its repeat is the triplanar value)")
+  if (triplanar && normalMap) throw new Error("phong: normalMap cannot combine with triplanar (normal maps sample by uv)")
+  if (triplanar && mapTransform) throw new Error("phong: mapTransform cannot combine with triplanar (its repeat is the triplanar value)")
   if (mapTransform && !map && !normalMap && !emissiveMap && !specularMap) {
-    throw new Error("lit: mapTransform without a map to transform")
+    throw new Error("phong: mapTransform without a map to transform")
   }
   let flags: LitClass = {
     map,
     vertexColors: opts.vertexColors === true,
     triplanar,
-    transparent: opts.transparent === true,
+    transparent: opts.transparent ?? (opts.blend !== undefined && opts.blend !== "none"),
+    blend: opts.blend,
     receiveShadow: opts.receiveShadow !== false,
     cull,
     alphaTest,
-    fog: opts.fog !== false,
+    fog: fogForm(opts.fog, opts.blend),
     normalMap,
     emissive,
     emissiveMap,
@@ -444,21 +499,23 @@ export function lit(opts: LitOptions = {}): Material {
     skinned: opts.skinned === true,
     instanced: opts.instanced === true || opts.instanceColors === true,
     instanceColors: opts.instanceColors === true,
+    morph: opts.morph === true,
   }
   let key = litClassKey(flags)
-  let cls = litClasses.get(key)
+  let cls = phongClasses.get(key)
   if (cls === undefined) {
     cls = shaderMaterialClass({
       vertex: litVertex(flags),
-      fragment: litFragment(flags),
-      shadowVertex: flags.instanced ? shadowDepthVertex(flags.skinned, true) : undefined,
-      instanceAttributes: stockInstanceAttributes(flags.instanced, flags.instanceColors),
+      fragment: phongFragment(flags),
+      shadowVertex: flags.instanced ? shadowDepthVertex(flags.skinned, true, flags.morph) : undefined,
+      instanceBuffers: stockInstanceBuffers(flags.instanced, flags.instanceColors),
       instanceStyle: flags.instanceColors ? INSTANCE_COLOR_DEFAULT : undefined,
       transparent: flags.transparent,
+      blend: flags.blend,
       cull,
-      label: "scene-lit-" + key,
+      label: "scene-phong-" + key,
     })
-    litClasses.set(key, cls)
+    phongClasses.set(key, cls)
   }
   let params: ShaderParams = {
     uColor,
@@ -499,7 +556,8 @@ export function lit(opts: LitOptions = {}): Material {
   return material
 }
 
-export type StandardOptions = Omit<LitOptions, "specular" | "shininess" | "specularMap" | "reflectivity"> & {
+/** `standard`'s options: the lit set plus the metalness/roughness model. */
+export type StandardOptions = LitOptions & {
   /** How metallic the surface is, 0..1 (default 0; 1 when `metalnessMap`
    * is given - the map is the value): a metal has no diffuse and
    * reflects tinted by `color`, a dielectric reflects 4% face-on.
@@ -518,10 +576,10 @@ export type StandardOptions = Omit<LitOptions, "specular" | "shininess" | "specu
   roughnessMap?: TextureId
 }
 
-// The `standard` class key: lit's minus the Blinn-Phong slots (env is
+// The `standard` class key: phong's minus the Blinn-Phong slots (env is
 // always on, the environment being intrinsic to the model) plus the two
-// packed maps. Its cutout shadow is lit's own, keyed on the shared subset
-// in lit's order, so the two materials share shadow programs.
+// packed maps. Its cutout shadow is the shared lit one, keyed on the
+// subset in phong's order, so the two materials share shadow programs.
 type StandardClass = Omit<LitClass, "specularMap" | "env"> & { metalnessMap: boolean; roughnessMap: boolean }
 
 function standardClassKey(c: StandardClass): string {
@@ -535,6 +593,7 @@ function standardShadowFlags(c: StandardClass): LitClass {
     vertexColors: c.vertexColors,
     triplanar: c.triplanar,
     transparent: c.transparent,
+    blend: c.blend,
     receiveShadow: c.receiveShadow,
     cull: c.cull,
     alphaTest: c.alphaTest,
@@ -549,6 +608,7 @@ function standardShadowFlags(c: StandardClass): LitClass {
     skinned: c.skinned,
     instanced: c.instanced,
     instanceColors: c.instanceColors,
+    morph: c.morph,
   }
 }
 
@@ -556,17 +616,17 @@ function standardShadowFlags(c: StandardClass): LitClass {
  * The metalness/roughness material, the look authored assets expect
  * (Three's MeshStandardMaterial, Godot's StandardMaterial3D, Unity's
  * Standard): the same base, maps, cutout, shadows, emissive, fog and
- * lights as `lit`, shaded with GGX specular (PBR in `@solidrt/3d/glsl`)
+ * lights as `phong`, shaded with GGX specular (PBR in `@solidrt/3d/glsl`)
  * and the scene's environment sampled ALWAYS as the split sum over its
  * mip chain - no `reflectivity` switch, the environment is intrinsic to
- * the model. Light intensities read as lit's (1 lights a white matte
+ * the model. Light intensities read as phong's (1 lights a white matte
  * surface to 1). Without an environment set a metal shows only its
  * highlights - its diffuse is zero and there is nothing to reflect, as
  * in Three and Godot - so give the scene one. One program per option
- * combination, shared by every instance, like lit.
+ * combination, shared by every instance, like phong.
  */
 export function standard(opts: StandardOptions = {}): Material {
-  let uColor = colorParam(opts.color ?? [1, 1, 1])
+  let uColor = premultipliedColor(opts.color ?? [1, 1, 1])
   let map = opts.map !== undefined
   let triplanar = map && opts.triplanar !== undefined
   let alphaTest = opts.alphaTest !== undefined
@@ -598,11 +658,12 @@ export function standard(opts: StandardOptions = {}): Material {
     map,
     vertexColors: opts.vertexColors === true,
     triplanar,
-    transparent: opts.transparent === true,
+    transparent: opts.transparent ?? (opts.blend !== undefined && opts.blend !== "none"),
+    blend: opts.blend,
     receiveShadow: opts.receiveShadow !== false,
     cull,
     alphaTest,
-    fog: opts.fog !== false,
+    fog: fogForm(opts.fog, opts.blend),
     normalMap,
     emissive,
     emissiveMap,
@@ -611,6 +672,7 @@ export function standard(opts: StandardOptions = {}): Material {
     skinned: opts.skinned === true,
     instanced: opts.instanced === true || opts.instanceColors === true,
     instanceColors: opts.instanceColors === true,
+    morph: opts.morph === true,
     metalnessMap,
     roughnessMap,
   }
@@ -620,10 +682,11 @@ export function standard(opts: StandardOptions = {}): Material {
     cls = shaderMaterialClass({
       vertex: litVertex(flags),
       fragment: standardFragment(flags),
-      shadowVertex: flags.instanced ? shadowDepthVertex(flags.skinned, true) : undefined,
-      instanceAttributes: stockInstanceAttributes(flags.instanced, flags.instanceColors),
+      shadowVertex: flags.instanced ? shadowDepthVertex(flags.skinned, true, flags.morph) : undefined,
+      instanceBuffers: stockInstanceBuffers(flags.instanced, flags.instanceColors),
       instanceStyle: flags.instanceColors ? INSTANCE_COLOR_DEFAULT : undefined,
       transparent: flags.transparent,
+      blend: flags.blend,
       cull,
       label: "scene-standard-" + key,
     })
@@ -687,7 +750,7 @@ function litShadowMaterial(
       vertex: litVertex(flags),
       fragment,
       cull: shadowCull(flags.cull),
-      instanceAttributes: stockInstanceAttributes(flags.instanced, flags.instanceColors),
+      instanceBuffers: stockInstanceBuffers(flags.instanced, flags.instanceColors),
       label: "scene-lit-shadow-" + key,
     })
     litShadowClasses.set(key, cls)
@@ -713,15 +776,18 @@ function litShadowMaterial(
 // Material.skinned); the instanced form places each copy by its instance
 // matrix, so a fleet casts where its records stand - the stock instanced
 // materials pass it as their class's shadowVertex.
-function shadowDepthVertex(skinned: boolean, instanced: boolean): string {
-  let local = skinned ? "(skin * vec4(aPos, 1.0))" : "vec4(aPos, 1.0)"
+function shadowDepthVertex(skinned: boolean, instanced: boolean, morphed = false): string {
+  let base = morphed ? "morphPos" : "aPos"
+  let local = skinned ? `(skin * vec4(${base}, 1.0))` : `vec4(${base}, 1.0)`
   return glsl`
   in vec3 aPos;
+  ${morphed ? MORPH_DECLS : ""}
   ${skinned ? SKIN_DECLS : ""}
   ${instanced ? INSTANCE_MATRIX : ""}
   uniform mat4 uModel;
   uniform mat4 uViewProj;
   void main() {
+    ${morphed ? MORPH_APPLY_POSITION : ""}
     ${skinned ? SKIN_MATRIX : ""}
     gl_Position = uViewProj * uModel * ${instanced ? `(instanceMatrix() * ${local})` : local};
   }
@@ -740,12 +806,12 @@ let shadowDepth = new Map<string, Material>()
  * per cull mode x skinned for the app, built on first use. The default,
  * "front", is the caster's back surface (see above); a material culling
  * or skinning otherwise carries its own variant as Material.shadow. */
-export function shadowDepthMaterial(cull: CullMode = "front", skinned = false): Material {
-  let key = cull + (skinned ? "|skinned" : "")
+export function shadowDepthMaterial(cull: CullMode = "front", skinned = false, morphed = false): Material {
+  let key = cull + (skinned ? "|skinned" : "") + (morphed ? "|morphed" : "")
   let material = shadowDepth.get(key)
   if (material === undefined) {
     material = shaderMaterialClass({
-      vertex: shadowDepthVertex(skinned, false),
+      vertex: shadowDepthVertex(skinned, false, morphed),
       fragment: SHADOW_DEPTH_FRAGMENT,
       cull,
       label: "scene-shadow-depth-" + key,
@@ -761,12 +827,12 @@ function shadowCull(cull: CullMode): CullMode {
   return cull === "none" ? "none" : cull === "back" ? "front" : "back"
 }
 
-/** "back" unskinned maps to the default depth material, so its variant
- * is undefined; a skinned class always needs its own (the default does
- * not skin). */
-function shadowVariant(cull: CullMode, skinned: boolean): Material | undefined {
-  if (cull === "back" && !skinned) return undefined
-  return shadowDepthMaterial(shadowCull(cull), skinned)
+/** "back" unskinned unmorphed maps to the default depth material, so its
+ * variant is undefined; a skinned or morphed class always needs its own
+ * (the default does neither). */
+function shadowVariant(cull: CullMode, skinned: boolean, morphed: boolean): Material | undefined {
+  if (cull === "back" && !skinned && !morphed) return undefined
+  return shadowDepthMaterial(shadowCull(cull), skinned, morphed)
 }
 
 let unlitShadowClasses = new Map<string, ShaderMaterialClass>()
@@ -780,24 +846,26 @@ let unlitShadowClasses = new Map<string, ShaderMaterialClass>()
  * transform). */
 function unlitShadowMaterial(
   cull: CullMode,
+  vertexColors: boolean,
   skinned: boolean,
   instanced: boolean,
   instanceColors: boolean,
+  morph: boolean,
   uColor: number[],
   uAlphaTest: number,
   uMap: TextureId,
   uMapTransform?: number[],
 ): Material {
-  let key = [cull, uMapTransform !== undefined, skinned, instanced, instanceColors].join("|")
+  let key = [cull, uMapTransform !== undefined, vertexColors, skinned, instanced, instanceColors, morph].join("|")
   let cls = unlitShadowClasses.get(key)
   if (cls === undefined) {
-    let fragment = unlitShadowFragment({ map: true, alphaTest: true, mapTransform: uMapTransform !== undefined, instanceColors })
+    let fragment = unlitShadowFragment({ map: true, vertexColors, alphaTest: true, mapTransform: uMapTransform !== undefined, instanceColors })
     if (fragment === undefined) throw new Error("unlitShadowMaterial: the cutout options cannot discard")
     cls = shaderMaterialClass({
-      vertex: unlitVertex({ skinned, instanced, instanceColors }),
+      vertex: unlitVertex({ vertexColors, skinned, instanced, instanceColors, morph }),
       fragment,
       cull,
-      instanceAttributes: stockInstanceAttributes(instanced, instanceColors),
+      instanceBuffers: stockInstanceBuffers(instanced, instanceColors),
       label: "scene-unlit-shadow-" + key,
     })
     unlitShadowClasses.set(key, cls)
@@ -809,8 +877,9 @@ function unlitShadowMaterial(
 
 /** A sprite's options: unlit's, minus instancing (the billboard stage
  * places one quad per mesh; an instanced billboard field is a custom
- * class's vertex stage). */
-export type SpriteOptions = Omit<UnlitOptions, "instanced" | "instanceColors"> & {
+ * class's vertex stage) and minus vertexColors (the quad is the stage's
+ * own, with no color channel). */
+export type SpriteOptions = Omit<UnlitOptions, "instanced" | "instanceColors" | "vertexColors"> & {
   /** Which way the quad turns to face the camera. `"full"` (default,
    * Three's Sprite): both axes follow the view, the quad is always flat
    * to the screen. `"fixed-y"` (Godot's BILLBOARD_FIXED_Y): only the yaw
@@ -883,22 +952,25 @@ let spriteClasses = new Map<string, ShaderMaterialClass>()
  */
 export function sprite(opts: SpriteOptions = {}): Material {
   // Excluded by the type and checked for a JS caller: the billboard stage
-  // has no instance placement, so the flags would otherwise be ignored.
-  if ((opts as UnlitOptions).instanced || (opts as UnlitOptions).instanceColors) {
-    throw new Error("sprite: instanced and instanceColors are not sprite options (one billboard per mesh)")
+  // has no instance placement and no vertex channel, so the flags would
+  // otherwise be ignored.
+  if ((opts as UnlitOptions).instanced || (opts as UnlitOptions).instanceColors || (opts as UnlitOptions).vertexColors) {
+    throw new Error("sprite: instanced, instanceColors and vertexColors are not sprite options (one billboard quad per mesh)")
   }
-  let uColor = colorParam(opts.color ?? [1, 1, 1])
+  let uColor = premultipliedColor(opts.color ?? [1, 1, 1])
   let map = opts.map !== undefined
+  let blend = opts.blend
   let transparent = opts.transparent !== false
   let fixedY = opts.billboard === "fixed-y"
-  let fog = opts.fog !== false
-  let key = [map, transparent, fixedY, fog].join("|")
+  let fog = fogForm(opts.fog, blend)
+  let key = [map, transparent, blend, fixedY, fog].join("|")
   let cls = spriteClasses.get(key)
   if (cls === undefined) {
     cls = shaderMaterialClass({
       vertex: fixedY ? SPRITE_FIXED_Y_VERTEX_SRC : SPRITE_VERTEX_SRC,
       fragment: unlitFragment({ map, transparent, fog }),
       transparent,
+      blend,
       cull: "none",
       label: "scene-sprite-" + key,
     })
@@ -909,11 +981,14 @@ export function sprite(opts: SpriteOptions = {}): Material {
 
 /** The attributes `material` reads that `layout` does not carry (name and
  * format) - empty when the pair is drawable. */
-export function missingAttributes(material: Material, layout: VertexLayout | undefined): VertexAttribute[] {
+export function missingAttributes(material: Material, geometry: Geometry): VertexAttribute[] {
   let missing: VertexAttribute[] = []
   for (let attr of material.attributes()) {
-    let slot = layoutSlot(layout, attr.name)
-    if (slot === null || slot.format !== attr.format) missing.push(attr)
+    // A format matches a shader `in` by component count and kind: a
+    // packed color feeds `in vec4 aColor` like a float one, byte joints
+    // feed `in uvec4 aJoints` like 32-bit ones. Any stream may carry it.
+    let slot = geometrySlot(geometry, attr.name)
+    if (slot === null || !formatFeeds(slot.format, attr.format)) missing.push(attr)
   }
   return missing
 }
@@ -952,25 +1027,25 @@ const BACKGROUND_VERTEX = glsl`
 
 // Pipeline fragments get no vUV from the engine preamble (a pipeline's
 // varyings are its own), so the background slot injects the full
-// shader-target fragment contract itself: vUV, fragColor, iResolution,
-// its own vRay, and the OUTPUT set, so a sky can end with outputColor
-// and take the scene's exposure and tone mapping.
+// shader-target fragment contract itself: vUV, fragColor, iResolution
+// and its own vRay. A sky writes linear light like every scene fragment;
+// the target's resolve exposes, tone maps and encodes it.
 const BACKGROUND_FRAGMENT_PREAMBLE =
-  "#version 300 es\nprecision highp float;\nin vec2 vUV;\nin vec3 vRay;\nout vec4 fragColor;\nuniform vec2 iResolution;\n" + OUTPUT + "\n"
+  "#version 300 es\nprecision highp float;\nin vec2 vUV;\nin vec3 vRay;\nout vec4 fragColor;\nuniform vec2 iResolution;\n"
 
 // The skybox fragment behind setBackground({ cube }): the view ray through
 // the sky's rotation (the INVERSE turn, written by skyboxParams, so the
 // sky itself turns by +rotation like a node would), then the cube lookup
-// times the intensity, through the output
-// stage (the preamble declares it) like every lit pixel. Opaque: the
-// skybox replaces the clearColor exactly as a GLSL background does.
+// times the intensity, written as linear light like every lit pixel.
+// Opaque: the skybox replaces the clearColor exactly as a GLSL
+// background does.
 export const SKYBOX_FRAGMENT = glsl`
   uniform samplerCube uSky;
   uniform float uSkyIntensity;
   uniform mat4 uSkyRotation;
   void main() {
     vec3 dir = mat3(uSkyRotation) * normalize(vRay);
-    fragColor = outputColor(texture(uSky, dir).rgb * uSkyIntensity, 1.0);
+    fragColor = vec4(max(texture(uSky, dir).rgb * uSkyIntensity, vec3(0.0)), 1.0);
   }
 `
 
@@ -991,6 +1066,35 @@ export function backgroundPipeline(fragment: string, label: string): { pipeline:
   return { pipeline, program }
 }
 
+// The resolve pass (a scene's or view's display stage): the attributeless
+// covering triangle emitting the shader-target vUV, over a fragment that
+// samples the scene buffer once and ends in resolveColor.
+const RESOLVE_VERTEX = glsl`
+  out vec2 vUV;
+  void main() {
+    vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+    vUV = p;
+    gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+  }
+`
+
+// The resolve fragment's contract, injected like the background's: the
+// shader-target names, then resolveFragment's `uScene` and RESOLVE set.
+const RESOLVE_FRAGMENT_PREAMBLE = "#version 300 es\nprecision highp float;\nin vec2 vUV;\nout vec4 fragColor;\nuniform vec2 iResolution;\n"
+
+/** A target's resolve pipeline (internal - reached via SceneOptions.resolve
+ * and scene.setResolve): depth-free, attributeless, the one entry of the
+ * resolve target. */
+export function resolvePipeline(fragment: string, label: string): { pipeline: RenderPipelineId; program: ProgramId } {
+  let vs = compileShader("vertex", RESOLVE_VERTEX, { header: true })
+  let fs = compileShader("fragment", needsHeader(fragment) ? RESOLVE_FRAGMENT_PREAMBLE + resolveFragment(fragment) : fragment, { header: false })
+  let program = linkProgram(vs, fs, { label })
+  destroyShader(vs)
+  destroyShader(fs)
+  let pipeline = createRenderPipeline(program, { label })
+  return { pipeline, program }
+}
+
 /** The class half of a shader material: sources and pipeline state, the
  * things one compiled program fixes. */
 export type ShaderMaterialClassOptions = {
@@ -1020,25 +1124,28 @@ export type ShaderMaterialClassOptions = {
   vertex: string
   fragment: string
   /**
-   * Per-instance attributes: the vertex stage reads these as `in` variables
-   * beside the layout's own, and each drawn instance gets one record from
-   * the mesh's instance buffer (interleaved floats in this order). A class
-   * with instance attributes makes INSTANCED materials: attach their meshes
-   * with createInstancedMesh or createRecordMesh, which carry the records
-   * - a createMesh mesh is rejected at add(). Each attribute's `slot`
-   * (default 0) picks the buffer: an instanced mesh binds the core's
-   * matrix records (INSTANCE_MATRIX_ATTRIBUTES, exactly) to slot 0 and
-   * the app's style records - any layout, written per instance with
-   * setInstanceStyle - to slot 1; a record mesh is slot 0 only, its
-   * records whatever the stage reads (a position/yaw/scale record beats
-   * four vec4 columns for a JS-stepped fleet, and the composed uModel
-   * still places the whole population).
+   * Instance buffers: one layout per per-instance buffer (`{ attributes
+   * }`: any vertex format, tightly packed in list order like a geometry
+   * layout; stepMode is "instance" by definition here). The vertex stage
+   * reads the attributes as `in` variables beside the geometry layout's
+   * own, and each drawn instance gets one record from each buffer. A
+   * class with instance buffers makes INSTANCED materials: attach their
+   * meshes with createInstancedMesh or createRecordMesh, which carry the
+   * records as streams - a createMesh mesh is rejected at add(). An
+   * instanced mesh binds the core's matrix records (the first buffer,
+   * INSTANCE_MATRIX_ATTRIBUTES exactly) and the app's style records (the
+   * second: any layout, written per instance with setInstanceStyle); a
+   * record mesh's buffers are all the app's, its records whatever the
+   * stage reads (a position/yaw/scale record beats four vec4 columns for
+   * a JS-stepped fleet, and the composed uModel still places the whole
+   * population). Every stream is written through instanceAttribute and
+   * published with updateRecords.
    */
-  instanceAttributes?: InstanceAttribute[]
-  /** The style record a fresh instance starts with (the slot-1
-   * attributes' floats, in order); default zeros. The identity of
-   * whatever the stage does with the record - white for a multiplied
-   * tint. */
+  instanceBuffers?: VertexBufferLayout[]
+  /** The style record a fresh instance starts with (one value per
+   * component of the second instance buffer's attributes, in order);
+   * default zeros. The identity of whatever the stage does with the
+   * record - white for a multiplied tint. */
   instanceStyle?: ArrayLike<number>
   /**
    * The class's vertex stage reduced to POSITION - the instance
@@ -1072,7 +1179,6 @@ export type ShaderMaterialClassOptions = {
   depthWrite?: boolean
   blend?: BlendMode
   cull?: CullMode
-  topology?: Topology
   label?: string
 }
 
@@ -1088,7 +1194,7 @@ export type ShaderMaterialInstanceOptions = {
    * `shadowVertex` cannot express. Default: the class's shadowVertex
    * depth material when one is declared, else the depth pass with this
    * class's cull side, skinned like the class when its vertex skins by
-   * uBones. */
+   * uBones and morphed like it when its vertex morphs by uMorphs. */
   shadow?: Material
 }
 
@@ -1139,25 +1245,48 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
   // Skinning is a vertex-stage affair like the attributes; a source that
   // mentions uBones skins by the mesh's palette texture (Material.skinned).
   let skinned = /\buBones\b/.test(opts.vertex)
+  // Morphing likewise: a source that mentions uMorphs walks the
+  // geometry's packed targets (Material.morphed).
+  let morphed = /\buMorphs\b/.test(opts.vertex)
+  // The LOD cross-fade is a fragment-stage discard (Material.lodFade).
+  let lodFade = /\buLodFade\b/.test(opts.fragment)
   let transparent = opts.transparent ?? (opts.blend !== undefined && opts.blend !== "none")
   let depth = opts.depth ?? true
   let cull = opts.cull ?? "back"
-  // An empty list declares nothing - same as absent (the engine requires an
-  // instance buffer exactly when attributes are declared).
-  let instanceAttributes = opts.instanceAttributes?.length ? opts.instanceAttributes.map(a => ({ ...a })) : undefined
-  // The shadowVertex depth pass binds the instance slots its stage reads
-  // from - the record slot always (a stage reading none of it cannot
-  // place the instances, an error here), a style slot only when the
-  // stage names one of its attributes - and declares each bound slot's
-  // whole layout, since a slot's stride is the record's (an unread
-  // attribute in a bound slot is inactive, like an extra geometry channel).
-  let shadowAttributes: InstanceAttribute[] | undefined
-  if (opts.shadowVertex !== undefined && instanceAttributes !== undefined) {
+  // An unknown format has no record stride: it would leave here intact,
+  // make a NaN stride at the mesh, and fail as an arithmetic complaint
+  // from createRecordMesh naming neither the attribute nor the format.
+  // Checked where the name is written instead. Records are tightly
+  // packed like geometry layouts; explicit strides and offsets are the
+  // engine's, reachable through core's own pipeline API.
+  for (let layout of opts.instanceBuffers ?? []) {
+    if (layout.stepMode === "vertex") throw new Error("shaderMaterial instanceBuffers are instance-step by definition; drop stepMode")
+    if (layout.arrayStride !== undefined || layout.attributes.some(a => a.offset !== undefined)) {
+      throw new Error("shaderMaterial instanceBuffers are tightly packed records; drop arrayStride and offset")
+    }
+    for (let attr of layout.attributes) {
+      if (!(attr.format in VERTEX_FORMATS)) {
+        throw new Error("shaderMaterial unknown instance attribute format '" + String(attr.format) + "' for " + attr.name + " (expected " + Object.keys(VERTEX_FORMATS).join(", ") + ")")
+      }
+    }
+  }
+  // An empty list declares nothing - same as absent (the engine requires a
+  // buffer exactly when a layout is declared).
+  let instanceBuffers = opts.instanceBuffers?.length ? opts.instanceBuffers.map(b => ({ stepMode: "instance" as const, attributes: b.attributes.map(a => ({ ...a })) })) : undefined
+  // The shadowVertex depth pass binds the instance buffers its stage reads
+  // from - the record buffer always (a stage reading none of it cannot
+  // place the instances, an error here), the style buffer only when the
+  // stage names one of its attributes - and declares each bound buffer's
+  // whole layout, since a buffer's stride is the record's (an unread
+  // attribute in a bound buffer is inactive, like an extra geometry
+  // channel).
+  let shadowBuffers: VertexBufferLayout[] | undefined
+  if (opts.shadowVertex !== undefined && instanceBuffers !== undefined) {
     let source = opts.shadowVertex
-    let named = (a: InstanceAttribute) => new RegExp("\\b" + a.name + "\\b").test(source)
-    let slots = new Set(instanceAttributes.filter(named).map(a => a.slot ?? 0))
-    if (!slots.has(0)) throw new Error("shaderMaterial shadowVertex must read the slot-0 instance attributes it places instances by")
-    shadowAttributes = instanceAttributes.filter(a => slots.has(a.slot ?? 0))
+    let named = (a: VertexAttribute) => new RegExp("\\b" + a.name + "\\b").test(source)
+    let read = instanceBuffers.map(b => b.attributes.some(named))
+    if (!read[0]) throw new Error("shaderMaterial shadowVertex must read the first instance buffer's attributes, which place the instances")
+    shadowBuffers = instanceBuffers.filter((_, i) => read[i])
   }
   // The shadowVertex depth material: one class and one shared instance,
   // built the first time a caster of this class meets a shadow view.
@@ -1170,7 +1299,7 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
         vertex: opts.shadowVertex,
         fragment: SHADOW_DEPTH_FRAGMENT,
         cull: shadowCull(cull),
-        instanceAttributes: shadowAttributes,
+        instanceBuffers: shadowBuffers,
         label: (opts.label ?? "shader-material") + "-shadow",
       })
       classShadow = shadowClass.instance()
@@ -1189,23 +1318,24 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
   }
   // What the program reads from the GEOMETRY: the engine's reflection of
   // the linked program minus the per-instance names (those come from the
-  // record buffer, declared on the pipeline beside the layout).
+  // instance buffers, declared on the pipeline after the layout).
   let attributes = (): VertexAttribute[] =>
-    programAttributes(programFor()).filter(a => !instanceAttributes?.some(i => i.name === a.name))
-  let pipelineFor = (layout: VertexLayout | undefined): RenderPipelineId => {
-    let key = layoutKey(layout)
+    programAttributes(programFor()).filter(a => !instanceBuffers?.some(b => b.attributes.some(i => i.name === a.name)))
+  let pipelineFor = (geometry: Geometry, topology: Topology): RenderPipelineId => {
+    let key = geometryKey(geometry) + "|" + topology
     let pipeline = pipelines.get(key)
     if (pipeline === undefined) {
+      // One vertex-step layout per geometry stream, the instance buffers
+      // after them.
       pipeline = createRenderPipeline(programFor(), {
-        attributes: layoutAttributes(layout),
-        instanceAttributes,
+        buffers: [...geometryLayouts(geometry).map(attributes => ({ attributes })), ...(instanceBuffers ?? [])],
         depth,
         // depthWrite needs a depth buffer, so the transparent default
         // only applies when there is one.
         depthWrite: opts.depthWrite ?? (transparent && depth ? false : undefined),
         blend: opts.blend ?? (transparent ? "alpha" : undefined),
         cull,
-        topology: opts.topology,
+        topology,
         label: opts.label,
       })
       pipelines.set(key, pipeline)
@@ -1217,9 +1347,11 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
       return {
         normalMatrix,
         skinned,
+        morphed,
+        lodFade,
         attributes,
         transparent,
-        instanceAttributes,
+        instanceBuffers,
         instanceStyle: opts.instanceStyle,
         pipeline: pipelineFor,
         params: inst.params ?? {},
@@ -1227,7 +1359,7 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
         // Lazy: the depth materials are shaderMaterialClass instances
         // themselves, so an eager variant would recurse into its own cache.
         get shadow() {
-          return inst.shadow ?? shadowFor() ?? shadowVariant(cull, skinned)
+          return inst.shadow ?? shadowFor() ?? shadowVariant(cull, skinned, morphed)
         },
       }
     },