@galacean/engine-physics-physx 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/browser.js

@@ -10,12 +10,6 @@
         } else return left instanceof right;
     }
 
-    function _type_of(obj) {
-        "@swc/helpers - typeof";
-
-        return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-    }
-
     function _set_prototype_of(o, p) {
         _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
             o.__proto__ = p;
@@ -827,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;
@@ -942,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 }
@@ -1059,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.
@@ -1090,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;
                 }
@@ -1160,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 {
@@ -1170,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;
     }();
@@ -1202,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.
@@ -1220,9 +1310,9 @@
     /**
      * PhysX runtime mode.
      */ var PhysXRuntimeMode = /*#__PURE__*/ function(PhysXRuntimeMode) {
-        /** Use webAssembly mode first, if WebAssembly mode is not supported, roll back to JavaScript mode.  */ PhysXRuntimeMode[PhysXRuntimeMode["Auto"] = 0] = "Auto";
+        /** Use WebAssembly SIMD mode first, then WebAssembly as fallback. */ PhysXRuntimeMode[PhysXRuntimeMode["Auto"] = 0] = "Auto";
         /** WebAssembly mode. */ PhysXRuntimeMode[PhysXRuntimeMode["WebAssembly"] = 1] = "WebAssembly";
-        /** JavaScript mode. */ PhysXRuntimeMode[PhysXRuntimeMode["JavaScript"] = 2] = "JavaScript";
+        /** WebAssembly SIMD mode. */ PhysXRuntimeMode[PhysXRuntimeMode["WebAssemblySIMD"] = 2] = "WebAssemblySIMD";
         return PhysXRuntimeMode;
     }({});
 
@@ -1454,62 +1544,62 @@
         return PhysXSpringJoint;
     }(PhysXJoint);
 
-    /** TriangleMesh flag: eDOUBLE_SIDED = 2 (1<<1) */ var DOUBLE_SIDED_FLAG = 2;
-    /** ConvexMesh flag: eTIGHT_BOUNDS = 1 (1<<0) */ var TIGHT_BOUNDS_FLAG = 1;
+    function _assert_this_initialized(self) {
+        if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+
+        return self;
+    }
+
+    function _type_of(obj) {
+        "@swc/helpers - typeof";
+
+        return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+    }
+
+    function _possible_constructor_return(self, call) {
+        if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
+
+        return _assert_this_initialized(self);
+    }
+
     /**
      * Mesh collider shape in PhysX.
      */ var PhysXMeshColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
         _inherits(PhysXMeshColliderShape, PhysXColliderShape);
