@opsydyn/effect-three 0.0.0-stage → 0.2.0

package/dist/kernel/index.js

@@ -0,0 +1,335 @@
+import {
+  handJoints2,
+  clipTime2,
+  clipRunning2,
+  createPose2,
+  resetPose2,
+  float2,
+  builtinBehaviours2,
+  spinAngle2,
+  writeRotation2,
+  buildMaterial2,
+  updateMaterial2,
+  vec3Equals2,
+  rotationEquals2,
+  shapeEquals2,
+  geometryRefEquals2,
+  instanceEquals2,
+  instancesEqual2,
+  behaviourEquals2,
+  animationEquals2,
+  transitionEquals2,
+  materialRefEquals2,
+  cameraEquals2,
+  renderSettingsEquals2,
+  effectsEqual2,
+  viewsEqual2,
+  resourcesEqual2,
+  overlaysEqual2,
+  environmentEquals2,
+  skyEquals2,
+  contactShadowsEquals2,
+  bodyEquals2,
+  physicsEquals2,
+  xrEquals2,
+  capacityFor2,
+  createPerformanceMonitor2,
+  easeProgress2,
+  startTween2,
+  applyTween2,
+  fixed2,
+  spin2,
+  box2,
+  sphere2,
+  plane2,
+  cylinder2,
+  torus2,
+  cone2,
+  capsule2,
+  ring2,
+  circle2,
+  text2,
+  instant2,
+  ease2,
+  basic2,
+  lambert2,
+  phong2,
+  standard2,
+  physical2,
+  normalMaterial2,
+  shadowMaterial2,
+  grid2,
+  shaderGrid2,
+  sharedGeometry2,
+  lentGeometry2,
+  sharedMaterial2,
+  group2,
+  headSpace2,
+  jointSpace2,
+  controllerSpace2,
+  anchorSpace2,
+  planeSpace2,
+  meshSpace2,
+  xrMeshGeometryId2,
+  xrMesh2,
+  xrAnchor2,
+  mesh2,
+  body2,
+  interactionGroups2,
+  cuboidCollider2,
+  ballCollider2,
+  capsuleCollider2,
+  cylinderCollider2,
+  coneCollider2,
+  velocityMotor2,
+  positionMotor2,
+  physics2,
+  bodyRef2,
+  joint2,
+  fixedJoint2,
+  sphericalJoint2,
+  revoluteJoint2,
+  prismaticJoint2,
+  ropeJoint2,
+  springJoint2,
+  glide2,
+  xr2,
+  instance2,
+  instances2,
+  behave2,
+  play2,
+  borrowed2,
+  label2,
+  colorRange2,
+  ambientLight2,
+  directionalLight2,
+  pointLight2,
+  spotLight2,
+  hemisphereLight2,
+  perspectiveCamera2,
+  orthographicCamera2,
+  bloom2,
+  vignette2,
+  film2,
+  renderSettings2,
+  view2,
+  renderTexture2,
+  environment2,
+  sunPositionFromAngles2,
+  sky2,
+  contactShadows2,
+  overlay2,
+  scene2,
+  emptyIndex2,
+  indexScene2,
+  changedFields2,
+  diff2,
+  createResourceStore2,
+  createSceneClock2,
+  createManualFrames2,
+  createGatedFrames2,
+  createFramePacer2,
+  defaultOrbit2,
+  orbitOptions2,
+  rotateCamera2,
+  dollyCamera2,
+  panCamera2,
+  dollyCameraToward2,
+  orbit2,
+  orbitKey2,
+  autoRotated2,
+  fitCamera2,
+  clipCamera2,
+  placeOverlays2,
+  interactionBits2,
+  colliderFor2,
+  describedColliders2,
+  collidersFor2,
+  colliderSignature2,
+  locomote2,
+  teleport2,
+  glided2,
+  createXrTracker2,
+  environmentPresets2,
+  environmentPresetUrl2,
+  stagePresets2,
+  stage2,
+  centerOffset2,
+  stageBounds2,
+  noModifiers2,
+  pointOnPlane2,
+  createPicker2,
+  createPointerTracker2,
+  createSceneLoop2,
+  recordingRendererFactory2,
+  createSceneGraph2
+} from "../index-01kwfekm.js";
+export {
+  ambientLight2 as ambientLight,
+  anchorSpace2 as anchorSpace,
+  animationEquals2 as animationEquals,
+  applyTween2 as applyTween,
+  autoRotated2 as autoRotated,
+  ballCollider2 as ballCollider,
+  basic2 as basic,
+  behave2 as behave,
+  behaviourEquals2 as behaviourEquals,
+  bloom2 as bloom,
+  body2 as body,
+  bodyEquals2 as bodyEquals,
+  bodyRef2 as bodyRef,
+  borrowed2 as borrowed,
+  box2 as box,
+  buildMaterial2 as buildMaterial,
+  builtinBehaviours2 as builtinBehaviours,
+  cameraEquals2 as cameraEquals,
+  capacityFor2 as capacityFor,
+  capsule2 as capsule,
+  capsuleCollider2 as capsuleCollider,
+  centerOffset2 as centerOffset,
+  changedFields2 as changedFields,
+  circle2 as circle,
+  clipCamera2 as clipCamera,
+  clipRunning2 as clipRunning,
+  clipTime2 as clipTime,
+  colliderFor2 as colliderFor,
+  colliderSignature2 as colliderSignature,
+  collidersFor2 as collidersFor,
+  colorRange2 as colorRange,
+  cone2 as cone,
+  coneCollider2 as coneCollider,
+  contactShadows2 as contactShadows,
+  contactShadowsEquals2 as contactShadowsEquals,
+  controllerSpace2 as controllerSpace,
+  createFramePacer2 as createFramePacer,
+  createGatedFrames2 as createGatedFrames,
+  createManualFrames2 as createManualFrames,
+  createPerformanceMonitor2 as createPerformanceMonitor,
+  createPicker2 as createPicker,
+  createPointerTracker2 as createPointerTracker,
+  createPose2 as createPose,
+  createResourceStore2 as createResourceStore,
+  createSceneClock2 as createSceneClock,
+  createSceneGraph2 as createSceneGraph,
+  createSceneLoop2 as createSceneLoop,
+  createXrTracker2 as createXrTracker,
+  cuboidCollider2 as cuboidCollider,
+  cylinder2 as cylinder,
+  cylinderCollider2 as cylinderCollider,
+  defaultOrbit2 as defaultOrbit,
+  describedColliders2 as describedColliders,
+  diff2 as diff,
+  directionalLight2 as directionalLight,
+  dollyCamera2 as dollyCamera,
+  dollyCameraToward2 as dollyCameraToward,
+  ease2 as ease,
+  easeProgress2 as easeProgress,
+  effectsEqual2 as effectsEqual,
+  emptyIndex2 as emptyIndex,
+  environment2 as environment,
+  environmentEquals2 as environmentEquals,
+  environmentPresetUrl2 as environmentPresetUrl,
+  environmentPresets2 as environmentPresets,
+  film2 as film,
+  fitCamera2 as fitCamera,
+  fixed2 as fixed,
+  fixedJoint2 as fixedJoint,
+  float2 as float,
+  geometryRefEquals2 as geometryRefEquals,
+  glide2 as glide,
+  glided2 as glided,
+  grid2 as grid,
+  group2 as group,
+  handJoints2 as handJoints,
+  headSpace2 as headSpace,
+  hemisphereLight2 as hemisphereLight,
+  indexScene2 as indexScene,
+  instance2 as instance,
+  instanceEquals2 as instanceEquals,
+  instances2 as instances,
+  instancesEqual2 as instancesEqual,
+  instant2 as instant,
+  interactionBits2 as interactionBits,
+  interactionGroups2 as interactionGroups,
+  joint2 as joint,
+  jointSpace2 as jointSpace,
+  label2 as label,
+  lambert2 as lambert,
+  lentGeometry2 as lentGeometry,
+  locomote2 as locomote,
+  materialRefEquals2 as materialRefEquals,
+  mesh2 as mesh,
+  meshSpace2 as meshSpace,
+  noModifiers2 as noModifiers,
+  normalMaterial2 as normalMaterial,
+  orbit2 as orbit,
+  orbitKey2 as orbitKey,
+  orbitOptions2 as orbitOptions,
+  orthographicCamera2 as orthographicCamera,
+  overlay2 as overlay,
+  overlaysEqual2 as overlaysEqual,
+  panCamera2 as panCamera,
+  perspectiveCamera2 as perspectiveCamera,
+  phong2 as phong,
+  physical2 as physical,
+  physics2 as physics,
+  physicsEquals2 as physicsEquals,
+  placeOverlays2 as placeOverlays,
+  plane2 as plane,
+  planeSpace2 as planeSpace,
+  play2 as play,
+  pointLight2 as pointLight,
+  pointOnPlane2 as pointOnPlane,
+  positionMotor2 as positionMotor,
+  prismaticJoint2 as prismaticJoint,
+  recordingRendererFactory2 as recordingRendererFactory,
+  renderSettings2 as renderSettings,
+  renderSettingsEquals2 as renderSettingsEquals,
+  renderTexture2 as renderTexture,
+  resetPose2 as resetPose,
+  resourcesEqual2 as resourcesEqual,
+  revoluteJoint2 as revoluteJoint,
+  ring2 as ring,
+  ropeJoint2 as ropeJoint,
+  rotateCamera2 as rotateCamera,
+  rotationEquals2 as rotationEquals,
+  scene2 as scene,
+  shaderGrid2 as shaderGrid,
+  shadowMaterial2 as shadowMaterial,
+  shapeEquals2 as shapeEquals,
+  sharedGeometry2 as sharedGeometry,
+  sharedMaterial2 as sharedMaterial,
+  sky2 as sky,
+  skyEquals2 as skyEquals,
+  sphere2 as sphere,
+  sphericalJoint2 as sphericalJoint,
+  spin2 as spin,
+  spinAngle2 as spinAngle,
+  spotLight2 as spotLight,
+  springJoint2 as springJoint,
+  stage2 as stage,
+  stageBounds2 as stageBounds,
+  stagePresets2 as stagePresets,
+  standard2 as standard,
+  startTween2 as startTween,
+  sunPositionFromAngles2 as sunPositionFromAngles,
+  teleport2 as teleport,
+  text2 as text,
+  torus2 as torus,
+  transitionEquals2 as transitionEquals,
+  updateMaterial2 as updateMaterial,
+  vec3Equals2 as vec3Equals,
+  velocityMotor2 as velocityMotor,
+  view2 as view,
+  viewsEqual2 as viewsEqual,
+  vignette2 as vignette,
+  writeRotation2 as writeRotation,
+  xr2 as xr,
+  xrAnchor2 as xrAnchor,
+  xrEquals2 as xrEquals,
+  xrMesh2 as xrMesh,
+  xrMeshGeometryId2 as xrMeshGeometryId
+};
+
+//# debugId=0E05A0594250FA0164756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/kernel/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "0E05A0594250FA0164756E2164756E21",
+  "names": []
+}

