MeshCardBuild.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/AsyncWork.h"
#include "DerivedMeshDataTaskUtils.h"
#include "MeshCardRepresentation.h"
#include "RenderDeferredCleanup.h"
#include "IAssetCompilingManager.h"
 
#if WITH_EDITORONLY_DATA
#include "MeshUtilities.h"
#endif
 
#include <atomic>
 
class FAsyncCompilationNotification;
class UStaticMesh;
struct FAppendToClassSchemaContext;
struct FSignedDistanceFieldBuildSectionData;
 
class FLumenCardBuildData
{
public:
    FLumenCardOBBf OBB;
    uint8 AxisAlignedDirectionIndex;
    ELumenCardDilationMode DilationMode = ELumenCardDilationMode::Disabled;
 
    bool ContainsNaN() const
    {
        return OBB.ContainsNaN();
    }
 
    friend FArchive& operator<<(FArchive& Ar, FLumenCardBuildData& Data)
    {
        // Note: this is derived data, no need for versioning (bump the DDC guid)
        Ar << Data.OBB;
        Ar << Data.AxisAlignedDirectionIndex;
        return Ar;
    }
};
 
class FLumenCardBuildDebugData
{
public:
    enum class ESurfelType : uint8
    {
        Valid,
        Invalid,
 
        Idle,
        Cluster,
        Used
    };
 
    struct FRay
    {
        FVector3f RayStart;
        FVector3f RayEnd;
        bool bHit;
    };
 
    struct FSurfel
    {
        FVector3f Position;
        FVector3f Normal;
        float Coverage = 0.0f;
        float Visibility = 1.0f;
        int32 SourceSurfelIndex = -1;
        ESurfelType Type;
    };
 
    struct FSurfelCluster
    {
        TArray<FSurfel> Surfels;
        TArray<FRay> Rays;
    };
 
    TArray<FSurfel> Surfels;
    TArray<FRay> SurfelRays;
    TArray<FSurfelCluster> Clusters;
    int32 NumSurfels = 0;
 
    void Init()
    {
        Surfels.Reset();
        SurfelRays.Reset();
        Clusters.Reset();
        NumSurfels = 0;
    }
};
 
class FMeshCardsBuildData
{
public:
    FBox Bounds = FBox(ForceInit);
    bool bMostlyTwoSided = false;
    TArray<FLumenCardBuildData> CardBuildData;
 
    // Temporary debug visualization data, don't serialize
    FLumenCardBuildDebugData DebugData;
 
    bool ContainsNaN() const
    {
        return Bounds.ContainsNaN() || CardBuildData.ContainsByPredicate([](const FLumenCardBuildData& Data) { return Data.ContainsNaN(); });
    }
 
    friend FArchive& operator<<(FArchive& Ar, FMeshCardsBuildData& Data)
    {
        // Note: this is derived data, no need for versioning (bump the DDC guid)
        Ar << Data.Bounds;
        Ar << Data.bMostlyTwoSided;
        Ar << Data.CardBuildData;
        return Ar;
    }
};
 
// Unique id per card representation data instance.
class FCardRepresentationDataId
{
public:
    uint32 Value = 0;
 
    bool IsValid() const
    {
        return Value != 0;
    }
 
    bool operator==(FCardRepresentationDataId B) const
    {
        return Value == B.Value;
    }
 
    friend uint32 GetTypeHash(FCardRepresentationDataId DataId)
    {
        return GetTypeHash(DataId.Value);
    }
};
 
class FCardRepresentationData : public FDeferredCleanupInterface
{
public:
 
    FMeshCardsBuildData MeshCardsBuildData;
 
    FCardRepresentationDataId CardRepresentationDataId;
 
    FCardRepresentationData()
    {
        // 0 means invalid id.
        static std::atomic<uint32> NextCardRepresentationId { 1 };
        CardRepresentationDataId.Value = NextCardRepresentationId++;
    }
 
    void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) const
    {
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(sizeof(*this));
    }
 
    SIZE_T GetResourceSizeBytes() const
    {
        FResourceSizeEx ResSize;
        GetResourceSizeEx(ResSize);
        return ResSize.GetTotalMemoryBytes();
    }
 
    bool ContainsNaN() const
    {
        return MeshCardsBuildData.ContainsNaN();
    }
 