-        function PhysXMeshColliderShape(physXPhysics, uniqueID, vertices, vertexCount, indices, isConvex, material) {
+        function PhysXMeshColliderShape(physXPhysics, uniqueID, positions, indices, isConvex, material, cookingFlags) {
             var _this;
-            _this = PhysXColliderShape.call(this, physXPhysics) || this, _this._pxMesh = null, _this._doubleSided = false, _this._tightBounds = true;
+            _this = PhysXColliderShape.call(this, physXPhysics) || this, _this._pxMesh = null;
             _this._isConvex = isConvex;
-            _this._vertices = vertices;
-            _this._vertexCount = vertexCount;
-            _this._indices = indices;
-            _this._createMeshAndShape(material, uniqueID);
+            if (!_this._cookMesh(positions, indices, cookingFlags)) {
+                return _possible_constructor_return(_this);
+            }
+            var physX = physXPhysics._physX, physics = physXPhysics._pxPhysics;
+            var _this__worldScale = _this._worldScale, scaleX = _this__worldScale.x, scaleY = _this__worldScale.y, scaleZ = _this__worldScale.z;
+            var shapeFlags = ShapeFlag.SCENE_QUERY_SHAPE | ShapeFlag.SIMULATION_SHAPE;
+            var meshFlag = isConvex ? PhysXMeshColliderShape._tightBoundsFlag : 0;
+            var createShapeFn = isConvex ? physX.createConvexMeshShape : physX.createTriMeshShape;
+            _this._pxShape = createShapeFn(_this._pxMesh, scaleX, scaleY, scaleZ, meshFlag, shapeFlags, material._pxMaterial, physics);
+            _this._id = uniqueID;
+            _this._pxMaterial = material._pxMaterial;
+            _this._pxShape.setUUID(uniqueID);
             _this._setLocalPose();
             return _this;
         }
         var _proto = PhysXMeshColliderShape.prototype;
         /**
        * {@inheritDoc IMeshColliderShape.setMeshData }
-       */ _proto.setMeshData = function setMeshData(vertices, vertexCount, indices, isConvex) {
-            // Save old resources
-            var oldMesh = this._pxMesh;
-            var oldGeometry = this._pxGeometry;
-            // Update data and create new mesh (may throw on failure)
+       */ _proto.setMeshData = function setMeshData(positions, indices, isConvex, cookingFlags) {
+            var _this__pxMesh, _this__pxGeometry;
+            (_this__pxMesh = this._pxMesh) == null ? void 0 : _this__pxMesh.release();
+            (_this__pxGeometry = this._pxGeometry) == null ? void 0 : _this__pxGeometry.delete();
             this._pxMesh = null;
             this._pxGeometry = null;
             this._isConvex = isConvex;
-            this._vertices = vertices;
-            this._vertexCount = vertexCount;
-            this._indices = indices;
-            this._createMesh();
-            this._pxShape.setGeometry(this._pxGeometry);
-            // Release old resources only after successful creation
-            if (oldMesh) {
-                oldMesh.release();
-            }
-            if (oldGeometry) {
-                oldGeometry.delete();
-            }
-        };
-        /**
-       * {@inheritDoc IMeshColliderShape.setDoubleSided }
-       */ _proto.setDoubleSided = function setDoubleSided(value) {
-            this._doubleSided = value;
-            if (!this._isConvex && this._pxMesh) {
-                this._updateGeometry();
-            }
-        };
-        /**
-       * {@inheritDoc IMeshColliderShape.setTightBounds }
-       */ _proto.setTightBounds = function setTightBounds(value) {
-            this._tightBounds = value;
-            if (this._isConvex && this._pxMesh) {
-                this._updateGeometry();
+            if (!this._cookMesh(positions, indices, cookingFlags)) {
+                return false;
             }
+            this._pxShape.setGeometry(this._pxGeometry);
+            return true;
         };
         /**
        * {@inheritDoc IColliderShape.setWorldScale }
@@ -1520,103 +1610,107 @@
         /**
        * {@inheritDoc IColliderShape.destroy }
        */ _proto.destroy = function destroy() {
-            this._releaseMesh();
+            var _this__pxMesh;
+            (_this__pxMesh = this._pxMesh) == null ? void 0 : _this__pxMesh.release();
             PhysXColliderShape.prototype.destroy.call(this);
         };
-        _proto._createMeshAndShape = function _createMeshAndShape(material, uniqueID) {
-            var physX = this._physXPhysics._physX;
-            var physics = this._physXPhysics._pxPhysics;
-            var shapeFlags = ShapeFlag.SCENE_QUERY_SHAPE | ShapeFlag.SIMULATION_SHAPE;
-            this._createMesh();
-            // Create shape with material
+        _proto._cookMesh = function _cookMesh(positions, indices, cookingFlags) {
+            var _this__physXPhysics = this._physXPhysics, physX = _this__physXPhysics._physX, physics = _this__physXPhysics._pxPhysics, cooking = _this__physXPhysics._pxCooking, cookingParams = _this__physXPhysics._pxCookingParams;
+            // Apply per-shape cooking flags
+            var preprocessFlags = 0;
+            if (cookingFlags & engine.MeshColliderShapeCookingFlag.VertexWelding) {
+                preprocessFlags |= 1; // eWELD_VERTICES
+            }
+            if (!(cookingFlags & engine.MeshColliderShapeCookingFlag.Cleaning)) {
+                preprocessFlags |= 2; // eDISABLE_CLEAN_MESH
+            }
+            physX.setCookingMeshPreprocessParams(cookingParams, preprocessFlags);
+            cooking.setParams(cookingParams);
+            var verticesPtr = this._allocatePositions(positions);
             if (this._isConvex) {
-                this._pxShape = physX.createConvexMeshShape(this._pxMesh, this._worldScale.x, this._worldScale.y, this._worldScale.z, this._tightBounds ? TIGHT_BOUNDS_FLAG : 0, shapeFlags, material._pxMaterial, physics);
+                this._pxMesh = cooking.createConvexMesh(verticesPtr, positions.length, physics);
+                physX._free(verticesPtr);
+                if (!this._pxMesh) {
+                    this._logConvexCookingError(physX);
+                    return false;
+                }
             } else {
-                this._pxShape = physX.createTriMeshShape(this._pxMesh, this._worldScale.x, this._worldScale.y, this._worldScale.z, this._doubleSided ? DOUBLE_SIDED_FLAG : 0, shapeFlags, material._pxMaterial, physics);
-            }
-            this._id = uniqueID;
-            this._pxMaterial = material._pxMaterial;
-            this._pxShape.setUUID(uniqueID);
-        };
-        _proto._createMesh = function _createMesh() {
-            var physX = this._physXPhysics._physX;
-            var physics = this._physXPhysics._pxPhysics;
-            var cooking = this._physXPhysics._pxCooking;
-            var verticesPtr = this._allocateVertices();
-            var indicesPtr = 0;
-            try {
-                if (this._isConvex) {
-                    this._pxMesh = cooking.createConvexMesh(verticesPtr, this._vertexCount, physics);
-                    if (!this._pxMesh) {
-                        throw new Error("Failed to create convex mesh. Check if vertex count <= 255 and geometry is valid.");
-                    }
-                    this._pxGeometry = physX.createConvexMeshGeometry(this._pxMesh, this._worldScale.x, this._worldScale.y, this._worldScale.z, this._tightBounds ? TIGHT_BOUNDS_FLAG : 0);
-                } else {
-                    if (!this._indices) {
-                        throw new Error("Triangle mesh requires indices");
-                    }
-                    var _this__allocateIndices = this._allocateIndices(), ptr = _this__allocateIndices.ptr, isU16 = _this__allocateIndices.isU16, triangleCount = _this__allocateIndices.triangleCount;
-                    indicesPtr = ptr;
-                    this._pxMesh = cooking.createTriMesh(verticesPtr, this._vertexCount, indicesPtr, triangleCount, isU16, physics);
-                    if (!this._pxMesh) {
-                        throw new Error("Failed to create triangle mesh. Check if geometry is valid.");
-                    }
-                    this._pxGeometry = physX.createTriMeshGeometry(this._pxMesh, this._worldScale.x, this._worldScale.y, this._worldScale.z, this._doubleSided ? DOUBLE_SIDED_FLAG : 0);
+                if (!indices) {
+                    physX._free(verticesPtr);
+                    console.error("PhysXMeshColliderShape: Triangle mesh requires indices.");
+                    return false;
                 }
-            } finally{
+                var isU32 = _instanceof(indices, Uint32Array);
+                var indicesPtr = this._allocateIndices(indices, isU32);
+                this._pxMesh = cooking.createTriMesh(verticesPtr, positions.length, indicesPtr, indices.length / 3, !isU32, physics);
                 physX._free(verticesPtr);
-                if (indicesPtr) {
-                    physX._free(indicesPtr);
+                physX._free(indicesPtr);
+                if (!this._pxMesh) {
+                    this._logTriMeshCookingError(physX);
+                    return false;
                 }
-                // Release JS memory after copying to WASM
-                this._vertices = null;
-                this._indices = null;
             }
+            var _this__worldScale = this._worldScale, scaleX = _this__worldScale.x, scaleY = _this__worldScale.y, scaleZ = _this__worldScale.z;
+            var meshFlag = this._isConvex ? PhysXMeshColliderShape._tightBoundsFlag : 0;
+            this._pxGeometry = this._isConvex ? physX.createConvexMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag) : physX.createTriMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag);
+            return true;
         };
-        _proto._allocateVertices = function _allocateVertices() {
+        _proto._logConvexCookingError = function _logConvexCookingError(physX) {
+            switch(physX.getLastConvexCookingResult()){
+                case 1:
+                    console.error("PhysXMeshColliderShape: Failed to create convex mesh. Could not find 4 vertices that do not form a zero-area triangle.");
+                    break;
+                case 2:
+                    console.error("PhysXMeshColliderShape: Failed to create convex mesh within the maximum polygons limit (256). Consider simplifying the mesh.");
+                    break;
+                default:
+                    console.error("PhysXMeshColliderShape: Failed to create convex mesh. The input geometry may be invalid.");
+                    break;
+            }
+        };
+        _proto._logTriMeshCookingError = function _logTriMeshCookingError(physX) {
+            switch(physX.getLastTriMeshCookingResult()){
+                case 1:
+                    console.error("PhysXMeshColliderShape: Failed to create triangle mesh. One of the triangles is too large. Consider tessellating large triangles.");
+                    break;
+                default:
+                    console.error("PhysXMeshColliderShape: Failed to create triangle mesh. The input geometry may be invalid.");
+                    break;
+            }
+        };
+        _proto._allocatePositions = function _allocatePositions(positions) {
             var physX = this._physXPhysics._physX;
-            var ptr = physX._malloc(this._vertexCount * 3 * 4);
-            var view = new Float32Array(physX.HEAPF32.buffer, ptr, this._vertexCount * 3);
-            view.set(this._vertices);
+            var length = positions.length;
+            var ptr = physX._malloc(length * 3 * 4);
+            var view = new Float32Array(physX.HEAPF32.buffer, ptr, length * 3);
+            for(var i = 0, offset = 0; i < length; i++, offset += 3){
+                positions[i].copyToArray(view, offset);
+            }
             return ptr;
         };
-        _proto._allocateIndices = function _allocateIndices() {
+        _proto._allocateIndices = function _allocateIndices(indices, isU32) {
             var physX = this._physXPhysics._physX;
-            var indices = this._indices;
-            var isU16 = _instanceof(indices, Uint16Array);
-            var triangleCount = indices.length / 3;
-            var bytesPerIndex = isU16 ? 2 : 4;
-            var ptr = physX._malloc(indices.length * bytesPerIndex);
-            if (isU16) {
-                new Uint16Array(physX.HEAPU16.buffer, ptr, indices.length).set(indices);
-            } else {
-                new Uint32Array(physX.HEAPU32.buffer, ptr, indices.length).set(indices);
-            }
-            return {
-                ptr: ptr,
-                isU16: isU16,
-                triangleCount: triangleCount
-            };
+            // Uint8Array and Uint16Array both write as Uint16 (PhysX minimum index size)
+            var TypedArrayCtor = isU32 ? Uint32Array : Uint16Array;
+            var heap = isU32 ? physX.HEAPU32 : physX.HEAPU16;
+            var ptr = physX._malloc(indices.length * TypedArrayCtor.BYTES_PER_ELEMENT);
+            new TypedArrayCtor(heap.buffer, ptr, indices.length).set(indices);
+            return ptr;
         };
         _proto._updateGeometry = function _updateGeometry() {
+            if (!this._pxMesh) return;
             var physX = this._physXPhysics._physX;
-            var newGeometry = this._isConvex ? physX.createConvexMeshGeometry(this._pxMesh, this._worldScale.x, this._worldScale.y, this._worldScale.z, this._tightBounds ? TIGHT_BOUNDS_FLAG : 0) : physX.createTriMeshGeometry(this._pxMesh, this._worldScale.x, this._worldScale.y, this._worldScale.z, this._doubleSided ? DOUBLE_SIDED_FLAG : 0);
+            var _this__worldScale = this._worldScale, scaleX = _this__worldScale.x, scaleY = _this__worldScale.y, scaleZ = _this__worldScale.z;
+            var meshFlag = this._isConvex ? PhysXMeshColliderShape._tightBoundsFlag : 0;
+            var newGeometry = this._isConvex ? physX.createConvexMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag) : physX.createTriMeshGeometry(this._pxMesh, scaleX, scaleY, scaleZ, meshFlag);
             this._pxGeometry.delete();
             this._pxGeometry = newGeometry;
             this._pxShape.setGeometry(this._pxGeometry);
         };
-        _proto._releaseMesh = function _releaseMesh() {
-            if (this._pxMesh) {
-                this._pxMesh.release();
-                this._pxMesh = null;
-            }
-            if (this._pxGeometry) {
-                this._pxGeometry.delete();
-                this._pxGeometry = null;
-            }
-        };
         return PhysXMeshColliderShape;
     }(PhysXColliderShape);
+    PhysXMeshColliderShape._tightBoundsFlag = 1 // eTIGHT_BOUNDS = 1 (1<<0)
+    ;
 
     /**
      * Plane collider shape in PhysX.
@@ -1674,10 +1768,10 @@
             if (runtimeMode === void 0) runtimeMode = PhysXRuntimeMode.Auto;
             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";
             var _runtimeUrls_wasmModeUrl;
-            this._wasmModeUrl = (_runtimeUrls_wasmModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmModeUrl) != null ? _runtimeUrls_wasmModeUrl : "https://mdn.alipayobjects.com/rms/afts/file/A*8pf0QJKeUXsAAAAASWAAAAgAehQnAQ/physx.release.js";
-            var _runtimeUrls_javaScriptModeUrl;
-            this._downgradeModeUrl = (_runtimeUrls_javaScriptModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.javaScriptModeUrl) != null ? _runtimeUrls_javaScriptModeUrl : "https://mdn.alipayobjects.com/rms/afts/file/A*PLtBTLf8Sm0AAAAAgFAAAAgAehQnAQ/physx.release.downgrade.js";
+            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";
         }
         var _proto = PhysXPhysics.prototype;
         /**
@@ -1691,6 +1785,7 @@
             } else if (this._initializeState === 1) {
                 return this._initializePromise;
             }
+            this._initializeState = 1;
             var runtimeMode = this._runTimeMode;
             var scriptPromise = new Promise(function(resolve, reject) {
                 var script = document.createElement("script");
@@ -1699,30 +1794,18 @@
                 script.onload = resolve;
                 script.onerror = reject;
                 if (runtimeMode == PhysXRuntimeMode.Auto) {
-                    var supported = function() {
-                        try {
-                            if ((typeof WebAssembly === "undefined" ? "undefined" : _type_of(WebAssembly)) === "object" && typeof WebAssembly.instantiate === "function") {
-                                var wasmModule = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
-                                if (_instanceof(wasmModule, WebAssembly.Module)) return _instanceof(new WebAssembly.Instance(wasmModule), WebAssembly.Instance);
-                            }
-                        } catch (e) {}
-                        return false;
-                    }();
-                    if (supported) {
-                        runtimeMode = PhysXRuntimeMode.WebAssembly;
-                    } else {
-                        runtimeMode = PhysXRuntimeMode.JavaScript;
-                    }
+                    runtimeMode = engine.SystemInfo._detectSIMDSupported() ? PhysXRuntimeMode.WebAssemblySIMD : PhysXRuntimeMode.WebAssembly;
                 }
-                if (runtimeMode == PhysXRuntimeMode.JavaScript) {
-                    script.src = _this._downgradeModeUrl;
-                } else if (runtimeMode == PhysXRuntimeMode.WebAssembly) {
+                if (runtimeMode == PhysXRuntimeMode.WebAssemblySIMD) {
+                    script.src = _this._wasmSIMDModeUrl;
+                } else {
                     script.src = _this._wasmModeUrl;
                 }
             });
             var initializePromise = new Promise(function(resolve, reject) {
                 scriptPromise.then(function() {
                     return window.PHYSX().then(function(PHYSX) {
+                        _this._runTimeMode = runtimeMode;
                         _this._init(PHYSX);
                         _this._initializeState = 2;
                         _this._initializePromise = null;
@@ -1747,26 +1830,14 @@
             this._tolerancesScale.delete();
         };
         /**
-       * Set cooking parameters for mesh colliders.
-       * @param params - Cooking parameters
-       */ _proto.setCookingParams = function setCookingParams(params) {
-            var cp = this._pxCookingParams;
-            if (params.meshWeldTolerance !== undefined) {
-                cp.meshWeldTolerance = params.meshWeldTolerance;
-            }
-            if (params.meshPreprocessParams !== undefined) {
-                this._physX.setCookingMeshPreprocessParams(cp, params.meshPreprocessParams);
-            }
-        };
-        /**
        * {@inheritDoc IPhysics.createPhysicsManager }
        */ _proto.createPhysicsManager = function createPhysicsManager() {
             return new PhysXPhysicsManager();
         };
         /**
        * {@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;
         };
         /**
@@ -1811,8 +1882,9 @@
         };
         /**
        * {@inheritDoc IPhysics.createMeshColliderShape }
-       */ _proto.createMeshColliderShape = function createMeshColliderShape(uniqueID, vertices, vertexCount, indices, isConvex, material) {
-            return new PhysXMeshColliderShape(this, uniqueID, vertices, vertexCount, indices, isConvex, material);
+       */ _proto.createMeshColliderShape = function createMeshColliderShape(uniqueID, positions, indices, isConvex, material, cookingFlags) {
+            var shape = new PhysXMeshColliderShape(this, uniqueID, positions, indices, isConvex, material, cookingFlags);
+            return shape._pxShape ? shape : null;
         };
         /**
        * {@inheritDoc IPhysics.createFixedJoint }
@@ -1849,9 +1921,12 @@
             physX.PxInitExtensions(pxPhysics, null);
             // Initialize cooking for mesh colliders
             var cookingParams = new physX.PxCookingParams(tolerancesScale);
-            // Set default cooking params (WeldVertices + small tolerance)
-            physX.setCookingMeshPreprocessParams(cookingParams, 1); // WeldVertices = 1
+            physX.setCookingMeshPreprocessParams(cookingParams, 1); // eWELD_VERTICES
             cookingParams.meshWeldTolerance = 0.001;
+            // BVH34 midphase requires SSE2; SIMD WASM provides SSE2 via WASM SIMD
+            if (this._runTimeMode === PhysXRuntimeMode.WebAssemblySIMD) {
+                physX.setCookingMidphaseType(cookingParams, 1); // eBVH34
+            }
             var pxCooking = physX.PxCreateCooking(version, pxFoundation, cookingParams);
             this._physX = physX;
             this._pxFoundation = pxFoundation;
@@ -1865,36 +1940,10 @@
         return PhysXPhysics;
     }();
 
-    /**
-     * Mesh preprocessing flags for cooking options.
-     * @remarks These flags control how the mesh is preprocessed during cooking.
-     */ var MeshPreprocessingFlag = /*#__PURE__*/ function(MeshPreprocessingFlag) {
-        /**
-       * When set, mesh welding is performed.
-       * Vertices within the meshWeldTolerance distance will be merged.
-       * Clean mesh must be enabled for this to work.
-       */ MeshPreprocessingFlag[MeshPreprocessingFlag["WeldVertices"] = 1] = "WeldVertices";
-        /**
-       * When set, mesh cleaning is disabled.
-       * This makes cooking faster but requires the input mesh to be valid.
-       * When clean mesh is disabled, vertex welding is also disabled.
-       */ MeshPreprocessingFlag[MeshPreprocessingFlag["DisableCleanMesh"] = 2] = "DisableCleanMesh";
-        /**
-       * When set, active edges computation is disabled.
-       * This makes cooking faster but may slow down contact generation.
-       */ MeshPreprocessingFlag[MeshPreprocessingFlag["DisableActiveEdgesPrecompute"] = 4] = "DisableActiveEdgesPrecompute";
-        /**
-       * When set, 32-bit indices will always be used regardless of triangle count.
-       * By default, 16-bit indices are used for meshes with <= 65535 triangles.
-       */ MeshPreprocessingFlag[MeshPreprocessingFlag["Force32BitIndices"] = 8] = "Force32BitIndices";
-        return MeshPreprocessingFlag;
-    }({});
-
     //@ts-ignore
-    var version = "2.0.0-alpha.2";
+    var version = "2.0.0-alpha.20";
     console.log("Galacean Engine Physics PhysX Version: " + version);
 
-    exports.MeshPreprocessingFlag = MeshPreprocessingFlag;
     exports.PhysXPhysics = PhysXPhysics;
     exports.PhysXRuntimeMode = PhysXRuntimeMode;
     exports.version = version;