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

package/dist/module.js

@@ -32,6 +32,14 @@ function _inherits(subClass, superClass) {
     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() {
@@ -118,8 +126,9 @@ function _inherits(subClass, superClass) {
     /**
    * {@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
@@ -673,13 +682,17 @@ PhysXCollider._tempTransform = {
         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:
@@ -1437,6 +1450,170 @@ 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;
+/**
+ * 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) {
@@ -1494,9 +1671,9 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
         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;
     /**
@@ -1556,6 +1733,8 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
     /**
    * Destroy PhysXPhysics.
    */ _proto.destroy = function destroy() {
+        this._pxCooking.release();
+        this._pxCookingParams.delete();
         this._physX.PxCloseExtensions();
         this._pxPhysics.release();
         this._pxFoundation.release();
@@ -1564,6 +1743,18 @@ 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();
@@ -1615,6 +1806,11 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
         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);
@@ -1647,9 +1843,17 @@ PhysXHingeJoint._xAxis = new Vector3(1, 0, 0);
         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;
@@ -1657,9 +1861,34 @@ 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 = "1.6.12";
+var version = "2.0.0-alpha.0";
 console.log("Galacean Engine Physics PhysX Version: " + version);
 
-export { PhysXPhysics, PhysXRuntimeMode, version };
+export { MeshPreprocessingFlag, PhysXPhysics, PhysXRuntimeMode, version };
 //# sourceMappingURL=module.js.map