#if WITH_EDITORONLY_DATA
 
    void CacheDerivedData(
        const FString& InDDCKey,
        UStaticMesh* Mesh,
        UStaticMesh* GenerateSource,
        int32 MaxLumenMeshCards,
        bool bGenerateDistanceFieldAsIfTwoSided,
        FSourceMeshDataForDerivedDataTask&& OptionalSourceMeshData = FSourceMeshDataForDerivedDataTask(),
        TArray<FSignedDistanceFieldBuildPartData>&& OptionalPartData = TArray<FSignedDistanceFieldBuildPartData>());
 
    UE_DEPRECATED(5.6, "Provide OptionalSourceMeshData by value (ideally using MoveTemp(...) to avoid copying the data)")
    void CacheDerivedData(
        const FString& InDDCKey,
        const ITargetPlatform* TargetPlatform,
        UStaticMesh* Mesh,
        UStaticMesh* GenerateSource,
        int32 MaxLumenMeshCards,
        bool bGenerateDistanceFieldAsIfTwoSided,
        FSourceMeshDataForDerivedDataTask* OptionalSourceMeshData)
    {
        CacheDerivedData(InDDCKey, Mesh, GenerateSource, MaxLumenMeshCards, bGenerateDistanceFieldAsIfTwoSided, OptionalSourceMeshData ? *OptionalSourceMeshData : FSourceMeshDataForDerivedDataTask());
    }
 
#endif
 
    friend FArchive& operator<<(FArchive& Ar, FCardRepresentationData& Data)
    {
        // Note: this is derived data, no need for versioning (bump the DDC guid)
        Ar << Data.MeshCardsBuildData;
        return Ar;
    }
};
 
 
class FAsyncCardRepresentationTask;
class FAsyncCardRepresentationTaskWorker : public FNonAbandonableTask
{
public:
    FAsyncCardRepresentationTaskWorker(FAsyncCardRepresentationTask& InTask)
        : Task(InTask)
    {
    }
 
    inline TStatId GetStatId() const
    {
        RETURN_QUICK_DECLARE_CYCLE_STAT(FAsyncCardRepresentationTaskWorker, STATGROUP_ThreadPoolAsyncTasks);
    }
 
    void DoWork();
 
private:
    FAsyncCardRepresentationTask& Task;
};
 
class FAsyncCardRepresentationTask
{
public:
    bool bSuccess = false;
 
#if WITH_EDITOR
    TArray<FSignedDistanceFieldBuildSectionData> SectionData;
    TArray<FSignedDistanceFieldBuildPartData> PartData;
#endif
 
    FSourceMeshDataForDerivedDataTask SourceMeshData;
    bool bGenerateDistanceFieldAsIfTwoSided = false;
    int32 MaxLumenMeshCards = 0;
    UStaticMesh* StaticMesh = nullptr;
    UStaticMesh* GenerateSource = nullptr;
    FString DDCKey;
    FCardRepresentationData* GeneratedCardRepresentation;
    TUniquePtr<FAsyncTask<FAsyncCardRepresentationTaskWorker>> AsyncTask = nullptr;
};
 
class FCardRepresentationAsyncQueue : IAssetCompilingManager
{
public:
 
    ENGINE_API FCardRepresentationAsyncQueue();
 
    ENGINE_API virtual ~FCardRepresentationAsyncQueue();
 
    ENGINE_API void AddTask(FAsyncCardRepresentationTask* Task);
 
    ENGINE_API void CancelBuild(UStaticMesh* StaticMesh);
 
    ENGINE_API void CancelBuilds(const TSet<UStaticMesh*>& InStaticMeshes);
 
    ENGINE_API void CancelAllOutstandingBuilds();
 
    ENGINE_API void BlockUntilBuildComplete(UStaticMesh* InStaticMesh, bool bWarnIfBlocked);
 
    ENGINE_API void BlockUntilAllBuildsComplete();
 
