SceneView.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Templates/SharedPointer.h"
#include "ConvexVolume.h"
#include "DebugViewModeHelpers.h"
#include "DynamicRenderScaling.h"
#include "EngineDefines.h"
#include "FinalPostProcessSettings.h"
#include "GameTime.h"
#include "GlobalDistanceFieldConstants.h"
#include "Interfaces/Interface_PostProcessVolume.h"
#include "Math/MirrorMatrix.h"
#include "PrimitiveComponentId.h"
#include "RendererInterface.h"
#include "RenderResource.h"
#include "SceneViewOwner.h"
#include "ShowFlags.h"
#include "StereoRendering.h"
#include "StereoRenderUtils.h"
 
#define MAX_PHYSICS_FIELD_TARGETS 32
 
class FSceneView;
class FSceneViewFamily;
class FSceneViewStateInterface;
class FViewElementDrawer;
class ISceneViewExtension;
class FSceneViewFamily;
class FVolumetricFogViewResources;
class ISceneRenderer;
class ISpatialUpscaler;
struct FMinimalViewInfo;
namespace UE::RenderViewportFeedback
{
    class FCollector;
}
 
namespace UE::Renderer::Private
{
 
class ITemporalUpscaler;
 
}
 
class FRenderTarget;
 
// Projection data for a FSceneView
struct FSceneViewProjectionData
{
    FVector ViewOrigin = FVector::ZeroVector;
 
    FMatrix ViewRotationMatrix = FMatrix::Identity;
 
    FMatrix ProjectionMatrix = FMatrix::Identity;
 
    //The unconstrained (no aspect ratio bars applied) view rectangle (also unscaled)
    FIntRect ViewRect = FIntRect(0,0,0,0);
 
    //The vector (including distance) from the camera to it's viewtarget, if set. Primarily only used for Ortho views.
    FVector CameraToViewTarget = FVector::ZeroVector;
 
protected:
    // The constrained view rectangle (identical to UnconstrainedUnscaledViewRect if aspect ratio is not constrained)
    FIntRect ConstrainedViewRect = FIntRect(0,0,0,0);
 
public:
    void SetViewRectangle(const FIntRect& InViewRect)
    {
        ViewRect = InViewRect;
        ConstrainedViewRect = InViewRect;
    }
 
    void SetConstrainedViewRectangle(const FIntRect& InViewRect)
    {
        ConstrainedViewRect = InViewRect;
    }
 
    bool IsValidViewRectangle() const
    {
        return (ConstrainedViewRect.Min.X >= 0) &&
            (ConstrainedViewRect.Min.Y >= 0) &&
            (ConstrainedViewRect.Width() > 0) &&
            (ConstrainedViewRect.Height() > 0);
    }
 
    bool IsPerspectiveProjection() const
    {
        return ProjectionMatrix.M[3][3] < 1.0f;
    }
 
    const FIntRect& GetViewRect() const { return ViewRect; }
    const FIntRect& GetConstrainedViewRect() const { return ConstrainedViewRect; }
 
    FMatrix ComputeViewProjectionMatrix() const
    {
        return FTranslationMatrix(-ViewOrigin) * ViewRotationMatrix * ProjectionMatrix;
    }
 
    //Function for retrieving the NearPlane from the existing projection matrix
    static float GetNearPlaneFromProjectionMatrix(const FMatrix& ProjectionMatrix)
    {
        if (ProjectionMatrix.M[3][3] < 1.0f)
        {
            // Infinite projection with reversed Z.
            return static_cast<float>(ProjectionMatrix.M[3][2]);
        }
        else
        {
            // Ortho projection with reversed Z.
            return static_cast<float>((1.0f - ProjectionMatrix.M[3][2]) / (ProjectionMatrix.M[2][2] == 0.0f ? UE_DELTA : ProjectionMatrix.M[2][2]));
        }
    }
 
    float GetNearPlaneFromProjectionMatrix() const
    {
        return GetNearPlaneFromProjectionMatrix(ProjectionMatrix);
    }
 
    // Function for correcting Ortho camera near plane locations to avoid artifacts behind camera view origin
    static ENGINE_API bool UpdateOrthoPlanes(FSceneViewProjectionData* InOutProjectionData, float& NearPlane, float& FarPlane, float HalfOrthoWidth, bool bUseCameraHeightAsViewTarget);
    inline bool UpdateOrthoPlanes(float& NearPlane, float& FarPlane, float HalfOrthoWidth, bool bUseCameraHeightAsViewTarget)
    {
        return UpdateOrthoPlanes(this, NearPlane, FarPlane, HalfOrthoWidth, bUseCameraHeightAsViewTarget);
    }
    ENGINE_API bool UpdateOrthoPlanes(FMinimalViewInfo& MinimalViewInfo);
    ENGINE_API bool UpdateOrthoPlanes(bool bUseCameraHeightAsViewTarget);
};
 
enum class EPrimaryScreenPercentageMethod
{
    // Add spatial upscale pass at the end of post processing chain, before the secondary upscale.
    SpatialUpscale,
 
    // Let temporal AA's do the upscale.
    TemporalUpscale,
 
    // No upscaling or up sampling, just output the view rect smaller.
    // This is useful for VR's render thread dynamic resolution with MSAA.
    RawOutput,
};
 
enum class ESecondaryScreenPercentageMethod
{
    // Helpful to work on aliasing issue on HighDPI monitors.
    NearestSpatialUpscale,
 
    // Upscale to simulate smaller pixel density on HighDPI monitors.
    LowerPixelDensitySimulation,
 
    // TODO: Same config as primary upscale?
};
 
struct FFirstPersonParameters
{
    float FOVCorrectionFactor = 1.0f;
 
    float Scale = 1.0f;
 
    bool bUseParameters = false;
 
    FFirstPersonParameters() = default;
    FFirstPersonParameters(float InFOVCorrectionFactor, float InScale, bool bInUseParameters) : FOVCorrectionFactor(InFOVCorrectionFactor), Scale(InScale), bUseParameters(bInUseParameters) {}
};
 
// Construction parameters for a FSceneView
struct FSceneViewInitOptions : public FSceneViewProjectionData
{
    const FSceneViewFamily* ViewFamily;
    FSceneViewStateInterface* SceneViewStateInterface;
    FSceneViewStateInterface* ExposureSceneViewStateInterface;
    FSceneViewOwner ViewActor; // TODO: Rename to ViewOwner
    int32 PlayerIndex;
    FViewElementDrawer* ViewElementDrawer;
 
    FLinearColor BackgroundColor;
    FLinearColor OverlayColor;
    FLinearColor ColorScale;
 
    EStereoscopicPass StereoPass;
 
    int32 StereoViewIndex;
 
    float WorldToMetersScale;
 
    FVector ViewLocation;
    FRotator ViewRotation;
 
    TSet<FPrimitiveComponentId> HiddenPrimitives;
 
    TOptional<TSet<FPrimitiveComponentId>> ShowOnlyPrimitives;
 
    // -1,-1 if not setup
    FIntPoint CursorPos;
 
    float LODDistanceFactor;
 
    float OverrideFarClippingPlaneDistance;
 
    FVector OriginOffsetThisFrame;
 
    bool bInCameraCut;
 
    bool bUseFieldOfViewForLOD;
 
    float FOV;
    float DesiredFOV;
 
    FFirstPersonParameters FirstPersonParams;
 
    bool bIsSceneCapture;
 
    bool bIsSceneCaptureCube;
 
    bool bSceneCaptureUsesRayTracing;
 
    bool bIsReflectionCapture;
 
    bool bIsPlanarReflection;
 
    bool bExcludeFromSceneTextureExtents = false;
 
    float OverridePrimaryResolutionFraction;
 
    float OverscanResolutionFraction = 1.0f;
 
    float CropFraction = 1.0f;
 
    FVector4f AsymmetricCropFraction = FVector4f::One();
    
#if WITH_EDITOR
    uint64 EditorViewBitflag;
 
    bool bDisableGameScreenPercentage;
#endif
 
    FSceneViewInitOptions()
        : ViewFamily(NULL)
        , SceneViewStateInterface(NULL)
        , ExposureSceneViewStateInterface(NULL)
        , PlayerIndex(INDEX_NONE)
        , ViewElementDrawer(NULL)
        , BackgroundColor(FLinearColor::Transparent)
        , OverlayColor(FLinearColor::Transparent)
        , ColorScale(FLinearColor::White)
        , StereoPass(EStereoscopicPass::eSSP_FULL)
        , StereoViewIndex(INDEX_NONE)
        , WorldToMetersScale(100.f)
        , ViewLocation(ForceInitToZero)
        , ViewRotation(ForceInitToZero)
        , CursorPos(-1, -1)
        , LODDistanceFactor(1.0f)
        , OverrideFarClippingPlaneDistance(-1.0f)
        , OriginOffsetThisFrame(ForceInitToZero)
        , bInCameraCut(false)
        , bUseFieldOfViewForLOD(true)
        , FOV(90.f)
        , DesiredFOV(90.f)
        , FirstPersonParams()
        , bIsSceneCapture(false)
        , bIsSceneCaptureCube(false)
        , bSceneCaptureUsesRayTracing(false)
        , bIsReflectionCapture(false)
        , bIsPlanarReflection(false)
        , OverridePrimaryResolutionFraction(-1.0)
#if WITH_EDITOR
        , EditorViewBitflag(1)
        , bDisableGameScreenPercentage(false)
        //@TODO: , const TBitArray<>& InSpriteCategoryVisibility=TBitArray<>()
#endif
    {
    }
};
 
 
 
struct FViewMatrices
{
    struct FMinimalInitializer
    {
        FMatrix ViewRotationMatrix = FMatrix::Identity;
        FMatrix ProjectionMatrix = FMatrix::Identity;
        FVector ViewOrigin = FVector::ZeroVector;
        FIntRect ConstrainedViewRect = FIntRect(0, 0, 0, 0);
        FVector CameraToViewTarget = FVector::ZeroVector;
        EStereoscopicPass StereoPass = EStereoscopicPass::eSSP_FULL;
        FFirstPersonParameters FirstPersonParams = {};
    };
 
    FViewMatrices()
    {
        ProjectionMatrix.SetIdentity();
        ProjectionNoAAMatrix.SetIdentity();
        InvProjectionMatrix.SetIdentity();
        ViewMatrix.SetIdentity();
        InvViewMatrix.SetIdentity();
        ViewProjectionMatrix.SetIdentity();
        InvViewProjectionMatrix.SetIdentity();
        HMDViewMatrixNoRoll.SetIdentity();
        TranslatedViewMatrix.SetIdentity();
        InvTranslatedViewMatrix.SetIdentity();
        OverriddenTranslatedViewMatrix.SetIdentity();
        OverriddenInvTranslatedViewMatrix.SetIdentity();
        TranslatedViewProjectionMatrix.SetIdentity();
        InvTranslatedViewProjectionMatrix.SetIdentity();
        ScreenToClipMatrix.SetIdentity();
        FirstPersonTransform.SetIdentity();
        PreViewTranslation = FVector::ZeroVector;
        ViewOrigin = FVector::ZeroVector;
        CameraToViewTarget = FVector::ZeroVector;
        ProjectionScale = FVector2D::ZeroVector;
        TemporalAAProjectionJitter = FVector2D::ZeroVector;
        ScreenScale = 1.f;
    }
 
    ENGINE_API FViewMatrices(const FMinimalInitializer& Initializer);
    ENGINE_API FViewMatrices(const FSceneViewInitOptions& InitOptions);
 
private:
 
    void Init(const FMinimalInitializer& Initializer);
 
