@woosh/meep-engine 2.34.23 → 2.34.27

package/core/bvh2/aabb3/aabb3_nearest_point_on_surface.js

@@ -0,0 +1,65 @@
+import { clamp } from "../../math/clamp.js";
+import { min2 } from "../../math/min2.js";
+
+//
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>} result
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} r_x
+ * @param {number} r_y
+ * @param {number} r_z
+ */
+export function aabb3_nearest_point_on_surface(result, x0, y0, z0, x1, y1, z1, r_x, r_y, r_z) {
+    const ar_x0 = Math.abs(r_x - x0);
+    const ar_x1 = Math.abs(r_x - x1);
+    const ar_x_min = min2(ar_x0, ar_x1);
+
+    const ar_y0 = Math.abs(r_y - y0);
+    const ar_y1 = Math.abs(r_y - y1);
+    const ar_y_min = min2(ar_y0, ar_y1);
+
+    const ar_z0 = Math.abs(r_z - z0);
+    const ar_z1 = Math.abs(r_z - z1);
+    const ar_z_min = min2(ar_z0, ar_z1);
+
+    // figure out closest face to the reference point
+    if (ar_x_min > ar_y_min && ar_x_min > ar_z_min) {
+        // X is smallest, project onto X axis
+        if (ar_x0 <= ar_x1) {
+            result[0] = x0;
+        } else {
+            result[0] = x1;
+        }
+
+        result[1] = clamp(r_y, y0, y1);
+        result[2] = clamp(r_z, z0, z1);
+    } else if (ar_y_min > ar_x_min && ar_y_min > ar_z_min) {
+        // Y is smallest, project onto X axis
+        if (ar_y0 <= ar_y1) {
+            result[1] = y0;
+        } else {
+            result[1] = y1;
+        }
+
+        result[0] = clamp(r_x, x0, x1);
+        result[2] = clamp(r_z, z0, z1);
+    } else {
+        // project onto Z axis
+
+        if (ar_z0 <= ar_z1) {
+            result[2] = z0;
+        } else {
+            result[2] = z1;
+        }
+
+        result[0] = clamp(r_x, x0, x1);
+        result[1] = clamp(r_y, y0, y1);
+    }
+}

package/core/geom/3d/ray/ray_distance_to_point.js

@@ -0,0 +1,14 @@
+import { v3_dot } from "../../v3_dot.js";
+
+export function ray_distance_to_point(origin_x, origin_y, origin_z, direction_x, direction_y, direction_z,ref_x, ref_y, ref_z){
+    // find closest point
+    const sp0_x = ref_x - origin_x;
+    const sp0_y = ref_y - origin_y;
+    const sp0_z = ref_z - origin_z;
+
+    //
+    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
+    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
+
+    return d3 / d2;
+}

package/core/geom/3d/shape/UnitCubeShape3D.js

@@ -4,8 +4,8 @@ import { v3_length } from "../../v3_length.js";
 import { max2 } from "../../../math/max2.js";
 import { max3 } from "../../../math/max3.js";
 import { min2 } from "../../../math/min2.js";
