ChaosVDQueryDataWrappers.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
#include "ChaosVDParticleDataWrapper.h"
#include "Math/BoxSphereBounds.h"
 
#include "ChaosVDQueryDataWrappers.generated.h"
 
UENUM()
enum class EChaosVDSceneQueryType
{
    Invalid,
    Sweep,
    Overlap,
    RayCast
};
 
UENUM()
enum class EChaosVDSceneQueryMode
{
    Single,
    Multi,
    Test,
    Invalid
};
 
USTRUCT()
struct FChaosVDCollisionResponseParams : public FChaosVDWrapperDataBase
{
    GENERATED_BODY()
 
    CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
 
    template <typename TOther>
    void CopyFrom(const TOther& Other)
    {
        const int32 ArrayNum = UE_ARRAY_COUNT(Other.CollisionResponse.EnumArray);
        for (int32 ChannelIndex = 0; ChannelIndex < ArrayNum; ++ChannelIndex)
        {
            FlagsPerChannel.Add(Other.CollisionResponse.EnumArray[ChannelIndex]);
        }
 
        bHasValidData = true;
    }
 
    TArray<uint8, TInlineAllocator<32>> FlagsPerChannel;
};
 
inline FArchive& operator<<(FArchive& Ar, FChaosVDCollisionResponseParams& Data)
{
    Data.Serialize(Ar);
    return Ar;
}
 
template<>
struct TStructOpsTypeTraits<FChaosVDCollisionResponseParams> : public TStructOpsTypeTraitsBase2<FChaosVDCollisionResponseParams>
{
    enum
    {
        WithSerializer = true,
    };
};
 
USTRUCT()
struct FChaosVDCollisionObjectQueryParams : public FChaosVDWrapperDataBase
{
    GENERATED_BODY()
 
    CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
 
    template <typename TOther>
    void CopyFrom(const TOther& Other)
    {
        ObjectTypesToQuery = Other.ObjectTypesToQuery;
        IgnoreMask = Other.IgnoreMask;
        bHasValidData = true;
    }
    
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint8 ObjectTypesToQuery = 0;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint8 IgnoreMask = 0;
};
 
inline FArchive& operator<<(FArchive& Ar, FChaosVDCollisionObjectQueryParams& Data)
{
    Data.Serialize(Ar);
    return Ar;
}
 
template<>
struct TStructOpsTypeTraits<FChaosVDCollisionObjectQueryParams> : public TStructOpsTypeTraitsBase2<FChaosVDCollisionObjectQueryParams>
{
    enum
    {
        WithSerializer = true,
    };
};
 
UENUM()
enum class EChaosVDCollisionQueryParamsFlags : uint16
{
    None = 0,
    TraceComplex = 1 << 0,
    FindInitialOverlaps = 1 << 1,
    ReturnFaceIndex = 1 << 2,
    ReturnPhysicalMaterial = 1 << 3,
    IgnoreBlocks = 1 << 4,
    IgnoreTouches = 1 << 5,
    SkipNarrowPhase = 1 << 6,
    TraceIntoSubComponents = 1 << 7,
    ReplaceHitWithSubComponents = 1 << 8
};
 
ENUM_CLASS_FLAGS(EChaosVDCollisionQueryParamsFlags)
 
USTRUCT()
struct FChaosVDCollisionQueryParams : public FChaosVDWrapperDataBase
{
    GENERATED_BODY()
 
    CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
 
    template <typename TOther>
    void CopyFrom(const TOther& Other)
    {
        TraceTag = Other.TraceTag;
        OwnerTag = Other.OwnerTag;
        bTraceComplex = Other.bTraceComplex;
        bFindInitialOverlaps = Other.bFindInitialOverlaps;
        bReturnFaceIndex = Other.bReturnFaceIndex;
        bReturnPhysicalMaterial = Other.bReturnPhysicalMaterial;
        bIgnoreBlocks = Other.bIgnoreBlocks;
        bIgnoreTouches = Other.bIgnoreTouches;
        bSkipNarrowPhase = Other.bSkipNarrowPhase;
        bTraceIntoSubComponents = Other.bTraceIntoSubComponents;
        bReplaceHitWithSubComponents = Other.bReplaceHitWithSubComponents;
        IgnoreMask = Other.IgnoreMask;
 
        bHasValidData = true;
    }
    
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    FName TraceTag;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    FName OwnerTag;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bTraceComplex : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bFindInitialOverlaps : 1= false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bReturnFaceIndex : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bReturnPhysicalMaterial : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bIgnoreBlocks : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bIgnoreTouches : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bSkipNarrowPhase : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bTraceIntoSubComponents : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint16 bReplaceHitWithSubComponents : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    uint8 IgnoreMask = 0;
 
