@woosh/meep-engine 2.46.28 → 2.46.29

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.46.28",
+  "version": "2.46.29",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/EBBVHLeafProxy.js

@@ -22,7 +22,7 @@ export class EBBVHLeafProxy {
      */
     bounds = new Float32Array(6);
 
-    get is_linked(){
+    get is_linked() {
         return this.#node_id !== -1;
     }
 
@@ -55,6 +55,11 @@ export class EBBVHLeafProxy {
     }
 
     write_bounds() {
+        if (this.#tree === null) {
+            // nothing to write to
+            return;
+        }
+
         this.#tree.node_move_aabb(this.#node_id, this.bounds);
     }
 }

package/src/core/geom/3d/aabb/aabb3_matrix4_project.js

@@ -5,7 +5,7 @@ import { assert } from "../../../assert.js";
  * NOTE: {@link result} and {@link aabb} must be different objects
  * @param {ArrayLike<number>|number[]|Float32Array} result
  * @param {ArrayLike<number>|number[]|Float32Array} aabb
- * @param {number[]} matrix 4x4 matrix
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix 4x4 matrix
  */
 export function aabb3_matrix4_project(result, aabb, matrix) {
     assert.notEqual(result, aabb, 'input and output must not be the same for algorithm to work correctly');

package/src/engine/graphics/ecs/decal/v2/FPDecalSystem.d.ts

@@ -2,7 +2,16 @@ import {System} from "../../../../ecs/System";
 import {Decal} from "./Decal";
 import {Transform} from "../../../../ecs/transform/Transform";
 import Engine from "../../../../Engine";
+import {SurfacePoint3} from "../../../../../core/geom/3d/SurfacePoint3";
 
 export class FPDecalSystem extends System<Decal, Transform> {
     constructor(engine: Engine)
+
+
+    raycast(
+        origin_x: number, origin_y: number, origin_z: number,
+        direction_x: number, direction_y: number, direction_z: number,
+        filter_function?: (entity: number, mesh: Decal) => boolean,
+        filter_function_context?: any
+    ): { entity: number, component: Decal, contact: SurfacePoint3 }[]
 }

package/src/engine/graphics/ecs/decal/v2/FPDecalSystem.js

@@ -11,21 +11,54 @@ import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { assert } from "../../../../../core/assert.js";
 import { AsyncLoadingCache } from "../../../../../core/collection/map/AsyncLoadingCache.js";
 import { sampler2d_to_uint8_RGBA } from "../../../texture/sampler/sampler2d_to_uint8_RGBA.js";
+import { returnTrue } from "../../../../../core/function/Functions.js";
+import {
+    ExplicitBinaryBoundingVolumeHierarchy
+} from "../../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_ray } from "../../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
+import { ray3_array_apply_matrix4 } from "../../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { aabb3_intersects_ray } from "../../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
+import { ray3_array_compose } from "../../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { mat4 } from "gl-matrix";
+import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
+import { EBBVHLeafProxy } from "../../../../../core/bvh2/bvh3/EBBVHLeafProxy.js";
+import { aabb3_matrix4_project } from "../../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 
 const placeholder_texture = Sampler2D.uint8(4, 1, 1);
 placeholder_texture.data.fill(255);
 
+/**
+ * @readonly
+ * @type {Float32Array}
+ */
+const scratch_ray_0 = new Float32Array(6);
+
+
+/**
+ *
+ * @type {Float32Array|mat4}
+ */
+const scratch_m4 = new Float32Array(16);
+
+/**
+ *
+ * @type {Float32Array}
+ */
+const AABB_UNIT_CUBE = new Float32Array([
+    -0.5, -0.5, -0.5,
+    0.5, 0.5, 0.5
+]);
+
 class Context extends SystemEntityContext {
-    constructor() {
-        super();
 
-        /**
-         *
-         * @type {FPDecal|null}
-         * @private
-         */
-        this.__fp_decal = null;
-    }
+    /**
+     *
+     * @type {FPDecal|null}
+     * @private
+     */
+    __fp_decal = null;
+
+    #bvh_leaf = new EBBVHLeafProxy();
 
     /**
      * @return {ForwardPlusRenderingPlugin}
@@ -51,6 +84,10 @@ class Context extends SystemEntityContext {
         const transform = this.getTransform();
 
         this.__fp_decal.setTransform(transform.matrix);
+
+        aabb3_matrix4_project(this.#bvh_leaf.bounds, AABB_UNIT_CUBE, transform.matrix);
+
+        this.#bvh_leaf.write_bounds();
     }
 
     async __load_texture() {
@@ -135,6 +172,7 @@ class Context extends SystemEntityContext {
             }
         });
 
+        this.#bvh_leaf.link(this.system.bvh, this.entity);
 
         super.link();
     }
@@ -150,6 +188,8 @@ class Context extends SystemEntityContext {
         const transform = this.getTransform();
         transform.subscribeAllChanges(this.__update_transform, this);
 
+        this.#bvh_leaf.unlink();
+
         super.unlink();
     }
 }
@@ -160,6 +200,8 @@ class Context extends SystemEntityContext {
  *
  */
 export class FPDecalSystem extends AbstractContextSystem {
+    bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
     /**
      *
      * @param {Engine} engine
@@ -223,4 +265,101 @@ export class FPDecalSystem extends AbstractContextSystem {
 
         super.shutdown(em, ready_callback, error_callback);
     }
+
+    /**
+     *
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @param {function(entity:number, component:Decal):boolean} [filter_function]
+     * @param {*} [filter_function_context]
+     * @returns {{entity:number, component:Decal, contact: SurfacePoint3}[]}
+     */
+    raycast(
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        filter_function = returnTrue, filter_function_context
+    ) {
+
+        const ecd = this.entityManager.dataset;
+
+        if (ecd === null) {
+            return [];
+        }
+
+        const leaves = [];
+
+        const hit_count = bvh_query_leaves_ray(this.bvh, leaves, 0,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        );
+
+        const result = [];
+
+
+        for (let i = 0; i < hit_count; i++) {
+            const node = leaves[i];
+
+            const entity = this.bvh.node_get_user_data(node);
+
+
+            /**
+             *
+             * @type {Decal}
+             */
+            const decal = ecd.getComponent(entity, Decal);
+
+            if (decal === undefined) {
+                // this shouldn't happen
+                continue;
+            }
+
+
+            const transform = ecd.getComponent(entity, Transform);
+
+            if (transform === undefined) {
+                // this shouldn't happen either
+                continue;
+            }
+
+            ray3_array_compose(
+                scratch_ray_0,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
+
+
+            // get transform in local space
+            mat4.invert(scratch_m4, transform.matrix);
+
+            // transform ray into decal's local space
+            ray3_array_apply_matrix4(scratch_ray_0, 0, scratch_ray_0, 0, scratch_m4);
+
+            if (aabb3_intersects_ray(
+                -0.5, -0.5, -0.5,
+                0.5, 0.5, 0.5,
+
+                scratch_ray_0[0], scratch_ray_0[1], scratch_ray_0[2],
+                scratch_ray_0[3], scratch_ray_0[4], scratch_ray_0[5],
+            )) {
+                const contact = new SurfacePoint3();
+
+                // contact will be the center of decal, and normal will follow the decal normal
+                contact.applyMatrix4(transform.matrix);
+
+                result.push({
+                    entity,
+                    component: decal,
+                    contact
+                });
+
+            }
+
+        }
+
+        return result;
+    }
 }

package/src/engine/graphics/ecs/decal/v2/prototypeDecalSystem.js

@@ -336,7 +336,7 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
                     side: DoubleSide
                 }), DrawMode.Triangles))
                 .add(arrow_transform)
