StaticMeshSceneProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    StaticMesh.h: Static mesh class definition.
=============================================================================*/
 
#pragma once
 
#include "Components/StaticMeshComponent.h"
#include "PrimitiveSceneProxy.h"
#include "RayTracingInstance.h"
#include "SceneManagement.h"
#include "RayTracingGeometry.h"
 
class FLocalVertexFactoryUniformShaderParameters;
class FRawStaticIndexBuffer;
struct FAdditionalStaticMeshIndexBuffers;
struct FStaticMeshSection;
struct FStaticMeshVertexFactories;
using FStaticMeshVertexFactoriesArray = TArray<FStaticMeshVertexFactories>;
struct FStaticMeshSceneProxyDesc;
class FTextureResource;
enum class EPSOPrecachePriority : uint8;
 
ENGINE_API EPSOPrecachePriority GetStaticMeshComponentBoostPSOPrecachePriority();
 
void GetStaticMeshRayTracingWPOConfig(bool& bOutHasRayTracingRepresentation, bool& bOutDynamicRayTracingGeometry);
bool ShouldStaticMeshEvaluateWPOInRayTracing(FVector ViewCenter, const FBoxSphereBounds& Bounds);
 
class FStaticMeshSceneProxy : public FPrimitiveSceneProxy
{
public:
    ENGINE_API SIZE_T GetTypeHash() const override;
 
    ENGINE_API FStaticMeshSceneProxy(UStaticMeshComponent* Component, bool bForceLODsShareStaticLighting);
 
    ENGINE_API FStaticMeshSceneProxy(const FStaticMeshSceneProxyDesc& InDesc, bool bForceLODsShareStaticLighting);
 
    ENGINE_API virtual ~FStaticMeshSceneProxy();
 
    virtual int32 GetNumMeshBatches() const
    {
        return 1;
    }
 
    ENGINE_API virtual bool GetShadowMeshElement(int32 LODIndex, int32 BatchIndex, uint8 InDepthPriorityGroup, FMeshBatch& OutMeshBatch, bool bDitheredLODTransition) const;
 
    ENGINE_API virtual bool GetMeshElement(
        int32 LODIndex, 
        int32 BatchIndex, 
        int32 SectionIndex,
        uint8 InDepthPriorityGroup, 
        bool bUseSelectionOutline,
        bool bAllowPreCulledIndices,
        FMeshBatch& OutMeshBatch) const;
 
    ENGINE_API virtual bool GetRayTracingMeshElement(int32 LODIndex, int32 BatchIndex, int32 SectionIndex, uint8 InDepthPriorityGroup, FMeshBatch& OutMeshBatch) const;
 
    ENGINE_API virtual void CreateRenderThreadResources(FRHICommandListBase& RHICmdList) override;
 
    ENGINE_API virtual void DestroyRenderThreadResources() override;
 
    ENGINE_API virtual bool GetWireframeMeshElement(int32 LODIndex, int32 BatchIndex, const FMaterialRenderProxy* WireframeRenderProxy, uint8 InDepthPriorityGroup, bool bAllowPreCulledIndices, FMeshBatch& OutMeshBatch) const;
 
    ENGINE_API virtual bool GetCollisionMeshElement(
        int32 LODIndex,
        int32 BatchIndex,
        int32 ElementIndex,
        uint8 InDepthPriorityGroup,
        const FMaterialRenderProxy* RenderProxy,
        FMeshBatch& OutMeshBatch) const;
 
    ENGINE_API virtual void SetEvaluateWorldPositionOffsetInRayTracing(FRHICommandListBase& RHICmdList, bool bEvaluate);
 
    virtual uint8 GetCurrentFirstLODIdx_RenderThread() const final override
    {
        return GetCurrentFirstLODIdx_Internal();
    }
 
    virtual FDesiredLODLevel GetDesiredLODLevel_RenderThread(const FSceneView* View) const final override
    {
        return FDesiredLODLevel::CreateFirst(GetCurrentFirstLODIdx_Internal());
    }
 
