@woosh/meep-engine 2.33.1 → 2.33.5

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -1,8 +1,5 @@
-import { BitSet } from "../../../../core/binary/BitSet.js";
 import { TopoMesh } from "../../../../core/geom/3d/topology/TopoMesh.js";
 import { PatchRepresentation } from "./PatchRepresentation.js";
-import { max3 } from "../../../../core/math/max3.js";
-import { min3 } from "../../../../core/math/min3.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { buildAbstractPatchHierarchy } from "./hierarchy/buildAbstractPatchHierarchy.js";
 import { MicronGeometryBufferAttributeSpec } from "../format/MicronGeometryBufferAttributeSpec.js";
@@ -15,6 +12,7 @@ import { build_graph_info } from "./debug/build_graph_info.js";
 import { expandConnectivityByLocality } from "../../../../core/geom/3d/topology/expandConnectivityByLocality.js";
 import { build_geometry_info } from "./build_geometry_info.js";
 import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.js";
+import { compute_buffer_geometry_byte_size } from "./compute_buffer_geometry_byte_size.js";
 
 
 /**
@@ -38,55 +36,6 @@ function buildVertexDataTypeMap(attributes) {
     return data_types;
 }
 
-
-/**
- *
- * @param {FastBinaryHeap} candidates
- * @param {BitSet} open_set
- * @param {TopoMesh} mesh
- */
-function pickCandidateForNextPatch(candidates, open_set, mesh) {
-
-}
-
-/**
- *
- * @param {AABB3} bounds
- * @param {TopoTriangle} face
- */
-function expandBoundsByFace(bounds, face) {
-    const vertices = face.vertices;
-
-    const vA = vertices[0];
-    const vB = vertices[1];
-    const vC = vertices[2];
-
-    bounds._expandToFitPoint(vA.x, vA.y, vA.z);
-    bounds._expandToFitPoint(vB.x, vB.y, vB.z);
-    bounds._expandToFitPoint(vC.x, vC.y, vC.z);
-}
-
-/**
- *
- * @param {AABB3} bounds
- * @param {TopoVertex} vA
- * @param {TopoVertex} vB
- * @param {TopoVertex} vC
- * @returns {number}
- */
-function computeBoundsTriangleInclusionCost(bounds, vA, vB, vC) {
-    // compute AABB of triangle
-    const x0 = min3(vA.x, vB.x, vC.x);
-    const y0 = min3(vA.y, vB.y, vC.y);
-    const z0 = min3(vA.z, vB.z, vC.z);
-
-    const x1 = max3(vA.x, vB.x, vC.x);
-    const y1 = max3(vA.y, vB.y, vC.y);
-    const z1 = max3(vA.z, vB.z, vC.z);
-
-    return bounds._costForInclusion(x0, y0, z0, x1, y1, z1);
-}
-
 /**
  *
  * @param {MicronGeometryBufferAttributeSpec} spec
@@ -120,6 +69,7 @@ function format_attribute(spec, source, name) {
 
     switch (name) {
         case 'uv':
+        case 'uv2':
             custom_attribute_format_uv(spec, source);
             break;
         case 'tangent':
@@ -157,23 +107,6 @@ function attributes_from_buffer_geometry(buffer_geometry) {
     return result;
 }
 
-/**
- *
- * @param {THREE.BufferGeometry} g
- * @returns {number}
- */
-export function compute_buffer_geometry_byte_size(g) {
-    let result = 0;
-
-    result += g.getIndex().array.buffer.byteLength;
-
-    for (const attribute_name in g.attributes) {
-        result += g.attributes[attribute_name].array.buffer.byteLength;
-    }
-
-    return result;
-}
-
 const PRINT_VERBOSE_STATS = false;
 
 /**
@@ -261,7 +194,7 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
     const r = new MicronGeometry();
 
     r.proxy = input; // TODO use r.buildProxy(1) instead
-    
+
     r.source_triangle_count = index_attribute.count / 3;
     r.source_vertex_count = input.getAttribute('position').count;
     r.source_byte_size = compute_buffer_geometry_byte_size(input);

package/engine/graphics/micron/build/compute_buffer_geometry_byte_size.js

@@ -0,0 +1,16 @@
+/**
+ * Estimated GPU-side geometry size
+ * @param {THREE.BufferGeometry} g
+ * @returns {number}
+ */
+export function compute_buffer_geometry_byte_size(g) {
+    let result = 0;
+
+    result += g.getIndex().array.buffer.byteLength;
+
+    for (const attribute_name in g.attributes) {
+        result += g.attributes[attribute_name].array.buffer.byteLength;
+    }
+
+    return result;
+}

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

