@woosh/meep-engine 2.169.1 → 2.169.2

package/src/core/math/noise/curl_noise_3d.js

@@ -1,27 +1,18 @@
-import { sdnoise3 } from "./sdnoise.js";
-
-
-const p_x0 = [];
-const p_y0 = [];
-const p_z0 = [];
-
-/**
- *
- * @param {number[]} result
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-export function curl_noise_3d(result, x,y,z) {
-    sdnoise3(p_x0, x, y, z);
-    sdnoise3(p_y0, x + 31.341, y - 43.23, z + 12.34);
-    sdnoise3(p_z0, x - 231.141, y + 124.123, z -54.4341);
-
-    const _x = p_z0[1] - p_y0[2];
-    const _y = p_x0[2] - p_z0[0];
-    const _z = p_y0[0] - p_x0[1];
-
-    result[0] = _x;
-    result[1] = _y;
-    result[2] = _z;
-}
+import { curl_noise_3dt } from "./curl_noise_3dt.js";
+
+/**
+ * Divergence-free 3D curl noise.
+ *
+ * This is the time-independent face of {@link curl_noise_3dt}: sampling the animated field at `w = 0`.
+ * `0` is a real point on the time axis, not a sentinel. The three decorrelation offsets that separate the
+ * potential-field components live in `curl_noise_3dt` only — duplicating them here meant retuning one
+ * field silently decorrelated it from the other.
+ *
+ * @param {number[]} result
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function curl_noise_3d(result, x, y, z) {
+    curl_noise_3dt(result, x, y, z, 0);
+}

package/src/core/math/statistics/hammersley_sequence.d.ts

@@ -1,22 +1,34 @@
 /**
- * Second coordinate of the Hammersley set: the van der Corput radical inverse
- * of `i` in base `R`.
+ * Writes the `i`-th point of the `N`-point Hammersley set to `output`.
  *
- * Computed in closed form, as {@link halton_sequence} does. The previous
- * incremental formulation restarted from zero and applied `i` successive
- * additions, so for any base whose reciprocal is not exactly representable --
- * base 3 among them -- rounding accumulated until the comparisons inside it
- * stopped agreeing with exact arithmetic and the sequence collapsed onto a
- * short cycle. It was also O(i) per element, and therefore quadratic to
- * enumerate; this is O(log i).
+ * The point is `( i/N, Φ_b(i) … )`, one radical inverse per entry of `bases`.
+ * Only the leading `i/N` distinguishes the Hammersley set from the Halton
+ * sequence -- every coordinate after it is a radical inverse, identical to the
+ * corresponding Halton coordinate. That one term is the whole construction: it
+ * buys a log factor of star discrepancy, O((log N)^(s-1) / N) against Halton's
+ * O((log N)^s / N), and it is paid for with `N`.
  *
- * The radical inverse does not depend on the size of the set, so the `count`
- * parameter this used to take is gone: the first Hammersley coordinate is
- * `i / count` and belongs to the caller. It was never read by the body.
+ * Which is why this is a *set* and not a sequence. `N` is fixed before the
+ * first point, and adding one moves every point already emitted. Where samples
+ * are drawn until some quality bar is met, rather than counted out in advance,
+ * the extensible {@link halton_sequence} is the one that applies.
  *
- * @param {number} i index of sequence element
- * @param {number} R a prime number
- * @returns {number} value in [0,1)
+ * ### This is the slow path
+ *
+ * Prefer {@link hammersley_sequence_2d}, which is the two-dimensional base-2
+ * case -- overwhelmingly the common one, and the only one anything in this tree
+ * currently asks for. It resolves its second coordinate through
+ * {@link radical_inverse_VdC_base_2}: a single bit reversal and a multiply, no
+ * loop. This function has no such route. Each coordinate costs a digit loop
+ * with a division per digit, so a point runs `bases.length` of them. Generate
+ * the set once into a buffer, as {@link generate_hammersley_jitter} does; do
+ * not call it per sample inside a hot loop.
+ *
+ * @param {number[]|Float32Array|Float64Array} output receives `1 + bases.length` values
+ * @param {number} output_offset
+ * @param {number} i index of the point within the set
+ * @param {number} N size of the set; `i` must lie in [0, N)
+ * @param {number[]} bases one per dimension after the first, pairwise coprime -- consecutive primes, canonically
  */
