@woosh/meep-engine 2.131.17 → 2.131.20

package/src/engine/animation/curve/animation_curve_optimize.js

@@ -1,14 +1,19 @@
 import { assert } from "../../../core/assert.js";
 import AABB2 from "../../../core/geom/2d/aabb/AABB2.js";
+import { spline3_hermite_derivative } from "../../../core/math/spline/spline3_hermite_derivative.js";
 import { animation_curve_compute_aabb } from "./animation_curve_compute_aabb.js";
 import { evaluate_two_key_curve } from "./evaluate_two_key_curve.js";
 
 const bounds = new AABB2();
 
-const NORMALIZED_CHECK_DISTANCE = 0.07;
+// Scaling factor to project slope error into value error.
+// 0.125 (1/8th) is a standard approximation for cubic bezier error bounds.
+const TANGENT_ERROR_WEIGHT = 0.125;
 
 /**
- * Compute the value difference in the curve if the `middle` key between `previous` and `next` is removed
+ * Computes importance by checking Position AND Slope integrity.
+ * Uses exact derivative calculation instead of neighbor sampling
+ *
  * @param {Keyframe} key_middle
  * @param {Keyframe} key_previous
  * @param {Keyframe} key_next
@@ -22,30 +27,54 @@ function compute_keyframe_value_effect(
     key_previous,
     key_next
 ) {
+    const duration = key_next.time - key_previous.time;
+
+    // Safety check for zero-duration (duplicate keys handled by outer loop, but safe to guard)
+    if (duration < 1e-9){
+        return 0;
+    }
+
+    // 1. Calculate Normalized Time t [0, 1]
+    const t_relative = key_middle.time - key_previous.time;
+    const t_normalized = t_relative / duration;
 
-    // check if this key contributes to the shape
-    const v1_actual = evaluate_two_key_curve(key_middle.time, key_previous, key_next);
-    const v1_expected = key_middle.value;
+    // 2. Calculate Position Error (The "Hit Test")
+    // Does the simplified curve actually hit the middle key's value?
+    const v_actual = evaluate_two_key_curve(key_middle.time, key_previous, key_next);
+    const v_error = Math.abs(v_actual - key_middle.value);
 
-    const v1_error = Math.abs(v1_actual - v1_expected);
+    // 3. Calculate Derivative Error (The "Shape Test")
+    // Does the simplified curve flow in the same direction as the original key?
 
-    // sample just before the current frame
-    const v0_time = key_middle.time - (key_middle.time - key_previous.time) * NORMALIZED_CHECK_DISTANCE;
+    // NOTE: Hermite basis requires tangents scaled by duration (m0, m1)
+    // We assume keyframes have .outTangent and .inTangent or similar.
+    // If you use standard Hermite data, it looks like this:
+    const m0 = key_previous.outTangent * duration;
+    const m1 = key_next.inTangent * duration;
 
-    const v0_actual = evaluate_two_key_curve(v0_time, key_previous, key_next);
-    const v0_expected = evaluate_two_key_curve(v0_time, key_previous, key_middle);
+    // This returns the derivative in "Value per Normalized Time"
+    const slope_normalized = spline3_hermite_derivative(
+        t_normalized,
+        key_previous.value,
+        key_next.value,
+        m0,
+        m1
+    );
 
-    const v0_error = Math.abs(v0_actual - v0_expected);
+    // Convert to "Value per Second" to match the keyframe's stored tangent
+    const slope_actual = slope_normalized / duration;
 
-    // sample just after the current frame
-    const v2_time = key_middle.time + (key_next.time - key_middle.time) * NORMALIZED_CHECK_DISTANCE;
+    // We compare against the explicit tangent stored on the middle key (or calculated implicit tangent)
+    // Assuming the key has a unified tangent or we use the inTangent
+    const slope_expected = key_middle.inTangent; // or .outTangent, or average if smooth
 
-    const v2_actual = evaluate_two_key_curve(v2_time, key_previous, key_next);
-    const v2_expected = evaluate_two_key_curve(v2_time, key_middle, key_next);
+    const slope_delta = Math.abs(slope_actual - slope_expected);
 
-    const v2_error = Math.abs(v2_actual - v2_expected);
+    // 4. Project Slope Delta into Value Units
+    // If the slope is off by 1 unit/sec, how much drift does that cause over the duration?
+    const slope_error_projected = slope_delta * duration * TANGENT_ERROR_WEIGHT;
 
-    return Math.max(v0_error, v1_error, v2_error);
+    return Math.max(v_error, slope_error_projected);
 }
 
 /**
@@ -65,11 +94,22 @@ export function animation_curve_optimize(
 ) {
     assert.lessThan(error_tolerance, 1, 'error_tolerance must be less than 1');
 
+    let key_count = curve.length;
+
+    if (key_count <= 1) {
+        // nothing to remove
+        return 0;
+    }
+
     animation_curve_compute_aabb(bounds, curve);
 
-    const absolute_error_tolerance = bounds.height * error_tolerance;
+    const EPSILON = 1e-9;
 
-    let key_count = curve.length;
+    // Clamp against epsilon to handle the flat-line case or very low tolerances resulting in precision issues
+    const absolute_error_tolerance = Math.max(
+        bounds.height * error_tolerance,
+        EPSILON,
+    );
 
     const keyframes = curve.keys;
 
@@ -84,9 +124,8 @@ export function animation_curve_optimize(
         if (key_current.equals(key_previous)) {
             // adds no semantic value
             should_remove = true;
-        }
+        } else if (i < key_count - 1) {
 
-        if (!should_remove && i < key_count - 1) {
             const key_next = keyframes[i + 1];
 
             const max_error = compute_keyframe_value_effect(key_current, key_previous, key_next);
@@ -95,13 +134,18 @@ export function animation_curve_optimize(
                 // does not significantly affect the curve shape
                 should_remove = true;
             }
+
         }
 
 
         if (should_remove) {
+
             curve.remove(key_current);
+
+            // update iterator
             i--;
             key_count--;
+
         }
     }
 

package/src/engine/animation/curve/animation_curve_subdivide.d.ts

@@ -1,11 +1,13 @@
 /**
  * Subdivide a curve segment by introducing a new keyframe at a given normalized time.
  * Subdivision does not alter the curve shape in any way, it is intended primarily for editing purposes.
+ *
  * @param {Keyframe} out keyframe to be added at the point of subdivision, its tangents, time and value will be overwritten
- * @param {Keyframe} key0
- * @param {Keyframe} key1
+ * @param {Keyframe} key0 start of the segment
+ * @param {Keyframe} key1 end of the segment
  * @param {number} t normalized time in [0..1] between key0 and key1 where new frame is to be inserted
  * @returns {Keyframe} `out`, for convenience
+ *
  * @see AnimationCurve
  * @example
  *  const new_frame = animation_curve_subdivide(new Keyframe(), key0, key1, 0.5);

package/src/engine/animation/curve/animation_curve_subdivide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"animation_curve_subdivide.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_subdivide.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,+CAVW,QAAQ,QACR,QAAQ,QACR,QAAQ,KACR,MAAM,GACJ,QAAQ,CAqDpB"}
+{"version":3,"file":"animation_curve_subdivide.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_subdivide.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,+CAXW,QAAQ,QACR,QAAQ,QACR,QAAQ,KACR,MAAM,GACJ,QAAQ,CAsDpB"}

package/src/engine/animation/curve/animation_curve_subdivide.js

@@ -6,11 +6,13 @@ import { spline3_hermite_derivative } from "../../../core/math/spline/spline3_he
 /**
  * Subdivide a curve segment by introducing a new keyframe at a given normalized time.
  * Subdivision does not alter the curve shape in any way, it is intended primarily for editing purposes.
+ *
  * @param {Keyframe} out keyframe to be added at the point of subdivision, its tangents, time and value will be overwritten
- * @param {Keyframe} key0
- * @param {Keyframe} key1
+ * @param {Keyframe} key0 start of the segment
+ * @param {Keyframe} key1 end of the segment
  * @param {number} t normalized time in [0..1] between key0 and key1 where new frame is to be inserted
  * @returns {Keyframe} `out`, for convenience
+ *
  * @see AnimationCurve
  * @example
  *  const new_frame = animation_curve_subdivide(new Keyframe(), key0, key1, 0.5);

package/src/engine/ecs/transform/Transform.d.ts

@@ -1,9 +1,7 @@
 /**
  * A Transform represents the position, rotation, and scale of an object in 3D space.
  * Think of it like the object's location, orientation, and size.
- * It has properties for position (like coordinates), rotation (how it's turned), and scale (how big it is).
- *
- * It also uses a "matrix" (a table of numbers) internally to efficiently store and calculate transformations, but you usually interact with the position, rotation, and scale directly.
+ * It has properties for {@link position} (like coordinates), {@link rotation} (how it's oriented), and {@link scale} (how big it is).
  *
  * @example
  *  const t = new Transform();
@@ -50,8 +48,11 @@ export class Transform {
      */
     readonly scale: Vector3;
     /**
-     * transform matrix, position, rotation, and scale must match, but shear can be different
-     * Note: this is managed by the Transform itself, do not modify the matrix directly. If you want to set it - use {@link fromMatrix} method instead
+     * Affine transform matrix, {@link position}, {@link rotation}, and {@link scale} must match, but shear can be different.
+     * Note: this is managed by the {@link Transform} itself unless {@link TransformFlags.AutomaticChangeDetection} is disabled; do not modify the matrix directly.
+     * Generally, if you want to modify it - use {@link fromMatrix} method instead.
+     *
+     * If you're not comfortable with matrices, just leave defaults on and stick to primary attributes i.e. {@link position}, {@link rotation}, and {@link scale}.
      * @readonly
      * @type {Float32Array}
      */
