ConstraintHandle.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Chaos/Core.h"
#include "Chaos/Declares.h"
#include "Chaos/Vector.h"
#include "Chaos/ParticleHandleFwd.h"
 
// Set to 1 to help trap erros in the constraint management which typically manifests as a dangling constraint handle in the IslandManager
// 
// WARNING: Do not submit with either of these set to 1 !!
//
#ifndef CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED
#define CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED  0
#endif
#ifndef CHAOS_CONSTRAINTHANDLE_DEBUG_DETAILED_ENABLED
#define CHAOS_CONSTRAINTHANDLE_DEBUG_DETAILED_ENABLED (CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED && 0)
#endif
 
// This is a proxy for not allowing the above to be checked in - CIS should fail if it is left enabled
#if UE_BUILD_SHIPPING || UE_BUILD_TEST
static_assert(CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED == 0, "CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED should be 0");
static_assert(CHAOS_CONSTRAINTHANDLE_DEBUG_DETAILED_ENABLED == 0, "CHAOS_CONSTRAINTHANDLE_DEBUG_DETAILED_ENABLED should be 0");
#endif
 
namespace Chaos
{
    class FPBDConstraintContainer;
    class FPBDIndexedConstraintContainer;
 
    using FParticlePair = TVec2<FGeometryParticleHandle*>;
    using FConstParticlePair = TVec2<const FGeometryParticleHandle*>;
 
    namespace Private
    {
        class FPBDIslandConstraint;
    }
 
    class FConstraintHandleTypeID
    {
    public:
        FConstraintHandleTypeID(const FName& InName, const FConstraintHandleTypeID* InBaseType = nullptr)
            : TypeName(InName)
            , BaseType(InBaseType)
        {
        }
 
        static const FConstraintHandleTypeID InvalidTypeID()
        {
            return FConstraintHandleTypeID(NAME_None);
        }
 
        bool IsA(const FConstraintHandleTypeID& TypeID) const
        {
            if (TypeID.TypeName == TypeName)
            {
                return true;
            }
            if (BaseType != nullptr)
            {
                return BaseType->IsA(TypeID);
            }
            return false;
        }
 
        FString ToString() const
        {
            return TypeName.ToString();
        }
 
    private:
        FName TypeName;
        const FConstraintHandleTypeID* BaseType;
    };
 
 
    class FConstraintHandle
    {
    public:
        using FGeometryParticleHandle = TGeometryParticleHandle<FReal, 3>;
 
        FConstraintHandle() 
            : ConstraintContainer(nullptr)
            , GraphEdge(nullptr)
        {
        }
 
        FConstraintHandle(FPBDConstraintContainer* InContainer)
            : ConstraintContainer(InContainer)
            , GraphEdge(nullptr)
        {
        }
 
        virtual ~FConstraintHandle()
        {
            // Make sure we are not still in the graph
            check(GraphEdge == nullptr);
        }
 
        virtual bool IsValid() const
        {
            return (ConstraintContainer != nullptr);
        }
 
        FPBDConstraintContainer* GetContainer()
        {
            return ConstraintContainer;
        }
 
        const FPBDConstraintContainer* GetContainer() const 
        {
            return ConstraintContainer;
        }
 
        bool IsInConstraintGraph() const
        {
            return (GraphEdge != nullptr);
        }
 
        Private::FPBDIslandConstraint* GetConstraintGraphEdge() const
        {
            return GraphEdge;
        }
 
        // NOTE: Should only be called by the IslandManager
        void SetConstraintGraphEdge(Private::FPBDIslandConstraint* InEdge)
        {
            // Check for double add
            check((InEdge == nullptr) || (GraphEdge == nullptr));
 
            GraphEdge = InEdge;
        }
 
        virtual TVec2<FGeometryParticleHandle*> GetConstrainedParticles() const = 0;
 
        virtual void SetEnabled(bool InEnabled) = 0;
 
        virtual bool IsEnabled() const = 0;
 
        virtual bool IsProbe() const { return false; }
 
        // Does this constraint have the concept of sleep? (only really used for debug validation)
        virtual bool SupportsSleeping() const { return false; }
 
        // Can this constraint connect sleeping and active particles for partial island sleeping?
        virtual bool SupportsPartialIslandSleeping() const { return false; }
 
        virtual bool IsSleeping() const { return false; }
        virtual void SetIsSleeping(const bool bInIsSleeping) {}
 
        // Total net linear impulse applied by the velocity-based dynamics (VBD) solver (velocity iterations only).
        virtual FVec3f GetNetLinearImpulse() const { return FVec3f(0); }
        