-export function hammersley_sequence(i: number, R: number): number;
+export function hammersley_sequence(output: number[] | Float32Array | Float64Array, output_offset: number, i: number, N: number, bases: number[]): void;
 //# sourceMappingURL=hammersley_sequence.d.ts.map

package/src/core/math/statistics/hammersley_sequence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hammersley_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/hammersley_sequence.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAelB"}
+{"version":3,"file":"hammersley_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/hammersley_sequence.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,EAAE,QAmBlB"}

package/src/core/math/statistics/hammersley_sequence.js

@@ -1,34 +1,53 @@
-/**
- * Second coordinate of the Hammersley set: the van der Corput radical inverse
- * of `i` in base `R`.
- *
- * Computed in closed form, as {@link halton_sequence} does. The previous
- * incremental formulation restarted from zero and applied `i` successive
- * additions, so for any base whose reciprocal is not exactly representable --
- * base 3 among them -- rounding accumulated until the comparisons inside it
- * stopped agreeing with exact arithmetic and the sequence collapsed onto a
- * short cycle. It was also O(i) per element, and therefore quadratic to
- * enumerate; this is O(log i).
- *
- * The radical inverse does not depend on the size of the set, so the `count`
- * parameter this used to take is gone: the first Hammersley coordinate is
- * `i / count` and belongs to the caller. It was never read by the body.
- *
- * @param {number} i index of sequence element
- * @param {number} R a prime number
- * @returns {number} value in [0,1)
- */
-export function hammersley_sequence(i, R) {
-
-    let result = 0;
-    let f = 1;
-    let n = i;
-
-    while (n > 0) {
-        f = f / R;
-        result = result + f * (n % R);
-        n = (n / R) >>> 0;
-    }
-
-    return result;
-}
+import { assert } from "../../assert.js";
+import { halton_sequence } from "./halton_sequence.js";
+
+/**
+ * Writes the `i`-th point of the `N`-point Hammersley set to `output`.
+ *
+ * The point is `( i/N, Φ_b(i) … )`, one radical inverse per entry of `bases`.
+ * Only the leading `i/N` distinguishes the Hammersley set from the Halton
+ * sequence -- every coordinate after it is a radical inverse, identical to the
+ * corresponding Halton coordinate. That one term is the whole construction: it
+ * buys a log factor of star discrepancy, O((log N)^(s-1) / N) against Halton's
+ * O((log N)^s / N), and it is paid for with `N`.
+ *
+ * Which is why this is a *set* and not a sequence. `N` is fixed before the
+ * first point, and adding one moves every point already emitted. Where samples
+ * are drawn until some quality bar is met, rather than counted out in advance,
+ * the extensible {@link halton_sequence} is the one that applies.
+ *
+ * ### This is the slow path
+ *
+ * Prefer {@link hammersley_sequence_2d}, which is the two-dimensional base-2
+ * case -- overwhelmingly the common one, and the only one anything in this tree
+ * currently asks for. It resolves its second coordinate through
+ * {@link radical_inverse_VdC_base_2}: a single bit reversal and a multiply, no
+ * loop. This function has no such route. Each coordinate costs a digit loop
+ * with a division per digit, so a point runs `bases.length` of them. Generate
+ * the set once into a buffer, as {@link generate_hammersley_jitter} does; do
+ * not call it per sample inside a hot loop.
+ *
+ * @param {number[]|Float32Array|Float64Array} output receives `1 + bases.length` values
+ * @param {number} output_offset
+ * @param {number} i index of the point within the set
+ * @param {number} N size of the set; `i` must lie in [0, N)
+ * @param {number[]} bases one per dimension after the first, pairwise coprime -- consecutive primes, canonically
+ */
+export function hammersley_sequence(
+    output, output_offset,
+    i, N, bases
+) {
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+    assert.isNonNegativeInteger(i, 'i');
+    assert.isPositiveInteger(N, 'N');
+    assert.lessThan(i, N, 'point index must lie within the set');
+    assert.isArray(bases, 'bases');
+
+    output[output_offset] = i / N;
+
+    const dimensions = bases.length;
+
+    for (let d = 0; d < dimensions; d++) {
+        output[output_offset + 1 + d] = halton_sequence(bases[d], i);
+    }
+}

