@woosh/meep-engine 2.39.13 → 2.39.16

package/engine/ecs/transform-attachment/TransformAttachmentSystem.js

@@ -1,6 +1,13 @@
 import { System } from "../System.js";
 import { TransformAttachment, TransformAttachmentFlags } from "./TransformAttachment.js";
 import { Transform } from "../transform/Transform.js";
+import { min2 } from "../../../core/math/min2.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const QUEUE_ITERATION_COUNT = 32;
 
 class UpdateContext {
     constructor() {
@@ -27,22 +34,63 @@ class UpdateContext {
          * @type {Transform|null}
          */
         this.parent_transform = null;
+
+        /**
+         *
+         * @type {EntityComponentDataset|null}
+         */
+        this.ecd = null;
+    }
+
+    toString() {
+        return `UpdateContext{ attachment:${this.attachment}, entity:${this.entity} }`;
     }
 
     update() {
         this.transform.multiplyTransforms(this.parent_transform, this.attachment.transform);
     }
 
+    /**
+     *
+     * @returns {boolean}
+     */
+    bind_parent() {
+
+        const parent_transform = this.ecd.getComponent(this.attachment.parent, Transform);
+
+        if (parent_transform === undefined) {
+            return false;
+        }
+
+        this.parent_transform = parent_transform;
+
+        return true;
+    }
+
     link() {
-        this.parent_transform.position.onChanged.add(this.update, this);
-        this.parent_transform.rotation.onChanged.add(this.update, this);
-        this.parent_transform.scale.onChanged.add(this.update, this);
+        const t_parent = this.parent_transform;
+
+        t_parent.position.onChanged.add(this.update, this);
+        t_parent.rotation.onChanged.add(this.update, this);
+        t_parent.scale.onChanged.add(this.update, this);
+
+        const t_attachment = this.attachment.transform;
+        t_attachment.position.onChanged.add(this.update,this);
+        t_attachment.rotation.onChanged.add(this.update,this);
+        t_attachment.scale.onChanged.add(this.update,this);
     }
 
     unlink() {
-        this.parent_transform.position.onChanged.remove(this.update, this);
-        this.parent_transform.rotation.onChanged.remove(this.update, this);
-        this.parent_transform.scale.onChanged.remove(this.update, this);
+        const transform = this.parent_transform;
+
+        transform.position.onChanged.remove(this.update, this);
+        transform.rotation.onChanged.remove(this.update, this);
+        transform.scale.onChanged.remove(this.update, this);
+
+        const t_attachment = this.attachment.transform;
+        t_attachment.position.onChanged.remove(this.update,this);
+        t_attachment.rotation.onChanged.remove(this.update,this);
+        t_attachment.scale.onChanged.remove(this.update,this);
     }
 }
 
@@ -58,6 +106,54 @@ export class TransformAttachmentSystem extends System {
          * @private
          */
         this.__contexts = [];
+
+        /**
+         *
+         * @type {UpdateContext[]}
+         * @private
+         */
+        this.__queue = [];
+        this.__queue_size = 0;
+        this.__queue_cursor = 0;
+    }
+
+    /**
+     *
+     * @param {UpdateContext} ctx
+     * @private
+     */
+    __finalize_link(ctx) {
+
+        ctx.link();
+
+        this.__contexts[ctx.entity] = ctx;
+
+        if ((ctx.attachment.flags & TransformAttachmentFlags.Immediate) !== 0) {
+            ctx.update();
+        }
+    }
+
+    /**
+     *
+     * @param {UpdateContext} ctx
+     * @private
+     */
+    __enqueue(ctx) {
+        this.__queue[this.__queue_size++] = ctx;
+    }
+
+    __dequeue_entity(entity) {
+        for (let i = 0; i < this.__queue_size; i++) {
+            const ctx = this.__queue[i];
+
+            if (ctx.entity === entity) {
+                this.__queue.splice(i, 1);
+                this.__queue_size--;
+                return true;
+            }
+        }
+
+        return false;
     }
 
     /**
@@ -68,22 +164,23 @@ export class TransformAttachmentSystem extends System {
      */
     link(attachment, transform, entity) {
         const ctx = new UpdateContext();
-        ctx.system = this;
 
         ctx.attachment = attachment;
         ctx.transform = transform;
         ctx.entity = entity;
 
 
-        ctx.parent_transform = this.entityManager.dataset.getComponent(attachment.parent, Transform);
+        const ecd = this.entityManager.dataset;
 
-        ctx.link();
-
-        this.__contexts[entity] = ctx;
+        ctx.ecd = ecd;
 
-        if ((attachment.flags & TransformAttachmentFlags.Immediate) !== 0) {
-            ctx.update();
+        if (ctx.bind_parent()) {
+            this.__finalize_link(ctx);
+        } else {
+            // failed to bind parent, queue up instead
+            this.__enqueue(ctx);
         }
+
     }
 
     /**
@@ -93,12 +190,37 @@ export class TransformAttachmentSystem extends System {
      * @param {number} entity
      */
     unlink(attachment, transform, entity) {
+        const ctx = this.__contexts[entity];
 
+        if (ctx !== undefined) {
 
-        const ctx = this.__contexts[entity];
+            delete this.__contexts[entity];
 
-        delete this.__contexts[entity];
+            ctx.unlink();
+
+        } else {
+            // no context found, check the queue
+            this.__dequeue_entity(entity);
+        }
 
-        ctx.unlink();
+    }
+
+    update(timeDelta) {
+        const step_count = min2(this.__queue_size, QUEUE_ITERATION_COUNT);
+        for (let i = 0; i < step_count; i++) {
+            const index = this.__queue_cursor % this.__queue_size;
+
+            const ctx = this.__queue[index];
+
+            if (ctx.bind_parent()) {
+                this.__finalize_link(ctx);
+
+                this.__queue.splice(index, 1);
+                this.__queue_size--;
+
+            } else {
+                this.__queue_cursor++;
+            }
+        }
     }
 }

package/engine/graphics/FrameRunner.js

@@ -1,3 +1,5 @@
+let global_count = 0;
+
 /**
  *
  */
@@ -33,7 +35,9 @@ export class FrameRunner {
             return false;
         }
 
-        console.warn("FrameFunner.started");
+        console.warn(`FrameFunner.started[${global_count}]`);
+
+        global_count++;
 
         this.running = true;
 
@@ -66,7 +70,9 @@ export class FrameRunner {
             return false;
         }
 
-        console.warn("FrameFunner.stopped");
+        global_count--;
+
+        console.warn(`FrameFunner.stopped[${global_count}]`);
 
         this.running = false;
         cancelAnimationFrame(this.animationFrameId);

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

@@ -1,3 +1,7 @@
+/**
+ *
+ * @enum {number}
+ */
 export const DrawMode = {
     Triangles: 0,
     Lines: 2,

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

@@ -3,6 +3,9 @@ import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { DrawMode } from "./DrawMode.js";
 import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { mat4 } from "gl-matrix";
+import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { GeometrySpatialQueryAccelerator } from "../../geometry/buffered/query/GeometrySpatialQueryAccelerator.js";
 
 /**
  * @readonly
@@ -12,12 +15,27 @@ const scratch_aabb3_array = new Float32Array(6);
 
 const DEFAULT_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
+    | ShadedGeometryFlags.Visible
 ;
 
 const FLAG_SET_EQUALITY = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
+    | ShadedGeometryFlags.DrawMethodLocked
+    | ShadedGeometryFlags.Visible
 ;
 
+/**
+ *
+ * @type {Float32Array|mat4}
+ */
+const scratch_m4 = new Float32Array(16);
+
+/**
+ * @readonly
+ * @type {Float32Array}
+ */
+const scratch_ray_0 = new Float32Array(6);
+
 export class ShadedGeometry {
     constructor() {
         /**
@@ -160,6 +178,30 @@ export class ShadedGeometry {
             ;
     }
 
+    /**
+     *
+     * @param {ShadedGeometry} other
+     */
+    copy(other) {
+        this.geometry = other.geometry;
+        this.material = other.material;
+        this.draw_method = other.draw_method;
+        this.mode = other.mode;
+        this.flags = other.flags;
+    }
+
+    /**
+     *
+     * @returns {ShadedGeometry}
+     */
+    clone() {
+        const r = new ShadedGeometry();
+
+        r.copy(this);
+
+        return r;
+    }
+
     /**
      * Current cached entity that this component is attached to
      * @return {number}
@@ -251,6 +293,41 @@ export class ShadedGeometry {
 
         aabb3_matrix4_project(this.__bvh_aabb, scratch_aabb3_array, this.transform);
     }
+
+    /**
+     *
+     * @param {SurfacePoint3} contact if found, contact is written here
+     * @param {ArrayLike<number>|number[]|Float32Array} ray 6-tuple: [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+     * @param {ArrayLike<number>|number[]|Float32Array} transform_matrix4
+     * @returns {boolean}
+     */
+    query_raycast_nearest(contact, ray, transform_matrix4) {
+
+        // get transform in local space
+        mat4.invert(scratch_m4, transform_matrix4);
+
+        // transform ray to local space
+        if (!ray3_array_apply_matrix4(scratch_ray_0, ray, scratch_m4)) {
+            // invalid transform matrix
+            return false;
+        }
+
+        const hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
+            contact,
+            this.geometry,
+            scratch_ray_0
+        );
+
+        if (!hit_found) {
+            return false;
+        }
+
+        // transform hit contact into global space
+        contact.applyMatrix4(transform_matrix4);
+
+        return true;
+
+    }
 }
 
 /**

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

@@ -7,4 +7,14 @@ export const ShadedGeometryFlags = {
 
     CastShadow: 2,
     ReceiveShadow: 4,
+
+    /**
+     * Draw method is not allowed to change if this is on
+     */
+    DrawMethodLocked: 8,
+
+    /**
+     * If set to false will not render
+     */
+    Visible:16
 };

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

@@ -1,7 +1,6 @@
 import { ShadedGeometry } from "./ShadedGeometry.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { System } from "../../../ecs/System.js";
-import { GeometrySpatialQueryAccelerator } from "../../geometry/buffered/query/GeometrySpatialQueryAccelerator.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
 import { mat4 } from "gl-matrix";
@@ -9,7 +8,6 @@ import { returnTrue } from "../../../../core/function/Functions.js";
 import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererContext.js";
 import { assert } from "../../../../core/assert.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
-import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
 import {
     ExplicitBinaryBoundingVolumeHierarchy
 } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
@@ -382,31 +380,18 @@ export class ShadedGeometrySystem extends System {
 
             const m4 = sg.transform;
 
-            // get transform in local space
-            mat4.invert(scratch_m4, m4);
-
             ray3_array_compose(
                 scratch_ray_0,
                 origin_x, origin_y, origin_z,
                 direction_x, direction_y, direction_z
             );
 
-            // transform ray to local space
-            ray3_array_apply_matrix4(scratch_ray_0, scratch_ray_0, scratch_m4);
-
-            const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
-                scratch_point,
-                sg.geometry,
-                scratch_ray_0
-            );
+            const geometry_hit_found = sg.query_raycast_nearest(scratch_point,scratch_ray_0,m4);
 
             if (!geometry_hit_found) {
                 continue;
             }
 
-            // transform hit contact into global space
-            scratch_point.applyMatrix4(m4);
-
             result.push({
                 entity,
                 mesh: sg,
@@ -476,31 +461,18 @@ export class ShadedGeometrySystem extends System {
              */
             const m4 = sg.transform;
 
-            // get transform in local space
-            mat4.invert(scratch_m4, m4);
-
             ray3_array_compose(
                 scratch_ray_0,
                 origin_x, origin_y, origin_z,
                 direction_x, direction_y, direction_z
             );
 
-            // transform ray to local space
-            ray3_array_apply_matrix4(scratch_ray_0, scratch_ray_0, scratch_m4);
-
-            const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
-                scratch_point,
-                sg.geometry,
-                scratch_ray_0
-            );
+            const geometry_hit_found = sg.query_raycast_nearest(scratch_point,scratch_ray_0,m4);
 
             if (!geometry_hit_found) {
                 continue;
             }
 
-            // transform hit contact into global space
-            scratch_point.applyMatrix4(m4);
-
             found_hit = true;
 
             const hit_position = scratch_point.position;

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

@@ -6,6 +6,7 @@ import { ShadedGeometry } from "../ShadedGeometry.js";
 import {
     bvh_query_user_data_overlaps_frustum
 } from "../../../../../core/bvh2/bvh3/bvh_query_user_data_overlaps_frustum.js";
+import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
 
 /**
  *
@@ -104,6 +105,16 @@ export class ShadedGeometryRendererContext {
              */
             const sg = ecd.getComponentByIndex(entity, sg_component_index);
 
+            if ((sg.flags & ShadedGeometryFlags.Visible) === 0) {
+                // not visible
+                continue;
+            }
+
+            if (!sg.material.visible) {
+                // material is not visible, skip
+                continue;
+            }
+
             const adapter = adapters[sg.draw_method];
 
             adapter.add(sg);

package/engine/graphics/ecs/mesh-v2/render/adapters/InstancedRendererAdapter.js

@@ -9,36 +9,6 @@ const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
 
-/**
- *
- * @param {ShadedGeometry} a
- * @param {ShadedGeometry} b
- * @returns {number}
- */
-function compare(a, b) {
-    const d_geometry = a.geometry.id - b.geometry.id;
-    if (d_geometry !== 0) {
-        return d_geometry;
-    }
-
-    const d_material = a.material.id - b.material.id;
-    if (d_material !== 0) {
-        return d_material;
-    }
-
-    const d_flags = (a.flags & INSTANCED_EQUALITY_FLAGS) - (b.flags & INSTANCED_EQUALITY_FLAGS);
-    if (d_flags !== 0) {
-        return d_flags;
-    }
-
-    const d_mode = a.mode - b.mode;
-    if (d_mode !== 0) {
-        return d_mode;
-    }
-
-    return 0;
-}
-
 export class InstancedRendererAdapter extends AbstractRenderAdapter {
     constructor() {
         super();
@@ -159,17 +129,23 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
     clear() {
         super.clear();
 
-        for (const activeMesh of this.__active_meshes) {
+        const meshes = this.__active_meshes;
+
+        for (const activeMesh of meshes) {
             activeMesh.setCount(0);
         }
 
-        this.__active_meshes.clear();
+        meshes.clear();
     }
 
     dispose() {
+        this.clear();
+
         // release GPU memory
         this.__instanced_meshes.forEach((value, key) => {
             value.dispose();
         });
+
+        this.__instanced_meshes.clear();
     }
 }

package/engine/graphics/ecs/mesh-v2/render/optimization/RuntimeDrawMethodOptimizer.js

@@ -1,4 +1,5 @@
 import { ShadedGeometry } from "../../ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../ShadedGeometryFlags.js";
 
 export class RuntimeDrawMethodOptimizer {
     constructor() {
@@ -70,6 +71,11 @@ export class RuntimeDrawMethodOptimizer {
             return false;
         }
 
+        if (sg.getFlag(ShadedGeometryFlags.DrawMethodLocked)) {
+            // draw mode is locked, can't change
+            return false;
+        }
+
         const use_count = system.getGeometryUsageCounters().get(sg.geometry.id);
 
         /**

package/engine/graphics/geometry/buffered/makeGeometryIndexed.js

@@ -0,0 +1,23 @@
+import { Float32BufferAttribute } from "three";
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ */
+export function makeGeometryIndexed(geometry) {
+    let index_attribute = geometry.getIndex();
+
+    if (index_attribute === null || index_attribute === undefined) {
+        const position_attribute = geometry.getAttribute('position');
+        // non-indexed geometry, build index
+        const array = new Float32Array(position_attribute.count * 3);
+
+        for (let i = 0; i < array.length; i++) {
+            array[i] = i;
+        }
+
+        index_attribute = new Float32BufferAttribute(array, 1, false);
+
+        geometry.setIndex(index_attribute);
+    }
+}

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -1,5 +1,5 @@
 import { Cache } from "../../../../../core/cache/Cache.js";
-import { buildUnsorted } from "../../bvh/buffered/BinaryBVHFromBufferGeometry.js";
+import { buildUnsorted, buildUnsortedUnindexed } from "../../bvh/buffered/BinaryBVHFromBufferGeometry.js";
 import { ClippingPlaneContainmentComputingVisitor } from "./ClippingPlaneContainmentComputingVisitor.js";
 import { RaycastNearestHitComputingVisitor } from "./RaycastNearestHitComputingVisitor.js";
 import { assert } from "../../../../../core/assert.js";
@@ -93,7 +93,15 @@ export class GeometrySpatialQueryAccelerator {
         assert.notNull(geometry, 'geometry');
         assert.defined(geometry, 'geometry');
 
-        const bvh = this.__acquireBVH(geometry);
+
+        let bvh;
+
+        try {
+            bvh = this.__acquireBVH(geometry);
+        } catch (e) {
+            console.error(e);
+            return false;
+        }
 
         this.__visitor_raycast.reset();
 
@@ -174,9 +182,13 @@ export class GeometrySpatialQueryAccelerator {
         const index_attribute = geometry.getIndex();
 
         const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
-        const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);
-
         const vertices = de_interleaved_position_attribute.array;
+
+        if(index_attribute === undefined || index_attribute === null){
+            return buildUnsortedUnindexed(vertices);
+        }
+
+        const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);
         const indices = de_interleaved_index_attribute.array;
 
         return buildUnsorted(vertices, indices);

package/engine/graphics/geometry/buffered/query/GeometryVisitor.js

@@ -60,7 +60,14 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor {
     setGeometry(geometry) {
         this.geometry = geometry;
 
-        this.__buffer_indices = geometry.getIndex().array;
+        const index_attribute = geometry.getIndex();
+
+        if (index_attribute) {
+            this.__buffer_indices = index_attribute.array;
+        } else {
+            // no index attribute
+            this.__buffer_indices = null;
+        }
 
         const position_attribute = geometry.getAttribute('position');
 

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -110,11 +110,20 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             const indices = this.__buffer_indices;
 
-            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
-
-            const a = indices[index3];
-            const b = indices[index3 + 1];
-            const c = indices[index3 + 2];
+            let a, b, c;
+
+            if(indices !== null) {
+                assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
+                a = indices[index3];
+                b = indices[index3 + 1];
+                c = indices[index3 + 2];
+            }else{
+                // implicit indices
+                a = index3;
+                b = index3+1;
+                c = index3+2;
+            }
 
             const vertices = this.__buffer_vertices;