@woosh/meep-engine 2.34.49 → 2.35.2

package/engine/ecs/transform/Transform.js

@@ -4,14 +4,16 @@
 
 import Vector3 from "../../../core/geom/Vector3.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
-import { Matrix4 } from "../../../core/geom/Matrix4.js";
 import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
 import { decompose_matrix_4_array } from "../../graphics/util/decompose_matrix_4_array.js";
+import { mat4 } from "gl-matrix";
 
 const delta = new Vector3();
 
-const m4_0 = new Matrix4();
-const m4_1 = new Matrix4();
+const scratch_buffer = new ArrayBuffer(32 * 4);
+
+const m4_0 = new Float32Array(scratch_buffer, 0, 16);
+const m4_1 = new Float32Array(scratch_buffer, 64, 16)
 
 export class Transform {
     /**
@@ -152,12 +154,12 @@ export class Transform {
      * @param {Transform} b
      */
     multiplyTransforms(a, b) {
-        m4_0.compose(a.position, a.rotation, a.scale);
-        m4_1.compose(b.position, b.rotation, b.scale);
+        compose_matrix4_array(m4_0, a.position, a.rotation, a.scale);
+        compose_matrix4_array(m4_1, b.position, b.rotation, b.scale);
 
-        m4_0.multiplyMatrices(m4_0, m4_1);
+        mat4.multiply(m4_0, m4_0, m4_1);
 
-        m4_0.decompose(this.position, this.rotation, this.scale);
+        this.fromMatrix4(m4_0);
     }
 
     /**
@@ -170,18 +172,18 @@ export class Transform {
 
     /**
      *
-     * @param {mat4|number[]|Float32Array} m
+     * @param {Matrix4} matrix
      */
-    fromMatrix4(m) {
-        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
+    toThreeMatrix(matrix) {
+        this.toMatrix4(matrix.elements);
     }
 
     /**
      *
-     * @param {Matrix4} matrix
+     * @param {mat4|number[]|Float32Array} m
      */
-    toThreeMatrix(matrix) {
-        this.toMatrix4(matrix.elements);
+    fromMatrix4(m) {
+        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
     }
 
     /**

package/engine/graphics/ecs/highlight/system/ShadedGeometryHighlightSystem.js

@@ -3,6 +3,7 @@ import { HighlightRenderElementSource } from "../plugin/HighlightRenderElementSo
 import Highlight from "../Highlight.js";
 import { OutlineRenderPlugin } from "../plugin/OutlineRenderPlugin.js";
 import { ShadedGeometry } from "../../mesh-v2/ShadedGeometry.js";
+import { build_three_object } from "../../mesh-v2/build_three_object.js";
 
 class Supplier extends HighlightRenderElementSource {
     /**
@@ -31,6 +32,13 @@ class Supplier extends HighlightRenderElementSource {
          * @private
          */
         this.__group = null;
+
+        /**
+         *
+         * @type {WeakMap<ShadedGeometry, THREE.Object3D>}
+         * @private
+         */
+        this.__object_cache = new WeakMap();
     }
 
     collect(pool, group) {
@@ -77,13 +85,14 @@ class Supplier extends HighlightRenderElementSource {
             return;
         }
 
-        const object = sg.__cached_object;
+        let object = this.__object_cache.get(sg);
 
-        if (object === null) {
-            // no renderable primitive
-            return;
+        if(object === undefined){
+            object = build_three_object(sg);
         }
 
+        object.matrixWorld.elements = sg.transform;
+
         const renderElement = this.__pool.create();
 
         renderElement.definitions = elements.asArray();

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

@@ -1,9 +1,7 @@
-import { Line, LineSegments, Mesh } from "three";
 import { updateNodeByMatrix4AndBBB } from "../mesh/updateNodeByTransformAndBBB.js";
 import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { DrawMode } from "./DrawMode.js";
-import { applyTransformToThreeObject } from "../mesh/applyTransformToThreeObject.js";
 import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 
 const _aabb3 = new AABB3();
@@ -31,13 +29,6 @@ export class ShadedGeometry {
          */
         this.mode = DrawMode.Triangles;
 
-        /**
-         *
-         * @type {THREE.Object3D|null}
-         * @private
-         */
-        this.__cached_object = null;
-
         /**
          *
          * @type {LeafNode<ShadedGeometry>}
@@ -51,13 +42,27 @@ export class ShadedGeometry {
          * @private
          */
         this.__entity = -1;
+
+        /**
+         *
+         * @type {Transform|null}
+         * @private
+         */
+        this.__c_transform = null;
+
         /**
          * Transform matrix
          * Transient, assigned in the system
          * @type {number[]|null}
          * @private
          */
-        this.__transform = null;
+        this.__transform = new Float32Array(16);
+
+        /**
+         * Transient property signifying how to render object
+         * @type {number}
+         */
+        this.draw_method = 0;
 
         /**
          *
@@ -66,6 +71,14 @@ export class ShadedGeometry {
         this.flags = DEFAULT_FLAGS;
     }
 
+    /**
+     * @deprecated
+     * @private
+     */
+    get __cached_object(){
+        throw new Error('Deprecated');
+    }
+
     /**
      *
      * @param {number|ShadedGeometryFlags} flag
@@ -106,6 +119,25 @@ export class ShadedGeometry {
         return (this.flags & flag) === flag;
     }
 
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return this.geometry.id ^ this.material.id;
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.geometry.id === other.geometry.id
+            && this.material.id === other.material.id
+            ;
+    }
+
     /**
      * Current cached entity that this component is attached to
      * @return {number}
@@ -120,42 +152,7 @@ export class ShadedGeometry {
      * @return {null|number[]}
      */
     get transform() {
-        if (this.__transform !== null) {
-            return this.__transform;
-        } else if (this.__cached_object !== null) {
-            return this.__cached_object.matrix.elements;
-        } else {
-            return null;
-        }
-    }
-
-    __build_object() {
-        /**
-         * @type {THREE.Object3D}
-         */
-        let object;
-
-        const mode = this.mode;
-        const shader = this.material;
-        const geo = this.geometry;
-
-        if (mode === DrawMode.Triangles) {
-            object = new Mesh(geo, shader);
-        } else if (mode === DrawMode.Lines) {
-            object = new Line(geo, shader);
-        } else if (mode === DrawMode.LineSegments) {
-            object = new LineSegments(geo, shader);
-        } else {
-            throw new Error(`Unsupported draw mode '${mode}'`);
-        }
-
-        object.matrixAutoUpdate = false;
-        object.frustumCulled = false;
-
-        object.castShadow = this.getFlag(ShadedGeometryFlags.CastShadow);
-        object.receiveShadow = this.getFlag(ShadedGeometryFlags.ReceiveShadow);
-
-        this.__cached_object = object;
+        return this.__transform;
     }
 
     get bvh() {
@@ -177,13 +174,6 @@ export class ShadedGeometry {
         if (geometry.boundingBox === null) {
             geometry.computeBoundingBox();
         }
-
-        if (this.__cached_object === null) {
-            this.__build_object();
-        } else {
-            this.__cached_object.material = material;
-            this.__cached_object.geometry = geometry;
-        }
     }
 
     /**
@@ -202,11 +192,8 @@ export class ShadedGeometry {
     }
 
     updateTransform() {
-        const object_3d = this.__cached_object;
-
-        // update matrix
-        object_3d.updateMatrix();
-        object_3d.updateMatrixWorld();
+        //
+        this.__c_transform.toMatrix4(this.__transform);
 
         // update bounds
         const gbb = this.geometry.boundingBox;
@@ -223,56 +210,7 @@ export class ShadedGeometry {
             max.z
         );
 
-        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, object_3d.matrix.elements);
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setPositionByComponents(x, y, z) {
-
-        this.__cached_object.position.set(x, y, z);
-
-        this.updateTransform();
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} w
-     */
-    setRotationByComponents(x, y, z, w) {
-
-        this.__cached_object.quaternion.set(x, y, z, w);
-
-        this.updateTransform();
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setScaleByComponents(x, y, z) {
-        this.__cached_object.scale.set(x, y, z);
-
-        this.updateTransform();
-    }
-
-    /**
-     *
-     * @param {Transform} t
-     */
-    applyTransform(t) {
-        applyTransformToThreeObject(this.__cached_object, t);
-
-        this.updateTransform();
+        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, this.__transform);
     }
 }
 

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

@@ -7,6 +7,8 @@ import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
 import { mat4 } from "gl-matrix";
 import { returnTrue } from "../../../../core/function/Functions.js";
 import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
+import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererContext.js";
+import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
 
 /**
  *
@@ -54,14 +56,72 @@ export class ShadedGeometrySystem extends System {
          * @private
          */
         this.__render_layer = null;
+
+        /**
+         *
+         * @type {Map<CameraView, ShadedGeometryRendererContext>}
+         * @private
+         */
+        this.__view_contexts = new Map();
+
+        this.__bvh = new BinaryNode();
+        this.__bvh.setNegativelyInfiniteBounds();
+    }
+
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_added(view) {
+        this.__view_contexts.set(view, new ShadedGeometryRendererContext());
+    }
+
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_removed(view) {
+        const ctx = this.__view_contexts.get(view);
+
+        this.__view_contexts.delete(view);
+
+        ctx.dispose();
     }
 
     async startup(entityManager, readyCallback, errorCallback) {
 
         const engine = this.__engine;
+        const graphics = engine.graphics;
+
+        const view_list = graphics.views.elements;
+
+        view_list.forEach(this.__handle_view_added, this);
+        view_list.on.added.add(this.__handle_view_added, this);
+        view_list.on.removed.add(this.__handle_view_removed, this);
 
-        this.__render_layer = engine.graphics.layers.create('shaded-geometry');
-        this.__render_layer.extractRenderable = (sg) => sg.__cached_object;
+        this.__render_layer = graphics.layers.create('shaded-geometry');
+
+        this.__render_layer.buildVisibleSet = ((destination, destination_offset, view) => {
+            const ctx = this.__view_contexts.get(view);
+
+            return ctx.collect(destination, destination_offset, view, this.__bvh);
+        });
+
+        readyCallback();
+    }
+
+    async shutdown(entityManager, readyCallback, errorCallback) {
+
+        const engine = this.__engine;
+        const graphics = engine.graphics;
+
+        const view_list = graphics.views.elements;
+
+        view_list.forEach(this.__handle_view_removed, this);
+        view_list.on.added.remove(this.__handle_view_added, this);
+        view_list.on.removed.remove(this.__handle_view_removed, this);
 
         readyCallback();
     }
@@ -73,11 +133,13 @@ export class ShadedGeometrySystem extends System {
      * @param {number} entity
      */
     link(sg, t, entity) {
-        t.position.onChanged.add(sg.setPositionByComponents, sg);
-        t.rotation.onChanged.add(sg.setRotationByComponents, sg);
-        t.scale.onChanged.add(sg.setScaleByComponents, sg);
+        sg.__c_transform = t;
+
+        t.position.onChanged.add(sg.updateTransform, sg);
+        t.rotation.onChanged.add(sg.updateTransform, sg);
+        t.scale.onChanged.add(sg.updateTransform, sg);
 
-        sg.applyTransform(t);
+        sg.updateTransform();
 
         const leaf_node = sg.bvh;
 
@@ -87,7 +149,7 @@ export class ShadedGeometrySystem extends System {
         // remember entity for lookups
         sg.__entity = entity;
 
-        this.__render_layer.bvh.insertNode(leaf_node);
+        this.__bvh.insertNode(leaf_node);
     }
 
     /**
@@ -97,9 +159,9 @@ export class ShadedGeometrySystem extends System {
      * @param {number} entity
      */
     unlink(sg, t, entity) {
-        t.position.onChanged.remove(sg.setPositionByComponents, sg);
-        t.rotation.onChanged.remove(sg.setRotationByComponents, sg);
-        t.scale.onChanged.remove(sg.setScaleByComponents, sg);
+        t.position.onChanged.remove(sg.updateTransform, sg);
+        t.rotation.onChanged.remove(sg.updateTransform, sg);
+        t.scale.onChanged.remove(sg.updateTransform, sg);
 
         sg.bvh.disconnect();
     }

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

@@ -0,0 +1,39 @@
+import { DrawMode } from "./DrawMode.js";
+import { Line, LineSegments, Mesh } from "three";
+import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
+
+/**
+ *
+ * @param {ShadedGeometry} sg
+ * @returns {THREE.Object3D}
+ */
+export function build_three_object(sg) {
+
+    /**
+     * @type {THREE.Object3D}
+     */
+    let object;
+
+    const mode = sg.mode;
+    const shader = sg.material;
+    const geo = sg.geometry;
+
+    if (mode === DrawMode.Triangles) {
+        object = new Mesh(geo, shader);
+    } else if (mode === DrawMode.Lines) {
+        object = new Line(geo, shader);
+    } else if (mode === DrawMode.LineSegments) {
+        object = new LineSegments(geo, shader);
+    } else {
+        throw new Error(`Unsupported draw mode '${mode}'`);
+    }
+
+    object.matrixAutoUpdate = false;
+    object.frustumCulled = false;
+    object.matrixWorldNeedsUpdate = false;
+
+    object.castShadow = sg.getFlag(ShadedGeometryFlags.CastShadow);
+    object.receiveShadow = sg.getFlag(ShadedGeometryFlags.ReceiveShadow);
+
+    return object;
+}

package/engine/graphics/ecs/mesh-v2/render/AbstractRenderAdapter.js

@@ -0,0 +1,67 @@
+export class AbstractRenderAdapter {
+    constructor() {
+
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__object_count = 0;
+
+        /**
+         *
+         * @type {THREE.Object3D[]}
+         * @protected
+         */
+        this.__objects = [];
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     * @param {THREE.Material} material
+     * @returns {number}
+     */
+    score(geometry, material) {
+        return 0;
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     * @returns {void}
+     */
+    add(sg) {
+        throw new Error('Not Implemented');
+    }
+
+    build_start() {
+
+    }
+
+    build_end() {
+
+    }
+
+    clear() {
+        this.__object_count = 0;
+    }
+
+    /**
+     * @returns {THREE.Object3D[]}
+     */
+    get objects() {
+        return this.__objects;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get object_count() {
+        return this.__object_count;
+    }
+
+    dispose() {
+
+    }
+}

package/engine/graphics/ecs/mesh-v2/render/GenericRendererAdapter.js

@@ -0,0 +1,48 @@
+import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
+import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+import { build_three_object } from "../build_three_object.js";
+
+export class GenericRendererAdapter extends AbstractRenderAdapter {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {Cache<ShadedGeometry, THREE.Object3D>}
+         * @private
+         */
+        this.__cache = new WeakMap();
+    }
+
+
+    score(geometry, material) {
+        return 0;
+    }
+
+    build_start() {
+        this.clear();
+    }
+
+    add(sg) {
+        const cache = this.__cache;
+
+        /**
+         *
+         * @type {THREE.Object3D}
+         */
+        let object = cache.get(sg);
+
+        if (object === undefined) {
+
+            object = build_three_object(sg);
+
+            cache.set(sg, object);
+
+        }
+
+        array_copy(sg.__transform, 0, object.matrixWorld.elements, 0, 16);
+
+        this.__objects[this.__object_count++] = object;
+    }
+
+}