SkeletalRenderGPUSkin.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SkeletalRenderGPUSkin.h: GPU skinned mesh object and resource definitions
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "ProfilingDebugging/ResourceSize.h"
#include "RenderResource.h"
#include "RayTracingGeometry.h"
#include "ShaderParameters.h"
#include "Components/ExternalMorphSet.h"
#include "Components/SkinnedMeshComponent.h"
#include "GlobalShader.h"
#include "GPUSkinVertexFactory.h"
#include "SkeletalMeshUpdater.h"
#include "SkeletalRenderPublic.h"
#include "ClothingSystemRuntimeTypes.h"
#include "Rendering/SkeletalMeshRenderData.h"
#include "Rendering/SkeletalMeshLODRenderData.h"
#include "Animation/MeshDeformerGeometry.h"
#include "SkinnedMeshSceneProxyDesc.h"
#include "InstancedSkinnedMeshSceneProxy.h"
#include "Animation/AnimBank.h"
 
enum class EGPUSkinCacheEntryMode;
class FGPUSkinCache;
class FSkeletalMeshUpdater;
class FSkeletalMeshObjectGPUSkin;
class FSkeletalMeshUpdatePacketGPUSkin;
class FVertexOffsetBuffers;
 
enum class ESkeletalMeshGPUSkinTechnique : uint8
{
    // Skinning is performed inline when the mesh is rendered in the mesh pass.
    Inline,
 
    // Skinning is performed by the GPU skin cache but falls back to the inline mode on a per-section basis if the skin cache is full.
    GPUSkinCache,
 
    // Skinning is performed by the mesh deformer graph.
    MeshDeformer
};
 
class FDynamicSkelMeshObjectDataGPUSkin final : public TSkeletalMeshDynamicData<FDynamicSkelMeshObjectDataGPUSkin>
{
    friend class TSkeletalMeshDynamicDataPool<FDynamicSkelMeshObjectDataGPUSkin>;
 
    FDynamicSkelMeshObjectDataGPUSkin()
    {
        Reset();
    }
 
    int32 Reset();
 
public:
    void InitDynamicSkelMeshObjectDataGPUSkin(
        const FSkinnedMeshSceneProxyDynamicData& InDynamicData,
        const FPrimitiveSceneProxy* SceneProxy,
        const USkinnedAsset* InSkinnedAsset,
        FSkeletalMeshRenderData* InSkeletalMeshRenderData,
        FSkeletalMeshObjectGPUSkin* InMeshObject,
        int32 InLODIndex,
        const FMorphTargetWeightMap& InActiveMorphTargets,
        const TArray<float>& InMorphTargetWeights, 
        EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode,
        const FExternalMorphWeightData& InExternalMorphWeightData);
 
    TArray<FMatrix44f> ReferenceToLocal;
    TArray<FMatrix44f> ReferenceToLocalForRayTracing;
 
    TArray<FMatrix44f> PreviousReferenceToLocal;
    TArray<FMatrix44f> PreviousReferenceToLocalForRayTracing;
 
    TConstArrayView<FMatrix44f> GetPreviousReferenceToLocal(EGPUSkinCacheEntryMode Mode) const;
    TConstArrayView<FMatrix44f> GetReferenceToLocal(EGPUSkinCacheEntryMode Mode) const;
    int32 GetLODIndex(EGPUSkinCacheEntryMode Mode) const;
 
    void BuildBoneTransforms(FDynamicSkelMeshObjectDataGPUSkin* PreviousDynamicData);
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) 
    TArray<FTransform> MeshComponentSpaceTransforms;
#endif
 
    uint32 BoneTransformFrameNumber;
    uint32 RevisionNumber;
    uint32 PreviousRevisionNumber;
    EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode;
 
    int32 LODIndex;
#if RHI_RAYTRACING
    int32 RayTracingLODIndex;
