unexpected rotation motion in contact modification callback

[yananZZZZ]

Hi,
I was creating two conveyor surface which has the same velocity but in opposite direction. I am expecting the object will moving only along the direction I specified in the contact modification. however, the box tilt in the tangent direction as well. I think this is due to the friction force.
I am using default patch mode for friction and I want to eliminate the effect object tilt as it pass to different surface. How should I do? I notice that if I make the surface speed slower. It helps. I also tried change the friction related parameter, collision material, etc. I hope to get some input for others.
Also, I found some unexpected bumping after the box passing through one surface to another. As my collisions are are the same level and there should not be any height different. Is this also cause by contact modification?

Thanks

Version

PhysX v5.3.0

Code

I also attached my snippet. it modified from SnippetContactReport

#include <vector>
#include "PxPhysicsAPI.h"
#include "../snippetutils/SnippetUtils.h"
#include "../snippetcommon/SnippetPrint.h"
#include "../snippetcommon/SnippetPVD.h"
#include "extensions/PxD6JointCreate.h"

using namespace physx;

static PxDefaultAllocator		gAllocator;
static PxDefaultErrorCallback	gErrorCallback;
static PxFoundation*			gFoundation = NULL;
static PxPhysics*				gPhysics	= NULL;
static PxDefaultCpuDispatcher*	gDispatcher = NULL;
static PxScene*					gScene		= NULL;
static PxMaterial*				gMaterial	= NULL;
static PxMaterial*				gMaterial1	= NULL;
static PxPvd*					gPvd        = NULL;

std::vector<PxVec3> gContactPositions;
std::vector<PxVec3> gContactImpulses;

static PxFilterFlags contactReportFilterShader(	PxFilterObjectAttributes attributes0, PxFilterData filterData0, 
												PxFilterObjectAttributes attributes1, PxFilterData filterData1,
												PxPairFlags& pairFlags, const void* constantBlock, PxU32 constantBlockSize)
{
	PX_UNUSED(attributes0);
	PX_UNUSED(attributes1);
	PX_UNUSED(filterData0);
	PX_UNUSED(filterData1);
	PX_UNUSED(constantBlockSize);
	PX_UNUSED(constantBlock);

	// all initial and persisting reports for everything, with per-point data
	pairFlags = PxPairFlag::eSOLVE_CONTACT | PxPairFlag::eDETECT_DISCRETE_CONTACT
			  |	PxPairFlag::eNOTIFY_TOUCH_FOUND 
			  | PxPairFlag::eNOTIFY_TOUCH_PERSISTS
			  | PxPairFlag::eNOTIFY_CONTACT_POINTS
              | PxPairFlag::eMODIFY_CONTACTS;;
	return PxFilterFlag::eDEFAULT;
}

class ContactReportCallback: public PxSimulationEventCallback
{
	void onConstraintBreak(PxConstraintInfo* constraints, PxU32 count)	{ PX_UNUSED(constraints); PX_UNUSED(count); }
	void onWake(PxActor** actors, PxU32 count)							{ PX_UNUSED(actors); PX_UNUSED(count); }
	void onSleep(PxActor** actors, PxU32 count)							{ PX_UNUSED(actors); PX_UNUSED(count); }
	void onTrigger(PxTriggerPair* pairs, PxU32 count)					{ PX_UNUSED(pairs); PX_UNUSED(count); }
	void onAdvance(const PxRigidBody*const*, const PxTransform*, const PxU32) {}
	void onContact(const PxContactPairHeader& pairHeader, const PxContactPair* pairs, PxU32 nbPairs) 
	{
		PX_UNUSED((pairHeader));
		std::vector<PxContactPairPoint> contactPoints;
		
		for(PxU32 i=0;i<nbPairs;i++)
		{
			PxU32 contactCount = pairs[i].contactCount;
			if(contactCount)
			{
				contactPoints.resize(contactCount);
				pairs[i].extractContacts(&contactPoints[0], contactCount);

				for(PxU32 j=0;j<contactCount;j++)
				{
					gContactPositions.push_back(contactPoints[j].position);
					gContactImpulses.push_back(contactPoints[j].impulse);
				}
			}
		}
	}
};

