SceneManagement.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SceneManagement.h: Scene manager definitions.
=============================================================================*/
 
#pragma once
 
// Includes the draw mesh macros
 
#include "CoreMinimal.h"
#include "Containers/ChunkedArray.h"
#include "Stats/Stats.h"
#include "Misc/Guid.h"
#include "Misc/MemStack.h"
#include "Misc/IQueuedWork.h"
#include "RHI.h"
#include "RenderResource.h"
#include "EngineDefines.h"
#include "HitProxies.h"
#include "SceneTypes.h"
#include "ConvexVolume.h"
#include "PrimitiveDrawingUtils.h"
#include "PrimitiveUniformShaderParameters.h"
#include "RendererInterface.h"
#include "BatchedElements.h"
#include "MeshBatch.h"
#include "MeshElementCollector.h"
#include "SceneUtils.h"
#include "LightmapUniformShaderParameters.h"
#include "DynamicBufferAllocator.h"
#include "Math/SHMath.h"
#include "GlobalRenderResources.h"
 
#if RHI_RAYTRACING
#include "RayTracingInstance.h"
#endif // RHI_RAYTRACING
 
class FCanvas;
class FGlobalDynamicIndexBuffer;
class FGlobalDynamicReadBuffer;
class FGlobalDynamicVertexBuffer;
class FLightMap;
class FLightmapResourceCluster;
class FLightSceneInfo;
class FLightSceneProxy;
class FPrimitiveSceneProxy;
class FScene;
class FSceneViewState;
class FShadowMap;
class FStaticLightingBuildContext;
class FStaticMeshRenderData;
class FTexture;
class UDecalComponent;
class ULightMapTexture2D;
class UMaterialInstanceDynamic;
class UMaterialInterface;
class UShadowMapTexture2D;
class UTexture2D;
class UTexture;
struct FDynamicMeshVertex;
class ULightMapVirtualTexture2D;
class FGPUScenePrimitiveCollector;
class FRayTracingGeometry;
struct FViewMatrices;
struct FEngineShowFlags;
class FViewport;
class FLandscapeRayTracingStateList;
struct FPrimitiveUniformShaderParametersBuilder;
struct FSceneViewStateSystemMemoryMirror;
 
namespace RayTracing
{
    using FGeometryGroupHandle = int32;
    using GeometryGroupHandle UE_DEPRECATED(5.6, "Use FGeometryGroupHandle instead.") = FGeometryGroupHandle;
}
 
namespace UE { namespace Color { class FColorSpace; } }
 
DECLARE_LOG_CATEGORY_EXTERN(LogBufferVisualization, Log, All);
DECLARE_LOG_CATEGORY_EXTERN(LogNaniteVisualization, Log, All);
DECLARE_LOG_CATEGORY_EXTERN(LogLumenVisualization, Log, All);
DECLARE_LOG_CATEGORY_EXTERN(LogVirtualShadowMapVisualization, Log, All);
DECLARE_LOG_CATEGORY_EXTERN(LogMultiView, Log, All);
 
// -----------------------------------------------------------------------------
 
 
struct FTemporalLODState
{
    FVector TemporalLODViewOrigin[2];
    float   TemporalLODTime[2];
    float   TemporalLODLag;
 
    FTemporalLODState()
        : TemporalLODLag(0.0f) // nothing else is used if this is zero
    {
 
    }
    float GetTemporalLODTransition(float LastRenderTime) const
    {
        if (TemporalLODLag == 0.0)
        {
            return 0.0f; // no fade
        }
        return FMath::Clamp((LastRenderTime - TemporalLODLag - TemporalLODTime[0]) / (TemporalLODTime[1] - TemporalLODTime[0]), 0.0f, 1.0f);
    }
 
    ENGINE_API void UpdateTemporalLODTransition(const FSceneView& View, float LastRenderTime);
};
 
enum ESequencerState
{
    ESS_None,
    ESS_Paused,
    ESS_Playing,
};
 
class FSceneViewStateInterface
{
public:
    FSceneViewStateInterface()
        :   bValidEyeAdaptationBuffer(0)
    {}
    
    virtual void Destroy() = 0;
 
public:
    virtual FSceneViewState* GetConcreteViewState () = 0;
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) = 0;
 
    virtual SIZE_T GetSizeBytes() const { return 0; }
 
    virtual void OnStartPostProcessing(FSceneView& CurrentView) = 0;
 
    virtual UMaterialInstanceDynamic* GetReusableMID(class UMaterialInterface* InSource) = 0;
 
    virtual void ClearMIDPool(FStringView MidParentRootPath = {}) = 0;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    virtual const FViewMatrices* GetFrozenViewMatrices() const = 0;
 
    virtual void ActivateFrozenViewMatrices(FSceneView& SceneView) = 0;
 
    virtual void RestoreUnfrozenViewMatrices(FSceneView& SceneView) = 0;
#endif
    // rest some state (e.g. FrameIndexMod8, TemporalAASampleIndex) to make the rendering [more] deterministic
    virtual void ResetViewState() = 0;
 
    virtual FTemporalLODState& GetTemporalLODState() = 0;
    virtual const FTemporalLODState& GetTemporalLODState() const = 0;
 
    virtual float GetTemporalLODTransition() const = 0;
 
    virtual uint32 GetViewKey() const = 0;
 
    /* Return the active volumetric cloud texture, can be null. */
    virtual FRDGTextureRef GetVolumetricCloudTexture(FRDGBuilder& GraphBuilder) = 0;
    virtual FVector2f GetVolumetricCloudTextureUVScale() const = 0;
    virtual FVector2f GetVolumetricCloudTextureUVMax() const = 0;
 
    //
    virtual uint32 GetCurrentTemporalAASampleIndex() const = 0;
 
    virtual uint32 GetDistanceFieldTemporalSampleIndex() const = 0;
 
    bool HasValidEyeAdaptationBuffer() const { return bValidEyeAdaptationBuffer; }
 
    virtual FRDGPooledBuffer* GetCurrentEyeAdaptationBuffer() const = 0;
 
    virtual float GetLastEyeAdaptationExposure() const = 0;
 
    virtual float GetLastAverageSceneLuminance() const = 0;
 
    virtual void SetExposureCompensationCurve(class UCurveFloat* NewCurve) {}
 
    virtual void SetSequencerState(ESequencerState InSequencerState) = 0;
 
    virtual ESequencerState GetSequencerState() = 0;
 
    virtual float GetPreExposure() const = 0;
 
    virtual uint32 GetOcclusionFrameCounter() const = 0;
 
#if RHI_RAYTRACING
    virtual uint32 GetPathTracingSampleIndex() const = 0;
 
    virtual uint32 GetPathTracingSampleCount() const = 0;
 
    virtual void SetLandscapeRayTracingStates(TPimplPtr<FLandscapeRayTracingStateList>&& InLandscapeRayTracingStates) = 0;
    virtual FLandscapeRayTracingStateList* GetLandscapeRayTracingStates() const = 0;
#endif
 
    virtual void AddLumenSceneData(FSceneInterface* InScene, float SurfaceCacheResolution = 1.0f) {}
    virtual void RemoveLumenSceneData(FSceneInterface* InScene) {}
    virtual bool HasLumenSceneData() const = 0;
    
    UE_DEPRECATED(5.3, "SetViewParent is deprecated")
    void SetViewParent(FSceneViewStateInterface*) {}
 
    UE_DEPRECATED(5.3, "GetViewParent is deprecated")
    FSceneViewStateInterface* GetViewParent() { return nullptr; }
 
    UE_DEPRECATED(5.3, "GetViewParent is deprecated")
    const FSceneViewStateInterface* GetViewParent() const { return nullptr; }
 
    UE_DEPRECATED(5.3, "HasViewParent is deprecated")
    bool HasViewParent() const { return false; }
 
    UE_DEPRECATED(5.3, "IsViewParent is deprecated")
    bool IsViewParent() const { return false; }
    
    ENGINE_API static TPimplPtr<FSceneViewStateSystemMemoryMirror> SystemMemoryMirrorAllocate();
 
    virtual void SystemMemoryMirrorBackup(FSceneViewStateSystemMemoryMirror* SystemMemoryMirror) = 0;
    virtual void SystemMemoryMirrorRestore(FSceneViewStateSystemMemoryMirror* SystemMemoryMirror) = 0;
 