#endif
    FMorphTargetWeightMap ActiveMorphTargets;
    TArray<float> MorphTargetWeights;
    TArray<int32> SectionIdsUseByActiveMorphTargets;
    TArray<int32> SectionIdsUseByActiveMorphTargetsForRayTracing;
    int32 NumWeightedActiveMorphTargets;
 
    FExternalMorphWeightData ExternalMorphWeightData;
 
    FExternalMorphSets ExternalMorphSets;
 
    TMap<int32, FClothSimulData> ClothingSimData;
 
    FMatrix ClothObjectLocalToWorld;
 
    FMatrix LocalToWorld;
 
    float ClothBlendWeight;
 
    bool ActiveMorphTargetsEqual(const FMorphTargetWeightMap& InCompareActiveMorphTargets, const TArray<float>& CompareMorphTargetWeights) const;
 
    bool IsRequiredUpdate() const
    {
        return PreviousBoneTransformUpdateMode != EPreviousBoneTransformUpdateMode::None;
    }
 
    void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize)
    {
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(sizeof(*this));
        
        CumulativeResourceSize.AddUnknownMemoryBytes(ReferenceToLocal.GetAllocatedSize());
        CumulativeResourceSize.AddUnknownMemoryBytes(ActiveMorphTargets.GetAllocatedSize());
    }
 
    static bool IsMorphUpdateNeeded(const FDynamicSkelMeshObjectDataGPUSkin* Previous, const FDynamicSkelMeshObjectDataGPUSkin* Current);
 
    ESkeletalMeshGPUSkinTechnique GPUSkinTechnique;
 
#if RHI_RAYTRACING
    uint8 bAnySegmentUsesWorldPositionOffset : 1;
#endif
 
    uint8 bRecreating : 1;
};
 
struct FMorphGPUSkinVertex
{
    // Changes to this struct must be reflected in MorphTargets.usf!
    FVector3f           DeltaPosition;
    FVector3f           DeltaTangentZ;
 
    FMorphGPUSkinVertex() {};
    
    FMorphGPUSkinVertex(const FVector3f& InDeltaPosition, const FVector3f& InDeltaTangentZ)
    {
        DeltaPosition = InDeltaPosition;
        DeltaTangentZ = InDeltaTangentZ;
    }
};
 
class FMorphVertexBuffer final : public FVertexBuffer
{
public:
    FMorphVertexBuffer()
        : bHasBeenUpdated(false)
        , bNeedsInitialClear(true)
        , bUsesComputeShader(false)
        , LODIdx(-1)
        , SkelMeshRenderData(nullptr)
    {
    }
 
    FMorphVertexBuffer(FSkeletalMeshRenderData* InSkelMeshRenderData, int32 InLODIdx, ERHIFeatureLevel::Type InFeatureLevel)
        :   bHasBeenUpdated(false)  
        ,   bNeedsInitialClear(true)
        ,   LODIdx(InLODIdx)
        ,   FeatureLevel(InFeatureLevel)
        ,   SkelMeshRenderData(InSkelMeshRenderData)
    {
        check(SkelMeshRenderData);
        check(SkelMeshRenderData->LODRenderData.IsValidIndex(LODIdx));
        bUsesComputeShader = false;
    }
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    virtual void ReleaseRHI() override;
 
    inline void RecreateResourcesIfRequired(FRHICommandListBase& RHICmdList, bool bInUsesComputeShader)
    {
        if (bUsesComputeShader != bInUsesComputeShader)
        {
            UpdateRHI(RHICmdList);
        }
    }
 
    FString GetFriendlyName() const { return TEXT("Morph target mesh vertices"); }
 
    SIZE_T GetResourceSize() const
    {
        SIZE_T ResourceSize = sizeof(*this);
 
        if (VertexBufferRHI)
        {
            // LOD of the skel mesh is used to find number of vertices in buffer
            FSkeletalMeshLODRenderData& LodData = SkelMeshRenderData->LODRenderData[LODIdx];
 
            // Create the buffer rendering resource
            ResourceSize += LodData.GetNumVertices() * sizeof(FMorphGPUSkinVertex);
        }
 
        return ResourceSize;
    }
    
    SIZE_T GetNumVerticies() const
    {
        // LOD of the skel mesh is used to find number of vertices in buffer
        FSkeletalMeshLODRenderData& LodData = SkelMeshRenderData->LODRenderData[LODIdx];
        // Create the buffer rendering resource
        return LodData.GetNumVertices();
    }
 
