@nakednous/tree 0.0.1 → 0.0.3

package/README.md

@@ -1,8 +1,6 @@
 # `@nakednous/tree`
 
-Backend for **animations, scene-space queries, visibility tests, and shader-space transforms**.
-
-The package is **renderer-agnostic**, has **no dependencies**, and can run in both browser and server environments.
+Pure numeric core for animation, coordinate-space mapping, and visibility — **zero dependencies**, runs anywhere.
 
 ---
 
@@ -12,114 +10,276 @@ The package is **renderer-agnostic**, has **no dependencies**, and can run in bo
 npm install @nakednous/tree
 ```
 
-```javascript
+```js
 import * as tree from '@nakednous/tree'
 ```
 
 ---
 
-## Role
+## Architecture
 
-`@nakednous/tree` is intended to sit behind a host library or engine.
+`@nakednous/tree` is the bottom layer of a three-package stack. It knows nothing about renderers, the DOM, or p5 — it operates on plain arrays and `Float32Array` buffers throughout.
 
-```text
-application / renderer
-        │
-        ▼
- integration layer
-   (e.g. p5.tree)
-        │
-        ▼
-  @nakednous/tree
+```
+  application
+      │
+      ▼
+  p5.tree.js        ← bridge: wires tree + ui into p5.js v2
+      │
+      ├── @nakednous/ui    ← DOM param panels, transport controls
+      │
+      └── @nakednous/tree  ← this package: math, spaces, animation, visibility
 ```
 
-The host layer provides camera state, projection parameters, and scene data.
-`@nakednous/tree` performs the underlying computations: animation interpolation, spatial mapping, and visibility testing.
+The dependency direction is strict: `@nakednous/tree` never imports from the bridge or the DOM layer. This is what lets the same `PoseTrack` that drives a camera path also animate any object — headless, server-side, or in a future renderer.
 
 ---
 
-## Capabilities
+## What it does
+
+### PoseTrack — TRS keyframe animation
+
+A renderer-agnostic state machine for `{ pos, rot, scl }` keyframe sequences. Rotation is stored as `[x,y,z,w]` quaternions (w-last, glTF layout).
+
+```js
+import { PoseTrack } from '@nakednous/tree'
+
+const track = new PoseTrack()
+track.add({ pos: [0, 0, 0],    rot: [0,0,0,1], scl: [1,1,1] })
+track.add({ pos: [100, 50, 0], rot: [0,0,0,1], scl: [2,1,1] })
+track.play({ duration: 60, loop: true })
+
+// per-frame — zero allocation
+const out = { pos: [0,0,0], rot: [0,0,0,1], scl: [1,1,1] }
+track.tick()
+track.eval(out)   // writes interpolated TRS into out
+```
 
-### Animation tracks
+Interpolation modes:
 
-Keyframe animation with playback control.
+```js
+track.posInterp = 'catmullrom'  // default — centripetal Catmull-Rom
+track.posInterp = 'linear'
 