protected:
    // Don't allow direct deletion of the view state, Destroy should be called instead.
    virtual ~FSceneViewStateInterface() {}
 
    uint8 bValidEyeAdaptationBuffer : 1;
 
private:
    friend class FScene;
};
 
class UE_DEPRECATED(5.7, "FFrozenSceneViewMatricesGuard is no longer used.") FFrozenSceneViewMatricesGuard
{
public:
    FFrozenSceneViewMatricesGuard(FSceneView& SV) {}
    ~FFrozenSceneViewMatricesGuard() {}
};
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FWorkingColorSpaceShaderParameters, ENGINE_API)
    SHADER_PARAMETER(FMatrix44f, ToXYZ)
    SHADER_PARAMETER(FMatrix44f, FromXYZ)
    SHADER_PARAMETER(FMatrix44f, ToAP1)
    SHADER_PARAMETER(FMatrix44f, FromAP1)
    SHADER_PARAMETER(FMatrix44f, ToAP0)
    SHADER_PARAMETER(FMatrix44f, FromAP0)
    SHADER_PARAMETER(uint32, bIsSRGB)
END_SHADER_PARAMETER_STRUCT()
 
class FDefaultWorkingColorSpaceUniformBuffer : public TUniformBuffer<FWorkingColorSpaceShaderParameters>
{
    typedef TUniformBuffer<FWorkingColorSpaceShaderParameters> Super;
public:
 
    void Update(FRHICommandListBase& RHICmdList, const UE::Color::FColorSpace& InColorSpace);
};
 
ENGINE_API extern TGlobalResource<FDefaultWorkingColorSpaceUniformBuffer> GDefaultWorkingColorSpaceUniformBuffer;
 
 
enum ELightInteractionType
{
    LIT_CachedIrrelevant,
    LIT_CachedLightMap,
    LIT_Dynamic,
    LIT_CachedSignedDistanceFieldShadowMap2D,
 
    LIT_MAX
};
 
class FLightInteraction
{
public:
 
    // Factory functions.
    static FLightInteraction Dynamic() { return FLightInteraction(LIT_Dynamic); }
    static FLightInteraction LightMap() { return FLightInteraction(LIT_CachedLightMap); }
    static FLightInteraction Irrelevant() { return FLightInteraction(LIT_CachedIrrelevant); }
    static FLightInteraction ShadowMap2D() { return FLightInteraction(LIT_CachedSignedDistanceFieldShadowMap2D); }
 
    // Accessors.
    ELightInteractionType GetType() const { return Type; }
 
    FLightInteraction(ELightInteractionType InType)
        : Type(InType)
    {}
 
private:
    ELightInteractionType Type;
};
 
 
 
 
 
inline constexpr int32 NUM_STORED_LIGHTMAP_COEF = 4;
 
inline constexpr int32 NUM_HQ_LIGHTMAP_COEF = 2;
 
inline constexpr int32 NUM_LQ_LIGHTMAP_COEF = 2;
 
inline constexpr int32 LQ_LIGHTMAP_COEF_INDEX = 2;
 
// @todo-mobile: Need to fix this!
#ifndef ALLOW_LQ_LIGHTMAPS
#define ALLOW_LQ_LIGHTMAPS (PLATFORM_DESKTOP || PLATFORM_IOS || PLATFORM_ANDROID)
#endif
 
#define ALLOW_HQ_LIGHTMAPS 1
 
#if !ALLOW_LQ_LIGHTMAPS && !ALLOW_HQ_LIGHTMAPS
#error At least one of ALLOW_LQ_LIGHTMAPS and ALLOW_HQ_LIGHTMAPS needs to be defined!
#endif
 
class FLightMapInteraction
{
public:
 
    // Factory functions.
    static FLightMapInteraction None()
    {
        FLightMapInteraction Result;
        Result.Type = LMIT_None;
        return Result;
    }
 
    static FLightMapInteraction GlobalVolume()
    {
        FLightMapInteraction Result;
        Result.Type = LMIT_GlobalVolume;
        return Result;
    }
 
    static FLightMapInteraction Texture(
        const class ULightMapTexture2D* const* InTextures,
        const ULightMapTexture2D* InSkyOcclusionTexture,
        const ULightMapTexture2D* InAOMaterialMaskTexture,
        const FVector4f* InCoefficientScales,
        const FVector4f* InCoefficientAdds,
        const FVector2D& InCoordinateScale,
        const FVector2D& InCoordinateBias,
        bool bAllowHighQualityLightMaps);
 
    static FLightMapInteraction InitVirtualTexture(
        const ULightMapVirtualTexture2D* VirtualTexture,
        const FVector4f* InCoefficientScales,
        const FVector4f* InCoefficientAdds,
        const FVector2D& InCoordinateScale,
        const FVector2D& InCoordinateBias,
        bool bAllowHighQualityLightMaps);
 
    FLightMapInteraction():
#if ALLOW_HQ_LIGHTMAPS
        HighQualityTexture(NULL),
        SkyOcclusionTexture(NULL),
        AOMaterialMaskTexture(NULL),
#endif
#if ALLOW_LQ_LIGHTMAPS
        LowQualityTexture(NULL),
#endif
#if ALLOW_HQ_LIGHTMAPS || ALLOW_LQ_LIGHTMAPS
        VirtualTexture(NULL),
#endif
        Type(LMIT_None)
    {}
 
    // Accessors.
    ELightMapInteractionType GetType() const { return Type; }
    
    const ULightMapTexture2D* GetTexture(bool bHighQuality) const
    {
        check(Type == LMIT_Texture);
#if ALLOW_LQ_LIGHTMAPS && ALLOW_HQ_LIGHTMAPS
        return bHighQuality ? HighQualityTexture : LowQualityTexture;
#elif ALLOW_HQ_LIGHTMAPS
        return HighQualityTexture;
#else
        return LowQualityTexture;
#endif
    }
 
    const ULightMapTexture2D* GetSkyOcclusionTexture() const
    {
        check(Type == LMIT_Texture);
#if ALLOW_HQ_LIGHTMAPS
        return SkyOcclusionTexture;
#else
        return NULL;
#endif
    }
 
    const ULightMapTexture2D* GetAOMaterialMaskTexture() const
    {
        check(Type == LMIT_Texture);
#if ALLOW_HQ_LIGHTMAPS
        return AOMaterialMaskTexture;
#else
        return NULL;
#endif
    }
 
    const ULightMapVirtualTexture2D* GetVirtualTexture() const
    {
        check(Type == LMIT_Texture);
#if ALLOW_HQ_LIGHTMAPS || ALLOW_LQ_LIGHTMAPS
        return VirtualTexture;
#else
        return NULL;
#endif
    }
 
    const FVector4f* GetScaleArray() const
    {
#if ALLOW_LQ_LIGHTMAPS && ALLOW_HQ_LIGHTMAPS
        return AllowsHighQualityLightmaps() ? HighQualityCoefficientScales : LowQualityCoefficientScales;
#elif ALLOW_HQ_LIGHTMAPS
        return HighQualityCoefficientScales;
#else
        return LowQualityCoefficientScales;
#endif
    }
 
    const FVector4f* GetAddArray() const
    {
#if ALLOW_LQ_LIGHTMAPS && ALLOW_HQ_LIGHTMAPS
        return AllowsHighQualityLightmaps() ? HighQualityCoefficientAdds : LowQualityCoefficientAdds;
#elif ALLOW_HQ_LIGHTMAPS
        return HighQualityCoefficientAdds;
#else
        return LowQualityCoefficientAdds;
#endif
    }
    
    const FVector2D& GetCoordinateScale() const
    {
        check(Type == LMIT_Texture);
        return CoordinateScale;
    }
    const FVector2D& GetCoordinateBias() const
    {
        check(Type == LMIT_Texture);
        return CoordinateBias;
    }
 