    bool bHasBeenUpdated;
 
    bool bNeedsInitialClear;
 
    // @param guaranteed only to be valid if the vertex buffer is valid
    FRHIShaderResourceView* GetSRV() const
    {
        return SRVValue;
    }
 
    // @param guaranteed only to be valid if the vertex buffer is valid
    FRHIUnorderedAccessView* GetUAV() const
    {
        return UAVValue;
    }
 
    FSkeletalMeshLODRenderData* GetLODRenderData() const { return &SkelMeshRenderData->LODRenderData[LODIdx]; }
    
    // section ids that are using this Morph buffer
    TArray<int32> SectionIds;
protected:
    // guaranteed only to be valid if the vertex buffer is valid
    FShaderResourceViewRHIRef SRVValue;
 
    // guaranteed only to be valid if the vertex buffer is valid
    FUnorderedAccessViewRHIRef UAVValue;
 
    bool bUsesComputeShader;
 
private:
    int32   LODIdx;
 
    ERHIFeatureLevel::Type FeatureLevel;
 
    // parent mesh containing the source data, never 0
    FSkeletalMeshRenderData* SkelMeshRenderData;
 
    friend class FMorphVertexBufferPool;
};
 
class FMorphVertexBufferPool : public FThreadSafeRefCountedObject
{
public:
    FMorphVertexBufferPool(FSkeletalMeshRenderData* InSkelMeshRenderData, int32 InLOD, ERHIFeatureLevel::Type InFeatureLevel)
    {
        MorphVertexBuffers[0] = FMorphVertexBuffer(InSkelMeshRenderData, InLOD, InFeatureLevel);
        MorphVertexBuffers[1] = FMorphVertexBuffer(InSkelMeshRenderData, InLOD, InFeatureLevel);
    }
 
    ~FMorphVertexBufferPool()
    {
        // Note that destruction of this class must occur on the render thread if InitResources has been called!
        // This is normally pointed to by FSkeletalMeshObjectGPUSkin, which is defer deleted on the render thread.
        if (bInitializedResources)
        {
            ReleaseResources();
        }
    }
 
    void InitResources(FName OwnerName);
    void ReleaseResources();
    SIZE_T GetResourceSize() const;
    void EnableDoubleBuffer(FRHICommandListBase& RHICmdList);
    bool IsInitialized() const                      { return bInitializedResources; }
    bool IsDoubleBuffered() const                   { return bDoubleBuffer; }
    void SetUpdatedFrameNumber(uint32 FrameNumber)  { UpdatedFrameNumber = FrameNumber; }
    uint32 GetUpdatedFrameNumber() const            { return UpdatedFrameNumber; }
    void SetCurrentRevisionNumber(uint32 RevisionNumber);
    const FMorphVertexBuffer& GetMorphVertexBufferForReading(bool bPrevious) const;
    FMorphVertexBuffer& GetMorphVertexBufferForWriting();
 
private:
    FMorphVertexBuffer MorphVertexBuffers[2];
    bool bInitializedResources = false;
    bool bDoubleBuffer = false;
 
    // 0 / 1 to index into MorphVertexBuffer
    uint32 CurrentBuffer = 0;
    // RevisionNumber Tracker
    uint32 PreviousRevisionNumber = 0;
    uint32 CurrentRevisionNumber = 0;
    // Frame number of the morph vertex buffer that is last updated
    uint32 UpdatedFrameNumber = 0;
};
 
class FSkeletalMeshObjectGPUSkin final : public FSkeletalMeshObject
{
public:
    FSkeletalMeshObjectGPUSkin(const USkinnedMeshComponent* InMeshComponent, FSkeletalMeshRenderData* InSkelMeshRenderData, ERHIFeatureLevel::Type InFeatureLevel);
    FSkeletalMeshObjectGPUSkin(const FSkinnedMeshSceneProxyDesc& InMeshDesc, FSkeletalMeshRenderData* InSkelMeshRenderData, ERHIFeatureLevel::Type InFeatureLevel);
    virtual ~FSkeletalMeshObjectGPUSkin();
 
