SkeletalRenderCPUSkin.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SkeletalRenderCPUSkin.h: CPU skinned mesh object and resource definitions
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "ProfilingDebugging/ResourceSize.h"
#include "RenderResource.h"
#include "RayTracingGeometry.h"
#include "LocalVertexFactory.h"
#include "Components/SkinnedMeshComponent.h"
#include "SkeletalRenderPublic.h"
#include "ClothingSystemRuntimeTypes.h"
#include "Rendering/SkeletalMeshRenderData.h"
#include "Rendering/SkeletalMeshLODRenderData.h"
#include "StaticMeshResources.h"
 
class FPrimitiveDrawInterface;
class UMorphTarget;
 
class FDynamicSkelMeshObjectDataCPUSkin
{
public:
 
    ENGINE_API FDynamicSkelMeshObjectDataCPUSkin(
        const FSkinnedMeshSceneProxyDynamicData& InDynamicData,
        const USkinnedAsset* InSkinnedAsset,
        FSkeletalMeshRenderData* InSkelMeshRenderData,
        int32 InLODIndex,
        const FMorphTargetWeightMap& InActiveMorphTargets,
        const TArrayView<const float>& InMorphTargetWeights);
 
    ENGINE_API virtual ~FDynamicSkelMeshObjectDataCPUSkin();
 
    FMatrix WorldToLocal;
 
    TArray<FMatrix44f> ReferenceToLocal;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) 
    TArray<FTransform> MeshComponentSpaceTransforms;
#endif
    int32 LODIndex;
    FMorphTargetWeightMap ActiveMorphTargets;
    TArray<float> MorphTargetWeights;
 
    TMap<int32, FClothSimulData> ClothSimulUpdateData;
 
    float ClothBlendWeight;
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize)
    {
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(sizeof(*this));
        
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(ReferenceToLocal.GetAllocatedSize());
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(ActiveMorphTargets.GetAllocatedSize());
    }
};
 
class FSkeletalMeshObjectCPUSkin : public FSkeletalMeshObject
{
public:
 
    ENGINE_API FSkeletalMeshObjectCPUSkin(const USkinnedMeshComponent* InMeshComponent, FSkeletalMeshRenderData* InSkelMeshRenderData, ERHIFeatureLevel::Type InFeatureLevel);
    ENGINE_API FSkeletalMeshObjectCPUSkin(const FSkinnedMeshSceneProxyDesc& InMeshDesc, FSkeletalMeshRenderData* InSkelMeshRenderData, ERHIFeatureLevel::Type InFeatureLevel);
    ENGINE_API virtual ~FSkeletalMeshObjectCPUSkin();
 
    //~ Begin FSkeletalMeshObject Interface
    ENGINE_API virtual void InitResources(const FSkinnedMeshSceneProxyDesc& InMeshDesc) override;
    ENGINE_API virtual void ReleaseResources() override;
    ENGINE_API virtual void Update(int32 LODIndex, const FSkinnedMeshSceneProxyDynamicData& InDynamicData, const FPrimitiveSceneProxy* InSceneProxy, const USkinnedAsset* InSkinnedAsset, const FMorphTargetWeightMap& InActiveMorphTargets, const TArray<float>& InMorphTargetWeights, EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode, const FExternalMorphWeightData& InExternalMorphWeightData) override;
    ENGINE_API void UpdateDynamicData_RenderThread(FRHICommandList& RHICmdList, FDynamicSkelMeshObjectDataCPUSkin* InDynamicData, uint64 FrameNumberToPrepare, uint32 RevisionNumber);
    ENGINE_API virtual void EnableOverlayRendering(bool bEnabled, const TArray<int32>* InBonesOfInterest, const TArray<UMorphTarget*>* InMorphTargetOfInterest) override;
    ENGINE_API virtual const FVertexFactory* GetSkinVertexFactory(const FSceneView* View, int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode = ESkinVertexFactoryMode::Default) const override;
    ENGINE_API virtual const FVertexFactory* GetStaticSkinVertexFactory(int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode) const override;
    ENGINE_API virtual TArray<FTransform>* GetComponentSpaceTransforms() const override;
    ENGINE_API virtual TConstArrayView<FMatrix44f> GetReferenceToLocalMatrices() const override;
 
