ChaosVisualDebuggerTrace.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
#include "Chaos/Core.h"
#include "Chaos/ParticleHandleFwd.h"
#include "Chaos/Serializable.h"
#include "Containers/Set.h"
 
#include "Chaos/ChaosArchive.h"
#include "ChaosVDContextProvider.h"
#include "ChaosVDOptionalDataChannel.h"
#include "Chaos/ParticleIterator.h"
#include "HAL/ThreadSafeBool.h"
 
#ifndef CHAOS_VISUAL_DEBUGGER_ENABLED
    #define CHAOS_VISUAL_DEBUGGER_ENABLED WITH_CHAOS_VISUAL_DEBUGGER
#endif
 
#ifndef CHAOS_VISUAL_DEBUGGER_WITHOUT_TRACE
    #define CHAOS_VISUAL_DEBUGGER_WITHOUT_TRACE 0
#endif
 
#include "Chaos/Framework/PhysicsSolverBase.h"
#include "ChaosVisualDebugger/ChaosVDTraceMacros.h"
 
#if WITH_CHAOS_VISUAL_DEBUGGER
 
#include "Chaos/ChaosDebugNameDefines.h"
#include "ChaosVDMemWriterReader.h"
#include "ChaosVDRuntimeModule.h"
#include "Containers/StripedMap.h"
#include "DataWrappers/ChaosVDImplicitObjectDataWrapper.h"
#include "Trace/Trace.h"
#include "Trace/Trace.inl"
 
namespace Chaos
{
class FRigidClustering;
class FAccelerationStructureHandle;
class FCharacterGroundConstraintContainer;
class FPBDConstraintContainer;
class FPBDJointConstraints;
}
 
UE_TRACE_MINIMAL_CHANNEL_EXTERN(ChaosVDChannel, CHAOS_API)
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDSolverFrameStart)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(UE::Trace::WideString, DebugName)
    UE_TRACE_MINIMAL_EVENT_FIELD(bool, IsKeyFrame)
    UE_TRACE_MINIMAL_EVENT_FIELD(bool, IsReSimulated)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, CurrentFrameNumber)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDSolverFrameEnd)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDParticleCreated)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, ParticleID)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDParticleDestroyed)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, ParticleID)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDSolverStepStart)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(UE::Trace::WideString, StepName)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDSolverStepEnd)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint32, StepNumber)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDBinaryDataStart)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(UE::Trace::WideString, TypeName)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, DataID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint32, DataSize)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint32, OriginalSize)
    UE_TRACE_MINIMAL_EVENT_FIELD(bool, IsCompressed)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDBinaryDataContent)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, DataID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint8[], RawData)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDBinaryDataEnd)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, DataID)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDSolverSimulationSpace)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    CVD_DEFINE_TRACE_VECTOR(Chaos::FReal, Position)
    CVD_DEFINE_TRACE_ROTATOR(Chaos::FReal, Rotation)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDNonSolverLocation)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    CVD_DEFINE_TRACE_VECTOR(Chaos::FReal, Position)
    UE_TRACE_MINIMAL_EVENT_FIELD(UE::Trace::WideString, DebugName)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDNonSolverTransform)
    UE_TRACE_MINIMAL_EVENT_FIELD(uint64, Cycle)
    CVD_DEFINE_TRACE_VECTOR(Chaos::FReal, Position)
    CVD_DEFINE_TRACE_VECTOR(Chaos::FReal, Scale)
    CVD_DEFINE_TRACE_ROTATOR(Chaos::FReal, Rotation)
    UE_TRACE_MINIMAL_EVENT_FIELD(UE::Trace::WideString, DebugName)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDNetworkTickOffset)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, Offset)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDRolledBackDataID)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, DataID)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDUsesAutoRTFM)
    UE_TRACE_MINIMAL_EVENT_FIELD(bool, bUsingAutoRTFM)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDTraceRelevancyVolume)
    CVD_DEFINE_TRACE_VECTOR(Chaos::FReal, BoxMin)
    CVD_DEFINE_TRACE_VECTOR(Chaos::FReal, BoxMax)
UE_TRACE_MINIMAL_EVENT_END()
 
UE_TRACE_MINIMAL_EVENT_BEGIN_EXTERN(ChaosVDLogger, ChaosVDDummyEvent)
    UE_TRACE_MINIMAL_EVENT_FIELD(int32, SolverID)
UE_TRACE_MINIMAL_EVENT_END()
 