-Tracks support:
+track.rotInterp = 'slerp'       // default — constant angular velocity
+track.rotInterp = 'nlerp'       // normalised lerp; cheaper, slightly non-constant
+```
 
-* interpolation between poses
-* rate control
-* seeking
-* looping and ping-pong modes
+Playback features: signed `rate` (negative reverses), `loop`, `pingPong`, `seek(t)` scrubbing, and lifecycle hooks (`onPlay`, `onEnd`, `onStop`). `_onActivate` / `_onDeactivate` are lib-space hooks for the host layer's draw-loop registry — not for user code.
 
-Tracks are renderer-agnostic and can drive cameras, objects, or any transform-like structure.
+Keyframe `rot` input is flexible — the parser normalises all forms:
+- raw `[x,y,z,w]` quaternion
+- `{ axis: [x,y,z], angle }` axis-angle
+- `{ dir: [x,y,z], up? }` look-direction
+- `{ view: mat4 }` from view matrix rotation block
+- `{ eye, center, up? }` lookat shorthand
 
 ---
 
-### Scene-space queries
+### CameraTrack — lookat keyframe animation
+
+A renderer-agnostic state machine for `{ eye, center, up }` lookat keyframes. Each field is independently interpolated — eye and center along their own paths, up nlerped on the unit sphere.
+
+```js
+import { CameraTrack } from '@nakednous/tree'
+
+const track = new CameraTrack()
+track.add({ eye:[0,0,500], center:[0,0,0] })
+track.add({ eye:[300,-150,0], center:[0,0,0] })
+track.play({ loop: true, duration: 90 })
+
+// per-frame — zero allocation
+const out = { eye:[0,0,0], center:[0,0,0], up:[0,1,0] }
+track.tick()
+track.eval(out)
+// apply: cam.camera(out.eye[0],out.eye[1],out.eye[2],
+//                   out.center[0],out.center[1],out.center[2],
+//                   out.up[0],out.up[1],out.up[2])
+```
+
+Interpolation modes:
+
+```js
+track.eyeInterp    = 'catmullrom'  // default
+track.eyeInterp    = 'linear'
+
+track.centerInterp = 'linear'      // default — suits fixed lookat targets
+track.centerInterp = 'catmullrom'  // smoother when center is also flying
+```
+
+`add()` accepts:
+- `{ eye, center, up? }` explicit lookat; `up` defaults to `[0,1,0]`
+- `{ view: mat4 }` column-major view matrix; eye and forward extracted
+
+---
 
-Utilities for converting between coordinate spaces.
+### Shared Track transport
+
+Both `PoseTrack` and `CameraTrack` extend `Track`, which holds all transport machinery:
+
+```js
+track.play({ duration, loop, pingPong, rate, onPlay, onEnd, onStop })
+track.stop([rewind])   // rewind=true seeks to origin on stop
+track.reset()          // clear all keyframes and stop
+track.seek(t)          // normalised position [0, 1]
+track.time()           // → number ∈ [0, 1]
+track.info()           // → { keyframes, segments, seg, f, playing, loop, ... }
+track.tick()           // advance cursor by rate — returns playing state
+track.add(spec)        // append keyframe(s)
+track.set(i, spec)     // replace keyframe at index
+track.remove(i)        // remove keyframe at index
+
+track.playing          // boolean
+track.rate             // get/set — never starts/stops playback
+track.duration         // frames per segment
+track.keyframes        // raw array
+```
 
-Common queries include:
+Hook firing order:
+```
+play()  → onPlay → _onActivate
+tick()  → onEnd  → _onDeactivate   (once mode, at boundary)
+stop()  → onStop → _onDeactivate
+reset() → onStop → _onDeactivate
+```
 
-* mapping locations between spaces
-* mapping directions between spaces
-* deriving projection parameters
+One-keyframe behaviour: `play()` with exactly one keyframe snaps `eval()` to that keyframe without setting `playing = true` and without firing hooks.
 
 ---
 
-### Visibility tests
+### Coordinate-space mapping
+
+`mapLocation` and `mapDirection` convert points and vectors between any pair of named spaces. All work is done in flat scalar arithmetic — no objects created per call.
 
-Frustum-based visibility checks for:
+**Spaces:** `WORLD`, `EYE`, `SCREEN`, `NDC`, `MODEL`, `MATRIX` (custom frame).
 
-* points
-* spheres
-* axis-aligned boxes
+**NDC convention:** `WEBGL = -1` (z ∈ [−1,1]), `WEBGPU = 0` (z ∈ [0,1]).
 
-These functions operate on numeric camera descriptions and do not depend on renderer classes.
+```js
+import { mapLocation, mapDirection, WORLD, SCREEN, WEBGL } from '@nakednous/tree'
+
+const out = new Float32Array(3)
+const m = {
+  proj: /* Float32Array(16) */,
+  view: /* Float32Array(16) */,
+  pv:   /* proj × view */,
+  ipv:  /* inv(pv) */,
+}
+const vp = [0, height, width, -height]
+
+mapLocation(out, worldX, worldY, worldZ, WORLD, SCREEN, m, vp, WEBGL)
+```
+
+The matrices bag `m` is assembled by the host (p5.tree reads live renderer state into it). All pairs are supported: WORLD↔EYE, WORLD↔SCREEN, WORLD↔NDC, EYE↔SCREEN, SCREEN↔NDC, WORLD↔MATRIX, and their reverses.
 
 ---
 
-### Shader-space helpers
+### Visibility testing
+
+[Frustum culling](https://learnopengl.com/Guest-Articles/2021/Scene/Frustum-Culling) against six planes. All functions take scalar inputs and a pre-filled `Float64Array(24)` planes buffer — zero allocations per test.
 
-Projection queries and coordinate transforms useful when developing GPU shaders and rendering pipelines.
+```js
+import { frustumPlanes, pointVisibility, sphereVisibility, boxVisibility,
+         VISIBLE, SEMIVISIBLE, INVISIBLE } from '@nakednous/tree'
+
+const planes = new Float64Array(24)
+frustumPlanes(planes, posX, posY, posZ, vdX, vdY, vdZ,
+              upX, upY, upZ, rtX, rtY, rtZ,
+              ortho, near, far, left, right, top, bottom)
+
+sphereVisibility(planes, cx, cy, cz, radius)  // → VISIBLE | SEMIVISIBLE | INVISIBLE
+boxVisibility(planes, x0,y0,z0, x1,y1,z1)
+pointVisibility(planes, px, py, pz)
+```
+
+Three-state result: `VISIBLE` (fully inside), `SEMIVISIBLE` (intersecting), `INVISIBLE` (fully outside).
 
 ---
 
-## Philosophy
+### Quaternion and matrix math
+
+Exported individually for use in hot paths.
 
-The backend follows a **query-oriented design**.
+**Quaternions** — `[x,y,z,w]` w-last:
 
-Instead of managing scene graphs or renderer state, it focuses on answering spatial and animation questions:
+```
+qSet  qCopy  qDot  qNormalize  qNegate  qMul
+qSlerp  qNlerp
+qFromAxisAngle  qFromLookDir  qFromRotMat3x3  qFromMat4  qToMat4
+quatToAxisAngle
+```
 
-* mapping coordinates between spaces
-* interpolating transforms over time
-* determining whether objects are visible
+**Spline / vector:** `catmullRomVec3`, `lerpVec3`
 
-This keeps the core portable and easy to integrate with different engines.
+**Mat4:**
+```
+mat4Mul  mat4Invert  mat4Transpose  mat4MulPoint
+mat3NormalFromMat4  mat4Location  mat3Direction
+```
+
+**TRS ↔ mat4:** `transformToMat4`, `mat4ToTransform`
+
+**Projection queries** (read from a projection mat4 — no renderer needed):
+```
+projIsOrtho  projNear  projFar  projFov  projHfov
+projLeft  projRight  projTop  projBottom
+```
+
+**Pixel ratio:** `pixelRatio(proj, vpH, eyeZ, ndcZMin)` — world-units-per-pixel at a given depth, handles both perspective and orthographic.
 
 ---
 
-## Use cases
+### Constants
+
+```js
+// Coordinate spaces
+WORLD, EYE, NDC, SCREEN, MODEL, MATRIX
+
+// NDC Z convention
+WEBGL   // −1  (z ∈ [−1, 1])
+WEBGPU  //  0  (z ∈ [0, 1])
 
