@woosh/meep-engine 2.47.42 → 2.48.0

package/editor/ecs/component/editors/ecs/ParticleEmitterLayerEditor.js

@@ -11,7 +11,7 @@ import {
 import {
     EmissionFromType
 } from "../../../../../src/engine/graphics/particles/particular/engine/emitter/EmissionFromType.js";
-import { DataType } from "../../../../../src/core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../../src/core/binary/type/BinaryDataType.js";
 import { ParameterTrackSetEditor } from "./ParameterTrackSetEditor.js";
 
 export class ParticleEmitterLayerEditor extends ObjectEditor {
@@ -30,11 +30,11 @@ export class ParticleEmitterLayerEditor extends ObjectEditor {
                 },
                 emissionRate: {
                     type: Number,
-                    numeric_type: DataType.Uint32
+                    numeric_type: BinaryDataType.Uint32
                 },
                 emissionImmediate: {
                     type: Number,
-                    numeric_type: DataType.Uint32
+                    numeric_type: BinaryDataType.Uint32
                 },
                 parameterTracks: {
                     editor: new ParameterTrackSetEditor()

package/editor/view/node-graph/NodeGraphView.js

@@ -356,7 +356,7 @@ export class NodeGraphView extends View {
      * @param {CanvasRenderingContext2D} ctx
      * @param {Vector2} source
      * @param {Vector2} target
-     * @param {DataType} dataType
+     * @param {BinaryDataType} dataType
      */
     drawConnection(ctx, source, target, dataType) {
         //check that the connection is visible

package/package.json

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

package/samples/terrain/editor.js

@@ -14,10 +14,10 @@ import { computeStringHash } from "../../src/core/primitives/strings/computeStri
 import { noop, strictEquals } from "../../src/core/function/Functions.js";
 import { scaleSampler2D } from "../../src/engine/graphics/texture/sampler/scaleSampler2D.js";
 import { Sampler2D } from "../../src/engine/graphics/texture/sampler/Sampler2D.js";
-import { DataType } from "../../src/core/collection/table/DataType.js";
+import { BinaryDataType } from "../../src/core/binary/type/BinaryDataType.js";
 import {
     compute_typed_array_constructor_from_data_type
-} from "../../src/core/collection/table/DataType2TypedArrayConstructorMapping.js";
+} from "../../src/core/binary/type/DataType2TypedArrayConstructorMapping.js";
 import { copy_Sampler2D_channel_data } from "../../src/engine/graphics/texture/sampler/copy_Sampler2D_channel_data.js";
 import { TextureAssetLoader } from "../../src/engine/asset/loaders/texture/TextureAssetLoader.js";
 import { CanvasView } from "../../src/view/elements/CanvasView.js";
@@ -70,10 +70,10 @@ class EditorTextureSlot {
      * @param {(Sampler2D)=>any} read
      * @param {(Sampler2D)=>any} write
      * @param {number} [itemSize]
-     * @param {DataType} [dataType]
+     * @param {BinaryDataType} [dataType]
      * @return {EditorTextureSlot}
      */
-    static from({ read, write, itemSize = 1, dataType = DataType.Uint8 }) {
+    static from({ read, write, itemSize = 1, dataType = BinaryDataType.Uint8 }) {
         const r = new EditorTextureSlot();
 
         r.__read = read;

package/src/core/{collection/table/DataType.js → binary/type/BinaryDataType.js}

@@ -2,7 +2,7 @@
  * @readonly
  * @enum {string}
  */
-export const DataType = {
+export const BinaryDataType = {
     Uint8: "uint8",
     Uint16: "uint16",
     Uint32: "uint32",

package/src/core/binary/type/DataType2TypedArrayConstructorMapping.js

@@ -0,0 +1,34 @@
+import { BinaryDataType } from "./BinaryDataType.js";
+
+
+/**
+ * Mapping from {@DataType} to TypedArray constructors
+ * @enum {function}
+ */
+export const DataType2TypedArrayConstructorMapping = {
+    [BinaryDataType.Uint8]: Uint8Array,
+    [BinaryDataType.Uint16]: Uint16Array,
+    [BinaryDataType.Uint32]: Uint32Array,
+    [BinaryDataType.Int8]: Int8Array,
+    [BinaryDataType.Int16]: Int16Array,
+    [BinaryDataType.Int32]: Int32Array,
+    // No float16 array type, using uint16 as a backing instead
+    [BinaryDataType.Float16]: Uint16Array,
+    [BinaryDataType.Float32]: Float32Array,
+    [BinaryDataType.Float64]: Float64Array,
+};
+
+/**
+ *
+ * @param {BinaryDataType} dt
+ * @returns {constructor|function}
+ */
+export function compute_typed_array_constructor_from_data_type(dt) {
+    const r = DataType2TypedArrayConstructorMapping[dt];
+
+    if (r === undefined) {
+        throw new Error(`Unsupported data type '${dt}'`);
+    }
+
+    return r;
+}

package/src/core/binary/type/DataTypeByteSizes.js

@@ -0,0 +1,37 @@
+import { BinaryDataType } from "./BinaryDataType.js";
+
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const DataTypeByteSizes = {
+    [BinaryDataType.Uint8]: 1,
+    [BinaryDataType.Uint16]: 2,
+    [BinaryDataType.Uint32]: 4,
+    [BinaryDataType.Uint64]: 8,
+
+    [BinaryDataType.Int8]: 1,
+    [BinaryDataType.Int16]: 2,
+    [BinaryDataType.Int32]: 4,
+    [BinaryDataType.Int64]: 8,
+
+    [BinaryDataType.Float16]: 2,
+    [BinaryDataType.Float32]: 4,
+    [BinaryDataType.Float64]: 8
+};
+
+
+/**
+ *
+ * @param {BinaryDataType} type
+ * @return {number}
+ */
+export function dataTypeByteSize(type) {
+    const size = DataTypeByteSizes[type];
+
+    if (size === undefined) {
+        throw new Error(`Unsupported type '${type}'`);
+    }
+
+    return size;
+}

package/src/core/binary/type/DataTypeIndices.js

@@ -0,0 +1,17 @@
+import { BinaryDataType } from "./BinaryDataType.js";
+
+/***
+ *
+ * @enum {number}
+ */
+export const DataTypeIndices = {
+    [BinaryDataType.Uint8]: 0,
+    [BinaryDataType.Uint16]: 1,
+    [BinaryDataType.Uint32]: 2,
+    [BinaryDataType.Int8]: 3,
+    [BinaryDataType.Int16]: 4,
+    [BinaryDataType.Int32]: 5,
+    [BinaryDataType.Float32]: 6,
+    [BinaryDataType.Float64]: 7,
+    [BinaryDataType.Float16]: 8
+};

package/src/core/{collection/table → binary/type}/computeDataTypeByIndex.js

@@ -3,7 +3,7 @@ import { DataTypeIndices } from "./DataTypeIndices.js";
 /**
  *
  * @param {number} index
- * @returns {DataType|undefined}
+ * @returns {BinaryDataType|undefined}
  */
 export function computeDataTypeByIndex(index) {
     for (let type in DataTypeIndices) {

package/src/core/binary/type/dataTypeFromTypedArray.js

@@ -0,0 +1,31 @@
+import { BinaryDataType } from "./BinaryDataType.js";
+
+/**
+ *
+ * @param {TypedArray} arr
+ * @returns {BinaryDataType}
+ */
+export function dataTypeFromTypedArray(arr) {
+    if (arr instanceof Float32Array) {
+        return BinaryDataType.Float32;
+    } else if (arr instanceof Float64Array) {
+        return BinaryDataType.Float64;
+    } else if (arr instanceof Uint8Array) {
+        return BinaryDataType.Uint8;
+    } else if (arr instanceof Uint16Array) {
+        return BinaryDataType.Uint16;
+    } else if (arr instanceof Uint32Array) {
+        return BinaryDataType.Uint32;
+    } else if (arr instanceof Int8Array) {
+        return BinaryDataType.Int8;
+    } else if (arr instanceof Int16Array) {
+        return BinaryDataType.Int16;
+    } else if (arr instanceof Int32Array) {
+        return BinaryDataType.Int32;
+    } else if (arr instanceof Array) {
+        //if array is untyped, use Float64 as numbers in JS are 64 bit
+        return BinaryDataType.Float64;
+    } else {
+        throw new TypeError(`Unknown array type`);
+    }
+}

package/src/core/collection/array/typedArrayToDataType.js

@@ -1,9 +1,9 @@
-import { DataType } from "../table/DataType.js";
+import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
 
 /**
  *
  * @param {*} v
- * @returns {DataType}
+ * @returns {BinaryDataType}
  */
 export function typedArrayToDataType(v) {
     const ctor = Object.getPrototypeOf(v).constructor;
@@ -11,23 +11,23 @@ export function typedArrayToDataType(v) {
     switch (ctor) {
         case Uint8Array:
         case Uint8ClampedArray:
-            return DataType.Uint8;
+            return BinaryDataType.Uint8;
         case Uint16Array:
-            return DataType.Uint16;
+            return BinaryDataType.Uint16;
         case Uint32Array:
-            return DataType.Uint32;
+            return BinaryDataType.Uint32;
 
         case Int8Array:
-            return DataType.Int8;
+            return BinaryDataType.Int8;
         case Int16Array:
-            return DataType.Int16;
+            return BinaryDataType.Int16;
         case Int32Array:
-            return DataType.Int32;
+            return BinaryDataType.Int32;
 
         case Float32Array:
-            return DataType.Float32;
+            return BinaryDataType.Float32;
         case Float64Array:
-            return DataType.Float64;
+            return BinaryDataType.Float64;
         default:
             throw new Error('unsupported constructor type');
     }

package/src/core/collection/table/RowFirstTable.js

@@ -26,7 +26,7 @@ function RowFirstTable(spec) {
 
     /**
      * @readonly
-     * @type {Array.<DataType>}
+     * @type {Array.<BinaryDataType>}
      */
     this.types = spec.types;
 

package/src/core/collection/table/RowFirstTable.spec.js

@@ -1,5 +1,5 @@
 import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
-import { DataType } from "./DataType.js";
+import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
 import { RowFirstTable } from "./RowFirstTable.js";
 import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
 import { serializeRowFirstTable } from "./serializeRowFirstTable.js";
@@ -10,7 +10,7 @@ test("constructor doesn't throw", () => {
 });
 
 test("add row then read back", () => {
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
 
@@ -21,7 +21,7 @@ test("add row then read back", () => {
 });
 
 test("add two rows, then read back", () => {
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
     sut.addRow([1.5, 9]);
@@ -41,7 +41,7 @@ test("add two rows, then read back", () => {
 
 test("serialization deserialization consistency", () => {
 
-    const expected = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const expected = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     expected.addRow([1.4, 8]);
     expected.addRow([1.5, 9]);
@@ -66,7 +66,7 @@ test("serialization deserialization consistency", () => {
 
 test("removeRows 1 in the middle", () => {
 
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
     sut.addRow([1.5, 9]);
@@ -89,7 +89,7 @@ test("removeRows 1 in the middle", () => {
 
 test("removeRows 2 in the middle", () => {
 
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
     sut.addRow([1.5, 9]);
@@ -113,7 +113,7 @@ test("removeRows 2 in the middle", () => {
 
 test("removeRows 1 at the start", () => {
 
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
     sut.addRow([1.5, 9]);
@@ -131,7 +131,7 @@ test("removeRows 1 at the start", () => {
 });
 
 test("removeRows 1 at the end", () => {
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
     sut.addRow([1.5, 9]);
@@ -150,7 +150,7 @@ test("removeRows 1 at the end", () => {
 
 test("writeCellValue", () => {
 
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
     sut.addRow([1.5, 9]);
@@ -175,7 +175,7 @@ test("writeCellValue", () => {
 });
 
 test("readCellValue", () => {
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64, DataType.Uint8]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]));
 
     sut.addRow([1.4, 8]);
     sut.addRow([1.5, 9]);
@@ -189,7 +189,7 @@ test("readCellValue", () => {
 
 
 test('insertRows', () => {
-    const sut = new RowFirstTable(new RowFirstTableSpec([DataType.Float64]));
+    const sut = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Float64]));
 
     // insert into empty table
     sut.insertRows(0, 1);
@@ -216,7 +216,7 @@ test('insertRows', () => {
 
 test('copy', () => {
 
-    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+    const spec = new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]);
 
     const a = new RowFirstTable(spec);
     a.addRow([3.1, 7]);
@@ -231,7 +231,7 @@ test('copy', () => {
 
 test('reverse_rows 3 rows (odd number)', () => {
 
-    const spec = new RowFirstTableSpec([DataType.Uint8]);
+    const spec = new RowFirstTableSpec([BinaryDataType.Uint8]);
 
     const a = new RowFirstTable(spec);
     a.addRow([1]);
@@ -247,7 +247,7 @@ test('reverse_rows 3 rows (odd number)', () => {
 
 test('reverse_rows 2 rows', () => {
 
-    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+    const spec = new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]);
 
     const a = new RowFirstTable(spec);
     a.addRow([3.1, 7]);
@@ -264,7 +264,7 @@ test('reverse_rows 2 rows', () => {
 
 test('reverse_rows 1 row', () => {
 
-    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+    const spec = new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]);
 
     const a = new RowFirstTable(spec);
 
@@ -277,7 +277,7 @@ test('reverse_rows 1 row', () => {
 
 test('reverse_rows empty', () => {
 
-    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+    const spec = new RowFirstTableSpec([BinaryDataType.Float64, BinaryDataType.Uint8]);
 
     const a = new RowFirstTable(spec);
 

package/src/core/collection/table/RowFirstTableSpec.js

@@ -7,8 +7,8 @@ import { Cache } from "../../cache/Cache.js";
 import { FunctionCompiler } from "../../function/FunctionCompiler.js";
 import { computeStringHash } from "../../primitives/strings/computeStringHash.js";
 import { isArrayEqualStrict } from "../array/isArrayEqualStrict.js";
-import { DataType } from "./DataType.js";
-import { DataTypeByteSizes } from "./DataTypeByteSizes.js";
+import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
+import { DataTypeByteSizes } from "../../binary/type/DataTypeByteSizes.js";
 
 /**
  * @readonly
@@ -50,7 +50,7 @@ export const DataType2DataViewWriters = {
 
 /**
  *
- * @param {DataType[]} types
+ * @param {BinaryDataType[]} types
  * @param {EndianType} [endianType]
  * @returns {(data_view:DataView, byte_offset:number, result:number[])=>void}
  */
@@ -84,7 +84,7 @@ function genRowReader(types, endianType = EndianType.BigEndian) {
 
 /**
  *
- * @param {DataType[]} types
+ * @param {BinaryDataType[]} types
  * @param {EndianType} [endianType]
  * @returns {(data_view:DataView, byte_offset:number, record:number[])=>void}
  */
@@ -117,7 +117,7 @@ function genRowWriter(types, endianType = EndianType.BigEndian) {
 
 /**
  *
- * @param {DataType} type
+ * @param {BinaryDataType} type
  * @param {number} offset
  * @param {EndianType} [endianType]
  * @returns {Function}
@@ -135,7 +135,7 @@ function genCellWriter(type, offset, endianType = EndianType.BigEndian) {
 
 /**
  *
- * @param {DataType} type
+ * @param {BinaryDataType} type
  * @param {number} offset
  * @param {EndianType} [endianType]
  * @returns {Function}
@@ -153,7 +153,7 @@ function genCellReader(type, offset, endianType = EndianType.BigEndian) {
 
 /**
  *
- * @param {DataType[]} types
+ * @param {BinaryDataType[]} types
  * @param {EndianType} [endianType]
  * @constructor
  */
@@ -162,7 +162,7 @@ export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
 
     /**
      * @readonly
-     * @type {DataType[]}
+     * @type {BinaryDataType[]}
      */
     this.types = types;
 
@@ -250,7 +250,7 @@ const cache = new Cache({
 
 /**
  *
- * @param {DataType[]} types
+ * @param {BinaryDataType[]} types
  * @param {EndianType} [endianType]
  * @returns {RowFirstTableSpec}
  */

package/src/core/collection/table/deserializeRowFirstTable.js

@@ -1,5 +1,5 @@
 import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
-import { computeDataTypeByIndex } from "./computeDataTypeByIndex.js";
+import { computeDataTypeByIndex } from "../../binary/type/computeDataTypeByIndex.js";
 
 /**
  *

package/src/core/collection/table/serializeRowFirstTable.js

@@ -1,4 +1,4 @@
-import { DataTypeIndices } from "./DataTypeIndices.js";
+import { DataTypeIndices } from "../../binary/type/DataTypeIndices.js";
 
 /**
  *

package/src/core/geom/3d/matrix/MATRIX_4_IDENTITY.js

@@ -2,7 +2,8 @@
  *
  * @type {number[]|mat4}
  */
-export const MATRIX_4_IDENTITY = Object.freeze([1, 0, 0, 0,
+export const MATRIX_4_IDENTITY = Object.freeze([
+    1, 0, 0, 0,
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1

package/src/core/geom/3d/matrix/m4_multiply.js

@@ -0,0 +1,67 @@
+/**
+ * Multiplies two mat4s
+ * Adapter from gl-matrix
+ *
+ * @param {ArrayLike<number>|Float32Array} out the receiving matrix
+ * @param {ArrayLike<number>|Float32Array} a the first operand
+ * @param {ArrayLike<number>|Float32Array} b the second operand
+ */
+export function m4_multiply(out, a, b) {
+    const a00 = a[0],
+        a01 = a[1],
+        a02 = a[2],
+        a03 = a[3],
+        a10 = a[4],
+        a11 = a[5],
+        a12 = a[6],
+        a13 = a[7],
+        a20 = a[8],
+        a21 = a[9],
+        a22 = a[10],
+        a23 = a[11],
+        a30 = a[12],
+        a31 = a[13],
+        a32 = a[14],
+        a33 = a[15];
+
+    // Cache only the current line of the second matrix
+    let b0 = b[0],
+        b1 = b[1],
+        b2 = b[2],
+        b3 = b[3];
+
+    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[4];
+    b1 = b[5];
+    b2 = b[6];
+    b3 = b[7];
+
+    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[8];
+    b1 = b[9];
+    b2 = b[10];
+    b3 = b[11];
+
+    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[12];
+    b1 = b[13];
+    b2 = b[14];
+    b3 = b[15];
+
+    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+}