package/src/core/science/units/MEASUREMENT_UNITS_SI.d.ts

@@ -7,6 +7,9 @@
  * with no derived shorthand. Compound matrices like Newton or Volt fall back to base-unit
  * rendering (`kg·m/s^2`, `kg·m^2/s^3·A`).
  *
+ * The ordering invariant (array index === UnitDimension ordinal) is defined once, by
+ * {@link UNIT_DIMENSION_MAPPING}; this is an alias of it so the two cannot drift apart.
+ *
  * @type {NamedUnit[]}
  */
 export const MEASUREMENT_UNITS_SI: NamedUnit[];

package/src/core/science/units/MEASUREMENT_UNITS_SI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MEASUREMENT_UNITS_SI.d.ts","sourceRoot":"","sources":["../../../../../src/core/science/units/MEASUREMENT_UNITS_SI.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,mCAFU,WAAW,CAUnB"}
+{"version":3,"file":"MEASUREMENT_UNITS_SI.d.ts","sourceRoot":"","sources":["../../../../../src/core/science/units/MEASUREMENT_UNITS_SI.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,mCAFU,WAAW,CAEsC"}

package/src/core/science/units/MEASUREMENT_UNITS_SI.js

@@ -1,10 +1,4 @@
-import { METER } from "./si/METER.js";
-import { KILOGRAM } from "./si/KILOGRAM.js";
-import { SECOND } from "./si/SECOND.js";
-import { AMPERE } from "./si/AMPERE.js";
-import { KELVIN } from "./si/KELVIN.js";
-import { MOLE } from "./si/MOLE.js";
-import { CANDELA } from "./si/CANDELA.js";
+import { UNIT_DIMENSION_MAPPING } from "./UNIT_DIMENSION_MAPPING.js";
 
 /**
  * The 7 SI base units in their ISO order: length, mass, time, electric current, temperature,
@@ -15,14 +9,9 @@ import { CANDELA } from "./si/CANDELA.js";
  * with no derived shorthand. Compound matrices like Newton or Volt fall back to base-unit
  * rendering (`kg·m/s^2`, `kg·m^2/s^3·A`).
  *
+ * The ordering invariant (array index === UnitDimension ordinal) is defined once, by
+ * {@link UNIT_DIMENSION_MAPPING}; this is an alias of it so the two cannot drift apart.
+ *
  * @type {NamedUnit[]}
  */
-export const MEASUREMENT_UNITS_SI = [
-    METER,
-    KILOGRAM,
-    SECOND,
-    AMPERE,
-    KELVIN,
-    MOLE,
-    CANDELA
-];
+export const MEASUREMENT_UNITS_SI = UNIT_DIMENSION_MAPPING;

package/src/engine/animation/TransitionFunctions.d.ts

@@ -1,4 +1,14 @@
 export default TransitionFunctions;
+/**
+ * Engine-wide easing enum. Members are compared by identity by serialization adapters
+ * (see `model/game/story/behaviors/camera/CameraMoveToTargetBehaviorSerializationAdapter.js`),
+ * so members may be added but never re-pointed.
+ *
+ * `EaseIn`/`EaseOut`/`EaseInOut` are the quadratic tier, `EaseInCubic`/`EaseOutCubic`/`EaseInOutCubic`
+ * the cubic one. A curve-valued expression of the same three concepts lives alongside as
+ * {@link CURVE_EASE_IN }/`CURVE_EASE_OUT`/`CURVE_EASE_IN_OUT` in `engine/animation/curve/preset/`
+ * — use those where an {@link AnimationCurve } is wanted rather than a plain function.
+ */
 type TransitionFunctions = (x: number) => number;
 declare namespace TransitionFunctions {
     export { linear as Linear };
@@ -7,6 +17,9 @@ declare namespace TransitionFunctions {
     export { easeOutQuad as EaseOut };
     export { easeInOutQuad as EaseInOut };
     export let CubicEaseIn: (arg0: number) => number;
+    export { easeInCubic as EaseInCubic };
+    export { easeOutCubic as EaseOutCubic };
+    export { easeInOutCubic as EaseInOutCubic };
 }
 /**
  * @param {number} x
@@ -36,4 +49,22 @@ declare function easeOutQuad(x: number): number;
  * @returns {number}
  */
 declare function easeInOutQuad(t: number): number;
+/**
+ * Back-loaded ease — gentle start, accelerating finish.
+ * @param {number} t [0..1]
+ * @returns {number}
+ */
+declare function easeInCubic(t: number): number;
+/**
+ * Front-loaded ease — fast rise then gentle settle.
+ * @param {number} t [0..1]
+ * @returns {number}
+ */
+declare function easeOutCubic(t: number): number;
+/**
+ * Smoothstep-style ease — slow-fast-slow. Sharper than {@link easeInOutQuad}.
+ * @param {number} t [0..1]
+ * @returns {number}
+ */
+declare function easeInOutCubic(t: number): number;
 //# sourceMappingURL=TransitionFunctions.d.ts.map

package/src/engine/animation/TransitionFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransitionFunctions.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/TransitionFunctions.js"],"names":[],"mappings":";+BAIc,MAAM,KAAK,MAAM;;;;;;;;;AAY/B;;;GAGG;AACH,2BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,yBAHW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;GAIG;AACH,+BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,kCAHW,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"TransitionFunctions.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/TransitionFunctions.js"],"names":[],"mappings":";;;;;;;;;;;+BAYc,MAAM,KAAK,MAAM;;;;;;;;;;;;AAmB/B;;;GAGG;AACH,2BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,yBAHW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;GAIG;AACH,+BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,kCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,iCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,mCAHW,MAAM,GACJ,MAAM,CAMlB"}

