CollisionQueryParams.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Structs used for passing parameters to scene query functions
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/EngineTypes.h"
#include "Chaos/ChaosEngineInterface.h"
#include "UObject/RemoteObjectTransfer.h"
 
#define ECC_TO_BITFIELD(x)  (1<<(x))
#define CRC_TO_BITFIELD(x)  (1<<(x))
 
class AActor;
class UPrimitiveComponent;
 
enum class EQueryMobilityType
{
    Any,
    Static, //Any shape that is considered static by physx (static mobility)
    Dynamic //Any shape that is considered dynamic by physx (movable/stationary mobility)
};
 
#define FIND_UNKNOWN_SCENE_QUERIES 0
 
#if ENABLE_STATNAMEDEVENTS
    #define SCENE_QUERY_STAT_ONLY(QueryName) TStatId(ANSI_TO_PROFILING(#QueryName))
#else
    #define SCENE_QUERY_STAT_ONLY(QueryName) QUICK_USE_CYCLE_STAT(QueryName, STATGROUP_CollisionTags)
#endif
 
#define SCENE_QUERY_STAT_NAME_ONLY(QueryName) [](){ static FName StaticName(#QueryName); return StaticName;}()
#define SCENE_QUERY_STAT(QueryName) SCENE_QUERY_STAT_NAME_ONLY(QueryName), SCENE_QUERY_STAT_ONLY(QueryName)
 
struct FCollisionQueryParams
{
    FName TraceTag;
 
    FName OwnerTag;
 
    bool bTraceComplex;
 
    bool bFindInitialOverlaps;
 
    bool bReturnFaceIndex;
 
    bool bReturnPhysicalMaterial;
 
    bool bIgnoreBlocks;
 
    bool bIgnoreTouches;
 
    bool bSkipNarrowPhase;
 
    bool bTraceIntoSubComponents;
 
    bool bReplaceHitWithSubComponents;
 
    EQueryMobilityType MobilityType;
 
    typedef TArray<uint32, TInlineAllocator<8>> IgnoreComponentsArrayType;
 
    typedef TArray<uint32, TInlineAllocator<4>> IgnoreSourceObjectsArrayType;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    typedef TArray<FRemoteObjectReference, TInlineAllocator<4>> IgnoreSourceObjectReferencesArrayType;
    typedef TArray<FRemoteObjectReference, TInlineAllocator<8>> IgnoreComponentReferencesArrayType;
#endif
 
    typedef IgnoreSourceObjectsArrayType IgnoreActorsArrayType;
 
    FMaskFilter IgnoreMask;
 
    TStatId StatId;
 
    static inline TStatId GetUnknownStatId()
    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(UnknownSceneQuery, STATGROUP_Collision);
    }
 
#if !(UE_BUILD_TEST || UE_BUILD_SHIPPING)
    bool bDebugQuery;
#endif
 
private:
 
    mutable bool bComponentListUnique;
 
    mutable IgnoreComponentsArrayType IgnoreComponents;
 
    IgnoreSourceObjectsArrayType IgnoreSourceObjects;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    mutable IgnoreComponentReferencesArrayType IgnoreComponentReferences;
    IgnoreSourceObjectReferencesArrayType IgnoreSourceObjectReferences;
#endif
 
    void Internal_AddIgnoredSourceObject(const FWeakObjectPtr& WeakPtr);
 
    ENGINE_API void Internal_AddIgnoredComponent(const UPrimitiveComponent* InIgnoreComponent);
 
public:
 
    ENGINE_API const IgnoreComponentsArrayType& GetIgnoredComponents() const;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    const IgnoreComponentReferencesArrayType& GetIgnoredComponentReferences() const
    {
        return IgnoreComponentReferences;
    }
#endif
 
    UE_DEPRECATED(5.5, "Use GetIgnoredSourceObjects instead.")
    const IgnoreActorsArrayType& GetIgnoredActors() const
    {
        return IgnoreSourceObjects;
    }
 
    const IgnoreActorsArrayType& GetIgnoredSourceObjects() const
    {
        return IgnoreSourceObjects;
    }
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    const IgnoreSourceObjectReferencesArrayType& GetIgnoredSourceObjectReferences() const
    {
        return IgnoreSourceObjectReferences;
    }
