@scenoco-three/editor 0.5.0 → 0.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scenoco-three/editor",
-  "version": "0.5.0",
-  "description": "Local visual editor for SceNoCo scenes, with an observation-only MCP server so an agent can see and drive the same live scene.",
+  "version": "0.6.0",
+  "description": "The standalone SceNoCo editor: a static site that opens any .scene.xml from a folder or a URL, builds the scene live, and saves back \u2014 a tree, an inspector, gizmos. `scenoco-editor` serves it locally.",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -14,25 +14,20 @@
   "bin": {
     "scenoco-editor": "./dist/cli/index.js"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
+  "main": "./dist/cli/index.js",
   "files": [
     "dist",
-    "app"
+    "dist-app"
   ],
   "keywords": [
     "three",
     "threejs",
     "scenoco",
     "editor",
-    "preview",
-    "render",
+    "scene",
+    "xml",
+    "gizmo",
+    "inspector",
     "gamedev"
   ],
   "publishConfig": {
@@ -40,29 +35,30 @@
   },
   "scripts": {
     "prebuild": "rm -rf dist",
-    "build": "tsc -p tsconfig.build.json && chmod +x dist/cli/index.js",
+    "build": "tsc -p tsconfig.build.json && chmod +x dist/cli/index.js && npm run build:app",
+    "build:app": "node scripts/static-model.mjs && node scripts/static-assets.mjs && vite build --config vite.static.config.ts",
+    "preview:app": "vite preview --config vite.static.config.ts --port 5195 --strictPort",
     "typecheck": "npm --prefix ../core run build && npm --prefix ../compiler run build && tsc --noEmit -p tsconfig.json"
   },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
-    "@scenoco-three/compiler": "^0.5.0",
-    "@scenoco-three/core": "^0.5.0",
+  "dependencies": {},
+  "peerDependencies": {},
+  "devDependencies": {
+    "@scenoco-three/audio": "^0.6.0",
+    "@scenoco-three/box2d": "^0.6.0",
+    "@scenoco-three/collision": "^0.6.0",
+    "@scenoco-three/compiler": "^0.6.0",
+    "@scenoco-three/core": "^0.6.0",
+    "@scenoco-three/particles": "^0.6.0",
+    "@scenoco-three/postfx": "^0.6.0",
+    "@scenoco-three/ui": "^0.6.0",
+    "@types/react": "^18.3.31",
+    "@types/react-dom": "^18.3.7",
     "@vitejs/plugin-react": "^6.0.3",
     "lucide-react": "^0.468.0",
     "react": "^18.3.1",
     "react-arborist": "^3.4.0",
     "react-dom": "^18.3.1",
-    "ws": "^8.18.0",
-    "zod": "^4.0.0",
+    "vite": "^8.0.0",
     "zustand": "^5.0.2"
-  },
-  "peerDependencies": {
-    "three": ">=0.160.0",
-    "vite": ">=5"
-  },
-  "devDependencies": {
-    "@types/react": "^18.3.31",
-    "@types/react-dom": "^18.3.7",
-    "@types/ws": "^8.5.13"
   }
-}
+}

package/app/cameraRig.ts