package/dist/kernel/instances.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Writing instance descriptions into three.js's `InstancedMesh` buffers.
+ *
+ * Slots are positional: instance `i` of the description lives in slot `i`. An update
+ * writes only the slots whose instance changed, so moving one of 10,000 instances writes
+ * one matrix. Capacity grows by doubling, so adding instances rarely reallocates.
+ *
+ * @module
+ */
+import { type BufferGeometry, InstancedMesh } from 'three';
+import type { Instance } from './description.ts';
+import type { HostMaterial } from './materials.ts';
+/** The three.js object an `instances` node is hosted as. */
+export type HostInstances = InstancedMesh<BufferGeometry, HostMaterial>;
+/** Slots to allocate for `count` instances: the next power of two, at least 16. */
+export declare const capacityFor: (count: number) => number;
+/** Creates an instanced mesh with room for at least `count` instances. */
+export declare const createInstances: (geometry: BufferGeometry, material: HostMaterial, count: number) => HostInstances;
+/** Whether `count` instances fit without reallocating. */
+export declare const fits: (mesh: HostInstances, count: number) => boolean;
+/**
+ * Writes `next` into `mesh`, skipping slots whose instance is unchanged from `previous`
+ * (pass an empty list to write every slot). `next` must fit. Returns the slots written.
+ */
+export declare const writeInstances: (mesh: HostInstances, previous: ReadonlyArray<Instance>, next: ReadonlyArray<Instance>) => number;
+//# sourceMappingURL=instances.d.ts.map

