@galacean/engine-physics-lite 0.0.0-experimental-1.3-xr.9 → 0.0.0-experimental-1.4-small-language.0

package/dist/main.js

@@ -94,6 +94,7 @@ function _instanceof(left, right) {
         /** @internal */ this._worldScale = new engine.Vector3(1, 1, 1);
         /** @internal */ this._transform = new LiteTransform();
         /** @internal */ this._invModelMatrix = new engine.Matrix();
+        this._rotation = new engine.Vector3();
         this._transform.owner = this;
         this._inverseWorldMatFlag = this._transform.registerWorldChangeFlag();
     }
@@ -101,7 +102,8 @@ function _instanceof(left, right) {
     /**
    * {@inheritDoc IColliderShape.setRotation }
    */ _proto.setRotation = function setRotation(rotation) {
-        console.log("Physics-lite don't support setRotation. Use Physics-PhysX instead!");
+        var rotationInRadians = this._rotation.set(engine.MathUtil.degreeToRadian(rotation.x), engine.MathUtil.degreeToRadian(rotation.y), engine.MathUtil.degreeToRadian(rotation.z));
+        engine.Quaternion.rotationEuler(rotationInRadians.x, rotationInRadians.y, rotationInRadians.z, this._transform.rotationQuaternion);
     };
     /**
    * {@inheritDoc IColliderShape.setPosition }
@@ -176,12 +178,12 @@ function _instanceof(left, right) {
     };
     return LiteColliderShape;
 }();
-(function() {
-    LiteColliderShape._ray = new engine.Ray();
-})();
-(function() {
-    LiteColliderShape._tempPoint = new engine.Vector3();
-})();
+LiteColliderShape._tempPos = new engine.Vector3();
+LiteColliderShape._tempRot = new engine.Quaternion();
+LiteColliderShape._tempScale = new engine.Vector3();
+LiteColliderShape._tempPoint = new engine.Vector3();
+LiteColliderShape._tempVector4 = new engine.Vector4();
+LiteColliderShape._ray = new engine.Ray();
 
 /**
  * Used to implement transformation related functions.
@@ -197,7 +199,7 @@ function _instanceof(left, right) {
         this._updateFlagManager = new LiteUpdateFlagManager();
         this._isParentDirty = true;
         this._parentTransformCache = null;
-        this._dirtyFlag = 0xbc;
+        this._dirtyFlag = 188;
     }
     var _proto = LiteTransform.prototype;
     /**
@@ -239,8 +241,8 @@ function _instanceof(left, right) {
    * 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 (!this._isContainDirtyFlags(132)) {
+            this._worldAssociatedChange(132);
             if (_instanceof(this._owner, LiteCollider)) {
                 var shapes = this._owner._shapes;
                 for(var i = 0, n = shapes.length; i < n; i++){
@@ -256,8 +258,8 @@ function _instanceof(left, right) {
    * 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 (!this._isContainDirtyFlags(152)) {
+            this._worldAssociatedChange(152);
             if (_instanceof(this._owner, LiteCollider)) {
                 var shapes = this._owner._shapes;
                 for(var i = 0, n = shapes.length; i < n; i++){
@@ -272,8 +274,8 @@ function _instanceof(left, right) {
    * 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 (!this._isContainDirtyFlags(160)) {
+            this._worldAssociatedChange(160);
             if (_instanceof(this._owner, LiteCollider)) {
                 var shapes = this._owner._shapes;
                 for(var i = 0, n = shapes.length; i < n; i++){
@@ -285,8 +287,8 @@ function _instanceof(left, right) {
     /**
    * 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 (!this._isContainDirtyFlags(188)) {
+            this._worldAssociatedChange(188);
             if (_instanceof(this._owner, LiteCollider)) {
                 var shapes = this._owner._shapes;
                 for(var i = 0, n = shapes.length; i < n; i++){
@@ -343,7 +345,7 @@ function _instanceof(left, right) {
                 if (this._position !== value) {
                     this._position.copyFrom(value);
                 }
-                this._setDirtyFlagTrue(0x40);
+                this._setDirtyFlagTrue(64);
                 this._updateWorldPositionFlag();
             }
         },
@@ -353,9 +355,9 @@ function _instanceof(left, right) {
    * 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)) {
+                if (this._isContainDirtyFlag(2)) {
                     engine.Quaternion.rotationEuler(engine.MathUtil.degreeToRadian(this._rotation.x), engine.MathUtil.degreeToRadian(this._rotation.y), engine.MathUtil.degreeToRadian(this._rotation.z), this._rotationQuaternion);
-                    this._setDirtyFlagFalse(0x2);
+                    this._setDirtyFlagFalse(2);
                 }
                 return this._rotationQuaternion;
             },
@@ -363,8 +365,8 @@ function _instanceof(left, right) {
                 if (this._rotationQuaternion !== value) {
                     this._rotationQuaternion.copyFrom(value);
                 }
-                this._setDirtyFlagTrue(0x40 | 0x1);
-                this._setDirtyFlagFalse(0x2);
+                this._setDirtyFlagTrue(64 | 1);
+                this._setDirtyFlagFalse(2);
                 this._updateWorldRotationFlag();
             }
         },
@@ -374,14 +376,14 @@ function _instanceof(left, right) {
    * 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)) {
+                if (this._isContainDirtyFlag(16)) {
                     var parent = this._getParentTransform();
                     if (parent != null) {
                         engine.Quaternion.multiply(parent.worldRotationQuaternion, this.rotationQuaternion, this._worldRotationQuaternion);
                     } else {
                         this._worldRotationQuaternion.copyFrom(this.rotationQuaternion);
                     }
-                    this._setDirtyFlagFalse(0x10);
+                    this._setDirtyFlagFalse(16);
                 }
                 return this._worldRotationQuaternion;
             },
@@ -397,7 +399,7 @@ function _instanceof(left, right) {
                     this._rotationQuaternion.copyFrom(value);
                 }
                 this.rotationQuaternion = this._rotationQuaternion;
-                this._setDirtyFlagFalse(0x10);
+                this._setDirtyFlagFalse(16);
             }
         },
         {
@@ -412,7 +414,7 @@ function _instanceof(left, right) {
                 if (this._scale !== value) {
                     this._scale.copyFrom(value);
                 }
-                this._setDirtyFlagTrue(0x40);
+                this._setDirtyFlagTrue(64);
                 this._updateWorldScaleFlag();
             }
         },
@@ -422,9 +424,9 @@ function _instanceof(left, right) {
    * Local matrix.
    * @remarks Need to re-assign after modification to ensure that the modification takes effect.
    */ function get() {
-                if (this._isContainDirtyFlag(0x40)) {
+                if (this._isContainDirtyFlag(64)) {
                     engine.Matrix.affineTransformation(this._scale, this.rotationQuaternion, this._position, this._localMatrix);
-                    this._setDirtyFlagFalse(0x40);
+                    this._setDirtyFlagFalse(64);
                 }
                 return this._localMatrix;
             },
@@ -433,8 +435,8 @@ function _instanceof(left, right) {
                     this._localMatrix.copyFrom(value);
                 }
                 this._localMatrix.decompose(this._position, this._rotationQuaternion, this._scale);
-                this._setDirtyFlagTrue(0x1);
-                this._setDirtyFlagFalse(0x40);
+                this._setDirtyFlagTrue(1);
+                this._setDirtyFlagFalse(64);
                 this._updateAllWorldFlag();
             }
         },
