@babylonjs/core 5.10.0 → 5.12.1

package/Maths/math.vector.d.ts

@@ -1852,6 +1852,13 @@ export declare class Quaternion {
      * @returns a new array populated with 4 elements from the quaternion coordinates
      */
     asArray(): number[];
+    /**
+     * Stores from the starting index in the given array the Quaternion successive values
+     * @param array defines the array where to store the x,y,z,w components
+     * @param index defines an optional index in the target array to define where to start storing values
+     * @returns the current Quaternion object
+     */
+    toArray(array: FloatArray, index?: number): Quaternion;
     /**
      * Check if two quaternions are equals
      * @param otherQuaternion defines the second operand

package/Maths/math.vector.js

@@ -1006,17 +1006,35 @@ var Vector3 = /** @class */ (function () {
      * @param result defines the Vector3 where to store the result
      */
     Vector3.prototype.projectOnPlaneToRef = function (plane, origin, result) {
-        var n = plane.normal;
-        var d = plane.d;
-        var V = MathTmp.Vector3[0];
-        // ray direction
-        this.subtractToRef(origin, V);
-        V.normalize();
-        var denom = Vector3.Dot(V, n);
-        var t = -(Vector3.Dot(origin, n) + d) / denom;
-        // P = P0 + t*V
-        var scaledV = V.scaleInPlace(t);
-        origin.addToRef(scaledV, result);
+        // Use the normal scaled to the plane offset as the origin for the formula
+        var planeOrigin = MathTmp.Vector3[0];
+        plane.normal.scaleToRef(-plane.d, planeOrigin);
+        // Since the normal in Babylon should point toward the viewer, invert it for the dot product
+        var inverseNormal = MathTmp.Vector3[1];
+        plane.normal.negateToRef(inverseNormal);
+        // This vector is the direction
+        var direction = this;
+        // Calculate how close the direction is to the normal of the plane
+        var dotProduct = Vector3.Dot(inverseNormal, direction);
+        /*
+         * Early out in case the direction will never hit the plane.
+         *
+         * Epsilon is used to avoid issues with rays very near to parallel with the
+         * plane, and squared because as of writing the value is not sufficiently
+         * small for this use case.
+         */
+        if (dotProduct <= Epsilon * Epsilon) {
+            // No good option for setting the result vector here, so just take the origin of the ray
+            result.copyFrom(origin);
+            return;
+        }
+        // Calculate the offset
+        var relativeOrigin = MathTmp.Vector3[2];
+        planeOrigin.subtractToRef(origin, relativeOrigin);
+        // Calculate the length along the direction vector to the hit point
+        var hitDistance = Vector3.Dot(relativeOrigin, inverseNormal) / dotProduct;
+        // Apply the hit point by adding the direction scaled by the distance to the origin
+        result.set(origin.x + direction.x * hitDistance, origin.y + direction.y * hitDistance, origin.z + direction.z * hitDistance);
     };
     /**
      * Returns true if the current Vector3 and the given vector coordinates are strictly equal
@@ -3159,6 +3177,20 @@ var Quaternion = /** @class */ (function () {
     Quaternion.prototype.asArray = function () {
         return [this._x, this._y, this._z, this._w];
     };
+    /**
+     * Stores from the starting index in the given array the Quaternion successive values
+     * @param array defines the array where to store the x,y,z,w components
+     * @param index defines an optional index in the target array to define where to start storing values
+     * @returns the current Quaternion object
+     */
+    Quaternion.prototype.toArray = function (array, index) {
+        if (index === void 0) { index = 0; }
+        array[index] = this.x;
+        array[index + 1] = this.y;
+        array[index + 2] = this.z;
+        array[index + 3] = this.w;
+        return this;
+    };
     /**
      * Check if two quaternions are equals
      * @param otherQuaternion defines the second operand