    ENGINE_API virtual int32 GetLightMapCoordinateIndex() const override;
 
    ENGINE_API virtual bool GetInstanceWorldPositionOffsetDisableDistance(float& OutWPODisableDistance) const override;
 
    ENGINE_API virtual void GetStreamableRenderAssetInfo(const FBoxSphereBounds& InPrimitiveBounds, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamableRenderAssets) const override;
 
    virtual bool CanApplyStreamableRenderAssetScaleFactor() const override { return true; }
 
protected:
    UE_DEPRECATED(5.6, "Provide FStaticMeshSection, IndexBuffer and AdditionalIndexBuffers instead of LODIndex, etc.")
    ENGINE_API uint32 SetMeshElementGeometrySource(
        int32 LODIndex,
        int32 ElementIndex,
        bool bWireframe,
        bool bUseInversedIndices,
        bool bAllowPreCulledIndices,
        const FVertexFactory* VertexFactory,
        FMeshBatch& OutMeshElement) const;
 
    ENGINE_API uint32 SetMeshElementGeometrySource(
        const FStaticMeshSection& Section,
        const FRawStaticIndexBuffer& IndexBuffer,
        const FAdditionalStaticMeshIndexBuffers* AdditionalIndexBuffers,
        const FVertexFactory* VertexFactory,
        bool bWireframe,
        bool bUseInversedIndices,
        FMeshBatch& OutMeshElement) const;
 
    ENGINE_API void SetMeshElementScreenSize(int32 LODIndex, bool bDitheredLODTransition, FMeshBatch& OutMeshBatch) const;
 
    ENGINE_API bool ShouldRenderBackFaces() const;
 
    ENGINE_API bool IsReversedCullingNeeded(bool bUseReversedIndices) const;
 
    ENGINE_API bool IsCollisionView(const FEngineShowFlags& EngineShowFlags, bool& bDrawSimpleCollision, bool& bDrawComplexCollision) const;
 
    ENGINE_API uint8 GetCurrentFirstLODIdx_Internal() const;
 
    ENGINE_API virtual void OnEvaluateWorldPositionOffsetChanged_RenderThread() override;
 
public:
    // FPrimitiveSceneProxy interface.
#if WITH_EDITOR
    ENGINE_API virtual HHitProxy* CreateHitProxies(UPrimitiveComponent* Component, TArray<TRefCountPtr<HHitProxy> >& OutHitProxies) override;
    ENGINE_API virtual HHitProxy* CreateHitProxies(IPrimitiveComponent* ComponentInterface, TArray<TRefCountPtr<HHitProxy> >& OutHitProxies) override;
#endif
    ENGINE_API virtual void DrawStaticElements(FStaticPrimitiveDrawInterface* PDI) override;
    ENGINE_API virtual int32 GetLOD(const FSceneView* View) const override;
    ENGINE_API virtual FPrimitiveViewRelevance GetViewRelevance(const FSceneView* View) const override;
    ENGINE_API virtual bool CanBeOccluded() const override;
    virtual bool AllowInstanceCullingOcclusionQueries() const override { return true; }
    ENGINE_API virtual bool IsUsingDistanceCullFade() const override;
    ENGINE_API virtual void GetLightRelevance(const FLightSceneProxy* LightSceneProxy, bool& bDynamic, bool& bRelevant, bool& bLightMapped, bool& bShadowMapped) const override;
    ENGINE_API virtual void GetDistanceFieldAtlasData(const FDistanceFieldVolumeData*& OutDistanceFieldData, float& SelfShadowBias) const override;
    ENGINE_API virtual bool HasDistanceFieldRepresentation() const override;
    ENGINE_API virtual bool StaticMeshHasPendingStreaming() const override;
    ENGINE_API virtual bool HasDynamicIndirectShadowCasterRepresentation() const override;
    virtual uint32 GetMemoryFootprint( void ) const override { return( sizeof( *this ) + GetAllocatedSize() ); }
    SIZE_T GetAllocatedSize( void ) const { return( FPrimitiveSceneProxy::GetAllocatedSize() + LODs.GetAllocatedSize() ); }
 