-            .build(ecd);
+                .build(ecd);
         }
     }
 }
@@ -476,6 +476,26 @@ async function main(engine) {
     //grid(engine.entityManager.dataset, 20,30,80, 25, .4, .6, .1, decal_urls.slice(105, 105+3));
     // await promise_time_out(10);
 
+    engine.devices.pointer.position.onChanged.add(() => {
+        const ray_origin = new Vector3();
+        const ray_direction = new Vector3();
+
+
+        const pointer = engine.devices.pointer.position;
+
+        const ndc = new Vector2();
+
+        engine.graphics.normalizeViewportPoint(pointer,ndc);
+        engine.graphics.viewportProjectionRay(ndc.x, ndc.y, ray_origin, ray_direction);
+
+        const hits = engine.entityManager.getSystem(FPDecalSystem)?.raycast(
+            ray_origin.x, ray_origin.y, ray_origin.z,
+            ray_direction.x, ray_direction.y, ray_direction.z
+        );
+
+        console.warn(hits);
+
+    });
 
 }
 

package/src/engine/graphics/render/forward_plus/LightManager.js

@@ -50,9 +50,6 @@ import {
     bvh_query_user_data_overlaps_frustum
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 import { point_light_inside_volume } from "./query/point_light_inside_volume.js";
-import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
-import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
-import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 
 
 /**
@@ -1205,61 +1202,4 @@ export class LightManager {
 
         return true;
     }
-
-    /**
-     *
-     * @param {Decal[]} result
-     * @param {number} result_offset
-     * @param {number[]} query
-     * @param {number} query_offset
-     * @returns {number} number of elements added to the result
-     */
-    query_decals_by_ray(result, result_offset, query, query_offset) {
-
-        const leaves = [];
-        const local_ray = new Float32Array(6);
-
-        const hit_count = bvh_query_leaves_ray(this.#light_data_bvh, leaves, 0,
-            query[query_offset], query[query_offset + 1], query[query_offset + 2],
-            query[query_offset + 3], query[query_offset + 4], query[query_offset + 5]
-        );
-
-        let result_count = 0;
-
-        for (let i = 0; i < hit_count; i++) {
-            const node = leaves[i];
-            const light_id = this.#light_data_bvh.node_get_user_data(node);
-
-            const metadata = this.#metadata_map.get(light_id);
-
-            /**
-             *
-             * @type {Decal}
-             */
-            const prop = metadata.light;
-
-            if (prop.isDecal !== true) {
-                // wrong prop type
-                continue;
-            }
-
-            // transform ray into decal's local space
-            ray3_array_apply_matrix4(local_ray, 0, query, query_offset, prop.transform_inverse);
-
-            if (aabb3_intersects_ray(
-                -0.5, -0.5, -0.5,
-                0.5, 0.5, 0.5,
-
-                local_ray[0], local_ray[1], local_ray[2],
-                local_ray[3], local_ray[4], local_ray[5],
-            )) {
-                result[result_offset + result_count] = prop;
-
-                result_count++;
-            }
-
-        }
-
-        return result_count;
-    }
 }

