ShaderParameterMacros.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ShaderParameterMacros.h: Macros to builds shader parameter structures and
        their metadata.
=============================================================================*/
 
#pragma once
 
#include "ShaderParameterStructDeclaration.h"
#include "ShaderParameterMetadata.h"
#include "RenderGraphAllocator.h"
#include "Algo/Reverse.h"
#include "Templates/IsArrayOrRefOfTypeByPredicate.h"
#include "Traits/IsCharEncodingCompatibleWith.h"
#include "Misc/AlignedElement.h"
#include "Misc/AssertionMacros.h"
#include "RHICommandList.h"
#include "RenderGraphTextureSubresource.h"
 
PGO_LINK_DISABLE_WARNINGS
 
class FRDGTexture;
class FRDGTextureSRV;
class FRDGTextureUAV;
class FRDGBuffer;
class FRDGBufferSRV;
class FRDGBufferUAV;
class FRDGUniformBuffer;
enum class EShaderBindingLayoutFlags : uint8;
class FShaderBindingLayoutContainer;
template <typename TUniformStruct> class TRDGUniformBuffer;
 
template<typename T, int32 Alignment>
class TAlignedTypedef;
 
#define IMPLEMENT_ALIGNED_TYPE(Alignment) \
    template<typename T> \
    class TAlignedTypedef<T,Alignment> \
    { \
    public: \
        typedef MS_ALIGN(Alignment) T Type GCC_ALIGN(Alignment); \
    };
 
IMPLEMENT_ALIGNED_TYPE(1);
IMPLEMENT_ALIGNED_TYPE(2);
IMPLEMENT_ALIGNED_TYPE(4);
IMPLEMENT_ALIGNED_TYPE(8);
IMPLEMENT_ALIGNED_TYPE(16);
#undef IMPLEMENT_ALIGNED_TYPE
 
 
#if PLATFORM_64BITS
 
template<typename PtrType>
using TAlignedShaderParameterPtr = typename TAlignedTypedef<PtrType, SHADER_PARAMETER_POINTER_ALIGNMENT>::Type;
 
static_assert(sizeof(void*) == 8, "Wrong PLATFORM_64BITS settings.");
 
#else 
 
template<typename PtrType>
class alignas(SHADER_PARAMETER_POINTER_ALIGNMENT) TAlignedShaderParameterPtr
{
public:
    TAlignedShaderParameterPtr()
    { }
 
    TAlignedShaderParameterPtr(const PtrType& Other)
        : Ref(Other)
    { }
 
    TAlignedShaderParameterPtr(const TAlignedShaderParameterPtr<PtrType>& Other)
        : Ref(Other.Ref)
    { }
 
    inline void operator=(const PtrType& Other)
    {
        Ref = Other;
    }
 
    inline operator PtrType&()
    {
        return Ref;
    }
 
    inline operator const PtrType&() const
    {
        return Ref;
    }
 
    inline const PtrType& operator->() const
    {
        return Ref;
    }
 
private:
    PtrType Ref;
    #if !PLATFORM_64BITS
        uint32 _Padding;
        static_assert(sizeof(void*) == 4, "Wrong PLATFORM_64BITS settings.");
    #endif
 
    static_assert(sizeof(PtrType) == sizeof(void*), "T should be a pointer.");
};
 
#endif // !PLATFORM_64BITS
 
template<class UniformBufferStructType, typename = void>
struct TUniformBufferMetadataHelper
{
    static const FShaderParametersMetadata* GetStructMetadata()
    {
        // This uses ADL rather than templates, because template specializations can't be defined in a different namespace
        return GetForwardDeclaredShaderParametersStructMetadata((UniformBufferStructType*)nullptr);
    }
};
 
template<class UniformBufferStructType>
struct TUniformBufferMetadataHelper<UniformBufferStructType, typename std::enable_if<!std::is_same<typename UniformBufferStructType::FTypeInfo, void>::value>::type>
{
    static const FShaderParametersMetadata* GetStructMetadata()
    {
        return UniformBufferStructType::FTypeInfo::GetStructMetadata();
    }
};
 
 
template<typename TBufferStruct>
class TUniformBufferRef : public FUniformBufferRHIRef
{
    static_assert(!TIsUECoreVariant<TBufferStruct, double>::Value, "UniformBufferRHIRef cannot be double core variants! Switch to float variant.");
 
public:
    TUniformBufferRef() = default;
 
    explicit TUniformBufferRef(FRHIUniformBuffer* InRHIRef)
        : FUniformBufferRHIRef(InRHIRef)
    {
        checkf(!InRHIRef || TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata()->GetLayoutPtr() == InRHIRef->GetLayoutPtr(),
            TEXT("Attempted to create a uniform buffer of type '%s' from uniform buffer pointer of type '%s'"),
            *TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata()->GetLayout().Name,
            *InRHIRef->GetLayout().Name);
    }
 
    static TUniformBufferRef<TBufferStruct> CreateUniformBufferImmediate(const TBufferStruct& Value, EUniformBufferUsage Usage, EUniformBufferValidation Validation = EUniformBufferValidation::ValidateResources)
    {
        return TUniformBufferRef<TBufferStruct>(RHICreateUniformBuffer(&Value, TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata()->GetLayoutPtr(), Usage, Validation));
    }
    static TUniformBufferRef<TBufferStruct> CreateEmptyUniformBufferImmediate(EUniformBufferUsage Usage)
    {
        return TUniformBufferRef<TBufferStruct>(RHICreateUniformBuffer(nullptr, TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata()->GetLayoutPtr(), Usage, EUniformBufferValidation::ValidateResources));
    }
 
    UE_DEPRECATED(5.3, "UpdateUniformBufferImmediate requires a command list.")
    void UpdateUniformBufferImmediate(const TBufferStruct& Value)
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        RHIUpdateUniformBuffer(GetReference(), &Value);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void UpdateUniformBufferImmediate(FRHICommandListBase& RHICmdList, const TBufferStruct& Value)
    {
        RHICmdList.UpdateUniformBuffer(GetReference(), &Value);
    }
 
private:
 
    template<typename TBufferStruct2>
    friend class TUniformBuffer;
 
    friend class TRDGUniformBuffer<TBufferStruct>;
};
 
class alignas(SHADER_PARAMETER_STRUCT_ALIGNMENT) FUniformBufferBinding
{
public:
    FUniformBufferBinding() = default;
 
    inline FRHIUniformBuffer* GetUniformBuffer() const
    {
        return UniformBuffer;
    }
 
    inline EUniformBufferBindingFlags GetBindingFlags() const
    {
        return BindingFlags;
    }
 
    inline bool IsStatic() const
    {
        return EnumHasAnyFlags(BindingFlags, EUniformBufferBindingFlags::Static);
    }
 
    inline bool IsShader() const
    {
        return EnumHasAnyFlags(BindingFlags, EUniformBufferBindingFlags::Shader);
    }
 
    inline operator bool() const
    {
        return UniformBuffer != nullptr;
    }
 
protected:
    inline FUniformBufferBinding(const FUniformBufferRHIRef& InUniformBuffer, EUniformBufferBindingFlags InBindingFlags)
        : UniformBuffer(InUniformBuffer)
        , BindingFlags(InBindingFlags)
    {}
 
private:
    FRHIUniformBuffer* UniformBuffer = nullptr;
    EUniformBufferBindingFlags BindingFlags = EUniformBufferBindingFlags::Shader;
};
 
template<typename TBufferStruct>
class alignas(SHADER_PARAMETER_STRUCT_ALIGNMENT) TUniformBufferBinding
    : public FUniformBufferBinding
{
public:
    TUniformBufferBinding() = default;
 
    TUniformBufferBinding(const TUniformBufferRef<TBufferStruct>& InUniformBuffer)
        : FUniformBufferBinding(InUniformBuffer, TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata()->GetPreferredBindingFlag())
    {}
 
    TUniformBufferBinding(const TUniformBufferRef<TBufferStruct>& InUniformBuffer, EUniformBufferBindingFlags InBindingFlags)
        : FUniformBufferBinding(InUniformBuffer, InBindingFlags)
    {
#if DO_CHECK
        const auto* StructMetadata = TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata();
        checkf(
            EnumHasAllFlags(StructMetadata->GetBindingFlags(), GetBindingFlags()),
            TEXT("Uniform buffer binding flags don't match those supported by the uniform buffer layout '%s."),
            StructMetadata->GetStructTypeName());
#endif
    }
 
    inline TUniformBufferRef<TBufferStruct> GetUniformBufferRef() const
    {
        return TUniformBufferRef<TBufferStruct>(FUniformBufferBinding::GetUniformBuffer());
    }
 
    inline TRDGUniformBuffer<TBufferStruct>* operator->() const
    {
        return GetUniformBuffer();
    }
};
 
