@woosh/meep-engine 2.34.32 → 2.34.36

package/engine/graphics/ecs/mesh-v2/three_object_to_entity_composition.js

@@ -10,10 +10,9 @@ import { ShadedGeometry } from "./ShadedGeometry.js";
 export function three_object_to_entity_composition(root) {
     const node = new EntityNode();
 
-    const transform = new Transform();
-    transform.fromMatrix4(root.matrix.elements);
+    node.transform.fromMatrix4(root.matrix.elements);
 
-    node.entity.add(transform);
+    node.entity.add(new Transform());
 
     if (root.isMesh) {
         if (root.isSkinnedMesh) {
@@ -30,6 +29,7 @@ export function three_object_to_entity_composition(root) {
 
         const child_node = three_object_to_entity_composition(child);
 
+
         node.addChild(child_node);
     }
 

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -320,11 +320,13 @@ export class InstancedMeshGroup {
 
         const lastIndex = this.count - 1;
 
+        const references = this.references;
+
         if (index === lastIndex) {
             //easy case, reference is placed at the end, no swap needed, we can just forget about it
-            delete this.references[index];
+            delete references[index];
         } else {
-            //not at the end, move end reference to this place
+            //not at the end, move the very last reference to this place, effectively shrinking the set
             const index3 = index * 3;
             const start3 = lastIndex * 3;
             const end3 = start3 + 3;
@@ -333,26 +335,30 @@ export class InstancedMeshGroup {
             const start4 = lastIndex * 4;
             const end4 = start4 + 4;
 
-            this.__attributePosition.array.copyWithin(index3, start3, end3);
-            this.__attributeRotation.array.copyWithin(index4, start4, end4);
-            this.__attributeScale.array.copyWithin(index3, start3, end3);
+            const a_position = this.__attributePosition;
+            const a_rotation = this.__attributeRotation;
+            const a_scale = this.__attributeScale;
+
+            a_position.array.copyWithin(index3, start3, end3);
+            a_rotation.array.copyWithin(index4, start4, end4);
+            a_scale.array.copyWithin(index3, start3, end3);
 
-            this.__attributePosition.needsUpdate = true;
-            this.__attributeRotation.needsUpdate = true;
-            this.__attributeScale.needsUpdate = true;
+            a_position.needsUpdate = true;
+            a_rotation.needsUpdate = true;
+            a_scale.needsUpdate = true;
 
             //update moved reference index
-            const movedReference = this.references[lastIndex];
+            const movedReference = references[lastIndex];
 
             if (movedReference === undefined) {
                 //moved reference not found
                 throw new Error(`Moved reference was not found`);
             }
 
-            delete this.references[lastIndex];
+            delete references[lastIndex];
 
             //assume the place of removed reference
-            this.references[index] = movedReference;
+            references[index] = movedReference;
             this.indices[movedReference] = index;
         }
 

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

@@ -14,8 +14,7 @@ import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.
 import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compute_buffer_geometry_byte_size.js";
 import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { max2 } from "../../../../core/math/max2.js";
+import { aabb3_from_v3_array } from "../../../../core/bvh2/aabb3/aabb3_from_v3_array.js";
 
 /**
  * Returns current time in milliseconds
@@ -118,38 +117,6 @@ function attributes_from_buffer_geometry(buffer_geometry) {
 
 const PRINT_VERBOSE_STATS = false;
 
-/**
- *
- * @param {AABB3} result
- * @param {number[]|ArrayLike<number>} input
- * @param {number} input_length
- */
-function aabb3_from_v3_array(result, input, input_length) {
-    let x0 = Infinity;
-    let y0 = Infinity;
-    let z0 = Infinity;
-
-    let x1 = -Infinity;
-    let y1 = -Infinity;
-    let z1 = -Infinity;
-
-    for (let i = 0; i < input_length; i += 3) {
-        const x = input[i];
-        const y = input[i + 1];
-        const z = input[i + 2];
-
-        x0 = min2(x, x0);
-        y0 = min2(y, y0);
-        z0 = min2(z, z0);
-
-        x1 = max2(x, x1);
-        y1 = max2(y, y1);
-        z1 = max2(z, z1);
-    }
-
-    result.setBounds(x0, y0, z0, x1, y1, z1);
-}
-
 /**
  *
  * @param {THREE.BufferGeometry} input

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

@@ -113,6 +113,15 @@ function normalize_to_int8(value) {
     return Math.round(value * 127);
 }
 
+/**
+ *
+ * @param {number} value
+ * @return {number}
+ */
+function normalize_to_uint8(value) {
+    return Math.round(value * 255);
+}
+
 /**
  * @enum {function(number):number}
  */
@@ -120,6 +129,7 @@ const DataConverterType = {
     None: passThrough,
     Number2HalfFloat: to_half_float_uint16,
     Normalize2Int8: normalize_to_int8,
+    Normalize2Uint8: normalize_to_uint8,
     ResampleNormalized_Uint16_to_Uint8: resample_normalized_uint16_to_uint8
 };
 
@@ -130,30 +140,33 @@ const DataConverterType = {
  * @returns {DataConverterType}
  */
 function compute_attribute_data_converter(source, spec) {
-    if (spec.type === DataType.Float16) {
+    const target_type = spec.type;
+    if (target_type === DataType.Float16) {
         return DataConverterType.Number2HalfFloat;
     } else if (spec.normalized && !source.normalized) {
         // source data can be normalized but isn't
-        if (spec.type === DataType.Int8) {
+        if (target_type === DataType.Int8) {
             return DataConverterType.Normalize2Int8;
+        } else if (target_type === DataType.Uint8) {
+            return DataConverterType.Normalize2Uint8;
         } else {
-            throw new Error(`Unsupported normalized type '${spec.type}'`);
+            throw new Error(`Unsupported normalized type '${target_type}'`);
         }
     } else {
         const source_array = source.array;
 
         const source_type = typedArrayToDataType(source_array);
 
-        const target_byte_size = dataTypeByteSize(spec.type);
+        const target_byte_size = dataTypeByteSize(target_type);
         const source_byte_size = dataTypeByteSize(source_type)
 
         if (target_byte_size !== source_byte_size) {
             // wrong data size
 
-            if (spec.type === DataType.Uint8 && source_type === DataType.Uint16) {
+            if (target_type === DataType.Uint8 && source_type === DataType.Uint16) {
                 return DataConverterType.ResampleNormalized_Uint16_to_Uint8;
             } else {
-                throw new Error(`Unsupported conversion ${source_type} -> `);
+                throw new Error(`Unsupported conversion ${source_type} -> ${target_type}`);
             }
 
         } else {

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

@@ -4,6 +4,7 @@ import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangl
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
 import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
+import { BitSet } from "../../../../core/binary/BitSet.js";
 
 let id_counter = 0;
 
@@ -13,6 +14,13 @@ let id_counter = 0;
  */
 const scratch_traversal_stack = [];
 
+/**
+ *
+ * @type {BitSet}
+ */
+const scratch_traversal_bitset = new BitSet();
+scratch_traversal_bitset.preventShrink();
+
 export class MicronGeometry {
     constructor() {
         /**
@@ -79,6 +87,7 @@ export class MicronGeometry {
         origin_x, origin_y, origin_z,
         direction_x, direction_y, direction_z
     ) {
+
         let i;
         let stack_cursor = 1;
 
@@ -99,6 +108,11 @@ export class MicronGeometry {
         // check that position attribute actually exists
         assert.isNonNegativeInteger(position_attribute_index, 'position_attribute_index');
 
+        const included_set = scratch_traversal_bitset;
+        included_set.reset();
+
+        included_set.set(this.root.id, true);
+
         const temp_hit = new SurfacePoint3();
 
         while (stack_cursor > 0) {
@@ -106,6 +120,7 @@ export class MicronGeometry {
 
             const patch = stack[stack_cursor];
 
+
             if (patch.lod === 0) {
                 // LOD 0 - source geometry
 
@@ -206,9 +221,15 @@ export class MicronGeometry {
                 for (i = 0; i < child_count; i++) {
                     const child = children[i];
 
+                    if (included_set.get(child.id)) {
+                        continue;
+                    }
+
                     // push to stack
                     stack[stack_cursor] = child;
 
+                    included_set.set(child.id, true);
+
                     stack_cursor++;
                 }
             }

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -2,7 +2,6 @@ import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
 import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { SOURCE_RENDER_LAYER_PROPERTY } from "../../render/visibility/VisibilityComputer.js";
 import { AssetTransformer } from "../../../asset/AssetTransformer.js";
 import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
 import { Cache } from "../../../../core/cache/Cache.js";
@@ -180,8 +179,6 @@ export class MicronRenderPlugin extends EnginePlugin {
 
             const mesh = ctx.mesh;
 
-            mesh[SOURCE_RENDER_LAYER_PROPERTY] = layer;
-
             visibleSet.elements.push(mesh);
             visibleSet.size++;
 

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -20,6 +20,8 @@ import {
     SphereGeometry,
     sRGBEncoding,
     TextureLoader,
+    Vector2,
+    Vector3,
     VSMShadowMap,
     WebGLRenderer
 } from "three";
@@ -46,6 +48,8 @@ import { CanvasView } from "../../../view/elements/CanvasView.js";
 import { Sampler2D } from "../texture/sampler/Sampler2D.js";
 import { downsampleSampler2D } from "../texture/sampler/downsampleSampler2D.js";
 import { ShadowMapRenderer } from "../shadows/ShadowMapRenderer.js";
+import { MouseEvents } from "../../input/devices/events/MouseEvents.js";
+import { mat4 } from "gl-matrix";
 
 const background = new TextureLoader().load('data/textures/utility/checkers_white_grey_256x256.png');
 background.repeat.set(50, 30);
@@ -473,7 +477,8 @@ function init() {
     // gltf_sample('moicon/03_Jan_22_Demo/3-area_ground_floor/model.gltf');
     // gltf_sample('moicon/03_Jan_22_Demo/4-area_1st_floor/model.gltf');
     // gltf_sample('moicon/03_Jan_22_Demo/8-assets/model.gltf');
-    gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
+    // gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
+    gltf_sample('moicon/A4/A4/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 
@@ -735,6 +740,7 @@ shadowmapRenderer.onBeforeRender.add((renderer, camera, scene) => {
     vgtr.render();
 });
 
+
 function render() {
     if (orbitControls !== undefined) {
         orbitControls.update();
@@ -790,3 +796,65 @@ function render() {
     // console.log(`patches:${active_patches.length}, polycount:${polycount}`);
 }
 
+window.document.body.addEventListener(MouseEvents.Move, ({ clientX, clientY }) => {
+    const direction = new Vector3();
+
+    const viewport_size = new Vector2();
+
+    renderer.getSize(viewport_size);
+
+    const v2_nx = (clientX / viewport_size.x) * 2 - 1;
+    const v2_ny = -(clientY / viewport_size.y) * 2 + 1;
+
+    direction.set(v2_nx, v2_ny, 0.5);
+
+    direction.unproject(camera);
+
+    direction.sub(camera.position);
+
+    direction.normalize();
+
+    const origin_x = camera.position.x;
+    const origin_y = camera.position.y;
+    const origin_z = camera.position.z;
+
+    const direction_x = direction.x;
+    const direction_y = direction.y;
+    const direction_z = direction.z;
+
+    const hits = [];
+    scene.traverse(o => {
+        if (o.isMicronMesh) {
+            /**
+             * @type {MicronGeometry}
+             */
+            const micron_geo = o.geometry;
+
+            const scratch_m4 = new Float32Array(16);
+
+            // get transform in local space
+            mat4.invert(scratch_m4, o.matrixWorld);
+
+            // transform ray to local space
+            const local_origin_x = scratch_m4[0] * origin_x + scratch_m4[4] * origin_y + scratch_m4[8] * origin_z + scratch_m4[12];
+            const local_origin_y = scratch_m4[1] * origin_x + scratch_m4[5] * origin_y + scratch_m4[9] * origin_z + scratch_m4[13];
+            const local_origin_z = scratch_m4[2] * origin_x + scratch_m4[6] * origin_y + scratch_m4[10] * origin_z + scratch_m4[14];
+
+            const local_direction_x = scratch_m4[0] * direction_x + scratch_m4[4] * direction_y + scratch_m4[8] * direction_z;
+            const local_direction_y = scratch_m4[1] * direction_x + scratch_m4[5] * direction_y + scratch_m4[9] * direction_z;
+            const local_direction_z = scratch_m4[2] * direction_x + scratch_m4[6] * direction_y + scratch_m4[10] * direction_z;
+            // NOTE: direction is not normalized
+
+            const point = micron_geo.raycast(local_origin_x, local_origin_y, local_origin_z, local_direction_x, local_direction_y, local_direction_z);
+
+            Array.prototype.push.apply(hits, point.map(p => {
+                return { position: p.position.toJSON(), geometry: micron_geo.id, instance: o.id };
+            }));
+        }
+    });
+
+    if (hits.length > 0) {
+        console.log(`HITS: ${hits.map(JSON.stringify).join(',')}`);
+    }
+});
+

package/engine/graphics/render/layers/RenderLayer.js

@@ -6,73 +6,19 @@
 import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
 import { RenderPassType } from "../RenderPassType.js";
 import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
-import { BVHVisitor } from "../../../../core/bvh2/traversal/BVHVisitor.js";
-import { noop, passThrough } from "../../../../core/function/Functions.js";
-import { ThreeFrustumsIntersectionBVHVisitor } from "../../../../core/bvh2/traversal/ThreeFrustumsIntersectionBVHVisitor.js";
+import { passThrough } from "../../../../core/function/Functions.js";
 import { traverseBinaryNodeUsingVisitor } from "../../../../core/bvh2/traversal/traverseBinaryNodeUsingVisitor.js";
 import { ThreeClippingPlaneComputingBVHVisitor } from "../../../../core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js";
 import { RenderLayerState } from "./RenderLayerState.js";
 import { compare_three_objects } from "../../three/compare_three_objects.js";
+import { queryBinaryNode_FrustumIntersections_Data } from "../../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
 
 
-class VisibleLeafCollector extends BVHVisitor {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {Function[]}
-         */
-        this.filters = [];
-        this.filterCount = 0;
-
-        this.callback = noop;
-        this.callbackContext = null;
-
-        this.reader = passThrough;
-
-        this.count = 0;
-    }
-
-    initialize() {
-        this.filterCount = this.filters.length;
-        this.count = 0;
-    }
-
-    visitLeaf(leaf) {
-        const numFilters = this.filterCount;
-
-        const filters = this.filters;
-
-        for (let i = 0; i < numFilters; i++) {
-            const filterFunction = filters[i];
-
-            const visibilityFlag = filterFunction(leaf);
-
-            if (!visibilityFlag) {
-                //not visible, skip
-                return;
-            }
-        }
-
-        const object = leaf.object;
-
-        if (object === null) {
-            // no payload on the BVH leaf
-            return;
-        }
-
-        const renderable = this.reader(object);
-
-        if (renderable === null) {
-            // no renderable on the payload
-            return;
-        }
-
-        this.count++;
-        this.callback.call(this.callbackContext, renderable, leaf);
-    }
-}
+/**
+ *
+ * @type {*[]}
+ */
+const scratch_array = [];
 
 export class RenderLayer {
     constructor() {
@@ -119,18 +65,6 @@ export class RenderLayer {
          * @type {RenderPassType|number}
          */
         this.renderPass = RenderPassType.Opaque;
-
-        /**
-         * @private
-         * @type {VisibleLeafCollector}
-         */
-        this.visibilityCollector = new VisibleLeafCollector();
-        /**
-         * @private
-         * @type {ThreeFrustumsIntersectionBVHVisitor}
-         */
-        this.bvhVisibilityVisitor = new ThreeFrustumsIntersectionBVHVisitor();
-        this.bvhVisibilityVisitor.collector = this.visibilityCollector;
     }
 
     /**
@@ -178,29 +112,32 @@ export class RenderLayer {
 
     /**
      *
-     * @param {Frustum[]} frustums
-     * @param {function[]} filters
-     * @param {function(Object3D, NodeDescription)} callback
+     * @param {CameraView} view
+     * @param {function(THREE.Object3D)} callback
      * @param {*} [callbackContext]
      */
-    buildVisibleSet(frustums, filters, callback, callbackContext) {
+    buildVisibleSet(view, callback, callbackContext) {
+        const frustum = view.frustum;
+
         const reader = this.extractRenderable;
 
 
         if (typeof reader === "function") {
-            this.visibilityCollector.callback = callback;
-            this.visibilityCollector.callbackContext = callbackContext;
 
-            this.visibilityCollector.filters = filters;
-            this.visibilityCollector.reader = reader;
+            const hits = queryBinaryNode_FrustumIntersections_Data(scratch_array, 0, this.bvh, frustum);
 
-            this.visibilityCollector.initialize();
+            for (let i = 0; i < hits; i++) {
+                const datum = scratch_array[i];
 
-            this.bvhVisibilityVisitor.setFrustums(frustums);
+                const object3D = reader(datum);
 
-            traverseBinaryNodeUsingVisitor(this.bvh, this.bvhVisibilityVisitor);
+                if (!object3D) {
+                    // null or undefined
+                    continue;
+                }
 
-            this.visibilityCollector.finalize();
+                callback.call(callbackContext, object3D);
+            }
 
         }