@@ -444,14 +446,14 @@ function _instanceof(left, right) {
    * World matrix.
    * @remarks Need to re-assign after modification to ensure that the modification takes effect.
    */ function get() {
-                if (this._isContainDirtyFlag(0x80)) {
+                if (this._isContainDirtyFlag(128)) {
                     var parent = this._getParentTransform();
                     if (parent) {
                         engine.Matrix.multiply(parent.worldMatrix, this.localMatrix, this._worldMatrix);
                     } else {
                         this._worldMatrix.copyFrom(this.localMatrix);
                     }
-                    this._setDirtyFlagFalse(0x80);
+                    this._setDirtyFlagFalse(128);
                 }
                 return this._worldMatrix;
             },
@@ -467,37 +469,14 @@ function _instanceof(left, right) {
                     this._localMatrix.copyFrom(value);
                 }
                 this.localMatrix = this._localMatrix;
-                this._setDirtyFlagFalse(0x80);
+                this._setDirtyFlagFalse(128);
             }
         }
     ]);
     return LiteTransform;
 }();
-(function() {
-    LiteTransform._tempQuat0 = new engine.Quaternion();
-})();
-(function() {
-    LiteTransform._tempMat42 = new engine.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 = {}));
+LiteTransform._tempQuat0 = new engine.Quaternion();
+LiteTransform._tempMat42 = new engine.Matrix();
 
 /**
  * Abstract class of physical collider.
@@ -513,11 +492,13 @@ var /**
    */ _proto.addShape = function addShape(shape) {
         var oldCollider = shape._collider;
         if (oldCollider !== this) {
+            var _this__scene;
             if (oldCollider) {
                 oldCollider.removeShape(shape);
             }
             this._shapes.push(shape);
             shape._collider = this;
+            (_this__scene = this._scene) == null ? void 0 : _this__scene._addColliderShape(shape);
         }
     };
     /**
@@ -525,8 +506,10 @@ var /**
    */ _proto.removeShape = function removeShape(shape) {
         var index = this._shapes.indexOf(shape);
         if (index !== -1) {
+            var _this__scene;
             this._shapes.splice(index, 1);
             shape._collider = null;
+            (_this__scene = this._scene) == null ? void 0 : _this__scene._removeColliderShape(shape);
         }
     };
     /**
@@ -561,18 +544,34 @@ var /**
 
 /**
  * A dynamic collider can act with self-defined movement or physical force
- */ var LiteDynamicCollider = /*#__PURE__*/ function(LiteCollider1) {
-    _inherits(LiteDynamicCollider, LiteCollider1);
+ */ var LiteDynamicCollider = /*#__PURE__*/ function(LiteCollider) {
+    _inherits(LiteDynamicCollider, LiteCollider);
     function LiteDynamicCollider(position, rotation) {
         var _this;
-        _this = LiteCollider1.call(this) || this;
-        /** @internal */ _this._isStaticCollider = false;
+        _this = LiteCollider.call(this) || this, /** @internal */ _this._isStaticCollider = false;
         _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.getInertiaTensor }
+   */ _proto.getInertiaTensor = function getInertiaTensor(out) {
+        engine.Logger.error("Physics-lite don't support getInertiaTensor. Use Physics-PhysX instead!");
+        return out;
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.getCenterOfMass }
+   */ _proto.getCenterOfMass = function getCenterOfMass(out) {
+        engine.Logger.error("Physics-lite don't support getCenterOfMass. Use Physics-PhysX instead!");
+        return out;
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setMassAndUpdateInertia }
+   */ _proto.setMassAndUpdateInertia = function setMassAndUpdateInertia(mass) {
+        engine.Logger.error("Physics-lite don't support setMassAndUpdateInertia. Use Physics-PhysX instead!");
+    };
+    /**
    * {@inheritDoc IDynamicCollider.addForce }
    */ _proto.addForce = function addForce(force) {
         throw "Physics-lite don't support addForce. Use Physics-PhysX instead!";
@@ -593,74 +592,96 @@ var /**
         throw "Physics-lite don't support putToSleep. Use Physics-PhysX instead!";
     };
     /**
+   * {@inheritDoc IDynamicCollider.isSleeping }
+   */ _proto.isSleeping = function isSleeping() {
+        throw "Physics-lite don't support isSleeping. Use Physics-PhysX instead!";
+    };
+    /**
    * {@inheritDoc IDynamicCollider.setAngularDamping }
    */ _proto.setAngularDamping = function setAngularDamping(value) {
-        throw "Physics-lite don't support setAngularDamping. Use Physics-PhysX instead!";
+        engine.Logger.error("Physics-lite don't support setAngularDamping. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.getAngularVelocity }
+   */ _proto.getAngularVelocity = function getAngularVelocity(out) {
+        engine.Logger.error("Physics-lite don't support getAngularVelocity. Use Physics-PhysX instead!");
+        return out;
     };
     /**
    * {@inheritDoc IDynamicCollider.setAngularVelocity }
    */ _proto.setAngularVelocity = function setAngularVelocity(value) {
-        throw "Physics-lite don't support setAngularVelocity. Use Physics-PhysX instead!";
+        engine.Logger.error("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!";
+        engine.Logger.error("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!";
+        engine.Logger.error("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!";
+        engine.Logger.error("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!";
+        engine.Logger.error("Physics-lite don't support setInertiaTensor. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.setUseGravity }
+   */ _proto.setUseGravity = function setUseGravity(value) {
+        engine.Logger.error("Physics-lite don't support setUseGravity. Use Physics-PhysX instead!");
     };
     /**
    * {@inheritDoc IDynamicCollider.setIsKinematic }
    */ _proto.setIsKinematic = function setIsKinematic(value) {
-        throw "Physics-lite don't support setIsKinematic. Use Physics-PhysX instead!";
+        engine.Logger.error("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!";
+        engine.Logger.error("Physics-lite don't support setLinearDamping. Use Physics-PhysX instead!");
+    };
+    /**
+   * {@inheritDoc IDynamicCollider.getLinearVelocity }
+   */ _proto.getLinearVelocity = function getLinearVelocity(out) {
+        engine.Logger.error("Physics-lite don't support getLinearVelocity. Use Physics-PhysX instead!");
+        return out;
     };
     /**
    * {@inheritDoc IDynamicCollider.setLinearVelocity }
    */ _proto.setLinearVelocity = function setLinearVelocity(value) {
-        throw "Physics-lite don't support setLinearVelocity. Use Physics-PhysX instead!";
+        engine.Logger.error("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!";
+        engine.Logger.error("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!";
+        engine.Logger.error("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!";
+        engine.Logger.error("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!";
+        engine.Logger.error("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!";
+        engine.Logger.error("Physics-lite don't support setSolverIterations. Use Physics-PhysX instead!");
     };
     /**
    * {@inheritDoc IDynamicCollider.wakeUp }
@@ -706,52 +727,6 @@ var /**
     return LitePhysicsMaterial;
 }();
 
-/**
- * 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
@@ -768,11 +743,7 @@ var /**
     _inherits(LiteBoxColliderShape, LiteColliderShape1);
     function LiteBoxColliderShape(uniqueID, size, material) {
         var _this;
-        _this = LiteColliderShape1.call(this) || this;
-        _this._halfSize = new engine.Vector3();
-        _this._sizeScale = new engine.Vector3(1, 1, 1);
-        /** @internal */ _this._boxMin = new engine.Vector3(-0.5, -0.5, -0.5);
-        /** @internal */ _this._boxMax = new engine.Vector3(0.5, 0.5, 0.5);
+        _this = LiteColliderShape1.call(this) || this, _this._halfSize = new engine.Vector3(), _this._sizeScale = new engine.Vector3(1, 1, 1), /** @internal */ _this._boxMin = new engine.Vector3(-0.5, -0.5, -0.5), /** @internal */ _this._boxMax = new engine.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();
@@ -799,6 +770,44 @@ var /**
         this._setBondingBox();
     };
     /**
+   * {@inheritDoc IColliderShape.pointDistance }
+   */ _proto.pointDistance = function pointDistance(point) {
+        var position = LiteColliderShape._tempPos;
+        var rotation = LiteColliderShape._tempRot;
+        this._transform.worldMatrix.decompose(position, rotation, LiteColliderShape._tempScale);
+        var _this__transform = this._transform, shapePosition = _this__transform.position;
+        var m = LiteBoxColliderShape._tempMatrix;
+        var invM = LiteBoxColliderShape._tempInvMatrix;
+        var p = LiteColliderShape._tempPoint;
+        var scale = this._sizeScale;
+        var boundingBox = LiteBoxColliderShape._tempBox;
+        var _this = this, _boxMin = _this._boxMin, _boxMax = _this._boxMax;
+        p.copyFrom(_boxMin);
+        p.subtract(shapePosition);
+        p.divide(scale);
+        boundingBox.min.copyFrom(p);
+        p.copyFrom(_boxMax);
+        p.subtract(shapePosition);
+        p.divide(scale);
+        boundingBox.max.copyFrom(p);
+        engine.Matrix.affineTransformation(scale, rotation, position, m);
+        engine.Matrix.invert(m, invM);
+        engine.Vector3.transformCoordinate(point, invM, p);
+        var min = boundingBox.min;
+        var max = boundingBox.max;
+        p.x = Math.max(min.x, Math.min(p.x, max.x));
+        p.y = Math.max(min.y, Math.min(p.y, max.y));
+        p.z = Math.max(min.z, Math.min(p.z, max.z));
+        engine.Vector3.transformCoordinate(p, m, p);
+        var res = LiteColliderShape._tempVector4;
+        if (engine.Vector3.equals(p, point)) {
+            res.set(point.x, point.y, point.z, 0);
+        } else {
+            res.set(p.x, p.y, p.z, engine.Vector3.distanceSquared(p, point));
+        }
+        return res;
+    };
+    /**
    * @internal
    */ _proto._raycast = function _raycast(ray, hit) {
         var localRay = this._getLocalRay(ray);
@@ -824,9 +833,9 @@ var /**
     };
     return LiteBoxColliderShape;
 }(LiteColliderShape);
-(function() {
-    LiteBoxColliderShape._tempBox = new engine.BoundingBox();
-})();
+LiteBoxColliderShape._tempBox = new engine.BoundingBox();
+LiteBoxColliderShape._tempMatrix = new engine.Matrix();
+LiteBoxColliderShape._tempInvMatrix = new engine.Matrix();
 
 /**
  * Sphere collider shape in Lite.
@@ -834,9 +843,7 @@ var /**
     _inherits(LiteSphereColliderShape, LiteColliderShape1);
     function LiteSphereColliderShape(uniqueID, radius, material) {
         var _this;
-        _this = LiteColliderShape1.call(this) || this;
-        _this._radius = 1;
-        _this._maxScale = 1;
+        _this = LiteColliderShape1.call(this) || this, _this._radius = 1, _this._maxScale = 1;
         _this._radius = radius;
         _this._id = uniqueID;
         return _this;
@@ -854,6 +861,27 @@ var /**
         this._maxScale = Math.max(Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z));
     };
     /**
+   * {@inheritDoc IColliderShape.pointDistance }
+   */ _proto.pointDistance = function pointDistance(point) {
+        var position = LiteColliderShape._tempPos;
+        var worldRadius = this.worldRadius;
+        this._transform.worldMatrix.decompose(position, LiteColliderShape._tempRot, LiteColliderShape._tempScale);
+        var p = LiteColliderShape._tempPoint;
+        engine.Vector3.subtract(point, position, p);
+        var distanceFromCenter = p.lengthSquared();
+        var direction = p.normalize();
+        engine.Vector3.scale(direction, worldRadius, p);
+        p.add(position);
+        var res = LiteColliderShape._tempVector4;
+        var distanceSquared = engine.Vector3.distanceSquared(p, point);
+        if (distanceFromCenter <= worldRadius * worldRadius) {
+            res.set(point.x, point.y, point.z, 0);
+        } else {
+            res.set(p.x, p.y, p.z, distanceSquared);
+        }
+        return res;
+    };
+    /**
    * @internal
    */ _proto._raycast = function _raycast(ray, hit) {
         var boundingSphere = LiteSphereColliderShape._tempSphere;
@@ -877,9 +905,7 @@ var /**
     ]);
     return LiteSphereColliderShape;
 }(LiteColliderShape);
-(function() {
-    LiteSphereColliderShape._tempSphere = new engine.BoundingSphere();
-})();
+LiteSphereColliderShape._tempSphere = new engine.BoundingSphere();
 
 /**
  * A manager is a collection of colliders and constraints which can interact.
@@ -889,7 +915,7 @@ var /**
         this._dynamicColliders = [];
         this._sphere = new engine.BoundingSphere();
         this._box = new engine.BoundingBox();
-        this._currentEvents = new DisorderedArray();
+        this._currentEvents = new engine.DisorderedArray();
         this._eventMap = {};
         this._eventPool = [];
         this._onContactEnter = onContactEnter;
@@ -901,51 +927,35 @@ var /**
     }
     var _proto = LitePhysicsScene.prototype;
     /**
-   * {@inheritDoc IPhysicsManager.setGravity }
+   * {@inheritDoc IPhysicsScene.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, eventMap = _this._eventMap;
-        var id = colliderShape._id;
-        for(var i = currentEvents.length - 1; i >= 0; i--){
-            var event = currentEvents.get(i);
-            if (event.index1 == id) {
-                currentEvents.deleteByIndex(i);
-                eventPool.push(event);
-            } else if (event.index2 == id) {
-                currentEvents.deleteByIndex(i);
-                eventPool.push(event);
-                // If the shape is big index, should clear from the small index shape subMap
-                eventMap[event.index1][id] = undefined;
-            }
-        }
-        delete eventMap[id];
-    };
-    /**
-   * {@inheritDoc IPhysicsManager.addCollider }
+   * {@inheritDoc IPhysicsScene.addCollider }
    */ _proto.addCollider = function addCollider(actor) {
+        actor._scene = this;
         var colliders = actor._isStaticCollider ? this._staticColliders : this._dynamicColliders;
         colliders.push(actor);
+        var shapes = actor._shapes;
+        for(var i = 0, n = shapes.length; i < n; i++){
+            this._addColliderShape(shapes[i]);
+        }
     };
     /**
-   * {@inheritDoc IPhysicsManager.removeCollider }
+   * {@inheritDoc IPhysicsScene.removeCollider }
    */ _proto.removeCollider = function removeCollider(collider) {
+        collider._scene = null;
         var colliders = collider._isStaticCollider ? this._staticColliders : this._dynamicColliders;
         var index = colliders.indexOf(collider);
-        if (index !== -1) {
-            colliders.splice(index, 1);
+        index > -1 && colliders.splice(index, 1);
+        var shapes = collider._shapes;
+        for(var i = 0, n = shapes.length; i < n; i++){
+            this._removeColliderShape(shapes[i]);
         }
     };
     /**
-   * {@inheritDoc IPhysicsManager.update }
+   * {@inheritDoc IPhysicsScene.update }
    */ _proto.update = function update(deltaTime) {
         var dynamicColliders = this._dynamicColliders;
         for(var i = 0, len = dynamicColliders.length; i < len; i++){
@@ -956,13 +966,16 @@ var /**
         this._fireEvent();
     };
     /**
-   * {@inheritDoc IPhysicsManager.raycast }
+   * {@inheritDoc IPhysicsScene.raycast }
    */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
         if (!hit) {
             return this._raycast(ray, distance, onRaycast, this._staticColliders, hit) || this._raycast(ray, distance, onRaycast, this._dynamicColliders, hit);
         } else {
             var raycastStaticRes = this._raycast(ray, distance, onRaycast, this._staticColliders, hit);
-            var raycastDynamicRes = this._raycast(ray, LitePhysicsScene._currentHit.distance, onRaycast, this._dynamicColliders, hit);
+            if (raycastStaticRes) {
+                distance = LitePhysicsScene._currentHit.distance;
+            }
+            var raycastDynamicRes = this._raycast(ray, distance, onRaycast, this._dynamicColliders, hit);
             var isHit = raycastStaticRes || raycastDynamicRes;
             var hitResult = LitePhysicsScene._hitResult;
             if (!isHit) {
@@ -977,15 +990,41 @@ var /**
         }
     };
     /**
-   * {@inheritDoc IPhysicsManager.addCharacterController }
+   * {@inheritDoc IPhysicsScene.addCharacterController }
    */ _proto.addCharacterController = function addCharacterController(characterController) {
         throw "Physics-lite don't support addCharacterController. Use Physics-PhysX instead!";
     };
     /**
-   * {@inheritDoc IPhysicsManager.removeCharacterController }
+   * {@inheritDoc IPhysicsScene.removeCharacterController }
    */ _proto.removeCharacterController = function removeCharacterController(characterController) {
         throw "Physics-lite don't support removeCharacterController. Use Physics-PhysX instead!";
     };
+    /**
+   * {@inheritDoc IPhysicsScene.destroy }
+   */ _proto.destroy = function destroy() {};
+    /**
+   * @internal
+   */ _proto._addColliderShape = function _addColliderShape(colliderShape) {
+        this._eventMap[colliderShape._id] = {};
+    };
+    /**
+   * @internal
+   */ _proto._removeColliderShape = function _removeColliderShape(colliderShape) {
+        var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents, eventMap = _this._eventMap;
+        var id = colliderShape._id;
+        currentEvents.forEach(function(event, i) {
+            if (event.index1 == id) {
+                currentEvents.deleteByIndex(i);
+                eventPool.push(event);
+            } else if (event.index2 == id) {
+                currentEvents.deleteByIndex(i);
+                eventPool.push(event);
+                // If the shape is big index, should clear from the small index shape subMap
+                eventMap[event.index1][id] = undefined;
+            }
+        });
+        delete eventMap[id];
+    };
     _proto._getTrigger = function _getTrigger(index1, index2) {
         var event;
         if (this._eventPool.length) {
@@ -1060,25 +1099,25 @@ var /**
         }
     };
     _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);
+        var _this = this;
+        var _this1 = this, eventPool = _this1._eventPool, currentEvents = _this1._currentEvents;
+        currentEvents.forEach(function(event, i) {
             if (!event.alreadyInvoked) {
                 if (event.state == 0) {
-                    this._onTriggerEnter(event.index1, event.index2);
+                    _this._onTriggerEnter(event.index1, event.index2);
                     event.alreadyInvoked = true;
                 } else if (event.state == 1) {
-                    this._onTriggerStay(event.index1, event.index2);
+                    _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);
+                _this._eventMap[event.index1][event.index2] = undefined;
                 currentEvents.deleteByIndex(i);
+                _this._onTriggerExit(event.index1, event.index2);
                 eventPool.push(event);
             }
-        }
+        });
     };
     _proto._boxCollision = function _boxCollision(other) {
         if (_instanceof(other, LiteBoxColliderShape)) {
@@ -1105,26 +1144,19 @@ var /**
         return false;
     };
     _proto._raycast = function _raycast(ray, distance, onRaycast, colliders, hit) {
-        var hitResult;
-        if (hit) {
-            hitResult = LitePhysicsScene._hitResult;
-        }
         var isHit = false;
         var curHit = LitePhysicsScene._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 (colliders[i]._raycast(ray, onRaycast, curHit) && curHit.distance < distance) {
+                if (hit) {
+                    isHit = true;
+                    var hitResult = LitePhysicsScene._hitResult;
+                    hitResult.normal.copyFrom(curHit.normal);
+                    hitResult.point.copyFrom(curHit.point);
+                    hitResult.distance = distance = curHit.distance;
+                    hitResult.shapeID = curHit.shapeID;
+                } else {
+                    return true;
                 }
             }
         }
@@ -1150,26 +1182,10 @@ var /**
     };
     return LitePhysicsScene;
 }();
-(function() {
-    LitePhysicsScene._tempSphere = new engine.BoundingSphere();
-})();
-(function() {
-    LitePhysicsScene._tempBox = new engine.BoundingBox();
-})();
-(function() {
-    LitePhysicsScene._currentHit = new LiteHitResult();
-})();
-(function() {
-    LitePhysicsScene._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 = {}));
+LitePhysicsScene._tempSphere = new engine.BoundingSphere();
+LitePhysicsScene._tempBox = new engine.BoundingBox();
+LitePhysicsScene._currentHit = new LiteHitResult();
+LitePhysicsScene._hitResult = new LiteHitResult();
 /**
  * Trigger event to store interactive object ids and state.
  */ var TriggerEvent = function TriggerEvent(index1, index2) {
@@ -1181,12 +1197,11 @@ var /**
 /**
  * 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(LiteCollider1) {
-    _inherits(LiteStaticCollider, LiteCollider1);
+ */ var LiteStaticCollider = /*#__PURE__*/ function(LiteCollider) {
+    _inherits(LiteStaticCollider, LiteCollider);
     function LiteStaticCollider(position, rotation) {
         var _this;
-        _this = LiteCollider1.call(this) || this;
-        /** @internal */ _this._isStaticCollider = true;
+        _this = LiteCollider.call(this) || this, /** @internal */ _this._isStaticCollider = true;
         _this._transform.setPosition(position.x, position.y, position.z);
         _this._transform.setRotationQuaternion(rotation.x, rotation.y, rotation.z, rotation.w);
         return _this;
@@ -1267,12 +1282,15 @@ var LitePhysics = /*#__PURE__*/ function() {
    */ _proto.createSpringJoint = function createSpringJoint(collider) {
         throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
     };
+    /**
+   * {@inheritDoc IPhysics.destroy }
+   */ _proto.destroy = function destroy() {};
     return LitePhysics;
 }();
 
 //@ts-ignore
-var version = "0.0.0-experimental-1.3-xr.9";
-console.log("Galacean PhysicsLite version: " + version);
+var version = "0.0.0-experimental-1.4-small-language.0";
+console.log("Galacean Engine Physics Lite Version: " + version);
 
 exports.LitePhysics = LitePhysics;
 exports.version = version;