ChaosVDDataWrapperUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Chaos/AABBTree.h"
#include "Chaos/Collision/ContactPoint.h"
#include "Chaos/ParticleHandle.h"
#include "Chaos/ShapeInstanceFwd.h"
#include "DataWrappers/ChaosVDCollisionDataWrappers.h"
#include "DataWrappers/ChaosVDAccelerationStructureDataWrappers.h"
#include "Chaos/ISpatialAccelerationCollection.h"
 
struct FChaosVDJointSettingsDataWrapper;
 
namespace Chaos
{
class FJointConstraint;
class FSolverSerializer;
}
 
struct FChaosVDAABBTreeDataWrapper;
struct FChaosVDCharacterGroundConstraint;
struct FChaosVDJointConstraint;
 
namespace Chaos
{
    class FCharacterGroundConstraintHandle;
    class FPBDJointConstraintHandle;
 
    namespace VisualDebugger
    {
        class FChaosVDSerializableNameTable;
    }
 
    class FParticlePairMidPhase;
    class FPBDCollisionConstraint;
    class FPBDCollisionConstraintMaterial;
}
 
class FChaosVisualDebuggerTrace;
struct FChaosVDCollisionMaterial;
struct FChaosVDConstraint;
struct FChaosVDParticlePairMidPhase;
struct FChaosVDParticleDataWrapper;
 
namespace Chaos::VisualDebugger::Utils
{
    template<typename InType,typename OutType, int32 Size, typename TransformT>
    void TransformStaticArray(const InType (&In)[Size], OutType (&Out)[Size], TransformT Trans)
    {
        for (int32 Index = 0; Index < Size; Index++)
        {
            Out[Index] = Invoke(Trans, In[Index]);
        }
    }
 
    template<typename InType,typename OutType, int32 Size>
    void CopyStaticArray(const InType (&In)[Size], OutType (&Out)[Size])
    {
        FMemory::Memcpy(Out, In, Size * sizeof(InType));
    }
 
    inline FTransform ConvertToFTransform(const FRigidTransform3& InChaosTransform)
    {
        return InChaosTransform;
    }
}
 
class FChaosVDDataWrapperUtils
{
private:
 
    static void CopyManifoldPointsToDataWrapper(const Chaos::FManifoldPoint& InCopyFrom, FChaosVDManifoldPoint& OutCopyTo);
 
    static void CopyManifoldPointResultsToDataWrapper(const Chaos::FManifoldPointResult& InCopyFrom, FChaosVDManifoldPoint& OutCopyTo);
 
    static void CopyCollisionMaterialToDataWrapper(const Chaos::FPBDCollisionConstraintMaterial& InCopyFrom, FChaosVDCollisionMaterial& OutCopyTo);
public:
    UE_INTERNAL static FChaosVDParticleDataWrapper BuildParticleDataWrapperFromParticle(const Chaos::FGeometryParticleHandle* ParticleHandlePtr);
    UE_INTERNAL static FChaosVDParticleDataWrapper BuildParticleDataWrapperFromGTParticle(const Chaos::FGeometryParticle* GTParticle);
 
private:
    static FChaosVDConstraint BuildConstraintDataWrapperFromConstraint(const Chaos::FPBDCollisionConstraint& InConstraint);
 
    static FChaosVDParticlePairMidPhase BuildMidPhaseDataWrapperFromMidPhase(const Chaos::FParticlePairMidPhase& InMidPhase);
    static void CopyJointConstraintSettingsToWrapper(const Chaos::FPBDJointSettings& InSettings, FChaosVDJointSettingsDataWrapper& InOutWrappedJointSettingsData);
 
public:
    UE_INTERNAL static FChaosVDJointConstraint BuildJointDataWrapper(const Chaos::FPBDJointConstraintHandle* ConstaintHanlde);
    UE_INTERNAL static FChaosVDJointConstraint BuildGTJointDataWrapper(Chaos::FJointConstraint* GTConstraintPtr);
 
    UE_INTERNAL static void ApplyJointDataWrapperToHandle(Chaos::FPBDJointConstraintHandle* ConstaintHanlde, const FChaosVDJointConstraint& WrappedJointData);
    UE_INTERNAL static void ApplyJointDataWrapperGTConstraint(Chaos::FJointConstraint* ConstraintPtr, const FChaosVDJointConstraint& InWrappedJointData);
 