    FMatrix     ProjectionMatrix;
    FMatrix     ProjectionNoAAMatrix;
    FMatrix     InvProjectionMatrix;
    // WorldToView..
    FMatrix     ViewMatrix;
    // ViewToWorld..
    FMatrix     InvViewMatrix;
    // WorldToClip : UE projection matrix projects such that clip space Z=1 is the near plane, and Z=0 is the infinite far plane. */
    FMatrix     ViewProjectionMatrix;
    // ClipToWorld : UE projection matrix projects such that clip space Z=1 is the near plane, and Z=0 is the infinite far plane. */
    FMatrix     InvViewProjectionMatrix;
    // HMD WorldToView with roll removed
    FMatrix     HMDViewMatrixNoRoll;
    FMatrix     TranslatedViewMatrix;
    FMatrix     InvTranslatedViewMatrix;
    FMatrix     OverriddenTranslatedViewMatrix;
    FMatrix     OverriddenInvTranslatedViewMatrix;
    FMatrix     TranslatedViewProjectionMatrix;
    FMatrix     InvTranslatedViewProjectionMatrix;
    FMatrix     ScreenToClipMatrix;
    FMatrix     FirstPersonTransform;
    FVector     PreViewTranslation;
    FVector     ViewOrigin;
    FVector     CameraToViewTarget;
    FVector2D   ProjectionScale;
    FVector2D   TemporalAAProjectionJitter;
 
    float ScreenScale;
 
    float PerProjectionDepthThicknessScale;
 
    FFirstPersonParameters FirstPersonParams;
 
    //
    // World = TranslatedWorld - PreViewTranslation
    // TranslatedWorld = World + PreViewTranslation
    // 
 
    // ----------------
 
public:
    ENGINE_API void UpdateViewMatrix(const FVector& ViewLocation, const FRotator& ViewRotation);
 
    void UpdatePlanarReflectionViewMatrix(const FSceneView& SourceView, const FMirrorMatrix& MirrorMatrix);
 
    inline const FMatrix& GetProjectionMatrix() const
    {
        return ProjectionMatrix;
    }
 
    inline const FMatrix& GetProjectionNoAAMatrix() const
    {
        return ProjectionNoAAMatrix;
    }
 
    inline const FMatrix& GetInvProjectionMatrix() const
    {
        return InvProjectionMatrix;
    }
 
    inline const FMatrix& GetViewMatrix() const
    {
        return ViewMatrix;
    }
 
    inline const FMatrix& GetInvViewMatrix() const
    {
        return InvViewMatrix;
    }
 
    inline const FMatrix& GetViewProjectionMatrix() const
    {
        return ViewProjectionMatrix;
    }
 
    inline const FMatrix& GetInvViewProjectionMatrix() const
    {
        return InvViewProjectionMatrix;
    }
    
    inline const FMatrix& GetHMDViewMatrixNoRoll() const
    {
        return HMDViewMatrixNoRoll;
    }
    
    inline const FMatrix& GetTranslatedViewMatrix() const
    {
        return TranslatedViewMatrix;
    }
 
    inline const FMatrix& GetInvTranslatedViewMatrix() const
    {
        return InvTranslatedViewMatrix;
    }
 
    inline const FMatrix& GetOverriddenTranslatedViewMatrix() const
    {
        return OverriddenTranslatedViewMatrix;
    }
 
    inline const FMatrix& GetOverriddenInvTranslatedViewMatrix() const
    {
        return OverriddenInvTranslatedViewMatrix;
    }
 
    inline const FMatrix& GetTranslatedViewProjectionMatrix() const
    {
        return TranslatedViewProjectionMatrix;
    }
 
    inline const FMatrix& GetInvTranslatedViewProjectionMatrix() const
    {
        return InvTranslatedViewProjectionMatrix;
    }
 
    inline const FMatrix& GetScreenToClipMatrix() const
    {
        return ScreenToClipMatrix;
    }
 
    inline const FMatrix& GetFirstPersonTransform() const
    {
        return FirstPersonTransform;
    }
 
    inline float GetFirstPersonScale() const
    {
        return FirstPersonParams.bUseParameters ? FirstPersonParams.Scale : 1.0f;
    }
 
    inline const FVector& GetPreViewTranslation() const
    {
        return PreViewTranslation;
    }
    
    inline const FVector& GetViewOrigin() const
    {
        return ViewOrigin;
    }
 
    inline const FVector& GetCameraToViewTarget() const
    {
        return CameraToViewTarget;
    }
 
    inline float GetScreenScale() const
    {
        return ScreenScale;
    }
 
    inline const FVector2D& GetProjectionScale() const
    {
        return ProjectionScale;
    } 
 
    inline bool IsPerspectiveProjection() const
    {
        return ProjectionMatrix.M[3][3] < 1.0f;
    }
 
    inline FVector2f GetInvTanHalfFov() const
    {
        //No concept of FOV for orthographic projection so only return perspective related values or 1.0f
        if (IsPerspectiveProjection())
        {
            return FVector2f(static_cast<float>(ProjectionMatrix.M[0][0]), static_cast<float>(ProjectionMatrix.M[1][1]));
        }
        return  FVector2f(1.0f, 1.0f);
    }
 
    inline FVector2f GetTanHalfFov() const
    {
        //No concept of FOV for orthographic projection so only return perspective related values or 1.0f
        if (IsPerspectiveProjection())
        {
            return FVector2f(static_cast<float>(InvProjectionMatrix.M[0][0]), static_cast<float>(InvProjectionMatrix.M[1][1]));
        }
        return  FVector2f(1.0f,1.0f);
    }
 
    //Used for initializing the View Uniform Buffer TanAndInvTanHalfFOV variable without repeated calls to IsPerspectiveProjection
    inline FVector4f GetTanAndInvTanHalfFOV() const
    {
        //No concept of FOV for orthographic projection so only return perspective related values or 1.0f
        if (IsPerspectiveProjection())
        {
            return FVector4f(static_cast<float>(InvProjectionMatrix.M[0][0]), //ClipToView[0][0] - X axis
                             static_cast<float>(InvProjectionMatrix.M[1][1]), //ClipToView[1][1] - Y axis
                             static_cast<float>(ProjectionMatrix.M[0][0]), //ViewToClip[0][0] - 1/X axis
                             static_cast<float>(ProjectionMatrix.M[1][1])); //ViewToClip[1][1] - 1/Y axis
        }
        return FVector4f(1.0f, 1.0f, 1.0f, 1.0f);
    }
 
    inline float GetPerProjectionDepthThicknessScale() const
    {
        return PerProjectionDepthThicknessScale;
    }
 
    FMatrix ScreenToClipProjectionMatrix() const;
 
    ENGINE_API void HackOverrideViewMatrixForShadows(const FMatrix& InViewMatrix);
 
    void SaveProjectionNoAAMatrix()
    {
        ProjectionNoAAMatrix = ProjectionMatrix;
    }
 
    void HackAddTemporalAAProjectionJitter(const FVector2D& InTemporalAAProjectionJitter)
    {
        ensure(TemporalAAProjectionJitter.X == 0.0f && TemporalAAProjectionJitter.Y == 0.0f);
 
        TemporalAAProjectionJitter = InTemporalAAProjectionJitter;
 
        if (IsPerspectiveProjection())
        {
            ProjectionMatrix.M[2][0] += TemporalAAProjectionJitter.X;
            ProjectionMatrix.M[2][1] += TemporalAAProjectionJitter.Y;
        }
        else
        {
            ProjectionMatrix.M[3][0] += TemporalAAProjectionJitter.X;
            ProjectionMatrix.M[3][1] += TemporalAAProjectionJitter.Y;
        }
        InvProjectionMatrix = InvertProjectionMatrix(ProjectionMatrix);
 
        RecomputeDerivedMatrices();
    }
 
    void HackRemoveTemporalAAProjectionJitter()
    {
        if (IsPerspectiveProjection())
        {
            ProjectionMatrix.M[2][0] -= TemporalAAProjectionJitter.X;
            ProjectionMatrix.M[2][1] -= TemporalAAProjectionJitter.Y;
        }
        else
        {
            ProjectionMatrix.M[3][0] -= TemporalAAProjectionJitter.X;
            ProjectionMatrix.M[3][1] -= TemporalAAProjectionJitter.Y;
        }
        InvProjectionMatrix = InvertProjectionMatrix(ProjectionMatrix);
 
        TemporalAAProjectionJitter = FVector2D::ZeroVector;
        RecomputeDerivedMatrices();
    }
 
    const FMatrix ComputeProjectionNoAAMatrix() const
    {
        FMatrix ProjNoAAMatrix = ProjectionMatrix;
 
        if (IsPerspectiveProjection())
        {
            ProjNoAAMatrix.M[2][0] -= TemporalAAProjectionJitter.X;
            ProjNoAAMatrix.M[2][1] -= TemporalAAProjectionJitter.Y;
        }
        else
        {
            ProjNoAAMatrix.M[3][0] -= TemporalAAProjectionJitter.X;
            ProjNoAAMatrix.M[3][1] -= TemporalAAProjectionJitter.Y;
        }
 
        return ProjNoAAMatrix;
    }
 
    inline const FVector2D GetTemporalAAJitter() const
    {
        return TemporalAAProjectionJitter;
    }
 
    const FMatrix ComputeViewRotationProjectionMatrix() const
    {
        return ViewMatrix.RemoveTranslation() * ProjectionMatrix;
    }
    
    const FMatrix ComputeInvProjectionNoAAMatrix() const
    {
        return InvertProjectionMatrix( ComputeProjectionNoAAMatrix() );
    }
 
    // @return in radians (horizontal,vertical)
    const FVector2D ComputeHalfFieldOfViewPerAxis() const
    {
        if(IsPerspectiveProjection())
        {
            const FMatrix ClipToView = ComputeInvProjectionNoAAMatrix();
 
            FVector VCenter = FVector(ClipToView.TransformPosition(FVector(0.0, 0.0, 0.0)));
            FVector VUp = FVector(ClipToView.TransformPosition(FVector(0.0, 1.0, 0.0)));
            FVector VRight = FVector(ClipToView.TransformPosition(FVector(1.0, 0.0, 0.0)));
 
            VCenter.Normalize();
            VUp.Normalize();
            VRight.Normalize();
 
            using ResultType = decltype(FVector2D::X);
            return FVector2D((ResultType)FMath::Acos(VCenter | VRight), (ResultType)FMath::Acos(VCenter | VUp));
        }
        return FVector2D::Zero();
    }
 
    FMatrix::FReal ComputeNearPlane() const
    {
        return ( ProjectionMatrix.M[3][3] - ProjectionMatrix.M[3][2] ) / ( ProjectionMatrix.M[2][2] - ProjectionMatrix.M[2][3] );
    }
 
    FMatrix::FReal ComputeOrthoFarPlane() const
    {
        if(!IsPerspectiveProjection())
        {
            return ComputeNearPlane() - InvProjectionMatrix.M[2][2];
        }
        return 0.0;
    }
 
    void ApplyWorldOffset(const FVector& InOffset)
    {
        ViewOrigin+= InOffset;
        PreViewTranslation-= InOffset;
    
        ViewMatrix.SetOrigin(ViewMatrix.GetOrigin() + ViewMatrix.TransformVector(-InOffset));
        InvViewMatrix.SetOrigin(ViewOrigin);
        RecomputeDerivedMatrices();
    }
 
    FVector2f GetOrthoDimensions() const
    {
        if (!IsPerspectiveProjection())
        {
            return  FVector2f(static_cast<float>(InvProjectionMatrix.M[0][0]) * 2.0f, static_cast<float>(InvProjectionMatrix.M[1][1]) * 2.0f);
        }
        return FVector2f::ZeroVector;
    }
 
