@woosh/meep-engine 2.47.35 → 2.47.36

package/package.json

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

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

@@ -0,0 +1,65 @@
+import { aabb3_build_corners } from "./aabb3_build_corners.js";
+import { aabb3_matrix4_project_by_corners } from "./aabb3_matrix4_project_by_corners.js";
+import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
+
+const scratch_corners = new Float32Array(24);
+
+/**
+ *
+ * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_offset
+ * @param {number[]|Float32Array} transform_matrix
+ * @returns {number}
+ */
+export function aabb3_transformed_compute_plane_side(
+    x0, y0, z0, x1, y1, z1,
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_offset,
+    transform_matrix
+) {
+
+    aabb3_build_corners(
+        scratch_corners, 0,
+        x0, y0, z0, x1, y1, z1
+    );
+
+    aabb3_matrix4_project_by_corners(
+        scratch_corners,
+        scratch_corners,
+        transform_matrix
+    );
+
+    let has_above = false, has_below = false;
+
+    for (let i = 0; i < 8; i++) {
+        const i3 = i * 3;
+        const x = scratch_corners[i3];
+        const y = scratch_corners[i3 + 1];
+        const z = scratch_corners[i3 + 2];
+
+        if (v3_distance_above_plane(x, y, z, plane_normal_x, plane_normal_y, plane_normal_z, plane_offset)) {
+            has_above = true;
+        } else {
+            has_below = true;
+        }
+    }
+
+    let result = 0;
+
+    if (has_above) {
+        result += 2;
+    }
+    if (has_below) {
+        result -= 2;
+    }
+
+    return result;
+}

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

@@ -14,4 +14,7 @@ export class FPDecalSystem extends System<Decal, Transform> {
         filter_function?: (entity: number, mesh: Decal) => boolean,
         filter_function_context?: any
     ): { entity: number, component: Decal, contact: SurfacePoint3 }[]
+
+
+    queryOverlapFrustum(result: number[], result_offset: number, planes: number[]): number
 }

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

@@ -23,6 +23,12 @@ 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";
 import { aabb3_raycast } from "../../../../../core/geom/3d/aabb/aabb3_raycast.js";
+import {
+    bvh_query_user_data_overlaps_frustum
+} from "../../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
+import {
+    aabb3_transformed_compute_plane_side
+} from "../../../../../core/geom/3d/aabb/aabb3_transformed_compute_plane_side.js";
 
 const placeholder_texture = Sampler2D.uint8(4, 1, 1);
 placeholder_texture.data.fill(255);
@@ -289,6 +295,72 @@ export class FPDecalSystem extends AbstractContextSystem {
         super.shutdown(em, ready_callback, error_callback);
     }
 
+    /**
+     *
+     * @param {number[]} result entity IDs
+     * @param {number} result_offset
+     * @param {number[]} planes
+     * @returns {number} number of results
+     */
+    queryOverlapFrustum(result, result_offset, planes) {
+        const ecd = this.entityManager.dataset;
+
+        if (ecd === null) {
+            return 0;
+        }
+
+        const entities = [];
+        const rough_count = bvh_query_user_data_overlaps_frustum(
+            entities, 0,
+            this.bvh,
+            planes
+        );
+
+        let result_cursor = result_offset;
+
+        loop_0: for (let i = 0; i < rough_count; i++) {
+
+            const entity = entities[i];
+
+            /**
+             *
+             * @type {Transform}
+             */
+            const transform = ecd.getComponent(entity, Transform);
+
+            if (transform === undefined) {
+                // this shouldn't happen either
+                continue;
+            }
+
+            for (let j = 0; j < 6; j++) {
+                // test true box against each plane
+                const plane_address = j * 4;
+
+                const plane_x = planes[plane_address]
+                const plane_y = planes[plane_address + 1]
+                const plane_z = planes[plane_address + 2]
+                const plane_offset = planes[plane_address + 3]
+
+                const side = aabb3_transformed_compute_plane_side(
+                    -0.5, -0.5, -0.5,
+                    0.5, 0.5, 0.5,
+                    plane_x, plane_y, plane_z, plane_offset,
+                    transform.matrix
+                );
+
+                if (side < 0) {
+                    // completely outside
+                    continue loop_0;
+                }
+            }
+
+            result[result_cursor++] = entity;
+        }
+
+        return result_cursor - result_offset;
+    }
+
     /**
      *
      * @param {number} origin_x
@@ -345,6 +417,10 @@ export class FPDecalSystem extends AbstractContextSystem {
                 continue;
             }
 
+            /**
+             *
+             * @type {Transform}
+             */
             const transform = ecd.getComponent(entity, Transform);
 
             if (transform === undefined) {