package/src/engine/animation/TransitionFunctions.js

@@ -1,6 +1,14 @@
 import { makeCubicCurve } from "../../core/math/spline/makeCubicCurve.js";
 
 /**
+ * Engine-wide easing enum. Members are compared by identity by serialization adapters
+ * (see `model/game/story/behaviors/camera/CameraMoveToTargetBehaviorSerializationAdapter.js`),
+ * so members may be added but never re-pointed.
+ *
+ * `EaseIn`/`EaseOut`/`EaseInOut` are the quadratic tier, `EaseInCubic`/`EaseOutCubic`/`EaseInOutCubic`
+ * the cubic one. A curve-valued expression of the same three concepts lives alongside as
+ * {@link CURVE_EASE_IN}/`CURVE_EASE_OUT`/`CURVE_EASE_IN_OUT` in `engine/animation/curve/preset/`
+ * — use those where an {@link AnimationCurve} is wanted rather than a plain function.
  *
  * @enum {(x: number) => number}
  */
@@ -10,7 +18,14 @@ const TransitionFunctions = {
     EaseIn: easeInQuad,
     EaseOut: easeOutQuad,
     EaseInOut: easeInOutQuad,
+    /**
+     * NOTE: despite the name this is a cubic *Bézier* through (0,1,0.98,1), not `t³`.
+     * It rises almost immediately and then flattens. For `t³` use {@link TransitionFunctions.EaseInCubic}.
+     */
     CubicEaseIn: makeCubicCurve(0, 1, 0.98, 1),
+    EaseInCubic: easeInCubic,
+    EaseOutCubic: easeOutCubic,
+    EaseInOutCubic: easeInOutCubic,
 };
 
 
@@ -58,4 +73,33 @@ function easeInOutQuad(t) {
     return t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
 }
 
+/**
+ * Back-loaded ease — gentle start, accelerating finish.
+ * @param {number} t [0..1]
+ * @returns {number}
+ */
+function easeInCubic(t) {
+    return t * t * t;
+}
+
+/**
+ * Front-loaded ease — fast rise then gentle settle.
+ * @param {number} t [0..1]
+ * @returns {number}
+ */
+function easeOutCubic(t) {
+    return 1 - Math.pow(1 - t, 3);
+}
+
+/**
+ * Smoothstep-style ease — slow-fast-slow. Sharper than {@link easeInOutQuad}.
+ * @param {number} t [0..1]
+ * @returns {number}
+ */
+function easeInOutCubic(t) {
+    return t < 0.5
+        ? 4 * t * t * t
+        : 1 - Math.pow(-2 * t + 2, 3) / 2;
+}
+
 export default TransitionFunctions;

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

