SkeletalRenderPublic.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SkeletalRenderPublic.h: Definitions and inline code for rendering SkeletalMeshComponent
=============================================================================*/
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "ProfilingDebugging/ResourceSize.h"
#include "PackedNormal.h"
#include "RenderDeferredCleanup.h"
#include "RenderUtils.h"
#include "Engine/SkeletalMesh.h"
#include "Components/SkinnedMeshComponent.h"
#include "MeshUVChannelInfo.h"
#include "SkeletalMeshTypes.h"
#include "RenderMath.h"
#include "Async/Mutex.h"
#include "Matrix3x4.h"
 
class FPrimitiveDrawInterface;
class FVertexFactory;
class UMorphTarget;
struct FSkelMeshRenderSection;
struct FCachedGeometry;
struct FRWBuffer;
class FGPUSkinCacheEntry;
class FMeshDeformerGeometry;
class FRayTracingGeometry;
class FSkinningSceneExtensionProxy;
class FRHICommandList;
class FRDGBuilder;
namespace Nanite
{
    struct FMaterialAudit;
}
 
namespace UE::SkeletalRender::Settings
{
    // Returns the maximum value allowed for morph targets blend weights, configured at RenderSettings
    ENGINE_API float GetMorphTargetMaxBlendWeight();
}
 
struct FFinalSkinVertex
{
    FVector3f           Position;
    FPackedNormal   TangentX;
    FPackedNormal   TangentZ;
    float           U;
    float           V;
    FVector2D TextureCoordinates[MAX_TEXCOORDS];
 
    FVector3f GetTangentY() const
    {
        return FVector3f(GenerateYAxis(TangentX, TangentZ));
    };
};
 
enum class EPreviousBoneTransformUpdateMode
{
    None,
 
    UpdatePrevious,
 
    DuplicateCurrentToPrevious,
};
 
struct FSkinBatchVertexFactoryUserData
{
    FGPUSkinCacheEntry* SkinCacheEntry = nullptr;
    FMeshDeformerGeometry* DeformerGeometry = nullptr;
    int32 SectionIndex = -1;
};
 
struct FSkinnedMeshSceneProxyDesc;
struct FSkinnedMeshSceneProxyDynamicData;
 
class FSkeletalMeshObject : public FDeferredCleanupInterface
{
public:
    ENGINE_API FSkeletalMeshObject(const USkinnedMeshComponent* InMeshComponent, FSkeletalMeshRenderData* InSkelMeshRenderData, ERHIFeatureLevel::Type FeatureLevel);
    ENGINE_API FSkeletalMeshObject(const FSkinnedMeshSceneProxyDesc& InMeshDesc, FSkeletalMeshRenderData* InSkelMeshRenderData, ERHIFeatureLevel::Type FeatureLevel);
 
    ENGINE_API virtual ~FSkeletalMeshObject();
 
    virtual void InitResources(const FSkinnedMeshSceneProxyDesc& InMeshDesc) = 0;
 
    virtual void ReleaseResources() = 0;
 
