ClothingAsset.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "ClothingAssetBase.h"
#include "ClothConfigBase.h"
#include "ClothLODData.h"
#include "ClothConfig_Legacy.h"
#include "ClothLODData_Legacy.h"
#include "ClothingSimulationInteractor.h"
#include "Algo/AnyOf.h"
#include "ClothingAsset.generated.h"
 
#define UE_API CLOTHINGSYSTEMRUNTIMECOMMON_API
 
class UPhysicsAsset;
struct FSkelMeshSection;
 
namespace ClothingAssetUtils
{
    struct FClothingAssetMeshBinding
    {
        UClothingAssetBase* Asset;
        int32 LODIndex;
        int32 SectionIndex;
        int32 AssetInternalLodIndex;
    };
 
#if WITH_EDITOR
    UE_API void UnbindFromSkeletalMesh(const UClothingAssetBase& Asset, USkeletalMesh& SkeletalMesh);
 
    UE_API void UnbindFromSkeletalMesh(const UClothingAssetBase& Asset, USkeletalMesh& SkeletalMesh, const int32 MeshLodIndex);
 
    UE_API bool HasAnyMeshClothingAssetBindings(const USkeletalMesh* SkeletalMesh);
 
    UE_API bool HasAnyLodMeshClothingAssetBindings(const USkeletalMesh* SkeletalMesh, const int32 LodIndex);
 
    UE_API void GetAllMeshClothingAssetBindings(const USkeletalMesh* SkeletalMesh, TArray<FClothingAssetMeshBinding>& OutBindings);
 
    UE_API void GetAllLodMeshClothingAssetBindings(
        const USkeletalMesh* SkeletalMesh,
        TArray<FClothingAssetMeshBinding>& OutBindings,
        int32 LodIndex);
 
    UE_API void ClearLODBiasMappings(USkeletalMesh& SkeletalMesh, const int32 UpdatedLodIndex, const int32 SectionIndex);
 
    UE_DEPRECATED(5.7, "Unused low level function, will be removed or re-added as a member to FSkelMeshSection.")
    UE_API void ClearSectionClothingData(FSkelMeshSection& Section);
#endif
}
 
class UE_DEPRECATED(5.0, "Redundant class.") UClothingAssetCustomData;
UCLASS(Abstract, MinimalAPI)
class UClothingAssetCustomData : public UObject
{
    GENERATED_BODY()
};
 
enum class EClothingCachedDataFlagsCommon : uint8
{
    None = 0,
    InverseMasses = 1 << 0,
    NumInfluences = 1 << 1,
    SelfCollisionData = 1 << 2,
    Tethers = 1 << 3,
    All = 0xFF
};
ENUM_CLASS_FLAGS(EClothingCachedDataFlagsCommon);
 
UCLASS(hidecategories = Object, BlueprintType, MinimalAPI)
class UClothingAssetCommon : public UClothingAssetBase
{
    GENERATED_BODY()
public:
 
    UE_API UClothingAssetCommon(const FObjectInitializer& ObjectInitializer);
 
#if WITH_EDITOR
 
    UE_API virtual bool BindToSkeletalMesh(USkeletalMesh* InSkelMesh, const int32 InMeshLodIndex, const int32 InSectionIndex, const int32 InAssetLodIndex) override;
 
    UE_API virtual void UnbindFromSkeletalMesh(USkeletalMesh* InSkelMesh) override;
    UE_API virtual void UnbindFromSkeletalMesh(USkeletalMesh* InSkelMesh, const int32 InMeshLodIndex) override;
 
    UE_API virtual void UpdateAllLODBiasMappings(USkeletalMesh* SkeletalMesh) override;
 
    UE_API void ApplyParameterMasks(bool bUpdateFixedVertData = false, bool bInvalidateDerivedDataCache = true);
 
    UE_API void BuildLodTransitionData();
 
    //~ Begin UObject interface
    UE_API virtual void PreEditUndo() override;
 
    UE_API virtual void PostEditUndo() override;
    //~ End UObject interface
#endif // WITH_EDITOR
 
    UE_API virtual void RefreshBoneMapping(USkeletalMesh* InSkelMesh) override;
 
    UE_API void CalculateReferenceBoneIndex();
 
    UE_API virtual bool IsValidLod(int32 InLodIndex) const override;
 
    UE_API virtual int32 GetNumLods() const override;
 
#if WITH_EDITORONLY_DATA
    virtual void InvalidateAllCachedData() override { InvalidateFlaggedCachedData(EClothingCachedDataFlagsCommon::All); }
 
    UE_API void InvalidateFlaggedCachedData(EClothingCachedDataFlagsCommon Flags);
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
    UE_API virtual int32 AddNewLod() override;
 
    /* Called after changes in any of the asset properties. */
    UE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& ChainEvent) override;