template <typename TBufferStruct>
inline TUniformBufferBinding<TBufferStruct> GetStaticBinding(const TUniformBufferRef<TBufferStruct>& InUniformBuffer)
{
    return TUniformBufferBinding<TBufferStruct>(InUniformBuffer, EUniformBufferBindingFlags::Static);
}
 
template <typename TBufferStruct>
inline TUniformBufferBinding<TBufferStruct> GetShaderBinding(const TUniformBufferRef<TBufferStruct>& InUniformBuffer)
{
    return TUniformBufferBinding<TBufferStruct>(InUniformBuffer, EUniformBufferBindingFlags::Shader);
}
 
class alignas(SHADER_PARAMETER_STRUCT_ALIGNMENT) FRDGUniformBufferBinding
{
public:
    FRDGUniformBufferBinding() = default;
 
    inline FRDGUniformBuffer* GetUniformBuffer() const
    {
        return UniformBuffer;
    }
 
    inline EUniformBufferBindingFlags GetBindingFlags() const
    {
        return BindingFlags;
    }
 
    inline bool IsStatic() const
    {
        return EnumHasAnyFlags(BindingFlags, EUniformBufferBindingFlags::Static);
    }
 
    inline bool IsShader() const
    {
        return EnumHasAnyFlags(BindingFlags, EUniformBufferBindingFlags::Shader);
    }
 
    inline operator bool() const
    {
        return UniformBuffer != nullptr;
    }
 
    inline FRDGUniformBuffer* operator->() const
    {
        return UniformBuffer;
    }
 
protected:
    FRDGUniformBufferBinding(FRDGUniformBuffer* InUniformBuffer, EUniformBufferBindingFlags InBindingFlags)
        : UniformBuffer(InUniformBuffer)
        , BindingFlags(InBindingFlags)
    {}
 
private:
    FRDGUniformBuffer* UniformBuffer = nullptr;
    EUniformBufferBindingFlags BindingFlags = EUniformBufferBindingFlags::Shader;
};
 
template <typename TBufferStruct>
class alignas(SHADER_PARAMETER_STRUCT_ALIGNMENT) TRDGUniformBufferBinding
    : public FRDGUniformBufferBinding
{
public:
    TRDGUniformBufferBinding() = default;
 
    TRDGUniformBufferBinding(TRDGUniformBuffer<TBufferStruct>* InUniformBuffer)
        : FRDGUniformBufferBinding(InUniformBuffer, TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata()->GetPreferredBindingFlag())
    {}
 
    TRDGUniformBufferBinding(TRDGUniformBuffer<TBufferStruct>* InUniformBuffer, EUniformBufferBindingFlags InBindingFlags)
        : FRDGUniformBufferBinding(InUniformBuffer, InBindingFlags)
    {
#if DO_CHECK
        const auto* StructMetadata = TUniformBufferMetadataHelper<TBufferStruct>::GetStructMetadata();
        checkf(
            EnumHasAllFlags(StructMetadata->GetBindingFlags(), GetBindingFlags()),
            TEXT("RDG uniform buffer binding flags don't match those supported by the uniform buffer layout '%s."),
            StructMetadata->GetStructTypeName());
#endif
    }
 
    inline TRDGUniformBuffer<TBufferStruct>* GetUniformBuffer() const
    {
        return static_cast<TRDGUniformBuffer<TBufferStruct>*>(FRDGUniformBufferBinding::GetUniformBuffer());
    }
 
    inline TRDGUniformBuffer<TBufferStruct>* operator->() const
    {
        return GetUniformBuffer();
    }
};
 
template <typename TBufferStruct>
inline TRDGUniformBufferBinding<TBufferStruct> GetShaderBinding(TRDGUniformBuffer<TBufferStruct>* InUniformBuffer)
{
    return TRDGUniformBufferBinding<TBufferStruct>(InUniformBuffer, EUniformBufferBindingFlags::Shader);
}
 
template <typename TBufferStruct>
inline TRDGUniformBufferBinding<TBufferStruct> GetStaticBinding(TRDGUniformBuffer<TBufferStruct>* InUniformBuffer)
{
    return TRDGUniformBufferBinding<TBufferStruct>(InUniformBuffer, EUniformBufferBindingFlags::Static);
}
 
class alignas(SHADER_PARAMETER_POINTER_ALIGNMENT) FRDGBufferAccess
{
public:
    FRDGBufferAccess() = default;
    FRDGBufferAccess(FRDGBuffer* InBuffer, ERHIAccess InAccess)
        : Buffer(InBuffer)
        , Access(InAccess)
    {
        check(IsValidAccess(InAccess));
    }
 
    inline FRDGBuffer* GetBuffer() const { return Buffer; }
    inline ERHIAccess  GetAccess() const { return Access; }
 
    inline operator bool() const
    {
        return Buffer != nullptr;
    }
 
    inline FRDGBuffer* operator->() const
    {
        check(Buffer);
        return Buffer;
    }
 
    inline operator FRDGBuffer*() const
    {
        return Buffer;
    }
 
    inline bool operator==(const FRDGBufferAccess& RHS) const
    {
        return Buffer == RHS.Buffer && Access == RHS.Access;
    }
 
    inline bool operator!=(const FRDGBufferAccess& RHS) const
    {
        return Buffer != RHS.Buffer || Access != RHS.Access;
    }
 
private:
    TAlignedShaderParameterPtr<FRDGBuffer*> Buffer = nullptr;
    ERHIAccess  Access = ERHIAccess::Unknown;
};
 
template <ERHIAccess InAccess>
class alignas(SHADER_PARAMETER_POINTER_ALIGNMENT) TRDGBufferAccess
    : public FRDGBufferAccess
{
public:
    static_assert(IsValidAccess(InAccess), "Buffer access is invalid.");
 
    TRDGBufferAccess()
        : FRDGBufferAccess(nullptr, InAccess)
    {
        check(IsValidAccess(InAccess));
    }
 
    TRDGBufferAccess(FRDGBuffer* InBuffer)
        : FRDGBufferAccess(InBuffer, InAccess)
    {}
};
 
class alignas(SHADER_PARAMETER_POINTER_ALIGNMENT) FRDGTextureAccess
{
public:
    FRDGTextureAccess() = default;
 
    FRDGTextureAccess(FRDGTexture* InTexture, FRDGTextureSubresourceRange InSubresourceRange, ERHIAccess InAccess)
        : Texture(InTexture)
        , SubresourceRange(InSubresourceRange)
        , Access(InAccess)
    {}
 
    RENDERCORE_API FRDGTextureAccess(FRDGTexture* InTexture, ERHIAccess InAccess);
    RENDERCORE_API FRDGTextureAccess(FRDGTextureSRV* InTextureSRV, ERHIAccess InAccess);
    RENDERCORE_API FRDGTextureAccess(FRDGTextureUAV* InTextureUAV, ERHIAccess InAccess);
 
    inline FRDGTexture* GetTexture() const { return Texture; }
    inline FRDGTextureSubresourceRange GetSubresourceRange() const { return SubresourceRange; }
    inline ERHIAccess GetAccess() const  { return Access; }
 
    inline operator bool() const
    {
        return Texture != nullptr;
    }
 
    inline FRDGTexture* operator->() const
    {
        check(Texture);
        return Texture;
    }
 
    inline operator FRDGTexture*() const
    {
        return Texture;
    }
 
    inline bool operator==(const FRDGTextureAccess& RHS) const
    {
        return Texture == RHS.Texture && Access == RHS.Access;
    }
 
    inline bool operator!=(const FRDGTextureAccess& RHS) const
    {
        return Texture != RHS.Texture || Access != RHS.Access;
    }
 
private:
    TAlignedShaderParameterPtr<FRDGTexture*> Texture = nullptr;
    FRDGTextureSubresourceRange SubresourceRange;
    ERHIAccess Access = ERHIAccess::Unknown;
};
 
