PrimitiveSceneProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    PrimitiveSceneProxy.h: Primitive scene proxy definition.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "RendererInterface.h"
#include "SceneViewOwner.h"
#include "Stats/Stats.h"
#include "Misc/MemStack.h"
#include "PrimitiveViewRelevance.h"
#include "SceneTypes.h"
#include "Engine/Scene.h"
#include "UniformBuffer.h"
#include "PrimitiveUniformShaderParameters.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "InstanceUniformShaderParameters.h"
#endif
#include "DrawDebugHelpers.h"
#include "Math/CapsuleShape.h"
#include "SceneDefinitions.h"
#include "MeshDrawCommandStatsDefines.h"
#include "InstanceDataTypes.h"
#include "PSOPrecacheFwd.h"
 
class FLightSceneInfo;
class FLightSceneProxy;
class FPrimitiveDrawInterface;
class FPrimitiveSceneInfo;
class FStaticPrimitiveDrawInterface;
class FSkinningSceneExtensionProxy;
class HHitProxy;
class UPrimitiveComponent;
class URuntimeVirtualTexture;
class UTexture2D;
enum class ERuntimeVirtualTextureMaterialType : uint8;
struct FMeshBatch;
class FColorVertexBuffer;
class FRayTracingGeometry;
class FVertexFactory;
class IHeterogeneousVolumeInterface;
struct FPrimitiveUniformShaderParametersBuilder;
struct FPrimitiveSceneProxyDesc;
class IPrimitiveComponent;
struct FEngineShowFlags;
struct FRenderTransform;
struct FRenderBounds;
struct FRenderCurveResourceData;
 
namespace Nanite
{
    using CoarseMeshStreamingHandle = int16;
}
 
#if RHI_RAYTRACING
namespace RayTracing
{
    using FGeometryGroupHandle = int32;
    using GeometryGroupHandle UE_DEPRECATED(5.6, "Use FGeometryGroupHandle instead.") = FGeometryGroupHandle;
}
#endif
 
struct FDesiredLODLevel
{
    enum class EType : uint8
    {
        // LOD is the first in a set of LODs that can be selected from.
        First,
 
        // LOD is fixed to a pre-selected level.
        Fixed
    };
 
    static FDesiredLODLevel CreateFixed(uint8 LOD)
    {
        return FDesiredLODLevel(LOD, EType::Fixed);
    }
    
    static FDesiredLODLevel CreateFirst(uint8 LOD)
    {
        return FDesiredLODLevel(LOD, EType::First);
    }
 
    FDesiredLODLevel(uint8 InLOD, EType InType)
        : LOD(InLOD)
        , Type(InType)
    {}
 
    bool IsFixed() const { return Type == EType::Fixed; }
    bool IsFirst() const { return Type == EType::First; }
 
    uint8 LOD = 0;
    EType Type = EType::First;
};
 
union FSimpleLightId
{
    struct 
    {
        int32 LocalId;
        int32 SourcePrimitiveId;
    };
    uint64 Packed;
 
    FSimpleLightId()
        : LocalId(INDEX_NONE)
        , SourcePrimitiveId(INDEX_NONE)
    {}
 
    FSimpleLightId(int32 InLocalId, int32 InSourcePrimitiveId)
        : LocalId(InLocalId)
        , SourcePrimitiveId(InSourcePrimitiveId)
    {}
 
    bool operator==(FSimpleLightId Other) const
    {
        return Other.Packed == Packed;
    }
 
    bool IsValid() const
    {
        return LocalId != INDEX_NONE && SourcePrimitiveId != INDEX_NONE;
    }
};
 
inline uint32 GetTypeHash(FSimpleLightId In)
{
    return GetTypeHash(In.Packed);
}
 
class FSimpleLightEntry
{
public:
    FVector3f Color;
    float Radius;
    float Exponent;
    float InverseExposureBlend = 0.0f;
    float VolumetricScatteringIntensity;
    float SpecularScale = 1.0f;
    float DiffuseScale = 1.0f;
    bool bAffectTranslucency;
    bool bAllowMegaLights = false;
    bool bMegaLightsCastShadows = false;
    FSimpleLightId LightId;
};
 
class FSimpleLightPerViewEntry
{
public:
    FVector Position;
};
 
class FSimpleLightInstacePerViewIndexData
{
public:
    uint32 PerViewIndex : 31;
    uint32 bHasPerViewData;
};
 
class FSimpleLightArray
{
public:
    TArray<FSimpleLightEntry, SceneRenderingAllocator> InstanceData;
    TArray<FSimpleLightPerViewEntry, SceneRenderingAllocator> PerViewData;
    TArray<FSimpleLightInstacePerViewIndexData, SceneRenderingAllocator> InstancePerViewDataIndices;
 
public:
 
    inline const FSimpleLightPerViewEntry& GetViewDependentData(int32 LightIndex, int32 ViewIndex, int32 NumViews) const
    {
        // If InstanceData has an equal number of elements to PerViewData then all views share the same PerViewData.
        if (InstanceData.Num() == PerViewData.Num())
        {
            check(InstancePerViewDataIndices.Num() == 0);
            return PerViewData[LightIndex];
        }
        else 
        {
            check(InstancePerViewDataIndices.Num() == InstanceData.Num());
 
            // Calculate per-view index.
            FSimpleLightInstacePerViewIndexData PerViewIndex = InstancePerViewDataIndices[LightIndex];
            const int32 PerViewDataIndex = PerViewIndex.PerViewIndex + ( PerViewIndex.bHasPerViewData ? ViewIndex : 0 );
            return PerViewData[PerViewDataIndex];
        }
    }
};
 
class FHeightfieldComponentDescription
{
public:
    FVector4f HeightfieldScaleBias = FVector4f(ForceInit);
    FVector4f MinMaxUV = FVector4f(ForceInit);
    FMatrix LocalToWorld = FMatrix::Identity;
    FVector2D LightingAtlasLocation = FVector2D(ForceInit);
    FIntRect HeightfieldRect; // Default initialized
 
    uint32 GPUSceneInstanceIndex = 0;
    int32 NumSubsections = 0;
    FVector4 SubsectionScaleAndBias = FVector4(ForceInit);
    int32 VisibilityChannel;
 
    FHeightfieldComponentDescription(const FMatrix& InLocalToWorld, uint32 InGPUSceneInstanceIndex) :
        LocalToWorld(InLocalToWorld),
        GPUSceneInstanceIndex(InGPUSceneInstanceIndex),
        VisibilityChannel(-1)
    {}
};
 
ENGINE_API extern bool ShouldOptimizedWPOAffectNonNaniteShaderSelection();
extern bool IsAllowingApproximateOcclusionQueries();
extern bool CacheShadowDepthsFromPrimitivesUsingWPO();
 
enum class ERayTracingPrimitiveFlags : uint8
{
    None = 0,
 
    // Visibility flags:
 
