SceneInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ContainersFwd.h"
#include "HAL/Platform.h"
#include "Math/MathFwd.h"
#include "Misc/EnumClassFlags.h"
#include "RenderGraphFwd.h"
#include "Engine/EngineTypes.h"
#include "PrimitiveComponentId.h"
#include "SceneViewOwner.h"
#include "ShowFlags.h"
#include "PathTracingOutputInvalidateReason.h"
 
class AWorldSettings;
struct FAnimBankDesc;
struct FAnimBankRecordHandle;
class FArchive;
class FFloat16Color;
class FInstanceCullingManager;
class FLightSceneProxy;
class FMaterial;
class FMaterialShaderMap;
class FName;
class FOutputDevice;
class FPrimitiveSceneInfo;
class FRDGBuilder;
class FRDGExternalAccessQueue;
class FRectLightSceneProxy;
class FRenderResource;
class FRenderTarget;
class FRHICommandListImmediate;
class FRHIUniformBuffer;
class FScene;
class FSceneRenderer;
class FSceneViewStateInterface;
class FSkyAtmosphereRenderSceneInfo;
class FSkyAtmosphereSceneProxy;
class FSkyLightSceneProxy;
class FSparseVolumeTextureViewerSceneProxy;
class FTexture;
class FVertexFactory;
class FViewInfo;
class FVolumetricCloudRenderSceneInfo;
class FVolumetricCloudSceneProxy;
class UDecalComponent;
struct FDeferredDecalUpdateParams;
class UInstancedStaticMeshComponent;
class ULightComponent;
class UPlanarReflectionComponent;
class UPrimitiveComponent;
class UReflectionCaptureComponent;
class URuntimeVirtualTextureComponent;
class USkyLightComponent;
class UStaticMeshComponent;
class UTextureCube;
enum class EPrimitiveDirtyState : uint8;
enum class EVTInvalidatePriority : uint8;
enum class EShadingPath;
enum EShaderPlatform : uint16;
namespace ERHIFeatureLevel { enum Type : int; }
struct FHairStrandsInstance;
struct FLightRenderParameters;
struct FPersistentPrimitiveIndex;
template<int32 MaxSHOrder> class TSHVectorRGB;
using FSHVectorRGB3 = TSHVectorRGB<3>;
struct FCustomPrimitiveData;
class FSceneViewFamily;
class FGPUSceneWriteDelegate;
 
struct FExponentialHeightFogDynamicState;
struct FPrimitiveSceneDesc;
struct FInstancedStaticMeshSceneDesc;
struct FLightSceneDesc;
 
enum EBasePassDrawListType
{
    EBasePass_Default=0,
    EBasePass_Masked,
    EBasePass_MAX
};
 
enum class EUpdateAllPrimitiveSceneInfosAsyncOps
{
    None = 0,
    
    // Cached mesh draw commands are cached asynchronously.
    CacheMeshDrawCommands = 1 << 0,
    
    // Light primitive interactions are created asynchronously.
    CreateLightPrimitiveInteractions = 1 << 1,
 
    // Material uniform expressions are cached asynchronously.
    CacheMaterialUniformExpressions = 1 << 2,
 
    All = CacheMeshDrawCommands | CreateLightPrimitiveInteractions | CacheMaterialUniformExpressions
};
ENUM_CLASS_FLAGS(EUpdateAllPrimitiveSceneInfosAsyncOps);
 
class FSceneInterface
{
public:
    ENGINE_API FSceneInterface(ERHIFeatureLevel::Type InFeatureLevel);
 
    // FSceneInterface interface
 
    virtual void AddPrimitive(UPrimitiveComponent* Primitive) = 0;
    virtual void RemovePrimitive(UPrimitiveComponent* Primitive) = 0;
    virtual void ReleasePrimitive(UPrimitiveComponent* Primitive) = 0;
 
    virtual void BatchAddPrimitives(TArrayView<UPrimitiveComponent*> InPrimitives) = 0;
    virtual void BatchRemovePrimitives(TArrayView<UPrimitiveComponent*> InPrimitives) = 0;
    virtual void BatchReleasePrimitives(TArrayView<UPrimitiveComponent*> InPrimitives) = 0;
 
