ShaderPermutation.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ShaderPermutation.h: All shader permutation's compile time API.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "ShaderCore.h"
 
// Enable this to log the parameters of each compiled permutation
inline constexpr bool bLogPermutations = false;
 
struct FShaderCompilerEnvironment;
 
// Flags that can specialize shader permutations compiled for specific platforms
enum class EShaderPermutationFlags : uint32
{
    None = 0u,
    HasEditorOnlyData = (1u << 0),
    IsODSCOnly = (1u << 1),
};
ENUM_CLASS_FLAGS(EShaderPermutationFlags);
 
struct FShaderPermutationParameters
{
    // Shader platform to compile to.
    const EShaderPlatform Platform;
 
    // Unique permutation identifier of the material shader type.
    const int32 PermutationId;
 
    // Flags that describe the permutation
    const EShaderPermutationFlags Flags;
 
    // Default to include editor-only shaders, to maintain backwards-compatibility
    explicit FShaderPermutationParameters(EShaderPlatform InPlatform, int32 InPermutationId = 0, EShaderPermutationFlags InFlags = EShaderPermutationFlags::HasEditorOnlyData)
        : Platform(InPlatform)
        , PermutationId(InPermutationId)
        , Flags(InFlags)
    {
    }
};
 
struct FShaderPermutationBool
{
    using Type = bool;
 
    static constexpr int32 PermutationCount = 2;
 
    static constexpr bool IsMultiDimensional = false;
 
 
    static int32 ToDimensionValueId(Type E)
    {
        return E ? 1 : 0;
    }
 
    static bool ToDefineValue(Type E)
    {
        return E;
    }
 
    static Type FromDimensionValueId(int32 PermutationId)
    {
        checkf(PermutationId == 0 || PermutationId == 1, TEXT("Invalid shader permutation dimension id %i."), PermutationId);
        return PermutationId == 1;
    }
};
 
 
template <typename TType, int32 TDimensionSize, int32 TFirstValue=0>
struct TShaderPermutationInt
{
    using Type = TType;
 
    static constexpr int32 PermutationCount = TDimensionSize;
    
    static constexpr bool IsMultiDimensional = false;
    
    static constexpr Type MinValue = static_cast<Type>(TFirstValue);
    static constexpr Type MaxValue = static_cast<Type>(TFirstValue + TDimensionSize - 1);
 
 
    static int32 ToDimensionValueId(Type E)
    {
        int32 PermutationId = static_cast<int32>(E) - TFirstValue;
        checkf(PermutationId < PermutationCount && PermutationId >= 0, TEXT("Unknown shader permutation dimension value id %i."), PermutationId);
        return PermutationId;
    }
 
    static int32 ToDefineValue(Type E)
    {
        return ToDimensionValueId(E) + TFirstValue;
    }
 
    static Type FromDimensionValueId(int32 PermutationId)
    {
        checkf(PermutationId < PermutationCount && PermutationId >= 0, TEXT("Invalid shader permutation dimension value id %i."), PermutationId);
        return static_cast<Type>(PermutationId + TFirstValue);
    }
};
 
 
template <int32... Ts>
struct TShaderPermutationSparseInt
{
    using Type = int32;
 
    static constexpr int32 PermutationCount = 0;
    
    static constexpr bool IsMultiDimensional = false;
 
 
    static int32 ToDimensionValueId(Type E)
    {
        checkf(false, TEXT("Unknown shader permutation dimension value %i."), E);
        return int32(0);
    }
 
    static Type FromDimensionValueId(int32 PermutationId)
    {
        checkf(false, TEXT("Invalid shader permutation dimension id %i."), PermutationId);
        return Type(0);
    }
};
 
template <int32 TUniqueValue, int32... Ts>
struct TShaderPermutationSparseInt<TUniqueValue, Ts...>
{
    using Type = int32;
 
    static constexpr int32 PermutationCount = TShaderPermutationSparseInt<Ts...>::PermutationCount + 1;
    
    static constexpr bool IsMultiDimensional = false;
 
 
    static int32 ToDimensionValueId(Type E)
    {
        if (E == TUniqueValue)
        {
            return PermutationCount - 1;
        }
        return TShaderPermutationSparseInt<Ts...>::ToDimensionValueId(E);
    }
 
    static int32 ToDefineValue(Type E)
    {
        return int32(E);
    }
 
