SingleParticlePhysicsProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Chaos/Real.h"
#include "Chaos/ArrayCollectionArray.h"
#include "Chaos/Framework/MultiBufferResource.h"
#include "Chaos/Framework/PhysicsProxy.h"
#include "Chaos/PBDPositionConstraints.h"
#include "Chaos/ParticleHandle.h"
#include "Chaos/PhysicsObject.h"
#include "PhysicsCoreTypes.h"
#include "Chaos/Defines.h"
#include "Chaos/PullPhysicsDataImp.h"
#include "Chaos/Core.h"
#include "PhysicsProxy/SingleParticlePhysicsProxyFwd.h"
#include "Framework/Threading.h"
#include "Math/NumericLimits.h"
#include "RewindData.h"
 
 
namespace Chaos
{
 
class FPBDRigidsEvolutionGBF;
 
struct FDirtyRigidParticleData;
 
class FInitialState
{
public:
    FInitialState()
        : Mass(0.f)
        , InvMass(0.f)
        , InertiaTensor(1.f)
    {}
 
    FInitialState(FReal MassIn, FReal InvMassIn, FVector InertiaTensorIn)
        : Mass(MassIn)
        , InvMass(InvMassIn)
        , InertiaTensor(InertiaTensorIn)
    {}
 
    FReal GetMass() const { return Mass; }
    FReal GetInverseMass() const { return InvMass; }
    FVector GetInertiaTensor() const { return InertiaTensor; }
 
private:
    FReal Mass;
    FReal InvMass;
    FVector InertiaTensor;
};
 
class FRigidBodyHandle_External;
class FRigidBodyHandle_Internal;
 
class FSingleParticlePhysicsProxy : public IPhysicsProxyBase
{
public:
    using PARTICLE_TYPE = FGeometryParticle;
    using FParticleHandle = FGeometryParticleHandle;
 
    static FSingleParticlePhysicsProxy* Create(TUniquePtr<FGeometryParticle>&& Particle, UObject* InOwner);
 
    FSingleParticlePhysicsProxy() = delete;
    FSingleParticlePhysicsProxy(const FSingleParticlePhysicsProxy&) = delete;
    FSingleParticlePhysicsProxy(FSingleParticlePhysicsProxy&&) = delete;
    CHAOS_API virtual ~FSingleParticlePhysicsProxy();
 
    FProxyInterpolationBase* GetInterpolationData() { return InterpolationData.Get(); }
    const FProxyInterpolationBase* GetInterpolationData() const { return InterpolationData.Get(); }
 
    FORCEINLINE FRigidBodyHandle_External& GetGameThreadAPI()
    {
        return (FRigidBodyHandle_External&)*this;
    }
 
    FORCEINLINE const FRigidBodyHandle_External& GetGameThreadAPI() const
    {
        return (const FRigidBodyHandle_External&)*this;
    }
 
    //Note this is a pointer because the internal handle may have already been deleted
    FORCEINLINE FRigidBodyHandle_Internal* GetPhysicsThreadAPI()
    {
        return GetHandle_LowLevel() == nullptr ? nullptr : (FRigidBodyHandle_Internal*)this;
    }
 
    //Note this is a pointer because the internal handle may have already been deleted
    FORCEINLINE const FRigidBodyHandle_Internal* GetPhysicsThreadAPI() const
    {
        return GetHandle_LowLevel() == nullptr ? nullptr : (const FRigidBodyHandle_Internal*)this;
    }
 
    //Returns the underlying physics thread particle. Note this should only be needed for internal book keeping type tasks. API may change, use GetPhysicsThreadAPI instead
    FParticleHandle* GetHandle_LowLevel()
    {
        return Handle;
    }
 
    //Returns the underlying physics thread particle. Note this should only be needed for internal book keeping type tasks. API may change, use GetPhysicsThreadAPI instead
    const FParticleHandle* GetHandle_LowLevel() const
    {
        return Handle;
    }
 
    virtual void* GetHandleUnsafe() const override
    {
        return Handle;
    }
 
    void SetHandle(FParticleHandle* InHandle)
    {
        Handle = InHandle;
    }
 
    // Threading API
 
    CHAOS_API void PushToPhysicsState(const FDirtyPropertiesManager& Manager,int32 DataIdx,const FDirtyProxy& Dirty,FShapeDirtyData* ShapesData, FReal ExternalDt);
 
    
    CHAOS_API void ClearAccumulatedData();
 
    
    CHAOS_API void BufferPhysicsResults(FDirtyRigidParticleData&);
 
    
    CHAOS_API void BufferPhysicsResults_External(FDirtyRigidParticleData&);
 
    
    CHAOS_API bool PullFromPhysicsState(const FDirtyRigidParticleData& PullData, int32 SolverSyncTimestamp, const FDirtyRigidParticleData* NextPullData = nullptr, const FRealSingle* Alpha = nullptr, const FDirtyRigidParticleReplicationErrorData* Error = nullptr, const Chaos::FReal AsyncFixedTimeStep = 0);
 
    
    CHAOS_API bool IsDirty();
 
 
    
    CHAOS_API EWakeEventEntry GetWakeEvent() const;
 
    
    CHAOS_API void ClearEvents();
 
    //Returns the underlying game thread particle. Note this should only be needed for internal book keeping type tasks. API may change, use GetGameThreadAPI instead
    PARTICLE_TYPE* GetParticle_LowLevel()
    {
        return Particle.Get();
    }
 
    //Returns the underlying game thread particle. Note this should only be needed for internal book keeping type tasks. API may change, use GetGameThreadAPI instead
    const PARTICLE_TYPE* GetParticle_LowLevel() const
    {
        return Particle.Get();
    }
 
