@solidrt/3d 0.0.57 → 0.0.58

package/src/gltf.ts

@@ -1,9 +1,12 @@
 // glTF 2.0, the subset an app needs to show authored models: the scene's
 // node tree RETAINED - a node table of local TRS with parent links (matrix
 // nodes decomposed; shear dropped), vertices in NODE-LOCAL space, one part
-// per mesh primitive referencing its node - triangles with positions,
-// normals (flat ones generated when absent, per the spec), one UV set and
-// indices, and materials reduced to what lit()/unlit() draw - base color
+// per mesh primitive referencing its node - positions, normals (flat ones
+// generated when absent, per the spec, for triangles), one UV set and
+// indices in the primitive's topology (strips and fans unrolled to
+// triangle lists, a line loop closed into a strip; lines and points keep
+// theirs on the geometry), and materials reduced to what lit()/unlit()
+// draw - base color
 // factor and texture, normal map (with scale), emissive factor and map
 // (KHR_materials_emissive_strength as the intensity), double-sidedness, alpha
 // blending and masking - plus the file's animations as baked clips
@@ -19,8 +22,8 @@
 // bytes in `images`, and uploading is the engine side's job.
 //
 // Outside the subset: Draco/meshopt-compressed meshes and any other
-// required extension throw naming it; non-triangle primitives, sparse
-// accessors and morph targets (the "weights" channel path) are skipped
+// required extension throw naming it; sparse accessors and morph
+// targets (the "weights" channel path) are skipped
 // or ignored; vertex colors, tangents and further UV sets are dropped
 // (the standard layout has no slot for them yet). Skins ARE parsed:
 // joints, inverse binds, and the "skinned" vertex layout.
@@ -30,6 +33,7 @@ import { linearToSrgb } from "./color.ts"
 import type { Mat4, Quat, Vec3 } from "./math.ts"
 import { layoutStride, packGeometry, packIndices, STANDARD_FLOATS } from "./geometry.ts"
 import type { Geometry } from "./geometry.ts"