    // This type of geometry is not supported in ray tracing and all proxies will be excluded
    // If a proxy decides to return UnsupportedProxyType it must be consistent across all proxies of this type
    // This value is used for primitives that return false from FPrimitiveSceneProxy::IsRayTracingRelevant().
    UnsupportedProxyType = 1 << 0,
 
    // This scene proxy will be excluded, because it decides to be invisible in ray tracing (probably due to other flags)
    // Excluded proxies will skip visibility checks
    Exclude = 1 << 1,
 
    // Similar to Exclude however scene proxy will still go through culling and run relevant logic when it is deemed visible
    Skip = 1 << 2,
 
    // Caching flags:
 
    // Fully dynamic (the ray tracing representation of this scene proxy will be polled every frame)
    // Ray tracing mesh commands generated from this proxy's materials can be cached
    // (not compatible with CacheInstances or ComputeLOD)
    Dynamic = 1 << 3,
    // Instances from this proxy can be cached
    // (not compatible with Dynamic or ComputeLOD)
    CacheInstances = 1 << 4,
 
    // Misc flags:
 
    // Static meshes with multiple LODs will want to select a LOD index based on screen size
    // (not compatible with Dynamic or CacheInstances)
    ComputeLOD = 1 << 5, 
 
    // Primitive is masked as a far field object
    FarField = 1 << 6,
 
    // Raytracing data is streamable (TODO: support in dynamic path)
    Streaming = 1 << 7,
};
ENUM_CLASS_FLAGS(ERayTracingPrimitiveFlags);
 
enum class ERayTracingProxyType : uint8
{
    None                                = 0,
    StaticMesh                          = 1 << 0,
    HierarchicalInstancedStaticMesh     = 1 << 1,
    LandscapeGrass                      = 1 << 2,
    NaniteProxy                         = 1 << 3,
    SkeletalMesh                        = 1 << 4,
    InstanceSkeletalMesh                = 1 << 5,
 
    All                                 = StaticMesh | HierarchicalInstancedStaticMesh | LandscapeGrass | NaniteProxy | SkeletalMesh | InstanceSkeletalMesh,
};
ENUM_CLASS_FLAGS(ERayTracingProxyType);
 
class FPrimitiveSceneProxy
{
public:
 
    ENGINE_API FPrimitiveSceneProxy(const UPrimitiveComponent* InComponent, FName ResourceName = NAME_None);
    ENGINE_API FPrimitiveSceneProxy(const FPrimitiveSceneProxyDesc& InDesc, FName ResourceName = NAME_None);
 
    ENGINE_API FPrimitiveSceneProxy(FPrimitiveSceneProxy const&);
 
    ENGINE_API virtual ~FPrimitiveSceneProxy();
 
    virtual SIZE_T GetTypeHash() const = 0;
 
    ENGINE_API void SetSelection_GameThread(const bool bInParentSelected, const bool bInIndividuallySelected=false);
 
    ENGINE_API void SetLevelInstanceEditingState_GameThread(const bool bInEditingState);
 
    void SetHovered_GameThread(const bool bInHovered);
 
    void SetLightingChannels_GameThread(FLightingChannels LightingChannels);
 
    void SetHiddenEdViews_GameThread( uint64 InHiddenEditorViews );
 
#if WITH_EDITOR
    void SetIsBeingMovedByEditor_GameThread(bool bIsBeingMoved);
 
    void SetSelectionOverride_GameThread(bool bForceSelection);
    
    void SetSelectionOutlineColorIndex_GameThread(uint8 ColorIndex);
 
    void SetOverlayColor_GameThread(FColor OverlayColor);
#endif // WITH_EDITOR
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ENGINE_API void SetPrimitiveColor_GameThread(const FLinearColor& InPrimitiveColor);
#endif  
 
    ENGINE_API void ResetSceneVelocity_GameThread();
 
    void SetEvaluateWorldPositionOffset_GameThread(bool bEvaluate);
 
    virtual void SetWorldPositionOffsetDisableDistance_GameThread(int32 NewValue) {}
 
    virtual void SetInstanceCullDistance_RenderThread(float StartCullDistance, float EndCullDistance) {}
 
    ENGINE_API bool IsShown(const FSceneView* View) const;
 
    ENGINE_API bool IsShadowCast(const FSceneView* View) const;
 
    ENGINE_API void RenderBounds(FPrimitiveDrawInterface* PDI, const FEngineShowFlags& EngineShowFlags, const FBoxSphereBounds& Bounds, bool bRenderInEditor) const;
 
    ENGINE_API bool VerifyUsedMaterial(const class FMaterialRenderProxy* MaterialRenderProxy) const;
 
    virtual int32 GetLOD(const FSceneView* View) const { return INDEX_NONE; }
    
 
 
    
 
    ENGINE_API virtual HHitProxy* CreateHitProxies(UPrimitiveComponent* Component,TArray<TRefCountPtr<HHitProxy> >& OutHitProxies);
 
    ENGINE_API virtual HHitProxy* CreateHitProxies(IPrimitiveComponent* ComponentInterface,TArray<TRefCountPtr<HHitProxy> >& OutHitProxies);
 
#if WITH_EDITOR
    virtual const FColorVertexBuffer* GetCustomHitProxyIdBuffer() const { return nullptr; }
#endif
    virtual void DrawStaticElements(FStaticPrimitiveDrawInterface* PDI) {}
 
    virtual void GetMeshDescription(int32 LODIndex, TArray<FMeshBatch>& OutMeshElements) const {}
 
    virtual void GetShadowShapes(FVector PreViewTranslation, TArray<FCapsuleShape3f>& OutCapsuleShapes) const {}
 
    virtual bool IsCullingReversedByComponent() const { return false; }
 
#if RHI_RAYTRACING
    // TODO: remove these individual functions in favor of ERayTracingPrimitiveFlags
    virtual bool IsRayTracingRelevant() const { return false; }
    virtual bool IsRayTracingStaticRelevant() const { return false; }
 
    virtual bool HasRayTracingRepresentation() const { return false; }
 
    virtual void GetDynamicRayTracingInstances(class FRayTracingInstanceCollector& Collector) {}
 
    virtual TArray<FRayTracingGeometry*> GetStaticRayTracingGeometries() const { return {}; }
 
    ENGINE_API virtual ERayTracingPrimitiveFlags GetCachedRayTracingInstance(struct FRayTracingInstance& OutRayTracingInstance);
 
    virtual Nanite::CoarseMeshStreamingHandle GetCoarseMeshStreamingHandle() const { return INDEX_NONE; }
 
    virtual RayTracing::FGeometryGroupHandle GetRayTracingGeometryGroupHandle() const { return INDEX_NONE; }
 
    ENGINE_API ERayTracingProxyType GetRayTracingProxyType() const;
#endif // RHI_RAYTRACING
 
    virtual void GetStreamableRenderAssetInfo(const FBoxSphereBounds& PrimitiveBounds, TArray<struct FStreamingRenderAssetPrimitiveInfo>& StreamableRenderAssets) const { check(IsSupportingStreamableRenderAssetsGathering()); }
    bool IsSupportingStreamableRenderAssetsGathering() const { return bImplementsStreamableAssetGathering; }
    virtual bool CanApplyStreamableRenderAssetScaleFactor() const { return false; }
    bool IsForceMipStreaming() const { return bForceMipStreaming; }
    