struct FChaosVDContext;
struct FChaosVDQueryVisitStep;
struct FChaosVDCollisionResponseParams;
struct FChaosVDCollisionObjectQueryParams;
struct FChaosVDCollisionQueryParams;
enum class EChaosVDSceneQueryMode;
enum class EChaosVDSceneQueryType;
struct FCollisionObjectQueryParams;
struct FCollisionResponseParams;
struct FCollisionQueryParams;
enum ECollisionChannel : int;
 
namespace Chaos
{
    namespace VisualDebugger
    {
        class FChaosVDSerializableNameTable;
    }
 
    class FPBDCollisionConstraints;
    class FPBDRigidsSOAs;
    class FImplicitObject;
    class FPhysicsSolverBase;
    template <typename T, int d>
    class TGeometryParticleHandles;
 
    class FPBDCollisionConstraint;
    class FParticlePairMidPhase;
 
    template <typename PayloadType, typename T, int d>
    class ISpatialAccelerationCollection;
}
 
using FChaosVDImplicitObjectWrapper = FChaosVDImplicitObjectDataWrapper<Chaos::FImplicitObjectPtr, Chaos::FChaosArchive>;
using FChaosVDSerializableNameTable = Chaos::VisualDebugger::FChaosVDSerializableNameTable;
 
enum class EChaosVDTraceBinaryDataOptions
{
    None = 0,
    ForceTrace = 1 << 0
};
ENUM_CLASS_FLAGS(EChaosVDTraceBinaryDataOptions)
 
struct FChaosVDParticleMetadata;
 
namespace Chaos::VD
{
    template<typename TObjectID>
    class FCachedObjectTraceIDByPtr
    {
    public:
 
        template<typename ObjectType, typename HashProducer>
        TObjectID FindOrProduceTraceObjectID(const ObjectType* ObjectPtr, const HashProducer& InHashProducer, bool& OutWasAlreadyCached)
        {
            if (ObjectPtr == nullptr)
            {
                return 0;
            }
 
            bool bHasCachedID = true;
            TObjectID FoundID = CachedIDsByPtr.FindOrProduce(reinterpret_cast<const void*>(ObjectPtr), [&InHashProducer, &bHasCachedID]()
            {
                bHasCachedID = false;
                return InHashProducer();
            });
 
            if (bHasCachedID)
            {
                OutWasAlreadyCached = true;
                return FoundID;
            }
 
            return FoundID;
        }
 
        template<typename ObjectType>
        void RemoveCachedTraceObjectID(const ObjectType* Implicit)
        {
            if (Implicit == nullptr)
            {
                return;
            }
 
            CachedIDsByPtr.Remove(reinterpret_cast<const void*>(Implicit));
        }
 
        void Reset()
        {
            CachedIDsByPtr.Reset();
        }
 
    private:
 
        static constexpr int32 StripCount = 32;
        TStripedMap<StripCount, const void*, TObjectID> CachedIDsByPtr;
    };
 
    struct FRecordingSessionState
    {
        FRecordingSessionState();
 
        DECLARE_DELEGATE_RetVal_TwoParams(FChaosVDParticleMetadata, FParticleMetaDataGeneratorDelegate, const IPhysicsProxyBase*, const Chaos::FGeometryParticleHandle* ParticleHandle)
        FParticleMetaDataGeneratorDelegate ExternalParticleMetadataGenerator;
 
        FDelegateHandle RecordingStartedDelegateHandle;
        FDelegateHandle RecordingStoppedDelegateHandle;
        FDelegateHandle RecordingFullCaptureRequestedHandle;
 
        TSet<int32> SolverIDsForDeltaRecording;
        TSet<int32> RequestedFullCaptureSolverIDs;
        TSharedRef<FChaosVDSerializableNameTable> CVDNameTable;
 
        FBox TraceRelevancyVolume;
 
        std::atomic<bool> bIsTracing;
 
        FCachedObjectTraceIDByPtr<uint32> TracedGeometryHashCache;
 
        FCachedObjectTraceIDByPtr<uint64> ParticleMetadataIDsCache;
 
        FRWLock DeltaRecordingStatesLock;
 
        uint64 GenerateUniqueID()
        {
            uint64 NewID = 0;
            UE_AUTORTFM_OPEN
            {
                NewID = InternalGenericIDCounter++;
            };
 
            return NewID;
        }
 
        static constexpr uint64 InvalidUniqueID = 0; 
 
        private:
        std::atomic<uint64> InternalGenericIDCounter;
    };
}
 
class FChaosVisualDebuggerTrace
{
public:
    static CHAOS_API void TraceParticle(const Chaos::FGeometryParticleHandle* ParticleHandle);
 
    static CHAOS_API void TraceParticles(const Chaos::TGeometryParticleHandles<Chaos::FReal, 3>& ParticleHandles);
    