package/dist/kernel/instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instances.d.ts","sourceRoot":"","sources":["../../src/kernel/instances.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,KAAK,cAAc,EAInB,aAAa,EAId,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,4DAA4D;AAC5D,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;AAIxE,mFAAmF;AACnF,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,MAC8B,CAAC;AAmB3E,0EAA0E;AAC1E,eAAO,MAAM,eAAe,aAChB,cAAc,YACd,YAAY,SACf,MAAM,KACZ,aAQF,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,IAAI,SAAU,aAAa,SAAS,MAAM,KAAG,OACtB,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,cAAc,SACnB,aAAa,YACT,aAAa,CAAC,QAAQ,CAAC,QAC3B,aAAa,CAAC,QAAQ,CAAC,KAC5B,MAmBF,CAAC"}

package/dist/kernel/labels.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The kernel's side of labels (distance-field text): an engine-neutral contract. An
+ * engine package (troika, in `@opsydyn/effect-three-troika`) implements `LabelEngine`; the
+ * scene graph hosts what it makes inside each label's wrapper.
+ *
+ * Behavioural reference: Drei's `Text` at `bf6f4ad` (`src/core/Text.tsx`): a troika mesh
+ * per label, its properties set from props, `sync` run after each change and the frame
+ * invalidated when it finishes, and the mesh disposed on unmount.
+ *
+ * @module
+ */
+import type { Material, Object3D } from 'three';
+import type { LabelNode } from './description.ts';
+/**
+ * A label's laid-out size in its own units (before its scale), each as
+ * `[minX, minY, maxX, maxY]`: `block` the whole text block, line height included, and
+ * `visible` tight round the glyphs (troika's `blockBounds` and `visibleBounds`).
+ */
+export type LabelLayout = {
+    readonly block: readonly [number, number, number, number];
+    readonly visible: readonly [number, number, number, number];
+};
+/** One label as an engine draws it. */
+export type HostedLabel = {
+    /** What to show inside the label's wrapper. */
+    readonly object: Object3D;
+    /** Applies new text or type settings; `ready` is called again when they are drawn. */
+    readonly update: (label: LabelNode) => void;
+    /**
+     * Draws the glyphs with a material the scene lends (`label({ material })`), or the
+     * engine's own with `undefined`. The scene owns it: the engine never disposes it.
+     */
+    readonly setMaterial: (material: Material | undefined) => void;
+    /** The text's laid-out size, once it has been laid out. */
+    readonly layout: () => LabelLayout | undefined;
+    readonly dispose: () => void;
+};
+/**
+ * Draws labels. `ready` is called whenever a label's glyphs have been built (fonts load
+ * and glyphs build in the background), so the scene can draw again.
+ */
+export type LabelEngine = {
+    /** A label drawn with WebGL's own materials, for a `'webgl'` render kit. */
+    readonly create: (label: LabelNode, ready: () => void) => HostedLabel;
+    /**
+     * A label drawn with three's node materials (TSL), for a `'tsl'` render kit such as
+     * `WebGPURenderer`'s. Without it, those renderers draw no labels.
+     */
+    readonly createTsl?: (label: LabelNode, ready: () => void) => HostedLabel;
+};
+//# sourceMappingURL=labels.d.ts.map

