collision detection between cloth and deformable mesh

[mohammad-jaf]

I want to simulate a scene where a piece of cloth falls on deformable mesh but the cloth passes right through the mesh, is there any way to make them collide?

[jumyungc]

Could you clarify what you meant by 'deformable mesh'? If possible, sharing the steps you took to create the deformable mesh would be greatly beneficial.

[mohammad-jaf]

I mean a triangle mesh that its vertices move over time but the indices remains fixed.
I created a deformable mesh following the steps in this snippet, here is my code:

initialization :

void initPhysics(bool)
{
	gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);

	gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale(), true);

	PxCudaContextManager* cudaContextManager = NULL;
	if (PxGetSuggestedCudaDeviceOrdinal(gFoundation->getErrorCallback()) >= 0)
	{
		PxCudaContextManagerDesc cudaContextManagerDesc;
		cudaContextManager = PxCreateCudaContextManager(*gFoundation, cudaContextManagerDesc, PxGetProfilerCallback());
		if (cudaContextManager && !cudaContextManager->contextIsValid())
		{
			cudaContextManager->release();
			cudaContextManager = NULL;
		}
	}
	if (cudaContextManager == NULL)
	{
		PxGetFoundation().error(PxErrorCode::eINVALID_OPERATION, __FILE__, __LINE__, "Failed to initialize CUDA!\n");
	}

	PxSceneDesc sceneDesc(gPhysics->getTolerancesScale());
	sceneDesc.gravity = PxVec3(0.0f, -9.81f, 0.0f);
	gDispatcher = PxDefaultCpuDispatcherCreate(2);
	sceneDesc.cpuDispatcher = gDispatcher;
	sceneDesc.filterShader = PxDefaultSimulationFilterShader;
	sceneDesc.cudaContextManager = cudaContextManager;
	sceneDesc.staticStructure = PxPruningStructureType::eDYNAMIC_AABB_TREE;
	sceneDesc.flags |= PxSceneFlag::eENABLE_PCM;
	sceneDesc.flags |= PxSceneFlag::eENABLE_GPU_DYNAMICS;
	sceneDesc.broadPhaseType = PxBroadPhaseType::eGPU;
	sceneDesc.solverType = PxSolverType::eTGS;
	gScene = gPhysics->createScene(sceneDesc);

	gMaterial = gPhysics->createMaterial(0.5f, 0.5f, 0.6f);

	const PxReal totalClothMass = 10.0f;

	PxU32 numPointsX = 250;
	PxU32 numPointsZ = 250;
	PxReal particleSpacing = 0.04f;
	initCloth(numPointsX, numPointsZ, PxVec3(-0.5f * numPointsX * particleSpacing, 20.f, -0.5f * numPointsZ * particleSpacing), particleSpacing, totalClothMass);


	//creating the deformable mesh
	PxCookingParams cookingparams(gPhysics->getTolerancesScale());
	cookingparams.buildGPUData = true;
	cookingparams.midphaseDesc.setToDefault(PxMeshMidPhase::eBVH34);
	cookingparams.midphaseDesc.mBVH34Desc.quantized = false;
	cookingparams.meshPreprocessParams = PxMeshPreprocessingFlag::eDISABLE_CLEAN_MESH;

	PxTriangleMeshDesc meshDesc = loadFile("./data/test.obj");
	gPointsCount = meshDesc.points.count;

	PxTriangleMesh* triMesh = PxCreateTriangleMesh(cookingparams, meshDesc, gPhysics->getPhysicsInsertionCallback());
	gMesh = triMesh;
	PxTriangleMeshGeometry geom(triMesh);
	PxRigidDynamic* mesh = gPhysics->createRigidDynamic(PxTransform(PxVec3(0, 12, 0)));
	gActor = mesh;
	PxShape* shape = gPhysics->createShape(geom, *gMaterial);
	shape->setContactOffset(0.02f);
	shape->setRestOffset(0.01f);
	mesh->setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, true);
	mesh->attachShape(*shape);
	
	gScene->addActor(*mesh);
	gScene->addActor(*PxCreatePlane(*gPhysics, PxPlane(0.f, 1.f, 0.f, 0.0f), *gMaterial));
}

loadFile function:

static PxTriangleMeshDesc loadFile(std::string fileAddress)
{
	bool loadout = loader.LoadFile(fileAddress);
	PxTriangleMeshDesc meshDesc;
	
	if (loadout)
	{
		objl::Mesh mesh = loader.LoadedMeshes[0];

		const PxU32 vertsCount = mesh.Vertices.size();
		const PxU32 trianglesCount = mesh.Indices.size()/3;

		PxVec3* verts = new PxVec3[vertsCount];
		Triangle* triangles = new Triangle[trianglesCount];

		for (size_t i = 0; i < vertsCount; i++) 
		{
			verts[i] = PxVec3(mesh.Vertices[i].Position.X * scale, mesh.Vertices[i].Position.Y * scale, mesh.Vertices[i].Position.Z * scale);
		}
		
		for (size_t i = 0; i < mesh.Indices.size(); i += 3)
		{
			Triangle& tri = triangles[i/3];
			tri.ind0 = mesh.Indices[i];
			tri.ind1 = mesh.Indices[i + 1];
			tri.ind2 = mesh.Indices[i + 2];
		}
		
		meshDesc.points.data = verts;
		meshDesc.points.count = vertsCount;
		meshDesc.points.stride = sizeof(PxVec3);
		meshDesc.triangles.count = trianglesCount;
		meshDesc.triangles.data = triangles;
		meshDesc.triangles.stride = sizeof(Triangle);
	}
	return meshDesc;
}

stepping the simulation :

void stepPhysics(bool)
{
	if (gIsRunning)
	{
		const PxReal dt = 1.0f / 60.0f;

		PxVec3* verts = gMesh->getVerticesForModification();
		
		simTime += dt;
		updateVertices(verts);

		gBounds = gMesh->refitBVH();

		gScene->resetFiltering(*gActor);
		gScene->simulate(dt);
		gScene->fetchResults(true);
		gScene->fetchResultsParticleSystem();
	}
}

[jumyungc]

Thank you for sharing the steps. Could you also try bumping up contact offset and rest offset to much larger values?

shape->setContactOffset(xxx);
shape->setRestOffset(xxx);