@woosh/meep-engine 2.69.0 → 2.70.0

package/src/core/geom/Vector2.js

@@ -546,11 +546,7 @@ class Vector2 {
         const x = computeHashFloat(this.x);
         const y = computeHashFloat(this.y);
 
-        let hash = ((x << 5) - x) + y;
-
-        hash |= 0; //convert to 32bit int
-
-        return hash;
+        return ((x << 5) - x) + y;
     }
 
     /**
@@ -561,8 +557,11 @@ class Vector2 {
         const sin = Math.sin(angle);
         const cos = Math.cos(angle);
 
-        const x = this.x * cos - this.y * sin
-        const y = this.x * sin + this.y * cos;
+        const _x = this.x;
+        const _y = this.y;
+
+        const x = _x * cos - _y * sin
+        const y = _x * sin + _y * cos;
 
         this.set(x, y);
     }

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/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
             ;
     }