@babylonjs/core 7.35.1 → 7.36.0

package/Maths/math.vector.d.ts

@@ -84,6 +84,14 @@ export declare class Vector2 implements Vector<Tuple<number, 2>, IVector2Like>,
     x: number;
     /** [0] defines the second coordinate */
     y: number;
+    /**
+     * If the first vector is flagged with integers (as everything is 0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+     * If subsequent vectors are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+     * and henceforth it will use floating-point representation for all Vector2 instances that it creates.
+     * But the original Vector2 instances are unchanged and has a "deprecated map".
+     * If we keep using the Vector2 instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+     */
+    static _V8PerformanceHack: DeepImmutable<Vector2>;
     private static _ZeroReadOnly;
     /**
      * @see Tensor.dimension
@@ -727,6 +735,14 @@ export declare class Vector2 implements Vector<Tuple<number, 2>, IVector2Like>,
  * Example Playground - Overview - https://playground.babylonjs.com/#R1F8YU
  */
 export declare class Vector3 implements Vector<Tuple<number, 3>, Vector3LikeInternal>, IVector3Like {
+    /**
+     * If the first vector is flagged with integers (as everything is 0,0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+     * If subsequent vectors are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+     * and henceforth it will use floating-point representation for all Vector3 instances that it creates.
+     * But the original Vector3 instances are unchanged and has a "deprecated map".
+     * If we keep using the Vector3 instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+     */
+    static _V8PerformanceHack: DeepImmutable<Vector3>;
     private static _UpReadOnly;
     private static _DownReadOnly;
     private static _LeftHandedForwardReadOnly;
@@ -1856,6 +1872,14 @@ export declare class Vector4 implements Vector<Tuple<number, 4>, IVector4Like>,
     z: number;
     /** [0] w value of the vector */
     w: number;
+    /**
+     * If the first vector is flagged with integers (as everything is 0,0,0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+     * If subsequent vectors are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+     * and henceforth it will use floating-point representation for all Vector4 instances that it creates.
+     * But the original Vector4 instances are unchanged and has a "deprecated map".
+     * If we keep using the Vector4 instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+     */
+    static _V8PerformanceHack: DeepImmutable<Vector4>;
     private static _ZeroReadOnly;
     /**
      * @see Tensor.dimension
@@ -2452,6 +2476,14 @@ export declare class Vector4 implements Vector<Tuple<number, 4>, IVector4Like>,
  * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms
  */
 export declare class Quaternion implements Tensor<Tuple<number, 4>, Quaternion>, IQuaternionLike {
+    /**
+     * If the first quaternion is flagged with integers (as everything is 0,0,0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+     * If subsequent quaternion are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+     * and henceforth it will use floating-point representation for all quaternion instances that it creates.
+     * But the original quaternion instances are unchanged and has a "deprecated map".
+     * If we keep using the quaternion instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+     */
+    static _V8PerformanceHack: DeepImmutable<Quaternion>;
     /** @internal */
     _x: number;
     /** @internal */

package/Maths/math.vector.js

@@ -933,6 +933,14 @@ export class Vector2 {
         return Vector2.Distance(p, proj);
     }
 }
+/**
+ * If the first vector is flagged with integers (as everything is 0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+ * If subsequent vectors are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+ * and henceforth it will use floating-point representation for all Vector2 instances that it creates.
+ * But the original Vector2 instances are unchanged and has a "deprecated map".
+ * If we keep using the Vector2 instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+ */
+Vector2._V8PerformanceHack = new Vector2(0.5, 0.5);
 Vector2._ZeroReadOnly = Vector2.Zero();
 Vector2;
 Object.defineProperties(Vector2.prototype, {
@@ -2851,6 +2859,14 @@ export class Vector3 {
         return ref;
     }
 }
+/**
+ * If the first vector is flagged with integers (as everything is 0,0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+ * If subsequent vectors are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+ * and henceforth it will use floating-point representation for all Vector3 instances that it creates.
+ * But the original Vector3 instances are unchanged and has a "deprecated map".
+ * If we keep using the Vector3 instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+ */
+Vector3._V8PerformanceHack = new Vector3(0.5, 0.5, 0.5);
 Vector3._UpReadOnly = Vector3.Up();
 Vector3._DownReadOnly = Vector3.Down();
 Vector3._LeftHandedForwardReadOnly = Vector3.Forward(false);
@@ -3816,6 +3832,14 @@ export class Vector4 {
         return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w;
     }
 }
+/**
+ * If the first vector is flagged with integers (as everything is 0,0,0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+ * If subsequent vectors are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+ * and henceforth it will use floating-point representation for all Vector4 instances that it creates.
+ * But the original Vector4 instances are unchanged and has a "deprecated map".
+ * If we keep using the Vector4 instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+ */
+Vector4._V8PerformanceHack = new Vector4(0.5, 0.5, 0.5, 0.5);
 Vector4._ZeroReadOnly = Vector4.Zero();
 Vector4;
 Object.defineProperties(Vector4.prototype, {
@@ -5173,6 +5197,14 @@ export class Quaternion {
         return ref.copyFromFloats((value1.x + value2.x) / 2, (value1.y + value2.y) / 2, (value1.z + value2.z) / 2, (value1.w + value2.w) / 2);
     }
 }
+/**
+ * If the first quaternion is flagged with integers (as everything is 0,0,0,0), V8 stores all of the properties as integers internally because it doesn't know any better yet.
+ * If subsequent quaternion are created with non-integer values, V8 determines that it would be best to represent these properties as doubles instead of integers,
+ * and henceforth it will use floating-point representation for all quaternion instances that it creates.
+ * But the original quaternion instances are unchanged and has a "deprecated map".
+ * If we keep using the quaternion instances from step 1, it will now be a poison pill which will mess up optimizations in any code it touches.
+ */
+Quaternion._V8PerformanceHack = new Quaternion(0.5, 0.5, 0.5, 0.5);
 Quaternion;
 Object.defineProperties(Quaternion.prototype, {
     dimension: { value: [4] },