BodySetup.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "EngineDefines.h"
#include "PhysicsEngine/BodyInstance.h"
#include "Serialization/BulkData.h"
#include "BodySetupEnums.h"
#include "PhysicsEngine/AggregateGeom.h"
#include "Interfaces/Interface_CollisionDataProvider.h"
#include "HAL/ThreadSafeBool.h"
#include "Async/TaskGraphInterfaces.h"
#include "BodySetupCore.h"
#if WITH_EDITOR
#include "Factories.h"
#endif
#include "BodySetup.generated.h"
 
class ITargetPlatform;
class UPhysicalMaterial;
class UPhysicalMaterialMask;
class UPrimitiveComponent;
struct FShapeData;
enum class EPhysXMeshCookFlags : uint8;
 
DECLARE_DELEGATE_OneParam(FOnAsyncPhysicsCookFinished, bool);
 
namespace Chaos
{
    class FImplicitObject;
    class FTriangleMeshImplicitObject;
    struct FCookHelper;
}
 
template<typename T, int d>
class FChaosDerivedDataReader;
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("BodySetup Cooking"), STAT_PhysXCooking, STATGROUP_Physics, );
 
 
struct FBodySetupUVInfo
{
    TArray<int32> IndexBuffer;
    TArray<FVector> VertPositions;
    TArray< TArray<FVector2D> > VertUVs;
 
    friend FArchive& operator<<(FArchive& Ar, FBodySetupUVInfo& UVInfo)
    {
        Ar << UVInfo.IndexBuffer;
        Ar << UVInfo.VertPositions;
        Ar << UVInfo.VertUVs;
 
        return Ar;
    }
 
    void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) const;
 
    void FillFromTriMesh(const FTriMeshCollisionData& TriMeshCollisionData);
};
 
struct FCookBodySetupInfo
{
    ENGINE_API FCookBodySetupInfo();
 
    FTriMeshCollisionData TriangleMeshDesc;
 
    EPhysXMeshCookFlags TriMeshCookFlags;
 
    EPhysXMeshCookFlags ConvexCookFlags;
 
    TArray<TArray<FVector>> NonMirroredConvexVertices;
 
    TArray<TArray<FVector>> MirroredConvexVertices;
 
    FString OuterDebugName;
 
    bool bCookNonMirroredConvex;
 
    bool bCookMirroredConvex;
 
    bool bConvexDeformableMesh;
 
    bool bCookTriMesh;
 
    bool bSupportUVFromHitResults;
 
    bool bSupportFaceRemap;
 
    bool bTriMeshError;
};
 
struct FPhysXCookHelper;
 
UCLASS(collapseCategories, MinimalAPI)
class UBodySetup : public UBodySetupCore
{
    GENERATED_UCLASS_BODY()
 
    
    UBodySetup(FVTableHelper& Helper);
 
    virtual ~UBodySetup();
 
    UPROPERTY(EditAnywhere, Category = BodySetup, meta=(DisplayName = "Primitives", NoResetToDefault))
    struct FKAggregateGeom AggGeom;
 
    UPROPERTY()
    uint8 bAlwaysFullAnimWeight_DEPRECATED:1;
 
    UPROPERTY(EditAnywhere, Category=BodySetup)
    uint8 bConsiderForBounds:1;
 
    UPROPERTY(Transient)
    uint8 bMeshCollideAll:1;
 
    UPROPERTY(EditAnywhere, Category=Physics)
    uint8 bDoubleSidedGeometry : 1;
 
    UPROPERTY()
    uint8 bGenerateNonMirroredCollision:1;
 
    UPROPERTY()
    uint8 bSharedCookedData : 1;
 
    UPROPERTY()
    uint8 bGenerateMirroredCollision:1;
 
    UPROPERTY()
    uint8 bSupportUVsAndFaceRemap:1;
 
    uint8 bCreatedPhysicsMeshes:1;
 
    uint8 bFailedToCreatePhysicsMeshes:1;
 
    uint8 bHasCookedCollisionData:1;
 
    UPROPERTY(EditAnywhere, Category = Collision)
    uint8 bNeverNeedsCookedCollisionData:1;
    