    ENGINE_API virtual void GetMeshDescription(int32 LODIndex, TArray<FMeshBatch>& OutMeshElements) const override;
 
    ENGINE_API virtual void GetDynamicMeshElements(const TArray<const FSceneView*>& Views, const FSceneViewFamily& ViewFamily, uint32 VisibilityMap, FMeshElementCollector& Collector) const override;
 
    ENGINE_API virtual const FCardRepresentationData* GetMeshCardRepresentation() const override;
 
    virtual bool IsCullingReversedByComponent() const override { return bReverseCulling; }
    
    virtual FUintVector2 GetMeshPaintTextureDescriptor() const override { return MeshPaintTextureDescriptor; }
 
#if RHI_RAYTRACING
    ENGINE_API virtual TArray<FRayTracingGeometry*> GetStaticRayTracingGeometries() const override;
    ENGINE_API virtual ERayTracingPrimitiveFlags GetCachedRayTracingInstance(FRayTracingInstance& OutRayTracingInstance);
    ENGINE_API virtual void GetDynamicRayTracingInstances(FRayTracingInstanceCollector& Collector) override;
    ENGINE_API virtual bool HasRayTracingRepresentation() const override;
    virtual bool IsRayTracingRelevant() const override { return true; }
    virtual bool IsRayTracingStaticRelevant() const override 
    { 
        const bool bAllowStaticLighting = IsStaticLightingAllowed();
        const bool bIsStaticInstance = !bDynamicRayTracingInstances && !bDynamicRayTracingGeometry;
        return bIsStaticInstance && !HasViewDependentDPG() && !(bAllowStaticLighting && HasStaticLighting() && !HasValidSettingsForStaticLighting());
    }
    ENGINE_API virtual RayTracing::FGeometryGroupHandle GetRayTracingGeometryGroupHandle() const override;
#endif // RHI_RAYTRACING
 
    ENGINE_API virtual void GetLCIs(FLCIArray& LCIs) override;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual bool GetPrimitiveDistance(int32 LODIndex, int32 SectionIndex, const FVector& ViewOrigin, float& PrimitiveDistance) const override;
    ENGINE_API virtual bool GetMeshUVDensities(int32 LODIndex, int32 SectionIndex, FVector4& WorldUVDensities) const override;
    ENGINE_API virtual bool GetMaterialTextureScales(int32 LODIndex, int32 SectionIndex, const FMaterialRenderProxy* MaterialRenderProxy, FVector4f* OneOverScales, FIntVector4* UVChannelIndices) const override;
#endif
 
#if STATICMESH_ENABLE_DEBUG_RENDERING
    virtual int32 GetLightMapResolution() const override { return LightMapResolution; }
#endif
 
protected:
    class FLODInfo : public FLightCacheInterface
    {
    public:
 
        struct FSectionInfo
        {
            UMaterialInterface* Material = nullptr;
 
        #if WITH_EDITOR
            bool bSelected = false;
 
            HHitProxy* HitProxy = nullptr;
        #endif
            
            // The material index from the component. Used by the texture streaming accuracy viewmodes.
            int32 MaterialIndex = 0;
            
            UMaterialInterface* OverlayMaterial = nullptr;
        };
 
        TArray<FSectionInfo, TInlineAllocator<1>> Sections;
 
        FColorVertexBuffer* OverrideColorVertexBuffer;
 
        TUniformBufferRef<FLocalVertexFactoryUniformShaderParameters> OverrideColorVFUniformBuffer;
 
        FLODInfo(const FStaticMeshSceneProxyDesc& InProxyDesc, const FStaticMeshVertexFactoriesArray& InLODVertexFactories, int32 InLODIndex, int32 InClampedMinLOD, bool bLODsShareStaticLighting);
 
        bool UsesMeshModifyingMaterials() const { return bUsesMeshModifyingMaterials; }
 
        // FLightCacheInterface.
        ENGINE_API virtual FLightInteraction GetInteraction(const FLightSceneProxy* LightSceneProxy) const override;
 