    virtual void GetDynamicMeshElements(const TArray<const FSceneView*>& Views, const FSceneViewFamily& ViewFamily, uint32 VisibilityMap, class FMeshElementCollector& Collector) const {}
 
    virtual const class FCardRepresentationData* GetMeshCardRepresentation() const { return nullptr; }
 
    virtual void ApplyViewDependentMeshArguments(const FSceneView& View, FMeshBatch& ViewDependentMeshBatch) const {};
 
    virtual const TArray<FBoxSphereBounds>* GetOcclusionQueries(const FSceneView* View) const 
    {
        return nullptr;
    }
 
    virtual void AcceptOcclusionResults(const FSceneView* View, TArray<bool>* Results, int32 ResultsStart, int32 NumResults) {}
 
    ENGINE_API virtual FPrimitiveViewRelevance GetViewRelevance(const FSceneView* View) const;
 
    virtual void GatherSimpleLights(const FSceneViewFamily& ViewFamily, FSimpleLightArray& OutParticleLights) const {}
 
    virtual void GetLightRelevance(const FLightSceneProxy* LightSceneProxy, bool& bDynamic, bool& bRelevant, bool& bLightMapped, bool& bShadowMapped) const
    {
        // Determine the lights relevance to the primitive.
        bDynamic = true;
        bRelevant = true;
        bLightMapped = false;
        bShadowMapped = false;
    }
 
    virtual void GetDistanceFieldAtlasData(const class FDistanceFieldVolumeData*& OutDistanceFieldData, float& SelfShadowBias) const
    {
        OutDistanceFieldData = nullptr;
        SelfShadowBias = 0;
    }
    UE_DEPRECATED(5.4, "Use generic instance data through GetInstanceSceneDataBuffers().")
    virtual void GetDistanceFieldInstanceData(TArray<FRenderTransform>& InstanceLocalToPrimitiveTransforms) const final
    {
    }
 
    virtual bool HeightfieldHasPendingStreaming() const { return false; }
 
    virtual bool StaticMeshHasPendingStreaming() const { return false; }
 
    virtual void GetHeightfieldRepresentation(UTexture2D*& OutHeightmapTexture, UTexture2D*& OutVisibilityTexture, FHeightfieldComponentDescription& OutDescription) const
    {
        OutHeightmapTexture = nullptr;
        OutVisibilityTexture = nullptr;
    }
 
    virtual TConstArrayView<FPrimitiveComponentId> GetSourceLandscapeComponentIds() const { return {}; }
 
    virtual void CreateRenderThreadResources(FRHICommandListBase& RHICmdList) {}
 
    virtual void DestroyRenderThreadResources() {}
 
    virtual void OnDetachLight(const FLightSceneInfo* Light)
    {
    }
 
    virtual void OnTransformChanged(FRHICommandListBase& RHICmdList) { }
 
    virtual bool CanBeOccluded() const
    {
        return true;
    }
 
    virtual bool AllowInstanceCullingOcclusionQueries() const
    {
        return false;
    }
 
    bool CanSkipRedundantTransformUpdates() const
    {
        return bCanSkipRedundantTransformUpdates;
    }
 
    void SetCanSkipRedundantTransformUpdates(bool bCanSkip)
    {
        bCanSkipRedundantTransformUpdates = bCanSkip;
    }
 
    virtual bool IsUsingDistanceCullFade() const
    {
        return false;
    }
 
    virtual bool HasSubprimitiveOcclusionQueries() const
    {
        return false;
    }
 
    virtual bool ShowInBSPSplitViewmode() const
    {
        return false;
    }
 
    virtual ESceneDepthPriorityGroup GetStaticDepthPriorityGroup() const
    {
        check(!HasViewDependentDPG());
        return (ESceneDepthPriorityGroup)StaticDepthPriorityGroup;
    }
 
    ENGINE_API ESceneDepthPriorityGroup GetDepthPriorityGroup(const FSceneView* View) const;
 
    virtual uint32 GetMemoryFootprint( void ) const = 0;
    SIZE_T GetAllocatedSize( void ) const { return( Owners.GetAllocatedSize() ); }
 
    void SetCollisionEnabled_GameThread(const bool bNewEnabled);
 
    void SetCollisionEnabled_RenderThread(const bool bNewEnabled);
 
    void SetCustomDepthEnabled_GameThread(const bool bInRenderCustomDepth);
 
    void SetCustomDepthEnabled_RenderThread(const bool bInRenderCustomDepth);
 
    void SetCustomDepthStencilValue_GameThread(const int32 InCustomDepthStencilValue );
 
    void SetCustomDepthStencilValue_RenderThread(const int32 InCustomDepthStencilValue);
 
    void SetDistanceFieldSelfShadowBias_RenderThread(float NewBias);
 
    ENGINE_API void SetDrawDistance_RenderThread(float MinDrawDistance, float MaxDrawDistance, float VirtualTextureMaxDrawDistance);
 
    // Accessors.
    inline FSceneInterface& GetScene() const { return *Scene; }
    inline FPrimitiveComponentId GetPrimitiveComponentId() const { return PrimitiveComponentId; }
    inline FPrimitiveSceneInfo* GetPrimitiveSceneInfo() const { return PrimitiveSceneInfo; }
    inline const FMatrix& GetLocalToWorld() const { return LocalToWorld; }
    inline bool IsLocalToWorldDeterminantNegative() const { return bIsLocalToWorldDeterminantNegative; }
    inline const FBoxSphereBounds& GetBounds() const { return Bounds; }
    inline const FBoxSphereBounds& GetLocalBounds() const { return LocalBounds; }
    ENGINE_API virtual void GetPreSkinnedLocalBounds(FBoxSphereBounds& OutBounds) const;
    inline FName GetOwnerName() const { return OwnerName; }
    inline FName GetResourceName() const { return ResourceName; }
    inline FName GetLevelName() const { return LevelName; }
    inline TStatId GetStatId() const 
    { 
        return StatId; 
    }   
    inline float GetMinDrawDistance() const { return MinDrawDistance; }
    inline float GetMaxDrawDistance() const { return MaxDrawDistance; }
    inline int32 GetVisibilityId() const { return VisibilityId; }
    inline int16 GetTranslucencySortPriority() const { return TranslucencySortPriority; }
    inline float GetTranslucencySortDistanceOffset() const { return TranslucencySortDistanceOffset; }
 
    inline int32 GetVirtualTextureLodBias() const { return VirtualTextureLodBias; }
    inline int32 GetVirtualTextureCullMips() const { return VirtualTextureCullMips; }
    inline int32 GetVirtualTextureMinCoverage() const { return VirtualTextureMinCoverage; }
    inline const TArray<int32>& GetRuntimeVirtualTextureIds() const { return RuntimeVirtualTextures; }
 
