@galacean/engine-physics-physx 2.0.0-alpha.17 → 2.0.0-alpha.19

package/dist/browser.js

@@ -821,44 +821,64 @@
         return PhysXPhysicsMaterial;
     }();
 
+    function _defineProperties(target, props) {
+        for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+
+            if ("value" in descriptor) descriptor.writable = true;
+
+            Object.defineProperty(target, descriptor.key, descriptor);
+        }
+    }
+    function _create_class(Constructor, protoProps, staticProps) {
+        if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) _defineProperties(Constructor, staticProps);
+
+        return Constructor;
+    }
+
     /**
      * A manager is a collection of colliders and constraints which can interact.
      */ var PhysXPhysicsScene = /*#__PURE__*/ function() {
-        function PhysXPhysicsScene(physXPhysics, physicsManager, onContactEnter, onContactExit, onContactStay, onTriggerEnter, onTriggerExit, onTriggerStay) {
+        function PhysXPhysicsScene(physXPhysics, physicsManager) {
             var _this = this;
             /** @internal */ this._pxControllerManager = null;
             // Cached geometry objects for reuse
             this._boxGeometry = null;
             this._sphereGeometry = null;
             this._capsuleGeometry = null;
-            this._currentEvents = new engine.DisorderedArray();
-            this._eventPool = [];
+            this._activeTriggers = new engine.DisorderedArray();
+            this._contactEvents = [];
+            this._contactEventCount = 0;
+            this._triggerEvents = [];
+            this._physicsEvents = {
+                contactEvents: [],
+                contactEventCount: 0,
+                triggerEvents: []
+            };
+            this._triggerEventPool = [];
             this._physXPhysics = physXPhysics;
             this._physXManager = physicsManager;
             var physX = physXPhysics._physX;
             this._pxRaycastHit = new physX.PxRaycastHit();
             this._pxFilterData = new physX.PxQueryFilterData();
             this._pxFilterData.flags = new physX.PxQueryFlags(1 | 2 | 4);
-            this._onContactEnter = onContactEnter;
-            this._onContactExit = onContactExit;
-            this._onContactStay = onContactStay;
-            this._onTriggerEnter = onTriggerEnter;
-            this._onTriggerExit = onTriggerExit;
-            this._onTriggerStay = onTriggerStay;
             var triggerCallback = {
                 onContactBegin: function(collision) {
-                    _this._onContactEnter(collision);
+                    _this._bufferContactEvent(collision, 0);
                 },
                 onContactEnd: function(collision) {
-                    _this._onContactExit(collision);
+                    _this._bufferContactEvent(collision, 2);
                 },
                 onContactPersist: function(collision) {
-                    _this._onContactStay(collision);
+                    _this._bufferContactEvent(collision, 1);
                 },
                 onTriggerBegin: function(index1, index2) {
                     var event = index1 < index2 ? _this._getTrigger(index1, index2) : _this._getTrigger(index2, index1);
                     event.state = 0;
-                    _this._currentEvents.add(event);
+                    _this._activeTriggers.add(event);
                 },
                 onTriggerEnd: function(index1, index2) {
                     var event;
@@ -936,9 +956,31 @@
         /**
        * {@inheritDoc IPhysicsScene.update }
        */ _proto.update = function update(elapsedTime) {
+            this._contactEventCount = 0;
             this._simulate(elapsedTime);
             this._fetchResults();
-            this._fireEvent();
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.updateEvents }
+       */ _proto.updateEvents = function updateEvents() {
+            var physicsEvents = this._physicsEvents;
+            // Collect trigger events: snapshot state for dispatch, then advance
+            var _this = this, triggerEventPool = _this._triggerEventPool, activeTriggers = _this._activeTriggers, triggerEvents = _this._triggerEvents;
+            triggerEvents.length = 0;
+            activeTriggers.forEach(function(event, i) {
+                event.dispatchState = event.state;
+                triggerEvents.push(event);
+                if (event.state === 0) {
+                    event.state = 1;
+                } else if (event.state === 2) {
+                    activeTriggers.deleteByIndex(i);
+                    triggerEventPool.push(event);
+                }
+            });
+            physicsEvents.contactEvents = this._contactEvents;
+            physicsEvents.contactEventCount = this._contactEventCount;
+            physicsEvents.triggerEvents = triggerEvents;
+            return physicsEvents;
         };
         /**
        * {@inheritDoc IPhysicsScene.raycast }
@@ -1053,6 +1095,11 @@
             return this._overlapMultiple(this._capsuleGeometry, pose, onOverlap);
         };
         /**
+       * {@inheritDoc IPhysicsScene.gc }
+       */ _proto.gc = function gc() {
+            this._contactEvents.length = this._contactEventCount;
+        };
+        /**
        * {@inheritDoc IPhysicsScene.destroy }
        */ _proto.destroy = function destroy() {
             var _this__boxGeometry, _this__sphereGeometry, _this__capsuleGeometry, // Need to release the controller manager before release the scene.
@@ -1084,15 +1131,15 @@
         /**
        * @internal
        */ _proto._removeColliderShape = function _removeColliderShape(id) {
-            var _this = this, eventPool = _this._eventPool, currentEvents = _this._currentEvents;
+            var _this = this, triggerEventPool = _this._triggerEventPool, activeTriggers = _this._activeTriggers;
             var _this__physXManager = this._physXManager, eventMap = _this__physXManager._eventMap;
-            currentEvents.forEach(function(event, i) {
+            activeTriggers.forEach(function(event, i) {
                 if (event.index1 == id) {
-                    currentEvents.deleteByIndex(i);
-                    eventPool.push(event);
+                    activeTriggers.deleteByIndex(i);
+                    triggerEventPool.push(event);
                 } else if (event.index2 == id) {
-                    currentEvents.deleteByIndex(i);
-                    eventPool.push(event);
+                    activeTriggers.deleteByIndex(i);
+                    triggerEventPool.push(event);
                     // If the shape is big index, should clear from the small index shape subMap
                     eventMap[event.index1][id] = undefined;
                 }
@@ -1154,8 +1201,8 @@
         };
         _proto._getTrigger = function _getTrigger(index1, index2) {
             var event;
-            if (this._eventPool.length) {
-                event = this._eventPool.pop();
+            if (this._triggerEventPool.length) {
+                event = this._triggerEventPool.pop();
                 event.index1 = index1;
                 event.index2 = index2;
             } else {
@@ -1164,21 +1211,27 @@
             this._physXManager._eventMap[index1][index2] = event;
             return event;
         };
-        _proto._fireEvent = function _fireEvent() {
-            var _this = this;
-            var _this1 = this, eventPool = _this1._eventPool, currentEvents = _this1._currentEvents;
-            currentEvents.forEach(function(event, i) {
-                if (event.state == 0) {
-                    _this._onTriggerEnter(event.index1, event.index2);
-                    event.state = 1;
-                } else if (event.state == 1) {
-                    _this._onTriggerStay(event.index1, event.index2);
-                } else if (event.state == 2) {
-                    currentEvents.deleteByIndex(i);
-                    _this._onTriggerExit(event.index1, event.index2);
-                    eventPool.push(event);
-                }
-            });
+        _proto._bufferContactEvent = function _bufferContactEvent(collision, state) {
+            var _this__contactEvents, _index;
+            var index = this._contactEventCount++;
+            var event = (_this__contactEvents = this._contactEvents)[_index = index] || (_this__contactEvents[_index] = new ContactEvent());
+            event.shape0Id = collision.shape0Id;
+            event.shape1Id = collision.shape1Id;
+            event.state = state;
+            // Copy contact points from PhysX (the native data is only valid during fetchResults)
+            var nativeContacts = collision.getContacts();
+            var count = nativeContacts.size();
+            var bufferedContacts = event._bufferedContacts;
+            bufferedContacts.contactCount = count;
+            for(var i = 0; i < count; i++){
+                var _bufferedContacts_contacts, _i;
+                var src = nativeContacts.get(i);
+                var dst = (_bufferedContacts_contacts = bufferedContacts.contacts)[_i = i] || (_bufferedContacts_contacts[_i] = new BufferedContactPoint());
+                dst.position.copyFrom(src.position);
+                dst.normal.copyFrom(src.normal);
+                dst.impulse.copyFrom(src.impulse);
+                dst.separation = src.separation;
+            }
         };
         return PhysXPhysicsScene;
     }();
@@ -1196,6 +1249,49 @@
         this.index1 = index1;
         this.index2 = index2;
     };
+    /**
+     * Buffered contact point data, copied from PhysX during fetchResults.
+     */ var BufferedContactPoint = function BufferedContactPoint() {
+        this.position = new engine.Vector3();
+        this.normal = new engine.Vector3();
+        this.impulse = new engine.Vector3();
+        this.separation = 0;
+    };
+    /**
+     * Contact event buffered from PhysX fetchResults callback.
+     * Implements ICollision so it can be passed directly to the core layer.
+     */ var BufferedContacts = /*#__PURE__*/ function() {
+        function BufferedContacts() {
+            this.contactCount = 0;
+            this.contacts = [];
+        }
+        var _proto = BufferedContacts.prototype;
+        _proto.size = function size() {
+            return this.contactCount;
+        };
+        _proto.get = function get(index) {
+            return this.contacts[index];
+        };
+        return BufferedContacts;
+    }();
+    var ContactEvent = /*#__PURE__*/ function() {
+        function ContactEvent() {
+            /** @internal */ this._bufferedContacts = new BufferedContacts();
+        }
+        var _proto = ContactEvent.prototype;
+        _proto.getContacts = function getContacts() {
+            return this._bufferedContacts;
+        };
+        _create_class(ContactEvent, [
+            {
+                key: "contactCount",
+                get: function get() {
+                    return this._bufferedContacts.contactCount;
+                }
+            }
+        ]);
+        return ContactEvent;
+    }();
 
     /**
      * A static collider component that will not move.
@@ -1740,8 +1836,8 @@
         };
         /**
        * {@inheritDoc IPhysics.createPhysicsScene }
-       */ _proto.createPhysicsScene = function createPhysicsScene(physicsManager, onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay) {
-            var scene = new PhysXPhysicsScene(this, physicsManager, onContactBegin, onContactEnd, onContactStay, onTriggerBegin, onTriggerEnd, onTriggerStay);
+       */ _proto.createPhysicsScene = function createPhysicsScene(physicsManager) {
+            var scene = new PhysXPhysicsScene(this, physicsManager);
             return scene;
         };
         /**
@@ -1845,7 +1941,7 @@
     }();
 
     //@ts-ignore
-    var version = "2.0.0-alpha.17";
+    var version = "2.0.0-alpha.19";
     console.log("Galacean Engine Physics PhysX Version: " + version);
 
     exports.PhysXPhysics = PhysXPhysics;