-import { clamp } from "../../../math/clamp.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+import { aabb3_nearest_point_on_surface } from "../../../bvh2/aabb3/aabb3_nearest_point_on_surface.js";
 
 export class UnitCubeShape3D extends AbstractShape3D {
 
@@ -18,43 +18,13 @@ export class UnitCubeShape3D extends AbstractShape3D {
         const r_y = reference[1];
         const r_z = reference[2];
 
-        // figure out closest face to the reference point
-        const ar_x = Math.abs(r_x);
-        const ar_y = Math.abs(r_y);
-        const ar_z = Math.abs(r_z);
+        aabb3_nearest_point_on_surface(
+            result,
+            -0.5, -0.5, -0.5,
+            0.5, 0.5, 0.5,
+            r_x, r_y, r_z
+        );
 
-        if (ar_x > ar_y && ar_x > ar_z) {
-            // X is smallest, project onto X axis
-            if (r_x <= 0) {
-                result[0] = -0.5;
-            } else {
-                result[0] = 0.5;
-            }
-
-            result[1] = clamp(r_y, -0.5, 0.5);
-            result[2] = clamp(r_z, -0.5, 0.5);
-        } else if (ar_y > ar_x && ar_y > ar_z) {
-            // Y is smallest, project onto X axis
-            if (r_y <= 0) {
-                result[1] = -0.5;
-            } else {
-                result[1] = 0.5;
-            }
-
-            result[0] = clamp(r_x, -0.5, 0.5);
-            result[2] = clamp(r_z, -0.5, 0.5);
-        } else {
-            // project onto Z axis
-
-            if (r_z <= 0) {
-                result[2] = -0.5;
-            } else {
-                result[2] = 0.5;
-            }
-
-            result[0] = clamp(r_x, -0.5, 0.5);
-            result[1] = clamp(r_y, -0.5, 0.5);
-        }
     }
 
     signed_distance_gradient_at_point(result, point) {

package/core/geom/3d/sphere/sphere_array_intersects_ray.js

@@ -0,0 +1,25 @@
+//
+
+import { sphere_intersects_ray } from "./sphere_intersects_ray.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>} sphere
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function sphere_array_intersects_ray(
+    sphere,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    return sphere_intersects_ray(sphere[0], sphere[1], sphere[2], sphere[3],
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z
+    );
+}

package/core/geom/3d/sphere/sphere_intersects_ray.js

@@ -0,0 +1,52 @@
+//
+
+import { v3_dot } from "../../v3_dot.js";
+import { ray_distance_to_point } from "../ray/ray_distance_to_point.js";
+
+/**
+ *
+ * @param {number} center_x
+ * @param {number} center_y
+ * @param {number} center_z
+ * @param {number} radius
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {boolean}
+ */
+export function sphere_intersects_ray(
+    center_x, center_y, center_z, radius,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    const delta_x = center_x - origin_x;
+    const delta_y = center_y - origin_y;
+    const delta_z = center_z - origin_z;
+
+    const tca = v3_dot(delta_x, delta_y, delta_z, direction_x, direction_y, direction_z);
+    const d2 = v3_dot(delta_x, delta_y, delta_z, delta_x, delta_y, delta_z) - tca * tca;
+
+    const radius2 = radius * radius;
+
+    if (d2 > radius2) {
+        return false;
+    }
+
+    const thc = Math.sqrt(radius2 - d2);
+
+    // t0 = first intersect point - entrance on front of sphere
+    const t0 = tca - thc;
+
+    // t1 = second intersect point - exit point on back of sphere
+    const t1 = tca + thc;
+
+    // test to see if both t0 and t1 are behind the ray - if so, no intersection
+    if (t0 < 0 && t1 < 0) {
+        return false;
+    }
+
+    return true;
+}

package/engine/graphics/micron/build/PatchRepresentation.js

@@ -10,6 +10,7 @@ import { vec4 } from "gl-matrix";
 import { computeTopoMeshBoundiningBox } from "../../../../core/geom/3d/topology/bounds/computeTopoMeshBoundiningBox.js";
 import { computeTopoMeshBoundingSphere } from "../../../../core/geom/3d/topology/bounds/computeTopoMeshBoundingSphere.js";
 import { meshopt_optimizeVertexCache } from "../../geometry/optimization/VertexCacheOptimizer.js";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
 
 /**
  *
@@ -190,15 +191,11 @@ export class PatchRepresentation {
         return result;
     }
 
-    computeBoundingBox() {
+    computeBounds() {
         computeTopoMeshBoundiningBox(this.bounding_box, this.topology_snapshot);
         computeTopoMeshBoundingSphere(this.bounding_sphere, this.topology_snapshot);
     }
 
-    computeBounds() {
-        this.computeBoundingBox();
-    }
-
     /**
      * @returns {number}
      */
@@ -403,11 +400,11 @@ export class PatchRepresentation {
 
         this.group_aabb.getCorners(result.group_bounding_box_corners);
 
-        vec4.copy(result.group_bounding_sphere, this.group_bounding_sphere);
+        array_copy(this.group_bounding_sphere, 0, result.group_bounding_sphere, 0, 4);
 
         result.group_error = this.group_error;
 
-        vec4.copy(result.bounding_sphere, this.bounding_sphere);
+        array_copy(this.bounding_sphere, 0, result.bounding_sphere, 0, 4);
 
         result.normal_cone.copy(this.normal_cone);
 

package/engine/graphics/micron/build/hierarchy/buildAbstractPatchHierarchy.js

@@ -134,7 +134,13 @@ async function assemble_graph(nodes) {
     }
 
     // return root
-    return __nodes[0];
+    const root = __nodes[0];
+
+    //set group bounds to produce a valid root
+    root.group_aabb.copy(root.bounding_box);
+    root.group_bounding_sphere.set(root.bounding_sphere);
+
+    return root;
 }
 
 

package/engine/graphics/micron/build/hierarchy/merge_patches.js

@@ -477,7 +477,8 @@ async function many_to_many_merge(
 
         rep.group_aabb.copy(group_aabb);
         rep.group_bounding_sphere.set(group_bounding_sphere);
-        computeTopoMeshBoundiningBox(rep.bounding_box, piece_mesh);
+
+        rep.computeBounds();
 
         rep.group_error = group_per_pixel_error;
 
@@ -515,10 +516,6 @@ export async function merge_patches(
         // only 1 patch, no merge opportunity, forward it to output directly
         const node = nodes[0];
 
-        //set group bounds to produce a valid root
-        node.group_aabb.copy(node.bounding_box);
-        node.group_bounding_sphere.set(node.bounding_sphere);
-
         output[output_offset.value++] = node;
         return 1;
     } else {

package/engine/graphics/micron/format/MicronGeometry.js

@@ -78,6 +78,8 @@ export class MicronGeometry {
         origin_x, origin_y, origin_z,
         direction_x, direction_y, direction_z
     ) {
+        let i;
+        let stack_cursor = 1;
 
         /**
          *
@@ -86,7 +88,6 @@ export class MicronGeometry {
         const hits = [];
 
         // initialize stack
-        let stack_cursor = 1;
         const stack = scratch_traversal_stack;
         stack[0] = this.root;
 
@@ -104,16 +105,25 @@ export class MicronGeometry {
 
             const patch = stack[stack_cursor];
 
-            // using group bounding box because it's conservative, as we want to be able to hit LOD_0
-            const bb = patch.group_bounding_box;
+            // using group bounds because it's conservative, as we want to be able to hit LOD_0
+
+            // sphere test
+
+            // TODO check what's wrong with sphere tests and re-enable them
+            // if (!sphere_array_intersects_ray(patch.group_bounding_sphere,
+            //     origin_x, origin_y, origin_z,
+            //     direction_x, direction_y, direction_z
+            // )) {
+            //     continue;
+            // }
+
 
-            const bb_intersection_exists = aabb3_array_intersects_ray(
-                bb,
+            // box test (more expensive, different volume)
+            if (!aabb3_array_intersects_ray(
+                patch.group_bounding_box,
                 origin_x, origin_y, origin_z,
                 direction_x, direction_y, direction_z
-            );
-
-            if (!bb_intersection_exists) {
+            )) {
                 // no intersection
                 continue;
             }
@@ -122,6 +132,18 @@ export class MicronGeometry {
                 // LOD 0 - source geometry
 
                 // cast against bounds
+
+                // sphere test
+
+                // TODO check what's wrong with sphere tests and re-enable them
+                // if (!sphere_array_intersects_ray(patch.bounding_sphere,
+                //     origin_x, origin_y, origin_z,
+                //     direction_x, direction_y, direction_z
+                // )) {
+                //     continue;
+                // }
+
+                // box test
                 if (!aabb3_array_intersects_ray(
                     patch.bounding_box,
                     origin_x, origin_y, origin_z,
@@ -136,7 +158,7 @@ export class MicronGeometry {
 
                 const vertices = patch.vertex_attribute_arrays[position_attribute_index];
 
-                for (let i = 0; i < index_count;) {
+                for (i = 0; i < index_count;) {
                     const a = indices[i++];
                     const b = indices[i++];
                     const c = indices[i++];
@@ -183,7 +205,7 @@ export class MicronGeometry {
 
                 const child_count = children.length;
 
-                for (let i = 0; i < child_count; i++) {
+                for (i = 0; i < child_count; i++) {
                     const child = children[i];
 
                     // push to stack

package/engine/graphics/micron/format/serialization/deserialize_patch.js

@@ -1,7 +1,6 @@
 import { aabb3_build_corners } from "../../../../../core/geom/3d/aabb/aabb3_build_corners.js";
 import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
-import { v3_distance } from "../../../../../core/geom/v3_distance.js";
 
 /**
  *
@@ -19,7 +18,6 @@ export function deserialize_patch(buffer, patch, vertex_spec, patch_array) {
     buffer.readFloat32Array(gbb, 0, 6);
     buffer.readFloat32Array(patch.group_bounding_sphere, 0, 4);
 
-
     patch.group_error = buffer.readFloat32();
     patch.lod = buffer.readUintVar();
     patch.polygon_count = buffer.readUintVar();
@@ -92,33 +90,6 @@ export function deserialize_patch(buffer, patch, vertex_spec, patch_array) {
         patch.vertex_attribute_arrays[i] = array;
     }
 
-
-    // validate and fix group bounds as necessary
-    if (
-        patch.group_bounding_box[0] > patch.bounding_box[0] // x0
-        || patch.group_bounding_box[1] > patch.bounding_box[1] // y0
-        || patch.group_bounding_box[2] > patch.bounding_box[2] // x0
-        || patch.group_bounding_box[3] < patch.bounding_box[3] // x1
-        || patch.group_bounding_box[4] < patch.bounding_box[4] // y1
-        || patch.group_bounding_box[5] < patch.bounding_box[5] // z1
-    ) {
-        // bounds are violated, fix
-        patch.group_bounding_box.set(patch.bounding_box);
-    }
-
-    if (v3_distance(
-        patch.group_bounding_sphere[0],
-        patch.group_bounding_sphere[1],
-        patch.group_bounding_sphere[2],
-        patch.bounding_sphere[0],
-        patch.bounding_sphere[1],
-        patch.bounding_sphere[2]
-    ) + patch.bounding_sphere[3] > patch.group_bounding_sphere[3]) {
-        // group's sphere bounds are violated, fix
-        patch.group_bounding_sphere.set(patch.bounding_sphere);
-    }
-
-
     // reconstruct corners
     aabb3_build_corners(
         patch.group_bounding_box_corners,

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -455,7 +455,7 @@ function init() {
     }
 
     // sample_gltf_sponza();
-    // sample_gltf_rts_factory();
+    gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
     // sample_lucy();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
@@ -467,7 +467,7 @@ function init() {
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/1/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/1-onematerial/model.gltf');
-    gltf_sample('moicon/29_Dec_2021_Nammo/2/model.gltf');
+    // gltf_sample('moicon/29_Dec_2021_Nammo/2/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

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