@woosh/meep-engine 2.34.35 → 2.34.39

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/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js

@@ -464,7 +464,11 @@ export function make_particle_billboard_shader({ lights = false } = {}) {
         fragmentShader: make_fragment_shader(),
         blending: CustomBlending,
         lights: lights,
-        depthTest: true,
+        /*
+         forcing transparent pass in Graphics Engine
+         three.js and indeed WebGL doesn't provide a way to pass depth buffer into the main draw pass (to canvas), so this is a workaround
+         */
+        depthTest: false,
         depthWrite: false,
         transparent: true,
         vertexColors: false,

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.39",
   "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();