template <ERHIAccess InAccess>
class alignas(SHADER_PARAMETER_POINTER_ALIGNMENT) TRDGTextureAccess
    : public FRDGTextureAccess
{
public:
    static_assert(IsValidAccess(InAccess), "Texture access is invalid.");
 
    TRDGTextureAccess() = default;
 
    TRDGTextureAccess(FRDGTexture* InTexture, FRDGTextureSubresourceRange InSubresourceRange)
        : FRDGTextureAccess(InTexture, InSubresourceRange, InAccess)
    {}
 
    TRDGTextureAccess(FRDGTexture* InTexture)
        : FRDGTextureAccess(InTexture, InAccess)
    {}
 
    TRDGTextureAccess(FRDGTextureSRV* InTextureSRV)
        : FRDGTextureAccess(InTextureSRV, InAccess)
    {}
 
    TRDGTextureAccess(FRDGTextureUAV* InTextureUAV)
        : FRDGTextureAccess(InTextureUAV, InAccess)
    {}
};
 
template <typename ResourceAccessType>
class alignas(SHADER_PARAMETER_POINTER_ALIGNMENT) TRDGResourceAccessArray
    : public TArray<ResourceAccessType, FRDGArrayAllocator>
{
    using Super = TArray<ResourceAccessType, FRDGArrayAllocator>;
public:
    using Super::Super;
 
private:
#if !PLATFORM_64BITS
    uint32 _Padding;
#endif
};
 
using FRDGBufferAccessArray = TRDGResourceAccessArray<FRDGBufferAccess>;
using FRDGTextureAccessArray = TRDGResourceAccessArray<FRDGTextureAccess>;
 
struct FRenderTargetBinding
{
    FRenderTargetBinding() = default;
 
    FRenderTargetBinding(FRDGTexture* InTexture, ERenderTargetLoadAction InLoadAction, uint8 InMipIndex = 0, int16 InArraySlice = -1)
        : Texture(InTexture)
        , LoadAction(InLoadAction)
        , MipIndex(InMipIndex)
        , ArraySlice(InArraySlice)
    {
        check(Validate());
    }
 
    FRenderTargetBinding(FRDGTexture* InTexture, FRDGTexture* InResolveTexture, ERenderTargetLoadAction InLoadAction, uint8 InMipIndex = 0, int16 InArraySlice = -1)
        : Texture(InTexture)
        , ResolveTexture(InResolveTexture)
        , LoadAction(InLoadAction)
        , MipIndex(InMipIndex)
        , ArraySlice(InArraySlice)
    {
        check(Validate());
    }
 
    FRDGTexture* GetTexture() const
    {
        return Texture;
    }
 
    FRDGTexture* GetResolveTexture() const
    {
        return ResolveTexture;
    }
 
    ERenderTargetLoadAction GetLoadAction() const
    {
        return LoadAction;
    }
 
    uint8 GetMipIndex() const
    {
        return MipIndex;
    }
 
    int16 GetArraySlice() const
    {
        return ArraySlice;
    }
 
    inline bool CanMergeBefore(const FRenderTargetBinding& Other) const
    {
        return
            Texture == Other.Texture &&
            ResolveTexture == Other.ResolveTexture &&
            Other.LoadAction != ERenderTargetLoadAction::EClear &&
            MipIndex == Other.MipIndex &&
            ArraySlice == Other.ArraySlice;
    }
 
    void SetTexture(FRDGTexture* InTexture)
    {
        Texture = InTexture;
        check(Validate());
    }
 
    void SetResolveTexture(FRDGTexture* InTexture)
    {
        ResolveTexture = InTexture;
        check(Validate());
    }
 
    void SetLoadAction(ERenderTargetLoadAction InLoadAction)
    {
        LoadAction = InLoadAction;
        check(Validate());
    }
 
    void SetMipIndex(uint8 InMipIndex)
    {
        MipIndex = InMipIndex;
        check(Validate());
    }
 
    void SetArraySlice(int16 InArraySlice)
    {
        ArraySlice = InArraySlice;
        check(Validate());
    }
 
    UE_DEPRECATED(5.1, "GetMipIndex has been renamed to SetMipIndex.")
    void GetMipIndex(uint8 InMipIndex) { SetMipIndex(InMipIndex); }
 
private:
    TAlignedShaderParameterPtr<FRDGTexture*> Texture        = nullptr;
    TAlignedShaderParameterPtr<FRDGTexture*> ResolveTexture = nullptr;
    ERenderTargetLoadAction     LoadAction      = ERenderTargetLoadAction::ENoAction;
    uint8                       MipIndex        = 0;
    int16                       ArraySlice      = -1;
 
    RENDERCORE_API bool Validate() const;
};
 
 
struct FDepthStencilBinding
{
    FDepthStencilBinding() = default;
 
    inline FDepthStencilBinding(
        FRDGTexture* InTexture,
        ERenderTargetLoadAction InDepthLoadAction,
        ERenderTargetLoadAction InStencilLoadAction,
        FExclusiveDepthStencil InDepthStencilAccess)
        : Texture(InTexture)
        , ResolveTexture(nullptr)
        , DepthLoadAction(InDepthLoadAction)
        , StencilLoadAction(InStencilLoadAction)
        , DepthStencilAccess(InDepthStencilAccess)
    {
        check(Validate());
    }
 
    inline FDepthStencilBinding(
        FRDGTexture* InTexture,
        FRDGTexture* InResolveTexture,
        ERenderTargetLoadAction InDepthLoadAction,
        ERenderTargetLoadAction InStencilLoadAction,
        FExclusiveDepthStencil InDepthStencilAccess)
        : Texture(InTexture)
        , ResolveTexture(InResolveTexture)
        , DepthLoadAction(InDepthLoadAction)
        , StencilLoadAction(InStencilLoadAction)
        , DepthStencilAccess(InDepthStencilAccess)
    {
        check(Validate());
    }
 
    inline FDepthStencilBinding(
        FRDGTexture* InTexture,
        ERenderTargetLoadAction InDepthLoadAction,
        FExclusiveDepthStencil InDepthStencilAccess)
        : Texture(InTexture)
        , ResolveTexture(nullptr)
        , DepthLoadAction(InDepthLoadAction)
        , DepthStencilAccess(InDepthStencilAccess)
    {
        check(Validate());
    }
 
    inline FDepthStencilBinding(
        FRDGTexture* InTexture,
        FRDGTexture* InResolveTexture,
        ERenderTargetLoadAction InDepthLoadAction,
        FExclusiveDepthStencil InDepthStencilAccess)
        : Texture(InTexture)
        , ResolveTexture(InResolveTexture)
        , DepthLoadAction(InDepthLoadAction)
        , DepthStencilAccess(InDepthStencilAccess)
    {
        check(Validate());
    }
 
    inline FRDGTexture* GetTexture() const
    {
        return Texture;
    }
    inline FRDGTexture* GetResolveTexture() const
    {
        return ResolveTexture;
    }
    inline ERenderTargetLoadAction GetDepthLoadAction() const
    {
        return DepthLoadAction;
    }
    inline ERenderTargetLoadAction GetStencilLoadAction() const
    {
        return StencilLoadAction;
    }
    inline FExclusiveDepthStencil GetDepthStencilAccess() const
    {
        return DepthStencilAccess;
    }
 
    // Whether we can merge a render pass using @ref Other into a render pass using this depth stencil binding.
    inline bool CanMergeBefore(const FDepthStencilBinding& Other) const
    {
        return
            Texture == Other.Texture &&
            ResolveTexture == Other.ResolveTexture &&
            Other.DepthLoadAction != ERenderTargetLoadAction::EClear &&
            Other.StencilLoadAction != ERenderTargetLoadAction::EClear &&
            DepthStencilAccess == Other.DepthStencilAccess;
    }
 
    void SetTexture(FRDGTexture* InTexture)
    {
        Texture = InTexture;
        check(Validate());
    }
 
    void SetResolveTexture(FRDGTexture* InTexture)
    {
        ResolveTexture = InTexture;
        check(Validate());
    }
 
    void SetDepthStencilAccess(FExclusiveDepthStencil InAccess)
    {
        DepthStencilAccess = InAccess;
        check(Validate());
    }
 
    void SetDepthLoadAction(ERenderTargetLoadAction InAction)
    {
        DepthLoadAction = InAction;
        check(Validate());
    }
 
