SkeletalMeshLODRenderData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Rendering/MultiSizeIndexContainer.h"
#include "Rendering/SkeletalMeshVertexBuffer.h"
#include "Rendering/SkinWeightVertexBuffer.h"
#include "Rendering/ColorVertexBuffer.h"
#include "Rendering/SkeletalMeshDuplicatedVerticesBuffer.h"
#include "Rendering/SkeletalMeshVertexClothBuffer.h"
#include "Rendering/MorphTargetVertexInfoBuffers.h"
#include "Rendering/SkeletalMeshHalfEdgeBuffer.h"
#include "SkeletalMeshTypes.h"
#include "BoneIndices.h"
#include "StaticMeshResources.h"
#include "GPUSkinVertexFactory.h"
#include "Animation/SkeletalMeshVertexAttribute.h"
#include "Animation/SkinWeightProfile.h"
 
class USkinnedAsset;
#if WITH_EDITOR
class FSkeletalMeshLODModel;
struct FSkeletalMeshVertexAttributeInfo;
#endif // WITH_EDITOR
 
struct FSkelMeshRenderSection
{
    uint16 MaterialIndex;
 
    uint32 BaseIndex;
 
    uint32 NumTriangles;
 
    bool bRecomputeTangent;
 
    bool bCastShadow;
 
    bool bVisibleInRayTracing;
 
    ESkinVertexColorChannel RecomputeTangentsVertexMaskChannel;
 
    uint32 BaseVertexIndex;
 
    TArray<FMeshToMeshVertData> ClothMappingData_DEPRECATED;
 
    TArray<TArray<FMeshToMeshVertData>> ClothMappingDataLODs;
 
    TArray<FBoneIndexType> BoneMap;
 
    uint32 NumVertices;
 
    int32 MaxBoneInfluences;
 
    // INDEX_NONE if not set
    int16 CorrespondClothAssetIndex;
 
    FClothingSectionData ClothingData;
 
    FDuplicatedVerticesBuffer DuplicatedVerticesBuffer;
 
    bool bDisabled;
 
    FSkelMeshRenderSection()
        : MaterialIndex(0)
        , BaseIndex(0)
        , NumTriangles(0)
        , bRecomputeTangent(false)
        , bCastShadow(true)
        , bVisibleInRayTracing(true)
        , RecomputeTangentsVertexMaskChannel(ESkinVertexColorChannel::None)
        , BaseVertexIndex(0)
        , NumVertices(0)
        , MaxBoneInfluences(4)
        , CorrespondClothAssetIndex(-1)
        , bDisabled(false)
    {}
 
    inline bool HasClothingData() const
    {
        constexpr int32 ClothLODBias = 0;  // Must at least have the mapping for the matching cloth LOD
        return ClothMappingDataLODs.Num() && ClothMappingDataLODs[ClothLODBias].Num();
    }
 
    inline int32 GetVertexBufferIndex() const
    {
        return BaseVertexIndex;
    }
 
    inline int32 GetNumVertices() const
    {
        return NumVertices;
    }
 
    inline bool IsValid() const
    {
        return NumTriangles > 0 && !bDisabled;
    }
 
    ENGINE_API friend FArchive& operator<<(FArchive& Ar, FSkelMeshRenderSection& S);
};
 
class FSkeletalMeshLODRenderData : public FRefCountBase
{
public:
 
    TArray<FSkelMeshRenderSection>  RenderSections;
 
    // Index Buffer (MultiSize: 16bit or 32bit)
    FMultiSizeIndexContainer    MultiSizeIndexContainer;
 
    FStaticMeshVertexBuffers    StaticVertexBuffers;
 
    FSkinWeightVertexBuffer     SkinWeightVertexBuffer;
 
    FSkeletalMeshVertexClothBuffer  ClothVertexBuffer;
 
    FMorphTargetVertexInfoBuffers   MorphTargetVertexInfoBuffers;
 
    FSkinWeightProfilesData SkinWeightProfilesData;
 
    FSkeletalMeshVertexAttributeRenderData VertexAttributeBuffers;
 
    FSkeletalMeshHalfEdgeBuffer HalfEdgeBuffer;
 
    TArray<FBoneIndexType> ActiveBoneIndices;
 
    TArray<FBoneIndexType> RequiredBones;
 
    uint32 BuffersSize;
 
    FRayTracingGeometry SourceRayTracingGeometry;
 
    FByteBulkData StreamingBulkData;
 
    uint32 bStreamedDataInlined : 1;
    uint32 bIsLODOptional : 1;
 
#if WITH_EDITOR
    FByteBulkData BulkData;
#endif
 
#if RHI_RAYTRACING
    int32 NumReferencingStaticSkeletalMeshObjects = 0;
    bool bReferencedByStaticSkeletalMeshObjects_RenderThread = false;
    FRayTracingGeometry StaticRayTracingGeometry;
#endif
 
