RawIndexBuffer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    RawIndexBuffer.h: Raw index buffer definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "RHI.h"
#include "RHICommandList.h"
#include "RenderResource.h"
#include "Containers/DynamicRHIResourceArray.h"
 
 
class FRawIndexBuffer : public FIndexBuffer
{
public:
 
    TArray<uint16> Indices;
 
    void CacheOptimize();
 
    // FRenderResource interface.
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    // Serialization.
    friend FArchive& operator<<(FArchive& Ar,FRawIndexBuffer& I);
};
 
 
class FRawIndexBuffer16or32 : public FIndexBuffer
{
public:
    FRawIndexBuffer16or32()
        : b32Bit(true)
    {
    }
 
    TArray<uint32> Indices;
 
    void CacheOptimize();
 
    void ComputeIndexWidth();
 
    void ForceUse32Bit(bool bIn32Bit) { b32Bit = bIn32Bit; }
 
    // FRenderResource interface.
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    // Serialization.
    friend FArchive& operator<<(FArchive& Ar,FRawIndexBuffer16or32& I);
 
private:
    bool b32Bit;
};
 
namespace EIndexBufferStride
{
    enum Type
    {
        Force16Bit = 1,
        Force32Bit = 2,
        AutoDetect = 3
    };
}
 
class FIndexArrayView
{
public:
    FIndexArrayView()
        : UntypedIndexData(nullptr)
        , NumIndices(0)
        , b32Bit(false)
    {
    }
 
    FIndexArrayView(const void* InIndexData, int32 InNumIndices, bool bIn32Bit)
        : UntypedIndexData(InIndexData)
        , NumIndices(InNumIndices)
        , b32Bit(bIn32Bit)
    {
    }
 
    uint32 operator[](int32 i) { return (uint32)(b32Bit ? ((const uint32*)UntypedIndexData)[i] : ((const uint16*)UntypedIndexData)[i]); }
    uint32 operator[](int32 i) const { return (uint32)(b32Bit ? ((const uint32*)UntypedIndexData)[i] : ((const uint16*)UntypedIndexData)[i]); }
    inline int32 Num() const { return NumIndices; }
 
private:
    const void* UntypedIndexData;
    int32 NumIndices;
    bool b32Bit;
};
 
class FRawStaticIndexBuffer : public FIndexBuffer
{
public: 
    ENGINE_API FRawStaticIndexBuffer(bool InNeedsCPUAccess=false);
    ENGINE_API virtual ~FRawStaticIndexBuffer();
 
    bool TrySetAllowCPUAccess(bool bAllowCPUAccess)
    {
        IndexStorage.SetAllowCPUAccess(bAllowCPUAccess);
 
        return !bAllowCPUAccess || CachedNumIndices == 0 || IndexStorage.Num() > 0;
    }
 
    inline void SetIndex( const uint32 At, const uint32 NewIndexValue )
    {
        check( At >= 0 && At < (uint32)IndexStorage.Num() );
 
        if( b32Bit )
        {
            uint32* Indices32Bit = (uint32*)IndexStorage.GetData();
            Indices32Bit[ At ] = NewIndexValue;
        }
        else
        {
            uint16* Indices16Bit = (uint16*)IndexStorage.GetData();
            Indices16Bit[ At ] = (uint16)NewIndexValue;
        }
    }
 
    ENGINE_API void SetIndices(const TArray<uint32>& InIndices, EIndexBufferStride::Type DesiredStride);
 
    ENGINE_API void InsertIndices( const uint32 At, const uint32* IndicesToAppend, const uint32 NumIndicesToAppend );
 
    ENGINE_API void AppendIndices( const uint32* IndicesToAppend, const uint32 NumIndicesToAppend );
 
    inline uint32 GetIndex( const uint32 At ) const
    {
        check( At >= 0 && At < (uint32)IndexStorage.Num() );
        uint32 IndexValue;
        if( b32Bit )
        {
            const uint32* SrcIndices32Bit = (const uint32*)IndexStorage.GetData();
            IndexValue = SrcIndices32Bit[ At ];
        }
        else
        {
            const uint16* SrcIndices16Bit = (const uint16*)IndexStorage.GetData();
            IndexValue = SrcIndices16Bit[ At ];
        }
 
        return IndexValue;
    }
 
 
    ENGINE_API void RemoveIndicesAt( const uint32 At, const uint32 NumIndicesToRemove );
 
    ENGINE_API void GetCopy(TArray<uint32>& OutIndices) const;
 
    void ExpandTo32Bit();
 
    ENGINE_API const uint16* AccessStream16() const;
 
    ENGINE_API const uint32* AccessStream32() const;
 