class ContactModifyCallback : public PxContactModifyCallback
{
    void onContactModify(PxContactModifyPair* const pairs, PxU32 count)
    {
        for (PxU32 i = 0; i < count; i++)
        {
            const PxRigidDynamic* dynamic0 = pairs[i].actor[0]->is<PxRigidDynamic>();
            const PxRigidDynamic* dynamic1 = pairs[i].actor[1]->is<PxRigidDynamic>();
            if (dynamic0 != NULL && dynamic1 != NULL)
            {
                PxVec3 vel(0);
                const char* name0 = dynamic0->getName();
                const char* name1 = dynamic1->getName();
                
                if (strcmp("Box", name0) == 0)
                {
                    if (strcmp("Con1", name1) == 0)
                    {
                        vel = PxVec3(0, 0, -10.);
                    }
                    else if (strcmp("Con2", name1) == 0)
                    {
                        vel = PxVec3(0, 0, 10.);
                    }
                }

                PxContactSet* contactPnts = &pairs[i].contacts;
                PxU32 contactCount = contactPnts->size();

                for (PxU32 j = 0; j < contactCount; j++)
                {
                    contactPnts->setTargetVelocity(j, vel);
                }
            }
        }
    }
};
ContactReportCallback gContactReportCallback;
ContactModifyCallback gContactModifyCallback;

static void createStack(const PxTransform& t, PxU32 size, PxVec3 halfExtent, bool bFixed, const char* name)
{
	PxShape* shape = gPhysics->createShape(PxBoxGeometry(halfExtent), *gMaterial1);
	for(PxU32 i=0; i<size;i++)
	{
		for(PxU32 j=0;j<size-i;j++)
		{
			/*PxTransform localTm(PxVec3(PxReal(j*2) - PxReal(size-i), PxReal(i*2+1), 0) * halfExtent);*/
			PxRigidDynamic* body = gPhysics->createRigidDynamic(t/*.transform(localTm)*/);
			body->attachShape(*shape);
            //shape->setContactOffset(PxReal(0.001));
            body->setName(name);
            body->setMaxDepenetrationVelocity(2);
            body->setWakeCounter(10000000);
           
			PxRigidBodyExt::updateMassAndInertia(*body, 50.0f);
            if (bFixed)
            {
                auto pJ = PxD6JointCreate_Fixed(*gPhysics, body, PxVec3(0.0,0.0,0.0),
                    NULL, t.p, true);
                pJ->setConstraintFlag(PxConstraintFlag::eGPU_COMPATIBLE, true);
            }
             
			gScene->addActor(*body);
		}
	}
	shape->release();
}

