MaterialShaderType.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    MaterialShader.h: Material shader definitions.
=============================================================================*/
 
#pragma once
 
#include "Shader.h"
#include "GlobalShader.h"
 
#define IMPLEMENT_MATERIAL_SHADER_TYPE(TemplatePrefix,ShaderClass,SourceFilename,FunctionName,Frequency) \
    IMPLEMENT_SHADER_TYPE( \
        TemplatePrefix, \
        ShaderClass, \
        SourceFilename, \
        FunctionName, \
        Frequency \
        );
 
class FMaterial;
class FMaterialShaderMap;
class FMaterialShaderMapId;
class FShaderCommonCompileJob;
class FShaderCompileJob;
class FShaderKeyGenerator;
class FUniformExpressionSet;
class FVertexFactoryType;
struct FMaterialShaderParameters;
struct FMaterialShadingModelField;
enum EBlendMode : int;
enum EMaterialShadingModel : int;
enum class EShaderCompileJobPriority : uint8;
#if WITH_EDITOR
class FMaterialKeyGeneratorContext;
#endif
 
 
DECLARE_DELEGATE_RetVal_OneParam(FString, FShadingModelToStringDelegate, EMaterialShadingModel)
 
 
extern ENGINE_API FString GetShadingModelString(EMaterialShadingModel ShadingModel);
 
extern ENGINE_API FString GetShadingModelFieldString(FMaterialShadingModelField ShadingModels, const FShadingModelToStringDelegate& Delegate, const FString& Delimiter = " ");
 
extern ENGINE_API FString GetShadingModelFieldString(FMaterialShadingModelField ShadingModels);
 
extern ENGINE_API FString GetBlendModeString(EBlendMode BlendMode);
 
#if WITH_EDITOR
extern ENGINE_API FString GetMaterialShaderMapKeyString(
    const FMaterialShaderMapId& ShaderMapId,
    const FMaterialShaderParameters& ShaderParameters,
    EShaderPlatform Platform,
    bool bIncludeKeyStringShaderDependencies = true);
 
extern ENGINE_API void RecordOrEmitMaterialShaderMapKey(
    FMaterialKeyGeneratorContext& Context,
    FMaterialShaderMapId& ShaderMapId,
    FMaterialShaderParameters& ShaderParameters);
 
// Alternate arguments for RecordOrEmitMaterialShaderMapKey: Support being called with const&
// when emitting or saving.
extern ENGINE_API void RecordOrEmitMaterialShaderMapKey(
    FMaterialKeyGeneratorContext& Context,
    const FMaterialShaderMapId& ShaderMapId,
    const FMaterialShaderParameters& ShaderParameters);
inline void RecordOrEmitMaterialShaderMapKey(
    FMaterialKeyGeneratorContext& Context,
    FMaterialShaderMapId& ShaderMapId,
    FMaterialShaderParameters&& ShaderParameters)
{
    RecordOrEmitMaterialShaderMapKey(Context, ShaderMapId, ShaderParameters);
}
#endif
 
extern void UpdateMaterialShaderCompilingStats(const FMaterial* Material);
 
extern ENGINE_API void DumpMaterialStats( EShaderPlatform Platform );
 
class FMaterialShaderType : public FShaderType
{
public:
    struct CompiledShaderInitializerType : FGlobalShaderType::CompiledShaderInitializerType
    {
        const FUniformExpressionSet& UniformExpressionSet;
        const FString DebugDescription;
 
        CompiledShaderInitializerType(
            const FShaderType* InType,
            int32 InPermutationId,
            const FShaderCompilerOutput& CompilerOutput,
            const FUniformExpressionSet& InUniformExpressionSet,
            const FSHAHash& InMaterialShaderMapHash,
            const FShaderPipelineType* InShaderPipeline,
            const FVertexFactoryType* InVertexFactoryType,
            const FString& InDebugDescription
            )
        : FGlobalShaderType::CompiledShaderInitializerType(
            InType, 
            nullptr, 
            InPermutationId,
            CompilerOutput,
            InMaterialShaderMapHash,
            InShaderPipeline,
            InVertexFactoryType
            )
        , UniformExpressionSet(InUniformExpressionSet)
        , DebugDescription(InDebugDescription)
        {}
    };
 
