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

package/dist/browser.js

@@ -481,10 +481,11 @@
     /**
      * 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;
         /**
@@ -526,6 +527,11 @@
             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() {};
         /**
@@ -546,9 +552,9 @@
      * 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;
@@ -910,7 +916,7 @@
     /**
      * 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 engine.BoundingSphere();
@@ -918,6 +924,7 @@
             this._currentEvents = new engine.DisorderedArray();
             this._eventMap = {};
             this._eventPool = [];
+            this._physics = physics;
             this._onContactEnter = onContactEnter;
             this._onContactExit = onContactExit;
             this._onContactStay = onContactStay;
@@ -927,12 +934,12 @@
         }
         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;
@@ -943,7 +950,7 @@
             }
         };
         /**
-       * {@inheritDoc IPhysicsManager.removeCollider }
+       * {@inheritDoc IPhysicsScene.removeCollider }
        */ _proto.removeCollider = function removeCollider(collider) {
             collider._scene = null;
             var colliders = collider._isStaticCollider ? this._staticColliders : this._dynamicColliders;
@@ -955,7 +962,7 @@
             }
         };
         /**
-       * {@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++){
@@ -966,7 +973,7 @@
             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);
@@ -990,16 +997,19 @@
             }
         };
         /**
-       * {@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] = {};
@@ -1041,7 +1051,12 @@
                 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;
@@ -1068,7 +1083,12 @@
                 } 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;
@@ -1159,6 +1179,14 @@
             }
             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
@@ -1196,9 +1224,9 @@
      * @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;
@@ -1207,7 +1235,9 @@
     }(LiteCollider);
 
     var LitePhysics = /*#__PURE__*/ function() {
-        function LitePhysics() {}
+        function LitePhysics() {
+            this._layerCollisionMatrix = [];
+        }
         var _proto = LitePhysics.prototype;
         /**
        * {@inheritDoc IPhysics.initialize }
@@ -1222,17 +1252,17 @@
         /**
        * {@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 }
@@ -1279,11 +1309,48 @@
        */ _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.1";
+    var version = "1.5.0-beta.0";
     console.log("Galacean Engine Physics Lite Version: " + version);
 
     exports.LitePhysics = LitePhysics;