    UPROPERTY(EditAnywhere, Category=Physics, meta=(DisplayName="Simple Collision Physical Material"))
    TObjectPtr<class UPhysicalMaterial> PhysMaterial;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category=Physics)
    struct FWalkableSlopeOverride WalkableSlopeOverride;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float BuildScale_DEPRECATED;
#endif
 
    FFormatContainer CookedFormatData;
 
#if WITH_EDITORONLY_DATA
    FCriticalSection CookedFormatDataMutex;
#endif
 
    FGuid BodySetupGuid;
    
    TArray<Chaos::FTriangleMeshImplicitObjectPtr> TriMeshGeometries;
 
    FBodySetupUVInfo UVInfo;
 
    TArray<int32> FaceRemap;
 
    UPROPERTY(EditAnywhere, Category=Collision, meta=(FullyExpand = "true"))
    FBodyInstance DefaultInstance;
 
    FFormatContainer* CookedFormatDataOverride;
 
    UPROPERTY()
    FVector BuildScale3D;
 
    using FAsyncCookHelper = Chaos::FCookHelper;
    FAsyncCookHelper* CurrentCookHelper;
 
    // Will contain deserialized data from the serialization function that can be used at PostLoad time.
    TUniquePtr<FChaosDerivedDataReader<float, 3>> ChaosDerivedDataReader;
    
    UE_DEPRECATED(5.4, "Please use TriMeshGeometries instead")
    TArray<TSharedPtr<Chaos::FTriangleMeshImplicitObject, ESPMode::ThreadSafe>> ChaosTriMeshes;
 
public:
    //~ Begin UObject Interface.
    virtual void Serialize(FArchive& Ar) override;
    virtual void BeginDestroy() override;
    virtual void FinishDestroy() override;
    virtual void PostLoad() override;
    virtual void PostInitProperties() override;
#if WITH_EDITOR
    virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
    virtual void PostEditUndo() override;
    virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const override;
#endif // WITH_EDITOR
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    //~ End UObject Interface.
 
    //
    //~ Begin UBodySetup Interface.
    //
    ENGINE_API void CopyBodyPropertiesFrom(const UBodySetup* FromSetup);
 
    ENGINE_API void AddCollisionFrom(class UBodySetup* FromSetup);
    ENGINE_API void AddCollisionFrom(const FKAggregateGeom& FromAggGeom);
    ENGINE_API bool AddCollisionElemFrom(const FKAggregateGeom& FromAggGeom, const EAggCollisionShape::Type ShapeType, const int32 ElemIndex);
    
    ENGINE_API virtual void CreatePhysicsMeshes();
 
    ENGINE_API void CreatePhysicsMeshesAsync(FOnAsyncPhysicsCookFinished OnAsyncPhysicsCookFinished);
 
    ENGINE_API void AbortPhysicsMeshAsyncCreation();
 
    enum class EBodySetupCookResult
    {
        NoError,
        FailedToLock,
        FailedToCook
    };
 
    struct FBodySetupTryCookResult
    {
        FByteBulkData* Data;
        EBodySetupCookResult CookResult;
    };
 
private:
    FByteBulkData* GetCookedFormatData();
 
    FByteBulkData* GetCookedData(FName Format);
 
    FBodySetupTryCookResult TryGetCookedData(FName Format);
 
    // #TODO MRMesh for some reason needs to be able to call this - that case needs fixed to correctly use the create meshes flow
    friend class UMRMeshComponent;
    bool ProcessFormatData_Chaos(FByteBulkData* FormatData);
    bool ProcessFormatData_Chaos(FChaosDerivedDataReader<float, 3>& Reader);
    bool RuntimeCookPhysics_Chaos();
    void FinishCreatingPhysicsMeshes_Chaos(FChaosDerivedDataReader<float, 3>& InReader);
    void FinishCreatingPhysicsMeshes_Chaos(Chaos::FCookHelper& InHelper);
    void FinishCreatingPhysicsMeshes_Chaos(TArray<Chaos::FConvexPtr>& InConvexImplicits, 
                                           TArray<Chaos::FTriangleMeshImplicitObjectPtr>& InTrimeshImplicits,
                                           FBodySetupUVInfo& InUvInfo,
                                           TArray<int32>& InFaceRemap);
 
    void FinishCreatePhysicsMeshesAsync(FAsyncCookHelper* AsyncPhysicsCookHelper, FOnAsyncPhysicsCookFinished OnAsyncPhysicsCookFinished);
 
