@galacean/engine-physics-lite 0.0.0-experimental-double11.3 → 0.0.0-experimental-double11.5

package/dist/miniprogram.js

@@ -90,6 +90,8 @@ function _instanceof(left, right) {
  * Abstract class for collider shapes.
  */ var LiteColliderShape = /*#__PURE__*/ function() {
     function LiteColliderShape() {
+        /** @internal */ this._position = new miniprogram.Vector3();
+        /** @internal */ this._worldScale = new miniprogram.Vector3(1, 1, 1);
         /** @internal */ this._transform = new LiteTransform();
         /** @internal */ this._invModelMatrix = new miniprogram.Matrix();
         this._transform.owner = this;
@@ -104,7 +106,18 @@ function _instanceof(left, right) {
     /**
    * {@inheritDoc IColliderShape.setPosition }
    */ _proto.setPosition = function setPosition(position) {
-        this._transform.setPosition(position.x, position.y, position.z);
+        if (position !== this._position) {
+            this._position.copyFrom(position);
+        }
+        this._setLocalPose();
+    };
+    /**
+   * {@inheritDoc IColliderShape.setWorldScale }
+   */ _proto.setWorldScale = function setWorldScale(scale) {
+        if (scale !== this._worldScale) {
+            this._worldScale.copyFrom(scale);
+        }
+        this._setLocalPose();
     };
     /**
    * {@inheritDoc IColliderShape.setContactOffset }
@@ -158,6 +171,11 @@ function _instanceof(left, right) {
         }
         return this._invModelMatrix;
     };
+    _proto._setLocalPose = function _setLocalPose() {
+        var shapePosition = LiteColliderShape._tempPoint;
+        miniprogram.Vector3.multiply(this._position, this._worldScale, shapePosition);
+        this._transform.position = shapePosition;
+    };
     return LiteColliderShape;
 }();
 (function() {
@@ -545,11 +563,11 @@ var /**
 
 /**
  * A dynamic collider can act with self-defined movement or physical force
- */ var LiteDynamicCollider = /*#__PURE__*/ function(LiteCollider) {
-    _inherits(LiteDynamicCollider, LiteCollider);
+ */ var LiteDynamicCollider = /*#__PURE__*/ function(LiteCollider1) {
+    _inherits(LiteDynamicCollider, LiteCollider1);
     function LiteDynamicCollider(position, rotation) {
         var _this;
-        _this = LiteCollider.call(this) || this;
+        _this = LiteCollider1.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;
@@ -653,6 +671,42 @@ var /**
     return LiteDynamicCollider;
 }(LiteCollider);
 
+/**
+ * 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;
+}();
+
 /**
  * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
  */ var DisorderedArray = /*#__PURE__*/ function() {
@@ -711,13 +765,12 @@ var /**
 
 /**
  * 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 = LiteColliderShape1.call(this) || this;
         _this._halfSize = new miniprogram.Vector3();
-        _this._scale = new miniprogram.Vector3(1, 1, 1);
         /** @internal */ _this._boxMin = new miniprogram.Vector3(-0.5, -0.5, -0.5);
         /** @internal */ _this._boxMax = new miniprogram.Vector3(0.5, 0.5, 0.5);
         _this._id = uniqueID;
@@ -729,14 +782,14 @@ var /**
     /**
    * {@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) {
-        this._transform.position = this._transform.position.multiply(scale);
-        this._scale.copyFrom(scale);
+        LiteColliderShape1.prototype.setWorldScale.call(this, scale);
+        this._setBondingBox();
     };
     /**
    * {@inheritDoc IBoxColliderShape.setSize }
@@ -749,8 +802,8 @@ var /**
    */ _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);
+        boundingBox.min.set(-this._halfSize.x * this._worldScale.x, -this._halfSize.y * this._worldScale.y, -this._halfSize.z * this._worldScale.z);
+        boundingBox.max.set(this._halfSize.x * this._worldScale.x, this._halfSize.y * this._worldScale.y, this._halfSize.z * this._worldScale.z);
         var rayDistance = localRay.intersectBox(boundingBox);
         if (rayDistance !== -1) {
             this._updateHitResult(localRay, rayDistance, hit, ray.origin);
@@ -760,10 +813,11 @@ var /**
         }
     };
     _proto._setBondingBox = function _setBondingBox() {
-        var _this__transform = this._transform, center = _this__transform.position;
+        var position = this._transform.position;
+        var scale = this._worldScale;
         var halfSize = this._halfSize;
-        miniprogram.Vector3.add(center, halfSize, this._boxMax);
-        miniprogram.Vector3.subtract(center, halfSize, this._boxMin);
+        this._boxMin.set(-halfSize.x * scale.x + position.x, -halfSize.y * scale.y + position.y, -halfSize.z * scale.z + position.z);
+        this._boxMax.set(halfSize.x * scale.x + position.x, halfSize.y * scale.y + position.y, halfSize.z * scale.z + position.z);
     };
     return LiteBoxColliderShape;
 }(LiteColliderShape);
@@ -773,11 +827,11 @@ var /**
 
 /**
  * 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 = LiteColliderShape1.call(this) || this;
         _this._radius = 1;
         _this._maxScale = 1;
         _this._radius = radius;
@@ -793,6 +847,7 @@ var /**
     /**
    * {@inheritDoc IColliderShape.setWorldScale }
    */ _proto.setWorldScale = function setWorldScale(scale) {
+        LiteColliderShape1.prototype.setWorldScale.call(this, scale);
         this._maxScale = Math.max(scale.x, scale.y, scale.z);
     };
     /**
@@ -825,8 +880,8 @@ var /**
 
 /**
  * A manager is a collection of colliders and constraints which can interact.
- */ var LitePhysicsManager = /*#__PURE__*/ function() {
-    function LitePhysicsManager(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
+ */ var LitePhysicsScene = /*#__PURE__*/ function() {
+    function LitePhysicsScene(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
         this._colliders = [];
         this._sphere = new miniprogram.BoundingSphere();
         this._box = new miniprogram.BoundingBox();
@@ -840,7 +895,7 @@ var /**
         this._onTriggerExit = onTriggerExit;
         this._onTriggerStay = onTriggerStay;
     }
-    var _proto = LitePhysicsManager.prototype;
+    var _proto = LitePhysicsScene.prototype;
     /**
    * {@inheritDoc IPhysicsManager.setGravity }
    */ _proto.setGravity = function setGravity(value) {
@@ -893,23 +948,25 @@ var /**
         var colliders = this._colliders;
         var hitResult;
         if (hit) {
-            hitResult = LitePhysicsManager._hitResult;
+            hitResult = LitePhysicsScene._hitResult;
         }
         var isHit = false;
-        var curHit = LitePhysicsManager._currentHit;
+        var curHit = LitePhysicsScene._currentHit;
         for(var i = 0, len = colliders.length; i < len; i++){
             var collider = colliders[i];
-            if (collider._raycast(ray, onRaycast, curHit) && curHit.distance < distance) {
+            if (collider._raycast(ray, onRaycast, curHit)) {
                 isHit = true;
-                if (hitResult) {
-                    hitResult.normal.copyFrom(curHit.normal);
-                    hitResult.point.copyFrom(curHit.point);
-                    hitResult.distance = curHit.distance;
-                    hitResult.shapeID = curHit.shapeID;
-                } else {
-                    return 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;
                 }
-                distance = curHit.distance;
             }
         }
         if (!isHit && hitResult) {
@@ -950,7 +1007,7 @@ var /**
         for(var i = 0, len = myColliderShapes.length; i < len; i++){
             var myShape = myColliderShapes[i];
             if (_instanceof(myShape, LiteBoxColliderShape)) {
-                LitePhysicsManager._updateWorldBox(myShape, this._box);
+                LitePhysicsScene._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++){
@@ -977,7 +1034,7 @@ var /**
                     }
                 }
             } else if (_instanceof(myShape, LiteSphereColliderShape)) {
-                LitePhysicsManager._upWorldSphere(myShape, this._sphere);
+                LitePhysicsScene._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++){
@@ -1029,24 +1086,24 @@ var /**
     };
     _proto._boxCollision = function _boxCollision(other) {
         if (_instanceof(other, LiteBoxColliderShape)) {
-            var box = LitePhysicsManager._tempBox;
-            LitePhysicsManager._updateWorldBox(other, box);
+            var box = LitePhysicsScene._tempBox;
+            LitePhysicsScene._updateWorldBox(other, box);
             return miniprogram.CollisionUtil.intersectsBoxAndBox(box, this._box);
         } else if (_instanceof(other, LiteSphereColliderShape)) {
-            var sphere = LitePhysicsManager._tempSphere;
-            LitePhysicsManager._upWorldSphere(other, sphere);
+            var sphere = LitePhysicsScene._tempSphere;
+            LitePhysicsScene._upWorldSphere(other, sphere);
             return miniprogram.CollisionUtil.intersectsSphereAndBox(sphere, this._box);
         }
         return false;
     };
     _proto._sphereCollision = function _sphereCollision(other) {
         if (_instanceof(other, LiteBoxColliderShape)) {
-            var box = LitePhysicsManager._tempBox;
-            LitePhysicsManager._updateWorldBox(other, box);
+            var box = LitePhysicsScene._tempBox;
+            LitePhysicsScene._updateWorldBox(other, box);
             return miniprogram.CollisionUtil.intersectsSphereAndBox(this._sphere, box);
         } else if (_instanceof(other, LiteSphereColliderShape)) {
-            var sphere = LitePhysicsManager._tempSphere;
-            LitePhysicsManager._upWorldSphere(other, sphere);
+            var sphere = LitePhysicsScene._tempSphere;
+            LitePhysicsScene._upWorldSphere(other, sphere);
             return miniprogram.CollisionUtil.intersectsSphereAndSphere(sphere, this._sphere);
         }
         return false;
@@ -1055,7 +1112,7 @@ var /**
    * 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) {
+   */ LitePhysicsScene._updateWorldBox = function _updateWorldBox(boxCollider, out) {
         var mat = boxCollider._transform.worldMatrix;
         out.min.copyFrom(boxCollider._boxMin);
         out.max.copyFrom(boxCollider._boxMax);
@@ -1065,23 +1122,23 @@ var /**
    * 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) {
+   */ LitePhysicsScene._upWorldSphere = function _upWorldSphere(sphereCollider, out) {
         miniprogram.Vector3.transformCoordinate(sphereCollider._transform.position, sphereCollider._transform.worldMatrix, out.center);
         out.radius = sphereCollider.worldRadius;
     };
-    return LitePhysicsManager;
+    return LitePhysicsScene;
 }();
 (function() {
-    LitePhysicsManager._tempSphere = new miniprogram.BoundingSphere();
+    LitePhysicsScene._tempSphere = new miniprogram.BoundingSphere();
 })();
 (function() {
-    LitePhysicsManager._tempBox = new miniprogram.BoundingBox();
+    LitePhysicsScene._tempBox = new miniprogram.BoundingBox();
 })();
 (function() {
-    LitePhysicsManager._currentHit = new LiteHitResult();
+    LitePhysicsScene._currentHit = new LiteHitResult();
 })();
 (function() {
-    LitePhysicsManager._hitResult = new LiteHitResult();
+    LitePhysicsScene._hitResult = new LiteHitResult();
 })();
 var /**
  * Physics state
@@ -1099,50 +1156,14 @@ var /**
     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);
+ */ var LiteStaticCollider = /*#__PURE__*/ function(LiteCollider1) {
+    _inherits(LiteStaticCollider, LiteCollider1);
     function LiteStaticCollider(position, rotation) {
         var _this;
-        _this = LiteCollider.call(this) || this;
+        _this = LiteCollider1.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;
@@ -1160,8 +1181,13 @@ var LitePhysics = /*#__PURE__*/ function() {
     };
     /**
    * {@inheritDoc IPhysics.createPhysicsManager }
-   */ _proto.createPhysicsManager = function createPhysicsManager(onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist) {
-        return new LitePhysicsManager(onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist);
+   */ _proto.createPhysicsManager = function createPhysicsManager() {
+        return null;
+    };
+    /**
+   * {@inheritDoc IPhysics.createPhysicsScene }
+   */ _proto.createPhysicsScene = function createPhysicsScene(physicsManager, onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist) {
+        return new LitePhysicsScene(onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist);
     };
     /**
    * {@inheritDoc IPhysics.createStaticCollider }
@@ -1221,4 +1247,9 @@ var LitePhysics = /*#__PURE__*/ function() {
     return LitePhysics;
 }();
 
+//@ts-ignore
+var version = "0.0.0-experimental-double11.5";
+console.log("Galacean PhysicsLite version: " + version);
+
 exports.LitePhysics = LitePhysics;
+exports.version = version;