@woosh/meep-engine 2.68.0 → 2.70.0

package/src/core/geom/Vector3.js

@@ -5,17 +5,19 @@
 
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
+import { EPSILON } from "../math/EPSILON.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
 import { lerp } from "../math/lerp.js";
 import { sign } from "../math/sign.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
+import { v3_angle_between } from "./vec3/v3_angle_between.js";
+import { v3_binary_equality_decode } from "./vec3/v3_binary_equality_decode.js";
+import { v3_binary_equality_encode } from "./vec3/v3_binary_equality_encode.js";
 import { v3_dot } from "./vec3/v3_dot.js";
-import { v3_length_sqr } from "./vec3/v3_length_sqr.js";
 import { v3_length } from "./vec3/v3_length.js";
-import { v3_angle_between } from "./vec3/v3_angle_between.js";
+import { v3_length_sqr } from "./vec3/v3_length_sqr.js";
 import { v3_lerp } from "./vec3/v3_lerp.js";
 import { v3_slerp } from "./vec3/v3_slerp.js";
-import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
-import { epsilonEquals } from "../math/epsilonEquals.js";
-import { EPSILON } from "../math/EPSILON.js";
 
 class Vector3 {
     /**
@@ -856,100 +858,31 @@ class Vector3 {
     /**
      *
      * @param {BinaryBuffer} buffer
+     * @deprecated use dedicated method directly instead
      */
     toBinaryBufferFloat32_EqualityEncoded(buffer) {
         const x = this.x;
         const y = this.y;
         const z = this.z;
 
-        let header = 0;
-
-        if (x === y) {
-            header |= 1;
-        }
-
-        if (y === z) {
-            header |= 2;
-        }
-
-        if (x === z) {
-            header |= 4;
-        }
-
-        buffer.writeUint8(header);
-
-        if ((header & 7) === 7) {
-            //all components are the same
-            buffer.writeFloat32(x);
-        } else if (header === 1) {
-            //X and Y are the same, Z is different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(z);
-        } else if (header === 2) {
-            //Y and Z are the same, X is different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(y);
-        } else if (header === 4) {
-            //X and Z are the same, Y is different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(y);
-        } else {
-            //scale components are different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(y);
-            buffer.writeFloat32(z);
-        }
+        v3_binary_equality_encode(buffer, x, y, z);
     }
 
     /**
      * Uses an extra byte for a header. Only writes unique components. Useful for things like scale where all components usually have the same value
      * @param {BinaryBuffer} buffer
+     * @deprecated use dedicated method directly instead
      */
     fromBinaryBufferFloat32_EqualityEncoded(buffer) {
-        const header = buffer.readUint8();
-
-        let x = 0;
-        let y = 0;
-        let z = 0;
-
-        if ((header & 7) === 7) {
-            //all scale components are the same
-            x = buffer.readFloat32();
-            y = x;
-            z = x;
-        } else if ((header & 1) === 1) {
-            //X and Y are the same, Z is different
-            x = buffer.readFloat32();
-            y = x;
-            z = buffer.readFloat32();
-        } else if ((header & 2) === 2) {
-            //Y and Z are the same, X is different
-            x = buffer.readFloat32();
-            y = buffer.readFloat32();
-            z = y;
-        } else if ((header & 4) === 4) {
-            //X and Z are the same, Y is different
-            x = buffer.readFloat32();
-            y = buffer.readFloat32();
-            z = x;
-        } else {
-            //scale components are different
-            x = buffer.readFloat32();
-            y = buffer.readFloat32();
-            z = buffer.readFloat32();
-        }
-
-        this.set(x, y, z);
+        v3_binary_equality_decode(buffer, this, 0);
     }
 
     hash() {
-        let hash = computeHashFloat(this.x);
-
-        hash = ((hash << 5) - hash) + computeHashFloat(this.y);
-
-        hash = ((hash << 5) - hash) + computeHashFloat(this.z);
+        const x = computeHashFloat(this.x);
+        const y = computeHashFloat(this.y);
+        const z = computeHashFloat(this.z);
 
-        return hash;
+        return x ^ (y << 1) ^ (z << 2);
     }
 
 

package/src/core/geom/vec3/v3_binary_equality_decode.js

@@ -0,0 +1,44 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number[]} result
+ * @param {number} result_offset
+ */
+export function v3_binary_equality_decode(buffer, result, result_offset) {
+    const header = buffer.readUint8();
+
+    let x = 0;
+    let y = 0;
+    let z = 0;
+
+    if ((header & 7) === 7) {
+        //all scale components are the same
+        x = buffer.readFloat32();
+        y = x;
+        z = x;
+    } else if ((header & 1) === 1) {
+        //X and Y are the same, Z is different
+        x = buffer.readFloat32();
+        y = x;
+        z = buffer.readFloat32();
+    } else if ((header & 2) === 2) {
+        //Y and Z are the same, X is different
+        x = buffer.readFloat32();
+        y = buffer.readFloat32();
+        z = y;
+    } else if ((header & 4) === 4) {
+        //X and Z are the same, Y is different
+        x = buffer.readFloat32();
+        y = buffer.readFloat32();
+        z = x;
+    } else {
+        //scale components are different
+        x = buffer.readFloat32();
+        y = buffer.readFloat32();
+        z = buffer.readFloat32();
+    }
+
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
+}