@@ -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

@@ -1,4 +1,3 @@
-import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { squirrel3 } from "../../../../core/math/hash/squirrel3.js";
 import { ConicRay } from "../../../../core/geom/ConicRay.js";
 import { vec4 } from "gl-matrix";
@@ -16,15 +15,20 @@ export class MicronGeometryPatch {
 
         /**
          * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
-         * @type {AABB3}
+         * @type {number[]}
          */
-        this.bounding_box = new AABB3(0, 0, 0, 0, 0, 0);
+        this.bounding_box = new Float32Array(6);
 
         /**
          *
-         * @type {AABB3}
+         * @type {number[]|Float32Array}
+         */
+        this.group_bounding_box = new Float32Array(6);
+        /**
+         *
+         * @type {number[]|Float32Array}
          */
-        this.group_bounding_box = new AABB3(0, 0, 0, 0, 0, 0);
+        this.group_bounding_box_corners = new Float32Array(24);
 
         /**
          *

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -53,7 +53,7 @@ background.wrapS = RepeatWrapping;
 background.wrapT = RepeatWrapping;
 
 const metrics = new MetricCollection();
-const METRIC_BUFFER_SIZE = 100;
+const METRIC_BUFFER_SIZE = 1000;
 metrics.create({
     name: 'vg_build', buffer_size: METRIC_BUFFER_SIZE
 });
@@ -153,17 +153,21 @@ async function micron_add_object(object) {
         if (t.isMesh && material !== null) {
 
             const attachments = TextureAttachmentsByMaterialType[material.type];
-            const n = attachments.length;
 
-            for (let i = 0; i < n; i++) {
-                const a = attachments[i];
-                const texture = a.read(material);
+            if (attachments !== undefined) {
 
-                if (texture !== undefined && texture !== null) {
-                    texture.anisotropy = 8;
+                const n = attachments.length;
+
+                for (let i = 0; i < n; i++) {
+                    const a = attachments[i];
+                    const texture = a.read(material);
+
+                    if (texture !== undefined && texture !== null) {
+                        texture.anisotropy = 8;
+                    }
                 }
-            }
 
+            }
 
         }
     });
@@ -228,7 +232,7 @@ function init() {
     pointLight.add(mesh);
 
     // add directional light
-    directionalLight = new DirectionalLight(0xFFAAAA, 0.7);
+    directionalLight = new DirectionalLight(0xFFAAAA, 0.8);
     directionalLight.position.set(-500, 1000, 300);
     directionalLight.castShadow = true;
     const shadow_camera = directionalLight.shadow.camera;
@@ -452,12 +456,15 @@ function init() {
 
     // sample_gltf_sponza();
     // sample_gltf_rts_factory();
-    // sample_lucy();
+    sample_lucy();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
     // sample_gltf_broken_isiflow();
-    gltf_grid('data/models/moicon/Kople/EVCharger1.gltf');
+    // gltf_grid('data/models/moicon/Kople/EVCharger1.gltf');
     // gltf_grid('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
+    // gltf_sample('data/models/moicon/08-clickable-assets/model.gltf');
+    // gltf_sample('data/models/moicon/05-ground-floor/model.gltf');
+    // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 
@@ -528,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/RefinementSpec.js

@@ -1,23 +1,89 @@
 import Vector2 from "../../../../core/geom/Vector2.js";
-import { Frustum, Matrix4 } from "three";
+import { Matrix4 } from "three";
 import { mat4 } from "gl-matrix";
+import { v3_length } from "../../../../core/geom/Vector3.js";
 
+/**
+ * Normalize a plane in-place
+ * @param {number[]} source
+ * @param {number} source_offset
+ */
+function array_normalize_plane(source, source_offset) {
+    const _x = source[source_offset];
+    const _y = source[source_offset + 1];
+    const _z = source[source_offset + 2];
 
-function setFromProjectionMatrix(planes, me) {
+    const length = v3_length(_x, _y, _z);
 
-    const me0 = me[0], me1 = me[1], me2 = me[2], me3 = me[3];
-    const me4 = me[4], me5 = me[5], me6 = me[6], me7 = me[7];
-    const me8 = me[8], me9 = me[9], me10 = me[10], me11 = me[11];
-    const me12 = me[12], me13 = me[13], me14 = me[14], me15 = me[15];
+    const inverseNormalLength = 1.0 / length;
 
-    planes[0].setComponents(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize();
-    planes[1].setComponents(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize();
-    planes[2].setComponents(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize();
-    planes[3].setComponents(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize();
-    planes[4].setComponents(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize();
-    planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize();
+    /*
+    By re-using values already in the registers instead of using *= we save a few extra READ ops
+     */
+    source[source_offset] = _x * inverseNormalLength;
+    source[source_offset + 1] = _y * inverseNormalLength;
+    source[source_offset + 2] = _z * inverseNormalLength;
+
+    source[source_offset + 3] *= inverseNormalLength;
+}
+
+/**
+ *
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ */
+function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+    const length = v3_length(x, y, z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    destination[destination_offset] = x * inverseNormalLength;
+    destination[destination_offset + 1] = y * inverseNormalLength;
+    destination[destination_offset + 2] = z * inverseNormalLength;
+    destination[destination_offset + 3] = w * inverseNormalLength;
+}
+
+/**
+ *
+ * @param {number[]|Float32Array} frustum_planes
+ * @param {number[]} me
+ */
+function array_setFromProjectionMatrix(frustum_planes, me) {
+
+    const me0 = me[0];
+    const me3 = me[3];
+
+    const me4 = me[4];
+    const me7 = me[7];
 
+    const me8 = me[8];
+    const me11 = me[11];
 
+    const me12 = me[12];
+    const me15 = me[15];
+
+    array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
+    array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
+
+    const me1 = me[1];
+    const me5 = me[5];
+    const me9 = me[9];
+    const me13 = me[13];
+
+    array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
+    array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
+
+    const me2 = me[2];
+    const me6 = me[6];
+    const me10 = me[10];
+    const me14 = me[14];
+
+    array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
+    array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);
 }
 
 export class RefinementSpec {
@@ -43,11 +109,18 @@ export class RefinementSpec {
          */
         this.error_threshold = 1;
 
+        /**
+         * Error threshold as a fraction of the screen area instead of pixels, derived internally from pixel value
+         * @type {number}
+         */
+        this.error_threshold_normalized = 1;
+
         /**
          * Object-space camera frustum
-         * @type {Frustum}
+         * Frustum planes in compact form
+         * @type {Float32Array}
          */
-        this.frustum = new Frustum();
+        this.frustum_f32 = new Float32Array(24);
 
         /**
          * Model world transform
@@ -74,6 +147,18 @@ export class RefinementSpec {
         this.view_position = new Float32Array(3);
     }
 
+    get frustum() {
+        throw new Error('deprecated, use .frustum_f32 instead');
+    }
+
+    setResolution(x, y) {
+        this.resolution.set(x, y);
+
+        this.viewport_area = x * y;
+
+        this.error_threshold_normalized = this.error_threshold / this.viewport_area;
+    }
+
     /**
      *
      * @param {Matrix4} transform world-space object transform
@@ -85,26 +170,12 @@ export class RefinementSpec {
         _transform.set(transform.elements);
 
         // build projection matrix
-        mat4.multiply(this.projection_matrix, matrix_world_inverse.elements, _transform);
-        mat4.multiply(this.projection_matrix, matrix_projection.elements, this.projection_matrix);
+        const projection_matrix = this.projection_matrix;
 
-        // compute view frustum in model-space
-        setFromProjectionMatrix(this.frustum.planes, this.projection_matrix);
-
-        /*
-
-        // get inverse of model view matrix
-        model_view_matrix.invert();
-
-        // get view origin position in the prjected space
-        const inv_mv = model_view_matrix.elements;
-        const view_position = this.view_position;
+        mat4.multiply(projection_matrix, matrix_world_inverse.elements, _transform);
+        mat4.multiply(projection_matrix, matrix_projection.elements, projection_matrix);
 
-        // extract position component from transform matrix
-        view_position[0] = inv_mv[12];
-        view_position[1] = inv_mv[13];
-        view_position[2] = inv_mv[14];
-
-         */
+        // compute view frustum in model-space
+        array_setFromProjectionMatrix(this.frustum_f32, projection_matrix);
     }
 }

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

@@ -48,10 +48,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 +76,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();
+    dropCache(){
+        this.__acl.clear();
     }
 
     /**
@@ -129,8 +125,6 @@ export class VirtualGeometryBuilder {
             return;
         }
 
-        const children = object.children;
-
         if (object.isMicronMesh) {
             /**
              *
@@ -139,14 +133,7 @@ export class VirtualGeometryBuilder {
             const micron_geometry = object.geometry;
             if (micron_geometry !== undefined) {
                 // get acl
-
-                let acl = this.__acls.get(object);
-
-
-                if (acl === undefined) {
-                    acl = new ActivePatchList();
-                    this.__acls.set(object, acl);
-                }
+                const acl = this.__acl;
 
                 acl.initializeFromGeometry(micron_geometry);
 
@@ -159,7 +146,9 @@ export class VirtualGeometryBuilder {
             }
         }
 
+        const children = object.children;
         const children_count = children.length;
+
         for (let i = 0; i < children_count; i++) {
             const child = children[i];
 
@@ -252,9 +241,10 @@ export class VirtualGeometryBuilder {
 
         // update refinement spec
         refinement_spec.error_threshold = this.error_bias;
-        refinement_spec.resolution.copy(this.resolution);
 
-        refinement_spec.viewport_area = this.resolution.x * this.resolution.y;
+        const resolution = this.resolution;
+
+        refinement_spec.setResolution(resolution.x, resolution.y);
 
         // clear output
         this.output.clear();
@@ -262,9 +252,10 @@ export class VirtualGeometryBuilder {
         this.__info_enforced_node_splits = 0;
 
         const n = this.input_scene_length;
+        const input_objects = this.input_scene;
 
         for (let i = 0; i < n; i++) {
-            const object3D = this.input_scene[i];
+            const object3D = input_objects[i];
 
             this.buildForObject(object3D);
         }

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";
 
 /**
  *

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

@@ -253,6 +253,7 @@ export class PatchDataTextures {
                 capacity + 1
             );
 
+            // Clamp to maximum texture size
             next_capacity = min2(next_capacity, MAX_TEXTURE_SIZE * this.__column_count);
 
             if (next_capacity < capacity) {

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

@@ -8,7 +8,7 @@ import {
 } from "three";
 import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
 import Signal from "../../../../../core/events/signal/Signal.js";
-import { ATTRIBUTE_INSTANCE_ID, ATTRIBUTE_NAME_ADDRESS, ATTRIBUTE_NAME_TRANSFORM } from "./shader/constants.js";
+import { ATTRIBUTE_NAME_ADDRESS, ATTRIBUTE_NAME_TRANSFORM } from "./shader/constants.js";
 import { shader_rewrite_standard } from "./shader/shader_rewrite_standard.js";
 
 
@@ -98,20 +98,8 @@ export class ThreeInstancedAdapter {
         const ia_patch_ref = new InstancedBufferAttribute(new Uint16Array(capacity), 1, false);
         ia_patch_ref.setUsage(StreamDrawUsage);
 
-
-        /**
-         * This is a workaround for bug in WebGLBindingStates
-         * @see https://github.com/mrdoob/three.js/issues/22843
-         * @type {number}
-         */
-        ia_patch_ref.data = 0;
-
         geo.setAttribute(ATTRIBUTE_NAME_ADDRESS, ia_patch_ref);
 
-        const ia_instance_id = new InstancedBufferAttribute(new Uint16Array(capacity), 1, false);
-        ia_instance_id.setUsage(StreamDrawUsage);
-        geo.setAttribute(ATTRIBUTE_INSTANCE_ID, ia_instance_id);
-
         // signal
         this.onRebuild.send0();
     }
@@ -151,7 +139,6 @@ export class ThreeInstancedAdapter {
      */
     build(patches, patch_count) {
         this.__prepare_capacity(patch_count);
-        // this.__build_geometry();
 
         const geo = this.__buffer_geometry;
 
@@ -163,21 +150,8 @@ export class ThreeInstancedAdapter {
         const patch_address_attribute = geo.getAttribute(ATTRIBUTE_NAME_ADDRESS);
         const patch_address_array = patch_address_attribute.array;
 
-        /**
-         * This is a workaround for bug in WebGLBindingStates
-         * @see https://github.com/mrdoob/three.js/issues/22843
-         * @type {number}
-         */
-        patch_address_attribute.data++;
-
         patch_address_attribute.needsUpdate = true;
 
-
-        const patch_instance_id_attribute = geo.getAttribute(ATTRIBUTE_INSTANCE_ID);
-        const patch_instance_id_array = patch_instance_id_attribute.array;
-
-        patch_instance_id_attribute.needsUpdate = true;
-
         const patch_data = this.__patch_data;
 
         for (let i = 0; i < patch_count; i++) {
@@ -190,8 +164,6 @@ export class ThreeInstancedAdapter {
             const patch_slot_id = patch_data.ensure(occurrence.patch);
 
             patch_address_array[i] = patch_slot_id;
-
-            patch_instance_id_array[i] = occurrence.instance_id;
         }
     }
 }