@galacean/engine-physics-physx 2.0.0-alpha.5 → 2.0.0-alpha.50

package/dist/browser.js

@@ -297,7 +297,8 @@
         /**
        * {@inheritDoc ICapsuleColliderShape.setUpAxis }
        */ _proto.setUpAxis = function setUpAxis(upAxis) {
-            var _this = this, rotation = _this._rotation, axis = _this._axis, physXRotation = _this._physXRotation;
+            var _this = this, rotation = _this._rotation, physXRotation = _this._physXRotation;
+            var axis = this._axis;
             this._upAxis = upAxis;
             switch(this._upAxis){
                 case 0:
@@ -525,7 +526,9 @@
        * {@inheritDoc ICollider.addShape }
        */ _proto.addShape = function addShape(shape) {
             var _this__scene;
-            this._pxActor.attachShape(shape._pxShape);
+            if (!this._pxActor.attachShape(shape._pxShape)) {
+                throw new Error("PhysXCollider: failed to attach shape to the native actor.");
+            }
             this._shapes.push(shape);
             (_this__scene = this._scene) == null ? void 0 : _this__scene._addColliderShape(shape._id);
         };
@@ -674,44 +677,27 @@
             this._pxActor.setSolverIterationCounts(value, 1);
         };
         /**
-       * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
-       */ _proto.setCollisionDetectionMode = function setCollisionDetectionMode(value) {
-            var physX = this._physXPhysics._physX;
-            switch(value){
-                case 1:
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
-                    break;
-                case 2:
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
-                    break;
-                case 3:
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, false);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
-                    break;
-                case 0:
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, false);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
-                    break;
-            }
-        };
-        /**
        * {@inheritDoc IDynamicCollider.setUseGravity }
        */ _proto.setUseGravity = function setUseGravity(value) {
             this._pxActor.setActorFlag(this._physXPhysics._physX.PxActorFlag.eDISABLE_GRAVITY, !value);
         };
         /**
-       * {@inheritDoc IDynamicCollider.setIsKinematic }
-       */ _proto.setIsKinematic = function setIsKinematic(value) {
-            if (value) {
-                this._pxActor.setRigidBodyFlag(this._physXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
-            } else {
-                this._pxActor.setRigidBodyFlag(this._physXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, false);
+       * {@inheritDoc IDynamicCollider.setMotionState }
+       */ _proto.setMotionState = function setMotionState(isKinematic, collisionDetectionMode) {
+            var PxRigidBodyFlag = this._physXPhysics._physX.PxRigidBodyFlag;
+            // PhysX 4.1 does not support sweep-based CCD on kinematic bodies
+            var useSpeculativeCCD = collisionDetectionMode === 3 || isKinematic && collisionDetectionMode !== 0;
+            this._pxActor.setRigidBodyFlag(PxRigidBodyFlag.eENABLE_CCD, false);
+            this._pxActor.setRigidBodyFlag(PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
+            this._pxActor.setRigidBodyFlag(PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
+            this._pxActor.setRigidBodyFlag(PxRigidBodyFlag.eKINEMATIC, isKinematic);
+            if (useSpeculativeCCD) {
+                this._pxActor.setRigidBodyFlag(PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
+            } else if (collisionDetectionMode !== 0) {
+                this._pxActor.setRigidBodyFlag(PxRigidBodyFlag.eENABLE_CCD, true);
+                if (collisionDetectionMode === 2) {
+                    this._pxActor.setRigidBodyFlag(PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
+                }
             }
         };
         /**
@@ -722,20 +708,17 @@
         /**
        * {@inheritDoc IDynamicCollider.addForce }
        */ _proto.addForce = function addForce(force) {
-            this._pxActor.addForce({
-                x: force.x,
-                y: force.y,
-                z: force.z
-            });
+            this._pxActor.addForce(force);
+        };
+        /**
+       * {@inheritDoc IDynamicCollider.addForceAtPosition }
+       */ _proto.addForceAtPosition = function addForceAtPosition(force, position) {
+            this._pxActor.addForceAtPos(force, position);
         };
         /**
        * {@inheritDoc IDynamicCollider.addTorque }
        */ _proto.addTorque = function addTorque(torque) {
-            this._pxActor.addTorque({
-                x: torque.x,
-                y: torque.y,
-                z: torque.z
-            });
+            this._pxActor.addTorque(torque);
         };
         /**
        * {@inheritDoc IDynamicCollider.move }
@@ -821,44 +804,68 @@
         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._currentOnQuery = null;
+            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._pxSweepHit = new physX.PxSweepHit();
             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;
+            this._pxRaycastSweepFilterData = new physX.PxQueryFilterData();
+            this._pxRaycastSweepFilterData.flags = new physX.PxQueryFlags(1 | 2 | 4 | 8);
             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;
@@ -879,6 +886,16 @@
             var sceneDesc = physX.getDefaultSceneDesc(pxPhysics.getTolerancesScale(), 0, this._physXSimulationCallbackInstance);
             this._pxScene = pxPhysics.createScene(sceneDesc);
             sceneDesc.delete();
+            this._pxQueryCallback = physX.PxQueryFilterCallback.implement({
+                preFilter: function(_filterData, index, _actor) {
+                    return _this._currentOnQuery(index) ? 2 : 0;
+                },
+                // distance <= 0 means initial overlap — drop the hit so subsequent hits can be considered.
+                // Only invoked when the query's filter data includes POST_FILTER (raycast/sweep, not overlap).
+                postFilter: function(_filterData, distance) {
+                    return distance <= 0 ? 0 : 2;
+                }
+            });
         }
         var _proto = PhysXPhysicsScene.prototype;
         /**
@@ -936,27 +953,53 @@
         /**
        * {@inheritDoc IPhysicsScene.update }
        */ _proto.update = function update(elapsedTime) {
+            this._contactEventCount = 0;
             this._simulate(elapsedTime);
             this._fetchResults();
-            this._fireEvent();
+        };
+        /**
+       * {@inheritDoc IPhysicsScene.setContactEventEnabled }
+       */ _proto.setContactEventEnabled = function setContactEventEnabled(enabled) {
+            this._physXPhysics._physX.setContactEventEnabled(this._physXSimulationCallbackInstance, enabled);
+            if (!enabled) {
+                this._contactEventCount = 0;
+            }
+        };
+        /**
+       * {@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 }
-       */ _proto.raycast = function raycast(ray, distance, onRaycast, hit) {
+       */ _proto.raycast = function raycast(origin, direction, distance, onRaycast, hit) {
             var _this = this, pxHitResult = _this._pxRaycastHit;
             distance = Math.min(distance, 3.4e38); // float32 max value limit in physX raycast.
-            var raycastCallback = {
-                preFilter: function(filterData, index, actor) {
-                    if (onRaycast(index)) {
-                        return 2; // eBLOCK
-                    } else {
-                        return 0; // eNONE
-                    }
-                }
-            };
-            var pxRaycastCallback = this._physXPhysics._physX.PxQueryFilterCallback.implement(raycastCallback);
-            var result = this._pxScene.raycastSingle(ray.origin, ray.direction, distance, pxHitResult, this._pxFilterData, pxRaycastCallback);
-            pxRaycastCallback.delete();
+            var prevOnQuery = this._currentOnQuery;
+            this._currentOnQuery = onRaycast;
+            var result;
+            try {
+                result = this._pxScene.raycastSingle(origin, direction, distance, pxHitResult, this._pxRaycastSweepFilterData, this._pxQueryCallback);
+            } finally{
+                this._currentOnQuery = prevOnQuery;
+            }
             if (result && hit != undefined) {
                 var position = PhysXPhysicsScene._tempPosition, normal = PhysXPhysicsScene._tempNormal;
                 var pxPosition = pxHitResult.position, pxNormal = pxHitResult.normal;
@@ -1053,6 +1096,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.
@@ -1062,8 +1110,12 @@
             (_this__capsuleGeometry = this._capsuleGeometry) == null ? void 0 : _this__capsuleGeometry.delete();
             this._physXSimulationCallbackInstance.delete();
             this._pxRaycastHit.delete();
+            this._pxSweepHit.delete();
             this._pxFilterData.flags.delete();
             this._pxFilterData.delete();
+            this._pxRaycastSweepFilterData.flags.delete();
+            this._pxRaycastSweepFilterData.delete();
+            this._pxQueryCallback.delete();
             (_this__pxControllerManager = this._pxControllerManager) == null ? void 0 : _this__pxControllerManager.release();
             this._pxScene.release();
         };
@@ -1084,15 +1136,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;
                 }
@@ -1100,19 +1152,16 @@
             delete eventMap[id];
         };
         _proto._sweepSingle = function _sweepSingle(geometry, pose, direction, distance, onSweep, outHitResult) {
+            var _this = this, pxSweepHit = _this._pxSweepHit;
             distance = Math.min(distance, 3.4e38); // float32 max value limit in physx sweep
-            var sweepCallback = {
-                preFilter: function(filterData, index, actor) {
-                    if (onSweep(index)) {
-                        return 2; // eBLOCK
-                    } else {
-                        return 0; // eNONE
-                    }
-                }
-            };
-            var pxSweepCallback = this._physXPhysics._physX.PxQueryFilterCallback.implement(sweepCallback);
-            var pxSweepHit = new this._physXPhysics._physX.PxSweepHit();
-            var result = this._pxScene.sweepSingle(geometry, pose, direction, distance, pxSweepHit, this._pxFilterData, pxSweepCallback);
+            var prevOnQuery = this._currentOnQuery;
+            this._currentOnQuery = onSweep;
+            var result;
+            try {
+                result = this._pxScene.sweepSingle(geometry, pose, direction, distance, pxSweepHit, this._pxRaycastSweepFilterData, this._pxQueryCallback);
+            } finally{
+                this._currentOnQuery = prevOnQuery;
+            }
             if (result && outHitResult != undefined) {
                 var position = PhysXPhysicsScene._tempPosition, normal = PhysXPhysicsScene._tempNormal;
                 var pxPosition = pxSweepHit.position, pxNormal = pxSweepHit.normal;
@@ -1120,19 +1169,18 @@
                 normal.set(pxNormal.x, pxNormal.y, pxNormal.z);
                 outHitResult(pxSweepHit.getShape().getUUID(), pxSweepHit.distance, position, normal);
             }
-            pxSweepCallback.delete();
-            pxSweepHit.delete();
             return result;
         };
         _proto._overlapMultiple = function _overlapMultiple(geometry, pose, onOverlap) {
-            var overlapCallback = {
-                preFilter: function(filterData, index, actor) {
-                    return onOverlap(index) ? 2 : 0;
-                }
-            };
-            var pxOverlapCallback = this._physXPhysics._physX.PxQueryFilterCallback.implement(overlapCallback);
+            var prevOnQuery = this._currentOnQuery;
+            this._currentOnQuery = onOverlap;
             var maxHits = 256;
-            var hits = this._pxScene.overlapMultiple(geometry, pose, maxHits, this._pxFilterData, pxOverlapCallback);
+            var hits;
+            try {
+                hits = this._pxScene.overlapMultiple(geometry, pose, maxHits, this._pxFilterData, this._pxQueryCallback);
+            } finally{
+                this._currentOnQuery = prevOnQuery;
+            }
             var result = PhysXPhysicsScene._tempShapeIDs;
             result.length = 0;
             if (hits) {
@@ -1141,7 +1189,6 @@
                     result.push(hits.get(i).getShape().getUUID());
                 }
             }
-            pxOverlapCallback.delete();
             hits == null ? void 0 : hits.delete();
             return result;
         };
@@ -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.
@@ -1673,9 +1769,9 @@
             this._initializeState = 0;
             this._runTimeMode = runtimeMode;
             var _runtimeUrls_wasmSIMDModeUrl;
-            this._wasmSIMDModeUrl = (_runtimeUrls_wasmSIMDModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmSIMDModeUrl) != null ? _runtimeUrls_wasmSIMDModeUrl : "https://mdn.alipayobjects.com/rms/afts/file/A*FHYHS4_ZL5UAAAAAQ4AAAAgAehQnAQ/physx.release.simd.js";
+            this._wasmSIMDModeUrl = (_runtimeUrls_wasmSIMDModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmSIMDModeUrl) != null ? _runtimeUrls_wasmSIMDModeUrl : "https://mdn.alipayobjects.com/rms/uri/file/as/apwallet/1787063975729/suyi/physx.release.simd.js";
             var _runtimeUrls_wasmModeUrl;
-            this._wasmModeUrl = (_runtimeUrls_wasmModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmModeUrl) != null ? _runtimeUrls_wasmModeUrl : "https://mdn.alipayobjects.com/rms/afts/file/A*2fv0RLMK1d0AAAAAQ4AAAAgAehQnAQ/physx.release.js";
+            this._wasmModeUrl = (_runtimeUrls_wasmModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmModeUrl) != null ? _runtimeUrls_wasmModeUrl : "https://mdn.alipayobjects.com/rms/uri/file/as/apwallet/1787063975729/suyi/physx.release.js";
         }
         var _proto = PhysXPhysics.prototype;
         /**
@@ -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.5";
+    var version = "2.0.0-alpha.50";
     console.log("Galacean Engine Physics PhysX Version: " + version);
 
     exports.PhysXPhysics = PhysXPhysics;