    inline bool IsMovable() const 
    { 
        // Note: primitives with EComponentMobility::Stationary can still move (as opposed to lights with EComponentMobility::Stationary)
        return Mobility == EComponentMobility::Movable || Mobility == EComponentMobility::Stationary; 
    }
 
    inline bool IsOftenMoving() const { return Mobility == EComponentMobility::Movable; }
 
    inline bool IsMeshShapeOftenMoving() const 
    { 
        return Mobility == EComponentMobility::Movable || !bGoodCandidateForCachedShadowmap; 
    }
 
    inline ELightmapType GetLightmapType() const { return LightmapType; }
    inline bool IsStatic() const { return Mobility == EComponentMobility::Static; }
    inline bool IsSelectable() const { return bSelectable; }
    inline bool IsParentSelected() const { return bParentSelected; }
    inline bool IsIndividuallySelected() const { return bIndividuallySelected; }
    inline bool IsEditingLevelInstanceChild() const { return bLevelInstanceEditingState; }
    inline bool IsSelected() const { return IsParentSelected() || IsIndividuallySelected(); }
    inline bool WantsEditorEffects() const { return bWantsEditorEffects; }
    inline bool WantsSelectionOutline() const { return bWantsSelectionOutline; }
    ENGINE_API bool ShouldRenderCustomDepth() const;
    inline bool IsVisibleInSceneCaptureOnly() const { return bVisibleInSceneCaptureOnly; }
    inline bool IsHiddenInSceneCapture() const { return bHiddenInSceneCapture; }
    inline uint8 GetCustomDepthStencilValue() const { return CustomDepthStencilValue; }
    inline EStencilMask GetStencilWriteMask() const { return CustomDepthStencilWriteMask; }
    inline uint8 GetLightingChannelMask() const { return LightingChannelMask; }
    inline uint8 GetLightingChannelStencilValue() const 
    { 
        // Flip the default channel bit so that the default value is 0, to align with the default stencil clear value and GBlackTexture value
        return (LightingChannelMask & 0x6) | (~LightingChannelMask & 0x1); 
    }
    inline bool IsVisibleInReflectionCaptures() const { return bVisibleInReflectionCaptures; }
    inline bool IsVisibleInRealTimeSkyCaptures() const { return bVisibleInRealTimeSkyCaptures; }
    inline bool IsVisibleInRayTracing() const { return bVisibleInRayTracing; }
    inline bool IsVisibleInLumenScene() const { return bVisibleInLumenScene; }
    inline bool IsOpaqueOrMasked() const { return bOpaqueOrMasked; }
    inline bool SupportsMaterialCache() const { return bSupportsMaterialCache; }
    inline bool ShouldRenderInMainPass() const { return bRenderInMainPass; }
    inline bool ShouldRenderInDepthPass() const { return bRenderInMainPass || bRenderInDepthPass; }
    inline bool SupportsParallelGDME() const { return bSupportsParallelGDME; }
    inline bool SinglePassGDME() const { return bSinglePassGDME; }
    inline bool SupportsParallelGDRTI() const { return bSupportsParallelGDRTI; }
    inline bool IsCollisionEnabled() const { return bCollisionEnabled; }
    inline bool IsHovered() const { return bHovered; }
    inline bool IsOwnedBy(const FSceneViewOwner& Owner) const { return Owner.IsPartOf(Owners); }
    inline bool HasViewDependentDPG() const { return bUseViewOwnerDepthPriorityGroup; }
    inline bool HasStaticLighting() const { return bStaticLighting; }
    inline bool NeedsUnbuiltPreviewLighting() const { return bNeedsUnbuiltPreviewLighting; }
    inline bool CastsStaticShadow() const { return bCastStaticShadow; }
    inline bool CastsDynamicShadow() const { return bCastDynamicShadow; }
    inline bool IsEmissiveLightSource() const { return bEmissiveLightSource; }
    inline bool WritesVirtualTexture() const{ return bSupportsRuntimeVirtualTexture && RuntimeVirtualTextures.Num() > 0; }
    UE_DEPRECATED(5.6, "Use GetRuntimeVirtualTextureIds() instead.")
    inline bool WritesVirtualTexture(URuntimeVirtualTexture* VirtualTexture) const { return false; }
    inline bool AffectsDynamicIndirectLighting() const { return bAffectDynamicIndirectLighting; }
    inline bool AffectsDistanceFieldLighting() const { return bAffectDistanceFieldLighting; }
    inline bool AffectsIndirectLightingWhileHidden() const { return bAffectIndirectLightingWhileHidden; }
    inline EIndirectLightingCacheQuality GetIndirectLightingCacheQuality() const { return IndirectLightingCacheQuality; }
    inline bool CastsVolumetricTranslucentShadow() const { return bCastVolumetricTranslucentShadow; }
    inline bool CastsContactShadow() const { return bCastContactShadow; }
    inline bool CastsDeepShadow() const { return bCastDeepShadow; }
    inline bool CastsCapsuleDirectShadow() const { return bCastCapsuleDirectShadow; }
    inline bool CastsDynamicIndirectShadow() const { return bCastsDynamicIndirectShadow; }
    inline float GetDynamicIndirectShadowMinVisibility() const { return DynamicIndirectShadowMinVisibility; }
    inline bool CastsHiddenShadow() const { return bCastHiddenShadow; }
    inline bool CastsShadowAsTwoSided() const { return bCastShadowAsTwoSided; }
    inline bool CastsSelfShadowOnly() const { return bSelfShadowOnly; }
    inline bool CastsInsetShadow() const { return bCastInsetShadow; }
    inline bool CastsCinematicShadow() const { return bCastCinematicShadow; }
    inline bool CastsFarShadow() const { return bCastFarShadow; }
    inline bool LightAttachmentsAsGroup() const { return bLightAttachmentsAsGroup; }
    ENGINE_API bool UseSingleSampleShadowFromStationaryLights() const;
    inline bool StaticElementsAlwaysUseProxyPrimitiveUniformBuffer() const { return bStaticElementsAlwaysUseProxyPrimitiveUniformBuffer; }
    inline bool DoesVFRequirePrimitiveUniformBuffer() const { return bVFRequiresPrimitiveUniformBuffer; }
 
    ENGINE_API bool IsInstanceDataGPUOnly() const;
 
    inline bool DoesMeshBatchesUseSceneInstanceCount() const { return bDoesMeshBatchesUseSceneInstanceCount; }
 
    inline bool ShouldUseAsOccluder() const { return bUseAsOccluder; }
    inline bool AllowApproximateOcclusion() const { return bAllowApproximateOcclusion; }
    inline bool Holdout() const { return bHoldout; }
    inline bool IsSplineMesh() const { return bSplineMesh; }
    inline bool IsSkinnedMesh() const { return bSkinnedMesh; }
    inline bool IsFirstPerson() const { return bIsFirstPerson; }
    inline bool IsFirstPersonWorldSpaceRepresentation() const { return bIsFirstPersonWorldSpaceRepresentation; }
    inline bool IsOwnerNoSee() const { return bOwnerNoSee; }
    inline bool IsOnlyOwnerSee() const { return bOnlyOwnerSee; }
 