    // @return in radians (horizontal,vertical)
    FVector2f GetFirstPersonHalfFieldOfViewPerAxis() const
    {
        if (IsPerspectiveProjection())
        {
            const FVector4f FirstPersonTandAndInvTanHalfFOV = GetFirstPersonTanAndInvTanHalfFOV();
            const FVector2f FirstPersonHalfFOV = FVector2f(FMath::Atan(FirstPersonTandAndInvTanHalfFOV.X), FMath::Atan(FirstPersonTandAndInvTanHalfFOV.Y));
            return FirstPersonHalfFOV;
        }
        return FVector2f::Zero();
    }
 
    FVector4f GetFirstPersonTanAndInvTanHalfFOV() const
    {
        // No concept of FOV for orthographic projection so only return perspective related values or 1.0f
        if (IsPerspectiveProjection())
        {
            const FVector4f SceneTanAndInvTanHalfFOV = GetTanAndInvTanHalfFOV();
            const float FOVCorrectionFactor = FirstPersonParams.bUseParameters ? FirstPersonParams.FOVCorrectionFactor : 1.0f;
            // FOVCorrectionFactor = SceneTanHalfFOV / FirstPersonTanHalfFov -> FirstPersonTanHalfFov = SceneTanHalfFOV / FOVCorrectionFactor
            const FVector4f FirstPersonTanAndInvTanHalfFOV = FVector4f(
                SceneTanAndInvTanHalfFOV.X / FOVCorrectionFactor,
                SceneTanAndInvTanHalfFOV.Y / FOVCorrectionFactor,
                SceneTanAndInvTanHalfFOV.Z * FOVCorrectionFactor,
                SceneTanAndInvTanHalfFOV.W * FOVCorrectionFactor);
            return FirstPersonTanAndInvTanHalfFOV;
        }
        return FVector4f(1.0f, 1.0f, 1.0f, 1.0f);
    }
 
private:
    inline void RecomputeDerivedMatrices()
    {
        // Compute the view projection matrix and its inverse.
        ViewProjectionMatrix = GetViewMatrix() * GetProjectionMatrix();
        InvViewProjectionMatrix = GetInvProjectionMatrix() * GetInvViewMatrix();
 
        // Compute a transform from view origin centered world-space to clip space.
        TranslatedViewProjectionMatrix = GetTranslatedViewMatrix() * GetProjectionMatrix();
        InvTranslatedViewProjectionMatrix = GetInvProjectionMatrix() * GetInvTranslatedViewMatrix();
    }
 
    static const FMatrix InvertProjectionMatrix( const FMatrix& M )
    {
        if( M.M[1][0] == 0.0f &&
            M.M[3][0] == 0.0f &&
            M.M[0][1] == 0.0f &&
            M.M[3][1] == 0.0f &&
            M.M[0][2] == 0.0f &&
            M.M[1][2] == 0.0f &&
            M.M[0][3] == 0.0f &&
            M.M[1][3] == 0.0f &&
            M.M[2][3] == 1.0f &&
            M.M[3][3] == 0.0f )
        {
            // Solve the common case directly with very high precision.
            /*
            M = 
            | a | 0 | 0 | 0 |
            | 0 | b | 0 | 0 |
            | s | t | c | 1 |
            | 0 | 0 | d | 0 |
            */
 
            double a = M.M[0][0];
            double b = M.M[1][1];
            double c = M.M[2][2];
            double d = M.M[3][2];
            double s = M.M[2][0];
            double t = M.M[2][1];
 
            return FMatrix(
                FPlane( 1.0 / a, 0.0f, 0.0f, 0.0f ),
                FPlane( 0.0f, 1.0 / b, 0.0f, 0.0f ),
                FPlane( 0.0f, 0.0f, 0.0f, 1.0 / d ),
                FPlane( -s/a, -t/b, 1.0f, -c/d )
            );
        }
        else
        {
            return M.Inverse();
        }
    }
};
 
 
inline constexpr int MAX_MOBILE_SHADOWCASCADES = 4;
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR(FMobileDirectionalLightShaderParameters, ENGINE_API)
    SHADER_PARAMETER_EX(FLinearColor, DirectionalLightColor, EShaderPrecisionModifier::Half)
    SHADER_PARAMETER_EX(FVector4f, DirectionalLightDirectionAndShadowTransition, EShaderPrecisionModifier::Half)
    SHADER_PARAMETER_EX(FVector4f, DirectionalLightShadowSize, EShaderPrecisionModifier::Half)
    SHADER_PARAMETER_EX(FVector4f, DirectionalLightDistanceFadeMADAndSpecularScale, EShaderPrecisionModifier::Half) // .z is used for SpecularScale, .w is for DiffuseScale
    SHADER_PARAMETER_EX(FVector4f, DirectionalLightShadowDistances, EShaderPrecisionModifier::Half)
    SHADER_PARAMETER_ARRAY(FMatrix44f, DirectionalLightScreenToShadow, [MAX_MOBILE_SHADOWCASCADES])
    SHADER_PARAMETER(uint32, DirectionalLightNumCascades)
    SHADER_PARAMETER(uint32, DirectionalLightShadowMapChannelMask)
    SHADER_PARAMETER_TEXTURE(Texture2D, DirectionalLightShadowTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, DirectionalLightShadowSampler)
    SHADER_PARAMETER(uint32, ShadowedBits)
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
 
 
 
enum ETranslucencyVolumeCascade
{
    TVC_Inner,
    TVC_Outer,
 
    TVC_MAX,
};
 
#define SKY_IRRADIANCE_ENVIRONMENT_MAP_VEC4_COUNT 8
 
//VIEW_UNIFORM_BUFFER_MEMBER(FMatrix44f, PrevProjection)
//VIEW_UNIFORM_BUFFER_MEMBER(FMatrix44f, PrevViewProj)
//VIEW_UNIFORM_BUFFER_MEMBER(FMatrix44f, PrevViewRotationProj)
 