    static CHAOS_API void TraceParticleDestroyed(const Chaos::FGeometryParticleHandle* ParticleHandle);
 
    static CHAOS_API void TraceParticlesSoA(const Chaos::FPBDRigidsSOAs& ParticlesSoA, Chaos::FRigidClustering* ClusteringData = nullptr);
 
    template<typename ParticleType>
    static void TraceParticlesView(const Chaos::TParticleView<ParticleType>& ParticlesView);
 
    static CHAOS_API void TraceMidPhase(const Chaos::FParticlePairMidPhase* MidPhase);
 
    static CHAOS_API void TraceMidPhasesFromCollisionConstraints(Chaos::FPBDCollisionConstraints& InCollisionConstraints);
 
    static CHAOS_API void TraceJointsConstraints(Chaos::FPBDJointConstraints& InJointConstraints);
 
    static CHAOS_API void TraceCharacterGroundConstraints(Chaos::FCharacterGroundConstraintContainer& InConstraints);
 
    static CHAOS_API void TraceCollisionConstraint(const Chaos::FPBDCollisionConstraint* CollisionConstraint);
 
    static CHAOS_API void TraceCollisionConstraintView(TArrayView<Chaos::FPBDCollisionConstraint* const> CollisionConstraintView);
 
    static CHAOS_API void TraceConstraintsContainer(TConstArrayView<Chaos::FPBDConstraintContainer*> ConstraintContainersView);
 
    static CHAOS_API void TraceSolverFrameStart(const FChaosVDContext& ContextData, const FString& InDebugName, int32 FrameNumber = INDEX_NONE);
    
    static CHAOS_API void TraceSolverFrameEnd(const FChaosVDContext& ContextData);
 
    static CHAOS_API void TraceSolverStepStart(FStringView StepName);
    static CHAOS_API void TraceSolverStepEnd();
 
    static CHAOS_API void TraceSolverSimulationSpace(const Chaos::FRigidTransform3& Transform);
 
    static CHAOS_API void TraceBinaryData(TConstArrayView<uint8> InData, FStringView TypeName, EChaosVDTraceBinaryDataOptions Options = EChaosVDTraceBinaryDataOptions::None);
 
    UE_DEPRECATED(5.7, "Use the TraceImplicitObject version that takes a ptr to the implicit object itself")
    static CHAOS_API void TraceImplicitObject(FChaosVDImplicitObjectWrapper WrappedGeometryData);
 
    static CHAOS_API uint32 TraceImplicitObject(Chaos::FImplicitObject* GeometryPtr);
 
    static CHAOS_API uint64 TraceParticleMetadata(Chaos::FGeometryParticleHandle* InParticleHandle);
 
    static CHAOS_API void InvalidateGeometryFromCache(const Chaos::FImplicitObject* CachedGeometryToInvalidate);
 
    static CHAOS_API void InvalidateParticleMetadataFromCache(Chaos::FGeometryParticleHandle* InParticleToInvalidate);
 
    static CHAOS_API void TraceSceneQueryStart(const Chaos::FImplicitObject* InputGeometry, const FQuat& GeometryOrientation, const FVector& Start, const FVector& End, ECollisionChannel TraceChannel, FChaosVDCollisionQueryParams&& Params, FChaosVDCollisionResponseParams&& ResponseParams, FChaosVDCollisionObjectQueryParams&& ObjectParams, EChaosVDSceneQueryType QueryType, EChaosVDSceneQueryMode QueryMode, int32 SolverID, bool bIsRetry);
 
    static CHAOS_API void TraceSceneQueryVisit(FChaosVDQueryVisitStep&& InQueryVisitData);
 
    static CHAOS_API void TraceSceneAccelerationStructures(const Chaos::ISpatialAccelerationCollection<Chaos::FAccelerationStructureHandle, Chaos::FReal, 3>* InAccelerationCollection);
 
    static CHAOS_API void TraceNetworkTickOffset(int32 TickOffset, int32 SolverID);
 
    static CHAOS_API void TraceDebugDrawBox(const FBox& InBox, FName Tag = NAME_None, FColor Color = FColor::Blue, int32 SolverID = INDEX_NONE);
    
    static CHAOS_API void TraceDebugDrawLine(const FVector& InStartLocation, const FVector& InEndLocation, FName Tag = NAME_None, FColor Color = FColor::Blue, int32 SolverID = INDEX_NONE);
    
    static CHAOS_API void TraceDebugDrawVector(const FVector& InStartLocation, const FVector& InVector, FName Tag = NAME_None, FColor Color = FColor::Blue, int32 SolverID = INDEX_NONE);
 