    inline FRHIUniformBuffer* GetUniformBuffer() const
    {
        return UniformBuffer.GetReference(); 
    }
 
    inline bool HasPerInstanceHitProxies() const { return bHasPerInstanceHitProxies; }
 
#if WITH_EDITOR
    inline uint8 GetSelectionOutlineColorIndex() const { return SelectionOutlineColorIndex; }
    inline FColor GetOverlayColor() const { return OverlayColor; }
#endif // WITH_EDITOR
    
    ENGINE_API bool UseEditorCompositing(const FSceneView* View) const;
    inline const FVector& GetActorPosition() const { return ActorPosition; }
    inline const bool ReceivesDecals() const { return bReceivesDecals; }
    inline bool WillEverBeLit() const { return bWillEverBeLit; }
    inline bool HasValidSettingsForStaticLighting() const { return bHasValidSettingsForStaticLighting; }
    inline bool SupportsDistanceFieldRepresentation() const { return bSupportsDistanceFieldRepresentation; }
    inline bool SupportsHeightfieldRepresentation() const { return bSupportsHeightfieldRepresentation; }
    inline bool IsLumenHeightfield() const { return bLumenHeightfield; }
    inline bool IsLandscapeProxy() const { return bIsLandscapeProxy; }
    inline bool IsLandscapeNaniteProxy() const { return bIsLandscapeNaniteProxy; }
    inline bool IsCompatibleWithLumenCardSharing() const { return bCompatibleWithLumenCardSharing; }
    inline bool SupportsInstanceDataBuffer() const { return InstanceSceneDataBuffersInternal != nullptr; }
    inline bool SupportsSortedTriangles() const { return bSupportsSortedTriangles; }
    inline bool TreatAsBackgroundForOcclusion() const { return bTreatAsBackgroundForOcclusion; }
    inline bool ShouldNotifyOnWorldAddRemove() const { return bShouldNotifyOnWorldAddRemove; }
    inline bool IsForceHidden() const {return bForceHidden;}
    inline bool ShouldReceiveMobileCSMShadows() const { return bReceiveMobileCSMShadows; }
    inline bool IsRayTracingFarField() const { return bRayTracingFarField; }
    inline int32 GetRayTracingGroupId() const { return RayTracingGroupId; }
    inline uint8 GetRayTracingGroupCullingPriority() const { return RayTracingGroupCullingPriority; }
 
    static constexpr int32 InvalidRayTracingGroupId = -1;
 
    inline bool EvaluateWorldPositionOffset() const { return bEvaluateWorldPositionOffset; }
    inline bool AnyMaterialHasWorldPositionOffset() const { return bAnyMaterialHasWorldPositionOffset; }
    inline bool AnyMaterialAlwaysEvaluatesWorldPositionOffset() const { return bAnyMaterialAlwaysEvaluatesWorldPositionOffset; }
    inline bool AnyMaterialHasPixelAnimation() const { return bAnyMaterialHasPixelAnimation; }
    inline bool AnyMaterialUsesTemporalResponsiveness() const { return bAnyMaterialUsesTemporalResponsiveness; }
    inline bool AnyMaterialUsesMotionVectorWorldOffset() const { return bAnyMaterialUsesMotionVectorWorldOffset; }
    inline float GetMaxWorldPositionOffsetExtent() const
    {
        if ((EvaluateWorldPositionOffset() && AnyMaterialHasWorldPositionOffset())
            || AnyMaterialAlwaysEvaluatesWorldPositionOffset())
        {
            return MaxWPOExtent;
        }
        return 0.0f;
    }
 
    inline const FVector2f& GetMinMaxMaterialDisplacement() const
    {
        return MinMaxMaterialDisplacement;
    }
 
    inline float GetAbsMaxDisplacement() const
    {
        // TODO: DISP - Fix me
        const float AbsMaxMaterialDisplacement = FMath::Max(-GetMinMaxMaterialDisplacement().X, GetMinMaxMaterialDisplacement().Y);
        return GetMaxWorldPositionOffsetExtent() + AbsMaxMaterialDisplacement;
    }
    
    inline bool HasDynamicTransform() const { return IsMovable() || bIsBeingMovedByEditor; }
    inline bool DrawsVelocity() const { return HasDynamicTransform() || bAlwaysHasVelocity || AnyMaterialHasPixelAnimation() || bHasWorldPositionOffsetVelocity || AnyMaterialUsesTemporalResponsiveness() || AnyMaterialUsesMotionVectorWorldOffset(); }
    inline bool AlwaysHasVelocity() const { return bAlwaysHasVelocity || AnyMaterialHasPixelAnimation() || (bHasWorldPositionOffsetVelocity && EvaluateWorldPositionOffset()) || AnyMaterialUsesTemporalResponsiveness() || AnyMaterialUsesMotionVectorWorldOffset(); }
 
#if WITH_EDITOR
    inline int32 GetNumUncachedStaticLightingInteractions() { return NumUncachedStaticLightingInteractions; }
 
    ENGINE_API void SetUsedMaterialForVerification(const TArray<UMaterialInterface*>& InUsedMaterialsForVerification);
#endif
 
#if !UE_BUILD_TEST
    inline FLinearColor GetWireframeColor() const { return WireframeColor; }
    inline FLinearColor GetPrimitiveColor() const { return PrimitiveColor; }
    inline void SetWireframeColor(const FLinearColor& InWireframeColor) { WireframeColor = InWireframeColor; }
    inline void SetPrimitiveColor(const FLinearColor& InPrimitiveColor) { PrimitiveColor = InPrimitiveColor; }
#else
    inline FLinearColor GetWireframeColor() const { return FLinearColor::White; }
    inline FLinearColor GetPrimitiveColor() const { return FLinearColor::White; }
    inline void SetWireframeColor(const FLinearColor& InWireframeColor) {}
    inline void SetPrimitiveColor(const FLinearColor& InPrimitiveColor) {}
#endif
 
    virtual bool IsDetailMesh() const
    {
        return false;
    }
 
    virtual FSkinningSceneExtensionProxy* GetSkinningSceneExtensionProxy() const
    {
        return nullptr;
    }
 
    inline bool IsNaniteMesh() const
    {
        return bIsNaniteMesh;
    }
 
    inline bool IsAlwaysVisible() const
    {
        return bIsAlwaysVisible;
    }
 
    inline bool IsHeterogeneousVolume() const
    {
        return bIsHeterogeneousVolume;
    }
 
    inline bool SupportsGPUScene() const
    {
        return bSupportsGPUScene;
    }
 
    inline bool HasDeformableMesh() const
    {
        return bHasDeformableMesh;
    }
 
    virtual bool HasCustomOcclusionBounds() const
    {
        return false;
    }
 
