ClothingSimulationInstance.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "ClothingSimulationInterface.h"
#include "Math/BoxSphereBounds.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "ClothingSimulationInstance.generated.h"
 
#define UE_API CLOTHINGSYSTEMRUNTIMEINTERFACE_API
 
struct FClothSimulData;
class UClothingSimulationFactory;
class UClothingSimulationInteractor;
class USkeletalMesh;
class USkeletalMeshComponent;
class USkinnedMeshComponent;
 
USTRUCT()
struct FClothingSimulationInstance
{
public:
    GENERATED_BODY()
 
    
    struct FFactoryAssetGroup
    {
    public:
        FFactoryAssetGroup(UClothingSimulationFactory* InClothingSimulationFactory, const int32 NumTotalClothAssets)
            : ClothingSimulationFactory(InClothingSimulationFactory)
        {
            check(ClothingSimulationFactory);
            ClothingAssets.SetNumZeroed(NumTotalClothAssets);
        }
 
        void AddClothingAsset(const UClothingAssetBase* ClothingAsset, const int32 Index)
        {
            ClothingAssets[Index] = ClothingAsset;
        }
 
        const UClothingSimulationFactory* GetClothingSimulationFactory() const
        {
            return ClothingSimulationFactory;
        }
 
    private:
        friend FClothingSimulationInstance;
        UClothingSimulationFactory* ClothingSimulationFactory;
        TArray<const UClothingAssetBase*> ClothingAssets;
    };
 
    UE_API FClothingSimulationInstance(USkeletalMeshComponent* SkeletalMeshComponent, const FFactoryAssetGroup& FactoryAssetGroup);
    
    UE_API FClothingSimulationInstance();
    UE_API ~FClothingSimulationInstance();
 
    FClothingSimulationInstance(const FClothingSimulationInstance&) = delete;
    FClothingSimulationInstance(FClothingSimulationInstance&&) = default;
    FClothingSimulationInstance& operator=(const FClothingSimulationInstance&) = delete;
    FClothingSimulationInstance& operator=(FClothingSimulationInstance&&) = default;
 
    UClothingSimulationFactory* GetClothingSimulationFactory() const
    {
        return ClothingSimulationFactory;
    }
 
    const IClothingSimulationInterface* GetClothingSimulation() const
    {
        return ClothingSimulation;
    }
 
    IClothingSimulationInterface* GetClothingSimulation()
    {
        return ClothingSimulation;
    }
 
    const IClothingSimulationContext* GetClothingSimulationContext() const
    {
        return ClothingSimulationContext;
    }
 
    IClothingSimulationContext* GetClothingSimulationContext()
    {
        return ClothingSimulationContext;
    }
 
    UClothingSimulationInteractor* GetClothingSimulationInteractor() const
    {
        return ClothingSimulationInteractor;
    }
 
    UE_API void RemoveAllClothingActors();
 
    UE_API void SyncClothingInteractor();
 
    void HardResetSimulation()
    {
        ClothingSimulation->HardResetSimulation(static_cast<const IClothingSimulationContext*>(ClothingSimulationContext));
    }
 
    void GetCollisions(FClothCollisionData& Collisions, bool bIncludeExternal) const
    {
        ClothingSimulation->GetCollisions(Collisions, bIncludeExternal);
    }
 
    UE_API void AppendUniqueCollisions(FClothCollisionData& OutCollisions, bool bIncludeExternal) const;
 
    void AddExternalCollisions(const FClothCollisionData& Collisions)
    {
        ClothingSimulation->AddExternalCollisions(Collisions);
    }
 
    void ClearExternalCollisions()
    {
        ClothingSimulation->ClearExternalCollisions();
    }
 
    UE_API void FillContextAndPrepareTick(const USkeletalMeshComponent* OwnerComponent, float DeltaTime, bool bIsInitialization);
 
    void Simulate()
    {
        if (ClothingSimulation->ShouldSimulateLOD(CurrentOwnerLODIndex))
        {
            ClothingSimulation->Simulate_AnyThread(static_cast<const IClothingSimulationContext*>(ClothingSimulationContext));
        }
        else
        {
            ClothingSimulation->ForceClothNextUpdateTeleportAndReset_AnyThread();
        }
    }
 
    void AppendSimulationData(TMap<int32, FClothSimulData>& CurrentSimulationData, const USkeletalMeshComponent* OwnerComponent, const USkinnedMeshComponent* LeaderPoseComponent) const
    {
        if (ClothingSimulation->ShouldSimulateLOD(CurrentOwnerLODIndex))
        {
            ClothingSimulation->AppendSimulationData(CurrentSimulationData, OwnerComponent, LeaderPoseComponent);
        }
    }
 
 
    FBoxSphereBounds GetBounds(const USkeletalMeshComponent* OwnerComponent) const
    {
        if (ClothingSimulation->ShouldSimulateLOD(CurrentOwnerLODIndex))
        {
            return ClothingSimulation->GetBounds(OwnerComponent);
        }
        return FBoxSphereBounds(ForceInit);
    }
 
private:
    IClothingSimulationInterface* ClothingSimulation = nullptr;
 
    IClothingSimulationContext* ClothingSimulationContext = nullptr;
 
    UPROPERTY(Transient)
    TObjectPtr<UClothingSimulationInteractor> ClothingSimulationInteractor;
 
    UPROPERTY(Transient)
    TObjectPtr<UClothingSimulationFactory> ClothingSimulationFactory;
 
    int32 CurrentOwnerLODIndex = INDEX_NONE; // This is populated by FillContextAndPrepareTick
};
 
template<>
struct TStructOpsTypeTraits<FClothingSimulationInstance> : public TStructOpsTypeTraitsBase2<FClothingSimulationInstance>
{
    enum
    {
        WithCopy = false
    };
};
 
#undef UE_API