package/dist/kernel/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../../src/kernel/labels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1D,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7D,CAAC;AAEF,uCAAuC;AACvC,MAAM,MAAM,WAAW,GAAG;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,KAAK,IAAI,CAAC;IAC/D,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,WAAW,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,WAAW,CAAC;IACtE;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,WAAW,CAAC;CAC3E,CAAC"}

package/dist/kernel/loop.d.ts

@@ -0,0 +1,49 @@
+import { type OverlayPlacement } from './overlays.ts';
+import { type PerformanceOptions } from './performance.ts';
+/**
+ * The per-frame step and pointer routing for one scene. Plain synchronous code: the
+ * Effect runtime owns its lifetime (ADR-003: Effect owns lifetimes, not frames).
+ *
+ * @module
+ */
+import { type PointerInput, type SceneEvent } from './pointer.ts';
+import type { SceneRenderer } from './renderer.ts';
+import type { SceneGraph } from './sceneGraph.ts';
+import { type XrInput } from './xrInput.ts';
+export type SceneLoopOptions = {
+    readonly graph: SceneGraph;
+    readonly renderer: SceneRenderer;
+    /** Scene time in seconds. Behaviours are a pure function of it. */
+    readonly elapsedSeconds: () => number;
+    /** Receives every scene event. Must not throw. */
+    readonly emit: (event: SceneEvent) => void;
+    /** Wall-clock milliseconds, for the frame-rate monitor. Defaults to `Date.now`. */
+    readonly now?: () => number;
+    /** Tuning for the frame-rate monitor. */
+    readonly performance?: PerformanceOptions;
+    /**
+     * Receives where the scene's overlays are after each drawn frame, for the host to move
+     * their HTML there; once with none after the last overlay goes. Must not throw.
+     */
+    readonly placeOverlays?: (placements: ReadonlyArray<OverlayPlacement>) => void;
+};
+export type SceneLoop = {
+    /** Advances behaviours, re-tests hover and renders one frame. */
+    readonly frame: () => void;
+    /**
+     * Whether frames should keep coming: always in `always` mode, while the graph needs one
+     * in `demand` mode, never in `never` mode (frames then come only from `advance`).
+     */
+    readonly wantsFrames: () => boolean;
+    /** Releases the render textures' targets and withdraws their textures. */
+    readonly dispose: () => void;
+    /**
+     * Routes pointer input to hit testing, emits the resulting events and returns them, so
+     * a DOM listener can decide synchronously whether the scene handled its event.
+     */
+    readonly pointer: (input: PointerInput) => ReadonlyArray<SceneEvent>;
+    /** Routes XR input (aims, selects, sticks, buttons, surfaces), emitting the events. */
+    readonly xrInput: (input: XrInput) => ReadonlyArray<SceneEvent>;
+};
+export declare const createSceneLoop: (options: SceneLoopOptions) => SceneLoop;
+//# sourceMappingURL=loop.d.ts.map

