@woosh/meep-engine 2.33.8 → 2.33.12

package/core/binary/BinaryBuffer.js

@@ -342,7 +342,7 @@ BinaryBuffer.prototype.readInt32Array = function (destination, destination_offse
  *
  * @param {number} destination_offset starting index in the destination array
  * @param {number} length number of elements to read
- * @param {Float32Array} destination
+ * @param {Float32Array|number[]} destination
  */
 BinaryBuffer.prototype.readFloat32Array = function (destination, destination_offset, length) {
     for (let i = 0; i < length; i++) {
@@ -366,7 +366,7 @@ BinaryBuffer.prototype.readFloat64Array = function (destination, destination_off
  *
  * @param {number} source_offset starting index in the source array
  * @param {number} length number of elements to read
- * @param {Float32Array} source
+ * @param {Float32Array|number[]} source
  */
 BinaryBuffer.prototype.writeFloat32Array = function (source, source_offset, length) {
     for (let i = 0; i < length; i++) {
@@ -452,6 +452,18 @@ BinaryBuffer.prototype.writeUint8 = function (value) {
     this.position = end;
 };
 
+/**
+ *
+ * @param {Uint8Array|number[]} source
+ * @param {number} source_offset
+ * @param {number} length
+ */
+BinaryBuffer.prototype.writeUint8Array = function (source, source_offset, length) {
+    for (let i = 0; i < length; i++) {
+        this.writeUint8(source[source_offset + i]);
+    }
+}
+
 /**
  *
  * @param {number} value
@@ -491,6 +503,18 @@ BinaryBuffer.prototype.writeUint16LE = function (value) {
     this.position = end;
 };
 
+/**
+ *
+ * @param {Uint16Array|number[]} source
+ * @param {number} source_offset
+ * @param {number} length
+ */
+BinaryBuffer.prototype.writeUint16Array = function (source, source_offset, length) {
+    for (let i = 0; i < length; i++) {
+        this.writeUint16(source[source_offset + i]);
+    }
+}
+
 /**
  *
  * @param {number} value

package/core/collection/table/DataType2TypedArrayConstructorMapping.js

@@ -12,6 +12,8 @@ export const DataType2TypedArrayConstructorMapping = {
     [DataType.Int8]: Int8Array,
     [DataType.Int16]: Int16Array,
     [DataType.Int32]: Int32Array,
+    // No float16 array type, using uint16 as a backing instead
+    [DataType.Float16]: Uint16Array,
     [DataType.Float32]: Float32Array,
     [DataType.Float64]: Float64Array,
 }

package/core/collection/table/DataTypeByteSizes.js

@@ -0,0 +1,21 @@
+import { DataType } from "./DataType.js";
+
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const DataTypeByteSizes = {
+    [DataType.Uint8]: 1,
+    [DataType.Uint16]: 2,
+    [DataType.Uint32]: 4,
+    [DataType.Uint64]: 8,
+
+    [DataType.Int8]: 1,
+    [DataType.Int16]: 2,
+    [DataType.Int32]: 4,
+    [DataType.Int64]: 8,
+
+    [DataType.Float16]: 2,
+    [DataType.Float32]: 4,
+    [DataType.Float64]: 8
+};

package/core/collection/table/RowFirstTable.js

@@ -6,7 +6,6 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
-import { DataTypeIndices } from "./DataTypeIndices.js";
 import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
 
 
@@ -439,92 +438,6 @@ RowFirstTable.prototype.printToConsole = function () {
     console.table(rows);
 };
 
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {RowFirstTable} table
- */
-function serializeRowFirstTable(buffer, table) {
-    //write types
-    buffer.writeUint16(table.types.length);
-    table.types.forEach(function (type) {
-        const typeIndex = DataTypeIndices[type];
-        buffer.writeUint8(typeIndex);
-    });
-
-    //write record length
-    buffer.writeUint32(table.bytesPerRecord);
-
-    //write number of records
-    buffer.writeUint32(table.length);
-
-    //write data
-    const numDataBytes = table.length * table.bytesPerRecord;
-    buffer.writeBytes(new Uint8Array(table.data), 0, numDataBytes);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {RowFirstTable} table
- */
-function deserializeRowFirstTable(buffer, table) {
-    /**
-     *
-     * @param {number} index
-     * @returns {DataType|null}
-     */
-    function typeByIndex(index) {
-        for (let type in DataTypeIndices) {
-            if (!DataTypeIndices.hasOwnProperty(type)) {
-                continue;
-            }
-
-            const typeIndex = DataTypeIndices[type];
-            if (typeIndex === index) {
-                return type;
-            }
-        }
-
-        return null;
-    }
-
-    //read types
-    const numTypes = buffer.readUint16();
-    const types = [];
-    for (let i = 0; i < numTypes; i++) {
-        const typeIndex = buffer.readUint8();
-        const type = typeByIndex(typeIndex);
-        if (type === null) {
-            throw new Error(`Unknown DataType index ${typeIndex}`);
-        }
-        types[i] = type;
-    }
-
-    //record size
-    const bytesPerRecord = buffer.readUint32();
-
-    //read number of records
-    const numRecords = buffer.readUint32();
-
-    const numDataBytes = bytesPerRecord * numRecords;
-    const data = new Uint8Array(numDataBytes);
-
-    //read data
-    buffer.readBytes(data, 0, numDataBytes);
-
-    //update table
-    table.spec = RowFirstTableSpec.get(types);
-    table.length = numRecords;
-    table.capacity = numRecords;
-    table.data = data.buffer;
-    table.dataView = new DataView(table.data);
-
-    table.initialize();
-}
-
 export {
-    RowFirstTable,
-    serializeRowFirstTable,
-    deserializeRowFirstTable
+    RowFirstTable
 };

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

@@ -1,7 +1,9 @@
 import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
 import { DataType } from "./DataType.js";
-import { deserializeRowFirstTable, RowFirstTable, serializeRowFirstTable } from "./RowFirstTable.js";
+import { RowFirstTable } from "./RowFirstTable.js";
 import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
+import { serializeRowFirstTable } from "./serializeRowFirstTable.js";
+import { deserializeRowFirstTable } from "./deserializeRowFirstTable.js";
 
 test("constructor doesn't throw", () => {
     new RowFirstTable(new RowFirstTableSpec([]));

package/core/collection/table/RowFirstTableSpec.js

@@ -8,6 +8,7 @@ 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";
 
 /**
  * @readonly
@@ -47,25 +48,6 @@ export const DataType2DataViewWriters = {
     "float64": "setFloat64"
 };
 
-/**
- * @readonly
- * @enum {number}
- */
-export const DataTypeByteSizes = {
-    [DataType.Uint8]: 1,
-    [DataType.Uint16]: 2,
-    [DataType.Uint32]: 4,
-    [DataType.Uint64]: 8,
-
-    [DataType.Int8]: 1,
-    [DataType.Int16]: 2,
-    [DataType.Int32]: 4,
-    [DataType.Int64]: 8,
-
-    [DataType.Float32]: 4,
-    [DataType.Float64]: 8
-};
-
 /**
  *
  * @param {DataType[]} types

package/core/collection/table/computeDataTypeByIndex.js

@@ -0,0 +1,21 @@
+import { DataTypeIndices } from "./DataTypeIndices.js";
+
+/**
+ *
+ * @param {number} index
+ * @returns {DataType|undefined}
+ */
+export function computeDataTypeByIndex(index) {
+    for (let type in DataTypeIndices) {
+        if (!DataTypeIndices.hasOwnProperty(type)) {
+            continue;
+        }
+
+        const typeIndex = DataTypeIndices[type];
+        if (typeIndex === index) {
+            return type;
+        }
+    }
+
+    return undefined;
+}

package/core/collection/table/deserializeRowFirstTable.js

@@ -0,0 +1,48 @@
+import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
+import { computeDataTypeByIndex } from "./computeDataTypeByIndex.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {RowFirstTable} table
+ */
+function deserializeRowFirstTable(buffer, table) {
+
+
+    //read types
+    const numTypes = buffer.readUint16();
+    const types = [];
+    for (let i = 0; i < numTypes; i++) {
+        const typeIndex = buffer.readUint8();
+
+        const type = computeDataTypeByIndex(typeIndex);
+
+        if (type === undefined) {
+            throw new Error(`Unknown DataType index ${typeIndex}`);
+        }
+        types[i] = type;
+    }
+
+    //record size
+    const bytesPerRecord = buffer.readUint32();
+
+    //read number of records
+    const numRecords = buffer.readUint32();
+
+    const numDataBytes = bytesPerRecord * numRecords;
+    const data = new Uint8Array(numDataBytes);
+
+    //read data
+    buffer.readBytes(data, 0, numDataBytes);
+
+    //update table
+    table.spec = RowFirstTableSpec.get(types);
+    table.length = numRecords;
+    table.capacity = numRecords;
+    table.data = data.buffer;
+    table.dataView = new DataView(table.data);
+
+    table.initialize();
+}
+
+export { deserializeRowFirstTable };

package/core/collection/table/serializeRowFirstTable.js

@@ -0,0 +1,27 @@
+import { DataTypeIndices } from "./DataTypeIndices.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {RowFirstTable} table
+ */
+function serializeRowFirstTable(buffer, table) {
+    //write types
+    buffer.writeUint16(table.types.length);
+    table.types.forEach(function (type) {
+        const typeIndex = DataTypeIndices[type];
+        buffer.writeUint8(typeIndex);
+    });
+
+    //write record length
+    buffer.writeUint32(table.bytesPerRecord);
+
+    //write number of records
+    buffer.writeUint32(table.length);
+
+    //write data
+    const numDataBytes = table.length * table.bytesPerRecord;
+    buffer.writeBytes(new Uint8Array(table.data), 0, numDataBytes);
+}
+
+export { serializeRowFirstTable };

package/core/process/worker/WorkerBuilder.js

@@ -52,17 +52,34 @@ WorkerBuilder.prototype.importScript = function (path) {
     this.imports.push(path);
 };
 
+/**
+ *
+ * @param {string} code
+ * @return {string}
+ */
 function codeToURL(code) {
+    const js_mime = 'application/javascript';
+
     let blob;
-    try {
-        blob = new Blob([code], { type: 'application/javascript' });
-    } catch (e) { // Backwards-compatibility
-        window.BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder;
-        blob = new BlobBuilder();
-        blob.append(code);
-        blob = blob.getBlob();
+
+    if (Blob !== undefined) {
+        blob = new Blob([code], { type: js_mime });
+    } else if (window !== undefined) {
+        // Backwards-compatibility
+        const BlobBuilder = window.BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder;
+        if (BlobBuilder !== undefined) {
+            blob = new BlobBuilder();
+            blob.append(code);
+            blob = blob.getBlob();
+        }
+    }
+
+    if (blob !== undefined && URL.createObjectURL !== undefined) {
+        return URL.createObjectURL(blob);
+    } else {
+        // build data URL in a slowest way possible
+        return `data:${js_mime},${encodeURIComponent(code)}`;
     }
-    return URL.createObjectURL(blob);
 }
 
 /**

package/engine/ecs/foliage/InstancedFoliage.js

@@ -1,9 +1,5 @@
 import { BinaryNode } from "../../../core/bvh2/BinaryNode.js";
-import {
-    deserializeRowFirstTable,
-    RowFirstTable,
-    serializeRowFirstTable
-} from "../../../core/collection/table/RowFirstTable.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
 import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { LeafNode } from "../../../core/bvh2/LeafNode.js";
@@ -19,6 +15,8 @@ import { traverseBinaryNodeUsingVisitor } from "../../../core/bvh2/traversal/tra
 import { serializeBinaryNodeToBinaryBuffer } from "../../../core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js";
 import { deserializeBinaryNodeFromBinaryBuffer } from "../../../core/bvh2/serialization/deserializeBinaryNodeFromBinaryBuffer.js";
 import { computeGeometryBoundingSphereMiniball } from "../../graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js";
+import { serializeRowFirstTable } from "../../../core/collection/table/serializeRowFirstTable.js";
+import { deserializeRowFirstTable } from "../../../core/collection/table/deserializeRowFirstTable.js";
 
 /**
  * @readonly

package/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.js

@@ -1,6 +1,7 @@
 import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
-import { deserializeRowFirstTable, serializeRowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
 import { FogOfWar } from "../FogOfWar.js";
+import { serializeRowFirstTable } from "../../../../core/collection/table/serializeRowFirstTable.js";
+import { deserializeRowFirstTable } from "../../../../core/collection/table/deserializeRowFirstTable.js";
 
 export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapter {
     constructor() {

package/engine/graphics/micron/format/MicronGeometry.js

@@ -55,6 +55,18 @@ export class MicronGeometry {
         this.__proxy = null;
     }
 
+    get patches() {
+        return this.__patches;
+    }
+
+    /**
+     *
+     * @param {MicronGeometryPatch[]} v
+     */
+    set patches(v) {
+        this.__patches = v;
+    }
+
     /**
      * @param {THREE.BufferGeometry} geometry
      */

package/engine/graphics/micron/format/MicronGeometryBufferAttributeSpec.js

@@ -1,6 +1,6 @@
 import { DataType } from "../../../../core/collection/table/DataType.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { DataTypeByteSizes } from "../../../../core/collection/table/DataTypeByteSizes.js";
 
 export class MicronGeometryBufferAttributeSpec {
     constructor() {

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -26,6 +26,12 @@ export class MicronGeometryPatch {
          */
         this.bounding_box = new Float32Array(array_buffer, 0, 6);
 
+        /**
+         *
+         * @type {vec4|number[]}
+         */
+        this.bounding_sphere = vec4.create()
+
         /**
          *
          * @type {number[]|Float32Array}
@@ -50,12 +56,6 @@ export class MicronGeometryPatch {
          */
         this.group_error = 0;
 
-        /**
-         *
-         * @type {vec4}
-         */
-        this.bounding_sphere = vec4.create()
-
         /**
          *
          * @type {MicronGeometryPatch[]}

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.js

@@ -0,0 +1,101 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { MicronGeometry } from "../MicronGeometry.js";
+import { MicronGeometryBufferAttributeSpec } from "../MicronGeometryBufferAttributeSpec.js";
+import { MicronGeometryPatch } from "../MicronGeometryPatch.js";
+import { serialize_patch } from "./serialize_patch.js";
+import { deserialize_patch } from "./deserialize_patch.js";
+import { serialize_attribute_spec } from "./serialize_attribute_spec.js";
+import { deserialize_attribute_spec } from "./deserialize_attribute_spec.js";
+
+export class MicronGeometryBinarySerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = MicronGeometry;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {MicronGeometry} value
+     */
+    serialize(buffer, value) {
+        const spec = value.vertex_spec;
+
+        // serialize vertex spec
+        const attributes = spec.attributes;
+        const attribute_count = attributes.length;
+        buffer.writeUintVar(attribute_count);
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute = attributes[i];
+
+            serialize_attribute_spec(buffer, attribute);
+        }
+
+        // serialize patches
+
+        /**
+         *
+         * @type {MicronGeometryPatch[]}
+         */
+        const patches = value.patches;
+        const patch_count = patches.length;
+
+        const root_patch_index = patches.indexOf(value.root);
+
+        buffer.writeUintVar(root_patch_index);
+
+        buffer.writeUintVar(patch_count);
+
+        for (let i = 0; i < patch_count; i++) {
+            serialize_patch(buffer, patches[i], spec, patches);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {MicronGeometry} value
+     */
+    deserialize(buffer, value) {
+        // read spec
+        const attribute_count = buffer.readUintVar();
+        const attributes = [];
+        for (let i = 0; i < attribute_count; i++) {
+            const spec = new MicronGeometryBufferAttributeSpec();
+
+            deserialize_attribute_spec(buffer, spec);
+            attributes[i] = spec;
+        }
+
+        const vertex_spec = value.vertex_spec;
+        vertex_spec.setAttributes(attributes);
+
+        // read patches
+        const root_patch_index = buffer.readUintVar();
+
+        const patch_count = buffer.readUintVar();
+
+        const patches = [];
+
+        // build initial patches
+        for (let i = 0; i < patch_count; i++) {
+            const patch = new MicronGeometryPatch();
+
+            patch.id = i;
+
+            patches[i] = patch;
+        }
+
+        //read patches
+        for (let i = 0; i < patch_count; i++) {
+            const patch = patches[i];
+
+            deserialize_patch(buffer, patch, vertex_spec, patches);
+        }
+
+        value.patches = patches;
+        value.root = patches[root_patch_index];
+    }
+}

package/engine/graphics/micron/format/serialization/deserialize_attribute_spec.js

@@ -0,0 +1,25 @@
+import { computeDataTypeByIndex } from "../../../../../core/collection/table/computeDataTypeByIndex.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryBufferAttributeSpec} spec
+ */
+export function deserialize_attribute_spec(buffer, spec) {
+
+    spec.name = buffer.readUTF8String();
+    spec.itemSize = buffer.readUintVar();
+
+    const type_index = buffer.readUint8();
+    const type = computeDataTypeByIndex(type_index);
+
+    if (type === undefined) {
+        throw new Error(`Unknown data type marker '${type_index}'`);
+    }
+
+    spec.type = type;
+
+    const flags = buffer.readUint8();
+
+    spec.normalized = (flags & 0x1) !== 0;
+}

package/engine/graphics/micron/format/serialization/deserialize_patch.js

@@ -0,0 +1,104 @@
+import { aabb3_build_corners } from "../../../../../core/geom/3d/aabb/aabb3_build_corners.js";
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
+import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryPatch} patch
+ * @param {MicronVertexDataSpec} vertex_spec
+ * @param {MicronGeometryPatch[]} patch_array
+ */
+export function deserialize_patch(buffer, patch, vertex_spec, patch_array) {
+    // METADATA
+    buffer.readFloat32Array(patch.bounding_box, 0, 6);
+    buffer.readFloat32Array(patch.bounding_sphere, 0, 4);
+
+    const gbb = patch.group_bounding_box;
+    buffer.readFloat32Array(gbb, 0, 6);
+    buffer.readFloat32Array(patch.group_bounding_sphere, 0, 4);
+
+    // reconstruct corners
+    aabb3_build_corners(
+        patch.group_bounding_box_corners,
+        0,
+        gbb[0],
+        gbb[1],
+        gbb[2],
+        gbb[3],
+        gbb[4],
+        gbb[5]
+    );
+
+    patch.group_error = buffer.readFloat32();
+    patch.lod = buffer.readUintVar();
+    patch.polygon_count = buffer.readUintVar();
+    patch.vertex_count = buffer.readUintVar();
+
+    // parents
+    const parents = [];
+    const parent_count = buffer.readUintVar();
+
+    for (let i = 0; i < parent_count; i++) {
+        const parent_index = buffer.readUintVar();
+
+        if (patch_array.length <= parent_index || parent_index < 0) {
+            throw new Error(`out of bounds parent index '${parent_index}'`);
+        }
+
+        parents[i] = patch_array[parent_index];
+    }
+
+    patch.parents = parents;
+
+    // children
+    const children = [];
+    const child_count = buffer.readUintVar();
+
+    for (let i = 0; i < child_count; i++) {
+        const child_index = buffer.readUintVar();
+
+        if (patch_array.length <= child_index || child_index < 0) {
+            throw new Error(`out of bounds child index '${child_index}'`);
+        }
+
+        children[i] = patch_array[child_index];
+    }
+
+    patch.children = children;
+
+    // INDICES
+    const index_count = patch.polygon_count * 3;
+
+    if (patch.vertex_count <= 256) {
+        patch.face_indices = new Uint8Array(index_count);
+        buffer.readUint8Array(patch.face_indices, 0, index_count);
+    } else if (patch.vertex_count <= 65536) {
+        patch.face_indices = new Uint16Array(index_count);
+        buffer.readUint16Array(patch.face_indices, 0, index_count);
+    } else {
+        throw new Error(`Unsupported vertex count '${patch.vertex_count}'`);
+    }
+
+    // VERTICES
+    const attributes = vertex_spec.attributes;
+    const attribute_count = attributes.length;
+
+    for (let i = 0; i < attribute_count; i++) {
+        const spec = attributes[i];
+
+        const data_type = spec.type;
+        const item_size = spec.itemSize;
+
+        const byte_size = DataTypeByteSizes[data_type];
+
+        const ArrayConstructor = DataType2TypedArrayConstructorMapping[data_type];
+
+        const elment_count = item_size * patch.vertex_count;
+        const array = new ArrayConstructor(elment_count);
+
+        buffer.readUint8Array(new Uint8Array(array.buffer), 0, byte_size * elment_count);
+
+        patch.vertex_attribute_arrays[i] = array;
+    }
+}

package/engine/graphics/micron/format/serialization/serialize_attribute_spec.js

@@ -0,0 +1,18 @@
+import { DataTypeIndices } from "../../../../../core/collection/table/DataTypeIndices.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryBufferAttributeSpec} spec
+ */
+export function serialize_attribute_spec(buffer, spec) {
+    buffer.writeUTF8String(spec.name);
+    buffer.writeUintVar(spec.itemSize);
+
+    const dataTypeIndex = DataTypeIndices[spec.type];
+    buffer.writeUint8(dataTypeIndex);
+
+    const flags = spec.normalized ? 1 : 0;
+
+    buffer.writeUint8(flags);// flags
+}

package/engine/graphics/micron/format/serialization/serialize_patch.js

@@ -0,0 +1,84 @@
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryPatch} patch
+ * @param {MicronVertexDataSpec} vertex_spec
+ * @param {MicronGeometryPatch[]} patch_array
+ */
+export function serialize_patch(buffer, patch, vertex_spec, patch_array) {
+    // METADATA
+    buffer.writeFloat32Array(patch.bounding_box, 0, 6);
+    buffer.writeFloat32Array(patch.bounding_sphere, 0, 4);
+
+    buffer.writeFloat32Array(patch.group_bounding_box, 0, 6);
+    buffer.writeFloat32Array(patch.group_bounding_sphere, 0, 4);
+
+    buffer.writeFloat32(patch.group_error);
+    buffer.writeUintVar(patch.lod);
+    buffer.writeUintVar(patch.polygon_count);
+    buffer.writeUintVar(patch.vertex_count);
+
+    // write parents
+    const parents = patch.parents;
+    const parent_count = parents.length;
+
+    buffer.writeUintVar(parent_count);
+
+    for (let i = 0; i < parent_count; i++) {
+        const parent = parents[i];
+
+        const parent_index = patch_array.indexOf(parent);
+
+        if (parent_index === -1) {
+            throw new Error(`Patch '${parent.id}' not found in the lookup table`);
+        }
+
+        buffer.writeUintVar(parent_index);
+    }
+
+    // write children
+    const children = patch.children;
+    const child_count = children.length;
+
+    buffer.writeUintVar(child_count);
+
+    for (let i = 0; i < child_count; i++) {
+        const child = children[i];
+
+        const child_index = patch_array.indexOf(child);
+
+        if (child_index === -1) {
+            throw new Error(`Patch '${child.id}' not found in the lookup table`);
+        }
+
+        buffer.writeUintVar(child_index);
+    }
+
+    // INDICES
+    if (patch.vertex_count <= 256) {
+        buffer.writeUint8Array(patch.face_indices, 0, patch.polygon_count * 3);
+    } else if (patch.vertex_count <= 65536) {
+        buffer.writeUint16Array(patch.face_indices, 0, patch.polygon_count * 3);
+    } else {
+        throw new Error(`Unsupported vertex count '${patch.vertex_count}'`);
+    }
+
+    // VERTICES
+    const attributes = vertex_spec.attributes;
+    const attribute_count = attributes.length;
+
+    for (let i = 0; i < attribute_count; i++) {
+        const spec = attributes[i];
+
+        const data_type = spec.type;
+        const item_size = spec.itemSize;
+
+        const byte_size = DataTypeByteSizes[data_type];
+
+        const attribute_values = patch.vertex_attribute_arrays[i];
+
+        buffer.writeUint8Array(new Uint8Array(attribute_values.buffer), 0, item_size * byte_size * patch.vertex_count);
+    }
+}

package/engine/graphics/micron/render/instanced/AttributeDataTexture.js

@@ -3,11 +3,11 @@ import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
 import { DataTexture, NearestFilter } from "three";
-import { DataTypeByteSizes } from "../../../../../core/collection/table/RowFirstTableSpec.js";
 import { DataType } from "../../../../../core/collection/table/DataType.js";
 import { compute_micron_buffer_array_constructor } from "../../build/compute_micron_buffer_array_constructor.js";
 import { computeThreeTextureTypeFromDataType } from "../../../render/forward_plus/data/computeThreeTextureTypeFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "../../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
 
 /**
  *

package/engine/graphics/render/forward_plus/data/TextureBackedMemoryRegion.js

@@ -3,12 +3,12 @@ import { DataType } from "../../../../../core/collection/table/DataType.js";
 import { assert } from "../../../../../core/assert.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 import { max2 } from "../../../../../core/math/max2.js";
-import { DataTypeByteSizes } from "../../../../../core/collection/table/RowFirstTableSpec.js";
 import { NumericType } from "./NumericType.js";
 import { computeDataType } from "./computeDataType.js";
 import { computeThreeTextureTypeFromDataType } from "./computeThreeTextureTypeFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "./computeThreeTextureInternalFormatFromDataType.js";
 import { computeThreeTextureFormat } from "./computeThreeTextureFormat.js";
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
 
 /**
  * How wide a data texture is

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -65,13 +65,12 @@ import LabelView from "../../../../../view/common/LabelView.js";
 import { randomFloatBetween } from "../../../../../core/math/MathUtils.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
-import { RefinementSpec } from "../../../micron/render/refinement/RefinementSpec.js";
-import { Matrix4 } from "three";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
 import { clamp } from "../../../../../core/math/clamp.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
+import { mat4 } from "gl-matrix";
 
 const engineHarness = new EngineHarness();
 
@@ -219,8 +218,14 @@ function prepare_query_test(hiz, graphics, ecd) {
 
     function prepare_query() {
 
-        const spec = new RefinementSpec();
-        spec.build(new Matrix4(), graphics.camera.matrixWorldInverse, graphics.camera.projectionMatrix);
+        const camera = graphics.camera;
+
+        const projection = mat4.create();
+        const world_inverse = camera.matrixWorldInverse.elements;
+        const camera_projection = camera.projectionMatrix.elements;
+
+        mat4.copy(projection, world_inverse);
+        mat4.multiply(projection, camera_projection, projection);
 
         for (let i = 0; i < query.getSize(); i++) {
             const entity = entities[i];
@@ -237,7 +242,7 @@ function prepare_query_test(hiz, graphics, ecd) {
 
             mesh.bvh.writeToArray(aabb, 0);
 
-            query.setElement(i, aabb, spec.projection_matrix);
+            query.setElement(i, aabb, projection);
         }
 
     }
@@ -412,7 +417,7 @@ function main(engine) {
         metrics.get('hiz_build').record(t1 - t0);
 
 
-        preview.texture = hiz.mips[0].texture;
+        preview.texture = hiz.mips[1].texture;
 
         preview.render();
 

package/engine/graphics/texture/sampler/TextureBinaryBufferSerializer.js

@@ -2,8 +2,8 @@ import { DataTypeIndices } from "../../../../core/collection/table/DataTypeIndic
 import { Sampler2D } from "./Sampler2D.js";
 import { EndianType } from "../../../../core/binary/BinaryBuffer.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import { assert } from "../../../../core/assert.js";
+import { DataTypeByteSizes } from "../../../../core/collection/table/DataTypeByteSizes.js";
 
 
 /**

package/engine/network/convertPathToURL.js

@@ -11,8 +11,8 @@ function isGlobalPath(path) {
 }
 
 // *** Environment setup code ***
-const ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function';
 const ENVIRONMENT_IS_WEB = typeof window === 'object';
+const ENVIRONMENT_IS_NODE = typeof process === 'object' && !ENVIRONMENT_IS_WEB;
 const ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
 const ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
 
@@ -34,6 +34,12 @@ export function convertPathToURL(path) {
             scope = window;
         } else if (ENVIRONMENT_IS_WORKER) {
             scope = self;
+        } else if (ENVIRONMENT_IS_NODE) {
+            scope = {
+                location: new URL(import.meta.url)
+            };
+        } else {
+            throw new Error('Unknown environment');
         }
 
         const location = scope.location;

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.8",
+  "version": "2.33.12",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",