@woosh/meep-engine 3.0.0 → 3.0.1

package/editor/particles/rebuildParticleEmitter.js

@@ -1,18 +1,19 @@
-import { ParticleEmitter } from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
-import { ParticleEmitterFlag } from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
-import { ParticleEmitterSystem } from "../../src/engine/graphics/particles/ecs/ParticleEmitterSystem.js";
+import {
+    ParticleEmitter
+} from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import { ParticleEmitterSystem3 } from "../../src/engine/graphics3/ParticleEmitterSystem3.js";
 
 /**
  * Rebuild a live particle emitter after structural edits (layers, sprites, parameter
- * tracks): pull it out of the particle engine, reset its built state, run the full
- * build sequence, put it back. Sleep state is preserved.
+ * tracks): the system pulls it out of the particle engine, runs the full build sequence and puts
+ * it back. Sleep state is preserved.
  *
  * @param {EntityManager} entityManager
  * @param {number} entity
  * @returns {boolean} false when the entity has no emitter or no emitter system runs
  */
 export function rebuildParticleEmitter(entityManager, entity) {
-    const system = entityManager.getSystem(ParticleEmitterSystem);
+    const system = entityManager.getSystem(ParticleEmitterSystem3);
 
     if (system === null) {
         return false;
@@ -24,26 +25,7 @@ export function rebuildParticleEmitter(entityManager, entity) {
         return false;
     }
 
-    const particleEngine = system.particleEngine;
-
-    const isSleeping = emitter.getFlag(ParticleEmitterFlag.Sleeping);
-
-    particleEngine.remove(emitter);
-
-    if (system.renderLayer.visibleSet.contains(emitter.mesh)) {
-        system.renderLayer.visibleSet.forceRemove(emitter.mesh);
-    }
-
-    emitter.clearFlag(ParticleEmitterFlag.Built | ParticleEmitterFlag.Initialized);
-
-    emitter.registerLayerParameters();
-    emitter.build();
-    emitter.initialize();
-    emitter.computeBoundingBox();
-
-    particleEngine.add(emitter);
-
-    emitter.writeFlag(ParticleEmitterFlag.Sleeping, isSleeping);
+    system.rebuild(emitter);
 
     return true;
 }

package/editor/process/symbolic/CameraSymbolicDisplay.js

@@ -1,146 +1,146 @@
-import { DEG_TO_RAD } from "../../../src/core/math/DEG_TO_RAD.js";
-import { v3_quaternion_apply } from "../../../src/core/geom/vec3/v3_quaternion_apply.js";
-import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
-import { Camera } from "../../../src/engine/graphics/ecs/camera/Camera.js";
-import { Gizmo } from "../../../src/engine/graphics/render/gizmo/Gizmo.js";
-import { entity_is_editor_owned, SymbolicDisplay } from "./SymbolicDisplay.js";
-
-/**
- * @type {number[]}
- */
-const CAMERA_COLOR = [0.4, 0.9, 1, 1];
-
-/**
- * Which corners are joined: the near rectangle, the far one, and the four edges between them.
- *
- * @type {number[]}
- */
-const EDGES = [
-    0, 1, 1, 2, 2, 3, 3, 0,
-    4, 5, 5, 6, 6, 7, 7, 4,
-    0, 4, 1, 5, 2, 6, 3, 7
-];
-
-/**
- * Eight frustum corners in world space, near plane first.
- *
- * @type {Float32Array}
- */
-const corners = new Float32Array(24);
-
-/**
- * @type {Float32Array}
- */
-const from = new Float32Array(3);
-
-/**
- * @type {Float32Array}
- */
-const to = new Float32Array(3);
-
-/**
- * The two depths the corners are taken at, near then far.
- *
- * @type {Float64Array}
- */
-const depths = new Float64Array(2);
-
-/**
- * The volume a camera entity can see.
- *
- * **Built from the component rather than from a renderer's camera object.** `Camera.object` is a
- * three `PerspectiveCamera` and is `null` under Shade, which is why the three `CameraHelper` this
- * replaces could not survive the port; everything the frustum needs — field of view, the two clip
- * planes — is on the component, and where the camera is and which way it faces is its `Transform`.
- * The one thing that is not is the aspect ratio, which belongs to the frame rather than to the
- * camera: it is the viewport's, exactly as the renderer's own is.
- *
- * **Perspective always, because that is what gets drawn.** `Camera.projectionType` carries an
- * orthographic option and no renderer in the program reads it — `CameraSystem3` copies the field of
- * view and the clip planes and nothing else — so a symbol that branched on it would be drawing a
- * projection the game cannot render.
- *
- * The transform's scale is deliberately not applied. A camera has no size, and a scaled entity
- * carrying one still sees exactly as far as its clip planes say.
- *
- * @see SymbolicDisplay
- */
-export class CameraSymbolicDisplay extends SymbolicDisplay {
-    /**
-     * Record a frustum per camera entity.
-     *
-     * The engine's viewport is expected to have a size: `preRender` is dispatched from inside a
-     * frame, and a frame is not drawn into a collapsed viewport at all.
-     *
-     * @param {EntityComponentDataset} dataset
-     */
-    record(dataset) {
-        const viewport = this.engine.graphics.viewport.size;
-        const aspect = viewport.x / viewport.y;
-
-        Gizmo.color = CAMERA_COLOR;
-
-        dataset.traverseEntities([Camera, Transform], (camera, transform, entity) => {
-            if (entity_is_editor_owned(dataset, entity)) {
-                return;
-            }
-
-            this.#write_corners(camera, transform, aspect);
-
-            for (let i = 0; i < 12; i++) {
-                const a = EDGES[i * 2] * 3;
-                const b = EDGES[i * 2 + 1] * 3;
-
-                from[0] = corners[a];
-                from[1] = corners[a + 1];
-                from[2] = corners[a + 2];
-
-                to[0] = corners[b];
-                to[1] = corners[b + 1];
-                to[2] = corners[b + 2];
-
-                Gizmo.draw_line(from, to);
-            }
-        });
-    }
-
-    /**
-     * @param {Camera} camera
-     * @param {Transform} transform
-     * @param {number} aspect
-     */
-    #write_corners(camera, transform, aspect) {
-        const tangent = Math.tan(camera.fov.getValue() * DEG_TO_RAD / 2);
-
-        const rotation = transform.rotation;
-        const position = transform.position;
-
-        // near plane first, then far, each anticlockwise from the top right as the camera sees it
-        depths[0] = camera.clip_near;
-        depths[1] = camera.clip_far;
-
-        for (let plane = 0; plane < 2; plane++) {
-            const depth = depths[plane];
-
-            const half_height = depth * tangent;
-            const half_width = half_height * aspect;
-
-            for (let corner = 0; corner < 4; corner++) {
-                const x = (corner === 0 || corner === 3) ? half_width : -half_width;
-                const y = (corner === 0 || corner === 1) ? half_height : -half_height;
-
-                const address = (plane * 4 + corner) * 3;
-
-                v3_quaternion_apply(
-                    corners, address,
-                    x, y, depth,
-                    rotation.x, rotation.y, rotation.z, rotation.w
-                );
-
-                corners[address] += position.x;
-                corners[address + 1] += position.y;
-                corners[address + 2] += position.z;
-            }
-        }
-    }
-}
+import { DEG_TO_RAD } from "../../../src/core/math/DEG_TO_RAD.js";
+import { v3_quaternion_apply } from "../../../src/core/geom/vec3/v3_quaternion_apply.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { Camera } from "../../../src/engine/graphics/ecs/camera/Camera.js";
+import { Gizmo } from "../../../src/engine/graphics/render/gizmo/Gizmo.js";
+import { entity_is_editor_owned, SymbolicDisplay } from "./SymbolicDisplay.js";
+
+/**
+ * @type {number[]}
+ */
+const CAMERA_COLOR = [0.4, 0.9, 1, 1];
+
+/**
+ * Which corners are joined: the near rectangle, the far one, and the four edges between them.
+ *
+ * @type {number[]}
+ */
+const EDGES = [
+    0, 1, 1, 2, 2, 3, 3, 0,
+    4, 5, 5, 6, 6, 7, 7, 4,
+    0, 4, 1, 5, 2, 6, 3, 7
+];
+
+/**
+ * Eight frustum corners in world space, near plane first.
+ *
+ * @type {Float32Array}
+ */
+const corners = new Float32Array(24);
+
+/**
+ * @type {Float32Array}
+ */
+const from = new Float32Array(3);
+
+/**
+ * @type {Float32Array}
+ */
+const to = new Float32Array(3);
+
+/**
+ * The two depths the corners are taken at, near then far.
+ *
+ * @type {Float64Array}
+ */
+const depths = new Float64Array(2);
+
+/**
+ * The volume a camera entity can see.
+ *
+ * **Built from the component rather than from a renderer's camera object.** A camera entity has no
+ * renderer object of its own, which is why the three `CameraHelper` this replaces could not survive
+ * the port; everything the frustum needs — field of view, the two clip planes — is on the component,
+ * and where the camera is and which way it faces is its `Transform`.
+ * The one thing that is not is the aspect ratio, which belongs to the frame rather than to the
+ * camera: it is the viewport's, exactly as the renderer's own is.
+ *
+ * **Perspective always, because that is what gets drawn.** `Camera.projectionType` carries an
+ * orthographic option and no renderer in the program reads it — `CameraSystem3` copies the field of
+ * view and the clip planes and nothing else — so a symbol that branched on it would be drawing a
+ * projection the game cannot render.
+ *
+ * The transform's scale is deliberately not applied. A camera has no size, and a scaled entity
+ * carrying one still sees exactly as far as its clip planes say.
+ *
+ * @see SymbolicDisplay
+ */
+export class CameraSymbolicDisplay extends SymbolicDisplay {
+    /**
+     * Record a frustum per camera entity.
+     *
+     * The engine's viewport is expected to have a size: `preRender` is dispatched from inside a
+     * frame, and a frame is not drawn into a collapsed viewport at all.
+     *
+     * @param {EntityComponentDataset} dataset
+     */
+    record(dataset) {
+        const viewport = this.engine.graphics.viewport.size;
+        const aspect = viewport.x / viewport.y;
+
+        Gizmo.color = CAMERA_COLOR;
+
+        dataset.traverseEntities([Camera, Transform], (camera, transform, entity) => {
+            if (entity_is_editor_owned(dataset, entity)) {
+                return;
+            }
+
+            this.#write_corners(camera, transform, aspect);
+
+            for (let i = 0; i < 12; i++) {
+                const a = EDGES[i * 2] * 3;
+                const b = EDGES[i * 2 + 1] * 3;
+
+                from[0] = corners[a];
+                from[1] = corners[a + 1];
+                from[2] = corners[a + 2];
+
+                to[0] = corners[b];
+                to[1] = corners[b + 1];
+                to[2] = corners[b + 2];
+
+                Gizmo.draw_line(from, to);
+            }
+        });
+    }
+
+    /**
+     * @param {Camera} camera
+     * @param {Transform} transform
+     * @param {number} aspect
+     */
+    #write_corners(camera, transform, aspect) {
+        const tangent = Math.tan(camera.fov.getValue() * DEG_TO_RAD / 2);
+
+        const rotation = transform.rotation;
+        const position = transform.position;
+
+        // near plane first, then far, each anticlockwise from the top right as the camera sees it
+        depths[0] = camera.clip_near;
+        depths[1] = camera.clip_far;
+
+        for (let plane = 0; plane < 2; plane++) {
+            const depth = depths[plane];
+
+            const half_height = depth * tangent;
+            const half_width = half_height * aspect;
+
+            for (let corner = 0; corner < 4; corner++) {
+                const x = (corner === 0 || corner === 3) ? half_width : -half_width;
+                const y = (corner === 0 || corner === 1) ? half_height : -half_height;
+
+                const address = (plane * 4 + corner) * 3;
+
+                v3_quaternion_apply(
+                    corners, address,
+                    x, y, depth,
+                    rotation.x, rotation.y, rotation.z, rotation.w
+                );
+
+                corners[address] += position.x;
+                corners[address + 1] += position.y;
+                corners[address + 2] += position.z;
+            }
+        }
+    }
+}

package/editor/tools/SelectionTool.js

@@ -108,8 +108,7 @@ class SelectionTool extends Tool {
         /*
          The active camera's own clip range, off the **component**. What a selection needs from a
          camera is how far it can see — the projection itself comes from the facade, which is the
-         only thing that knows it on either renderer, and `Camera.object` is three's and is null
-         under Shade.
+         only thing that knows it.
         */
         let near = 0.1;
         let far = 1000;

package/editor/tools/TransformToolV2.js

@@ -246,9 +246,8 @@ export class TransformToolV2 extends Tool {
     }
 
     /**
-     * The gizmo asks the graphics engine for rays and nothing else, so this needs no camera of its
-     * own — which is what it used to want, as `Camera.object`, three's camera and `null` under
-     * Shade.
+     * The gizmo asks the graphics engine for rays and nothing else, so this needs no camera object
+     * of its own, which is what the three version wanted.
      */
     initialize() {
         super.initialize();