@galacean/engine-physics-lite 1.4.0-alpha.0 → 1.4.0-alpha.2

package/dist/browser.js

@@ -94,6 +94,7 @@
             /** @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 @@
         /**
        * {@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,8 +178,12 @@
         };
         return LiteColliderShape;
     }();
-    LiteColliderShape._ray = new engine.Ray();
+    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.
@@ -486,11 +492,13 @@
        */ _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);
             }
         };
         /**
@@ -498,8 +506,10 @@
        */ _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);
             }
         };
         /**
@@ -545,6 +555,23 @@
         }
         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!";
@@ -565,74 +592,111 @@
             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.getAngularDamping }
+       */ _proto.getAngularDamping = function getAngularDamping() {
+            throw "Physics-lite don't support getAngularDamping. 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) {
+            throw "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.getLinearDamping = function getLinearDamping() {
+            throw "Physics-lite don't support getLinearDamping. 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.getMaxDepenetrationVelocity = function getMaxDepenetrationVelocity() {
+            throw "Physics-lite don't support getMaxDepenetrationVelocity. 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 }
@@ -690,11 +754,11 @@
 
     /**
      * Box collider shape in Lite.
-     */ var LiteBoxColliderShape = /*#__PURE__*/ function(LiteColliderShape) {
-        _inherits(LiteBoxColliderShape, LiteColliderShape);
+     */ var LiteBoxColliderShape = /*#__PURE__*/ function(LiteColliderShape1) {
+        _inherits(LiteBoxColliderShape, LiteColliderShape1);
         function LiteBoxColliderShape(uniqueID, size, material) {
             var _this;
-            _this = LiteColliderShape.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();
@@ -704,13 +768,13 @@
         /**
        * {@inheritDoc IColliderShape.setPosition }
        */ _proto.setPosition = function setPosition(position) {
-            LiteColliderShape.prototype.setPosition.call(this, position);
+            LiteColliderShape1.prototype.setPosition.call(this, position);
             this._setBondingBox();
         };
         /**
        * {@inheritDoc IColliderShape.setWorldScale }
        */ _proto.setWorldScale = function setWorldScale(scale) {
-            LiteColliderShape.prototype.setWorldScale.call(this, scale);
+            LiteColliderShape1.prototype.setWorldScale.call(this, scale);
             this._sizeScale.set(Math.abs(scale.x), Math.abs(scale.y), Math.abs(scale.z));
             this._setBondingBox();
         };
@@ -721,6 +785,44 @@
             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);
@@ -747,14 +849,16 @@
         return LiteBoxColliderShape;
     }(LiteColliderShape);
     LiteBoxColliderShape._tempBox = new engine.BoundingBox();
+    LiteBoxColliderShape._tempMatrix = new engine.Matrix();
+    LiteBoxColliderShape._tempInvMatrix = new engine.Matrix();
 
     /**
      * Sphere collider shape in Lite.
-     */ var LiteSphereColliderShape = /*#__PURE__*/ function(LiteColliderShape) {
-        _inherits(LiteSphereColliderShape, LiteColliderShape);
+     */ var LiteSphereColliderShape = /*#__PURE__*/ function(LiteColliderShape1) {
+        _inherits(LiteSphereColliderShape, LiteColliderShape1);
         function LiteSphereColliderShape(uniqueID, radius, material) {
             var _this;
-            _this = LiteColliderShape.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;
@@ -768,10 +872,31 @@
         /**
        * {@inheritDoc IColliderShape.setWorldScale }
        */ _proto.setWorldScale = function setWorldScale(scale) {
-            LiteColliderShape.prototype.setWorldScale.call(this, scale);
+            LiteColliderShape1.prototype.setWorldScale.call(this, scale);
             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;
@@ -822,41 +947,26 @@
             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;
-            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];
-        };
-        /**
        * {@inheritDoc IPhysicsManager.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 }
        */ _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]);
             }
         };
         /**
@@ -904,6 +1014,29 @@
        */ _proto.removeCharacterController = function removeCharacterController(characterController) {
             throw "Physics-lite don't support removeCharacterController. Use Physics-PhysX instead!";
         };
+        /**
+       * @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) {
@@ -1165,7 +1298,7 @@
     }();
 
     //@ts-ignore
-    var version = "1.4.0-alpha.0";
+    var version = "1.4.0-alpha.2";
     console.log("Galacean PhysicsLite version: " + version);
 
     exports.LitePhysics = LitePhysics;