    uint32 GetNumLightmapCoefficients() const
    {
#if ALLOW_LQ_LIGHTMAPS && ALLOW_HQ_LIGHTMAPS
#if PLATFORM_DESKTOP && (!(UE_BUILD_SHIPPING || UE_BUILD_TEST) || WITH_EDITOR)      // This is to allow for dynamic switching between simple and directional light maps in the PC editor
        if( !AllowsHighQualityLightmaps() )
        {
            return NUM_LQ_LIGHTMAP_COEF;
        }
#endif
        return NumLightmapCoefficients;
#elif ALLOW_HQ_LIGHTMAPS
        return NUM_HQ_LIGHTMAP_COEF;
#else
        return NUM_LQ_LIGHTMAP_COEF;
#endif
    }
 
    inline bool AllowsHighQualityLightmaps() const
    {
#if ALLOW_LQ_LIGHTMAPS && ALLOW_HQ_LIGHTMAPS
        return bAllowHighQualityLightMaps;
#elif ALLOW_HQ_LIGHTMAPS
        return true;
#else
        return false;
#endif
    }
 
    void SetLightMapInteractionType(ELightMapInteractionType InType)
    {
        Type = InType;
    }
    void SetCoordinateScale(const FVector2D& InCoordinateScale)
    {
        CoordinateScale = InCoordinateScale;
    }
    void SetCoordinateBias(const FVector2D& InCoordinateBias)
    {
        CoordinateBias = InCoordinateBias;
    }
 
private:
 
#if ALLOW_HQ_LIGHTMAPS
    FVector4f HighQualityCoefficientScales[NUM_HQ_LIGHTMAP_COEF];
    FVector4f HighQualityCoefficientAdds[NUM_HQ_LIGHTMAP_COEF];
    const class ULightMapTexture2D* HighQualityTexture;
    const ULightMapTexture2D* SkyOcclusionTexture;
    const ULightMapTexture2D* AOMaterialMaskTexture;
#endif
 
#if ALLOW_LQ_LIGHTMAPS
    FVector4f LowQualityCoefficientScales[NUM_LQ_LIGHTMAP_COEF];
    FVector4f LowQualityCoefficientAdds[NUM_LQ_LIGHTMAP_COEF];
    const class ULightMapTexture2D* LowQualityTexture;
#endif
 
#if ALLOW_LQ_LIGHTMAPS && ALLOW_HQ_LIGHTMAPS
    bool bAllowHighQualityLightMaps;
    uint32 NumLightmapCoefficients;
#endif
 
#if ALLOW_HQ_LIGHTMAPS || ALLOW_LQ_LIGHTMAPS
    const ULightMapVirtualTexture2D* VirtualTexture;
#endif
 
    ELightMapInteractionType Type;
 
    FVector2D CoordinateScale;
    FVector2D CoordinateBias;
};
 
class FShadowMapInteraction
{
public:
 
    // Factory functions.
    static FShadowMapInteraction None()
    {
        FShadowMapInteraction Result;
        Result.Type = SMIT_None;
        return Result;
    }
 
    static FShadowMapInteraction GlobalVolume()
    {
        FShadowMapInteraction Result;
        Result.Type = SMIT_GlobalVolume;
        return Result;
    }
 
    static FShadowMapInteraction Texture(
        class UShadowMapTexture2D* InTexture,
        const FVector2D& InCoordinateScale,
        const FVector2D& InCoordinateBias,
        const bool* InChannelValid,
        const FVector4f& InInvUniformPenumbraSize)
    {
        FShadowMapInteraction Result;
        Result.Type = SMIT_Texture;
        Result.ShadowTexture = InTexture;
        Result.CoordinateScale = InCoordinateScale;
        Result.CoordinateBias = InCoordinateBias;
        Result.InvUniformPenumbraSize = InInvUniformPenumbraSize;
 
        for (int Channel = 0; Channel < 4; Channel++)
        {
            Result.bChannelValid[Channel] = InChannelValid[Channel];
        }
 
        return Result;
    }
 
    static FShadowMapInteraction InitVirtualTexture(
        class ULightMapVirtualTexture2D* InTexture,
        const FVector2D& InCoordinateScale,
        const FVector2D& InCoordinateBias,
        const bool* InChannelValid,
        const FVector4f& InInvUniformPenumbraSize)
    {
        FShadowMapInteraction Result;
        Result.Type = SMIT_Texture;
        Result.VirtualTexture = InTexture;
        Result.CoordinateScale = InCoordinateScale;
        Result.CoordinateBias = InCoordinateBias;
        Result.InvUniformPenumbraSize = InInvUniformPenumbraSize;
        for (int Channel = 0; Channel < 4; Channel++)
        {
            Result.bChannelValid[Channel] = InChannelValid[Channel];
        }
 
        return Result;
    }
 
    FShadowMapInteraction() :
        ShadowTexture(nullptr),
        VirtualTexture(nullptr),
        InvUniformPenumbraSize(FVector4f(0, 0, 0, 0)),
        Type(SMIT_None)
    {
        for (int Channel = 0; Channel < UE_ARRAY_COUNT(bChannelValid); Channel++)
        {
            bChannelValid[Channel] = false;
        }
    }
 
    // Accessors.
    EShadowMapInteractionType GetType() const { return Type; }
 
    UShadowMapTexture2D* GetTexture() const
    {
        checkSlow(Type == SMIT_Texture);
        return ShadowTexture;
    }
 
    const ULightMapVirtualTexture2D* GetVirtualTexture() const
    {
        checkSlow(Type == SMIT_Texture);
        return VirtualTexture;
    }
 
    const FVector2D& GetCoordinateScale() const
    {
        checkSlow(Type == SMIT_Texture);
        return CoordinateScale;
    }
 
    const FVector2D& GetCoordinateBias() const
    {
        checkSlow(Type == SMIT_Texture);
        return CoordinateBias;
    }
 
    bool GetChannelValid(int32 ChannelIndex) const
    {
        checkSlow(Type == SMIT_Texture);
        return bChannelValid[ChannelIndex];
    }
 
    inline FVector4f GetInvUniformPenumbraSize() const
    {
        return InvUniformPenumbraSize;
    }
 
private:
    UShadowMapTexture2D* ShadowTexture;
    const ULightMapVirtualTexture2D* VirtualTexture;
    FVector2D CoordinateScale;
    FVector2D CoordinateBias;
    bool bChannelValid[4];
    FVector4f InvUniformPenumbraSize;
    EShadowMapInteractionType Type;
};
 
class FLightMap;
class FShadowMap;
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FLightmapResourceClusterShaderParameters,ENGINE_API)
    SHADER_PARAMETER_TEXTURE(Texture2D, LightMapTexture)
    SHADER_PARAMETER_TEXTURE(Texture2D, SkyOcclusionTexture) 
    SHADER_PARAMETER_TEXTURE(Texture2D, AOMaterialMaskTexture) 
    SHADER_PARAMETER_TEXTURE(Texture2D, StaticShadowTexture)
    SHADER_PARAMETER_SRV(Texture2D<float4>, VTLightMapTexture) // VT
    SHADER_PARAMETER_SRV(Texture2D<float4>, VTLightMapTexture_1) // VT
    SHADER_PARAMETER_SRV(Texture2D<float4>, VTSkyOcclusionTexture) // VT
    SHADER_PARAMETER_SRV(Texture2D<float4>, VTAOMaterialMaskTexture) // VT
    SHADER_PARAMETER_SRV(Texture2D<float4>, VTStaticShadowTexture) // VT
    SHADER_PARAMETER_SAMPLER(SamplerState, LightMapSampler)
    SHADER_PARAMETER_SAMPLER(SamplerState, LightMapSampler_1)
    SHADER_PARAMETER_SAMPLER(SamplerState, SkyOcclusionSampler) 
    SHADER_PARAMETER_SAMPLER(SamplerState, AOMaterialMaskSampler) 
    SHADER_PARAMETER_SAMPLER(SamplerState, StaticShadowTextureSampler)
    SHADER_PARAMETER_TEXTURE(Texture2D<uint4>, LightmapVirtualTexturePageTable0) // VT
    SHADER_PARAMETER_TEXTURE(Texture2D<uint4>, LightmapVirtualTexturePageTable1) // VT
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
class FLightmapClusterResourceInput
{
public:
 