    static CHAOS_API void TraceDebugDrawSphere(const FVector& Center, float Radius, FName Tag = NAME_None, FColor Color = FColor::Blue, int32 SolverID = INDEX_NONE);
 
    static CHAOS_API void TraceDebugDrawImplicitObject(const Chaos::FImplicitObject* Implicit, const FTransform& InParentTransform, FName Tag = NAME_None, FColor Color = FColor::Blue, int32 SolverID = INDEX_NONE);
 
    static CHAOS_API void SetTraceRelevancyVolume(const FBox& InTraceRelevancyVolume);
 
    /*
     * Returns the currently bounding box used to determine if we should trace data or not, for objects that can be applied to.
     */
    static FBox GetTraceRelevancyVolume()
    {
        return SessionState.TraceRelevancyVolume;
    }
 
    static bool IsInRelevancyVolume(const Chaos::FAABB3& InChaosBounds)
    {
        if (!SessionState.TraceRelevancyVolume.IsValid)
        {
            // An invalid volume means we want to trace everything
            return true;
        }
 
        return SessionState.TraceRelevancyVolume.Intersect(FBox(InChaosBounds.Min(), InChaosBounds.Max()));
    }
 
    static bool IsInRelevancyVolume(const FBox& InBounds)
    {
        if (!SessionState.TraceRelevancyVolume.IsValid)
        {
            // An invalid volume means we want to trace everything
            return true;
        }
 
        return SessionState.TraceRelevancyVolume.Intersect(InBounds);
    }
 
    static bool IsInRelevancyVolume(const FVector& Center, double Radius)
    {
        if (!SessionState.TraceRelevancyVolume.IsValid)
        {
            // An invalid volume means we want to trace everything
            return true;
        }
    
        return FMath::SphereAABBIntersection(Center, Radius * Radius, SessionState.TraceRelevancyVolume);
    }
 
    static bool IsInRelevancyVolume(const Chaos::FVec3& InPosition)
    {
        if (!SessionState.TraceRelevancyVolume.IsValid)
        {
            // An invalid volume means we want to trace everything
            return true;
        }
 
        return FMath::PointBoxIntersection(InPosition, SessionState.TraceRelevancyVolume);
    }
 
    static bool IsInRelevancyVolume(const Chaos::FVec3& InStartPoint, const Chaos::FVec3& InEndPoint)
    {
        if (!SessionState.TraceRelevancyVolume.IsValid)
        {
            // An invalid volume means we want to trace everything
            return true;
        }
 
        return SessionState.TraceRelevancyVolume.Intersect(FBox(FVector::Min(InStartPoint, InEndPoint), FVector::Max(InStartPoint, InEndPoint)));
    }
 
    static bool IsInRelevancyVolume(const Chaos::FGeometryParticleHandle* InParticleHandle);
    static bool IsInRelevancyVolume(const Chaos::FImplicitObject* Geometry, const Chaos::FRigidTransform3& InTransform);
 
    template<typename WorldType>
    static int32 GetSolverIDFromWorld(WorldType* World);
 
    static int32 CHAOS_API GetSolverID(Chaos::FPhysicsSolverBase& Solver);
 
    static CHAOS_API bool ShouldPerformFullCapture(int32 SolverID);
 
    template<typename T>
    static void GetCVDContext(T& ObjectWithContext, FChaosVDContext& OutCVDContext);
 
    template<typename T>
    static FString GetDebugName(T& ObjectWithDebugName);
 
    static CHAOS_API bool IsTracing();
 
    static void RegisterEventHandlers();
    
    static void UnregisterEventHandlers();
 
    static CHAOS_API TSharedRef<FChaosVDSerializableNameTable>& GetNameTableInstance();
 
    static CHAOS_API void OverrideDefaultEnabledDataChannels(TConstArrayView<FString> EnabledDataChannelsOverrideList);
 
    static CHAOS_API void RegisterExternalParticleDebugNameGenerator(const Chaos::VD::FRecordingSessionState::FParticleMetaDataGeneratorDelegate& InCallback);
 
private:
 
    static CHAOS_API void TraceParticleClusterChildData(const Chaos::TParticleView<Chaos::TPBDRigidParticles<Chaos::FReal, 3>>& ParticlesView, Chaos::FRigidClustering* ClusteringData, const FChaosVDContext& CVDContextData);
 
    static CHAOS_API void TraceParticle(Chaos::FGeometryParticleHandle* ParticleHandle, const FChaosVDContext& ContextData);
 
    static void TraceNonSolverLocation(const FVector& InLocation, FStringView DebugNameID);
 
    static void TraceNonSolverTransform(const FTransform& InTransform, FStringView DebugNameID);
 
