@woosh/meep-engine 2.33.4 → 2.33.9

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() {
@@ -40,8 +40,8 @@ export class MicronGeometryBufferAttributeSpec {
     equals(other) {
         return this.type === other.type
             && this.itemSize === other.itemSize
-            && this.name === other.name
             && this.normalized === other.normalized
+            && this.name === other.name
             ;
     }
 

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

@@ -13,22 +13,36 @@ export class MicronGeometryPatch {
          */
         this.id = 0;
 
+        /**
+         * Continuous memory region for various pieces of data to get better memory access patterns
+         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer((6 + 6 + 24) * 4);
+
         /**
          * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
          * @type {number[]}
          */
-        this.bounding_box = new Float32Array(6);
+        this.bounding_box = new Float32Array(array_buffer, 0, 6);
+
+        /**
+         *
+         * @type {vec4|number[]}
+         */
+        this.bounding_sphere = vec4.create()
 
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box = new Float32Array(6);
+        this.group_bounding_box = new Float32Array(array_buffer, 6 * 4, 6);
+
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box_corners = new Float32Array(24);
+        this.group_bounding_box_corners = new Float32Array(array_buffer, 12 * 4, 24);
 
         /**
          *
@@ -42,12 +56,6 @@ export class MicronGeometryPatch {
          */
         this.group_error = 0;
 
-        /**
-         *
-         * @type {vec4}
-         */
-        this.bounding_sphere = vec4.create()
-
         /**
          *
          * @type {MicronGeometryPatch[]}

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

@@ -2,6 +2,8 @@ import { isArrayEqual } from "../../../../core/collection/ArrayUtils.js";
 import { computeHashArray } from "../../../../core/math/MathUtils.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
 
+const DEFAULT_HASH = 123456;
+
 export class MicronVertexDataSpec {
     constructor() {
         /**
@@ -12,9 +14,21 @@ export class MicronVertexDataSpec {
 
         /**
          *
-         * @type {RowFirstTableSpec|null}
+         * @type {number}
+         * @private
          */
-        this.data = null;
+        this.__hash = DEFAULT_HASH;
+    }
+
+    /**
+     *
+     * @param {MicronGeometryBufferAttributeSpec[]} attributes
+     */
+    setAttributes(attributes) {
+        this.attributes = attributes;
+
+        // reset hash to trigger hash update
+        this.__hash = DEFAULT_HASH;
     }
 
     /**
@@ -30,10 +44,18 @@ export class MicronVertexDataSpec {
         return isArrayEqual(this.attributes, other.attributes);
     }
 
-    hash() {
+    computeHash() {
         return computeHashArray(this.attributes, invokeObjectHash);
     }
 
+    hash() {
+        if (this.__hash === DEFAULT_HASH) {
+            this.__hash = this.computeHash();
+        }
+
+        return this.__hash;
+    }
+
     /**
      *
      * @param {string} name

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/prototypeVirtualGeometry.js

@@ -535,7 +535,7 @@ function createScene(geometry, m1, scale) {
     geometry.computeVertexNormals();
 
 
-    const grid_size = 10;
+    const grid_size = 100;
     const grid_spacing = 2000;
 
     for (let i = 0; i < grid_size; i++) {

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -2,19 +2,33 @@ import { Frustum, Matrix4 } from "three";
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import { MicronGeometryPatchOccurrence } from "../format/MicronGeometryPatchOccurance.js";
-import { RefinementSpec } from "./RefinementSpec.js";
+import { RefinementSpec } from "./refinement/RefinementSpec.js";
 import { ActivePatchList } from "./refinement/ActivePatchList.js";
 import { ActivePatchFlags } from "./refinement/ActivePatchFlags.js";
 
-
+/**
+ * @readonly
+ * @type {RefinementSpec}
+ */
 const refinement_spec = new RefinementSpec();
 
 export class VirtualGeometryBuilder {
     constructor() {
         this.view_projection_matrix = new Matrix4();
-        this.matrix_projection = new Matrix4();
+
+        /**
+         *
+         * @type {Float32Array|number[]|mat4}
+         */
+        this.matrix_projection = new Float32Array(16);
+
         this.matrix_projection_inverse = new Matrix4();
-        this.matrix_world_inverse = new Matrix4();
+
+        /**
+         *
+         * @type {Float32Array|number[]|mat4}
+         */
+        this.matrix_world_inverse = new Float32Array(16);
 
         /**
          *
@@ -48,10 +62,10 @@ export class VirtualGeometryBuilder {
 
         /**
          *
-         * @type {WeakMap<ThreeMicronMesh, ActivePatchList>}
+         * @type {ActivePatchList}
          * @private
          */
-        this.__acls = new WeakMap();
+        this.__acl = new ActivePatchList();
 
         /**
          * How much error to accept when deciding to subdivide a cluster
@@ -76,12 +90,8 @@ export class VirtualGeometryBuilder {
         this.__flags__enforce_dependency_splits = true;
     }
 
-    /**
-     * Drop all cached data, forcing a complete rebuild next time
-     * Useful for testing and debugging
-     */
     dropCache() {
-        this.__acls = new WeakMap();
+        this.__acl.clear();
     }
 
     /**
@@ -102,8 +112,10 @@ export class VirtualGeometryBuilder {
         camera.updateMatrixWorld(true);
 
         this.view_projection_matrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-        this.matrix_world_inverse.copy(camera.matrixWorldInverse);
-        this.matrix_projection.copy(camera.projectionMatrix);
+
+        this.matrix_world_inverse.set(camera.matrixWorldInverse.elements);
+        this.matrix_projection.set(camera.projectionMatrix.elements);
+
         this.matrix_projection_inverse.copy(camera.projectionMatrixInverse);
 
         this.view_frustum.setFromProjectionMatrix(this.view_projection_matrix);
@@ -137,15 +149,7 @@ export class VirtualGeometryBuilder {
             const micron_geometry = object.geometry;
             if (micron_geometry !== undefined) {
                 // get acl
-
-                const acls = this.__acls;
-
-                let acl = acls.get(object);
-
-                if (acl === undefined) {
-                    acl = new ActivePatchList();
-                    acls.set(object, acl);
-                }
+                const acl = this.__acl;
 
                 acl.initializeFromGeometry(micron_geometry);
 
@@ -182,7 +186,7 @@ export class VirtualGeometryBuilder {
         apl
     ) {
 
-        refinement_spec.build(transform, this.matrix_world_inverse, this.matrix_projection);
+        refinement_spec.build(transform.elements, this.matrix_world_inverse, this.matrix_projection);
 
         const output = this.output;
 

package/engine/graphics/micron/render/culling/{PathCullingSystem.js → PatchCullingSystem.js}

@@ -49,7 +49,7 @@ function buildExecutor() {
 
 const MAX_PATCH_COUNT = 60000;
 
-export class PathCullingSystem {
+export class PatchCullingSystem {
     constructor() {
         /**
          *

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

@@ -2,14 +2,12 @@ import { assert } from "../../../../../core/assert.js";
 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 {
-    computeThreeTextureInternalFormatFromDataType,
-    computeThreeTextureTypeFromDataType
-} from "../../../render/forward_plus/TextureBackedMemoryRegion.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";
 
 /**
  *