MeshRenderBufferSet.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved. 
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "Async/ParallelFor.h"
 
#include "Components/BaseDynamicMeshComponent.h"
#include "Components/DynamicMeshComponent.h"
#include "DynamicMeshBuilder.h"
#include "DynamicMesh/DynamicMesh3.h"   
#include "DynamicMesh/DynamicMeshAttributeSet.h"
 
#include "LocalVertexFactory.h"
#include "Rendering/StaticMeshVertexBuffer.h"
#include "Rendering/PositionVertexBuffer.h"
#include "Rendering/ColorVertexBuffer.h"
#include "RHICommandList.h"
#include "RayTracingGeometry.h"
#include "VertexFactory.h"
 
 
 
 
using UE::Geometry::FDynamicMesh3;
using UE::Geometry::FDynamicMeshAttributeSet;
using UE::Geometry::FDynamicMeshUVOverlay;
using UE::Geometry::FDynamicMeshNormalOverlay;
using UE::Geometry::FDynamicMeshColorOverlay;
using UE::Geometry::FDynamicMeshMaterialAttribute;
 
class UMaterialInterface;
 
class FMeshRenderBufferSet
{
public:
    int TriangleCount = 0;
 
    FStaticMeshVertexBuffer StaticMeshVertexBuffer;
    FPositionVertexBuffer PositionVertexBuffer;
    FColorVertexBuffer ColorVertexBuffer;
 
    FDynamicMeshIndexBuffer32 IndexBuffer;
 
    FLocalVertexFactory VertexFactory;
 
    UMaterialInterface* Material = nullptr;
 
    TOptional<TArray<int>> Triangles;
 
    bool bEnableSecondaryIndexBuffer = false;
 
    FDynamicMeshIndexBuffer32 SecondaryIndexBuffer;
 
    bool bEnableRaytracing = false;
 
#if RHI_RAYTRACING
    FRayTracingGeometry PrimaryRayTracingGeometry;
    FRayTracingGeometry SecondaryRayTracingGeometry;
    bool bIsRayTracingDataValid = false;
#endif
 
    FCriticalSection BuffersLock;
 
 
    FMeshRenderBufferSet(ERHIFeatureLevel::Type FeatureLevelType)
    : VertexFactory(FeatureLevelType, "FMeshRenderBufferSet")
    {
        StaticMeshVertexBuffer.SetUseFullPrecisionUVs(true);
        StaticMeshVertexBuffer.SetUseHighPrecisionTangentBasis(true);
 
#if RHI_RAYTRACING
        EnumAddFlags(IndexBuffer.UsageFlags, EBufferUsageFlags::ShaderResource);
        EnumAddFlags(SecondaryIndexBuffer.UsageFlags, EBufferUsageFlags::ShaderResource);
#endif // RHI_RAYTRACING
    }
 
    virtual ~FMeshRenderBufferSet()
    {
        if (TriangleCount > 0)
        {
            PositionVertexBuffer.ReleaseResource();
            StaticMeshVertexBuffer.ReleaseResource();
            ColorVertexBuffer.ReleaseResource();
            VertexFactory.ReleaseResource();
            if (IndexBuffer.IsInitialized())
            {
                IndexBuffer.ReleaseResource();
            }
            if (SecondaryIndexBuffer.IsInitialized())
            {
                SecondaryIndexBuffer.ReleaseResource();
            }
 
#if RHI_RAYTRACING
            if (bEnableRaytracing)
            {
                PrimaryRayTracingGeometry.ReleaseResource();
                SecondaryRayTracingGeometry.ReleaseResource();
            }
#endif
        }
    }
 
 
    GEOMETRYFRAMEWORK_API void Upload();
    
 
 
    void UploadIndexBufferUpdate()
    {
        // todo: can this be done with RHI locking and memcpy, like in TransferVertexUpdateToGPU?
        FRHICommandListBase& RHICmdList = FRHICommandListImmediate::Get();
 
        if (IndexBuffer.Indices.Num() > 0)
        {
            InitOrUpdateResource(RHICmdList, &IndexBuffer);
        }
        if (bEnableSecondaryIndexBuffer && SecondaryIndexBuffer.Indices.Num() > 0)
        {
            InitOrUpdateResource(RHICmdList, &SecondaryIndexBuffer);
        }
 
        InvalidateRayTracingData();
        ValidateRayTracingData();       // currently we are immediately validating. This may be revisited in future.
    }
 
 
    GEOMETRYFRAMEWORK_API void UploadVertexUpdate(bool bPositions, bool bMeshAttribs, bool bColors);
    
 
 