// View uniform buffer member declarations
#define VIEW_UNIFORM_BUFFER_MEMBER_TABLE \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, TranslatedWorldToClip) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, RelativeWorldToClip) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ClipToRelativeWorld)  \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, TranslatedWorldToView) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ViewToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, TranslatedWorldToCameraView) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, CameraViewToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ViewToClip) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ViewToClipNoAA) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ClipToView) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ClipToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, SVPositionToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ScreenToRelativeWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ScreenToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, MobileMultiviewShadowTransform) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, MobileMultiviewDecalTransform) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, FirstPersonTransform) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevFirstPersonTransform) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, ViewOriginHigh) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector3f, ViewForward, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector3f, ViewUp, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector3f, ViewRight, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(FVector3f, HMDViewNoRollUp, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(FVector3f, HMDViewNoRollRight, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, InvDeviceZToWorldZTransform) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(FVector4f, ScreenPositionScaleBias, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, ViewOriginLow) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, TranslatedWorldCameraOrigin) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, WorldViewOriginHigh) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, WorldViewOriginLow) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PreViewTranslationHigh) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PreViewTranslationLow) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevViewToClip) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevClipToView) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevTranslatedWorldToClip) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevTranslatedWorldToView) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevViewToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevTranslatedWorldToCameraView) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevCameraViewToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevTranslatedWorldCameraOrigin) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevWorldCameraOriginHigh) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevWorldCameraOriginLow) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevWorldViewOriginHigh) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevWorldViewOriginLow) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevPreViewTranslationHigh) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevPreViewTranslationLow) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, ViewTilePosition) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, RelativeWorldCameraOriginTO) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, RelativeWorldViewOriginTO) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, RelativePreViewTranslationTO) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevRelativeWorldCameraOriginTO) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, PrevRelativeWorldViewOriginTO) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, RelativePrevPreViewTranslationTO) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevClipToRelativeWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, PrevScreenToTranslatedWorld) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ClipToPrevClip) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FMatrix44f, ClipToPrevClipWithAA) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, TemporalAAJitter) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, GlobalClippingPlane) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector2f, FieldOfViewWideAngles) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector2f, PrevFieldOfViewWideAngles) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector2f, FirstPersonFieldOfViewWideAngles) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector2f, PrevFirstPersonFieldOfViewWideAngles) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(FVector4f, ViewRectMin, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, ViewSizeAndInvSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FUintVector4, ViewRectMinAndSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, LightProbeSizeRatioAndInvSizeRatio) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, BufferSizeAndInvSize) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, BufferBilinearUVMinMax) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, ScreenToViewSpace) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector2f, BufferToSceneTextureScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, ResolutionFractionAndInv) \
    VIEW_UNIFORM_BUFFER_MEMBER(int32, NumSceneColorMSAASamples) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(float, ProjectionDepthThicknessScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, PreExposure) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, OneOverPreExposure) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4f, DiffuseOverrideParameter, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4f, SpecularOverrideParameter, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector4f, NormalOverrideParameter, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector2f, RoughnessOverrideParameter, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector2f, AmbientOcclusionOverrideParameter, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, PrevFrameGameTime) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, PrevFrameRealTime) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(float, OutOfBoundsMask, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector3f, WorldCameraMovementSinceLastFrame) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, CullingSign) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(float, NearPlane, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(float, OrthoFarPlane) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, GameTime) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, RealTime) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DeltaTime) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, MaterialTextureMipBias) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, MaterialTextureDerivativeMultiply) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, Random) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, FrameNumber) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, FrameCounter) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, StateFrameIndexMod8) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, StateFrameIndex) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, StateOutputFrameIndex) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, DebugViewModeMask) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, WorldIsPaused) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(float, CameraCut, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(float, UnlitViewmodeMask, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FLinearColor, DirectionalLightColor, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(FVector3f, DirectionalLightDirection, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, TranslucencyLightingVolumeMin, TVC_MAX) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, TranslucencyLightingVolumeInvSize, TVC_MAX) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, TemporalAAParams) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, CircleDOFParams) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldSensorWidth) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFocalDistance) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFocalLength) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFocalRegion) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldNearTransitionRegion) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DepthOfFieldFarTransitionRegion) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, MotionBlurNormalizedToPixel) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, GeneralPurposeTweak) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, GeneralPurposeTweak2) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(float, DemosaicVposOffset, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DecalDepthBias) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, SceneColorTextureFormatQuantizationError) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, IndirectLightingColorScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, PrecomputedIndirectLightingColorScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, PrecomputedIndirectSpecularColorScale) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, AtmosphereLightDirection, NUM_ATMOSPHERE_LIGHTS) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FLinearColor, AtmosphereLightIlluminanceOnGroundPostTransmittance, NUM_ATMOSPHERE_LIGHTS) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FLinearColor, AtmosphereLightIlluminanceOuterSpace, NUM_ATMOSPHERE_LIGHTS) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FLinearColor, AtmosphereLightDiscLuminance, NUM_ATMOSPHERE_LIGHTS) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, AtmosphereLightDiscCosHalfApexAngle_PPTrans, NUM_ATMOSPHERE_LIGHTS) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, SkyViewLutSizeAndInvSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, SkyCameraTranslatedWorldOrigin) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, SkyPlanetTranslatedWorldCenterAndViewHeight) \
    VIEW_UNIFORM_BUFFER_MEMBER(FMatrix44f, SkyViewLutReferential) \
    VIEW_UNIFORM_BUFFER_MEMBER(FLinearColor, SkyAtmosphereSkyLuminanceFactor) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmospherePresentInScene) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereHeightFogContribution) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereBottomRadiusKm) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereTopRadiusKm) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, SkyAtmosphereCameraAerialPerspectiveVolumeSizeAndInvSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereAerialPerspectiveStartDepthKm) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolution) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolutionInv) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKm) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKmInv) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyAtmosphereApplyCameraAerialPerspectiveVolume) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, NormalCurvatureToRoughnessScaleBias) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, RenderingReflectionCaptureMask) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, RealTimeReflectionCapture) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, RealTimeReflectionCapturePreExposure) \
    VIEW_UNIFORM_BUFFER_MEMBER(FLinearColor, AmbientCubemapTint) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, AmbientCubemapIntensity) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyLightApplyPrecomputedBentNormalShadowingFlag) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyLightAffectReflectionFlag) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyLightAffectGlobalIlluminationFlag) \
    VIEW_UNIFORM_BUFFER_MEMBER(FLinearColor, SkyLightColor) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SkyLightVolumetricScatteringIntensity) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, MobileSkyIrradianceEnvironmentMap, SKY_IRRADIANCE_ENVIRONMENT_MAP_VEC4_COUNT) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, MobilePreviewMode) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(float, HMDEyePaddingOffset) \
    VIEW_UNIFORM_BUFFER_MEMBER_EX(float, ReflectionCubemapMaxMip, EShaderPrecisionModifier::Half) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, ShowDecalsMask) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, DistanceFieldAOSpecularOcclusionMode) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, IndirectCapsuleSelfShadowingIntensity) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, ReflectionEnvironmentRoughnessMixingScaleBiasAndLargestWeight) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(int32, StereoPassIndex) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, GlobalVolumeTranslatedCenterAndExtent, GlobalDistanceField::MaxClipmaps) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, GlobalVolumeTranslatedWorldToUVAddAndMul, GlobalDistanceField::MaxClipmaps) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, GlobalDistanceFieldMipTranslatedWorldToUVScale, GlobalDistanceField::MaxClipmaps) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, GlobalDistanceFieldMipTranslatedWorldToUVBias, GlobalDistanceField::MaxClipmaps) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, GlobalDistanceFieldMipFactor) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, GlobalDistanceFieldMipTransition) \
    VIEW_UNIFORM_BUFFER_MEMBER(int32, GlobalDistanceFieldClipmapSizeInPages) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, GlobalDistanceFieldInvPageAtlasSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, GlobalDistanceFieldInvCoverageAtlasSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, GlobalVolumeDimension) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, GlobalVolumeTexelSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, MaxGlobalDFAOConeDistance) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, NumGlobalSDFClipmaps) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, CoveredExpandSurfaceScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, NotCoveredExpandSurfaceScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, NotCoveredMinStepScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DitheredTransparencyStepThreshold) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, DitheredTransparencyTraceThreshold) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, ViewportScaleUI) \
    VIEW_UNIFORM_BUFFER_MEMBER(FIntPoint, CursorPosition) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, bCheckerboardSubsurfaceProfileRendering) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, VolumetricFogInvGridSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, VolumetricFogGridZParams) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, VolumetricFogSVPosToVolumeUV) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, VolumetricFogViewGridUVToPrevViewRectUV) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, VolumetricFogPrevViewGridRectUVToResourceUV) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, VolumetricFogPrevUVMax) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, VolumetricFogPrevUVMaxForTemporalBlend) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, VolumetricFogPrevResourceGridSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, VolumetricFogScreenToResourceUV) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector2f, VolumetricFogUVMax) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, VolumetricFogMaxDistance) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, VolumetricLightmapWorldToUVScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, VolumetricLightmapWorldToUVAdd) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, VolumetricLightmapIndirectionTextureSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, VolumetricLightmapBrickSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, VolumetricLightmapBrickTexelSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, IndirectLightingCacheShowFlag) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, EyeToPixelSpreadAngle) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FVector4f, XRPassthroughCameraUVs, 2) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, GlobalVirtualTextureMipBias) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, VirtualTextureFeedbackBufferSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, VirtualTextureFeedbackShift) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, VirtualTextureFeedbackMask) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, VirtualTextureFeedbackJitterOffset) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, VirtualTextureFeedbackSampleOffset) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, VirtualTextureExtendedDebugBufferSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(int32, FarShadowStaticMeshLODBias) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, MinRoughness) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, HairRenderInfo) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, EnableSkyLight) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, HairRenderInfoBits) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, HairComponents) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, bSubsurfacePostprocessEnabled) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, SSProfilesTextureSizeAndInvSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, SSProfilesPreIntegratedTextureSizeAndInvSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector4f, SpecularProfileTextureSizeAndInvSize) \
    VIEW_UNIFORM_BUFFER_MEMBER(FVector3f, PhysicsFieldClipmapCenter) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, PhysicsFieldClipmapDistance) \
    VIEW_UNIFORM_BUFFER_MEMBER(int, PhysicsFieldClipmapResolution) \
    VIEW_UNIFORM_BUFFER_MEMBER(int, PhysicsFieldClipmapExponent) \
    VIEW_UNIFORM_BUFFER_MEMBER(int, PhysicsFieldClipmapCount) \
    VIEW_UNIFORM_BUFFER_MEMBER(int, PhysicsFieldTargetCount) \
    VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(FIntVector4, PhysicsFieldTargets, MAX_PHYSICS_FIELD_TARGETS) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(uint32, GPUSceneViewId) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, ViewResolutionFraction) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, SubSurfaceColorAsTransmittanceAtDistanceInMeters) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, TanAndInvTanHalfFOV) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, PrevTanAndInvTanHalfFOV) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, FirstPersonTanAndInvTanHalfFOV) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, PrevFirstPersonTanAndInvTanHalfFOV) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector2f, WorldDepthToPixelWorldRadius) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, ScreenRayLengthMultiplier) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, GlintLUTParameters0) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(FVector4f, GlintLUTParameters1) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(float, FirstPersonScale) \
    VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(float, PrevFirstPersonScale) \
    VIEW_UNIFORM_BUFFER_MEMBER(float, MaterialMaxEmissiveValue) \
    VIEW_UNIFORM_BUFFER_MEMBER(int32, PostVolumeUserFlags) \
    VIEW_UNIFORM_BUFFER_MEMBER(FIntVector4, EnvironmentComponentsFlags) \
    VIEW_UNIFORM_BUFFER_MEMBER(uint32, bPrimitiveAlphaHoldoutEnabled) \
 
#define VIEW_UNIFORM_BUFFER_MEMBER(type, identifier) \
    SHADER_PARAMETER(type, identifier)
 
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(type, identifier) \
    SHADER_PARAMETER(type, identifier)
 
#define VIEW_UNIFORM_BUFFER_MEMBER_EX(type, identifier, precision) \
    SHADER_PARAMETER_EX(type, identifier, precision)
 
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(type, identifier, precision) \
    SHADER_PARAMETER_EX(type, identifier, precision)
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(type, identifier, dimension) \
    SHADER_PARAMETER_ARRAY(type, identifier, [dimension])
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW(type, identifier, dimension) \
    SHADER_PARAMETER_ARRAY(type, identifier, [dimension])
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR(FViewUniformShaderParameters, ENGINE_API)
 
    VIEW_UNIFORM_BUFFER_MEMBER_TABLE
 
    // Same as Wrap_WorldGroupSettings and Clamp_WorldGroupSettings, but with mipbias=MaterialTextureMipBias.
    SHADER_PARAMETER_SAMPLER(SamplerState, MaterialTextureBilinearWrapedSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, MaterialTextureBilinearClampedSampler)
 
    SHADER_PARAMETER_TEXTURE(Texture3D<uint4>, VolumetricLightmapIndirectionTexture) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickAmbientVector) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients0) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients1) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients2) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients3) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients4) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, VolumetricLightmapBrickSHCoefficients5) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, SkyBentNormalBrickTexture) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_TEXTURE(Texture3D, DirectionalLightShadowingBrickTexture) // FPrecomputedVolumetricLightmapLightingPolicy
 
    SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapBrickAmbientVectorSampler) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler0) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler1) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler2) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler3) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler4) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, VolumetricLightmapTextureSampler5) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, SkyBentNormalTextureSampler) // FPrecomputedVolumetricLightmapLightingPolicy
    SHADER_PARAMETER_SAMPLER(SamplerState, DirectionalLightShadowingTextureSampler) // FPrecomputedVolumetricLightmapLightingPolicy
 
    SHADER_PARAMETER_TEXTURE(Texture3D, GlobalDistanceFieldPageAtlasTexture)
    SHADER_PARAMETER_TEXTURE(Texture3D, GlobalDistanceFieldCoverageAtlasTexture)
    SHADER_PARAMETER_TEXTURE(Texture3D<uint>, GlobalDistanceFieldPageTableTexture)
    SHADER_PARAMETER_TEXTURE(Texture3D, GlobalDistanceFieldMipTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, GlobalDistanceFieldPageAtlasTextureSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, GlobalDistanceFieldCoverageAtlasTextureSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, GlobalDistanceFieldMipTextureSampler)
 
    SHADER_PARAMETER_TEXTURE(Texture2D, AtmosphereTransmittanceTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, AtmosphereTransmittanceTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D, AtmosphereIrradianceTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, AtmosphereIrradianceTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture3D, AtmosphereInscatterTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, AtmosphereInscatterTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D, PerlinNoiseGradientTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, PerlinNoiseGradientTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture3D, PerlinNoise3DTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, PerlinNoise3DTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D<uint>, SobolSamplingTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SharedPointWrappedSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, SharedPointClampedSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, SharedBilinearWrappedSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, SharedBilinearClampedSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, SharedBilinearAnisoClampedSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, SharedTrilinearWrappedSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, SharedTrilinearClampedSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D, PreIntegratedBRDF)
    SHADER_PARAMETER_SAMPLER(SamplerState, PreIntegratedBRDFSampler)
    SHADER_PARAMETER_SRV(StructuredBuffer<float4>, SkyIrradianceEnvironmentMap)
    // Atmosphere
    SHADER_PARAMETER_TEXTURE(Texture2D, TransmittanceLutTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, TransmittanceLutTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D, SkyViewLutTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SkyViewLutTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture3D, CameraAerialPerspectiveVolume)
    SHADER_PARAMETER_SAMPLER(SamplerState, CameraAerialPerspectiveVolumeSampler)
    SHADER_PARAMETER_TEXTURE(Texture3D, CameraAerialPerspectiveVolumeMieOnly)
    SHADER_PARAMETER_SAMPLER(SamplerState, CameraAerialPerspectiveVolumeMieOnlySampler)
    SHADER_PARAMETER_TEXTURE(Texture3D, CameraAerialPerspectiveVolumeRayOnly)
    SHADER_PARAMETER_SAMPLER(SamplerState, CameraAerialPerspectiveVolumeRayOnlySampler)
    SHADER_PARAMETER_SRV(StructuredBuffer<float4>, DistantSkyLightLutBufferSRV) 
    SHADER_PARAMETER_SRV(Buffer<float4>, MobileDistantSkyLightLutBufferSRV)     
    // Hair
    SHADER_PARAMETER_TEXTURE(Texture3D, HairScatteringLUTTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, HairScatteringLUTSampler)
    // GGX/Sheen LTC textures
    SHADER_PARAMETER_TEXTURE(Texture2D, GGXLTCMatTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, GGXLTCMatSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D, GGXLTCAmpTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, GGXLTCAmpSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D, SheenLTCTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SheenLTCSampler)
    // Energy conservation
    SHADER_PARAMETER(uint32, bShadingEnergyConservation)
    SHADER_PARAMETER(uint32, bShadingEnergyPreservation)
    SHADER_PARAMETER_TEXTURE(Texture2D<float2>, ShadingEnergyGGXSpecTexture)
    SHADER_PARAMETER_TEXTURE(Texture3D<float2>, ShadingEnergyGGXGlassTexture)
    SHADER_PARAMETER_TEXTURE(Texture2D<float2>, ShadingEnergyClothSpecTexture)
    SHADER_PARAMETER_TEXTURE(Texture2D<float>, ShadingEnergyDiffuseTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, ShadingEnergySampler)
    // Glints
    SHADER_PARAMETER_TEXTURE(Texture2DArray<float4>, GlintTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, GlintSampler)
    // Simple volume texture
    SHADER_PARAMETER_TEXTURE(Texture3D<float>, SimpleVolumeTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SimpleVolumeTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture3D<float>, SimpleVolumeEnvTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SimpleVolumeEnvTextureSampler)
    // SSS
    SHADER_PARAMETER_TEXTURE(Texture2D, SSProfilesTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SSProfilesSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, SSProfilesTransmissionSampler)
    SHADER_PARAMETER_TEXTURE(Texture2DArray, SSProfilesPreIntegratedTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SSProfilesPreIntegratedSampler)
    // Specular Profile
    SHADER_PARAMETER_TEXTURE(Texture2DArray, SpecularProfileTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, SpecularProfileSampler)
    // Water
    SHADER_PARAMETER_SRV(Buffer<float4>, WaterIndirection)
    SHADER_PARAMETER_SRV(Buffer<float4>, WaterData)
    SHADER_PARAMETER(int32, WaterInfoTextureViewIndex)
    // Rect light atlas
    SHADER_PARAMETER(FVector4f, RectLightAtlasSizeAndInvSize)
    SHADER_PARAMETER(float, RectLightAtlasMaxMipLevel)
    SHADER_PARAMETER_TEXTURE(Texture2D<float4>, RectLightAtlasTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, RectLightAtlasSampler)
    // IES atlas
    SHADER_PARAMETER(FVector4f, IESAtlasSizeAndInvSize)
    SHADER_PARAMETER_TEXTURE(Texture2DArray<float>, IESAtlasTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, IESAtlasSampler)
    // Landscape
    SHADER_PARAMETER_SAMPLER(SamplerState, LandscapeWeightmapSampler)
    SHADER_PARAMETER_SRV(Buffer<uint>, LandscapeIndirection)
    SHADER_PARAMETER_SRV(Buffer<float>, LandscapePerComponentData)
 
    SHADER_PARAMETER_UAV(RWStructuredBuffer<uint>, VTFeedbackBuffer)
 
    SHADER_PARAMETER_SRV(Buffer<float>, PhysicsFieldClipmapBuffer)
 
    // Blue noise texture
    SHADER_PARAMETER_TEXTURE(Texture2D<float>, BlueNoiseScalarTexture)
    SHADER_PARAMETER(FIntVector, BlueNoiseDimensions)
    SHADER_PARAMETER(FIntVector, BlueNoiseModuloMasks)
 
    // Ray tracing
    SHADER_PARAMETER(FVector3f, TLASPreViewTranslationHigh)
    SHADER_PARAMETER(FVector3f, TLASPreViewTranslationLow)
 
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
#undef VIEW_UNIFORM_BUFFER_MEMBER
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW
#undef VIEW_UNIFORM_BUFFER_MEMBER_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW
 
