@mlightcad/geometry-engine 1.0.0

package/lib/math/AcGeQuaternion.js

@@ -0,0 +1,666 @@
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import * as MathUtils from '../util';
+var AcGeQuaternion = /** @class */ (function () {
+    /**
+     * Create one instance of this class
+     * @param x Input x coordinate
+     * @param y Input y coordinate
+     * @param z Input z coordinate
+     * @param w Input w coordinate
+     */
+    function AcGeQuaternion(x, y, z, w) {
+        if (x === void 0) { x = 0; }
+        if (y === void 0) { y = 0; }
+        if (z === void 0) { z = 0; }
+        if (w === void 0) { w = 1; }
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
+    }
+    /**
+     * This SLERP implementation assumes the quaternion data are managed in flat arrays.
+     * @param dst Input the output array
+     * @param dstOffset Input an offset into the output array
+     * @param src0 Input the source array of the starting quaternion.
+     * @param srcOffset0 Input an offset into the array src0.
+     * @param src1 Input the source array of the target quaternion.
+     * @param srcOffset1 Input an offset into the array src1.
+     * @param t Input normalized interpolation factor (between 0 and 1).
+     */
+    AcGeQuaternion.slerpFlat = function (dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
+        // fuzz-free, array-based Quaternion SLERP operation
+        var x0 = src0[srcOffset0 + 0], y0 = src0[srcOffset0 + 1], z0 = src0[srcOffset0 + 2], w0 = src0[srcOffset0 + 3];
+        var x1 = src1[srcOffset1 + 0], y1 = src1[srcOffset1 + 1], z1 = src1[srcOffset1 + 2], w1 = src1[srcOffset1 + 3];
+        if (t === 0) {
+            dst[dstOffset + 0] = x0;
+            dst[dstOffset + 1] = y0;
+            dst[dstOffset + 2] = z0;
+            dst[dstOffset + 3] = w0;
+            return;
+        }
+        if (t === 1) {
+            dst[dstOffset + 0] = x1;
+            dst[dstOffset + 1] = y1;
+            dst[dstOffset + 2] = z1;
+            dst[dstOffset + 3] = w1;
+            return;
+        }
+        if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
+            var s = 1 - t;
+            var cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, dir = cos >= 0 ? 1 : -1, sqrSin = 1 - cos * cos;
+            // Skip the Slerp for tiny steps to avoid numeric problems:
+            if (sqrSin > Number.EPSILON) {
+                var sin = Math.sqrt(sqrSin), len = Math.atan2(sin, cos * dir);
+                s = Math.sin(s * len) / sin;
+                t = Math.sin(t * len) / sin;
+            }
+            var tDir = t * dir;
+            x0 = x0 * s + x1 * tDir;
+            y0 = y0 * s + y1 * tDir;
+            z0 = z0 * s + z1 * tDir;
+            w0 = w0 * s + w1 * tDir;
+            // Normalize in case we just did a lerp:
+            if (s === 1 - t) {
+                var f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
+                x0 *= f;
+                y0 *= f;
+                z0 *= f;
+                w0 *= f;
+            }
+        }
+        dst[dstOffset] = x0;
+        dst[dstOffset + 1] = y0;
+        dst[dstOffset + 2] = z0;
+        dst[dstOffset + 3] = w0;
+    };
+    /**
+     * This multiplication implementation assumes the quaternion data are managed in flat arrays.
+     * @param dst Input the output array.
+     * @param dstOffset Input an offset into the output array.
+     * @param src0 Input the source array of the starting quaternion.
+     * @param srcOffset0 Input an offset into the array src0.
+     * @param src1 Input the source array of the target quaternion.
+     * @param srcOffset1 Input an offset into the array src1.
+     * @returns Return an array
+     */
+    AcGeQuaternion.multiplyQuaternionsFlat = function (dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
+        var x0 = src0[srcOffset0];
+        var y0 = src0[srcOffset0 + 1];
+        var z0 = src0[srcOffset0 + 2];
+        var w0 = src0[srcOffset0 + 3];
+        var x1 = src1[srcOffset1];
+        var y1 = src1[srcOffset1 + 1];
+        var z1 = src1[srcOffset1 + 2];
+        var w1 = src1[srcOffset1 + 3];
+        dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
+        dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
+        dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
+        dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
+        return dst;
+    };
+    Object.defineProperty(AcGeQuaternion.prototype, "x", {
+        /**
+         * X cooridinate
+         */
+        get: function () {
+            return this._x;
+        },
+        set: function (value) {
+            this._x = value;
+            this._onChangeCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcGeQuaternion.prototype, "y", {
+        /**
+         * Y cooridinate
+         */
+        get: function () {
+            return this._y;
+        },
+        set: function (value) {
+            this._y = value;
+            this._onChangeCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcGeQuaternion.prototype, "z", {
+        /**
+         * Z cooridinate
+         */
+        get: function () {
+            return this._z;
+        },
+        set: function (value) {
+            this._z = value;
+            this._onChangeCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcGeQuaternion.prototype, "w", {
+        /**
+         * W cooridinate
+         */
+        get: function () {
+            return this._w;
+        },
+        set: function (value) {
+            this._w = value;
+            this._onChangeCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Set x, y, z, w properties of this quaternion.
+     * @param x Input x coordinate
+     * @param y Input y coordinate
+     * @param z Input z coordinate
+     * @param w Input w coordinate
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.set = function (x, y, z, w) {
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Create a new quaternion with identical x, y, z and w properties to this one.
+     * @returns Return cloned instance
+     */
+    AcGeQuaternion.prototype.clone = function () {
+        return new AcGeQuaternion(this._x, this._y, this._z, this._w);
+    };
+    /**
+     * Copy the x, y, z and w properties of q into this quaternion.
+     * @param quaternion Input the quaternion copied from
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.copy = function (quaternion) {
+        this._x = quaternion.x;
+        this._y = quaternion.y;
+        this._z = quaternion.z;
+        this._w = quaternion.w;
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Sets this quaternion from the rotation specified by euler angle.
+     * @param euler Input one euler angle
+     * @param update Input one flag whether to trigger change callback function
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.setFromEuler = function (euler, update) {
+        if (update === void 0) { update = true; }
+        var x = euler.x, y = euler.y, z = euler.z, order = euler.order;
+        // http://www.mathworks.com/matlabcentral/fileexchange/
+        // 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
+        //	content/SpinCalc.m
+        var cos = Math.cos;
+        var sin = Math.sin;
+        var c1 = cos(x / 2);
+        var c2 = cos(y / 2);
+        var c3 = cos(z / 2);
+        var s1 = sin(x / 2);
+        var s2 = sin(y / 2);
+        var s3 = sin(z / 2);
+        switch (order) {
+            case 'XYZ':
+                this._x = s1 * c2 * c3 + c1 * s2 * s3;
+                this._y = c1 * s2 * c3 - s1 * c2 * s3;
+                this._z = c1 * c2 * s3 + s1 * s2 * c3;
+                this._w = c1 * c2 * c3 - s1 * s2 * s3;
+                break;
+            case 'YXZ':
+                this._x = s1 * c2 * c3 + c1 * s2 * s3;
+                this._y = c1 * s2 * c3 - s1 * c2 * s3;
+                this._z = c1 * c2 * s3 - s1 * s2 * c3;
+                this._w = c1 * c2 * c3 + s1 * s2 * s3;
+                break;
+            case 'ZXY':
+                this._x = s1 * c2 * c3 - c1 * s2 * s3;
+                this._y = c1 * s2 * c3 + s1 * c2 * s3;
+                this._z = c1 * c2 * s3 + s1 * s2 * c3;
+                this._w = c1 * c2 * c3 - s1 * s2 * s3;
+                break;
+            case 'ZYX':
+                this._x = s1 * c2 * c3 - c1 * s2 * s3;
+                this._y = c1 * s2 * c3 + s1 * c2 * s3;
+                this._z = c1 * c2 * s3 - s1 * s2 * c3;
+                this._w = c1 * c2 * c3 + s1 * s2 * s3;
+                break;
+            case 'YZX':
+                this._x = s1 * c2 * c3 + c1 * s2 * s3;
+                this._y = c1 * s2 * c3 + s1 * c2 * s3;
+                this._z = c1 * c2 * s3 - s1 * s2 * c3;
+                this._w = c1 * c2 * c3 - s1 * s2 * s3;
+                break;
+            case 'XZY':
+                this._x = s1 * c2 * c3 - c1 * s2 * s3;
+                this._y = c1 * s2 * c3 - s1 * c2 * s3;
+                this._z = c1 * c2 * s3 + s1 * s2 * c3;
+                this._w = c1 * c2 * c3 + s1 * s2 * s3;
+                break;
+            default:
+                console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' +
+                    order);
+        }
+        if (update === true)
+            this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Set this quaternion from rotation specified by axis and angle. Axis is assumed to be normalized,
+     * angle is in radians.
+     * @param axis Input one normalized axis
+     * @param angle Input one angle in radians
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.setFromAxisAngle = function (axis, angle) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
+        // assumes axis is normalized
+        var halfAngle = angle / 2, s = Math.sin(halfAngle);
+        this._x = axis.x * s;
+        this._y = axis.y * s;
+        this._z = axis.z * s;
+        this._w = Math.cos(halfAngle);
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Set this quaternion from rotation component of the specified matrix.
+     * @param m Input a Matrix4 of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.setFromRotationMatrix = function (m) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+        var te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10], trace = m11 + m22 + m33;
+        if (trace > 0) {
+            var s = 0.5 / Math.sqrt(trace + 1.0);
+            this._w = 0.25 / s;
+            this._x = (m32 - m23) * s;
+            this._y = (m13 - m31) * s;
+            this._z = (m21 - m12) * s;
+        }
+        else if (m11 > m22 && m11 > m33) {
+            var s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
+            this._w = (m32 - m23) / s;
+            this._x = 0.25 * s;
+            this._y = (m12 + m21) / s;
+            this._z = (m13 + m31) / s;
+        }
+        else if (m22 > m33) {
+            var s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
+            this._w = (m13 - m31) / s;
+            this._x = (m12 + m21) / s;
+            this._y = 0.25 * s;
+            this._z = (m23 + m32) / s;
+        }
+        else {
+            var s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
+            this._w = (m21 - m12) / s;
+            this._x = (m13 + m31) / s;
+            this._y = (m23 + m32) / s;
+            this._z = 0.25 * s;
+        }
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Set this quaternion to the rotation required to rotate direction vector vFrom to direction vector vTo.
+     * @param vFrom Input one normalized direction vector
+     * @param vTo Input one normalized direction vector
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.setFromUnitVectors = function (vFrom, vTo) {
+        // assumes direction vectors vFrom and vTo are normalized
+        var r = vFrom.dot(vTo) + 1;
+        if (r < Number.EPSILON) {
+            // vFrom and vTo point in opposite directions
+            r = 0;
+            if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
+                this._x = -vFrom.y;
+                this._y = vFrom.x;
+                this._z = 0;
+                this._w = r;
+            }
+            else {
+                this._x = 0;
+                this._y = -vFrom.z;
+                this._z = vFrom.y;
+                this._w = r;
+            }
+        }
+        else {
+            // crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
+            this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
+            this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
+            this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
+            this._w = r;
+        }
+        return this.normalize();
+    };
+    /**
+     * Return the angle between this quaternion and quaternion q in radians.
+     * @param q Input one quaternion
+     * @returns Return the angle between this quaternion and quaternion q in radians.
+     */
+    AcGeQuaternion.prototype.angleTo = function (q) {
+        return 2 * Math.acos(Math.abs(MathUtils.clamp(this.dot(q), -1, 1)));
+    };
+    /**
+     * Rotate this quaternion by a given angular step to the defined quaternion q. The method ensures
+     * that the final quaternion will not overshoot q.
+     * @param q Input the target quaternion.
+     * @param step Input the angular step in radians.
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.rotateTowards = function (q, step) {
+        var angle = this.angleTo(q);
+        if (angle === 0)
+            return this;
+        var t = Math.min(1, step / angle);
+        this.slerp(q, t);
+        return this;
+    };
+    /**
+     * Set this quaternion to the identity quaternion; that is, to the quaternion that represents
+     * "no rotation".
+     * @returns Return this quaternion.
+     */
+    AcGeQuaternion.prototype.identity = function () {
+        return this.set(0, 0, 0, 1);
+    };
+    /**
+     * Invert this quaternion - calculates the conjugate. The quaternion is assumed to have unit length.
+     * @returns Return this quaternion.
+     */
+    AcGeQuaternion.prototype.invert = function () {
+        // quaternion is assumed to have unit length
+        return this.conjugate();
+    };
+    /**
+     * Return the rotational conjugate of this quaternion. The conjugate of a quaternion represents the
+     * same rotation in the opposite direction about the rotational axis.
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.conjugate = function () {
+        this._x *= -1;
+        this._y *= -1;
+        this._z *= -1;
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Calculate the dot product of quaternions v and this one.
+     * @param v Input one quaternion
+     * @returns Return the dot product of quaternions v and this one
+     */
+    AcGeQuaternion.prototype.dot = function (v) {
+        return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
+    };
+    /**
+     * Compute the squared Euclidean length (straight-line length) of this quaternion, considered as a
+     * 4 dimensional vector. This can be useful if you are comparing the lengths of two quaternions, as
+     * this is a slightly more efficient calculation than length().
+     * @returns Return the squared Euclidean length (straight-line length) of this quaternion
+     */
+    AcGeQuaternion.prototype.lengthSq = function () {
+        return (this._x * this._x +
+            this._y * this._y +
+            this._z * this._z +
+            this._w * this._w);
+    };
+    /**
+     * Compute the Euclidean length (straight-line length) of this quaternion, considered as a 4 dimensional
+     * vector.
+     * @returns Return the Euclidean length (straight-line length) of this quaternion.
+     */
+    AcGeQuaternion.prototype.length = function () {
+        return Math.sqrt(this._x * this._x +
+            this._y * this._y +
+            this._z * this._z +
+            this._w * this._w);
+    };
+    /**
+     * Normalize this quaternion - that is, calculated the quaternion that performs the same rotation as
+     * this one, but has length equal to 1.
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.normalize = function () {
+        var l = this.length();
+        if (l === 0) {
+            this._x = 0;
+            this._y = 0;
+            this._z = 0;
+            this._w = 1;
+        }
+        else {
+            l = 1 / l;
+            this._x = this._x * l;
+            this._y = this._y * l;
+            this._z = this._z * l;
+            this._w = this._w * l;
+        }
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Multiply this quaternion by q.
+     * @param q Input one quaternion to multiply
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.multiply = function (q) {
+        return this.multiplyQuaternions(this, q);
+    };
+    /**
+     * Pre-multiply this quaternion by q.
+     * @param q Input one quaternion
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.premultiply = function (q) {
+        return this.multiplyQuaternions(q, this);
+    };
+    /**
+     * Sets this quaternion to a x b.
+     * @param a Input one quaternion
+     * @param b Input one quaternion
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.multiplyQuaternions = function (a, b) {
+        // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+        var qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
+        var qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
+        this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+        this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+        this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+        this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Handles the spherical linear interpolation between quaternions. t represents the amount of rotation
+     * between this quaternion (where t is 0) and qb (where t is 1).
+     * @param qb Input the other quaternion rotation
+     * @param t Input interpolation factor in the closed interval [0, 1].
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.slerp = function (qb, t) {
+        if (t === 0)
+            return this;
+        if (t === 1)
+            return this.copy(qb);
+        var x = this._x, y = this._y, z = this._z, w = this._w;
+        // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
+        var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
+        if (cosHalfTheta < 0) {
+            this._w = -qb._w;
+            this._x = -qb._x;
+            this._y = -qb._y;
+            this._z = -qb._z;
+            cosHalfTheta = -cosHalfTheta;
+        }
+        else {
+            this.copy(qb);
+        }
+        if (cosHalfTheta >= 1.0) {
+            this._w = w;
+            this._x = x;
+            this._y = y;
+            this._z = z;
+            return this;
+        }
+        var sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
+        if (sqrSinHalfTheta <= Number.EPSILON) {
+            var s = 1 - t;
+            this._w = s * w + t * this._w;
+            this._x = s * x + t * this._x;
+            this._y = s * y + t * this._y;
+            this._z = s * z + t * this._z;
+            this.normalize(); // normalize calls _onChangeCallback()
+            return this;
+        }
+        var sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
+        var halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
+        var ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta, ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+        this._w = w * ratioA + this._w * ratioB;
+        this._x = x * ratioA + this._x * ratioB;
+        this._y = y * ratioA + this._y * ratioB;
+        this._z = z * ratioA + this._z * ratioB;
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Perform a spherical linear interpolation between the given quaternions and stores the result in
+     * this quaternion.
+     * @param qa Input one quaternion rotation
+     * @param qb Input the other quaternion rotation
+     * @param t Input interpolation factor in the closed interval [0, 1].
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.slerpQuaternions = function (qa, qb, t) {
+        return this.copy(qa).slerp(qb, t);
+    };
+    /**
+     * Set this quaternion to a uniformly random, normalized quaternion.
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.random = function () {
+        // sets this quaternion to a uniform random unit quaternnion
+        // Ken Shoemake
+        // Uniform random rotations
+        // D. Kirk, editor, Graphics Gems III, pages 124-132. Academic Press, New York, 1992.
+        var theta1 = 2 * Math.PI * Math.random();
+        var theta2 = 2 * Math.PI * Math.random();
+        var x0 = Math.random();
+        var r1 = Math.sqrt(1 - x0);
+        var r2 = Math.sqrt(x0);
+        return this.set(r1 * Math.sin(theta1), r1 * Math.cos(theta1), r2 * Math.sin(theta2), r2 * Math.cos(theta2));
+    };
+    /**
+     * Compare the x, y, z and w properties of v to the equivalent properties of this quaternion to
+     * determine if they represent the same rotation.
+     * @param quaternion Input quaternion that this quaternion will be compared to.
+     * @returns Return true if the specified quaternion and this quaternion represent the same rotation.
+     */
+    AcGeQuaternion.prototype.equals = function (quaternion) {
+        return (quaternion._x === this._x &&
+            quaternion._y === this._y &&
+            quaternion._z === this._z &&
+            quaternion._w === this._w);
+    };
+    /**
+     * Set this quaternion's x, y, z and w properties from an array.
+     * @param array Input an array of format (x, y, z, w) used to construct the quaternion.
+     * @param offset Input an optional offset into the array
+     * @returns Return this quaternion
+     */
+    AcGeQuaternion.prototype.fromArray = function (array, offset) {
+        if (offset === void 0) { offset = 0; }
+        this._x = array[offset];
+        this._y = array[offset + 1];
+        this._z = array[offset + 2];
+        this._w = array[offset + 3];
+        this._onChangeCallback();
+        return this;
+    };
+    /**
+     * Return the numerical elements of this quaternion in an array of format [x, y, z, w].
+     * @param array Input an optional array to store the quaternion. If not specified, a new array will be created.
+     * @param offset (optional) if specified, the result will be copied into this Array.
+     * @returns Return an array
+     */
+    AcGeQuaternion.prototype.toArray = function (array, offset) {
+        if (array === void 0) { array = []; }
+        if (offset === void 0) { offset = 0; }
+        array[offset] = this._x;
+        array[offset + 1] = this._y;
+        array[offset + 2] = this._z;
+        array[offset + 3] = this._w;
+        return array;
+    };
+    AcGeQuaternion.prototype.toJSON = function () {
+        return this.toArray();
+    };
+    AcGeQuaternion.prototype._onChange = function (callback) {
+        this._onChangeCallback = callback;
+        return this;
+    };
+    AcGeQuaternion.prototype._onChangeCallback = function () { };
+    AcGeQuaternion.prototype[Symbol.iterator] = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, this._x];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, this._y];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, this._z];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, this._w];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
+    return AcGeQuaternion;
+}());
+export { AcGeQuaternion };
+//# sourceMappingURL=AcGeQuaternion.js.map