SkeletalMeshVertexBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "PackedNormal.h"
#include "Components.h"
#include "Containers/DynamicRHIResourceArray.h"
#include "Rendering/StaticMeshVertexBuffer.h"
#include "RenderMath.h"
 
struct FSoftSkinVertex;
 
struct TGPUSkinVertexBase
{
    // Tangent, U-direction
    FPackedNormal   TangentX;
    // Normal
    FPackedNormal   TangentZ;
 
    inline FVector3f GetTangentY() const
    {
        return FVector3f(GenerateYAxis(TangentX, TangentZ));
    }
 
    void Serialize(FArchive& Ar);
};
 
template<uint32 InNumTexCoords>
struct TGPUSkinVertexFloat16Uvs : public TGPUSkinVertexBase
{
    constexpr static uint32 NumTexCoords = InNumTexCoords;
    constexpr static EStaticMeshVertexUVType StaticMeshVertexUVType = EStaticMeshVertexUVType::Default;
 
    FVector3f           Position;
    FVector2DHalf   UVs[NumTexCoords];
 
    friend FArchive& operator<<(FArchive& Ar, TGPUSkinVertexFloat16Uvs& V)
    {
        V.Serialize(Ar);
        Ar << V.Position;
 
        for (uint32 UVIndex = 0; UVIndex < NumTexCoords; UVIndex++)
        {
            Ar << V.UVs[UVIndex];
        }
        return Ar;
    }
};
 
template<uint32 InNumTexCoords>
struct TGPUSkinVertexFloat32Uvs : public TGPUSkinVertexBase
{
    constexpr static uint32 NumTexCoords = InNumTexCoords;
    constexpr static EStaticMeshVertexUVType StaticMeshVertexUVType = EStaticMeshVertexUVType::HighPrecision;
 
    FVector3f           Position;
    FVector2f UVs[NumTexCoords];
 
    friend FArchive& operator<<(FArchive& Ar, TGPUSkinVertexFloat32Uvs& V)
    {
        V.Serialize(Ar);
        Ar << V.Position;
 
        for (uint32 UVIndex = 0; UVIndex < NumTexCoords; UVIndex++)
        {
            Ar << V.UVs[UVIndex];
        }
        return Ar;
    }
};
 
class FSkeletalMeshVertexDataInterface
{
public:
 
    virtual ~FSkeletalMeshVertexDataInterface() {}
 
    virtual void ResizeBuffer(uint32 NumVertices) = 0;
 
    virtual uint32 GetStride() const = 0;
 
    virtual uint8* GetDataPointer() = 0;
 
    virtual uint32 GetNumVertices() = 0;
 
    virtual FResourceArrayInterface* GetResourceArray() = 0;
 
    virtual void Serialize(FArchive& Ar) = 0;
};
 
 
template<typename VertexDataType>
class TSkeletalMeshVertexData :
    public FSkeletalMeshVertexDataInterface,
    public TResourceArray<VertexDataType, VERTEXBUFFER_ALIGNMENT>
{
public:
    typedef TResourceArray<VertexDataType, VERTEXBUFFER_ALIGNMENT> ArrayType;
 
    TSkeletalMeshVertexData(bool InNeedsCPUAccess = false)
        : TResourceArray<VertexDataType, VERTEXBUFFER_ALIGNMENT>(InNeedsCPUAccess)
    {
    }
 
    virtual void ResizeBuffer(uint32 NumVertices)
    {
        if ((uint32)ArrayType::Num() < NumVertices)
        {
            // Enlarge the array.
            ArrayType::Reserve(NumVertices);
            ArrayType::AddUninitialized(NumVertices - ArrayType::Num());
        }
        else if ((uint32)ArrayType::Num() > NumVertices)
        {
            // Shrink the array.
            ArrayType::RemoveAt(NumVertices, ArrayType::Num() - NumVertices);
        }
    }
    virtual uint32 GetStride() const
    {
        return sizeof(VertexDataType);
    }
    virtual uint8* GetDataPointer()
    {
        return (uint8*)&(*this)[0];
    }
    virtual uint32 GetNumVertices()
    {
        return ArrayType::Num();
    }
    virtual FResourceArrayInterface* GetResourceArray()
    {
        return this;
    }
    virtual void Serialize(FArchive& Ar)
    {
        ArrayType::BulkSerialize(Ar);
    }
    TSkeletalMeshVertexData<VertexDataType>& operator=(const TArray<VertexDataType>& Other)
    {
        ArrayType::operator=(TArray<VertexDataType, TAlignedHeapAllocator<VERTEXBUFFER_ALIGNMENT> >(Other));
        return *this;
    }
};
 
 
class FDummySkeletalMeshVertexBuffer
{
public:
    ~FDummySkeletalMeshVertexBuffer();
 
    friend FArchive& operator<<(FArchive& Ar, FDummySkeletalMeshVertexBuffer& VertexBuffer);
 
protected:
    // guaranteed only to be valid if the vertex buffer is valid
    FShaderResourceViewRHIRef SRVValue;
 
private:
    bool bUseFullPrecisionUVs = false;
    bool bNeedsCPUAccess = false;
    FSkeletalMeshVertexDataInterface* VertexData = nullptr;
    uint8* Data = nullptr;
    uint32 Stride = 0;
    uint32 NumVertices = 0;
    uint32 NumTexCoords = 0;
 
    void AllocateData();
 
    void CleanUp();
};