504 lines
13 KiB
C++
504 lines
13 KiB
C++
// 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,
|
|
/** Whether we should trace against complex collision */
|
|
TraceComplex = 1 << 0,
|
|
/** Whether we want to find out initial overlap or not. If true, it will return if this was initial overlap. */
|
|
FindInitialOverlaps = 1 << 1,
|
|
/** Whether we want to return the triangle face index for complex static mesh traces */
|
|
ReturnFaceIndex = 1 << 2,
|
|
/** Whether we want to include the physical material in the results. */
|
|
ReturnPhysicalMaterial = 1 << 3,
|
|
/** Whether to ignore blocking results. */
|
|
IgnoreBlocks = 1 << 4,
|
|
/** Whether to ignore touch/overlap results. */
|
|
IgnoreTouches = 1 << 5,
|
|
/** Whether to skip narrow phase checks (only for overlaps). */
|
|
SkipNarrowPhase = 1 << 6,
|
|
/** Whether to ignore traces to the cluster union and trace against its children instead. */
|
|
TraceIntoSubComponents = 1 << 7,
|
|
/** Extra filtering done on the query. See declaration for filtering logic */
|
|
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;
|
|
}
|
|
|
|
/** Tag used to provide extra information or filtering for debugging of the trace (e.g. Collision Analyzer) */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
FName TraceTag;
|
|
|
|
/** Tag used to indicate an owner for this trace */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
FName OwnerTag;
|
|
|
|
/** Whether we should trace against complex collision */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bTraceComplex : 1 = false;
|
|
|
|
/** Whether we want to find out initial overlap or not. If true, it will return if this was initial overlap. */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bFindInitialOverlaps : 1= false;
|
|
|
|
/** Whether we want to return the triangle face index for complex static mesh traces */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bReturnFaceIndex : 1 = false;
|
|
|
|
/** Whether we want to include the physical material in the results. */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bReturnPhysicalMaterial : 1 = false;
|
|
|
|
/** Whether to ignore blocking results. */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bIgnoreBlocks : 1 = false;
|
|
|
|
/** Whether to ignore touch/overlap results. */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bIgnoreTouches : 1 = false;
|
|
|
|
/** Whether to skip narrow phase checks (only for overlaps). */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bSkipNarrowPhase : 1 = false;
|
|
|
|
/** Whether to ignore traces to the cluster union and trace against its children instead. */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bTraceIntoSubComponents : 1 = false;
|
|
|
|
/** If bTraceIntoSubComponents is true, whether to replace the hit of the cluster union with its children instead. */
|
|
UPROPERTY(VisibleAnywhere, Category=QueryData)
|
|
uint16 bReplaceHitWithSubComponents : 1 = false;
|
|
|
|
/** Extra filtering done on the query. See declaration for filtering logic */
|
|
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,
|
|
};
|
|
};
|
|
|
|
/** Possible results from a scene query */
|
|
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;
|
|
|
|
/** This is not used for Line Traces */
|
|
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()
|
|
|
|
inline static FStringView WrapperTypeName = TEXT("FChaosVDQueryVisitStep");
|
|
|
|
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;
|
|
|
|
/** Cached solver id property populated and used during playback of an already loaded file .
|
|
* This should not be serialized
|
|
*/
|
|
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()
|
|
|
|
inline static FStringView WrapperTypeName = TEXT("FChaosVDQueryDataWrapper");
|
|
|
|
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;
|
|
};
|