    virtual FBoxSphereBounds GetCustomOcclusionBounds() const
    {
        checkf(false, TEXT("GetCustomOcclusionBounds> Should not be called on base scene proxy!"));
        return GetBounds();
    }
 
    virtual bool HasDistanceFieldRepresentation() const
    {
        return false;
    }
 
    virtual bool HasDynamicIndirectShadowCasterRepresentation() const
    {
        return false;
    }
 
    virtual bool GetInstanceDrawDistanceMinMax(FVector2f& OutDistanceMinMax) const
    {
        OutDistanceMinMax = FVector2f(0.0f);
        return false;
    }
 
    virtual bool GetInstanceWorldPositionOffsetDisableDistance(float& OutWPODisableDistance) const
    {
        OutWPODisableDistance = 0.0f;
        return false;
    }
 
    UE_DEPRECATED(5.6, "This interface will be removed in a future release. Use Nanite::FSceneProxyBase::GetResourcePrimitiveInfo instead.")
    virtual void GetNaniteResourceInfo(uint32& ResourceID, uint32& HierarchyOffset, uint32& ImposterIndex) const
    {
        ResourceID = INDEX_NONE;
        HierarchyOffset = INDEX_NONE;
        ImposterIndex = INDEX_NONE;
    }
 
    virtual float GetAnimationMinScreenSize() const  { return -1.0f; }
 
    virtual FRenderCurveResourceData* GetRenderCurveResourceData()
    {
        return nullptr;
    }
 
    static ENGINE_API void DrawArc(FPrimitiveDrawInterface* PDI, const FVector& Start, const FVector& End, const float Height, const uint32 Segments, const FLinearColor& Color
        , uint8 DepthPriorityGroup, const float Thickness = 0.0f, const bool bScreenSpace = false);
    
    static ENGINE_API void DrawArrowHead(FPrimitiveDrawInterface* PDI, const FVector& Tip, const FVector& Origin, const float Size, const FLinearColor& Color
        , uint8 DepthPriorityGroup, const float Thickness = 0.0f, const bool bScreenSpace = false);
 
 
    ENGINE_API virtual void ApplyWorldOffset(FRHICommandListBase& RHICmdList, FVector InOffset);
 
    ENGINE_API virtual void ApplyLateUpdateTransform(FRHICommandListBase& RHICmdList, const FMatrix& LateUpdateTransform);
 
    ENGINE_API void UpdateUniformBuffer(FRHICommandList& RHICmdList);
 
    ENGINE_API void BuildUniformShaderParameters(FPrimitiveUniformShaderParametersBuilder &Builder) const;
 
#if ENABLE_DRAW_DEBUG
 
    struct FDebugMassData
    {
        //Local here just means local to ElemTM which can be different depending on how the component uses the mass data
        FQuat LocalTensorOrientation;
        FVector LocalCenterOfMass;
        FVector MassSpaceInertiaTensor;
        int32 BoneIndex;
 
        ENGINE_API void DrawDebugMass(class FPrimitiveDrawInterface* PDI, const FTransform& ElemTM) const;
    };
 
    TArray<FDebugMassData> DebugMassData;
 
    ENGINE_API virtual void SetDebugMassData(const TArray<FDebugMassData>& InDebugMassData);
#endif
 
#if MESH_DRAW_COMMAND_STATS
    inline FName GetMeshDrawCommandStatsCategory() const { return MeshDrawCommandStatsCategory; }
#endif
 
    typedef TArray<class FLightCacheInterface*, TInlineAllocator<8> > FLCIArray;
    virtual void GetLCIs(FLCIArray& LCIs) {}
 
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual bool GetPrimitiveDistance(int32 LODIndex, int32 SectionIndex, const FVector& ViewOrigin, float& PrimitiveDistance) const;
 
    ENGINE_API virtual bool GetMeshUVDensities(int32 LODIndex, int32 SectionIndex, FVector4& WorldUVDensities) const;
 
    ENGINE_API virtual bool GetMaterialTextureScales(int32 LODIndex, int32 SectionIndex, const class FMaterialRenderProxy* MaterialRenderProxy, FVector4f* OneOverScales, FIntVector4* UVChannelIndices) const;
#endif
 
    virtual int32 GetLightMapResolution() const { return 0; }
 
    virtual int32 GetLightMapCoordinateIndex() const { return INDEX_NONE; }
 
    inline bool IsDrawnInGame() const { return DrawInGame; }
 
    ENGINE_API void SetDrawnInGame_RenderThread(bool bInDrawInGame);
 
    inline bool IsDrawnInEditor() const { return DrawInEditor; }
 
    virtual uint8 GetCurrentFirstLODIdx_RenderThread() const { return 0; }
 
    virtual FDesiredLODLevel GetDesiredLODLevel_RenderThread(const FSceneView* View) const { return FDesiredLODLevel::CreateFirst(0); }
 
    virtual float GetLodScreenSizeScale() const { return 1.f; }
 
    virtual float GetGpuLodInstanceRadius() const { return 0.f; }
 
    virtual FUintVector2 GetMeshPaintTextureDescriptor() const { return FUintVector2(0, 0); }
 
    ENGINE_API virtual uint32 GetMaterialCacheDescriptor() const;
 
    const FCustomPrimitiveData* GetCustomPrimitiveData() const { return &CustomPrimitiveData; }
 
    EShadowCacheInvalidationBehavior GetShadowCacheInvalidationBehavior() const { return ShadowCacheInvalidationBehavior; }
 
    enum class EInstanceBufferAccessFlags
    {
        SynchronizeUpdateTask,
        UnsynchronizedAndUnsafe,
    };
 
    inline bool HasInstanceDataBuffers() const { return InstanceSceneDataBuffersInternal != nullptr; }
 
 
    ENGINE_API const FInstanceSceneDataBuffers *GetInstanceSceneDataBuffers(EInstanceBufferAccessFlags AccessFlags = EInstanceBufferAccessFlags::SynchronizeUpdateTask) const;
 
    virtual FInstanceDataUpdateTaskInfo *GetInstanceDataUpdateTaskInfo() const { return nullptr; }
 
    ENGINE_API FInstanceDataBufferHeader GetInstanceDataHeader() const;
 
#if UE_WITH_PSO_PRECACHING
    ENGINE_API void BoostPrecachedPSORequestsOnDraw();
    ENGINE_API void SetPSORequestsToBoostOnDraw(const TArray<FMaterialPSOPrecacheRequestID>& PSORequestsToBoostOnDrawIN);
#endif
 
protected:
    ENGINE_API void SetupInstanceSceneDataBuffers(const FInstanceSceneDataBuffers* InInstanceSceneDataBuffers);
 
    ENGINE_API void UpdateVisibleInLumenScene();
 
    bool IsRuntimeVirtualTextureOnly() const { return bVirtualTextureMainPassDrawNever; }
 
    bool DrawInRuntimeVirtualTextureOnly(bool bEditor) const;
 
    void OverrideOwnerName(FName InOwnerName)
    {
        OwnerName = InOwnerName;
    }
 
    ENGINE_API void OnLevelAddedToWorld_RenderThread();
 