    virtual void UpdateAllPrimitiveSceneInfos(FRDGBuilder& GraphBuilder, EUpdateAllPrimitiveSceneInfosAsyncOps AsyncOps = EUpdateAllPrimitiveSceneInfosAsyncOps::None) = 0;
    ENGINE_API void UpdateAllPrimitiveSceneInfos(FRHICommandListImmediate& RHICmdList);
 
    virtual void UpdatePrimitiveTransform(UPrimitiveComponent* Primitive) = 0;
    virtual void UpdatePrimitiveOcclusionBoundsSlack(UPrimitiveComponent* Primitive, float NewSlack) = 0;
    virtual void UpdatePrimitiveDrawDistance(UPrimitiveComponent* Primitive, float MinDrawDistance, float MaxDrawDistance, float VirtualTextureMaxDrawDistance) = 0;
    virtual void UpdateInstanceCullDistance(UPrimitiveComponent* Primitive, float StartCullDistance, float EndCullDistance) = 0;
    virtual void UpdatePrimitiveAttachment(UPrimitiveComponent* Primitive) = 0;
 
    virtual void UpdatePrimitiveInstances(UPrimitiveComponent* Primitive) = 0;  
 
    virtual void UpdateCustomPrimitiveData(UPrimitiveComponent* Primitive) = 0;
    virtual void UpdatePrimitiveDistanceFieldSceneData_GameThread(UPrimitiveComponent* Primitive) {}
 
    virtual FPrimitiveSceneInfo* GetPrimitiveSceneInfo(int32 PrimitiveIndex) const = 0;
 
    virtual FPrimitiveSceneInfo* GetPrimitiveSceneInfo(FPrimitiveComponentId PrimitiveId) const = 0;
    virtual FPrimitiveSceneInfo* GetPrimitiveSceneInfo(const FPersistentPrimitiveIndex& PersistentPrimitiveIndex) const = 0;
 
    virtual bool GetPreviousLocalToWorld(const FPrimitiveSceneInfo* PrimitiveSceneInfo, FMatrix& OutPreviousLocalToWorld) const { return false; }
    virtual void AddLight(ULightComponent* Light) = 0;
    virtual void RemoveLight(ULightComponent* Light) = 0;
    virtual void AddInvisibleLight(ULightComponent* Light) = 0;
    virtual void SetSkyLight(FSkyLightSceneProxy* Light) = 0;
    virtual void DisableSkyLight(FSkyLightSceneProxy* Light) = 0;
 
    virtual bool HasSkyLightRequiringLightingBuild() const = 0;
    virtual bool HasAtmosphereLightRequiringLightingBuild() const = 0;
 
    virtual void AddDecal(UDecalComponent* Component) = 0;
    virtual void RemoveDecal(UDecalComponent* Component) = 0;
    virtual void UpdateDecalTransform(UDecalComponent* Component) = 0;
    virtual void UpdateDecalFadeOutTime(UDecalComponent* Component) = 0;
    virtual void UpdateDecalFadeInTime(UDecalComponent* Component) = 0;
    virtual void BatchUpdateDecals(TArray<FDeferredDecalUpdateParams>&& UpdateParams) = 0;
 
    virtual void AddReflectionCapture(class UReflectionCaptureComponent* Component) {}
 
    virtual void RemoveReflectionCapture(class UReflectionCaptureComponent* Component) {}
 
    virtual void GetReflectionCaptureData(UReflectionCaptureComponent* Component, class FReflectionCaptureData& OutCaptureData) {}
 
    virtual void UpdateReflectionCaptureTransform(class UReflectionCaptureComponent* Component) {}
 
    virtual void AllocateReflectionCaptures(const TArray<UReflectionCaptureComponent*>& NewCaptures, const TCHAR* CaptureReason, bool bVerifyOnlyCapturing, bool bCapturingForMobile, bool bInsideTick) {}
    virtual void ReleaseReflectionCubemap(UReflectionCaptureComponent* CaptureComponent) {}
 
    virtual void ResetReflectionCaptures(bool bOnlyIfOOM) {}
 
    UE_DEPRECATED(5.1, "This method now accepts a bInsideTick parameter, which specifies whether it's called during the frame Tick.")
    inline void AllocateReflectionCaptures(const TArray<UReflectionCaptureComponent*>& NewCaptures, const TCHAR* CaptureReason, bool bVerifyOnlyCapturing, bool bCapturingForMobile)
    {
        AllocateReflectionCaptures(NewCaptures, CaptureReason, bVerifyOnlyCapturing, bCapturingForMobile, false);
    }
 