    GEOMETRYFRAMEWORK_API void TransferVertexUpdateToGPU(FRHICommandListBase& RHICmdList, bool bPositions, bool bNormals, bool bTexCoords, bool bColors);
 
 
    void InvalidateRayTracingData()
    {
#if RHI_RAYTRACING
        bIsRayTracingDataValid = false;
#endif
    }
 
    // Verify that valid raytracing data is available. This will cause a rebuild of the
    // raytracing data if any of our buffers have been modified. Currently this is called
    // by GetDynamicRayTracingInstances to ensure the RT data is available when needed.
    void ValidateRayTracingData()
    {
#if RHI_RAYTRACING
        if (bIsRayTracingDataValid == false && IsRayTracingEnabled() && bEnableRaytracing)
        {
            UpdateRaytracingGeometryIfEnabled();
 
            bIsRayTracingDataValid = true;
        }
#endif
    }
 
 
protected:
 
    // rebuild raytracing data for current buffers
    void UpdateRaytracingGeometryIfEnabled()
    {
#if RHI_RAYTRACING
        // do we always want to do this?
        PrimaryRayTracingGeometry.ReleaseResource();
        SecondaryRayTracingGeometry.ReleaseResource();
        FRHICommandListBase& RHICmdList = FRHICommandListImmediate::Get();
 
        for (int32 k = 0; k < 2; ++k)
        {
            FDynamicMeshIndexBuffer32& UseIndexBuffer = (k == 0) ? IndexBuffer : SecondaryIndexBuffer;
            if (UseIndexBuffer.Indices.Num() == 0)
            {
                continue;
            }
 
            FRayTracingGeometry& RayTracingGeometry = (k == 0) ? PrimaryRayTracingGeometry : SecondaryRayTracingGeometry;
 
            FRayTracingGeometryInitializer Initializer;
            Initializer.IndexBuffer = UseIndexBuffer.IndexBufferRHI;
            Initializer.TotalPrimitiveCount = UseIndexBuffer.Indices.Num() / 3;
            Initializer.GeometryType = RTGT_Triangles;
            Initializer.bFastBuild = true;
            Initializer.bAllowUpdate = false;
 
            FRayTracingGeometrySegment Segment;
            Segment.VertexBuffer = PositionVertexBuffer.VertexBufferRHI;
            Segment.NumPrimitives = Initializer.TotalPrimitiveCount;
            Segment.MaxVertices = PositionVertexBuffer.GetNumVertices();
 
            Initializer.Segments.Add(Segment);
 
            RayTracingGeometry.SetInitializer(MoveTemp(Initializer));
            RayTracingGeometry.InitResource(RHICmdList);
        }
#endif
    }
 
 
 
    void InitOrUpdateResource(FRHICommandListBase& RHICmdList, FRenderResource* Resource)
    {
        if (!Resource->IsInitialized())
        {
            Resource->InitResource(RHICmdList);
        }
        else
        {
            Resource->UpdateRHI(RHICmdList);
        }
    }
 
 
public: 
 
    static void DestroyRenderBufferSet(FMeshRenderBufferSet* BufferSet)
    {
        //@todo, remove this check?  based on our usage it could produce a memory leak - see BaseDynamicMeshSceneProxy.cpp
        if (BufferSet->TriangleCount == 0)
        {
            return;
        }
 
        delete BufferSet;
    }
 
 
};
 
 
struct FMeshRenderBufferSetConversionUtil
{
 
    FColor ConstantVertexColor = FColor::White;
 
    bool bIgnoreVertexColors = false;
 
    bool bUsePerTriangleColor = false;
 
    TFunction<FColor(const FDynamicMesh3*, int)> PerTriangleColorFunc = nullptr;
 
    bool bApplyVertexColorRemapping = false;
 
    TUniqueFunction<void(FVector4f&)> VertexColorRemappingFunc = nullptr;
 
    EDynamicMeshVertexColorTransformMode ColorSpaceTransformMode = EDynamicMeshVertexColorTransformMode::NoTransform;
 
    bool bUsePerTriangleNormals = false;
 
    bool bUseSecondaryTriBuffers = false;
 
