@woosh/meep-engine 2.111.6 → 2.111.8

package/build/meep.module.js

@@ -25,8 +25,9 @@ function isArrayEqualStrict(a, b) {
 }
 
 /**
- *
- * @param o
+ * Checks whether supplied argument is a TypedArray instance, such as Flaot32Array
+ * @template T
+ * @param {T} o
  * @returns {boolean}
  */
 function isTypedArray(o) {
@@ -48926,6 +48927,40 @@ function compute_typed_array_constructor_from_data_type(dt) {
     return r;
 }
 
+/**
+ *
+ * @param {*} array
+ * @returns {BinaryDataType}
+ */
+function compute_binary_data_type_from_typed_array(array) {
+
+    const ctor = Object.getPrototypeOf(array).constructor;
+
+    switch (ctor) {
+        case Uint8Array:
+        case Uint8ClampedArray:
+            return BinaryDataType.Uint8;
+        case Uint16Array:
+            return BinaryDataType.Uint16;
+        case Uint32Array:
+            return BinaryDataType.Uint32;
+
+        case Int8Array:
+            return BinaryDataType.Int8;
+        case Int16Array:
+            return BinaryDataType.Int16;
+        case Int32Array:
+            return BinaryDataType.Int32;
+
+        case Float32Array:
+            return BinaryDataType.Float32;
+        case Float64Array:
+            return BinaryDataType.Float64;
+        default:
+            throw new Error(`unsupported constructor type ${ctor.name}`);
+    }
+}
+
 //
 
 /**
@@ -49000,39 +49035,6 @@ function is_typed_array_equals(a, b) {
     return isArrayEqualStrict(a_proxy, b_proxy);
 }
 
-/**
- *
- * @param {*} v
- * @returns {BinaryDataType}
- */
-function typedArrayToDataType(v) {
-    const ctor = Object.getPrototypeOf(v).constructor;
-
-    switch (ctor) {
-        case Uint8Array:
-        case Uint8ClampedArray:
-            return BinaryDataType.Uint8;
-        case Uint16Array:
-            return BinaryDataType.Uint16;
-        case Uint32Array:
-            return BinaryDataType.Uint32;
-
-        case Int8Array:
-            return BinaryDataType.Int8;
-        case Int16Array:
-            return BinaryDataType.Int16;
-        case Int32Array:
-            return BinaryDataType.Int32;
-
-        case Float32Array:
-            return BinaryDataType.Float32;
-        case Float64Array:
-            return BinaryDataType.Float64;
-        default:
-            throw new Error('unsupported constructor type');
-    }
-}
-
 /**
  * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
  * @param {number} t ratio
@@ -49999,7 +50001,7 @@ class Sampler2D {
             height: this.height,
             width: this.width,
             itemSize: this.itemSize,
-            type: typedArrayToDataType(this.data),
+            type: compute_binary_data_type_from_typed_array(this.data),
             data: encoded
         }
     }
@@ -59791,19 +59793,19 @@ function array_swap_one(array, index0, index1) {
 
 /**
  *
- * @param {number} count
- * @returns {function}
+ * @param {number} max_value maximum value to be contained in the array
+ * @returns {function} constructor
  */
-function UintArrayForCount(count) {
+function UintArrayForCount(max_value) {
 
-    if (count <= 256) {
+    if (max_value <= 256) {
         return Uint8Array;
-    } else if (count <= 65536) {
+    } else if (max_value <= 65536) {
         return Uint16Array;
-    } else if (count <= 4294967295) {
+    } else if (max_value <= 4294967295) {
         return Uint32Array;
     } else {
-        throw new Error(`Unsupported size ${count}`)
+        throw new Error(`Unsupported size ${max_value}`)
     }
 }
 

package/package.json

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

package/src/core/collection/array/typed/compute_binary_data_type_from_typed_array.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {*} array
+ * @returns {BinaryDataType}
+ */
+export function compute_binary_data_type_from_typed_array(array: any): BinaryDataType;
+import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
+//# sourceMappingURL=compute_binary_data_type_from_typed_array.d.ts.map

package/src/core/collection/array/typed/compute_binary_data_type_from_typed_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_binary_data_type_from_typed_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/compute_binary_data_type_from_typed_array.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,uEAFa,cAAc,CAgC1B;+BArC8B,wCAAwC"}

package/src/core/collection/array/typed/compute_binary_data_type_from_typed_array.js

@@ -0,0 +1,39 @@
+import { assert } from "../../../assert.js";
+import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
+
+/**
+ *
+ * @param {*} array
+ * @returns {BinaryDataType}
+ */
+export function compute_binary_data_type_from_typed_array(array) {
+    assert.notNull(array, 'array');
+    assert.isObject(array, 'array');
+    assert.isArrayLike(array, 'array');
+
+    const ctor = Object.getPrototypeOf(array).constructor;
+
+    switch (ctor) {
+        case Uint8Array:
+        case Uint8ClampedArray:
+            return BinaryDataType.Uint8;
+        case Uint16Array:
+            return BinaryDataType.Uint16;
+        case Uint32Array:
+            return BinaryDataType.Uint32;
+
+        case Int8Array:
+            return BinaryDataType.Int8;
+        case Int16Array:
+            return BinaryDataType.Int16;
+        case Int32Array:
+            return BinaryDataType.Int32;
+
+        case Float32Array:
+            return BinaryDataType.Float32;
+        case Float64Array:
+            return BinaryDataType.Float64;
+        default:
+            throw new Error(`unsupported constructor type ${ctor.name}`);
+    }
+}

package/src/core/collection/array/typed/isTypedArray.d.ts

@@ -1,7 +1,8 @@
 /**
- *
- * @param o
+ * Checks whether supplied argument is a TypedArray instance, such as Flaot32Array
+ * @template T
+ * @param {T} o
  * @returns {boolean}
  */
-export function isTypedArray(o: any): boolean;
+export function isTypedArray<T>(o: T): boolean;
 //# sourceMappingURL=isTypedArray.d.ts.map

package/src/core/collection/array/typed/isTypedArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isTypedArray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/isTypedArray.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,sCAFa,OAAO,CAcnB"}
+{"version":3,"file":"isTypedArray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/isTypedArray.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,uCAFa,OAAO,CAcnB"}

package/src/core/collection/array/typed/isTypedArray.js

@@ -1,9 +1,10 @@
 /**
- *
- * @param o
+ * Checks whether supplied argument is a TypedArray instance, such as Flaot32Array
+ * @template T
+ * @param {T} o
  * @returns {boolean}
  */
-function isTypedArray(o) {
+export function isTypedArray(o) {
     return (
         o instanceof Int8Array ||
         o instanceof Uint8Array ||
@@ -16,5 +17,3 @@ function isTypedArray(o) {
         o instanceof Float64Array
     );
 }
-
-export { isTypedArray };

package/src/core/collection/array/typed/typedArrayToDataType.d.ts

@@ -1,8 +1,6 @@
 /**
- *
- * @param {*} v
- * @returns {BinaryDataType}
+ * @deprecated renamed to {@link compute_binary_data_type_from_typed_array}
  */
-export function typedArrayToDataType(v: any): BinaryDataType;
-import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
+export const typedArrayToDataType: typeof compute_binary_data_type_from_typed_array;
+import { compute_binary_data_type_from_typed_array } from "./compute_binary_data_type_from_typed_array.js";
 //# sourceMappingURL=typedArrayToDataType.d.ts.map

package/src/core/collection/array/typed/typedArrayToDataType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typedArrayToDataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/typedArrayToDataType.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,8CAFa,cAAc,CA4B1B;+BAjC8B,wCAAwC"}
+{"version":3,"file":"typedArrayToDataType.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/typedArrayToDataType.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,oFAA6E;0DALnB,gDAAgD"}

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

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

package/src/core/collection/array/typed/uint_array_for_count.d.ts

@@ -1,7 +1,7 @@
 /**
  *
- * @param {number} count
- * @returns {function}
+ * @param {number} max_value maximum value to be contained in the array
+ * @returns {function} constructor
  */
-export function UintArrayForCount(count: number): Function;
+export function UintArrayForCount(max_value: number): Function;
 //# sourceMappingURL=uint_array_for_count.d.ts.map

package/src/core/collection/array/typed/uint_array_for_count.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uint_array_for_count.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/uint_array_for_count.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,yCAHW,MAAM,YAchB"}
+{"version":3,"file":"uint_array_for_count.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/uint_array_for_count.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,6CAHW,MAAM,YAchB"}

package/src/core/collection/array/typed/uint_array_for_count.js

@@ -1,17 +1,17 @@
 /**
  *
- * @param {number} count
- * @returns {function}
+ * @param {number} max_value maximum value to be contained in the array
+ * @returns {function} constructor
  */
-export function UintArrayForCount(count) {
+export function UintArrayForCount(max_value) {
 
-    if (count <= 256) {
+    if (max_value <= 256) {
         return Uint8Array;
-    } else if (count <= 65536) {
+    } else if (max_value <= 65536) {
         return Uint16Array;
-    } else if (count <= 4294967295) {
+    } else if (max_value <= 4294967295) {
         return Uint32Array;
     } else {
-        throw new Error(`Unsupported size ${count}`)
+        throw new Error(`Unsupported size ${max_value}`)
     }
 }

package/src/core/geom/3d/topology/expandConnectivityByLocality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expandConnectivityByLocality.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/expandConnectivityByLocality.js"],"names":[],"mappings":"AA+DA;;;;GAIG;AACH,gFAkCC"}
+{"version":3,"file":"expandConnectivityByLocality.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/expandConnectivityByLocality.js"],"names":[],"mappings":"AAgEA;;;;GAIG;AACH,gFAkCC"}

package/src/core/geom/3d/topology/expandConnectivityByLocality.js

@@ -1,7 +1,8 @@
 import { array_copy } from "../../../collection/array/array_copy.js";
-import { computeTopoMeshVertexDuplicates } from "./computeTopoMeshVertexDuplicates.js";
 import { arraySetSortingDiff } from "../../../collection/array/arraySetSortingDiff.js";
 import { compareFaces } from "./compareFaces.js";
+import { computeTopoMeshVertexDuplicates } from "./computeTopoMeshVertexDuplicates.js";
+import { query_edge_other_vertex } from "./query/query_edge_other_vertex.js";
 
 /**
  *
@@ -25,7 +26,7 @@ function findCommonDuplicateEdges(result, source_a, source_b) {
         for (j = 0; j < edge_count_a; j++) {
             const topoEdge = edges_a[j];
 
-            const other_vertex_a = topoEdge.getOtherVertex(v_a);
+            const other_vertex_a = query_edge_other_vertex(topoEdge, v_a);
 
             if (source_b.includes(other_vertex_a)) {
                 const existing_result_place = result.indexOf(topoEdge);

package/src/core/geom/3d/topology/isEdgeConnectedToOutline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isEdgeConnectedToOutline.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/isEdgeConnectedToOutline.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,0DAFa,OAAO,CAMnB"}
+{"version":3,"file":"isEdgeConnectedToOutline.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/isEdgeConnectedToOutline.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,0DAFa,OAAO,CAMnB"}

package/src/core/geom/3d/topology/isEdgeConnectedToOutline.js

@@ -1,4 +1,5 @@
 import { isVertexConnectedToOutline } from "./isVertexConnectedToOutline.js";
+import { query_edge_is_boundary } from "./query/query_edge_is_boundary.js";
 
 /**
  * Determines whether the given edge is part of the topology outline (outer edge)
@@ -6,7 +7,7 @@ import { isVertexConnectedToOutline } from "./isVertexConnectedToOutline.js";
  * @returns {boolean}
  */
 export function isEdgeConnectedToOutline(edge) {
-    return edge.isTopologyBorder()
+    return query_edge_is_boundary(edge)
         || isVertexConnectedToOutline(edge.v0)
         || isVertexConnectedToOutline(edge.v1);
 }

package/src/core/geom/3d/topology/isVertexConnectedToOutline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isVertexConnectedToOutline.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/isVertexConnectedToOutline.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,gEAFa,OAAO,CAenB"}
+{"version":3,"file":"isVertexConnectedToOutline.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/isVertexConnectedToOutline.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,gEAFa,OAAO,CAenB"}

package/src/core/geom/3d/topology/isVertexConnectedToOutline.js

@@ -1,3 +1,5 @@
+import { query_edge_is_boundary } from "./query/query_edge_is_boundary.js";
+
 /**
  * Determines whether vertex is part of the topology outline (outer edge)
  * @param {TopoVertex} vertex
@@ -10,7 +12,7 @@ export function isVertexConnectedToOutline(vertex) {
     for (let i = 0; i < n; i++) {
         const edge = edges[i];
 
-        if (edge.isTopologyBorder()) {
+        if (query_edge_is_boundary(edge)) {
             return true;
         }
     }

package/src/core/geom/3d/topology/query/query_edge_other_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_edge_other_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/query/query_edge_other_vertex.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wEAFa,aAAW,IAAI,CAa3B"}
+{"version":3,"file":"query_edge_other_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/query/query_edge_other_vertex.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wEAFa,aAAW,IAAI,CAgB3B"}

package/src/core/geom/3d/topology/query/query_edge_other_vertex.js

@@ -10,6 +10,9 @@ export function query_edge_other_vertex(edge, v) {
     assert.notNull(edge, 'edge');
     assert.notNull(v, 'v');
 
+    assert.equal(edge.isTopoEdge,true,'edge.isTopoEdge !== true');
+    assert.equal(v.isTopoVertex,true,'v.isTopoVertex !== true');
+
     if (edge.v0 === v) {
         return edge.v1;
     } else if (edge.v1 === v) {

package/src/core/geom/3d/topology/util/mesh_flood_fill.d.ts

@@ -1,9 +1,8 @@
 /**
  *
- * @param {TopoMesh} mesh
  * @param {TopoTriangle[]} initial_set indices of triangles that make up initial set, these are triangles that we start from, they will also be included in the resulting set
  * @param {function(tri:TopoTriangle, prev:TopoTriangle):boolean} filter decides whether a triangle should be included or not
  * @returns {TopoTriangle[]} set of selected triangles, will include initial set as well
  */
-export function mesh_flood_fill({ mesh, initial_set, filter }: TopoMesh): TopoTriangle[];
+export function mesh_flood_fill({ initial_set, filter }: TopoTriangle[]): TopoTriangle[];
 //# sourceMappingURL=mesh_flood_fill.d.ts.map

package/src/core/geom/3d/topology/util/mesh_flood_fill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh_flood_fill.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/util/mesh_flood_fill.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,0EAFa,cAAc,CA+C1B"}
+{"version":3,"file":"mesh_flood_fill.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/util/mesh_flood_fill.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,yDAJW,cAAc,GAEZ,cAAc,CA8C1B"}

package/src/core/geom/3d/topology/util/mesh_flood_fill.js

@@ -8,13 +8,11 @@ const neighbours = [];
 
 /**
  *
- * @param {TopoMesh} mesh
  * @param {TopoTriangle[]} initial_set indices of triangles that make up initial set, these are triangles that we start from, they will also be included in the resulting set
  * @param {function(tri:TopoTriangle, prev:TopoTriangle):boolean} filter decides whether a triangle should be included or not
  * @returns {TopoTriangle[]} set of selected triangles, will include initial set as well
  */
 export function mesh_flood_fill({
-                                    mesh,
                                     initial_set,
                                     filter
                                 }) {

package/src/engine/ecs/terrain/tiles/TileBuildWorker.js

@@ -1,10 +1,10 @@
 import { BinaryUint32BVH } from "../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
 import { bvh32_from_indexed_geometry } from "../../../graphics/geometry/bvh/buffered/bvh32_from_indexed_geometry.js";
+import { geometry_optimize_uv_tension } from "../../../graphics/geometry/optimization/geometry_optimize_uv_tension.js";
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
 import { sampler2d_channel_compute_max } from "../../../graphics/texture/sampler/sampler2d_channel_compute_max.js";
 import { sampler2d_channel_compute_min } from "../../../graphics/texture/sampler/sampler2d_channel_compute_min.js";
 import BufferedGeometryArraysBuilder from '../BufferedGeometryArraysBuilder.js';
-import { tensionOptimizeUV } from "../util/tensionOptimizeUV.js";
 
 self.Lib = {
     /**
@@ -21,7 +21,7 @@ self.Lib = {
     },
     Sampler2D,
     BufferedGeometryArraysBuilder,
-    tensionOptimizeUV,
+    tensionOptimizeUV: geometry_optimize_uv_tension,
     sampler2d_channel_compute_min,
     sampler2d_channel_compute_max
 };

package/src/engine/graphics/geometry/AttributeSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AttributeSpec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/AttributeSpec.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;IA+BI,uCAMC;IA0DD;;;;;OAKG;IACH,iBAJW,aAAa,KACb,aAAa,GACZ,MAAM,CAIjB;IArGG;;;OAGG;IACH,MAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,MAFU,cAAc,CAEU;IAElC;;;;;OAKG;IACH,UAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,YAFU,OAAO,CAEM;IAW3B;;;;;aAoBC;IAED;;;;;MAOC;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAQnB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAaL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;+BAjH8B,6CAA6C"}
+{"version":3,"file":"AttributeSpec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/AttributeSpec.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;IA+BI,uCAMC;IA6ED;;;;;OAKG;IACH,iBAJW,aAAa,KACb,aAAa,GACZ,MAAM,CAIjB;IAxHD;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,cAAc,CAEM;IAE9B;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,YAFU,OAAO,CAEE;IAWnB;;;;;aAoBC;IAED;;;;;MAOC;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CAQnB;IAED;;;OAGG;IACH,YAFW,aAAa,QAOvB;IAED,uBAMC;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAaL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;+BAnI8B,6CAA6C"}

package/src/engine/graphics/geometry/AttributeSpec.js

@@ -1,42 +1,42 @@
+import { assert } from "../../../core/assert.js";
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 import { DataTypeByteSizes } from "../../../core/binary/type/DataTypeByteSizes.js";
-import { assert } from "../../../core/assert.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 
 /**
  * Describes data structure of a single data attribute, such as a scalar, or a vector
  * This structure is designed to map well to GPU shader formats and is intended for larger datasets, such as meshes or particle clouds
  */
 export class AttributeSpec {
-    constructor() {
-        /**
-         * Typically unique within a given set, used to identify the attribute
-         * @type {string}
-         */
-        this.name = "";
-
-        /**
-         * How the attribute is stored in memory and interpreted
-         * @type {BinaryDataType}
-         */
-        this.type = BinaryDataType.Float32;
-
-        /**
-         * How many elements the attribute uses. This is cardinality of a vector.
-         * 1 means the attribute is a scalar
-         * must be greater or equal to 1
-         * @type {number}
-         */
-        this.itemSize = 1;
-
-        /**
-         * Normalized values will be automatically converted to float32 in the shader
-         * This gives good optimization opportunities for things like normal vectors
-         * Applies to integer types only
-         * @type {boolean}
-         */
-        this.normalized = false;
-    }
+
+    /**
+     * Typically unique within a given set, used to identify the attribute
+     * @type {string}
+     */
+    name = "";
+
+    /**
+     * How the attribute is stored in memory and interpreted
+     * @type {BinaryDataType}
+     */
+    type = BinaryDataType.Float32;
+
+    /**
+     * How many elements the attribute uses. This is cardinality of a vector.
+     * 1 means the attribute is a scalar
+     * must be greater or equal to 1
+     * @type {number}
+     */
+    itemSize = 1;
+
+    /**
+     * Normalized values will be automatically converted to float32 in the shader
+     * This gives good optimization opportunities for things like normal vectors
+     * Applies to integer types only
+     * @type {boolean}
+     */
+    normalized = false;
+
 
     static fromJSON(j) {
         const r = new AttributeSpec();
@@ -96,14 +96,33 @@ export class AttributeSpec {
 
     /**
      *
-     * @returns {number}
+     * @param {AttributeSpec} other
+     */
+    copy(other) {
+        this.type = other.type;
+        this.name = other.name;
+        this.itemSize = other.itemSize;
+        this.normalized = other.normalized;
+    }
+
+    clone() {
+        const r = new AttributeSpec();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     * How much space a single attribute value takes up
+     * @returns {number} in bytes
      */
     getByteSize() {
         return this.itemSize * DataTypeByteSizes[this.type];
     }
 
     /**
-     *
+     * Sorting comparator
      * @param {AttributeSpec} a
      * @param {AttributeSpec} b
      * @return {number}

package/src/engine/graphics/geometry/VertexDataSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VertexDataSpec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/VertexDataSpec.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IAeI;;;;OAIG;IACH,2BAHW,aAAa,GACX,cAAc,CAQ1B;IAxBD;;;OAGG;IACH,YAFU,aAAa,EAAE,CAET;IAsBhB;;;;OAIG;IACH,yBAHW,MAAM,GACL,aAAa,GAAC,SAAS,CAgBlC;IAED;;;OAGG;IACH,8BAFW,MAAM,GADJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,oBAFW,aAAa,EAAE,QAOzB;IAED;;;;OAIG;IACH,eAHW,aAAa,GACZ,cAAc,CAkBzB;IAED;;;OAGG;IACH,0BAFW,aAAa,EAAE,QAQzB;IAED,cAMC;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAQnB;IAED,sBAEC;IAED,eAMC;IAED;;MAIC;IAED;;aAkBC;IAED;;;OAGG;IACH,eAFa,MAAM,CAelB;IAIL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;;CAPxC;8BA5M6B,oBAAoB"}
+{"version":3,"file":"VertexDataSpec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/geometry/VertexDataSpec.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IAeI;;;;OAIG;IACH,2BAHW,aAAa,GACX,cAAc,CAQ1B;IAxBD;;;OAGG;IACH,YAFU,aAAa,EAAE,CAET;IAsBhB;;;;OAIG;IACH,yBAHW,MAAM,GACL,aAAa,GAAC,SAAS,CAgBlC;IAED;;;OAGG;IACH,8BAFW,MAAM,GADJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,oBAFW,aAAa,EAAE,QAOzB;IAED;;;;OAIG;IACH,eAHW,aAAa,GACZ,cAAc,CAkBzB;IAED;;;OAGG;IACH,0BAFW,aAAa,EAAE,QAQzB;IAED,cAMC;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAQnB;IAED,sBASC;IAED,eAMC;IAED;;MAIC;IAED;;aAkBC;IAED;;;OAGG;IACH,eAFa,MAAM,CAelB;IAIL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;;CAPxC;8BAnN6B,oBAAoB"}

package/src/engine/graphics/geometry/VertexDataSpec.js

@@ -8,7 +8,7 @@ import { AttributeSpec } from "./AttributeSpec.js";
  * @readonly
  * @type {number}
  */
-const DEFAULT_HASH = 1234567;
+const RESERVED_HASH = 1234567;
 
 /**
  * Describes a set of data attributes. A good analogy would be "all data associated with geometry vertex"
@@ -27,7 +27,7 @@ export class VertexDataSpec {
      * @type {number}
      * @private
      */
-    #hash = DEFAULT_HASH;
+    #hash = RESERVED_HASH;
 
     /**
      *
@@ -111,7 +111,7 @@ export class VertexDataSpec {
         this.attributes.push(attribute);
 
         // reset hash
-        this.#hash = DEFAULT_HASH;
+        this.#hash = RESERVED_HASH;
 
         //for chaining, return self
         return this;
@@ -134,7 +134,7 @@ export class VertexDataSpec {
         this.attributes.splice(0, count);
 
         // reset hash to trigger hash update
-        this.#hash = DEFAULT_HASH;
+        this.#hash = RESERVED_HASH;
     }
 
     /**
@@ -151,11 +151,18 @@ export class VertexDataSpec {
     }
 
     computeHash() {
-        return computeHashArray(this.attributes, invokeObjectHash);
+        const hash_value = computeHashArray(this.attributes, invokeObjectHash);
+
+        if (hash_value === RESERVED_HASH) {
+            // collision with reserved hash, replace
+            return 0;
+        }
+
+        return hash_value;
     }
 
     hash() {
-        if (this.#hash === DEFAULT_HASH) {
+        if (this.#hash === RESERVED_HASH) {
             this.#hash = this.computeHash();
         }