@chromatic-coherence/generative-engine 1.6.0 → 1.7.1

package/README.md

@@ -44,6 +44,11 @@ w.start();
 | **Group transforms** | `w.setTransform(group, { translate, rotateY, scale })` — geometry moves rigidly in the vertex stage, zero CPU re-tessellation, shadow pass included. |
 | **Morph targets** | `w.meshMorph(geoA, geoB, opts)` + `w.morph(group, t)` — blend between two vertex sets in the shader (breathing, becoming). Eased like `fade`. |
 | **8 point lights** | Up from 4; `lights[0]` casts the shadows. HDR intensities welcome — bloom catches what exceeds 1.0. |
+| **GPU crowds** | `meshInstanced` — a forest in one draw call; `sway` gives every instance its own wind, `flight: true` makes the batch a ten-thousand-bird murmuration — all evaluated in the vertex stage, zero CPU per frame. |
+| **Real water** | `w.water` — the scene renders a second time through the reflected camera (flocks included) under a wave-displaced fresnel surface. Carve a basin, get a lake. |
+| **Skeletal figures** | `humanoid()` / `quadruped()` / your own rig + `w.figure()` — bones grown from code, bent in the vertex stage, with `walkPose` / `trotPose` procedural cycles. |
+| **Objectives** | `attachObjectives(w)` — give a scene a goal and it drives itself there; a live movement meter tells you what is moving and when it has settled. |
+| **Cinema + flight** | Depth of field, camera motion blur, filmic grade — and `controls: "fly"`: drag to look, scroll to fly. |
 | **The carried light model** | Everything the chart edition learned rides along: GGX + Fresnel specular, procedural micro-relief, the perfusion term (`blood`, `bloodPulse`), pore noise, subsurface rim, coloured hemispheric ambient, fog — now resolving toward a real background colour the engine owns. |
 
 **The ink edition** (`theme: "light"`) still renders any recipe on paper instead of night —
@@ -143,9 +148,14 @@ Bones, grown from code like everything else — no asset pipeline. `humanoid()`
 in the vertex stage — scene, shadows and water reflections alike. `walkPose` / `trotPose`
 ship as procedural cycles; `composePose` takes any per-joint rotations you write.
 
+## Fly controls (v1.7)
+
+`controls: "fly"` — free flight: drag to look, wheel to fly along your gaze, W/A/S/D to
+move (shift for speed), `w.flySpeed` to tune. The pitch clamp opens to near-vertical.
+
 ## Roadmap
 
-The engine's four founding frontiers are landed. What comes next, the scenes will ask for. The chart editions stay lean.
+The engine's founding frontiers are landed. What comes next, the scenes will ask for. The chart editions stay lean.
 
 ## Licence
 

package/dist/world.d.ts