        virtual bool WasAwakened() const { return false; }
        virtual void SetWasAwakened(const bool bInWasAwakened) {}
 
        // Implemented in ConstraintContainer.h
        int32 GetContainerId() const;
 
        // Implemented in ConstraintContainer.h
        template<typename T>  T* As();
        template<typename T>  const T* As() const;
 
        // For use when you absolutely know the type (asserted in non-shipping)
        template<typename T>  T* AsUnsafe() { check(As<T>() != nullptr); return static_cast<T*>(this); }
        template<typename T>  const T* AsUnsafe() const { check(As<T>() != nullptr); return static_cast<const T*>(this); }
 
        const FConstraintHandleTypeID& GetType() const;
 
        static const FConstraintHandleTypeID& StaticType()
        {
            static FConstraintHandleTypeID STypeID(TEXT("FConstraintHandle"), nullptr);
            return STypeID;
        }
 
        static const FConstraintHandleTypeID& InvalidType()
        {
            static FConstraintHandleTypeID STypeID(TEXT("InvalidConstraintHandle"), nullptr);
            return STypeID;
        }
 
        // Deprecated API
        UE_DEPRECATED(5.3, "Use GetConstraintGraphEdge") int32 GetConstraintGraphIndex() const { return INDEX_NONE; }
        UE_DEPRECATED(5.3, "Not supported") void SetConstraintGraphIndex(const int32 InIndex) const {}
 
    protected:
        friend class FPBDConstraintContainer;
 
        FPBDConstraintContainer* ConstraintContainer;
        
        Private::FPBDIslandConstraint* GraphEdge;
    };
 
 
    class FIntrusiveConstraintHandle : public FConstraintHandle
    {
    public:
        FIntrusiveConstraintHandle()
            : FConstraintHandle()
        {
        }
 
        void SetContainer(FPBDConstraintContainer* InContainer)
        {
            ConstraintContainer = InContainer;
        }
 
        static const FConstraintHandleTypeID& StaticType()
        {
            static FConstraintHandleTypeID STypeID(TEXT("FIntrusiveConstraintHandle"), &FConstraintHandle::StaticType());
            return STypeID;
        }
    };
 
 
    template<typename T_CONSTRAINT>
    class TIntrusiveConstraintHandle : public FIntrusiveConstraintHandle
    {
    public:
        using FConstraint = T_CONSTRAINT;
 
        TIntrusiveConstraintHandle()
            : FIntrusiveConstraintHandle()
        {
        }
 
        void SetContainer(FPBDConstraintContainer* InContainer)
        {
            ConstraintContainer = InContainer;
        }
 
        FConstraint* GetConstraint()
        {
            return static_cast<FConstraint*>(this);
        }
 
        const FConstraint* GetConstraint() const
        {
            return static_cast<const FConstraint*>(this);
        }
    };
 
 
 
    template<class T_CONTAINER>
    class TConstraintHandleAllocator
    {
    public:
        using FConstraintContainer = T_CONTAINER;
        using FConstraintContainerHandle = typename FConstraintContainer::FConstraintContainerHandle;
 
        FConstraintContainerHandle* AllocHandle(FConstraintContainer* ConstraintContainer, int32 ConstraintIndex) { return new FConstraintContainerHandle(ConstraintContainer, ConstraintIndex); }
 
        void FreeHandle(FConstraintContainerHandle* Handle) { delete Handle; }
    };
 
 
    class FConstraintHandleHolder
    {
    public:
        FConstraintHandleHolder()
            : Handle(nullptr)
        {
#if CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED
            InitDebugData();
#endif
        }
 
        FConstraintHandleHolder(FConstraintHandle* InHandle)
            : Handle(InHandle)
        {
#if CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED
            InitDebugData();
#endif
        }
 
        FConstraintHandle* operator->() const { return Handle; }
        operator FConstraintHandle* () const { return Handle; }
        FConstraintHandle* Get() const { return Handle; }
 
        friend uint32 GetTypeHash(const FConstraintHandleHolder& V)
        {
            return ::GetTypeHash(V.Handle);
        }
 
    private:
        FConstraintHandle* Handle;
 
#if CHAOS_CONSTRAINTHANDLE_DEBUG_ENABLED
    public:
        const FGeometryParticleHandle* GetParticle0() const { return Particles[0]; }
        const FGeometryParticleHandle* GetParticle1() const { return Particles[1]; }
 
    private:
        CHAOS_API void InitDebugData();
 
        const FConstraintHandleTypeID* ConstraintType;
        const FGeometryParticleHandle* Particles[2];
#endif
    };
}