@@ -0,0 +1,29 @@
+/**
+ * Binary wire codec for {@link AnimationCurve}: a `uintVar` keyframe count followed by
+ * `time / value / inTangent / outTangent` as float32 per key.
+ *
+ * WHY this exists: {@link AnimationCurve} has no registered binary class adapter of its own, so every binary
+ * adapter that owns a curve-valued FIELD has to spell the payload out inline. Two sopra adapters
+ * (`EventDescriptionSerializationAdapter` for the attenuation curve, `BlendContainerAudioClipSerializationAdapter`
+ * for the per-child blend curves) had written the same four float32s out and read them back — four hand-written
+ * copies of one wire format, where changing the payload (adding wrap modes, packing tangents) in three of the
+ * four places leaves the fourth silently mis-reading a stream it thinks it understands.
+ *
+ * This is deliberately a plain read/write PAIR rather than a registered `ObjectBasedClassSerializationAdapter`:
+ * routing curves through the object adapter would prefix each one with a class tag and change the bytes on the
+ * wire, breaking every already-serialized payload. The format here is byte-identical to what the sopra adapters
+ * previously emitted inline.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AnimationCurve} curve
+ */
+export function serialize_animation_curve(buffer: BinaryBuffer, curve: AnimationCurve): void;
+/**
+ * Read back a curve written by {@link serialize_animation_curve}.
+ *
+ * @param {BinaryBuffer} buffer
+ * @returns {AnimationCurve} a fresh curve
+ */
+export function deserialize_animation_curve(buffer: BinaryBuffer): AnimationCurve;
+import { AnimationCurve } from "./AnimationCurve.js";
+//# sourceMappingURL=animation_curve_binary_codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation_curve_binary_codec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_binary_codec.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,uEAFW,cAAc,QAgBxB;AAED;;;;;GAKG;AACH,mEAFa,cAAc,CAiB1B;+BA3D8B,qBAAqB"}

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

@@ -0,0 +1,60 @@
+import { AnimationCurve } from "./AnimationCurve.js";
+import { Keyframe } from "./Keyframe.js";
+
+/**
+ * Binary wire codec for {@link AnimationCurve}: a `uintVar` keyframe count followed by
+ * `time / value / inTangent / outTangent` as float32 per key.
+ *
+ * WHY this exists: {@link AnimationCurve} has no registered binary class adapter of its own, so every binary
+ * adapter that owns a curve-valued FIELD has to spell the payload out inline. Two sopra adapters
+ * (`EventDescriptionSerializationAdapter` for the attenuation curve, `BlendContainerAudioClipSerializationAdapter`
+ * for the per-child blend curves) had written the same four float32s out and read them back — four hand-written
+ * copies of one wire format, where changing the payload (adding wrap modes, packing tangents) in three of the
+ * four places leaves the fourth silently mis-reading a stream it thinks it understands.
+ *
+ * This is deliberately a plain read/write PAIR rather than a registered `ObjectBasedClassSerializationAdapter`:
+ * routing curves through the object adapter would prefix each one with a class tag and change the bytes on the
+ * wire, breaking every already-serialized payload. The format here is byte-identical to what the sopra adapters
+ * previously emitted inline.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AnimationCurve} curve
+ */
+export function serialize_animation_curve(buffer, curve) {
+    const keys = curve.keys;
+    const key_count = keys.length;
+
+    buffer.writeUintVar(key_count);
+
+    for (let i = 0; i < key_count; i++) {
+        const key = keys[i];
+
+        buffer.writeFloat32(key.time);
+        buffer.writeFloat32(key.value);
+        buffer.writeFloat32(key.inTangent);
+        buffer.writeFloat32(key.outTangent);
+    }
+}
+
+/**
+ * Read back a curve written by {@link serialize_animation_curve}.
+ *
+ * @param {BinaryBuffer} buffer
+ * @returns {AnimationCurve} a fresh curve
+ */
+export function deserialize_animation_curve(buffer) {
+    const curve = new AnimationCurve();
+
+    const key_count = buffer.readUintVar();
+
+    for (let i = 0; i < key_count; i++) {
+        const time = buffer.readFloat32();
+        const value = buffer.readFloat32();
+        const inTangent = buffer.readFloat32();
+        const outTangent = buffer.readFloat32();
+
+        curve.add(Keyframe.from(time, value, inTangent, outTangent));
+    }
+
+    return curve;
+}