void initPhysics(bool /*interactive*/)
{
	gFoundation = PxCreateFoundation(PX_PHYSICS_VERSION, gAllocator, gErrorCallback);
	gPvd = PxCreatePvd(*gFoundation);
	PxPvdTransport* transport = PxDefaultPvdSocketTransportCreate(PVD_HOST, 5425, 10);
	gPvd->connect(*transport,PxPvdInstrumentationFlag::eALL);
	gPhysics = PxCreatePhysics(PX_PHYSICS_VERSION, *gFoundation, PxTolerancesScale(),true,gPvd);
	PxInitExtensions(*gPhysics,gPvd);
	PxU32 numCores = SnippetUtils::getNbPhysicalCores();
	gDispatcher = PxDefaultCpuDispatcherCreate(numCores == 0 ? 0 : numCores - 1);
	PxSceneDesc sceneDesc(gPhysics->getTolerancesScale());
	sceneDesc.cpuDispatcher = gDispatcher;
	sceneDesc.gravity = PxVec3(0, -9.81f, 0);
	sceneDesc.filterShader	= contactReportFilterShader;			
	sceneDesc.simulationEventCallback = &gContactReportCallback;	
    sceneDesc.contactModifyCallback = &gContactModifyCallback;
    //sceneDesc.frictionType = PxFrictionType::eTWO_DIRECTIONAL;
    //sceneDesc.frictionCorrelationDistance = PxReal(0.001);
    //sceneDesc.frictionOffsetThreshold = 0.25;
	gScene = gPhysics->createScene(sceneDesc);

	PxPvdSceneClient* pvdClient = gScene->getScenePvdClient();
	if(pvdClient)
	{
		pvdClient->setScenePvdFlag(PxPvdSceneFlag::eTRANSMIT_CONTACTS, true);
	}
	gMaterial = gPhysics->createMaterial(0.7f, 1.f, 0.001f);
    gMaterial1 = gPhysics->createMaterial(1.f, 1.f, 0.001f);
    gMaterial1->setFlag(PxMaterialFlag::eIMPROVED_PATCH_FRICTION, true);
	PxRigidStatic* groundPlane = PxCreatePlane(*gPhysics, PxPlane(0,1,0,0), *gMaterial);
	gScene->addActor(*groundPlane);
	createStack(PxTransform(PxVec3(2.5,15.25f,20.1f)), 1, PxVec3(5.0,1, 20.0), true, "Con1");
	createStack(PxTransform(PxVec3(2.5,15.25f,-20.1f)), 1, PxVec3(5.0,1, 20.0), true, "Con2");
	createStack(PxTransform(PxVec3(2.5,17.f,-20.f)), 1, PxVec3(2.0,1, 5.0), false, "Box");
	createStack(PxTransform(PxVec3(2.5,17.f,-30.f)), 1, PxVec3(2.0,1, 5.0), false, "Box");
}

[preist-nvidia]

Thank you for the excellent issue description @yananZZZZ, we'll have a look!

Internal tracking: PX-4657

[kermado]

This example doesn’t account for the fact that ‘dynamic0’ may be one of the two conveyors. In such a case, the contact velocity is not set. It also doesn’t fix the contact normals, which can result in edge catching. However, I have seen similar rotational behaviour from boxes sliding backwards down a single inclined conveyor.

[yananZZZZ]

Hi Kermado,

For the edge catching, indeed, I haven't checked the normal of all my contact points. I did a quick try and set the normal to the normal of my conveyor. it works.
However, I not quite fellow the idea of

In such a case, the contact velocity is not set.

do you mean that for these contact points do applied a opposite target velocity, but they counteract with each other's which give the body an affect as there is no target velocity at all?
One of my assumptions, contact points in different conveyors might not be symmetrical from the COM, even when set the same target velocity the actual force might not be the same. this can cause some tilt behavior. If it is the case, how to make the box stay stationary in the between without rotating? How to understand the friction behavior at this situation?

thank you

[kermado]

do you mean that for these contact points do applied a opposite target velocity, but they counteract with each other's which give the body an affect as there is no target velocity at all?

Your example assumes that dynamic0 always corresponds to your box. However, there is no such guarantee. It could be that dynamic0 corresponds to one of the conveyors. In such cases you should negate the velocity vector rather than setting it to zero.

[yananZZZZ]

Hi,
thanks for the elaboration, I tried to catch the case when the dynamic0 be one of the conveyors, however, it never happens. maybe it because those conveyors are fixed. The rotating motion I think is still from friction and contact points. I just want to know more about friction model used in PhysX, for me, it looks a bit slippery compare with other Physics Engine such as Bullet.

[vreutskyy]

Hi @yananZZZZ
This behavior is expected as the target velocity you set in the contact modification callback isn't just applied to the body directly, instead, the solver is said that one of the bodies has this velocity, so the friction force will try to make the velocity of the other body match the first one. It's the friction force moves the bodies on the conveyor. And this friction force is applied at the contact points whose distribution on the body's surface is quite random. When two conveyor apply their forces to the same body, it's quite possible that the body will start to rotate or move in unpredictable way. I'm quite sure that's what would happen in reality too.

[preist-nvidia]

Closing for now until more comments are made.