    FLightmapClusterResourceInput()
    {
        LightMapTextures[0] = nullptr;
        LightMapTextures[1] = nullptr;
        SkyOcclusionTexture = nullptr;
        AOMaterialMaskTexture = nullptr;
        LightMapVirtualTextures[0] = nullptr;
        LightMapVirtualTextures[1] = nullptr;
        ShadowMapTexture = nullptr;
    }
 
    const UTexture2D* LightMapTextures[2];
    const UTexture2D* SkyOcclusionTexture;
    const UTexture2D* AOMaterialMaskTexture;
    const ULightMapVirtualTexture2D* LightMapVirtualTextures[2];
    const UTexture2D* ShadowMapTexture;
 
    friend uint32 GetTypeHash(const FLightmapClusterResourceInput& Cluster)
    {
        // TODO - LightMapVirtualTexture needed here? What about Sky/AO textures?  Or is it enough to just check LightMapTexture[n]?
        return
            PointerHash(Cluster.LightMapTextures[0],
            PointerHash(Cluster.LightMapTextures[1],
            PointerHash(Cluster.LightMapVirtualTextures[0],
            PointerHash(Cluster.LightMapVirtualTextures[1],
            PointerHash(Cluster.ShadowMapTexture)))));
    }
 
    bool operator==(const FLightmapClusterResourceInput& Rhs) const
    {
        return LightMapTextures[0] == Rhs.LightMapTextures[0]
            && LightMapTextures[1] == Rhs.LightMapTextures[1]
            && SkyOcclusionTexture == Rhs.SkyOcclusionTexture
            && AOMaterialMaskTexture == Rhs.AOMaterialMaskTexture
            && LightMapVirtualTextures[0] == Rhs.LightMapVirtualTextures[0]
            && LightMapVirtualTextures[1] == Rhs.LightMapVirtualTextures[1]
            && ShadowMapTexture == Rhs.ShadowMapTexture;
    }
};
 
ENGINE_API void GetLightmapClusterResourceParameters(
    ERHIFeatureLevel::Type FeatureLevel, 
    const FLightmapClusterResourceInput& Input,
    const IAllocatedVirtualTexture* AllocatedVT,
    FLightmapResourceClusterShaderParameters& Parameters);
 
class FDefaultLightmapResourceClusterUniformBuffer : public TUniformBuffer< FLightmapResourceClusterShaderParameters >
{
    typedef TUniformBuffer< FLightmapResourceClusterShaderParameters > Super;
public:
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
};
 
ENGINE_API extern TGlobalResource< FDefaultLightmapResourceClusterUniformBuffer > GDefaultLightmapResourceClusterUniformBuffer;
 
class FLightCacheInterface
{
public:
    virtual ~FLightCacheInterface() {}
 
    // @param LightSceneProxy must not be 0
    virtual FLightInteraction GetInteraction(const class FLightSceneProxy* LightSceneProxy) const = 0;
 
    // helper function to implement GetInteraction(), call after checking for this: if(LightSceneProxy->HasStaticShadowing())
    // @param LightSceneProxy same as in GetInteraction(), must not be 0
    ENGINE_API ELightInteractionType GetStaticInteraction(const FLightSceneProxy* LightSceneProxy, const TArray<FGuid>& IrrelevantLights) const;
    
    ENGINE_API void CreatePrecomputedLightingUniformBuffer_RenderingThread(ERHIFeatureLevel::Type FeatureLevel);
 
    ENGINE_API bool GetVirtualTextureLightmapProducer(ERHIFeatureLevel::Type FeatureLevel, FVirtualTextureProducerHandle& OutProducerHandle);
 
    // @param InLightMap may be 0
    void SetLightMap(const FLightMap* InLightMap)
    {
        LightMap = InLightMap;
    }
 
    void SetResourceCluster(const FLightmapResourceCluster* InResourceCluster)
    {
        checkSlow(InResourceCluster);
        ResourceCluster = InResourceCluster;
    }
 
    // @return may be 0
    const FLightMap* GetLightMap() const
    {
        return LightMap;
    }
 
    // @param InShadowMap may be 0
    void SetShadowMap(const FShadowMap* InShadowMap)
    {
        ShadowMap = InShadowMap;
    }
 
    // @return may be 0
    const FShadowMap* GetShadowMap() const
    {
        return ShadowMap;
    }
 
    const FLightmapResourceCluster* GetResourceCluster() const
    {
        return ResourceCluster;
    }
 
    void SetGlobalVolumeLightmap(bool bInGlobalVolumeLightmap)
    {
        bGlobalVolumeLightmap = bInGlobalVolumeLightmap;
    }
 
    FRHIUniformBuffer* GetPrecomputedLightingBuffer() const
    {
        return PrecomputedLightingUniformBuffer;
    }
 
    void SetPrecomputedLightingBuffer(FRHIUniformBuffer* InPrecomputedLightingUniformBuffer)
    {
        PrecomputedLightingUniformBuffer = InPrecomputedLightingUniformBuffer;
    }
 
    ENGINE_API FLightMapInteraction GetLightMapInteraction(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    ENGINE_API FShadowMapInteraction GetShadowMapInteraction(ERHIFeatureLevel::Type InFeatureLevel) const;
 
public:
    // Load parameters from GPUScene when possible
    // Basically this is the same as VF_SUPPORTS_PRIMITIVE_SCENE_DATA on the vertex factory, but we can't deduce automatically
    // because we don't know about VF type until we see the actual mesh batch
    bool bCanUsePrecomputedLightingParametersFromGPUScene = false;
    
private:
 
    bool bGlobalVolumeLightmap = false;
 
    // The light-map used by the element. may be 0
    const FLightMap* LightMap = nullptr;
 
    // The shadowmap used by the element, may be 0
    const FShadowMap* ShadowMap = nullptr;
 
    const FLightmapResourceCluster* ResourceCluster = nullptr;
 
    FUniformBufferRHIRef PrecomputedLightingUniformBuffer = nullptr;
};
 
 
template<typename TPendingTextureType>
class FAsyncEncode : public IQueuedWork
{
private:
    TPendingTextureType* PendingTexture;
    FThreadSafeCounter& Counter;
    const FStaticLightingBuildContext* LightingContext;
    class ITextureCompressorModule* Compressor;
 
public:
 
    FAsyncEncode(TPendingTextureType* InPendingTexture, const FStaticLightingBuildContext* InLightingContext, FThreadSafeCounter& InCounter, ITextureCompressorModule* InCompressor) : PendingTexture(nullptr), Counter(InCounter), Compressor(InCompressor)
    {
        LightingContext = InLightingContext;
        PendingTexture = InPendingTexture;
    }
 
    void Abandon()
    {
        PendingTexture->StartEncoding(LightingContext, Compressor);
        Counter.Decrement();
    }
 
    void DoThreadedWork()
    {
        PendingTexture->StartEncoding(LightingContext, Compressor);
        Counter.Decrement();
    }
};
 
 
 
// Information about a single shadow cascade.
class FShadowCascadeSettings
{
public:
    // The following 3 floats represent the view space depth of the split planes for this cascade.
    // SplitNear <= FadePlane <= SplitFar
 
    // The distance from the camera to the near split plane, in world units (linear).
    float SplitNear;
 
    // The distance from the camera to the far split plane, in world units (linear).
    float SplitFar;
 
    // in world units (linear).
    float SplitNearFadeRegion;
 
    // in world units (linear).
    float SplitFarFadeRegion;
 
    // ??
    // The distance from the camera to the start of the fade region, in world units (linear).
    // The area between the fade plane and the far split plane is blended to smooth between cascades.
    float FadePlaneOffset;
 
    // The length of the fade region (SplitFar - FadePlaneOffset), in world units (linear).
    float FadePlaneLength;
 
    // The accurate bounds of the cascade used for primitive culling.
    FConvexVolume ShadowBoundsAccurate;
 