package/dist/kernel/loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/kernel/loop.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,gBAAgB,EAAiB,MAAM,eAAe,CAAC;AACrE,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACrF;;;;;GAKG;AACH,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAmB,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAE7D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,mEAAmE;IACnE,QAAQ,CAAC,cAAc,EAAE,MAAM,MAAM,CAAC;IACtC,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC3C,mFAAmF;IACnF,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,yCAAyC;IACzC,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,aAAa,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;CAChF,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,iEAAiE;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC;IACpC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,aAAa,CAAC,UAAU,CAAC,CAAC;IACrE,uFAAuF;IACvF,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,UAAU,CAAC,CAAC;CACjE,CAAC;AAKF,eAAO,MAAM,eAAe,YAAa,gBAAgB,KAAG,SAyL3D,CAAC"}

package/dist/kernel/materials.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Building and updating three.js materials from descriptions.
+ *
+ * Kinds and defaults follow three.js's mesh materials (`three/src/materials`). A change
+ * within one kind is applied in place; when it touches something compiled into the shader
+ * (transparency, side, flat shading) the material is flagged for recompilation, as three
+ * requires. A change of kind needs a new material, which the resource store handles.
+ *
+ * @module
+ */
+import { MeshBasicMaterial, MeshLambertMaterial, MeshNormalMaterial, MeshPhongMaterial, MeshPhysicalMaterial, MeshStandardMaterial, ShadowMaterial as ThreeShadowMaterial, type Texture } from 'three';
+import type { SurfaceMaterial } from './description.ts';
+/** Looks up a texture lent to the store. */
+export type Textures = (id: string) => Texture | undefined;
+/** The three.js material kinds the kernel hosts. */
+export type HostMaterial = MeshBasicMaterial | MeshLambertMaterial | MeshPhongMaterial | MeshStandardMaterial | MeshPhysicalMaterial | MeshNormalMaterial | ThreeShadowMaterial;
+/** Builds a new material for a description. */
+export declare const buildMaterial: (description: SurfaceMaterial, textures?: Textures) => HostMaterial;
+/**
+ * Applies a description to an existing material in place. Returns `false`, changing
+ * nothing, when the material is a different kind: the caller must build a new one.
+ */
+export declare const updateMaterial: (material: HostMaterial, description: SurfaceMaterial, textures?: Textures) => boolean;
+//# sourceMappingURL=materials.d.ts.map