    FPBDRigidParticle* GetRigidParticleUnsafe()
    {
        return static_cast<FPBDRigidParticle*>(GetParticle_LowLevel());
    }
 
    const FPBDRigidParticle* GetRigidParticleUnsafe() const
    {
        return static_cast<const FPBDRigidParticle*>(GetParticle_LowLevel());
    }
 
    FPhysicsObjectHandle GetPhysicsObject()
    {
        return Reference.Get();
    }
 
    const FPhysicsObjectHandle GetPhysicsObject() const
    {
        return Reference.Get();
    }
 
    template<typename ErrorDataType>
    ErrorDataType* GetOrCreateErrorInterpolationData()
    {
        if (!InterpolationData.IsValid())
        {
            InterpolationData = MakeUnique<ErrorDataType>();
        }
        else if (InterpolationData.Get()->GetInterpolationType() != ErrorDataType::InterpolationType)
        {
            InterpolationData = MakeUnique<ErrorDataType>(InterpolationData.Get()->GetPullDataInterpIdx_External(), InterpolationData.Get()->GetInterpChannel_External());
        }
 
        return static_cast<ErrorDataType*>(InterpolationData.Get());
    }
 
protected:
    TUniquePtr<PARTICLE_TYPE> Particle;
    FParticleHandle* Handle;
    FPhysicsObjectUniquePtr Reference;
 
    int32 GravityGroupIndex;
 
private:
    TUniquePtr<FProxyInterpolationBase> InterpolationData;
 
    //use static Create
    CHAOS_API FSingleParticlePhysicsProxy(TUniquePtr<PARTICLE_TYPE>&& InParticle, FParticleHandle* InHandle, UObject* InOwner = nullptr);
};
 
template <bool bExternal>
class TThreadedSingleParticlePhysicsProxyBase : protected FSingleParticlePhysicsProxy
{
    TThreadedSingleParticlePhysicsProxyBase() = delete; //You should only ever new FSingleParticlePhysicsProxy, derived types are simply there for API constraining, no new data
public:
 
    FSingleParticlePhysicsProxy* GetProxy() { return static_cast<FSingleParticlePhysicsProxy*>(this); }
 
    bool CanTreatAsKinematic() const
    {
        return Read([](auto* Particle) { return Particle->CastToKinematicParticle() != nullptr; });
    }
 
    bool CanTreatAsRigid() const
    {
        return Read([](auto* Particle) { return Particle->CastToRigidParticle() != nullptr; });
    }
 
    //API for static particle
    const FVec3& X() const { return ReadRef([](auto* Particle) -> const auto& { return Particle->GetX(); }); }
    const FVec3& GetX() const { return ReadRef([](auto* Particle) -> const auto& { return Particle->GetX(); }); }
 
protected:
    void SetXBase(const FVec3& InX, bool bInvalidate = true) { Write([&InX, bInvalidate, this](auto* Particle)
    {
        if (bInvalidate)
        {
            auto Dyn = Particle->CastToRigidParticle();
            if (Dyn && Dyn->ObjectState() == EObjectStateType::Sleeping)
            {
                SetObjectStateHelper(*GetProxy(), *Dyn, EObjectStateType::Dynamic, true);
            }
        }
        Particle->SetX(InX, bInvalidate);
    });}
public:
 
    FUniqueIdx UniqueIdx() const { return Read([](auto* Particle) { return Particle->UniqueIdx(); }); }
    void SetUniqueIdx(const FUniqueIdx UniqueIdx, bool bInvalidate = true) { Write([UniqueIdx, bInvalidate](auto* Particle) { Particle->SetUniqueIdx(UniqueIdx, bInvalidate); }); }
 
    FRotation3 R() const { return Read([](auto* Particle) -> const auto { return Particle->GetR(); }); }
    FRotation3 GetR() const { return Read([](auto* Particle) -> const auto { return Particle->GetR(); }); }
 
protected:
    void SetRBase(const FRotation3& InR, bool bInvalidate = true){ Write([&InR, bInvalidate, this](auto* Particle)
    {
            if (bInvalidate)
            {
                auto Dyn = Particle->CastToRigidParticle();
                if (Dyn && Dyn->ObjectState() == EObjectStateType::Sleeping)
                {
                    SetObjectStateHelper(*GetProxy(), *Dyn, EObjectStateType::Dynamic, true);
                }
            }
            Particle->SetR(InR, bInvalidate);
    });}
public:
    
    UE_DEPRECATED(5.4, "Use GetGeometry instead.")
    const TSharedPtr<FImplicitObject, ESPMode::ThreadSafe>& SharedGeometryLowLevel() const
    {
        check(false);
        static TSharedPtr<FImplicitObject, ESPMode::ThreadSafe> DummyPtr(nullptr);
        return DummyPtr;
    }
 
    
#if CHAOS_DEBUG_NAME
    const TSharedPtr<FString, ESPMode::ThreadSafe>& DebugName() const { return ReadRef([](auto* Ptr) -> const auto& { return Ptr->DebugName(); }); }
    void SetDebugName(const TSharedPtr<FString, ESPMode::ThreadSafe>& InDebugName) { Write([&InDebugName](auto* Ptr) { Ptr->SetDebugName(InDebugName); }); }
#endif
 
    const FImplicitObjectRef GetGeometry() const { return Read([](auto* Ptr) { FImplicitObjectRef ImplicitRef = Ptr->GetGeometry(); return ImplicitRef; }); }
 
    UE_DEPRECATED(5.4, "Please use GetGeometry instead")
    TSerializablePtr<FImplicitObject> Geometry() const { check(false); return TSerializablePtr<FImplicitObject>(); }
 