    FPlane NearFrustumPlane;
    FPlane FarFrustumPlane;
 
    bool bFarShadowCascade;
 
    int32 ShadowSplitIndex;
 
    float CascadeBiasDistribution;
 
    FShadowCascadeSettings()
        : SplitNear(0.0f)
        , SplitFar(WORLD_MAX)
        , SplitNearFadeRegion(0.0f)
        , SplitFarFadeRegion(0.0f)
        , FadePlaneOffset(SplitFar)
        , FadePlaneLength(SplitFar - FadePlaneOffset)
        , bFarShadowCascade(false)
        , ShadowSplitIndex(INDEX_NONE)
        , CascadeBiasDistribution(1)
    {
    }
};
 
class FProjectedShadowInitializer
{
public:
 
    FVector PreShadowTranslation;
 
    FMatrix WorldToLight;
    FVector2D Scales;
 
    FBoxSphereBounds SubjectBounds;
    FVector4 WAxis;
    float MinLightW;
    float MaxDistanceToCastInLightW;
 
    FProjectedShadowInitializer()
    {}
 
    bool IsCachedShadowValid(const FProjectedShadowInitializer& CachedShadow) const
    {
        return PreShadowTranslation == CachedShadow.PreShadowTranslation
            && WorldToLight == CachedShadow.WorldToLight
            && Scales == CachedShadow.Scales
            && SubjectBounds.Origin == CachedShadow.SubjectBounds.Origin
            && SubjectBounds.BoxExtent == CachedShadow.SubjectBounds.BoxExtent
            && SubjectBounds.SphereRadius == CachedShadow.SubjectBounds.SphereRadius
            && WAxis == CachedShadow.WAxis
            && MinLightW == CachedShadow.MinLightW
            && MaxDistanceToCastInLightW == CachedShadow.MaxDistanceToCastInLightW;
    }
};
 
class FPerObjectProjectedShadowInitializer : public FProjectedShadowInitializer
{
public:
 
};
 
class FWholeSceneProjectedShadowInitializer : public FProjectedShadowInitializer
{
public:
    FShadowCascadeSettings CascadeSettings;
    bool bOnePassPointLightShadow;
    bool bRayTracedDistanceField;
 
    FWholeSceneProjectedShadowInitializer() :
        bOnePassPointLightShadow(false),
        bRayTracedDistanceField(false)
    {}
 
    bool IsCachedShadowValid(const FWholeSceneProjectedShadowInitializer& CachedShadow) const
    {
        return FProjectedShadowInitializer::IsCachedShadowValid((const FProjectedShadowInitializer&)CachedShadow)
            && bOnePassPointLightShadow == CachedShadow.bOnePassPointLightShadow
            && bRayTracedDistanceField == CachedShadow.bRayTracedDistanceField;
    }
};
 
ENGINE_API bool DoesPlatformSupportDistanceFields(const FStaticShaderPlatform Platform);
 
ENGINE_API bool DoesPlatformSupportDistanceFieldShadowing(EShaderPlatform Platform);
 
ENGINE_API bool DoesPlatformSupportDistanceFieldAO(EShaderPlatform Platform);
 
ENGINE_API bool DoesProjectSupportDistanceFields();
 
ENGINE_API bool ShouldAllPrimitivesHaveDistanceField(EShaderPlatform ShaderPlatform);
 
ENGINE_API bool ShouldCompileDistanceFieldShaders(EShaderPlatform ShaderPlatform);
 
inline bool PrimitiveNeedsDistanceFieldSceneData(bool bTrackAllPrimitives,
    bool bCastsDynamicIndirectShadow,
    bool bAffectsDistanceFieldLighting,
    bool bIsDrawnInGame,
    bool bCastsHiddenShadow,
    bool bCastsDynamicShadow,
    bool bAffectsDynamicIndirectLighting,
    bool bAffectIndirectLightingWhileHidden)
{
    return (bTrackAllPrimitives || bCastsDynamicIndirectShadow)
        && bAffectsDistanceFieldLighting
        && (bIsDrawnInGame || bCastsHiddenShadow || bAffectIndirectLightingWhileHidden)
        && (bCastsDynamicShadow || bAffectsDynamicIndirectLighting);
}
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FMobileReflectionCaptureShaderParameters,ENGINE_API)
    SHADER_PARAMETER(FVector4f, Params) // x - inv average brightness, y - sky cubemap max mip, z - unused, w - brightness of reflection capture
    SHADER_PARAMETER_TEXTURE(TextureCube, Texture)
    SHADER_PARAMETER_SAMPLER(SamplerState, TextureSampler)
    SHADER_PARAMETER_TEXTURE(TextureCube, TextureBlend)         // Only used when this refelction is a sky light
    SHADER_PARAMETER_SAMPLER(SamplerState, TextureBlendSampler) // Idem
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
class FDefaultMobileReflectionCaptureUniformBuffer : public TUniformBuffer<FMobileReflectionCaptureShaderParameters>
{
    typedef TUniformBuffer<FMobileReflectionCaptureShaderParameters> Super;
public:
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
};
 
ENGINE_API extern TGlobalResource<FDefaultMobileReflectionCaptureUniformBuffer> GDefaultMobileReflectionCaptureUniformBuffer;
 
BEGIN_SHADER_PARAMETER_STRUCT(FLightShaderParameters, ENGINE_API)
    // Position of the light in the translated world space.
    SHADER_PARAMETER(FVector3f, TranslatedWorldPosition)
 
    // 1 / light's falloff radius from Position.
    SHADER_PARAMETER(float, InvRadius)
 
    // Color of the light.
    SHADER_PARAMETER(FVector3f, Color)
 
    // The exponent for the falloff of the light intensity from the distance.
    SHADER_PARAMETER(float, FalloffExponent)
 
    // Direction of the light if applies.
    SHADER_PARAMETER(FVector3f, Direction)
 
    // Factor to applies on the specular.
    SHADER_PARAMETER(float, SpecularScale)
 
    // Factor to applies on the diffuse.
    SHADER_PARAMETER(float, DiffuseScale)
 
    // One tangent of the light if applies.
    // Note: BiTangent is on purpose not stored for memory optimisation purposes.
    SHADER_PARAMETER(FVector3f, Tangent)
 
    // Radius of the point light.
    SHADER_PARAMETER(float, SourceRadius)
 
    // Dimensions of the light, for spot light, but also
    SHADER_PARAMETER(FVector2f, SpotAngles)
 
    // Radius of the soft source.
    SHADER_PARAMETER(float, SoftSourceRadius)
 
    // Other dimensions of the light source for rect light specifically.
    SHADER_PARAMETER(float, SourceLength)
 
    // Barn door angle for rect light
    SHADER_PARAMETER(float, RectLightBarnCosAngle)
 
    // Barn door length for rect light
    SHADER_PARAMETER(float, RectLightBarnLength)
 
    // Rect. light atlas transformation
    SHADER_PARAMETER(FVector2f, RectLightAtlasUVOffset)
    SHADER_PARAMETER(FVector2f, RectLightAtlasUVScale)
    SHADER_PARAMETER(float, RectLightAtlasMaxLevel)
 
    // IES texture slice index
    SHADER_PARAMETER(float, IESAtlasIndex)
 
    // Index of the light function in the atlas
    SHADER_PARAMETER(uint32, LightFunctionAtlasLightIndex)
 
    // Wether the light affect translucent material or not
    SHADER_PARAMETER(uint32, bAffectsTranslucentLighting)
 
END_SHADER_PARAMETER_STRUCT()
 
 
// Movable local light shadow parameters for mobile deferred
BEGIN_SHADER_PARAMETER_STRUCT(FMobileMovableLocalLightShadowParameters,ENGINE_API)
    SHADER_PARAMETER(FVector4f, SpotLightShadowSharpenAndFadeFractionAndReceiverDepthBiasAndSoftTransitionScale) // x ShadowSharpen, y ShadowFadFraction, z ReceiverDepthBias, w SoftTransitionScale
    SHADER_PARAMETER(FVector4f, SpotLightShadowmapMinMax)
    SHADER_PARAMETER(FMatrix44f, SpotLightShadowWorldToShadowMatrix)
    SHADER_PARAMETER(FVector4f, LocalLightShadowBufferSize)
    SHADER_PARAMETER_TEXTURE(Texture2D, LocalLightShadowTexture)
    SHADER_PARAMETER_SAMPLER(SamplerState, LocalLightShadowSampler)
    SHADER_PARAMETER(uint32, ShadowedBits)