    IMPLEMENT_SHADER_TYPE_CONSTRUCTOR(FMaterialShaderType, EShaderTypeForDynamicCast::Material, TEXT("material shader"));
 
#if WITH_EDITOR
    void BeginCompileShader(
        EShaderCompileJobPriority Priority,
        uint32 ShaderMapJobId,
        int32 PermutationId,
        const FMaterial* Material,
        const FMaterialShaderMapId& ShaderMapId,
        FSharedShaderCompilerEnvironment* MaterialEnvironment,
        EShaderPlatform Platform,
        EShaderPermutationFlags PermutationFlags,
        TArray<TRefCountPtr<FShaderCommonCompileJob>>& NewJobs,
        const FString& DebugGroupName,
        const TCHAR* DebugDescription,
        const TCHAR* DebugExtension
    ) const;
 
    static void BeginCompileShaderPipeline(
        EShaderCompileJobPriority Priority,
        uint32 ShaderMapJobId,
        EShaderPlatform Platform,
        EShaderPermutationFlags PermutationFlags,
        const FMaterial* Material,
        const FMaterialShaderMapId& ShaderMapId,
        FSharedShaderCompilerEnvironment* MaterialEnvironment,
        const FShaderPipelineType* ShaderPipeline,
        TArray<TRefCountPtr<FShaderCommonCompileJob>>& NewJobs,
        const FString& DebugGroupName,
        const TCHAR* DebugDescription,
        const TCHAR* DebugExtension
    );
 
    FShader* FinishCompileShader(
        const FUniformExpressionSet& UniformExpressionSet,
        const FSHAHash& MaterialShaderMapHash,
        const FShaderCompileJob& CurrentJob,
        const FShaderPipelineType* ShaderPipeline,
        const FString& InDebugDescription
        ) const;
#endif // WITH_EDITOR
 
    bool ShouldCompilePermutation(EShaderPlatform Platform, const FMaterialShaderParameters& MaterialParameters, int32 PermutationId, EShaderPermutationFlags Flags) const;
 
    static bool ShouldCompilePipeline(const FShaderPipelineType* ShaderPipelineType, EShaderPlatform Platform, const FMaterialShaderParameters& MaterialParameters, EShaderPermutationFlags Flags);
 
#if WITH_EDITOR
    void SetupCompileEnvironment(EShaderPlatform Platform, const FMaterialShaderParameters& MaterialParameters, int32 PermutationId, EShaderPermutationFlags Flags, FShaderCompilerEnvironment& Environment) const;
#endif // WITH_EDITOR
};
 
struct FMaterialShaderTypes
{
    const FShaderPipelineType* PipelineType;
    const FShaderType* ShaderType[SF_NumFrequencies];
    int32 PermutationId[SF_NumFrequencies];
 
    inline FMaterialShaderTypes() : PipelineType(nullptr) { FMemory::Memzero(ShaderType); FMemory::Memzero(PermutationId); }
 
    inline const FShaderType* AddShaderType(const FShaderType* InType, int32 InPermutationId = 0)
    {
        const EShaderFrequency Frequency = InType->GetFrequency();
        check(ShaderType[Frequency] == nullptr);
        ShaderType[Frequency] = InType;
        PermutationId[Frequency] = InPermutationId;
        return InType;
    }
 
    template<typename ShaderType>
    inline const FShaderType* AddShaderType(int32 InPermutationId = 0)
    {
        return AddShaderType(&ShaderType::GetStaticType(), InPermutationId);
    }
};
 
struct FMaterialShaders
{
    const FShaderMapBase* ShaderMap;
    FShaderPipeline* Pipeline;
    FShader* Shaders[SF_NumFrequencies];
 
