castle-web-cli 0.4.129 → 0.4.131

package/kits/physics-3d/engine3d/pxmodel.js

@@ -0,0 +1,265 @@
+// The `.pxmodel` part-based model format: parse / serialize, the three.js
+// builder, and the walk animator. See docs/pxmodel-format.md. A model is a
+// list of named primitive parts with hierarchy -- the 3d analog of `.pxart`,
+// built to be written by hand or by an agent.
+import * as THREE from 'three';
+import { makeShapeMesh, makeMaterial, artRefSignature } from './materials';
+import { buildMeshGeometry } from './meshops';
+
+const DEG = Math.PI / 180;
+
+export const PART_DEFAULTS = {
+  parent: '',
+  kind: 'box',
+  position: [0, 0, 0],
+  rotation: [0, 0, 0],
+  offset: [0, 0, 0],
+  size: [1, 1, 1],
+  radius: 0.5,
+  height: 1,
+  color: '#c7cfdd',
+  art: '',
+  artRepeat: null,
+  tint: '',
+  roughness: 0.7,
+  metalness: 0,
+  clearcoat: 0,
+  emissive: '#000000',
+  emissiveIntensity: 1,
+};
+
+const VEC3_KEYS = new Set(['position', 'rotation', 'offset', 'size']);
+
+function normalizeVec3(value, fallback) {
+  if (!Array.isArray(value)) return [...fallback];
+  return [0, 1, 2].map((i) => (Number.isFinite(value[i]) ? value[i] : fallback[i]));
+}
+
+function normalizePart(raw, index) {
+  const part = { ...PART_DEFAULTS, ...(raw ?? {}) };
+  part.id = typeof part.id === 'string' && part.id ? part.id : `part-${index + 1}`;
+  for (const key of VEC3_KEYS) part[key] = normalizeVec3(part[key], PART_DEFAULTS[key]);
+  if (part.kind === 'mesh') {
+    part.vertices = Array.isArray(part.vertices)
+      ? part.vertices.map((v) => normalizeVec3(v, [0, 0, 0]))
+      : [];
+    part.faces = Array.isArray(part.faces)
+      ? part.faces
+          .map((face) =>
+            Array.isArray(face) ? face.filter((i) => Number.isInteger(i) && i >= 0) : []
+          )
+          .filter((face) => face.length >= 3)
+      : [];
+  }
+  return part;
+}
+
+// Parse model text into { name, parts } with defaults applied, or null when
+// it isn't a model. Duplicate ids get suffixed; a parent ref that doesn't
+// resolve (or cycles) is dropped to root rather than rejected.
+export function parseModel(text) {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!json || typeof json !== 'object' || !Array.isArray(json.parts)) return null;
+  const parts = json.parts.map(normalizePart);
+  const seen = new Set();
+  for (const part of parts) {
+    while (seen.has(part.id)) part.id = `${part.id}-2`;
+    seen.add(part.id);
+  }
+  for (const part of parts) {
+    if (part.parent && !seen.has(part.parent)) part.parent = '';
+  }
+  for (const part of parts) {
+    const visited = new Set([part.id]);
+    let current = part;
+    while (current.parent) {
+      if (visited.has(current.parent)) {
+        part.parent = '';
+        break;
+      }
+      visited.add(current.parent);
+      current = parts.find((candidate) => candidate.id === current.parent) ?? { parent: '' };
+    }
+  }
+  return { name: typeof json.name === 'string' ? json.name : 'Model', parts };
+}
+
+const sameVec = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+
+// Serialize sparsely: only fields that differ from the defaults, so files stay
+// as small as what an author would write by hand.
+export function serializeModel(model) {
+  const parts = model.parts.map((part) => {
+    const out = { id: part.id };
+    if (part.parent) out.parent = part.parent;
+    if (part.kind !== 'box') out.kind = part.kind;
+    for (const key of ['position', 'rotation', 'offset']) {
+      if (!sameVec(part[key], PART_DEFAULTS[key])) out[key] = part[key];
+    }
+    if (part.kind === 'mesh') {
+      out.vertices = part.vertices;
+      out.faces = part.faces;
+    } else if (part.kind === 'box') {
+      if (!sameVec(part.size, PART_DEFAULTS.size)) out.size = part.size;
+    } else {
+      if (part.radius !== PART_DEFAULTS.radius) out.radius = part.radius;
+      if (part.kind !== 'sphere' && part.height !== PART_DEFAULTS.height) out.height = part.height;
+    }
+    for (const key of [
+      'color',
+      'art',
+      'artRepeat',
+      'tint',
+      'roughness',
+      'metalness',
+      'clearcoat',
+      'emissive',
+      'emissiveIntensity',
+    ]) {
+      const value = part[key];
+      const fallback = PART_DEFAULTS[key];
+      const differs = key === 'artRepeat' ? value != null : value !== fallback;
+      if (differs) out[key] = value;
+    }
+    return out;
+  });
+  return `${JSON.stringify({ format: 'pxmodel', name: model.name, parts }, null, 2)}\n`;
+}
+
+export const STARTER_MODEL_TEXT = serializeModel({
+  name: 'New Model',
+  parts: [normalizePart({ id: 'body', size: [1, 1, 1], position: [0, 0.5, 0] }, 0)],
+});
+
+// Bounded parse cache -- model text is re-seen constantly by signatures and
+// rebuilds; parsing is cheap but not free.
+const parseCache = new Map();
+export function parseModelCached(text) {
+  if (typeof text !== 'string') return null;
+  const cached = parseCache.get(text);
+  if (cached !== undefined) return cached;
+  if (parseCache.size > 200) parseCache.clear();
+  const model = parseModel(text);
+  parseCache.set(text, model);
+  return model;
+}
+
+// A part expressed in the Shape behavior's vocabulary, so the mesh builder is
+// shared with everything else.
+function partAsShape(part) {
+  return {
+    kind: part.kind,
+    width: part.size[0],
+    height: part.kind === 'box' ? part.size[1] : part.height,
+    depth: part.size[2],
+    radius: part.kind === 'sphere' ? part.radius : part.radius,
+    color: part.color,
+    art: part.art,
+    artRepeat: part.artRepeat,
+    tint: part.tint,
+    roughness: part.roughness,
+    metalness: part.metalness,
+    clearcoat: part.clearcoat,
+    emissive: part.emissive,
+    emissiveIntensity: part.emissiveIntensity,
+  };
+}
+
+// Build the model as a THREE.Group: one group per part at its pivot (child
+// groups nested under their parent's group), the mesh offset inside. The
+// returned group's userData.modelParts maps part id -> group.
+export function buildModelNode(model, sprites) {
+  const root = new THREE.Group();
+  const groups = new Map();
+  for (const part of model.parts) {
+    const group = new THREE.Group();
+    group.userData.partId = part.id;
+    group.position.set(part.position[0], part.position[1], part.position[2]);
+    group.rotation.set(part.rotation[0] * DEG, part.rotation[1] * DEG, part.rotation[2] * DEG);
+    let mesh;
+    if (part.kind === 'mesh') {
+      const { geometry, triFaces } = buildMeshGeometry(part);
+      mesh = new THREE.Mesh(geometry, makeMaterial(partAsShape(part), null));
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      mesh.userData.triFaces = triFaces;
+    } else {
+      mesh = makeShapeMesh(partAsShape(part), sprites);
+    }
+    mesh.userData.partMesh = part.id;
+    mesh.position.set(part.offset[0], part.offset[1], part.offset[2]);
+    group.add(mesh);
+    groups.set(part.id, group);
+  }
+  for (const part of model.parts) {
+    const parent = part.parent ? groups.get(part.parent) : null;
+    (parent ?? root).add(groups.get(part.id));
+  }
+  root.userData.modelParts = groups;
+  return root;
+}
+
+// Every art ref a model uses, for change signatures.
+export function modelArtSignature(model, sprites) {
+  if (!model) return '';
+  const refs = [];
+  for (const part of model.parts) {
+    if (typeof part.art === 'string' && part.art) refs.push(part.art);
+    else if (part.art && typeof part.art === 'object') {
+      refs.push(...Object.values(part.art).filter((ref) => typeof ref === 'string'));
+    }
+  }
+  return refs.map((ref) => artRefSignature(ref, sprites)).join('|');
+}
+
+// Walk animation by part-id convention (legL/legR/armL/armR/torso), driven by
+// observed motion: speed from position deltas, air from vertical speed, lean
+// from yaw rate. dt of 0 (editor views) holds the neutral pose.
+export function animateModelParts(entry, dt) {
+  const partGroups = entry.node.userData.modelParts;
+  if (!partGroups) return;
+  const parts = {
+    legL: partGroups.get('legL'),
+    legR: partGroups.get('legR'),
+    armL: partGroups.get('armL'),
+    armR: partGroups.get('armR'),
+    torso: partGroups.get('torso'),
+  };
+  if (!parts.legL && !parts.torso) return;
+  const anim = (entry.modelAnim ??= { phase: 0, swing: 0, air: 0, lean: 0, last: null });
+  const p = entry.node.position;
+  if (dt > 0 && anim.last) {
+    const speed = Math.hypot(p.x - anim.last.x, p.z - anim.last.z) / dt;
+    const verticalSpeed = (p.y - anim.last.y) / dt;
+    anim.swing += (Math.min(1, speed / 5) - anim.swing) * Math.min(1, dt * 10);
+    anim.air += ((Math.abs(verticalSpeed) > 1.2 ? 1 : 0) - anim.air) * Math.min(1, dt * 8);
+    anim.phase += Math.min(speed, 8) * 2.4 * dt;
+    const yaw = entry.node.rotation.y;
+    let yawDelta = yaw - (anim.lastYaw ?? yaw);
+    yawDelta = Math.atan2(Math.sin(yawDelta), Math.cos(yawDelta));
+    const leanTarget = Math.max(-0.13, Math.min(0.13, (yawDelta / dt) * 0.04));
+    anim.lean += (leanTarget - anim.lean) * Math.min(1, dt * 9);
+    anim.lastYaw = yaw;
+  }
+  anim.last = { x: p.x, y: p.y, z: p.z };
+
+  const swing = Math.sin(anim.phase) * 0.8 * anim.swing * (1 - anim.air);
+  if (parts.legL) parts.legL.rotation.x = swing + anim.air * -0.55;
+  if (parts.legR) parts.legR.rotation.x = -swing + anim.air * -0.3;
+  if (parts.armL) parts.armL.rotation.x = -swing * 0.75 + anim.air * -1.5;
+  if (parts.armR) parts.armR.rotation.x = swing * 0.75 + anim.air * -1.5;
+  if (parts.torso) {
+    const base =
+      parts.torso.userData.basePosition ??
+      (parts.torso.userData.basePosition = parts.torso.position.y);
+    parts.torso.position.y =
+      base + Math.abs(Math.sin(anim.phase)) * 0.05 * anim.swing * (1 - anim.air);
+    parts.torso.rotation.z = -anim.lean;
+    parts.torso.rotation.y = anim.lean * 0.4;
+  }
+}

