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

package/dist/module.js

@@ -1,4 +1,4 @@
-import { Vector3, Vector4, MathUtil, Quaternion, DisorderedArray } from '@galacean/engine';
+import { Vector3, Vector4, MathUtil, Quaternion, DisorderedArray, MeshColliderShapeCookingFlag, SystemInfo } from '@galacean/engine';
 
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -6,12 +6,6 @@ function _instanceof(left, right) {
     } 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;
@@ -823,44 +817,64 @@ var PhysXPhysicsManager = function PhysXPhysicsManager() {
     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 DisorderedArray();
-        this._eventPool = [];
+        this._activeTriggers = new 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;
@@ -938,9 +952,31 @@ var PhysXPhysicsManager = function PhysXPhysicsManager() {
     /**
    * {@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 }
@@ -1055,6 +1091,11 @@ var PhysXPhysicsManager = function PhysXPhysicsManager() {
         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.
@@ -1086,15 +1127,15 @@ var PhysXPhysicsManager = function PhysXPhysicsManager() {
     /**
    * @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;
             }
@@ -1156,8 +1197,8 @@ var PhysXPhysicsManager = function PhysXPhysicsManager() {
     };
     _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 {
@@ -1166,21 +1207,27 @@ var PhysXPhysicsManager = function PhysXPhysicsManager() {
         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;
 }();
@@ -1198,6 +1245,49 @@ PhysXPhysicsScene._tempShapeIDs = [];
     this.index1 = index1;
     this.index2 = index2;
 };
+/**
+ * Buffered contact point data, copied from PhysX during fetchResults.
+ */ var BufferedContactPoint = function BufferedContactPoint() {
+    this.position = new Vector3();
+    this.normal = new Vector3();
+    this.impulse = new 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.
@@ -1216,9 +1306,9 @@ PhysXPhysicsScene._tempShapeIDs = [];
 /**
  * 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;
 }({});
 
@@ -1450,62 +1540,62 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
     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 }
@@ -1516,103 +1606,107 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
     /**
    * {@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 & MeshColliderShapeCookingFlag.VertexWelding) {
+            preprocessFlags |= 1; // eWELD_VERTICES
+        }
+        if (!(cookingFlags & 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.
@@ -1670,10 +1764,10 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
         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;
     /**
@@ -1687,6 +1781,7 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
         } 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");
@@ -1695,30 +1790,18 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
             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 = 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;
@@ -1743,26 +1826,14 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
         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;
     };
     /**
@@ -1807,8 +1878,9 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
     };
     /**
    * {@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 }
@@ -1845,9 +1917,12 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
         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;
@@ -1861,34 +1936,9 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
     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);
 
-export { MeshPreprocessingFlag, PhysXPhysics, PhysXRuntimeMode, version };
+export { PhysXPhysics, PhysXRuntimeMode, version };
 //# sourceMappingURL=module.js.map