    virtual FSkinningSceneExtensionProxy* CreateSceneExtensionProxy(const USkinnedAsset* InSkinnedAsset, bool bAllowScaling)
    {
        return nullptr;
    }
 
    ENGINE_API void CacheVertices(int32 LODIndex, bool bForce, FRHICommandList& RHICmdList) const;
 
    virtual int32 GetLOD() const override
    {
        if(DynamicData)
        {
            return DynamicData->LODIndex;
        }
        else
        {
            return 0;
        }
    }
 
    virtual bool HaveValidDynamicData() const override
    { 
        return (DynamicData != nullptr); 
    }
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override
    {
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(sizeof(*this));
 
        if(DynamicData)
        {
            DynamicData->GetResourceSizeEx(CumulativeResourceSize);
        }
 
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(LODs.GetAllocatedSize()); 
 
        // include extra data from LOD
        for (int32 I=0; I<LODs.Num(); ++I)
        {
            LODs[I].GetResourceSizeEx(CumulativeResourceSize);
        }
 
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(CachedFinalVertices.GetAllocatedSize());
        CumulativeResourceSize.AddDedicatedSystemMemoryBytes(BonesOfInterest.GetAllocatedSize());
    }
 
    virtual bool IsCPUSkinned() const override { return true; }
 
    ENGINE_API virtual void DrawVertexElements(FPrimitiveDrawInterface* PDI, const FMatrix& ToWorldSpace, bool bDrawNormals, bool bDrawTangents, bool bDrawBinormals) const override;
    //~ End FSkeletalMeshObject Interface
 
    const TArray<FFinalSkinVertex>& GetCachedFinalVertices() const { return CachedFinalVertices; }
 
 
    ENGINE_API virtual void UpdateSkinWeightBuffer(const TArrayView<const FSkelMeshComponentLODInfo> InLODInfo) override;
 
private:
    struct FSkeletalMeshObjectLOD
    {
        FSkeletalMeshRenderData* SkelMeshRenderData;
        // index into FSkeletalMeshRenderData::LODRenderData[]
        int32 LODIndex;
 
        mutable FLocalVertexFactory VertexFactory;
 
        mutable FStaticMeshVertexBuffer StaticMeshVertexBuffer;
        mutable FPositionVertexBuffer PositionVertexBuffer;
 
        FSkinWeightVertexBuffer* MeshObjectWeightBuffer;
 
        FColorVertexBuffer* MeshObjectColorBuffer;
 
#if RHI_RAYTRACING
        FRayTracingGeometry RayTracingGeometry;
#endif // RHI_RAYTRACING
 
        bool                        bResourcesInitialized;
 
        FSkeletalMeshObjectLOD(ERHIFeatureLevel::Type InFeatureLevel, FSkeletalMeshRenderData* InSkelMeshRenderData, int32 InLOD)
        :   SkelMeshRenderData(InSkelMeshRenderData)
        ,   LODIndex(InLOD)
        ,   VertexFactory(InFeatureLevel, "FSkeletalMeshObjectLOD")
        ,   MeshObjectWeightBuffer(nullptr)
        ,   MeshObjectColorBuffer(nullptr)
        ,   bResourcesInitialized( false )
        {
        }
        void InitResources(const FSkelMeshComponentLODInfo* CompLODInfo);
        void ReleaseResources();
 
        void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize)
        {
            CumulativeResourceSize.AddUnknownMemoryBytes(StaticMeshVertexBuffer.GetResourceSize() + PositionVertexBuffer.GetStride() * PositionVertexBuffer.GetNumVertices());
        }
 
        void UpdateSkinWeights(const FSkelMeshComponentLODInfo* CompLODInfo);
    };
 
    TArray<FSkeletalMeshObjectLOD> LODs;
 
protected:
    class FDynamicSkelMeshObjectDataCPUSkin* DynamicData;
 
private:
    mutable int32   CachedVertexLOD;
 
    mutable TArray<FFinalSkinVertex> CachedFinalVertices;
 
    TArray<int32> BonesOfInterest;
    TArray<UMorphTarget*> MorphTargetOfInterest;
 
    bool bRenderOverlayMaterial;
};