@woosh/meep-engine 2.110.2 → 2.110.5

package/src/core/geom/3d/sphere/sphere_fibonacci_point.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Generate a spherical fibonacci point
+ *
+ * http://lgdv.cs.fau.de/publications/publication/Pub.2015.tech.IMMD.IMMD9.spheri/
+ *
+ * To generate a nearly uniform point distribution on the unit sphere of size N, do
+ * for (const i = 0.0; i < N; i += 1.0) {
+ *    sphere_fibonacci_point(points, i*3, i, N);
+ * }
+ *
+ * The points go from z = +1 down to z = -1 in a spiral. To generate samples on the +z hemisphere, just stop before i > N/2.
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} i index of a point, from 0 to n-1
+ * @param {number} n total number of points
+ */
+export function sphere_fibonacci_point(output: number[] | Float32Array, output_offset: number, i: number, n: number): void;
+//# sourceMappingURL=sphere_fibonacci_point.d.ts.map

package/src/core/geom/3d/sphere/sphere_fibonacci_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere_fibonacci_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/sphere_fibonacci_point.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;GAeG;AACH,+CALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,QAoBhB"}

package/src/core/geom/3d/sphere/sphere_fibonacci_point.js

@@ -0,0 +1,51 @@
+import { assert } from "../../../assert.js";
+import { clamp01 } from "../../../math/clamp01.js";
+
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+function multiply_add_fraction(a, b) {
+    const ab = a * b;
+    return ab - Math.floor(ab);
+}
+
+const PHI = Math.sqrt(5) * 0.5 + 0.5;
+
+/**
+ * Generate a spherical fibonacci point
+ *
+ * http://lgdv.cs.fau.de/publications/publication/Pub.2015.tech.IMMD.IMMD9.spheri/
+ *
+ * To generate a nearly uniform point distribution on the unit sphere of size N, do
+ * for (const i = 0.0; i < N; i += 1.0) {
+ *    sphere_fibonacci_point(points, i*3, i, N);
+ * }
+ *
+ * The points go from z = +1 down to z = -1 in a spiral. To generate samples on the +z hemisphere, just stop before i > N/2.
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} i index of a point, from 0 to n-1
+ * @param {number} n total number of points
+ */
+export function sphere_fibonacci_point(output, output_offset, i, n) {
+    assert.isNonNegativeInteger(i, 'i');
+    assert.isNonNegativeInteger(n, 'n');
+    assert.isNonNegativeInteger(output_offset, 'output_offset');
+
+    const phi = 2 * Math.PI * multiply_add_fraction(i, PHI - 1);
+
+    const cosTheta = 1.0 - (2.0 * i + 1.0) * (1.0 / n);
+
+    const sinTheta = Math.sqrt(clamp01(1.0 - cosTheta * cosTheta));
+
+    const x = Math.cos(phi) * sinTheta;
+    const y = Math.sin(phi) * sinTheta;
+    const z = cosTheta;
+
+    output[output_offset] = x;
+    output[output_offset + 1] = y;
+    output[output_offset + 2] = z;
+}

package/src/core/model/object/ObjectPoolFactory.d.ts