    static bool CanTraceDebugDrawShape(int32& OutSolverID);
    
    static void Reset();
 
    static void HandleRecordingStop();
    static void TraceArchiveHeader();
    static void HandleRecordingStart();
 
    static void PerformFullCapture(EChaosVDFullCaptureFlags CaptureOptions);
 
    static void SetupForFullCaptureIfNeeded(int32 SolverID, bool& bOutFullCaptureRequested);
 
    static Chaos::VD::FRecordingSessionState SessionState;
 
    friend class FChaosEngineModule;
};
 
template <typename ParticleType>
void FChaosVisualDebuggerTrace::TraceParticlesView(const Chaos::TParticleView<ParticleType>& ParticlesView)
{
    if (!IsTracing())
    {
        return;
    }
 
    const FChaosVDContext* CVDContextData = FChaosVDThreadContext::Get().GetCurrentContext(EChaosVDContextType::Solver);
    if (!ensure(CVDContextData))
    {
        return;
    }
 
    FChaosVDContext CopyContext = *CVDContextData;
    
    ParticlesView.ParallelFor([CopyContext](auto& Particle, int32 Index)
    {
        CVD_SCOPE_CONTEXT(CopyContext);
        TraceParticle(Particle.Handle());
    });
}
 
template <typename WorldType>
int32 FChaosVisualDebuggerTrace::GetSolverIDFromWorld(WorldType* World)
{
    int32 SolverID = INDEX_NONE;
    if (World)
    {
        if (Chaos::FPhysicsSolverBase* Solver = World->GetPhysicsScene() ? World->GetPhysicsScene()->GetSolver() : nullptr)
        {
            SolverID = GetSolverID(*Solver);
        }
    }
 
    return SolverID;
}
 
template <typename T>
void FChaosVisualDebuggerTrace::GetCVDContext(T& ObjectWithContext, FChaosVDContext& OutCVDContext)
{
    OutCVDContext = ObjectWithContext.GetChaosVDContextData();  
}
 
template <typename T>
FString FChaosVisualDebuggerTrace::GetDebugName(T& ObjectWithDebugName)
{
#if CHAOS_SOLVER_DEBUG_NAME
    return ObjectWithDebugName.GetDebugName().ToString();
#else
    return FString("COMPILED OUT");
#endif
}
 
struct FChaosVDScopeSolverStep
{
    FChaosVDScopeSolverStep(FStringView StepName)
    {
        CVD_TRACE_SOLVER_STEP_START(StepName);
    }
 
    ~FChaosVDScopeSolverStep()
    {
        CVD_TRACE_SOLVER_STEP_END();
    }
};
 
template<typename T>
struct FChaosVDScopeSolverFrame
{
    FChaosVDScopeSolverFrame(T& InSolverRef) : SolverRef(InSolverRef)
    {
        CVD_TRACE_SOLVER_START_FRAME(T, SolverRef);
    }
 
    ~FChaosVDScopeSolverFrame()
    {
        CVD_TRACE_SOLVER_END_FRAME(T, SolverRef);
    }
 
    T& SolverRef;
};
 
struct FChaosVDScopeSceneQueryVisit
{
    FChaosVDScopeSceneQueryVisit(FChaosVDQueryVisitStep& InVisitData) : VisitData(InVisitData)
    {
    }
 
    ~FChaosVDScopeSceneQueryVisit()
    {
        CVD_TRACE_SCENE_QUERY_VISIT(MoveTemp(VisitData));
    }
 
    FChaosVDQueryVisitStep& VisitData;
};
 
namespace Chaos::VisualDebugger
{
    template<typename TDataToSerialize>
    void WriteDataToBuffer(TArray<uint8>& InOutDataBuffer, TDataToSerialize& Data)
    {
        FChaosVDMemoryWriter MemWriterAr(InOutDataBuffer, FChaosVisualDebuggerTrace::GetNameTableInstance());
        MemWriterAr.SetShouldSkipUpdateCustomVersion(true);
 
        Data.Serialize(MemWriterAr);
    }
 
    template<typename TDataToSerialize, typename TArchive>
    void WriteDataToBuffer(TArray<uint8>& InOutDataBuffer, TDataToSerialize& Data)
    {
        FChaosVDMemoryWriter MemWriterAr(InOutDataBuffer, FChaosVisualDebuggerTrace::GetNameTableInstance());
        TArchive Ar(MemWriterAr);
        Ar.SetShouldSkipUpdateCustomVersion(true);
 
        Data.Serialize(Ar);
    }
}
#endif // WITH_CHAOS_VISUAL_DEBUGGER