PhysicsProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Chaos/ArrayCollectionArray.h"
#include "Chaos/Declares.h"
#include "Chaos/Framework/PhysicsSolverBase.h"
#include "Chaos/Framework/PhysicsProxyBase.h"
#include "UObject/GCObject.h"
//
// NOTE: This file is widely included in Engine code. 
// Avoid including Chaos headers when possible.
//
 
struct FKinematicProxy;
class FFieldSystemCommand;
struct FBodyInstance;
 
namespace Chaos
{
    template<typename T, int D> class TPBDRigidParticles;
 
    using FPBDRigidParticles = TPBDRigidParticles<FReal, 3>;
}
 
template<class Concrete, class ConcreteData, typename TProxyTimeStamp>
class TPhysicsProxy : public IPhysicsProxyBase
{
 
public:
    using FParticleType = Concrete;
 
    using FParticlesType = Chaos::FPBDRigidParticles;
    using FIntArray = Chaos::TArrayCollectionArray<int32>;
 
    TPhysicsProxy()
        : IPhysicsProxyBase(ConcreteType(), nullptr, MakeShared<TProxyTimeStamp>())
    {
    }
 
    explicit TPhysicsProxy(UObject* InOwner)
        : IPhysicsProxyBase(ConcreteType(), InOwner, MakeShared<TProxyTimeStamp>())
    {
    }
 
    virtual ~TPhysicsProxy() {}
 
    // Previously callback related functions, all called in the context of the physics thread if enabled.
    bool IsSimulating() const { return static_cast<const Concrete*>(this)->IsSimulating(); }
    void UpdateKinematicBodiesCallback(const FParticlesType& InParticles, const float InDt, const float InTime, FKinematicProxy& InKinematicProxy) { static_cast<Concrete*>(this)->UpdateKinematicBodiesCallback(InParticles, InDt, InTime, InKinematicProxy); }
    void StartFrameCallback(const float InDt, const float InTime) { static_cast<Concrete*>(this)->StartFrameCallback(InDt, InTime); }
    void EndFrameCallback(const float InDt) { static_cast<Concrete*>(this)->EndFrameCallback(InDt); }
    void CreateRigidBodyCallback(FParticlesType& InOutParticles) { static_cast<Concrete*>(this)->CreateRigidBodyCallback(InOutParticles); }
    void DisableCollisionsCallback(TSet<TTuple<int32, int32>>& InPairs) { static_cast<Concrete*>(this)->DisableCollisionsCallback(InPairs); }
    void AddForceCallback(FParticlesType& InParticles, const float InDt, const int32 InIndex) { static_cast<Concrete*>(this)->AddForceCallback(InParticles, InDt, InIndex); }
 
    void BindParticleCallbackMapping(Chaos::TArrayCollectionArray<PhysicsProxyWrapper> & PhysicsProxyReverseMap, Chaos::TArrayCollectionArray<int32> & ParticleIDReverseMap) {static_cast<Concrete*>(this)->BindParticleCallbackMapping(PhysicsProxyReverseMap, ParticleIDReverseMap);}
 
    static constexpr EPhysicsProxyType ConcreteType() { return Concrete::ConcreteType(); }
    
    //ConcreteData* NewData() { return static_cast<Concrete*>(this)->NewData(); }
 
    //void PushToPhysicsState(const ConcreteData* InData) { static_cast<Concrete*>(this)->PushToPhysicsState(InData); }
 
    void ClearAccumulatedData() { static_cast<Concrete*>(this)->ClearAccumulatedData(); }
    
    void SyncBeforeDestroy() { static_cast<Concrete*>(this)->SyncBeforeDestroy(); }
 
    void OnRemoveFromScene() { static_cast<Concrete*>(this)->OnRemoveFromScene(); }
 
    bool IsDirty() { return static_cast<Concrete*>(this)->IsDirty(); }
 
    void* GetUserData() const { return nullptr; }
 
    Chaos::FRigidTransform3 GetTransform() const { return Chaos::FRigidTransform3(); }
    
    FORCEINLINE_DEBUGGABLE TProxyTimeStamp& GetSyncTimestampTyped()
    {
        return GetSyncTimestampAs<TProxyTimeStamp>();
    }
};