    UE_INTERNAL static FChaosVDCharacterGroundConstraint BuildCharacterGroundConstraintDataWrapper(const Chaos::FCharacterGroundConstraintHandle* ConstaintHanlde);
private:
 
    static void CopyJointSettingsFromWrapper(const FChaosVDJointSettingsDataWrapper& InWrappedJointSettingsData, Chaos::FPBDJointSettings& NewSettings);
 
    static FVector ConvertToFVector(const Chaos::FVec3f& VectorRef) { return FVector(VectorRef); }
 
    static void CopyShapeDataToWrapper(const Chaos::FShapeInstancePtr& ShapeDataPtr, FChaosVDShapeCollisionData& OutCopyTo);
    
    template<typename LeafType>
    static void BuildDataWrapperFromAABBStructure(const Chaos::TAABBTree<Chaos::FAccelerationStructureHandle, LeafType>& AABBTree, FChaosVDAABBTreeDataWrapper& OutAABBTreeWrapper);
 
    static FBox ConvertToFBox(const Chaos::TAABB<Chaos::FReal, 3>& Bounds)
    {
        FBox ConvertedBox(Bounds.Min(), Bounds.Max());
        return ConvertedBox;
    }
 
    static void BuildDataWrapperFromAABBStructure(const Chaos::ISpatialAccelerationCollection<Chaos::FAccelerationStructureHandle, Chaos::FReal, 3>*, int32 OwnerSolverID, TArray<FChaosVDAABBTreeDataWrapper>& OutAABBTrees);
 
    static void AddTreeLeaves(const TConstArrayView<Chaos::TAABBTreeLeafArray<Chaos::FAccelerationStructureHandle>>& LeavesContainer, FChaosVDAABBTreeDataWrapper& InOutAABBTreeWrapper);
    static void AddTreeLeaves(const TConstArrayView<Chaos::TBoundingVolume<Chaos::FAccelerationStructureHandle>>& LeavesContainer, FChaosVDAABBTreeDataWrapper& InOutAABBTreeWrapper);
 
    friend FChaosVisualDebuggerTrace;
};
 
template<typename LeafType>
void FChaosVDDataWrapperUtils::BuildDataWrapperFromAABBStructure(const Chaos::TAABBTree<Chaos::FAccelerationStructureHandle, LeafType>& AABBTree, FChaosVDAABBTreeDataWrapper& OutAABBTreeWrapper)
{
    using namespace Chaos;
 
    OutAABBTreeWrapper.MaxTreeDepth = AABBTree.MaxTreeDepth;
    OutAABBTreeWrapper.MaxChildrenInLeaf = AABBTree.MaxTreeDepth;
    OutAABBTreeWrapper.MaxPayloadBounds = AABBTree.MaxPayloadBounds;
    OutAABBTreeWrapper.RootNodeIndex = AABBTree.RootNode;
    OutAABBTreeWrapper.bDynamicTree = AABBTree.bDynamicTree;
 
    const int32 NodesToCopyNum = AABBTree.Nodes.Num();
    OutAABBTreeWrapper.Nodes.Reserve(NodesToCopyNum);
    OutAABBTreeWrapper.NodesNum = NodesToCopyNum;
 
    OutAABBTreeWrapper.Type = static_cast<EChaosVDAccelerationStructureType>(AABBTree.StaticType);
        
    for (const typename TAABBTree<FAccelerationStructureHandle, LeafType>::FNode& Node : AABBTree.Nodes)
    {
        FChaosVDAABBTreeNodeDataWrapper CVDNode;
        CVDNode.bLeaf = Node.bLeaf;
        CVDNode.bDirtyNode = Node.bDirtyNode;
 
        VisualDebugger::Utils::TransformStaticArray(Node.ChildrenBounds, CVDNode.ChildrenBounds, &FChaosVDDataWrapperUtils::ConvertToFBox);
        VisualDebugger::Utils::CopyStaticArray(Node.ChildrenNodes, CVDNode.ChildrenNodes);
 
        CVDNode.ParentNode =  Node.ParentNode;
        CVDNode.MarkAsValid();
 
        OutAABBTreeWrapper.Nodes.Emplace(CVDNode);
    }
    
    AddTreeLeaves(MakeArrayView(AABBTree.Leaves.GetData(), AABBTree.Leaves.Num()), OutAABBTreeWrapper);
    
    OutAABBTreeWrapper.MarkAsValid();
}