    //~ Begin FSkeletalMeshObject Interface
    virtual void InitResources(const FSkinnedMeshSceneProxyDesc& InMeshDesc) override;
    virtual void ReleaseResources() override;
    virtual void Update(int32 LODIndex, const FSkinnedMeshSceneProxyDynamicData& InSkeletalMeshDynamicData, const FPrimitiveSceneProxy* InSceneProxy, const USkinnedAsset* InSkinnedAsset, const FMorphTargetWeightMap& InActiveMorphTargets, const TArray<float>& InMorphTargetWeights, EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode, const FExternalMorphWeightData& InExternalMorphWeightData) override;
    void UpdateDynamicData_RenderThread(FRHICommandList& RHICmdList, FDynamicSkelMeshObjectDataGPUSkin* InDynamicData);
    virtual const FVertexFactory* GetSkinVertexFactory(const FSceneView* View, int32 LODIndex,int32 ChunkIdx, ESkinVertexFactoryMode VFMode = ESkinVertexFactoryMode::Default) const override;
    virtual const FVertexFactory* GetStaticSkinVertexFactory(int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode) const override;
    virtual TArray<FTransform>* GetComponentSpaceTransforms() const override;
    virtual TConstArrayView<FMatrix44f> GetReferenceToLocalMatrices() const override;
    virtual TConstArrayView<FMatrix44f> GetPrevReferenceToLocalMatrices() const override;
    virtual bool GetCachedGeometry(FRDGBuilder& GraphBuilder, FCachedGeometry& OutCachedGeometry) const override;
    
    FMeshDeformerGeometry& GetDeformerGeometry(int32 LODIndex);
 
    virtual bool IsGPUSkinMesh() const override { return true; }
 
    virtual int32 GetDynamicBoundsStartOffset(int32 LODIndex) const override;
 
#if RHI_RAYTRACING
    FRayTracingGeometry RayTracingGeometry; 
    FRWBuffer RayTracingDynamicVertexBuffer;
 
    // GetRayTracingGeometry()->IsInitialized() is checked as a workaround for UE-92634. FSkeletalMeshSceneProxy's resources may have already been released, but proxy has not removed yet)
    FRayTracingGeometry* GetRayTracingGeometry() { return RayTracingGeometry.HasValidInitializer() && RayTracingGeometry.IsInitialized() ? & RayTracingGeometry : nullptr; }
    const FRayTracingGeometry* GetRayTracingGeometry() const { return RayTracingGeometry.HasValidInitializer() && RayTracingGeometry.IsInitialized() ? & RayTracingGeometry : nullptr; }
 
    FRWBuffer* GetRayTracingDynamicVertexBuffer() { return RayTracingDynamicVertexBuffer.NumBytes > 0 ? &RayTracingDynamicVertexBuffer : nullptr; }
 
    virtual int32 GetRayTracingLOD() const override
    {
        if (DynamicData)
        {
            return DynamicData->RayTracingLODIndex;
        }
        else
        {
            return 0;
        }
    }
 
    virtual void UpdateRayTracingGeometry(FRHICommandListBase& RHICmdList, FSkeletalMeshLODRenderData& LODModel, uint32 LODIndex, TArray<FBufferRHIRef>& VertexBuffers) override;
    
#endif // RHI_RAYTRACING
 
    virtual int32 GetLOD() const override
    {
        if(DynamicData)
        {
            return DynamicData->LODIndex;
        }
        else
        {
            return 0;
        }
    }
 
    virtual bool HaveValidDynamicData() const override
    { 
        return ( DynamicData!=NULL ); 
    }
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override
    {
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(sizeof(*this));
        
        if(DynamicData)
        {
            DynamicData->GetResourceSizeEx(CumulativeResourceSize);
        }
        
        CumulativeResourceSize.AddUnknownMemoryBytes(LODs.GetAllocatedSize()); 
 
        // include extra data from LOD
        for (int32 I=0; I<LODs.Num(); ++I)
        {
            LODs[I].GetResourceSizeEx(CumulativeResourceSize);
        }
    }
    //~ End FSkeletalMeshObject Interface
 
    bool IsExternalMorphSetActive(int32 MorphSetID, const FExternalMorphSet& MorphSet) const;
 