    const FShapesArray& ShapesArray() const { return ReadRef([](auto* Ptr) -> const auto& { return Ptr->ShapesArray(); }); }
 
    EObjectStateType ObjectState() const { return Read([](auto* Ptr) { return Ptr->ObjectState(); }); }
 
    EParticleType ObjectType() const { return Read([](auto* Ptr) { return Ptr->ObjectType(); }); }
 
    FSpatialAccelerationIdx SpatialIdx() const { return Read([](auto* Ptr) { return Ptr->SpatialIdx(); }); }
    void SetSpatialIdx(FSpatialAccelerationIdx Idx) { Write([Idx](auto* Ptr) { Ptr->SetSpatialIdx(Idx); }); }
 
    //API for kinematic particle
    const FVec3 V() const
    {
        return Read([](auto* Particle)
        {
            if (auto Kinematic = Particle->CastToKinematicParticle())
            {
                return Kinematic->GetV();
            }
            
            return FVec3(0);
        });
    }
    const FVec3 GetV() const
    {
        return V();
    }
 
protected:
    void SetVBase(const FVec3& InV, bool bInvalidate = true)
    {
        Write([&InV, bInvalidate, this](auto* Particle)
        {
            if (auto Kinematic = Particle->CastToKinematicParticle())
            {
                if (bInvalidate)
                {
                    auto Dyn = Particle->CastToRigidParticle();
                    if (Dyn && Dyn->ObjectState() == EObjectStateType::Sleeping && !InV.IsNearlyZero())
                    {
                        SetObjectStateHelper(*GetProxy(), *Dyn, EObjectStateType::Dynamic, true);
                    }
                }
 
                Kinematic->SetV(InV, bInvalidate);
            }
        });
    }
public:
 
    const FVec3 W() const
    {
        return Read([](auto* Particle)
        {
            if (auto Kinematic = Particle->CastToKinematicParticle())
            {
                return Kinematic->GetW();
            }
 
            return FVec3(0);
        });
    }
 
    const FVec3 GetW() const
    {
        return W();
    }
 
protected:
    void SetWBase(const FVec3& InW, bool bInvalidate = true)
    {
        Write([&InW, bInvalidate, this](auto* Particle)
        {
            if (auto Kinematic = Particle->CastToKinematicParticle())
            {
                if (bInvalidate)
                {
                    auto Dyn = Particle->CastToRigidParticle();
                    if (Dyn && Dyn->ObjectState() == EObjectStateType::Sleeping && !InW.IsNearlyZero())
                    {
                        SetObjectStateHelper(*GetProxy(), *Dyn, EObjectStateType::Dynamic, true);
                    }
                }
                
                Kinematic->SetW(InW, bInvalidate);
            }
        });
    }
public:
 
    void SetKinematicTarget(const FRigidTransform3& InTargetTransform, bool bInvalidate = true)
    {
        SetKinematicTarget(FKinematicTarget::MakePositionTarget(InTargetTransform), bInvalidate);
    }
 
    void SetKinematicTarget(const FKinematicTarget& InKinematicTarget, bool bInvalidate = true)
    {
        Write([&InKinematicTarget, bInvalidate](auto* Ptr)
        {
            if (auto Kinematic = Ptr->CastToKinematicParticle())
            {
                Kinematic->SetKinematicTarget(InKinematicTarget, bInvalidate);
            }
        });
    }
    
    //API for dynamic particle
 
    bool GravityEnabled() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->GravityEnabled();
            }
 