#endif
 
    void ClearIgnoredComponents()
    {
        IgnoreComponents.Reset();
        bComponentListUnique = true;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
        IgnoreComponentReferences.Reset();
#endif
    }
 
    UE_DEPRECATED(5.5, "Use ClearIgnoredSourceObjects instead.")
    void ClearIgnoredActors()
    {
        IgnoreSourceObjects.Reset();
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
        IgnoreSourceObjectReferences.Reset();
#endif
    }
 
    void ClearIgnoredSourceObjects()
    {
        IgnoreSourceObjects.Reset();
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
        IgnoreSourceObjectReferences.Reset();
#endif
    }
 
    ENGINE_API void SetNumIgnoredComponents(int32 NewNum);
 
    // Constructors
#if !FIND_UNKNOWN_SCENE_QUERIES
 
    FCollisionQueryParams()
    {
        bTraceComplex = false;
        MobilityType = EQueryMobilityType::Any;
        TraceTag = NAME_None;
        bFindInitialOverlaps = true;
        bReturnFaceIndex = false;
        bReturnPhysicalMaterial = false;
        bComponentListUnique = true;
        IgnoreMask = 0;
        bIgnoreBlocks = false;
        bIgnoreTouches = false;
        bSkipNarrowPhase = false;
        StatId = GetUnknownStatId();
#if !(UE_BUILD_TEST || UE_BUILD_SHIPPING)
        bDebugQuery = false;
#endif
        bTraceIntoSubComponents = true;
        bReplaceHitWithSubComponents = true;
    }
 
    FCollisionQueryParams(FName InTraceTag, bool bInTraceComplex=false, const AActor* InIgnoreActor=NULL)
    : FCollisionQueryParams(InTraceTag, GetUnknownStatId(), bInTraceComplex, InIgnoreActor)
    {
 
    }
#endif
 
    ENGINE_API FCollisionQueryParams(FName InTraceTag, const TStatId& InStatId, bool bInTraceComplex = false, const AActor* InIgnoreActor = NULL);
 
    // Utils
 
    ENGINE_API void AddIgnoredActor(const AActor* InIgnoreActor);
 
    ENGINE_API void AddIgnoredActor(const uint32 InIgnoreActorID);
 
    ENGINE_API void AddIgnoredSourceObject(const UObject* InIgnoreActor);
    ENGINE_API void AddIgnoredSourceObject(const TWeakObjectPtr<const UObject>& InIgnoreObject);
    ENGINE_API void AddIgnoredSourceObject(const FRemoteObjectReference& ObjectRef);
 
    ENGINE_API void AddIgnoredSourceObject(const uint32 InIgnoreActorID);
 
    ENGINE_API void AddIgnoredActors(const TArray<AActor*>& InIgnoreActors);
    ENGINE_API void AddIgnoredActors(const TArray<const AActor*>& InIgnoreActors);
    ENGINE_API void AddIgnoredActors(const TArray<TWeakObjectPtr<const AActor> >& InIgnoreActors);
 
    ENGINE_API void AddIgnoredSourceObjects(const TArray<UObject*>& InIgnoreObjects);
    ENGINE_API void AddIgnoredSourceObjects(const TArray<const UObject*>& InIgnoreObjects);
    ENGINE_API void AddIgnoredSourceObjects(const TArray<TWeakObjectPtr<const UObject> >& InIgnoreObjects);
 
    ENGINE_API void AddIgnoredComponent(const UPrimitiveComponent* InIgnoreComponent);
    ENGINE_API void AddIgnoredComponent(const TWeakObjectPtr<UPrimitiveComponent>& InIgnoreComponent);
    ENGINE_API void AddIgnoredComponent(const FRemoteObjectReference& InComponentRef);
 
    ENGINE_API void AddIgnoredComponents(const TArray<UPrimitiveComponent*>& InIgnoreComponents);
    
    ENGINE_API void AddIgnoredComponents(const TArray<TWeakObjectPtr<UPrimitiveComponent>>& InIgnoreComponents);
 
    ENGINE_API void AddIgnoredComponent_LikelyDuplicatedRoot(const UPrimitiveComponent* InIgnoreComponent);
 
    UE_INTERNAL ENGINE_API void Internal_AddIgnoredComponent(const uint32 ComponentID);
 
    FString ToString() const
    {
        return FString::Printf(TEXT("[%s:%s] TraceComplex(%d)"), *OwnerTag.ToString(), *TraceTag.ToString(), bTraceComplex );
    }
 
    static ENGINE_API FCollisionQueryParams DefaultQueryParam;
};
 