package/src/engine/animation/curve/draw/canvas_point_to_curve.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Map a point in canvas space (pixels) back to curve space (time, value).
+ *
+ * Inverse of {@link curve_point_to_canvas}; see that function for why the mapping lives in exactly
+ * one place. Written as an out-parameter form so callers on a drag path do not allocate.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: curve time then curve value
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x canvas x
+ * @param {number} y canvas y
+ */
+export function canvas_point_to_curve(out: Float32Array | Float64Array | number[], out_offset: number, size: Vector2, frame: AABB2, margin: Vector2, x: number, y: number): void;
+//# sourceMappingURL=canvas_point_to_curve.d.ts.map

package/src/engine/animation/curve/draw/canvas_point_to_curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas_point_to_curve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/canvas_point_to_curve.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,2CARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,mDAIN,MAAM,KACN,MAAM,QAShB"}

package/src/engine/animation/curve/draw/canvas_point_to_curve.js

@@ -0,0 +1,22 @@
+/**
+ * Map a point in canvas space (pixels) back to curve space (time, value).
+ *
+ * Inverse of {@link curve_point_to_canvas}; see that function for why the mapping lives in exactly
+ * one place. Written as an out-parameter form so callers on a drag path do not allocate.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: curve time then curve value
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x canvas x
+ * @param {number} y canvas y
+ */
+export function canvas_point_to_curve(out, out_offset, size, frame, margin, x, y) {
+
+    const u = (x - margin.x) / (size.x - margin.x * 2);
+    const v = 1 - (y - margin.y) / (size.y - margin.y * 2);
+
+    out[out_offset] = u * frame.width + frame.x0;
+    out[out_offset + 1] = v * frame.height + frame.y0;
+}

package/src/engine/animation/curve/draw/curve_point_to_canvas.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Map a point in curve space (time, value) to canvas space (pixels).
+ *
+ * The frame is stretched to fill the canvas minus a symmetric pixel margin on each side, and the
+ * value axis is flipped so larger values are higher on screen.
+ *
+ * This is the ONE definition of the curve-editor's coordinate mapping. It exists because the editor
+ * used to draw the curve through an inline copy of this arithmetic
+ * ({@link canvas2dPlotCurvePoints}) while hit-testing, marker placement and panning went through
+ * {@link position_curve_to_canvas} / {@link position_canvas_to_curve} — the same formula written
+ * twice, so a change to the margin or anchoring convention in one desynced what the user clicks
+ * from what they see. Written as an out-parameter form because the plot calls it once per pixel
+ * column.
+ *
+ * Inverse of {@link canvas_point_to_curve}.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: canvas x then canvas y
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible; a zero-width or zero-height frame
+ * collapses that axis onto the low edge of the plot rather than producing a non-finite coordinate
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x curve time
+ * @param {number} y curve value
+ */
+export function curve_point_to_canvas(out: Float32Array | Float64Array | number[], out_offset: number, size: Vector2, frame: AABB2, margin: Vector2, x: number, y: number): void;
+//# sourceMappingURL=curve_point_to_canvas.d.ts.map

package/src/engine/animation/curve/draw/curve_point_to_canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve_point_to_canvas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/curve_point_to_canvas.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,2CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,mDAKN,MAAM,KACN,MAAM,QAchB"}

package/src/engine/animation/curve/draw/curve_point_to_canvas.js