    void InitResources(bool bNeedsVertexColors, int32 LODIndex, USkinnedAsset* Owner);
 
    void InitMorphResources();
 
    ENGINE_API void ReleaseResources();
 
    void ReleaseCPUResources(bool bForStreaming = false);
 
    FSkeletalMeshLODRenderData(bool bAddRef = true)
        : BuffersSize(0)
        , bStreamedDataInlined(true)
        , bIsLODOptional(false)
    {
        if (bAddRef)
        {
            AddRef();
        }
    }
 
    inline ~FSkeletalMeshLODRenderData()
    {
        check(GetRefCount() == 0);
    }
 
    void Serialize(FArchive& Ar, UObject* Owner, int32 Idx);
 
    ENGINE_API void SerializeStreamedData(FArchive& Ar, USkinnedAsset* Owner, int32 LODIdx, uint8 ClassStripFlags, bool bNeedsCPUAccess, bool bForceKeepCPUResources);
 
    void SerializeAvailabilityInfo(FArchive& Ar, int32 LODIdx, bool bHasAdjacencyData, bool bNeedsCPUAccess);
 
#if WITH_EDITOR
 
    struct FBuildSettings
    {
        ESkeletalMeshVertexFlags BuildFlags = ESkeletalMeshVertexFlags::None;
        bool bBuildHalfEdgeBuffers = false;
    };
    
    void ENGINE_API BuildFromLODModel(
        const FSkeletalMeshLODModel* InLODModel,
        TConstArrayView<FSkeletalMeshVertexAttributeInfo> InVertexAttributeInfos = {},
        const FBuildSettings& InBuildSettings = FBuildSettings{ESkeletalMeshVertexFlags::None, false}
        );
#endif // WITH_EDITOR
 
    uint32 GetNumVertices() const
    {
        return StaticVertexBuffers.PositionVertexBuffer.GetNumVertices();
    }
 
    uint32 GetVertexBufferMaxBoneInfluences() const
    {
        return SkinWeightVertexBuffer.GetMaxBoneInfluences();
    }
 
    bool DoesVertexBufferUse16BitBoneIndex() const
    {
        return SkinWeightVertexBuffer.Use16BitBoneIndex();
    }
 
    uint32 GetNumTexCoords() const
    {
        return StaticVertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords();
    }
 
    FSkinWeightVertexBuffer* GetSkinWeightVertexBuffer() 
    {
        FSkinWeightVertexBuffer* OverrideBuffer = SkinWeightProfilesData.GetDefaultOverrideBuffer();
        return OverrideBuffer != nullptr ? OverrideBuffer : &SkinWeightVertexBuffer;
    }
    
    const FSkinWeightVertexBuffer* GetSkinWeightVertexBuffer() const
    {
        FSkinWeightVertexBuffer* OverrideBuffer = SkinWeightProfilesData.GetDefaultOverrideBuffer();
        return OverrideBuffer != nullptr ? OverrideBuffer : &SkinWeightVertexBuffer;
    }
 
    ENGINE_API int32 GetTotalFaces() const;
 
    ENGINE_API bool HasClothData() const;
 
    ENGINE_API void GetSectionFromVertexIndex(int32 InVertIndex, int32& OutSectionIndex, int32& OutVertIndex) const;
 
    ENGINE_API void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) const;
 
    SIZE_T GetCPUAccessMemoryOverhead() const;
 
    // O(1)
    // @return -1 if not found
    uint32 FindSectionIndex(const FSkelMeshRenderSection& Section) const;
 
    ENGINE_API int32 NumNonClothingSections() const;
 
    void IncrementMemoryStats(bool bNeedsVertexColors);
    void DecrementMemoryStats();
 
    static bool ShouldForceKeepCPUResources();
    static bool ShouldKeepCPUResources(const USkinnedAsset* SkinnedAsset, int32 LODIdx, bool bForceKeep);
 
private:
    enum EClassDataStripFlag : uint8
    {
        CDSF_AdjacencyData_DEPRECATED = 1,
        CDSF_MinLodData = 2
    };
 
    static uint8 GenerateClassStripFlags(FArchive& Ar, const USkinnedAsset* OwnerMesh, int32 LODIdx);
 
    static bool IsLODCookedOut(const ITargetPlatform* TargetPlatform, const USkinnedAsset* SkinnedAsset, bool bIsBelowMinLOD);
 
    static bool IsLODInlined(const ITargetPlatform* TargetPlatform, const USkinnedAsset* SkinnedAsset, int32 LODIdx, bool bIsBelowMinLOD);
 
    static int32 GetNumOptionalLODsAllowed(const ITargetPlatform* TargetPlatform, const USkinnedAsset* SkinnedAsset);
 
    friend class FSkeletalMeshRenderData;
};