    ENGINE_API FIndexArrayView GetArrayView() const;
 
    inline int32 GetNumIndices() const
    {
        return CachedNumIndices >= 0 ? CachedNumIndices : (b32Bit ? (IndexStorage.Num()/4) : (IndexStorage.Num()/2));
    }
 
    inline SIZE_T GetAllocatedSize() const
    {
        return IndexStorage.GetAllocatedSize();
    }
 
    inline bool GetAllowCPUAccess() const
    {
        return IndexStorage.GetAllowCPUAccess();
    }
 
    int32 GetIndexDataSize() const { return IndexStorage.Num(); }
 
    FBufferRHIRef CreateRHIBuffer(FRHICommandListBase& RHICmdList);
 
    void InitRHIForStreaming(FRHIBuffer* IntermediateBuffer, FRHIResourceReplaceBatcher& Batcher);
 
    void ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher);
 
    ENGINE_API void Serialize(FArchive& Ar, bool bNeedsCPUAccess);
 
    void SerializeMetaData(FArchive& Ar);
 
    void ClearMetaData();
 
    void Discard();
    
    // FRenderResource interface.
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    inline bool Is32Bit() const { return b32Bit; }
 
private:
    TResourceArray<uint8, INDEXBUFFER_ALIGNMENT> IndexStorage;
 
    int32 CachedNumIndices;
 
    bool b32Bit;
};
 
class FRawStaticIndexBuffer16or32Interface : public FIndexBuffer
{
public:
    virtual void Serialize( FArchive& Ar ) = 0;
 
    virtual void SerializeMetaData(FArchive& Ar) = 0;
 
    virtual void SetMetaData(int32 InCachedNumIndices) = 0;
 
    virtual bool GetNeedsCPUAccess() const = 0;
    // number of indices (e.g. 4 triangles would result in 12 elements)
    virtual int32 Num() const = 0;
    virtual int32 AddItem(uint32 Val) = 0;
    virtual uint32 Get(uint32 Idx) const = 0;
    virtual void* GetPointerTo(uint32 Idx) = 0;
    virtual void Insert(int32 Idx, int32 Num = 1) = 0;
    virtual void Remove(int32 Idx, int32 Num = 1) = 0;
    virtual void Empty(int32 Slack = 0) = 0;
    virtual int32 GetResourceDataSize() const = 0;
 
    // @param guaranteed only to be valid if the vertex buffer is valid and the buffer was created with the SRV flags
    FRHIShaderResourceView* GetSRV() const
    {
        return SRVValue;
    }
 
    // Allows for creating SRV on demand
    // Note: consider cache the SRV locally if multiple compute tasks all need access to one in a single frame
    virtual FShaderResourceViewRHIRef GetOrCreateSRV(FRHICommandListBase& RHICmdList) const = 0;
 
protected:
    ENGINE_API bool IsSRVCreatedByDefault(bool bAllowCPUAccess) const;
    ENGINE_API bool IsShaderResource(bool bAllowCPUAccess) const;
 
    UE_DEPRECATED(5.7, "Use IsSRVCreatedByDefault or IsShaderResource instead, which gives more granular control over platform specific behavior")  
    ENGINE_API bool IsSRVNeeded(bool bAllowCPUAccess) const;
    
    void InitRHIForStreaming(FRHIBuffer* IntermediateBuffer, size_t IndexSize, FRHIResourceReplaceBatcher& Batcher);
    void ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher);
 
    static ENGINE_API FBufferRHIRef CreateRHIIndexBufferInternal(
        FRHICommandListBase& RHICmdList,
        const TCHAR* InDebugName,
        const FName& InOwnerName,
        int32 IndexCount,
        size_t IndexSize,
        FResourceArrayInterface* ResourceArray,
        bool bIsShaderResource
    );
 
    // guaranteed only to be valid if the vertex buffer is valid and the buffer was created with the SRV flags
    FShaderResourceViewRHIRef SRVValue;
};
 
template <typename INDEX_TYPE>
class FRawStaticIndexBuffer16or32 : public FRawStaticIndexBuffer16or32Interface
{
public: 
    FRawStaticIndexBuffer16or32(bool InNeedsCPUAccess=false)
        : Indices(InNeedsCPUAccess)
        , CachedNumIndices(0)
    {
        static_assert(sizeof(INDEX_TYPE) == 2 || sizeof(INDEX_TYPE) == 4, "FRawStaticIndexBuffer16or32 must have a stride of 2 or 4 bytes.");
    }
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override
    {
        IndexBufferRHI = CreateRHIBuffer(RHICmdList);
 
        if (IsSRVCreatedByDefault(Indices.GetAllowCPUAccess()))
        {
            SRVValue = GetOrCreateSRV(RHICmdList);
        }
    }
    
