@woosh/meep-engine 2.39.15 → 2.39.18

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;
 

package/engine/graphics/geometry/bvh/buffered/BinaryBVHFromBufferGeometry.js

@@ -62,6 +62,62 @@ function buildUnsorted(vertices, indices) {
     return tree;
 }
 
+/**
+ *
+ * @param {Float32Array|Float64Array|Array.<Number>} vertices
+ * @returns {IndexedBinaryBVH}
+ */
+export function buildUnsortedUnindexed(vertices) {
+    //
+    const numNodes = vertices.length / 9;
+
+    const tree = new IndexedBinaryBVH();
+    tree.initialize(numNodes);
+
+    for (let i = 0; i < numNodes; i++) {
+
+        const index3 = i * 3;
+
+        // read triangle vertex indices
+        const iA = index3;
+        const iB = index3 + 1;
+        const iC = index3 + 2;
+
+        const a = iA * 3;
+        const b = iB * 3;
+        const c = iC * 3;
+
+        // read actual positions of each vertex
+        const aX = vertices[a];
+        const aY = vertices[a + 1];
+        const aZ = vertices[a + 2];
+
+        const bX = vertices[b];
+        const bY = vertices[b + 1];
+        const bZ = vertices[b + 2];
+
+        const cX = vertices[c];
+        const cY = vertices[c + 1];
+        const cZ = vertices[c + 2];
+
+        // compute bounds of the triangle
+        const x0 = min3(aX, bX, cX);
+        const y0 = min3(aY, bY, cY);
+        const z0 = min3(aZ, bZ, cZ);
+
+        const x1 = max3(aX, bX, cX);
+        const y1 = max3(aY, bY, cY);
+        const z1 = max3(aZ, bZ, cZ);
+
+        tree.writeLeaf(i, x0, y0, z0, x1, y1, z1);
+    }
+
+    // finalize build
+    tree.unsortedBuiltIntermediate();
+
+    return tree;
+}
+
 export {
     buildUnsorted
 };

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.39.15",
+  "version": "2.39.18",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",