    TArray<uint32> IgnoredComponentsIDs;
 
    TArray<uint32> IgnoredActorsIDs;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    TArray<FName> IgnoredActorsNames;
    
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    TArray<FName> IgnoredComponentsNames;
};
 
inline FArchive& operator<<(FArchive& Ar, FChaosVDCollisionQueryParams& Data)
{
    Data.Serialize(Ar);
    return Ar;
}
 
template<>
struct TStructOpsTypeTraits<FChaosVDCollisionQueryParams> : public TStructOpsTypeTraitsBase2<FChaosVDCollisionQueryParams>
{
    enum
    {
        WithSerializer = true,
    };
};
 
UENUM()
enum class EChaosVDQueryFastDataParallelFlags : uint8
{
    None = 0,
    Parallel0 = 1 << 0,
    Parallel1 = 1 << 1,
    Parallel2 = 1 << 2
};
 
USTRUCT()
struct FChaosVDQueryFastData : public FChaosVDWrapperDataBase
{
    GENERATED_BODY()
 
    CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
 
    UPROPERTY(VisibleAnywhere, Category=QueryFastData)
    FVector Dir = FVector::ZeroVector;
    
    UPROPERTY(VisibleAnywhere, Category=QueryFastData)
    FVector InvDir = FVector::ZeroVector;
    
    UPROPERTY(VisibleAnywhere, Category=QueryFastData)
    double CurrentLength = 0.0;
 
    UPROPERTY(VisibleAnywhere, Category=QueryFastData)
    double InvCurrentLength = 0.0;
 
    UPROPERTY(VisibleAnywhere, Category=QueryFastData)
    uint8 bParallel0 : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryFastData)
    uint8 bParallel1 : 1 = false;
 
    UPROPERTY(VisibleAnywhere, Category=QueryFastData)
    uint8 bParallel2 : 1 = false;
};
 
inline FArchive& operator<<(FArchive& Ar, FChaosVDQueryFastData& Data)
{
    Data.Serialize(Ar);
    return Ar;
}
 
template<>
struct TStructOpsTypeTraits<FChaosVDQueryFastData> : public TStructOpsTypeTraitsBase2<FChaosVDQueryFastData>
{
    enum
    {
        WithSerializer = true,
    };
};
 
UENUM(meta = (Bitflags, UseEnumValuesAsMaskValuesInEditor = "true"))
enum class EChaosVDSQHitFlags : uint16
{
    None =          0,
    Position =      1 << 0,
    Normal =        1 << 1,
    Distance =      1 << 2,
    UV =            1 << 3,
    MTD =           1 << 9,
    FaceIndex =     1 << 10
};
 
ENUM_CLASS_FLAGS(EChaosVDSQHitFlags)
 
USTRUCT()
struct FChaosVDQueryHitData : public FChaosVDWrapperDataBase
{
    GENERATED_BODY()
 
    CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    float Distance = 0.0f;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    int32 FaceIdx = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData, meta = (Bitmask, BitmaskEnum = "/Script/ChaosVDRuntime.EChaosVDSQHitFlags"))
    uint16 Flags = 0;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    FVector WorldPosition = FVector::ZeroVector;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    FVector WorldNormal = FVector::ZeroVector;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    FVector FaceNormal = FVector::ZeroVector;
};
 
inline FArchive& operator<<(FArchive& Ar, FChaosVDQueryHitData& Data)
{
    Data.Serialize(Ar);
    return Ar;
}
 
template<>
struct TStructOpsTypeTraits<FChaosVDQueryHitData> : public TStructOpsTypeTraitsBase2<FChaosVDQueryHitData>
{
    enum
    {
        WithSerializer = true,
    };
};
 
UENUM()
enum class EChaosVDCollisionQueryHitType
{
    None = 0,
    Touch = 1,
    Block = 2
};
 