END_GLOBAL_SHADER_PARAMETER_STRUCT()
 
struct FLightRenderParameters
{
    ENGINE_API void MakeShaderParameters(const FViewMatrices& ViewMatrices, float Exposure, FLightShaderParameters& OutShaderParameters) const;
    ENGINE_API float GetLightExposureScale(float Exposure) const;
    static ENGINE_API float GetLightExposureScale(float Exposure, float InverseExposureBlend);
 
    // Position of the light in world space.
    FVector WorldPosition;
 
    // 1 / light's falloff radius from Position.
    float InvRadius;
 
    // Color of the light.
    FLinearColor Color;
 
    // The exponent for the falloff of the light intensity from the distance.
    float FalloffExponent;
 
    // Direction of the light if applies.
    FVector3f Direction;
 
    // Factor to applies on the specular.
    float SpecularScale;
 
    // Factor to applies on the diffuse.
    float DiffuseScale;
 
    // One tangent of the light if applies.
    // Note: BiTangent is on purpose not stored for memory optimisation purposes.
    FVector3f Tangent;
 
    // Radius of the point light.
    float SourceRadius;
 
    // Dimensions of the light, for spot light, but also
    FVector2f SpotAngles;
 
    // Radius of the soft source.
    float SoftSourceRadius;
 
    // Other dimensions of the light source for rect light specifically.
    float SourceLength;
 
    // Barn door angle for rect light
    float RectLightBarnCosAngle;
 
    // Barn door length for rect light
    float RectLightBarnLength;
 
    // Rect. light atlas transformation
    FVector2f RectLightAtlasUVOffset;
    FVector2f RectLightAtlasUVScale;
    float RectLightAtlasMaxLevel;
 
    // IES atlas slice index
    float IESAtlasIndex;
 
    // Index of the light in the Light function atlas data
    uint32 LightFunctionAtlasLightIndex;
 
    // Wether this lights affect translucent materials or not
    uint32 bAffectsTranslucentLighting;
 
    float InverseExposureBlend;
 
    // Return Invalid rect light atlas MIP level
    static float GetRectLightAtlasInvalidMIPLevel() { return 32.f;  }
};
 
 
extern ENGINE_API void ComputeShadowCullingVolume(bool bReverseCulling, const FVector* CascadeFrustumVerts, const FVector& LightDirection, FConvexVolume& ConvexVolumeOut, FPlane& NearPlaneOut, FPlane& FarPlaneOut);
 
class FDynamicPrimitiveResource
{
public:
    UE_DEPRECATED(5.3, "InitPrimitiveResource now requires a command list.")
    ENGINE_API void InitPrimitiveResource();
 
    virtual void InitPrimitiveResource(FRHICommandListBase& RHICmdList) = 0;
    virtual void ReleasePrimitiveResource() = 0;
};
 
class FViewElementDrawer
{
public:
 
    virtual void Draw(const FSceneView* View,FPrimitiveDrawInterface* PDI) {}
};
 
class FStaticPrimitiveDrawInterface
{
public:
    virtual ~FStaticPrimitiveDrawInterface() { }
 
    virtual void SetHitProxy(HHitProxy* HitProxy) = 0;
 
    virtual void ReserveMemoryForMeshes(int32 MeshNum) = 0;
 
    virtual void DrawMesh(
        const FMeshBatch& Mesh,
        float ScreenSize
        ) = 0;
};
 
 
class FSimpleElementCollector : public FPrimitiveDrawInterface
{
public:
 
    ENGINE_API FSimpleElementCollector();
    ENGINE_API ~FSimpleElementCollector();
 
    ENGINE_API virtual void SetHitProxy(HHitProxy* HitProxy) override;
    virtual void AddReserveLines(uint8 DepthPriorityGroup, int32 NumLines, bool bDepthBiased = false, bool bThickLines = false) override {}
 
    ENGINE_API virtual void DrawSprite(
        const FVector& Position,
        float SizeX,
        float SizeY,
        const FTexture* Sprite,
        const FLinearColor& Color,
        uint8 DepthPriorityGroup,
        float U,
        float UL,
        float V,
        float VL,
        uint8 BlendMode = SE_BLEND_Masked,
        float OpacityMaskRevVal = .5f
    ) override;
 
    ENGINE_API virtual void DrawLine(
        const FVector& Start,
        const FVector& End,
        const FLinearColor& Color,
        uint8 DepthPriorityGroup,
        float Thickness = 0.0f,
        float DepthBias = 0.0f,
        bool bScreenSpace = false
        ) override;
 
    ENGINE_API virtual void DrawTranslucentLine(
        const FVector& Start,
        const FVector& End,
        const FLinearColor& Color,
        uint8 DepthPriorityGroup,
        float Thickness = 0.0f,
        float DepthBias = 0.0f,
        bool bScreenSpace = false
    ) override;
 
    ENGINE_API virtual void DrawPoint(
        const FVector& Position,
        const FLinearColor& Color,
        float PointSize,
        uint8 DepthPriorityGroup
        ) override;
 
    ENGINE_API virtual void RegisterDynamicResource(FDynamicPrimitiveResource* DynamicResource) override;
 
    // Not supported
    virtual bool IsHitTesting() override
    { 
        static bool bTriggered = false;
 
        if (!bTriggered)
        {
            bTriggered = true;
            ensureMsgf(false, TEXT("FSimpleElementCollector::DrawMesh called"));
        }
 
        return false; 
    }
 
    // Not supported
    virtual int32 DrawMesh(const FMeshBatch& Mesh) override
    {
        static bool bTriggered = false;
 
        if (!bTriggered)
        {
            bTriggered = true;
            ensureMsgf(false, TEXT("FSimpleElementCollector::DrawMesh called"));
        }
 
        return 0;
    }
 
    ENGINE_API void DrawBatchedElements(FRHICommandList& RHICmdList, const FMeshPassProcessorRenderState& DrawRenderState, const FSceneView& InView, EBlendModeFilter::Type Filter, ESceneDepthPriorityGroup DPG, uint32 NumInstances = 1) const;
 
    class FAllocationInfo
    {
    public:
        FAllocationInfo() = default;
 
    private:
        FBatchedElements::FAllocationInfo BatchedElements;
        FBatchedElements::FAllocationInfo TopBatchedElements;
        uint32 NumDynamicResources = 0;
 
        friend FSimpleElementCollector;
    };
 
    ENGINE_API void AddAllocationInfo(FAllocationInfo& AllocationInfo) const;
 
    ENGINE_API void Reserve(const FAllocationInfo& AllocationInfo);
 
    ENGINE_API void Append(FSimpleElementCollector& Other);
 
    bool HasAnyPrimitives() const
    {
        return BatchedElements.HasPrimsToDraw() || TopBatchedElements.HasPrimsToDraw();
    }
 
    bool HasPrimitives(ESceneDepthPriorityGroup DPG) const
    {
        if (DPG == SDPG_World)
        {
            return BatchedElements.HasPrimsToDraw();
        }
 
        return TopBatchedElements.HasPrimsToDraw();
    }
 
    FBatchedElements BatchedElements;
    FBatchedElements TopBatchedElements;
 
private:
    FHitProxyId HitProxyId;
 
    TArray<FDynamicPrimitiveResource*,SceneRenderingAllocator> DynamicResources;
 
    friend class FMeshElementCollector;
};
 
 
class FOneFrameResource
{
public:
 
    virtual ~FOneFrameResource() {}
};
 
struct FMeshBatchAndRelevance
{
    const FMeshBatch* Mesh;
 