@@ -1,118 +0,0 @@
-import { Euler, Quaternion, Vector3, type PerspectiveCamera } from 'three';
-
-/**
- * Owns the editor camera's orientation (yaw/pitch, roll-free) and exposes simple
- * verbs that both the desktop (mouse/keyboard) and touch input adapters call, so
- * the two never fight over the camera transform. Call `sync()` once per frame.
- */
-export class CameraRig {
-  readonly euler = new Euler(0, 0, 0, 'YXZ');
-  /** Base movement speed (world units/sec), tuned by the wheel / scene size. */
-  speed: number;
-  /**
-   * Distance to the focus point (Unity scene-camera pivot). Touch pan/dolly scale
-   * by this, so motion stays consistent on screen at any zoom — fine near objects,
-   * fast when far. Set by `frameOn`; dolly shrinks/grows it.
-   */
-  focusDistance: number;
-
-  private readonly q = new Quaternion();
-  private readonly v = new Vector3();
-
-  /** Where a focus glide is taking the camera, while one is running. */
-  private glideTo: Vector3 | null = null;
-
-  readonly camera: PerspectiveCamera;
-
-  constructor(camera: PerspectiveCamera, target: Vector3) {
-    this.camera = camera;
-    camera.lookAt(target);
-    this.euler.setFromQuaternion(camera.quaternion);
-    this.speed = Math.max(1, camera.position.distanceTo(target) * 0.5);
-    this.focusDistance = Math.max(0.1, camera.position.distanceTo(target));
-  }
-
-  /**
-   * Frame a point: keep looking exactly the way you are, and move until it is centred
-   * `distance` away.
-   *
-   * This is Unity's F, and the angle is the whole of it. Turning to face the selection instead
-   * throws away the view the person spent their time arranging — they lined the scene up from
-   * one side, pressed F to get closer to a node, and now they are looking at it from wherever
-   * the pivot maths decided. Keeping the orientation means F only ever answers "put that in
-   * front of me", which is the question it was asked.
-   *
-   * The camera glides rather than teleports: a cut leaves you working out where you ended up,
-   * and the motion is what tells you the scene did not change — only your seat.
-   */
-  frameOn(point: Vector3, distance: number): void {
-    this.focusDistance = Math.max(0.1, distance);
-    // Straight back along the current view direction — `-Z` in camera space, which is where the
-    // camera already looks, so nothing about the orientation moves.
-    this.glideTo = point.clone().addScaledVector(this.forward(this.v), -this.focusDistance);
-    this.speed = Math.max(1, this.focusDistance * 0.5); // fly speed scales with how far out we sit
-  }
-
-  /** The unit vector the camera currently looks along. */
-  private forward(into: Vector3): Vector3 {
-    return into.set(0, 0, -1).applyQuaternion(this.q.setFromEuler(this.euler));
-  }
-
-  /** Add yaw/pitch in radians (pitch clamped to avoid flipping). */
-  rotate(dYaw: number, dPitch: number): void {
-    this.glideTo = null; // the person is driving now
-    this.euler.y += dYaw;
-    this.euler.x = clamp(this.euler.x + dPitch, -Math.PI / 2 + 0.01, Math.PI / 2 - 0.01);
-  }
-
-  /**
-   * Translate: `right` and `forward` in camera-local space, `up` along **world** up.
-   *
-   * Local up is the tempting reading and the wrong one. With the camera pitched down at the
-   * scene — which is where an editor camera spends its life — a local "up" also carries you
-   * backwards, so Q and E slide the view around instead of raising and lowering it. Unity's scene
-   * camera uses world up for the same reason.
-   */
-  move(right: number, up: number, forward: number): void {
-    this.glideTo = null; // any input cancels a focus glide — the camera has one owner at a time
-    this.v.set(right, 0, -forward).applyQuaternion(this.q.setFromEuler(this.euler));
-    this.v.y += up;
-    this.camera.position.add(this.v);
-  }
-
-  /**
-   * Apply the orientation, and advance a focus glide. Call once per frame, after input.
-   *
-   * Frame-rate independent easing: the *fraction of the remaining distance* covered per second
-   * is fixed, so the same glide takes the same time at 60Hz and at 144Hz. `1 - k ** dt` is the
-   * exponential form of that — the naive `lerp(a, b, 0.1)` per frame is twice as fast on a
-   * 120Hz display, which is how a smooth camera on one machine becomes a snap on another.
-   */
-  sync(dt = 0): void {
-    this.camera.quaternion.setFromEuler(this.euler);
-    if (!this.glideTo) return;
-    const remaining = this.v.subVectors(this.glideTo, this.camera.position);
-    // Close enough that another frame of easing would be invisible: land exactly and stop, so
-    // the camera is never left a hair off with a live tween attached to it.
-    if (remaining.lengthSq() < 1e-8) {
-      this.camera.position.copy(this.glideTo);
-      this.glideTo = null;
-      return;
-    }
-    this.camera.position.addScaledVector(remaining, 1 - GLIDE_LEFT_PER_SECOND ** dt);
-  }
-}
-
-/**
- * The fraction of the distance to the focus target still left after one second.
- *
- * Measured rather than guessed: at 1e-6 the camera is 94% of the way there in 0.2s and 98.5% in
- * 0.3s, so the move reads as quick and decisive and is visually over in about a third of a
- * second. Ten times gentler (1e-5) drifts long enough to feel laggy on a phone; ten times
- * sharper is indistinguishable from a cut.
- */
-const GLIDE_LEFT_PER_SECOND = 1e-6;
-
-function clamp(v: number, lo: number, hi: number): number {
-  return Math.max(lo, Math.min(hi, v));
-}

package/app/commands.ts