UENUM()
enum class EChaosVDSQVisitRejectReason
{
    None = 0,
    NoHit = 1,
    PreFilter = 2,
    PostFilter = 3,
    ColocatedHitHasWorseNormal = 4,
    FailedFastBoundTest = 5
};
 
UENUM()
enum class EChaosVDSceneQueryVisitorType
{
    Invalid,
    BroadPhase,
    NarrowPhase
};
 
USTRUCT()
struct FChaosVDQueryVisitStep : public FChaosVDWrapperDataBase
{
    GENERATED_BODY()
 
    CHAOSVDRUNTIME_API static FStringView WrapperTypeName;
 
    CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
 
    int32 OwningQueryID = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    EChaosVDSceneQueryVisitorType Type = EChaosVDSceneQueryVisitorType::Invalid;
 
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    uint32 ShapeIndex = 0;
    
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    int32 ParticleIndex = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    FTransform ParticleTransform;
 
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    FChaosVDQueryFastData QueryFastData;
    
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    EChaosVDCollisionQueryHitType HitType = EChaosVDCollisionQueryHitType::None;
 
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    FChaosVDQueryHitData HitData;
 
    UPROPERTY(VisibleAnywhere, Category="SQ Visit Data")
    EChaosVDSQVisitRejectReason RejectReason = EChaosVDSQVisitRejectReason::None;
 
    int32 SolverID_Editor = INDEX_NONE;
};
 
inline FArchive& operator<<(FArchive& Ar, FChaosVDQueryVisitStep& Data)
{
    Data.Serialize(Ar);
    return Ar;
}
 
template<>
struct TStructOpsTypeTraits<FChaosVDQueryVisitStep> : public TStructOpsTypeTraitsBase2<FChaosVDQueryVisitStep>
{
    enum
    {
        WithSerializer = true,
    };
};
 
USTRUCT()
struct FChaosVDQueryDataWrapper
{
    GENERATED_BODY()
 
    CHAOSVDRUNTIME_API static FStringView WrapperTypeName;
 
    CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
 
    UPROPERTY(VisibleAnywhere, Category="CVD QueryData")
    int32 ID = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, Category="CVD QueryData")
    int32 ParentQueryID = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, Category="CVD QueryData")
    int32 WorldSolverID = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    bool bIsRetryQuery = false;
 
    uint32 InputGeometryKey = 0;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    FQuat GeometryOrientation = FQuat::Identity;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    EChaosVDSceneQueryType Type = EChaosVDSceneQueryType::Invalid;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    EChaosVDSceneQueryMode Mode = EChaosVDSceneQueryMode::Invalid;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    FVector StartLocation = FVector::ZeroVector;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    FVector EndLocation = FVector::ZeroVector;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    int32 CollisionChannel = INDEX_NONE;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    FChaosVDCollisionQueryParams CollisionQueryParams;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    FChaosVDCollisionResponseParams CollisionResponseParams;
 
    UPROPERTY(VisibleAnywhere, Category=RecordedQueryData)
    FChaosVDCollisionObjectQueryParams CollisionObjectQueryParams;
 
    TArray<FChaosVDQueryVisitStep> SQVisitData;
 
    UPROPERTY(VisibleAnywhere, Category=QueryData)
    TArray<FChaosVDQueryVisitStep> Hits;
 
    TArray<int32> SubQueriesIDs;
 
    int32 CurrentVisitIndex = 0;
};
 
inline FArchive& operator<<(FArchive& Ar, FChaosVDQueryDataWrapper& Data)
{
    Data.Serialize(Ar);
    return Ar;
}
 
template<>
struct TStructOpsTypeTraits<FChaosVDQueryDataWrapper> : public TStructOpsTypeTraitsBase2<FChaosVDQueryDataWrapper>
{
    enum
    {
        WithSerializer = true,
    };
};
 
USTRUCT()
struct FChaosVDSceneQueriesDataContainer
{
    GENERATED_BODY()
 
    TMap<int32, TMap<int32, TSharedPtr<FChaosVDQueryDataWrapper>>> RecordedSceneQueriesBySolverID;
 
    TMap<int32, TSharedPtr<FChaosVDQueryDataWrapper>> RecordedSceneQueriesByQueryID;
};