package/dist/kernel/materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/kernel/materials.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAIL,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,cAAc,IAAI,mBAAmB,EAErC,KAAK,OAAO,EACb,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EASV,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAE1B,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;AAgB3D,oDAAoD;AACpD,MAAM,MAAM,YAAY,GACpB,iBAAiB,GACjB,mBAAmB,GACnB,iBAAiB,GACjB,oBAAoB,GACpB,oBAAoB,GACpB,kBAAkB,GAClB,mBAAmB,CAAC;AA6GxB,+CAA+C;AAC/C,eAAO,MAAM,aAAa,gBACX,eAAe,aAClB,QAAQ,KACjB,YAsCF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,aACf,YAAY,eACT,eAAe,aAClB,QAAQ,KACjB,OAkCF,CAAC"}

package/dist/kernel/motion.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Registered behaviours: application motion as pure functions of scene time.
+ *
+ * A behaviour writes a pose (a position offset, a rotation and a scale factor) into a
+ * reused scratch value, so ticking allocates nothing. The scene graph composes that pose
+ * on top of the node's own transform each frame: position added, rotation added, scale
+ * multiplied. Because the pose depends only on time and parameters, behaviours pause,
+ * rewind and replay with the scene, unlike `useFrame` callbacks that mutate state.
+ *
+ * @module
+ */
+import { Vector3 } from 'three';
+/** Where a behaviour writes its pose. Reset to no change before every call. */
+export type BehaviourPose = {
+    /** Added to the node's position, in its parent's space. */
+    readonly offset: Vector3;
+    /** Euler angles (radians) added to the node's rotation. */
+    readonly rotation: Vector3;
+    /** Multiplies the node's scale. */
+    readonly scale: Vector3;
+};
+/** A behaviour: writes the pose for `seconds` of scene time and the node's parameters. */
+export type Behaviour = (pose: BehaviourPose, seconds: number, params: Readonly<Record<string, number>>) => void;
+/** A pose that changes nothing. */
+export declare const createPose: () => BehaviourPose;
+export declare const resetPose: (pose: BehaviourPose) => void;
+/**
+ * Drei's `Float` (`drei-main/src/core/Float.tsx` at `bf6f4ad`): a gentle bob and sway.
+ * Parameters (Drei's defaults): `speed` 1, `rotationIntensity` 1, `floatIntensity` 1,
+ * `low` -0.1 and `high` 0.1 (Drei's `floatingRange`), and `phase` 0 in place of Drei's
+ * random start, so the motion is the same on every run.
+ */
+export declare const float: Behaviour;
+/** Behaviours every scene knows without registering them. */
+export declare const builtinBehaviours: Readonly<Record<string, Behaviour>>;
+//# sourceMappingURL=motion.d.ts.map