            return false;
        });
    }
 
    void SetGravityEnabled(const bool InGravityEnabled)
    {
        Write([InGravityEnabled](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->SetGravityEnabled(InGravityEnabled);
            }
        });
    }
 
    int32 GravityGroupIndex() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->GravityGroupIndex();
            }
 
            return -1;
        });
    }
 
    void SetGravityGroupIndex(const uint32 InGravityGroupIndex)
    {
        Write([InGravityGroupIndex](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetGravityGroupIndex(InGravityGroupIndex);
                }
            });
    }
 
    bool UpdateKinematicFromSimulation() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->UpdateKinematicFromSimulation();
            }
 
            return false;
        });
    }
 
    void SetUpdateKinematicFromSimulation(const bool InUpdateKinematicFromSimulation)
    {
        Write([InUpdateKinematicFromSimulation](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->SetUpdateKinematicFromSimulation(InUpdateKinematicFromSimulation);
            }
        });
    }
 
    bool GyroscopicTorqueEnabled() const
    {
        return Read([](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->GyroscopicTorqueEnabled();
                }
 
                return false;
            });
    }
 
    void SetGyroscopicTorqueEnabled(const bool InGyroscopicTorqueEnabled)
    {
        Write([InGyroscopicTorqueEnabled](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetGyroscopicTorqueEnabled(InGyroscopicTorqueEnabled);
                }
            });
    }
 
    bool CCDEnabled() const
    {
        return Read([](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->CCDEnabled();
                }
 
                return false;
            });
    }
 
    void SetCCDEnabled(const bool InCCDEnabled)
    {
        Write([InCCDEnabled](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetCCDEnabled(InCCDEnabled);
                }
            });
    }
 
    bool MACDEnabled() const
    {
        return Read([](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->MACDEnabled();
                }
 
                return false;
            });
    }
 
    void SetMACDEnabled(const bool InMACDEnabled)
    {
        Write([InMACDEnabled](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetMACDEnabled(InMACDEnabled);
                }
            });
    }
 
    bool PartialIslandSleepAllowed() const
    {
        return Read([](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->PartialIslandSleepAllowed();
                }
 
                return false;
            });
    }
 
    void SetPartialIslandSleepAllowed(const bool InPartialIslandSleepAllowed)
    {
        Write([InPartialIslandSleepAllowed](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetPartialIslandSleepAllowed(InPartialIslandSleepAllowed);
                }
            });
    }
 
    void SetPositionSolverIterations(const int32 PositionSolverIterationsIn)
    {
        Write([PositionSolverIterationsIn](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetPositionSolverIterations(PositionSolverIterationsIn);
                }
            });
    }
 
    void SetVelocitySolverIterations(const int32 VelocitySolverIterationsIn)
    {
        Write([VelocitySolverIterationsIn](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetVelocitySolverIterations(VelocitySolverIterationsIn);
                }
            });
    }
 
    void SetProjectionSolverIterations(const int32 ProjectionSolverIterationsIn)
    {
        Write([ProjectionSolverIterationsIn](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetProjectionSolverIterations(ProjectionSolverIterationsIn);
                }
            });
    }
 
    bool OneWayInteraction() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->OneWayInteraction();
            }
 
            return false;
        });
    }
 
    void SetOneWayInteraction(const bool bInOneWayInteraction)
    {
        Write([bInOneWayInteraction](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->SetOneWayInteraction(bInOneWayInteraction);
            }
        });
    }
 
    bool InertiaConditioningEnabled() const
    {
        return Read([](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->InertiaConditioningEnabled();
                }
 
                return false;
            });
    }
 
    void SetInertiaConditioningEnabled(const bool bInEnabled)
    {
        Write([bInEnabled](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    return Rigid->SetInertiaConditioningEnabled(bInEnabled);
                }
            });
    }
 
    void SetResimType(EResimType ResimType)
    {
        Write([ResimType](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->SetResimType(ResimType);
            }
        });
    }
 
    EResimType ResimType() const
    {
        if (auto Rigid = Particle->CastToRigidParticle())
        {
            return Rigid->ResimType();
        }
 
        return EResimType::FullResim;
    }
 
    const FVec3 Acceleration() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->Acceleration();
            }
 
            return FVec3(0);
        });
    }
    
    void SetAcceleration(const FVec3& Acceleration, bool bInvalidate = true)
    {
        Write([&Acceleration, bInvalidate, this](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    if (Rigid->ObjectState() == EObjectStateType::Sleeping || Rigid->ObjectState() == EObjectStateType::Dynamic)
                    {
                        if (bInvalidate)
                        {
                            SetObjectStateHelper(*GetProxy(), *Rigid, EObjectStateType::Dynamic, true);
                        }
 
                        Rigid->SetAcceleration(Acceleration);
                    }
                }
            });
    }
 
    void AddForce(const FVec3& InForce, bool bInvalidate = true)
    {
        Write([&InForce, bInvalidate, this](auto* Particle)
        {
            if (auto* Rigid = Particle->CastToRigidParticle())
            {
                if (Rigid->ObjectState() == EObjectStateType::Sleeping || Rigid->ObjectState() == EObjectStateType::Dynamic)
                {
                    if (bInvalidate)
                    {
                        SetObjectStateHelper(*GetProxy(), *Rigid, EObjectStateType::Dynamic, true);
                    }
 
                    Rigid->AddForce(InForce, bInvalidate);
                }
            }
        });
    }
 
    void SetAngularAcceleration(const FVec3& AngularAcceleration, bool bInvalidate = true)
    {
        Write([&AngularAcceleration, bInvalidate, this](auto* Particle)
            {
                if (auto Rigid = Particle->CastToRigidParticle())
                {
                    if (Rigid->ObjectState() == EObjectStateType::Sleeping || Rigid->ObjectState() == EObjectStateType::Dynamic)
                    {
                        if (bInvalidate)
                        {
                            SetObjectStateHelper(*GetProxy(), *Rigid, EObjectStateType::Dynamic, true);
                        }
 
                        Rigid->SetAngularAcceleration(AngularAcceleration);
                    }
                }
            });
    }
 
    const FVec3 AngularAcceleration() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->AngularAcceleration();
            }
 
            return FVec3(0);
        });
    }
 
    void AddTorque(const FVec3& InTorque, bool bInvalidate = true)
    {
        Write([&InTorque, bInvalidate, this](auto* Particle)
        {
            if (auto* Rigid = Particle->CastToRigidParticle())
            {
                if (Rigid->ObjectState() == EObjectStateType::Sleeping || Rigid->ObjectState() == EObjectStateType::Dynamic)
                {
                    if (bInvalidate)
                    {
                        SetObjectStateHelper(*GetProxy(), *Rigid, EObjectStateType::Dynamic, true);
                    }
 
                    Rigid->AddTorque(InTorque, bInvalidate);
                }
            }
        });
    }
 
    const FVec3 LinearImpulseVelocity() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->LinearImpulseVelocity();
            }
 
            return FVec3(0);
        });
    }
 
    const FVec3 LinearImpulse() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->LinearImpulseVelocity() * Rigid->M();
            }
 
            return FVec3(0);
        });
    }
 
    void SetLinearImpulse(const FVec3& InLinearImpulse, bool bIsVelocity, bool bInvalidate = true)
    {
        Write([&InLinearImpulse, bIsVelocity, bInvalidate, this](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                if (Rigid->ObjectState() == EObjectStateType::Sleeping || Rigid->ObjectState() == EObjectStateType::Dynamic)
                {
                    if (bInvalidate)
                    {
                        SetObjectStateHelper(*GetProxy(), *Rigid, EObjectStateType::Dynamic, true);
                    }
 
                    if (bIsVelocity)
                    {
                        Rigid->SetLinearImpulseVelocity(InLinearImpulse, bInvalidate);
                    }
                    else
                    {
                        Rigid->SetLinearImpulseVelocity(InLinearImpulse * Rigid->InvM(), bInvalidate);
                    }
                }
            }
        });
    }
 
    const FVec3 AngularImpulseVelocity() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->AngularImpulseVelocity();
            }
 
            return FVec3(0);
        });
    }
 
    const FVec3 AngularImpulse() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                const FMatrix33 WorldI = Utilities::ComputeWorldSpaceInertia(Rigid->GetR() * Rigid->RotationOfMass(), Rigid->I());
                return WorldI * Rigid->AngularImpulseVelocity();
            }
 
            return FVec3(0);
        });
    }
 
    void SetAngularImpulse(const FVec3& InAngularImpulse, bool bIsVelocity, bool bInvalidate = true)
    {
        Write([&InAngularImpulse, bIsVelocity, bInvalidate, this](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                if (Rigid->ObjectState() == EObjectStateType::Sleeping || Rigid->ObjectState() == EObjectStateType::Dynamic)
                {
                    if (bInvalidate)
                    {
                        SetObjectStateHelper(*GetProxy(), *Rigid, EObjectStateType::Dynamic, true);
                    }
 
                    if (bIsVelocity)
                    {
                        Rigid->SetAngularImpulseVelocity(InAngularImpulse, bInvalidate);
                    }
                    else
                    {
                        const FMatrix33 WorldInvI = Utilities::ComputeWorldSpaceInertia(Rigid->GetR() * Rigid->RotationOfMass(), Rigid->InvI());
                        Rigid->SetAngularImpulseVelocity(WorldInvI * InAngularImpulse, bInvalidate);
                    }
                }
            }
        });
    }
 
    const Chaos::TVec3<FRealSingle> I() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->I();
            }
 
            return Chaos::TVec3<FRealSingle>(0, 0, 0);
        });
    }
 
    void SetI(const Chaos::TVec3<FRealSingle>& InI)
    {
        Write([&InI](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetI(InI);
            }
        });
    }
 
    const Chaos::TVec3<FRealSingle> InvI() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->InvI();
            }
 
            return Chaos::TVec3<FRealSingle>(0, 0, 0);
        });
    }
 
    void SetInvI(const Chaos::TVec3<FRealSingle>& InInvI)
    {
        Write([&InInvI](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetInvI(InInvI);
            }
        });
    }
 
    const FReal M() const
    {
        return Read([](auto* Particle) -> FReal
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->M();
            }
 
            return 0;
        });
    }
 
    void SetM(const FReal InM)
    {
        Write([&InM](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetM(InM);
            }
        });
    }
 
    const FReal InvM() const
    {
        return Read([](auto* Particle) -> FReal
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->InvM();
            }
 
            return 0;
        });
    }
 
    void SetInvM(const FReal InInvM)
    {
        Write([&InInvM](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetInvM(InInvM);
            }
        });
    }
 
    const FVec3 CenterOfMass() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->CenterOfMass();
            }
 
            return FVec3(0);
        });
    }
 
    void SetCenterOfMass(const FVec3& InCenterOfMass, bool bInvalidate = true)
    {
        Write([&InCenterOfMass, bInvalidate](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetCenterOfMass(InCenterOfMass, bInvalidate);
            }
        });
    }
 
    const FRotation3 RotationOfMass() const
    {
        return Read([](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->RotationOfMass();
            }
 
            return FRotation3::FromIdentity();
        });
    }
 
    void SetRotationOfMass(const FRotation3& InRotationOfMass, bool bInvalidate = true)
    {
        Write([&InRotationOfMass, bInvalidate](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetRotationOfMass(InRotationOfMass, bInvalidate);
            }
        });
    }
 
    const FReal LinearEtherDrag() const
    {
        return Read([](auto* Particle) -> FReal
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->LinearEtherDrag();
            }
 
            return 0;
        });
    }
 
    void SetLinearEtherDrag(const FReal InLinearEtherDrag)
    {
        Write([&InLinearEtherDrag](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetLinearEtherDrag(InLinearEtherDrag);
            }
        });
    }
 
    const FReal AngularEtherDrag() const
    {
        return Read([](auto* Particle) -> FReal
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->AngularEtherDrag();
            }
 
            return 0;
        });
    }
 
    void SetAngularEtherDrag(const FReal InAngularEtherDrag)
    {
        Write([&InAngularEtherDrag](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                Rigid->SetAngularEtherDrag(InAngularEtherDrag);
            }
        });
    }
 