@@ -52,7 +52,9 @@ export type WorldOpts = {
     maxDpr?: number;
     drift?: number;
     parallax?: number;
-    controls?: boolean;
+    /** true = orbit (drag + ctrl-wheel zoom). "fly" (W13) = free flight: drag to look,
+     *  wheel to fly forward/back, W/A/S/D to move, shift for speed. */
+    controls?: boolean | "fly";
     /** shadow maps — lights[0] casts. true, or { size (px, default 2048), softness, bias } */
     shadows?: boolean | {
         size?: number;
@@ -84,6 +86,12 @@ export declare class World {
     private overlay;
     private og;
     private opts;
+    private flyMode;
+    private pitchMin;
+    private pitchMax;
+    private keys;
+    /** W13 fly speed, units/second (shift = 3x). */
+    flySpeed: number;
     private pFace;
     private pLine;
     private pPt;

package/dist/world.js

@@ -34,6 +34,12 @@ export class World {
         this.groupNM.set(normalMat3(mat), i * 9);
     }
     constructor(o) {
+        this.flyMode = false;
+        this.pitchMin = 0.18;
+        this.pitchMax = 0.95;
+        this.keys = new Set();
+        /** W13 fly speed, units/second (shift = 3x). */
+        this.flySpeed = 420;
         this.instanced = [];
         /** W9 — the one wind that blows through every swaying instanced batch */
         this.wind = { dir: v3(1, 0, 0.35), speed: 1 };
@@ -159,8 +165,13 @@ export class World {
             maxDpr: o.maxDpr ?? 2,
             drift: o.drift ?? 0.045,
             parallax: o.parallax ?? 0.3,
-            controls: o.controls ?? false,
+            controls: !!o.controls,
         };
+        this.flyMode = o.controls === "fly";
+        if (this.flyMode) {
+            this.pitchMin = -1.15;
+            this.pitchMax = 1.15;
+        }
         if (o.camera) {
             if (o.camera.target)
                 this.cam.target = o.camera.target;
@@ -264,11 +275,26 @@ export class World {
         };
         const upFn = () => { dragging = false; cv.style.cursor = "grab"; };
         const wheel = (e) => {
+            if (this.flyMode) {
+                e.preventDefault();
+                // fly: the wheel moves the camera along its own gaze
+                const d = -e.deltaY * this.flySpeed * 0.004;
+                this.cam.target = add(this.cam.target, scale(this.fw, d));
+                return;
+            }
             if (!e.ctrlKey && !e.metaKey)
                 return;
             e.preventDefault();
             this.cam.distT = clamp(this.cam.distT + e.deltaY * 0.6, 120, 2200);
         };
+        const kdown = (e) => { if (this.flyMode)
+            this.keys.add(e.key.toLowerCase()); };
+        const kup = (e) => { this.keys.delete(e.key.toLowerCase()); };
+        if (this.flyMode) {
+            window.addEventListener("keydown", kdown);
+            window.addEventListener("keyup", kup);
+            this.cleanup.push(() => { window.removeEventListener("keydown", kdown); window.removeEventListener("keyup", kup); });
+        }
         cv.addEventListener("pointerdown", down);
         cv.addEventListener("pointermove", move);
         cv.addEventListener("pointerup", upFn);
@@ -462,13 +488,26 @@ export class World {
     overlay2d(cb) { cb(this.og, this); }
     // ── camera + CPU projection for pick/labels ──
     setupCamera(t, dt) {
+        if (this.flyMode && this.keys.size && dt > 0) { // W13: keys fly the camera
+            const sp = this.flySpeed * (this.keys.has("shift") ? 3 : 1) * dt;
+            let m = v3();
+            if (this.keys.has("w"))
+                m = add(m, scale(this.fw, sp));
+            if (this.keys.has("s"))
+                m = add(m, scale(this.fw, -sp));
+            if (this.keys.has("a"))
+                m = add(m, scale(this.rt, -sp));
+            if (this.keys.has("d"))
+                m = add(m, scale(this.rt, sp));
+            this.cam.target = add(this.cam.target, m);
+        }
         this.mx += (this.mxT - this.mx) * Math.min(1, dt * 3);
         this.my += (this.myT - this.my) * Math.min(1, dt * 3);
         this.cam.yawUser += (this.yawUserT - this.cam.yawUser) * Math.min(1, dt * 5);
         this.cam.pitchUser += (this.pitchUserT - this.cam.pitchUser) * Math.min(1, dt * 5);
         this.cam.dist += (this.cam.distT - this.cam.dist) * Math.min(1, dt * 4);
         const yaw = this.cam.yawBase + t * this.opts.drift + this.cam.yawUser + this.mx * this.opts.parallax;
-        const pitch = clamp(this.cam.pitch + this.cam.pitchUser + this.my * this.opts.parallax * 0.5, 0.18, 0.95);
+        const pitch = clamp(this.cam.pitch + this.cam.pitchUser + this.my * this.opts.parallax * 0.5, this.pitchMin, this.pitchMax);
         const cp = Math.cos(pitch), sp = Math.sin(pitch);
         this.cx = add(this.cam.target, scale(v3(cp * Math.cos(yaw), sp, cp * Math.sin(yaw)), this.cam.dist));
         this.fw = norm(sub(this.cam.target, this.cx));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chromatic-coherence/generative-engine",
-  "version": "1.6.0",
-  "description": "THE THIRD ENGINE — a zero-dependency WebGL2 graphics engine grown from generative-charts-3d: HDR + bloom + SSAO post chain, hardware-PCF shadow maps, a geometry stdlib, ribbon strokes, group transforms and morph targets. The charts API rides on top unchanged.",
+  "version": "1.7.1",
+  "description": "A zero-dependency WebGL2 graphics engine where everything is grown from code — no models, no textures, no asset pipeline. Real light and shadow with a cinematic HDR finish (bloom, SSAO, filmic grade, depth of field, motion blur), a geometry stdlib, GPU crowds (instanced wind, ten-thousand-bird flocks), real water with planar reflections, skeletal figures with procedural walk cycles, free-flight controls, and scenes that drive themselves toward objectives. The Generative Charts API rides on top unchanged.",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",