    const FPrimitiveSceneProxy* PrimitiveSceneProxy;
 
private:
    uint32 bHasOpaqueMaterial : 1;
    uint32 bHasMaskedMaterial : 1;
    uint32 bRenderInMainPass : 1;
 
public:
    ENGINE_API FMeshBatchAndRelevance(const FMeshBatch& InMesh, const FPrimitiveSceneProxy* InPrimitiveSceneProxy, ERHIFeatureLevel::Type FeatureLevel);
 
    bool GetHasOpaqueMaterial() const { return bHasOpaqueMaterial; }
    bool GetHasMaskedMaterial() const { return bHasMaskedMaterial; }
    bool GetHasOpaqueOrMaskedMaterial() const { return bHasOpaqueMaterial || bHasMaskedMaterial; }
    bool GetRenderInMainPass() const { return bRenderInMainPass; }
};
 
#if RHI_RAYTRACING
 
struct FRayTracingDynamicGeometryUpdateParams
{
    TArray<FMeshBatch> MeshBatches;
 
    bool bUsingIndirectDraw = false;
    // When bUsingIndirectDraw == false, NumVertices == the actual number of vertices to process
    // When bUsingIndirectDraw == true, it is the maximum possible vertices that GPU can emit
    uint32 NumVertices = 0;
    uint32 VertexBufferSize = 0;
    uint32 NumTriangles = 0;
 
    FRayTracingGeometry* Geometry = nullptr;
    FRWBuffer* Buffer = nullptr;
 
    bool bApplyWorldPositionOffset = true;
 
    uint32 InstanceId = 0;
    FMatrix44f WorldToInstance = FMatrix44f::Identity;
 
    bool bAlphaMasked = false;
    FBufferRHIRef IndexBuffer = nullptr;
};
 
namespace RayTracing
{
    class FDynamicRayTracingInstancesContext;
}
 
class FRayTracingInstanceCollector : public FMeshElementCollector
{
public:
    // No MeshBatch should be allocated from an FRayTracingInstanceCollector.
    inline FMeshBatch& AllocateMesh() = delete;
    void RegisterOneFrameMaterialProxy(FMaterialRenderProxy* Proxy) = delete;
 
    TConstArrayView<const FSceneView*> GetViews() const { return Views; }
    uint32 GetVisibilityMap() const { return VisibilityMap; }
 
    UE_DEPRECATED(5.7, "Use Views array passed directly to GetDynamicRayTracingInstances.")
    const FSceneView* GetReferenceView() const { return Views[0]; }
 
    UE_DEPRECATED(5.7, "Please specify ViewIndex.")
    ENGINE_API void AddRayTracingInstance(FRayTracingInstance Instance);
 
    ENGINE_API void AddRayTracingInstance(int32 ViewIndex, FRayTracingInstance Instance);
 
    ENGINE_API void AddReferencedGeometryGroup(RayTracing::FGeometryGroupHandle GeometryGroup);
 
    ENGINE_API void AddReferencedGeometryGroupForDynamicUpdate(RayTracing::FGeometryGroupHandle GeometryGroup);
 
    UE_DEPRECATED(5.7, "Please specify ViewIndex.")
    ENGINE_API void AddRayTracingGeometryUpdate(FRayTracingDynamicGeometryUpdateParams Params);
 
    ENGINE_API void AddRayTracingGeometryUpdate(int32 ViewIndex, FRayTracingDynamicGeometryUpdateParams Params);
 
    UE_DEPRECATED(5.7, "Please specify ViewIndex.")
    void AddRDGPooledBuffer(FRDGPooledBuffer* PooledBuffer)
    {
        AddRDGPooledBuffer(0, PooledBuffer);
    }
 
    void AddRDGPooledBuffer(int32 ViewIndex, FRDGPooledBuffer* PooledBuffer)
    {
        RDGPooledBuffers[ViewIndex].Add(PooledBuffer);
    }
 
private:
 
    ENGINE_API FRayTracingInstanceCollector(
        ERHIFeatureLevel::Type InFeatureLevel,
        FSceneRenderingBulkObjectAllocator& InBulkAllocator,
        bool bInTrackReferencedGeometryGroups);
 
    ENGINE_API void AddViewMeshArrays(
        const FSceneView* InView,
        FGPUScenePrimitiveCollector* DynamicPrimitiveCollector
    );
 
    ENGINE_API void SetVisibilityMap(uint32 VisibilityMap);
 
    struct FRayTracingInstanceAndViewIndex
    {
        FRayTracingInstance Instance;
        int32 ViewIndex;
    };
 
    struct FRayTracingDynamicGeometryUpdateRequest
    {
        FRayTracingDynamicGeometryUpdateParams Params;
        int32 ViewIndex;
    };
 
    TArray<const FSceneView*> Views;
    TArray<FRayTracingInstanceAndViewIndex, SceneRenderingAllocator> RayTracingInstances;
    TArray<TSet<FRDGPooledBuffer*>, TInlineAllocator<2, SceneRenderingAllocator> > RDGPooledBuffers;
    TArray<FRayTracingDynamicGeometryUpdateRequest, SceneRenderingAllocator> RayTracingGeometriesToUpdate;
    TSet<RayTracing::FGeometryGroupHandle> ReferencedGeometryGroups;
    TSet<RayTracing::FGeometryGroupHandle> ReferencedGeometryGroupsForDynamicUpdate;
 
    const bool bTrackReferencedGeometryGroups;
 
    uint32 VisibilityMap;
 
    friend RayTracing::FDynamicRayTracingInstancesContext;
};
 
#endif
 
class FDynamicPrimitiveUniformBuffer : public FOneFrameResource
{
public:
    ENGINE_API FDynamicPrimitiveUniformBuffer();
    // FDynamicPrimitiveUniformBuffer is non-copyable
    FDynamicPrimitiveUniformBuffer(const FDynamicPrimitiveUniformBuffer&) = delete;
    ENGINE_API virtual ~FDynamicPrimitiveUniformBuffer();
 
    TUniformBuffer<FPrimitiveUniformShaderParameters> UniformBuffer;
 
    ENGINE_API void Set(FRHICommandListBase& RHICmdList, FPrimitiveUniformShaderParametersBuilder& Builder);
 
    ENGINE_API void Set(
        FRHICommandListBase& RHICmdList,
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FVector& ActorPositionWS, 
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        const FBoxSphereBounds& PreSkinnedLocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity,
        const FCustomPrimitiveData* CustomPrimitiveData);
 
    ENGINE_API void Set(
        FRHICommandListBase& RHICmdList,
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        const FBoxSphereBounds& PreSkinnedLocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity,
        const FCustomPrimitiveData* CustomPrimitiveData);
 
    ENGINE_API void Set(
        FRHICommandListBase& RHICmdList,
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        const FBoxSphereBounds& PreSkinnedLocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity);
 
    ENGINE_API void Set(
        FRHICommandListBase& RHICmdList,
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity);
 
    UE_DEPRECATED(5.4, "Set requires a command list")
    ENGINE_API void Set(
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FVector& ActorPositionWS, 
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        const FBoxSphereBounds& PreSkinnedLocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity,
        const FCustomPrimitiveData* CustomPrimitiveData);
 
    UE_DEPRECATED(5.4, "Set requires a command list")
    ENGINE_API void Set(
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        const FBoxSphereBounds& PreSkinnedLocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity,
        const FCustomPrimitiveData* CustomPrimitiveData);
 
    UE_DEPRECATED(5.4, "Set requires a command list")
    ENGINE_API void Set(
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        const FBoxSphereBounds& PreSkinnedLocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity);
 
    UE_DEPRECATED(5.4, "Set requires a command list")
    ENGINE_API void Set(
        const FMatrix& LocalToWorld,
        const FMatrix& PreviousLocalToWorld,
        const FBoxSphereBounds& WorldBounds,
        const FBoxSphereBounds& LocalBounds,
        bool bReceivesDecals,
        bool bHasPrecomputedVolumetricLightmap,
        bool bOutputVelocity);
};
 
extern ENGINE_API FVector CalcConeVert(float Angle1, float Angle2, float AzimuthAngle);
extern ENGINE_API void BuildConeVerts(float Angle1, float Angle2, float Scale, float XOffset, uint32 NumSides, TArray<FDynamicMeshVertex>& OutVerts, TArray<uint32>& OutIndices);
 