    private:
        TArray<FGuid> IrrelevantLights;
 
        bool bUsesMeshModifyingMaterials;
    };
 
    class FRayTracingLODInfo
    {
    public:
 
        struct FSectionInfo
        {
            UMaterialInterface* Material = nullptr;
        };
 
        TArray<FSectionInfo, TInlineAllocator<1>> Sections;
 
        // TODO: Support OverrideColorVertexBuffer (needs to be generated similar to what is done for regular LODs)
 
        FRayTracingLODInfo(const FStaticMeshSceneProxyDesc& InProxyDesc, int32 InLODIndex);
    };
 
    FStaticMeshRenderData* RenderData;
 
    TArray<FLODInfo> LODs;
    TArray<FRayTracingLODInfo> RayTracingLODInfos;
 
    const FDistanceFieldVolumeData* DistanceFieldData;  
    const FCardRepresentationData* CardRepresentationData;  
 
    UMaterialInterface* OverlayMaterial;
    float OverlayMaterialMaxDrawDistance;
    TArray<TObjectPtr<UMaterialInterface>> MaterialSlotsOverlayMaterial;
 
#if RHI_RAYTRACING
    ENGINE_API virtual void GetRayTracingWPOConfig(bool& bOutHasRayTracingRepresentation, bool& bOutDynamicRayTracingGeometry) const;
    ENGINE_API virtual bool ShouldEvaluateWPOInRayTracing(FVector ViewCenter) const;
 
    ENGINE_API void CreateDynamicRayTracingGeometries(FRHICommandListBase& RHICmdList);
    ENGINE_API void ReleaseDynamicRayTracingGeometries();
 
    bool bSupportRayTracing : 1;
    bool bHasRayTracingRepresentation : 1;
    bool bDynamicRayTracingInstances : 1;
    bool bDynamicRayTracingGeometry : 1;
    bool bCreateDynamicRayTracingGeometries : 1;
 
    TArray<FRayTracingGeometry, TInlineAllocator<MAX_MESH_LOD_COUNT>> DynamicRayTracingGeometries;
    TArray<FMeshBatch> CachedRayTracingMaterials;
    int16 CachedRayTracingMaterialsLODIndex = INDEX_NONE;
 
    RayTracing::FGeometryGroupHandle RayTracingGeometryGroupHandle = INDEX_NONE;
#endif
    int32 ForcedLodModel;
 
    int32 ClampedMinLOD;
 
    uint32 bCastShadow : 1;
 
    uint32 bReverseCulling : 1;
 
    uint32 MeshPaintTextureCoordinateIndex : 2;
 
    FMaterialRelevance MaterialRelevance;
 
    float WPODisableDistance;
 
#if WITH_EDITORONLY_DATA
    float StreamingDistanceMultiplier;
    float StreamingTransformScale;
    TArray<uint32> MaterialStreamingRelativeBoxes;
 
    int32 SectionIndexPreview;
    int32 MaterialIndexPreview;
 
    bool bPerSectionSelection;
#endif
 
private:
 
    const UStaticMesh* StaticMesh;
 
    FTextureResource* MeshPaintTextureResource = nullptr;
    FUintVector2 MeshPaintTextureDescriptor = FUintVector2(0, 0);
 
#if STATICMESH_ENABLE_DEBUG_RENDERING
    UObject* Owner;
    int32 LightMapResolution;
    UBodySetup* BodySetup;
    ECollisionTraceFlag     CollisionTraceFlag;
    FCollisionResponseContainer CollisionResponse;
    int32 LODForCollision;
    uint32 bDrawMeshCollisionIfComplex : 1;
    uint32 bDrawMeshCollisionIfSimple : 1;
 
protected:
    uint8 HierarchicalLODIndex;
#endif
 
public:
 
    ENGINE_API float GetScreenSize(int32 LODIndex) const;
 
    ENGINE_API FLODMask GetLODMask(const FSceneView* View) const;
 
private:
    ENGINE_API void AddSpeedTreeWind();
    ENGINE_API void RemoveSpeedTreeWind();
};