    void SetStencilLoadAction(ERenderTargetLoadAction InAction)
    {
        StencilLoadAction = InAction;
        check(Validate());
    }
 
private:
    TAlignedShaderParameterPtr<FRDGTexture*> Texture = nullptr;
    TAlignedShaderParameterPtr<FRDGTexture*> ResolveTexture = nullptr;
    ERenderTargetLoadAction     DepthLoadAction     = ERenderTargetLoadAction::ENoAction;
    ERenderTargetLoadAction     StencilLoadAction   = ERenderTargetLoadAction::ENoAction;
    FExclusiveDepthStencil      DepthStencilAccess  = FExclusiveDepthStencil::DepthNop_StencilNop;
 
    RENDERCORE_API bool Validate() const;
};
 
struct alignas(SHADER_PARAMETER_STRUCT_ALIGNMENT) FRenderTargetBindingSlots
{
    TStaticArray<FRenderTargetBinding, MaxSimultaneousRenderTargets> Output;
    FDepthStencilBinding DepthStencil;
    FResolveRect ResolveRect;
    uint32 NumOcclusionQueries = 0;
    ESubpassHint SubpassHint = ESubpassHint::None;
    uint8 MultiViewCount = 0;
    FRDGTexture* ShadingRateTexture = nullptr;
 
    FRenderTargetBinding& operator[](uint32 Index)
    {
        return Output[Index];
    }
 
    const FRenderTargetBinding& operator[](uint32 Index) const
    {
        return Output[Index];
    }
 
    template <typename TFunction>
    void Enumerate(TFunction Function)
    {
        for (int32 Index = 0; Index < Output.Num(); Index++)
        {
            if (Output[Index].GetTexture())
            {
                Function(Output[Index]);
            }
            else
            {
                break;
            }
        }
    }
 
    template <typename TFunction>
    void Enumerate(TFunction Function) const
    {
        for (int32 Index = 0; Index < Output.Num(); Index++)
        {
            if (Output[Index].GetTexture())
            {
                Function(Output[Index]);
            }
            else
            {
                break;
            }
        }
    }
 
    uint32 GetActiveCount() const
    {
        uint32 Count = 0;
        for (; Output[Count].GetTexture() != nullptr; ++Count) {};
        return Count;
    }
 
    bool CanMergeBefore(const FRenderTargetBindingSlots& Other) const
    {
        for (int32 Index = 0; Index < MaxSimultaneousRenderTargets; ++Index)
        {
            if (!Output[Index].CanMergeBefore(Other.Output[Index]))
            {
                return false;
            }
        }
 
        if (!DepthStencil.CanMergeBefore(Other.DepthStencil))
        {
            return false;
        }
 
        if (ResolveRect != Other.ResolveRect ||
            (NumOcclusionQueries != Other.NumOcclusionQueries && Other.NumOcclusionQueries != 0) ||
            SubpassHint != Other.SubpassHint ||
            MultiViewCount != Other.MultiViewCount ||
            ShadingRateTexture != Other.ShadingRateTexture)
        {
            return false;
        }
 
        return true;
    }
 
    struct FTypeInfo
    {
        static constexpr int32 NumRows = 1;
        static constexpr int32 NumColumns = 1;
        static constexpr int32 NumElements = 0;
        static constexpr int32 Alignment = SHADER_PARAMETER_STRUCT_ALIGNMENT;
        static constexpr bool bIsStoredInConstantBuffer = false;
 
        using TAlignedType = FRenderTargetBindingSlots;
 
        static inline const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
    };
};
 
static_assert(sizeof(FRenderTargetBindingSlots) == 256, "FRenderTargetBindingSlots needs to be same size on all platforms.");
 
template<typename TElement, uint32 NumElements>
class alignas(SHADER_PARAMETER_POINTER_ALIGNMENT) TShaderResourceParameterArray : public TStaticArray<std::conditional_t<SHADER_PARAMETER_POINTER_ALIGNMENT == alignof(TElement), TElement, UE::Core::TAlignedElement<TElement, SHADER_PARAMETER_POINTER_ALIGNMENT>>, NumElements>
{
public:
    inline TShaderResourceParameterArray()
    {
        for (uint32 i = 0; i < NumElements; i++)
        {
            (*this)[i] = nullptr;
        }
    }
};
 
 
template<typename TypeParameter>
struct TShaderParameterTypeInfo
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_INVALID;
 
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
 
    static constexpr int32 NumElements = 0;
 
    static constexpr int32 Alignment = alignof(TypeParameter);
 
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TypeParameter;
 
    using TInstancedType = TypeParameter;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return TypeParameter::FTypeInfo::GetStructMetadata(); }
};
 
// Compile SHADER_PARAMETER(bool, MyBool), just to give good error message to programmer why they shouldn't do that.
template<>
struct TShaderParameterTypeInfo<bool>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_BOOL;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 4;
    static constexpr bool bIsStoredInConstantBuffer = true;
    
    using TAlignedType = TAlignedTypedef<bool, Alignment>::Type;
    using TInstancedType = FUintVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<uint32>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_UINT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 4;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<uint32, Alignment>::Type;
    using TInstancedType = FUintVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
    
 
template<>
struct TShaderParameterTypeInfo<int32>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_INT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 4;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<int32, Alignment>::Type;
    using TInstancedType = FIntVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<float>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_FLOAT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 4;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<float, Alignment>::Type;
    using TInstancedType = FVector4f;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FVector2f>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_FLOAT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 2;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 8;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FVector2f, Alignment>::Type;
    using TInstancedType = FVector4f;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FVector3f>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_FLOAT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 3;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FVector3f, Alignment>::Type;
    using TInstancedType = FVector4f;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FVector4f>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_FLOAT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 4;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FVector4f, Alignment>::Type;
    using TInstancedType = FVector4f;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
    
template<>
struct TShaderParameterTypeInfo<FLinearColor>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_FLOAT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 4;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FLinearColor, Alignment>::Type;
    using TInstancedType = FLinearColor;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
    
template<>
struct TShaderParameterTypeInfo<FIntPoint>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_INT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 2;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 8;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FIntPoint, Alignment>::Type;
    using TInstancedType = FIntVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FUintVector2>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_UINT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 2;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 8;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FUintVector2, Alignment>::Type;
    using TInstancedType = FUintVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FIntVector>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_INT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 3;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FIntVector, Alignment>::Type;
    using TInstancedType = FIntVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FUintVector3>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_UINT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 3;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FUintVector3, Alignment>::Type;
    using TInstancedType = FUintVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FIntVector4>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_INT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 4;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FIntVector4, Alignment>::Type;
    using TInstancedType = FIntVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FUintVector4>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_UINT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 4;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FUintVector4, Alignment>::Type;
    using TInstancedType = FUintVector4;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FIntRect>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_INT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 4;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FIntRect, Alignment>::Type;
    using TInstancedType = FIntRect;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FQuat4f>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_FLOAT32;
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 4;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FQuat4f, Alignment>::Type;
    using TInstancedType = FQuat4f;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<>
struct TShaderParameterTypeInfo<FMatrix44f>
{
    static constexpr EUniformBufferBaseType BaseType = UBMT_FLOAT32;
    static constexpr int32 NumRows = 4;
    static constexpr int32 NumColumns = 4;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = 16;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TAlignedTypedef<FMatrix44f, Alignment>::Type;
    using TInstancedType = FMatrix44f;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template <typename BufferAccessType>
struct TRDGResourceAccessTypeInfo
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = SHADER_PARAMETER_POINTER_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = false;
 
    using TAlignedType = BufferAccessType;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
 
    static_assert(sizeof(TAlignedType) == SHADER_PARAMETER_POINTER_ALIGNMENT * 2, "Uniform buffer layout must not be platform dependent.");
};
 
template <typename TextureAccessType>
struct TRDGTextureAccessTypeInfo
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = SHADER_PARAMETER_POINTER_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = false;
 
    using TAlignedType = TextureAccessType;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
 
    static_assert(sizeof(TAlignedType) == SHADER_PARAMETER_POINTER_ALIGNMENT * 3, "Uniform buffer layout must not be platform dependent.");
};
 
 
template<typename T, size_t InNumElements>
struct TShaderParameterTypeInfo<T[InNumElements]>
{
    static constexpr EUniformBufferBaseType BaseType = TShaderParameterTypeInfo<T>::BaseType;
    static constexpr int32 NumRows = TShaderParameterTypeInfo<T>::NumRows;
    static constexpr int32 NumColumns = TShaderParameterTypeInfo<T>::NumColumns;
    static constexpr int32 NumElements = InNumElements;
    static constexpr int32 Alignment = SHADER_PARAMETER_ARRAY_ELEMENT_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = TShaderParameterTypeInfo<T>::bIsStoredInConstantBuffer;
 