    const FSkinWeightVertexBuffer* GetSkinWeightVertexBuffer(int32 LODIndex) const;
 
    FGPUBaseSkinVertexFactory const* GetBaseSkinVertexFactory(int32 LODIndex, int32 ChunkIdx) const;
 
    struct FVertexFactoryBuffers
    {
        FStaticMeshVertexBuffers* StaticVertexBuffers = nullptr;
        const FSkinWeightVertexBuffer* SkinWeightVertexBuffer = nullptr;
        FColorVertexBuffer* ColorVertexBuffer = nullptr;
        FMorphVertexBufferPool* MorphVertexBufferPool = nullptr;
        FSkeletalMeshVertexClothBuffer* APEXClothVertexBuffer = nullptr;
        FVertexOffsetBuffers* VertexOffsetVertexBuffers = nullptr;
        uint32 NumVertices = 0;
    };
 
    FMatrix GetTransform() const;
    virtual void SetTransform(const FMatrix& InNewLocalToWorld, uint32 FrameNumber) override;
    virtual void RefreshClothingTransforms(const FMatrix& InNewLocalToWorld, uint32 FrameNumber) override;
    virtual void UpdateSkinWeightBuffer(const TArrayView<const FSkelMeshComponentLODInfo> InLODInfo) override;
 
    static void GetUsedVertexFactoryData(FSkeletalMeshRenderData* SkelMeshRenderData, int32 InLOD, USkinnedMeshComponent* SkinnedMeshComponent, FSkelMeshRenderSection& RenderSection, ERHIFeatureLevel::Type InFeatureLevel, FPSOPrecacheVertexFactoryDataList& VertexFactoryDataList);
 
    inline ESkeletalMeshGPUSkinTechnique GetGPUSkinTechnique(int32 LODIndex)
    {
        return LODs[LODIndex].GPUSkinTechnique;
    }
 
private:
    friend class FSkeletalMeshDeformerHelpers;
    
    friend class FSkeletalMeshObjectNanite;
    static void CreateVertexFactory(
        FRHICommandList& RHICmdList,
        TArray<TUniquePtr<FGPUBaseSkinVertexFactory>>& VertexFactories,
        TUniquePtr<FGPUSkinPassthroughVertexFactory>* PassthroughVertexFactory,
        const FSkeletalMeshObjectGPUSkin::FVertexFactoryBuffers& VertexBuffers,
        ERHIFeatureLevel::Type FeatureLevel,
        FGPUSkinPassthroughVertexFactory::EVertexAttributeFlags VertexAttributeMask,
        uint32 NumBones,
        uint32 BoneOffset,
        uint32 BaseVertexIndex,
        bool bUsedForPassthroughVertexFactory);
 
    static void UpdateRayTracingGeometry_Internal(
        FSkeletalMeshLODRenderData& LODModel, uint32 LODIndex, TArray<FBufferRHIRef>& VertexBuffers,
        FRayTracingGeometry& RayTracingGeometry, bool bAnySegmentUsesWorldPositionOffset, FSkeletalMeshObject* MeshObject);
 
    class FVertexFactoryData
    {
    public:
        FVertexFactoryData() {}
 
        TArray<TUniquePtr<FGPUBaseSkinVertexFactory>> VertexFactories;
 
        TUniquePtr<FGPUSkinPassthroughVertexFactory> PassthroughVertexFactory;
 
        uint32 NumVertices;
 
        void InitVertexFactories(
            FRHICommandList& RHICmdList,
            const FVertexFactoryBuffers& VertexBuffers,
            const TArray<FSkelMeshRenderSection>& Sections,
            ERHIFeatureLevel::Type FeatureLevel,
            FGPUSkinPassthroughVertexFactory::EVertexAttributeFlags VertexAttributeMask,
            ESkeletalMeshGPUSkinTechnique GPUSkinTechnique);
 
        void ReleaseVertexFactories();
 
        void UpdateVertexFactoryData(const FVertexFactoryBuffers& VertexBuffers);
 
        uint64 GetResourceSize() const
        {
            return VertexFactories.GetAllocatedSize();
        }
 