    static Type FromDimensionValueId(int32 PermutationId)
    {
        if (PermutationId == PermutationCount - 1)
        {
            return TUniqueValue;
        }
        return TShaderPermutationSparseInt<Ts...>::FromDimensionValueId(PermutationId);
    }
};
 
 
template <typename... Ts>
struct TShaderPermutationDomain
{
    using Type = TShaderPermutationDomain<Ts...>;
 
    static constexpr bool IsMultiDimensional = true;
 
    static constexpr int32 PermutationCount = 1;
 
 
    TShaderPermutationDomain<Ts...>() {}
    explicit TShaderPermutationDomain<Ts...>(int32 PermutationId)
    {
        checkf(PermutationId == 0, TEXT("Invalid shader permutation id %i."), PermutationId);
    }
 
 
    template<class DimensionToSet>
    void Set(typename DimensionToSet::Type)
    {
        // On clang, we can't do static_assert(false), because is evaluated even when method is not used. So
        // we test sizeof(DimensionToSet::Type) == 0 to make the static assert depend on the DimensionToSet
        // template parameter.
        static_assert(sizeof(typename DimensionToSet::Type) == 0, "Unknown shader permutation dimension.");
    }
 
    template<class DimensionToGet>
    const typename DimensionToGet::Type Get() const
    {
        // On clang, we can't do static_assert(false), because is evaluated even when method is not used. So
        // we test sizeof(DimensionToSet::Type) == 0 to make the static assert depend on the DimensionToGet
        // template parameter.
        static_assert(sizeof(typename DimensionToGet::Type) == 0, "Unknown shader permutation dimension.");
        return DimensionToGet::Type();
    }
 
 
    void ModifyCompilationEnvironment(FShaderCompilerEnvironment& OutEnvironment) const {}
 
 
    static int32 ToDimensionValueId(const Type& PermutationVector)
    {
        return 0;
    }
 
    int32 ToDimensionValueId() const
    {
        return ToDimensionValueId(*this);
    }
 
 
    static Type FromDimensionValueId(const int32 PermutationId)
    {
        return Type(PermutationId);
    }
 
 
    bool operator==(const Type& Other) const
    {
        return true;
    }
};
 
 
// C++11 doesn't allow partial specialization of templates method or function. So we spetialise class that have
// non spetialised static method, but leave templated static function.
template<bool BooleanSpecialization>
class TShaderPermutationDomainSpetialization
{
public:
 
    template<typename TPermutationVector, typename TDimension>
    static void ModifyCompilationEnvironment(const TPermutationVector& PermutationVector, FShaderCompilerEnvironment& OutEnvironment)
    {
 
        if constexpr (bLogPermutations)
        {
            UE_LOG(LogShaders, Verbose, TEXT("      %s = %d"), TDimension::DefineName, TDimension::ToDefineValue(PermutationVector.DimensionValue));
        }
 
        OutEnvironment.SetDefine(TDimension::DefineName, TDimension::ToDefineValue(PermutationVector.DimensionValue));
        return PermutationVector.Tail.ModifyCompilationEnvironment(OutEnvironment);
    }
 
    template<typename TPermutationVector, typename TDimensionToGet>
    static const typename TDimensionToGet::Type& GetDimension(const TPermutationVector& PermutationVector)
    {
        return PermutationVector.Tail.template Get<TDimensionToGet>();
    }
 
    template<typename TPermutationVector, typename TDimensionToSet>
    static void SetDimension(TPermutationVector& PermutationVector, const typename TDimensionToSet::Type& Value)
    {
        return PermutationVector.Tail.template Set<TDimensionToSet>(Value);
    }
 
};
 
template<>
class TShaderPermutationDomainSpetialization<true>
{
public:
 
    template<typename TPermutationVector, typename TDimension>
    static void ModifyCompilationEnvironment(const TPermutationVector& PermutationVector, FShaderCompilerEnvironment& OutEnvironment)
    {
        PermutationVector.DimensionValue.ModifyCompilationEnvironment(OutEnvironment);
        return PermutationVector.Tail.ModifyCompilationEnvironment(OutEnvironment);
    }
 
    template<typename TPermutationVector, typename TDimensionToGet>
    static const typename TDimensionToGet::Type& GetDimension(const TPermutationVector& PermutationVector)
    {
        return PermutationVector.DimensionValue;
    }
 
