SkeletalMeshUpdate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
SkeletalMeshUpdate.h: Helpers to stream in and out skeletal mesh LODs.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/SkeletalMesh.h"
#include "IO/IoDispatcher.h"
#include "RenderAssetUpdate.h"
#include "Rendering/SkeletalMeshHalfEdgeBuffer.h"
#include "Rendering/SkinWeightVertexBuffer.h"
#include "Serialization/BulkData.h"
#include "RayTracingGeometry.h"
 
#define UE_API ENGINE_API
 
 
struct FSkinWeightProfileStack;
 
struct FSkelMeshUpdateContext
{
    typedef int32 EThreadType;
 
    UE_API FSkelMeshUpdateContext(const USkeletalMesh* InMesh, EThreadType InCurrentThread);
 
    UE_API FSkelMeshUpdateContext(const UStreamableRenderAsset* InMesh, EThreadType InCurrentThread);
 
    EThreadType GetCurrentThread() const
    {
        return CurrentThread;
    }
 
    const USkeletalMesh* Mesh;
    FSkeletalMeshRenderData* RenderData;
    TArrayView<FSkeletalMeshLODRenderData*> LODResourcesView;
    int32 AssetLODBias = 0;
 
    EThreadType CurrentThread;
};
 
extern template class TRenderAssetUpdate<FSkelMeshUpdateContext>;
 
class FSkeletalMeshUpdate : public TRenderAssetUpdate<FSkelMeshUpdateContext>
{
public:
    FSkeletalMeshUpdate(const USkeletalMesh* InMesh);
 
    virtual ~FSkeletalMeshUpdate() {}
 
    virtual void Abort()
    {
        TRenderAssetUpdate<FSkelMeshUpdateContext>::Abort();
    }
};
 
class FSkeletalMeshStreamIn : public FSkeletalMeshUpdate
{
public:
    UE_API FSkeletalMeshStreamIn(const USkeletalMesh* InMesh, EThreadType CreateResourcesThread);
 
    UE_API virtual ~FSkeletalMeshStreamIn();
 
protected:
    struct FIntermediateBuffers
    {
        FBufferRHIRef TangentsVertexBuffer;
        FBufferRHIRef TexCoordVertexBuffer;
        FBufferRHIRef PositionVertexBuffer;
        FBufferRHIRef ColorVertexBuffer;
        FSkinWeightRHIInfo SkinWeightVertexBuffer;
        FBufferRHIRef ClothVertexBuffer;
        FBufferRHIRef IndexBuffer;
        TArray<TPair<FSkinWeightProfileStack, FSkinWeightRHIInfo>> AltSkinWeightVertexBuffers;
        FSkeletalMeshHalfEdgeBuffer::FRHIInfo HalfEdgeBuffer;
 
        void CreateFromCPUData(FRHICommandListBase& RHICmdList, FSkeletalMeshLODRenderData& LODResource);
 
        void TransferBuffers(FSkeletalMeshLODRenderData& LODResource, FRHIResourceReplaceBatcher& Batcher);
    };
 
#if RHI_RAYTRACING
    struct FIntermediateRayTracingGeometry
    {
    private:
        FRayTracingGeometryInitializer Initializer;
        FRayTracingGeometryRHIRef RayTracingGeometryRHI;
        bool bRequiresBuild = false;
 
    public:
        void CreateFromCPUData(FRHICommandListBase& RHICmdList, FRayTracingGeometry& RayTracingGeometry);
 
        void SafeRelease();
 
        void TransferRayTracingGeometry(FRayTracingGeometry& RayTracingGeometry, FRHIResourceReplaceBatcher& Batcher);
    };
#endif
 
    UE_API void CreateBuffers(const FContext& Context);
 
    UE_API void DiscardNewLODs(const FContext& Context);
 
    UE_API void DoFinishUpdate(const FContext& Context);
 
    UE_API void DoCancel(const FContext& Context);
 
    FIntermediateBuffers IntermediateBuffersArray[MAX_MESH_LOD_COUNT];
 
#if RHI_RAYTRACING
    FIntermediateRayTracingGeometry IntermediateRayTracingGeometry[MAX_MESH_LOD_COUNT];
#endif
 
    FRHICommandList* StreamingRHICmdList = nullptr;
 
    const EThreadType CreateResourcesThread;
};
 
class FSkeletalMeshStreamOut : public FSkeletalMeshUpdate
{
public:
    FSkeletalMeshStreamOut(const USkeletalMesh* InMesh);
 
    virtual ~FSkeletalMeshStreamOut() {}
 
private:
 
    int32 NumReferenceChecks = 0;
    uint32 PreviousNumberOfExternalReferences = 0;
 
 
    void ConditionalMarkComponentsDirty(const FContext& Context);
 
    void WaitForReferences(const FContext& Context);
 
    void ReleaseBuffers(const FContext& Context);
 
    void Cancel(const FContext& Context);
};
 
class FSkeletalMeshStreamIn_IO : public FSkeletalMeshStreamIn
{
public:
    FSkeletalMeshStreamIn_IO(const USkeletalMesh* InMesh, bool bHighPrio, EThreadType CreateResourcesThread);
 
    virtual ~FSkeletalMeshStreamIn_IO() {}
 
    virtual void Abort() override;
 
protected:
    class FCancelIORequestsTask : public FNonAbandonableTask
    {
    public:
        FCancelIORequestsTask(FSkeletalMeshStreamIn_IO* InPendingUpdate)
            : PendingUpdate(InPendingUpdate)
        {}
 
        void DoWork();
 
        FORCEINLINE TStatId GetStatId() const
        {
            RETURN_QUICK_DECLARE_CYCLE_STAT(FCancelIORequestsTask_SkeletalMesh, STATGROUP_ThreadPoolAsyncTasks);
        }
 
    private:
        TRefCountPtr<FSkeletalMeshStreamIn_IO> PendingUpdate;
    };
 
    typedef FAutoDeleteAsyncTask<FCancelIORequestsTask> FAsyncCancelIORequestsTask;
    friend class FCancelIORequestsTask;
 
    void SetIORequest(const FContext& Context);
 
    void ClearIORequest(const FContext& Context);
 
    void ReportIOError(const FContext& Context);
 
    void SerializeLODData(const FContext& Context);
 
    void Cancel(const FContext& Context);
 
    void CancelIORequest();
 
    FBulkDataBatchRequest BulkDataRequest;
 
    FIoBuffer BulkData;
 
    bool bHighPrioIORequest;
 
    // Whether an IO error was detected (when files do not exists).
    bool bFailedOnIOError = false;
 
    void DoInitiateIO(const FContext& Context);
 
    void DoSerializeLODData(const FContext& Context);
 
    void DoCreateBuffers(const FContext& Context);
 
    void DoCancelIO(const FContext& Context);
};
 
#if WITH_EDITOR
class FSkeletalMeshStreamIn_DDC : public FSkeletalMeshStreamIn
{
public:
    FSkeletalMeshStreamIn_DDC(const USkeletalMesh* InMesh, EThreadType CreateResourcesThread);
 
    virtual ~FSkeletalMeshStreamIn_DDC() {}
 
protected:
    void LoadNewLODsFromDDC(const FContext& Context);
 
private:
    void DoLoadNewLODsFromDDC(const FContext& Context);
 
    void DoCreateBuffers(const FContext& Context);
};
#endif
 
#undef UE_API