package/dist/kernel/motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../src/kernel/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC,+EAA+E;AAC/E,MAAM,MAAM,aAAa,GAAG;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,0FAA0F;AAC1F,MAAM,MAAM,SAAS,GAAG,CACtB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KACrC,IAAI,CAAC;AAEV,mCAAmC;AACnC,eAAO,MAAM,UAAU,QAAO,aAI5B,CAAC;AAEH,eAAO,MAAM,SAAS,SAAU,aAAa,KAAG,IAI/C,CAAC;AAMF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,SAkBnB,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAa,CAAC"}

package/dist/kernel/orbit.d.ts

@@ -0,0 +1,127 @@
+import type { Camera, Vec3 } from './description.ts';
+import type { Gesture, Modifiers } from './pointer.ts';
+/** How `orbit` reads gestures: speeds and limits, as three.js's `OrbitControls`. */
+export type OrbitOptions = {
+    readonly enableRotate: boolean;
+    readonly enableZoom: boolean;
+    readonly enablePan: boolean;
+    readonly rotateSpeed: number;
+    readonly zoomSpeed: number;
+    readonly panSpeed: number;
+    /** Pan in the screen's plane (`true`, the default) or along the ground (`false`). */
+    readonly screenSpacePanning: boolean;
+    /** Perspective cameras: the closest and furthest distance from the target. */
+    readonly minDistance: number;
+    readonly maxDistance: number;
+    /** Orthographic cameras: the smallest and largest `zoom`. */
+    readonly minZoom: number;
+    readonly maxZoom: number;
+    /** Radians from straight above (0) to straight below (π). */
+    readonly minPolarAngle: number;
+    readonly maxPolarAngle: number;
+    /** Radians around the vertical axis; infinite (the default) for no limit. */
+    readonly minAzimuthAngle: number;
+    readonly maxAzimuthAngle: number;
+    /** Dolly toward the point under the pointer rather than the target (`zoomToCursor`). */
+    readonly zoomToCursor: boolean;
+    /** Pixels an arrow key pans by, and turns an arrow key with a modifier makes. */
+    readonly keyPanSpeed: number;
+    readonly keyRotateSpeed: number;
+};
+/** three.js's `OrbitControls` defaults. */
+export declare const defaultOrbit: OrbitOptions;
+/** Orbit options: three.js's defaults with yours on top. */
+export declare const orbitOptions: (options?: Partial<OrbitOptions>) => OrbitOptions;
+/**
+ * Turns the camera round its target by a drag of `deltaX`, `deltaY` CSS pixels over an
+ * area `height` pixels tall: a drag the full height turns it once round.
+ */
+export declare const rotateCamera: (camera: Camera, deltaX: number, deltaY: number, height: number, options?: OrbitOptions) => Camera;
+/**
+ * Scales the camera's distance from its target by `scale` (below 1 moves closer). An
+ * orthographic camera keeps its distance and divides its `zoom` by `scale` instead.
+ */
+export declare const dollyCamera: (camera: Camera, scale: number, options?: OrbitOptions) => Camera;
+/**
+ * Moves the camera and its target together by a drag of `deltaX`, `deltaY` CSS pixels
+ * over an area `width` by `height`: the scene follows the pointer at the target's depth.
+ */
+export declare const panCamera: (camera: Camera, deltaX: number, deltaY: number, area: {
+    readonly width: number;
+    readonly height: number;
+}, options?: OrbitOptions) => Camera;
+/** Where on a gesture's area the pointer is: its size, and `x`, `y` from −1 to 1, y up. */
+export type Cursor = {
+    readonly width: number;
+    readonly height: number;
+    readonly x: number;
+    readonly y: number;
+};
+/**
+ * Dollies toward the point under the cursor by `scale` (below 1 moves closer), as
+ * OrbitControls does with `zoomToCursor`: a perspective camera moves along the pointer's
+ * ray; an orthographic one zooms and shifts so the point under the cursor stays there.
+ * The target then follows, `radius` ahead along the view (or on the ground, when panning
+ * along it and the view is not too steep). A middle-button drag aims where it was
+ * pressed: three 0.186's `_handleMouseDownDolly` passes `clientX` for both coordinates, a
+ * typo this does not copy.
+ */
+export declare const dollyCameraToward: (camera: Camera, scale: number, cursor: Cursor, options?: OrbitOptions) => Camera;
+/**
+ * The camera after one gesture, as three.js's `OrbitControls` would move it. Apply it in
+ * `update` and keep the result in the Model:
+ *
+ * ```ts
+ * GotGesture: ({ gesture }) => ({ model: { ...model, camera: orbit(model.camera, gesture) } })
+ * ```
+ *
+ * A wheel with control held (how trackpads report a pinch) dollies ten times as far.
+ */
+export declare const orbit: (camera: Camera, gesture: Gesture, options?: OrbitOptions) => Camera;
+/** The arrow keys OrbitControls listens to (`keys`). */
+export type OrbitKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
+/**
+ * The camera after an arrow key, as OrbitControls' `_handleKeyDown`: up, down, left and
+ * right pan by `keyPanSpeed` pixels, or with shift, control or meta held turn by
+ * `keyRotateSpeed`. Map key presses to Messages (a Foldkit key subscription) and apply it.
+ */
+export declare const orbitKey: (camera: Camera, key: OrbitKey, modifiers: Modifiers, area: {
+    readonly width: number;
+    readonly height: number;
+}, options?: OrbitOptions) => Camera;
+/** A world-space box, as `Measured` events report a node's. */
+export type Box = {
+    readonly min: Vec3;
+    readonly max: Vec3;
+};
+/**
+ * The camera where turning by itself (`autoRotate`) took it, from an `AutoRotated`
+ * event: keep it in the Model before orbiting, so the gesture goes on from where the
+ * camera was shown.
+ *
+ * ```ts
+ * AutoRotated: ({ position }) => ({ model: { ...model, camera: autoRotated(model.camera, { position }) } })
+ * ```
+ */
+export declare const autoRotated: <C extends Camera>(camera: C, turned: {
+    readonly position: Vec3;
+}) => C;
+/**
+ * The camera framing a box, as Drei's `Bounds` `fit` (margin 1.2 by default). A
+ * perspective camera keeps its direction and moves to the distance that fits the box,
+ * looking at its centre; an orthographic one keeps its place and zooms so the box's
+ * corners, seen from it, fit the area. Set the camera's `damping` to ease there.
+ */
+export declare const fitCamera: (camera: Camera, box: Box, area: {
+    readonly width: number;
+    readonly height: number;
+}, margin?: number) => Camera;
+/**
+ * Near and far planes that suit a box at its fitting distance, as Drei's `Bounds` `clip`:
+ * a hundredth of it and a hundred times it.
+ */
+export declare const clipCamera: (camera: Camera, box: Box, area: {
+    readonly width: number;
+    readonly height: number;
+}, margin?: number) => Camera;
+//# sourceMappingURL=orbit.d.ts.map