#define INSTANCED_VIEW_COUNT 2
 
#define VIEW_UNIFORM_BUFFER_MEMBER(type, identifier) \
    SHADER_PARAMETER(type, identifier)
 
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(type, identifier) \
    SHADER_PARAMETER_ARRAY(TShaderParameterTypeInfo<type>::TInstancedType, identifier, [INSTANCED_VIEW_COUNT])
 
#define VIEW_UNIFORM_BUFFER_MEMBER_EX(type, identifier, precision) \
    SHADER_PARAMETER_EX(type, identifier, precision)
 
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(type, identifier, precision) \
    SHADER_PARAMETER_ARRAY_EX(TShaderParameterTypeInfo<type>::TInstancedType, identifier, [INSTANCED_VIEW_COUNT], precision)
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(type, identifier, dimension) \
    SHADER_PARAMETER_ARRAY(type, identifier, [dimension])
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW(type, identifier, dimension) \
    SHADER_PARAMETER_ARRAY(type, identifier, [dimension * INSTANCED_VIEW_COUNT])
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT_WITH_CONSTRUCTOR(FInstancedViewUniformShaderParameters, ENGINE_API)
    VIEW_UNIFORM_BUFFER_MEMBER_TABLE
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
#undef VIEW_UNIFORM_BUFFER_MEMBER
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW
#undef VIEW_UNIFORM_BUFFER_MEMBER_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW
 
#define VIEW_UNIFORM_BUFFER_MEMBER(type, identifier) \
    if ( CopyViewId == 0 ) \
    { \
        FMemory::Memcpy(&InstancedViewParameters.identifier, &ViewParameters.identifier, sizeof(type)); \
    }
 
// since per-view attributes are of type type, but the backing structure is TInstancedType for 16 byte alignment, we'd need to mem0 the rest,
// but we rely on FInstancedViewUniformShaderParameters zeroing itself in the constructor
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(type, identifier) \
    FMemory::Memcpy(&InstancedViewParameters.identifier[CopyViewId], &ViewParameters.identifier, sizeof(type)); \
    check(FMemory::MemIsZero(((uint8*) &InstancedViewParameters.identifier[CopyViewId]) + sizeof(type), sizeof(TShaderParameterTypeInfo<type>::TInstancedType) - sizeof(type)));
 
#define VIEW_UNIFORM_BUFFER_MEMBER_EX(type, identifier, precision) \
    if ( CopyViewId == 0 ) \
    { \
        FMemory::Memcpy(&InstancedViewParameters.identifier, &ViewParameters.identifier, sizeof(type)); \
    }
 
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(type, identifier, precision) \
    FMemory::Memcpy(&InstancedViewParameters.identifier[CopyViewId], &ViewParameters.identifier, sizeof(type)); \
    check(FMemory::MemIsZero(((uint8*)&InstancedViewParameters.identifier[CopyViewId]) + sizeof(type), sizeof(TShaderParameterTypeInfo<type>::TInstancedType) - sizeof(type)));
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(type, identifier, dimension) \
    if ( CopyViewId == 0 ) \
    { \
        for (uint32 ElementIndex = 0; ElementIndex < dimension; ElementIndex++) \
        { \
            FMemory::Memcpy(&InstancedViewParameters.identifier[CopyViewId * dimension + ElementIndex], &ViewParameters.identifier[ElementIndex], sizeof(type)); \
        } \
    }
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW(type, identifier, dimension) \
    for (uint32 ElementIndex = 0; ElementIndex < dimension; ElementIndex++) \
    { \
        FMemory::Memcpy(&InstancedViewParameters.identifier[CopyViewId * dimension + ElementIndex], &ViewParameters.identifier[ElementIndex], sizeof(type)); \
        check(FMemory::MemIsZero(((uint8*) &InstancedViewParameters.identifier[CopyViewId * dimension + ElementIndex]) + sizeof(type), sizeof(TShaderParameterTypeInfo<type>::TInstancedType) - sizeof(type))); \
    }
 
namespace InstancedViewParametersUtils
{
    static void CopyIntoInstancedViewParameters(FInstancedViewUniformShaderParameters& InstancedViewParameters, const FViewUniformShaderParameters& ViewParameters, uint32 CopyViewId)
    {
        VIEW_UNIFORM_BUFFER_MEMBER_TABLE
    }
}
 
#undef VIEW_UNIFORM_BUFFER_MEMBER
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW
#undef VIEW_UNIFORM_BUFFER_MEMBER_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW
 
#define VIEW_UNIFORM_BUFFER_MEMBER(type, identifier) \
    FMemory::Memcpy(&DstView.identifier, &SrcView.identifier, sizeof(type));
 
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW(type, identifier) \
    FMemory::Memcpy(&DstView.identifier, &SrcView.identifier, sizeof(type));
 
#define VIEW_UNIFORM_BUFFER_MEMBER_EX(type, identifier, precision) \
    FMemory::Memcpy(&DstView.identifier, &SrcView.identifier, sizeof(type));
 
#define VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX(type, identifier, precision) \
    FMemory::Memcpy(&DstView.identifier, &SrcView.identifier, sizeof(type));
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY(type, identifier, dimension) \
    for (uint32 ElementIndex = 0; ElementIndex < dimension; ElementIndex++) \
    { \
        FMemory::Memcpy(&DstView.identifier[ElementIndex], &SrcView.identifier[ElementIndex], sizeof(type)); \
    } \
 
#define VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW(type, identifier, dimension) \
    for (uint32 ElementIndex = 0; ElementIndex < dimension; ElementIndex++) \
    { \
        FMemory::Memcpy(&DstView.identifier[ElementIndex], &SrcView.identifier[ElementIndex], sizeof(type)); \
    } \
 
namespace ViewParametersUtils
{
    // This only copy the base view, not any instanced view data.
    static void CopyViewParametersOnly(FViewUniformShaderParameters& DstView, const FViewUniformShaderParameters& SrcView)
    {
        VIEW_UNIFORM_BUFFER_MEMBER_TABLE
    }
}
 
#undef VIEW_UNIFORM_BUFFER_MEMBER
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW
#undef VIEW_UNIFORM_BUFFER_MEMBER_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_PER_VIEW_EX
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY
#undef VIEW_UNIFORM_BUFFER_MEMBER_ARRAY_PER_VIEW
 
#undef INSTANCED_VIEW_COUNT
#undef VIEW_UNIFORM_BUFFER_MEMBER_TABLE
 
BEGIN_SHADER_PARAMETER_STRUCT(FViewShaderParameters, )
    SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
    SHADER_PARAMETER_STRUCT_REF(FInstancedViewUniformShaderParameters, InstancedView)
END_SHADER_PARAMETER_STRUCT()
 
namespace EDrawDynamicFlags
{
    enum Type : int32
    {
        None = 0,
        ForceLowestLOD = 0x1,
        FarShadowCascade = 0x2,
    };
}
 
enum class EViewWaterIntersection : uint8
{
    OutsideWater,
    PossiblyIntersectingWater,
    InsideWater
};
 
// Hacky base class to avoid 8 bytes of padding after the vtable
class FSceneViewFixLayout
{
public:
    virtual ~FSceneViewFixLayout() = default;
};
 
class FSceneView : public FSceneViewFixLayout
{
public:
    const FSceneViewFamily* Family;
    FSceneViewStateInterface* State;
 
    TUniformBufferRef<FViewUniformShaderParameters> ViewUniformBuffer;
 
private:
    const FConvexVolume* DynamicMeshElementsShadowCullFrustum;
    FVector     PreShadowTranslation;
 
    TSharedPtr<FConvexVolume> StereoCullingFrustum;
    void SetupViewFrustum();
 
public:
    FSceneViewInitOptions SceneViewInitOptions;
 
    FSceneViewOwner ViewActor; // TODO: Rename to ViewOwner
     
    int32 PlayerIndex;
 
    FViewElementDrawer* Drawer;
 
    /* Final position of the view in the final render target (in pixels), potentially constrained by an aspect ratio requirement (black bars) */
    const FIntRect UnscaledViewRect;
 
    /* Raw view size (in pixels), used for screen space calculations */
    FIntRect UnconstrainedViewRect;
 
    int32 MaxShadowCascades;
 
    FViewMatrices ViewMatrices;
 
    FVector     ViewLocation;
    FRotator    ViewRotation;
    FQuat       BaseHmdOrientation;
    FVector     BaseHmdLocation;
    float       WorldToMetersScale;
    TOptional<FTransform> PreviousViewTransform;
 