    private:
        FVertexFactoryData(const FVertexFactoryData&);
        FVertexFactoryData& operator=(const FVertexFactoryData&);
    };
 
    struct FSkeletalMeshObjectLOD
    {
        FSkeletalMeshObjectLOD(FSkeletalMeshRenderData* InSkelMeshRenderData, int32 InLOD, ERHIFeatureLevel::Type InFeatureLevel, FMorphVertexBufferPool* InRecreateBufferPool, ESkeletalMeshGPUSkinTechnique InSkinTechnique)
            : SkelMeshRenderData(InSkelMeshRenderData)
            , LODIndex(InLOD)
            , FeatureLevel(InFeatureLevel)
            , MeshObjectWeightBuffer(nullptr)
            , MeshObjectWeightBuffer_RenderThread(nullptr)
            , MeshObjectColorBuffer(nullptr)
            , GPUSkinTechnique(InSkinTechnique)
        {
            if (InRecreateBufferPool)
            {
                MorphVertexBufferPool = InRecreateBufferPool;
            }
            else
            {
                MorphVertexBufferPool = new FMorphVertexBufferPool(InSkelMeshRenderData, LODIndex, FeatureLevel);
            }
        }
 
        void InitResources(
            FGPUSkinCache* GPUSkinCache,
            const FSkelMeshObjectLODInfo& MeshLODInfo,
            const FSkelMeshComponentLODInfo* CompLODInfo,
            ERHIFeatureLevel::Type FeatureLevel,
            FGPUSkinPassthroughVertexFactory::EVertexAttributeFlags VertexAttributeMask);
 
        void ReleaseResources(FGPUSkinCache* GPUSkinCache);
 
        void InitMorphResources(const FSkelMeshObjectLODInfo& MeshLODInfo, ERHIFeatureLevel::Type FeatureLevel);
 
        void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize)
        {
            CumulativeResourceSize.AddUnknownMemoryBytes(MorphVertexBufferPool->GetResourceSize());
            CumulativeResourceSize.AddUnknownMemoryBytes(GPUSkinVertexFactories.GetResourceSize());
        }
 
        FSkeletalMeshRenderData* SkelMeshRenderData;
        // index into FSkeletalMeshRenderData::LODRenderData[]
        int32 LODIndex;
 
        ERHIFeatureLevel::Type FeatureLevel;
 
        TRefCountPtr<FMorphVertexBufferPool> MorphVertexBufferPool;
 
        FVertexFactoryData GPUSkinVertexFactories;
 
        const FSkinWeightVertexBuffer* MeshObjectWeightBuffer;
        const FSkinWeightVertexBuffer* MeshObjectWeightBuffer_RenderThread;
 
        FColorVertexBuffer* MeshObjectColorBuffer;
 
        FMeshDeformerGeometry DeformerGeometry;
 
        ESkeletalMeshGPUSkinTechnique GPUSkinTechnique;
 
        int32 DynamicBoundsStartOffset = INDEX_NONE;
        int32 DynamicBoundsNumSections = 0;
 
        void UpdateMorphVertexBufferCPU(FRHICommandList& RHICmdList, const FMorphTargetWeightMap& InActiveMorphTargets, const TArray<float>& MorphTargetWeights, const TArray<int32>& SectionIdsUseByActiveMorphTargets, 
                                        bool bGPUSkinCacheEnabled, FMorphVertexBuffer& MorphVertexBuffer);
 
        void UpdateMorphVertexBufferGPU(FRHICommandList& RHICmdList, const TArray<float>& MorphTargetWeights, const FMorphTargetVertexInfoBuffers& MorphTargetVertexInfoBuffers, 
                                        const TArray<int32>& SectionIdsUseByActiveMorphTargets, const FName& OwnerName, EGPUSkinCacheEntryMode Mode, FMorphVertexBuffer& MorphVertexBuffer,
                                        bool bClearMorphVertexBuffer, bool bNormalizePass, const FVector4& MorphScale, const FVector4& InvMorphScale);
 
        void UpdateSkinWeights(const FSkelMeshComponentLODInfo* CompLODInfo);
 