    ENGINE_API void OnLevelRemovedFromWorld_RenderThread();
 
    void SetForceHidden(bool bForceHiddenIn)
    {
        if (bForceHidden != bForceHiddenIn)
        {
            bForceHidden = bForceHiddenIn;
            OnForceHiddenChanged();
        }
    }
 
    virtual void OnForceHiddenChanged() {}
 
    ENGINE_API void EnableGPUSceneSupportFlags();
 
public:
    TSharedPtr<int32, ESPMode::ThreadSafe> SimpleStreamableAssetManagerIndex = MakeShared<int32, ESPMode::ThreadSafe>(INDEX_NONE);
    
private:
#if !UE_BUILD_TEST
    FLinearColor WireframeColor;
    FLinearColor PrimitiveColor;
#endif
 
    friend class FScene;
 
    FCustomPrimitiveData CustomPrimitiveData;
 
    int16 TranslucencySortPriority;
 
    float TranslucencySortDistanceOffset;
 
    TEnumAsByte<EComponentMobility::Type> Mobility;
    ELightmapType LightmapType;
 
    TStatId StatId;
 
    uint8 bIsLocalToWorldDeterminantNegative : 1;
    uint8 DrawInGame : 1;
    uint8 DrawInEditor : 1;
    uint8 bReceivesDecals : 1;
    uint8 bVirtualTextureMainPassDrawAlways : 1;
    uint8 bVirtualTextureMainPassDrawNever : 1;
    uint8 bOnlyOwnerSee : 1;
    uint8 bOwnerNoSee : 1;
    uint8 bOftenMoving : 1;
    uint8 bParentSelected : 1;
    uint8 bIndividuallySelected : 1;
    uint8 bLevelInstanceEditingState : 1;
    
    uint8 bHovered : 1;
 
    uint8 bUseViewOwnerDepthPriorityGroup : 1;
 
    uint8 StaticDepthPriorityGroup : SDPG_NumBits;
 
    uint8 ViewOwnerDepthPriorityGroup : SDPG_NumBits;
 
    uint8 bStaticLighting : 1;
 
    uint8 bVisibleInReflectionCaptures : 1;
 
    uint8 bVisibleInRealTimeSkyCaptures : 1;
 
    uint8 bVisibleInRayTracing : 1;
 
    uint8 bRenderInDepthPass : 1;
 
    uint8 bRenderInMainPass : 1;
 
    uint8 bForceHidden : 1;
 
    uint8 bCollisionEnabled : 1;
 
    uint8 bTreatAsBackgroundForOcclusion : 1;
 
    friend class FLightPrimitiveInteraction;
    friend class FMaterialCacheSceneExtensionUpdater;
 
protected:
 
    uint8 bSupportsParallelGDME : 1;
 
    uint8 bSinglePassGDME : 1;
 
    uint8 bSupportsParallelGDRTI : 1;
 
    uint8 bVisibleInLumenScene : 1;
 
    uint8 bOpaqueOrMasked : 1;
 
    uint8 bCanSkipRedundantTransformUpdates : 1;
 
    uint8 bGoodCandidateForCachedShadowmap : 1;
 
    uint8 bNeedsUnbuiltPreviewLighting : 1;
 
    uint8 bHasValidSettingsForStaticLighting : 1;
 
    uint8 bWillEverBeLit : 1;
 
    uint8 bCastDynamicShadow : 1;
 
    uint8 bEmissiveLightSource : 1;
 
    uint8 bAffectDynamicIndirectLighting : 1;
 
    uint8 bAffectIndirectLightingWhileHidden : 1;
 
    uint8 bAffectDistanceFieldLighting : 1;
 
    uint8 bSupportsMaterialCache : 1;
 
    uint8 bCastStaticShadow : 1;
 
    EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
 
    uint8 bCastVolumetricTranslucentShadow : 1;
 
    uint8 bCastContactShadow : 1;
 
    uint8 bCastDeepShadow : 1;
 
    uint8 bCastCapsuleDirectShadow : 1;
 
    uint8 bCastsDynamicIndirectShadow : 1;
 
    uint8 bCastHiddenShadow : 1;
 
    uint8 bCastShadowAsTwoSided : 1;
 
    uint8 bSelfShadowOnly : 1;
 
    uint8 bCastInsetShadow : 1;
 
    uint8 bCastCinematicShadow : 1;
 
    /* When enabled, the component will be rendering into the distant shadow cascades (only for directional lights). */
    uint8 bCastFarShadow : 1;
 
    uint8 bLightAttachmentsAsGroup : 1;
 
    uint8 bSingleSampleShadowFromStationaryLights : 1;
 
    uint8 bStaticElementsAlwaysUseProxyPrimitiveUniformBuffer : 1;
 
    uint8 bVFRequiresPrimitiveUniformBuffer : 1;
 
    uint8 bDoesMeshBatchesUseSceneInstanceCount : 1;
 
    uint8 bIsStaticMesh : 1;
 
    uint8 bIsNaniteMesh : 1;
 
    uint8 bIsAlwaysVisible : 1;
 
    uint8 bIsHeterogeneousVolume : 1;
 
    uint8 bIsHierarchicalInstancedStaticMesh : 1;
 
    uint8 bIsLandscapeGrass : 1;
 
    uint8 bSupportsGPUScene : 1;
 
    uint8 bHasDeformableMesh : 1;
 
    uint8 bEvaluateWorldPositionOffset : 1;
 
    uint8 bHasWorldPositionOffsetVelocity : 1;
 
    uint8 bAnyMaterialHasWorldPositionOffset : 1;
 
    uint8 bAnyMaterialAlwaysEvaluatesWorldPositionOffset : 1;
 
    uint8 bAnyMaterialHasPixelAnimation : 1;
 
    uint8 bAnyMaterialUsesTemporalResponsiveness : 1;
 
    uint8 bAnyMaterialUsesMotionVectorWorldOffset : 1;
 
    uint8 bAlwaysHasVelocity : 1;
 
    uint8 bSupportsDistanceFieldRepresentation : 1;
 
    uint8 bSupportsHeightfieldRepresentation : 1;
 
    uint8 bLumenHeightfield : 1;
 
    uint8 bIsLandscapeProxy : 1;
    
    uint8 bIsLandscapeNaniteProxy : 1;
 
    uint8 bCompatibleWithLumenCardSharing : 1;
 
    uint8 bSupportsSortedTriangles : 1;
 
    uint8 bShouldNotifyOnWorldAddRemove : 1;
 
    uint8 bWantsSelectionOutline : 1;
 
    uint8 bVerifyUsedMaterials : 1;
 
    uint8 bWantsEditorEffects : 1;
    
    uint8 bAllowApproximateOcclusion : 1;
 
    uint8 bHoldout : 1;
 
    uint8 bSplineMesh : 1;
 
    uint8 bSkinnedMesh : 1;
    
    uint8 bInstancedSkinnedMesh : 1;
 
    uint8 bIsFirstPerson : 1;
 