    UE_DEPRECATED(5.6, "Use GetShadowViewMatrices instead")
    uint8 ShadowViewMatrices;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ENGINE_API const FViewMatrices& GetShadowViewMatrices() const;
#else
    const FViewMatrices& GetShadowViewMatrices() const { return ViewMatrices; }
#endif
 
    FMatrix ProjectionMatrixUnadjustedForRHI;
 
    FLinearColor BackgroundColor;
    FLinearColor OverlayColor;
 
    FLinearColor ColorScale;
 
    EStereoscopicPass StereoPass;
 
    int32 StereoViewIndex;
 
    int32 PrimaryViewIndex;
 
    bool bAllowCrossGPUTransfer;
 
    bool bOverrideGPUMask;
 
    FRHIGPUMask GPUMask;
 
    bool bRenderFirstInstanceOnly;
 
    // Whether to use FOV when computing mesh LOD.
    bool bUseFieldOfViewForLOD;
 
    // Whether this view should use an HMD hidden area mask where appropriate.
    bool bHMDHiddenAreaMaskActive = false;
 
    float FOV;
    float DesiredFOV;
 
    EDrawDynamicFlags::Type DrawDynamicFlags;
 
    FName CurrentBufferVisualizationMode;
 
    FName CurrentNaniteVisualizationMode;
 
    FName CurrentLumenVisualizationMode;
 
    FName CurrentSubstrateVisualizationMode;
 
    FName CurrentGroomVisualizationMode;
 
    FName CurrentVirtualShadowMapVisualizationMode;
 
    FName CurrentVirtualTextureVisualizationMode;
 
    FName CurrentVisualizeCalibrationColorMaterialName;
 
    FName CurrentVisualizeCalibrationGrayscaleMaterialName;
 
    FName CurrentVisualizeCalibrationCustomMaterialName;
 
    FName CurrentGPUSkinCacheVisualizationMode;
 
#if WITH_EDITOR
    /* Whether to use the pixel inspector */
    bool bUsePixelInspector;
#endif //WITH_EDITOR
 
    FVector4f DiffuseOverrideParameter;
    FVector4f SpecularOverrideParameter;
    FVector4f NormalOverrideParameter;
    FVector2f RoughnessOverrideParameter;
    FVector2f AmbientOcclusionOverrideParameter;
 
    float MaterialTextureMipBias;
 
    TSet<FPrimitiveComponentId> HiddenPrimitives;
 
    TOptional<TSet<FPrimitiveComponentId>> ShowOnlyPrimitives;
 
    // Derived members.
 
    bool bAllowTemporalJitter;
 
    FConvexVolume ViewFrustum;
 
    UE_DEPRECATED(5.6, "Use GetCullingFrustum() instead.")
    uint8 CullingFrustum;
 
    const FConvexVolume& GetCullingFrustum() const
    {
        return StereoCullingFrustum ? *StereoCullingFrustum : ViewFrustum;
    }
 
    bool bHasNearClippingPlane;
 
    FPlane NearClippingPlane;
 
    float NearClippingDistance;
 
    FVector CullingOrigin;
 
    bool bReverseCulling;
 
    /* Vector used by shaders to convert depth buffer samples into z coordinates in world space */
    FVector4f InvDeviceZToWorldZTransform;
 
    FVector OriginOffsetThisFrame;
 
    float LODDistanceFactor;
 
    bool bCameraCut;
    
    // -1,-1 if not setup
    FIntPoint CursorPos;
 
    bool bIsGameView;
 
    bool bIsViewInfo;
 
    class FCustomRenderPassBase* CustomRenderPass = nullptr;
 
    bool bIsSceneCapture;
 
    bool bIsSceneCaptureCube;
 
    bool bEyeAdaptationAllViewPixels;
 
    bool bSceneCaptureUsesRayTracing;
 
    bool bIsReflectionCapture;
 
    bool bIsPlanarReflection;
 
    bool bIsVirtualTexture;
 
    bool bIsOfflineRender;
 
    bool bRenderSceneTwoSided;
 
    bool bIsLocked;
 
    bool bStaticSceneOnly;
 
    bool bIsInstancedStereoEnabled;
 
    bool bIsMultiViewportEnabled;
 
    bool bIsMobileMultiViewEnabled;
 
    bool bShouldBindInstancedViewUB;
 
    bool bIsSinglePassStereo;
 
    bool bForceCameraVisibilityReset;
 
    bool bDisableDistanceBasedFadeTransitions;
 
    bool bExcludeFromSceneTextureExtents = false;
 
    bool bForcePathTracerReset;
 
    int32 PathTracerSeedOffset;
 
    float UnderwaterDepth;
 
    EViewWaterIntersection WaterIntersection = EViewWaterIntersection::OutsideWater;
 
    FPlane GlobalClippingPlane;
 
    FIntRect CameraConstrainedViewRect;
 
    FVector TranslucentSortAxis;
 
    TEnumAsByte<ETranslucentSortPolicy::Type> TranslucentSortPolicy;
    
    TOptional<uint32> OverrideFrameIndexValue;
    TOptional<uint32> OverrideOutputFrameIndexValue;
 
    FVector4f LensPrincipalPointOffsetScale;
 
    TOptional<bool> bCameraMotionBlur;
 
    TOptional<FMatrix> ClipToPrevClipOverride;
 
#if WITH_EDITOR
    uint64 EditorViewBitflag;
 
    bool bAllowTranslucentPrimitivesInHitProxy;
 
    TBitArray<> SpriteCategoryVisibility;
    FLinearColor SelectionOutlineColor;
    FLinearColor SubduedSelectionOutlineColor;
    TStaticArray<FLinearColor, 6> AdditionalSelectionOutlineColors;
    bool bHasSelectedComponents;
 
    TSharedPtr<UE::RenderViewportFeedback::FCollector> ViewportFeedback;
#endif
 
    FFinalPostProcessSettings FinalPostProcessSettings;
#if DEBUG_POST_PROCESS_VOLUME_ENABLE
    TArray<FPostProcessSettingsDebugInfo> FinalPostProcessDebugInfo;
#endif
 
    // The antialiasing method.
    EAntiAliasingMethod AntiAliasingMethod;
 
    // Primary screen percentage method to use.
    EPrimaryScreenPercentageMethod PrimaryScreenPercentageMethod;
 
    FTextureRHIRef AtmosphereTransmittanceTexture;
    FTextureRHIRef AtmosphereIrradianceTexture;
    FTextureRHIRef AtmosphereInscatterTexture;
 
    FShaderResourceViewRHIRef WaterIndirectionBuffer;
    FShaderResourceViewRHIRef WaterDataBuffer;
    int32 WaterInfoTextureViewIndex = INDEX_NONE;
 
    struct FWaterInfoTextureRenderingParams
    {
        FRenderTarget* RenderTarget = nullptr;
        FVector ViewLocation = FVector::Zero();
        FMatrix ViewRotationMatrix = FMatrix(EForceInit::ForceInit);
        FMatrix ProjectionMatrix = FMatrix(EForceInit::ForceInit);
        TSet<FPrimitiveComponentId> TerrainComponentIds;
        TSet<FPrimitiveComponentId> WaterBodyComponentIds;
        TSet<FPrimitiveComponentId> DilatedWaterBodyComponentIds;
        FVector WaterZoneExtents = FVector::Zero();
        FVector2f WaterHeightExtents = FVector2f::ZeroVector;
        float GroundZMin = 0.0f;
        float CaptureZ = 0.0f;
        int32 VelocityBlurRadius = 0;
        int32 RenderTargetArrayLayer = 0;
    };
    TArray<FWaterInfoTextureRenderingParams> WaterInfoTextureRenderingParams;
 
    FShaderResourceViewRHIRef LandscapeIndirectionBuffer;
    FShaderResourceViewRHIRef LandscapePerComponentDataBuffer;
 
    bool bEnableDynamicCocOffset = false;
 
    float InFocusDistance = 0.0;
 
    FTextureRHIRef DynamicCocOffsetLUT;
 
    const ERHIFeatureLevel::Type FeatureLevel;
 
    uint32 InstanceFactor = 1;
 
    bool bAllowRayTracing = true;
 
    uint8 ViewLightingChannelMask = FViewLightingChannels::GetMaskDefault();
 
    UE::StereoRenderUtils::FStereoShaderAspects Aspects;
 
protected:
    friend class FSceneRenderer;
 
    const FSceneView* SnapshotOriginView = nullptr;
 
public:
 
    ENGINE_API FSceneView(const FSceneViewInitOptions& InitOptions);
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FSceneView(const FSceneView& Other) = default;
    FSceneView(FSceneView&& Other) = default;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API virtual ~FSceneView();
 
#if DO_CHECK || USING_CODE_ANALYSIS
    ENGINE_API bool VerifyMembersChecks() const;
#endif
 
    inline bool AllowGPUParticleUpdate() const { return !bIsPlanarReflection && !bIsSceneCapture && !bIsReflectionCapture; }
 
    ENGINE_API FVector4 WorldToScreen(const FVector& WorldPoint) const;
 
    ENGINE_API FVector ScreenToWorld(const FVector4& ScreenPoint) const;
 
    ENGINE_API bool ScreenToPixel(const FVector4& ScreenPoint,FVector2D& OutPixelLocation) const;
 
    ENGINE_API FVector4 PixelToScreen(float X,float Y,float Z) const;
 
    ENGINE_API FVector4 CursorToScreen(float X, float Y, float Z) const;
 
    ENGINE_API bool WorldToPixel(const FVector& WorldPoint,FVector2D& OutPixelLocation) const;
 
    ENGINE_API FVector4 PixelToWorld(float X,float Y,float Z) const;
 
    ENGINE_API FPlane Project(const FVector& WorldPoint) const;
 
    ENGINE_API FVector Deproject(const FPlane& ScreenPoint) const;
 
    ENGINE_API void DeprojectFVector2D(const FVector2D& ScreenPos, FVector& out_WorldOrigin, FVector& out_WorldDirection) const;
 
    static ENGINE_API void DeprojectScreenToWorld(const FVector2D& ScreenPos, const FIntRect& ViewRect, const FMatrix& InvViewMatrix, const FMatrix& InvProjMatrix, FVector& out_WorldOrigin, FVector& out_WorldDirection);
 
    static ENGINE_API void DeprojectScreenToWorld(const FVector2D& ScreenPos, const FIntRect& ViewRect, const FMatrix& InvViewProjMatrix, FVector& out_WorldOrigin, FVector& out_WorldDirection);
 
    static ENGINE_API bool ProjectWorldToScreen(const FVector& WorldPosition, const FIntRect& ViewRect, const FMatrix& ViewProjectionMatrix, FVector2D& out_ScreenPos, bool bShouldCalcOutsideViewPosition = false);
 
    inline FVector GetViewRight() const { return ViewMatrices.GetViewMatrix().GetColumn(0); }
    inline FVector GetViewUp() const { return ViewMatrices.GetViewMatrix().GetColumn(1); }
    inline FVector GetViewDirection() const { return ViewMatrices.GetViewMatrix().GetColumn(2); }
 
    inline const FConvexVolume* GetDynamicMeshElementsShadowCullFrustum() const { return DynamicMeshElementsShadowCullFrustum; }
    inline void SetDynamicMeshElementsShadowCullFrustum(const FConvexVolume* InDynamicMeshElementsShadowCullFrustum) { DynamicMeshElementsShadowCullFrustum = InDynamicMeshElementsShadowCullFrustum; }
 
    inline const FVector& GetPreShadowTranslation() const { return PreShadowTranslation; }
    inline void SetPreShadowTranslation(const FVector& InPreShadowTranslation) { PreShadowTranslation = InPreShadowTranslation; }
 
    inline bool IsPerspectiveProjection() const { return ViewMatrices.IsPerspectiveProjection(); }
 
