PxFilterFlags PhysXSimFilterShader( PxFilterObjectAttributes attributes0, PxFilterData filterData0,
PxFilterObjectAttributes attributes1, PxFilterData filterData1,
PxPairFlags& pairFlags, const void* constantBlock, PxU32 constantBlockSize )
{
//UE_LOG(LogPhysics, Log, TEXT("filterData0 (%s): %x %x %x %x"), *ObjTypeToString(attributes0), filterData0.word0, filterData0.word1, filterData0.word2, filterData0.word3);
//UE_LOG(LogPhysics, Log, TEXT("filterData1 (%s): %x %x %x %x"), *ObjTypeToString(attributes1), filterData1.word0, filterData1.word1, filterData1.word2, filterData1.word3);
bool k0 = PxFilterObjectIsKinematic(attributes0);
bool k1 = PxFilterObjectIsKinematic(attributes1);
// Find out which channels the objects are in
ECollisionChannel Channel0 = GetCollisionChannel(filterData0.word3);
ECollisionChannel Channel1 = GetCollisionChannel(filterData1.word3);
// ignore kinematic-kinematic interactions which don't involve a destructible
if(k0 && k1 && (Channel0 != ECC_Destructible) && (Channel1 != ECC_Destructible))
{
//return PxFilterFlag::eKILL;
return PxFilterFlag::eSUPPRESS; //NOTE: Waiting on physx fix for refiltering on aggregates. For now use supress which automatically tests when changes to simulation happen
}
bool s0 = PxGetFilterObjectType(attributes0) == PxFilterObjectType::eRIGID_STATIC;
bool s1 = PxGetFilterObjectType(attributes1) == PxFilterObjectType::eRIGID_STATIC;
//ignore static-kinematic (this assumes that statics can't be flagged as kinematics)
// should return eSUPPRESS here instead eKILL so that kinematics vs statics will still be considered once kinematics become dynamic (dying ragdoll case)
if((k0 || k1) && (s0 || s1))
{
return PxFilterFlag::eSUPPRESS;
}
// if these bodies are from the same component, use the disable table to see if we should disable collision. This case should only happen for things like skeletalmesh and destruction. The table is only created for skeletal mesh components at the moment
if(filterData0.word2 == filterData1.word2)
{
check(constantBlockSize == sizeof(FPhysSceneShaderInfo));
const FPhysSceneShaderInfo* PhysSceneShaderInfo = (const FPhysSceneShaderInfo*) constantBlock;
check(PhysSceneShaderInfo);
FPhysScene * PhysScene = PhysSceneShaderInfo->PhysScene;
check(PhysScene);
const TMap<uint32, TMap<FRigidBodyIndexPair, bool> *> & CollisionDisableTableLookup = PhysScene->GetCollisionDisableTableLookup();
TMap<FRigidBodyIndexPair, bool>* const * DisableTablePtrPtr = CollisionDisableTableLookup.Find(filterData1.word2);
if (DisableTablePtrPtr) //Since collision table is deferred during sub-stepping it's possible that we won't get the collision disable table until the next frame
{
TMap<FRigidBodyIndexPair, bool>* DisableTablePtr = *DisableTablePtrPtr;
FRigidBodyIndexPair BodyPair(filterData0.word0, filterData1.word0); // body indexes are stored in word 0
if (DisableTablePtr->Find(BodyPair))
{
return PxFilterFlag::eKILL;
}
}
}
// see if 0/1 would like to block the other
PxU32 BlockFlagTo1 = (ECC_TO_BITFIELD(Channel1) & filterData0.word1);
PxU32 BlockFlagTo0 = (ECC_TO_BITFIELD(Channel0) & filterData1.word1);
bool bDoesWantToBlock = (BlockFlagTo1 && BlockFlagTo0);
// if don't want to block, suppress
if ( !bDoesWantToBlock )
{
return PxFilterFlag::eSUPPRESS;
}
PxU32 FilterFlags0 = (filterData0.word3 & 0xFFFFFF);
PxU32 FilterFlags1 = (filterData1.word3 & 0xFFFFFF);
pairFlags = PxPairFlag::eCONTACT_DEFAULT;
//todo enabling CCD objects against everything else for now
if(!(k0 && k1) && ((FilterFlags0&EPDF_CCD) || (FilterFlags1&EPDF_CCD)))
{
pairFlags |= PxPairFlag::eDETECT_CCD_CONTACT | PxPairFlag::eSOLVE_CONTACT;
}
if((FilterFlags0&EPDF_ContactNotify) || (FilterFlags1&EPDF_ContactNotify))
{
pairFlags |= (PxPairFlag::eNOTIFY_TOUCH_FOUND | PxPairFlag::eNOTIFY_TOUCH_PERSISTS | PxPairFlag::eNOTIFY_CONTACT_POINTS );
}
if ((FilterFlags0&EPDF_ModifyContacts) || (FilterFlags1&EPDF_ModifyContacts))
{
pairFlags |= (PxPairFlag::eMODIFY_CONTACTS);
}
return PxFilterFlags();
}
void UAblTargetingBox::FindTargets(UAblAbilityContext& Context) const
{
AActor* SourceActor = m_Location.GetSourceActor(Context);
check(SourceActor);
UWorld* World = SourceActor->GetWorld();
FTransform QueryTransform;
if (IsUsingAsync() && UAbleSettings::IsAsyncEnabled())
{
// Check if we have a valid Async handle already.
if (!Context.HasValidAsyncHandle())
{
FCollisionShape BoxShape = FCollisionShape::MakeBox(m_HalfExtents);
m_Location.GetTransform(Context, QueryTransform);
// Push our query out by our half extents so we aren't centered in the box.
FQuat Rotation = QueryTransform.GetRotation();
FVector HalfExtentsOffset = Rotation.GetForwardVector() * m_HalfExtents.X;
QueryTransform *= FTransform(HalfExtentsOffset);
FTraceHandle AsyncHandle = World->AsyncOverlapByChannel(QueryTransform.GetLocation(), QueryTransform.GetRotation(), GetCollisionChannel(), BoxShape);
Context.SetAsyncHandle(AsyncHandle);
}
else // Poll and see if our query is done, if so - process it.
{
FOverlapDatum Datum;
if (World->QueryOverlapData(Context.GetAsyncHandle(), Datum))
{
ProcessResults(Context, Datum.OutOverlaps);
FTraceHandle Empty;
Context.SetAsyncHandle(Empty); // Reset our handle.
}
return;
}
}
else // Normal Sync Query
{
FCollisionShape BoxShape = FCollisionShape::MakeBox(m_HalfExtents);
m_Location.GetTransform(Context, QueryTransform);
// Push our query out by our half extents so we aren't centered in the box.
FQuat Rotation = QueryTransform.GetRotation();
FVector HalfExtentsOffset = Rotation.GetForwardVector() * m_HalfExtents.X;
QueryTransform *= FTransform(HalfExtentsOffset);
TArray<FOverlapResult> Results;
if (World->OverlapMultiByChannel(Results, QueryTransform.GetLocation(), QueryTransform.GetRotation(), GetCollisionChannel(), BoxShape))
{
ProcessResults(Context, Results);
}
}
#if !UE_BUILD_SHIPPING
if (FAblAbilityDebug::ShouldDrawQueries())
{
// Nope, go ahead and fire off our Async query.
FVector AlignedBox = GetAlignedBox(Context, QueryTransform);
FAblAbilityDebug::DrawBoxQuery(World, QueryTransform, AlignedBox);
}
#endif // UE_BUILD_SHIPPING
}
