SimpleElementShaders.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*==============================================================================
    SimpleElementShaders.h: Definitions for simple element shaders.
==============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "ShaderParameters.h"
#include "Shader.h"
#include "GlobalShader.h"
#include "SceneTypes.h"
#include "Engine/EngineTypes.h"
#include "DataDrivenShaderPlatformInfo.h"
 
class FSceneView;
struct FDFRelativeViewMatrices;
 
class FSimpleElementVS : public FGlobalShader
{
    DECLARE_EXPORTED_GLOBAL_SHADER(FSimpleElementVS, ENGINE_API);
public:
    FSimpleElementVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementVS() {}
 
    ENGINE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FMatrix& WorldToClipMatrix);
    ENGINE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FDFRelativeViewMatrices& Matrices, const FDFRelativeViewMatrices& InstancedViewMatrices);
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FDFRelativeViewMatrices& Matrices)
    {
        SetParameters(BatchedParameters, Matrices, Matrices);
    }
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment);
 
private:
    LAYOUT_FIELD(FShaderParameter, RelativeTransform);
    LAYOUT_FIELD(FShaderParameter, TransformPositionHigh);
};
 
class FSimpleElementPS : public FGlobalShader
{
    DECLARE_SHADER_TYPE(FSimpleElementPS, Global);
public:
    FSimpleElementPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementPS() {}
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FTexture* TextureValue);
    void SetEditorCompositingParameters(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView* View);
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView* View, const FTexture* TextureValue);
 
private:
    LAYOUT_FIELD(FShaderResourceParameter, InTexture)
    LAYOUT_FIELD(FShaderResourceParameter, InTextureSampler)
    LAYOUT_FIELD(FShaderParameter, TextureComponentReplicate)
    LAYOUT_FIELD(FShaderParameter, TextureComponentReplicateAlpha)
    LAYOUT_FIELD(FShaderParameter, EditorCompositeDepthTestParameter)
    LAYOUT_FIELD(FShaderParameter, ScreenToPixel)
};
 
class FSimpleElementAlphaOnlyPS : public FSimpleElementPS
{
    DECLARE_SHADER_TYPE(FSimpleElementAlphaOnlyPS, Global);
public:
 
    FSimpleElementAlphaOnlyPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementAlphaOnlyPS() {}
};
 
class FSimpleElementGammaBasePS : public FSimpleElementPS
{
    DECLARE_TYPE_LAYOUT(FSimpleElementGammaBasePS, NonVirtual);
public:
 
    FSimpleElementGammaBasePS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementGammaBasePS() {}
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FTexture* Texture, float GammaValue, ESimpleElementBlendMode BlendMode);
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView* View, const FTexture* Texture, float GammaValue, ESimpleElementBlendMode BlendMode);
 
private:
    LAYOUT_FIELD(FShaderParameter, Gamma)
};
 
template <bool bSRGBTexture>
class FSimpleElementGammaPS : public FSimpleElementGammaBasePS
{
    DECLARE_SHADER_TYPE(FSimpleElementGammaPS, Global);
public:
    FSimpleElementGammaPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer) : FSimpleElementGammaBasePS(Initializer) {}
    FSimpleElementGammaPS() {}
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        // SRGB_INPUT_TEXTURE is now ignored, this has no effect
        // input texture gamma correction is done automatically by the sampler, controlled by TexCreate_SRGB
        OutEnvironment.SetDefine(TEXT("SRGB_INPUT_TEXTURE"), bSRGBTexture);
    }
};
 
class FSimpleElementGammaAlphaOnlyPS : public FSimpleElementGammaBasePS
{
    DECLARE_SHADER_TYPE(FSimpleElementGammaAlphaOnlyPS, Global);
public:
    FSimpleElementGammaAlphaOnlyPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer) : FSimpleElementGammaBasePS(Initializer) {}
    FSimpleElementGammaAlphaOnlyPS() {}
};
 
