@woosh/meep-engine 2.109.22 → 2.109.24

package/build/meep.cjs

@@ -49144,7 +49144,7 @@ function computeStridedIntegerArrayHash(
     let hash = length;
 
     for (let i = offset; i < length; i += stride) {
-        const value = array[i] >>> 0; //force int32
+        const value = array[i] >>> 0; //force uint32
 
         /**
          * Simple hashing scheme, multiplying existing hash by a prime and adding next value

package/build/meep.module.js

@@ -49142,7 +49142,7 @@ function computeStridedIntegerArrayHash(
     let hash = length;
 
     for (let i = offset; i < length; i += stride) {
-        const value = array[i] >>> 0; //force int32
+        const value = array[i] >>> 0; //force uint32
 
         /**
          * Simple hashing scheme, multiplying existing hash by a prime and adding next value

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.109.22",
+  "version": "2.109.24",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/table/bind/TableRecord.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TableRecord.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/table/bind/TableRecord.js"],"names":[],"mappings":"AAGA;IA+DI;;;OAGG;IACH,yBAUC;IA7BD,qBAEC;IAND,kBAEC;IAOD,uBAIC;IAED,YAEC;IAkBD,sCAEC;IAED;;;;OAIG;IACH,sCAFW,MAAM,QAKhB;;CACJ;kCA9FiC,yBAAyB"}
+{"version":3,"file":"TableRecord.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/table/bind/TableRecord.js"],"names":[],"mappings":"AAKA;IA+DI;;;OAGG;IACH,yBAYC;IA/BD,qBAEC;IAND,kBAEC;IAOD,uBAIC;IAED,YAEC;IAoBD,sCAEC;IAED;;;;OAIG;IACH,sCAFW,MAAM,QAKhB;;CACJ;kCAhGiC,yBAAyB"}

package/src/core/collection/table/bind/TableRecord.js

@@ -1,4 +1,6 @@
 import { assert } from "../../../assert.js";
+import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
+import { validate_enum_schema } from "../../../model/validate_enum_schema.js";
 import { RowFirstTableSpec } from "../RowFirstTableSpec.js";
 
 export class TableRecord {
@@ -72,6 +74,8 @@ export class TableRecord {
         assert.notNull(schema, 'schema');
         assert.defined(schema, 'schema');
 
+        assert.ok(validate_enum_schema(schema, BinaryDataType, console.warn), 'invalid schema');
+
         this.#schema = schema;
         const keys = Object.keys(schema);
 

package/src/core/model/validate_enum_schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @template T
+ * @param {Object<BinaryDataType>} schema
+ * @param {Object<T>} enumerable
+ * @param {function(message:string)} [error_consumer]
+ * @param {*} [error_consumer_context]
+ */
+export function validate_enum_schema<T>(schema: any, enumerable: any, error_consumer?: typeof noop, error_consumer_context?: any): boolean;
+import { noop } from "../function/noop.js";
+//# sourceMappingURL=validate_enum_schema.d.ts.map

package/src/core/model/validate_enum_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate_enum_schema.d.ts","sourceRoot":"","sources":["../../../../src/core/model/validate_enum_schema.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,2IAoBC;qBA7BoB,qBAAqB"}

package/src/core/model/validate_enum_schema.js

@@ -0,0 +1,31 @@
+import { assert } from "../assert.js";
+import { noop } from "../function/noop.js";
+
+/**
+ * @template T
+ * @param {Object<BinaryDataType>} schema
+ * @param {Object<T>} enumerable
+ * @param {function(message:string)} [error_consumer]
+ * @param {*} [error_consumer_context]
+ */
+export function validate_enum_schema(schema, enumerable, error_consumer = noop, error_consumer_context) {
+
+    assert.notNull(schema, 'schema');
+    assert.isObject(schema, 'schema');
+
+    let valid = true;
+    const valid_types = Object.values(enumerable);
+
+    for (const schemaKey in schema) {
+
+        const type = schema[schemaKey];
+
+        if (!valid_types.includes(type)) {
+            error_consumer.call(error_consumer_context, `Field '${schemaKey}' is expected to have have BinaryDataType value, instead found '${type}'. Valid values are: ${valid_types.join(', ')}.`);
+            valid = false;
+        }
+
+    }
+
+    return valid;
+}

package/src/core/primitives/array/computeStridedArrayHash.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
+ * @template T
+ * @param {T[]|Uint32Array|Uint16Array|Uint8Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} stride
+ * @param {function(T):number} elementHash
+ * @param {*} [elementHashContext]
+ * @return {number}
+ */
+export function computeStridedArrayHash<T>(array: Uint8Array | Uint16Array | Uint32Array | T[], offset: number, length: number, stride: number, elementHash: (arg0: T) => number, elementHashContext?: any): number;
+//# sourceMappingURL=computeStridedArrayHash.d.ts.map

package/src/core/primitives/array/computeStridedArrayHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeStridedArrayHash.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/array/computeStridedArrayHash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wGAPW,MAAM,UACN,MAAM,UACN,MAAM,4BACM,MAAM,6BAEjB,MAAM,CAwBjB"}

package/src/core/primitives/array/computeStridedArrayHash.js

@@ -0,0 +1,36 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Useful for computing hashes of large arrays, can pick a relevant stride and skip large chunks of memory while still capturing good amount of unique information from evenly-spaced areas of the array
+ * @template T
+ * @param {T[]|Uint32Array|Uint16Array|Uint8Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} stride
+ * @param {function(T):number} elementHash
+ * @param {*} [elementHashContext]
+ * @return {number}
+ */
+export function computeStridedArrayHash(
+    array, offset, length, stride,
+    elementHash, elementHashContext
+) {
+
+    assert.isFunction(elementHash, 'elementHash');
+
+    let hash = length;
+
+    for (let i = offset; i < length; i += stride) {
+        const value = elementHash.call(elementHashContext, array[i]);
+
+        /**
+         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
+         * (h<<5) - h ===  h*31
+         * @type {number}
+         */
+        hash = ((hash << 5) - hash) + value;
+    }
+
+    // force uint32
+    return hash >>> 0;
+}

package/src/core/primitives/array/computeStridedIntegerArrayHash.js

@@ -12,7 +12,7 @@ export function computeStridedIntegerArrayHash(
     let hash = length;
 
     for (let i = offset; i < length; i += stride) {
-        const value = array[i] >>> 0; //force int32
+        const value = array[i] >>> 0; //force uint32
 
         /**
          * Simple hashing scheme, multiplying existing hash by a prime and adding next value
@@ -25,3 +25,4 @@ export function computeStridedIntegerArrayHash(
     // force uint32
     return hash >>> 0;
 }
+

package/src/engine/animation/async/TimeSeries.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @template T
+ */
+export class TimeSeries<T> {
+    /**
+     *
+     * @param {Object<BinaryDataType>} schema
+     * @param {string} [time_column_name]
+     */
+    constructor(schema: any, time_column_name?: string);
+    /**
+     * @type {RowFirstTableSpec}
+     */
+    spec: RowFirstTableSpec;
+    /**
+     * @type {RowFirstTable}
+     */
+    table: RowFirstTable;
+    time_column_index: number;
+    /**
+     *
+     * @param {number} index
+     * @returns {Object}
+     */
+    getSampleObjectByIndex(index: number): any;
+    /**
+     *
+     * @returns {number}
+     */
+    get sample_count(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    get last_timestamp(): number;
+    validateNextSample(data: any): void;
+    /**
+     *
+     * @param {number[]} data
+     */
+    addSample(data: number[]): void;
+    /**
+     *
+     * @param {Object} sample
+     */
+    addObjectSample(sample: any): void;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} index
+     */
+    getSampleByIndex(result: number[], index: number): void;
+    /**
+     *
+     * @param {number} time
+     * @returns {number}
+     */
+    findLowSampleIndexByTime(time: number): number;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {number} time
+     */
+    sampleLinear(result: number[], result_offset: number, time: number): void;
+    /**
+     * Get linearly interpolated sample for given time in object form, following supplied schema
+     * @param {number} time
+     * @returns {Object}
+     */
+    sampleObjectLinear(time: number): any;
+    #private;
+}
+import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
+//# sourceMappingURL=TimeSeries.d.ts.map

package/src/engine/animation/async/TimeSeries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeSeries.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/async/TimeSeries.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IA+BI;;;;OAIG;IACH,4CAFW,MAAM,EAuChB;IAxED;;OAEG;IACH,MAFU,iBAAiB,CAEvB;IAEJ;;OAEG;IACH,OAFU,aAAa,CAElB;IAEL,0BAAsB;IAyHtB;;;;OAIG;IACH,8BAHW,MAAM,OAOhB;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,6BAWC;IAED,oCAcC;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAQlB;IAED;;;OAGG;IACH,mCAIC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,SACR,MAAM,QAIhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,iBACR,MAAM,QACN,MAAM,QAuBhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,OAShB;;CAEJ;kCAzRiC,qDAAqD;8BADzD,iDAAiD"}

package/src/engine/animation/async/TimeSeries.js

@@ -0,0 +1,285 @@
+import { assert } from "../../../core/assert.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
+import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
+import { inverseLerp } from "../../../core/math/inverseLerp.js";
+import { lerp } from "../../../core/math/lerp.js";
+import { max2 } from "../../../core/math/max2.js";
+import { min2 } from "../../../core/math/min2.js";
+import { validate_enum_schema } from "../../../core/model/validate_enum_schema.js";
+import { findSampleIndex } from "./findSampleIndex.js";
+
+const scratch_row = [];
+
+/**
+ * @template T
+ */
+export class TimeSeries {
+    /**
+     * @type {RowFirstTableSpec}
+     */
+    spec
+
+    /**
+     * @type {RowFirstTable}
+     */
+    table
+
+    time_column_index = 0;
+
+    /**
+     *
+     * @type {Object<BinaryDataType>}
+     */
+    #schema = {}
+
+    /**
+     *
+     * @type {Object<number>}
+     */
+    #schema_column_names_to_indices = {};
+
+    /**
+     *
+     * @type {string[]}
+     */
+    #schema_column_indices_to_names = [];
+
+    /**
+     *
+     * @param {Object<BinaryDataType>} schema
+     * @param {string} [time_column_name]
+     */
+    constructor(schema, time_column_name = 'time') {
+        assert.isString(time_column_name, 'time_column_name');
+        assert.notNull(schema, 'schema');
+        assert.isObject(schema, 'schema');
+
+        let issues = [];
+
+        if (!validate_enum_schema(schema, BinaryDataType, (issue) => issues.push(issue))) {
+            throw new TypeError(`Invalid schema. Problems:\n ${issues.join('\n')}`);
+        }
+
+        this.#schema = schema;
+
+        const schema_keys = Object.keys(schema);
+
+        const time_row_index = schema_keys.indexOf(time_column_name);
+
+        if (time_row_index === -1) {
+            throw new TypeError(`supplies schema does not include time column '${time_column_name}', exising columns: ${schema_keys.join(', ')}`);
+        }
+
+        this.time_column_index = time_row_index;
+
+
+        this.#schema_column_names_to_indices = {};
+
+        for (let i = 0; i < schema_keys.length; i++) {
+            const key = schema_keys[i];
+
+            this.#schema_column_names_to_indices[key] = i;
+            this.#schema_column_indices_to_names[i] = key;
+        }
+
+        this.spec = RowFirstTableSpec.get(Object.values(schema));
+
+        this.table = new RowFirstTable(this.spec);
+
+    }
+
+    /**
+     *
+     * @param {number[]} row
+     * @param {Object} object
+     */
+    #object_to_row(row, object) {
+
+        const columnCount = this.spec.getColumnCount();
+
+        for (let i = 0; i < columnCount; i++) {
+
+            const key = this.#schema_column_indices_to_names[i];
+
+            const value = object[key];
+
+            const t = typeof value;
+
+            if (t !== "number") {
+                throw new TypeError(`Expected sample.${key} to be a number, instead was ${t} (=${value})`);
+            }
+
+            row[i] = value;
+
+        }
+    }
+
+    /**
+     *
+     * @param {Object} object
+     * @param {number[]} row
+     */
+    #row_to_object(object, row) {
+
+        const columnCount = this.spec.getColumnCount();
+        for (let i = 0; i < columnCount; i++) {
+
+            const key = this.#schema_column_indices_to_names[i];
+
+            object[key] = row[i];
+        }
+
+    }
+
+    /**
+     *
+     * @param {number[]} row
+     * @returns {Object}
+     */
+    #row_to_object_allocating(row) {
+
+        const result = {};
+
+        this.#row_to_object(result, row);
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @returns {Object}
+     */
+    getSampleObjectByIndex(index) {
+        this.table.getRow(index, scratch_row);
+
+        return this.#row_to_object_allocating(scratch_row);
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get sample_count() {
+        return this.table.length;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get last_timestamp() {
+        const table = this.table;
+        const record_count = table.length;
+
+        if (record_count === 0) {
+            // default
+            return 0;
+        }
+
+        const time_column = this.time_column_index;
+        return table.readCellValue(record_count - 1, time_column);
+    }
+
+    validateNextSample(data) {
+
+        const table = this.table;
+        const record_count = table.length;
+
+        if (record_count > 0) {
+            const time_column = this.time_column_index;
+            const last_time = table.readCellValue(record_count - 1, time_column);
+
+            if (data[time_column] <= last_time) {
+                throw new Error(`Sample.time[${time_column}] = ${data[time_column]}, which is <= to previous time stamp(=${last_time}). Each sample's time stamp must be strictly greater than the previous one`);
+            }
+        }
+
+    }
+
+    /**
+     *
+     * @param {number[]} data
+     */
+    addSample(data) {
+        // validate
+        this.validateNextSample(data);
+
+        const table = this.table;
+        table.addRow(data);
+    }
+
+    /**
+     *
+     * @param {Object} sample
+     */
+    addObjectSample(sample) {
+        this.#object_to_row(scratch_row, sample);
+
+        this.addSample(scratch_row);
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} index
+     */
+    getSampleByIndex(result, index) {
+        this.table.getRow(index, result)
+    }
+
+    /**
+     *
+     * @param {number} time
+     * @returns {number}
+     */
+    findLowSampleIndexByTime(time) {
+        const table = this.table;
+        const time_column_index = this.time_column_index;
+        return max2(0, findSampleIndex(table, time, time_column_index))
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {number} time
+     */
+    sampleLinear(result, result_offset, time) {
+        const table = this.table;
+        const time_column_index = this.time_column_index;
+
+        // seek to the right sample
+        const sample_index = this.findLowSampleIndexByTime(time);
+        const next_sample_index = min2(table.length - 1, sample_index + 1);
+
+        const prev = table.readCellValue(sample_index, time_column_index);
+        const next = table.readCellValue(next_sample_index, time_column_index);
+
+        const normalized_offset = inverseLerp(prev, next, time);
+
+        const column_count = this.spec.getColumnCount();
+
+        for (let i = 0; i < column_count; i++) {
+            const v0 = table.readCellValue(sample_index, i);
+            const v1 = table.readCellValue(next_sample_index, i);
+
+            result[result_offset + i] = lerp(v0, v1, normalized_offset)
+        }
+    }
+
+    /**
+     * Get linearly interpolated sample for given time in object form, following supplied schema
+     * @param {number} time
+     * @returns {Object}
+     */
+    sampleObjectLinear(time) {
+
+        this.sampleLinear(scratch_row, 0, time);
+
+        return this.#row_to_object_allocating(scratch_row);
+
+    }
+
+}

package/src/engine/animation/async/findSampleIndex.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {RowFirstTable} table
+ * @param {number} time
+ * @param {number} [column_index]
+ * @return {number}
+ */
+export function findSampleIndex(table: RowFirstTable, time: number, column_index?: number): number;
+//# sourceMappingURL=findSampleIndex.d.ts.map

package/src/engine/animation/async/findSampleIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findSampleIndex.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/async/findSampleIndex.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4DAJW,MAAM,iBACN,MAAM,GACL,MAAM,CAuBjB"}

package/src/engine/animation/async/findSampleIndex.js

@@ -0,0 +1,31 @@
+import { min2 } from "../../../core/math/min2.js";
+
+/**
+ *
+ * @param {RowFirstTable} table
+ * @param {number} time
+ * @param {number} [column_index]
+ * @return {number}
+ */
+export function findSampleIndex(table, time, column_index = 0) {
+    let minIndex = 0;
+    let maxIndex = table.length - 1;
+
+    while (minIndex <= maxIndex) {
+
+        const pivotIndex = (minIndex + maxIndex) >> 1;
+
+        const cmp = time - table.readCellValue(pivotIndex, column_index);
+
+        if (cmp > 0) {
+            minIndex = pivotIndex + 1;
+        } else if (cmp < 0) {
+            maxIndex = pivotIndex - 1;
+        } else {
+            //set low boundary for next step based on assumption that upper bound is higher than lower bound
+            return pivotIndex;
+        }
+    }
+
+    return min2(minIndex, maxIndex);
+}

package/src/engine/animation/async/prototypeAsyncAnimation.js

@@ -1,11 +1,7 @@
 import { GUI } from "dat.gui";
 import { MeshBasicMaterial, MeshStandardMaterial, OctahedronBufferGeometry } from "three";
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
-import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
-import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
 import { Color } from "../../../core/color/Color.js";
-import { inverseLerp } from "../../../core/math/inverseLerp.js";
-import { lerp } from "../../../core/math/lerp.js";
 import { max2 } from "../../../core/math/max2.js";
 import { min2 } from "../../../core/math/min2.js";
 import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
@@ -27,42 +23,14 @@ import { BehaviorComponent } from "../../intelligence/behavior/ecs/BehaviorCompo
 import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
 import { ActionBehavior } from "../../intelligence/behavior/primitive/ActionBehavior.js";
 import { RandomDelayBehavior } from "../../intelligence/behavior/util/RandomDelayBehavior.js";
+import { TimeSeries } from "./TimeSeries.js";
 
 const harness = new EngineHarness();
 
-/**
- *
- * @param {RowFirstTable} table
- * @param {number} time
- * @return {number}
- */
-function findSampleIndex(table, time) {
-    let minIndex = 0;
-    let maxIndex = table.length - 1;
-
-    while (minIndex <= maxIndex) {
-
-        const pivotIndex = (minIndex + maxIndex) >> 1;
-
-        const cmp = time - table.readCellValue(pivotIndex, 0);
-
-        if (cmp > 0) {
-            minIndex = pivotIndex + 1;
-        } else if (cmp < 0) {
-            maxIndex = pivotIndex - 1;
-        } else {
-            //set low boundary for next step based on assumption that upper bound is higher than lower bound
-            return pivotIndex;
-        }
-    }
-
-    return min2(minIndex, maxIndex);
-}
-
 /**
  *
  * @param {EntityComponentDataset} ecd
- * @param {RowFirstTable} table
+ * @param {TimeSeries} table
  * @param {number} [count]
  */
 function makeGhostMarkers({
@@ -108,10 +76,12 @@ function makeGhostMarkers({
     return {
         set time(time) {
 
-            const ref_index = findSampleIndex(table, time);
+            const sample = table.sampleObjectLinear(time);
+
+            const ref_index = table.findLowSampleIndexByTime(time);
 
             const start_index = max2(0, ref_index - Math.floor(count / 2));
-            const limit_index = min2(table.length - 1, ref_index + Math.ceil(count / 2));
+            const limit_index = min2(table.sample_count - 1, ref_index + Math.ceil(count / 2));
 
             for (let i = 0; i < count; i++) {
 
@@ -137,10 +107,12 @@ function makeGhostMarkers({
 
                 const transform = entity.getComponentSafe(Transform);
 
+                const sample = table.getSampleObjectByIndex(sample_index);
+
                 transform.position.set(
-                    table.readCellValue(sample_index, 1),
-                    table.readCellValue(sample_index, 2),
-                    table.readCellValue(sample_index, 3)
+                    sample.x,
+                    sample.y,
+                    sample.z
                 );
 
             }
@@ -158,23 +130,19 @@ async function main(engine) {
         engine
     });
 
-    const table = new RowFirstTable(
-        RowFirstTableSpec.get([
-            BinaryDataType.Float64, // time
-            BinaryDataType.Float32, // x
-            BinaryDataType.Float32, //y
-            BinaryDataType.Float32 //z
-        ])
-    );
+    const timeSeries = new TimeSeries({
+        time: BinaryDataType.Float64,
+        x: BinaryDataType.Float32,
+        y: BinaryDataType.Float32,
+        z: BinaryDataType.Float32,
+    }, 'time');
 
     const random = seededRandom(42);
 
-    table.addRow([
+    timeSeries.addSample([
         0, 0, 1, 0
     ]);
 
-    const sample = [];
-
     const sim_clock = new Clock();
     sim_clock.start();
 
@@ -183,9 +151,7 @@ async function main(engine) {
         const time_delta = sim_clock.getDelta();
 
         // get last row
-        const row_count = table.length;
-
-        table.getRow(row_count - 1, sample);
+        const last_record = timeSeries.getSampleObjectByIndex(timeSeries.sample_count - 1);
 
         const speed = 7;
 
@@ -196,15 +162,14 @@ async function main(engine) {
         const displacement_x = displacement * Math.cos(direction);
         const displacement_y = displacement * Math.sin(direction);
 
-        const new_x = sample[1] + displacement_x;
-        const new_z = sample[3] + displacement_y;
+        const new_x = last_record.x + displacement_x;
+        const new_z = last_record.z + displacement_y;
 
-        table.addRow([
-            sample[0] + time_delta,
+        timeSeries.addSample([
+            last_record.time + time_delta,
             new_x,
             1,
             new_z,
-
         ]);
     }
 
@@ -226,14 +191,14 @@ async function main(engine) {
         playing: true,
         play_time: -1,
         get latest_data_time() {
-            return table.readCellValue(table.length - 1, 0);
+            return timeSeries.last_timestamp;
         },
         get behind_latest() {
-            return table.readCellValue(table.length - 1, 0) - this.play_time;
+            return timeSeries.last_timestamp - this.play_time;
         },
         set behind_latest(v) {
 
-            const current_delay = table.readCellValue(table.length - 1, 0) - this.play_time;
+            const current_delay = timeSeries.last_timestamp - this.play_time;
 
             const delta = v - current_delay;
 
@@ -260,38 +225,21 @@ async function main(engine) {
                     sim_parameters.play_time += delta;
                 }
 
-
-                // seek to the right sample
-                const sample_index = max2(0, findSampleIndex(table, sim_parameters.play_time));
-                const next_sample_index = min2(table.length - 1, sample_index + 1);
-
-                const prev = table.readCellValue(sample_index, 0);
-                const next = table.readCellValue(next_sample_index, 0);
-
-                const normalized_offset = inverseLerp(prev, next, sim_parameters.play_time);
+                const sample = timeSeries.sampleObjectLinear(sim_parameters.play_time);
 
                 const transform = subject.getComponentSafe(Transform);
 
-                const x0 = table.readCellValue(sample_index, 1);
-                const x1 = table.readCellValue(next_sample_index, 1);
-
-                const y0 = table.readCellValue(sample_index, 2);
-                const y1 = table.readCellValue(next_sample_index, 2);
-
-                const z0 = table.readCellValue(sample_index, 3);
-                const z1 = table.readCellValue(next_sample_index, 3);
-
                 transform.position.set(
-                    lerp(x0, x1, normalized_offset),
-                    lerp(y0, y1, normalized_offset),
-                    lerp(z0, z1, normalized_offset),
+                    sample.x,
+                    sample.y,
+                    sample.z,
                 );
             })
         )))
         .build(ecd);
 
     const markers = makeGhostMarkers({
-        ecd, table, count: 5
+        ecd, table: timeSeries, count: 5
     });
 
     engine.ticker.onTick.add(() => markers.time = sim_parameters.play_time);

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeBufferAttributeHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,sDAHW,MAAM,eAAe,GACnB,MAAM,CAsBlB"}
+{"version":3,"file":"computeBufferAttributeHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,sDAHW,MAAM,eAAe,GACnB,MAAM,CAyBlB"}

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js

@@ -1,5 +1,6 @@
 import { min2 } from "../../../../core/math/min2.js";
-import { computeStridedIntegerArrayHash } from "../../../../core/primitives/array/computeStridedIntegerArrayHash.js";
+import { computeStridedArrayHash } from "../../../../core/primitives/array/computeStridedArrayHash.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 
 /**
  *
@@ -21,7 +22,10 @@ export function computeBufferAttributeHash(attribute) {
         // compute stride so that we don't have to iterate over the entire buffer, instead picking at most X(509) values to consider
         const stride = Math.max(1, Math.ceil(hash_evaluation_length / 31));
 
-        result ^= computeStridedIntegerArrayHash(data, 0, hash_evaluation_length, stride);
+        result ^= computeStridedArrayHash(
+            data, 0, hash_evaluation_length, stride,
+            computeHashFloat
+        );
 
     }
 

package/src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js"],"names":[],"mappings":"AA0FA;IAuiCI;;;;OAIG;IACH,4BAFa,eAAe,CAM3B;IA/iCD;;OAEG;IACH,IAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,wBAAoB;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEe;IAChC,eAA6B;IAC7B,qBAAsC;IAEtC;;;;;OAKG;IACH,qCAA2C;IAE3C;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,cAFU,YAAY,GAAC,MAAM,CAEM;IAEnC;;;OAGG;IACH,WAFU,YAAY,GAAC,IAAI,CAEV;IAEjB;;;OAGG;IACH,MAFU,WAAS,IAAI,CAEX;IAEZ;;;OAGG;IACH,mBAFU,SAAS,CAEQ;IAG3B;;;;OAIG;IACH,yBAFU,KAAK,CAE2E;IAE1F;;;OAGG;IACH,yBAFU,KAAK,CAE8B;IAG7C;;;OAGG;IACH,OAFU,MAAM,CAE6F;IAE7G;;;;OAIG;IACH,eAAW;IAGX;;;OAGG;IACH,qBAFU,YAAY,CAEU;IAWhC,wBAIC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,SAC1B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,OAAO,CAInB;IAED;;OAEG;IACH,gCAaC;IAED;;;;;;;;;;;;;MAeC;IAED,0BAkEC;IAGD;;;OAGG;IACH,gBAFW,aAAa,QASvB;IAED;;;;OAIG;IACH,kDAUC;IAED;;;;OAIG;IACH,iCAHW,aAAa,GACZ,MAAM,CA2CjB;IAED,8BA0DC;IAED,8BAmBC;IAED,2BAmBC;IAED,6BAkBC;IAED;;;OAGG;IACH,uCAHW,MAAM,GACJ,MAAM,CA+BlB;IAED,cAuCC;IAED,mBA6BC;IAuBD,eAOC;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAQnB;IAED;;;;OAIG;IACH,qCAyFC;IAED,eAOC;IAED;;;OAGG;IACH,4BAFY,MAAM,CAejB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAiCD;;;;OAIG;IACH,sCA+GC;IAED;;;;OAIG;IACH,qCA6GC;IAED;;;OAGG;IACH,aA4CC;IAGD;;OAEG;IACH,gBAIC;;CAYJ;;;;;;;;;;;;;;;;oBAhoCmB,wCAAwC;uBAFrC,2CAA2C;6BAOrC,6CAA6C;6BAqB7C,mBAAmB;0BAnCtB,+CAA+C;sBAGnD,8CAA8C;6BAYvC,8BAA8B;oCAiBvB,0BAA0B;8BAChC,oBAAoB;uCAF3C,0BAA0B;6CAA1B,0BAA0B;kDAA1B,0BAA0B;4CAA1B,0BAA0B;4CAA1B,0BAA0B;kDAA1B,0BAA0B;wCAA1B,0BAA0B;sCAA1B,0BAA0B;4CAA1B,0BAA0B;AAWjC,yCAKC"}
+{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js"],"names":[],"mappings":"AA2FA;IAyiCI;;;;OAIG;IACH,4BAFa,eAAe,CAM3B;IAjjCD;;OAEG;IACH,IAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,wBAAoB;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEe;IAChC,eAA6B;IAC7B,qBAAsC;IAEtC;;;;;OAKG;IACH,qCAA2C;IAE3C;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,cAFU,YAAY,GAAC,MAAM,CAEM;IAEnC;;;OAGG;IACH,WAFU,YAAY,GAAC,IAAI,CAEV;IAEjB;;;OAGG;IACH,MAFU,WAAS,IAAI,CAEX;IAEZ;;;OAGG;IACH,mBAFU,SAAS,CAEQ;IAG3B;;;;OAIG;IACH,yBAFU,KAAK,CAE2E;IAE1F;;;OAGG;IACH,yBAFU,KAAK,CAE8B;IAG7C;;;OAGG;IACH,OAFU,MAAM,CAE6F;IAE7G;;;;OAIG;IACH,eAAW;IAGX;;;OAGG;IACH,qBAFU,YAAY,CAEU;IAWhC,wBAIC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,SAC1B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,OAAO,CAInB;IAED;;OAEG;IACH,gCAaC;IAED;;;;;;;;;;;;;MAeC;IAED,0BAkEC;IAGD;;;OAGG;IACH,gBAFW,aAAa,QASvB;IAED;;;;OAIG;IACH,kDAUC;IAED;;;;OAIG;IACH,iCAHW,aAAa,GACZ,MAAM,CA2CjB;IAED,8BA0DC;IAED,8BAmBC;IAED,2BAmBC;IAED,6BAkBC;IAED;;;OAGG;IACH,uCAHW,MAAM,GACJ,MAAM,CA+BlB;IAED,cAuCC;IAED,mBA6BC;IAuBD,eAOC;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAQnB;IAED;;;;OAIG;IACH,qCA2FC;IAED,eAOC;IAED;;;OAGG;IACH,4BAFY,MAAM,CAejB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAiCD;;;;OAIG;IACH,sCA+GC;IAED;;;;OAIG;IACH,qCA6GC;IAED;;;OAGG;IACH,aA4CC;IAGD;;OAEG;IACH,gBAIC;;CAYJ;;;;;;;;;;;;;;;;oBAloCmB,wCAAwC;uBAFrC,2CAA2C;6BAOrC,6CAA6C;6BAqB7C,mBAAmB;0BApCtB,+CAA+C;sBAInD,8CAA8C;6BAYvC,8BAA8B;oCAiBvB,0BAA0B;8BAChC,oBAAoB;uCAF3C,0BAA0B;6CAA1B,0BAA0B;kDAA1B,0BAA0B;4CAA1B,0BAA0B;4CAA1B,0BAA0B;kDAA1B,0BAA0B;wCAA1B,0BAA0B;sCAA1B,0BAA0B;4CAA1B,0BAA0B;AAWjC,yCAKC"}

package/src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js

@@ -3,6 +3,7 @@ import { assert } from "../../../../../../core/assert.js";
 import { BvhClient } from "../../../../../../core/bvh2/bvh3/BvhClient.js";
 import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 import List from "../../../../../../core/collection/list/List.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { AABB3 } from "../../../../../../core/geom/3d/aabb/AABB3.js";
 import { aabb3_array_combine } from "../../../../../../core/geom/3d/aabb/aabb3_array_combine.js";
 import { aabb3_expand_array } from "../../../../../../core/geom/3d/aabb/aabb3_expand_array.js";
@@ -60,9 +61,9 @@ const scratch_near_plane_normal = new Float32Array(3);
 
 /**
  *
- * @type {number[]}
+ * @type {Float32Array}
  */
-const scratch_array = [];
+const scratch_aabb3 = new Float32Array(6);
 
 /**
  *
@@ -484,17 +485,17 @@ export class ParticleEmitter {
         //retire dead particles
         const particles = this.particles;
 
-        particles.computeAttributeVector3AxisAlignedBoundingBox(PARTICLE_ATTRIBUTE_POSITION, scratch_array);
+        particles.computeAttributeVector3AxisAlignedBoundingBox(PARTICLE_ATTRIBUTE_POSITION, scratch_aabb3);
 
         //expand bounds by maximum sprite size
         const extents = this.computeSpriteMaxHalfSize();
 
-        aabb3_expand_array(scratch_array, scratch_array, extents);
+        aabb3_expand_array(scratch_aabb3, scratch_aabb3, extents);
 
         //write updated bonds
         const bb = this.particleBounds;
 
-        bb.readFromArray(scratch_array);
+        bb.readFromArray(scratch_aabb3);
 
         this.updateGeometryBounds();
 
@@ -516,7 +517,7 @@ export class ParticleEmitter {
         const ebb = this.emissionBounds;
         const pbb = this.particleBounds;
 
-        aabb3_array_combine(this.bvh_leaf.bounds,0, ebb,0, pbb,0);
+        aabb3_array_combine(this.bvh_leaf.bounds, 0, ebb, 0, pbb, 0);
 
         this.bvh_leaf.write_bounds();
 
@@ -732,15 +733,17 @@ export class ParticleEmitter {
         }
 
         //Stack-based implementation, avoiding recursion for performance improvement
-        const stack = scratch_array;
+        const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+        const stack_top = stack.pointer;
+        let stackPointer = stack_top;
 
-        stack[0] = 0;
-        stack[1] = particleCount - 1;
+        stack[stackPointer++] = 0;
+        stack[stackPointer++] = particleCount - 1;
 
-        let stackPointer = 2;
         let i, j;
 
-        while (stackPointer > 0) {
+        while (stackPointer > stack_top) {
             stackPointer -= 2;
 
             const right = stack[stackPointer + 1];

package/src/engine/graphics/particles/particular/engine/emitter/ParticlePool.js

@@ -525,7 +525,7 @@ export class ParticlePool {
 
         const data = attribute.array;
 
-        aabb3_from_v3_array(result,data,particle_count*3);
+        aabb3_from_v3_array(result, data, particle_count * 3);
 
     }