    inline FMaterialShaders() : ShaderMap(nullptr), Pipeline(nullptr) { FMemory::Memzero(Shaders); }
 
    bool TryGetPipeline(FShaderPipelineRef& OutPipeline) const
    {
        if (Pipeline)
        {
            OutPipeline = FShaderPipelineRef(Pipeline, *ShaderMap);
            return true;
        }
        return false;
    }
 
    template<typename ShaderType>
    inline bool TryGetShader(EShaderFrequency InFrequency, TShaderRef<ShaderType>& OutShader) const
    {
        FShader* Shader = Shaders[InFrequency];
        if (Shader)
        {
            checkSlow(Shader->GetFrequency() == InFrequency);
            OutShader = TShaderRef<ShaderType>(static_cast<ShaderType*>(Shader), *ShaderMap);
            // FTypeLayoutDesc::operator== doesn't work correctly in all cases, when dealing with inline/templated types
            //checkfSlow(OutShader.GetType()->GetLayout().IsDerivedFrom(StaticGetTypeLayoutDesc<ShaderType>()), TEXT("Invalid cast of shader type '%s' to '%s'"),
            //  OutShader.GetType()->GetName(),
            //  StaticGetTypeLayoutDesc<ShaderType>().Name);
            return true;
        }
        return false;
    }
 
    template<typename ShaderType>
    inline bool TryGetShader(EShaderFrequency InFrequency, TShaderRef<ShaderType>* OutShader) const
    {
        FShader* Shader = Shaders[InFrequency];
        if (Shader)
        {
            checkSlow(Shader->GetFrequency() == InFrequency);
            check(OutShader); // make sure output isn't null, if we have the shader
            *OutShader = TShaderRef<ShaderType>(static_cast<ShaderType*>(Shader), *ShaderMap);
            // FTypeLayoutDesc::operator== doesn't work correctly in all cases, when dealing with inline/templated types
            //checkfSlow(OutShader.GetType()->GetLayout().IsDerivedFrom(StaticGetTypeLayoutDesc<ShaderType>()), TEXT("Invalid cast of shader type '%s' to '%s'"),
            //  OutShader.GetType()->GetName(),
            //  StaticGetTypeLayoutDesc<ShaderType>().Name);
            return true;
        }
        return false;
    }
 
    template<typename ShaderType> inline bool TryGetVertexShader(TShaderRef<ShaderType>& OutShader) const { return TryGetShader(SF_Vertex, OutShader); }
    template<typename ShaderType> inline bool TryGetPixelShader(TShaderRef<ShaderType>& OutShader) const { return TryGetShader(SF_Pixel, OutShader); }
    template<typename ShaderType> inline bool TryGetGeometryShader(TShaderRef<ShaderType>& OutShader) const { return TryGetShader(SF_Geometry, OutShader); }
    template<typename ShaderType> inline bool TryGetMeshShader(TShaderRef<ShaderType>& OutShader) const { return TryGetShader(SF_Mesh, OutShader); }
    template<typename ShaderType> inline bool TryGetComputeShader(TShaderRef<ShaderType>& OutShader) const { return TryGetShader(SF_Compute, OutShader); }
 
    template<typename ShaderType> inline bool TryGetVertexShader(TShaderRef<ShaderType>* OutShader) const { return TryGetShader(SF_Vertex, OutShader); }
    template<typename ShaderType> inline bool TryGetPixelShader(TShaderRef<ShaderType>* OutShader) const { return TryGetShader(SF_Pixel, OutShader); }
    template<typename ShaderType> inline bool TryGetGeometryShader(TShaderRef<ShaderType>* OutShader) const { return TryGetShader(SF_Geometry, OutShader); }
    template<typename ShaderType> inline bool TryGetMeshShader(TShaderRef<ShaderType>* OutShader) const { return TryGetShader(SF_Mesh, OutShader); }
    template<typename ShaderType> inline bool TryGetComputeShader(TShaderRef<ShaderType>* OutShader) const { return TryGetShader(SF_Compute, OutShader); }
};