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

package/dist/module.js

@@ -477,10 +477,11 @@ LiteTransform._tempMat42 = new Matrix();
 /**
  * Abstract class of physical collider.
  */ var LiteCollider = /*#__PURE__*/ function() {
-    function LiteCollider() {
+    function LiteCollider(litePhysics) {
         /** @internal */ this._shapes = [];
         /** @internal */ this._transform = new LiteTransform();
         this._transform.owner = this;
+        this._litePhysics = litePhysics;
     }
     var _proto = LiteCollider.prototype;
     /**
@@ -522,6 +523,11 @@ LiteTransform._tempMat42 = new Matrix();
         outRotation.set(rotationQuaternion.x, rotationQuaternion.y, rotationQuaternion.z, rotationQuaternion.w);
     };
     /**
+   * {@inheritDoc ICollider.setCollisionLayer }
+   */ _proto.setCollisionLayer = function setCollisionLayer(collisionLayer) {
+        this._litePhysics.setColliderLayer(this, collisionLayer);
+    };
+    /**
    * {@inheritDoc ICollider.destroy }
    */ _proto.destroy = function destroy() {};
     /**
@@ -542,9 +548,9 @@ LiteTransform._tempMat42 = new Matrix();
  * A dynamic collider can act with self-defined movement or physical force
  */ var LiteDynamicCollider = /*#__PURE__*/ function(LiteCollider) {
     _inherits(LiteDynamicCollider, LiteCollider);
-    function LiteDynamicCollider(position, rotation) {
+    function LiteDynamicCollider(litePhysics, position, rotation) {
         var _this;
-        _this = LiteCollider.call(this) || this, /** @internal */ _this._isStaticCollider = false;
+        _this = LiteCollider.call(this, litePhysics) || 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;
@@ -906,7 +912,7 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
 /**
  * A manager is a collection of colliders and constraints which can interact.
  */ var LitePhysicsScene = /*#__PURE__*/ function() {
-    function LitePhysicsScene(onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
+    function LitePhysicsScene(physics, onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
         this._staticColliders = [];
         this._dynamicColliders = [];
         this._sphere = new BoundingSphere();
@@ -914,6 +920,7 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
         this._currentEvents = new DisorderedArray();
         this._eventMap = {};
         this._eventPool = [];
+        this._physics = physics;
         this._onContactEnter = onContactEnter;
         this._onContactExit = onContactExit;
         this._onContactStay = onContactStay;
@@ -923,12 +930,12 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
     }
     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.addCollider }
+   * {@inheritDoc IPhysicsScene.addCollider }
    */ _proto.addCollider = function addCollider(actor) {
         actor._scene = this;
         var colliders = actor._isStaticCollider ? this._staticColliders : this._dynamicColliders;
@@ -939,7 +946,7 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
         }
     };
     /**
-   * {@inheritDoc IPhysicsManager.removeCollider }
+   * {@inheritDoc IPhysicsScene.removeCollider }
    */ _proto.removeCollider = function removeCollider(collider) {
         collider._scene = null;
         var colliders = collider._isStaticCollider ? this._staticColliders : this._dynamicColliders;
@@ -951,7 +958,7 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
         }
     };
     /**
-   * {@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++){
@@ -962,7 +969,7 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
         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);
@@ -986,16 +993,19 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
         }
     };
     /**
-   * {@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] = {};
@@ -1037,7 +1047,12 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
             if (_instanceof(myShape, LiteBoxColliderShape)) {
                 LitePhysicsScene._updateWorldBox(myShape, this._box);
                 for(var j = 0, len1 = colliders.length; j < len1; j++){
-                    var colliderShape = colliders[j]._shapes;
+                    var collider = colliders[j];
+                    var colliderShape = collider._shapes;
+                    // Skip collision check if layers can't collide
+                    if (!this._checkColliderCollide(collider, myCollider)) {
+                        continue;
+                    }
                     for(var k = 0, len2 = colliderShape.length; k < len2; k++){
                         var shape = colliderShape[k];
                         var index1 = shape._id;
@@ -1064,7 +1079,12 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
             } else if (_instanceof(myShape, LiteSphereColliderShape)) {
                 LitePhysicsScene._upWorldSphere(myShape, this._sphere);
                 for(var j1 = 0, len3 = colliders.length; j1 < len3; j1++){
-                    var colliderShape1 = colliders[j1]._shapes;
+                    var collider1 = colliders[j1];
+                    var colliderShape1 = collider1._shapes;
+                    // Skip collision check if layers can't collide
+                    if (!this._checkColliderCollide(collider1, myCollider)) {
+                        continue;
+                    }
                     for(var k1 = 0, len4 = colliderShape1.length; k1 < len4; k1++){
                         var shape1 = colliderShape1[k1];
                         var index11 = shape1._id;
@@ -1155,6 +1175,14 @@ LiteSphereColliderShape._tempSphere = new BoundingSphere();
         }
         return isHit;
     };
+    _proto._checkColliderCollide = function _checkColliderCollide(collider1, collider2) {
+        var group1 = collider1._collisionLayer;
+        var group2 = collider2._collisionLayer;
+        if (group1 === group2) {
+            return true;
+        }
+        return this._physics.getColliderLayerCollision(group1, group2);
+    };
     /**
    * Calculate the bounding box in world space from boxCollider.
    * @param boxCollider - The boxCollider to calculate
@@ -1192,9 +1220,9 @@ LitePhysicsScene._hitResult = new LiteHitResult();
  * @remarks Mostly used for object which always stays at the same place and never moves around.
  */ var LiteStaticCollider = /*#__PURE__*/ function(LiteCollider) {
     _inherits(LiteStaticCollider, LiteCollider);
-    function LiteStaticCollider(position, rotation) {
+    function LiteStaticCollider(litePhysics, position, rotation) {
         var _this;
-        _this = LiteCollider.call(this) || this, /** @internal */ _this._isStaticCollider = true;
+        _this = LiteCollider.call(this, litePhysics) || 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;
@@ -1203,7 +1231,9 @@ LitePhysicsScene._hitResult = new LiteHitResult();
 }(LiteCollider);
 
 var LitePhysics = /*#__PURE__*/ function() {
-    function LitePhysics() {}
+    function LitePhysics() {
+        this._layerCollisionMatrix = [];
+    }
     var _proto = LitePhysics.prototype;
     /**
    * {@inheritDoc IPhysics.initialize }
@@ -1218,17 +1248,17 @@ var LitePhysics = /*#__PURE__*/ function() {
     /**
    * {@inheritDoc IPhysics.createPhysicsScene }
    */ _proto.createPhysicsScene = function createPhysicsScene(physicsManager, onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist) {
-        return new LitePhysicsScene(onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist);
+        return new LitePhysicsScene(this, onContactBegin, onContactEnd, onContactPersist, onTriggerBegin, onTriggerEnd, onTriggerPersist);
     };
     /**
    * {@inheritDoc IPhysics.createStaticCollider }
    */ _proto.createStaticCollider = function createStaticCollider(position, rotation) {
-        return new LiteStaticCollider(position, rotation);
+        return new LiteStaticCollider(this, position, rotation);
     };
     /**
    * {@inheritDoc IPhysics.createDynamicCollider }
    */ _proto.createDynamicCollider = function createDynamicCollider(position, rotation) {
-        return new LiteDynamicCollider(position, rotation);
+        return new LiteDynamicCollider(this, position, rotation);
     };
     /**
    * {@inheritDoc IPhysics.createCharacterController }
@@ -1275,11 +1305,48 @@ var LitePhysics = /*#__PURE__*/ function() {
    */ _proto.createSpringJoint = function createSpringJoint(collider) {
         throw "Physics-lite don't support CapsuleColliderShape. Use Physics-PhysX instead!";
     };
+    /**
+   * {@inheritDoc IPhysics.setColliderLayer }
+   */ _proto.setColliderLayer = function setColliderLayer(collider, layer) {
+        collider._collisionLayer = layer;
+    };
+    /**
+   * {@inheritDoc IPhysics.getColliderLayerCollision }
+   */ _proto.getColliderLayerCollision = function getColliderLayerCollision(layer1, layer2) {
+        var index = this._getColliderLayerIndex(layer1, layer2);
+        if (index > -1) {
+            var _this__layerCollisionMatrix_index;
+            return (_this__layerCollisionMatrix_index = this._layerCollisionMatrix[index]) != null ? _this__layerCollisionMatrix_index : true;
+        }
+        // If either layer is Layer.Nothing, they cant collide
+        return false;
+    };
+    /**
+   * {@inheritDoc IPhysics.setColliderLayerCollision }
+   */ _proto.setColliderLayerCollision = function setColliderLayerCollision(layer1, layer2, collide) {
+        var index = this._getColliderLayerIndex(layer1, layer2);
+        if (index > -1) {
+            this._layerCollisionMatrix[index] = collide;
+        }
+    };
+    /**
+   * {@inheritDoc IPhysics.destroy }
+   */ _proto.destroy = function destroy() {};
+    _proto._getColliderLayerIndex = function _getColliderLayerIndex(layer1, layer2) {
+        if (layer1 === 32 || layer2 === 32) {
+            return -1;
+        }
+        var min = Math.min(layer1, layer2);
+        var max = Math.max(layer1, layer2);
+        // Calculate a unique index for the layer pair using the triangular number formula
+        // This ensures that each layer combination maps to a unique index in the collision matrix
+        return max * (max + 1) / 2 + min;
+    };
     return LitePhysics;
 }();
 
 //@ts-ignore
-var version = "1.5.0-alpha.0";
+var version = "1.5.0-alpha.2";
 console.log("Galacean Engine Physics Lite Version: " + version);
 
 export { LitePhysics, version };