MaterialKeyGeneratorContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if WITH_EDITOR
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "MaterialKeyIncludeEnum.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/StringBuilder.h"
#include "RHIShaderPlatform.h"
#include "Serialization/CompactBinary.h"
#include "Serialization/CompactBinaryWriter.h"
#include "Serialization/ShaderKeyGenerator.h"
#include "Templates/Function.h"
#include "UObject/NameTypes.h"
 
class FMaterialKeyGeneratorContext
{
public:
    enum class EMode : uint8
    {
        Emitting,
        Saving,
        Loading,
    };
 
public:
    ENGINE_API FMaterialKeyGeneratorContext(TUniqueFunction<void(const void* Data, uint64 Size)>&& HashFunction,
        EShaderPlatform InShaderPlatform);
    ENGINE_API FMaterialKeyGeneratorContext(FString& InResultString, EShaderPlatform InShaderPlatform);
    ENGINE_API FMaterialKeyGeneratorContext(FCbWriter& InWriter, EShaderPlatform InShaderPlatform);
    ENGINE_API FMaterialKeyGeneratorContext(FCbObjectView LoadRoot, EShaderPlatform InShaderPlatform);
    ENGINE_API ~FMaterialKeyGeneratorContext();
 
    inline void AddFlags(EMaterialKeyInclude Flags);
    inline void RemoveFlags(EMaterialKeyInclude Flags);
    inline void SetFlags(EMaterialKeyInclude Flags, bool bIncluded);
    inline bool HasAllFlags(EMaterialKeyInclude Flags) const;
    inline EMaterialKeyInclude GetFlags() const;
 
    inline EMode GetMode() const;
    inline bool IsEmitting() const;
    inline bool IsRecording() const;
    inline bool IsSaving() const;
    inline bool IsLoading() const;
    inline EShaderPlatform GetShaderPlatform() const;
    inline FName GetShaderFormat() const;
 
    template <typename T>
    inline void RecordAndEmit(FUtf8StringView Name, T&& Data);
 
    template <typename T>
    inline void Record(FUtf8StringView Name, T&& Data);
    ENGINE_API void RecordObjectStart(FUtf8StringView Name);
    ENGINE_API void RecordObjectEnd();
    inline void PostLoad(TFunctionRef<void()> Action);
 
    template <typename T>
    inline void Emit(T&& Data);
    inline void EmitFunc(TFunctionRef<void(FShaderKeyGenerator&)> Callback);
    inline void EmitDebugText(FStringView Data);
    inline void EmitSeparator();
    inline void EmitBoolInt(bool Data);
    inline FShaderKeyGenerator* GetKeyGenIfEmitting();
    inline FShaderKeyGenerator& GetKeyGenIfEmittingChecked();
 
    inline bool HasLoadError() const;
 
private:
    FCbObjectView GetCurrentObject();
 
private:
    union
    {
        FShaderKeyGenerator KeyGen;
        TArray<FCbObjectView, TInlineAllocator<2>> ObjectStack;
        FCbWriter* Writer;
    };
    FName ShaderFormat;
    EShaderPlatform ShaderPlatform = EShaderPlatform::SP_NumPlatforms;
    EMode Mode = EMode::Emitting;
    EMaterialKeyInclude IncludeFlags = EMaterialKeyInclude::All;
    bool bHasLoadError = false;
};
 
ENUM_CLASS_FLAGS(EMaterialKeyInclude);
 
// Inline implementations
 
inline void FMaterialKeyGeneratorContext::AddFlags(EMaterialKeyInclude Flags)
{
    EnumAddFlags(IncludeFlags, Flags);
}
 
inline void FMaterialKeyGeneratorContext::RemoveFlags(EMaterialKeyInclude Flags)
{
    EnumRemoveFlags(IncludeFlags, Flags);
}
 
