@woosh/meep-engine 2.31.6 → 2.31.10

package/engine/ecs/EntityManager.js

@@ -204,22 +204,23 @@ EntityManager.prototype.entityExists = function (entityIndex) {
  * @param {Number} entityId
  * @param {Class} componentClass
  * @param {function} callback
+ * @param {*} [thisArg]
  */
-EntityManager.prototype.getComponentAsync = function (entityId, componentClass, callback) {
+EntityManager.prototype.getComponentAsync = function (entityId, componentClass, callback, thisArg) {
     const self = this;
     const component = this.getComponent(entityId, componentClass);
 
     function handler(options) {
         if (options.klass === componentClass) {
             self.removeEntityEventListener(entityId, EventType.ComponentAdded, handler);
-            callback(options.instance);
+            callback.call(thisArg, options.instance);
         }
     }
 
     if (component === void 0 || component === null) {
         this.addEntityEventListener(entityId, EventType.ComponentAdded, handler);
     } else {
-        callback(component);
+        callback.call(thisArg, component);
     }
 };
 

package/engine/graphics/ecs/mesh/Mesh.js

@@ -7,6 +7,9 @@ import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math
 import { getSkeletonBoneByType } from "./SkeletonUtils.js";
 import { assert } from "../../../../core/assert.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { updateNodeByTransformAndBBB } from "./updateNodeByTransformAndBBB.js";
+import { applyTransformToThreeObject } from "./applyTransformToThreeObject.js";
 
 /**
  *
@@ -27,6 +30,12 @@ const DEFAULT_FLAGS = 0;
  */
 const scratch_stack = [];
 
+/**
+ * @readonly
+ * @type {Transform}
+ */
+const scratch_transform = new Transform();
+
 class Mesh {
     constructor() {
         /**
@@ -63,7 +72,7 @@ class Mesh {
          * Managed by MeshSystem, do not change
          * @type {LeafNode}
          */
-        this.bvh = new LeafNode(null, 0, 0, 0, 0, 0, 0);
+        this.bvh = new LeafNode(this, 0, 0, 0, 0, 0, 0);
 
         /**
          * Initialized to size 1x1x1
@@ -78,6 +87,52 @@ class Mesh {
         this.flags = DEFAULT_FLAGS;
     }
 
+    /**
+     *
+     * @param {Transform} transform
+     */
+    internalApplyTransform(transform) {
+        assert.equal(transform.isTransform, true, 'transform.isTransform! == true');
+
+        if (!this.hasMesh()) {
+            // not loaded, can't apply anything
+            return;
+        }
+
+        /**
+         * @type {Transform}
+         */
+        let _t;
+
+        const asset = this.asset;
+
+        if (asset.has_root_transform) {
+            _t = scratch_transform;
+
+            _t.multiplyTransforms(transform, asset.root_transform);
+
+            // console.log("root transform");
+        } else {
+            _t = transform;
+        }
+
+        /**
+         *
+         * @type {Object3D}
+         */
+        const m = this.mesh;
+
+        applyTransformToThreeObject(m, _t);
+
+        //set bvh
+        updateNodeByTransformAndBBB(this.bvh, this.boundingBox, _t);
+
+        // micron
+        if (this.micron_mesh !== null) {
+            applyTransformToThreeObject(this.micron_mesh, _t);
+        }
+    }
+
     /**
      *
      * @param {AABB3} destination

package/engine/graphics/ecs/mesh/MeshSystem.js

@@ -13,10 +13,9 @@ import { Transform } from "../../../ecs/transform/Transform.js";
 import checkerTexture from "../../texture/CheckersTexture.js";
 
 import ThreeFactory from "../../three/ThreeFactory.js";
-import { applyTransform } from "./applyTransform.js";
 import { assetTypeByPath } from "./assetTypeByPath.js";
 import Mesh, { MeshFlags } from "./Mesh.js";
-import { setMesh } from "./setMesh.js";
+import { applyComponentPropertiesToThreeObject, setMesh } from "./setMesh.js";
 import { GLTFAssetLoader } from "../../../asset/loaders/GLTFAssetLoader.js";
 import { MeshEvents } from "./MeshEvents.js";
 import { MicronRenderPlugin } from "../../micron/plugin/MicronRenderPlugin.js";
@@ -103,15 +102,9 @@ export class MeshSystem extends System {
      */
     __set_mesh_from_asset(entity, dataset, asset, component) {
 
-        let mesh;
 
-        if (asset.micron !== undefined && this.__use_micron) {
-            mesh = asset.micron.clone();
-        } else {
-            mesh = asset.create();
-        }
+        const mesh = asset.create(); // remember the asset
 
-        // remember the asset
         component.asset = asset;
 
         if (asset.boundingBox !== undefined) {
@@ -131,8 +124,16 @@ export class MeshSystem extends System {
 
         component.setFlag(MeshFlags.Loaded);
 
+        // micron
+        if (asset.micron !== undefined && this.__use_micron) {
+            component.micron_mesh = asset.micron.clone();
+
+            applyComponentPropertiesToThreeObject(component, component.micron_mesh, entity);
+        }
+
         setMesh(dataset, entity, component, mesh);
 
+
         // send event about asset being attached
         dataset.sendEvent(entity, MeshEvents.AssetLoaded);
     }
@@ -155,6 +156,23 @@ export class MeshSystem extends System {
         const graphics = this.graphics;
         this.renderLayer = graphics.layers.create("mesh-system");
 
+        const extractRenderable = (component) => {
+            if (this.__use_micron && component.micron_mesh !== null) {
+                // use micron mesh
+                return component.micron_mesh;
+            } else {
+                // use standard mesh
+                return component.mesh;
+            }
+        };
+
+        /**
+         *
+         * @param {Mesh} component
+         * @return {Object3D|null}
+         */
+        this.renderLayer.extractRenderable = extractRenderable;
+
         this.bvh = this.renderLayer.bvh;
 
         const visibleSet = this.renderLayer.visibleSet;
@@ -257,7 +275,7 @@ export class MeshSystem extends System {
         this.process(entity, model);
 
         function apply_transform() {
-            applyTransform(model, transform);
+            model.internalApplyTransform(transform);
         }
 
         const bPosition = new SignalBinding(
@@ -407,11 +425,7 @@ export class MeshSystem extends System {
             }
         }
 
-        em.getComponentAsync(entity, Transform, function (t) {
-            if (component.hasMesh()) {
-                applyTransform(component, t);
-            }
-        });
+        em.getComponentAsync(entity, Transform, component.internalApplyTransform, component);
     }
 
     update(timeDelta) {

package/engine/graphics/ecs/mesh/applyTransformToThreeObject.js

@@ -0,0 +1,14 @@
+import { rootObject3DFastMatrixUpdate } from "./rootObject3DFastMatrixUpdate.js";
+
+/**
+ *
+ * @param {Object3D} m
+ * @param {Transform} t
+ */
+export function applyTransformToThreeObject(m, t) {
+    m.position.copy(t.position);
+    t.rotation.__setThreeEuler(m.rotation);
+    m.scale.copy(t.scale);
+
+    rootObject3DFastMatrixUpdate(m);
+}

package/engine/graphics/ecs/mesh/setMesh.js

@@ -1,46 +1,50 @@
 import { Transform } from "../../../ecs/transform/Transform.js";
-import { applyTransform } from "./applyTransform.js";
-import { setTransform } from "./setTransform.js";
 import { MeshEvents } from "./MeshEvents.js";
 
 /**
  *
- * @param {EntityComponentDataset} dataset
- * @param {number} entity
  * @param {Mesh} component
- * @param {Object3D} mesh
+ * @param {THREE.Object3D} mesh
+ * @param {number} entity
  */
-export function setMesh(dataset, entity, component, mesh) {
-
+export function applyComponentPropertiesToThreeObject(component, mesh, entity) {
     mesh.traverse(o => {
         o.castShadow = component.castShadow;
         o.receiveShadow = component.receiveShadow;
     });
 
-    let object = mesh;
-
     /*
         disable auto updates. We know when transform changes and thus we can avoid unnecessary matrix computations
         @see https://threejs.org/docs/index.html#api/core/Object3D.matrixWorldNeedsUpdate
      */
-    object.matrixWorldNeedsUpdate = false;
+    mesh.matrixWorldNeedsUpdate = false;
 
     if (component.opacity === 0) {
-        object.visible = false;
+        mesh.visible = false;
     }
 
-    object.__meep_ecs_component = component;
-    object.__meep_ecs_entity = entity;
+    mesh.__meep_ecs_component = component;
+    mesh.__meep_ecs_entity = entity;
+
+}
 
-    component.mesh = object;
-    component.bvh.object = component.mesh;
+/**
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @param {Mesh} component
+ * @param {Object3D} mesh
+ */
+export function setMesh(dataset, entity, component, mesh) {
+    applyComponentPropertiesToThreeObject(component, mesh, entity);
 
+    component.mesh = mesh;
 
     const transform = dataset.getComponent(entity, Transform);
 
     if (transform !== undefined) {
         // transform component found, apply transform
-        applyTransform( component,transform);
+        component.internalApplyTransform(transform);
     }
 
     // scene.add(object);

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

@@ -259,6 +259,9 @@ 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/graph/build_face_graph_from_mesh.js

@@ -2,68 +2,9 @@ import { Graph } from "../../../../../core/graph/v2/Graph.js";
 import { MultiNode } from "./MultiNode.js";
 import { compute_face_connection_weight } from "../clustering/compute_face_connection_weight.js";
 import { WeightedEdge } from "./WeightedEdge.js";
+import { graph_compute_disconnected_clusters } from "./graph_compute_disconnected_clusters.js";
 
 
-/**
- * @template T
- * @param {Graph<T>} graph
- * @returns {T[][]}
- */
-function graph_compute_disconnected_clusters(graph) {
-
-    // discover disconnected clusters
-    const unprocessed = new Set(graph.getNodes());
-
-    /**
-     *
-     * @type {T[][]}
-     */
-    const clusters = [];
-
-    while (unprocessed.size > 0) {
-        /**
-         *
-         * @type {T[]}
-         */
-        const cluster = [];
-
-        const next = unprocessed.values().next().value;
-
-        const open = [next];
-
-        while (open.length > 0) {
-            const node = open.pop();
-
-            unprocessed.delete(node);
-            cluster.push(node);
-
-            const container = graph.getNodeContainer(node);
-
-            const edges = container.getEdges();
-
-            const edge_count = edges.length;
-
-            for (let i = 0; i < edge_count; i++) {
-                const edge = edges[i];
-
-                const neighbour = edge.other(node);
-
-                if (!unprocessed.has(neighbour)) {
-                    continue;
-                }
-
-                unprocessed.delete(neighbour);
-
-                open.push(neighbour);
-            }
-        }
-
-        clusters.push(cluster);
-    }
-
-    return clusters;
-}
-
 /**
  * Given that the input graph is disconnected - makes it connected by adding very heavy edges between disconnected node clusters
  * If the graph is connected already - no change will be made

package/engine/graphics/micron/build/graph/graph_compute_disconnected_clusters.js

@@ -0,0 +1,59 @@
+/**
+ * @template T
+ * @param {Graph<T>} graph
+ * @returns {T[][]}
+ */
+export function graph_compute_disconnected_clusters(graph) {
+
+    // discover disconnected clusters
+    const unprocessed = new Set(graph.getNodes());
+
+    /**
+     *
+     * @type {T[][]}
+     */
+    const clusters = [];
+
+    while (unprocessed.size > 0) {
+        /**
+         *
+         * @type {T[]}
+         */
+        const cluster = [];
+
+        const next = unprocessed.values().next().value;
+
+        const open = [next];
+
+        while (open.length > 0) {
+            const node = open.pop();
+
+            unprocessed.delete(node);
+            cluster.push(node);
+
+            const container = graph.getNodeContainer(node);
+
+            const edges = container.getEdges();
+
+            const edge_count = edges.length;
+
+            for (let i = 0; i < edge_count; i++) {
+                const edge = edges[i];
+
+                const neighbour = edge.other(node);
+
+                if (!unprocessed.has(neighbour)) {
+                    continue;
+                }
+
+                unprocessed.delete(neighbour);
+
+                open.push(neighbour);
+            }
+        }
+
+        clusters.push(cluster);
+    }
+
+    return clusters;
+}

package/engine/graphics/micron/format/MicronGeometry.d.ts

@@ -0,0 +1,5 @@
+import {BufferGeometry} from "three";
+
+export class MicronGeometry {
+    public proxy: BufferGeometry
+}

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

@@ -46,6 +46,36 @@ export class MicronGeometry {
          * @private
          */
         this.__patches = [];
+
+        /**
+         * Physical proxy geometry, useful for raycasting and other spatial queries
+         * @type {THREE.BufferGeometry|null}
+         * @private
+         */
+        this.__proxy = null;
+    }
+
+    /**
+     * @param {THREE.BufferGeometry} geometry
+     */
+    set proxy(geometry) {
+        this.__proxy = geometry;
+    }
+
+    /**
+     *
+     * @return {THREE.BufferGeometry|null}
+     */
+    get proxy() {
+        return this.__proxy;
+    }
+
+    /**
+     * Build geometry proxy from the patches
+     * @param {number} percent percentage of the original geometry to keep
+     */
+    buildProxy(percent) {
+        throw new Error('Not Implemented');
     }
 
     computeByteSize() {

package/engine/graphics/micron/format/ThreeMicronMesh.d.ts

@@ -0,0 +1,10 @@
+import {Material, Object3D} from "three";
+import {MicronGeometry} from "./MicronGeometry";
+
+export class ThreeMicronMesh extends Object3D {
+    readonly instance_id: number
+    material: Material
+    geometry: MicronGeometry
+
+    readonly isMicronMesh: boolean
+}

package/engine/graphics/micron/render/VIRTUAL_MESH_FLAG.d.ts

@@ -0,0 +1 @@
+export const VIRTUAL_MESH_FLAG: string

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

@@ -0,0 +1 @@
+export const VIRTUAL_MESH_FLAG = '@meep/is-virtual';

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -1,8 +1,10 @@
 import { ThreeInstancedAdapter } from "../instanced/ThreeInstancedAdapter.js";
 import { composeCompile } from "../../../material/composeCompile.js";
 import { Mesh, MeshDepthMaterial, MeshNormalMaterial, RGBADepthPacking } from "three";
+import { VIRTUAL_MESH_FLAG } from "../VIRTUAL_MESH_FLAG.js";
 
 const MATERIAL_FLAG = '@micron_instanced_rewritten';
+const MATERIAL_VERTEX_DISPLACED = '@meep/vertex-displaced';
 
 export class MaterialContext {
     /**
@@ -73,6 +75,7 @@ export class MaterialContext {
         if (material[MATERIAL_FLAG] === undefined) {
             material.onBeforeCompile = composeCompile(material.onBeforeCompile, rewrite_material);
             material[MATERIAL_FLAG] = true;
+            material[MATERIAL_VERTEX_DISPLACED] = true;
         } else {
             throw new Error(`Material was already processed by micron, this is an illegal state`);
         }
@@ -82,6 +85,8 @@ export class MaterialContext {
 
         const m = new Mesh();
 
+        m[VIRTUAL_MESH_FLAG] = true;
+
         m.name = 'Materialized Micron Mesh';
 
         m.geometry = null;

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

@@ -59,11 +59,20 @@ class VisibleLeafCollector extends BVHVisitor {
 
         const object = leaf.object;
 
-        if (object !== null) {
-            this.count++;
-            const renderable = this.reader(object);
-            this.callback.call(this.callbackContext, renderable, leaf);
+        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);
     }
 }
 

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.31.6",
+  "version": "2.31.10",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",

package/engine/graphics/ecs/mesh/applyTransform.js

@@ -1,39 +0,0 @@
-import { Transform } from "../../../ecs/transform/Transform.js";
-import { setTransform } from "./setTransform.js";
-
-/**
- * @readonly
- * @type {Transform}
- */
-const scratch_transform = new Transform();
-
-/**
- *
- * @param {Mesh} component
- * @param {Transform} transform
- */
-export function applyTransform(component, transform) {
-    if (!component.hasMesh()) {
-        // not loaded, can't apply anything
-        return;
-    }
-
-    /**
-     * @type {Transform}
-     */
-    let _t;
-
-    const asset = component.asset;
-
-    if (asset.has_root_transform) {
-        _t = scratch_transform;
-
-        _t.multiplyTransforms(transform, asset.root_transform);
-
-        // console.log("root transform");
-    } else {
-        _t = transform;
-    }
-
-    setTransform(_t, component);
-}

package/engine/graphics/ecs/mesh/setMeshFromAsset.js

@@ -1,47 +0,0 @@
-import { MeshFlags } from "./Mesh.js";
-import { MeshEvents } from "./MeshEvents.js";
-import { setMesh } from "./setMesh.js";
-
-/**
- *
- * @param {number} entity
- * @param {EntityComponentDataset} dataset
- * @param {Asset} asset
- * @param {Mesh} component
- */
-export function setMeshFromAsset(entity, dataset, asset, component) {
-
-    let mesh;
-
-    if (asset.micron !== undefined) {
-        mesh = asset.micron.clone();
-    } else {
-        mesh = asset.create();
-    }
-
-    // remember the asset
-    component.asset = asset;
-
-    if (asset.boundingBox !== undefined) {
-        component.boundingBox.copy(asset.boundingBox);
-    } else if (mesh.isMesh) {
-        const geometry = mesh.geometry;
-        const bb = geometry.boundingBox;
-        component.boundingBox.setBounds(
-            bb.min.x,
-            bb.min.y,
-            bb.min.z,
-            bb.max.x,
-            bb.max.y,
-            bb.max.z
-        );
-    }
-
-    component.setFlag(MeshFlags.Loaded);
-
-    setMesh(dataset, entity, component, mesh);
-
-    // send event about asset being attached
-    dataset.sendEvent(entity, MeshEvents.AssetLoaded);
-
-}

package/engine/graphics/ecs/mesh/setTransform.js

@@ -1,30 +0,0 @@
-import { updateMeshTransform } from "./updateMeshTransform.js";
-import { updateNodeByTransformAndBBB } from "./updateNodeByTransformAndBBB.js";
-
-/**
- *
- * @param {Transform} t
- * @param {Mesh} component
- */
-export function setTransform(t, component) {
-    /**
-     *
-     * @type {Object3D}
-     */
-    const m = component.mesh;
-
-    /**
-     *
-     * @type {Vector3}
-     */
-    const position = t.position;
-
-    m.position.copy(position);
-    t.rotation.__setThreeEuler(m.rotation);
-    m.scale.copy(t.scale);
-
-    updateMeshTransform(component);
-
-    //set bvh
-    updateNodeByTransformAndBBB(component.bvh, component.boundingBox, t);
-}