#endif // WITH_EDITOR
 
    template<typename ClothConfigType, typename = typename TEnableIf<TIsDerivedFrom<ClothConfigType, UClothConfigBase>::IsDerived>::Type>
    const ClothConfigType* GetClothConfig() const
    {
        auto const* const ClothConfig = ClothConfigs.Find(ClothConfigType::StaticClass()->GetFName());
        return ClothConfig ? ExactCast<ClothConfigType>(*ClothConfig) : nullptr;
    }
 
    template<typename ClothConfigType, typename = typename TEnableIf<TIsDerivedFrom<ClothConfigType, UClothConfigBase>::IsDerived>::Type>
    ClothConfigType* GetClothConfig()
    {
        auto const* const ClothConfig = ClothConfigs.Find(ClothConfigType::StaticClass()->GetFName());
        return ClothConfig ? ExactCast<ClothConfigType>(*ClothConfig) : nullptr;
    }
 
    UE_API virtual void PostLoad() override;
#if WITH_EDITORONLY_DATA
    static UE_API void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
 
    UE_API virtual void Serialize(FArchive& Ar) override;
 
    UE_API virtual void PostUpdateAllAssets() override;
 
    // The physics asset to extract collisions from when building a simulation.
    UPROPERTY(EditAnywhere, Category = "Skeletal Mesh Clothing")
    TObjectPtr<UPhysicsAsset> PhysicsAsset;
 
    // Simulation specific cloth parameters. 
    // Use GetClothConfig() to retrieve the correct parameters/config type for the desired cloth simulation system.
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, EditFixedSize, Instanced, Category = "Skeletal Mesh Clothing")
    TMap<FName, TObjectPtr<UClothConfigBase>> ClothConfigs;
 
#if WITH_EDITORONLY_DATA
    // Shared by all cloth instances in a skeletal mesh
    // Only supported with Chaos Cloth for now
    // This may not be editable on unused cloth assets
    UPROPERTY()
    TObjectPtr<UClothConfigBase> ClothSharedSimConfig_DEPRECATED;
 
    // Parameters for how the NVcloth behaves.
    // These will have no effect on Chaos cloth
    UPROPERTY()
    TObjectPtr<UClothConfigBase> ClothSimConfig_DEPRECATED;
 
    // Parameters for how Chaos cloth behaves 
    // These will not affect NVcloth
    // For now, we have two configuration parameters so that we can switch between chaos and
    // non chaos at will without losing the original NVcloth data
    UPROPERTY()
    TObjectPtr<UClothConfigBase> ChaosClothSimConfig_DEPRECATED;
 
    // Deprecated. Use LodData instead
    UPROPERTY()
    TArray<TObjectPtr<UClothLODDataCommon_Legacy>> ClothLodData_DEPRECATED;
#endif
 
    // The actual asset data, listed by LOD.
    UPROPERTY()
    TArray<FClothLODDataCommon> LodData;
 
    // Tracks which clothing LOD each skel mesh LOD corresponds to (LodMap[SkelLod]=ClothingLod).
    UPROPERTY()
    TArray<int32> LodMap;
 
    // List of bones this asset uses inside its parent mesh.
    UPROPERTY()
    TArray<FName> UsedBoneNames;
 
    // List of the indices for the bones in UsedBoneNames, used for remapping.
    UPROPERTY()
    TArray<int32> UsedBoneIndices;
 
    // Bone to treat as the root of the simulation space.
    UPROPERTY()
    int32 ReferenceBoneIndex;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FClothConfig_Legacy ClothConfig_DEPRECATED;
#endif
 
private:
 
    // Add or replace a new cloth config of the specified type.
    template<typename ClothConfigType, typename = typename TEnableIf<TIsDerivedFrom<ClothConfigType, UClothConfigBase>::IsDerived>::Type>
    void SetClothConfig(ClothConfigType* ClothConfig)
    {
        check(ClothConfig);
        ClothConfigs.Add(ClothConfig->GetClass()->GetFName(), static_cast<UClothConfigBase*>(ClothConfig));
    }
 
    // Create and add any missing cloth configs.
    // If a config from a different factory exists already, the newly
    // created config will attempt to initialize its parameters from it.
    // Return true when at least one config has been added, false otherwise.
    bool AddClothConfigs();
 
    // Propagate the shared simulation configs between assets.
    // Also migrate all deprecated shared parameters which have been moved to the per cloth configs if required.
    // Called after a cloth asset is created or loaded.
    void PropagateSharedConfigs(bool bMigrateSharedConfigToConfig=false);
 
    // Return true when any one of the cloth configs fullfill the predicate.
    // Used to select which type of data to cache.
    template<typename PredicateType>
    bool AnyOfClothConfigs(PredicateType Predicate) const
    {
        return Algo::AnyOf(ClothConfigs, [&Predicate](const TPair<FName, TObjectPtr<UClothConfigBase>>& ClothConfig)
            {
                return Predicate(*ClothConfig.Value);
            });
    }
 
#if WITH_EDITOR
    // Add extra cloth deformer mappings to cope with a different raytracing LOD than the one currently rendered.
    void UpdateLODBiasMappings(const USkeletalMesh* SkeletalMesh, int32 UpdatedLODIndex, int32 SectionIndex);
 
    // Helper functions used in PostPropertyChangeCb
    void ReregisterComponentsUsingClothing();
    void ForEachInteractorUsingClothing(TFunction<void (UClothingSimulationInteractor*)> Func);
#endif // WITH_EDITOR
};
 
#undef UE_API