    virtual void UpdateSkyCaptureContents(const USkyLightComponent* CaptureComponent, bool bCaptureEmissiveOnly, UTextureCube* SourceCubemap, FTexture* OutProcessedTexture, float& OutAverageBrightness, FSHVectorRGB3& OutIrradianceEnvironmentMap, TArray<FFloat16Color>* OutRadianceMap, FLinearColor* SpecifiedCubemapColorScale) {}
 
    UE_DEPRECATED(5.2, "AllocateAndCaptureFrameSkyEnvMap now takes an FRDGExternalAccessQueue")
    virtual void AllocateAndCaptureFrameSkyEnvMap(FRDGBuilder& GraphBuilder, FSceneRenderer& SceneRenderer, FViewInfo& MainView, bool bShouldRenderSkyAtmosphere, bool bShouldRenderVolumetricCloud, FInstanceCullingManager& InstanceCullingManager) {}
 
    virtual void AllocateAndCaptureFrameSkyEnvMap(FRDGBuilder& GraphBuilder, FSceneRenderer& SceneRenderer, FViewInfo& MainView, bool bShouldRenderSkyAtmosphere, bool bShouldRenderVolumetricCloud, FInstanceCullingManager& InstanceCullingManager, FRDGExternalAccessQueue& ExternalAccessQueue) {}
    virtual void ValidateSkyLightRealTimeCapture(FRDGBuilder& GraphBuilder, const FViewInfo& View, FRDGTextureRef SceneColorTexture) {}
 
    UE_DEPRECATED(5.4, "This method has been refactored to be a proper visualization post process. It should have never been added on the FSceneInterface in the first place.")
    ENGINE_API virtual void ProcessAndRenderIlluminanceMeter(FRDGBuilder& GraphBuilder, TArrayView<FViewInfo> Views, FRDGTextureRef SceneColorTexture);
 
    virtual void AddPlanarReflection(class UPlanarReflectionComponent* Component) {}
    virtual void RemovePlanarReflection(class UPlanarReflectionComponent* Component) {}
    virtual void UpdatePlanarReflectionTransform(UPlanarReflectionComponent* Component) {}
 
    virtual void UpdateSceneCaptureContents(class USceneCaptureComponent2D* CaptureComponent, class ISceneRenderBuilder& SceneRenderBuilder) {}
    virtual void UpdateSceneCaptureContents(class USceneCaptureComponentCube* CaptureComponent, class ISceneRenderBuilder& SceneRenderBuilder) {}
    virtual void UpdatePlanarReflectionContents(class UPlanarReflectionComponent* CaptureComponent, class FSceneRenderer& MainSceneRenderer, class ISceneRenderBuilder& SceneRenderBuilder) {}
 
    virtual void AddPrecomputedLightVolume(const class FPrecomputedLightVolume* Volume) {}
    virtual void RemovePrecomputedLightVolume(const class FPrecomputedLightVolume* Volume) {}
 
    virtual bool HasPrecomputedVolumetricLightmap_RenderThread() const { return false; }
    virtual void AddPrecomputedVolumetricLightmap(const class FPrecomputedVolumetricLightmap* Volume, bool bIsPersistentLevel) {}
    virtual void RemovePrecomputedVolumetricLightmap(const class FPrecomputedVolumetricLightmap* Volume) {}
 
    virtual void AddRuntimeVirtualTexture(URuntimeVirtualTextureComponent* Component) {}
    virtual void RemoveRuntimeVirtualTexture(URuntimeVirtualTextureComponent* Component) {}
    /* Get the bitmasks describing which virtual texture objects will hide the associated primitives. */
    virtual void GetRuntimeVirtualTextureHidePrimitiveMask(uint8& bHideMaskEditor, uint8& bHideMaskGame) const {}
    
    virtual void InvalidateRuntimeVirtualTexture(URuntimeVirtualTextureComponent* Component, FBoxSphereBounds const& WorldBounds, EVTInvalidatePriority InvalidatePriority) {}
    UE_DEPRECATED(5.6, "Use the alternate prototype with the Priority param")
    virtual void InvalidateRuntimeVirtualTexture(URuntimeVirtualTextureComponent* Component, FBoxSphereBounds const& WorldBounds) {}
 