@@ -115,7 +116,9 @@ export class Transform {
      */
     getFlag(flag: number | TransformFlags): boolean;
     /**
-     * Update {@link matrix} attribute from current position/rotation/scale
+     * Update {@link matrix} attribute from current {@link position}/{@link rotation}/{@link scale}
+     *
+     * Useful for when {@link TransformFlags.AutomaticChangeDetection} is disabled.
      */
     updateMatrix(): void;
     /**

package/src/engine/ecs/transform/Transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;GAaG;AACH;IA6QI;;;;OAIG;IACH,4BAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,uBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,SAAS,CAQrB;IA0FD;;;;;OAKG;IACH,wCAJW,UAAU,gBACV,OAAO,wBAejB;IA/YD;;;OAGG;IACH,mBAHU,OAAO,CAGe;IAEhC;;;;;OAKG;IACH,mBAHU,UAAU,CAGkB;IAEtC;;;OAGG;IACH,gBAHU,OAAO,CAGY;IAE7B;;;;;OAKG;IACH,iBAFU,YAAY,CAEC;IAEvB;;;;OAIG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;OAIG;IACH,uBAMC;IAED;;;OAGG;IACH,kBAMC;IAED;;;OAGG;IACH,qBAMC;IAED;;;;OAIG;IACH,kDAIC;IAED;;;;OAIG;IACH,oDAIC;IAYD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,OAAO,OACP,OAAO,QAmBjB;IAED,0BAwBC;IAED;;;;;;;;;;;;;;;;;MAMC;IAED;;;;;OAKG;IACH,YAFW,SAAS,QAenB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAMnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAKlB;IA4BD;;;;;;OAMG;IACH,gBAHW,SAAS,GACP,IAAI,CAIhB;IAED;;;;;OAKG;IACH,sBAJW,SAAS,KACT,SAAS,GACP,IAAI,CAWhB;IAED;;;;OAIG;IACH,mBAHW,OAAK,MAAM,EAAE,GAAC,YAAY,GACxB,IAAI,CAmBhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,EAAE,CAOpB;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,cAFa,OAAO,CAMnB;IAED,mBAEC;IA6BL;;;;;;;;OAQG;IACH,sBANU,OAAO,CAMc;IAE/B;;;OAGG;IACH,8BA5Ee,MAAM,EAAE,GAAC,YAAY,KACnB,MAAM,EAAE,CA2EI;IAE7B;;;OAGG;IACH,+BA1Ge,OAAK,MAAM,EAAE,GAAC,YAAY,KACxB,IAAI,CAyGU;;CA7B9B;;kBAIS,MAAM;;oBAnbI,+BAA+B;uBAD5B,kCAAkC;+BAE1B,qBAAqB"}
+{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;GAWG;AACH;IAsRI;;;;OAIG;IACH,4BAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,uBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,SAAS,CAQrB;IA0FD;;;;;OAKG;IACH,wCAJW,UAAU,gBACV,OAAO,wBAejB;IAxZD;;;OAGG;IACH,mBAHU,OAAO,CAGe;IAEhC;;;;;OAKG;IACH,mBAHU,UAAU,CAGkB;IAEtC;;;OAGG;IACH,gBAHU,OAAO,CAGY;IAE7B;;;;;;;;OAQG;IACH,iBAFU,YAAY,CAEC;IAEvB;;;;OAIG;IACH,OAFU,MAAM,CAEM;IAStB;;;;OAIG;IACH,uBAMC;IAED;;;OAGG;IACH,kBAMC;IAED;;;OAGG;IACH,qBAMC;IAED;;;;OAIG;IACH,kDAIC;IAED;;;;OAIG;IACH,oDAIC;IAYD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,OAAO,OACP,OAAO,QAqBjB;IAED,0BAwBC;IAED;;;;;;;;;;;;;;;;;MAMC;IAED;;;;;OAKG;IACH,YAFW,SAAS,QAenB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAMnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAKlB;IA4BD;;;;;;OAMG;IACH,gBAHW,SAAS,GACP,IAAI,CAIhB;IAED;;;;;OAKG;IACH,sBAJW,SAAS,KACT,SAAS,GACP,IAAI,CAWhB;IAED;;;;OAIG;IACH,mBAHW,OAAK,MAAM,EAAE,GAAC,YAAY,GACxB,IAAI,CAmBhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,EAAE,CAOpB;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,cAFa,OAAO,CAMnB;IAED,mBAEC;IA6BL;;;;;;;;OAQG;IACH,sBANU,OAAO,CAMc;IAE/B;;;OAGG;IACH,8BA5Ee,MAAM,EAAE,GAAC,YAAY,KACnB,MAAM,EAAE,CA2EI;IAE7B;;;OAGG;IACH,+BA1Ge,OAAK,MAAM,EAAE,GAAC,YAAY,KACxB,IAAI,CAyGU;;CA7B9B;;kBAIS,MAAM;;oBA1bI,+BAA+B;uBAD5B,kCAAkC;+BAE1B,qBAAqB"}

package/src/engine/ecs/transform/Transform.js

@@ -23,9 +23,7 @@ const FLAGS_DEFAULT = TransformFlags.AutomaticChangeDetection;
 /**
  * A Transform represents the position, rotation, and scale of an object in 3D space.
  * Think of it like the object's location, orientation, and size.
- * It has properties for position (like coordinates), rotation (how it's turned), and scale (how big it is).
- *
- * It also uses a "matrix" (a table of numbers) internally to efficiently store and calculate transformations, but you usually interact with the position, rotation, and scale directly.
+ * It has properties for {@link position} (like coordinates), {@link rotation} (how it's oriented), and {@link scale} (how big it is).
  *
  * @example
  *  const t = new Transform();
@@ -57,8 +55,11 @@ export class Transform {
     scale = new Vector3(1, 1, 1);
 
     /**
-     * transform matrix, position, rotation, and scale must match, but shear can be different
-     * Note: this is managed by the Transform itself, do not modify the matrix directly. If you want to set it - use {@link fromMatrix} method instead
+     * Affine transform matrix, {@link position}, {@link rotation}, and {@link scale} must match, but shear can be different.
+     * Note: this is managed by the {@link Transform} itself unless {@link TransformFlags.AutomaticChangeDetection} is disabled; do not modify the matrix directly.
+     * Generally, if you want to modify it - use {@link fromMatrix} method instead.
+     *
+     * If you're not comfortable with matrices, just leave defaults on and stick to primary attributes i.e. {@link position}, {@link rotation}, and {@link scale}.
      * @readonly
      * @type {Float32Array}
      */
@@ -72,7 +73,9 @@ export class Transform {
     flags = FLAGS_DEFAULT;
 
     constructor() {
-        // watch changes
+        // Watch changes.
+        // This creates a data dependency, which makes GC impossible if we keep references to position/rotation/scale
+        // Please clone those properties if you need to keep them past the expiry of the Transform
         this.subscribe(this.#handle_component_change, this);
     }
 
@@ -186,7 +189,9 @@ export class Transform {
     }
 
     /**
-     * Update {@link matrix} attribute from current position/rotation/scale
+     * Update {@link matrix} attribute from current {@link position}/{@link rotation}/{@link scale}
+     *
+     * Useful for when {@link TransformFlags.AutomaticChangeDetection} is disabled.
      */
     updateMatrix() {
         compose_matrix4_array(this.matrix, this.position, this.rotation, this.scale);
@@ -206,7 +211,9 @@ export class Transform {
         const delta_z = target.z - position.z;
 
         if (delta_x === 0 && delta_y === 0 && delta_z === 0) {
-            // target is at the same location as this transform, no valid rotation, keep whatever we have
+            // Target is at the same location as this transform, no valid rotation, keep whatever we have.
+            // Generally this is a programmer mistake, making any changes to the rotation would be undesirable.
+            // The most valid option is to keep the current state.
             return;
         }
 

package/src/engine/graphics/ecs/camera/topdown/ComputeCameraFacingVector.js

@@ -11,7 +11,7 @@ const q = new Quaternion();
  * @param {Vector3} result
  */
 export function computeCameraFacingVector(yaw, pitch, roll, result) {
-    q.__setFromEuler(pitch, yaw, roll, 'ZYX');
+    q.fromEulerAnglesZYX(pitch, yaw, roll);
     q.normalize();
 
     result.copy(Vector3.forward);

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js

@@ -74,7 +74,7 @@ export function computeTopDownTransform(control, result) {
     const roll = control.roll;
 
     // compute rotation
-    rotation.__setFromEuler(pitch, yaw, roll, 'ZYX');
+    rotation.fromEulerAnglesZYX(pitch, yaw, roll);
 
     // compute camera position
     v3_scratch.copy(Vector3.forward);

package/src/engine/graphics/ecs/mesh-v2/aggregate/prototypeSGMesh.js

@@ -62,7 +62,7 @@ function make_grid(ecd, engine) {
         for (let j = 0; j < GRID_SIZE; j++) {
             const quaternion = new Quaternion();
 
-            quaternion.__setFromEuler(0, random() * Math.PI, 0);
+            quaternion.fromEulerAnglesXYZ(0, random() * Math.PI, 0);
 
             const center = new Vector3(i * 8, 0, j * 8);
 

package/src/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -1083,7 +1083,7 @@ function makeKnot(engine, position, scale, rotation) {
         }
     });
 
-    transform.rotation.__setFromEuler(position[0], position[1], position[2]);
+    transform.rotation.fromEulerAnglesXYZ(position[0], position[1], position[2]);
 
     transform.scale.multiplyScalar(scale);
 

package/src/generation/markers/transform/MarkerNodeTransformerYRotateByFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkerNodeTransformerYRotateByFilter.d.ts","sourceRoot":"","sources":["../../../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilter.js"],"names":[],"mappings":"AAQA;IAqBI;;;;OAIG;IACH,yCAFW,MAAM,wCAahB;IAnCD;;;OAGG;IACH,mBAAc;IAEd;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,uCAIC;IAqBD,qCAmBC;CACJ;sCAnEqC,4BAA4B"}
+{"version":3,"file":"MarkerNodeTransformerYRotateByFilter.d.ts","sourceRoot":"","sources":["../../../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilter.js"],"names":[],"mappings":"AAQA;IAqBI;;;;OAIG;IACH,yCAFW,MAAM,wCAahB;IAnCD;;;OAGG;IACH,mBAAc;IAEd;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,uCAIC;IAqBD,qCAmBC;CACJ;sCA/DqC,4BAA4B"}

package/src/generation/markers/transform/MarkerNodeTransformerYRotateByFilter.js

@@ -1,8 +1,8 @@
-import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
 import { assert } from "../../../core/assert.js";
 import Vector3 from "../../../core/geom/Vector3.js";
-import { epsilonEquals } from "../../../core/math/epsilonEquals.js";
 import { EPSILON } from "../../../core/math/EPSILON.js";
+import { epsilonEquals } from "../../../core/math/epsilonEquals.js";
+import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
 
 const v3_object = new Vector3();
 
@@ -61,7 +61,7 @@ export class MarkerNodeTransformerYRotateByFilter extends MarkerNodeTransformer
         const result = node.clone();
 
 
-        result.transform.rotation.__setFromEuler(v3_object.x, finalAngle, v3_object.z, 'YXZ');
+        result.transform.rotation.fromEulerAnglesYXZ(v3_object.x, finalAngle, v3_object.z);
 
         return result;
     }

package/src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkerNodeTransformerYRotateByFilterGradient.d.ts","sourceRoot":"","sources":["../../../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAoBI;;;;OAIG;IACH,yCAFW,MAAM,gDAahB;IAlCD;;;OAGG;IACH,mBAAc;IAEd;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,uCAIC;IAoBD,qCA4BC;CACJ;sCAlFqC,4BAA4B"}
+{"version":3,"file":"MarkerNodeTransformerYRotateByFilterGradient.d.ts","sourceRoot":"","sources":["../../../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAoBI;;;;OAIG;IACH,yCAFW,MAAM,gDAahB;IAlCD;;;OAGG;IACH,mBAAc;IAEd;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,uCAIC;IAoBD,qCA2BC;CACJ;sCA5EqC,4BAA4B"}

package/src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js

@@ -1,9 +1,9 @@
-import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
-import Vector3 from "../../../core/geom/Vector3.js";
 import { assert } from "../../../core/assert.js";
-import { computeCellFilterGradient } from "../../filtering/numeric/process/computeCellFilterGradient.js";
-import { epsilonEquals } from "../../../core/math/epsilonEquals.js";
+import Vector3 from "../../../core/geom/Vector3.js";
 import { EPSILON } from "../../../core/math/EPSILON.js";
+import { epsilonEquals } from "../../../core/math/epsilonEquals.js";
+import { computeCellFilterGradient } from "../../filtering/numeric/process/computeCellFilterGradient.js";
+import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
 
 const v3_object = new Vector3();
 
@@ -75,8 +75,7 @@ export class MarkerNodeTransformerYRotateByFilterGradient extends MarkerNodeTran
 
         const result = node.clone();
 
-
-        result.transform.rotation.__setFromEuler(v3_object.x, finalAngle, v3_object.z, 'YXZ');
+        result.transform.rotation.fromEulerAnglesYXZ(v3_object.x, finalAngle, v3_object.z);
 
         return result;
     }

package/src/view/View.d.ts

@@ -1,5 +1,5 @@
-import Vector2 from "../core/geom/Vector2";
 import Signal from "../core/events/signal/Signal";
+import Vector2 from "../core/geom/Vector2";
 
 export interface IViewSignals {
     readonly linked: Signal
@@ -7,8 +7,8 @@ export interface IViewSignals {
 }
 
 export default class View<T extends Element = HTMLElement> {
-    size: Vector2
-    position: Vector2
+    readonly size: Vector2
+    readonly position: Vector2
 
     el: T