DiaphragmDOF.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    PostProcessDOF.h: Post process Depth of Field implementation.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "RendererInterface.h"
#include "PostProcess/PostProcessing.h"
 
class FViewInfo;
class FSceneTextureParameters;
struct FTranslucencyPassResources;
struct FTemporalAAHistory;
 
 
namespace DiaphragmDOF
{
 
// Whether DOF is enabled for the requested view.
bool IsEnabled(const FViewInfo& View);
 
FVector4f CircleDofHalfCoc(const FViewInfo& View);
 
struct FPhysicalCocModel
{
    // Size of the sensor, in unreal unit.
    float SensorWidth;
    float SensorHeight;
 
    // Aspect ratio of the croped frame being rendered.
    float RenderingAspectRatio;
 
    // Focal length of the lens in unreal unit.
    float VerticalFocalLength;
    // float HorizontalFocalLength = VerticalFocalLength / Squeeze;
 
    // Apperture diameter in fstop
    float FStops; // = VerticalFocalLength / ApartureDiameter.
 
    // Unclamped background vertical coc radius, in horizontal ViewportUV unit.
    float InfinityBackgroundCocRadius;
    // HorizontalInfinityBackgroundCocRadius = InfinityBackgroundCocRadius / Squeeze
    // VerticalInfinityBackgroundCocRadius = InfinityBackgroundCocRadius
 
    bool bEnableDynamicOffset;
 
    float InFocusRadius;
 
    FRHITexture* DynamicRadiusOffsetLUT;
 
    // Resolution less minimal foreground coc radius < 0.
    float MinForegroundCocRadius;
 
    // Resolution less maximal background coc radius.
    float MaxBackgroundCocRadius;
 
    // Focus distance in unreal unit.
    float FocusDistance;
 
    // SqueezeFactor = VerticalFocalDistance / HorizontalFocalDistance
    float Squeeze;
 
    // Swirly bokeh Petzval lens effect
    float Petzval;
    float PetzvalFalloffPower;
    FVector2f PetzvalExclusionBoxExtents;
    float PetzvalExclusionBoxRadius;
    float BarrelRadius;
    float BarrelLength;
 
    static const uint32 MaxMatteBoxFlags = 3;
    TStaticArray<FMatteBoxFlag, MaxMatteBoxFlags> MatteBoxFlags;
 
    // The maximum radius of depth blur.
    float MaxDepthBlurRadius;
    float DepthBlurExponent;
 
    void Compile(const FViewInfo& View);
    
    FVector2f GetLensRadius() const;
 
    float DepthToResCocRadius(float SceneDepth, float HorizontalResolution) const;
 
    FORCEINLINE float ComputeViewMaxBackgroundCocRadius(float HorizontalResolution) const
    {
        // Dynamic CoC offset is designed to go to zero at infinite distance, so we don't need to factor it into the max background radius
        return FMath::Min(FMath::Max(InfinityBackgroundCocRadius, MaxDepthBlurRadius), MaxBackgroundCocRadius) * HorizontalResolution;
    }
    
    FORCEINLINE float ComputeViewMinForegroundCocRadius(float HorizontalResolution) const
    {
        return DepthToResCocRadius(GNearClippingPlane, HorizontalResolution);
    }
 
private:
    float GetCocOffset(float CocRadius) const;
};
 
 
enum class EBokehShape
{
    // No blade simulation.
    Circle,
 
    // Diaphragm's blades are straight.
    StraightBlades,
 
    // Diaphragm's blades are circle with a radius matching largest aperture of the lens system settings.
    RoundedBlades,
};
 
 
struct FBokehModel
{
    // Shape of the bokeh.
    EBokehShape BokehShape;
 
    // Scale factor to transform a CocRadius to CircumscribedRadius or in circle radius.
    float CocRadiusToCircumscribedRadius;
    float CocRadiusToIncircleRadius;
 
    // Number of blades of the diaphragm.
    int32 DiaphragmBladeCount;
    
    // Rotation angle of the diaphragm in radians.
    float DiaphragmRotation;
 
    // BokehShape == RoundedBlades specific parameters.
    struct
    {
        // Radius of the blade for a boked area=PI.
        float DiaphragmBladeRadius;
 
        // Offset of the center of the blade's circle from the center of the bokeh.
        float DiaphragmBladeCenterOffset;
    } RoundedBlades;
 
    float Squeeze;
 
    void Compile(const FViewInfo& View, const FPhysicalCocModel& CocModel);
 
    bool operator==(const FBokehModel& Other) const
    {
        return BokehShape == Other.BokehShape
            && CocRadiusToCircumscribedRadius == Other.CocRadiusToCircumscribedRadius
            && CocRadiusToIncircleRadius == Other.CocRadiusToIncircleRadius
            && DiaphragmBladeCount == Other.DiaphragmBladeCount
            && DiaphragmRotation == Other.DiaphragmRotation
            && RoundedBlades.DiaphragmBladeRadius == Other.RoundedBlades.DiaphragmBladeRadius
            && RoundedBlades.DiaphragmBladeCenterOffset == Other.RoundedBlades.DiaphragmBladeCenterOffset
            && Squeeze == Other.Squeeze;
    }
 
    bool operator!=(const FBokehModel& Other) const
    {
        return !(*this == Other);
    }
};
 
RENDERER_API bool IsSupported(const FStaticShaderPlatform ShaderPlatform);
 
RENDERER_API bool AddPasses(
    FRDGBuilder& GraphBuilder,
    const FSceneTextureParameters& SceneTextures,
    const FViewInfo& View,
    FRDGTextureRef InputSceneColor,
    const FTranslucencyPassResources& TranslucencyViewResources,
    FRDGTextureRef& OutputColor);
 
 
BEGIN_SHADER_PARAMETER_STRUCT(FDOFCocModelShaderParameters, )
    SHADER_PARAMETER(float, CocInfinityRadius)
    SHADER_PARAMETER(float, CocInFocusRadius)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, DynamicRadiusOffsetLUT)
    SHADER_PARAMETER_SAMPLER(SamplerState, DynamicRadiusOffsetLUTSampler)
    SHADER_PARAMETER(uint32, bCocEnableDynamicRadiusOffset)
    SHADER_PARAMETER(float, CocMinRadius)
    SHADER_PARAMETER(float, CocMaxRadius)
    SHADER_PARAMETER(float, CocSqueeze)
    SHADER_PARAMETER(float, CocInvSqueeze)
    SHADER_PARAMETER(float, DepthBlurRadius)
    SHADER_PARAMETER(float, DepthBlurExponent)
END_SHADER_PARAMETER_STRUCT()
 
void SetCocModelParameters(
    FRDGBuilder& GraphBuilder,
    FDOFCocModelShaderParameters* OutParameters,
    const FPhysicalCocModel& CocModel,
    float CocRadiusBasis = 1.0f);
 
} // namespace DiaphragmDOF