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

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;
@@ -1220,9 +1214,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 +1448,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 +1514,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 +1672,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 +1689,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 +1698,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,18 +1734,6 @@
             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();
@@ -1811,8 +1786,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 +1825,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 +1844,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.1";
+    var version = "2.0.0-alpha.5";
     console.log("Galacean Engine Physics PhysX Version: " + version);
 
-    exports.MeshPreprocessingFlag = MeshPreprocessingFlag;
     exports.PhysXPhysics = PhysXPhysics;
     exports.PhysXRuntimeMode = PhysXRuntimeMode;
     exports.version = version;