    TUniqueFunction<bool(const FDynamicMesh3*, int32)> SecondaryTriFilterFunc = nullptr;
 
 
    template<typename TriangleEnumerable>
    void InitializeBuffersFromOverlays(
                                        FMeshRenderBufferSet* RenderBuffers,
                                        const FDynamicMesh3* Mesh,
                                        int NumTriangles, const TriangleEnumerable& Enumerable,
                                        const FDynamicMeshUVOverlay* UVOverlay,
                                        const FDynamicMeshNormalOverlay* NormalOverlay,
                                        const FDynamicMeshColorOverlay* ColorOverlay,
                                        TFunctionRef<void(int, int, int, const FVector3f&, FVector3f&, FVector3f&)> TangentsFunc,
                                        bool bTrackTriangles = false,
                                        bool bParallel = false)
    {
        TArray<const FDynamicMeshUVOverlay*> UVOverlays;
        UVOverlays.Add(UVOverlay);
        InitializeBuffersFromOverlays(RenderBuffers, Mesh, NumTriangles, Enumerable,
            UVOverlays, NormalOverlay, ColorOverlay, TangentsFunc, bTrackTriangles, bParallel);
    }
 
 
    template<typename TriangleEnumerable, typename UVOverlayListAllocator>
    void InitializeBuffersFromOverlays( FMeshRenderBufferSet* RenderBuffers,
                                        const FDynamicMesh3* Mesh,
                                        int NumTriangles, 
                                        const TriangleEnumerable& Enumerable,
                                        const TArray<const FDynamicMeshUVOverlay*, UVOverlayListAllocator>& UVOverlays,
                                        const FDynamicMeshNormalOverlay* NormalOverlay,
                                        const FDynamicMeshColorOverlay* ColorOverlay,
                                        TFunctionRef<void(int, int, int, const FVector3f&, FVector3f&, FVector3f&)> TangentsFunc,
                                        bool bTrackTriangles = false,
                                        bool bParallel = false);
                                                
 
 
    void GEOMETRYFRAMEWORK_API UpdateSecondaryTriangleBuffer( FMeshRenderBufferSet* RenderBuffers,
                                                              const FDynamicMesh3* Mesh,
                                                              bool bDuplicate);
 
 
    void GEOMETRYFRAMEWORK_API RecomputeRenderBufferTriangleIndexSets( FMeshRenderBufferSet* RenderBuffers,
                                                                       const FDynamicMesh3* Mesh);
 
 
    template<typename TriangleEnumerable>
    void UpdateVertexBuffersFromOverlays( FMeshRenderBufferSet* RenderBuffers,
                                          const FDynamicMesh3* Mesh,
                                          int NumTriangles, const TriangleEnumerable& Enumerable,
                                          const FDynamicMeshNormalOverlay* NormalOverlay,
                                          const FDynamicMeshColorOverlay* ColorOverlay,
                                          TFunctionRef<void(int, int, int, const FVector3f&, FVector3f&, FVector3f&)> TangentsFunc,
                                          bool bUpdatePositions = true,
                                          bool bUpdateNormals = false,
                                          bool bUpdateColors = false);
 
 
    template<typename TriangleEnumerable, typename UVOverlayListAllocator>
    void UpdateVertexUVBufferFromOverlays( FMeshRenderBufferSet* RenderBuffers,
                                           const FDynamicMesh3* Mesh,
                                           int32 NumTriangles, const TriangleEnumerable& Enumerable,
                                           const TArray<const FDynamicMeshUVOverlay*, UVOverlayListAllocator>& UVOverlays);
 
 
    FColor GetOverlayColorAsFColor( const FDynamicMeshColorOverlay* ColorOverlay,
                                                          int32 ElementID)
    {
        checkSlow(ColorOverlay);
        FVector4f UseColor = ColorOverlay->GetElement(ElementID);
 
        if (bApplyVertexColorRemapping)
        {
            VertexColorRemappingFunc(UseColor);
        }
 
        if (ColorSpaceTransformMode == EDynamicMeshVertexColorTransformMode::SRGBToLinear)
        {
            // is there a better way to do this? 
            FColor QuantizedSRGBColor = ((FLinearColor)UseColor).ToFColor(false);
            return FLinearColor(QuantizedSRGBColor).ToFColor(false);
        }
        else
        {
            bool bConvertToSRGB = (ColorSpaceTransformMode == EDynamicMeshVertexColorTransformMode::LinearToSRGB);
            return ((FLinearColor)UseColor).ToFColor(bConvertToSRGB);
        }
    }
 
 
private:
    using FIndex2i = UE::Geometry::FIndex2i;
    using FIndex3i = UE::Geometry::FIndex3i;
    
};
 
 
// Simple tool to initialize a single set of mesh buffers for the entire mesh.  
// for examples of more complicated conversions, see DynamicMeshSceneProxy 
class FDynamicMeshComponentToMeshRenderBufferSet
{
 
public:
    FMeshRenderBufferSetConversionUtil MeshRenderBufferSetConverter;
 