struct FComponentQueryParams : public FCollisionQueryParams
{
#if !FIND_UNKNOWN_SCENE_QUERIES
    FComponentQueryParams()
    : FCollisionQueryParams(NAME_None, FCollisionQueryParams::GetUnknownStatId(),false)
    {
    }
 
    FComponentQueryParams(FName InTraceTag, const AActor* InIgnoreActor=NULL, const FCollisionEnabledMask InShapeCollisionMask = 0)
    : FComponentQueryParams(InTraceTag, GetUnknownStatId(), InIgnoreActor, InShapeCollisionMask)
    {
    }
#endif
 
    FComponentQueryParams(FName InTraceTag, const TStatId& InStatId, const AActor* InIgnoreActor = NULL, const FCollisionEnabledMask InShapeCollisionMask = 0)
        : FCollisionQueryParams(InTraceTag, InStatId, false, InIgnoreActor), ShapeCollisionMask(InShapeCollisionMask)
    {
    }
 
    FCollisionEnabledMask ShapeCollisionMask;
 
    static ENGINE_API FComponentQueryParams DefaultComponentQueryParams;
};
 
struct FCollisionResponseParams
{
    struct FCollisionResponseContainer CollisionResponse;
 
    FCollisionResponseParams(ECollisionResponse DefaultResponse = ECR_Block)
    {
        CollisionResponse.SetAllChannels(DefaultResponse);
    }
 
    FCollisionResponseParams(const FCollisionResponseContainer& ResponseContainer)
    {
        CollisionResponse = ResponseContainer;
    }
    static ENGINE_API FCollisionResponseParams DefaultResponseParam;
};
 
// If ECollisionChannel entry has metadata of "TraceType = 1", they will be excluded by Collision Profile
// Any custom channel with bTraceType=true also will be excluded
// By default everything is object type
struct FCollisionQueryFlag
{
private:
    int32 AllObjectQueryFlag;
    int32 AllStaticObjectQueryFlag;
 
    FCollisionQueryFlag()
    {
        AllObjectQueryFlag = 0xFFFFFFFF;
        AllStaticObjectQueryFlag = ECC_TO_BITFIELD(ECC_WorldStatic);
    }
 
public:
    static ENGINE_API FCollisionQueryFlag& Get();
 
    int32 GetAllObjectsQueryFlag()
    {
        // this doesn't really verify trace queries to come this way
        return AllObjectQueryFlag;
    }
 
    int32 GetAllStaticObjectsQueryFlag()
    {
        return AllStaticObjectQueryFlag;
    }
 
    int32 GetAllDynamicObjectsQueryFlag()
    {
        return (AllObjectQueryFlag & ~AllStaticObjectQueryFlag);
    }
 
    void AddToAllObjectsQueryFlag(ECollisionChannel NewChannel)
    {
        if (ensure ((int32)NewChannel < 32))
        {
            SetAllObjectsQueryFlag (AllObjectQueryFlag |= ECC_TO_BITFIELD(NewChannel));
        }
    }
 
    void AddToAllStaticObjectsQueryFlag(ECollisionChannel NewChannel)
    {
        if (ensure ((int32)NewChannel < 32))
        {
            SetAllStaticObjectsQueryFlag (AllStaticObjectQueryFlag |= ECC_TO_BITFIELD(NewChannel));
        }
    }
 
    void RemoveFromAllObjectsQueryFlag(ECollisionChannel NewChannel)
    {
        if (ensure ((int32)NewChannel < 32))
        {
            SetAllObjectsQueryFlag (AllObjectQueryFlag &= ~ECC_TO_BITFIELD(NewChannel));
        }
    }
 
    void RemoveFromAllStaticObjectsQueryFlag(ECollisionChannel NewChannel)
    {
        if (ensure ((int32)NewChannel < 32))
        {
            SetAllStaticObjectsQueryFlag (AllObjectQueryFlag &= ~ECC_TO_BITFIELD(NewChannel));
        }
    }
 
    void SetAllObjectsQueryFlag(int32 NewQueryFlag)
    {
        // if all object query has changed, make sure to apply to static object query
        AllObjectQueryFlag = NewQueryFlag;
        AllStaticObjectQueryFlag = AllObjectQueryFlag & AllStaticObjectQueryFlag;
    }
 