package/kits/physics-3d/engine3d/thumbnails.js

@@ -0,0 +1,137 @@
+// 3d blueprint thumbnails for the imported hotbar / inspector chrome. The
+// imported BlueprintThumbnail only knows how to draw `Sprite.file` art from
+// the sprites map, so we render each blueprint template from a corner view
+// into an offscreen canvas, wrap that canvas as an image-shaped art object,
+// and register it in the sprites map under a virtual `@thumb/<path>` ref that
+// gets injected as the template's `Sprite.file`. Renders are cached by the
+// template's node signature; one shared WebGL renderer serves all thumbs.
+import * as THREE from 'three';
+import { makeShapeMesh, nodeSignature, disposeNode } from './materials';
+import { parseModelCached, buildModelNode, modelArtSignature } from './pxmodel';
+import { findBehaviorClass } from '@imports/castle.physics-2d/editors/behaviorRegistry';
+
+export const THUMB_PREFIX = '@thumb/';
+const THUMB_SIZE = 192;
+
+let sharedRenderer = null;
+let releaseTimer = 0;
+
+function ensureRenderer() {
+  if (sharedRenderer) return sharedRenderer;
+  const canvas = document.createElement('canvas');
+  canvas.width = THUMB_SIZE;
+  canvas.height = THUMB_SIZE;
+  sharedRenderer = new THREE.WebGLRenderer({
+    canvas,
+    antialias: true,
+    alpha: true,
+    preserveDrawingBuffer: true,
+  });
+  sharedRenderer.setClearColor(0x000000, 0);
+  return sharedRenderer;
+}
+
+// Browsers cap LIVE WebGL contexts (~16); when the cap is hit they kill the
+// oldest, which has white-screened an editor viewport. Thumbs render in
+// bursts and then sit cached, so release this renderer's context shortly
+// after the last render instead of holding a slot forever.
+function releaseRendererSoon() {
+  window.clearTimeout(releaseTimer);
+  releaseTimer = window.setTimeout(() => {
+    if (!sharedRenderer) return;
+    sharedRenderer.forceContextLoss();
+    sharedRenderer.dispose();
+    sharedRenderer = null;
+  }, 2000);
+}
+
+function renderTemplate(template, sprites, files) {
+  const renderer = ensureRenderer();
+  const scene = new THREE.Scene();
+  // Match the main rig's exposure -- brighter than this blows the albedo out
+  // to white.
+  scene.add(new THREE.HemisphereLight(0xc8d0d8, 0x3a3530, 0.55 * Math.PI));
+  scene.add(new THREE.AmbientLight(0xffffff, 0.25));
+  const sun = new THREE.DirectionalLight(0xffffff, 0.9);
+  sun.position.set(3, 5, 2);
+  scene.add(sun);
+
+  const node = new THREE.Group();
+  const components = template.components ?? {};
+  // Templates are raw file data -- merge each behavior's defaultProps like the
+  // scene runtime would, so unspecified fields don't go undefined.
+  const merged = (name) => {
+    const defaults = findBehaviorClass(name)?.defaultProps ?? {};
+    return { ...defaults, ...(components[name] ?? {}) };
+  };
+  const model = components.Model?.file ? parseModelCached(files?.[components.Model.file]) : null;
+  if (model) node.add(buildModelNode(model, sprites));
+  else if (components.Shape) node.add(makeShapeMesh(merged('Shape'), sprites));
+  scene.add(node);
+
+  const bounds = new THREE.Box3().setFromObject(node);
+  const center = bounds.getCenter(new THREE.Vector3());
+  const radius = Math.max(0.2, bounds.getSize(new THREE.Vector3()).length() / 2);
+  const camera = new THREE.PerspectiveCamera(30, 1, 0.01, 100);
+  camera.position
+    .set(1, 0.75, 1)
+    .normalize()
+    .multiplyScalar(radius * 3.9)
+    .add(center);
+  camera.lookAt(center);
+
+  renderer.setSize(THUMB_SIZE, THUMB_SIZE, false);
+  renderer.render(scene, camera);
+
+  const out = document.createElement('canvas');
+  out.width = THUMB_SIZE;
+  out.height = THUMB_SIZE;
+  out.getContext('2d')?.drawImage(renderer.domElement, 0, 0);
+  disposeNode(node);
+  releaseRendererSoon();
+  return out;
+}
+
+const cache = new Map(); // blueprint path -> { sig, art }
+
+// Image-shaped art object for one blueprint, rendered fresh only when its
+// template (or a texture / model file it uses) changed.
+export function thumbArtFor(path, template, sprites, files) {
+  const modelFile = template.components?.Model?.file;
+  const modelText = modelFile ? (files?.[modelFile] ?? '') : '';
+  const modelSig = modelText
+    ? `${modelText.length}:${modelArtSignature(parseModelCached(modelText), sprites)}:${modelText}`
+    : '';
+  const sig = nodeSignature({ components: template.components ?? {} }, sprites, modelSig);
+  const cached = cache.get(path);
+  if (cached && cached.sig === sig) return cached.art;
+  const canvas = renderTemplate(template, sprites, files);
+  const art = {
+    kind: 'image',
+    path,
+    url: `${THUMB_PREFIX}${path}`,
+    image: canvas,
+    ready: true,
+    failed: false,
+    resolution: { width: canvas.width, height: canvas.height },
+    frames: [{ durationMs: 0 }],
+    layers: [],
+    palette: [],
+    tags: [],
+    defaultTag: '',
+    defaultDurationMs: 0,
+    cornerRadius: 0,
+  };
+  cache.set(path, { sig, art });
+  return art;
+}
+
+// A template clone whose Sprite points at the virtual thumb ref, for handing
+// to the imported BlueprintThumbnail.
+export function withThumbRef(template, path) {
+  if (!template) return template;
+  return {
+    ...template,
+    components: { ...(template.components ?? {}), Sprite: { file: `${THUMB_PREFIX}${path}` } },
+  };
+}

