PhysicsAsset.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "PhysicsEngine/RigidBodyIndexPair.h"
#include "Interfaces/Interface_PreviewMeshProvider.h"
#include "Interfaces/Interface_AssetUserData.h"
#include "PhysicsAsset.generated.h"
 
namespace ECollisionEnabled { enum Type : int; }
namespace EAggCollisionShape { enum Type : int; }
 
struct FConstraintInstance;
struct FConstraintInstanceAccessor;
struct FReferenceSkeleton;
 
class UMaterialInterface;
class FMeshElementCollector;
class USkeletalBodySetup;
 
 
USTRUCT(BlueprintType)
struct FPhysicsAssetSolverSettings
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FPhysicsAssetSolverSettings();
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings)
    int32 PositionIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings)
    int32 VelocityIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings)
    int32 ProjectionIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMin = 0))
    float CullDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMin = 0))
    float MaxDepenetrationVelocity;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMin = 0))
    float FixedTimeStep;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings)
    bool bUseLinearJointSolver;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CollisionSettings)
    bool bUseManifolds;
};
 
 
USTRUCT(BlueprintType)
struct FSolverIterations
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FSolverIterations();
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMax = 50))
        int32 SolverIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMax = 50))
        int32 JointIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMax = 50))
        int32 CollisionIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMax = 50))
        int32 SolverPushOutIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMax = 50))
        int32 JointPushOutIterations;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SolverSettings, meta = (ClampMax = 50))
        int32 CollisionPushOutIterations;
};
 
 
 
 
UENUM()
enum class EPhysicsAssetSolverType: uint8
{
    RBAN,
    World,
};
 
UCLASS(hidecategories=Object, BlueprintType, MinimalAPI, Config=Game, PerObjectConfig, AutoCollapseCategories=(OldSolverSettings))
class UPhysicsAsset : public UObject, public IInterface_PreviewMeshProvider, public IInterface_AssetUserData
{
    GENERATED_UCLASS_BODY()
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<class USkeletalMesh>  DefaultSkelMesh_DEPRECATED;
 
    UPROPERTY(AssetRegistrySearchable)
    TSoftObjectPtr<class USkeletalMesh> PreviewSkeletalMesh;
 
    UPROPERTY(EditAnywhere, Category = Profiles, meta=(DisableCopyPaste))
    TArray<FName> PhysicalAnimationProfiles;
 
    UPROPERTY(EditAnywhere, Category = Profiles, meta=(DisableCopyPaste))
    TArray<FName> ConstraintProfiles;
 
    UPROPERTY()
    TArray<int32> EditorBodyFlags;
 
    UPROPERTY(transient)
    FName CurrentPhysicalAnimationProfileName;
 
    UPROPERTY(transient)
    FName CurrentConstraintProfileName;
 
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    TArray<int32> BoundsBodies;
 
    UPROPERTY(instanced)
    TArray<TObjectPtr<USkeletalBodySetup>> SkeletalBodySetups;
 
    UPROPERTY(instanced)
    TArray<TObjectPtr<class UPhysicsConstraintTemplate>> ConstraintSetup;
 
public:
 
    UPROPERTY(EditAnywhere, Category = SolverSettings, Config)
    FPhysicsAssetSolverSettings SolverSettings;
 
    UPROPERTY(VisibleAnywhere, Category = OldSolverSettings, Config, Meta = (DisplayName="[Not Used] Old Solver Settings"))
    FSolverIterations SolverIterations;
 
    UPROPERTY(EditAnywhere, Category = SolverSettings)
    EPhysicsAssetSolverType SolverType;
 
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Physics)
    uint8 bNotForDedicatedServer:1;
 
    TMap<FName, int32>                  BodySetupIndexMap;
 
    TMap<FRigidBodyIndexPair,bool>      CollisionDisableTable;
 
    UPROPERTY(VisibleAnywhere, Instanced, Category = Thumbnail)
    TObjectPtr<class UThumbnailInfo> ThumbnailInfo;
 
    //~ Begin UObject Interface
    virtual void Serialize(FArchive& Ar) override;
    virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    static void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
    virtual FString GetDesc() override;
    virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
#if WITH_EDITOR
    virtual void PostEditUndo() override;
 
    const TArray<FName>& GetPhysicalAnimationProfileNames() const
    {
        return PhysicalAnimationProfiles;
    }
 
    const TArray<FName>& GetConstraintProfileNames() const
    {
        return ConstraintProfiles;
    }
 
    virtual void PreEditChange(FProperty* PropertyThatWillChange) override;
    virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
    virtual EDataValidationResult IsDataValid(class FDataValidationContext& Context) const override;
#endif
    //~ End UObject Interface
 
    // Find the index of the physics bone that is controlling this graphics bone.
    ENGINE_API int32        FindControllingBodyIndex(const class USkeletalMesh* skelMesh, int32 BoneIndex) const;
    ENGINE_API int32        FindParentBodyIndex(const class USkeletalMesh * skelMesh, int32 StartBoneIndex) const;
    ENGINE_API int32        FindParentBodyIndex(const FReferenceSkeleton& RefSkeleton, const int32 StartBoneIndex) const;
    ENGINE_API int32        FindConstraintIndex(FName ConstraintName) const;
    ENGINE_API int32        FindConstraintIndex(FName Bone1Name, FName Bone2Name) const;
    FName                   FindConstraintBoneName(int32 ConstraintIndex) const;
    ENGINE_API int32        FindMirroredBone(const class USkeletalMesh* skelMesh, int32 BoneIndex) const;
 
    ENGINE_API void         GetBodyIndicesBelow(TArray<int32>& OutBodyIndices, FName InBoneName, const USkeletalMesh* InSkelMesh, bool bIncludeParent = true) const;
    ENGINE_API void         GetBodyIndicesBelow(TArray<int32>& OutBodyIndices, const FName InBoneName, const FReferenceSkeleton& RefSkeleton, const bool bIncludeParent = true) const;
 
    ENGINE_API void         GetNearestBodyIndicesBelow(TArray<int32> & OutBodyIndices, FName InBoneName, const USkeletalMesh* InSkelMesh) const;
 
    ENGINE_API FBox         CalcAABB(const class USkinnedMeshComponent* MeshComponent, const FTransform& LocalToWorld) const;
 
    ENGINE_API void ClearAllPhysicsMeshes();
    