    ENGINE_API void Update(int32 LODIndex, const USkinnedMeshComponent* InMeshComponent, const FMorphTargetWeightMap& InActiveMorphTargets, const TArray<float>& MorphTargetWeights, EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode, const FExternalMorphWeightData& InExternalMorphWeightData);
    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) = 0;
 
    UE_DEPRECATED(5.5, "PreGDMECallback is no longer used")
    virtual void PreGDMECallback(FRHICommandList& RHICmdList, class FGPUSkinCache* GPUSkinCache, uint32 FrameNumber) {}
 
    virtual const FVertexFactory* GetSkinVertexFactory(const FSceneView* View, int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode = ESkinVertexFactoryMode::Default) const = 0;
 
    virtual const FVertexFactory* GetStaticSkinVertexFactory(int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode) const = 0;
 
    UE_DEPRECATED(5.5, "This method is no longer in use")
    virtual const FSkinBatchVertexFactoryUserData* GetVertexFactoryUserData(const int32 LODIndex, int32 ChunkIdx, ESkinVertexFactoryMode VFMode) const { return nullptr; }
 
    virtual bool IsCPUSkinned() const { return false; }
 
    virtual bool IsGPUSkinMesh() const { return false; }
 
    virtual bool IsNaniteMesh() const { return false; }
 
    virtual const Nanite::FMaterialAudit* GetNaniteMaterials() const { return nullptr; }
 
    virtual TArray<FTransform>* GetComponentSpaceTransforms() const = 0;
 
    virtual TConstArrayView<FMatrix44f> GetReferenceToLocalMatrices() const = 0;
 
    virtual TConstArrayView<FMatrix44f> GetPrevReferenceToLocalMatrices() const
    {
        // Not implemented
        checkNoEntry();
        return GetReferenceToLocalMatrices();
    }
 
    UE_DEPRECATED(5.7, "Use GetReferenceToLocalMatrices instead")
    virtual const TArray<FMatrix3x4>* GetCurrentBoneTransforms() const
    {
        checkNoEntry();
        return nullptr;
    }
 
    UE_DEPRECATED(5.7, "Use GetPrevReferenceToLocalMatrices instead")
    virtual const TArray<FMatrix3x4>* GetPreviousBoneTransforms() const
    {
        checkNoEntry();
        return nullptr;
    }
 
    virtual FSkinningSceneExtensionProxy* CreateSceneExtensionProxy(const USkinnedAsset* InSkinnedAsset, bool bAllowScaling);
 
    virtual bool GetCachedGeometry(FRDGBuilder& GraphBuilder, FCachedGeometry& OutCachedGeometry) const { return false; }
 
    UE_DEPRECATED(5.6, "GetCachedGeometry now requires a GraphBuilder")
    bool GetCachedGeometry(FCachedGeometry& OutCachedGeometry) const { return false; }
 
    void UpdateSkinWeightBuffer(const USkinnedMeshComponent* InMeshComponent);
    virtual void UpdateSkinWeightBuffer(const TArrayView<const FSkelMeshComponentLODInfo> InLODInfo) = 0;
 
    virtual int32 GetLOD() const = 0;
    virtual void EnableOverlayRendering(bool bEnabled, const TArray<int32>* InBonesOfInterest, const TArray<UMorphTarget*>* MorphTargetOfInterest) {}
 
    virtual void DrawVertexElements(FPrimitiveDrawInterface* PDI, const FMatrix& ToWorldSpace, bool bDrawNormals, bool bDrawTangents, bool bDrawBinormals) const {}
 
    void UpdateMinDesiredLODLevel(const FSceneView* View, const FBoxSphereBounds& Bounds);
 
    virtual bool HaveValidDynamicData() const = 0;
 
    // allow access to mesh component
    friend class FDynamicSkelMeshObjectDataCPUSkin;
    friend class FDynamicSkelMeshObjectDataGPUSkin;
    friend class FSkeletalMeshSceneProxy;
    friend class FSkeletalMeshSectionIter;
 
    bool ShouldUsePerBoneMotionBlur() const { return bUsePerBoneMotionBlur; }
    
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) = 0;
 
    ENGINE_API const TArray<FSkelMeshRenderSection>& GetRenderSections(int32 InLODIndex) const;
 
    void SetHiddenMaterials(int32 InLODIndex,const TArray<bool>& HiddenMaterials);
    
    bool IsMaterialHidden(int32 InLODIndex,int32 MaterialIdx) const;
    
    void InitLODInfos(const TArrayView<const FSkelMeshComponentLODInfo> InComponentLODInfo, const USkinnedAsset* InSkinnedAsset);
 
    inline uint32 GetComponentId() const { return ComponentId; }
 
    inline TStatId GetStatId() const { return StatId; }
 
    inline FSkeletalMeshRenderData& GetSkeletalMeshRenderData() const { return *SkeletalMeshRenderData; }
 
    FColor GetSkinCacheVisualizationDebugColor(const FName& GPUSkinCacheVisualizationMode, uint32 SectionIndex) const;
 
    FName GetAssetPathName(int32 LODIndex = -1) const;
 
