@galacean/engine-physics-lite 0.0.0-experimental-0.9-plus.7 → 0.0.0-experimental-ktx2.0

package/dist/module.js

@@ -1,26 +1,4 @@
-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;
-}
+import { Utils, Ray, Vector3, Matrix, Quaternion, MathUtil, BoundingBox, BoundingSphere, CollisionUtil } from '@galacean/engine';
 
 function _set_prototype_of(o, p) {
     _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
@@ -66,22 +44,6 @@ function _instanceof(left, right) {
     } 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() {
@@ -95,7 +57,7 @@ function _instanceof(left, right) {
     /**
    * Destroy.
    */ _proto.destroy = function destroy() {
-        removeFromArray(this._flags, this);
+        Utils.removeFromArray(this._flags, this);
         this._flags = null;
     };
     return LiteUpdateFlag;
@@ -687,6 +649,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() {
@@ -859,8 +857,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 BoundingSphere();
         this._box = new BoundingBox();
@@ -874,7 +872,7 @@ var /**
         this._onTriggerExit = onTriggerExit;
         this._onTriggerStay = onTriggerStay;
     }
-    var _proto = LitePhysicsManager.prototype;
+    var _proto = LitePhysicsScene.prototype;
     /**
    * {@inheritDoc IPhysicsManager.setGravity }
    */ _proto.setGravity = function setGravity(value) {
@@ -927,10 +925,10 @@ 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)) {
@@ -986,7 +984,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++){
@@ -1013,7 +1011,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++){
@@ -1065,24 +1063,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 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 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 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 CollisionUtil.intersectsSphereAndSphere(sphere, this._sphere);
         }
         return false;
@@ -1091,7 +1089,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);
@@ -1101,23 +1099,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) {
         Vector3.transformCoordinate(sphereCollider._transform.position, sphereCollider._transform.worldMatrix, out.center);
         out.radius = sphereCollider.worldRadius;
     };
-    return LitePhysicsManager;
+    return LitePhysicsScene;
 }();
 (function() {
-    LitePhysicsManager._tempSphere = new BoundingSphere();
+    LitePhysicsScene._tempSphere = new BoundingSphere();
 })();
 (function() {
-    LitePhysicsManager._tempBox = new BoundingBox();
+    LitePhysicsScene._tempBox = new BoundingBox();
 })();
 (function() {
-    LitePhysicsManager._currentHit = new LiteHitResult();
+    LitePhysicsScene._currentHit = new LiteHitResult();
 })();
 (function() {
-    LitePhysicsManager._hitResult = new LiteHitResult();
+    LitePhysicsScene._hitResult = new LiteHitResult();
 })();
 var /**
  * Physics state
@@ -1135,42 +1133,6 @@ 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.
@@ -1186,81 +1148,81 @@ var /**
     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() {}
+    var _proto = LitePhysics.prototype;
+    /**
+   * {@inheritDoc IPhysics.initialize }
+   */ _proto.initialize = function initialize() {
+        return Promise.resolve();
+    };
     /**
    * {@inheritDoc IPhysics.createPhysicsManager }
-   */ LitePhysics.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 }
-   */ LitePhysics.createStaticCollider = function createStaticCollider(position, rotation) {
+   */ _proto.createStaticCollider = function createStaticCollider(position, rotation) {
         return new LiteStaticCollider(position, rotation);
     };
     /**
    * {@inheritDoc IPhysics.createDynamicCollider }
-   */ LitePhysics.createDynamicCollider = function createDynamicCollider(position, rotation) {
+   */ _proto.createDynamicCollider = function createDynamicCollider(position, rotation) {
         return new LiteDynamicCollider(position, rotation);
     };
     /**
    * {@inheritDoc IPhysics.createCharacterController }
-   */ LitePhysics.createCharacterController = function createCharacterController() {
+   */ _proto.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) {
+   */ _proto.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) {
+   */ _proto.createBoxColliderShape = function createBoxColliderShape(uniqueID, size, material) {
         return new LiteBoxColliderShape(uniqueID, size, material);
     };
     /**
    * {@inheritDoc IPhysics.createSphereColliderShape }
-   */ LitePhysics.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
+   */ _proto.createSphereColliderShape = function createSphereColliderShape(uniqueID, radius, material) {
         return new LiteSphereColliderShape(uniqueID, radius, material);
     };
     /**
    * {@inheritDoc IPhysics.createPlaneColliderShape }
-   */ LitePhysics.createPlaneColliderShape = function createPlaneColliderShape(uniqueID, material) {
+   */ _proto.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) {
+   */ _proto.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) {
+   */ _proto.createFixedJoint = function createFixedJoint(collider) {
         throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
     };
     /**
    * {@inheritDoc IPhysics.createHingeJoint }
-   */ LitePhysics.createHingeJoint = function createHingeJoint(collider) {
+   */ _proto.createHingeJoint = function createHingeJoint(collider) {
         throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
     };
     /**
    * {@inheritDoc IPhysics.createSpringJoint }
-   */ LitePhysics.createSpringJoint = function createSpringJoint(collider) {
+   */ _proto.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