ColorVertexBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "RenderResource.h"
#include "StaticMeshVertexData.h"
#include "RHI.h"
 
struct FStaticMeshBuildVertex;
struct FConstMeshBuildVertexView;
 
class FColorVertexBuffer : public FVertexBuffer
{
public:
    enum class NullBindStride
    {
        FColorSizeForComponentOverride, //when we want to bind null buffer with the expectation that it must be overridden.  Stride must be correct so override binds correctly
        ZeroForDefaultBufferBind, //when we want to bind the null color buffer for it to actually be used for draw.  Stride must be 0 so the IA gives correct data for all verts.
    };
 
    ENGINE_API FColorVertexBuffer();
 
    ENGINE_API ~FColorVertexBuffer();
 
    ENGINE_API void CleanUp();
 
    ENGINE_API void Init(uint32 InNumVertices, bool bNeedsCPUAccess = true);
 
    ENGINE_API void Init(const TArray<FStaticMeshBuildVertex>& InVertices, bool bNeedsCPUAccess = true);
    ENGINE_API void Init(const FConstMeshBuildVertexView& InVertices, bool bNeedsCPUAccess = true);
 
    void Init(const FColorVertexBuffer& InVertexBuffer, bool bNeedsCPUAccess = true);
    
    ENGINE_API bool AppendVertices( const FStaticMeshBuildVertex* Vertices, const uint32 NumVerticesToAppend );
    
    ENGINE_API void Serialize(FArchive& Ar, bool bNeedsCPUAccess);
 
    void SerializeMetaData(FArchive& Ar);
 
    ENGINE_API void SetMetaData(uint32 InStride, uint32 InNumVertices);
 
    void ClearMetaData();
 
    void ExportText(FString &ValueStr) const;
 
    void ImportText(const TCHAR* SourceText);
 
    ENGINE_API void operator=(const FColorVertexBuffer &Other);
 
    inline FColor& VertexColor(uint32 VertexIndex)
    {
        checkSlow(VertexIndex < GetNumVertices());
        return *(FColor*)(Data + VertexIndex * Stride);
    }
 
    inline const FColor& VertexColor(uint32 VertexIndex) const
    {
        checkSlow(VertexIndex < GetNumVertices());
        return *(FColor*)(Data + VertexIndex * Stride);
    }
 
    // Other accessors.
    inline uint32 GetStride() const
    {
        return Stride;
    }
    inline uint32 GetNumVertices() const
    {
        return NumVertices;
    }
    ENGINE_API bool GetAllowCPUAccess() const;
 
    ENGINE_API uint32 GetAllocatedSize() const;
 
    ENGINE_API void GetVertexColors(TArray<FColor>& OutColors) const;
 
    ENGINE_API void InitFromColorArray(const FColor *InColors, uint32 Count, uint32 Stride = sizeof(FColor), bool bNeedsCPUAccess = true);
 
    void InitFromColorArray(const TArray<FColor> &InColors)
    {
        InitFromColorArray(InColors.GetData(), InColors.Num());
    }
 
    void InitFromSingleColor(const FColor &InColor, uint32 Count)
    {
        InitFromColorArray(&InColor, Count, 0);
    }
 
    FBufferRHIRef CreateRHIBuffer(FRHICommandListBase& RHICmdList);
 
    void InitRHIForStreaming(FRHIBuffer* IntermediateBuffer, FRHIResourceReplaceBatcher& Batcher);
    void ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher);
 
    // FRenderResource interface.
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    ENGINE_API virtual void ReleaseRHI() override;
    virtual FString GetFriendlyName() const override { return TEXT("ColorOnly Mesh Vertices"); }
 
    ENGINE_API void BindColorVertexBuffer(const class FVertexFactory* VertexFactory, struct FStaticMeshDataType& StaticMeshData) const;
    ENGINE_API static void BindDefaultColorVertexBuffer(const class FVertexFactory* VertexFactory, struct FStaticMeshDataType& StaticMeshData, NullBindStride BindStride);
 
    inline FRHIShaderResourceView* GetColorComponentsSRV() const { return ColorComponentsSRV; }
 
    void* GetVertexData() { return Data; }
    const void* GetVertexData() const { return Data; }
 
private:
 
    class FColorVertexData* VertexData;
 
    FShaderResourceViewRHIRef ColorComponentsSRV;
 
    uint8* Data;
 
    uint32 Stride;
 
    uint32 NumVertices;
 
    bool NeedsCPUAccess = true;
 
    void AllocateData(bool bNeedsCPUAccess = true);
 
    ENGINE_API FColorVertexBuffer(const FColorVertexBuffer &rhs);
};