protected:
    void SetObjectStateBase(const EObjectStateType InState, bool bAllowEvents = false, bool bInvalidate = true)
    {
        Write([InState, bAllowEvents, bInvalidate, this](auto* Ptr)
        {
            if (auto Rigid = Ptr->CastToRigidParticle())
            {
                SetObjectStateHelper(*this, *Rigid, InState, bAllowEvents, bInvalidate);
            }
        });
    }
public:
 
    void SetSleepType(ESleepType InSleepType)
    {
        Write([InSleepType](auto* Particle)
        {
            if (auto Rigid = Particle->CastToRigidParticle())
            {
                return Rigid->SetSleepType(InSleepType);
            }
        });
    }
 
    ESleepType SleepType() const
    {
        if (auto Rigid = Particle->CastToRigidParticle())
        {
            return Rigid->SleepType();
        }
 
        return ESleepType::MaterialSleep;
    }
 
protected:
    void VerifyContext() const
    {
#if PHYSICS_THREAD_CONTEXT
        //Are you using the wrong API type for the thread this code runs in?
        //GetGameThreadAPI should be used for gamethread, GetPhysicsThreadAPI should be used for callbacks and internal physics thread
        //Note if you are using a ParallelFor you must use PhysicsParallelFor to ensure the right context is inherited from parent thread
        if(bExternal)
        {
            //if proxy is registered with solver, we need a lock
            if(GetSolverBase() != nullptr)
            {
                EnsureIsInGameThreadContext();
            }
        }
        else
        {
            EnsureIsInPhysicsThreadContext();
        }
#endif
    }
 