package/src/core/geom/vec3/v3_binary_equality_encode.js

@@ -0,0 +1,47 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function v3_binary_equality_encode(buffer, x, y, z){
+
+    let header = 0;
+
+    if (x === y) {
+        header |= 1;
+    }
+
+    if (y === z) {
+        header |= 2;
+    }
+
+    if (x === z) {
+        header |= 4;
+    }
+
+    buffer.writeUint8(header);
+
+    if ((header & 7) === 7) {
+        //all components are the same
+        buffer.writeFloat32(x);
+    } else if (header === 1) {
+        //X and Y are the same, Z is different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(z);
+    } else if (header === 2) {
+        //Y and Z are the same, X is different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(y);
+    } else if (header === 4) {
+        //X and Z are the same, Y is different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(y);
+    } else {
+        //scale components are different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(y);
+        buffer.writeFloat32(z);
+    }
+}

package/src/core/primitives/numbers/computeHashFloat.js

@@ -5,10 +5,10 @@
  */
 export function computeHashFloat(v) {
     //we break the number up into fractional and whole parts
-    const fraction = v % 1;
-
     const whole = v | 0;
 
+    const fraction = v - whole;
+
     //fractional part is scaled up into int32 range, this inexact method, as it will produce 0 hash for values below a certain threshold
     const fractionHash = fraction * 1367130550;
 

package/src/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -4,7 +4,7 @@ import {
     bvh_query_user_data_overlaps_frustum
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 import { noop } from "../../../../core/function/Functions.js";
-import { read_frustum_planes_to_array } from "../../../../core/geom/3d/frustum/read_frustum_planes_to_array.js";
+import { read_three_planes_to_array } from "../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
 import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { CameraSystem } from '../../../graphics/ecs/camera/CameraSystem.js';
@@ -255,7 +255,7 @@ class TerrainSystem extends System {
 
                 for (let i = 0; i < frustums.length; i++) {
 
-                    read_frustum_planes_to_array(frustums[i].planes, frustum);
+                    read_three_planes_to_array(frustums[i].planes, frustum);
 
                     found_tiles += bvh_query_user_data_overlaps_frustum(tiles, tile_count, tileManager.bvh, frustum);
                 }

package/src/engine/ecs/terrain/ecs/makeTerrainWorkerProxy.js

@@ -70,7 +70,7 @@ export function makeTerrainWorkerProxy() {
                     resolve({
                         geometry: geometry,
                         bvh: {
-                            leaf_count: bvh.getLeafNodeCount(),
+                            leaf_count: bvh.leaf_node_count,
                             data: bvh.data
                         }
                     });

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -13,7 +13,6 @@ import {
     Vector3 as ThreeVector3
 } from 'three';
 import { BinaryUint32BVH } from "../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
-import { bvh32_query_user_data_ray } from "../../../../core/bvh2/binary/2/bvh32_query_user_data_ray.js";
 import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import Signal from "../../../../core/events/signal/Signal.js";
@@ -21,11 +20,11 @@ import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
-import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import Vector2 from '../../../../core/geom/Vector2.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
 import ObservedInteger from "../../../../core/model/ObservedInteger.js";
+import { bvh32_geometry_raycast } from "../../../graphics/geometry/buffered/query/bvh32_geometry_raycast.js";
 
 import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
 
@@ -33,9 +32,6 @@ import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
 const EMPTY_GEOMETRY = new ThreeBufferGeometry();
 const DEFAULT_MATERIAL = new MeshBasicMaterial();
 
-const scratch_array = []
-const scratch_hit = new SurfacePoint3()
-
 const ray_tmp = [];
 const m4_tmp = [];
 
@@ -191,52 +187,19 @@ class TerrainTile {
         const _directionY = ray_tmp[4];
         const _directionZ = ray_tmp[5];
 
-        const hit_count = bvh32_query_user_data_ray(
-            this.bvh,
-            scratch_array, 0,
-            _originX, _originY, _originZ,
-            _directionX, _directionY, _directionZ
-        );
-
-        let best_distance = Infinity;
-        let hit_found = false;
-
         const geometry = this.geometry;
 
         const geometryIndices = geometry.getIndex().array;
         const geometryPositions = geometry.getAttribute('position').array;
 
-        for (let i = 0; i < hit_count; i++) {
-            const triangle_index = scratch_array[i];
-
-            const index3 = triangle_index * 3;
-
-            const a = geometryIndices[index3] * 3;
-            const b = geometryIndices[index3 + 1] * 3;
-            const c = geometryIndices[index3 + 2] * 3;
-
-            const triangle_hit_found = computeTriangleRayIntersection(
-                scratch_hit,
-                _originX, _originY, _originZ,
-                _directionX, _directionY, _directionZ,
-                geometryPositions[a], geometryPositions[a + 1], geometryPositions[a + 2],
-                geometryPositions[b], geometryPositions[b + 1], geometryPositions[b + 2],
-                geometryPositions[c], geometryPositions[c + 1], geometryPositions[c + 2],
-            )
-
-            if (!triangle_hit_found) {
-                continue;
-            }
-
-            hit_found = true;
-
-            const distance_sqr = scratch_hit.position._distanceSqrTo(_originX, _originY, _originZ);
-
-            if (distance_sqr < best_distance) {
-                best_distance = distance_sqr;
-                result.copy(scratch_hit);
-            }
-        }
+        let hit_found = bvh32_geometry_raycast(
+            result,
+            this.bvh,
+            geometryPositions, 0, 3,
+            geometryIndices,
+            _originX, _originY, _originZ,
+            _directionX, _directionY, _directionZ
+        );
 
         if (hit_found) {
             result.applyMatrix4(m4);

package/src/engine/ecs/transform/Transform.js

@@ -2,15 +2,15 @@
  * Created by Alex on 02/04/2014.
  */
 
-import {assert} from "../../../core/assert.js";
-import {compose_matrix4_array} from "../../../core/geom/3d/compose_matrix4_array.js";
-import {decompose_matrix_4_array} from "../../../core/geom/3d/decompose_matrix_4_array.js";
-import {allocate_transform_m4} from "../../../core/geom/3d/matrix/allocate_transform_m4.js";
-import {m4_multiply} from "../../../core/geom/3d/matrix/m4_multiply.js";
-import {MATRIX_4_IDENTITY} from "../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
+import { assert } from "../../../core/assert.js";
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
+import { decompose_matrix_4_array } from "../../../core/geom/3d/decompose_matrix_4_array.js";
+import { allocate_transform_m4 } from "../../../core/geom/3d/matrix/allocate_transform_m4.js";
+import { m4_multiply } from "../../../core/geom/3d/matrix/m4_multiply.js";
+import { MATRIX_4_IDENTITY } from "../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
-import {TransformFlags} from "./TransformFlags.js";
+import { TransformFlags } from "./TransformFlags.js";
 
 /**
  *
@@ -261,8 +261,7 @@ export class Transform {
      * @returns {boolean}
      */
     equals(other) {
-        return other.isTransform
-            && this.position.equals(other.position)
+        return this.position.equals(other.position)
             && this.rotation.equals(other.rotation)
             && this.scale.equals(other.scale);
     }

package/src/engine/ecs/transform/TransformSerializationAdapter.js

@@ -1,3 +1,7 @@
+import { quat_decode_from_uint32 } from "../../../core/geom/3d/quaternion/quat_decode_from_uint32.js";
+import { quat_encode_to_uint32 } from "../../../core/geom/3d/quaternion/quat_encode_to_uint32.js";
+import { v3_binary_equality_decode } from "../../../core/geom/vec3/v3_binary_equality_decode.js";
+import { v3_binary_equality_encode } from "../../../core/geom/vec3/v3_binary_equality_encode.js";
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { Transform } from "./Transform.js";
 
@@ -23,11 +27,19 @@ export class TransformSerializationAdapter extends BinaryClassSerializationAdapt
         buffer.writeFloat64(positionY);
         buffer.writeFloat64(positionZ);
 
-        const encodedRotation = value.rotation.encodeToUint32();
+        const rotation = value.rotation;
+        const encoded_rotation = quat_encode_to_uint32(
+            rotation.x,
+            rotation.y,
+            rotation.z,
+            rotation.w
+        );
 
-        buffer.writeUint32(encodedRotation);
+        buffer.writeUint32(encoded_rotation);
 
-        value.scale.toBinaryBufferFloat32_EqualityEncoded(buffer);
+        const scale = value.scale;
+
+        v3_binary_equality_encode(buffer, scale.x, scale.y, scale.z);
     }
 
     /**
@@ -40,12 +52,11 @@ export class TransformSerializationAdapter extends BinaryClassSerializationAdapt
         const positionY = buffer.readFloat64();
         const positionZ = buffer.readFloat64();
 
-        const encodedRotation = buffer.readUint32();
+        const encoded_rotation = buffer.readUint32();
 
-        value.scale.fromBinaryBufferFloat32_EqualityEncoded(buffer);
+        v3_binary_equality_decode(buffer, value.scale, 0);
 
+        quat_decode_from_uint32(value.rotation, 0, encoded_rotation);
         value.position.set(positionX, positionY, positionZ);
-
-        value.rotation.decodeFromUint32(encodedRotation);
     }
 }

package/src/engine/graphics/ecs/mesh/Mesh.js

@@ -3,10 +3,8 @@
  */
 import { assert } from "../../../../core/assert.js";
 import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
-import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
-import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { applyTransformToThreeObject } from "./applyTransformToThreeObject.js";
@@ -25,6 +23,15 @@ export const MeshFlags = {
 
 const DEFAULT_FLAGS = 0;
 
+/**
+ *
+ * @type {number}
+ */
+const EQUALITY_FLAGS =
+    MeshFlags.CastShadow
+    | MeshFlags.ReceiveShadow
+;
+
 /**
  * Traversal stack
  * @type {Object3D[]}
@@ -255,13 +262,7 @@ class Mesh {
     }
 
     hash() {
-        let urlHash = computeStringHash(this.url);
-        return computeHashIntegerArray(
-            urlHash,
-            this.castShadow ? 1 : 0,
-            this.receiveShadow ? 1 : 0,
-            computeHashFloat(this.opacity)
-        );
+        return computeStringHash(this.url) ^ this.flags;
     }
 
     /**
@@ -271,9 +272,8 @@ class Mesh {
      */
     equals(other) {
         return this.url === other.url
+            && (this.flags & EQUALITY_FLAGS) === (other.flags & EQUALITY_FLAGS)
             && this.opacity === other.opacity
-            && this.castShadow === other.castShadow
-            && this.receiveShadow === other.receiveShadow
             ;
     }
 

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts

@@ -1,11 +1,11 @@
 import {BufferGeometry, Plane} from "three";
-import Vector3 from "../../../../../core/geom/Vector3";
 import {SurfacePoint3} from "../../../../../core/geom/3d/SurfacePoint3";
+import Vector3 from "../../../../../core/geom/Vector3";
 
 export class GeometrySpatialQueryAccelerator {
     constructor(cache_size?: number)
 
-    queryContainmentViaClippingPlanes(geometry: BufferGeometry, planes: Plane[]): number
+    queryContainmentViaClippingPlanes(geometry: BufferGeometry, planes: Plane[]): boolean
 
     queryRaycastNearest(destination: SurfacePoint3, geometry: BufferGeometry, ray_origin: Vector3, ray_direction: Vector3): boolean