@@ -1,78 +0,0 @@
-/**
- * The stateful edit primitive. Every mutation in the editor is a `Command` so it
- * can be undone and (because each one also mutates the compiled scene) saved as a
- * diff. Commands are deliberately tiny — `apply` redoes, `invert` undoes.
- */
-export interface Command {
-  /** Human label (undo menu / debugging). */
-  readonly label: string;
-  apply(): void;
-  invert(): void;
-  /**
-   * Edits sharing a key, applied back-to-back, collapse into a single undo step.
-   * A gizmo drag or a numeric scrub emits one command per frame; undo should
-   * rewind the whole gesture, not each intermediate value.
-   */
-  readonly coalesceKey?: string;
-}
-
-/** Undo/redo history with same-key coalescing. `onChange` fires after every mutation. */
-export class UndoStack {
-  private readonly undoables: Command[] = [];
-  private readonly redoables: Command[] = [];
-
-  private readonly onChange: (() => void) | undefined;
-
-  constructor(onChange?: () => void) {
-    this.onChange = onChange;
-  }
-
-  /** Apply a command and record it, merging into the previous one if keys match. */
-  run(cmd: Command): void {
-    cmd.apply();
-    const prev = this.undoables[this.undoables.length - 1];
-    if (cmd.coalesceKey !== undefined && prev?.coalesceKey === cmd.coalesceKey) {
-      // Adopt the latest `apply` (current value) but keep the earliest `invert`
-      // (the pre-gesture state), so one undo rewinds the entire gesture.
-      this.undoables[this.undoables.length - 1] = {
-        label: prev.label,
-        coalesceKey: prev.coalesceKey,
-        apply: cmd.apply,
-        invert: prev.invert,
-      };
-    } else {
-      this.undoables.push(cmd);
-    }
-    this.redoables.length = 0;
-    this.onChange?.();
-  }
-
-  undo(): void {
-    const cmd = this.undoables.pop();
-    if (!cmd) return;
-    cmd.invert();
-    this.redoables.push(cmd);
-    this.onChange?.();
-  }
-
-  redo(): void {
-    const cmd = this.redoables.pop();
-    if (!cmd) return;
-    cmd.apply();
-    this.undoables.push(cmd);
-    this.onChange?.();
-  }
-
-  get canUndo(): boolean {
-    return this.undoables.length > 0;
-  }
-  get canRedo(): boolean {
-    return this.redoables.length > 0;
-  }
-
-  clear(): void {
-    this.undoables.length = 0;
-    this.redoables.length = 0;
-    this.onChange?.();
-  }
-}

package/app/desktopControls.ts

@@ -1,47 +0,0 @@
-import { Input, KeyCode, MouseButton } from '@scenoco-three/core';
-import type { CameraRig } from './cameraRig.js';
-
-/**
- * Desktop fly navigation via `engine.input` (Unity scene-view style):
- *   • hold RIGHT mouse to look · WASD move · Q/E down/up · Shift faster · wheel speed.
- */
-export class DesktopControls {
-  private readonly look = 0.0025; // radians per pixel
-
-  private readonly rig: CameraRig;
-  /** v2's input is one singleton attached to the canvas, not a per-engine manager. */
-  private readonly input = Input;
-
-  constructor(rig: CameraRig) {
-    this.rig = rig;
-  }
-
-  /** Advance one frame (call after `engine.tick`). */
-  update(dt: number): void {
-    const { input, rig } = this;
-
-    const wheel = input.mouseScrollDelta.y;
-    if (wheel !== 0) rig.speed = clamp(rig.speed * (wheel < 0 ? 1.1 : 1 / 1.1), 0.05, 1000);
-
-    if (input.getMouseButton(MouseButton.Right)) {
-      const d = input.mouseDelta;
-      rig.rotate(-d.x * this.look, -d.y * this.look);
-    }
-
-    const right = axis(input.getKey(KeyCode.D), input.getKey(KeyCode.A));
-    const up = axis(input.getKey(KeyCode.E), input.getKey(KeyCode.Q));
-    const forward = axis(input.getKey(KeyCode.W), input.getKey(KeyCode.S));
-    if (right || up || forward) {
-      const len = Math.hypot(right, up, forward);
-      const step = (rig.speed * (input.getKey(KeyCode.LeftShift) ? 4 : 1) * dt) / len;
-      rig.move(right * step, up * step, forward * step);
-    }
-  }
-}
-
-function axis(pos: boolean, neg: boolean): number {
-  return (pos ? 1 : 0) - (neg ? 1 : 0);
-}
-function clamp(v: number, lo: number, hi: number): number {
-  return Math.max(lo, Math.min(hi, v));
-}