class FSimpleElementMaskedGammaBasePS : public FSimpleElementGammaBasePS
{
    DECLARE_TYPE_LAYOUT(FSimpleElementMaskedGammaBasePS, NonVirtual);
public:
    FSimpleElementMaskedGammaBasePS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementMaskedGammaBasePS() {}
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FTexture* Texture,float Gamma,float ClipRefValue,ESimpleElementBlendMode BlendMode);
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FSceneView* View, const FTexture* Texture,float Gamma,float ClipRefValue,ESimpleElementBlendMode BlendMode);
 
private:
    LAYOUT_FIELD(FShaderParameter, ClipRef)
};
 
template <bool bSRGBTexture>
class FSimpleElementMaskedGammaPS : public FSimpleElementMaskedGammaBasePS
{
    DECLARE_SHADER_TYPE(FSimpleElementMaskedGammaPS, Global);
public:
    FSimpleElementMaskedGammaPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer) : FSimpleElementMaskedGammaBasePS(Initializer) {}
    FSimpleElementMaskedGammaPS() {}
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        OutEnvironment.SetDefine(TEXT("SRGB_INPUT_TEXTURE"), bSRGBTexture);
    }
};
 
class FSimpleElementDistanceFieldGammaPS : public FSimpleElementMaskedGammaBasePS
{
    DECLARE_SHADER_TYPE(FSimpleElementDistanceFieldGammaPS,Global);
public:
    FSimpleElementDistanceFieldGammaPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementDistanceFieldGammaPS() {}
 
    void SetParameters(
        FRHIBatchedShaderParameters& BatchedParameters,
        const FTexture* Texture,
        float Gamma,
        float ClipRef,
        float SmoothWidthValue,
        bool EnableShadowValue,
        const FVector2D& ShadowDirectionValue,
        const FLinearColor& ShadowColorValue,
        float ShadowSmoothWidthValue,
        const FDepthFieldGlowInfo& GlowInfo,
        ESimpleElementBlendMode BlendMode
        );
 
private:
    LAYOUT_FIELD(FShaderParameter, SmoothWidth)
    LAYOUT_FIELD(FShaderParameter, EnableShadow)
    LAYOUT_FIELD(FShaderParameter, ShadowDirection)
    LAYOUT_FIELD(FShaderParameter, ShadowColor) 
    
    LAYOUT_FIELD(FShaderParameter, ShadowSmoothWidth)
    LAYOUT_FIELD(FShaderParameter, EnableGlow)
    LAYOUT_FIELD(FShaderParameter, GlowColor)
    LAYOUT_FIELD(FShaderParameter, GlowOuterRadius)
    LAYOUT_FIELD(FShaderParameter, GlowInnerRadius)
};
 
class FSimpleElementHitProxyPS : public FGlobalShader
{
    DECLARE_SHADER_TYPE(FSimpleElementHitProxyPS,Global);
public:
    FSimpleElementHitProxyPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementHitProxyPS() {}
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters);
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FTexture* TextureValue);
 
private:
    LAYOUT_FIELD(FShaderResourceParameter, InTexture)
    LAYOUT_FIELD(FShaderResourceParameter, InTextureSampler)
};
 
class FSimpleElementColorChannelMaskPS : public FGlobalShader
{
    DECLARE_SHADER_TYPE(FSimpleElementColorChannelMaskPS,Global);
public:
    FSimpleElementColorChannelMaskPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer);
    FSimpleElementColorChannelMaskPS() {}
 
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters);
 
    void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FTexture* TextureValue, const FMatrix& ColorWeightsValue, float GammaValue);
 
private:
    LAYOUT_FIELD(FShaderResourceParameter, InTexture)
    LAYOUT_FIELD(FShaderResourceParameter, InTextureSampler)
    LAYOUT_FIELD(FShaderParameter, ColorWeights) 
    LAYOUT_FIELD(FShaderParameter, Gamma)
};
 
typedef FSimpleElementGammaPS<true> FSimpleElementGammaPS_SRGB;
typedef FSimpleElementGammaPS<false> FSimpleElementGammaPS_Linear;
typedef FSimpleElementMaskedGammaPS<true> FSimpleElementMaskedGammaPS_SRGB;
typedef FSimpleElementMaskedGammaPS<false> FSimpleElementMaskedGammaPS_Linear;