    uint8 bIsFirstPersonWorldSpaceRepresentation : 1;
 
    uint8 bSupportsRuntimeVirtualTexture : 1;
 
    uint8 bImplementsStreamableAssetGathering : 1;
 
private:
 
    uint8 bUseAsOccluder:1;
 
    uint8 bSelectable : 1;
 
    uint8 bHasPerInstanceHitProxies : 1;
 
    uint8 bUseEditorCompositing : 1;
 
    uint8 bIsBeingMovedByEditor : 1;
 
    uint8 bReceiveMobileCSMShadows : 1;
 
    uint8 bRenderCustomDepth : 1;
 
    uint8 bVisibleInSceneCaptureOnly : 1;
 
    uint8 bHiddenInSceneCapture : 1;
 
    uint8 bForceMipStreaming : 1;
 
    bool bRayTracingFarField : 1;
 
    uint8 CustomDepthStencilValue;
 
    TEnumAsByte<EStencilMask> CustomDepthStencilWriteMask;
 
    uint8 LightingChannelMask;
 
    // Run-time groups of proxies
    int32 RayTracingGroupId;
    uint8 RayTracingGroupCullingPriority;
 
private:
    // Never use directly in descendant or implementation except for very good reason.
    const FInstanceSceneDataBuffers *InstanceSceneDataBuffersInternal = nullptr;
 
protected:
    FMaterialRelevance CombinedMaterialRelevance;
 
    TEnumAsByte<EIndirectLightingCacheQuality> IndirectLightingCacheQuality;
 
    int8 VirtualTextureLodBias;
    int8 VirtualTextureCullMips;
    int8 VirtualTextureMinCoverage;
 
    float DynamicIndirectShadowMinVisibility;
 
    float DistanceFieldSelfShadowBias;
 
    float MaxWPOExtent;
 
    FVector2f MinMaxMaterialDisplacement;
 
    TArray<int32> RuntimeVirtualTextures;
    TArray<ERuntimeVirtualTextureMaterialType> RuntimeVirtualTextureMaterialTypes;
 
public:
    TArray<class FMaterialCacheVirtualTextureRenderProxy*> MaterialCacheRenderProxies;
 
    uint32 MaterialCacheDescriptor = UINT32_MAX;
 
private:
    TArray<uint32> Owners;
 
    FMatrix LocalToWorld;
 
    FBoxSphereBounds Bounds = FBoxSphereBounds(ForceInit);
 
    FBoxSphereBounds LocalBounds = FBoxSphereBounds(ForceInit);
 
    FVector ActorPosition;
 
    FPrimitiveComponentId PrimitiveComponentId;
 
    FSceneInterface* Scene;
 
    FPrimitiveSceneInfo* PrimitiveSceneInfo;
 
    FName OwnerName;
 
    FName ResourceName;
 
    FName LevelName;
 
#if MESH_DRAW_COMMAND_STATS
    FName MeshDrawCommandStatsCategory;
#endif
 
#if WITH_EDITOR
    uint64 HiddenEditorViews;
 
    FColor OverlayColor = FColor(EForceInit::ForceInitToZero);
 
    uint32 SelectionOutlineColorIndex : 8;
 
    uint32 DrawInAnyEditMode : 1;
 
    uint32 bIsFoliage : 1;
#endif
 
    int32 VisibilityId;
 
    TUniformBufferRef<FPrimitiveUniformShaderParameters> UniformBuffer;
 
    const UPrimitiveComponent* ComponentForDebuggingOnly;
 
#if WITH_EDITOR
    int32 NumUncachedStaticLightingInteractions;
 
    TArray<UMaterialInterface*> UsedMaterialsForVerification;
#endif
#if UE_WITH_PSO_PRECACHING
    // The pso precache request IDs that will be boosted to the highest priority when drawn.
    TArray<FMaterialPSOPrecacheRequestID> PSOPrecacheRequestsToBoostOnDraw;
#endif
    ENGINE_API void SetTransform(FRHICommandListBase& RHICmdList, const FMatrix& InLocalToWorld, const FBoxSphereBounds& InBounds, const FBoxSphereBounds& InLocalBounds, FVector InActorPosition);
 
    ENGINE_API bool WouldSetTransformBeRedundant_AnyThread(const FMatrix& InLocalToWorld, const FBoxSphereBounds& InBounds, const FBoxSphereBounds& InLocalBounds, const FVector& InActorPosition) const;
 
    ENGINE_API void CreateUniformBuffer();
 
    void SetHiddenEdViews_RenderThread( uint64 InHiddenEditorViews );
 
protected:
 
    float MaxDrawDistance;
 
    float MinDrawDistance;
 
    UE_DEPRECATED(5.6, "StaticMeshBounds is no longer a parameter of this interface, please update the implementation.")
    ENGINE_API virtual void UpdateInstances_RenderThread(FRHICommandListBase& RHICmdList, const FBoxSphereBounds& InBounds, const FBoxSphereBounds& InLocalBounds, const FBoxSphereBounds& InStaticMeshBounds) final;
    ENGINE_API virtual void UpdateInstances_RenderThread(FRHICommandListBase& RHICmdList, const FBoxSphereBounds& InBounds, const FBoxSphereBounds& InLocalBounds);
 
    void SetSelection_RenderThread(const bool bInParentSelected, const bool bInIndividuallySelected);
 
    void SetLevelInstanceEditingState_RenderThread(const bool bInLevelInstanceEditingState);
 
    void SetHovered_RenderThread(const bool bInHovered);
 
    virtual void OnEvaluateWorldPositionOffsetChanged_RenderThread() {}
 
    ENGINE_API FRenderBounds PadInstanceLocalBounds(const FRenderBounds& InBounds);
};
 
ENGINE_API extern bool SupportsCachingMeshDrawCommands(const FMeshBatch& MeshBatch);
 
ENGINE_API extern bool SupportsCachingMeshDrawCommands(const FMeshBatch& MeshBatch, ERHIFeatureLevel::Type FeatureLevel);
 
ENGINE_API extern bool SupportsNaniteRendering(const FVertexFactory* RESTRICT VertexFactory, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy);
 
ENGINE_API extern bool SupportsNaniteRendering(const FVertexFactory* RESTRICT VertexFactory, const FPrimitiveSceneProxy* RESTRICT PrimitiveSceneProxy, const class FMaterialRenderProxy* MaterialRenderProxy, ERHIFeatureLevel::Type FeatureLevel);
 
ENGINE_API extern bool SupportsNaniteRendering(const class FVertexFactoryType* RESTRICT VertexFactoryType, const class FMaterial& Material, ERHIFeatureLevel::Type FeatureLevel);
 
// Whether scene proxies will have GetDynamicMeshElements called in parallel.
ENGINE_API bool IsParallelGatherDynamicMeshElementsEnabled();
 
// Whether scene proxies will have GetDynamicRayTracingInstances called in parallel.
ENGINE_API bool IsParallelGatherDynamicRayTracingInstancesEnabled();
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "SceneView.h"
#endif