-Typical uses include:
+// Visibility results
+INVISIBLE, VISIBLE, SEMIVISIBLE
 
-* animation backend for cameras or scene objects
-* coordinate-space mapping utilities
-* CPU-side frustum culling
-* shader development tooling
-* server-side scene analysis or preprocessing
+// Basis vectors (frozen)
+ORIGIN, i, j, k, _i, _j, _k
+```
+
+---
+
+## Performance contract
+
+All hot-path functions follow an **out-first, zero-allocation** contract:
+
+- `out` is the first parameter — the caller owns the buffer
+- the function writes into `out` and returns it
+- `null` is returned on degeneracy (singular matrix, etc.)
+- no heap allocations per call
+
+```js
+// allocate once
+const out  = new Float32Array(3)
+const pv   = new Float32Array(16)
+const ipv  = new Float32Array(16)
+
+// per frame — zero allocation
+mat4Mul(pv, proj, view)
+mat4Invert(ipv, pv)
+mapLocation(out, px, py, pz, WORLD, SCREEN, { proj, view, pv, ipv }, vp, WEBGL)
+```
 
 ---
 
 ## Relationship to `p5.tree`
 
-`p5.tree` provides a p5.js integration layer built on top of this backend.
+[p5.tree](https://github.com/VisualComputing/p5.tree) is the bridge layer. It reads live renderer state (camera matrices, viewport dimensions, NDC convention) and passes it to `@nakednous/tree` functions. It wires `PoseTrack` and `CameraTrack` to the p5 draw loop, exposes `createTrack` / `getCamera`, and provides `createPanel` for transport and parameter UIs.
 
-It handles renderer-specific tasks such as retrieving camera matrices and applying transforms to p5 objects, while `@nakednous/tree` provides the underlying algorithms.
+`@nakednous/tree` provides the algorithms. The bridge provides the wiring.
 
 ---
 
 ## License
 
-GPL-3.0-only
+GPL-3.0-only  
 © JP Charalambos