    ENGINE_API void ProcessAsyncTasks(bool bLimitExecutionTime = false) override;
 
    ENGINE_API void Shutdown() override;
 
    int32 GetNumOutstandingTasks() const
    {
        FScopeLock Lock(&CriticalSection);
        return ReferencedTasks.Num();
    }
 
    ENGINE_API static FName GetStaticAssetTypeName();
 
private:
    friend FAsyncCardRepresentationTaskWorker;
    friend class FDistanceFieldAsyncQueue;
 
    ENGINE_API FName GetAssetTypeName() const override;
    ENGINE_API FTextFormat GetAssetNameFormat() const override;
    ENGINE_API TArrayView<FName> GetDependentTypeNames() const override;
    ENGINE_API int32 GetNumRemainingAssets() const override;
    ENGINE_API void FinishAllCompilation() override;
 
    void ProcessPendingTasks();
 
    TUniquePtr<FQueuedThreadPool> ThreadPool;
 
    void Build(FAsyncCardRepresentationTask* Task, class FQueuedThreadPool& ThreadPool);
 
    void RescheduleBackgroundTask(FAsyncCardRepresentationTask* InTask, EQueuedWorkPriority InPriority);
 
    void StartBackgroundTask(FAsyncCardRepresentationTask* Task);
 
    void RunImmediateTask(FAsyncCardRepresentationTask* Task);
 
    void CancelAndDeleteTaskByPredicate(TFunctionRef<bool(FAsyncCardRepresentationTask*)> ShouldCancelPredicate);
 
    void CancelAndDeleteTask(const TSet<FAsyncCardRepresentationTask*>& Tasks);
 
    void FinishCompilationForObjects(TArrayView<UObject* const> InObjects) override;
 
    void MarkCompilationAsCanceled(TArrayView<UObject* const> InObjects) override;
 
    bool IsTaskInvalid(FAsyncCardRepresentationTask* Task) const;
 
    void OnPostReachabilityAnalysis();
 
    TSet<FAsyncCardRepresentationTask*> ReferencedTasks;
 
    TSet<FAsyncCardRepresentationTask*> PendingTasks;
 
    TSet<FAsyncCardRepresentationTask*> CompletedTasks;
 
    FDelegateHandle PostReachabilityAnalysisHandle;
 
    class IMeshUtilities* MeshUtilities;
 
    mutable FCriticalSection CriticalSection;
 
    TUniquePtr<FAsyncCompilationNotification> Notification;
};
 
extern ENGINE_API FCardRepresentationAsyncQueue* GCardRepresentationAsyncQueue;
 
#if WITH_EDITORONLY_DATA
extern ENGINE_API void AppendMeshCardConstantsToClassSchema(FAppendToClassSchemaContext& Context);
 
extern ENGINE_API FString BuildCardRepresentationDerivedDataKey(const FString& InMeshKey);
 
extern ENGINE_API void BeginCacheMeshCardRepresentation(
    UStaticMesh* StaticMeshAsset,
    class FStaticMeshRenderData& RenderData,
    const FString& DistanceFieldKey,
    FSourceMeshDataForDerivedDataTask&& OptionalSourceMeshData = FSourceMeshDataForDerivedDataTask(),
    TArray<FSignedDistanceFieldBuildPartData>&& OptionalPartData = TArray<FSignedDistanceFieldBuildPartData>());
 
UE_DEPRECATED(5.6, "Provide OptionalSourceMeshData by value (ideally using MoveTemp(...) to avoid copying the data)")
inline void BeginCacheMeshCardRepresentation(
    const ITargetPlatform* TargetPlatform,
    UStaticMesh* StaticMeshAsset,
    class FStaticMeshRenderData& RenderData,
    const FString& DistanceFieldKey,
    FSourceMeshDataForDerivedDataTask* OptionalSourceMeshData)
{
    BeginCacheMeshCardRepresentation(StaticMeshAsset, RenderData, DistanceFieldKey, OptionalSourceMeshData ? *OptionalSourceMeshData : FSourceMeshDataForDerivedDataTask());
}
#endif
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "AssetCompilingManager.h"
#include "AsyncCompilationHelpers.h"
#endif