@woosh/meep-engine 3.15.0 → 3.16.0

package/editor/process/symbolic/GridPositionSymbolicDisplay.js

@@ -1,7 +1,7 @@
 import { SurfacePoint3 } from "../../../src/core/geom/3d/SurfacePoint3.js";
 import Vector3 from "../../../src/core/geom/Vector3.js";
 import { obtainTerrain } from "../../../src/engine/ecs/terrain/util/obtainTerrain.js";
-import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
 import { Gizmo } from "../../../src/engine/graphics/render/gizmo/Gizmo.js";
 import GridPosition from "../../../src/engine/grid/position/GridPosition.js";
 import { entity_is_editor_owned, SymbolicDisplay } from "./SymbolicDisplay.js";
@@ -70,7 +70,7 @@ export class GridPositionSymbolicDisplay extends SymbolicDisplay {
 
         Gizmo.color = TETHER_COLOR;
 
-        dataset.traverseEntities([GridPosition, Transform], (grid_position, transform, entity) => {
+        dataset.traverseEntities([GridPosition, Transform64], (grid_position, transform, entity) => {
             if (entity_is_editor_owned(dataset, entity)) {
                 return;
             }
@@ -88,12 +88,12 @@ export class GridPositionSymbolicDisplay extends SymbolicDisplay {
                 return;
             }
 
-            const position = transform.position;
+            const position = transform.translation;
             const ground = contact.position;
 
-            from[0] = position.x;
-            from[1] = position.y;
-            from[2] = position.z;
+            from[0] = position[0];
+            from[1] = position[1];
+            from[2] = position[2];
 
             to[0] = ground.x;
             to[1] = ground.y;

package/editor/process/symbolic/LightSymbolicDisplay.js

@@ -1,172 +1,172 @@
-import { v3_quaternion_apply } from "../../../src/core/geom/vec3/v3_quaternion_apply.js";
-import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
-import { Light } from "../../../src/engine/graphics/ecs/light/Light.js";
-import { LightType } from "../../../src/engine/graphics/ecs/light/LightType.js";
-import { Gizmo } from "../../../src/engine/graphics/render/gizmo/Gizmo.js";
-import { gizmo_draw_wire_circle } from "./gizmo_draw_wire_circle.js";
-import { entity_is_editor_owned, SymbolicDisplay } from "./SymbolicDisplay.js";
-
-/**
- * @type {number[]}
- */
-const LIGHT_COLOR = [1, 0.9, 0.3, 1];
-
-/**
- * How many straight pieces a drawn circle is made of. Enough to read as round at the distance an
- * editor looks at a light from, and few enough that a scene full of lights is not a scene full of
- * lines.
- *
- * @type {number}
- */
-const CIRCLE_SEGMENTS = 24;
-
-/**
- * How far a directional light's arrow reaches, in world units. It has no range to draw — that is
- * what makes it directional — so the length is the symbol's own and says only which way.
- *
- * @type {number}
- */
-const DIRECTION_LENGTH = 2;
-
-/**
- * @type {number}
- */
-const DIRECTION_DISC_RADIUS = 0.5;
-
-/**
- * @type {Float32Array}
- */
-const origin = new Float32Array(3);
-
-/**
- * @type {Float32Array}
- */
-const forward = new Float32Array(3);
-
-/**
- * @type {Float32Array}
- */
-const right = new Float32Array(3);
-
-/**
- * @type {Float32Array}
- */
-const up = new Float32Array(3);
-
-/**
- * @type {Float32Array}
- */
-const rim_center = new Float32Array(3);
-
-/**
- * @type {Float32Array}
- */
-const rim_point = new Float32Array(3);
-
-/**
- * What a light reaches, drawn as the shape of its own type.
- *
- * **Range rather than a fixed-size badge.** three's `PointLightHelper` drew a unit sphere whatever
- * the light's distance was, so the symbol said where the light was and nothing about what it lit;
- * the useful question in an editor is the second one, and the component already answers it. Where
- * the light *is* stays answered too — the positioned marker draws that, on the same entity.
- *
- * **A light shines along its forward**, which is `LightSystem`'s stated convention and puts it on
- * the transform's local +Z. The spot cone and the directional arrow are both built from that, so a
- * light that is turned in the editor turns its symbol with it.
- *
- * @see SymbolicDisplay
- */
-export class LightSymbolicDisplay extends SymbolicDisplay {
-    /**
-     * @param {EntityComponentDataset} dataset
-     */
-    record(dataset) {
-        Gizmo.color = LIGHT_COLOR;
-
-        dataset.traverseEntities([Light, Transform], (light, transform, entity) => {
-            if (entity_is_editor_owned(dataset, entity)) {
-                return;
-            }
-
-            const position = transform.position;
-
-            origin[0] = position.x;
-            origin[1] = position.y;
-            origin[2] = position.z;
-
-            switch (light.type.getValue()) {
-                case LightType.POINT:
-                    Gizmo.draw_wire_sphere(origin, light.distance.getValue());
-                    break;
-
-                case LightType.SPOT:
-                    this.#write_basis(transform);
-                    this.#draw_cone(light.angle.getValue(), light.distance.getValue());
-                    break;
-
-                case LightType.DIRECTION:
-                    this.#write_basis(transform);
-                    this.#draw_arrow();
-                    break;
-            }
-        });
-    }
-
-    /**
-     * Fill {@link forward}, {@link right} and {@link up} with the entity's own axes.
-     *
-     * @param {Transform} transform
-     */
-    #write_basis(transform) {
-        const rotation = transform.rotation;
-
-        v3_quaternion_apply(forward, 0, 0, 0, 1, rotation.x, rotation.y, rotation.z, rotation.w);
-        v3_quaternion_apply(right, 0, 1, 0, 0, rotation.x, rotation.y, rotation.z, rotation.w);
-        v3_quaternion_apply(up, 0, 0, 1, 0, rotation.x, rotation.y, rotation.z, rotation.w);
-    }
-
-    /**
-     * Four edges to the rim of the cone, and the rim.
-     *
-     * @param {number} half_angle in radians, from the axis to the edge
-     * @param {number} length
-     */
-    #draw_cone(half_angle, length) {
-        const radius = Math.tan(half_angle) * length;
-
-        for (let c = 0; c < 3; c++) {
-            rim_center[c] = origin[c] + forward[c] * length;
-        }
-
-        // the four edges are the rim's own axis points, so an edge and the rim always meet
-        for (let i = 0; i < 4; i++) {
-            const angle = i * (Math.PI / 2);
-
-            const cos = Math.cos(angle) * radius;
-            const sin = Math.sin(angle) * radius;
-
-            for (let c = 0; c < 3; c++) {
-                rim_point[c] = rim_center[c] + right[c] * cos + up[c] * sin;
-            }
-
-            Gizmo.draw_line(origin, rim_point);
-        }
-
-        gizmo_draw_wire_circle(rim_center, right, up, radius, CIRCLE_SEGMENTS);
-    }
-
-    /**
-     * A shaft along the direction, and a disc across it to say the light is a plane of rays rather
-     * than a point.
-     */
-    #draw_arrow() {
-        for (let c = 0; c < 3; c++) {
-            rim_center[c] = origin[c] + forward[c] * DIRECTION_LENGTH;
-        }
-
-        Gizmo.draw_line(origin, rim_center);
-
-        gizmo_draw_wire_circle(origin, right, up, DIRECTION_DISC_RADIUS, CIRCLE_SEGMENTS);
-    }
-}
+import { v3_quaternion_apply } from "../../../src/core/geom/vec3/v3_quaternion_apply.js";
+import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
+import { Light } from "../../../src/engine/graphics/ecs/light/Light.js";
+import { LightType } from "../../../src/engine/graphics/ecs/light/LightType.js";
+import { Gizmo } from "../../../src/engine/graphics/render/gizmo/Gizmo.js";
+import { gizmo_draw_wire_circle } from "./gizmo_draw_wire_circle.js";
+import { entity_is_editor_owned, SymbolicDisplay } from "./SymbolicDisplay.js";
+
+/**
+ * @type {number[]}
+ */
+const LIGHT_COLOR = [1, 0.9, 0.3, 1];
+
+/**
+ * How many straight pieces a drawn circle is made of. Enough to read as round at the distance an
+ * editor looks at a light from, and few enough that a scene full of lights is not a scene full of
+ * lines.
+ *
+ * @type {number}
+ */
+const CIRCLE_SEGMENTS = 24;
+
+/**
+ * How far a directional light's arrow reaches, in world units. It has no range to draw — that is
+ * what makes it directional — so the length is the symbol's own and says only which way.
+ *
+ * @type {number}
+ */
+const DIRECTION_LENGTH = 2;
+
+/**
+ * @type {number}
+ */
+const DIRECTION_DISC_RADIUS = 0.5;
+
+/**
+ * @type {Float32Array}
+ */
+const origin = new Float32Array(3);
+
+/**
+ * @type {Float32Array}
+ */
+const forward = new Float32Array(3);
+
+/**
+ * @type {Float32Array}
+ */
+const right = new Float32Array(3);
+
+/**
+ * @type {Float32Array}
+ */
+const up = new Float32Array(3);
+
+/**
+ * @type {Float32Array}
+ */
+const rim_center = new Float32Array(3);
+
+/**
+ * @type {Float32Array}
+ */
+const rim_point = new Float32Array(3);
+
+/**
+ * What a light reaches, drawn as the shape of its own type.
+ *
+ * **Range rather than a fixed-size badge.** three's `PointLightHelper` drew a unit sphere whatever
+ * the light's distance was, so the symbol said where the light was and nothing about what it lit;
+ * the useful question in an editor is the second one, and the component already answers it. Where
+ * the light *is* stays answered too — the positioned marker draws that, on the same entity.
+ *
+ * **A light shines along its forward**, which is `LightSystem`'s stated convention and puts it on
+ * the transform's local +Z. The spot cone and the directional arrow are both built from that, so a
+ * light that is turned in the editor turns its symbol with it.
+ *
+ * @see SymbolicDisplay
+ */
+export class LightSymbolicDisplay extends SymbolicDisplay {
+    /**
+     * @param {EntityComponentDataset} dataset
+     */
+    record(dataset) {
+        Gizmo.color = LIGHT_COLOR;
+
+        dataset.traverseEntities([Light, Transform64], (light, transform, entity) => {
+            if (entity_is_editor_owned(dataset, entity)) {
+                return;
+            }
+
+            const position = transform.translation;
+
+            origin[0] = position[0];
+            origin[1] = position[1];
+            origin[2] = position[2];
+
+            switch (light.type.getValue()) {
+                case LightType.POINT:
+                    Gizmo.draw_wire_sphere(origin, light.distance.getValue());
+                    break;
+
+                case LightType.SPOT:
+                    this.#write_basis(transform);
+                    this.#draw_cone(light.angle.getValue(), light.distance.getValue());
+                    break;
+
+                case LightType.DIRECTION:
+                    this.#write_basis(transform);
+                    this.#draw_arrow();
+                    break;
+            }
+        });
+    }
+
+    /**
+     * Fill {@link forward}, {@link right} and {@link up} with the entity's own axes.
+     *
+     * @param {Transform64} transform
+     */
+    #write_basis(transform) {
+        const rotation = transform.rotation;
+
+        v3_quaternion_apply(forward, 0, 0, 0, 1, rotation[0], rotation[1], rotation[2], rotation[3]);
+        v3_quaternion_apply(right, 0, 1, 0, 0, rotation[0], rotation[1], rotation[2], rotation[3]);
+        v3_quaternion_apply(up, 0, 0, 1, 0, rotation[0], rotation[1], rotation[2], rotation[3]);
+    }
+
+    /**
+     * Four edges to the rim of the cone, and the rim.
+     *
+     * @param {number} half_angle in radians, from the axis to the edge
+     * @param {number} length
+     */
+    #draw_cone(half_angle, length) {
+        const radius = Math.tan(half_angle) * length;
+
+        for (let c = 0; c < 3; c++) {
+            rim_center[c] = origin[c] + forward[c] * length;
+        }
+
+        // the four edges are the rim's own axis points, so an edge and the rim always meet
+        for (let i = 0; i < 4; i++) {
+            const angle = i * (Math.PI / 2);
+
+            const cos = Math.cos(angle) * radius;
+            const sin = Math.sin(angle) * radius;
+
+            for (let c = 0; c < 3; c++) {
+                rim_point[c] = rim_center[c] + right[c] * cos + up[c] * sin;
+            }
+
+            Gizmo.draw_line(origin, rim_point);
+        }
+
+        gizmo_draw_wire_circle(rim_center, right, up, radius, CIRCLE_SEGMENTS);
+    }
+
+    /**
+     * A shaft along the direction, and a disc across it to say the light is a plane of rays rather
+     * than a point.
+     */
+    #draw_arrow() {
+        for (let c = 0; c < 3; c++) {
+            rim_center[c] = origin[c] + forward[c] * DIRECTION_LENGTH;
+        }
+
+        Gizmo.draw_line(origin, rim_center);
+
+        gizmo_draw_wire_circle(origin, right, up, DIRECTION_DISC_RADIUS, CIRCLE_SEGMENTS);
+    }
+}