    bool IsUnderwater() const { return UnderwaterDepth > 0.0f; }
 
    ENGINE_API FVector GetTemporalLODOrigin(int32 Index, bool bUseLaggedLODTransition = true) const;
 
    ENGINE_API float GetTemporalLODTransition() const;
 
    ENGINE_API uint32 GetDistanceFieldTemporalSampleIndex() const;
 
    ENGINE_API uint32 GetViewKey() const;
 
    ENGINE_API uint32 GetOcclusionFrameCounter() const;
 
    ENGINE_API void UpdateProjectionMatrix(const FMatrix& NewProjectionMatrix);
 
    ENGINE_API void UpdateViewMatrix();
 
    ENGINE_API void UpdatePlanarReflectionViewMatrix(const FSceneView& SourceView, const FMirrorMatrix& MirrorMatrix);
 
    ENGINE_API void StartFinalPostprocessSettings(FVector InViewLocation);
 
    ENGINE_API void OverridePostProcessSettings(const FPostProcessSettings& Src, float Weight);
 
    ENGINE_API void EndFinalPostprocessSettings(const FSceneViewInitOptions& ViewInitOptions);
 
    ENGINE_API void SetupAntiAliasingMethod();
 
    ENGINE_API void ConfigureBufferVisualizationSettings();
 
#if !(UE_BUILD_SHIPPING)
    ENGINE_API void ConfigureVisualizeCalibrationSettings();
#endif
 
    ERHIFeatureLevel::Type GetFeatureLevel() const { return FeatureLevel; }
 
    ENGINE_API EShaderPlatform GetShaderPlatform() const;
 
    ENGINE_API bool IsInstancedStereoPass() const;
 
    int32 GetStereoPassInstanceFactor() const { return InstanceFactor; }
 
    ENGINE_API void SetupViewRectUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters, 
        const FIntPoint& InBufferSize,
        const FIntRect& InEffectiveViewRect,
        const FViewMatrices& InViewMatrices,
        const FViewMatrices& InPrevViewMatrice) const;
 
    static ENGINE_API FVector4f GetScreenPositionScaleBias(const FIntPoint& BufferSize, const FIntRect& ViewRect);
 
    ENGINE_API void SetupCommonViewUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters,
        const FIntPoint& InBufferSize,
        int32 NumMSAASamples,
        const FIntRect& InEffectiveViewRect,
        const FViewMatrices& InViewMatrices,
        const FViewMatrices& InPrevViewMatrices) const;
 
    FName CurrentRayTracingDebugVisualizationMode;
 
    ENGINE_API bool HasValidEyeAdaptationBuffer() const;
 
    ENGINE_API FRDGPooledBuffer* GetEyeAdaptationBuffer() const;
 
    ENGINE_API float GetLastEyeAdaptationExposure() const;
 
    ENGINE_API float GetLastAverageSceneLuminance() const;
 
    ENGINE_API const FSceneView* GetPrimarySceneView() const;
 
    inline bool IsPrimarySceneView() const
    {
        return GetPrimarySceneView() == this;
    }
 
    ENGINE_API const FSceneView* GetInstancedSceneView() const;
 
    inline bool IsInstancedSceneView() const
    {
        return GetInstancedSceneView() == this;
    }
 
    ENGINE_API TArray<const FSceneView*> GetSecondaryViews() const;
 
    const TUniformBufferRef<FInstancedViewUniformShaderParameters>& GetInstancedViewUniformBuffer() const
    {
        return InstancedViewUniformBuffer;
    }
 
    inline ERenderTargetLoadAction GetOverwriteLoadAction() const
    {
        return bHMDHiddenAreaMaskActive ? ERenderTargetLoadAction::EClear : ERenderTargetLoadAction::ENoAction;
    }
 
    const FSceneView* GetSnapshotOriginView() const { return SnapshotOriginView; }
 
    inline bool IsRayTracingAllowedForView() const
    {
        return bAllowRayTracing && (!bIsSceneCapture || bSceneCaptureUsesRayTracing);
    }
 
    inline bool HasEyeAdaptationViewState() const
    {
        return EyeAdaptationViewState != nullptr;
    }
 
protected:
    friend class FViewSnapshotCache;
 
    FSceneViewStateInterface* EyeAdaptationViewState = nullptr;
 
    TUniformBufferRef<FInstancedViewUniformShaderParameters> InstancedViewUniformBuffer;
};
 
 
// for r.DisplayInternals (allows for easy passing down data from main to render thread)
struct FDisplayInternalsData
{
    //
    int32 DisplayInternalsCVarValue;
    // -1 if not set, from IStreamingManager::Get().StreamAllResources(Duration) in FStreamAllResourcesLatentCommand
    uint32 NumPendingStreamingRequests;
 
    FDisplayInternalsData()
        : DisplayInternalsCVarValue(0)
        , NumPendingStreamingRequests(-1)
    {
        check(!IsValid());
    }
 
    // called on main thread
    // @param World may be 0
    void Setup(UWorld *World);
 
    bool IsValid() const { return DisplayInternalsCVarValue != 0; }
};
 
 
class ISceneViewFamilyExtention
{
protected:
    virtual ~ISceneViewFamilyExtention() {};
 
    friend class FSceneViewFamily;
};
 
class ISceneViewFamilyExtentionData : public ISceneViewFamilyExtention
{
public:
    virtual const TCHAR* GetSubclassIdentifier() const = 0;
};
 
 
/*
 * Game thread and render thread interface that takes care of a FSceneViewFamily's screen percentage.
 *
 * The renderer reserves the right to delete and replace the view family's screen percentage interface
 * for testing purposes with the r.Test.OverrideScreenPercentageInterface CVar.
 */
class ISceneViewFamilyScreenPercentage : ISceneViewFamilyExtention
{
public:
    // Sets the minimal and max screen percentage.
    static constexpr float kMinResolutionFraction = 0.01f;
    static constexpr float kMaxResolutionFraction = 4.0f;
 
    // Sets the minimal and maximal screen percentage for TSR.
    static constexpr float kMinTSRResolutionFraction = 0.25f;
    static constexpr float kMaxTSRResolutionFraction = 2.0f;
 
    // Sets the minimal and maximal screen percentage for TAAU.
    static constexpr float kMinTAAUpsampleResolutionFraction = 0.5f;
    static constexpr float kMaxTAAUpsampleResolutionFraction = 2.0f;
 
#if DO_CHECK || USING_CODE_ANALYSIS
    static bool IsValidResolutionFraction(float ResolutionFraction)
    {
        return ResolutionFraction >= kMinResolutionFraction && ResolutionFraction <= kMaxResolutionFraction;
    }
#endif
 
    virtual DynamicRenderScaling::TMap<float> GetResolutionFractionsUpperBound() const = 0;
 
    virtual ISceneViewFamilyScreenPercentage* Fork_GameThread(const class FSceneViewFamily& ViewFamily) const = 0;
 
protected:
    virtual DynamicRenderScaling::TMap<float> GetResolutionFractions_RenderThread() const = 0;
 
    friend class FSceneViewFamily;
    friend class FSceneRenderer;
};
 
 
 
class FSceneViewFamily
{
public:
    struct ConstructionValues
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        ConstructionValues(ConstructionValues&&) = default;
        ConstructionValues(const ConstructionValues& Other) = default;
        ConstructionValues& operator=(ConstructionValues&&) = default;
        ConstructionValues& operator=(const ConstructionValues& Other) = default;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
        ENGINE_API ConstructionValues(
            const FRenderTarget* InRenderTarget,
            FSceneInterface* InScene,
            const FEngineShowFlags& InEngineShowFlags
            );
 
        const FRenderTarget* RenderTarget;
        const FRenderTarget* RenderTargetDepth;
 
        FSceneInterface* Scene;
 
        FEngineShowFlags EngineShowFlags;
 
        int32 ViewModeParam;
        FName ViewModeParamName;
 
        FGameTime Time;
 
        uint32 bAdditionalViewFamily : 1;
 
        uint32 bRealtimeUpdate:1;
        
        uint32 bDeferClear:1;
        
        uint32 bResolveScene:1;     
        
        uint32 bTimesSet:1;
 
        uint32 bRequireMultiView:1;
 
        ConstructionValues& SetRenderTargetDepth(const FRenderTarget* InRenderTargetDepth)
        {
            RenderTargetDepth = InRenderTargetDepth;
            return *this;
        }
 
        ConstructionValues& SetTime(const FGameTime& InTime)
        {
            Time = InTime;
            bTimesSet = true;
            return *this;
        }
 
        ConstructionValues& SetAdditionalViewFamily(const bool Value) { bAdditionalViewFamily = Value; return *this; }
 
        ConstructionValues& SetRealtimeUpdate(const bool Value) { bRealtimeUpdate = Value; return *this; }
        
        ConstructionValues& SetDeferClear(const bool Value) { bDeferClear = Value; return *this; }
        
        ConstructionValues& SetResolveScene(const bool Value) { bResolveScene = Value; return *this; }
 
        ConstructionValues& SetRequireMobileMultiView(const bool Value) { bRequireMultiView = Value; return *this; }
 
        ConstructionValues& SetViewModeParam(const int InViewModeParam, const FName& InViewModeParamName) { ViewModeParam = InViewModeParam; ViewModeParamName = InViewModeParamName; return *this; }       
    };
    
    TArray<const FSceneView*> Views;
 
    TArray<const FSceneView*> AllViews;
 
    EViewModeIndex ViewMode;
 
    const FRenderTarget* RenderTarget;
    const FRenderTarget* RenderTargetDepth;
 
    FSceneInterface* Scene;
 
    FEngineShowFlags EngineShowFlags;
 
    FGameTime Time;
 
    uint32 FrameNumber;
 
    uint64 FrameCounter = 0;
 
    bool bAdditionalViewFamily;
 
    bool bRealtimeUpdate;
 
    bool bDeferClear;
 
    bool bResolveScene;
 
    bool bMultiGPUForkAndJoin;
 
#if WITH_MGPU
    bool bForceCopyCrossGPU = false;
#endif
 
    UE_DEPRECATED(5.6, "bIsMultipleViewFamily is no longer used")
    bool bIsMultipleViewFamily = false;
    
    bool bIsFirstViewInMultipleViewFamily = true;
 
    bool bIsViewFamilyInfo = false;
 
    bool bSplitScreenDebugAllowed = false;
 
    bool bIsMainViewFamily = false;
 
    ESceneCaptureSource SceneCaptureSource;
    
 
    ESceneCaptureCompositeMode SceneCaptureCompositeMode;
 
    bool bThumbnailRendering = false;
 
    bool bWorldIsPaused;
 
    bool bIsHDR;
 
    bool bRequireMultiView;
    
    float DebugDPIScale = 1.0f;
 
    FExposureSettings ExposureSettings;
 
    TArray<TSharedRef<class ISceneViewExtension, ESPMode::ThreadSafe> > ViewExtensions;
 
    // for r.DisplayInternals (allows for easy passing down data from main to render thread)
    FDisplayInternalsData DisplayInternalsData;
 
    float SecondaryViewFraction;
    ESecondaryScreenPercentageMethod SecondaryScreenPercentageMethod;
 
    // Override the LOD of landscape in this viewport
    int8 LandscapeLODOverride;
 
    bool bCurrentlyBeingEdited;
 
    bool bOverrideVirtualTextureThrottle;
 
    int32 VirtualTextureFeedbackFactor;
 
#if WITH_EDITOR
    bool bDrawBaseInfo;
 
    bool bNullifyWorldSpacePosition;
