DynamicRHIResourceArray.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/UnrealTypeTraits.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Array.h"
#include "CoreGlobals.h"
#include "Containers/ResourceArray.h"
#include "Serialization/MemoryImage.h"
 
enum EResourceAlignment
{
    VERTEXBUFFER_ALIGNMENT  =DEFAULT_ALIGNMENT,
    INDEXBUFFER_ALIGNMENT   =DEFAULT_ALIGNMENT
};
 
template< typename ElementType, uint32 Alignment = DEFAULT_ALIGNMENT>
class TResourceArray
    :   public FResourceArrayInterface
    ,   public TArray<ElementType, TMemoryImageAllocator<Alignment>>
{
    using ParentArrayType = TArray<ElementType, TMemoryImageAllocator<Alignment>>;
    DECLARE_INLINE_TYPE_LAYOUT_EXPLICIT_BASES(TResourceArray, Virtual, FResourceArrayInterface, ParentArrayType);
public:
    using Super = ParentArrayType;
 
    [[nodiscard]] explicit TResourceArray(bool InNeedsCPUAccess=false)
        :   Super()
        ,   bNeedsCPUAccess(InNeedsCPUAccess)
    {
    }
 
    [[nodiscard]] TResourceArray(TResourceArray&&) = default;
    [[nodiscard]] TResourceArray(const TResourceArray&) = default;
    TResourceArray& operator=(TResourceArray&&) = default;
    TResourceArray& operator=(const TResourceArray&) = default;
 
    virtual ~TResourceArray() = default;
 
 
    // FResourceArrayInterface
 
    [[nodiscard]] virtual const void* GetResourceData() const override
    { 
        return &(*this)[0]; 
    }
 
    [[nodiscard]] virtual uint32 GetResourceDataSize() const override
    {
        if (this->Num() > UINT32_MAX / sizeof(ElementType))
        {
            UE_LOG(LogCore, Fatal, TEXT("Resource data size too large for uint32, will overflow. Calculate with larger data type or use fewer elements. sizeof(ElementType): %" SIZE_T_FMT), sizeof(ElementType));
            return 0;
        }
        return this->Num() * sizeof(ElementType);
    }
 
    virtual void Discard() override
    {
        if(!bNeedsCPUAccess && FPlatformProperties::RequiresCookedData() && !IsRunningCommandlet())
        {
            this->Empty();
        }
    }
 
    [[nodiscard]] virtual bool IsStatic() const override
    {
        return false;
    }
 
    [[nodiscard]] virtual bool GetAllowCPUAccess() const override
    {
        return bNeedsCPUAccess;
    }
 
    virtual void SetAllowCPUAccess(bool bInNeedsCPUAccess) override
    {
        bNeedsCPUAccess = bInNeedsCPUAccess;
    }
 
    // Assignment operators.
    TResourceArray& operator=(const Super& Other)
    {
        Super::operator=(Other);
        return *this;
    }
 
    void BulkSerialize(FArchive& Ar, bool bForcePerElementSerialization = false)
    {
        Super::BulkSerialize(Ar, bForcePerElementSerialization);
    }
 
private:
    LAYOUT_FIELD(bool, bNeedsCPUAccess);
};
 
template<typename ElementType, uint32 Alignment>
FArchive& operator<<(FArchive& Ar,TResourceArray<ElementType,Alignment>& ResourceArray)
{
    return Ar << *(typename TResourceArray<ElementType,Alignment>::Super*)&ResourceArray;
}