inline void FMaterialKeyGeneratorContext::SetFlags(EMaterialKeyInclude Flags, bool bIncluded)
{
    if (bIncluded)
    {
        AddFlags(Flags);
    }
    else
    {
        RemoveFlags(Flags);
    }
}
 
inline bool FMaterialKeyGeneratorContext::HasAllFlags(EMaterialKeyInclude Flags) const
{
    return EnumHasAllFlags(IncludeFlags, Flags);
}
 
inline EMaterialKeyInclude FMaterialKeyGeneratorContext::GetFlags() const
{
    return IncludeFlags;
}
 
FMaterialKeyGeneratorContext::EMode FMaterialKeyGeneratorContext::GetMode() const
{
    return Mode;
}
 
inline bool FMaterialKeyGeneratorContext::IsEmitting() const
{
    return Mode == EMode::Emitting;
}
 
inline bool FMaterialKeyGeneratorContext::IsRecording() const
{
    return (Mode == EMode::Saving) | (Mode == EMode::Loading);
}
 
inline bool FMaterialKeyGeneratorContext::IsSaving() const
{
    return Mode == EMode::Saving;
}
 
inline bool FMaterialKeyGeneratorContext::IsLoading() const
{
    return Mode == EMode::Loading;
}
 
inline EShaderPlatform FMaterialKeyGeneratorContext::GetShaderPlatform() const
{
    return ShaderPlatform;
}
 
inline FName FMaterialKeyGeneratorContext::GetShaderFormat() const
{
    return ShaderFormat;
}
 
template <typename T>
inline void FMaterialKeyGeneratorContext::RecordAndEmit(FUtf8StringView Name, T&& Data)
{
    Record(Name, Data);
    Emit(Data);
}
 
template <typename T>
inline void FMaterialKeyGeneratorContext::Record(FUtf8StringView Name, T&& Data)
{
    switch (Mode)
    {
    case EMode::Emitting:
        break;
    case EMode::Saving:
        *Writer << Name << Data;
        break;
    case EMode::Loading:
        if (!LoadFromCompactBinary(GetCurrentObject()[Name], Data))
        {
            bHasLoadError = true;
        }
        break;
    default:
        checkNoEntry();
        break;
    }
}
 
inline void FMaterialKeyGeneratorContext::PostLoad(TFunctionRef<void()> Action)
{
    if (Mode == EMode::Loading)
    {
        Action();
    }
}
 
template <typename T>
inline void FMaterialKeyGeneratorContext::Emit(T&& Data)
{
    if (Mode == EMode::Emitting)
    {
        KeyGen << Data;
    }
}
 
inline void FMaterialKeyGeneratorContext::EmitFunc(TFunctionRef<void(FShaderKeyGenerator&)> Callback)
{
    if (Mode == EMode::Emitting)
    {
        Callback(KeyGen);
    }
}
 
inline void FMaterialKeyGeneratorContext::EmitDebugText(FStringView Data)
{
    if (Mode == EMode::Emitting)
    {
        KeyGen.AppendDebugText(Data);
    }
}
 
inline void FMaterialKeyGeneratorContext::EmitSeparator()
{
    if (Mode == EMode::Emitting)
    {
        KeyGen.AppendSeparator();
    }
}
 
inline void FMaterialKeyGeneratorContext::EmitBoolInt(bool Data)
{
    if (Mode == EMode::Emitting)
    {
        KeyGen.AppendBoolInt(Data);
    }
}
 
inline FShaderKeyGenerator* FMaterialKeyGeneratorContext::GetKeyGenIfEmitting()
{
    if (Mode == EMode::Emitting)
    {
        return &KeyGen;
    }
    return nullptr;
}
 
inline FShaderKeyGenerator& FMaterialKeyGeneratorContext::GetKeyGenIfEmittingChecked()
{
    check(Mode == EMode::Emitting);
    return KeyGen;
}
 
inline bool FMaterialKeyGeneratorContext::HasLoadError() const
{
    return Mode != EMode::Loading || bHasLoadError;
}
 
#endif