package/kits/physics-3d/engine3d/world3d.js

@@ -0,0 +1,216 @@
+// The three.js side of the kit: renderer, lighting rig, ground, and per-actor
+// nodes built from Shape components. Values follow the vase reference rig --
+// hemisphere + ambient + one tuned shadow-casting directional, PCFSoft shadows,
+// EffectComposer with RenderPass + OutputPass. Actor Transforms are the source
+// of truth; this module only reads them.
+import * as THREE from 'three';
+import { EffectComposer, RenderPass, OutputPass } from 'three/examples/jsm/Addons.js';
+import {
+  makeShapeMesh,
+  nodeSignature,
+  disposeNode,
+  resolveArtTexture,
+  artRefSignature,
+} from './materials';
+import { parseModelCached, buildModelNode, modelArtSignature, animateModelParts } from './pxmodel';
+
+const GROUND_SIZE = 60;
+
+export function makeWorld3D(canvas) {
+  const scene = new THREE.Scene();
+  const aspect = canvas.clientWidth / Math.max(1, canvas.clientHeight);
+  const camera = new THREE.PerspectiveCamera(50, aspect, 0.1, 1000);
+  camera.position.set(8, 8, 8);
+  camera.lookAt(0, 0, 0);
+
+  const renderer = new THREE.WebGLRenderer({
+    canvas,
+    antialias: true,
+    preserveDrawingBuffer: true, // screenshots read the canvas after the frame
+  });
+  // If the browser reclaims this context (live-context cap), ask for the
+  // automatic restore instead of staying a white canvas forever.
+  canvas.addEventListener('webglcontextlost', (event) => event.preventDefault());
+  renderer.setPixelRatio(window.devicePixelRatio);
+  renderer.setSize(canvas.clientWidth, canvas.clientHeight, false);
+  renderer.setClearColor(0x000000);
+  renderer.shadowMap.enabled = true;
+  renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+
+  addLights(scene);
+  const { ground, grid } = addGround(scene);
+
+  const composer = new EffectComposer(renderer);
+  composer.addPass(new RenderPass(scene, camera));
+  composer.addPass(new OutputPass());
+
+  // Collider wireframes from rapier's debugRender, toggled with `p`.
+  const debugLines = new THREE.LineSegments(
+    new THREE.BufferGeometry(),
+    new THREE.LineBasicMaterial({ vertexColors: true })
+  );
+  debugLines.visible = false;
+  debugLines.frustumCulled = false;
+  scene.add(debugLines);
+
+  return { scene, camera, renderer, composer, nodes: new Map(), debugLines, ground, grid };
+}
+
+export function updatePhysicsDebug(world, buffers) {
+  if (!buffers) return;
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute('position', new THREE.BufferAttribute(buffers.vertices, 3));
+  geometry.setAttribute('color', new THREE.BufferAttribute(buffers.colors, 4));
+  world.debugLines.geometry.dispose();
+  world.debugLines.geometry = geometry;
+}
+
+function addLights(scene) {
+  // The vase rig, lifted -- brighter overall than the raw vase values, with a
+  // stronger shadow term so shadows stay readable against the lift.
+  scene.add(new THREE.HemisphereLight(0xc8d0d8, 0x3a3530, 0.62 * Math.PI));
+  scene.add(new THREE.AmbientLight(0xffffff, 0.24));
+
+  const sun = new THREE.DirectionalLight(0xffffff, 1.15);
+  sun.position.set(6, 18, -6);
+  sun.castShadow = true;
+  sun.shadow.intensity = 0.65;
+  sun.shadow.mapSize.width = 2048;
+  sun.shadow.mapSize.height = 2048;
+  sun.shadow.camera.near = 0.5;
+  sun.shadow.camera.far = 50;
+  sun.shadow.camera.top = 85;
+  sun.shadow.camera.bottom = -35;
+  sun.shadow.camera.left = -75;
+  sun.shadow.camera.right = 75;
+  sun.shadow.normalBias = -0.14;
+  scene.add(sun);
+}
+
+function addGround(scene) {
+  const ground = new THREE.Mesh(
+    new THREE.PlaneGeometry(GROUND_SIZE, GROUND_SIZE),
+    new THREE.MeshStandardMaterial({ color: 0x22222b, dithering: true })
+  );
+  ground.rotation.x = -Math.PI / 2;
+  ground.position.y = -0.01;
+  ground.receiveShadow = true;
+  scene.add(ground);
+
+  const grid = new THREE.GridHelper(GROUND_SIZE, GROUND_SIZE, 0x505050, 0x505050);
+  grid.material.transparent = true;
+  grid.material.opacity = 0.35;
+  scene.add(grid);
+  return { ground, grid };
+}
+
+// A scene can dress the ground: `"ground": { "art": "drawings/floor.pxart",
+// "tile": 2, "color": "#..." }` at the scene file's top level. `tile` is the
+// world size of one texture repeat (meters). The line grid only shows on the
+// untextured ground -- over art it reads as noise.
+export function syncGround(world, setting, sprites) {
+  const sig = `${JSON.stringify(setting ?? null)}|${artRefSignature(setting?.art, sprites)}`;
+  if (sig === world.groundSig) return;
+  const tile = setting?.tile > 0 ? setting.tile : 2;
+  const repeat = [GROUND_SIZE / tile, GROUND_SIZE / tile];
+  const texture = setting?.art ? resolveArtTexture(setting.art, sprites, repeat) : null;
+  world.groundSig = sig;
+  const material = new THREE.MeshStandardMaterial({
+    color: new THREE.Color(setting?.color ?? (texture ? '#ffffff' : '#22222b')),
+    map: texture,
+    dithering: true,
+  });
+  world.ground.material.dispose();
+  world.ground.material = material;
+  world.grid.visible = !texture;
+}
+
+// The signature suffix for an actor's Model component: the model file's text
+// plus the readiness/identity of any art it references.
+function actorModelSig(actor, sprites, files) {
+  const file = actor.components.Model?.file;
+  if (!file) return '';
+  const text = files?.[file];
+  if (typeof text !== 'string') return 'missing';
+  return `${text.length}:${modelArtSignature(parseModelCached(text), sprites)}:${text}`;
+}
+
+// Build / refresh the node for one actor. Rebuilds only when what it looks
+// like (Shape / Model / their art) changes. A Model replaces the Shape's own
+// mesh with the .pxmodel rig; the Shape still sizes the physics collider.
+function ensureActorNode(world, actor, sprites, files) {
+  const sig = nodeSignature(actor, sprites, actorModelSig(actor, sprites, files));
+  let entry = world.nodes.get(actor.id);
+  if (entry && entry.sig !== sig) {
+    world.scene.remove(entry.node);
+    disposeNode(entry.node);
+    entry = null;
+  }
+  if (!entry) {
+    const node = new THREE.Group();
+    node.userData.actorId = actor.id; // raycast hits map back to the actor
+    const modelComponent = actor.components.Model;
+    const shape = actor.components.Shape;
+    const model = modelComponent?.file ? parseModelCached(files?.[modelComponent.file]) : null;
+    if (model) {
+      const rig = buildModelNode(model, sprites);
+      rig.position.y = modelComponent.yOffset ?? 0;
+      const scale = modelComponent.scale ?? 1;
+      rig.scale.set(scale, scale, scale);
+      node.userData.modelParts = rig.userData.modelParts;
+      node.add(rig);
+    } else if (shape) {
+      node.add(makeShapeMesh(shape, sprites));
+    }
+    world.scene.add(node);
+    entry = { node, sig };
+    world.nodes.set(actor.id, entry);
+  }
+  return entry;
+}
+
+const DEG = Math.PI / 180;
+
+// Copy actor Transforms into three nodes, creating and removing nodes as
+// actors come and go. Dynamic bodies leave an exact quaternion in
+// `actor.runtime.quat`; everything else rotates by the Transform's euler
+// degrees.
+export function syncActors(world, runtime, sprites, dt = 0) {
+  syncGround(world, runtime.data?.ground, sprites);
+  const seen = new Set();
+  for (const actor of runtime.getActors()) {
+    const t = actor.components.Transform;
+    if (!t) continue;
+    seen.add(actor.id);
+    const entry = ensureActorNode(world, actor, sprites, runtime.files);
+    const node = entry.node;
+    node.position.set(t.x, t.y, t.z);
+    const quat = actor.runtime?.quat;
+    if (quat) node.quaternion.set(quat.x, quat.y, quat.z, quat.w);
+    else node.rotation.set(t.rotationX * DEG, t.rotationY * DEG, t.rotationZ * DEG);
+    animateModelParts(entry, dt);
+  }
+  for (const [id, entry] of world.nodes) {
+    if (seen.has(id)) continue;
+    world.scene.remove(entry.node);
+    disposeNode(entry.node);
+    world.nodes.delete(id);
+  }
+}
+
+export function resizeWorld(world, width, height) {
+  world.renderer.setSize(width, height, false);
+  world.composer.setSize(width, height);
+  world.camera.aspect = width / Math.max(1, height);
+  world.camera.updateProjectionMatrix();
+}
+
+export function renderWorld(world) {
+  world.composer.render();
+}
+
+export function disposeWorld(world) {
+  for (const entry of world.nodes.values()) disposeNode(entry.node);
+  world.nodes.clear();
+  world.renderer.dispose();
+}