        void GetVertexBuffers(FVertexFactoryBuffers& OutVertexBuffers, FSkeletalMeshLODRenderData& LODData);
 
        // Temporary arrays used on UpdateMorphVertexBuffer(); these grow to the max and are not thread safe.
        static TArray<float> MorphAccumulatedWeightArray;
    };
 
    TArray<struct FSkeletalMeshObjectLOD> LODs;
 
    FDynamicSkelMeshObjectDataGPUSkin* DynamicData = nullptr;
 
    FSkeletalMeshObjectGPUSkin(const FSkeletalMeshObjectGPUSkin&);
    FSkeletalMeshObjectGPUSkin& operator=(const FSkeletalMeshObjectGPUSkin&);
 
    void InitMorphResources();
 
    void UpdateBufferData(FRHICommandList& RHICmdList, EGPUSkinCacheEntryMode Mode);
    void ProcessUpdatedDynamicData(FRHICommandList& RHICmdList, EGPUSkinCacheEntryMode Mode);
    void UpdateMorphVertexBuffer(FRHICommandList& RHICmdList);
 
    bool IsRayTracingSkinCacheUpdateNeeded() const
    {
#if RHI_RAYTRACING
        return DynamicData->RayTracingLODIndex != -1
            && DynamicData->GPUSkinTechnique != ESkeletalMeshGPUSkinTechnique::MeshDeformer
            && ShouldUseSeparateSkinCacheEntryForRayTracing()
            && GetSkeletalMeshRenderData().bSupportRayTracing;
#else
        return false;
#endif
    }
 
    bool IsSkinCacheEnabled(EGPUSkinCacheEntryMode Mode) const;
 
    FSkeletalMeshUpdateHandle UpdateHandle;
 
    FGPUSkinCache* GPUSkinCache = nullptr;
    FMorphVertexBuffer* MorphVertexBuffer = nullptr;
    uint32 LastRayTracingBoneTransformUpdate = INDEX_NONE;
    bool bMorphResourcesInitialized = false;
    bool bMorphNeedsUpdate = false;
 
    friend FSkeletalMeshUpdater;
    friend FSkeletalMeshUpdatePacketGPUSkin;
};
 
 
class FInstancedSkeletalMeshObjectGPUSkin : public FSkeletalMeshObject
{
public:
    FInstancedSkeletalMeshObjectGPUSkin(
        const FInstancedSkinnedMeshSceneProxyDesc& InMeshDesc,
        FSkeletalMeshRenderData* InRenderData,
        ERHIFeatureLevel::Type InFeatureLevel);
 
    FInstancedSkeletalMeshObjectGPUSkin(USkinnedMeshComponent* InComponent, FSkeletalMeshRenderData* InRenderData, ERHIFeatureLevel::Type InFeatureLevel);
 
    virtual void InitResources(const FSkinnedMeshSceneProxyDesc& InMeshDesc) override;
    virtual void ReleaseResources() override;
 
    virtual void Update(
        int32 LODIndex,
        const FSkinnedMeshSceneProxyDynamicData& InDynamicData,
        const FPrimitiveSceneProxy* InSceneProxy,
        const USkinnedAsset* InSkinnedAsset,
        const FMorphTargetWeightMap& InActiveMorphTargets,
        const TArray<float>& MorphTargetWeights,
        EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode,
        const FExternalMorphWeightData& InExternalMorphWeightData) override
    {}
 
    virtual FSkinningSceneExtensionProxy* CreateSceneExtensionProxy(const USkinnedAsset* InSkinnedAsset, bool bAllowScaling) override;
 
    virtual const FVertexFactory* GetSkinVertexFactory(const FSceneView* View, int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode) const override;
 
    virtual const FVertexFactory* GetStaticSkinVertexFactory(int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode) const override;
 
    virtual TArray<FTransform>* GetComponentSpaceTransforms() const override { return nullptr; }
 
    virtual TConstArrayView<FMatrix44f> GetReferenceToLocalMatrices() const override { return {}; }
 
    virtual TConstArrayView<FMatrix44f> GetPrevReferenceToLocalMatrices() const override { return {}; }
 
    virtual int32 GetLOD() const override { return 0; }
 