#if WITH_EDITOR
    ENGINE_API bool CanCalculateValidAABB(const class USkinnedMeshComponent* MeshComponent, const FTransform& LocalToWorld) const;
 
    ENGINE_API void InvalidateAllPhysicsMeshes();
#endif
 
    // @todo document
    void GetCollisionMesh(int32 ViewIndex, FMeshElementCollector& Collector, const FReferenceSkeleton& RefSkeleton, const TArray<FTransform>& SpaceBases, const FTransform& LocalToWorld, const FVector& Scale3D) const;
 
    // @todo document
    void DrawConstraints(int32 ViewIndex, FMeshElementCollector& Collector, const FReferenceSkeleton& RefSkeleton, const TArray<FTransform>& SpaceBases, const FTransform& LocalToWorld, float Scale) const;
 
    ENGINE_API void GetUsedMaterials(TArray<UMaterialInterface*>& Materials);
 
    // Disable collsion between the bodies specified by index
    ENGINE_API void DisableCollision(int32 BodyIndexA, int32 BodyIndexB);
 
    // Enable collsion between the bodies specified by index
    ENGINE_API void EnableCollision(int32 BodyIndexA, int32 BodyIndexB);
 
    // Check whether the two bodies specified are enabled for collision
    ENGINE_API bool IsCollisionEnabled(int32 BodyIndexA, int32 BodyIndexB) const;
 
    // Get the per-primitive collision filtering mode for a body
    ENGINE_API void SetPrimitiveCollision(int32 BodyIndex, EAggCollisionShape::Type PrimitiveType, int32 PrimitiveIndex, ECollisionEnabled::Type CollisionEnabled);
 
    // Get the per-primitive collision filtering mode for a body
    ENGINE_API ECollisionEnabled::Type GetPrimitiveCollision(int32 BodyIndex, EAggCollisionShape::Type PrimitiveType, int32 PrimitiveIndex) const;
 
    // Set whether or not a primitive volume contributes to the mass of the object
    ENGINE_API void SetPrimitiveContributeToMass(int32 BodyIndex, EAggCollisionShape::Type PrimitiveType, int32 PrimitiveIndex, bool bContributesToMass);
 
    // Get whether or not a primitive volume contributes to the mass of the object
    ENGINE_API bool GetPrimitiveContributeToMass(int32 BodyIndex, EAggCollisionShape::Type PrimitiveType, int32 PrimitiveIndex) const;
 
    ENGINE_API void UpdateBoundsBodiesArray();
 
    ENGINE_API void UpdateBodySetupIndexMap();
 
 
    // @todo document
    ENGINE_API int32 FindBodyIndex(FName BodyName) const;
 
    ENGINE_API void BodyFindConstraints(int32 BodyIndex, TArray<int32>& Constraints);
 
#if WITH_EDITOR
    ENGINE_API void RefreshPhysicsAssetChange() const;
#endif
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FRefreshPhysicsAssetChangeDelegate, const UPhysicsAsset*);
    ENGINE_API static FRefreshPhysicsAssetChangeDelegate OnRefreshPhysicsAssetChange;
    virtual void SetPreviewMesh(USkeletalMesh* PreviewMesh, bool bMarkAsDirty = true);
    virtual USkeletalMesh* GetPreviewMesh() const;
 
#if WITH_EDITOR
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    FConstraintInstanceAccessor GetConstraintByName(FName ConstraintName);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    FConstraintInstanceAccessor GetConstraintByBoneNames(FName Bone1Name, FName Bone2Name);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    void GetConstraints(bool bIncludesTerminated, TArray<FConstraintInstanceAccessor>& OutConstraints);
 
    FConstraintInstanceAccessor GetConstraintInstanceAccessorByIndex(int32 Index);
    FConstraintInstance* GetConstraintInstanceByIndex(uint32 Index);
#endif
 
private:
 
#if WITH_EDITORONLY_DATA
    TArray<FName> PrePhysicalAnimationProfiles;
    TArray<FName> PreConstraintProfiles;
#endif
 
 
    UPROPERTY(instanced)
    TArray<TObjectPtr<class UBodySetup>> BodySetup_DEPRECATED;
 
    // Asset User Data
public:
    ENGINE_API void AddAssetUserData(UAssetUserData* InUserData) override;
    ENGINE_API void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API const TArray<UAssetUserData*>* GetAssetUserDataArray() const override;
 
private:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = UserData)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
};
 
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_5
#include "CoreMinimal.h"
#include "Engine/SkeletalMesh.h"
#include "PhysicsEngine/BodySetup.h"
#include "PhysicsEngine/PhysicalAnimationComponent.h"
#include "PhysicsEngine/SkeletalBodySetup.h"
#endif