    virtual void RequestPreloadRuntimeVirtualTexture(class URuntimeVirtualTextureComponent* Component, FBoxSphereBounds const& WorldBounds, int32 Level) {}
 
    virtual void InvalidatePathTracedOutput(PathTracing::EInvalidateReason InvalidateReason = PathTracing::EInvalidateReason::Uncategorized) {}
 
    virtual void InvalidateLumenSurfaceCache_GameThread(UPrimitiveComponent* Component) {}
 
    virtual void GetPrimitiveUniformShaderParameters_RenderThread(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool& bHasPrecomputedVolumetricLightmap, FMatrix& PreviousLocalToWorld, int32& SingleCaptureIndex, bool& OutputVelocity) const {}
     
    virtual void UpdateLightTransform(ULightComponent* Light) = 0;
    virtual void UpdateLightColorAndBrightness(ULightComponent* Light) = 0;
 
    virtual void UpdateLightProxy(ULightComponent* Light, TFunction<void(FLightSceneProxy*)>&& Func) = 0;
 
    virtual void SetPrecomputedVisibility(const class FPrecomputedVisibilityHandler* PrecomputedVisibilityHandler) {}
 
    virtual void SetPrecomputedVolumeDistanceField(const class FPrecomputedVolumeDistanceField* PrecomputedVolumeDistanceField) {}
 
    virtual void UpdateStaticDrawLists() {}
 
    virtual void UpdateCachedRenderStates(class FPrimitiveSceneProxy* SceneProxy) {}
    
    virtual void UpdatePrimitiveSelectedState_RenderThread(const FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bIsSelected) {}
 
    virtual void UpdatePrimitiveVelocityState_RenderThread(FPrimitiveSceneInfo* PrimitiveSceneInfo, bool bIsBeingMoved) {}
 
    virtual void AddExponentialHeightFog(uint64 Id, const FExponentialHeightFogDynamicState& State) = 0;
    virtual void RemoveExponentialHeightFog(uint64 Id) = 0;
    virtual bool HasAnyExponentialHeightFog() const = 0;
 
    virtual void AddLocalFogVolume(class FLocalFogVolumeSceneProxy* FogProxy) = 0;
    virtual void RemoveLocalFogVolume(class FLocalFogVolumeSceneProxy* FogProxy) = 0;
    virtual bool HasAnyLocalFogVolume() const = 0;
 
    virtual void AddSkyAtmosphere(FSkyAtmosphereSceneProxy* SkyAtmosphereSceneProxy, bool bStaticLightingBuilt) = 0;
    virtual void RemoveSkyAtmosphere(FSkyAtmosphereSceneProxy* SkyAtmosphereSceneProxy) = 0;
    virtual FSkyAtmosphereRenderSceneInfo* GetSkyAtmosphereSceneInfo() = 0;
    virtual const FSkyAtmosphereRenderSceneInfo* GetSkyAtmosphereSceneInfo() const = 0;
 
    virtual void AddSparseVolumeTextureViewer(FSparseVolumeTextureViewerSceneProxy* SVTV) = 0;
    virtual void RemoveSparseVolumeTextureViewer(FSparseVolumeTextureViewerSceneProxy* SVTV) = 0;
 
    virtual TArray<FAnimBankRecordHandle> RegisterAnimBank(const TConstArrayView<FAnimBankDesc> Descs) = 0;
    virtual void UnregisterAnimBank(const TConstArrayView<FAnimBankRecordHandle> Handles) = 0;
 
    virtual void AddVolumetricCloud(FVolumetricCloudSceneProxy* VolumetricCloudSceneProxy) = 0;
    virtual void RemoveVolumetricCloud(FVolumetricCloudSceneProxy* VolumetricCloudSceneProxy) = 0;
 
    virtual void AddHairStrands(FHairStrandsInstance* Proxy) = 0;
 
    virtual void RemoveHairStrands(FHairStrandsInstance* Proxy) = 0;
 
    virtual void GetLightIESAtlasSlot(const FLightSceneProxy* Proxy, FLightRenderParameters* Out) = 0;
 
