@woosh/meep-engine 2.34.25 → 2.34.29

package/core/bvh2/aabb3/aabb3_array_contains_point.js

@@ -0,0 +1,18 @@
+//
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]} aabb
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {boolean}
+ */
+export function aabb3_array_contains_point(aabb, x, y, z) {
+    return x >= aabb[0]
+        && x <= aabb[3]
+        && y >= aabb[1]
+        && y <= aabb[4]
+        && z >= aabb[2]
+        && z <= aabb[5];
+}

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/sphere/sphere_array_intersects_point.js

@@ -0,0 +1,15 @@
+import { sphereIntersectsPoint } from "./sphereIntersectsPoint.js";
+
+//
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]} sphere
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {boolean}
+ */
+export function sphere_array_intersects_point(sphere, x, y, z) {
+    return sphereIntersectsPoint(sphere[0], sphere[1], sphere[2], sphere[3], x, y, z);
+}

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";
 
 /**
  *
@@ -30,6 +31,10 @@ export class PatchRepresentation {
             Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY
         );
 
+        /**
+         *
+         * @type {AABB3}
+         */
         this.group_aabb = new AABB3(0, 0, 0, 0, 0, 0);
 
         /**
@@ -399,11 +404,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/buildMicronGeometryFromBufferGeometry.js

@@ -202,6 +202,11 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
 
     const t_build_hierarchy_start = current_time_millis();
+
+    /**
+     *
+     * @type {PatchRepresentation}
+     */
     const root = await buildAbstractPatchHierarchy(patches);
 
     if (PRINT_VERBOSE_STATS) {

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

@@ -48,13 +48,15 @@ async function assemble_graph(nodes) {
      */
     let __nodes = nodes.slice();
 
+    const initial_node_count = __nodes.length;
+
     /**
      *
      * @type {{value: number}}
      * @private
      */
     const __node_count = {
-        value: __nodes.length
+        value: initial_node_count
     };
 
     let level = 0;
@@ -136,9 +138,12 @@ async function assemble_graph(nodes) {
     // return root
     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);
+    if (initial_node_count === 1) {
+        // there are no children, whole hierarchy is just one node, set group bounds to equal node bounds
+        root.group_bounding_sphere.set(root.bounding_sphere);
+        root.group_aabb.copy(root.bounding_box);
+    }
+
 
     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;
 

package/engine/graphics/micron/format/MicronGeometry.d.ts

@@ -1,6 +1,7 @@
 import {BufferGeometry} from "three";
 import {VertexDataSpec} from "../../geometry/VertexDataSpec";
 import {SurfacePoint3} from "../../../../core/geom/3d/SurfacePoint3";
+import {MicronGeometryPatch} from "./MicronGeometryPatch";
 
 export class MicronGeometry {
     vertex_spec: VertexDataSpec
@@ -14,4 +15,6 @@ export class MicronGeometry {
     ): SurfacePoint3[]
 
     readonly isMicronGeometry: boolean
+
+    readonly patches: MicronGeometryPatch[]
 }

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

@@ -3,7 +3,6 @@ import { assert } from "../../../../core/assert.js";
 import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
-import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
 
 let id_counter = 0;
 
@@ -109,12 +108,14 @@ export class MicronGeometry {
             // using group bounds because it's conservative, as we want to be able to hit LOD_0
 
             // sphere test
-            if (!sphere_array_intersects_ray(patch.group_bounding_sphere,
-                origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z
-            )) {
-                continue;
-            }
+
+            // 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;
+            // }
 
 
             // box test (more expensive, different volume)
@@ -133,12 +134,14 @@ export class MicronGeometry {
                 // cast against bounds
 
                 // sphere test
-                if (!sphere_array_intersects_ray(patch.bounding_sphere,
-                    origin_x, origin_y, origin_z,
-                    direction_x, direction_y, direction_z
-                )) {
-                    continue;
-                }
+
+                // 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(
@@ -155,7 +158,7 @@ export class MicronGeometry {
 
                 const vertices = patch.vertex_attribute_arrays[position_attribute_index];
 
-                for ( i = 0; i < index_count;) {
+                for (i = 0; i < index_count;) {
                     const a = indices[i++];
                     const b = indices[i++];
                     const c = indices[i++];
@@ -202,7 +205,7 @@ export class MicronGeometry {
 
                 const child_count = children.length;
 
-                for ( 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/MicronGeometryPatch.d.ts

@@ -0,0 +1,3 @@
+export class MicronGeometryPatch {
+
+}

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.spec.js

@@ -0,0 +1,63 @@
+import { MicronGeometryPatch } from "../MicronGeometryPatch.js";
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../MicronGeometry.js";
+import { VertexDataSpec } from "../../../geometry/VertexDataSpec.js";
+import { AttributeSpec } from "../../../geometry/AttributeSpec.js";
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+import { MicronGeometryBinarySerializationAdapter } from "./MicronGeometryBinarySerializationAdapter.js";
+
+function sampleGeometry() {
+    const a = new MicronGeometryPatch();
+
+    a.vertex_attribute_arrays[0] = new Uint8Array([
+        7, 11, 13,
+        17, 23, 29,
+        31, 39, 43
+    ]);
+    a.vertex_count = 3;
+
+    a.face_indices = new Uint8Array([1, 2, 3]);
+    a.polygon_count = 1;
+
+    a.group_error = 1.234;
+
+    a.bounding_box.set([7, 11, 13, 31, 39, 43]);
+    a.group_bounding_box.set([7, 11, 13, 31, 39, 43]);
+    a.bounding_sphere.set([19, 25, 28, 50.1]);
+    a.group_bounding_sphere.set([19, 25, 28, 50.1]);
+
+    const g_a = new MicronGeometry();
+
+    const vertex_spec = new VertexDataSpec();
+    vertex_spec.add(AttributeSpec.fromJSON({
+        name: 'position',
+        type: DataType.Uint8,
+        itemSize: 3,
+        normalized: false
+    }));
+
+    g_a.vertex_spec = vertex_spec;
+    g_a.root = a;
+    g_a.initialize();
+
+    return g_a;
+}
+
+test("serialization/deserialization consistency", () => {
+    const g_a = sampleGeometry();
+
+    const buffer = new BinaryBuffer();
+
+    const adapter = new MicronGeometryBinarySerializationAdapter();
+
+    adapter.serialize(buffer, g_a);
+
+
+    const g_b = new MicronGeometry();
+
+    buffer.position = 0;
+    adapter.deserialize(buffer, g_b);
+
+    expect(g_b.vertex_spec.equals(g_a.vertex_spec)).toBe(true);
+    expect(g_b.patches.length).toEqual(g_a.patches.length);
+});

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/format/validate_patch_bounds.js

@@ -0,0 +1,69 @@
+import { noop } from "../../../../core/function/Functions.js";
+import { aabb3_array_contains_point } from "../../../../core/bvh2/aabb3/aabb3_array_contains_point.js";
+import { sphere_array_intersects_point } from "../../../../core/geom/3d/sphere/sphere_array_intersects_point.js";
+
+/**
+ *
+ * @param {MicronGeometryPatch} patch
+ * @param {VertexDataSpec} vertex_spec
+ * @param {function(string)} [error_consumer]
+ * @returns {boolean}
+ */
+export function validate_patch_bounds(patch, vertex_spec, error_consumer = noop) {
+    const position_attribute_index = vertex_spec.getAttributeIndexByName('position');
+
+    if (position_attribute_index === -1) {
+        error_consumer(`No 'position' attribute found`);
+        // technically any bounds are valid if there is no position
+        return true;
+    }
+
+    const position_data = patch.vertex_attribute_arrays[position_attribute_index];
+
+    let b_sphere_valid = true;
+    let b_box_valid = true;
+    let gb_sphere_valid = true;
+    let gb_box_valid = true;
+
+    for (let i = 0; i < this.vertex_count; i++) {
+        const i3 = i * 3;
+
+        const x = position_data[i3];
+        const y = position_data[i3 + 1];
+        const z = position_data[i3 + 2];
+
+        if (!aabb3_array_contains_point(patch.bounding_box, x, y, z)) {
+            b_box_valid = false;
+        }
+
+        if (!aabb3_array_contains_point(patch.group_bounding_box, x, y, z)) {
+            gb_box_valid = false;
+        }
+
+        if (!sphere_array_intersects_point(patch.bounding_sphere, x, y, z)) {
+            b_sphere_valid = false;
+        }
+
+        if (!sphere_array_intersects_point(patch.group_bounding_sphere, x, y, z)) {
+            gb_sphere_valid = false;
+        }
+    }
+
+    if (!b_sphere_valid) {
+        error_consumer('.bounding_sphere is violated');
+    }
+
+    if (!gb_sphere_valid) {
+        error_consumer('.group_bounding_sphere is violated');
+    }
+
+    if (!b_box_valid) {
+        error_consumer('.bounding_box is violated');
+    }
+
+    if (!gb_box_valid) {
+        error_consumer('.group_bounding_box is violated');
+    }
+
+    return b_sphere_valid && gb_sphere_valid && b_box_valid && gb_box_valid;
+}

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