@@ -1,4 +1,6 @@
 /**
+ * Object Pool pattern implementation.
+ * Reuse objects instead of relying on garbage collector. Useful in cases where creating or destroying an object is costly, and objects are relatively short-lived
  * @template T
  */
 export class ObjectPoolFactory<T> {
@@ -8,6 +10,15 @@ export class ObjectPoolFactory<T> {
      * @param {function(T)} resetter
      */
     constructor(creator: () => T, destroyer?: (arg0: T) => any, resetter?: (arg0: T) => any);
+    /**
+     * @private
+     * @type {Array<T>}
+     */
+    private pool;
+    /**
+     * @type {number}
+     */
+    maxSize: number;
     /**
      * @private
      * @type {function(): T}
@@ -23,25 +34,21 @@ export class ObjectPoolFactory<T> {
      * @type {function(T)}
      */
     private resetter;
-    /**
-     * @private
-     * @type {Array<T>}
-     */
-    private pool;
-    /**
-     * @type {number}
-     */
-    maxSize: number;
     /**
      *
      * @returns {T}
      */
-    create(): T;
+    get(): T;
     /**
      *
      * @param {T} object
      * @returns {boolean} true if object was added back to the pool, false if pool was full and object was destroyed instead
      */
     release(object: T): boolean;
+    /**
+     * @deprecated use `get` instead
+     * @type {function(): T}
+     */
+    create: () => T;
 }
 //# sourceMappingURL=ObjectPoolFactory.d.ts.map

package/src/core/model/object/ObjectPoolFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObjectPoolFactory.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/ObjectPoolFactory.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;;;OAIG;IACH,2BAJsB,CAAC,qBACH,CAAC,4BACD,CAAC,UAqCpB;IA1BG;;;OAGG;IACH,gBAAsB;IACtB;;;OAGG;IACH,kBAA0B;IAC1B;;;OAGG;IACH,iBAAwB;IAExB;;;OAGG;IACH,aAAc;IAEd;;OAEG;IACH,SAFU,MAAM,CAEE;IAGtB;;;OAGG;IACH,UAFa,CAAC,CAwBb;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACC,OAAO,CAqBnB;CACJ"}
+{"version":3,"file":"ObjectPoolFactory.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/ObjectPoolFactory.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IAYI;;;;OAIG;IACH,2BAJsB,CAAC,qBACH,CAAC,4BACD,CAAC,UA6BpB;IA3CD;;;OAGG;IACH,aAAU;IAEV;;OAEG;IACH,SAFU,MAAM,CAEF;IAgBV;;;OAGG;IACH,gBAAsB;IAEtB;;;OAGG;IACH,kBAA0B;IAE1B;;;OAGG;IACH,iBAAwB;IAI5B;;;OAGG;IACH,OAFa,CAAC,CA2Bb;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACC,OAAO,CAuBnB;IAIL;;;OAGG;IACH,cAFsB,CAAC,CAEW;CAPjC"}

package/src/core/model/object/ObjectPoolFactory.js

@@ -3,9 +3,22 @@ import { assert } from "../../assert.js";
 import { noop } from "../../function/noop.js";
 
 /**
+ * Object Pool pattern implementation.
+ * Reuse objects instead of relying on garbage collector. Useful in cases where creating or destroying an object is costly, and objects are relatively short-lived
  * @template T
  */
 export class ObjectPoolFactory {
+    /**
+     * @private
+     * @type {Array<T>}
+     */
+    pool = [];
+
+    /**
+     * @type {number}
+     */
+    maxSize = 256;
+
     /**
      * @param {function():T} creator
      * @param {function(T)} destroyer
@@ -25,36 +38,31 @@ export class ObjectPoolFactory {
          * @type {function(): T}
          */
         this.creator = creator;
+
         /**
          * @private
          * @type {function(T)}
          */
         this.destroyer = destroyer;
+
         /**
          * @private
          * @type {function(T)}
          */
         this.resetter = resetter;
 
-        /**
-         * @private
-         * @type {Array<T>}
-         */
-        this.pool = [];
-
-        /**
-         * @type {number}
-         */
-        this.maxSize = 256;
     }
 
     /**
      *
      * @returns {T}
      */
-    create() {
-        if (this.pool.length > 0) {
-            const oldInstance = this.pool.pop();
+    get() {
+        const pool = this.pool;
+
+        if (pool.length > 0) {
+
+            const oldInstance = pool.pop();
 
             //reset the object
             this.resetter(oldInstance);
@@ -85,9 +93,11 @@ export class ObjectPoolFactory {
         assert.notNull(object, 'object');
         assert.defined(object, 'object');
 
-        assert.arrayHasNo(this.pool, object, `Pool already contains object that is being attempted to be release`);
+        const pool = this.pool;
 
-        if (this.pool.length >= this.maxSize) {
+        assert.arrayHasNo(pool, object, `Pool already contains object that is being attempted to be release`);
+
+        if (pool.length >= this.maxSize) {
             //pool is too large, destroy and discard the object
             if (this.destroyer !== noop) {
                 this.destroyer(object);
@@ -97,8 +107,15 @@ export class ObjectPoolFactory {
         }
 
         //add it to the pool
-        this.pool.push(object);
+        pool.push(object);
 
         return true;
     }
 }
+
+
+/**
+ * @deprecated use `get` instead
+ * @type {function(): T}
+ */
+ObjectPoolFactory.prototype.create = ObjectPoolFactory.prototype.get

package/src/engine/animation/clip/AnimationClip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationClip.js"],"names":[],"mappings":"AAEA;IACI,aAAS;IACT;;;OAGG;IACH,QAFU,gBAAgB,CAEf;IAEX,uBAWC;CACJ"}
+{"version":3,"file":"AnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationClip.js"],"names":[],"mappings":"AAEA;IACI,aAAS;IACT;;;OAGG;IACH,QAFU,gBAAgB,CAEf;IAEX;;;OAGG;IACH,uBAWC;CACJ"}

package/src/engine/animation/clip/AnimationClip.js

@@ -8,6 +8,10 @@ export class AnimationClip {
      */
     tracks = []
 
+    /**
+     *
+     * @return {number}
+     */
     get duration() {
         let r = 0;
 

package/src/engine/animation/clip/AnimationInterpolationKind.d.ts

@@ -0,0 +1,7 @@
+export type AnimationInterpolationKind = number;
+export namespace AnimationInterpolationKind {
+    let Discrete: number;
+    let Linear: number;
+    let CubicTangents: number;
+}
+//# sourceMappingURL=AnimationInterpolationKind.d.ts.map

package/src/engine/animation/clip/AnimationInterpolationKind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationInterpolationKind.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationInterpolationKind.js"],"names":[],"mappings":"yCAEU,MAAM"}

package/src/engine/animation/clip/AnimationInterpolationKind.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @enum {number}
+ */
+export const AnimationInterpolationKind = {
+    Discrete: 0,
+    Linear: 1,
+    CubicTangents: 2
+};

package/src/engine/animation/clip/AnimationTrack.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Represents animation of a meaningful multi-variate thing, such as 3d vector or single scalar
+ */
 export class AnimationTrack {
     /**
      *
@@ -33,6 +36,10 @@ export class AnimationTrack {
      * @return {number}
      */
     get duration(): number;
+    /**
+     *
+     * @return {number}
+     */
     get curveCount(): number;
     /**
      *
@@ -41,5 +48,10 @@ export class AnimationTrack {
      * @param {number} time
      */
     sample(output: number[] | Float32Array | Float64Array, output_offset: number, time: number): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isAnimationTrack: boolean;
 }
 //# sourceMappingURL=AnimationTrack.d.ts.map

package/src/engine/animation/clip/AnimationTrack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationTrack.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrack.js"],"names":[],"mappings":"AAEA;IAkEI;;;;;OAKG;IACH,qBAJW,gBAAgB,SAChB,MAAM,GACL,cAAc,CASzB;IA9ED;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,MAFU,MAAM,EAAE,CAET;IAET;;;OAGG;IACH,QAFU,gBAAgB,CAEf;IAEX;;;;;OAKG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,uBAYC;IAED,yBAEC;IAED;;;;;OAKG;IACH,eAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QAWhB;CAgBJ"}
+{"version":3,"file":"AnimationTrack.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrack.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAwEI;;;;;OAKG;IACH,qBAJW,gBAAgB,SAChB,MAAM,GACL,cAAc,CAYzB;IAvFD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,MAFU,MAAM,EAAE,CAET;IAET;;;OAGG;IACH,QAFU,gBAAgB,CAEf;IAEX;;;;;OAKG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,uBAYC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,eAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QAahB;IAqBL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC"}

package/src/engine/animation/clip/AnimationTrack.js

@@ -1,5 +1,9 @@
+import { assert } from "../../../core/assert.js";
 import { max2 } from "../../../core/math/max2.js";
 
+/**
+ * Represents animation of a meaningful multi-variate thing, such as 3d vector or single scalar
+ */
 export class AnimationTrack {
     /**
      * Human-readable label
@@ -45,6 +49,10 @@ export class AnimationTrack {
         return r;
     }
 
+    /**
+     *
+     * @return {number}
+     */
     get curveCount() {
         return this.curves.length;
     }
@@ -59,6 +67,8 @@ export class AnimationTrack {
         const curves = this.curves;
         const curve_count = curves.length;
 
+        assert.greaterThanOrEqual(output.length, output_offset + curve_count, 'output overflow');
+
         for (let i = 0; i < curve_count; i++) {
             const curve = curves[i];
 
@@ -73,6 +83,9 @@ export class AnimationTrack {
      * @return {AnimationTrack}
      */
     static from(curves = [], name = "") {
+        assert.isString(name, 'name');
+        assert.isArray(curves, 'curves');
+
         const r = new AnimationTrack();
 
         r.curves = curves;
@@ -80,4 +93,10 @@ export class AnimationTrack {
 
         return r;
     }
-}
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AnimationTrack.prototype.isAnimationTrack = true;

package/src/engine/animation/clip/AnimationTrackBinding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationTrackBinding.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrackBinding.js"],"names":[],"mappings":"AAEA;IAaI;;;;;OAKG;IACH,8DAFa,qBAAqB,CAWjC;IA3BD;;;OAGG;IACH,QAFU,mBAAiB,IAAI,CAElB;IAEb;;;OAGG;IACH,sBAAY;IAmBZ;;;OAGG;IACH,cAFW,MAAM,QAMhB;CACJ"}
+{"version":3,"file":"AnimationTrackBinding.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrackBinding.js"],"names":[],"mappings":"AAIA;IAaI;;;;;OAKG;IACH,8DAFa,qBAAqB,CAqBjC;IArCD;;;OAGG;IACH,QAFU,mBAAiB,IAAI,CAElB;IAEb;;;OAGG;IACH,sBAAY;IA6BZ;;;OAGG;IACH,cAFW,MAAM,QAMhB;CACJ"}

package/src/engine/animation/clip/AnimationTrackBinding.js

@@ -1,3 +1,5 @@
+import { assert } from "../../../core/assert.js";
+
 const sample = new Float64Array(1024);
 
 export class AnimationTrackBinding {
@@ -20,6 +22,16 @@ export class AnimationTrackBinding {
      * @returns {AnimationTrackBinding}
      */
     static from(writer, track) {
+        assert.defined(writer,'writer');
+        assert.isObject(writer,'writer');
+        assert.notNull(writer,'writer');
+        assert.equal(writer.isBoundValueWriter,true,'writer.isBoundValueWriter !== true');
+
+        assert.defined(track,'track');
+        assert.isObject(track,'track');
+        assert.notNull(track,'track');
+        assert.equal(track.isAnimationTrack,true,'track.isAnimationTrack !== true');
+
 
         const r = new AnimationTrackBinding();
 

package/src/engine/animation/clip/bind_property_writer.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {EntityNode} node
+ * @param {string} path
+ * @returns {BoundValueWriter}
+ */
+export function bind_property_writer(node: EntityNode, path: string): BoundValueWriter;
+import { BoundValueWriter } from "../curve/binding/BoundValueWriter.js";
+//# sourceMappingURL=bind_property_writer.d.ts.map

package/src/engine/animation/clip/bind_property_writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind_property_writer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/bind_property_writer.js"],"names":[],"mappings":"AAqFA;;;;;GAKG;AACH,6DAHW,MAAM,GACJ,gBAAgB,CA4B5B;iCAnHgC,sCAAsC"}

package/src/engine/animation/clip/bind_property_writer.js

@@ -0,0 +1,118 @@
+import Name from "../../ecs/name/Name.js";
+import { BoundQuaternionWriter } from "../curve/binding/BoundQuaternionWriter.js";
+import { BoundValueWriter } from "../curve/binding/BoundValueWriter.js";
+import { BoundVector3Writer } from "../curve/binding/BoundVector3Writer.js";
+
+/**
+ *
+ * @param {EntityNode} node
+ * @returns {string|undefined}
+ */
+function get_node_name(node) {
+    /**
+     * @type {Name}
+     */
+    const name = node.entity.getComponent(Name);
+
+    if (name === null) {
+        return undefined;
+    }
+
+    return name.getValue();
+}
+
+/**
+ * Following THREE.js PropertyBinding.findNode implementation
+ * @param {EntityNode} root
+ * @param {string} nodeName
+ * @returns {EntityNode|undefined}
+ */
+function find_node(root, nodeName) {
+
+    const root_name = get_node_name(root);
+
+    if (root_name === nodeName) {
+        return root;
+    }
+
+    // search into node subtree.
+    const children = root.children;
+
+    const child_count = children.length;
+
+
+    for (let j = 0; j < child_count; j++) {
+        /**
+         * @type {EntityNode}
+         */
+        const child = children[j];
+
+        const subtree_result = find_node(child, nodeName);
+
+        if (subtree_result !== undefined) {
+            return subtree_result;
+        }
+    }
+}
+
+/**
+ *
+ * @param {EntityNode} root
+ * @param {string[]} path_parts
+ */
+function entity_node_resolve_path(root, path_parts) {
+
+    let node = root;
+
+    const part_count = path_parts.length;
+    for (let i = 0; i < part_count; i++) {
+
+        const part = path_parts[i];
+
+        const sub_node = find_node(node, part);
+
+        if (sub_node === undefined) {
+
+            throw new Error(`Child '${part}' not found, at index ${i} of [${path_parts.join(', ')}]. Valid names at this level: [${node.children.map(get_node_name)}]`);
+
+        }
+
+        node = sub_node;
+    }
+
+    return node;
+}
+
+/**
+ *
+ * @param {EntityNode} node
+ * @param {string} path
+ * @returns {BoundValueWriter}
+ */
+export function bind_property_writer(node, path) {
+    const path_parts = path.split('.');
+
+    const property_name = path_parts[path_parts.length - 1];
+
+    const parent = entity_node_resolve_path(node, path_parts.slice(0, path_parts.length - 1));
+
+    let writer;
+
+    switch (property_name) {
+        case "position":
+            writer = new BoundVector3Writer(parent.transform.position);
+            break;
+        case "quaternion":
+            writer = new BoundQuaternionWriter(parent.transform.rotation);
+            break;
+        case "scale":
+            writer = new BoundVector3Writer(parent.transform.scale);
+            break;
+        default:
+            console.log(`Unsupported property name: ${property_name}`);
+            // NO-OP
+            writer = new BoundValueWriter();
+    }
+
+    return writer;
+}

package/src/engine/animation/clip/curve_from_track_data.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {AnimationCurve} curve
+ * @param {AnimationInterpolationKind} type
+ * @param {number[]|Float32Array} values
+ * @param {number[]|Float32Array} times
+ * @param {number} component_count
+ * @param {number} component_index
+ */
+export function curve_from_track_data(curve: AnimationCurve, type: AnimationInterpolationKind, values: number[] | Float32Array, times: number[] | Float32Array, component_count: number, component_index: number): void;
+import { AnimationInterpolationKind } from "./AnimationInterpolationKind.js";
+//# sourceMappingURL=curve_from_track_data.d.ts.map

package/src/engine/animation/clip/curve_from_track_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve_from_track_data.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/curve_from_track_data.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,mEANW,0BAA0B,UAC1B,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,mBACN,MAAM,QAchB;2CA1B0C,iCAAiC"}

package/src/engine/animation/clip/curve_from_track_data.js

@@ -0,0 +1,27 @@
+import { AnimationInterpolationKind } from "./AnimationInterpolationKind.js";
+import { curve_from_track_data_cubic_tangents } from "./curve_from_track_data_cubic_tangents.js";
+import { curve_from_track_data_discrete } from "./curve_from_track_data_discrete.js";
+import { curve_from_track_data_linear } from "./curve_from_track_data_linear.js";
+
+/**
+ *
+ * @param {AnimationCurve} curve
+ * @param {AnimationInterpolationKind} type
+ * @param {number[]|Float32Array} values
+ * @param {number[]|Float32Array} times
+ * @param {number} component_count
+ * @param {number} component_index
+ */
+export function curve_from_track_data(curve, type, values, times, component_count, component_index) {
+    switch (type) {
+        case AnimationInterpolationKind.Discrete:
+            return curve_from_track_data_discrete(curve, values, times, component_count, component_index);
+        case AnimationInterpolationKind.Linear:
+            return curve_from_track_data_linear(curve, values, times, component_count, component_index);
+        case AnimationInterpolationKind.CubicTangents:
+            return curve_from_track_data_cubic_tangents(curve, values, times, component_count, component_index);
+        default:
+            throw new Error(`Unsupported type '${type}'`);
+    }
+
+}

package/src/engine/animation/clip/curve_from_track_data_cubic_tangents.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {AnimationCurve} curve
+ * @param {number[]} values
+ * @param {number[]} times
+ * @param {number} component_count
+ * @param {number} component_index
+ */
+export function curve_from_track_data_cubic_tangents(curve: AnimationCurve, values: number[], times: number[], component_count: number, component_index: number): void;
+//# sourceMappingURL=curve_from_track_data_cubic_tangents.d.ts.map

package/src/engine/animation/clip/curve_from_track_data_cubic_tangents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve_from_track_data_cubic_tangents.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/curve_from_track_data_cubic_tangents.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,oFALW,MAAM,EAAE,SACR,MAAM,EAAE,mBACR,MAAM,mBACN,MAAM,QAwBhB"}

package/src/engine/animation/clip/curve_from_track_data_cubic_tangents.js

@@ -0,0 +1,33 @@
+import { Keyframe } from "../curve/Keyframe.js";
+
+/**
+ *
+ * @param {AnimationCurve} curve
+ * @param {number[]} values
+ * @param {number[]} times
+ * @param {number} component_count
+ * @param {number} component_index
+ */
+export function curve_from_track_data_cubic_tangents(curve, values, times, component_count, component_index) {
+
+    const key_count = times.length;
+
+    for (let k = 0; k < key_count; k++) {
+        const component_position = k * component_count;
+
+        // 3 corresponds to 3 parts of a keyframe: inTangent, value, outTangent
+        const base_offset = 3 * component_position;
+
+        // Layout of keyframe output values for CUBICSPLINE animations:
+        //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
+
+        const inTangent = values[base_offset + component_index];
+        const value = values[base_offset + component_count + component_index];
+        const outTangent = values[base_offset + component_count * 2 + component_index];
+
+        const time = times[k];
+
+        curve.add(Keyframe.from(time, value, inTangent, outTangent));
+    }
+
+}

package/src/engine/animation/clip/curve_from_track_data_discrete.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {AnimationCurve} curve
+ * @param {number[]} values
+ * @param {number[]} times
+ * @param {number} component_count
+ * @param {number} component_index
+ */
+export function curve_from_track_data_discrete(curve: AnimationCurve, values: number[], times: number[], component_count: number, component_index: number): void;
+//# sourceMappingURL=curve_from_track_data_discrete.d.ts.map

package/src/engine/animation/clip/curve_from_track_data_discrete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve_from_track_data_discrete.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/curve_from_track_data_discrete.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8EALW,MAAM,EAAE,SACR,MAAM,EAAE,mBACR,MAAM,mBACN,MAAM,QAqBhB"}

package/src/engine/animation/clip/curve_from_track_data_discrete.js

@@ -0,0 +1,30 @@
+import { Keyframe } from "../curve/Keyframe.js";
+
+/**
+ *
+ * @param {AnimationCurve} curve
+ * @param {number[]} values
+ * @param {number[]} times
+ * @param {number} component_count
+ * @param {number} component_index
+ */
+export function curve_from_track_data_discrete(curve, values, times, component_count, component_index) {
+
+    const key_count = times.length;
+
+    for (let k = 0; k < key_count; k++) {
+        const value = values[k * component_count + component_index];
+        const time = times[k];
+
+        curve.add(Keyframe.from(time, value));
+    }
+
+    const keys = curve.keys;
+
+    for (let i = key_count - 1; i > 0; i--) {
+        const key = keys[i];
+        const prev = keys[i - 1];
+
+        keys.splice(i, 0, Keyframe.from(key.time, prev.value));
+    }
+}