    virtual void GetRectLightAtlasSlot(const FRectLightSceneProxy* Proxy, FLightRenderParameters* Out) = 0;
 
    virtual void SetPhysicsField(class FPhysicsFieldSceneProxy* PhysicsFieldSceneProxy) = 0;
 
    virtual void ResetPhysicsField() = 0;
 
    virtual void ShowPhysicsField() = 0;
 
    virtual void UpdatePhysicsField(FRDGBuilder& GraphBuilder, FViewInfo& View) = 0;
 
    UE_DEPRECATED(5.0, "This method has been refactored to use an FRDGBuilder instead.")
    virtual void UpdatePhysicsField(FRHICommandListImmediate& RHICmdList, FViewInfo& View) {}
 
    virtual FVolumetricCloudRenderSceneInfo* GetVolumetricCloudSceneInfo() = 0;
    virtual const FVolumetricCloudRenderSceneInfo* GetVolumetricCloudSceneInfo() const = 0;
 
    virtual void AddWindSource(class UWindDirectionalSourceComponent* WindComponent) = 0;
    virtual void RemoveWindSource(class UWindDirectionalSourceComponent* WindComponent) = 0;
    virtual void UpdateWindSource(class UWindDirectionalSourceComponent* WindComponent) = 0;
    virtual const TArray<class FWindSourceSceneProxy*>& GetWindSources_RenderThread() const = 0;
 
    virtual void GetWindParameters(const FVector& Position, FVector& OutDirection, float& OutSpeed, float& OutMinGustAmt, float& OutMaxGustAmt) const = 0;
 
    virtual void GetWindParameters_GameThread(const FVector& Position, FVector& OutDirection, float& OutSpeed, float& OutMinGustAmt, float& OutMaxGustAmt) const = 0;
 
    virtual void GetDirectionalWindParameters(FVector& OutDirection, float& OutSpeed, float& OutMinGustAmt, float& OutMaxGustAmt) const = 0;
 
    virtual void AddSpeedTreeWind(class FVertexFactory* VertexFactory, const class UStaticMesh* StaticMesh) = 0;
 
    virtual void RemoveSpeedTreeWind_RenderThread(class FVertexFactory* VertexFactory, const class UStaticMesh* StaticMesh) = 0;
 
    virtual void UpdateSpeedTreeWind(double CurrentTime) = 0;
 
    virtual FRHIUniformBuffer* GetSpeedTreeUniformBuffer(const FVertexFactory* VertexFactory) const = 0;
 
    virtual void AddLumenSceneCard(class ULumenSceneCardComponent* LumenSceneCardComponent) {};
    virtual void UpdateLumenSceneCardTransform(class ULumenSceneCardComponent* LumenSceneCardComponent) {};
    virtual void RemoveLumenSceneCard(class ULumenSceneCardComponent* LumenSceneCardComponent) {};
 
    // FPrimtiveDesc version for primitive/light scene interactions
    virtual void AddPrimitive(FPrimitiveSceneDesc* Primitive) = 0;
    virtual void RemovePrimitive(FPrimitiveSceneDesc* Primitive) = 0;
    virtual void ReleasePrimitive(FPrimitiveSceneDesc* Primitive) = 0;
    virtual void UpdatePrimitiveTransform(FPrimitiveSceneDesc* Primitive) = 0;
 
    virtual void BatchAddPrimitives(TArrayView<FPrimitiveSceneDesc*> InPrimitives) = 0;
    virtual void BatchRemovePrimitives(TArrayView<FPrimitiveSceneDesc*> InPrimitives) = 0;
    virtual void BatchReleasePrimitives(TArrayView<FPrimitiveSceneDesc*> InPrimitives) = 0;
 
    virtual void BatchRemovePrimitives(TArray<FPrimitiveSceneProxy*>&& InPrimitives) = 0;
    
    virtual void UpdateCustomPrimitiveData(FPrimitiveSceneDesc* Primitive, const FCustomPrimitiveData& CustomPrimitiveData) = 0;
 
    virtual void UpdatePrimitiveInstances(FPrimitiveSceneDesc* Primitive) = 0;  
 
