@galacean/engine-physics-lite 0.0.0-experimental-animator-additive.1

package/dist/module.js

@@ -0,0 +1,1266 @@
+import { Ray, Vector3, Matrix, Quaternion, MathUtil, BoundingBox, BoundingSphere, CollisionUtil } from '@galacean/engine';
+
+/******************************************************************************
+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;
+}
+
+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);
+}
+
+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;
+}
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+
+/**
+ * Fastly remove an element from array.
+ * @param array - Array
+ * @param item - Element
+ */ function removeFromArray(array, item) {
+    var index = array.indexOf(item);
+    if (index < 0) {
+        return false;
+    }
+    var last = array.length - 1;
+    if (index !== last) {
+        array[index] = array[last];
+    }
+    array.length--;
+    return true;
+}
+/**
+ * Used to update tags.
+ */ var LiteUpdateFlag = /*#__PURE__*/ function() {
+    function LiteUpdateFlag(_flags) {
+        if (_flags === void 0) _flags = [];
+        this._flags = _flags;
+        this./** Flag. */ flag = true;
+        this._flags.push(this);
+    }
+    var _proto = LiteUpdateFlag.prototype;
+    /**
+   * Destroy.
+   */ _proto.destroy = function destroy() {
+        removeFromArray(this._flags, this);
+        this._flags = null;
+    };
+    return LiteUpdateFlag;
+}();
+
+/**
+ * @internal
+ */ var LiteUpdateFlagManager = /*#__PURE__*/ function() {
+    function LiteUpdateFlagManager() {
+        this._updateFlags = [];
+    }
+    var _proto = LiteUpdateFlagManager.prototype;
+    _proto.register = function register() {
+        return new LiteUpdateFlag(this._updateFlags);
+    };
+    _proto.distribute = function distribute() {
+        var updateFlags = this._updateFlags;
+        for(var i = updateFlags.length - 1; i >= 0; i--){
+            updateFlags[i].flag = true;
+        }
+    };
+    return LiteUpdateFlagManager;
+}();
+
+/**
+ * Abstract class for collider shapes.
+ */ var LiteColliderShape = /*#__PURE__*/ function() {
+    function LiteColliderShape() {
+        /** @internal */ this._transform = new LiteTransform();
+        /** @internal */ this._invModelMatrix = new Matrix();
+        this._transform.owner = this;
+        this._inverseWorldMatFlag = this._transform.registerWorldChangeFlag();
+    }
+    var _proto = LiteColliderShape.prototype;
+    /**
+   * {@inheritDoc IColliderShape.setRotation }
+   */ _proto.setRotation = function setRotation(rotation) {
+        console.log("Physics-lite don't support setRotation. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IColliderShape.setPosition }
+   */ _proto.setPosition = function setPosition(position) {
+        this._transform.setPosition(position.x, position.y, position.z);
+    };
+    /**
+   * {@inheritDoc IColliderShape.setContactOffset }
+   */ _proto.setContactOffset = function setContactOffset(offset) {
+        console.log("Physics-lite don't support setContactOffset. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IColliderShape.setMaterial }
+   */ _proto.setMaterial = function setMaterial(material) {
+        console.log("Physics-lite don't support setMaterial. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IColliderShape.setUniqueID }
+   */ _proto.setUniqueID = function setUniqueID(id) {
+        this._id = id;
+    };
+    /**
+   * {@inheritDoc IColliderShape.setIsTrigger }
+   */ _proto.setIsTrigger = function setIsTrigger(value) {
+        console.log("Physics-lite don't support setIsTrigger. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IColliderShape.destroy }
+   */ _proto.destroy = function destroy() {};
+    _proto._updateHitResult = function _updateHitResult(ray, rayDistance, outHit, origin, isWorldRay) {
+        if (isWorldRay === void 0) isWorldRay = false;
+        var hitPoint = LiteColliderShape._tempPoint;
+        ray.getPoint(rayDistance, hitPoint);
+        if (!isWorldRay) {
+            Vector3.transformCoordinate(hitPoint, this._transform.worldMatrix, hitPoint);
+        }
+        var distance = Vector3.distance(origin, hitPoint);
+        if (distance < outHit.distance) {
+            outHit.point.copyFrom(hitPoint);
+            outHit.distance = distance;
+            outHit.shapeID = this._id;
+        }
+    };
+    _proto._getLocalRay = function _getLocalRay(ray) {
+        var worldToLocal = this._getInvModelMatrix();
+        var outRay = LiteColliderShape._ray;
+        Vector3.transformCoordinate(ray.origin, worldToLocal, outRay.origin);
+        Vector3.transformNormal(ray.direction, worldToLocal, outRay.direction);
+        outRay.direction.normalize();
+        return outRay;
+    };
+    _proto._getInvModelMatrix = function _getInvModelMatrix() {
+        if (this._inverseWorldMatFlag.flag) {
+            Matrix.invert(this._transform.worldMatrix, this._invModelMatrix);
+            this._inverseWorldMatFlag.flag = false;
+        }
+        return this._invModelMatrix;
+    };
+    return LiteColliderShape;
+}();
+(function() {
+    LiteColliderShape._ray = new Ray();
+})();
+(function() {
+    LiteColliderShape._tempPoint = new Vector3();
+})();
+
+/**
+ * Used to implement transformation related functions.
+ */ var LiteTransform = /*#__PURE__*/ function() {
+    function LiteTransform() {
+        this._position = new Vector3();
+        this._rotation = new Vector3();
+        this._rotationQuaternion = new Quaternion();
+        this._scale = new Vector3(1, 1, 1);
+        this._worldRotationQuaternion = new Quaternion();
+        this._localMatrix = new Matrix();
+        this._worldMatrix = new Matrix();
+        this._updateFlagManager = new LiteUpdateFlagManager();
+        this._isParentDirty = true;
+        this._parentTransformCache = null;
+        this._dirtyFlag = 0xbc;
+    }
+    var _proto = LiteTransform.prototype;
+    /**
+   * Set local position by X, Y, Z value.
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param z - Z coordinate
+   */ _proto.setPosition = function setPosition(x, y, z) {
+        this._position.set(x, y, z);
+        this.position = this._position;
+    };
+    /**
+   * Set local rotation by the X, Y, Z, and W components of the quaternion.
+   * @param x - X component of quaternion
+   * @param y - Y component of quaternion
+   * @param z - Z component of quaternion
+   * @param w - W component of quaternion
+   */ _proto.setRotationQuaternion = function setRotationQuaternion(x, y, z, w) {
+        this._rotationQuaternion.set(x, y, z, w);
+        this.rotationQuaternion = this._rotationQuaternion;
+    };
+    /**
+   * Set local scaling by scaling values along X, Y, Z axis.
+   * @param x - Scaling along X axis
+   * @param y - Scaling along Y axis
+   * @param z - Scaling along Z axis
+   */ _proto.setScale = function setScale(x, y, z) {
+        this._scale.set(x, y, z);
+        this.scale = this._scale;
+    };
+    /**
+   * Register world transform change flag.
+   * @returns Change flag
+   */ _proto.registerWorldChangeFlag = function registerWorldChangeFlag() {
+        return this._updateFlagManager.register();
+    };
+    /**
+   * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+   * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+   * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
+   */ _proto._updateWorldPositionFlag = function _updateWorldPositionFlag() {
+        if (!this._isContainDirtyFlags(0x84)) {
+            this._worldAssociatedChange(0x84);
+            if (_instanceof(this._owner, LiteCollider)) {
+                var shapes = this._owner._shapes;
+                for(var i = 0, n = shapes.length; i < n; i++){
+                    shapes[i]._transform._updateWorldPositionFlag();
+                }
+            }
+        }
+    };
+    /**
+   * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+   * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+   * Get worldRotationQuaternion: Will trigger the world rotation (in quaternion) update of itself and all parent entities.
+   * Get worldRotation: Will trigger the world rotation(in euler and quaternion) update of itself and world rotation(in quaternion) update of all parent entities.
+   * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix or worldRotationQuaternion) to be false.
+   */ _proto._updateWorldRotationFlag = function _updateWorldRotationFlag() {
+        if (!this._isContainDirtyFlags(0x98)) {
+            this._worldAssociatedChange(0x98);
+            if (_instanceof(this._owner, LiteCollider)) {
+                var shapes = this._owner._shapes;
+                for(var i = 0, n = shapes.length; i < n; i++){
+                    shapes[i]._transform._updateWorldRotationFlag();
+                }
+            }
+        }
+    };
+    /**
+   * Get worldMatrix: Will trigger the worldMatrix update of itself and all parent entities.
+   * Get worldPosition: Will trigger the worldMatrix, local position update of itself and the worldMatrix update of all parent entities.
+   * Get worldScale: Will trigger the scaling update of itself and all parent entities.
+   * In summary, any update of related variables will cause the dirty mark of one of the full process (worldMatrix) to be false.
+   */ _proto._updateWorldScaleFlag = function _updateWorldScaleFlag() {
+        if (!this._isContainDirtyFlags(0xa0)) {
+            this._worldAssociatedChange(0xa0);
+            if (_instanceof(this._owner, LiteCollider)) {
+                var shapes = this._owner._shapes;
+                for(var i = 0, n = shapes.length; i < n; i++){
+                    shapes[i]._transform._updateWorldScaleFlag();
+                }
+            }
+        }
+    };
+    /**
+   * Update all world transform property dirty flag, the principle is the same as above.
+   */ _proto._updateAllWorldFlag = function _updateAllWorldFlag() {
+        if (!this._isContainDirtyFlags(0xbc)) {
+            this._worldAssociatedChange(0xbc);
+            if (_instanceof(this._owner, LiteCollider)) {
+                var shapes = this._owner._shapes;
+                for(var i = 0, n = shapes.length; i < n; i++){
+                    shapes[i]._transform._updateAllWorldFlag();
+                }
+            }
+        }
+    };
+    _proto._getParentTransform = function _getParentTransform() {
+        if (!this._isParentDirty) {
+            return this._parentTransformCache;
+        }
+        var parentCache = null;
+        if (_instanceof(this._owner, LiteColliderShape)) {
+            var parent = this._owner._collider;
+            parentCache = parent._transform;
+        }
+        this._parentTransformCache = parentCache;
+        this._isParentDirty = false;
+        return parentCache;
+    };
+    _proto._isContainDirtyFlags = function _isContainDirtyFlags(targetDirtyFlags) {
+        return (this._dirtyFlag & targetDirtyFlags) === targetDirtyFlags;
+    };
+    _proto._isContainDirtyFlag = function _isContainDirtyFlag(type) {
+        return (this._dirtyFlag & type) != 0;
+    };
+    _proto._setDirtyFlagTrue = function _setDirtyFlagTrue(type) {
+        this._dirtyFlag |= type;
+    };
+    _proto._setDirtyFlagFalse = function _setDirtyFlagFalse(type) {
+        this._dirtyFlag &= ~type;
+    };
+    _proto._worldAssociatedChange = function _worldAssociatedChange(type) {
+        this._dirtyFlag |= type;
+        this._updateFlagManager.distribute();
+    };
+    _create_class(LiteTransform, [
+        {
+            key: "owner",
+            set: function set(value) {
+                this._owner = value;
+            }
+        },
+        {
+            key: "position",
+            get: /**
+   * Local position.
+   * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+   */ function get() {
+                return this._position;
+            },
+            set: function set(value) {
+                if (this._position !== value) {
+                    this._position.copyFrom(value);
+                }
+                this._setDirtyFlagTrue(0x40);
+                this._updateWorldPositionFlag();
+            }
+        },
+        {
+            key: "rotationQuaternion",
+            get: /**
+   * Local rotation, defining the rotation by using a unit quaternion.
+   * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+   */ function get() {
+                if (this._isContainDirtyFlag(0x2)) {
+                    Quaternion.rotationEuler(MathUtil.degreeToRadian(this._rotation.x), MathUtil.degreeToRadian(this._rotation.y), MathUtil.degreeToRadian(this._rotation.z), this._rotationQuaternion);
+                    this._setDirtyFlagFalse(0x2);
+                }
+                return this._rotationQuaternion;
+            },
+            set: function set(value) {
+                if (this._rotationQuaternion !== value) {
+                    this._rotationQuaternion.copyFrom(value);
+                }
+                this._setDirtyFlagTrue(0x40 | 0x1);
+                this._setDirtyFlagFalse(0x2);
+                this._updateWorldRotationFlag();
+            }
+        },
+        {
+            key: "worldRotationQuaternion",
+            get: /**
+   * World rotation, defining the rotation by using a unit quaternion.
+   * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+   */ function get() {
+                if (this._isContainDirtyFlag(0x10)) {
+                    var parent = this._getParentTransform();
+                    if (parent != null) {
+                        Quaternion.multiply(parent.worldRotationQuaternion, this.rotationQuaternion, this._worldRotationQuaternion);
+                    } else {
+                        this._worldRotationQuaternion.copyFrom(this.rotationQuaternion);
+                    }
+                    this._setDirtyFlagFalse(0x10);
+                }
+                return this._worldRotationQuaternion;
+            },
+            set: function set(value) {
+                if (this._worldRotationQuaternion !== value) {
+                    this._worldRotationQuaternion.copyFrom(value);
+                }
+                var parent = this._getParentTransform();
+                if (parent) {
+                    Quaternion.invert(parent.worldRotationQuaternion, LiteTransform._tempQuat0);
+                    Quaternion.multiply(value, LiteTransform._tempQuat0, this._rotationQuaternion);
+                } else {
+                    this._rotationQuaternion.copyFrom(value);
+                }
+                this.rotationQuaternion = this._rotationQuaternion;
+                this._setDirtyFlagFalse(0x10);
+            }
+        },
+        {
+            key: "scale",
+            get: /**
+   * Local scaling.
+   * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+   */ function get() {
+                return this._scale;
+            },
+            set: function set(value) {
+                if (this._scale !== value) {
+                    this._scale.copyFrom(value);
+                }
+                this._setDirtyFlagTrue(0x40);
+                this._updateWorldScaleFlag();
+            }
+        },
+        {
+            key: "localMatrix",
+            get: /**
+   * Local matrix.
+   * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+   */ function get() {
+                if (this._isContainDirtyFlag(0x40)) {
+                    Matrix.affineTransformation(this._scale, this.rotationQuaternion, this._position, this._localMatrix);
+                    this._setDirtyFlagFalse(0x40);
+                }
+                return this._localMatrix;
+            },
+            set: function set(value) {
+                if (this._localMatrix !== value) {
+                    this._localMatrix.copyFrom(value);
+                }
+                this._localMatrix.decompose(this._position, this._rotationQuaternion, this._scale);
+                this._setDirtyFlagTrue(0x1);
+                this._setDirtyFlagFalse(0x40);
+                this._updateAllWorldFlag();
+            }
+        },
+        {
+            key: "worldMatrix",
+            get: /**
+   * World matrix.
+   * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+   */ function get() {
+                if (this._isContainDirtyFlag(0x80)) {
+                    var parent = this._getParentTransform();
+                    if (parent) {
+                        Matrix.multiply(parent.worldMatrix, this.localMatrix, this._worldMatrix);
+                    } else {
+                        this._worldMatrix.copyFrom(this.localMatrix);
+                    }
+                    this._setDirtyFlagFalse(0x80);
+                }
+                return this._worldMatrix;
+            },
+            set: function set(value) {
+                if (this._worldMatrix !== value) {
+                    this._worldMatrix.copyFrom(value);
+                }
+                var parent = this._getParentTransform();
+                if (parent) {
+                    Matrix.invert(parent.worldMatrix, LiteTransform._tempMat42);
+                    Matrix.multiply(LiteTransform._tempMat42, value, this._localMatrix);
+                } else {
+                    this._localMatrix.copyFrom(value);
+                }
+                this.localMatrix = this._localMatrix;
+                this._setDirtyFlagFalse(0x80);
+            }
+        }
+    ]);
+    return LiteTransform;
+}();
+(function() {
+    LiteTransform._tempQuat0 = new Quaternion();
+})();
+(function() {
+    LiteTransform._tempMat42 = new Matrix();
+})();
+var /**
+ * Dirty flag of transform.
+ */ TransformFlag;
+(function(TransformFlag) {
+    TransformFlag[TransformFlag["LocalEuler"] = 0x1] = "LocalEuler";
+    TransformFlag[TransformFlag["LocalQuat"] = 0x2] = "LocalQuat";
+    TransformFlag[TransformFlag["WorldPosition"] = 0x4] = "WorldPosition";
+    TransformFlag[TransformFlag["WorldEuler"] = 0x8] = "WorldEuler";
+    TransformFlag[TransformFlag["WorldQuat"] = 0x10] = "WorldQuat";
+    TransformFlag[TransformFlag["WorldScale"] = 0x20] = "WorldScale";
+    TransformFlag[TransformFlag["LocalMatrix"] = 0x40] = "LocalMatrix";
+    TransformFlag[TransformFlag["WorldMatrix"] = 0x80] = "WorldMatrix";
+    TransformFlag[TransformFlag[/** WorldMatrix | WorldPosition */ "WmWp"] = 0x84] = "WmWp";
+    TransformFlag[TransformFlag[/** WorldMatrix | WorldEuler | WorldQuat */ "WmWeWq"] = 0x98] = "WmWeWq";
+    TransformFlag[TransformFlag[/** WorldMatrix | WorldPosition | WorldEuler | WorldQuat */ "WmWpWeWq"] = 0x9c] = "WmWpWeWq";
+    TransformFlag[TransformFlag[/** WorldMatrix | WorldScale */ "WmWs"] = 0xa0] = "WmWs";
+    TransformFlag[TransformFlag[/** WorldMatrix | WorldPosition | WorldScale */ "WmWpWs"] = 0xa4] = "WmWpWs";
+    TransformFlag[TransformFlag[/** WorldMatrix | WorldPosition | WorldEuler | WorldQuat | WorldScale */ "WmWpWeWqWs"] = 0xbc] = "WmWpWeWqWs";
+})(TransformFlag || (TransformFlag = {}));
+
+/**
+ * Abstract class of physical collider.
+ */ var LiteCollider = /*#__PURE__*/ function() {
+    function LiteCollider() {
+        /** @internal */ this._shapes = [];
+        /** @internal */ this._transform = new LiteTransform();
+        this._transform.owner = this;
+    }
+    var _proto = LiteCollider.prototype;
+    /**
+   * {@inheritDoc ICollider.addShape }
+   */ _proto.addShape = function addShape(shape) {
+        var oldCollider = shape._collider;
+        if (oldCollider !== this) {
+            if (oldCollider) {
+                oldCollider.removeShape(shape);
+            }
+            this._shapes.push(shape);
+            shape._collider = this;
+        }
+    };
+    /**
+   * {@inheritDoc ICollider.removeShape }
+   */ _proto.removeShape = function removeShape(shape) {
+        var index = this._shapes.indexOf(shape);
+        if (index !== -1) {
+            this._shapes.splice(index, 1);
+            shape._collider = null;
+        }
+    };
+    /**
+   * {@inheritDoc ICollider.setWorldTransform }
+   */ _proto.setWorldTransform = function setWorldTransform(position, rotation) {
+        this._transform.setPosition(position.x, position.y, position.z);
+        this._transform.setRotationQuaternion(rotation.x, rotation.y, rotation.z, rotation.w);
+    };
+    /**
+   * {@inheritDoc ICollider.getWorldTransform }
+   */ _proto.getWorldTransform = function getWorldTransform(outPosition, outRotation) {
+        var _this__transform = this._transform, position = _this__transform.position, rotationQuaternion = _this__transform.rotationQuaternion;
+        outPosition.set(position.x, position.y, position.z);
+        outRotation.set(rotationQuaternion.x, rotationQuaternion.y, rotationQuaternion.z, rotationQuaternion.w);
+    };
+    /**
+   * {@inheritDoc ICollider.destroy }
+   */ _proto.destroy = function destroy() {};
+    /**
+   * @internal
+   */ _proto._raycast = function _raycast(ray, onRaycast, hit) {
+        hit.distance = Number.MAX_VALUE;
+        var shapes = this._shapes;
+        for(var i = 0, n = shapes.length; i < n; i++){
+            var shape = shapes[i];
+            onRaycast(shape._id) && shape._raycast(ray, hit);
+        }
+        return hit.distance != Number.MAX_VALUE;
+    };
+    return LiteCollider;
+}();
+
+/**
+ * A dynamic collider can act with self-defined movement or physical force
+ */ var LiteDynamicCollider = /*#__PURE__*/ function(LiteCollider) {
+    _inherits(LiteDynamicCollider, LiteCollider);
+    function LiteDynamicCollider(position, rotation) {
+        var _this;
+        _this = LiteCollider.call(this) || this;
+        _this._transform.setPosition(position.x, position.y, position.z);
+        _this._transform.setRotationQuaternion(rotation.x, rotation.y, rotation.z, rotation.w);
+        return _this;
+    }
+    var _proto = LiteDynamicCollider.prototype;
+    /**
+   * {@inheritDoc IDynamicCollider.addForce }
+   */ _proto.addForce = function addForce(force) {
+        throw "Physics-lite don't support addForce. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.addTorque }
+   */ _proto.addTorque = function addTorque(torque) {
+        throw "Physics-lite don't support addTorque. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.move }
+   */ _proto.move = function move(positionOrRotation, rotation) {
+        throw "Physics-lite don't support move. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.sleep }
+   */ _proto.sleep = function sleep() {
+        throw "Physics-lite don't support putToSleep. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setAngularDamping }
+   */ _proto.setAngularDamping = function setAngularDamping(value) {
+        throw "Physics-lite don't support setAngularDamping. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setAngularVelocity }
+   */ _proto.setAngularVelocity = function setAngularVelocity(value) {
+        throw "Physics-lite don't support setAngularVelocity. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setCenterOfMass }
+   */ _proto.setCenterOfMass = function setCenterOfMass(value) {
+        throw "Physics-lite don't support setCenterOfMass. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
+   */ _proto.setCollisionDetectionMode = function setCollisionDetectionMode(value) {
+        throw "Physics-lite don't support setCollisionDetectionMode. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setConstraints }
+   */ _proto.setConstraints = function setConstraints(flags) {
+        throw "Physics-lite don't support setConstraints. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setInertiaTensor }
+   */ _proto.setInertiaTensor = function setInertiaTensor(value) {
+        throw "Physics-lite don't support setInertiaTensor. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setIsKinematic }
+   */ _proto.setIsKinematic = function setIsKinematic(value) {
+        throw "Physics-lite don't support setIsKinematic. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setLinearDamping }
+   */ _proto.setLinearDamping = function setLinearDamping(value) {
+        throw "Physics-lite don't support setLinearDamping. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setLinearVelocity }
+   */ _proto.setLinearVelocity = function setLinearVelocity(value) {
+        throw "Physics-lite don't support setLinearVelocity. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setMass }
+   */ _proto.setMass = function setMass(value) {
+        throw "Physics-lite don't support setMass. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setMaxAngularVelocity }
+   */ _proto.setMaxAngularVelocity = function setMaxAngularVelocity(value) {
+        throw "Physics-lite don't support setMaxAngularVelocity. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setMaxDepenetrationVelocity }
+   */ _proto.setMaxDepenetrationVelocity = function setMaxDepenetrationVelocity(value) {
+        throw "Physics-lite don't support setMaxDepenetrationVelocity. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setSleepThreshold }
+   */ _proto.setSleepThreshold = function setSleepThreshold(value) {
+        throw "Physics-lite don't support setSleepThreshold. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setSolverIterations }
+   */ _proto.setSolverIterations = function setSolverIterations(value) {
+        throw "Physics-lite don't support setSolverIterations. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.wakeUp }
+   */ _proto.wakeUp = function wakeUp() {
+        throw "Physics-lite don't support wakeUp. Use Physics-PhysX instead!";
+    };
+    return LiteDynamicCollider;
+}(LiteCollider);
+
+/**
+ * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
+ */ var DisorderedArray = /*#__PURE__*/ function() {
+    function DisorderedArray(count) {
+        if (count === void 0) count = 0;
+        this.length = 0;
+        this._elements = new Array(count);
+    }
+    var _proto = DisorderedArray.prototype;
+    _proto.add = function add(element) {
+        if (this.length === this._elements.length) this._elements.push(element);
+        else this._elements[this.length] = element;
+        this.length++;
+    };
+    _proto.delete = function _delete(element) {
+        //TODO: It can be optimized for custom binary search and other algorithms, currently this._elements>=this.length wastes performance.
+        var index = this._elements.indexOf(element);
+        this.deleteByIndex(index);
+    };
+    _proto.get = function get(index) {
+        if (index >= this.length) {
+            throw "Index is out of range.";
+        }
+        return this._elements[index];
+    };
+    /**
+   *
+   * @param index
+   * @returns The replaced item is used to reset its index.
+   */ _proto.deleteByIndex = function deleteByIndex(index) {
+        var elements = this._elements;
+        var end = null;
+        var lastIndex = this.length - 1;
+        if (index !== lastIndex) {
+            end = elements[lastIndex];
+            elements[index] = end;
+        }
+        this.length--;
+        return end;
+    };
+    _proto.garbageCollection = function garbageCollection() {
+        this._elements.length = this.length;
+    };
+    return DisorderedArray;
+}();
+
+/**
+ * Structure used to get information back from a raycast or a sweep.
+ * @internal
+ */ var LiteHitResult = function LiteHitResult() {
+    /** The collider that was hit. */ this.shapeID = -1;
+    /** The distance from the origin to the hit point. */ this.distance = 0;
+    /** The hit point of the collider that was hit in world space. */ this.point = new Vector3();
+    /** The hit normal of the collider that was hit in world space. */ this.normal = new Vector3();
+};
+
+/**
+ * Box collider shape in Lite.
+ */ var LiteBoxColliderShape = /*#__PURE__*/ function(LiteColliderShape) {
+    _inherits(LiteBoxColliderShape, LiteColliderShape);
+    function LiteBoxColliderShape(uniqueID, size, material) {
+        var _this;
+        _this = LiteColliderShape.call(this) || this;
+        _this._halfSize = new Vector3();
+        _this._scale = new Vector3(1, 1, 1);
+        /** @internal */ _this._boxMin = new Vector3(-0.5, -0.5, -0.5);
+        /** @internal */ _this._boxMax = new Vector3(0.5, 0.5, 0.5);
+        _this._id = uniqueID;
+        _this._halfSize.set(size.x * 0.5, size.y * 0.5, size.z * 0.5);
+        _this._setBondingBox();
+        return _this;
+    }
+    var _proto = LiteBoxColliderShape.prototype;
+    /**
+   * {@inheritDoc IColliderShape.setPosition }
+   */ _proto.setPosition = function setPosition(position) {
+        LiteColliderShape.prototype.setPosition.call(this, position);
+        this._setBondingBox();
+    };
+    /**
+   * {@inheritDoc IColliderShape.setWorldScale }
+   */ _proto.setWorldScale = function setWorldScale(scale) {
+        this._transform.position = this._transform.position.multiply(scale);
+        this._scale.copyFrom(scale);
+    };
+    /**
+   * {@inheritDoc IBoxColliderShape.setSize }
+   */ _proto.setSize = function setSize(value) {
+        this._halfSize.set(value.x * 0.5, value.y * 0.5, value.z * 0.5);
+        this._setBondingBox();
+    };
+    /**
+   * @internal
+   */ _proto._raycast = function _raycast(ray, hit) {
+        var localRay = this._getLocalRay(ray);
+        var boundingBox = LiteBoxColliderShape._tempBox;
+        boundingBox.min.set(-this._halfSize.x * this._scale.x, -this._halfSize.y * this._scale.y, -this._halfSize.z * this._scale.z);
+        boundingBox.max.set(this._halfSize.x * this._scale.x, this._halfSize.y * this._scale.y, this._halfSize.z * this._scale.z);
+        var rayDistance = localRay.intersectBox(boundingBox);
+        if (rayDistance !== -1) {
+            this._updateHitResult(localRay, rayDistance, hit, ray.origin);
+            return true;
+        } else {
+            return false;
+        }
+    };
+    _proto._setBondingBox = function _setBondingBox() {
+        var _this__transform = this._transform, center = _this__transform.position;
+        var halfSize = this._halfSize;
+        Vector3.add(center, halfSize, this._boxMax);
+        Vector3.subtract(center, halfSize, this._boxMin);
+    };
+    return LiteBoxColliderShape;
+}(LiteColliderShape);
+(function() {
+    LiteBoxColliderShape._tempBox = new BoundingBox();
+})();
+
+/**
+ * Sphere collider shape in Lite.
+ */ var LiteSphereColliderShape = /*#__PURE__*/ function(LiteColliderShape) {
+    _inherits(LiteSphereColliderShape, LiteColliderShape);
+    function LiteSphereColliderShape(uniqueID, radius, material) {
+        var _this;
+        _this = LiteColliderShape.call(this) || this;
+        _this._radius = 1;
+        _this._maxScale = 1;
+        _this._radius = radius;
+        _this._id = uniqueID;
+        return _this;
+    }
+    var _proto = LiteSphereColliderShape.prototype;
+    /**
+   * {@inheritDoc ISphereColliderShape.setRadius }
+   */ _proto.setRadius = function setRadius(value) {
+        this._radius = value;
+    };
+    /**
+   * {@inheritDoc IColliderShape.setWorldScale }
+   */ _proto.setWorldScale = function setWorldScale(scale) {
+        this._maxScale = Math.max(scale.x, Math.max(scale.x, scale.y));
+    };
+    /**
+   * @internal
+   */ _proto._raycast = function _raycast(ray, hit) {
+        var boundingSphere = LiteSphereColliderShape._tempSphere;
+        Vector3.transformCoordinate(this._transform.position, this._collider._transform.worldMatrix, boundingSphere.center);
+        boundingSphere.radius = this.worldRadius;
+        var rayDistance = ray.intersectSphere(boundingSphere);
+        if (rayDistance !== -1) {
+            this._updateHitResult(ray, rayDistance, hit, ray.origin, true);
+            return true;
+        } else {
+            return false;
+        }
+    };
+    _create_class(LiteSphereColliderShape, [
+        {
+            key: "worldRadius",
+            get: function get() {
+                return this._radius * this._maxScale;
+            }
+        }
+    ]);
+    return LiteSphereColliderShape;
+}(LiteColliderShape);
+(function() {
+    LiteSphereColliderShape._tempSphere = new BoundingSphere();
+})();
+
+/**
+ * A manager is a collection of colliders and constraints which can interact.
+ */ var LitePhysicsManager = /*#__PURE__*/ function() {
+    function LitePhysicsManager(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
+        this._colliders = [];
+        this._sphere = new BoundingSphere();
+        this._box = new BoundingBox();
+        this._currentEvents = new DisorderedArray();
+        this._eventMap = {};
+        this._eventPool = [];
+        this._onContactEnter = onContactEnter;
+        this._onContactExit = onContactExit;
+        this._onContactStay = onContactStay;
+        this._onTriggerEnter = onTriggerEnter;
+        this._onTriggerExit = onTriggerExit;
+        this._onTriggerStay = onTriggerStay;
+    }
+    var _proto = LitePhysicsManager.prototype;
+    /**
+   * {@inheritDoc IPhysicsManager.setGravity }
+   */ _proto.setGravity = function setGravity(value) {
+        console.log("Physics-lite don't support gravity. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.addColliderShape }
+   */ _proto.addColliderShape = function addColliderShape(colliderShape) {
+        this._eventMap[colliderShape._id] = {};
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.removeColliderShape }
+   */ _proto.removeColliderShape = function removeColliderShape(colliderShape) {
+        var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
+        var shapeID = colliderShape._id;
+        for(var i = currentEvents.length - 1; i >= 0; i--){
+            var event = currentEvents.get(i);
+            if (event.index1 == shapeID || event.index2 == shapeID) {
+                currentEvents.deleteByIndex(i);
+                eventPool.push(event);
+            }
+        }
+        delete this._eventMap[shapeID];
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.addCollider }
+   */ _proto.addCollider = function addCollider(actor) {
+        this._colliders.push(actor);
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.removeCollider }
+   */ _proto.removeCollider = function removeCollider(collider) {
+        var index = this._colliders.indexOf(collider);
+        if (index !== -1) {
+            this._colliders.splice(index, 1);
+        }
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.update }
+   */ _proto.update = function update(deltaTime) {
+        var colliders = this._colliders;
+        for(var i = 0, len = colliders.length; i < len; i++){
+            this._collisionDetection(deltaTime, colliders[i]);
+        }
+        this._fireEvent();
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.raycast }
+   */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
+        var colliders = this._colliders;
+        var hitResult;
+        if (hit) {
+            hitResult = LitePhysicsManager._hitResult;
+        }
+        var isHit = false;
+        var curHit = LitePhysicsManager._currentHit;
+        for(var i = 0, len = colliders.length; i < len; i++){
+            var collider = colliders[i];
+            if (collider._raycast(ray, onRaycast, curHit)) {
+                isHit = true;
+                if (curHit.distance < distance) {
+                    if (hitResult) {
+                        hitResult.normal.copyFrom(curHit.normal);
+                        hitResult.point.copyFrom(curHit.point);
+                        hitResult.distance = curHit.distance;
+                        hitResult.shapeID = curHit.shapeID;
+                    } else {
+                        return true;
+                    }
+                    distance = curHit.distance;
+                }
+            }
+        }
+        if (!isHit && hitResult) {
+            hitResult.shapeID = -1;
+            hitResult.distance = 0;
+            hitResult.point.set(0, 0, 0);
+            hitResult.normal.set(0, 0, 0);
+        } else if (isHit && hitResult) {
+            hit(hitResult.shapeID, hitResult.distance, hitResult.point, hitResult.normal);
+        }
+        return isHit;
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.addCharacterController }
+   */ _proto.addCharacterController = function addCharacterController(characterController) {
+        throw "Physics-lite don't support addCharacterController. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysicsManager.removeCharacterController }
+   */ _proto.removeCharacterController = function removeCharacterController(characterController) {
+        throw "Physics-lite don't support removeCharacterController. Use Physics-PhysX instead!";
+    };
+    _proto._getTrigger = function _getTrigger(index1, index2) {
+        var event;
+        if (this._eventPool.length) {
+            event = this._eventPool.pop();
+            event.index1 = index1;
+            event.index2 = index2;
+        } else {
+            event = new TriggerEvent(index1, index2);
+        }
+        this._eventMap[index1][index2] = event;
+        return event;
+    };
+    _proto._collisionDetection = function _collisionDetection(deltaTime, myCollider) {
+        var colliders = this._colliders;
+        var myColliderShapes = myCollider._shapes;
+        for(var i = 0, len = myColliderShapes.length; i < len; i++){
+            var myShape = myColliderShapes[i];
+            if (_instanceof(myShape, LiteBoxColliderShape)) {
+                LitePhysicsManager._updateWorldBox(myShape, this._box);
+                for(var j = 0, len1 = colliders.length; j < len1; j++){
+                    var colliderShape = colliders[j]._shapes;
+                    for(var k = 0, len2 = colliderShape.length; k < len2; k++){
+                        var shape = colliderShape[k];
+                        var index1 = shape._id;
+                        var index2 = myShape._id;
+                        var event = index1 < index2 ? this._eventMap[index1][index2] : this._eventMap[index2][index1];
+                        if (event !== undefined && !event.alreadyInvoked) {
+                            continue;
+                        }
+                        if (shape != myShape && this._boxCollision(shape)) {
+                            if (event === undefined) {
+                                var event1 = index1 < index2 ? this._getTrigger(index1, index2) : this._getTrigger(index2, index1);
+                                event1.state = 0;
+                                event1.alreadyInvoked = false;
+                                this._currentEvents.add(event1);
+                            } else if (event.state === 0) {
+                                event.state = 1;
+                                event.alreadyInvoked = false;
+                            } else if (event.state === 1) {
+                                event.alreadyInvoked = false;
+                            }
+                        }
+                    }
+                }
+            } else if (_instanceof(myShape, LiteSphereColliderShape)) {
+                LitePhysicsManager._upWorldSphere(myShape, this._sphere);
+                for(var j1 = 0, len3 = colliders.length; j1 < len3; j1++){
+                    var colliderShape1 = colliders[j1]._shapes;
+                    for(var k1 = 0, len4 = colliderShape1.length; k1 < len4; k1++){
+                        var shape1 = colliderShape1[k1];
+                        var index11 = shape1._id;
+                        var index21 = myShape._id;
+                        var event2 = index11 < index21 ? this._eventMap[index11][index21] : this._eventMap[index21][index11];
+                        if (event2 !== undefined && !event2.alreadyInvoked) {
+                            continue;
+                        }
+                        if (shape1 != myShape && this._sphereCollision(shape1)) {
+                            if (event2 === undefined) {
+                                var event3 = index11 < index21 ? this._getTrigger(index11, index21) : this._getTrigger(index21, index11);
+                                event3.state = 0;
+                                event3.alreadyInvoked = false;
+                                this._currentEvents.add(event3);
+                            } else if (event2.state === 0) {
+                                event2.state = 1;
+                                event2.alreadyInvoked = false;
+                            } else if (event2.state === 1) {
+                                event2.alreadyInvoked = false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    _proto._fireEvent = function _fireEvent() {
+        var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
+        for(var i = currentEvents.length - 1; i >= 0; i--){
+            var event = currentEvents.get(i);
+            if (!event.alreadyInvoked) {
+                if (event.state == 0) {
+                    this._onTriggerEnter(event.index1, event.index2);
+                    event.alreadyInvoked = true;
+                } else if (event.state == 1) {
+                    this._onTriggerStay(event.index1, event.index2);
+                    event.alreadyInvoked = true;
+                }
+            } else {
+                event.state = 2;
+                this._eventMap[event.index1][event.index2] = undefined;
+                this._onTriggerExit(event.index1, event.index2);
+                currentEvents.deleteByIndex(i);
+                eventPool.push(event);
+            }
+        }
+    };
+    _proto._boxCollision = function _boxCollision(other) {
+        if (_instanceof(other, LiteBoxColliderShape)) {
+            var box = LitePhysicsManager._tempBox;
+            LitePhysicsManager._updateWorldBox(other, box);
+            return CollisionUtil.intersectsBoxAndBox(box, this._box);
+        } else if (_instanceof(other, LiteSphereColliderShape)) {
+            var sphere = LitePhysicsManager._tempSphere;
+            LitePhysicsManager._upWorldSphere(other, sphere);
+            return CollisionUtil.intersectsSphereAndBox(sphere, this._box);
+        }
+        return false;
+    };
+    _proto._sphereCollision = function _sphereCollision(other) {
+        if (_instanceof(other, LiteBoxColliderShape)) {
+            var box = LitePhysicsManager._tempBox;
+            LitePhysicsManager._updateWorldBox(other, box);
+            return CollisionUtil.intersectsSphereAndBox(this._sphere, box);
+        } else if (_instanceof(other, LiteSphereColliderShape)) {
+            var sphere = LitePhysicsManager._tempSphere;
+            LitePhysicsManager._upWorldSphere(other, sphere);
+            return CollisionUtil.intersectsSphereAndSphere(sphere, this._sphere);
+        }
+        return false;
+    };
+    /**
+   * Calculate the bounding box in world space from boxCollider.
+   * @param boxCollider - The boxCollider to calculate
+   * @param out - The calculated boundingBox
+   */ LitePhysicsManager._updateWorldBox = function _updateWorldBox(boxCollider, out) {
+        var mat = boxCollider._transform.worldMatrix;
+        out.min.copyFrom(boxCollider._boxMin);
+        out.max.copyFrom(boxCollider._boxMax);
+        BoundingBox.transform(out, mat, out);
+    };
+    /**
+   * Get the sphere info of the given sphere collider in world space.
+   * @param sphereCollider - The given sphere collider
+   * @param out - The calculated boundingSphere
+   */ LitePhysicsManager._upWorldSphere = function _upWorldSphere(sphereCollider, out) {
+        Vector3.transformCoordinate(sphereCollider._transform.position, sphereCollider._transform.worldMatrix, out.center);
+        out.radius = sphereCollider.worldRadius;
+    };
+    return LitePhysicsManager;
+}();
+(function() {
+    LitePhysicsManager._tempSphere = new BoundingSphere();
+})();
+(function() {
+    LitePhysicsManager._tempBox = new BoundingBox();
+})();
+(function() {
+    LitePhysicsManager._currentHit = new LiteHitResult();
+})();
+(function() {
+    LitePhysicsManager._hitResult = new LiteHitResult();
+})();
+var /**
+ * Physics state
+ */ TriggerEventState;
+(function(TriggerEventState) {
+    TriggerEventState[TriggerEventState["Enter"] = 0] = "Enter";
+    TriggerEventState[TriggerEventState["Stay"] = 1] = "Stay";
+    TriggerEventState[TriggerEventState["Exit"] = 2] = "Exit";
+})(TriggerEventState || (TriggerEventState = {}));
+/**
+ * Trigger event to store interactive object ids and state.
+ */ var TriggerEvent = function TriggerEvent(index1, index2) {
+    this.alreadyInvoked = false;
+    this.index1 = index1;
+    this.index2 = index2;
+};
+
+/**
+ * Physics material describes how to handle colliding objects (friction, bounciness).
+ */ var LitePhysicsMaterial = /*#__PURE__*/ function() {
+    function LitePhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {}
+    var _proto = LitePhysicsMaterial.prototype;
+    /**
+   * {@inheritDoc IPhysicsMaterial.setBounciness }
+   */ _proto.setBounciness = function setBounciness(value) {
+        throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysicsMaterial.setDynamicFriction }
+   */ _proto.setDynamicFriction = function setDynamicFriction(value) {
+        throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysicsMaterial.setStaticFriction }
+   */ _proto.setStaticFriction = function setStaticFriction(value) {
+        throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysicsMaterial.setBounceCombine }
+   */ _proto.setBounceCombine = function setBounceCombine(value) {
+        throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysicsMaterial.setFrictionCombine }
+   */ _proto.setFrictionCombine = function setFrictionCombine(value) {
+        throw "Physics-lite don't support physics material. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysicsMaterial.destroy }
+   */ _proto.destroy = function destroy() {};
+    return LitePhysicsMaterial;
+}();
+
+/**
+ * A static collider component that will not move.
+ * @remarks Mostly used for object which always stays at the same place and never moves around.
+ */ var LiteStaticCollider = /*#__PURE__*/ function(LiteCollider) {
+    _inherits(LiteStaticCollider, LiteCollider);
+    function LiteStaticCollider(position, rotation) {
+        var _this;
+        _this = LiteCollider.call(this) || this;
+        _this._transform.setPosition(position.x, position.y, position.z);
+        _this._transform.setRotationQuaternion(rotation.x, rotation.y, rotation.z, rotation.w);
+        return _this;
+    }
+    return LiteStaticCollider;
+}(LiteCollider);
+
+/**
+ *  Static interface implement decorator.
+ *  https://stackoverflow.com/questions/13955157/how-to-define-static-property-in-typescript-interface
+ */ function StaticInterfaceImplement() {
+    return function(constructor) {
+    };
+}
+
+var LitePhysics = /*#__PURE__*/ function() {
+    function LitePhysics() {}
+    /**
+   * {@inheritDoc IPhysics.createPhysicsManager }
+   */ LitePhysics.createPhysicsManager = function createPhysicsManager(onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist) {
+        return new LitePhysicsManager(onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist);
+    };
+    /**
+   * {@inheritDoc IPhysics.createStaticCollider }
+   */ LitePhysics.createStaticCollider = function createStaticCollider(position, rotation) {
+        return new LiteStaticCollider(position, rotation);
+    };
+    /**
+   * {@inheritDoc IPhysics.createDynamicCollider }
+   */ LitePhysics.createDynamicCollider = function createDynamicCollider(position, rotation) {
+        return new LiteDynamicCollider(position, rotation);
+    };
+    /**
+   * {@inheritDoc IPhysics.createCharacterController }
+   */ LitePhysics.createCharacterController = function createCharacterController() {
+        throw "Physics-lite don't support createCharacterController. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysics.createPhysicsMaterial }
+   */ LitePhysics.createPhysicsMaterial = function createPhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine) {
+        return new LitePhysicsMaterial(staticFriction, dynamicFriction, bounciness, frictionCombine, bounceCombine);
+    };
+    /**
+   * {@inheritDoc IPhysics.createBoxColliderShape }
+   */ LitePhysics.createBoxColliderShape = function createBoxColliderShape(uniqueID, size, material) {
+        return new LiteBoxColliderShape(uniqueID, size, material);
+    };
+    /**
+   * {@inheritDoc IPhysics.createSphereColliderShape }
+   */ LitePhysics.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
+        return new LiteSphereColliderShape(uniqueID, radius, material);
+    };
+    /**
+   * {@inheritDoc IPhysics.createPlaneColliderShape }
+   */ LitePhysics.createPlaneColliderShape = function createPlaneColliderShape(uniqueID, material) {
+        throw "Physics-lite don't support PlaneColliderShape. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysics.createCapsuleColliderShape }
+   */ LitePhysics.createCapsuleColliderShape = function createCapsuleColliderShape(uniqueID, radius, height, material) {
+        throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysics.createFixedJoint }
+   */ LitePhysics.createFixedJoint = function createFixedJoint(collider) {
+        throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysics.createHingeJoint }
+   */ LitePhysics.createHingeJoint = function createHingeJoint(collider) {
+        throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
+    };
+    /**
+   * {@inheritDoc IPhysics.createSpringJoint }
+   */ LitePhysics.createSpringJoint = function createSpringJoint(collider) {
+        throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
+    };
+    return LitePhysics;
+}();
+LitePhysics = __decorate([
+    StaticInterfaceImplement()
+], LitePhysics);
+
+export { LitePhysics };
+//# sourceMappingURL=module.js.map