ShaderKeyGenerator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Misc/StringBuilder.h"
#include "Templates/Function.h"
#include "UObject/NameTypes.h"
 
class FSHAHash;
struct FBlake3Hash;
struct FGuid;
 
class FShaderKeyGenerator
{
public:
    inline FShaderKeyGenerator(TUniqueFunction<void(const void* Data, uint64 Size)>&& InResultFunc);
    inline FShaderKeyGenerator(FString& InResultString);
    inline ~FShaderKeyGenerator();
 
    inline bool IsBinary() const;
    inline bool IsText() const;
 
    inline void BinaryAppend(const void* Data, uint64 Size);
    inline FString& TextGetResultString();
 
    inline void Append(FStringView Value);
    inline void Append(const TCHAR* Value);
    inline void Append(FName Value);
    inline void Append(int64 Value);
    inline void Append(uint64 Value);
    inline void Append(int32 Value);
    inline void Append(uint32 Value);
    inline void AppendHex(uint32 Value);
    inline void AppendBoolInt(bool Value);
    CORE_API void Append(const FBlake3Hash& Value);
    CORE_API void Append(const FGuid& Value);
    CORE_API void Append(const FSHAHash& Value);
 
    inline void AppendDebugText(FStringView Value);
    inline void AppendSeparator();
 
private:
    enum class EOutputType
    {
        Text,
        Binary,
    };
 
private:
    TUniqueFunction<void(const void* Data, uint64 Size)> ResultFunc;
    FString* ResultString = nullptr;
    EOutputType OutputType = EOutputType::Text;
};
 
 
// Global functions taking FShaderKeyGenerator argument
 
template <typename T>
void Append(FShaderKeyGenerator& KeyGen, TConstArrayView<T> Value);
 
template <typename T>
void Append(FShaderKeyGenerator& KeyGen, const TArray<T>& Value);
 
// template <typename T>
// FShaderKeyGenerator& operator<<(FShaderKeyGenerator& KeyGen, const T& Value);
 
 
// Inline implementations
 
inline FShaderKeyGenerator::FShaderKeyGenerator(TUniqueFunction<void(const void* Data, uint64 Size)>&& InResultFunc)
    : ResultFunc(MoveTemp(InResultFunc))
    , OutputType(EOutputType::Binary)
{
}
 
inline FShaderKeyGenerator::FShaderKeyGenerator(FString& InResultString)
    : ResultString(&InResultString)
    , OutputType(EOutputType::Text)
{
}
 
// This destructor needs to be defined so that it can be called manually from union destructors.
inline FShaderKeyGenerator::~FShaderKeyGenerator() = default;
 
inline bool FShaderKeyGenerator::IsBinary() const
{
    return OutputType == EOutputType::Binary;
}
 
inline bool FShaderKeyGenerator::IsText() const
{
    return OutputType == EOutputType::Text;
}
 
inline void FShaderKeyGenerator::BinaryAppend(const void* Data, uint64 Size)
{
    check(IsBinary());
    ResultFunc(Data, Size);
}
 
inline FString& FShaderKeyGenerator::TextGetResultString()
{
    check(IsText());
    return *ResultString;
}
 
inline void FShaderKeyGenerator::Append(FStringView Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->Append(Value);
        return;
    case EOutputType::Binary:
        ResultFunc(Value.GetData(), Value.Len() * sizeof(Value.GetData()[0]));
        return;
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::Append(const TCHAR* Value)
{
    Append(FStringView(Value));
}
 
inline void FShaderKeyGenerator::Append(FName Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        Value.AppendString(*ResultString);
        return;
    case EOutputType::Binary:
    {
        TStringBuilder<FName::StringBufferSize> Builder(InPlace, Value);
        ResultFunc(Builder.GetData(), Builder.Len() * sizeof(Builder.GetData()[0]));
        return;
    }
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::Append(int64 Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->Appendf(TEXT(INT64_FMT), Value);
        return;
    case EOutputType::Binary:
        ResultFunc(&Value, sizeof(Value));
        return;
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::Append(uint64 Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->Appendf(TEXT(UINT64_FMT), Value);
        return;
    case EOutputType::Binary:
        ResultFunc(&Value, sizeof(Value));
        return;
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::Append(int32 Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->Appendf(TEXT("%d"), Value);
        return;
    case EOutputType::Binary:
        ResultFunc(&Value, sizeof(Value));
        return;
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::Append(uint32 Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->Appendf(TEXT("%u"), Value);
        return;
    case EOutputType::Binary:
        ResultFunc(&Value, sizeof(Value));
        return;
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::AppendHex(uint32 Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->Appendf(TEXT("%X"), Value);
        return;
    case EOutputType::Binary:
        ResultFunc(&Value, sizeof(Value));
        return;
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::AppendBoolInt(bool Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->AppendChar(Value ? '1' : '0');
        return;
    case EOutputType::Binary:
    {
        uint8 SizedValue = Value ? 1 : 0;
        ResultFunc(&SizedValue, sizeof(SizedValue));
        return;
    }
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::AppendDebugText(FStringView Value)
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->Append(Value);
        return;
    case EOutputType::Binary:
        // Binary output ignores DebugText
        return;
    default:
        checkNoEntry();
    }
}
 
inline void FShaderKeyGenerator::AppendSeparator()
{
    switch (OutputType)
    {
    case EOutputType::Text:
        ResultString->AppendChar('_');
        return;
    case EOutputType::Binary:
        // Binary output ignores DebugText; Separator is a type of DebugText
        return;
    default:
        checkNoEntry();
    }
}
 
template <typename T>
void Append(FShaderKeyGenerator& KeyGen, const TArray<T>& Value)
{
    Append(KeyGen, TConstArrayView<T>(Value));
}
 
template <typename T>
void Append(FShaderKeyGenerator& KeyGen, TConstArrayView<T> Value)
{
    for (const T& Element : Value)
    {
        KeyGen << Element;
    }
}
 
template <typename T, typename = int>
struct IsFShaderKeyGeneratorKnownType
 : std::false_type
{
};
 
template <typename T>
struct IsFShaderKeyGeneratorKnownType<T, decltype(std::declval<FShaderKeyGenerator>().Append(std::declval<T>()), 0)>
 : std::true_type
{
};
 
template <typename T>
typename std::enable_if<IsFShaderKeyGeneratorKnownType<T>::value, FShaderKeyGenerator&>::type
operator<<(FShaderKeyGenerator& KeyGen, const T& Value)
{
    KeyGen.Append(Value);
    return KeyGen;
}
 
template <typename T>
typename std::enable_if<!IsFShaderKeyGeneratorKnownType<T>::value, FShaderKeyGenerator&>::type
operator<<(FShaderKeyGenerator& KeyGen, const T& Value)
{
    Append(KeyGen, Value);
    return KeyGen;
}