package/kits/{basic-2d → physics-3d}/eslint.config.js

@@ -3,32 +3,17 @@ import reactHooks from 'eslint-plugin-react-hooks';
 
 export default [
   {
-    ignores: ['node_modules/**', 'dist/**', '.castle/**', '*.config.js'],
+    ignores: ['node_modules/**', 'dist/**', '.castle/**', 'imports/**', '*.config.js'],
   },
   js.configs.recommended,
   {
-    // Node-side kit tooling (e.g. the `npm run draw` art generator). Runs under
-    // Node, not the browser, so it gets Node globals.
-    files: ['scripts/**/*.{js,mjs}'],
-    languageOptions: {
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-      globals: {
-        process: 'readonly',
-        Buffer: 'readonly',
-        console: 'readonly',
-        URL: 'readonly',
-        setTimeout: 'readonly',
-        clearTimeout: 'readonly',
-      },
-    },
-    rules: {
-      'no-undef': 'off',
-      'no-unused-vars': ['warn', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
-    },
-  },
-  {
-    files: ['engine/**/*.{js,jsx}', 'editors/**/*.{js,jsx}', 'behaviors/**/*.{js,jsx}', '*.js', '*.jsx'],
+    files: [
+      'engine3d/**/*.{js,jsx}',
+      'systems/**/*.{js,jsx}',
+      'behaviors/**/*.{js,jsx}',
+      '*.js',
+      '*.jsx',
+    ],
     languageOptions: {
       ecmaVersion: 'latest',
       sourceType: 'module',
@@ -45,16 +30,16 @@ export default [
         setTimeout: 'readonly',
         clearTimeout: 'readonly',
         URL: 'readonly',
+        URLSearchParams: 'readonly',
         fetch: 'readonly',
         navigator: 'readonly',
         location: 'readonly',
         HTMLCanvasElement: 'readonly',
         Image: 'readonly',
-        FileReader: 'readonly',
+        ResizeObserver: 'readonly',
         KeyboardEvent: 'readonly',
         PointerEvent: 'readonly',
         MouseEvent: 'readonly',
-        TouchEvent: 'readonly',
         structuredClone: 'readonly',
       },
     },