package/editor/process/symbolic/ParticleEmitterSymbolicDisplay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitterSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/ParticleEmitterSymbolicDisplay.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;GAYG;AACH;;CAqDC;gCA3HuD,sBAAsB"}
+{"version":3,"file":"ParticleEmitterSymbolicDisplay.d.ts","sourceRoot":"","sources":["../../../../editor/process/symbolic/ParticleEmitterSymbolicDisplay.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;GAYG;AACH;;CAwDC;gCA9HuD,sBAAsB"}

package/editor/process/symbolic/ParticleEmitterSymbolicDisplay.js

@@ -2,7 +2,7 @@ import { m4_compose } from "../../../src/core/geom/3d/mat4/m4_compose.js";
 import { m4_multiply } from "../../../src/core/geom/3d/mat4/m4_multiply.js";
 import Quaternion from "../../../src/core/geom/Quaternion.js";
 import Vector3 from "../../../src/core/geom/Vector3.js";
-import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
 import {
     EmissionShapeType
 } from "../../../src/engine/graphics/particles/particular/engine/emitter/EmissionShapeType.js";
@@ -86,12 +86,15 @@ export class ParticleEmitterSymbolicDisplay extends SymbolicDisplay {
      * @param {EntityComponentDataset} dataset
      */
     record(dataset) {
-        dataset.traverseEntities([ParticleEmitter, Transform], (emitter, transform, entity) => {
+        dataset.traverseEntities([ParticleEmitter, Transform64], (emitter, transform, entity) => {
             if (entity_is_editor_owned(dataset, entity)) {
                 return;
             }
 
-            transform.toMatrix(emitter_matrix);
+            // the matrix sits at offset 0, so the first sixteen elements are it
+            for (let i = 0; i < 16; i++) {
+                emitter_matrix[i] = transform[i];
+            }
 
             // a sphere in the recording has one radius, so a non-uniformly scaled emitter cannot
             // have its emission sphere drawn exactly; x is the component the three version scaled

package/editor/process/symbolic/PositionedMarkerSymbolicDisplay.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../src/core/assert.js";
-import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
 import { Gizmo } from "../../../src/engine/graphics/render/gizmo/Gizmo.js";
 import { entity_is_editor_owned, SymbolicDisplay } from "./SymbolicDisplay.js";
 
@@ -62,16 +62,16 @@ export class PositionedMarkerSymbolicDisplay extends SymbolicDisplay {
     record(dataset) {
         Gizmo.color = this.#color;
 
-        dataset.traverseEntities([this.#component, Transform], (component, transform, entity) => {
+        dataset.traverseEntities([this.#component, Transform64], (component, transform, entity) => {
             if (entity_is_editor_owned(dataset, entity)) {
                 return;
             }
 
-            const position = transform.position;
+            const position = transform.translation;
 
-            scratch_center[0] = position.x;
-            scratch_center[1] = position.y;
-            scratch_center[2] = position.z;
+            scratch_center[0] = position[0];
+            scratch_center[1] = position[1];
+            scratch_center[2] = position[2];
 
             Gizmo.draw_solid_sphere(scratch_center, MARKER_RADIUS);
         });