    UE_EXPERIMENTAL(5.6, "Experimental API, scene writing delegate may be internalized in the future.")
    virtual void UpdatePrimitiveInstancesFromCompute(FPrimitiveSceneDesc* Primitive, FGPUSceneWriteDelegate&& DataWriterGPU) = 0;
 
    UE_DEPRECATED(5.6, "StaticMeshBounds is no longer a parameter of this interface, please update FPrimitiveSceneDesc version.")
    virtual void UpdatePrimitiveInstances(FInstancedStaticMeshSceneDesc* Primitive) = 0;    
 
    virtual void UpdatePrimitivesDrawnInGame_RenderThread(TArrayView<FPrimitiveSceneProxy*> PrimitiveSceneProxies, bool bDrawnInGame) = 0;
 
    virtual void Release() = 0;
    virtual void GetRelevantLights( UPrimitiveComponent* Primitive, TArray<const ULightComponent*>* RelevantLights ) const = 0;
    virtual bool RequiresHitProxies() const = 0;
    virtual class UWorld* GetWorld() const = 0;
    
    virtual FScene* GetRenderScene() = 0;
    virtual const FScene* GetRenderScene() const = 0;
 
    virtual void OnWorldCleanup()
    {
    }
    virtual void UpdateSceneSettings(AWorldSettings* WorldSettings) {}
 
    class IPrimitiveTransformUpdater
    {
    public:
        virtual ~IPrimitiveTransformUpdater() = default;
 
        ENGINE_API static IPrimitiveTransformUpdater* SetInstanceTLS(IPrimitiveTransformUpdater* Instance);
        ENGINE_API static IPrimitiveTransformUpdater* GetInstanceTLS();
    };
 
    class FPrimitiveTransformUpdateScope
    {
    public:
        explicit FPrimitiveTransformUpdateScope(IPrimitiveTransformUpdater* Updater)
        {
            PreviousUpdater = IPrimitiveTransformUpdater::SetInstanceTLS(Updater);
        }
 
        ~FPrimitiveTransformUpdateScope()
        {
            IPrimitiveTransformUpdater::SetInstanceTLS(PreviousUpdater);
        }
 
    private:
        IPrimitiveTransformUpdater* PreviousUpdater;
    };
 
    virtual IPrimitiveTransformUpdater* CreatePrimitiveTransformUpdater(int32 MaxPrimitives) { return nullptr; }
    virtual void UpdatePrimitiveTransforms(IPrimitiveTransformUpdater* Updater) {}
 
    UE_DEPRECATED(5.6, "Use IPrimitiveTransformUpdater instead")
    virtual void StartUpdatePrimitiveTransform(int32 NumPrimitives) {};
    
    UE_DEPRECATED(5.6, "Use IPrimitiveTransformUpdater instead")
    virtual void FinishUpdatePrimitiveTransform() {};
 
    virtual class FGPUSkinCache* GetGPUSkinCache()
    {
        return nullptr;
    }
 
    virtual class FSkeletalMeshUpdater* GetSkeletalMeshUpdater()
    {
        return nullptr;
    }
 
    virtual void GetComputeTaskWorkers(TArray<class IComputeTaskWorker*>& OutWorkers) const {}
 
    virtual void SetFXSystem( class FFXSystemInterface* InFXSystem ) = 0;
 
    virtual class FFXSystemInterface* GetFXSystem() = 0;
 
    virtual void DumpUnbuiltLightInteractions( FOutputDevice& Ar ) const { }
 
    virtual void UpdateParameterCollections(const TArray<class FMaterialParameterCollectionInstanceResource*>& InParameterCollections) {}
 
    virtual void Export( FArchive& Ar ) const
    {}
 
    virtual void ApplyWorldOffset(const FVector& InOffset) {}
 
    virtual void OnLevelAddedToWorld(const FName& InLevelName, UWorld* InWorld, bool bIsLightingScenario) {}
    virtual void OnLevelRemovedFromWorld(const FName& InLevelName, UWorld* InWorld, bool bIsLightingScenario) {}
 
    virtual bool HasAnyLights() const = 0;
 
    virtual bool IsEditorScene() const { return false; }
 
    virtual void UpdateEarlyZPassMode() {}
 
    ERHIFeatureLevel::Type GetFeatureLevel() const { return FeatureLevel; }
 
    ENGINE_API EShaderPlatform GetShaderPlatform() const;
 
