@galacean/engine-physics-physx 1.6.13 → 2.0.0-alpha.0

package/dist/browser.js

@@ -36,6 +36,14 @@
         if (superClass) _set_prototype_of(subClass, superClass);
     }
 
+    /**
+     * Flags which affect the behavior of Shapes.
+     */ var ShapeFlag = /*#__PURE__*/ function(ShapeFlag) {
+        /** The shape will partake in collision in the physical simulation. */ ShapeFlag[ShapeFlag["SIMULATION_SHAPE"] = 1] = "SIMULATION_SHAPE";
+        /** The shape will partake in scene queries (ray casts, overlap tests, sweeps, ...). */ ShapeFlag[ShapeFlag["SCENE_QUERY_SHAPE"] = 2] = "SCENE_QUERY_SHAPE";
+        /** The shape is a trigger which can send reports whenever other shapes enter/leave its volume. */ ShapeFlag[ShapeFlag["TRIGGER_SHAPE"] = 4] = "TRIGGER_SHAPE";
+        return ShapeFlag;
+    }({});
     /**
      * Abstract class for collider shapes.
      */ var PhysXColliderShape = /*#__PURE__*/ function() {
@@ -122,8 +130,9 @@
         /**
        * {@inheritDoc IColliderShape.destroy }
        */ _proto.destroy = function destroy() {
+            var _this__pxGeometry;
             this._pxShape.release();
-            this._pxGeometry.delete();
+            (_this__pxGeometry = this._pxGeometry) == null ? void 0 : _this__pxGeometry.delete();
         };
         /**
        *  @internal
@@ -677,13 +686,17 @@
             switch(value){
                 case 1:
                     this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
                     break;
                 case 2:
-                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
                     this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, true);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, false);
                     break;
                 case 3:
                     this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, false);
+                    this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD_FRICTION, false);
                     this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_SPECULATIVE_CCD, true);
                     break;
                 case 0:
@@ -1441,6 +1454,170 @@
         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;
+    /**
+     * Mesh collider shape in PhysX.
+     */ var PhysXMeshColliderShape = /*#__PURE__*/ function(PhysXColliderShape) {
+        _inherits(PhysXMeshColliderShape, PhysXColliderShape);
+        function PhysXMeshColliderShape(physXPhysics, uniqueID, vertices, vertexCount, indices, isConvex, material) {
+            var _this;
+            _this = PhysXColliderShape.call(this, physXPhysics) || this, _this._pxMesh = null, _this._doubleSided = false, _this._tightBounds = true;
+            _this._isConvex = isConvex;
+            _this._vertices = vertices;
+            _this._vertexCount = vertexCount;
+            _this._indices = indices;
+            _this._createMeshAndShape(material, 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)
+            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();
+            }
+        };
+        /**
+       * {@inheritDoc IColliderShape.setWorldScale }
+       */ _proto.setWorldScale = function setWorldScale(scale) {
+            PhysXColliderShape.prototype.setWorldScale.call(this, scale);
+            this._updateGeometry();
+        };
+        /**
+       * {@inheritDoc IColliderShape.destroy }
+       */ _proto.destroy = function destroy() {
+            this._releaseMesh();
+            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
+            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);
+            } 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);
+                }
+            } finally{
+                physX._free(verticesPtr);
+                if (indicesPtr) {
+                    physX._free(indicesPtr);
+                }
+                // Release JS memory after copying to WASM
+                this._vertices = null;
+                this._indices = null;
+            }
+        };
+        _proto._allocateVertices = function _allocateVertices() {
+            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);
+            return ptr;
+        };
+        _proto._allocateIndices = function _allocateIndices() {
+            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
+            };
+        };
+        _proto._updateGeometry = function _updateGeometry() {
+            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);
+            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);
+
     /**
      * Plane collider shape in PhysX.
      */ var PhysXPlaneColliderShape = /*#__PURE__*/ function(PhysXColliderShape1) {
@@ -1498,9 +1675,9 @@
             this._initializeState = 0;
             this._runTimeMode = runtimeMode;
             var _runtimeUrls_wasmModeUrl;
-            this._wasmModeUrl = (_runtimeUrls_wasmModeUrl = runtimeUrls == null ? void 0 : runtimeUrls.wasmModeUrl) != null ? _runtimeUrls_wasmModeUrl : "https://mdn.alipayobjects.com/rms/afts/file/A*m04iQojeKRgAAAAASWAAAAgAehQnAQ/physx.release.js";
+            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*13gEToqpJWcAAAAAgEAAAAgAehQnAQ/physx.release.downgrade.js";
+            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";
         }
         var _proto = PhysXPhysics.prototype;
         /**
@@ -1560,6 +1737,8 @@
         /**
        * Destroy PhysXPhysics.
        */ _proto.destroy = function destroy() {
+            this._pxCooking.release();
+            this._pxCookingParams.delete();
             this._physX.PxCloseExtensions();
             this._pxPhysics.release();
             this._pxFoundation.release();
@@ -1568,6 +1747,18 @@
             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();
@@ -1619,6 +1810,11 @@
             return new PhysXCapsuleColliderShape(this, uniqueID, radius, height, material);
         };
         /**
+       * {@inheritDoc IPhysics.createMeshColliderShape }
+       */ _proto.createMeshColliderShape = function createMeshColliderShape(uniqueID, vertices, vertexCount, indices, isConvex, material) {
+            return new PhysXMeshColliderShape(this, uniqueID, vertices, vertexCount, indices, isConvex, material);
+        };
+        /**
        * {@inheritDoc IPhysics.createFixedJoint }
        */ _proto.createFixedJoint = function createFixedJoint(collider) {
             return new PhysXFixedJoint(this, collider);
@@ -1651,9 +1847,17 @@
             var tolerancesScale = new physX.PxTolerancesScale();
             var pxPhysics = physX.PxCreatePhysics(version, pxFoundation, tolerancesScale, false, null);
             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
+            cookingParams.meshWeldTolerance = 0.001;
+            var pxCooking = physX.PxCreateCooking(version, pxFoundation, cookingParams);
             this._physX = physX;
             this._pxFoundation = pxFoundation;
             this._pxPhysics = pxPhysics;
+            this._pxCooking = pxCooking;
+            this._pxCookingParams = cookingParams;
             this._defaultErrorCallback = defaultErrorCallback;
             this._allocator = allocator;
             this._tolerancesScale = tolerancesScale;
@@ -1661,10 +1865,36 @@
         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 = "1.6.13";
+    var version = "2.0.0-alpha.0";
     console.log("Galacean Engine Physics PhysX Version: " + version);
 
+    exports.MeshPreprocessingFlag = MeshPreprocessingFlag;
     exports.PhysXPhysics = PhysXPhysics;
     exports.PhysXRuntimeMode = PhysXRuntimeMode;
     exports.version = version;