    virtual bool HaveValidDynamicData() const override { return false; }
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
 
    virtual void UpdateSkinWeightBuffer(const TArrayView<const FSkelMeshComponentLODInfo> InLODInfo) override {}
 
    virtual bool IsGPUSkinMesh() const override { return true; }
 
#if RHI_RAYTRACING
    // TODO: Support skinning in ray tracing (currently representing with static geometry)
    virtual const FRayTracingGeometry* GetStaticRayTracingGeometry() const override;
#endif
 
private:
    struct FSkeletalMeshObjectLOD
    {
        FSkeletalMeshRenderData* RenderData;
        FLocalVertexFactory LocalVertexFactory;
        TArray<TUniquePtr<FGPUBaseSkinVertexFactory>> VertexFactories;
        int32 LODIndex;
        ERHIFeatureLevel::Type FeatureLevel;
        bool bInitialized = false;
        bool bStaticRayTracingGeometryInitialized = false;
 
        FSkeletalMeshObjectLOD(ERHIFeatureLevel::Type InFeatureLevel, FSkeletalMeshRenderData* InRenderData, int32 InLOD);
 
        void InitResources(const FSkelMeshComponentLODInfo* InLODInfo);
        void ReleaseResources();
    };
 
    TObjectPtr<UTransformProviderData> TransformProvider;
    TArray<FSkeletalMeshObjectLOD> LODs;
};
 
class FGPUMorphUpdateCS : public FGlobalShader
{
public:
    DECLARE_SHADER_TYPE(FGPUMorphUpdateCS, Global);
 
    FGPUMorphUpdateCS();
    FGPUMorphUpdateCS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
 
    static const uint32 MorphTargetDispatchBatchSize = 128;
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        const FVector4& LocalScale,
        const FMorphTargetVertexInfoBuffers& MorphTargetVertexInfoBuffers,
        FMorphVertexBuffer& MorphVertexBuffer,
        uint32 NumGroups,
        uint32 BatchOffsets[MorphTargetDispatchBatchSize],
        uint32 GroupOffsets[MorphTargetDispatchBatchSize],
        float Weights[MorphTargetDispatchBatchSize]);
 
    void Dispatch(FRHICommandList& RHICmdList, uint32 Size);
    void UnsetParameters(FRHIBatchedShaderUnbinds& BatchedUnbinds);
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters);
 
protected:
    LAYOUT_FIELD(FShaderResourceParameter, MorphVertexBufferParameter);
 
    LAYOUT_FIELD(FShaderParameter, MorphTargetWeightsParameter);
    LAYOUT_FIELD(FShaderParameter, OffsetAndSizeParameter);
    LAYOUT_FIELD(FShaderParameter, MorphTargetBatchOffsetsParameter);
    LAYOUT_FIELD(FShaderParameter, MorphTargetGroupOffsetsParameter);
    LAYOUT_FIELD(FShaderParameter, PositionScaleParameter);
    LAYOUT_FIELD(FShaderParameter, PrecisionParameter);
    LAYOUT_FIELD(FShaderParameter, NumGroupsParameter);
 
    LAYOUT_FIELD(FShaderResourceParameter, MorphDataBufferParameter);
};
 
class FGPUMorphNormalizeCS : public FGlobalShader
{
public:
    DECLARE_SHADER_TYPE(FGPUMorphNormalizeCS, Global);
 
    FGPUMorphNormalizeCS();
    FGPUMorphNormalizeCS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters);
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FVector4& LocalScale, const FMorphTargetVertexInfoBuffers& MorphTargetVertexInfoBuffers, FMorphVertexBuffer& MorphVertexBuffer, uint32 NumVertices);
 
    void Dispatch(FRHICommandList& RHICmdList, uint32 NumVertices);
    void UnsetParameters(FRHIBatchedShaderUnbinds& BatchedUnbinds);
 
protected:
    LAYOUT_FIELD(FShaderResourceParameter, MorphVertexBufferParameter);
 
    LAYOUT_FIELD(FShaderParameter, PositionScaleParameter);
    LAYOUT_FIELD(FShaderParameter, NumVerticesParameter);
};