+import type { Topology } from "@solidrt/core/gpu"
 
 /** What lit()/unlit() take from a glTF material. */
 export type ModelMaterial = {
@@ -182,7 +186,39 @@ export type UriResolver = (uri: string) => Uint8Array
 const GLB_MAGIC = 0x46546c67
 const CHUNK_JSON = 0x4e4f534a
 const CHUNK_BIN = 0x004e4942
+// glTF primitive modes (the GL enum values).
+const MODE_POINTS = 0
+const MODE_LINES = 1
+const MODE_LINE_LOOP = 2
+const MODE_LINE_STRIP = 3
 const MODE_TRIANGLES = 4
+const MODE_TRIANGLE_STRIP = 5
+const MODE_TRIANGLE_FAN = 6
+
+/** A triangle strip unrolled to a list: triangle t is (t, t+1, t+2),
+ * every odd one with its last two swapped so the winding stays put. */
+function stripTriangles(strip: ArrayLike<number>): number[] {
+  let out: number[] = []
+  for (let t = 0; t + 2 < strip.length; t++) {
+    if (t % 2 === 0) out.push(strip[t]!, strip[t + 1]!, strip[t + 2]!)
+    else out.push(strip[t]!, strip[t + 2]!, strip[t + 1]!)
+  }
+  return out
+}
+
+/** A triangle fan unrolled to a list: every triangle shares the hub. */
+function fanTriangles(fan: ArrayLike<number>): number[] {
+  let out: number[] = []
+  for (let t = 1; t + 1 < fan.length; t++) out.push(fan[0]!, fan[t]!, fan[t + 1]!)
+  return out
+}
+
+/** A line loop as a strip that returns to its first vertex. */
+function closeLoop(loop: ArrayLike<number>): number[] {
+  let out = Array.from(loop)
+  if (loop.length > 0) out.push(loop[0]!)
+  return out
+}
 
 // The spec's alphaCutoff when a MASK material leaves it out.
 const GLTF_ALPHA_CUTOFF = 0.5
@@ -383,8 +419,8 @@ export function parseGltf(bytes: Uint8Array, resolve?: UriResolver): ModelData {
   let bounds = new Float32Array([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity])
 
   let emit = (prim: any, name: string, node: number, world: Mat4, skin: number | null): void => {
-    if ((prim.mode ?? MODE_TRIANGLES) !== MODE_TRIANGLES) return
     if (prim.attributes?.POSITION === undefined) return
+    let mode: number = prim.mode ?? MODE_TRIANGLES
     let pos = accessorFloats(prim.attributes.POSITION, name + " POSITION")
     if (pos.elements !== 3) throw new Error("parseGltf: " + name + " POSITION is not VEC3")
     let count = pos.count
@@ -408,17 +444,57 @@ export function parseGltf(bytes: Uint8Array, resolve?: UriResolver): ModelData {
       weights = w.data
     }
     let stride = skinned ? SKINNED_FLOATS : STANDARD_FLOATS
-    let indices: ArrayLike<number> =
+    let raw: ArrayLike<number> =
       prim.indices !== undefined ? accessorFloats(prim.indices, name + " indices").data : Array.from({ length: count }, (_, i) => i)
-    if (indices.length % 3 !== 0) throw new Error("parseGltf: " + name + " index count is not a multiple of 3")
+    // The primitive's topology, carried on the geometry. Triangle strips
+    // and fans are unrolled to lists (what the winding flip, the
+    // flat-shading un-index and the picking shape expect) and a line
+    // loop, which has no GPU topology, is closed into a strip.
+    let topology: Topology
+    let indices: ArrayLike<number>
+    switch (mode) {
+      case MODE_TRIANGLES:
+        topology = "triangles"
+        indices = raw
+        break
+      case MODE_TRIANGLE_STRIP:
+        topology = "triangles"
+        indices = stripTriangles(raw)
+        break
+      case MODE_TRIANGLE_FAN:
+        topology = "triangles"
+        indices = fanTriangles(raw)
+        break
+      case MODE_LINES:
+        topology = "lines"
+        indices = raw
+        break
+      case MODE_LINE_STRIP:
+        topology = "line-strip"
+        indices = raw
+        break
+      case MODE_LINE_LOOP:
+        topology = "line-strip"
+        indices = closeLoop(raw)
+        break
+      case MODE_POINTS:
+        topology = "points"
+        indices = raw
+        break
+      default:
+        throw new Error("parseGltf: " + name + " has an unknown primitive mode " + mode)
+    }
+    let triangles = topology === "triangles"
+    if (triangles && indices.length % 3 !== 0) throw new Error("parseGltf: " + name + " index count is not a multiple of 3")
 
     // A mirroring chain (negative world determinant at the rest pose)
     // flips the displayed winding, so the index order is flipped here to
     // compensate - cull: "back" keeps the outside. Stored normals stay the
     // authored ones: the runtime's inverse-transpose maps them outward for
     // the flipped winding. Baked from the REST pose; a scale animated
-    // across zero would unbake it, which is pathological.
-    let flip = !skinned && det3(world) < 0
+    // across zero would unbake it, which is pathological. Lines and
+    // points have no winding.
+    let flip = triangles && !skinned && det3(world) < 0
     // Joint boxes need the skin's inverse binds, and skins are built after
     // the walk (their joints are ordinary nodes the walk registers), so
     // the arrays are parked under the FILE's skin index and grown then.
@@ -426,14 +502,18 @@ export function parseGltf(bytes: Uint8Array, resolve?: UriResolver): ModelData {
 
     let vertices: Float32Array
     let packedIndices: number[]
-    if (nrm !== null) {
+    if (nrm !== null || !triangles) {
+      // Indexed as authored. Lines and points without normals get zero
+      // ones (there is no face to take one from; nothing lights them).
       vertices = new Float32Array(count * stride)
       for (let i = 0; i < count; i++) writeVertex(vertices, i, pos.data, nrm, uv, i, stride, joints, weights)
-      packedIndices = new Array(indices.length)
-      for (let i = 0; i < indices.length; i += 3) {
-        packedIndices[i] = indices[i]!
-        packedIndices[i + 1] = flip ? indices[i + 2]! : indices[i + 1]!
-        packedIndices[i + 2] = flip ? indices[i + 1]! : indices[i + 2]!
+      packedIndices = Array.from(indices)
+      if (flip) {
+        for (let i = 0; i < packedIndices.length; i += 3) {
+          let b = packedIndices[i + 1]!
+          packedIndices[i + 1] = packedIndices[i + 2]!
+          packedIndices[i + 2] = b
+        }
       }
     } else {
       // No normals: the spec asks for flat shading, which needs one vertex
@@ -508,6 +588,7 @@ export function parseGltf(bytes: Uint8Array, resolve?: UriResolver): ModelData {
     let geometry: Geometry = skinned
       ? { vertices, indices: packIndices(packedIndices, count), layout: "skinned", label: name }
       : packGeometry(vertices, packedIndices, { label: name })
+    if (!triangles) geometry.topology = topology
     parts.push({ name, node, skin, geometry, material })
   }
 

package/src/index.ts

@@ -35,7 +35,7 @@ export { linearColor, linearToSrgb, srgbToLinear } from "./color.ts"
 export type { CameraState, CameraUpdate, OrthoExtent } from "./camera.ts"
 export type { NodeTransition, NodeTransitionSpec } from "flux:spatial"
 export { disposeGeometry } from "./geometry-gpu.ts"
-export { box, circle, cone, cylinder, fillAttribute, fillColors, geometryBounds, layoutAttributes, layoutKey, layoutSlot, layoutStride, mergeGeometries, packGeometry, plane, ring, sphere, torus, torusKnot, transformGeometry, validateGeometry, withAttribute, withColors, STANDARD_FLOATS, VERTEX_LAYOUTS } from "./geometry.ts"
+export { box, circle, cone, cylinder, fillAttribute, fillColors, edgesGeometry, geometryBounds, geometryTopology, layoutAttributes, layoutKey, layoutSlot, layoutStride, mergeGeometries, packGeometry, plane, ring, sphere, torus, torusKnot, transformGeometry, validateGeometry, wireframeGeometry, withAttribute, withColors, STANDARD_FLOATS, VERTEX_LAYOUTS } from "./geometry.ts"
 export type { AttributeFill, BoxOptions, CircleOptions, ColorFill, ConeOptions, CylinderOptions, Geometry, GeometryOptions, PlaneOptions, RingOptions, SphereOptions, TorusKnotOptions, TorusOptions, VertexLayout } from "./geometry.ts"
 export { fillet, roundRect, shape, triangulate } from "./profile.ts"
 export type { Profile, ProfilePoint } from "./profile.ts"
@@ -69,6 +69,7 @@ export type { ModelChannel, ModelClip, ModelData, ModelMaterial, ModelNode, Mode
 export { decodeModel, encodeModel } from "./model-file.ts"
 export { createModel, loadGltf, loadModel } from "./model.ts"
 export type { Model, ModelMaps, ModelOptions } from "./model.ts"
+export { bindSkeleton } from "./skeleton.ts"
 export { createMixer } from "./mixer.ts"
 export type { Mixer, MixerOptions, MixerPlayOptions } from "./mixer.ts"
 export { sampleChannel } from "./clip.ts"

package/src/input.ts

@@ -31,7 +31,9 @@ export type CameraDevices = {
 export let orbitActions = { rotate: "vec2", zoom: "axis", pan: "vec2" } as const
 
 /**
- * The orbit camera's standard bindings: a drag rotates, a pinch and the
+ * The orbit camera's standard bindings: a drag rotates, a Ctrl-drag or a
+ * right-drag pans (the desktop pans, Three's and Blender's; a chorded or
+ * right-button drag feeds only `pan`, never `rotate`), a pinch and the
  * wheel zoom, two fingers pan; the right stick rotates, the triggers
  * zoom, the left stick pans; the arrow keys rotate and minus/equals zoom.
  */
@@ -39,7 +41,14 @@ export function orbitBindings(devices: CameraDevices): Binding[] {
   let out: Binding[] = []
   let { pointer, gamepad, keyboard } = devices
   if (pointer) {
-    out.push({ action: "rotate", source: pointer.drag }, { action: "zoom", source: pointer.pinch }, { action: "zoom", source: pointer.wheel }, { action: "pan", source: pointer.pan })
+    out.push(
+      { action: "rotate", source: pointer.drag },
+      { action: "pan", source: pointer.drag("Ctrl") },
+      { action: "pan", source: pointer.drag("Right") },
+      { action: "pan", source: pointer.pan },
+      { action: "zoom", source: pointer.pinch },
+      { action: "zoom", source: pointer.wheel },
+    )
   }
   if (gamepad) {
     out.push({ action: "rotate", source: invert(gamepad.rightStick) }, { action: "zoom", source: gamepad.triggers }, { action: "pan", source: invert(gamepad.leftStick) })

package/src/material.ts

@@ -41,7 +41,7 @@ import type {
   Topology,
   VertexAttribute,
 } from "@solidrt/core/gpu"
-import { layoutAttributes, layoutKey, layoutSlot } from "./geometry.ts"
+import { FORMAT_FLOATS, layoutAttributes, layoutKey, layoutSlot } from "./geometry.ts"
 import type { VertexLayout } from "./geometry.ts"
 import { linearColor } from "./color.ts"
 import {
@@ -63,9 +63,10 @@ import {
 } 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(layout: VertexLayout | undefined, topology: Topology): RenderPipelineId
   /** Per-entry uniform values this material contributes at addDraw. */
   params: ShaderParams
   /** Per-entry sampler bindings, when the material samples textures. */
@@ -1072,7 +1073,6 @@ export type ShaderMaterialClassOptions = {
   depthWrite?: boolean
   blend?: BlendMode
   cull?: CullMode
-  topology?: Topology
   label?: string
 }
 
@@ -1142,6 +1142,24 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
   let transparent = opts.transparent ?? (opts.blend !== undefined && opts.blend !== "none")
   let depth = opts.depth ?? true
   let cull = opts.cull ?? "back"
+  // Formats are the vertex vocabulary (f32/vec2/vec3/vec4), not WebGPU's
+  // spelling, and an unknown one has no float count: it would leave here
+  // intact, make a NaN record 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.
+  for (let attr of opts.instanceAttributes ?? []) {
+    if (!(attr.format in FORMAT_FLOATS)) {
+      throw new Error(
+        "shaderMaterial unknown instance attribute format '" +
+          String(attr.format) +
+          "' for " +
+          attr.name +
+          " (expected " +
+          Object.keys(FORMAT_FLOATS).join(", ") +
+          ")",
+      )
+    }
+  }
   // 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
@@ -1192,8 +1210,8 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
   // record buffer, declared on the pipeline beside 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)
+  let pipelineFor = (layout: VertexLayout | undefined, topology: Topology): RenderPipelineId => {
+    let key = layoutKey(layout) + "|" + topology
     let pipeline = pipelines.get(key)
     if (pipeline === undefined) {
       pipeline = createRenderPipeline(programFor(), {
@@ -1205,7 +1223,7 @@ export function shaderMaterialClass(opts: ShaderMaterialClassOptions): ShaderMat
         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)

package/src/mesh.ts

@@ -4,8 +4,8 @@
 // scene side is reached through the node's SceneHooks (node.ts).
 
 import { createBuffer, destroyBuffer, writeBuffer } from "@solidrt/core/gpu"
-import type { BufferId, DrawId, InstanceAttribute, ShaderParams, TextureBindings, VertexAttribute } from "@solidrt/core/gpu"
-import { geometryBounds, plane } from "./geometry.ts"
+import type { BufferId, DrawId, InstanceAttribute, ShaderParams, TextureBindings } from "@solidrt/core/gpu"
+import { FORMAT_FLOATS, geometryBounds, plane } from "./geometry.ts"
 import type { Geometry } from "./geometry.ts"
 import type { GeometryBuffers } from "./geometry-gpu.ts"
 import type { Material } from "./material.ts"
@@ -24,7 +24,8 @@ export type Mesh = SceneNode & {
   renderOrder: number
   /** Draw into the scene's shadow map (default false, Three's default).
    * Set with setCastShadow. A casting instanced mesh is skipped (the
-   * depth pass cannot know its record layout). */
+   * depth pass cannot know its record layout), and so is any geometry
+   * that is not a triangle list: lines and points cast nothing. */
   castShadow: boolean
   /** Layer membership bitmask (default 1, Three's `object.layers`): a
    * target draws the mesh when its mask intersects this. Not inherited
@@ -225,13 +226,11 @@ export function localBounds(mesh: Mesh): Float32Array | null {
   return mesh._sprite ? SPRITE_BOUNDS : geometryBounds(mesh.geometry)
 }
 
-const ATTRIBUTE_FLOATS: Record<VertexAttribute["format"], number> = { f32: 1, vec2: 2, vec3: 3, vec4: 4 }
-
 /** Floats per record of one instance slot of an attribute list (slot 0
  * by default; the list's `slot` keys pick the others). */
 export function instanceStride(attributes: InstanceAttribute[], slot = 0): number {
   let stride = 0
-  for (let a of attributes) if ((a.slot ?? 0) === slot) stride += ATTRIBUTE_FLOATS[a.format]
+  for (let a of attributes) if ((a.slot ?? 0) === slot) stride += FORMAT_FLOATS[a.format]
   return stride
 }
 

package/src/model.ts

@@ -24,6 +24,8 @@ import { add, createGroup, remove, setTransform } from "./node.ts"
 import type { SceneNode } from "./node.ts"
 import { createMesh } from "./mesh.ts"
 import type { Mesh } from "./mesh.ts"
+import { refreshJointBounds, unbindSkeleton } from "./skeleton.ts"
+import type { WornPiece } from "./skeleton.ts"
 
 /** Anisotropic filtering level for a model's textures: the engines' usual
  * default (Godot ships 2x, Unity's quality presets 2-8x) - enough to keep a
@@ -80,8 +82,30 @@ export type Model = SceneNode & {
   /** Local rest-pose [minX, minY, minZ, maxX, maxY, maxZ] over every part
    * (conservative for parts under rotated nodes). */
   bounds: Float32Array
-  /** Detach the model and free its geometry buffers and textures. */
+  /** Detach the model and free its geometry buffers and textures. A
+   * worn piece (bindSkeleton) comes off its body; a body takes the
+   * pieces it wears with it. */
   dispose(): void
+  /** @internal The skins the parts draw, in file order: the palette
+   * texture (shared by identical skins), the joint nodes in row order,
+   * their inverse binds and joint-space influence boxes. */
+  _skins: ModelSkinNodes[]
+  /** @internal The pieces bound onto this model's skeleton. */
+  _worn: WornPiece[]
+  /** @internal The body this model is bound onto, or null. */
+  _body: Model | null
+  /** @internal Subtrees bindSkeleton moved under the body's joints (no
+   * longer under this model); detached again by dispose. */
+  _grafts: SceneNode[]
+}
+
+/** @internal One skin of a built model: ModelSkin with its joints
+ * resolved to the model's nodes and its palette texture. */
+export type ModelSkinNodes = {
+  texture: TextureId
+  joints: SceneNode[]
+  inverseBind: Float32Array
+  jointBounds: Float32Array
 }
 
 /**
@@ -162,6 +186,10 @@ export function createModel(data: ModelData, opts: ModelOptions = {}): Model {
   let materials = data.materials.map((_, i) => materialFor(i, false))
 
   let model = createGroup() as Model
+  model._skins = []
+  model._worn = []
+  model._body = null
+  model._grafts = []
   // The node table is pre-order, so every parent group exists before its
   // children reference it.
   let groups: SceneNode[] = data.nodes.map((n) => {
@@ -183,39 +211,38 @@ export function createModel(data: ModelData, opts: ModelOptions = {}): Model {
   // joints move - there is no JS palette walk, and posing joints with
   // setTransform is always enough. Identical skins (same joints, same
   // inverse binds - the body/legs and LOD splits exporters produce) share
-  // one texture, so their palette is computed and uploaded once.
-  let skinTextures: TextureId[] = []
+  // one texture, so their palette is computed and uploaded once. A worn
+  // piece's rows move onto another model's joints (bindSkeleton).
   data.skins.forEach((skin, i) => {
-    let joints = skin.joints.join(",")
-    for (let j = 0; j < i; j++) {
-      let other = data.skins[j]!
-      if (
-        other.joints.join(",") === joints &&
-        other.inverseBind.length === skin.inverseBind.length &&
-        other.inverseBind.every((v, k) => v === skin.inverseBind[k])
-      ) {
-        skinTextures.push(skinTextures[j]!)
-        return
-      }
-    }
-    let texture = createMutableTexture(new Float32Array(skin.joints.length * 16), 4, skin.joints.length, {
-      format: "rgba32f",
-      autoFree: false,
-      label: label ? label + "-skin" + i : "skin" + i,
+    let joints = skin.joints.map((n) => {
+      let joint = groups[n]
+      if (joint === undefined) throw new Error("createModel: skin " + i + " names a missing node " + n)
+      return joint
     })
+    let key = skin.joints.join(",")
+    let same = model._skins.find(
+      (other, j) =>
+        data.skins[j]!.joints.join(",") === key &&
+        other.inverseBind.length === skin.inverseBind.length &&
+        other.inverseBind.every((v, k) => v === skin.inverseBind[k]),
+    )
+    let texture =
+      same?.texture ??
+      createMutableTexture(new Float32Array(skin.joints.length * 16), 4, skin.joints.length, {
+        format: "rgba32f",
+        autoFree: false,
+        label: label ? label + "-skin" + i : "skin" + i,
+      })
+    model._skins.push({ texture, joints, inverseBind: skin.inverseBind, jointBounds: skin.jointBounds })
+    if (same !== undefined) return
     textures.push(texture)
-    skinTextures.push(texture)
-    for (let j = 0; j < skin.joints.length; j++) {
-      let joint = groups[skin.joints[j]!]
-      if (joint === undefined) throw new Error("createModel: skin " + i + " names a missing node " + skin.joints[j])
+    joints.forEach((joint, j) => {
       ;(joint._palettes ??= []).push({ texture, row: j, post: skin.inverseBind.slice(j * 16, j * 16 + 16), anchor: model })
-      // The joint's influence box, in joint space: culling-only bounds the
-      // flush carries through the pose. A joint influencing nothing (an
-      // inverted box) gets none and contributes nothing to the union.
-      let jb = skin.jointBounds.subarray(j * 6, j * 6 + 6)
-      if (jb[0]! <= jb[3]! && jb[1]! <= jb[4]! && jb[2]! <= jb[5]!) joint._cullBounds = Float32Array.from(jb)
-    }
+    })
   })
+  // Each joint's influence box, in joint space: culling-only bounds the
+  // flush carries through the pose, united over every skin reaching it.
+  refreshJointBounds(model)
   model.parts = data.parts.map((part) => {
     let skinned = part.skin !== null
     let material = materialFor(part.material, skinned)
@@ -225,11 +252,11 @@ export function createModel(data: ModelData, opts: ModelOptions = {}): Model {
       // matrices place them, so its mesh hangs off the model root (the
       // spec ignores the node's transform for skinned meshes) and uModel
       // stays the model's own placement.
-      let texture = skinTextures[part.skin!]
-      if (texture === undefined) throw new Error("createModel: part '" + part.name + "' names a missing skin " + part.skin)
-      mesh._textures = { uBones: texture }
+      let skin = model._skins[part.skin!]
+      if (skin === undefined) throw new Error("createModel: part '" + part.name + "' names a missing skin " + part.skin)
+      mesh._textures = { uBones: skin.texture }
       // Culled by its joints' boxes, so the box follows the animation.
-      mesh._cullJoints = data.skins[part.skin!]!.joints.map((n) => groups[n]!)
+      mesh._cullJoints = skin.joints.slice()
       add(model, mesh)
     } else {
       let node = groups[part.node]
@@ -242,6 +269,11 @@ export function createModel(data: ModelData, opts: ModelOptions = {}): Model {
   model.clips = data.clips
   model.bounds = data.bounds
   model.dispose = () => {
+    // A worn piece comes off first (its rows sit on the body's joints);
+    // a body takes its pieces with it (their skins read joints that are
+    // about to go).
+    if (model._body !== null) unbindSkeleton(model)
+    for (let worn of model._worn.slice()) worn.piece.dispose()
     if (model.parent !== null) remove(model)
     for (let part of model.parts) disposeGeometry(part.mesh.geometry)
     for (let id of textures) destroyTexture(id)

package/src/node.ts

@@ -143,7 +143,8 @@ export type SceneNode = {
    * skin): bound to the core at every scene enter, so the flush writes
    * `inverse(anchorWorld) * world * post` - the model-local bone matrix -
    * to the palette texture's row whenever the node moves. `anchor` is the
-   * model root; null for non-joints (the common case pays one null check). */
+   * model root - the body's, for a piece bound onto its skeleton - and
+   * null for non-joints (the common case pays one null check). */
   _palettes: { texture: TextureId; row: number; post: Float32Array; anchor: SceneNode }[] | null
   /** A culling-only local box (a model joint's influence region, in joint
    * space): bound at every scene enter so the joint's world box follows

package/src/scene.ts

@@ -50,7 +50,7 @@ import { cameraParams, cameraState, ensureCamera, makeCamera, updateCamera } fro
 import type { Camera, CameraState, CameraUpdate } from "./camera.ts"
 import { makeShadowSystem } from "./scene-shadows.ts"
 import { makePointerInput } from "./scene-pointer.ts"
-import { geometryBounds, layoutKey, validateGeometry } from "./geometry.ts"
+import { geometryBounds, geometryTopology, layoutKey, 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"
@@ -1289,7 +1289,7 @@ 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), entrySeed(mesh.material, mesh._params), {
+    mesh._entry = addDraw(texture, mesh.material.pipeline(mesh.geometry.layout, geometryTopology(mesh.geometry)), entrySeed(mesh.material, mesh._params), {
       buffer: bufs.buffer,
       indexBuffer: bufs.index,
       indexFormat: bufs.indexFormat,
@@ -1319,6 +1319,9 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
     if (v.entries.has(mesh)) return
     let inst = mesh._instances
     if (v.shadowFilter !== null && !v.shadowFilter(mesh)) return
+    // Lines and points cast nothing: a one-pixel wireframe in a shadow
+    // map is speckle on the floor, never a shadow anyone wanted.
+    if (v.shadowFilter !== null && geometryTopology(mesh.geometry) !== "triangles") return
     if ((mesh.layers & v.mask) === 0) return
     let material = viewMaterial(v, mesh)
     // An override pipeline cannot know a populated mesh's record layout,
@@ -1331,7 +1334,7 @@ export function createScene(width: number, height: number, opts?: SceneOptions):
       checkInstancePairing(material, inst, "Shadow material")
     }
     let bufs = mesh._buffers!
-    let entry = addDraw(v.texture, material.pipeline(mesh.geometry.layout), entrySeed(material, v.override !== null ? null : mesh._params), {
+    let entry = addDraw(v.texture, material.pipeline(mesh.geometry.layout, geometryTopology(mesh.geometry)), entrySeed(material, v.override !== null ? null : mesh._params), {
       buffer: bufs.buffer,
       indexBuffer: bufs.index,
       indexFormat: bufs.indexFormat,