    // note, this conversion may recompute the tangents on the DynamicMeshComponent 
    // since a dynamic mesh component with "autocalculated" tangents will compute them on first request
    // @param DynamicMeshComponent - the mesh to be converted
    // @param MeshRenderBufferSet  - the buffer set to be initialized
    // @param bUseComponentSettings - if true, the Component settings will override (and update)  MeshRederBufferSetBuilder.{ColorspaceTransformMode, bUsePerTriangleNormals}.
    GEOMETRYFRAMEWORK_API void Convert(class UDynamicMeshComponent& DynamicMeshComponent, FMeshRenderBufferSet& MeshRenderBufferSet, bool bUseComponentSettings = true);
 
protected:
    TUniqueFunction<void(int, int, int, const FVector3f&, FVector3f&, FVector3f&)> MakeTangentsFunc(class UDynamicMeshComponent& DynamicMeshCompnent, bool bSkipAutoCompute = false);
};
 
 
 
 
 
 
 
 
// -- template implementations -- // 
 
 
template<typename TriangleEnumerable, typename UVOverlayListAllocator>
void FMeshRenderBufferSetConversionUtil::InitializeBuffersFromOverlays( FMeshRenderBufferSet* RenderBuffers,
                                                                        const FDynamicMesh3* Mesh,
                                                                        int NumTriangles,
                                                                        const TriangleEnumerable& Enumerable,
                                                                        const TArray<const FDynamicMeshUVOverlay*, UVOverlayListAllocator>& UVOverlays,
                                                                        const FDynamicMeshNormalOverlay* NormalOverlay,
                                                                        const FDynamicMeshColorOverlay* ColorOverlay,
                                                                        TFunctionRef<void(int, int, int, const FVector3f&, FVector3f&, FVector3f&)> TangentsFunc,
                                                                        bool bTrackTriangles,
                                                                        bool bParallel)
 
