PhysicsPublic.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    PhysicsPublic.h
    Rigid Body Physics Public Types
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "Engine/EngineTypes.h"
#include "Misc/CoreMisc.h"
#include "Misc/App.h"
#include "EngineDefines.h"
#include "PhysicsInterfaceDeclaresCore.h"
#include "PhysicsPublicCore.h"
//#include "StaticMeshResources.h"
 
class AActor;
class ULineBatchComponent;
class UPhysicalMaterial;
class UPhysicsAsset;
class UPrimitiveComponent;
class USkeletalMeshComponent;
struct FConstraintInstance;
struct FBodyInstance;
struct FStaticMeshVertexBuffers;
class FPhysScene_PhysX;
class FLocalVertexFactory;
class FDynamicMeshIndexBuffer32;
 
DECLARE_DELEGATE_TwoParams(FCalculateCustomPhysics, float, FBodyInstance*);
 
DECLARE_DELEGATE_TwoParams(FCalculateCustomProjection, const FBodyInstance*, FTransform&);
 
DECLARE_MULTICAST_DELEGATE_OneParam(FRecalculatedMassProperties, FBodyInstance*);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("FetchAndStart Time (all)"), STAT_TotalPhysicsTime, STATGROUP_Physics, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Cloth Actor Count"), STAT_NumCloths, STATGROUP_Physics, ENGINE_API);
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Simulated Cloth Verts"), STAT_NumClothVerts, STATGROUP_Physics, ENGINE_API);
 
extern ENGINE_API class FPhysCommandHandler* GPhysCommandHandler;
 
struct FRigidBodyCollisionInfo
{
    TWeakObjectPtr<AActor>                  Actor;
 
    TWeakObjectPtr<UPrimitiveComponent>     Component;
 
    int32                                   BodyIndex;
 
    FName                                   BoneName;
 
    FVector                                 DeltaVelocity;
 
    FRigidBodyCollisionInfo() :
        BodyIndex(INDEX_NONE),
        BoneName(NAME_None)
    {}
 
    ENGINE_API void SetFrom(const FBodyInstance* BodyInst, const FVector& InDeltaVelocity = FVector::ZeroVector);
    ENGINE_API FBodyInstance* GetBodyInstance() const;
};
 
struct FCollisionNotifyInfo
{
    bool                            bCallEvent0;
 
    bool                            bCallEvent1;
 
    FRigidBodyCollisionInfo         Info0;
 
    FRigidBodyCollisionInfo         Info1;
 
    FCollisionImpactData            RigidCollisionData;
 
    Chaos::FReal                    SolverTime;
 
    FCollisionNotifyInfo() :
        bCallEvent0(false),
        bCallEvent1(false),
        SolverTime((Chaos::FReal)0.0)
    {}
 
    ENGINE_API bool IsValidForNotify() const;
};
 
namespace PhysCommand
{
    enum Type
    {
        Release,
        ReleasePScene,
        DeleteCPUDispatcher,
        DeleteSimEventCallback,
        DeleteContactModifyCallback,
        DeleteCCDContactModifyCallback,
        DeleteMbpBroadphaseCallback,
        Max
    };
}
 
class FPhysCommandHandler
{
public:
 
    ~FPhysCommandHandler();
    
    void ENGINE_API Flush();
    bool ENGINE_API HasPendingCommands();
 
private:
 
    struct FPhysPendingCommand
    {
        //union
        //{
        //} Pointer;
 
        PhysCommand::Type CommandType;
    };
 
    void ExecuteCommands();
 
    void EnqueueCommand(const FPhysPendingCommand& Command);
 
    TArray<FPhysPendingCommand> PendingCommands;
};
 
void ClearForces_AssumesLocked(FBodyInstance* BodyInstance, bool bAllowSubstepping);
 
 
void ClearTorques_AssumesLocked(FBodyInstance* BodyInstance, bool bAllowSubstepping);
 
inline bool PhysSingleThreadedMode()
{
    if (IsRunningDedicatedServer() || !FApp::ShouldUseThreadingForPerformance() || FPlatformMisc::NumberOfCores() < 3 || !FPlatformProcess::SupportsMultithreading() || FParse::Param(FCommandLine::Get(), TEXT("SingleThreadedPhysics")))
    {
        return true;
    }
    return false;
}
 
// Only used for legacy serialization (ver < VER_UE4_REMOVE_PHYS_SCALED_GEOM_CACHES)
class FKCachedConvexDataElement
{
public:
    TArray<uint8>   ConvexElementData;
 
    friend FArchive& operator<<( FArchive& Ar, FKCachedConvexDataElement& S )
    {
        S.ConvexElementData.BulkSerialize(Ar);
        return Ar;
    }
};
 
// Only used for legacy serialization (ver < VER_UE4_REMOVE_PHYS_SCALED_GEOM_CACHES)
class FKCachedConvexData
{
public:
    TArray<FKCachedConvexDataElement>   CachedConvexElements;
 
    friend FArchive& operator<<( FArchive& Ar, FKCachedConvexData& S )
    {
        Ar << S.CachedConvexElements;
        return Ar;
    }
};
 
// Only used for legacy serialization (ver < VER_UE4_ADD_BODYSETUP_GUID)
struct FKCachedPerTriData
{
    TArray<uint8> CachedPerTriData;
 
    friend FArchive& operator<<( FArchive& Ar, FKCachedPerTriData& S )
    {
        S.CachedPerTriData.BulkSerialize(Ar);
        return Ar;
    }
};
 
class FKConvexGeomRenderInfo
{
public:
    FStaticMeshVertexBuffers* VertexBuffers;
    FDynamicMeshIndexBuffer32* IndexBuffer;
    FLocalVertexFactory* CollisionVertexFactory;
 
    FKConvexGeomRenderInfo();
 
    bool HasValidGeometry();
};
 
ENGINE_API bool InitGamePhys();
ENGINE_API void TermGamePhys();
 
ENGINE_API void DeferredPhysResourceCleanup();
 
 
FTransform FindBodyTransform(AActor* Actor, FName BoneName);
FBox    FindBodyBox(AActor* Actor, FName BoneName);
 
class FPhysicsDelegates : public FPhysicsDelegatesCore
{
public:
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPhysicsAssetChanged, const UPhysicsAsset*);
    static ENGINE_API FOnPhysicsAssetChanged OnPhysicsAssetChanged;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPhysSceneInit, FPhysScene*);
    static ENGINE_API FOnPhysSceneInit OnPhysSceneInit;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPhysSceneTerm, FPhysScene*);
    static ENGINE_API FOnPhysSceneTerm OnPhysSceneTerm;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnPhysDispatchNotifications, FPhysScene*);
    static ENGINE_API FOnPhysDispatchNotifications OnPhysDispatchNotifications;
};