@galacean/engine-xr-webxr 1.6.8 → 1.6.10

package/dist/module.js

@@ -0,0 +1,3620 @@
+import { XRTrackedInputDevice, XRTrackingState, XRInputEventType, XRTargetRayMode, XRFeatureType, XRRequestTrackingState, XRPlaneMode } from '@galacean/engine-xr';
+
+function _defineProperties$1(target, props) {
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+
+        if ("value" in descriptor) descriptor.writable = true;
+
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$1(Constructor, staticProps);
+
+    return Constructor;
+}
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+
+        return o;
+    };
+
+    return _set_prototype_of(o, p);
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function _is_native_reflect_construct() {
+    // Since Reflect.construct can't be properly polyfilled, some
+    // implementations (e.g. core-js@2) don't set the correct internal slots.
+    // Those polyfills don't allow us to subclass built-ins, so we need to
+    // use our fallback implementation.
+    try {
+        // If the internal slots aren't set, this throws an error similar to
+        //   TypeError: this is not a Boolean object.
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+
+            if (Class) _set_prototype_of(instance, Class.prototype);
+
+            return instance;
+        };
+    }
+
+    return _construct.apply(null, arguments);
+}
+
+function parseXRMode(mode) {
+    switch(mode){
+        case 1:
+            return "immersive-ar";
+        case 2:
+            return "immersive-vr";
+        default:
+            return null;
+    }
+}
+function getInputSource(inputSource) {
+    var type;
+    switch(inputSource.targetRayMode){
+        case "gaze":
+            break;
+        case "screen":
+            return XRTrackedInputDevice.Controller;
+        case "tracked-pointer":
+            if (inputSource.hand) {
+                switch(inputSource.handedness){
+                    case "left":
+                        return XRTrackedInputDevice.LeftHand;
+                    case "right":
+                        return XRTrackedInputDevice.RightHand;
+                }
+            } else {
+                switch(inputSource.handedness){
+                    case "left":
+                        return XRTrackedInputDevice.LeftController;
+                    case "right":
+                        return XRTrackedInputDevice.RightController;
+                }
+            }
+            break;
+    }
+    return type;
+}
+function viewToCamera(type) {
+    switch(type){
+        case "left":
+            return XRTrackedInputDevice.LeftCamera;
+        case "right":
+            return XRTrackedInputDevice.RightCamera;
+        default:
+            return XRTrackedInputDevice.Camera;
+    }
+}
+
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+/**
+ * Common utility methods for math operations.
+ */ var MathUtil = /*#__PURE__*/ function() {
+    function MathUtil() {}
+    /**
+   * Clamps the specified value.
+   * @param v - The specified value
+   * @param min - The min value
+   * @param max - The max value
+   * @returns The result of clamping a value between min and max
+   */ MathUtil.clamp = function clamp(v, min, max) {
+        return Math.max(min, Math.min(max, v));
+    };
+    /**
+   * Checks if a and b are almost equals.
+   * The absolute value of the difference between a and b is close to zero.
+   * @param a - The left value to compare
+   * @param b - The right value to compare
+   * @returns True if a almost equal to b, false otherwise
+   */ MathUtil.equals = function equals(a, b) {
+        return Math.abs(a - b) <= MathUtil.zeroTolerance;
+    };
+    /**
+   * Determines whether the specified v is pow2.
+   * @param v - The specified v
+   * @returns True if the specified v is pow2, false otherwise
+   */ MathUtil.isPowerOf2 = function isPowerOf2(v) {
+        return (v & v - 1) === 0;
+    };
+    /**
+   * Modify the specified r from radian to degree.
+   * @param r - The specified r
+   * @returns The degree value
+   */ MathUtil.radianToDegree = function radianToDegree(r) {
+        return r * MathUtil.radToDegreeFactor;
+    };
+    /**
+   * Modify the specified d from degree to radian.
+   * @param d - The specified d
+   * @returns The radian value
+   */ MathUtil.degreeToRadian = function degreeToRadian(d) {
+        return d * MathUtil.degreeToRadFactor;
+    };
+    /**
+   * Linearly interpolate between two values
+   * @param start - Specify the start of the range in which to interpolate
+   * @param end - Specify the end of the range in which to interpolate
+   * @param t - The blend amount where 0 returns start and 1 end
+   * @returns The result of linear blending between start and end
+   */ MathUtil.lerp = function lerp(start, end, t) {
+        return start + (end - start) * t;
+    };
+    return MathUtil;
+}();
+/** The value for which all absolute numbers smaller than are considered equal to zero. */ MathUtil.zeroTolerance = 1e-6;
+/** The conversion factor that radian to degree. */ MathUtil.radToDegreeFactor = 180 / Math.PI;
+/** The conversion factor that degree to radian. */ MathUtil.degreeToRadFactor = Math.PI / 180;
+/**
+ * Describes a 3D-vector.
+ */ var Vector3 = /*#__PURE__*/ function() {
+    function Vector3(x, y, z) {
+        if (x === void 0) x = 0;
+        if (y === void 0) y = 0;
+        if (z === void 0) z = 0;
+        /** @internal */ this._onValueChanged = null;
+        this._x = x;
+        this._y = y;
+        this._z = z;
+    }
+    var _proto = Vector3.prototype;
+    /**
+   * Set the value of this vector.
+   * @param x - The x component of the vector
+   * @param y - The y component of the vector
+   * @param z - The z component of the vector
+   * @returns This vector
+   */ _proto.set = function set(x, y, z) {
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Determines the sum of this vector and the specified vector.
+   * @param right - The specified vector
+   * @returns This vector
+   */ _proto.add = function add(right) {
+        this._x += right._x;
+        this._y += right._y;
+        this._z += right._z;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Determines the difference of this vector and the specified vector.
+   * @param right - The specified vector
+   * @returns This vector
+   */ _proto.subtract = function subtract(right) {
+        this._x -= right._x;
+        this._y -= right._y;
+        this._z -= right._z;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Determines the product of this vector and the specified vector.
+   * @param right - The specified vector
+   * @returns This vector
+   */ _proto.multiply = function multiply(right) {
+        this._x *= right._x;
+        this._y *= right._y;
+        this._z *= right._z;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Determines the divisor of this vector and the specified vector.
+   * @param right - The specified vector
+   * @returns This vector
+   */ _proto.divide = function divide(right) {
+        this._x /= right._x;
+        this._y /= right._y;
+        this._z /= right._z;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Calculate the length of this vector.
+   * @returns The length of this vector
+   */ _proto.length = function length() {
+        var _this = this, _x = _this._x, _y = _this._y, _z = _this._z;
+        return Math.sqrt(_x * _x + _y * _y + _z * _z);
+    };
+    /**
+   * Calculate the squared length of this vector.
+   * @returns The squared length of this vector
+   */ _proto.lengthSquared = function lengthSquared() {
+        var _this = this, _x = _this._x, _y = _this._y, _z = _this._z;
+        return _x * _x + _y * _y + _z * _z;
+    };
+    /**
+   * Reverses the direction of this vector.
+   * @returns This vector
+   */ _proto.negate = function negate() {
+        this._x = -this._x;
+        this._y = -this._y;
+        this._z = -this._z;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Converts this vector into a unit vector.
+   * @returns This vector
+   */ _proto.normalize = function normalize() {
+        Vector3.normalize(this, this);
+        return this;
+    };
+    /**
+   * Scale this vector by the given value.
+   * @param s - The amount by which to scale the vector
+   * @returns This vector
+   */ _proto.scale = function scale(s) {
+        this._x *= s;
+        this._y *= s;
+        this._z *= s;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * This vector performs a normal transformation using the given 4x4 matrix.
+   * @remarks
+   * A normal transform performs the transformation with the assumption that the w component
+   * is zero. This causes the fourth row and fourth column of the matrix to be unused. The
+   * end result is a vector that is not translated, but all other transformation properties
+   * apply. This is often preferred for normal vectors as normals purely represent direction
+   * rather than location because normal vectors should not be translated.
+   * @param m - The transform matrix
+   * @returns This vector
+   */ _proto.transformNormal = function transformNormal(m) {
+        Vector3.transformNormal(this, m, this);
+        return this;
+    };
+    /**
+   * This vector performs a transformation using the given 4x4 matrix.
+   * @param m - The transform matrix
+   * @returns This vector
+   */ _proto.transformToVec3 = function transformToVec3(m) {
+        Vector3.transformToVec3(this, m, this);
+        return this;
+    };
+    /**
+   * This vector performs a coordinate transformation using the given 4x4 matrix.
+   * @remarks
+   * A coordinate transform performs the transformation with the assumption that the w component
+   * is one. The four dimensional vector obtained from the transformation operation has each
+   * component in the vector divided by the w component. This forces the w-component to be one and
+   * therefore makes the vector homogeneous. The homogeneous vector is often preferred when working
+   * with coordinates as the w component can safely be ignored.
+   * @param m - The transform matrix
+   * @returns This vector
+   */ _proto.transformCoordinate = function transformCoordinate(m) {
+        Vector3.transformCoordinate(this, m, this);
+        return this;
+    };
+    /**
+   * This vector performs a transformation using the given quaternion.
+   * @param quaternion - The transform quaternion
+   * @returns This vector
+   */ _proto.transformByQuat = function transformByQuat(quaternion) {
+        Vector3.transformByQuat(this, quaternion, this);
+        return this;
+    };
+    /**
+   * Creates a clone of this vector.
+   * @returns A clone of this vector
+   */ _proto.clone = function clone() {
+        return new Vector3(this._x, this._y, this._z);
+    };
+    /**
+   * Copy from vector3 like object.
+   * @param source - Vector3 like object.
+   * @returns This vector
+   */ _proto.copyFrom = function copyFrom(source) {
+        this._x = source.x;
+        this._y = source.y;
+        this._z = source.z;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Copy to vector3 like object.
+   * @param target - Vector3 like object
+   * @returns This Vector3 like object
+   */ _proto.copyTo = function copyTo(target) {
+        target.x = this._x;
+        target.y = this._y;
+        target.z = this._z;
+        return target;
+    };
+    /**
+   * Copy the value of this vector from an array.
+   * @param array - The array
+   * @param offset - The start offset of the array
+   * @returns This vector
+   */ _proto.copyFromArray = function copyFromArray(array, offset) {
+        if (offset === void 0) offset = 0;
+        this._x = array[offset];
+        this._y = array[offset + 1];
+        this._z = array[offset + 2];
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Copy the value of this vector to an array.
+   * @param out - The array
+   * @param outOffset - The start offset of the array
+   */ _proto.copyToArray = function copyToArray(out, outOffset) {
+        if (outOffset === void 0) outOffset = 0;
+        out[outOffset] = this._x;
+        out[outOffset + 1] = this._y;
+        out[outOffset + 2] = this._z;
+    };
+    /**
+   * Serialize this vector to a JSON representation.
+   * @returns A JSON representation of this vector
+   */ _proto.toJSON = function toJSON() {
+        return {
+            x: this._x,
+            y: this._y,
+            z: this._z
+        };
+    };
+    /**
+   * Determines the sum of two vectors.
+   * @param left - The first vector to add
+   * @param right - The second vector to add
+   * @param out - The sum of two vectors
+   */ Vector3.add = function add(left, right, out) {
+        out._x = left._x + right._x;
+        out._y = left._y + right._y;
+        out._z = left._z + right._z;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Determines the difference between two vectors.
+   * @param left - The first vector to subtract
+   * @param right - The second vector to subtract
+   * @param out - The difference between two vectors
+   */ Vector3.subtract = function subtract(left, right, out) {
+        out._x = left._x - right._x;
+        out._y = left._y - right._y;
+        out._z = left._z - right._z;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Determines the product of two vectors.
+   * @param left - The first vector to multiply
+   * @param right - The second vector to multiply
+   * @param out - The product of two vectors
+   */ Vector3.multiply = function multiply(left, right, out) {
+        out._x = left._x * right._x;
+        out._y = left._y * right._y;
+        out._z = left._z * right._z;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Determines the divisor of two vectors.
+   * @param left - The first vector to divide
+   * @param right - The second vector to divide
+   * @param out - The divisor of two vectors
+   */ Vector3.divide = function divide(left, right, out) {
+        out._x = left._x / right._x;
+        out._y = left._y / right._y;
+        out._z = left._z / right._z;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Determines the dot product of two vectors.
+   * @param left - The first vector to dot
+   * @param right - The second vector to dot
+   * @returns The dot product of two vectors
+   */ Vector3.dot = function dot(left, right) {
+        return left._x * right._x + left._y * right._y + left._z * right._z;
+    };
+    /**
+   * Determines the cross product of two vectors.
+   * @param left - The first vector to cross
+   * @param right - The second vector to cross
+   * @param out - The cross product of two vectors
+   */ Vector3.cross = function cross(left, right, out) {
+        var ax = left._x;
+        var ay = left._y;
+        var az = left._z;
+        var bx = right._x;
+        var by = right._y;
+        var bz = right._z;
+        out.set(ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx);
+    };
+    /**
+   * Determines the distance of two vectors.
+   * @param a - The first vector
+   * @param b - The second vector
+   * @returns The distance of two vectors
+   */ Vector3.distance = function distance(a, b) {
+        var x = b._x - a._x;
+        var y = b._y - a._y;
+        var z = b._z - a._z;
+        return Math.sqrt(x * x + y * y + z * z);
+    };
+    /**
+   * Determines the squared distance of two vectors.
+   * @param a - The first vector
+   * @param b - The second vector
+   * @returns The squared distance of two vectors
+   */ Vector3.distanceSquared = function distanceSquared(a, b) {
+        var x = b._x - a._x;
+        var y = b._y - a._y;
+        var z = b._z - a._z;
+        return x * x + y * y + z * z;
+    };
+    /**
+   * Determines whether the specified vectors are equals.
+   * @param left - The first vector to compare
+   * @param right - The second vector to compare
+   * @returns True if the specified vectors are equals, false otherwise
+   */ Vector3.equals = function equals(left, right) {
+        return MathUtil.equals(left._x, right._x) && MathUtil.equals(left._y, right._y) && MathUtil.equals(left._z, right._z);
+    };
+    /**
+   * Performs a linear interpolation between two vectors.
+   * @param start - The first vector
+   * @param end - The second vector
+   * @param t - The blend amount where 0 returns start and 1 end
+   * @param out - The result of linear blending between two vectors
+   */ Vector3.lerp = function lerp(start, end, t, out) {
+        var _x = start._x, _y = start._y, _z = start._z;
+        out._x = _x + (end._x - _x) * t;
+        out._y = _y + (end._y - _y) * t;
+        out._z = _z + (end._z - _z) * t;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a vector containing the largest components of the specified vectors.
+   * @param left - The first vector
+   * @param right - The second vector
+   * @param out - The vector containing the largest components of the specified vectors
+   */ Vector3.max = function max(left, right, out) {
+        out._x = Math.max(left._x, right._x);
+        out._y = Math.max(left._y, right._y);
+        out._z = Math.max(left._z, right._z);
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a vector containing the smallest components of the specified vectors.
+   * @param left - The first vector
+   * @param right - The second vector
+   * @param out - The vector containing the smallest components of the specified vectors
+   */ Vector3.min = function min(left, right, out) {
+        out._x = Math.min(left._x, right._x);
+        out._y = Math.min(left._y, right._y);
+        out._z = Math.min(left._z, right._z);
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Reverses the direction of a given vector.
+   * @param a - The vector to negate
+   * @param out - The vector facing in the opposite direction
+   */ Vector3.negate = function negate(a, out) {
+        out._x = -a._x;
+        out._y = -a._y;
+        out._z = -a._z;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Converts the vector into a unit vector.
+   * @param a - The vector to normalize
+   * @param out - The normalized vector
+   */ Vector3.normalize = function normalize(a, out) {
+        var _x = a._x, _y = a._y, _z = a._z;
+        var len = Math.sqrt(_x * _x + _y * _y + _z * _z);
+        if (len > MathUtil.zeroTolerance) {
+            len = 1 / len;
+            out.set(_x * len, _y * len, _z * len);
+        }
+    };
+    /**
+   * Scale a vector by the given value.
+   * @param a - The vector to scale
+   * @param s - The amount by which to scale the vector
+   * @param out - The scaled vector
+   */ Vector3.scale = function scale(a, s, out) {
+        out._x = a._x * s;
+        out._y = a._y * s;
+        out._z = a._z * s;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Performs a normal transformation using the given 4x4 matrix.
+   * @remarks
+   * A normal transform performs the transformation with the assumption that the w component
+   * is zero. This causes the fourth row and fourth column of the matrix to be unused. The
+   * end result is a vector that is not translated, but all other transformation properties
+   * apply. This is often preferred for normal vectors as normals purely represent direction
+   * rather than location because normal vectors should not be translated.
+   * @param v - The normal vector to transform
+   * @param m - The transform matrix
+   * @param out - The transformed normal
+   */ Vector3.transformNormal = function transformNormal(v, m, out) {
+        var _x = v._x, _y = v._y, _z = v._z;
+        var e = m.elements;
+        out._x = _x * e[0] + _y * e[4] + _z * e[8];
+        out._y = _x * e[1] + _y * e[5] + _z * e[9];
+        out._z = _x * e[2] + _y * e[6] + _z * e[10];
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Performs a transformation using the given 4x4 matrix.
+   * @param v - The vector to transform
+   * @param m - The transform matrix
+   * @param out - The transformed vector3
+   */ Vector3.transformToVec3 = function transformToVec3(v, m, out) {
+        var _x = v._x, _y = v._y, _z = v._z;
+        var e = m.elements;
+        out._x = _x * e[0] + _y * e[4] + _z * e[8] + e[12];
+        out._y = _x * e[1] + _y * e[5] + _z * e[9] + e[13];
+        out._z = _x * e[2] + _y * e[6] + _z * e[10] + e[14];
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Performs a transformation from vector3 to vector4 using the given 4x4 matrix.
+   * @param v - The vector to transform
+   * @param m - The transform matrix
+   * @param out - The transformed vector4
+   */ Vector3.transformToVec4 = function transformToVec4(v, m, out) {
+        var _x = v._x, _y = v._y, _z = v._z;
+        var e = m.elements;
+        out._x = _x * e[0] + _y * e[4] + _z * e[8] + e[12];
+        out._y = _x * e[1] + _y * e[5] + _z * e[9] + e[13];
+        out._z = _x * e[2] + _y * e[6] + _z * e[10] + e[14];
+        out._w = _x * e[3] + _y * e[7] + _z * e[11] + e[15];
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Performs a coordinate transformation using the given 4x4 matrix.
+   *
+   * @remarks
+   * A coordinate transform performs the transformation with the assumption that the w component
+   * is one. The four dimensional vector obtained from the transformation operation has each
+   * component in the vector divided by the w component. This forces the w-component to be one and
+   * therefore makes the vector homogeneous. The homogeneous vector is often preferred when working
+   * with coordinates as the w component can safely be ignored.
+   * @param v - The coordinate vector to transform
+   * @param m - The transform matrix
+   * @param out - The transformed coordinates
+   */ Vector3.transformCoordinate = function transformCoordinate(v, m, out) {
+        var _x = v._x, _y = v._y, _z = v._z;
+        var e = m.elements;
+        var w = _x * e[3] + _y * e[7] + _z * e[11] + e[15];
+        w = 1.0 / w;
+        out._x = (_x * e[0] + _y * e[4] + _z * e[8] + e[12]) * w;
+        out._y = (_x * e[1] + _y * e[5] + _z * e[9] + e[13]) * w;
+        out._z = (_x * e[2] + _y * e[6] + _z * e[10] + e[14]) * w;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Performs a transformation using the given quaternion.
+   * @param v - The vector to transform
+   * @param quaternion - The transform quaternion
+   * @param out - The transformed vector
+   */ Vector3.transformByQuat = function transformByQuat(v, quaternion, out) {
+        var _x = v._x, _y = v._y, _z = v._z;
+        var qx = quaternion._x, qy = quaternion._y, qz = quaternion._z, qw = quaternion._w;
+        // calculate quat * vec
+        var ix = qw * _x + qy * _z - qz * _y;
+        var iy = qw * _y + qz * _x - qx * _z;
+        var iz = qw * _z + qx * _y - qy * _x;
+        var iw = -qx * _x - qy * _y - qz * _z;
+        // calculate result * inverse quat
+        out._x = ix * qw - iw * qx - iy * qz + iz * qy;
+        out._y = iy * qw - iw * qy - iz * qx + ix * qz;
+        out._z = iz * qw - iw * qz - ix * qy + iy * qx;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    _create_class(Vector3, [
+        {
+            key: "x",
+            get: /**
+   * The x component of the vector.
+   */ function get() {
+                return this._x;
+            },
+            set: function set(value) {
+                this._x = value;
+                this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+            }
+        },
+        {
+            key: "y",
+            get: /**
+   * The y component of the vector.
+   */ function get() {
+                return this._y;
+            },
+            set: function set(value) {
+                this._y = value;
+                this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+            }
+        },
+        {
+            key: "z",
+            get: /**
+   * The z component of the vector.
+   */ function get() {
+                return this._z;
+            },
+            set: function set(value) {
+                this._z = value;
+                this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+            }
+        }
+    ]);
+    return Vector3;
+}();
+/** @internal */ Vector3._zero = new Vector3(0.0, 0.0, 0.0);
+/** @internal */ Vector3._one = new Vector3(1.0, 1.0, 1.0);
+new Vector3();
+new Vector3();
+new Vector3();
+new Vector3();
+new Vector3();
+new Vector3();
+/**
+ * Represents a 3x3 mathematical matrix.
+ */ var Matrix3x3 = /*#__PURE__*/ function() {
+    function Matrix3x3(m11, m12, m13, m21, m22, m23, m31, m32, m33) {
+        if (m11 === void 0) m11 = 1;
+        if (m12 === void 0) m12 = 0;
+        if (m13 === void 0) m13 = 0;
+        if (m21 === void 0) m21 = 0;
+        if (m22 === void 0) m22 = 1;
+        if (m23 === void 0) m23 = 0;
+        if (m31 === void 0) m31 = 0;
+        if (m32 === void 0) m32 = 0;
+        if (m33 === void 0) m33 = 1;
+        /**
+   * An array containing the elements of the matrix (column matrix).
+   * @remarks
+   * elements[0] first column and first row value m11
+   * elements[1] first column and second row value m12
+   * elements[2] first column and third row value m13
+   * elements[3] second column and first row value m21
+   * and so on
+   */ this.elements = new Float32Array(9);
+        var e = this.elements;
+        e[0] = m11;
+        e[1] = m12;
+        e[2] = m13;
+        e[3] = m21;
+        e[4] = m22;
+        e[5] = m23;
+        e[6] = m31;
+        e[7] = m32;
+        e[8] = m33;
+    }
+    var _proto = Matrix3x3.prototype;
+    /**
+   * Set the value of this matrix, and return this matrix.
+   * @param m11
+   * @param m12
+   * @param m13
+   * @param m21
+   * @param m22
+   * @param m23
+   * @param m31
+   * @param m32
+   * @param m33
+   * @returns This matrix
+   */ _proto.set = function set(m11, m12, m13, m21, m22, m23, m31, m32, m33) {
+        var e = this.elements;
+        e[0] = m11;
+        e[1] = m12;
+        e[2] = m13;
+        e[3] = m21;
+        e[4] = m22;
+        e[5] = m23;
+        e[6] = m31;
+        e[7] = m32;
+        e[8] = m33;
+        return this;
+    };
+    /**
+   * Determines the sum of this matrix and the specified matrix.
+   * @param right - The specified matrix
+   * @returns This matrix that store the sum of the two matrices
+   */ _proto.add = function add(right) {
+        Matrix3x3.add(this, right, this);
+        return this;
+    };
+    /**
+   * Determines the difference between this matrix and the specified matrix.
+   * @param right - The specified matrix
+   * @returns This matrix that store the difference between the two matrices
+   */ _proto.subtract = function subtract(right) {
+        Matrix3x3.subtract(this, right, this);
+        return this;
+    };
+    /**
+   * Determines the product of this matrix and the specified matrix.
+   * @param right - The specified matrix
+   * @returns This matrix that store the product of the two matrices
+   */ _proto.multiply = function multiply(right) {
+        Matrix3x3.multiply(this, right, this);
+        return this;
+    };
+    /**
+   * Calculate a determinant of this matrix.
+   * @returns The determinant of this matrix
+   */ _proto.determinant = function determinant() {
+        var e = this.elements;
+        var a11 = e[0], a12 = e[1], a13 = e[2];
+        var a21 = e[3], a22 = e[4], a23 = e[5];
+        var a31 = e[6], a32 = e[7], a33 = e[8];
+        var b12 = a33 * a22 - a23 * a32;
+        var b22 = -a33 * a21 + a23 * a31;
+        var b32 = a32 * a21 - a22 * a31;
+        return a11 * b12 + a12 * b22 + a13 * b32;
+    };
+    /**
+   * Identity this matrix.
+   * @returns This matrix after identity
+   */ _proto.identity = function identity() {
+        var e = this.elements;
+        e[0] = 1;
+        e[1] = 0;
+        e[2] = 0;
+        e[3] = 0;
+        e[4] = 1;
+        e[5] = 0;
+        e[6] = 0;
+        e[7] = 0;
+        e[8] = 1;
+        return this;
+    };
+    /**
+   * Invert the matrix.
+   * @returns The matrix after invert
+   */ _proto.invert = function invert() {
+        Matrix3x3.invert(this, this);
+        return this;
+    };
+    /**
+   * This matrix rotates around an angle.
+   * @param r - The rotation angle in radians
+   * @returns This matrix after rotate
+   */ _proto.rotate = function rotate(r) {
+        Matrix3x3.rotate(this, r, this);
+        return this;
+    };
+    /**
+   * Scale this matrix by a given vector.
+   * @param s - The given vector
+   * @returns This matrix after scale
+   */ _proto.scale = function scale(s) {
+        Matrix3x3.scale(this, s, this);
+        return this;
+    };
+    /**
+   * Translate this matrix by a given vector.
+   * @param translation - The given vector
+   * @returns This matrix after translate
+   */ _proto.translate = function translate(translation) {
+        Matrix3x3.translate(this, translation, this);
+        return this;
+    };
+    /**
+   * Calculate the transpose of this matrix.
+   * @returns This matrix after transpose
+   */ _proto.transpose = function transpose() {
+        Matrix3x3.transpose(this, this);
+        return this;
+    };
+    /**
+   * Creates a clone of this matrix.
+   * @returns A clone of this matrix
+   */ _proto.clone = function clone() {
+        var e = this.elements;
+        var ret = new Matrix3x3(e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8]);
+        return ret;
+    };
+    /**
+   * Copy this matrix from the specified matrix.
+   * @param source - The specified matrix
+   * @returns This matrix
+   */ _proto.copyFrom = function copyFrom(source) {
+        var e = this.elements;
+        var se = source.elements;
+        e[0] = se[0];
+        e[1] = se[1];
+        e[2] = se[2];
+        e[3] = se[3];
+        e[4] = se[4];
+        e[5] = se[5];
+        e[6] = se[6];
+        e[7] = se[7];
+        e[8] = se[8];
+        return this;
+    };
+    /**
+   * Copy the value of this matrix from an array.
+   * @param array - The array
+   * @param offset - The start offset of the array
+   * @returns This matrix
+   */ _proto.copyFromArray = function copyFromArray(array, offset) {
+        if (offset === void 0) offset = 0;
+        var srce = this.elements;
+        for(var i = 0; i < 12; i++){
+            srce[i] = array[i + offset];
+        }
+        return this;
+    };
+    /**
+   * Copy the value of this matrix to an array.
+   * @param out - The array
+   * @param outOffset - The start offset of the array
+   */ _proto.copyToArray = function copyToArray(out, outOffset) {
+        if (outOffset === void 0) outOffset = 0;
+        var e = this.elements;
+        out[outOffset] = e[0];
+        out[outOffset + 1] = e[1];
+        out[outOffset + 2] = e[2];
+        out[outOffset + 3] = e[3];
+        out[outOffset + 4] = e[4];
+        out[outOffset + 5] = e[5];
+        out[outOffset + 6] = e[6];
+        out[outOffset + 7] = e[7];
+        out[outOffset + 8] = e[8];
+    };
+    /**
+   * Copy the value of this 3x3 matrix from the specified 4x4 matrix.
+   * upper-left principle
+   * @param source - The specified 4x4 matrix
+   * @returns This 3x3 matrix
+   */ _proto.copyFromMatrix = function copyFromMatrix(source) {
+        var ae = source.elements;
+        var e = this.elements;
+        e[0] = ae[0];
+        e[1] = ae[1];
+        e[2] = ae[2];
+        e[3] = ae[4];
+        e[4] = ae[5];
+        e[5] = ae[6];
+        e[6] = ae[8];
+        e[7] = ae[9];
+        e[8] = ae[10];
+        return this;
+    };
+    /**
+   * Determines the sum of two matrices.
+   * @param left - The first matrix to add
+   * @param right - The second matrix to add
+   * @param out - The sum of two matrices
+   */ Matrix3x3.add = function add(left, right, out) {
+        var le = left.elements;
+        var re = right.elements;
+        var oe = out.elements;
+        oe[0] = le[0] + re[0];
+        oe[1] = le[1] + re[1];
+        oe[2] = le[2] + re[2];
+        oe[3] = le[3] + re[3];
+        oe[4] = le[4] + re[4];
+        oe[5] = le[5] + re[5];
+        oe[6] = le[6] + re[6];
+        oe[7] = le[7] + re[7];
+        oe[8] = le[8] + re[8];
+    };
+    /**
+   * Determines the difference between two matrices.
+   * @param left - The first matrix to subtract
+   * @param right - The second matrix to subtract
+   * @param out - The difference between two matrices
+   */ Matrix3x3.subtract = function subtract(left, right, out) {
+        var le = left.elements;
+        var re = right.elements;
+        var oe = out.elements;
+        oe[0] = le[0] - re[0];
+        oe[1] = le[1] - re[1];
+        oe[2] = le[2] - re[2];
+        oe[3] = le[3] - re[3];
+        oe[4] = le[4] - re[4];
+        oe[5] = le[5] - re[5];
+        oe[6] = le[6] - re[6];
+        oe[7] = le[7] - re[7];
+        oe[8] = le[8] - re[8];
+    };
+    /**
+   * Determines the product of two matrices.
+   * @param left - The first matrix to multiply
+   * @param right - The second matrix to multiply
+   * @param out - The product of two matrices
+   */ Matrix3x3.multiply = function multiply(left, right, out) {
+        var le = left.elements;
+        var re = right.elements;
+        var oe = out.elements;
+        var l11 = le[0], l12 = le[1], l13 = le[2];
+        var l21 = le[3], l22 = le[4], l23 = le[5];
+        var l31 = le[6], l32 = le[7], l33 = le[8];
+        var r11 = re[0], r12 = re[1], r13 = re[2];
+        var r21 = re[3], r22 = re[4], r23 = re[5];
+        var r31 = re[6], r32 = re[7], r33 = re[8];
+        oe[0] = l11 * r11 + l21 * r12 + l31 * r13;
+        oe[1] = l12 * r11 + l22 * r12 + l32 * r13;
+        oe[2] = l13 * r11 + l23 * r12 + l33 * r13;
+        oe[3] = l11 * r21 + l21 * r22 + l31 * r23;
+        oe[4] = l12 * r21 + l22 * r22 + l32 * r23;
+        oe[5] = l13 * r21 + l23 * r22 + l33 * r23;
+        oe[6] = l11 * r31 + l21 * r32 + l31 * r33;
+        oe[7] = l12 * r31 + l22 * r32 + l32 * r33;
+        oe[8] = l13 * r31 + l23 * r32 + l33 * r33;
+    };
+    /**
+   * Determines whether the specified matrices are equals.
+   * @param left - The first matrix to compare
+   * @param right - The second matrix to compare
+   * @returns True if the specified matrices are equals, false otherwise
+   */ Matrix3x3.equals = function equals(left, right) {
+        var le = left.elements;
+        var re = right.elements;
+        return MathUtil.equals(le[0], re[0]) && MathUtil.equals(le[1], re[1]) && MathUtil.equals(le[2], re[2]) && MathUtil.equals(le[3], re[3]) && MathUtil.equals(le[4], re[4]) && MathUtil.equals(le[5], re[5]) && MathUtil.equals(le[6], re[6]) && MathUtil.equals(le[7], re[7]) && MathUtil.equals(le[8], re[8]);
+    };
+    /**
+   * Performs a linear interpolation between two matrices.
+   * @param start - The first matrix
+   * @param end - The second matrix
+   * @param t - The blend amount where 0 returns start and 1 end
+   * @param out - The result of linear blending between two matrices
+   */ Matrix3x3.lerp = function lerp(start, end, t, out) {
+        var se = start.elements;
+        var ee = end.elements;
+        var oe = out.elements;
+        var inv = 1.0 - t;
+        oe[0] = se[0] * inv + ee[0] * t;
+        oe[1] = se[1] * inv + ee[1] * t;
+        oe[2] = se[2] * inv + ee[2] * t;
+        oe[3] = se[3] * inv + ee[3] * t;
+        oe[4] = se[4] * inv + ee[4] * t;
+        oe[5] = se[5] * inv + ee[5] * t;
+        oe[6] = se[6] * inv + ee[6] * t;
+        oe[7] = se[7] * inv + ee[7] * t;
+        oe[8] = se[8] * inv + ee[8] * t;
+    };
+    /**
+   * Calculate a rotation matrix from a quaternion.
+   * @param quaternion - The quaternion used to calculate the matrix
+   * @param out - The calculated rotation matrix
+   */ Matrix3x3.rotationQuaternion = function rotationQuaternion(quaternion, out) {
+        var oe = out.elements;
+        var x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
+        var x2 = x + x;
+        var y2 = y + y;
+        var z2 = z + z;
+        var xx = x * x2;
+        var yx = y * x2;
+        var yy = y * y2;
+        var zx = z * x2;
+        var zy = z * y2;
+        var zz = z * z2;
+        var wx = w * x2;
+        var wy = w * y2;
+        var wz = w * z2;
+        oe[0] = 1 - yy - zz;
+        oe[3] = yx - wz;
+        oe[6] = zx + wy;
+        oe[1] = yx + wz;
+        oe[4] = 1 - xx - zz;
+        oe[7] = zy - wx;
+        oe[2] = zx - wy;
+        oe[5] = zy + wx;
+        oe[8] = 1 - xx - yy;
+    };
+    /**
+   * Calculate a matrix from scale vector.
+   * @param s - The scale vector
+   * @param out - The calculated matrix
+   */ Matrix3x3.scaling = function scaling(s, out) {
+        var oe = out.elements;
+        oe[0] = s._x;
+        oe[1] = 0;
+        oe[2] = 0;
+        oe[3] = 0;
+        oe[4] = s._y;
+        oe[5] = 0;
+        oe[6] = 0;
+        oe[7] = 0;
+        oe[8] = 1;
+    };
+    /**
+   * Calculate a matrix from translation vector.
+   * @param translation - The translation vector
+   * @param out - The calculated matrix
+   */ Matrix3x3.translation = function translation(translation, out) {
+        var oe = out.elements;
+        oe[0] = 1;
+        oe[1] = 0;
+        oe[2] = 0;
+        oe[3] = 0;
+        oe[4] = 1;
+        oe[5] = 0;
+        oe[6] = translation._x;
+        oe[7] = translation._y;
+        oe[8] = 1;
+    };
+    /**
+   * Calculate the inverse of the specified matrix.
+   * @param a - The matrix whose inverse is to be calculated
+   * @param out - The inverse of the specified matrix
+   */ Matrix3x3.invert = function invert(a, out) {
+        var ae = a.elements;
+        var oe = out.elements;
+        var a11 = ae[0], a12 = ae[1], a13 = ae[2];
+        var a21 = ae[3], a22 = ae[4], a23 = ae[5];
+        var a31 = ae[6], a32 = ae[7], a33 = ae[8];
+        var b12 = a33 * a22 - a23 * a32;
+        var b22 = -a33 * a21 + a23 * a31;
+        var b32 = a32 * a21 - a22 * a31;
+        var det = a11 * b12 + a12 * b22 + a13 * b32;
+        if (!det) {
+            return;
+        }
+        det = 1.0 / det;
+        oe[0] = b12 * det;
+        oe[1] = (-a33 * a12 + a13 * a32) * det;
+        oe[2] = (a23 * a12 - a13 * a22) * det;
+        oe[3] = b22 * det;
+        oe[4] = (a33 * a11 - a13 * a31) * det;
+        oe[5] = (-a23 * a11 + a13 * a21) * det;
+        oe[6] = b32 * det;
+        oe[7] = (-a32 * a11 + a12 * a31) * det;
+        oe[8] = (a22 * a11 - a12 * a21) * det;
+    };
+    /**
+   * Calculate a 3x3 normal matrix from a 4x4 matrix.
+   * @remarks The calculation process is the transpose matrix of the inverse matrix.
+   * @param mat4 - The 4x4 matrix
+   * @param out - THe 3x3 normal matrix
+   */ Matrix3x3.normalMatrix = function normalMatrix(mat4, out) {
+        var ae = mat4.elements;
+        var oe = out.elements;
+        var a11 = ae[0], a12 = ae[1], a13 = ae[2], a14 = ae[3];
+        var a21 = ae[4], a22 = ae[5], a23 = ae[6], a24 = ae[7];
+        var a31 = ae[8], a32 = ae[9], a33 = ae[10], a34 = ae[11];
+        var a41 = ae[12], a42 = ae[13], a43 = ae[14], a44 = ae[15];
+        var b00 = a11 * a22 - a12 * a21;
+        var b01 = a11 * a23 - a13 * a21;
+        var b02 = a11 * a24 - a14 * a21;
+        var b03 = a12 * a23 - a13 * a22;
+        var b04 = a12 * a24 - a14 * a22;
+        var b05 = a13 * a24 - a14 * a23;
+        var b06 = a31 * a42 - a32 * a41;
+        var b07 = a31 * a43 - a33 * a41;
+        var b08 = a31 * a44 - a34 * a41;
+        var b09 = a32 * a43 - a33 * a42;
+        var b10 = a32 * a44 - a34 * a42;
+        var b11 = a33 * a44 - a34 * a43;
+        var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+        if (!det) {
+            return null;
+        }
+        det = 1.0 / det;
+        oe[0] = (a22 * b11 - a23 * b10 + a24 * b09) * det;
+        oe[1] = (a23 * b08 - a21 * b11 - a24 * b07) * det;
+        oe[2] = (a21 * b10 - a22 * b08 + a24 * b06) * det;
+        oe[3] = (a13 * b10 - a12 * b11 - a14 * b09) * det;
+        oe[4] = (a11 * b11 - a13 * b08 + a14 * b07) * det;
+        oe[5] = (a12 * b08 - a11 * b10 - a14 * b06) * det;
+        oe[6] = (a42 * b05 - a43 * b04 + a44 * b03) * det;
+        oe[7] = (a43 * b02 - a41 * b05 - a44 * b01) * det;
+        oe[8] = (a41 * b04 - a42 * b02 + a44 * b00) * det;
+    };
+    /**
+   * The specified matrix rotates around an angle.
+   * @param a - The specified matrix
+   * @param r - The rotation angle in radians
+   * @param out - The rotated matrix
+   */ Matrix3x3.rotate = function rotate(a, r, out) {
+        var ae = a.elements;
+        var oe = out.elements;
+        var s = Math.sin(r);
+        var c = Math.cos(r);
+        var a11 = ae[0], a12 = ae[1], a13 = ae[2];
+        var a21 = ae[3], a22 = ae[4], a23 = ae[5];
+        var a31 = ae[6], a32 = ae[7], a33 = ae[8];
+        oe[0] = c * a11 + s * a21;
+        oe[1] = c * a12 + s * a22;
+        oe[2] = c * a13 + s * a23;
+        oe[3] = c * a21 - s * a11;
+        oe[4] = c * a22 - s * a12;
+        oe[5] = c * a23 - s * a13;
+        oe[6] = a31;
+        oe[7] = a32;
+        oe[8] = a33;
+    };
+    /**
+   * Scale a matrix by a given vector.
+   * @param m - The matrix
+   * @param s - The given vector
+   * @param out - The scaled matrix
+   */ Matrix3x3.scale = function scale(m, s, out) {
+        var x = s._x, y = s._y;
+        var ae = m.elements;
+        var oe = out.elements;
+        oe[0] = x * ae[0];
+        oe[1] = x * ae[1];
+        oe[2] = x * ae[2];
+        oe[3] = y * ae[3];
+        oe[4] = y * ae[4];
+        oe[5] = y * ae[5];
+        oe[6] = ae[6];
+        oe[7] = ae[7];
+        oe[8] = ae[8];
+    };
+    /**
+   * Translate a matrix by a given vector.
+   * @param m - The matrix
+   * @param translation - The given vector
+   * @param out - The translated matrix
+   */ Matrix3x3.translate = function translate(m, translation, out) {
+        var x = translation._x, y = translation._y;
+        var ae = m.elements;
+        var oe = out.elements;
+        var a11 = ae[0], a12 = ae[1], a13 = ae[2];
+        var a21 = ae[3], a22 = ae[4], a23 = ae[5];
+        var a31 = ae[6], a32 = ae[7], a33 = ae[8];
+        oe[0] = a11;
+        oe[1] = a12;
+        oe[2] = a13;
+        oe[3] = a21;
+        oe[4] = a22;
+        oe[5] = a23;
+        oe[6] = x * a11 + y * a21 + a31;
+        oe[7] = x * a12 + y * a22 + a32;
+        oe[8] = x * a13 + y * a23 + a33;
+    };
+    /**
+   * Calculate the transpose of the specified matrix.
+   * @param a - The specified matrix
+   * @param out - The transpose of the specified matrix
+   */ Matrix3x3.transpose = function transpose(a, out) {
+        var ae = a.elements;
+        var oe = out.elements;
+        if (out === a) {
+            var a12 = ae[1];
+            var a13 = ae[2];
+            var a23 = ae[5];
+            oe[1] = ae[3];
+            oe[2] = ae[6];
+            oe[3] = a12;
+            oe[5] = ae[7];
+            oe[6] = a13;
+            oe[7] = a23;
+        } else {
+            oe[0] = ae[0];
+            oe[1] = ae[3];
+            oe[2] = ae[6];
+            oe[3] = ae[1];
+            oe[4] = ae[4];
+            oe[5] = ae[7];
+            oe[6] = ae[2];
+            oe[7] = ae[5];
+            oe[8] = ae[8];
+        }
+    };
+    return Matrix3x3;
+}();
+/**
+ * Represents a four dimensional mathematical quaternion.
+ */ var Quaternion = /*#__PURE__*/ function() {
+    function Quaternion(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;
+        /** @internal */ this._onValueChanged = null;
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
+    }
+    var _proto = Quaternion.prototype;
+    /**
+   * Set the value of this quaternion, and return this quaternion.
+   * @param x - The x component of the quaternion
+   * @param y - The y component of the quaternion
+   * @param z - The z component of the quaternion
+   * @param w - The w component of the quaternion
+   * @returns This quaternion
+   */ _proto.set = function set(x, y, z, w) {
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Transforms this quaternion into its conjugated version.
+   * @returns This quaternion
+   */ _proto.conjugate = function conjugate() {
+        this._x *= -1;
+        this._y *= -1;
+        this._z *= -1;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Get the rotation axis and rotation angle of the quaternion (unit: radians).
+   * @param out - The axis as an output parameter
+   * @returns The rotation angle (unit: radians)
+   */ _proto.getAxisAngle = function getAxisAngle(out) {
+        var _this = this, _x = _this._x, _y = _this._y, _z = _this._z;
+        var length = _x * _x + _y * _y + _z * _z;
+        if (length < MathUtil.zeroTolerance) {
+            out._x = 1;
+            out._y = 0;
+            out._z = 0;
+            return 0;
+        } else {
+            var inv = 1.0 / length;
+            out._x = this._x * inv;
+            out._y = this._y * inv;
+            out._z = this._z * inv;
+            return Math.acos(this._w) * 2.0;
+        }
+    };
+    /**
+   * Identity this quaternion.
+   * @returns This quaternion after identity
+   */ _proto.identity = function identity() {
+        this._x = 0;
+        this._y = 0;
+        this._z = 0;
+        this._w = 1;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Calculate the length of this quaternion.
+   * @returns The length of this quaternion
+   */ _proto.length = function length() {
+        var _this = this, _x = _this._x, _y = _this._y, _z = _this._z, _w = _this._w;
+        return Math.sqrt(_x * _x + _y * _y + _z * _z + _w * _w);
+    };
+    /**
+   * Calculates the squared length of this quaternion.
+   * @returns The squared length of this quaternion
+   */ _proto.lengthSquared = function lengthSquared() {
+        var _this = this, _x = _this._x, _y = _this._y, _z = _this._z, _w = _this._w;
+        return _x * _x + _y * _y + _z * _z + _w * _w;
+    };
+    /**
+   * Converts this quaternion into a unit quaternion.
+   * @returns This quaternion
+   */ _proto.normalize = function normalize() {
+        Quaternion.normalize(this, this);
+        return this;
+    };
+    /**
+   * Get the euler of this quaternion.
+   * @param out - The euler (in radians) as an output parameter
+   * @returns Euler x->pitch y->yaw z->roll
+   */ _proto.toEuler = function toEuler(out) {
+        this._toYawPitchRoll(out);
+        var t = out._x;
+        out._x = out._y;
+        out._y = t;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+        return out;
+    };
+    /**
+   * Get the euler of this quaternion.
+   * @param out - The euler (in radians) as an output parameter
+   * @returns Euler x->yaw y->pitch z->roll
+   */ _proto.toYawPitchRoll = function toYawPitchRoll(out) {
+        this._toYawPitchRoll(out);
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+        return out;
+    };
+    /**
+   * Calculate this quaternion rotate around X axis.
+   * @param rad - The rotation angle in radians
+   * @returns This quaternion
+   */ _proto.rotateX = function rotateX(rad) {
+        Quaternion.rotateX(this, rad, this);
+        return this;
+    };
+    /**
+   * Calculate this quaternion rotate around Y axis.
+   * @param rad - The rotation angle in radians
+   * @returns This quaternion
+   */ _proto.rotateY = function rotateY(rad) {
+        Quaternion.rotateY(this, rad, this);
+        return this;
+    };
+    /**
+   * Calculate this quaternion rotate around Z axis.
+   * @param rad - The rotation angle in radians
+   * @returns This quaternion
+   */ _proto.rotateZ = function rotateZ(rad) {
+        Quaternion.rotateZ(this, rad, this);
+        return this;
+    };
+    /**
+   * Calculate this quaternion rotates around an arbitrary axis.
+   * @param axis - The axis
+   * @param rad - The rotation angle in radians
+   * @returns This quaternion
+   */ _proto.rotationAxisAngle = function rotationAxisAngle(axis, rad) {
+        Quaternion.rotationAxisAngle(axis, rad, this);
+        return this;
+    };
+    /**
+   * Determines the product of this quaternion and the specified quaternion.
+   * @param quat - The specified quaternion
+   * @returns The product of the two quaternions
+   */ _proto.multiply = function multiply(quat) {
+        Quaternion.multiply(this, quat, this);
+        return this;
+    };
+    /**
+   * Invert this quaternion.
+   * @returns This quaternion after invert
+   */ _proto.invert = function invert() {
+        Quaternion.invert(this, this);
+        return this;
+    };
+    /**
+   * Determines the dot product of this quaternion and the specified quaternion.
+   * @param quat - The specified quaternion
+   * @returns The dot product of two quaternions
+   */ _proto.dot = function dot(quat) {
+        return Quaternion.dot(this, quat);
+    };
+    /**
+   * Performs a linear blend between this quaternion and the specified quaternion.
+   * @param quat - The specified quaternion
+   * @param t - The blend amount where 0 returns this and 1 quat
+   * @returns - The result of linear blending between two quaternions
+   */ _proto.lerp = function lerp(quat, t) {
+        Quaternion.lerp(this, quat, t, this);
+        return this;
+    };
+    /**
+   * Calculate this quaternion rotation around an arbitrary axis.
+   * @param axis - The axis
+   * @param rad - The rotation angle in radians
+   * @returns This quaternion
+   */ _proto.rotateAxisAngle = function rotateAxisAngle(axis, rad) {
+        Quaternion._tempQuat1.rotationAxisAngle(axis, rad);
+        this.multiply(Quaternion._tempQuat1);
+        return this;
+    };
+    /**
+   * Creates a clone of this quaternion.
+   * @returns A clone of this quaternion
+   */ _proto.clone = function clone() {
+        return new Quaternion(this._x, this._y, this._z, this._w);
+    };
+    /**
+   * Copy this quaternion from the specified quaternion.
+   * @param source - The specified quaternion
+   * @returns This quaternion
+   */ _proto.copyFrom = function copyFrom(source) {
+        this._x = source.x;
+        this._y = source.y;
+        this._z = source.z;
+        this._w = source.w;
+        this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Copy this quaternion to the specified quaternion.
+   * @param target - The specified quaternion
+   * @returns This specified quaternion
+   */ _proto.copyTo = function copyTo(target) {
+        target.x = this._x;
+        target.y = this._y;
+        target.z = this._z;
+        target.w = this._w;
+        return target;
+    };
+    /**
+   * Copy the value of this quaternion from an array.
+   * @param array - The array
+   * @param offset - The start offset of the array
+   * @returns This quaternion
+   */ _proto.copyFromArray = function copyFromArray(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._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+        return this;
+    };
+    /**
+   * Copy the value of this quaternion to an array.
+   * @param out - The array
+   * @param outOffset - The start offset of the array
+   */ _proto.copyToArray = function copyToArray(out, outOffset) {
+        if (outOffset === void 0) outOffset = 0;
+        out[outOffset] = this._x;
+        out[outOffset + 1] = this._y;
+        out[outOffset + 2] = this._z;
+        out[outOffset + 3] = this._w;
+    };
+    /**
+   * Serialize this quaternion to a JSON representation.
+   * @returns A JSON Object representation of this quaternion
+   */ _proto.toJSON = function toJSON() {
+        return {
+            x: this._x,
+            y: this._y,
+            z: this._z,
+            w: this._w
+        };
+    };
+    _proto._toYawPitchRoll = function _toYawPitchRoll(out) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/
+        var _this = this, x = _this._x, y = _this._y, z = _this._z, w = _this._w;
+        var xx = x * x;
+        var yy = y * y;
+        var zz = z * z;
+        var ww = w * w;
+        var unit = xx + yy + zz + ww;
+        var test = 2 * (x * w - y * z);
+        if (test > (1 - MathUtil.zeroTolerance) * unit) {
+            out._x = Math.atan2(2.0 * (w * y - x * z), xx + ww - yy - zz);
+            out._y = Math.PI / 2;
+            out._z = 0;
+        } else if (test < -(1 - MathUtil.zeroTolerance) * unit) {
+            out._x = Math.atan2(2.0 * (w * y - x * z), xx + ww - yy - zz);
+            out._y = -Math.PI / 2;
+            out._z = 0;
+        } else {
+            out._x = Math.atan2(2.0 * (z * x + y * w), zz + ww - yy - xx);
+            out._y = Math.asin(test / unit);
+            out._z = Math.atan2(2.0 * (x * y + z * w), yy + ww - zz - xx);
+        }
+    };
+    /**
+   * Determines the sum of two quaternions.
+   * @param left - The first quaternion to add
+   * @param right - The second quaternion to add
+   * @param out - The sum of two quaternions
+   */ Quaternion.add = function add(left, right, out) {
+        out._x = left._x + right._x;
+        out._y = left._y + right._y;
+        out._z = left._z + right._z;
+        out._w = left._w + right._w;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Determines the product of two quaternions.
+   * @param left - The first quaternion to multiply
+   * @param right - The second quaternion to multiply
+   * @param out - The product of two quaternions
+   */ Quaternion.multiply = function multiply(left, right, out) {
+        var ax = left._x, ay = left._y, az = left._z, aw = left._w;
+        var bx = right._x, by = right._y, bz = right._z, bw = right._w;
+        out._x = ax * bw + aw * bx + ay * bz - az * by;
+        out._y = ay * bw + aw * by + az * bx - ax * bz;
+        out._z = az * bw + aw * bz + ax * by - ay * bx;
+        out._w = aw * bw - ax * bx - ay * by - az * bz;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate quaternion that contains conjugated version of the specified quaternion.
+   * @param a - The specified quaternion
+   * @param out - The conjugate version of the specified quaternion
+   */ Quaternion.conjugate = function conjugate(a, out) {
+        out._x = -a._x;
+        out._y = -a._y;
+        out._z = -a._z;
+        out._w = a._w;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Determines the dot product of two quaternions.
+   * @param left - The first quaternion to dot
+   * @param right - The second quaternion to dot
+   * @returns The dot product of two quaternions
+   */ Quaternion.dot = function dot(left, right) {
+        return left._x * right._x + left._y * right._y + left._z * right._z + left._w * right._w;
+    };
+    /**
+   * Determines whether the specified quaternions are equals.
+   * @param left - The first quaternion to compare
+   * @param right - The second quaternion to compare
+   * @returns True if the specified quaternions are equals, false otherwise
+   */ Quaternion.equals = function equals(left, right) {
+        return MathUtil.equals(left._x, right._x) && MathUtil.equals(left._y, right._y) && MathUtil.equals(left._z, right._z) && MathUtil.equals(left._w, right._w);
+    };
+    /**
+   * Calculate a quaternion rotates around an arbitrary axis.
+   * @param axis - The axis
+   * @param rad - The rotation angle in radians
+   * @param out - The quaternion after rotate
+   */ Quaternion.rotationAxisAngle = function rotationAxisAngle(axis, rad, out) {
+        var normalAxis = Quaternion._tempVector3;
+        Vector3.normalize(axis, normalAxis);
+        rad *= 0.5;
+        var s = Math.sin(rad);
+        out._x = normalAxis._x * s;
+        out._y = normalAxis._y * s;
+        out._z = normalAxis._z * s;
+        out._w = Math.cos(rad);
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a quaternion rotates around x, y, z axis (pitch/yaw/roll).
+   * @param x - The radian of rotation around X (pitch)
+   * @param y - The radian of rotation around Y (yaw)
+   * @param z - The radian of rotation around Z (roll)
+   * @param out - The calculated quaternion
+   */ Quaternion.rotationEuler = function rotationEuler(x, y, z, out) {
+        Quaternion.rotationYawPitchRoll(y, x, z, out);
+    };
+    /**
+   * Calculate a quaternion from the specified yaw, pitch and roll angles.
+   * @param yaw - Yaw around the y axis in radians
+   * @param pitch - Pitch around the x axis in radians
+   * @param roll - Roll around the z axis in radians
+   * @param out - The calculated quaternion
+   */ Quaternion.rotationYawPitchRoll = function rotationYawPitchRoll(yaw, pitch, roll, out) {
+        var halfRoll = roll * 0.5;
+        var halfPitch = pitch * 0.5;
+        var halfYaw = yaw * 0.5;
+        var sinRoll = Math.sin(halfRoll);
+        var cosRoll = Math.cos(halfRoll);
+        var sinPitch = Math.sin(halfPitch);
+        var cosPitch = Math.cos(halfPitch);
+        var sinYaw = Math.sin(halfYaw);
+        var cosYaw = Math.cos(halfYaw);
+        var cosYawPitch = cosYaw * cosPitch;
+        var sinYawPitch = sinYaw * sinPitch;
+        out._x = cosYaw * sinPitch * cosRoll + sinYaw * cosPitch * sinRoll;
+        out._y = sinYaw * cosPitch * cosRoll - cosYaw * sinPitch * sinRoll;
+        out._z = cosYawPitch * sinRoll - sinYawPitch * cosRoll;
+        out._w = cosYawPitch * cosRoll + sinYawPitch * sinRoll;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a quaternion from the specified 3x3 matrix.
+   * @param m - The specified 3x3 matrix
+   * @param out - The calculated quaternion
+   */ Quaternion.rotationMatrix3x3 = function rotationMatrix3x3(m, out) {
+        var me = m.elements;
+        var m11 = me[0], m12 = me[1], m13 = me[2];
+        var m21 = me[3], m22 = me[4], m23 = me[5];
+        var m31 = me[6], m32 = me[7], m33 = me[8];
+        var scale = m11 + m22 + m33;
+        var sqrt, half;
+        if (scale > 0) {
+            sqrt = Math.sqrt(scale + 1.0);
+            out._w = sqrt * 0.5;
+            sqrt = 0.5 / sqrt;
+            out._x = (m23 - m32) * sqrt;
+            out._y = (m31 - m13) * sqrt;
+            out._z = (m12 - m21) * sqrt;
+        } else if (m11 >= m22 && m11 >= m33) {
+            sqrt = Math.sqrt(1.0 + m11 - m22 - m33);
+            half = 0.5 / sqrt;
+            out._x = 0.5 * sqrt;
+            out._y = (m12 + m21) * half;
+            out._z = (m13 + m31) * half;
+            out._w = (m23 - m32) * half;
+        } else if (m22 > m33) {
+            sqrt = Math.sqrt(1.0 + m22 - m11 - m33);
+            half = 0.5 / sqrt;
+            out._x = (m21 + m12) * half;
+            out._y = 0.5 * sqrt;
+            out._z = (m32 + m23) * half;
+            out._w = (m31 - m13) * half;
+        } else {
+            sqrt = Math.sqrt(1.0 + m33 - m11 - m22);
+            half = 0.5 / sqrt;
+            out._x = (m13 + m31) * half;
+            out._y = (m23 + m32) * half;
+            out._z = 0.5 * sqrt;
+            out._w = (m12 - m21) * half;
+        }
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate the inverse of the specified quaternion.
+   * @param a - The quaternion whose inverse is to be calculated
+   * @param out - The inverse of the specified quaternion
+   */ Quaternion.invert = function invert(a, out) {
+        var x = a._x, y = a._y, z = a._z, w = a._w;
+        var dot = x * x + y * y + z * z + w * w;
+        if (dot > MathUtil.zeroTolerance) {
+            var invDot = 1.0 / dot;
+            out._x = -x * invDot;
+            out._y = -y * invDot;
+            out._z = -z * invDot;
+            out._w = w * invDot;
+            out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+        }
+    };
+    /**
+   * Performs a linear blend between two quaternions.
+   * @param start - The first quaternion
+   * @param end - The second quaternion
+   * @param t - The blend amount where 0 returns start and 1 end
+   * @param out - The result of linear blending between two quaternions
+   */ Quaternion.lerp = function lerp(start, end, t, out) {
+        var inv = 1.0 - t;
+        if (Quaternion.dot(start, end) >= 0) {
+            out._x = start._x * inv + end._x * t;
+            out._y = start._y * inv + end._y * t;
+            out._z = start._z * inv + end._z * t;
+            out._w = start._w * inv + end._w * t;
+        } else {
+            out._x = start._x * inv - end._x * t;
+            out._y = start._y * inv - end._y * t;
+            out._z = start._z * inv - end._z * t;
+            out._w = start._w * inv - end._w * t;
+        }
+        out.normalize();
+    };
+    /**
+   * Performs a spherical linear blend between two quaternions.
+   * @param start - The first quaternion
+   * @param end - The second quaternion
+   * @param amount - The blend amount where 0 returns start and 1 end
+   * @param out - The result of spherical linear blending between two quaternions
+   */ Quaternion.slerp = function slerp(start, end, amount, out) {
+        var opposite;
+        var inverse;
+        var dot = Quaternion.dot(start, end);
+        if (Math.abs(dot) > 1.0 - MathUtil.zeroTolerance) {
+            inverse = 1.0 - amount;
+            opposite = amount * Math.sign(dot);
+        } else {
+            var acos = Math.acos(Math.abs(dot));
+            var invSin = 1.0 / Math.sin(acos);
+            inverse = Math.sin((1.0 - amount) * acos) * invSin;
+            opposite = Math.sin(amount * acos) * invSin * Math.sign(dot);
+        }
+        out.x = inverse * start.x + opposite * end.x;
+        out.y = inverse * start.y + opposite * end.y;
+        out.z = inverse * start.z + opposite * end.z;
+        out.w = inverse * start.w + opposite * end.w;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Scales the specified quaternion magnitude to unit length.
+   * @param a - The specified quaternion
+   * @param out - The normalized quaternion
+   */ Quaternion.normalize = function normalize(a, out) {
+        var _x = a._x, _y = a._y, _z = a._z, _w = a._w;
+        var len = Math.sqrt(_x * _x + _y * _y + _z * _z + _w * _w);
+        if (len > MathUtil.zeroTolerance) {
+            len = 1 / len;
+            out._x = _x * len;
+            out._y = _y * len;
+            out._z = _z * len;
+            out._w = _w * len;
+            out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+        }
+    };
+    /**
+   * Calculate a quaternion rotate around X axis.
+   * @param rad - The rotation angle in radians
+   * @param out - The calculated quaternion
+   */ Quaternion.rotationX = function rotationX(rad, out) {
+        rad *= 0.5;
+        var s = Math.sin(rad);
+        var c = Math.cos(rad);
+        out._x = s;
+        out._y = 0;
+        out._z = 0;
+        out._w = c;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a quaternion rotate around Y axis.
+   * @param rad - The rotation angle in radians
+   * @param out - The calculated quaternion
+   */ Quaternion.rotationY = function rotationY(rad, out) {
+        rad *= 0.5;
+        var s = Math.sin(rad);
+        var c = Math.cos(rad);
+        out._x = 0;
+        out._y = s;
+        out._z = 0;
+        out._w = c;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a quaternion rotate around Z axis.
+   * @param rad - The rotation angle in radians
+   * @param out - The calculated quaternion
+   */ Quaternion.rotationZ = function rotationZ(rad, out) {
+        rad *= 0.5;
+        var s = Math.sin(rad);
+        var c = Math.cos(rad);
+        out._x = 0;
+        out._y = 0;
+        out._z = s;
+        out._w = c;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a quaternion that the specified quaternion rotate around X axis.
+   * @param quaternion - The specified quaternion
+   * @param rad - The rotation angle in radians
+   * @param out - The calculated quaternion
+   */ Quaternion.rotateX = function rotateX(quaternion, rad, out) {
+        var _x = quaternion._x, _y = quaternion._y, _z = quaternion._z, _w = quaternion._w;
+        rad *= 0.5;
+        var bx = Math.sin(rad);
+        var bw = Math.cos(rad);
+        out._x = _x * bw + _w * bx;
+        out._y = _y * bw + _z * bx;
+        out._z = _z * bw - _y * bx;
+        out._w = _w * bw - _x * bx;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a quaternion that the specified quaternion rotate around Y axis.
+   * @param quaternion - The specified quaternion
+   * @param rad - The rotation angle in radians
+   * @param out - The calculated quaternion
+   */ Quaternion.rotateY = function rotateY(quaternion, rad, out) {
+        var _x = quaternion._x, _y = quaternion._y, _z = quaternion._z, _w = quaternion._w;
+        rad *= 0.5;
+        var by = Math.sin(rad);
+        var bw = Math.cos(rad);
+        out._x = _x * bw - _z * by;
+        out._y = _y * bw + _w * by;
+        out._z = _z * bw + _x * by;
+        out._w = _w * bw - _y * by;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Calculate a quaternion that the specified quaternion rotate around Z axis.
+   * @param quaternion - The specified quaternion
+   * @param rad - The rotation angle in radians
+   * @param out - The calculated quaternion
+   */ Quaternion.rotateZ = function rotateZ(quaternion, rad, out) {
+        var _x = quaternion._x, _y = quaternion._y, _z = quaternion._z, _w = quaternion._w;
+        rad *= 0.5;
+        var bz = Math.sin(rad);
+        var bw = Math.cos(rad);
+        out._x = _x * bw + _y * bz;
+        out._y = _y * bw - _x * bz;
+        out._z = _z * bw + _w * bz;
+        out._w = _w * bw - _z * bz;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    /**
+   * Scale a quaternion by a given number.
+   * @param a - The quaternion
+   * @param s - The given number
+   * @param out - The scaled quaternion
+   */ Quaternion.scale = function scale(a, s, out) {
+        out._x = a._x * s;
+        out._y = a._y * s;
+        out._z = a._z * s;
+        out._w = a._w * s;
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+    };
+    _create_class(Quaternion, [
+        {
+            key: "x",
+            get: /**
+   * The x component of the quaternion.
+   */ function get() {
+                return this._x;
+            },
+            set: function set(value) {
+                this._x = value;
+                this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+            }
+        },
+        {
+            key: "y",
+            get: /**
+   * The y component of the quaternion.
+   */ function get() {
+                return this._y;
+            },
+            set: function set(value) {
+                this._y = value;
+                this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+            }
+        },
+        {
+            key: "z",
+            get: /**
+   * The z component of the quaternion.
+   */ function get() {
+                return this._z;
+            },
+            set: function set(value) {
+                this._z = value;
+                this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+            }
+        },
+        {
+            key: "normalized",
+            get: /**
+   * Indicting whether this instance is normalized.
+   */ function get() {
+                return Math.abs(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w - 1) < MathUtil.zeroTolerance;
+            }
+        },
+        {
+            key: "w",
+            get: /**
+   * The w component of the quaternion.
+   */ function get() {
+                return this._w;
+            },
+            set: function set(value) {
+                this._w = value;
+                this._onValueChanged == null ? void 0 : this._onValueChanged.call(this);
+            }
+        }
+    ]);
+    return Quaternion;
+}();
+/** @internal */ Quaternion._tempVector3 = new Vector3();
+/** @internal */ Quaternion._tempQuat1 = new Quaternion();
+/**
+ * Represents a 4x4 mathematical matrix.
+ */ var Matrix = /*#__PURE__*/ function() {
+    function Matrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44) {
+        if (m11 === void 0) m11 = 1;
+        if (m12 === void 0) m12 = 0;
+        if (m13 === void 0) m13 = 0;
+        if (m14 === void 0) m14 = 0;
+        if (m21 === void 0) m21 = 0;
+        if (m22 === void 0) m22 = 1;
+        if (m23 === void 0) m23 = 0;
+        if (m24 === void 0) m24 = 0;
+        if (m31 === void 0) m31 = 0;
+        if (m32 === void 0) m32 = 0;
+        if (m33 === void 0) m33 = 1;
+        if (m34 === void 0) m34 = 0;
+        if (m41 === void 0) m41 = 0;
+        if (m42 === void 0) m42 = 0;
+        if (m43 === void 0) m43 = 0;
+        if (m44 === void 0) m44 = 1;
+        /**
+   * An array containing the elements of the matrix (column matrix).
+   * @remarks
+   * elements[0] first column and first row value m11
+   * elements[1] first column and second row value m12
+   * elements[2] first column and third row value m13
+   * elements[3] first column and fourth row value m14
+   * elements[4] second column and first row value m21
+   * and so on
+   */ this.elements = new Float32Array(16);
+        var e = this.elements;
+        e[0] = m11;
+        e[1] = m12;
+        e[2] = m13;
+        e[3] = m14;
+        e[4] = m21;
+        e[5] = m22;
+        e[6] = m23;
+        e[7] = m24;
+        e[8] = m31;
+        e[9] = m32;
+        e[10] = m33;
+        e[11] = m34;
+        e[12] = m41;
+        e[13] = m42;
+        e[14] = m43;
+        e[15] = m44;
+    }
+    var _proto = Matrix.prototype;
+    /**
+   * Set the value of this matrix, and return this matrix.
+   * @param m11 - column 1, row 1
+   * @param m12 - column 1, row 2
+   * @param m13 - column 1, row 3
+   * @param m14 - column 1, row 4
+   * @param m21 - column 2, row 1
+   * @param m22 - column 2, row 2
+   * @param m23 - column 2, row 3
+   * @param m24 - column 2, row 4
+   * @param m31 - column 3, row 1
+   * @param m32 - column 3, row 2
+   * @param m33 - column 3, row 3
+   * @param m34 - column 3, row 4
+   * @param m41 - column 4, row 1
+   * @param m42 - column 4, row 2
+   * @param m43 - column 4, row 3
+   * @param m44 - column 4, row 4
+   * @returns This matrix
+   */ _proto.set = function set(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44) {
+        var e = this.elements;
+        e[0] = m11;
+        e[1] = m12;
+        e[2] = m13;
+        e[3] = m14;
+        e[4] = m21;
+        e[5] = m22;
+        e[6] = m23;
+        e[7] = m24;
+        e[8] = m31;
+        e[9] = m32;
+        e[10] = m33;
+        e[11] = m34;
+        e[12] = m41;
+        e[13] = m42;
+        e[14] = m43;
+        e[15] = m44;
+        return this;
+    };
+    /**
+   * Determines the product of this matrix and the specified matrix.
+   * @param right - The specified matrix
+   * @returns This matrix that store the product of the two matrices
+   */ _proto.multiply = function multiply(right) {
+        Matrix.multiply(this, right, this);
+        return this;
+    };
+    /**
+   * Calculate a determinant of this matrix.
+   * @returns The determinant of this matrix
+   */ _proto.determinant = function determinant() {
+        var e = this.elements;
+        var a11 = e[0], a12 = e[1], a13 = e[2], a14 = e[3];
+        var a21 = e[4], a22 = e[5], a23 = e[6], a24 = e[7];
+        var a31 = e[8], a32 = e[9], a33 = e[10], a34 = e[11];
+        var a41 = e[12], a42 = e[13], a43 = e[14], a44 = e[15];
+        var b00 = a11 * a22 - a12 * a21;
+        var b01 = a11 * a23 - a13 * a21;
+        var b02 = a11 * a24 - a14 * a21;
+        var b03 = a12 * a23 - a13 * a22;
+        var b04 = a12 * a24 - a14 * a22;
+        var b05 = a13 * a24 - a14 * a23;
+        var b06 = a31 * a42 - a32 * a41;
+        var b07 = a31 * a43 - a33 * a41;
+        var b08 = a31 * a44 - a34 * a41;
+        var b09 = a32 * a43 - a33 * a42;
+        var b10 = a32 * a44 - a34 * a42;
+        var b11 = a33 * a44 - a34 * a43;
+        // Calculate the determinant
+        return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    };
+    /**
+   * Decompose this matrix to translation, rotation and scale elements.
+   * @param translation - Translation vector as an output parameter
+   * @param rotation - Rotation quaternion as an output parameter
+   * @param scale - Scale vector as an output parameter
+   * @returns True if this matrix can be decomposed, false otherwise
+   */ _proto.decompose = function decompose(translation, rotation, scale) {
+        var rm = Matrix._tempMat30;
+        var e = this.elements;
+        var rme = rm.elements;
+        var m11 = e[0];
+        var m12 = e[1];
+        var m13 = e[2];
+        var m21 = e[4];
+        var m22 = e[5];
+        var m23 = e[6];
+        var m31 = e[8];
+        var m32 = e[9];
+        var m33 = e[10];
+        translation.set(e[12], e[13], e[14]);
+        var sx = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+        var sy = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+        var sz = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+        if (this.determinant() < 0) sx = -sx;
+        scale.set(sx, sy, sz);
+        if (Math.abs(sx) < MathUtil.zeroTolerance || Math.abs(sy) < MathUtil.zeroTolerance || Math.abs(sz) < MathUtil.zeroTolerance) {
+            rotation.identity();
+            return false;
+        } else {
+            var invSX = 1 / sx;
+            var invSY = 1 / sy;
+            var invSZ = 1 / sz;
+            rme[0] = m11 * invSX;
+            rme[1] = m12 * invSX;
+            rme[2] = m13 * invSX;
+            rme[3] = m21 * invSY;
+            rme[4] = m22 * invSY;
+            rme[5] = m23 * invSY;
+            rme[6] = m31 * invSZ;
+            rme[7] = m32 * invSZ;
+            rme[8] = m33 * invSZ;
+            Quaternion.rotationMatrix3x3(rm, rotation);
+            return true;
+        }
+    };
+    /**
+   * Get rotation from this matrix.
+   * @param out - Rotation quaternion as an output parameter
+   * @returns The out
+   */ _proto.getRotation = function getRotation(out) {
+        var e = this.elements;
+        var trace = e[0] + e[5] + e[10];
+        if (trace > MathUtil.zeroTolerance) {
+            var s = Math.sqrt(trace + 1.0) * 2;
+            out._w = 0.25 * s;
+            out._x = (e[6] - e[9]) / s;
+            out._y = (e[8] - e[2]) / s;
+            out._z = (e[1] - e[4]) / s;
+        } else if (e[0] > e[5] && e[0] > e[10]) {
+            var s1 = Math.sqrt(1.0 + e[0] - e[5] - e[10]) * 2;
+            out._w = (e[6] - e[9]) / s1;
+            out._x = 0.25 * s1;
+            out._y = (e[1] + e[4]) / s1;
+            out._z = (e[8] + e[2]) / s1;
+        } else if (e[5] > e[10]) {
+            var s2 = Math.sqrt(1.0 + e[5] - e[0] - e[10]) * 2;
+            out._w = (e[8] - e[2]) / s2;
+            out._x = (e[1] + e[4]) / s2;
+            out._y = 0.25 * s2;
+            out._z = (e[6] + e[9]) / s2;
+        } else {
+            var s3 = Math.sqrt(1.0 + e[10] - e[0] - e[5]) * 2;
+            out._w = (e[1] - e[4]) / s3;
+            out._x = (e[8] + e[2]) / s3;
+            out._y = (e[6] + e[9]) / s3;
+            out._z = 0.25 * s3;
+        }
+        out._onValueChanged == null ? void 0 : out._onValueChanged.call(out);
+        return out;
+    };
+    /**
+   * Get scale from this matrix.
+   * @param out - Scale vector as an output parameter
+   * @returns The out
+   */ _proto.getScaling = function getScaling(out) {
+        //getScale()
+        var e = this.elements;
+        var m11 = e[0], m12 = e[1], m13 = e[2];
+        var m21 = e[4], m22 = e[5], m23 = e[6];
+        var m31 = e[8], m32 = e[9], m33 = e[10];
+        out.set(Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13), Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23), Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33));
+        return out;
+    };
+    /**
+   * Get translation from this matrix.
+   * @param out - Translation vector as an output parameter
+   * @returns The out
+   */ _proto.getTranslation = function getTranslation(out) {
+        var e = this.elements;
+        out.set(e[12], e[13], e[14]);
+        return out;
+    };
+    /**
+   * Identity this matrix.
+   * @returns This matrix after identity
+   */ _proto.identity = function identity() {
+        var e = this.elements;
+        e[0] = 1;
+        e[1] = 0;
+        e[2] = 0;
+        e[3] = 0;
+        e[4] = 0;
+        e[5] = 1;
+        e[6] = 0;
+        e[7] = 0;
+        e[8] = 0;
+        e[9] = 0;
+        e[10] = 1;
+        e[11] = 0;
+        e[12] = 0;
+        e[13] = 0;
+        e[14] = 0;
+        e[15] = 1;
+        return this;
+    };
+    /**
+   * Invert the matrix.
+   * @returns The matrix after invert
+   */ _proto.invert = function invert() {
+        Matrix.invert(this, this);
+        return this;
+    };
+    /**
+   * This matrix rotates around an arbitrary axis.
+   * @param axis - The axis
+   * @param r - The rotation angle in radians
+   * @returns This matrix after rotate
+   */ _proto.rotateAxisAngle = function rotateAxisAngle(axis, r) {
+        Matrix.rotateAxisAngle(this, axis, r, this);
+        return this;
+    };
+    /**
+   * Scale this matrix by a given vector.
+   * @param s - The given vector
+   * @returns This matrix after scale
+   */ _proto.scale = function scale(s) {
+        Matrix.scale(this, s, this);
+        return this;
+    };
+    /**
+   * Translate this matrix by a given vector.
+   * @param v - The given vector
+   * @returns This matrix after translate
+   */ _proto.translate = function translate(v) {
+        Matrix.translate(this, v, this);
+        return this;
+    };
+    /**
+   * Calculate the transpose of this matrix.
+   * @returns This matrix after transpose
+   */ _proto.transpose = function transpose() {
+        Matrix.transpose(this, this);
+        return this;
+    };
+    /**
+   * Creates a clone of this matrix.
+   * @returns A clone of this matrix
+   */ _proto.clone = function clone() {
+        var e = this.elements;
+        var ret = new Matrix(e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8], e[9], e[10], e[11], e[12], e[13], e[14], e[15]);
+        return ret;
+    };
+    /**
+   * Copy this matrix from the specified matrix.
+   * @param source - The specified matrix
+   * @returns This matrix
+   */ _proto.copyFrom = function copyFrom(source) {
+        var e = this.elements;
+        var se = source.elements;
+        e[0] = se[0];
+        e[1] = se[1];
+        e[2] = se[2];
+        e[3] = se[3];
+        e[4] = se[4];
+        e[5] = se[5];
+        e[6] = se[6];
+        e[7] = se[7];
+        e[8] = se[8];
+        e[9] = se[9];
+        e[10] = se[10];
+        e[11] = se[11];
+        e[12] = se[12];
+        e[13] = se[13];
+        e[14] = se[14];
+        e[15] = se[15];
+        return this;
+    };
+    /**
+   * Copy the value of this matrix from an array.
+   * @param array - The array
+   * @param offset - The start offset of the array
+   * @returns This matrix
+   */ _proto.copyFromArray = function copyFromArray(array, offset) {
+        if (offset === void 0) offset = 0;
+        var srce = this.elements;
+        for(var i = 0; i < 16; i++){
+            srce[i] = array[i + offset];
+        }
+        return this;
+    };
+    /**
+   * Copy the value of this matrix to an array.
+   * @param out - The array
+   * @param outOffset - The start offset of the array
+   */ _proto.copyToArray = function copyToArray(out, outOffset) {
+        if (outOffset === void 0) outOffset = 0;
+        var e = this.elements;
+        out[outOffset] = e[0];
+        out[outOffset + 1] = e[1];
+        out[outOffset + 2] = e[2];
+        out[outOffset + 3] = e[3];
+        out[outOffset + 4] = e[4];
+        out[outOffset + 5] = e[5];
+        out[outOffset + 6] = e[6];
+        out[outOffset + 7] = e[7];
+        out[outOffset + 8] = e[8];
+        out[outOffset + 9] = e[9];
+        out[outOffset + 10] = e[10];
+        out[outOffset + 11] = e[11];
+        out[outOffset + 12] = e[12];
+        out[outOffset + 13] = e[13];
+        out[outOffset + 14] = e[14];
+        out[outOffset + 15] = e[15];
+    };
+    /**
+   * Determines the product of two matrices.
+   * @param left - The first matrix to multiply
+   * @param right - The second matrix to multiply
+   * @param out - The product of the two matrices
+   */ Matrix.multiply = function multiply(left, right, out) {
+        var le = left.elements;
+        var re = right.elements;
+        var oe = out.elements;
+        // prettier-ignore
+        var l11 = le[0], l12 = le[1], l13 = le[2], l14 = le[3], l21 = le[4], l22 = le[5], l23 = le[6], l24 = le[7], l31 = le[8], l32 = le[9], l33 = le[10], l34 = le[11], l41 = le[12], l42 = le[13], l43 = le[14], l44 = le[15];
+        // prettier-ignore
+        var r11 = re[0], r12 = re[1], r13 = re[2], r14 = re[3], r21 = re[4], r22 = re[5], r23 = re[6], r24 = re[7], r31 = re[8], r32 = re[9], r33 = re[10], r34 = re[11], r41 = re[12], r42 = re[13], r43 = re[14], r44 = re[15];
+        oe[0] = l11 * r11 + l21 * r12 + l31 * r13 + l41 * r14;
+        oe[1] = l12 * r11 + l22 * r12 + l32 * r13 + l42 * r14;
+        oe[2] = l13 * r11 + l23 * r12 + l33 * r13 + l43 * r14;
+        oe[3] = l14 * r11 + l24 * r12 + l34 * r13 + l44 * r14;
+        oe[4] = l11 * r21 + l21 * r22 + l31 * r23 + l41 * r24;
+        oe[5] = l12 * r21 + l22 * r22 + l32 * r23 + l42 * r24;
+        oe[6] = l13 * r21 + l23 * r22 + l33 * r23 + l43 * r24;
+        oe[7] = l14 * r21 + l24 * r22 + l34 * r23 + l44 * r24;
+        oe[8] = l11 * r31 + l21 * r32 + l31 * r33 + l41 * r34;
+        oe[9] = l12 * r31 + l22 * r32 + l32 * r33 + l42 * r34;
+        oe[10] = l13 * r31 + l23 * r32 + l33 * r33 + l43 * r34;
+        oe[11] = l14 * r31 + l24 * r32 + l34 * r33 + l44 * r34;
+        oe[12] = l11 * r41 + l21 * r42 + l31 * r43 + l41 * r44;
+        oe[13] = l12 * r41 + l22 * r42 + l32 * r43 + l42 * r44;
+        oe[14] = l13 * r41 + l23 * r42 + l33 * r43 + l43 * r44;
+        oe[15] = l14 * r41 + l24 * r42 + l34 * r43 + l44 * r44;
+    };
+    /**
+   * Determines whether the specified matrices are equals.
+   * @param left - The first matrix to compare
+   * @param right - The second matrix to compare
+   * @returns True if the specified matrices are equals, false otherwise
+   */ Matrix.equals = function equals(left, right) {
+        var le = left.elements;
+        var re = right.elements;
+        return MathUtil.equals(le[0], re[0]) && MathUtil.equals(le[1], re[1]) && MathUtil.equals(le[2], re[2]) && MathUtil.equals(le[3], re[3]) && MathUtil.equals(le[4], re[4]) && MathUtil.equals(le[5], re[5]) && MathUtil.equals(le[6], re[6]) && MathUtil.equals(le[7], re[7]) && MathUtil.equals(le[8], re[8]) && MathUtil.equals(le[9], re[9]) && MathUtil.equals(le[10], re[10]) && MathUtil.equals(le[11], re[11]) && MathUtil.equals(le[12], re[12]) && MathUtil.equals(le[13], re[13]) && MathUtil.equals(le[14], re[14]) && MathUtil.equals(le[15], re[15]);
+    };
+    /**
+   * Performs a linear interpolation between two matrices.
+   * @param start - The first matrix
+   * @param end - The second matrix
+   * @param t - The blend amount where 0 returns start and 1 end
+   * @param out - The result of linear blending between two matrices
+   */ Matrix.lerp = function lerp(start, end, t, out) {
+        var se = start.elements;
+        var ee = end.elements;
+        var oe = out.elements;
+        var inv = 1.0 - t;
+        oe[0] = se[0] * inv + ee[0] * t;
+        oe[1] = se[1] * inv + ee[1] * t;
+        oe[2] = se[2] * inv + ee[2] * t;
+        oe[3] = se[3] * inv + ee[3] * t;
+        oe[4] = se[4] * inv + ee[4] * t;
+        oe[5] = se[5] * inv + ee[5] * t;
+        oe[6] = se[6] * inv + ee[6] * t;
+        oe[7] = se[7] * inv + ee[7] * t;
+        oe[8] = se[8] * inv + ee[8] * t;
+        oe[9] = se[9] * inv + ee[9] * t;
+        oe[10] = se[10] * inv + ee[10] * t;
+        oe[11] = se[11] * inv + ee[11] * t;
+        oe[12] = se[12] * inv + ee[12] * t;
+        oe[13] = se[13] * inv + ee[13] * t;
+        oe[14] = se[14] * inv + ee[14] * t;
+        oe[15] = se[15] * inv + ee[15] * t;
+    };
+    /**
+   * Determines the sum of two matrices.
+   * @param left - The first matrix to add
+   * @param right - The second matrix to add
+   * @param out - The sum of two matrices
+   */ Matrix.add = function add(left, right, out) {
+        var le = left.elements;
+        var re = right.elements;
+        var oe = out.elements;
+        oe[0] = le[0] + re[0];
+        oe[1] = le[1] + re[1];
+        oe[2] = le[2] + re[2];
+        oe[3] = le[3] + re[3];
+        oe[4] = le[4] + re[4];
+        oe[5] = le[5] + re[5];
+        oe[6] = le[6] + re[6];
+        oe[7] = le[7] + re[7];
+        oe[8] = le[8] + re[8];
+        oe[9] = le[9] + re[9];
+        oe[10] = le[10] + re[10];
+        oe[11] = le[11] + re[11];
+        oe[12] = le[12] + re[12];
+        oe[13] = le[13] + re[13];
+        oe[14] = le[14] + re[14];
+        oe[15] = le[15] + re[15];
+    };
+    /**
+   * Multiplies a matrix by a scalar.
+   * @param source - The matrix to multiply
+   * @param scalar - The scalar to multiply
+   * @param out - The result of multiplying a matrix by a scalar
+   */ Matrix.multiplyScalar = function multiplyScalar(source, scalar, out) {
+        var se = source.elements;
+        var oe = out.elements;
+        oe[0] = se[0] * scalar;
+        oe[1] = se[1] * scalar;
+        oe[2] = se[2] * scalar;
+        oe[3] = se[3] * scalar;
+        oe[4] = se[4] * scalar;
+        oe[5] = se[5] * scalar;
+        oe[6] = se[6] * scalar;
+        oe[7] = se[7] * scalar;
+        oe[8] = se[8] * scalar;
+        oe[9] = se[9] * scalar;
+        oe[10] = se[10] * scalar;
+        oe[11] = se[11] * scalar;
+        oe[12] = se[12] * scalar;
+        oe[13] = se[13] * scalar;
+        oe[14] = se[14] * scalar;
+        oe[15] = se[15] * scalar;
+    };
+    /**
+   * Calculate a rotation matrix from a quaternion.
+   * @param quaternion - The quaternion used to calculate the matrix
+   * @param out - The calculated rotation matrix
+   */ Matrix.rotationQuaternion = function rotationQuaternion(quaternion, out) {
+        var oe = out.elements;
+        var x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
+        var x2 = x + x;
+        var y2 = y + y;
+        var z2 = z + z;
+        var xx = x * x2;
+        var yx = y * x2;
+        var yy = y * y2;
+        var zx = z * x2;
+        var zy = z * y2;
+        var zz = z * z2;
+        var wx = w * x2;
+        var wy = w * y2;
+        var wz = w * z2;
+        oe[0] = 1 - yy - zz;
+        oe[1] = yx + wz;
+        oe[2] = zx - wy;
+        oe[3] = 0;
+        oe[4] = yx - wz;
+        oe[5] = 1 - xx - zz;
+        oe[6] = zy + wx;
+        oe[7] = 0;
+        oe[8] = zx + wy;
+        oe[9] = zy - wx;
+        oe[10] = 1 - xx - yy;
+        oe[11] = 0;
+        oe[12] = 0;
+        oe[13] = 0;
+        oe[14] = 0;
+        oe[15] = 1;
+    };
+    /**
+   * Calculate a matrix rotates around an arbitrary axis.
+   * @param axis - The axis
+   * @param r - The rotation angle in radians
+   * @param out - The matrix after rotate
+   */ Matrix.rotationAxisAngle = function rotationAxisAngle(axis, r, out) {
+        var oe = out.elements;
+        var x = axis._x, y = axis._y, z = axis._z;
+        var len = Math.sqrt(x * x + y * y + z * z);
+        var s, c, t;
+        if (Math.abs(len) < MathUtil.zeroTolerance) {
+            return;
+        }
+        len = 1 / len;
+        x *= len;
+        y *= len;
+        z *= len;
+        s = Math.sin(r);
+        c = Math.cos(r);
+        t = 1 - c;
+        // Perform rotation-specific matrix multiplication
+        oe[0] = x * x * t + c;
+        oe[1] = y * x * t + z * s;
+        oe[2] = z * x * t - y * s;
+        oe[3] = 0;
+        oe[4] = x * y * t - z * s;
+        oe[5] = y * y * t + c;
+        oe[6] = z * y * t + x * s;
+        oe[7] = 0;
+        oe[8] = x * z * t + y * s;
+        oe[9] = y * z * t - x * s;
+        oe[10] = z * z * t + c;
+        oe[11] = 0;
+        oe[12] = 0;
+        oe[13] = 0;
+        oe[14] = 0;
+        oe[15] = 1;
+    };
+    /**
+   * Calculate a matrix from a quaternion and a translation.
+   * @param quaternion - The quaternion used to calculate the matrix
+   * @param translation - The translation used to calculate the matrix
+   * @param out - The calculated matrix
+   */ Matrix.rotationTranslation = function rotationTranslation(quaternion, translation, out) {
+        Matrix.rotationQuaternion(quaternion, out);
+        var oe = out.elements;
+        oe[12] = translation._x;
+        oe[13] = translation._y;
+        oe[14] = translation._z;
+    };
+    /**
+   * Calculate an affine matrix.
+   * @param scale - The scale used to calculate matrix
+   * @param rotation - The rotation used to calculate matrix
+   * @param translation - The translation used to calculate matrix
+   * @param out - The calculated matrix
+   */ Matrix.affineTransformation = function affineTransformation(scale, rotation, translation, out) {
+        var oe = out.elements;
+        var x = rotation._x, y = rotation._y, z = rotation._z, w = rotation._w;
+        var x2 = x + x;
+        var y2 = y + y;
+        var z2 = z + z;
+        var xx = x * x2;
+        var xy = x * y2;
+        var xz = x * z2;
+        var yy = y * y2;
+        var yz = y * z2;
+        var zz = z * z2;
+        var wx = w * x2;
+        var wy = w * y2;
+        var wz = w * z2;
+        var sx = scale._x;
+        var sy = scale._y;
+        var sz = scale._z;
+        oe[0] = (1 - (yy + zz)) * sx;
+        oe[1] = (xy + wz) * sx;
+        oe[2] = (xz - wy) * sx;
+        oe[3] = 0;
+        oe[4] = (xy - wz) * sy;
+        oe[5] = (1 - (xx + zz)) * sy;
+        oe[6] = (yz + wx) * sy;
+        oe[7] = 0;
+        oe[8] = (xz + wy) * sz;
+        oe[9] = (yz - wx) * sz;
+        oe[10] = (1 - (xx + yy)) * sz;
+        oe[11] = 0;
+        oe[12] = translation._x;
+        oe[13] = translation._y;
+        oe[14] = translation._z;
+        oe[15] = 1;
+    };
+    /**
+   * Calculate a matrix from scale vector.
+   * @param s - The scale vector
+   * @param out - The calculated matrix
+   */ Matrix.scaling = function scaling(s, out) {
+        var oe = out.elements;
+        oe[0] = s._x;
+        oe[1] = 0;
+        oe[2] = 0;
+        oe[3] = 0;
+        oe[4] = 0;
+        oe[5] = s._y;
+        oe[6] = 0;
+        oe[7] = 0;
+        oe[8] = 0;
+        oe[9] = 0;
+        oe[10] = s._z;
+        oe[11] = 0;
+        oe[12] = 0;
+        oe[13] = 0;
+        oe[14] = 0;
+        oe[15] = 1;
+    };
+    /**
+   * Calculate a matrix from translation vector.
+   * @param translation - The translation vector
+   * @param out - The calculated matrix
+   */ Matrix.translation = function translation(translation, out) {
+        var oe = out.elements;
+        oe[0] = 1;
+        oe[1] = 0;
+        oe[2] = 0;
+        oe[3] = 0;
+        oe[4] = 0;
+        oe[5] = 1;
+        oe[6] = 0;
+        oe[7] = 0;
+        oe[8] = 0;
+        oe[9] = 0;
+        oe[10] = 1;
+        oe[11] = 0;
+        oe[12] = translation._x;
+        oe[13] = translation._y;
+        oe[14] = translation._z;
+        oe[15] = 1;
+    };
+    /**
+   * Calculate the inverse of the specified matrix.
+   * @param a - The matrix whose inverse is to be calculated
+   * @param out - The inverse of the specified matrix
+   */ Matrix.invert = function invert(a, out) {
+        var ae = a.elements;
+        var oe = out.elements;
+        var a11 = ae[0], a12 = ae[1], a13 = ae[2], a14 = ae[3];
+        var a21 = ae[4], a22 = ae[5], a23 = ae[6], a24 = ae[7];
+        var a31 = ae[8], a32 = ae[9], a33 = ae[10], a34 = ae[11];
+        var a41 = ae[12], a42 = ae[13], a43 = ae[14], a44 = ae[15];
+        var b00 = a11 * a22 - a12 * a21;
+        var b01 = a11 * a23 - a13 * a21;
+        var b02 = a11 * a24 - a14 * a21;
+        var b03 = a12 * a23 - a13 * a22;
+        var b04 = a12 * a24 - a14 * a22;
+        var b05 = a13 * a24 - a14 * a23;
+        var b06 = a31 * a42 - a32 * a41;
+        var b07 = a31 * a43 - a33 * a41;
+        var b08 = a31 * a44 - a34 * a41;
+        var b09 = a32 * a43 - a33 * a42;
+        var b10 = a32 * a44 - a34 * a42;
+        var b11 = a33 * a44 - a34 * a43;
+        var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+        if (!det) {
+            return null;
+        }
+        det = 1.0 / det;
+        oe[0] = (a22 * b11 - a23 * b10 + a24 * b09) * det;
+        oe[1] = (a13 * b10 - a12 * b11 - a14 * b09) * det;
+        oe[2] = (a42 * b05 - a43 * b04 + a44 * b03) * det;
+        oe[3] = (a33 * b04 - a32 * b05 - a34 * b03) * det;
+        oe[4] = (a23 * b08 - a21 * b11 - a24 * b07) * det;
+        oe[5] = (a11 * b11 - a13 * b08 + a14 * b07) * det;
+        oe[6] = (a43 * b02 - a41 * b05 - a44 * b01) * det;
+        oe[7] = (a31 * b05 - a33 * b02 + a34 * b01) * det;
+        oe[8] = (a21 * b10 - a22 * b08 + a24 * b06) * det;
+        oe[9] = (a12 * b08 - a11 * b10 - a14 * b06) * det;
+        oe[10] = (a41 * b04 - a42 * b02 + a44 * b00) * det;
+        oe[11] = (a32 * b02 - a31 * b04 - a34 * b00) * det;
+        oe[12] = (a22 * b07 - a21 * b09 - a23 * b06) * det;
+        oe[13] = (a11 * b09 - a12 * b07 + a13 * b06) * det;
+        oe[14] = (a42 * b01 - a41 * b03 - a43 * b00) * det;
+        oe[15] = (a31 * b03 - a32 * b01 + a33 * b00) * det;
+    };
+    /**
+   * Calculate a right-handed look-at matrix.
+   * @param eye - The position of the viewer's eye
+   * @param target - The camera look-at target
+   * @param up - The camera's up vector
+   * @param out - The calculated look-at matrix
+   */ Matrix.lookAt = function lookAt(eye, target, up, out) {
+        var oe = out.elements;
+        var xAxis = Matrix._tempVec30;
+        var yAxis = Matrix._tempVec31;
+        var zAxis = Matrix._tempVec32;
+        Vector3.subtract(eye, target, zAxis);
+        zAxis.normalize();
+        Vector3.cross(up, zAxis, xAxis);
+        xAxis.normalize();
+        Vector3.cross(zAxis, xAxis, yAxis);
+        oe[0] = xAxis._x;
+        oe[1] = yAxis._x;
+        oe[2] = zAxis._x;
+        oe[3] = 0;
+        oe[4] = xAxis._y;
+        oe[5] = yAxis._y;
+        oe[6] = zAxis._y;
+        oe[7] = 0;
+        oe[8] = xAxis._z;
+        oe[9] = yAxis._z;
+        oe[10] = zAxis._z;
+        oe[11] = 0;
+        oe[12] = -Vector3.dot(xAxis, eye);
+        oe[13] = -Vector3.dot(yAxis, eye);
+        oe[14] = -Vector3.dot(zAxis, eye);
+        oe[15] = 1;
+    };
+    /**
+   * Calculate an orthographic projection matrix.
+   * @param left - The left edge of the viewing
+   * @param right - The right edge of the viewing
+   * @param bottom - The bottom edge of the viewing
+   * @param top - The top edge of the viewing
+   * @param near - The depth of the near plane
+   * @param far - The depth of the far plane
+   * @param out - The calculated orthographic projection matrix
+   */ Matrix.ortho = function ortho(left, right, bottom, top, near, far, out) {
+        var oe = out.elements;
+        var lr = 1 / (left - right);
+        var bt = 1 / (bottom - top);
+        var nf = 1 / (near - far);
+        oe[0] = -2 * lr;
+        oe[1] = 0;
+        oe[2] = 0;
+        oe[3] = 0;
+        oe[4] = 0;
+        oe[5] = -2 * bt;
+        oe[6] = 0;
+        oe[7] = 0;
+        oe[8] = 0;
+        oe[9] = 0;
+        oe[10] = 2 * nf;
+        oe[11] = 0;
+        oe[12] = (left + right) * lr;
+        oe[13] = (top + bottom) * bt;
+        oe[14] = (far + near) * nf;
+        oe[15] = 1;
+    };
+    /**
+   * Calculate a perspective projection matrix.
+   * @param fovY - Field of view in the y direction, in radians
+   * @param aspect - Aspect ratio, defined as view space width divided by height
+   * @param near - The depth of the near plane
+   * @param far - The depth of the far plane
+   * @param out - The calculated perspective projection matrix
+   */ Matrix.perspective = function perspective(fovY, aspect, near, far, out) {
+        var oe = out.elements;
+        var f = 1.0 / Math.tan(fovY / 2);
+        var nf = 1 / (near - far);
+        oe[0] = f / aspect;
+        oe[1] = 0;
+        oe[2] = 0;
+        oe[3] = 0;
+        oe[4] = 0;
+        oe[5] = f;
+        oe[6] = 0;
+        oe[7] = 0;
+        oe[8] = 0;
+        oe[9] = 0;
+        oe[10] = (far + near) * nf;
+        oe[11] = -1;
+        oe[12] = 0;
+        oe[13] = 0;
+        oe[14] = 2 * far * near * nf;
+        oe[15] = 0;
+    };
+    /**
+   * The specified matrix rotates around an arbitrary axis.
+   * @param m - The specified matrix
+   * @param axis - The axis
+   * @param r - The rotation angle in radians
+   * @param out - The rotated matrix
+   */ Matrix.rotateAxisAngle = function rotateAxisAngle(m, axis, r, out) {
+        var x = axis._x, y = axis._y, z = axis._z;
+        var len = Math.sqrt(x * x + y * y + z * z);
+        if (Math.abs(len) < MathUtil.zeroTolerance) {
+            return;
+        }
+        var me = m.elements;
+        var oe = out.elements;
+        var s, c, t;
+        len = 1 / len;
+        x *= len;
+        y *= len;
+        z *= len;
+        s = Math.sin(r);
+        c = Math.cos(r);
+        t = 1 - c;
+        var a11 = me[0], a12 = me[1], a13 = me[2], a14 = me[3];
+        var a21 = me[4], a22 = me[5], a23 = me[6], a24 = me[7];
+        var a31 = me[8], a32 = me[9], a33 = me[10], a34 = me[11];
+        // Construct the elements of the rotation matrix
+        var b11 = x * x * t + c;
+        var b12 = y * x * t + z * s;
+        var b13 = z * x * t - y * s;
+        var b21 = x * y * t - z * s;
+        var b22 = y * y * t + c;
+        var b23 = z * y * t + x * s;
+        var b31 = x * z * t + y * s;
+        var b32 = y * z * t - x * s;
+        var b33 = z * z * t + c;
+        // Perform rotation-specific matrix multiplication
+        oe[0] = a11 * b11 + a21 * b12 + a31 * b13;
+        oe[1] = a12 * b11 + a22 * b12 + a32 * b13;
+        oe[2] = a13 * b11 + a23 * b12 + a33 * b13;
+        oe[3] = a14 * b11 + a24 * b12 + a34 * b13;
+        oe[4] = a11 * b21 + a21 * b22 + a31 * b23;
+        oe[5] = a12 * b21 + a22 * b22 + a32 * b23;
+        oe[6] = a13 * b21 + a23 * b22 + a33 * b23;
+        oe[7] = a14 * b21 + a24 * b22 + a34 * b23;
+        oe[8] = a11 * b31 + a21 * b32 + a31 * b33;
+        oe[9] = a12 * b31 + a22 * b32 + a32 * b33;
+        oe[10] = a13 * b31 + a23 * b32 + a33 * b33;
+        oe[11] = a14 * b31 + a24 * b32 + a34 * b33;
+        if (m !== out) {
+            // If the source and destination differ, copy the unchanged last row
+            oe[12] = me[12];
+            oe[13] = me[13];
+            oe[14] = me[14];
+            oe[15] = me[15];
+        }
+    };
+    /**
+   * Scale a matrix by a given vector.
+   * @param m - The matrix
+   * @param s - The given vector
+   * @param out - The scaled matrix
+   */ Matrix.scale = function scale(m, s, out) {
+        var me = m.elements;
+        var oe = out.elements;
+        var x = s._x, y = s._y, z = s._z;
+        oe[0] = me[0] * x;
+        oe[1] = me[1] * x;
+        oe[2] = me[2] * x;
+        oe[3] = me[3] * x;
+        oe[4] = me[4] * y;
+        oe[5] = me[5] * y;
+        oe[6] = me[6] * y;
+        oe[7] = me[7] * y;
+        oe[8] = me[8] * z;
+        oe[9] = me[9] * z;
+        oe[10] = me[10] * z;
+        oe[11] = me[11] * z;
+        oe[12] = me[12];
+        oe[13] = me[13];
+        oe[14] = me[14];
+        oe[15] = me[15];
+    };
+    /**
+   * Translate a matrix by a given vector.
+   * @param m - The matrix
+   * @param v - The given vector
+   * @param out - The translated matrix
+   */ Matrix.translate = function translate(m, v, out) {
+        var me = m.elements;
+        var oe = out.elements;
+        var x = v._x, y = v._y, z = v._z;
+        if (m === out) {
+            oe[12] = me[0] * x + me[4] * y + me[8] * z + me[12];
+            oe[13] = me[1] * x + me[5] * y + me[9] * z + me[13];
+            oe[14] = me[2] * x + me[6] * y + me[10] * z + me[14];
+            oe[15] = me[3] * x + me[7] * y + me[11] * z + me[15];
+        } else {
+            var a11 = me[0], a12 = me[1], a13 = me[2], a14 = me[3];
+            var a21 = me[4], a22 = me[5], a23 = me[6], a24 = me[7];
+            var a31 = me[8], a32 = me[9], a33 = me[10], a34 = me[11];
+            oe[0] = a11, oe[1] = a12, oe[2] = a13, oe[3] = a14;
+            oe[4] = a21, oe[5] = a22, oe[6] = a23, oe[7] = a24;
+            oe[8] = a31, oe[9] = a32, oe[10] = a33, oe[11] = a34;
+            oe[12] = a11 * x + a21 * y + a31 * z + me[12];
+            oe[13] = a12 * x + a22 * y + a32 * z + me[13];
+            oe[14] = a13 * x + a23 * y + a33 * z + me[14];
+            oe[15] = a14 * x + a24 * y + a34 * z + me[15];
+        }
+    };
+    /**
+   * Calculate the transpose of the specified matrix.
+   * @param a - The specified matrix
+   * @param out - The transpose of the specified matrix
+   */ Matrix.transpose = function transpose(a, out) {
+        var ae = a.elements;
+        var oe = out.elements;
+        if (out === a) {
+            var a12 = ae[1];
+            var a13 = ae[2];
+            var a14 = ae[3];
+            var a23 = ae[6];
+            var a24 = ae[7];
+            var a34 = ae[11];
+            oe[1] = ae[4];
+            oe[2] = ae[8];
+            oe[3] = ae[12];
+            oe[4] = a12;
+            oe[6] = ae[9];
+            oe[7] = ae[13];
+            oe[8] = a13;
+            oe[9] = a23;
+            oe[11] = ae[14];
+            oe[12] = a14;
+            oe[13] = a24;
+            oe[14] = a34;
+        } else {
+            oe[0] = ae[0];
+            oe[1] = ae[4];
+            oe[2] = ae[8];
+            oe[3] = ae[12];
+            oe[4] = ae[1];
+            oe[5] = ae[5];
+            oe[6] = ae[9];
+            oe[7] = ae[13];
+            oe[8] = ae[2];
+            oe[9] = ae[6];
+            oe[10] = ae[10];
+            oe[11] = ae[14];
+            oe[12] = ae[3];
+            oe[13] = ae[7];
+            oe[14] = ae[11];
+            oe[15] = ae[15];
+        }
+    };
+    return Matrix;
+}();
+Matrix._tempVec30 = new Vector3();
+Matrix._tempVec31 = new Vector3();
+Matrix._tempVec32 = new Vector3();
+Matrix._tempMat30 = new Matrix3x3();
+/** @internal Identity matrix. */ Matrix._identity = new Matrix(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
+
+var WebXRFrame = /*#__PURE__*/ function() {
+    function WebXRFrame(session) {
+        this._session = session;
+    }
+    var _proto = WebXRFrame.prototype;
+    _proto.updateInputs = function updateInputs(inputs) {
+        if (!this._platformFrame) return;
+        this._updateController(inputs);
+        this._updateCamera(inputs);
+    };
+    _proto._updateController = function _updateController(inputs) {
+        var _this = this, frame = _this._platformFrame;
+        var _this__session = this._session, session = _this__session._platformSession, referenceSpace = _this__session._platformReferenceSpace;
+        var inputSources = session.inputSources;
+        for(var i = 0, n = inputSources.length; i < n; i++){
+            var inputSource = inputSources[i];
+            var type = getInputSource(inputSource);
+            var input = inputs[type];
+            switch(inputSource.targetRayMode){
+                case "screen":
+                case "tracked-pointer":
+                    var gripSpace = inputSource.gripSpace, targetRaySpace = inputSource.targetRaySpace;
+                    if (gripSpace) {
+                        var _frame_getPose = frame.getPose(gripSpace, referenceSpace), transform = _frame_getPose.transform, emulatedPosition = _frame_getPose.emulatedPosition;
+                        if (transform) {
+                            var gripPose = input.gripPose;
+                            gripPose.matrix.copyFromArray(transform.matrix);
+                            gripPose.position.copyFrom(transform.position);
+                            gripPose.rotation.copyFrom(transform.orientation);
+                        }
+                        input.trackingState = emulatedPosition ? XRTrackingState.TrackingLost : XRTrackingState.Tracking;
+                    }
+                    if (targetRaySpace) {
+                        var _frame_getPose1 = frame.getPose(targetRaySpace, referenceSpace), transform1 = _frame_getPose1.transform, emulatedPosition1 = _frame_getPose1.emulatedPosition;
+                        if (transform1) {
+                            var targetRayPose = input.targetRayPose;
+                            targetRayPose.matrix.copyFromArray(transform1.matrix);
+                            targetRayPose.position.copyFrom(transform1.position);
+                            targetRayPose.rotation.copyFrom(transform1.orientation);
+                            input.trackingState = emulatedPosition1 ? XRTrackingState.TrackingLost : XRTrackingState.Tracking;
+                        }
+                    }
+                    break;
+            }
+        }
+    };
+    _proto._updateCamera = function _updateCamera(inputs) {
+        var _this = this, frame = _this._platformFrame;
+        var _this__session = this._session, referenceSpace = _this__session._platformReferenceSpace, layer = _this__session._platformLayer, framebufferWidth = _this__session.framebufferWidth, framebufferHeight = _this__session.framebufferHeight;
+        var viewerPose = frame.getViewerPose(referenceSpace);
+        if (viewerPose) {
+            var hadUpdateCenterViewer = false;
+            var views = viewerPose.views, emulatedPosition = viewerPose.emulatedPosition;
+            for(var i = 0, n = views.length; i < n; i++){
+                var view = views[i];
+                var type = viewToCamera(view.eye);
+                var transform = views[i].transform;
+                if (type === XRTrackedInputDevice.Camera) {
+                    hadUpdateCenterViewer || (hadUpdateCenterViewer = true);
+                }
+                var xrCamera = inputs[type];
+                var pose = xrCamera.pose;
+                pose.matrix.copyFromArray(transform.matrix);
+                pose.position.copyFrom(transform.position);
+                pose.rotation.copyFrom(transform.orientation);
+                xrCamera.projectionMatrix.copyFromArray(view.projectionMatrix);
+                xrCamera.trackingState = emulatedPosition ? XRTrackingState.TrackingLost : XRTrackingState.Tracking;
+                var xrViewport = layer.getViewport(view);
+                var width = xrViewport.width / framebufferWidth;
+                var height = xrViewport.height / framebufferHeight;
+                var x = xrViewport.x / framebufferWidth;
+                var y = 1 - xrViewport.y / framebufferHeight - height;
+                xrCamera.viewport.set(x, y, width, height);
+            }
+            if (!hadUpdateCenterViewer) {
+                var leftCameraDevice = inputs[XRTrackedInputDevice.LeftCamera];
+                var rightCameraDevice = inputs[XRTrackedInputDevice.RightCamera];
+                var cameraDevice = inputs[XRTrackedInputDevice.Camera];
+                var leftCameraPose = leftCameraDevice.pose;
+                var rightCameraPose = rightCameraDevice.pose;
+                var cameraPose = cameraDevice.pose;
+                cameraPose.rotation.copyFrom(leftCameraPose.rotation);
+                var position = cameraPose.position, matrix = cameraPose.matrix;
+                Vector3.add(leftCameraPose.position, rightCameraPose.position, position);
+                position.scale(0.5);
+                matrix.copyFrom(leftCameraPose.matrix);
+                var elements = matrix.elements;
+                elements[12] = position.x;
+                elements[13] = position.y;
+                elements[14] = position.z;
+                cameraDevice.projectionMatrix.copyFrom(leftCameraDevice.projectionMatrix);
+                cameraDevice.trackingState = emulatedPosition ? XRTrackingState.TrackingLost : XRTrackingState.Tracking;
+                cameraDevice.viewport = leftCameraDevice.viewport.width && leftCameraDevice.viewport.height ? leftCameraDevice.viewport : rightCameraDevice.viewport;
+            }
+        }
+    };
+    return WebXRFrame;
+}();
+
+var WebXRSession = /*#__PURE__*/ function() {
+    function WebXRSession(session, layer, referenceSpace) {
+        this._events = [];
+        this._screenPointers = [];
+        this._inputEventTypeMap = {
+            selectstart: XRInputEventType.SelectStart,
+            select: XRInputEventType.Select,
+            selectend: XRInputEventType.SelectEnd,
+            squeezestart: XRInputEventType.SqueezeStart,
+            squeeze: XRInputEventType.Squeeze,
+            squeezeend: XRInputEventType.SqueezeEnd
+        };
+        this._targetRayModeMap = {
+            gaze: XRTargetRayMode.Gaze,
+            "tracked-pointer": XRTargetRayMode.TrackedPointer,
+            screen: XRTargetRayMode.Screen
+        };
+        this._frame = new WebXRFrame(this);
+        this._platformSession = session;
+        this._platformLayer = layer;
+        this._platformReferenceSpace = referenceSpace;
+        var xrRequestAnimationFrame = session.requestAnimationFrame.bind(session);
+        var onFrame = (function(time, frame, callback) {
+            this._frame._platformFrame = frame;
+            callback(time);
+        }).bind(this);
+        this.requestAnimationFrame = function(callback) {
+            return xrRequestAnimationFrame(function(time, frame) {
+                onFrame(time, frame, callback);
+            });
+        };
+        this.cancelAnimationFrame = session.cancelAnimationFrame.bind(session);
+        this._onSessionEvent = this._onSessionEvent.bind(this);
+        this._onSessionExit = this._onSessionExit.bind(this);
+    }
+    var _proto = WebXRSession.prototype;
+    _proto.getFixedFoveation = function getFixedFoveation() {
+        return this._platformLayer.fixedFoveation;
+    };
+    _proto.setFixedFoveation = function setFixedFoveation(value) {
+        this._platformLayer.fixedFoveation = value;
+    };
+    _proto.start = function start() {};
+    _proto.stop = function stop() {
+        this._frame._platformFrame = null;
+    };
+    _proto.end = function end() {
+        this._frame._platformFrame = null;
+        return this._platformSession.end();
+    };
+    _proto.setSessionExitCallBack = function setSessionExitCallBack(onSessionExitCallBack) {
+        this._onSessionExitCallBack = onSessionExitCallBack;
+    };
+    _proto.addEventListener = function addEventListener() {
+        var _this = this, onSessionEvent = _this._onSessionEvent, session = _this._platformSession;
+        session.addEventListener("select", onSessionEvent);
+        session.addEventListener("selectstart", onSessionEvent);
+        session.addEventListener("selectend", onSessionEvent);
+        session.addEventListener("squeeze", onSessionEvent);
+        session.addEventListener("squeezestart", onSessionEvent);
+        session.addEventListener("squeezeend", onSessionEvent);
+        session.addEventListener("end", this._onSessionExit);
+    };
+    _proto.removeEventListener = function removeEventListener() {
+        var _this = this, onSessionEvent = _this._onSessionEvent, session = _this._platformSession;
+        session.removeEventListener("select", onSessionEvent);
+        session.removeEventListener("selectstart", onSessionEvent);
+        session.removeEventListener("selectend", onSessionEvent);
+        session.removeEventListener("squeeze", onSessionEvent);
+        session.removeEventListener("squeezestart", onSessionEvent);
+        session.removeEventListener("squeezeend", onSessionEvent);
+        session.removeEventListener("end", this._onSessionExit);
+        this._events.length = 0;
+    };
+    _proto.resetEvents = function resetEvents() {
+        this._events.length = 0;
+    };
+    _proto._onSessionExit = function _onSessionExit() {
+        if (this._onSessionExitCallBack) {
+            this._onSessionExitCallBack();
+            this._onSessionExitCallBack = null;
+        }
+    };
+    _proto._onSessionEvent = function _onSessionEvent(inputSourceEvent) {
+        var inputSource = inputSourceEvent.inputSource;
+        var event = {
+            type: this._inputEventTypeMap[inputSourceEvent.type],
+            input: getInputSource(inputSource),
+            targetRayMode: this._targetRayModeMap[inputSource.targetRayMode]
+        };
+        if (event.targetRayMode === XRTargetRayMode.Screen) {
+            var _this = this, screenPointers = _this._screenPointers;
+            var axes = inputSource.gamepad.axes;
+            event.x = axes[0];
+            event.y = axes[1];
+            switch(event.type){
+                case XRInputEventType.SelectStart:
+                    var idx = -1;
+                    var emptyIdx = -1;
+                    for(var i = screenPointers.length - 1; i >= 0; i--){
+                        var pointer = screenPointers[i];
+                        if (pointer === inputSource) {
+                            idx = i;
+                            break;
+                        }
+                        if (!pointer) {
+                            emptyIdx = i;
+                        }
+                    }
+                    if (idx === -1) {
+                        if (emptyIdx === -1) {
+                            idx = screenPointers.push(inputSource) - 1;
+                        } else {
+                            idx = emptyIdx;
+                            screenPointers[emptyIdx] = inputSource;
+                        }
+                    }
+                    event.id = idx;
+                    break;
+                case XRInputEventType.SelectEnd:
+                    for(var i1 = screenPointers.length - 1; i1 >= 0; i1--){
+                        if (screenPointers[i1] === inputSource) {
+                            screenPointers[i1] = null;
+                            event.id = i1;
+                        }
+                    }
+                    break;
+            }
+        }
+        this._events.push(event);
+    };
+    _create_class$1(WebXRSession, [
+        {
+            key: "frame",
+            get: function get() {
+                return this._frame;
+            }
+        },
+        {
+            key: "framebuffer",
+            get: function get() {
+                return this._platformLayer.framebuffer;
+            }
+        },
+        {
+            key: "framebufferWidth",
+            get: function get() {
+                return this._platformLayer.framebufferWidth;
+            }
+        },
+        {
+            key: "framebufferHeight",
+            get: function get() {
+                return this._platformLayer.framebufferHeight;
+            }
+        },
+        {
+            key: "frameRate",
+            get: function get() {
+                return this._platformSession.frameRate;
+            }
+        },
+        {
+            key: "supportedFrameRates",
+            get: function get() {
+                return this._platformSession.supportedFrameRates;
+            }
+        },
+        {
+            key: "events",
+            get: function get() {
+                var _this = this, events = _this._events;
+                // Select event does not dispatch the move event, so we need to simulate dispatching the move here.
+                var _this1 = this, screenPointers = _this1._screenPointers;
+                for(var i = 0; i < screenPointers.length; i++){
+                    var inputSource = screenPointers[i];
+                    if (!inputSource) continue;
+                    var axes = inputSource.gamepad.axes;
+                    var event = {
+                        type: XRInputEventType.Select,
+                        targetRayMode: XRTargetRayMode.Screen,
+                        input: XRTrackedInputDevice.Controller,
+                        id: i,
+                        x: axes[0],
+                        y: axes[1]
+                    };
+                    events.push(event);
+                }
+                return events;
+            }
+        }
+    ]);
+    return WebXRSession;
+}();
+
+var WebXRDevice = /*#__PURE__*/ function() {
+    function WebXRDevice() {}
+    var _proto = WebXRDevice.prototype;
+    _proto.isSupportedSessionMode = function isSupportedSessionMode(mode) {
+        return new Promise(function(resolve, reject) {
+            if (!window.isSecureContext) {
+                reject(new Error("WebXR is available only in secure contexts (HTTPS)."));
+                return;
+            }
+            if (!navigator.xr) {
+                reject(new Error("WebXR isn't available"));
+                return;
+            }
+            navigator.xr.isSessionSupported(parseXRMode(mode)).then(function(isSupported) {
+                isSupported ? resolve() : reject(new Error("The current context doesn't support WebXR."));
+            });
+        });
+    };
+    _proto.isSupportedFeature = function isSupportedFeature(type) {
+        switch(type){
+            case XRFeatureType.HitTest:
+            case XRFeatureType.PlaneTracking:
+                return typeof XRPlane !== "undefined";
+            case XRFeatureType.AnchorTracking:
+                return typeof XRAnchor !== "undefined";
+            case XRFeatureType.ImageTracking:
+                // @ts-ignore
+                return typeof XRImageTrackingResult !== "undefined";
+        }
+    };
+    _proto.createPlatformFeature = function createPlatformFeature(type) {
+        for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            args[_key - 1] = arguments[_key];
+        }
+        var platformFeatureConstructor = WebXRDevice._platformFeatureMap[type];
+        return platformFeatureConstructor ? _construct(platformFeatureConstructor, [].concat(args)) : null;
+    };
+    _proto.requestSession = function requestSession(rhi, mode, platformFeatures) {
+        return new Promise(function(resolve, reject) {
+            var sessionMode = parseXRMode(mode);
+            var options = {
+                requiredFeatures: [
+                    "local"
+                ],
+                optionalFeatures: []
+            };
+            var promiseArr = [];
+            for(var i = 0, n = platformFeatures.length; i < n; i++){
+                var promise = platformFeatures[i]._assembleOptions(options);
+                promise && promiseArr.push(promise);
+            }
+            Promise.all(promiseArr).then(function() {
+                navigator.xr.requestSession(sessionMode, options).then(function(session) {
+                    var gl = rhi.gl;
+                    var attributes = gl.getContextAttributes();
+                    if (!attributes) {
+                        reject(Error("GetContextAttributes Error!"));
+                    }
+                    gl.makeXRCompatible().then(function() {
+                        var scaleFactor = XRWebGLLayer.getNativeFramebufferScaleFactor(session);
+                        var layer;
+                        if (session.renderState.layers === undefined || !!!rhi.isWebGL2) {
+                            var layerInit = {
+                                antialias: session.renderState.layers === undefined ? attributes.antialias : true,
+                                alpha: true,
+                                depth: attributes.depth,
+                                stencil: attributes.stencil,
+                                framebufferScaleFactor: scaleFactor
+                            };
+                            layer = new XRWebGLLayer(session, gl, layerInit);
+                            session.updateRenderState({
+                                baseLayer: layer
+                            });
+                        } else {
+                            layer = new XRWebGLLayer(session, gl);
+                            session.updateRenderState({
+                                layers: [
+                                    layer
+                                ]
+                            });
+                        }
+                        session.requestReferenceSpace("local").then(function(referenceSpace) {
+                            resolve(new WebXRSession(session, layer, referenceSpace));
+                        }, reject);
+                    }, reject);
+                }, reject);
+            }, reject);
+        });
+    };
+    return WebXRDevice;
+}();
+/** @internal */ WebXRDevice._platformFeatureMap = [];
+function registerXRPlatformFeature(type) {
+    return function(platformFeatureConstructor) {
+        WebXRDevice._platformFeatureMap[type] = platformFeatureConstructor;
+    };
+}
+
+/**
+ * @internal
+ */ var WebXRFeature = function WebXRFeature() {
+};
+
+/**
+ * @internal
+ */ var WebXRTrackableFeature = /*#__PURE__*/ function(WebXRFeature) {
+    _inherits(WebXRTrackableFeature, WebXRFeature);
+    function WebXRTrackableFeature() {
+        return WebXRFeature.apply(this, arguments) || this;
+    }
+    var _proto = WebXRTrackableFeature.prototype;
+    _proto.onAddRequestTracking = function onAddRequestTracking(requestTracking) {};
+    _proto.onDelRequestTracking = function onDelRequestTracking(requestTracking) {
+        requestTracking.state = XRRequestTrackingState.Destroyed;
+    };
+    _create_class$1(WebXRTrackableFeature, [
+        {
+            key: "canModifyRequestTrackingAfterInit",
+            get: function get() {
+                return false;
+            }
+        }
+    ]);
+    return WebXRTrackableFeature;
+}(WebXRFeature);
+
+var WebXRAnchorTracking = /*#__PURE__*/ function(WebXRTrackableFeature) {
+    _inherits(WebXRAnchorTracking, WebXRTrackableFeature);
+    function WebXRAnchorTracking() {
+        return WebXRTrackableFeature.apply(this, arguments) || this;
+    }
+    var _proto = WebXRAnchorTracking.prototype;
+    _proto.checkAvailable = function checkAvailable(session, frame, requestTrackings) {
+        if (!frame._platformFrame) return false;
+        for(var i = 0, n = requestTrackings.length; i < n; i++){
+            var requestTracking = requestTrackings[i];
+            if (requestTracking.state === XRRequestTrackingState.None) {
+                this._addAnchor(session, frame, requestTracking);
+            }
+        }
+        return true;
+    };
+    _proto.getTrackedResult = function getTrackedResult(session, frame, requestTrackings) {
+        var platformReferenceSpace = session._platformReferenceSpace;
+        var platformFrame = frame._platformFrame;
+        var trackedAnchors = platformFrame.trackedAnchors;
+        for(var i = 0, n = requestTrackings.length; i < n; i++){
+            var requestTracking = requestTrackings[i];
+            if (requestTracking.state !== XRRequestTrackingState.Resolved) continue;
+            var tracked = requestTracking.tracked[0];
+            if (trackedAnchors.has(requestTracking.xrAnchor)) {
+                var emulated = this._updateTrackedAnchor(platformFrame, platformReferenceSpace, requestTracking);
+                if (emulated) {
+                    if (tracked.state === XRTrackingState.Tracking) {
+                        tracked.state = XRTrackingState.TrackingLost;
+                    }
+                } else {
+                    tracked.state = XRTrackingState.Tracking;
+                }
+            } else {
+                tracked.state = XRTrackingState.NotTracking;
+            }
+        }
+    };
+    _proto.onDelRequestTracking = function onDelRequestTracking(requestTracking) {
+        switch(requestTracking.state){
+            case XRRequestTrackingState.Submitted:
+                requestTracking.state = XRRequestTrackingState.WaitingDestroy;
+                break;
+            case XRRequestTrackingState.Resolved:
+                requestTracking.xrAnchor.delete();
+                requestTracking.state = XRRequestTrackingState.Destroyed;
+                break;
+            default:
+                requestTracking.state = XRRequestTrackingState.Destroyed;
+                break;
+        }
+    };
+    /**
+   * @internal
+   */ _proto._assembleOptions = function _assembleOptions(options) {
+        options.optionalFeatures.push("anchors");
+    };
+    _proto._addAnchor = function _addAnchor(session, frame, requestTracking) {
+        if (!session || !frame) {
+            return;
+        }
+        requestTracking.state = XRRequestTrackingState.Submitted;
+        var position = requestTracking.position, rotation = requestTracking.rotation;
+        var platformFrame = frame._platformFrame;
+        var platformReferenceSpace = session._platformReferenceSpace;
+        platformFrame.createAnchor(new XRRigidTransform({
+            x: position.x,
+            y: position.y,
+            z: position.z
+        }, {
+            x: rotation.x,
+            y: rotation.y,
+            z: rotation.z,
+            w: rotation.w
+        }), platformReferenceSpace).then(function(xrAnchor) {
+            if (requestTracking.state === XRRequestTrackingState.WaitingDestroy) {
+                xrAnchor.delete();
+                requestTracking.state = XRRequestTrackingState.Destroyed;
+            } else {
+                requestTracking.xrAnchor = xrAnchor;
+                requestTracking.state = XRRequestTrackingState.Resolved;
+            }
+        }, function() {
+            if (requestTracking.state === XRRequestTrackingState.WaitingDestroy) {
+                requestTracking.state = XRRequestTrackingState.Destroyed;
+            } else {
+                requestTracking.state = XRRequestTrackingState.Rejected;
+            }
+        });
+    };
+    _proto._updateTrackedAnchor = function _updateTrackedAnchor(frame, space, requestTracking) {
+        var xrAnchor = requestTracking.xrAnchor;
+        var xrPose = frame.getPose(xrAnchor.anchorSpace, space);
+        var transform = xrPose.transform;
+        var pose = requestTracking.tracked[0].pose;
+        pose.matrix.copyFromArray(transform.matrix);
+        pose.rotation.copyFrom(transform.orientation);
+        pose.position.copyFrom(transform.position);
+        return xrPose.emulatedPosition;
+    };
+    _create_class$1(WebXRAnchorTracking, [
+        {
+            key: "canModifyRequestTrackingAfterInit",
+            get: function get() {
+                return true;
+            }
+        }
+    ]);
+    return WebXRAnchorTracking;
+}(WebXRTrackableFeature);
+WebXRAnchorTracking = __decorate([
+    registerXRPlatformFeature(XRFeatureType.AnchorTracking)
+], WebXRAnchorTracking);
+
+var WebXRImageTracking = /*#__PURE__*/ function(WebXRTrackableFeature) {
+    _inherits(WebXRImageTracking, WebXRTrackableFeature);
+    function WebXRImageTracking(images) {
+        var _this;
+        _this = WebXRTrackableFeature.call(this) || this, _this._trackingScoreStatus = 0, _this._tempIdx = 0, _this._tempArr = [];
+        _this._images = images;
+        return _this;
+    }
+    var _proto = WebXRImageTracking.prototype;
+    _proto.checkAvailable = function checkAvailable(session, frame, requestTrackings) {
+        if (!frame._platformFrame) return false;
+        switch(this._trackingScoreStatus){
+            case 0:
+                this._requestTrackingScore(session, requestTrackings);
+                return false;
+            case 1:
+                return false;
+        }
+        return true;
+    };
+    _proto.getTrackedResult = function getTrackedResult(session, frame, requestTrackings, generateTracked) {
+        var platformReferenceSpace = session._platformReferenceSpace;
+        var platformFrame = frame._platformFrame;
+        var _this = this, tempArr = _this._tempArr;
+        var idx = ++this._tempIdx;
+        // @ts-ignore
+        var trackingResults = platformFrame.getImageTrackingResults();
+        for(var i = 0, n = trackingResults.length; i < n; i++){
+            var trackingResult = trackingResults[i];
+            var index = trackingResult.index;
+            var requestTrackingImage = requestTrackings[index];
+            if (requestTrackingImage) {
+                var tracked = requestTrackingImage.tracked[0];
+                if (!tracked) {
+                    tracked = requestTrackingImage.tracked[0] = generateTracked();
+                    tracked.referenceImage = requestTrackingImage.image;
+                }
+                if (trackingResult.trackingState === "tracked") {
+                    this._updateTrackedImage(platformFrame, platformReferenceSpace, tracked, trackingResult);
+                    tracked.state = XRTrackingState.Tracking;
+                } else {
+                    tracked.state = XRTrackingState.TrackingLost;
+                }
+                tempArr[index] = idx;
+            } else {
+                console.warn("Images can not find " + index);
+            }
+        }
+        for(var i1 = 0, n1 = requestTrackings.length; i1 < n1; i1++){
+            if (tempArr[i1] < idx) requestTrackings[i1].tracked[0].state = XRTrackingState.NotTracking;
+        }
+    };
+    _proto.onAddRequestTracking = function onAddRequestTracking(requestTracking) {
+        requestTracking.state = XRRequestTrackingState.Submitted;
+    };
+    /**
+   * @internal
+   */ _proto._assembleOptions = function _assembleOptions(options) {
+        options.optionalFeatures.push("image-tracking");
+        var _this = this, images = _this._images;
+        var promiseArr = [];
+        if (images) {
+            for(var i = 0, n = images.length; i < n; i++){
+                var referenceImage = images[i];
+                var imageSource = images[i].imageSource;
+                if (!imageSource) {
+                    return Promise.reject(new Error("referenceImage[" + referenceImage.name + "].src is null"));
+                } else {
+                    promiseArr.push(createImageBitmap(imageSource));
+                }
+            }
+            return new Promise(function(resolve, reject) {
+                // @ts-ignore
+                var trackedImages = options.trackedImages = [];
+                Promise.all(promiseArr).then(function(bitmaps) {
+                    for(var i = 0, n = bitmaps.length; i < n; i++){
+                        trackedImages.push({
+                            image: bitmaps[i],
+                            widthInMeters: images[i].physicalWidth
+                        });
+                    }
+                    resolve();
+                }, reject);
+            });
+        } else {
+            return Promise.reject(new Error("Images.length is 0"));
+        }
+    };
+    _proto._requestTrackingScore = function _requestTrackingScore(session, requestTrackings) {
+        var _this = this;
+        this._trackingScoreStatus = 1;
+        session._platformSession// @ts-ignore
+        .getTrackedImageScores().then(function(trackingScores) {
+            if (trackingScores) {
+                for(var i = 0, n = trackingScores.length; i < n; i++){
+                    var trackingScore = trackingScores[i];
+                    var requestTracking = requestTrackings[i];
+                    if (trackingScore === "trackable") {
+                        _this._trackingScoreStatus = 2;
+                        requestTracking.state = XRRequestTrackingState.Resolved;
+                    } else {
+                        requestTracking.state = XRRequestTrackingState.Rejected;
+                        console.warn(requestTracking.image.name, " unTrackable");
+                    }
+                }
+            }
+        });
+    };
+    _proto._updateTrackedImage = function _updateTrackedImage(frame, space, trackedImage, trackingResult) {
+        var pose = trackedImage.pose;
+        var transform = frame.getPose(trackingResult.imageSpace, space).transform;
+        pose.matrix.copyFromArray(transform.matrix);
+        pose.rotation.copyFrom(transform.orientation);
+        pose.position.copyFrom(transform.position);
+        trackedImage.measuredPhysicalWidth = trackingResult.measuredWidthInMeters;
+    };
+    return WebXRImageTracking;
+}(WebXRTrackableFeature);
+WebXRImageTracking = __decorate([
+    registerXRPlatformFeature(XRFeatureType.ImageTracking)
+], WebXRImageTracking);
+
+var WebXRPlaneTracking = /*#__PURE__*/ function(WebXRTrackableFeature) {
+    _inherits(WebXRPlaneTracking, WebXRTrackableFeature);
+    function WebXRPlaneTracking(detectedMode) {
+        var _this;
+        _this = WebXRTrackableFeature.call(this) || this;
+        if (detectedMode !== XRPlaneMode.EveryThing) {
+            console.warn("WebXR only support XRPlaneMode.EveryThing");
+        }
+        return _this;
+    }
+    var _proto = WebXRPlaneTracking.prototype;
+    _proto.checkAvailable = function checkAvailable(session, frame, requestTrackings) {
+        return !!frame._platformFrame;
+    };
+    _proto.getTrackedResult = function getTrackedResult(session, frame, requestTrackings, generateTracked) {
+        var _this = this;
+        var _platformFrame_worldInformation;
+        var platformReferenceSpace = session._platformReferenceSpace;
+        var platformFrame = frame._platformFrame;
+        // @ts-ignore
+        var detectedPlanes = platformFrame.detectedPlanes || ((_platformFrame_worldInformation = platformFrame.worldInformation) == null ? void 0 : _platformFrame_worldInformation.detectedPlanes);
+        var tracked = requestTrackings[0].tracked;
+        for(var i = 0, n = tracked.length; i < n; i++){
+            var trackedPlane = tracked[i];
+            if (detectedPlanes.has(trackedPlane.xrPlane)) {
+                trackedPlane.state = XRTrackingState.Tracking;
+                this._updatePlane(platformFrame, platformReferenceSpace, trackedPlane);
+            } else {
+                trackedPlane.state = XRTrackingState.NotTracking;
+            }
+        }
+        var _this1 = this, lastDetectedPlanes = _this1._lastDetectedPlanes;
+        detectedPlanes.forEach(function(xrPlane) {
+            if (!(lastDetectedPlanes == null ? void 0 : lastDetectedPlanes.has(xrPlane))) {
+                var plane = generateTracked();
+                plane.xrPlane = xrPlane;
+                plane.lastChangedTime = -1;
+                _this._updatePlane(platformFrame, platformReferenceSpace, plane);
+                tracked.push(plane);
+            }
+        });
+        this._lastDetectedPlanes = detectedPlanes;
+    };
+    _proto.onAddRequestTracking = function onAddRequestTracking(requestTracking) {
+        requestTracking.state = XRRequestTrackingState.Resolved;
+    };
+    /**
+   * @internal
+   */ _proto._assembleOptions = function _assembleOptions(options) {
+        options.optionalFeatures.push("plane-detection");
+    };
+    _proto._updatePlane = function _updatePlane(frame, space, trackedPlane) {
+        var pose = trackedPlane.pose, polygon = trackedPlane.polygon, xrPlane = trackedPlane.xrPlane;
+        var planePose = frame.getPose(xrPlane.planeSpace, space);
+        if (!planePose) return;
+        var transform = planePose.transform, emulatedPosition = planePose.emulatedPosition;
+        trackedPlane.state = emulatedPosition ? XRTrackingState.TrackingLost : XRTrackingState.Tracking;
+        trackedPlane.planeMode = xrPlane.orientation === "horizontal" ? XRPlaneMode.Horizontal : XRPlaneMode.Vertical;
+        if (trackedPlane.lastChangedTime < xrPlane.lastChangedTime) {
+            trackedPlane.lastChangedTime = xrPlane.lastChangedTime;
+            trackedPlane.attributesDirty = true;
+            var oriPolygon = xrPlane.polygon;
+            for(var i = 0, n = polygon.length = oriPolygon.length; i < n; i++){
+                var _polygon, _i;
+                ((_polygon = polygon)[_i = i] || (_polygon[_i] = new Vector3())).copyFrom(oriPolygon[i]);
+            }
+        } else {
+            trackedPlane.attributesDirty = false;
+        }
+        pose.rotation.copyFrom(transform.orientation);
+        pose.position.copyFrom(transform.position);
+        pose.matrix.copyFromArray(transform.matrix);
+        pose.inverseMatrix.copyFromArray(transform.inverse.matrix);
+    };
+    return WebXRPlaneTracking;
+}(WebXRTrackableFeature);
+WebXRPlaneTracking = __decorate([
+    registerXRPlatformFeature(XRFeatureType.PlaneTracking)
+], WebXRPlaneTracking);
+
+export { WebXRDevice };
+//# sourceMappingURL=module.js.map