private:
 
    template <typename TLambda>
    auto Read(const TLambda& Lambda) const { VerifyContext(); return bExternal ? Lambda(GetParticle_LowLevel()) : Lambda(GetHandle_LowLevel()); }
 
    template <typename TLambda>
    const auto& ReadRef(const TLambda& Lambda) const { VerifyContext(); return bExternal ? Lambda(GetParticle_LowLevel()) : Lambda(GetHandle_LowLevel()); }
 
    template <typename TLambda>
    auto& ReadRef(const TLambda& Lambda) { VerifyContext(); return bExternal ? Lambda(GetParticle_LowLevel()) : Lambda(GetHandle_LowLevel()); }
 
    template <typename TLambda>
    void Write(const TLambda& Lambda)
    {
        VerifyContext();
        if (bExternal)
        {
            Lambda(GetParticle_LowLevel());
        }
        else
        {
            //Mark entire particle as dirty from PT. TODO: use property system
            FPhysicsSolverBase* SolverBase = GetSolverBase();   //internal so must have solver already
            if(FRewindData* RewindData = SolverBase->GetRewindData())
            {
                RewindData->MarkDirtyFromPT(*GetHandle_LowLevel());
            }
 
            Lambda(GetHandle_LowLevel());
        }
    }
};
 
static_assert(sizeof(TThreadedSingleParticlePhysicsProxyBase<true>) == sizeof(FSingleParticlePhysicsProxy), "Derived types only used to constrain API, all data lives in base class ");
static_assert(sizeof(TThreadedSingleParticlePhysicsProxyBase<false>) == sizeof(FSingleParticlePhysicsProxy), "Derived types only used to constrain API, all data lives in base class ");
 
 
class FRigidBodyHandle_External : public TThreadedSingleParticlePhysicsProxyBase<true>
{
    FRigidBodyHandle_External() = delete;   //You should only ever new FSingleParticlePhysicsProxy, derrived types are simply there for API constraining, no new data
 
public:
    using Base = TThreadedSingleParticlePhysicsProxyBase<true>;
    using Base::VerifyContext;
 
    void SetIgnoreAnalyticCollisions(bool bIgnoreAnalyticCollisions) { VerifyContext(); GetParticle_LowLevel()->SetIgnoreAnalyticCollisions(bIgnoreAnalyticCollisions); }
    void UpdateShapeBounds() { VerifyContext(); GetParticle_LowLevel()->UpdateShapeBounds(); }
 
    void UpdateShapeBounds(const FTransform& Transform) { VerifyContext(); GetParticle_LowLevel()->UpdateShapeBounds(Transform); }
 
    void SetShapeCollisionTraceType(int32 InShapeIndex, EChaosCollisionTraceFlag TraceType) { VerifyContext(); GetParticle_LowLevel()->SetShapeCollisionTraceType(InShapeIndex, TraceType); }
 
    void SetShapeSimCollisionEnabled(int32 InShapeIndex, bool bInEnabled) { VerifyContext(); GetParticle_LowLevel()->SetShapeSimCollisionEnabled(InShapeIndex, bInEnabled); }
    void SetShapeQueryCollisionEnabled(int32 InShapeIndex, bool bInEnabled) { VerifyContext(); GetParticle_LowLevel()->SetShapeQueryCollisionEnabled(InShapeIndex, bInEnabled); }
    void SetShapeSimData(int32 InShapeIndex, const FCollisionFilterData& SimData) { VerifyContext(); GetParticle_LowLevel()->SetShapeSimData(InShapeIndex, SimData); }
 
    void SetParticleID(const FParticleID& ParticleID)
    {
        VerifyContext();
        GetParticle_LowLevel()->SetParticleID(ParticleID);
    }
 
    void SetX(const FVec3& InX, bool bInvalidate = true)
    {
        VerifyContext();
        SetXBase(InX, bInvalidate);
        FSingleParticleProxyTimestamp& SyncTS = GetSyncTimestampAs<FSingleParticleProxyTimestamp>(); 
        SyncTS.OverWriteX.Set(GetSolverSyncTimestamp_External(), InX);
    }
 
    void SetR(const FRotation3& InR, bool bInvalidate = true)
    {
        VerifyContext();
        SetRBase(InR, bInvalidate);
        FSingleParticleProxyTimestamp& SyncTS = GetSyncTimestampAs<FSingleParticleProxyTimestamp>();
        SyncTS.OverWriteR.Set(GetSolverSyncTimestamp_External(), InR);
    }
 
    void SetV(const FVec3& InV, bool bInvalidate = true)
    {
        VerifyContext();
        SetVBase(InV, bInvalidate);
        if (InV == FVec3(0))    //should we use an explicit API instead?
        {
            //external thread is setting velocity to 0 so we want to freeze object until sim catches up
            //but we also want position to snap to where it currently is on external thread
            SetX(X(), bInvalidate);
        }
        FSingleParticleProxyTimestamp& SyncTS = GetSyncTimestampAs<FSingleParticleProxyTimestamp>();
        SyncTS.OverWriteV.Set(GetSolverSyncTimestamp_External(), InV);
    }
 