    void SetAllStaticObjectsQueryFlag(int32 NewQueryFlag)
    {
        AllStaticObjectQueryFlag = NewQueryFlag;
    }
 
    void SetAllDynamicObjectsQueryFlag(int32 NewQueryFlag)
    {
        AllStaticObjectQueryFlag = AllObjectQueryFlag & ~NewQueryFlag;
    }
};
 
struct FCollisionObjectQueryParams
{
    enum InitType
    {
        AllObjects,
        AllStaticObjects,
        AllDynamicObjects
    };
 
    int32 ObjectTypesToQuery;
 
    FMaskFilter IgnoreMask;
 
    FCollisionObjectQueryParams()
        : ObjectTypesToQuery(0)
        , IgnoreMask(0)
    {
    }
 
    FCollisionObjectQueryParams(ECollisionChannel QueryChannel)
    {
        ObjectTypesToQuery = ECC_TO_BITFIELD(QueryChannel);
        IgnoreMask = 0;
    }
 
    FCollisionObjectQueryParams(const TArray<TEnumAsByte<EObjectTypeQuery> > & ObjectTypes)
    {
        ObjectTypesToQuery = 0;
 
        for (auto Iter = ObjectTypes.CreateConstIterator(); Iter; ++Iter)
        {
            AddObjectTypesToQuery(UEngineTypes::ConvertToCollisionChannel((*Iter).GetValue()));
        }
 
        IgnoreMask = 0;
    }
 
    FCollisionObjectQueryParams(enum FCollisionObjectQueryParams::InitType QueryType)
    {
        switch (QueryType)
        {
        case AllObjects:
            ObjectTypesToQuery = FCollisionQueryFlag::Get().GetAllObjectsQueryFlag();
            break;
        case AllStaticObjects:
            ObjectTypesToQuery = FCollisionQueryFlag::Get().GetAllStaticObjectsQueryFlag();
            break;
        case AllDynamicObjects:
            ObjectTypesToQuery = FCollisionQueryFlag::Get().GetAllDynamicObjectsQueryFlag();
            break;
        }
 
        IgnoreMask = 0;
        
    };
 
    // to do this, use ECC_TO_BITFIELD to convert to bit field
    // i.e. FCollisionObjectQueryParams ( ECC_TO_BITFIELD(ECC_WorldStatic) | ECC_TO_BITFIELD(ECC_WorldDynamic) )
    FCollisionObjectQueryParams(int32 InObjectTypesToQuery)
    {
        ObjectTypesToQuery = InObjectTypesToQuery;
        IgnoreMask = 0;
        DoVerify();
    }
 
    void AddObjectTypesToQuery(ECollisionChannel QueryChannel)
    {
        ObjectTypesToQuery |= ECC_TO_BITFIELD(QueryChannel);
        DoVerify();
    }
 
    void RemoveObjectTypesToQuery(ECollisionChannel QueryChannel)
    {
        ObjectTypesToQuery &= ~ECC_TO_BITFIELD(QueryChannel);
        DoVerify();
    }
 
    int32 GetQueryBitfield() const
    {
        checkSlow(IsValid());
 
        return ObjectTypesToQuery;
    }
 
    bool IsValid() const
    { 
        return (ObjectTypesToQuery != 0); 
    }
 
    static bool IsValidObjectQuery(ECollisionChannel QueryChannel) 
    {
        // return true if this belong to object query type
        return (ECC_TO_BITFIELD(QueryChannel) & FCollisionQueryFlag::Get().GetAllObjectsQueryFlag()) != 0;
    }
 
    void DoVerify() const
    {
        // you shouldn't use Trace Types to be Object Type Query parameter. This is not technical limitation, but verification process. 
        checkSlow((ObjectTypesToQuery & FCollisionQueryFlag::Get().GetAllObjectsQueryFlag()) == ObjectTypesToQuery);
    }
 
    static inline FCollisionObjectQueryParams::InitType GetCollisionChannelFromOverlapFilter(EOverlapFilterOption Filter)
    {
        static FCollisionObjectQueryParams::InitType ConvertMap[3] = { FCollisionObjectQueryParams::InitType::AllObjects, FCollisionObjectQueryParams::InitType::AllDynamicObjects, FCollisionObjectQueryParams::InitType::AllStaticObjects };
        return ConvertMap[Filter];
    }
    static ENGINE_API FCollisionObjectQueryParams DefaultObjectQueryParam;
};