RHIUniformBufferLayoutInitializer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "RHIDefinitions.h"
#include "RHIMemoryLayout.h"
#include "RHIResources.h"
#include "Serialization/MemoryImage.h"
#include "Serialization/MemoryLayout.h"
 
struct FRHIUniformBufferResourceInitializer
{
    DECLARE_EXPORTED_TYPE_LAYOUT(FRHIUniformBufferResourceInitializer, RHI_API, NonVirtual);
 
    LAYOUT_FIELD(uint16, MemberOffset);
 
    LAYOUT_FIELD(EUniformBufferBaseType, MemberType);
 
    friend inline bool operator==(const FRHIUniformBufferResourceInitializer& A, const FRHIUniformBufferResourceInitializer& B)
    {
        return A.MemberOffset == B.MemberOffset
            && A.MemberType == B.MemberType;
    }
};
 
inline FArchive& operator<<(FArchive& Ar, FRHIUniformBufferResourceInitializer& Ref)
{
    uint8 Type = (uint8)Ref.MemberType;
    Ar << Ref.MemberOffset;
    Ar << Type;
    Ref.MemberType = (EUniformBufferBaseType)Type;
    return Ar;
}
 
struct FRHIUniformBufferLayoutInitializer
{
    DECLARE_EXPORTED_TYPE_LAYOUT(FRHIUniformBufferLayoutInitializer, RHI_API, NonVirtual);
 
    FRHIUniformBufferLayoutInitializer() = default;
 
    explicit FRHIUniformBufferLayoutInitializer(const TCHAR* InName)
        : Name(InName)
    {}
    explicit FRHIUniformBufferLayoutInitializer(const TCHAR* InName, uint32 InConstantBufferSize)
        : Name(InName)
        , ConstantBufferSize(InConstantBufferSize)
    {
        ComputeHash();
    }
 
    inline uint32 GetHash() const
    {
        checkSlow(Hash != 0);
        return Hash;
    }
 
    void ComputeHash()
    {
        uint32 TmpHash = 0;
 
        TmpHash |= (ConstantBufferSize << 16);
        TmpHash |= (static_cast<uint32>(BindingFlags) << 8);
 
        // Static slot is not stable. Just track whether we have one at all.
        TmpHash |= (StaticSlot != MAX_UNIFORM_BUFFER_STATIC_SLOTS ? 1 << 0 : 0);
 
        // These flags aren't based on the resources, so make sure they change the hash
        TmpHash |= (EnumHasAnyFlags(Flags, ERHIUniformBufferFlags::NoEmulatedUniformBuffer) ? 1 << 1 : 0);
        TmpHash |= (EnumHasAnyFlags(Flags, ERHIUniformBufferFlags::NeedsReflectedMembers)   ? 1 << 2 : 0);
        TmpHash |= (EnumHasAnyFlags(Flags, ERHIUniformBufferFlags::UniformView)             ? 1 << 3 : 0);
 
        for (int32 ResourceIndex = 0; ResourceIndex < Resources.Num(); ResourceIndex++)
        {
            // Offset and therefore hash must be the same regardless of pointer size
            checkSlow(Resources[ResourceIndex].MemberOffset == Align(Resources[ResourceIndex].MemberOffset, SHADER_PARAMETER_POINTER_ALIGNMENT));
            TmpHash ^= Resources[ResourceIndex].MemberOffset;
        }
 
        uint32 N = Resources.Num();
        while (N >= 4)
        {
            TmpHash ^= (Resources[--N].MemberType << 0);
            TmpHash ^= (Resources[--N].MemberType << 8);
            TmpHash ^= (Resources[--N].MemberType << 16);
            TmpHash ^= (Resources[--N].MemberType << 24);
        }
        while (N >= 2)
        {
            TmpHash ^= Resources[--N].MemberType << 0;
            TmpHash ^= Resources[--N].MemberType << 16;
        }
        while (N > 0)
        {
            TmpHash ^= Resources[--N].MemberType;
        }
 
        // Name is necessary to distinguish different uniform buffer declarations with matching layouts.
        // Without it FindUniformBufferStructByLayoutHash() is vulnerable to hash collisions.
        TmpHash ^= FCrc::StrCrc32(*Name);
        
        Hash = TmpHash;
    }
 