    void SetW(const FVec3& InW, bool bInvalidate = true)
    {
        VerifyContext();
        SetWBase(InW, bInvalidate);
        
        if (InW == FVec3(0))    //should we use an explicit API instead?
        {
            //external thread is setting velocity to 0 so we want to freeze object until sim catches up
            //but we also want position to snap to where it currently is on external thread
            SetR(R(), bInvalidate);
        }
        FSingleParticleProxyTimestamp& SyncTS = GetSyncTimestampAs<FSingleParticleProxyTimestamp>();
        SyncTS.OverWriteW.Set(GetSolverSyncTimestamp_External(), InW);
    }
 
    void SetObjectState(const EObjectStateType InState, bool bAllowEvents = false, bool bInvalidate = true)
    {
        VerifyContext();
        if (auto Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            FSingleParticleProxyTimestamp& SyncTS = GetSyncTimestampAs<FSingleParticleProxyTimestamp>();
            SyncTS.ObjectStateTimestamp = GetSolverSyncTimestamp_External();
            if (InState != EObjectStateType::Dynamic && Rigid->ObjectState() == EObjectStateType::Dynamic)
            {
                //we want to snap the particle to its current state on the external thread. This is because the user wants the object to fully stop right now
                //the internal thread will continue if async is on, but eventually it will see this snap
                SetV(FVec3(0), bInvalidate);
                SetW(FVec3(0), bInvalidate);
            }
 
            if (InState == EObjectStateType::Kinematic && Rigid->ObjectState() != EObjectStateType::Kinematic)
            {
                // NOTE: using ClearKinematicTarget() here would just clean the dirty flag, but we actually
                // want to make sure the kinematic target mode is set to "None", which is how it's default constructed.
                SetKinematicTarget(Chaos::FKinematicTarget(), bInvalidate);
            }
        }
 
        SetObjectStateBase(InState, bAllowEvents, bInvalidate);
    }
 
    int32 Island() const
    {
        VerifyContext();
        if (const TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->Island();
        }
 
        return INDEX_NONE;
    }
    // TODO(stett): Make the setter private. It is public right now to provide access to proxies.
    void SetIsland(const int32 InIsland)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetIsland(InIsland);
        }
    }
 
    void ClearEvents()
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->ClearEvents();
        }
    }
 
    EWakeEventEntry GetWakeEvent()
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->GetWakeEvent();
        }
 
        return EWakeEventEntry::None;
    }
 
    void ClearForces(bool bInvalidate = true)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
 
            Rigid->ClearForces(bInvalidate);
        }
    }
 
    void ClearTorques(bool bInvalidate = true)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->ClearTorques(bInvalidate);
        }
    }
 
    void* UserData() const { VerifyContext(); return GetParticle_LowLevel()->UserData(); }
    void SetUserData(void* InUserData) { VerifyContext(); GetParticle_LowLevel()->SetUserData(InUserData); }
    
    void SetGeometry(const Chaos::FImplicitObjectPtr& ImplicitGeometryPtr)
    {
        VerifyContext();
        GetParticle_LowLevel()->SetGeometry(ImplicitGeometryPtr);
    }
    
    UE_DEPRECATED(5.4, "Use SetGeometry with FImplicitObjectPtr instead.")
    void SetGeometry(TUniquePtr<FImplicitObject>&& UniqueGeometry)
    {
        check(false);
    }
    
    UE_DEPRECATED(5.4, "Use SetGeometry with FImplicitObjectPtr instead.")
    void SetGeometry(TSharedPtr<const FImplicitObject, ESPMode::ThreadSafe> SharedGeometry)
    {
        check(false);
    }
    
    void RemoveShape(FPerShapeData* InShape, bool bWakeTouching) { VerifyContext(); GetParticle_LowLevel()->RemoveShape(InShape, bWakeTouching); }
 
    void MergeShapesArray(FShapesArray&& OtherShapesArray) { VerifyContext(); GetParticle_LowLevel()->MergeShapesArray(MoveTemp(OtherShapesArray)); }
 
    void MergeGeometry(TArray<Chaos::FImplicitObjectPtr>&& Objects) { VerifyContext(); GetParticle_LowLevel()->MergeGeometry(MoveTemp(Objects)); }
 
    UE_DEPRECATED(5.4, "Please use MergeGeometry with FImplicitObjectPtr instead.")
    void MergeGeometry(TArray<TUniquePtr<FImplicitObject>>&& Objects) { check(false); }
 
    bool IsKinematicTargetDirty() const
    {
        VerifyContext();
        if (auto Kinematic = GetParticle_LowLevel()->CastToKinematicParticle())
        {
            return Kinematic->IsKinematicTargetDirty();
        }
        return false;
    }
 
    void ClearKinematicTarget()
    {
        VerifyContext();
        if (auto Kinematic = GetParticle_LowLevel()->CastToKinematicParticle())
        {
            return Kinematic->ClearKinematicTarget();
        }
    }
 
    void SetSmoothEdgeCollisionsEnabled(bool bEnabled)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            if (bEnabled)
            {
                Rigid->AddCollisionConstraintFlag(ECollisionConstraintFlags::CCF_SmoothEdgeCollisions);
            }
            else
            {
                Rigid->RemoveCollisionConstraintFlag(ECollisionConstraintFlags::CCF_SmoothEdgeCollisions);
            }
        }
    }
 
    void SetCCDEnabled(bool bEnabled)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetCCDEnabled(bEnabled);
        }
    }
 
    bool CCDEnabled() const
    {
        VerifyContext();
        if (const TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->CCDEnabled();
        }
 
        return false;
    }
 
    void SetMACDEnabled(bool bEnabled)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetMACDEnabled(bEnabled);
        }
    }
 
    bool MACDEnabled() const
    {
        VerifyContext();
        if (const TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->MACDEnabled();
        }
 
        return false;
    }
 
    void SetPartialIslandSleepAllowed(bool bEnabled)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetPartialIslandSleepAllowed(bEnabled);
        }
    }
 
    bool PartialIslandSleepAllowed() const
    {
        VerifyContext();
        if (const TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->PartialIslandSleepAllowed();
        }
 
        return false;
    }
 
    Private::FIterationSettings IterationSettings() const
    {
        VerifyContext();
        if (const TPBDRigidParticle<FReal, 3>*Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->IterationSettings();
        }
 
        return Private::FIterationSettings(0, 0, 0);
    }
 
    void SetPositionSolverIterationCount(int32 PositionSolverIterationCountIn)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetPositionSolverIterations(PositionSolverIterationCountIn);
        }
    }
 
 
    void SetVelocitySolverIterationCount(int32 VelocitySolverIterationCountIn)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetVelocitySolverIterations(VelocitySolverIterationCountIn);
        }
    }
 
 
    void SetProjectionSolverIterationCount(int32 ProjectionSolverIterationCountIn)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetProjectionSolverIterations(ProjectionSolverIterationCountIn);
        }
    }
 
    void SetMaxLinearSpeedSq(FReal InNewSpeed)
    {
        VerifyContext();
        if(TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetMaxLinearSpeedSq(InNewSpeed);
        }
    }
 
    FReal GetMaxLinearSpeedSq()
    {
        VerifyContext();
        if(const TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->MaxLinearSpeedSq();
        }
 
        return TNumericLimits<FReal>::Max();
    }
 
    void SetMaxAngularSpeedSq(FReal InNewSpeed)
    {
        VerifyContext();
        if(TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetMaxAngularSpeedSq(InNewSpeed);
        }
    }
 
    FReal GetMaxAngularSpeedSq()
    {
        VerifyContext();
        if(const TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->MaxAngularSpeedSq();
        }
 
        return TNumericLimits<FReal>::Max();
    }
 
    FRealSingle GetInitialOverlapDepenetrationVelocity()
    {
        VerifyContext();
        if (const TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->InitialOverlapDepenetrationVelocity();
        }
 
        return 0;
    }
 
    void SetInitialOverlapDepenetrationVelocity(FRealSingle InNewSpeed)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetInitialOverlapDepenetrationVelocity(InNewSpeed);
        }
    }
 
    void SetSleepThresholdMultiplier(FRealSingle Multiplier)
    {
        VerifyContext();
        if (TPBDRigidParticle<FReal, 3>* Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetSleepThresholdMultiplier(Multiplier);
        }
    }
 
    void SetDisabled(bool bDisable)
    {
        VerifyContext();
        if (auto Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetDisabled(bDisable);
        }
    }
 
    bool Disabled() const
    {
        VerifyContext();
        if (auto Rigid = GetParticle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->Disabled();
        }
 
        return false;
    }
};
 
