Shapecast behavior and performance

[BobbyAnguelov]

Me again (Sorry 😅)

I've been getting the shape cast queries integrated and hitting some issues. What I'm trying to do is to shapecast and return all shapes that I collide along the way, i.e. I treat all collisions as non-blocking (aka touches in physx). I'm using the all hit collector.

This results in the following result for a simple use case where I cast against 3 mesh shapes.

I get 405 hits (135 hits per shape) since Jolt is returning every hit per triangle per shape. I have ignore backfaces set, if I dont the hit count significantly climbs

With PhysX I get back only the closest hit per shape.

The physx behavior is kinda what I would expect in my use case since it is a sweep and not an overlap. IIRC havok and chaos will behave similarly in only returning the closest hit per shape. PhysX is also ~2X faster in performing the raw sweep ( 0.04ms vs 0.08ms for Jolt).

I've written a simple collector to track the closest hit per bodyID (see code below). This has no effect on the performance and gives me the expected result but it's still significantly slower than physx for the same query.

virtual void AddHit( ShapeCastResult const& inResult ) override
{
    // If we hit a new body
    if ( inResult.mBodyID2 != m_currentlyHitBody )
    {
        // Add previous body closest hit to results
        if ( !m_currentlyHitBody.IsInvalid() )
        {
            m_results.m_hits.emplace_back( m_closestHit );
        }

        m_currentlyHitBody = inResult.mBodyID2;
        m_lowestHitfractionForBody = FLT_MAX;
    }

    // Check if the new hit is closer than our previous hit
    if ( inResult.mFraction < m_lowestHitfractionForBody )
    {
        m_lowestHitfractionForBody = inResult.mFraction;
                
        // Update closest hit
        m_closestHit.m_contactBodyID = inResult.mBodyID2;
        m_closestHit.m_positionOfCastShape = FromJolt( m_shapeCast.GetPointOnRay( inResult.mFraction ) );
        m_closestHit.m_contactPointOnCastShape = FromJolt( inResult.mContactPointOn1 );
        m_closestHit.m_contactPointOnHitShape = FromJolt( inResult.mContactPointOn2 );
        m_closestHit.m_contactNormal = FromJolt( -inResult.mPenetrationAxis.Normalized() );
        m_closestHit.m_surfaceNormal = FromJolt( GetContext()->GetWorldSpaceSurfaceNormal( inResult.mSubShapeID2, inResult.mContactPointOn2 ) );
        m_closestHit.m_isBackfaceHit = inResult.mIsBackFaceHit;

        if ( m_closestHit.m_isBackfaceHit )
        {
            m_closestHit.m_surfaceNormal.Negate();
        }
    }
}

Additionally, I considered what you said in the filtering test with regards to how you dont really run such queries but you instead run multiple sequential sweeps. This feels like it would be significantly more expensive as I would need to repeat the same query over and over, adding a new body to ignore to the filter as well as shifting the starting location with each detected hit until there are no more hits.

As I mentioned, I'm not sure what benefit there is to returning every single hit for a sweep, and it feels like it can be significantly faster to just find the closest hit for a shape in place while walking the triangles of the shape and then just return that to the user. There are various avenues for optimizing that in place, I mean just avoiding 402 virtual function calls for one will provide a decent speedup. If the user REALLY wants to get all hits in special situations, they can simple just do an overlap with the hit body as a follow up or perhaps we can make that a setting on the filter just like the ignore back faces option?

What are your thoughts on this?

[jrouwe]

I think it's very simple to implement the behavior that you want (I didn't make this the default behavior as people may actually want all those hits).

Make a copy of NarrowPhaseQuery::CastShape in your own code and apply this patch to it:

@@ -334,8 +334,16 @@ void NarrowPhaseQuery::CastShape(const RShapeCast &inShapeCast, const ShapeCastS
                                                // Release the lock now, we have all the info we need in the transformed shape
                                                lock.ReleaseLock();

+                                               // Create a temporary collector to hold the closest hit
+                                               ClosestHitCollisionCollector<CastShapeCollector> collector;
+                                               collector.UpdateEarlyOutFraction(mCollector.GetEarlyOutFraction());
+
                                                // Do narrow phase collision check
-                                               ts.CastShape(mShapeCast, mShapeCastSettings, mBaseOffset, mCollector, mShapeFilter);
+                                               ts.CastShape(mShapeCast, mShapeCastSettings, mBaseOffset, collector, mShapeFilter);
+
+                                               // If a hit was found, propagate it to the collector
+                                               if (collector.HadHit())
+                                                       mCollector.AddHit(collector.mHit);

                                                // Update early out fraction based on narrow phase collector
                                                PropagateEarlyOutFraction();

Note that mBroadPhase is PhysicsSystem::GetBroadPhaseQuery() and mBodyLockInterface is PhysicsSystem::GetBodyLockInterface()

[BobbyAnguelov]

Ah that's a good point. Yeh probably want the option to be something like:

• All hits
• Closest Hit Per Body
• Closest Hit Per Shape

[erincatto]

I've always treated meshes and convex hulls as a single shape when it comes to world queries. So even with a ray/sphere cast that continues through many shapes, the user only gets the closest hit on each shape.

It may make sense to allow multiple hits when doing a query on a mesh shape directly. For example, I may want to do an AABB query on a mesh shape to get all the overlapping triangles.

[Ivan-le-sketch]

Hey @jrouwe ! Is this manual fix still the recommended way to go ?

[jrouwe]

Yes, although it has been on my list for a long time to make an official option for this.

[jrouwe]

I've official support for this in #1465