Trying to recreate a collision response behaviour: overriding ContactSettings

[WaveCollaps]

Hello,

I'm trying to create this behaviour for my vehicle:

crash.mp4

It looks like a pretty standard/realistic collision response, however, the car never pitches up or down due to crashing into barriers, other than that it just seems to reflect the car depending on your entry angle. So I tried to modify the ContactSettings inside a ContactListener and managed to disable the rotation by setting mInvInertiaScale2 to zero and really low friction and restitution, however I guess this also takes away your ability to utilize mRelativeAngularSurfaceVelocity as well, though I'm not really sure that's the right way to solve this. Anyway, my question is, is this doable by only modifying contacts? Another way that comes to mind is keeping the inv intertia scale 0 and keep a 'just crashed' state and apply angular impulse outside.

[jrouwe]

I think mInvInertiaScaleX is not really suitable as it completely prevents the car from rotating and you do want it to rotate around its up axis. There is currently no way to affect individual components of the rotation in the contact callback.

If you use Jolt's VehicleConstraint class you can use VehicleConstraintSettings::mMaxPitchRollAngle to prevent the vehicle from rolling over. If not, you could try to use a SixDOFConstraint to constrain the car to the world up axis (Body::sFixedToWorld). If your track has slopes, you could use a motor and SetTargetOrientationCS to drive the the vehicle towards the local track up vector. If your track has no slopes at all you could also update BodyCreationSettings::mAllowedDOFs to restrict rotation to the up vector.

You could also use PhysicsSystem::SetSimCollideBodyVsBody to completely override the contact points, but I don't think it's simple to adjust contact points so that no roll occurs.

[WaveCollaps]

Thanks for the suggestions @jrouwe .
I am using VehicleConstraint, however I want the car to freely rotate like usual, but only customize the collision response with the walls for more arcade feeling. My tracks have slope so mMaxPitchRollAngle isn't suitable.I'll be trying SixDOFConstraint but I'm still not sure since there are tracks where each wheel could have a different normal (banked corners).

There is currently no way to affect individual components of the rotation in the contact callback

Do you think it would be easy to integrate this in to Jolt? I could try my luck but I don't know how much stuff there would be to touch to implement this

[jrouwe]

I think your best bet is to use PhysicsSystem::SetSimCollideBodyVsBody. You can create a function that looks like this:

void MySimCollideBodyVsBody(..., CollideShapeCollector &ioCollector, ...)
{
	struct MyCollector : public CollideShapeCollector
	{
		MyCollector(CollideShapeCollector &ioCollector) :
			mCollector(ioCollector)
		{
		}
	
		virtual void AddHit(const CollideShapeResult &inResult) override
		{
			CollideShapeResult result = inResult;			
			// Modify 'result' if the contact is between the car and a wall			
			mCollector.AddHit(result);
		}
		
		CollideShapeCollector &mCollector;
	};
	
	MyCollector my_collector(ioCollector);
	PhysicsSystem::sDefaultSimCollideBodyVsBody(..., my_collector, ...);			
}

which will give you full control over what contact points / normals you send to the sim.

[WaveCollaps]

Thanks for the help, like you said, by only modifying the contacts it did not seem trivial so I went with another method.
Similar to PostSimulation in Character.cpp, I run a collision step:

class MyCollector : public CollideShapeCollector
{
  public:
  // Constructor
  explicit MyCollector(Vec3 inVehicleFwd) : inForward(inVehicleFwd)
  {
  }

  virtual void AddHit(const CollideShapeResult& inResult) override
  {
        mNormal = -inResult.mPenetrationAxis.Normalized();

        // Point on the wall
        mContactPoint = inResult.mContactPointOn2;
	mContactPointOnVehicle = inResult.mContactPointOn1;

	// Normal of which we will reflect the car's forward vector to 'reflect' the car
	mFaceNormal = (inResult.mShape2Face[1] - inResult.mShape2Face[0]).Cross(inResult.mShape2Face[2] - inResult.mShape2Face[0]).Normalized();

	// Reflect inForward along mFaceNormal
	mReflected = inForward - 2.0f * inForward.Dot(mFaceNormal) * mFaceNormal;
  }

  Vec3 mNormal = Vec3::sZero();
  Vec3 mFaceNormal = Vec3::sZero();
  Vec3 mContactPoint = Vec3::sZero();
  Vec3 mContactPointOnVehicle = Vec3::sZero();
  Vec3 mReflected = Vec3::sZero();

  private:
        Vec3 inForward;
};

Then I calculate an angular impulse to apply a rolling rotation to the vehicle

Vec3 rollAxis = mBody->GetRotation() * Vec3(0, 0, 1); // Z is up
Vec3 rotationAxis = carFwd.Cross(collector.mReflected).Normalized();

Then using the contact point on the vehicle and the center of mass position, I apply the impulse if the car is hitting the wall from the 'front'. This is to prevent another bounce because after reflecting once, the rear side of the vehicle might hit the wall again, causing another bounce.

This is of course with, mInvInertiaScaleX is set to 0. I'll see if this is ok in all scenarios but so far it does what I want and on all kinds of flat/curved geometry.