@@ -0,0 +1,38 @@
+/**
+ * Map a point in curve space (time, value) to canvas space (pixels).
+ *
+ * The frame is stretched to fill the canvas minus a symmetric pixel margin on each side, and the
+ * value axis is flipped so larger values are higher on screen.
+ *
+ * This is the ONE definition of the curve-editor's coordinate mapping. It exists because the editor
+ * used to draw the curve through an inline copy of this arithmetic
+ * ({@link canvas2dPlotCurvePoints}) while hit-testing, marker placement and panning went through
+ * {@link position_curve_to_canvas} / {@link position_canvas_to_curve} — the same formula written
+ * twice, so a change to the margin or anchoring convention in one desynced what the user clicks
+ * from what they see. Written as an out-parameter form because the plot calls it once per pixel
+ * column.
+ *
+ * Inverse of {@link canvas_point_to_curve}.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: canvas x then canvas y
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible; a zero-width or zero-height frame
+ * collapses that axis onto the low edge of the plot rather than producing a non-finite coordinate
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x curve time
+ * @param {number} y curve value
+ */
+export function curve_point_to_canvas(out, out_offset, size, frame, margin, x, y) {
+
+    const curve_width = frame.width;
+    const curve_width_multiplier = curve_width > 0 ? 1 / curve_width : 0;
+    const u = (x - frame.x0) * curve_width_multiplier;
+
+    const curve_height = frame.height;
+    const curve_height_multiplier = curve_height > 0 ? 1 / curve_height : 0;
+    const v = 1 - (y - frame.y0) * curve_height_multiplier;
+
+    out[out_offset] = margin.x + u * (size.x - margin.x * 2);
+    out[out_offset + 1] = margin.y + v * (size.y - margin.y * 2);
+}

package/src/engine/animation/curve/draw/position_canvas_to_curve.d.ts

@@ -1,4 +1,6 @@
 /**
+ * Allocating convenience wrapper around {@link canvas_point_to_curve}; use that directly on any
+ * path that runs per-pixel or per-frame.
  *
  * @param {Vector2} size
  * @param {AABB2} frame

package/src/engine/animation/curve/draw/position_canvas_to_curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"position_canvas_to_curve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_canvas_to_curve.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAclB;oBAvBmB,kCAAkC"}
+{"version":3,"file":"position_canvas_to_curve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_canvas_to_curve.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;oBArBmB,kCAAkC"}

package/src/engine/animation/curve/draw/position_canvas_to_curve.js

@@ -1,24 +1,22 @@
-import Vector2 from "../../../../core/geom/Vector2.js";
-
-/**
- *
- * @param {Vector2} size
- * @param {AABB2} frame
- * @param {Vector2} margin
- * @param {number} x
- * @param {number} y
- * @return {Vector2}
- */
-export function position_canvas_to_curve(size, frame, margin, x, y) {
-
-    const width = size.x;
-    const height = size.y;
-
-    const u = (x - margin.x) / (width - margin.x * 2);
-    const v = 1 - (y - margin.y) / (height - margin.y * 2);
-
-    return new Vector2(
-        u * frame.width + frame.x0,
-        v * frame.height + frame.y0
-    );
-}
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { canvas_point_to_curve } from "./canvas_point_to_curve.js";
+
+const scratch = new Float64Array(2);
+
+/**
+ * Allocating convenience wrapper around {@link canvas_point_to_curve}; use that directly on any
+ * path that runs per-pixel or per-frame.
+ *
+ * @param {Vector2} size
+ * @param {AABB2} frame
+ * @param {Vector2} margin
+ * @param {number} x
+ * @param {number} y
+ * @return {Vector2}
+ */
+export function position_canvas_to_curve(size, frame, margin, x, y) {
+
+    canvas_point_to_curve(scratch, 0, size, frame, margin, x, y);
+
+    return new Vector2(scratch[0], scratch[1]);
+}

package/src/engine/animation/curve/draw/position_curve_to_canvas.d.ts

@@ -1,4 +1,6 @@
 /**
+ * Allocating convenience wrapper around {@link curve_point_to_canvas}; use that directly on any
+ * path that runs per-pixel or per-frame.
  *
  * @param {Vector2} size
  * @param {AABB2} frame