public:
 
    void GetGeometryDDCKey(FString& OutString) const;
 
    UE_DEPRECATED(5.1, "Use GetScaledVolume which uses the same scaling technique as the generated collision geometry")
    ENGINE_API virtual float GetVolume(const FVector& Scale) const;
 
    ENGINE_API virtual FVector::FReal GetScaledVolume(const FVector& Scale) const;
 
    ENGINE_API void ClearPhysicsMeshes();
 
    ENGINE_API virtual float CalculateMass(const UPrimitiveComponent* Component = nullptr) const;
 
    ENGINE_API class UPhysicalMaterial* GetPhysMaterial() const;
 
    ENGINE_API void RemoveSimpleCollision();
 
    ENGINE_API void RescaleSimpleCollision( FVector BuildScale );
 
    ENGINE_API virtual void InvalidatePhysicsData();    
 
    ENGINE_API bool CreateFromModel(class UModel* InModel, bool bRemoveExisting);
 
    ENGINE_API void UpdateTriMeshVertices(const TArray<FVector> & NewPositions);
 
    ENGINE_API float GetShortestDistanceToPoint(const FVector& WorldPosition, const FTransform& BodyToWorldTM, bool bUseConvexShapes = false) const;
 
    ENGINE_API float GetClosestPointAndNormal(const FVector& WorldPosition, const FTransform& BodyToWorldTM, FVector& ClosestWorldPosition, FVector& FeatureNormal, bool bUseConvexShapes = false) const;
 
    ENGINE_API void GetCookInfo(FCookBodySetupInfo& OutCookInfo, EPhysXMeshCookFlags InCookFlags) const;
 
    bool CalcUVAtLocation(const FVector& BodySpaceLocation, int32 FaceIndex, int32 UVChannel, FVector2D& UV) const;
 
 
#if WITH_EDITOR
    ENGINE_API virtual void BeginCacheForCookedPlatformData(  const ITargetPlatform* TargetPlatform ) override;
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded(  const ITargetPlatform* TargetPlatform ) override;
    ENGINE_API virtual void ClearCachedCookedPlatformData(  const ITargetPlatform* TargetPlatform ) override;
 
    /*
    * Copy all UPROPERTY settings except the collision geometry.
    * This function is use when we restore the original data after a re-import of a static mesh.
    * All FProperty should be copy here except the collision geometry (i.e. AggGeom)
    */
    ENGINE_API virtual void CopyBodySetupProperty(const UBodySetup* Other);
#endif // WITH_EDITOR
 
    ENGINE_API void AddShapesToRigidActor_AssumesLocked(
        FBodyInstance* OwningInstance, 
        FVector& Scale3D, 
        UPhysicalMaterial* SimpleMaterial,
        TArray<UPhysicalMaterial*>& ComplexMaterials,
        TArray<FPhysicalMaterialMaskParams>& ComplexMaterialMasks,
        const FBodyCollisionData& BodyCollisionData,
        const FTransform& RelativeTM = FTransform::Identity, 
        TArray<FPhysicsShapeHandle>* NewShapes = NULL);
 
    friend struct FIterateBodySetupHelper;
 
};
 
#if WITH_EDITOR
 
class FBodySetupObjectTextFactory : public FCustomizableTextObjectFactory
{
public:
    FBodySetupObjectTextFactory() : FCustomizableTextObjectFactory(GWarn) { }
    ENGINE_API virtual bool CanCreateClass(UClass* InObjectClass, bool& bOmitSubObjs) const override;
    ENGINE_API virtual void ProcessConstructedObject(UObject* NewObject) override;
 
public:
    TArray<UBodySetup*> NewBodySetups;
};
 
#endif // WITH_EDITOR