static_assert(sizeof(FRigidBodyHandle_External) == sizeof(FSingleParticlePhysicsProxy), "Derived types only used to constrain API, all data lives in base class ");
 
 
class FRigidBodyHandle_Internal : public TThreadedSingleParticlePhysicsProxyBase<false>
{
    FRigidBodyHandle_Internal() = delete;   //You should only ever new FSingleParticlePhysicsProxy, derived types are simply there for API constraining, no new data
 
public:
    using Base = TThreadedSingleParticlePhysicsProxyBase<false>;
 
    const FVec3 PreV() const
    {
        VerifyContext();
        if (auto Rigid = GetHandle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->GetPreV();
        }
        return FVec3(0);
    }
 
    const FVec3 PreW() const
    {
        VerifyContext();
        if (auto Rigid = GetHandle_LowLevel()->CastToRigidParticle())
        {
            return Rigid->GetPreW();
        }
        return FVec3(0);
    }
 
    void SetX(const FVec3& InX, bool bInvalidate = true)
    {
        VerifyContext();
        SetXBase(InX, bInvalidate);
        if (auto Rigid = GetHandle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetP(InX);
        }
    }
 
    void SetR(const FRotation3& InR, bool bInvalidate = true)
    {
        VerifyContext();
        SetRBase(InR, bInvalidate);
        if (auto Rigid = GetHandle_LowLevel()->CastToRigidParticle())
        {
            Rigid->SetQ(InR);
        }
    }
 
    void SetV(const FVec3& InV, bool bInvalidate = true)
    {
        VerifyContext();
        SetVBase(InV, bInvalidate);
    }
 
    void SetW(const FVec3& InW, bool bInvalidate = true)
    {
        VerifyContext();
        SetWBase(InW, bInvalidate);
    }
 
    void SetObjectState(const EObjectStateType InState, bool bAllowEvents = false, bool bInvalidate = true)
    {
        VerifyContext();
        SetObjectStateBase(InState, bAllowEvents, bInvalidate);
    }
};
 
static_assert(sizeof(FRigidBodyHandle_Internal) == sizeof(FSingleParticlePhysicsProxy), "Derived types only used to constrain API, all data lives in base class ");
 
inline FSingleParticlePhysicsProxy* FSingleParticlePhysicsProxy::Create(TUniquePtr<FGeometryParticle>&& Particle, UObject* InOwner = nullptr)
{
    ensure(Particle->GetProxy() == nullptr);    //not already owned by another proxy. TODO: use TUniquePtr
    auto Proxy = new FSingleParticlePhysicsProxy(MoveTemp(Particle), nullptr, InOwner);
    return Proxy;
}
}