    virtual void ReleaseRHI() override
    {
        FRawStaticIndexBuffer16or32Interface::ReleaseRHI();
 
        SRVValue.SafeRelease();
    }
 
    virtual FShaderResourceViewRHIRef GetOrCreateSRV(FRHICommandListBase& RHICmdList) const override
    {
        if (SRVValue.IsValid())
        {
            return SRVValue;
        }
        
        if (!IndexBufferRHI)
        {
            return {};
        }
        
        if (!IsShaderResource(Indices.GetAllowCPUAccess()))
        {
            return {};
        }
        
        FShaderResourceViewRHIRef ExternalSRV = RHICmdList.CreateShaderResourceView(
                IndexBufferRHI,
                FRHIViewDesc::CreateBufferSRV()
                    .SetType(FRHIViewDesc::EBufferType::Typed)
                    .SetFormat(sizeof(INDEX_TYPE) == 2 ? PF_R16_UINT : PF_R32_UINT));
        
        return ExternalSRV;
    }
    
    virtual void Serialize( FArchive& Ar ) override
    {
        Indices.BulkSerialize(Ar);
        CachedNumIndices = Indices.Num();
    }
 
    virtual void SerializeMetaData(FArchive& Ar) override
    {
        Ar << CachedNumIndices;
    }
 
    virtual void SetMetaData(int32 InCachedNumIndices) override
    {
        CachedNumIndices = InCachedNumIndices;
    }
 
    void CacheOptimize();
 
    
    virtual bool GetNeedsCPUAccess() const override { return Indices.GetAllowCPUAccess(); }
 
    virtual int32 Num() const override
    {
        return CachedNumIndices;
    }
 
    virtual int32 AddItem(uint32 Val) override
    {
        ++CachedNumIndices;
        return Indices.Add((INDEX_TYPE)Val);
    }
 
    virtual uint32 Get(uint32 Idx) const override
    {
        return (uint32)Indices[Idx];
    }
 
    virtual void* GetPointerTo(uint32 Idx) override
    {
        return (void*)(&Indices[Idx]);
    }
 
    virtual void Insert(int32 Idx, int32 Num) override
    {
        CachedNumIndices += Num;
        Indices.InsertUninitialized(Idx, Num);
        check(CachedNumIndices == Indices.Num());
    }
 
    virtual void Remove(int32 Idx, int32 Num) override
    {
        CachedNumIndices -= Num;
        Indices.RemoveAt(Idx, Num);
        check(CachedNumIndices == Indices.Num());
    }
 
    virtual void Empty(int32 Slack) override
    {
        Indices.Empty(Slack);
        CachedNumIndices = 0;
    }
 
    virtual int32 GetResourceDataSize() const override
    {
        return Indices.GetResourceDataSize();
    }
 
    virtual void AssignNewBuffer(const TArray<INDEX_TYPE>& Buffer)
    {
        using IndexBufferType = typename TResourceArray<INDEX_TYPE, INDEXBUFFER_ALIGNMENT>::Super;
        Indices = IndexBufferType(Buffer);
        CachedNumIndices = Indices.Num();
    }
 
    FBufferRHIRef CreateRHIBuffer(FRHICommandListBase& RHICmdList)
    {
        if (CachedNumIndices)
        {
            // Need to cache number of indices from the source array *before* RHICreateBuffer is called
            // because it will empty the source array.
            CachedNumIndices = Indices.Num();
 
            return CreateRHIIndexBufferInternal(
                RHICmdList,
                sizeof(INDEX_TYPE) == 4 ? TEXT("FRawStaticIndexBuffer32") : TEXT("FRawStaticIndexBuffer16"),
                GetOwnerName(),
                Indices.Num(),
                sizeof(INDEX_TYPE),
                &Indices,
                IsShaderResource(Indices.GetAllowCPUAccess())
            );
        }
        return nullptr;
    }
 
    void InitRHIForStreaming(FRHIBuffer* IntermediateBuffer, FRHIResourceReplaceBatcher& Batcher)
    {
        FRawStaticIndexBuffer16or32Interface::InitRHIForStreaming(IntermediateBuffer, sizeof(INDEX_TYPE), Batcher);
    }
 
    void ReleaseRHIForStreaming(FRHIResourceReplaceBatcher& Batcher)
    {
        FRawStaticIndexBuffer16or32Interface::ReleaseRHIForStreaming(Batcher);
    }
 
private:
    TResourceArray<INDEX_TYPE,INDEXBUFFER_ALIGNMENT> Indices;
 
    int32 CachedNumIndices;
 
};