@woosh/meep-engine 2.34.35 → 2.34.36

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
 };
 
@@ -137,6 +147,8 @@ function compute_attribute_data_converter(source, spec) {
         // source data can be normalized but isn't
         if (target_type === DataType.Int8) {
             return DataConverterType.Normalize2Int8;
+        } else if (target_type === DataType.Uint8) {
+            return DataConverterType.Normalize2Uint8;
         } else {
             throw new Error(`Unsupported normalized type '${target_type}'`);
         }

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);
+            }
 
         }
 

package/engine/graphics/render/visibility/VisibilityComputer.js

@@ -1,42 +1,14 @@
-import { Frustum } from "three";
-import { frustumFromCamera } from "../../ecs/camera/CameraSystem.js";
 import { assert } from "../../../../core/assert.js";
 
-const frustum = new Frustum();
-/**
- *
- * @type {VisibilityFilter[]}
- */
-const objectFilters = [];
-
-/**
- *
- * @type {function[]}
- */
-const objectFilterExecutors = [];
-
-export const SOURCE_RENDER_LAYER_PROPERTY = '@meep-render-layer';
-
 export class VisibilityComputer {
     constructor() {
-        /**
-         *
-         * @type {VisibilityFilter[]}
-         */
-        this.filters = [];
+
         /**
          *
          * @type {CameraView}
          */
         this.__view = null;
 
-        /**
-         * @deprecated use view.frustum instead
-         * @type {Frustum[]}
-         * @private
-         */
-        this.__frustums = [];
-
         /**
          *
          * @type {RenderLayer}
@@ -53,15 +25,28 @@ export class VisibilityComputer {
     }
 
     /**
-     *
+     * @deprecated
+     * @returns {VisibilityFilter[]}
+     */
+    get filters() {
+
+        throw new Error('Method is deprecated');
+    }
+
+    /**
+     * @deprecated
+     * @param {VisibilityFilter[]} v
+     */
+    set filters(v) {
+        throw new Error('Method is deprecated');
+    }
+
+    /**
+     * @deprecated
      * @param {VisibilityFilter} filter
      */
     addFilter(filter) {
-        if (this.filters.find(f => f.name === filter.name)) {
-            throw new Error(`Filter named '${filter.name}' already exists`);
-        }
-
-        this.filters.push(filter);
+        throw new Error('Method is deprecated');
     }
 
     /**
@@ -70,16 +55,8 @@ export class VisibilityComputer {
      * @returns {boolean}
      */
     removeFilter(filter) {
-        const i = this.filters.indexOf(filter);
-
-        if (i === -1) {
-            //not present
-            return false;
-        }
 
-        //cut
-        this.filters.splice(i, 1);
-        return true;
+        throw new Error('Method is deprecated');
     }
 
     /**
@@ -97,9 +74,6 @@ export class VisibilityComputer {
     __includeObject(object3d) {
         assert.equal(object3d.isObject3D, true, 'object3d.isObject3D !== true');
 
-        // mark object, this is a hack, needs to be fixed at some point
-        object3d[SOURCE_RENDER_LAYER_PROPERTY] = this.__activeLayer;
-
         //object passed all filters, add it to visible set
         this.__output.push(object3d);
 
@@ -111,8 +85,6 @@ export class VisibilityComputer {
      * @param {RenderLayer} layer
      */
     __processLayer(layer) {
-
-
         if (!layer.state.visible) {
             //whole layer is hidden
 
@@ -123,61 +95,13 @@ export class VisibilityComputer {
         this.__activeLayer = layer;
 
         if (layer.managed) {
-            this.__output.pushOther(layer.visibleSet);
 
-            // mark all elements in the layer
-            const elements = layer.visibleSet.elements;
-
-            const element_count = elements.length;
-            for (let j = 0; j < element_count; j++) {
-                const object3D = elements[j];
-
-                object3D[SOURCE_RENDER_LAYER_PROPERTY] = layer;
-            }
+            this.__output.pushOther(layer.visibleSet);
 
             return;
         }
 
-        // clear visible set
-        // this.__output.initializeUpdate();
-
-        const filters = this.filters;
-        const filterCount = filters.length;
-
-        let objectFilterCount = 0;
-        let i;
-        for (i = 0; i < filterCount; i++) {
-            const f = filters[i];
-
-            if (f.enabled && f.layerPredicate(layer)) {
-                objectFilters[objectFilterCount] = f;
-                objectFilterExecutors[objectFilterCount] = f.objectPredicateExecute;
-
-                objectFilterCount++;
-            }
-        }
-
-
-        //prepare filters
-        for (i = 0; i < objectFilterCount; i++) {
-            const f = objectFilters[i];
-
-            f.objectPredicateInitialize(this.__view.camera);
-        }
-
-        objectFilterExecutors.length = objectFilterCount;
-
-        layer.buildVisibleSet(this.__frustums, objectFilterExecutors, this.__includeObject, this);
-
-        //finalize filters
-        for (i = 0; i < objectFilterCount; i++) {
-            const f = objectFilters[i];
-
-            f.objectPredicateFinalize();
-        }
-
-
-        // layer.visibleSet.finalizeUpdate();
+        layer.buildVisibleSet(this.__view, this.__includeObject, this);
     }
 
 
@@ -193,10 +117,6 @@ export class VisibilityComputer {
      * @param {RenderLayerManager} renderLayers
      */
     build(renderLayers) {
-        frustumFromCamera(this.__view.camera, frustum);
-
-        this.__frustums = [frustum];
-
         renderLayers.traverse(this.__processLayer, this);
     }
 }

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.35",
+  "version": "2.34.36",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/samples/terrain/editor.js

@@ -20,7 +20,6 @@ import { copy_Sampler2D_channel_data } from "../../engine/graphics/texture/sampl
 import { TextureAssetLoader } from "../../engine/asset/loaders/texture/TextureAssetLoader.js";
 import { CanvasView } from "../../view/elements/CanvasView.js";
 import convertSampler2D2Canvas from "../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
-import { drawSamplerHTML } from "../../engine/graphics/texture/sampler/util/drawSamplerHTML.js";
 
 const engineHarness = new EngineHarness();