{
    RenderBuffers->TriangleCount = NumTriangles;
    if (NumTriangles == 0)
    {
        return;
    }
 
    bool bHaveColors = (ColorOverlay != nullptr) && (bIgnoreVertexColors == false);
 
    const int NumVertices = NumTriangles * 3;
    const int NumUVOverlays = UVOverlays.Num();
    const int NumTexCoords = FMath::Max(1, NumUVOverlays);      // must have at least one tex coord
 
    {
        RenderBuffers->PositionVertexBuffer.Init(NumVertices);
        RenderBuffers->StaticMeshVertexBuffer.Init(NumVertices, NumTexCoords);
        RenderBuffers->ColorVertexBuffer.Init(NumVertices);
        RenderBuffers->IndexBuffer.Indices.AddUninitialized(NumTriangles * 3);
    }
 
    // build triangle list if requested, or if we are using secondary buffers in which case we need it to filter later
    const bool bBuildTriangleList = bTrackTriangles || bUseSecondaryTriBuffers;
 
    // populate the triangle array.  we use this for parallelism. 
    TArray<int32> TriangleArray;
    {
        TriangleArray.Reserve(NumTriangles);
        for (int TriangleID : Enumerable)
        {
            TriangleArray.Add(TriangleID);
        }
    }
 
    TArray<uint32>& IndexBuffer = RenderBuffers->IndexBuffer.Indices;
    {
        // populate the index buffer.
        for (int idx = 0, IdxMax = 3 * NumTriangles; idx < IdxMax; ++idx)
        {
            IndexBuffer[idx] = idx;
        }
    }
 
 
    ParallelFor(TriangleArray.Num(), [&](int idx)
    {
        int32 TriangleID = TriangleArray[idx];
        FIndex3i Tri = Mesh->GetTriangle(TriangleID);
 
    
        FIndex3i TriNormal = (NormalOverlay != nullptr) ? NormalOverlay->GetTriangle(TriangleID) : FIndex3i::Zero();
        FIndex3i TriColor = (ColorOverlay != nullptr) ? ColorOverlay->GetTriangle(TriangleID) : FIndex3i::Zero();
 
        FColor UniformTriColor = ConstantVertexColor;
        if (bUsePerTriangleColor && PerTriangleColorFunc != nullptr)
        {
            UniformTriColor = PerTriangleColorFunc(Mesh, TriangleID);
            bHaveColors = false;
        }
 
        int32 VertIdx = idx * 3;
        for (int j = 0; j < 3; ++j)
        {
            RenderBuffers->PositionVertexBuffer.VertexPosition(VertIdx) = (FVector3f)Mesh->GetVertex(Tri[j]);
 
            FVector3f Normal;
            if (bUsePerTriangleNormals)
            {
                Normal = (FVector3f)Mesh->GetTriNormal(TriangleID);
            }
            else
            {
                Normal = (NormalOverlay != nullptr && TriNormal[j] != FDynamicMesh3::InvalidID) ?
                    NormalOverlay->GetElement(TriNormal[j]) : Mesh->GetVertexNormal(Tri[j]);
            }
 
            // get tangents
            FVector3f TangentX, TangentY;
            TangentsFunc(Tri[j], TriangleID, j, Normal, TangentX, TangentY);
 
            RenderBuffers->StaticMeshVertexBuffer.SetVertexTangents(VertIdx, TangentX, TangentY, Normal);
 
            FColor VertexFColor = (bHaveColors && TriColor[j] != FDynamicMesh3::InvalidID) ?
                GetOverlayColorAsFColor(ColorOverlay, TriColor[j]) : UniformTriColor;
 
            RenderBuffers->ColorVertexBuffer.VertexColor(VertIdx) = VertexFColor;
 
            VertIdx++;
        }
 
        for (int32 k = 0; k < NumTexCoords; ++k)
        {
            VertIdx = idx * 3;
            FIndex3i UVTriangle = (k < NumUVOverlays && UVOverlays[k] != nullptr) ? UVOverlays[k]->GetTriangle(TriangleID) : FIndex3i::Invalid();
            for (int j = 0; j < 3; ++j)
            {
                FVector2f UV = (UVTriangle[j] != FDynamicMesh3::InvalidID) ?
                    UVOverlays[k]->GetElement(UVTriangle[j]) : FVector2f::Zero();
                RenderBuffers->StaticMeshVertexBuffer.SetVertexUV(VertIdx, k, UV);
                VertIdx++;
            }
        }
    }, !bParallel);
 
    if (bBuildTriangleList)
    {
        RenderBuffers->Triangles = MoveTemp(TriangleArray);
    }
 
    // split triangles into secondary buffer (at bit redundant since we just built IndexBuffer, but we may optionally duplicate triangles in the future)
    if (bUseSecondaryTriBuffers)
    {
        RenderBuffers->bEnableSecondaryIndexBuffer = true;
        UpdateSecondaryTriangleBuffer(RenderBuffers, Mesh, false);
    }
}
 
 
template<typename TriangleEnumerable>
void FMeshRenderBufferSetConversionUtil::UpdateVertexBuffersFromOverlays(  FMeshRenderBufferSet* RenderBuffers,
                                                                           const FDynamicMesh3* Mesh,
                                                                           int NumTriangles, const TriangleEnumerable& Enumerable,
                                                                           const FDynamicMeshNormalOverlay* NormalOverlay,
                                                                           const FDynamicMeshColorOverlay* ColorOverlay,
                                                                           TFunctionRef<void(int, int, int, const FVector3f&, FVector3f&, FVector3f&)> TangentsFunc,
                                                                           bool bUpdatePositions,
                                                                           bool bUpdateNormals,
                                                                           bool bUpdateColors)
{
    if (RenderBuffers->TriangleCount == 0)
    {
        return;
    }
 
    bool bHaveColors = (ColorOverlay != nullptr) && (bIgnoreVertexColors == false);
 
    int NumVertices = NumTriangles * 3;
    if ((bUpdatePositions && ensure(RenderBuffers->PositionVertexBuffer.GetNumVertices() == NumVertices) == false)
        || (bUpdateNormals && ensure(RenderBuffers->StaticMeshVertexBuffer.GetNumVertices() == NumVertices) == false)
        || (bUpdateColors && ensure(RenderBuffers->ColorVertexBuffer.GetNumVertices() == NumVertices) == false))
    {
        return;
    }
 
    int VertIdx = 0;
    FVector3f TangentX, TangentY;
    for (int TriangleID : Enumerable)
    {
        FIndex3i Tri = Mesh->GetTriangle(TriangleID);
 
        FIndex3i TriNormal = (bUpdateNormals && NormalOverlay != nullptr) ? NormalOverlay->GetTriangle(TriangleID) : FIndex3i::Zero();
        FIndex3i TriColor = (bUpdateColors && ColorOverlay != nullptr) ? ColorOverlay->GetTriangle(TriangleID) : FIndex3i::Zero();
 
        FColor UniformTriColor = ConstantVertexColor;
        if (bUpdateColors && bUsePerTriangleColor && PerTriangleColorFunc != nullptr)
        {
            UniformTriColor = PerTriangleColorFunc(Mesh, TriangleID);
            bHaveColors = false;
        }
 
        for (int j = 0; j < 3; ++j)
        {
            if (bUpdatePositions)
            {
                RenderBuffers->PositionVertexBuffer.VertexPosition(VertIdx) = (FVector3f)Mesh->GetVertex(Tri[j]);
            }
 
            if (bUpdateNormals)
            {
                // get normal and tangent
                FVector3f Normal;
                if (bUsePerTriangleNormals)
                {
                    Normal = (FVector3f)Mesh->GetTriNormal(TriangleID);
                }
                else
                {
                    Normal = (NormalOverlay != nullptr && TriNormal[j] != FDynamicMesh3::InvalidID) ?
                        NormalOverlay->GetElement(TriNormal[j]) : Mesh->GetVertexNormal(Tri[j]);
                }
 
                TangentsFunc(Tri[j], TriangleID, j, Normal, TangentX, TangentY);
 
                RenderBuffers->StaticMeshVertexBuffer.SetVertexTangents(VertIdx, (FVector3f)TangentX, (FVector3f)TangentY, (FVector3f)Normal);
            }
 
            if (bUpdateColors)
            {
                FColor VertexFColor = (bHaveColors && TriColor[j] != FDynamicMesh3::InvalidID) ?
                    GetOverlayColorAsFColor(ColorOverlay, TriColor[j]) : UniformTriColor;
                RenderBuffers->ColorVertexBuffer.VertexColor(VertIdx) = VertexFColor;
            }
 
            VertIdx++;
        }
    }
}
 