    void CopyFrom(const FRHIUniformBufferLayoutInitializer& Source)
    {
        ConstantBufferSize = Source.ConstantBufferSize;
        StaticSlot = Source.StaticSlot;
        BindingFlags = Source.BindingFlags;
        Flags = Source.Flags;
        Resources = Source.Resources;
        Name = Source.Name;
        Hash = Source.Hash;
    }
 
    const FMemoryImageString& GetDebugName() const
    {
        return Name;
    }
 
    bool HasRenderTargets() const
    {
        return RenderTargetsOffset != kUniformBufferInvalidOffset;
    }
 
    bool HasStaticSlot() const
    {
        return IsUniformBufferStaticSlotValid(StaticSlot);
    }
 
    friend FArchive& operator<<(FArchive& Ar, FRHIUniformBufferLayoutInitializer& Ref)
    {
        Ar << Ref.ConstantBufferSize;
        Ar << Ref.StaticSlot;
        Ar << Ref.RenderTargetsOffset;
        Ar << Ref.BindingFlags;
        Ar << Ref.Flags;
        Ar << Ref.Resources;
        Ar << Ref.GraphResources;
        Ar << Ref.GraphTextures;
        Ar << Ref.GraphBuffers;
        Ar << Ref.GraphUniformBuffers;
        Ar << Ref.UniformBuffers;
        Ar << Ref.Name;
        Ar << Ref.Hash;
        return Ar;
    }
 
private:
    // for debugging / error message
    LAYOUT_FIELD(FMemoryImageString, Name);
 
public:
    LAYOUT_FIELD(TMemoryImageArray<FRHIUniformBufferResourceInitializer>, Resources);
 
    LAYOUT_FIELD(TMemoryImageArray<FRHIUniformBufferResourceInitializer>, GraphResources);
 
    LAYOUT_FIELD(TMemoryImageArray<FRHIUniformBufferResourceInitializer>, GraphTextures);
 
    LAYOUT_FIELD(TMemoryImageArray<FRHIUniformBufferResourceInitializer>, GraphBuffers);
 
    LAYOUT_FIELD(TMemoryImageArray<FRHIUniformBufferResourceInitializer>, GraphUniformBuffers);
 
    LAYOUT_FIELD(TMemoryImageArray<FRHIUniformBufferResourceInitializer>, UniformBuffers);
 
private:
    LAYOUT_FIELD_INITIALIZED(uint32, Hash, 0);
 
public:
    LAYOUT_FIELD_INITIALIZED(uint32, ConstantBufferSize, 0);
 
    LAYOUT_FIELD_INITIALIZED(uint16, RenderTargetsOffset, kUniformBufferInvalidOffset);
 
    LAYOUT_FIELD_INITIALIZED(FUniformBufferStaticSlot, StaticSlot, MAX_UNIFORM_BUFFER_STATIC_SLOTS);
 
    LAYOUT_FIELD_INITIALIZED(EUniformBufferBindingFlags, BindingFlags, EUniformBufferBindingFlags::Shader);
 
    LAYOUT_FIELD_INITIALIZED(ERHIUniformBufferFlags, Flags, ERHIUniformBufferFlags::None);
    
    friend inline bool operator==(const FRHIUniformBufferLayoutInitializer& A, const FRHIUniformBufferLayoutInitializer& B)
    {
        return A.ConstantBufferSize == B.ConstantBufferSize
            && A.StaticSlot == B.StaticSlot
            && A.BindingFlags == B.BindingFlags
            && A.Resources == B.Resources;
    }
};