    static ENGINE_API EShadingPath GetShadingPath(ERHIFeatureLevel::Type InFeatureLevel);
 
    EShadingPath GetShadingPath() const
    {
        return GetShadingPath(GetFeatureLevel());
    }
 
#if WITH_EDITOR
    virtual bool InitializePixelInspector(FRenderTarget* BufferFinalColor, FRenderTarget* BufferSceneColor, FRenderTarget* BufferDepth, FRenderTarget* BufferHDR, FRenderTarget* BufferA, FRenderTarget* BufferBCDEF, int32 BufferIndex)
    {
        return false;
    }
 
    virtual bool AddPixelInspectorRequest(class FPixelInspectorRequest *PixelInspectorRequest)
    {
        return false;
    }
#endif //WITH_EDITOR
 
    virtual TConstArrayView<FPrimitiveSceneProxy*> GetPrimitiveSceneProxies() const = 0;
 
    virtual TConstArrayView<FPrimitiveComponentId> GetScenePrimitiveComponentIds() const = 0;
 
    virtual void StartFrame() {}
    virtual void EndFrame(FRHICommandListImmediate& RHICmdList) {}
    virtual uint32 GetFrameNumber() const { return 0; }
    virtual void IncrementFrameNumber() {}
 
    virtual void UpdateCachedRayTracingState(class FPrimitiveSceneProxy* SceneProxy) {}
    
    UE_DEPRECATED(5.6, "FRayTracingDynamicGeometryCollection has been removed - all raytracing dynamic geometries are collected via the FRayTracingInstanceCollector during GetDynamicRayTracingInstances on the proxy.")
    virtual class FRayTracingDynamicGeometryCollection* GetRayTracingDynamicGeometryCollection() { return nullptr; }
    UE_DEPRECATED(5.6, "FRayTracingSkinnedGeometryUpdateQueue has been removed - all raytracing dynamic geometries are collected via the FRayTracingInstanceCollector during GetDynamicRayTracingInstances on the proxy.")
    virtual class FRayTracingSkinnedGeometryUpdateQueue* GetRayTracingSkinnedGeometryUpdateQueue() { return nullptr; }
 
    virtual bool RequestGPUSceneUpdate(FPrimitiveSceneInfo& PrimitiveSceneInfo, EPrimitiveDirtyState PrimitiveDirtyState) { return false; }
    virtual bool RequestUniformBufferUpdate(FPrimitiveSceneInfo& PrimitiveSceneInfo) { return false; }
 
    virtual void RefreshNaniteRasterBins(FPrimitiveSceneInfo& PrimitiveSceneInfo) {}
    virtual void ReloadNaniteFixedFunctionBins() {}
 
    struct FCustomRenderPassRendererInput
    {
        FCustomRenderPassRendererInput()
            : EngineShowFlags(ESFIM_Game)
        {
            EngineShowFlags.DisableFeaturesForUnlit();
        }
 
        FVector ViewLocation;
        FMatrix ViewRotationMatrix;
        FMatrix ProjectionMatrix;
        TSet<FPrimitiveComponentId> HiddenPrimitives;
        TOptional<TSet<FPrimitiveComponentId>> ShowOnlyPrimitives;
        FEngineShowFlags EngineShowFlags;
        FSceneViewOwner ViewActor;
        class FSceneViewStateInterface* ViewStateInterface = nullptr;
        int32 PostVolumeUserFlags = 0;                      // UserFlags from Post Process Volume, used if bOverridesPostVolumeUserFlags set, allows per-view material overrides
        bool bIsSceneCapture = false;
        bool bUseMainViewFamilyShowFlags = false;           // Custom render pass should use flags from main view family, rather than ones in this structure
        bool bOverridesPostVolumeUserFlags = false;         // Use PostVolumeUserFlags, instead of flags from main view family
 
        class FCustomRenderPassBase* CustomRenderPass = nullptr;
    };
 
    virtual bool AddCustomRenderPass(const FSceneViewFamily* ViewFamily, const FCustomRenderPassRendererInput& CustomRenderPassInput) { return false; }
 
protected:
    virtual ~FSceneInterface() {}
 
    ERHIFeatureLevel::Type FeatureLevel;
 
    friend class FSceneViewStateReference;
};