template<typename TriangleEnumerable, typename UVOverlayListAllocator>
void FMeshRenderBufferSetConversionUtil::UpdateVertexUVBufferFromOverlays( FMeshRenderBufferSet* RenderBuffers,
                                                                           const FDynamicMesh3* Mesh,
                                                                           int32 NumTriangles, const TriangleEnumerable& Enumerable,
                                                                           const TArray<const FDynamicMeshUVOverlay*, UVOverlayListAllocator>& UVOverlays)
{
    // We align the update to the way we set UV's in InitializeBuffersFromOverlays.
 
    if (RenderBuffers->TriangleCount == 0)
    {
        return;
    }
    int NumVertices = NumTriangles * 3;
    if (ensure(RenderBuffers->StaticMeshVertexBuffer.GetNumVertices() == NumVertices) == false)
    {
        return;
    }
 
    int NumUVOverlays = UVOverlays.Num();
    int NumTexCoords = RenderBuffers->StaticMeshVertexBuffer.GetNumTexCoords();
    if (!ensure(NumUVOverlays <= NumTexCoords))
    {
        return;
    }
 
    // Temporarily stores the UV element indices for all UV channels of a single triangle
    TArray<FIndex3i, TFixedAllocator<MAX_STATIC_TEXCOORDS>> UVTriangles;
    UVTriangles.SetNum(NumTexCoords);
 
    int VertIdx = 0;
    for (int TriangleID : Enumerable)
    {
        for (int32 k = 0; k < NumTexCoords; ++k)
        {
            UVTriangles[k] = (k < NumUVOverlays && UVOverlays[k] != nullptr) ? UVOverlays[k]->GetTriangle(TriangleID) : FIndex3i::Invalid();
        }
 
        for (int j = 0; j < 3; ++j)
        {
            for (int32 k = 0; k < NumTexCoords; ++k)
            {
                FVector2f UV = (UVTriangles[k][j] != FDynamicMesh3::InvalidID) ?
                    UVOverlays[k]->GetElement(UVTriangles[k][j]) : FVector2f::Zero();
                RenderBuffers->StaticMeshVertexBuffer.SetVertexUV(VertIdx, k, UV);
            }
 
            ++VertIdx;
        }
    }
}