extern ENGINE_API void BuildCylinderVerts(const FVector& Base, const FVector& XAxis, const FVector& YAxis, const FVector& ZAxis, double Radius, double HalfHeight, uint32 Sides, TArray<FDynamicMeshVertex>& OutVerts, TArray<uint32>& OutIndices);
 
extern ENGINE_API void BuildTaperedCylinderVerts(const FVector& Base, const FVector& XAxis, const FVector& YAxis, const FVector& ZAxis, double BaseRadius, double TopRadius, double HalfHeight, uint32 Sides, TArray<FDynamicMeshVertex>& OutVerts, TArray<uint32>& OutIndices);
 
 
extern ENGINE_API FLinearColor GetSelectionColor(const FLinearColor& BaseColor,bool bSelected,bool bHovered, bool bUseOverlayIntensity = true);
extern ENGINE_API FLinearColor GetViewSelectionColor(const FLinearColor& BaseColor, const FSceneView& View, bool bSelected, bool bHovered, bool bUseOverlayIntensity, bool bIndividuallySelected);
 
extern ENGINE_API bool IsRichView(const FSceneViewFamily& ViewFamily);
 
extern ENGINE_API void ApplyViewModeOverrides(
    int32 ViewIndex,
    const FEngineShowFlags& EngineShowFlags,
    ERHIFeatureLevel::Type FeatureLevel,
    const FPrimitiveSceneProxy* PrimitiveSceneProxy,
    bool bSelected,
    struct FMeshBatch& Mesh,
    FMeshElementCollector& Collector
    );
 
extern ENGINE_API void DrawUVs(FViewport* InViewport, FCanvas* InCanvas, int32 InTextYPos, const int32 LODLevel, int32 UVChannel, TArray<FVector2D> SelectedEdgeTexCoords, class FStaticMeshRenderData* StaticMeshRenderData, class FSkeletalMeshLODRenderData* SkeletalMeshRenderData);
 
ENGINE_API const FSceneView& GetLODView(const FSceneView& InView);
 
float ENGINE_API ComputeBoundsScreenSize(const FVector4& Origin, const float SphereRadius, const FSceneView& View);
 
float ENGINE_API ComputeBoundsScreenSize(const FVector4& BoundsOrigin, const float SphereRadius, const FVector4& ViewOrigin, const FMatrix& ProjMatrix);
 
float ENGINE_API ComputeBoundsScreenRadiusSquared(const FVector4& Origin, const float SphereRadius, const FSceneView& View);
 
float ENGINE_API ComputeBoundsScreenRadiusSquared(const FVector4& BoundsOrigin, const float SphereRadius, const FVector4& ViewOrigin, const FMatrix& ProjMatrix);
 
float ENGINE_API ComputeBoundsDrawDistance(const float ScreenSize, const float SphereRadius, const FMatrix& ProjMatrix);
 
int8 ENGINE_API ComputeStaticMeshLOD(const FStaticMeshRenderData* RenderData, const FVector4& Origin, const float SphereRadius, const FSceneView& View, int32 MinLOD, float FactorScale = 1.0f);
 
int8 ENGINE_API ComputeTemporalStaticMeshLOD( const FStaticMeshRenderData* RenderData, const FVector4& Origin, const float SphereRadius, const FSceneView& View, int32 MinLOD, float FactorScale, int32 SampleIndex );
 
struct FLODMask
{
    // Assumes a max lod index of 127.
    // In fact MAX_STATIC_MESH_LODS is 8 so we could use 3 bits per LODIndex and fit in a uint8 here.
    uint16 LODIndex0 : 7;
    uint16 LODIndex1 : 7;
    uint16 bIsValid : 1;
    uint16 bIsRange : 1;
 
    FLODMask()
        : LODIndex0(0)
        , LODIndex1(0)
        , bIsValid(0)
        , bIsRange(0)
    {
    }
 
    bool IsValid() const
    {
        return bIsValid;
    }
    void SetLOD(uint32 LODIndex)
    {
        LODIndex0 = LODIndex1 = (uint8)LODIndex;
        bIsValid = 1;
        bIsRange = 0;
    }
    void SetLODSample(uint32 LODIndex, uint32 SampleIndex)
    {
        if (SampleIndex == 0)
        {
            LODIndex0 = (uint8)LODIndex;
        }
        else if (SampleIndex == 1)
        {
            LODIndex1 = (uint8)LODIndex;
        }
        bIsValid = 1;
        bIsRange = 0;
    }
    void SetLODRange(uint32 MinLODIndex, uint32 MaxLODIndex)
    {
        LODIndex0 = (uint8)MinLODIndex;
        LODIndex1 = (uint8)MaxLODIndex;
        bIsValid = 1;
        bIsRange = 1;
    }
    void ClampToFirstLOD(uint32 FirstLODIdx)
    {
        LODIndex0 = LODIndex0 > (uint8)FirstLODIdx ? LODIndex0 : (uint8)FirstLODIdx;
        LODIndex1 = LODIndex1 > (uint8)FirstLODIdx ? LODIndex1 : (uint8)FirstLODIdx;
    }
    bool IsDithered() const
    {
        return IsValid() && !bIsRange && LODIndex0 != LODIndex1;
    }
    bool IsLODRange() const
    {
        return IsValid() && bIsRange && LODIndex0 != LODIndex1;
    }
    bool ContainsLOD(int32 LODIndex) const
    {
        if (!IsValid())
        {
            return false;
        }
        if (bIsRange)
        {
            return (int32)LODIndex0 <= LODIndex && (int32)LODIndex1 >= LODIndex;
        }
        return (int32)LODIndex0 == LODIndex || (int32)LODIndex1 == LODIndex;
    }
    bool IsMinLODInRange(int32 LODIndex) const
    {
        return IsLODRange() && LODIndex == LODIndex0;
    }
    bool IsMaxLODInRange(int32 LODIndex) const
    {
        return IsLODRange() && LODIndex == LODIndex1;
    }
 
    //#dxr_todo UE-72106: We should probably add both LoDs but mask them based on their 
    //LodFade value within the BVH based on the LodFadeMask in the GBuffer
    int8 GetRayTracedLOD() const
    {
        return LODIndex1;
    }
};
 
FLODMask ENGINE_API ComputeLODForMeshes(const TArray<class FStaticMeshBatchRelevance>& StaticMeshRelevances, const FSceneView& View, const FVector4& Origin, float SphereRadius, int32 ForcedLODLevel, float& OutScreenRadiusSquared, int8 CurFirstLODIdx, float ScreenSizeScale = 1.0f, bool bDitheredLODTransition = true);
 
FLODMask ENGINE_API ComputeLODForMeshes(const TArray<class FStaticMeshBatchRelevance>& StaticMeshRelevances, const FSceneView& View, const FVector4& Origin, float SphereRadius, float InstanceSphereRadius, int32 ForcedLODLevel, float& OutScreenRadiusSquared, int8 CurFirstLODIdx, float ScreenSizeScale = 1.0f);
 
class FSharedSamplerState : public FRenderResource
{
public:
    FSamplerStateRHIRef SamplerStateRHI;
    bool bWrap;
 
    FSharedSamplerState(bool bInWrap) :
        bWrap(bInWrap)
    {}
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    virtual void ReleaseRHI() override
    {
        SamplerStateRHI.SafeRelease();
    }
};
 
extern ENGINE_API FSharedSamplerState* Wrap_WorldGroupSettings;
 
extern ENGINE_API FSharedSamplerState* Clamp_WorldGroupSettings;
 
extern ENGINE_API void InitializeSharedSamplerStates();
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_5
#include "MeshPaintVisualize.h"
#include "Rendering/SkyAtmosphereCommonData.h"
#include "SceneProxies/SkyAtmosphereSceneProxy.h"
#include "SceneProxies/SkyLightSceneProxy.h"
#include "SceneProxies/WindSourceSceneProxy.h"
#include "SceneProxies/DeferredDecalProxy.h"
#include "SceneProxies/ReflectionCaptureProxy.h"
#endif