    using TAlignedType = TStaticArray<std::conditional_t<Alignment == alignof(T), T, UE::Core::TAlignedElement<T, Alignment>>, InNumElements>;
    using TInstancedType = T;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return TShaderParameterTypeInfo<T>::GetStructMetadata(); }
 
    static_assert(((sizeof(T) % 16) == 0), "Array element size does not satisfy 16 byte alignment requirements.  Try packing it with other values in a vector or using SHADER_PARAMETER_SCALAR_ARRAY.");
};
    
template<typename T,size_t InNumElements,uint32 IgnoredAlignment>
struct TShaderParameterTypeInfo<TStaticArray<T,InNumElements,IgnoredAlignment>>
{
    static constexpr EUniformBufferBaseType BaseType = TShaderParameterTypeInfo<T>::BaseType;
    static constexpr int32 NumRows = TShaderParameterTypeInfo<T>::NumRows;
    static constexpr int32 NumColumns = TShaderParameterTypeInfo<T>::NumColumns;
    static constexpr int32 NumElements = InNumElements;
    static constexpr int32 Alignment = SHADER_PARAMETER_ARRAY_ELEMENT_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = TShaderParameterTypeInfo<T>::bIsStoredInConstantBuffer;
 
    using TAlignedType = TStaticArray<std::conditional_t<Alignment == alignof(T), T, UE::Core::TAlignedElement<T, Alignment>>, InNumElements>;
    using TInstancedType = T;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return TShaderParameterTypeInfo<T>::GetStructMetadata(); }
 
    static_assert(((sizeof(T) % 16) == 0), "Array element size does not satisfy 16 byte alignment requirements.  Try packing it with other values in a vector or using SHADER_PARAMETER_SCALAR_ARRAY.");
};
 
template<typename ShaderResourceType>
struct TShaderResourceParameterTypeInfo
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = SHADER_PARAMETER_POINTER_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = false;
 
    using TAlignedType = TAlignedShaderParameterPtr<ShaderResourceType>;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
 
    static_assert(sizeof(TAlignedType) == SHADER_PARAMETER_POINTER_ALIGNMENT, "Uniform buffer layout must not be platform dependent.");
};
 
template<typename ShaderResourceType, size_t InNumElements>
struct TShaderResourceParameterTypeInfo<ShaderResourceType[InNumElements]>
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = InNumElements;
    static constexpr int32 Alignment = SHADER_PARAMETER_POINTER_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = false;
 
    using TAlignedType = TShaderResourceParameterArray<ShaderResourceType, InNumElements>;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return nullptr; }
};
 
template<class UniformBufferStructType>
struct TShaderParameterTypeInfo<TUniformBufferRef<UniformBufferStructType>>
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = SHADER_PARAMETER_POINTER_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = false;
    
    using TAlignedType = TAlignedShaderParameterPtr<TUniformBufferRef<UniformBufferStructType>>;
    using TInstancedType = UniformBufferStructType;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return TUniformBufferMetadataHelper<UniformBufferStructType>::GetStructMetadata(); }
};
 
template<class UniformBufferStructType>
struct TShaderParameterTypeInfo<TUniformBufferBinding<UniformBufferStructType>>
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = SHADER_PARAMETER_STRUCT_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = false;
 
    using TAlignedType = TUniformBufferBinding<UniformBufferStructType>;
    using TInstancedType = UniformBufferStructType;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return TUniformBufferMetadataHelper<UniformBufferStructType>::GetStructMetadata(); }
};
 
template<class UniformBufferStructType>
struct TShaderParameterTypeInfo<TRDGUniformBufferBinding<UniformBufferStructType>>
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = SHADER_PARAMETER_STRUCT_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = false;
 
    using TAlignedType = TRDGUniformBufferBinding<UniformBufferStructType>;
    using TInstancedType = UniformBufferStructType;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return TUniformBufferMetadataHelper<UniformBufferStructType>::GetStructMetadata(); }
};
 
template<typename StructType>
struct TShaderParameterStructTypeInfo
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = 0;
    static constexpr int32 Alignment = SHADER_PARAMETER_STRUCT_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = StructType;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return StructType::FTypeInfo::GetStructMetadata(); }
};
 
template<typename StructType, size_t InNumElements>
struct TShaderParameterStructTypeInfo<StructType[InNumElements]>
{
    static constexpr int32 NumRows = 1;
    static constexpr int32 NumColumns = 1;
    static constexpr int32 NumElements = InNumElements;
    static constexpr int32 Alignment = SHADER_PARAMETER_STRUCT_ALIGNMENT;
    static constexpr bool bIsStoredInConstantBuffer = true;
 
    using TAlignedType = TStaticArray<StructType, InNumElements>;
 
    static const FShaderParametersMetadata* GetStructMetadata() { return StructType::FTypeInfo::GetStructMetadata(); }
};
 
#define INTERNAL_BEGIN_UNIFORM_BUFFER_STRUCT(DllStorage) \
    static DllStorage const FShaderParametersMetadata* GetStructMetadata(); 
 
#define INTERNAL_UNIFORM_BUFFER_STRUCT_GET_STRUCT_METADATA(StructTypeName) \
    { return StructTypeName::GetStructMetadata(); }
 