#endif
 
    // Optional description of view family for Unreal Insights profiling
    FString ProfileDescription;
 
    UE_DEPRECATED(5.6, "This member is no longer used")
    float* ProfileSceneRenderTime = nullptr;
 
    TArray<FVector, TInlineAllocator<2>> StreamingViewOrigins;
 
    ENGINE_API FSceneViewFamily( const ConstructionValues& CVS );
    ENGINE_API FSceneViewFamily(const FSceneViewFamily&);
    ENGINE_API virtual ~FSceneViewFamily();
 
    ENGINE_API ERHIFeatureLevel::Type GetFeatureLevel() const;
 
    EShaderPlatform GetShaderPlatform() const { return GetFeatureLevelShaderPlatform(GetFeatureLevel()); }
 
#if WITH_DEBUG_VIEW_MODES
    UE_DEPRECATED(5.7, "Use GetDebugViewShaderMode()")
    mutable EDebugViewShaderMode DebugViewShaderMode = DVSM_MAX; // should be private
    UE_DEPRECATED(5.7, "Use GetViewModeParam()")
    int32 ViewModeParam;
    UE_DEPRECATED(5.7, "Use GetViewModeParamName()")
    FName ViewModeParamName;
 
    UE_DEPRECATED(5.7, "Use GetDebugViewShaderMode()")
    ENGINE_API EDebugViewShaderMode ChooseDebugViewShaderMode() const;
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    // Return the debug viewmode last set by SetDebugViewShaderMode.
    // If no debug viewmode was set, this function will set one based on showflags.
    ENGINE_API EDebugViewShaderMode GetDebugViewShaderMode() const;
    void SetDebugViewShaderMode(EDebugViewShaderMode InMode) { DebugViewShaderMode = InMode; }
    inline int32 GetViewModeParam() const { return ViewModeParam; }
    inline const FName& GetViewModeParamName() const { return ViewModeParamName; }  
    inline bool UseDebugViewPS() const { return GetDebugViewShaderMode() != DVSM_None; }
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#else
    inline EDebugViewShaderMode GetDebugViewShaderMode() const { return DVSM_None; }
    void SetDebugViewShaderMode(EDebugViewShaderMode InMode) { }
    inline int32 GetViewModeParam() const { return -1; }
    inline FName GetViewModeParamName() const { return NAME_None; }
    inline bool UseDebugViewPS() const { return false; }
#endif
 
    ENGINE_API bool SupportsScreenPercentage() const;
 
    inline bool AllowTranslucencyAfterDOF() const { return bAllowTranslucencyAfterDOF; }
 
    inline bool AllowStandardTranslucencySeparated() const { return bAllowStandardTranslucencySeparated; }
 
    inline const ISceneViewFamilyScreenPercentage* GetScreenPercentageInterface() const
    {
        return ScreenPercentageInterface;
    }
 
    inline void SetScreenPercentageInterface(ISceneViewFamilyScreenPercentage* InScreenPercentageInterface)
    {
        check(InScreenPercentageInterface);
        checkf(ScreenPercentageInterface == nullptr, TEXT("View family already had a screen percentage interface assigned."));
        ScreenPercentageInterface = InScreenPercentageInterface;
    }
 
    inline void SetScreenPercentageInterface_Unchecked(ISceneViewFamilyScreenPercentage* InScreenPercentageInterface)
    {
        ScreenPercentageInterface = InScreenPercentageInterface;
    }
 
    // View family assignment operator is not allowed because of ScreenPercentageInterface lifetime.
    void operator = (const FSceneViewFamily&) = delete;
 
    // Allow moving view family as long as no screen percentage interface are set.
    ENGINE_API FSceneViewFamily(FSceneViewFamily&& InViewFamily);
 
    template<typename TExtensionData> const TExtensionData* GetExtentionData() const
    {
        static_assert(TIsDerivedFrom<TExtensionData, ISceneViewFamilyExtentionData>::Value, "TExtensionData is not derived from ISceneViewFamilyExtentionData.");
 
        for (const TSharedRef<class ISceneViewFamilyExtentionData, ESPMode::ThreadSafe>& ViewExtensionData : ViewExtentionDatas)
        {
            if (ViewExtensionData->GetSubclassIdentifier() == TExtensionData::GSubclassIdentifier)
            {
                return static_cast<const TExtensionData*>(&ViewExtensionData.Get());
            }
        }
        return nullptr;
    }
 
    template<typename TExtensionData> TExtensionData* GetExtentionData()
    {
        return const_cast<TExtensionData*>(AsConst(*this).GetExtentionData<TExtensionData>());
    }
 
    template<typename TExtensionData> TExtensionData* GetOrCreateExtentionData()
    {
        TExtensionData* ViewExtensionData = GetExtentionData<TExtensionData>();
        if (!ViewExtensionData)
        {
            ViewExtentionDatas.Push(MakeShared<TExtensionData>());
            ViewExtensionData = static_cast<TExtensionData*>(&ViewExtentionDatas.Last().Get());
            check(ViewExtensionData->GetSubclassIdentifier() == TExtensionData::GSubclassIdentifier);
        }
        return ViewExtensionData;
    }
 
    inline void SetTemporalUpscalerInterface(UE::Renderer::Private::ITemporalUpscaler* InTemporalUpscalerInterface)
    {
        check(InTemporalUpscalerInterface);
        checkf(TemporalUpscalerInterface == nullptr, TEXT("View family already had a temporal upscaler assigned."));
        TemporalUpscalerInterface = InTemporalUpscalerInterface;
    }
 
    inline const UE::Renderer::Private::ITemporalUpscaler* GetTemporalUpscalerInterface() const
    {
        return TemporalUpscalerInterface;
    }
 
    inline void SetPrimarySpatialUpscalerInterface(ISpatialUpscaler* InSpatialUpscalerInterface)
    {
        check(InSpatialUpscalerInterface);
        checkf(PrimarySpatialUpscalerInterface == nullptr, TEXT("View family already had a primary spatial upscaler assigned."));
        PrimarySpatialUpscalerInterface = InSpatialUpscalerInterface;
    }
 
    inline const ISpatialUpscaler* GetPrimarySpatialUpscalerInterface() const
    {
        return PrimarySpatialUpscalerInterface;
    }
 
    inline void SetSecondarySpatialUpscalerInterface(ISpatialUpscaler* InSpatialUpscalerInterface)
    {
        check(InSpatialUpscalerInterface);
        checkf(SecondarySpatialUpscalerInterface == nullptr, TEXT("View family already had a secondary spatial upscaler assigned."));
        SecondarySpatialUpscalerInterface = InSpatialUpscalerInterface;
    }
 
    inline const ISpatialUpscaler* GetSecondarySpatialUpscalerInterface() const
    {
        return SecondarySpatialUpscalerInterface;
    }
 
    inline bool GetIsInFocus() const                { return bIsInFocus; }
    inline void SetIsInFocus(bool bInIsInFocus)     { bIsInFocus = bInIsInFocus; }
 
    void SetSceneRenderer(ISceneRenderer* NewSceneRenderer) { SceneRenderer = NewSceneRenderer; }
    ISceneRenderer* GetSceneRenderer() const { check(SceneRenderer); return SceneRenderer; }
 
private:
    ISceneRenderer* SceneRenderer;
 
    ISceneViewFamilyScreenPercentage* ScreenPercentageInterface;
 
    UE::Renderer::Private::ITemporalUpscaler* TemporalUpscalerInterface;
    ISpatialUpscaler* PrimarySpatialUpscalerInterface;
    ISpatialUpscaler* SecondarySpatialUpscalerInterface;
 
    TArray<TSharedRef<class ISceneViewFamilyExtentionData, ESPMode::ThreadSafe> > ViewExtentionDatas;
 
    bool bAllowTranslucencyAfterDOF = false;
 
    bool bAllowStandardTranslucencySeparated = false;
 
    bool bIsInFocus = true;
 
    friend class FSceneRenderer;
    friend class FViewFamilyInfo;
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
};
PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
class FSceneViewFamilyContext : public FSceneViewFamily
{
public:
    ENGINE_API FSceneViewFamilyContext(const ConstructionValues& CVS);
 
    ENGINE_API virtual ~FSceneViewFamilyContext();
};
 
struct FSetupViewUniformParametersInputs
{
    static FSetupViewUniformParametersInputs Create(const FSceneView& View)
    {
        return FSetupViewUniformParametersInputs
        {
              .EngineShowFlags = &View.Family->EngineShowFlags
            , .UnscaledViewRect = View.UnscaledViewRect
            , .Time = View.Family->Time
            , .CursorPosition = View.CursorPos
            , .GlobalClippingPlane = View.GlobalClippingPlane
            , .InvDeviceZToWorldZTransform = View.InvDeviceZToWorldZTransform
            , .DiffuseOverrideParameter = View.DiffuseOverrideParameter
            , .NormalOverrideParameter = View.NormalOverrideParameter
            , .SpecularOverrideParameter = View.SpecularOverrideParameter
            , .RoughnessOverrideParameter = View.RoughnessOverrideParameter
            , .AmbientOcclusionOverrideParameter = View.AmbientOcclusionOverrideParameter
            , .DebugViewShaderMode = View.Family->GetDebugViewShaderMode()
            , .FrameCounter = View.Family->FrameCounter
            , .FrameNumber = View.Family->FrameNumber
            , .FOV = View.FOV
            , .MotionBlurMax = View.FinalPostProcessSettings.MotionBlurMax
#if WITH_EDITOR
            , .bNullifyWorldSpacePosition = View.Family->bNullifyWorldSpacePosition
#endif
            , .bReverseCulling = View.bReverseCulling
            , .bCameraCut = View.bCameraCut
            , .bWorldIsPaused = View.Family->bWorldIsPaused
        };
    }
 
    const FEngineShowFlags* EngineShowFlags  = nullptr;
    FIntRect UnscaledViewRect;
    FGameTime Time;
    FIntPoint CursorPosition                 = FIntPoint::ZeroValue;
    FPlane GlobalClippingPlane               = FPlane(0, 0, 0, 0);
    FVector4f InvDeviceZToWorldZTransform    = FVector4f(0, 0, 0, 0);
    FVector4f DiffuseOverrideParameter       = FVector4f(0, 0, 0, 1);
    FVector4f NormalOverrideParameter        = FVector4f(0, 0, 0, 1);
    FVector4f SpecularOverrideParameter      = FVector4f(0, 0, 0, 1);
    FVector2f RoughnessOverrideParameter     = FVector2f(0, 1);
    FVector2f AmbientOcclusionOverrideParameter = FVector2f(0, 1);
    EDebugViewShaderMode DebugViewShaderMode = EDebugViewShaderMode::DVSM_None;
    uint64 FrameCounter                      = 0;
    uint32 FrameNumber                       = 0;
    float FOV                                = 0.0f;
    float MotionBlurMax                      = 0.0f;
    bool bNullifyWorldSpacePosition          = false;
    bool bReverseCulling                     = false;
    bool bCameraCut                          = false;
    bool bWorldIsPaused                      = false;
};
 
ENGINE_API void SetupCommonViewUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters,
    const FIntPoint& InBufferSize,
    int32 NumMSAASamples,
    const FIntRect& InEffectiveViewRect,
    const FViewMatrices& InViewMatrices,
    const FViewMatrices& InPrevViewMatrices,
    const FSetupViewUniformParametersInputs& Inputs);
 
ENGINE_API void SetupViewRectUniformBufferParameters(FViewUniformShaderParameters& ViewUniformShaderParameters,
    const FIntPoint& InBufferSize,
    const FIntRect& InEffectiveViewRect,
    const FViewMatrices& InViewMatrices,
    const FViewMatrices& InPrevViewMatrice,
    const FSetupViewUniformParametersInputs& Inputs);