package/src/engine/graphics/render/forward_plus/LightRenderMetadata.js

@@ -37,9 +37,7 @@ export class LightRenderMetadata {
 
         this.light.getAABB(leaf.bounds);
 
-        if (leaf.is_linked) {
-            leaf.write_bounds();
-        }
+        leaf.write_bounds();
     }
 
     /**

package/src/engine/graphics/render/forward_plus/model/Decal.js

@@ -37,7 +37,7 @@ export class Decal extends AbstractLight {
 
     /**
      *
-     * @param {number[]} m
+     * @param {number[]|Float32Array|ArrayLike<number>} m
      */
     setTransform(m) {
         mat4.copy(this.transform, m);

package/src/engine/graphics/render/forward_plus/plugin/ForwardPlusRenderingPlugin.d.ts

@@ -1,8 +1,5 @@
 import {EnginePlugin} from "../../../../plugin/EnginePlugin";
-import {Decal} from "../../../ecs/decal/v2/Decal";
 
 export class ForwardPlusRenderingPlugin extends EnginePlugin {
     setClusterResolution(x: number, y: number, z: number): void
-
-    queryDecalsByRay(result: Decal[], result_offset: number, query: ArrayLike<number>, query_offset?: number): number
 }

package/src/engine/graphics/render/forward_plus/plugin/ForwardPlusRenderingPlugin.js

@@ -89,15 +89,4 @@ export class ForwardPlusRenderingPlugin extends EnginePlugin {
         return this.__light_manager;
     }
 
-    /**
-     *
-     * @param {Decal[]} result
-     * @param {number} result_offset
-     * @param {number[]} query
-     * @param {number} query_offset
-     * @returns {number} number of elements added to the result
-     */
-    queryDecalsByRay(result, result_offset, query, query_offset=0){
-return        this.__light_manager.query_decals_by_ray(result,result_offset, query,query_offset);
-    }
 }