    template<typename TPermutationVector, typename TDimensionToSet>
    static void SetDimension(TPermutationVector& PermutationVector, const typename TDimensionToSet::Type& Value)
    {
        PermutationVector.DimensionValue = Value;
    }
 
};
 
 
template <typename TDimension, typename... Ts>
struct TShaderPermutationDomain<TDimension, Ts...>
{
    using Type = TShaderPermutationDomain<TDimension, Ts...>;
 
    static constexpr bool IsMultiDimensional = true;
 
    using Super = TShaderPermutationDomain<Ts...>;
 
    static constexpr int32 PermutationCount = Super::PermutationCount * TDimension::PermutationCount;
 
 
    TShaderPermutationDomain<TDimension, Ts...>()
        : DimensionValue(TDimension::FromDimensionValueId(0))
    {
    }
 
    explicit TShaderPermutationDomain<TDimension, Ts...>(int32 PermutationId)
        : DimensionValue(TDimension::FromDimensionValueId(PermutationId % TDimension::PermutationCount))
        , Tail(PermutationId / TDimension::PermutationCount)
    {
        checkf(PermutationId >= 0 && PermutationId < PermutationCount, TEXT("Invalid shader permutation id %i."), PermutationId);
    }
 
 
    template<class DimensionToSet>
    void Set(typename DimensionToSet::Type Value)
    {
        return TShaderPermutationDomainSpetialization<std::is_same_v<TDimension, DimensionToSet>>::template SetDimension<Type, DimensionToSet>(*this, Value);
    }
 
 
    template<class DimensionToGet>
    const typename DimensionToGet::Type& Get() const
    {
        return TShaderPermutationDomainSpetialization<std::is_same_v<TDimension, DimensionToGet>>::template GetDimension<Type, DimensionToGet>(*this);
    }
 
 
    inline const typename Super::Type& GetTail() const
    {
        return Tail;
    }
 
 
    void ModifyCompilationEnvironment(FShaderCompilerEnvironment& OutEnvironment) const
    {
        TShaderPermutationDomainSpetialization<TDimension::IsMultiDimensional>::template ModifyCompilationEnvironment<Type, TDimension>(*this, OutEnvironment);
    }
 
 
    static int32 ToDimensionValueId(const Type& PermutationVector)
    {
        return PermutationVector.ToDimensionValueId();
    }
 
    int32 ToDimensionValueId() const
    {
        return TDimension::ToDimensionValueId(DimensionValue) + TDimension::PermutationCount * Tail.ToDimensionValueId();
    }
 
 
    static Type FromDimensionValueId(const int32 PermutationId)
    {
        return Type(PermutationId);
    }
 
 
    bool operator==(const Type& Other) const
    {
        return DimensionValue == Other.DimensionValue && Tail == Other.Tail;
    }
 
    bool operator!=(const Type& Other) const
    {
        return !(*this == Other);
    }
 
private:
    template<bool BooleanSpecialization>
    friend class TShaderPermutationDomainSpetialization;
 
    typename TDimension::Type DimensionValue;
    Super Tail;
};
 
 
using FShaderPermutationNone = TShaderPermutationDomain<>;
 
 
// Internal implementation of non multi-dimensional shader permutation dimension.
#define DECLARE_SHADER_PERMUTATION_IMPL(InDefineName,PermutationMetaType,...) \
    public PermutationMetaType<__VA_ARGS__> { \
    public: \
        static constexpr const TCHAR* DefineName = TEXT(InDefineName); \
    }
 
 
#define SHADER_PERMUTATION_BOOL(InDefineName) \
    public FShaderPermutationBool { \
    public: \
        static constexpr const TCHAR* DefineName = TEXT(InDefineName); \
    }
    
#define SHADER_PERMUTATION_INT(InDefineName, Count) \
    DECLARE_SHADER_PERMUTATION_IMPL(InDefineName, TShaderPermutationInt, int32, Count)
    
#define SHADER_PERMUTATION_RANGE_INT(InDefineName, Start, Count) \
    DECLARE_SHADER_PERMUTATION_IMPL(InDefineName, TShaderPermutationInt, int32, Count, Start)
 
#define SHADER_PERMUTATION_SPARSE_INT(InDefineName,...) \
    DECLARE_SHADER_PERMUTATION_IMPL(InDefineName, TShaderPermutationSparseInt, __VA_ARGS__)
    
#define SHADER_PERMUTATION_ENUM_CLASS(InDefineName, EnumName) \
    DECLARE_SHADER_PERMUTATION_IMPL(InDefineName, TShaderPermutationInt, EnumName, static_cast<int32>(EnumName::MAX))