#define INTERNAL_SHADER_PARAMETER_GET_STRUCT_METADATA(StructTypeName) \
    { \
        static FShaderParametersMetadata StaticStructMetadata(\
            FShaderParametersMetadata::EUseCase::ShaderParameterStruct, \
            EUniformBufferBindingFlags::Shader, \
            TEXT(#StructTypeName), \
            TEXT(#StructTypeName), \
            nullptr, \
            nullptr, \
            FTypeInfo::FileName, \
            FTypeInfo::FileLine, \
            sizeof(StructTypeName), \
            StructTypeName::zzGetMembers()); \
        return &StaticStructMetadata; \
    }
 
 
#define INTERNAL_SHADER_PARAMETER_STRUCT_CREATE_UNIFORM_BUFFER return nullptr;
 
#define INTERNAL_UNIFORM_BUFFER_STRUCT_CREATE_UNIFORM_BUFFER return RHICreateUniformBuffer(&InContents, FTypeInfo::GetStructMetadata()->GetLayoutPtr(), InUsage);
 
#define INTERNAL_SHADER_PARAMETER_STRUCT_BEGIN(StructTypeName,DllStorage,ConstructorSuffix,GetStructMetadataScope,CreateUniformBufferImpl) \
    MS_ALIGN(SHADER_PARAMETER_STRUCT_ALIGNMENT) class StructTypeName \
    { \
    public: \
        DllStorage StructTypeName () ConstructorSuffix \
        struct FTypeInfo { \
            static constexpr int32 NumRows = 1; \
            static constexpr int32 NumColumns = 1; \
            static constexpr int32 NumElements = 0; \
            static constexpr int32 Alignment = SHADER_PARAMETER_STRUCT_ALIGNMENT; \
            static constexpr bool bIsStoredInConstantBuffer = true; \
            static constexpr const ANSICHAR* const FileName = UE_LOG_SOURCE_FILE(__builtin_FILE()); \
            static constexpr int32 FileLine = __builtin_LINE(); \
            using TAlignedType = StructTypeName; \
            static const FShaderParametersMetadata* GetStructMetadata() GetStructMetadataScope \
        }; \
        static FUniformBufferRHIRef CreateUniformBuffer(const StructTypeName& InContents, EUniformBufferUsage InUsage) \
        { \
            CreateUniformBufferImpl \
        } \
    private: \
        typedef StructTypeName zzTThisStruct; \
        struct zzFirstMemberId { enum { HasDeclaredResource = 0 }; }; \
        typedef void* zzFuncPtr; \
        typedef zzFuncPtr(*zzMemberFunc)(zzFirstMemberId, TArray<FShaderParametersMetadata::FMember>*); \
        static zzFuncPtr zzAppendMemberGetPrev(zzFirstMemberId, TArray<FShaderParametersMetadata::FMember>*) \
        { \
            return nullptr; \
        } \
        typedef zzFirstMemberId
 
#define INTERNAL_SHADER_PARAMETER_EXPLICIT(BaseType,TypeInfo,MemberType,MemberName,ArrayDecl,DefaultValue,Precision,OptionalShaderType,IsMemberStruct) \
        zzMemberId##MemberName; \
    public: \
        alignas(TypeInfo::Alignment) TypeInfo::TAlignedType MemberName DefaultValue; \
        static_assert(BaseType != UBMT_INVALID, "Invalid type " #MemberType " of member " #MemberName "."); \
    private: \
        struct zzNextMemberId##MemberName { enum { HasDeclaredResource = zzMemberId##MemberName::HasDeclaredResource || !TypeInfo::bIsStoredInConstantBuffer }; }; \
        static zzFuncPtr zzAppendMemberGetPrev(zzNextMemberId##MemberName, TArray<FShaderParametersMetadata::FMember>* Members) \
        { \
            static_assert(TypeInfo::bIsStoredInConstantBuffer || TIsArrayOrRefOfTypeByPredicate<decltype(OptionalShaderType), TIsCharEncodingCompatibleWithTCHAR>::Value, "No shader type for " #MemberName "."); \
            static_assert(\
                (STRUCT_OFFSET(zzTThisStruct, MemberName) & (TypeInfo::Alignment - 1)) == 0, \
                "Misaligned uniform buffer struct member " #MemberName "."); \
            Members->Add(FShaderParametersMetadata::FMember( \
                TEXT(#MemberName), \
                (const TCHAR*)OptionalShaderType, \
                __LINE__, \
                STRUCT_OFFSET(zzTThisStruct,MemberName), \
                EUniformBufferBaseType(BaseType), \
                Precision, \
                TypeInfo::NumRows, \
                TypeInfo::NumColumns, \
                TypeInfo::NumElements, \
                TypeInfo::GetStructMetadata() \
                )); \
            zzFuncPtr(*PrevFunc)(zzMemberId##MemberName, TArray<FShaderParametersMetadata::FMember>*); \
            PrevFunc = zzAppendMemberGetPrev; \
            return (zzFuncPtr)PrevFunc; \
        } \
        typedef zzNextMemberId##MemberName
 
extern RENDERCORE_API FShaderParametersMetadata* FindUniformBufferStructByName(const TCHAR* StructName);
extern RENDERCORE_API FShaderParametersMetadata* FindUniformBufferStructByFName(FName StructName);
 
extern RENDERCORE_API FShaderParametersMetadata* FindUniformBufferStructByLayoutHash(uint32 Hash);
 
extern RENDERCORE_API FShaderParametersMetadata* FindUniformBufferStructByShaderVariableName(const FHashedName& Name);
 
extern RENDERCORE_API void BuildShaderBindingLayout(TConstArrayView<FShaderParametersMetadata*> UniformBuffers, EShaderBindingLayoutFlags BaseShaderBindingLayoutFlags, FShaderBindingLayoutContainer& OutShaderBindingLayoutContainer);
 
#define BEGIN_SHADER_PARAMETER_STRUCT(StructTypeName, DllStorage) \
    INTERNAL_SHADER_PARAMETER_STRUCT_BEGIN(StructTypeName,, {}, INTERNAL_SHADER_PARAMETER_GET_STRUCT_METADATA(StructTypeName), INTERNAL_SHADER_PARAMETER_STRUCT_CREATE_UNIFORM_BUFFER)
 
#define END_SHADER_PARAMETER_STRUCT() \
        zzLastMemberId; \
    public: \
        static TArray<FShaderParametersMetadata::FMember> zzGetMembers() { \
            TArray<FShaderParametersMetadata::FMember> Members; \
            zzFuncPtr(*LastFunc)(zzLastMemberId, TArray<FShaderParametersMetadata::FMember>*); \
            LastFunc = zzAppendMemberGetPrev; \
            zzFuncPtr Ptr = (zzFuncPtr)LastFunc; \
            do \
            { \
                Ptr = reinterpret_cast<zzMemberFunc>(Ptr)(zzFirstMemberId(), &Members); \
            } while (Ptr); \
            Algo::Reverse(Members); \
            return Members; \
        } \
    } GCC_ALIGN(SHADER_PARAMETER_STRUCT_ALIGNMENT);
 
#define BEGIN_UNIFORM_BUFFER_STRUCT(StructTypeName, DllStorage) \
    DECLARE_UNIFORM_BUFFER_STRUCT(StructTypeName, DllStorage) \
    INTERNAL_SHADER_PARAMETER_STRUCT_BEGIN(StructTypeName,,{} INTERNAL_BEGIN_UNIFORM_BUFFER_STRUCT(DllStorage), INTERNAL_UNIFORM_BUFFER_STRUCT_GET_STRUCT_METADATA(StructTypeName), INTERNAL_UNIFORM_BUFFER_STRUCT_CREATE_UNIFORM_BUFFER)
 
#define BEGIN_UNIFORM_BUFFER_STRUCT_WITH_CONSTRUCTOR(StructTypeName, DllStorage) \
    DECLARE_UNIFORM_BUFFER_STRUCT(StructTypeName, DllStorage) \
    INTERNAL_SHADER_PARAMETER_STRUCT_BEGIN(StructTypeName,DllStorage,; INTERNAL_BEGIN_UNIFORM_BUFFER_STRUCT(DllStorage), INTERNAL_UNIFORM_BUFFER_STRUCT_GET_STRUCT_METADATA(StructTypeName), INTERNAL_UNIFORM_BUFFER_STRUCT_CREATE_UNIFORM_BUFFER)
 
#define END_UNIFORM_BUFFER_STRUCT() \
    END_SHADER_PARAMETER_STRUCT()
 
 
class FShaderParametersMetadataRegistration
{
public:
    FShaderParametersMetadataRegistration(TFunctionRef<const FShaderParametersMetadata* ()> LazyShaderParametersMetadataAccessor)
        : LazyShaderParametersMetadataAccessor(LazyShaderParametersMetadataAccessor)
    {
        GetInstances().Add(this);
    }
 
    static RENDERCORE_API TArray<const FShaderParametersMetadataRegistration*>& GetInstances();
 
    // Actually register all the instances and clear the array
    static RENDERCORE_API void CommitAll();
    static RENDERCORE_API bool IsReadyForRegistration();
 
private:
    TFunctionRef<const FShaderParametersMetadata* ()> LazyShaderParametersMetadataAccessor;
};
 
#define IMPLEMENT_UNIFORM_BUFFER_STRUCT_EX(StructTypeName,ShaderVariableName,UsageFlags) \
    const FShaderParametersMetadata* GetForwardDeclaredShaderParametersStructMetadata(const StructTypeName* DummyPtr) { return StructTypeName::FTypeInfo::GetStructMetadata(); } \
    const FShaderParametersMetadata* StructTypeName::GetStructMetadata() \
    { \
        ensureMsgf(FShaderParametersMetadataRegistration::IsReadyForRegistration(), TEXT("GetStructMetadata should not be called from a static initializer")); \
        static const FShaderParametersMetadata StaticStructMetadata( \
            FShaderParametersMetadata::EUseCase::UniformBuffer, \
            EUniformBufferBindingFlags::Shader, \
            TEXT(#StructTypeName), \
            TEXT(#StructTypeName), \
            TEXT(ShaderVariableName), \
            nullptr, \
            StructTypeName::FTypeInfo::FileName, \
            StructTypeName::FTypeInfo::FileLine, \
            sizeof(StructTypeName), \
            StructTypeName::zzGetMembers(), \
            false, \
            nullptr, \
            UsageFlags); \
        return &StaticStructMetadata; \
    } \
    FShaderParametersMetadataRegistration StructTypeName##MetadataRegistration { TFunctionRef<const ::FShaderParametersMetadata* ()>{StructTypeName::GetStructMetadata} };
 
#define IMPLEMENT_UNIFORM_BUFFER_STRUCT(StructTypeName,ShaderVariableName) \
    IMPLEMENT_UNIFORM_BUFFER_STRUCT_EX(StructTypeName,ShaderVariableName,FShaderParametersMetadata::EUsageFlags::None)
 
#define IMPLEMENT_UNIFORM_BUFFER_ALIAS_STRUCT(StructTypeName, UniformBufferAlias) \
    static const FShaderParametersMetadata UniformBufferAlias( \
    FShaderParametersMetadata::EUseCase::UniformBuffer, \
    EUniformBufferBindingFlags::Shader, \
    TEXT(#StructTypeName), \
    TEXT(#StructTypeName), \
    TEXT(#UniformBufferAlias), \
    nullptr, \
    StructTypeName::FTypeInfo::FileName, \
    StructTypeName::FTypeInfo::FileLine, \
    sizeof(StructTypeName), \
    StructTypeName::zzGetMembers())
 
#define IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT_EX(StructTypeName,ShaderVariableName,StaticSlotName,BindingFlagsEnum) \
    static_assert(EnumHasAnyFlags(EUniformBufferBindingFlags::BindingFlagsEnum, EUniformBufferBindingFlags::Static), "Shader bindings must include 'Static'."); \
    const FShaderParametersMetadata* GetForwardDeclaredShaderParametersStructMetadata(const StructTypeName* DummyPtr) { return StructTypeName::FTypeInfo::GetStructMetadata(); } \
    const FShaderParametersMetadata* StructTypeName::GetStructMetadata() \
    { \
        ensureMsgf(FShaderParametersMetadataRegistration::IsReadyForRegistration(), TEXT("GetStructMetadata should not be called from a static initializer")); \
        static const FShaderParametersMetadata StaticStructMetadata( \
            FShaderParametersMetadata::EUseCase::UniformBuffer, \
            EUniformBufferBindingFlags::BindingFlagsEnum, \
            TEXT(#StructTypeName), \
            TEXT(#StructTypeName), \
            TEXT(ShaderVariableName), \
            TEXT(#StaticSlotName), \
            StructTypeName::FTypeInfo::FileName, \
            StructTypeName::FTypeInfo::FileLine, \
            sizeof(StructTypeName), \
            StructTypeName::zzGetMembers()); \
        return &StaticStructMetadata; \
    } \
    FShaderParametersMetadataRegistration StructTypeName##MetadataRegistration { TFunctionRef<const ::FShaderParametersMetadata* ()>{StructTypeName::GetStructMetadata} };
 
#define IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT_EX2(StructTypeName,ShaderVariableName,StaticSlotName,BindingFlagsEnum,UsageFlags) \
    static_assert(EnumHasAnyFlags(EUniformBufferBindingFlags::BindingFlagsEnum, EUniformBufferBindingFlags::Static), "Shader bindings must include 'Static'."); \
    const FShaderParametersMetadata* GetForwardDeclaredShaderParametersStructMetadata(const StructTypeName* DummyPtr) {  return StructTypeName::FTypeInfo::GetStructMetadata(); } \
    const FShaderParametersMetadata* StructTypeName::GetStructMetadata() \
    { \
        ensureMsgf(FShaderParametersMetadataRegistration::IsReadyForRegistration(), TEXT("GetStructMetadata should not be called from a static initializer")); \
        static const FShaderParametersMetadata StaticStructMetadata( \
            FShaderParametersMetadata::EUseCase::UniformBuffer, \
            EUniformBufferBindingFlags::BindingFlagsEnum, \
            TEXT(#StructTypeName), \
            TEXT(#StructTypeName), \
            TEXT(ShaderVariableName), \
            TEXT(#StaticSlotName), \
            StructTypeName::FTypeInfo::FileName, \
            StructTypeName::FTypeInfo::FileLine, \
            sizeof(StructTypeName), \
            StructTypeName::zzGetMembers(), \
            false, \
            nullptr, \
            UsageFlags); \
        return &StaticStructMetadata; \
    } \
    FShaderParametersMetadataRegistration StructTypeName##MetadataRegistration { TFunctionRef<const ::FShaderParametersMetadata* ()>{StructTypeName::GetStructMetadata} };
 
#define IMPLEMENT_STATIC_AND_SHADER_UNIFORM_BUFFER_STRUCT(StructTypeName,ShaderVariableName,StaticSlotName) \
    IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT_EX(StructTypeName, ShaderVariableName, StaticSlotName, StaticAndShader)
 
#define IMPLEMENT_STATIC_AND_SHADER_UNIFORM_BUFFER_STRUCT_EX(StructTypeName,ShaderVariableName,StaticSlotName,UsageFlags) \
    IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT_EX2(StructTypeName, ShaderVariableName, StaticSlotName, StaticAndShader, UsageFlags)
 
#define IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT(StructTypeName,ShaderVariableName,StaticSlotName) \
    IMPLEMENT_STATIC_UNIFORM_BUFFER_STRUCT_EX(StructTypeName, ShaderVariableName, StaticSlotName, Static)
 
#define IMPLEMENT_STATIC_UNIFORM_BUFFER_SLOT(SlotName) \
    static FUniformBufferStaticSlotRegistrar UniformBufferStaticSlot_##SlotName(TEXT(#SlotName));
 
#define BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT \
     BEGIN_UNIFORM_BUFFER_STRUCT
 
#define BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR \
    BEGIN_UNIFORM_BUFFER_STRUCT_WITH_CONSTRUCTOR
 
#define END_GLOBAL_SHADER_PARAMETER_STRUCT \
    END_UNIFORM_BUFFER_STRUCT
 
#define IMPLEMENT_GLOBAL_SHADER_PARAMETER_STRUCT \
    IMPLEMENT_UNIFORM_BUFFER_STRUCT
 
#define IMPLEMENT_GLOBAL_SHADER_PARAMETER_ALIAS_STRUCT \
    IMPLEMENT_UNIFORM_BUFFER_ALIAS_STRUCT
 
#define SHADER_PARAMETER(MemberType,MemberName) \
    SHADER_PARAMETER_EX(MemberType,MemberName,EShaderPrecisionModifier::Float)
 
#define SHADER_PARAMETER_EX(MemberType,MemberName,Precision) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(TShaderParameterTypeInfo<MemberType>::BaseType, TShaderParameterTypeInfo<MemberType>, MemberType,MemberName,,,Precision,TEXT(""),false)
 
#define SHADER_PARAMETER_ARRAY(MemberType,MemberName,ArrayDecl) \
    SHADER_PARAMETER_ARRAY_EX(MemberType,MemberName,ArrayDecl,EShaderPrecisionModifier::Float)
 
#define SHADER_PARAMETER_ARRAY_EX(MemberType,MemberName,ArrayDecl,Precision) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(TShaderParameterTypeInfo<MemberType ArrayDecl>::BaseType, TShaderParameterTypeInfo<MemberType ArrayDecl>, MemberType,MemberName,ArrayDecl,,Precision,TEXT(""),false)
 
#define SHADER_PARAMETER_TEXTURE(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_TEXTURE, TShaderResourceParameterTypeInfo<FRHITexture*>, FRHITexture*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_TEXTURE_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_TEXTURE, TShaderResourceParameterTypeInfo<FRHITexture* ArrayDecl>, FRHITexture*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_SRV(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_SRV, TShaderResourceParameterTypeInfo<FRHIShaderResourceView*>, FRHIShaderResourceView*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_SRV_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_SRV, TShaderResourceParameterTypeInfo<FRHIShaderResourceView* ArrayDecl>, FRHIShaderResourceView*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_UAV(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_UAV, TShaderResourceParameterTypeInfo<FRHIUnorderedAccessView*>, FRHIUnorderedAccessView*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_SAMPLER(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_SAMPLER, TShaderResourceParameterTypeInfo<FRHISamplerState*>, FRHISamplerState*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_SAMPLER_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_SAMPLER, TShaderResourceParameterTypeInfo<FRHISamplerState* ArrayDecl>, FRHISamplerState*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE, TShaderResourceParameterTypeInfo<FRDGTexture*>, FRDGTexture*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE, TShaderResourceParameterTypeInfo<FRDGTexture* ArrayDecl>, FRDGTexture*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE_SRV(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_SRV, TShaderResourceParameterTypeInfo<FRDGTextureSRV*>, FRDGTextureSRV*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE_SRV_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_SRV, TShaderResourceParameterTypeInfo<FRDGTextureSRV* ArrayDecl>, FRDGTextureSRV*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE_NON_PIXEL_SRV(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_NON_PIXEL_SRV, TShaderResourceParameterTypeInfo<FRDGTextureSRV*>, FRDGTextureSRV*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE_NON_PIXEL_SRV_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_NON_PIXEL_SRV, TShaderResourceParameterTypeInfo<FRDGTextureSRV* ArrayDecl>, FRDGTextureSRV*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE_UAV(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_UAV, TShaderResourceParameterTypeInfo<FRDGTextureUAV*>, FRDGTextureUAV*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_TEXTURE_UAV_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_UAV, TShaderResourceParameterTypeInfo<FRDGTextureUAV* ArrayDecl>, FRDGTextureUAV*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_BUFFER_SRV(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_BUFFER_SRV, TShaderResourceParameterTypeInfo<FRDGBufferSRV*>, FRDGBufferSRV*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_BUFFER_SRV_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_BUFFER_SRV, TShaderResourceParameterTypeInfo<FRDGBufferSRV* ArrayDecl>, FRDGBufferSRV*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_BUFFER_UAV(ShaderType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_BUFFER_UAV, TShaderResourceParameterTypeInfo<FRDGBufferUAV*>, FRDGBufferUAV*,MemberName,, = nullptr,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_BUFFER_UAV_ARRAY(ShaderType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_BUFFER_UAV, TShaderResourceParameterTypeInfo<FRDGBufferUAV* ArrayDecl>, FRDGBufferUAV*,MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#ShaderType),false)
 
#define SHADER_PARAMETER_RDG_UNIFORM_BUFFER(StructType, MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_UNIFORM_BUFFER, TShaderParameterTypeInfo<TRDGUniformBufferBinding<StructType>>, TRDGUniformBufferBinding<StructType>,MemberName,,,EShaderPrecisionModifier::Float,TEXT(#StructType),false)
 
#define SHADER_PARAMETER_STRUCT(StructType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_NESTED_STRUCT, StructType::FTypeInfo, StructType, MemberName,,,EShaderPrecisionModifier::Float,TEXT(#StructType),true)
 
#define SHADER_PARAMETER_STRUCT_ARRAY(StructType,MemberName, ArrayDecl) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_NESTED_STRUCT, TShaderParameterStructTypeInfo<StructType ArrayDecl>, StructType, MemberName,ArrayDecl,,EShaderPrecisionModifier::Float,TEXT(#StructType),true)
 
#define SHADER_PARAMETER_STRUCT_INCLUDE(StructType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_INCLUDED_STRUCT, StructType::FTypeInfo, StructType, MemberName,,,EShaderPrecisionModifier::Float,TEXT(#StructType),true)
 
#define SHADER_PARAMETER_STRUCT_REF(StructType,MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_REFERENCED_STRUCT, TShaderParameterTypeInfo<TUniformBufferBinding<StructType>>, TUniformBufferBinding<StructType>,MemberName,,,EShaderPrecisionModifier::Float,TEXT(#StructType),false)
 
#define RDG_BUFFER_ACCESS(MemberName, Access) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_BUFFER_ACCESS, TRDGResourceAccessTypeInfo<TRDGBufferAccess<Access>>, TRDGBufferAccess<Access>,MemberName,,,EShaderPrecisionModifier::Float,TEXT(""),false)
 
#define RDG_BUFFER_ACCESS_DYNAMIC(MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_BUFFER_ACCESS, TRDGResourceAccessTypeInfo<FRDGBufferAccess>, FRDGBufferAccess,MemberName,,,EShaderPrecisionModifier::Float,TEXT(""),false)
 
#define RDG_BUFFER_ACCESS_ARRAY(MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_BUFFER_ACCESS_ARRAY, TRDGResourceAccessTypeInfo<FRDGBufferAccessArray>, FRDGBufferAccessArray,MemberName,,,EShaderPrecisionModifier::Float,TEXT(""),false)
 
#define RDG_TEXTURE_ACCESS(MemberName, Access) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_ACCESS, TRDGTextureAccessTypeInfo<TRDGTextureAccess<Access>>, TRDGTextureAccess<Access>,MemberName,,,EShaderPrecisionModifier::Float,TEXT(""),false)
 
#define RDG_TEXTURE_ACCESS_DYNAMIC(MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_ACCESS, TRDGTextureAccessTypeInfo<FRDGTextureAccess>, FRDGTextureAccess,MemberName,,,EShaderPrecisionModifier::Float,TEXT(""),false)
 
#define RDG_TEXTURE_ACCESS_ARRAY(MemberName) \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RDG_TEXTURE_ACCESS_ARRAY, TRDGResourceAccessTypeInfo<FRDGTextureAccessArray>, FRDGTextureAccessArray,MemberName,,,EShaderPrecisionModifier::Float,TEXT(""),false)
 
#define RENDER_TARGET_BINDING_SLOTS() \
    INTERNAL_SHADER_PARAMETER_EXPLICIT(UBMT_RENDER_TARGET_BINDING_SLOTS, FRenderTargetBindingSlots::FTypeInfo, FRenderTargetBindingSlots,RenderTargets,,,EShaderPrecisionModifier::Float,TEXT(""),false)
 
BEGIN_SHADER_PARAMETER_STRUCT(FEmptyShaderParameters, RENDERCORE_API)
END_SHADER_PARAMETER_STRUCT()
 
 
BEGIN_SHADER_PARAMETER_STRUCT(FRenderTargetParameters, RENDERCORE_API)
    RENDER_TARGET_BINDING_SLOTS()
END_SHADER_PARAMETER_STRUCT()
 
const TCHAR* GetShaderParameterMacroName(EUniformBufferBaseType ShaderParameterBaseType);
 
#define SHADER_PARAMETER_RDG_BUFFER_UPLOAD(MemberName) \
    UE_DEPRECATED_MACRO(5.0, "SHADER_PARAMETER_RDG_BUFFER_UPLOAD has been deprecated. Use RDG_BUFFER_ACCESS(Buffer, ERHIAccess::CopyDest) instead.") \
    RDG_BUFFER_ACCESS(MemberName, ERHIAccess::CopyDest)
 
#define SHADER_PARAMETER_RDG_BUFFER(ShaderType,MemberName) \
    UE_DEPRECATED_MACRO(5.0, "SHADER_PARAMETER_RDG_BUFFER has been deprecated. Use RDG_BUFFER_ACCESS with an explicit RHI state instead.") \
    RDG_BUFFER_ACCESS(MemberName, ERHIAccess::SRVMask | ERHIAccess::IndirectArgs)
 
#define SHADER_PARAMETER_RDG_BUFFER_ARRAY(ShaderType,MemberName, ArrayDecl) \
    UE_DEPRECATED_MACRO(5.0, "SHADER_PARAMETER_RDG_BUFFER_ARRAY has been deprecated. Use RDG_BUFFER_ACCESS_ARRAY instead.")
 
 
 
 
template<typename TypeParameter>
struct TShaderParameterScalarArrayTypeInfo
{
    static_assert(sizeof(TypeParameter) == 0, "This type is not supported for automatic packing.");
    using PackedArrayType = void;
};
 
template<>
struct TShaderParameterScalarArrayTypeInfo<uint32>
{
    using PackedArrayType = FUintVector4;
};
 
template<>
struct TShaderParameterScalarArrayTypeInfo<int32>
{
    using PackedArrayType = FIntVector4;
};
 
template<>
struct TShaderParameterScalarArrayTypeInfo<float>
{
    using PackedArrayType = FVector4f;
};
 
constexpr uint32 CalcPackedArraySize(uint32 NumElements)        { return (NumElements + 3) / 4; }
constexpr uint32 CalcPackedArrayIndex(uint32 ElementIndex)      { return (ElementIndex >> 2);   }
constexpr uint32 CalcPackedComponentIndex(uint32 ElementIndex)  { return (ElementIndex & 3);    }
 
#define SHADER_PARAMETER_SCALAR_ARRAY(MemberType,MemberName,ArrayDecl) \
    SHADER_PARAMETER_ARRAY(TShaderParameterScalarArrayTypeInfo<MemberType>::PackedArrayType, MemberName, [CalcPackedArraySize(TShaderParameterTypeInfo<TShaderParameterScalarArrayTypeInfo<MemberType>::PackedArrayType ArrayDecl>::NumElements)])
 
#define GET_SCALAR_ARRAY_ELEMENT(PackedArray, ElementIndex) \
    PackedArray[CalcPackedArrayIndex(ElementIndex)][CalcPackedComponentIndex(ElementIndex)]
 
PGO_LINK_ENABLE_WARNINGS