#if RHI_RAYTRACING
    virtual FRayTracingGeometry* GetRayTracingGeometry() { return nullptr; }
    virtual const FRayTracingGeometry* GetRayTracingGeometry() const { return nullptr; }
    virtual const FRayTracingGeometry* GetStaticRayTracingGeometry() const { return nullptr; }
    virtual FRWBuffer* GetRayTracingDynamicVertexBuffer() { return nullptr; }
    virtual int32 GetRayTracingLOD() const { return GetLOD(); }
 
    virtual bool ShouldUseSeparateSkinCacheEntryForRayTracing() const { return GetLOD() != GetRayTracingLOD(); }
    virtual FGPUSkinCacheEntry* GetSkinCacheEntryForRayTracing() const { return ShouldUseSeparateSkinCacheEntryForRayTracing() ? SkinCacheEntryForRayTracing : SkinCacheEntry; }
 
    virtual void UpdateRayTracingGeometry(FRHICommandListBase& RHICmdList, FSkeletalMeshLODRenderData& LODModel, uint32 LODIndex, TArray<FBufferRHIRef>& VertexBuffers) {}
 
    UE_DEPRECATED(5.6, "QueuePendingRayTracingGeometryUpdate is no longer used, but bRequiresRebuild flag on FRayTracingGeometry is used to check if ray tracing geometry needs to be updated during FRayTracingGeometry")
    void QueuePendingRayTracingGeometryUpdate(FRHICommandListBase& RHICmdList) {}
       
#endif // RHI_RAYTRACING
 
    virtual void SetTransform(const FMatrix& InNewLocalToWorld, uint32 FrameNumber) {};
 
    virtual void RefreshClothingTransforms(const FMatrix& InNewLocalToWorld, uint32 FrameNumber) {};
 
    struct FSkelMeshObjectLODInfo
    {
        TArray<bool>    HiddenMaterials;
 
        FPerPlatformFloat ScreenSize;
 
        float LODHysteresis;
 
#if RHI_ENABLE_RESOURCE_INFO
        FName AssetPathName;
#endif
    };
 
    TArray<FSkelMeshObjectLODInfo> LODInfo;
 
    TArray<FCapsuleShape3f> ShadowCapsuleShapes;
 
    int32 MinDesiredLODLevel;
 
    float MaxDistanceFactor;
 
    int32 WorkingMinDesiredLODLevel;
 
    float WorkingMaxDistanceFactor;
 
    bool bHasBeenUpdatedAtLeastOnce;
 
#if RHI_RAYTRACING
    bool bSupportRayTracing;
    bool bHiddenMaterialVisibilityDirtyForRayTracing;
    int32 RayTracingMinLOD;
#endif
 
#if UE_BUILD_SHIPPING
    FName GetDebugName() const { return FName(); }
#else
    FName GetDebugName() const { return DebugName; }
    FName DebugName;
#endif // !UE_BUILD_SHIPPING
 
#if WITH_EDITORONLY_DATA
    int32 SectionIndexPreview;
    int32 MaterialIndexPreview;
 
    int32 SelectedEditorSection;
    int32 SelectedEditorMaterial;
#endif
 
    ERHIFeatureLevel::Type GetFeatureLevel() const
    {
        return FeatureLevel;
    }
 
    bool SupportsStaticRelevance() const
    {
        return bSupportsStaticRelevance;
    }
 
    float GetScreenSize(int32 LODIndex) const;
 
    static FSkinWeightVertexBuffer* GetSkinWeightVertexBuffer(FSkeletalMeshLODRenderData& LODData, const FSkelMeshComponentLODInfo* CompLODInfo);
 
    static FColorVertexBuffer* GetColorVertexBuffer(FSkeletalMeshLODRenderData& LODData, const FSkelMeshComponentLODInfo* CompLODInfo);
 
    virtual const FSkinWeightVertexBuffer* GetSkinWeightVertexBuffer(int32 LODIndex) const { return nullptr; }
 
    virtual int32 GetDynamicBoundsStartOffset(int32 LODIndex) const { return -1; }
 
protected:
    FSkeletalMeshRenderData* SkeletalMeshRenderData;
 
    FGPUSkinCacheEntry* SkinCacheEntry;
    FGPUSkinCacheEntry* SkinCacheEntryForRayTracing;
 
    uint32 LastFrameNumber;
 
    UE::FMutex DesiredLODLevelMutex;
 
    bool bUsePerBoneMotionBlur;
 
    bool bSupportsStaticRelevance = false;
 
    TStatId StatId;
 
    ERHIFeatureLevel::Type FeatureLevel;
 
    uint32 ComponentId;
 
    FVector WorldScale = FVector::OneVector;
 
#if RHI_ENABLE_RESOURCE_INFO
    FName AssetPathName;
#endif
};