NaniteShared.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "SceneView.h"
#include "ShaderParameterMacros.h"
#include "GlobalShader.h"
#include "UnifiedBuffer.h"
#include "RenderGraphResources.h"
#include "RenderGraphUtils.h"
#include "Rendering/NaniteResources.h"
#include "NaniteFeedback.h"
#include "MaterialDomain.h"
#include "MaterialShaderType.h"
#include "MaterialShader.h"
#include "Misc/ScopeRWLock.h"
#include "Experimental/Containers/RobinHoodHashTable.h"
#include "LightMapRendering.h" // TODO: Remove with later refactor (moving Nanite shading into its own files)
#include "RenderUtils.h"
#include "PrimitiveViewRelevance.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogNanite, Warning, All);
 
DECLARE_GPU_STAT_NAMED_EXTERN(NaniteDebug, TEXT("Nanite Debug"));
 
struct FSceneTextures;
struct FDBufferTextures;
 
namespace Nanite
{
 
// Counterpart to FPackedNaniteView in NanitePackedNaniteView.ush
struct FPackedView
{
    FMatrix44f  SVPositionToTranslatedWorld;
    FMatrix44f  ViewToTranslatedWorld;
 
    FMatrix44f  TranslatedWorldToView;
    FMatrix44f  TranslatedWorldToClip;
    FMatrix44f  ViewToClip;
    FMatrix44f  ClipToRelativeWorld;
 
    FMatrix44f  PrevTranslatedWorldToView;
    FMatrix44f  PrevTranslatedWorldToClip;
    FMatrix44f  PrevViewToClip;
    FMatrix44f  PrevClipToRelativeWorld;
 
    FIntVector4 ViewRect;
    FVector4f   ViewSizeAndInvSize;
    FVector4f   ClipSpaceScaleOffset;
    FVector4f   MaterialCacheUnwrapMinAndInvSize;
    FVector4f   MaterialCachePageOffsetAndInvSize;
    FVector3f   PreViewTranslationHigh;
    float       ViewOriginHighX;
    FVector3f   PrevPreViewTranslationHigh;
    float       ViewOriginHighY;
    FVector3f   PrevPreViewTranslationLow;
    float       CullingViewMinRadiusTestFactorSq;
    FVector3f   ViewOriginLow;
    float       ViewOriginHighZ;
    FVector3f   CullingViewOriginTranslatedWorld;
    float       RangeBasedCullingDistance;
    FVector3f   ViewForward;
    float       NearPlane;
 
    FVector4f   TranslatedGlobalClipPlane;
 
    FVector3f   PreViewTranslationLow;
    float       CullingViewScreenMultipleSq;
 
    FVector2f   LODScales;
    uint32      InstanceOcclusionQueryMask;
    uint32      StreamingPriorityCategory_AndFlags;
 
    FIntVector4 TargetLayerIdX_AndMipLevelY_AndNumMipLevelsZ;
 
    FIntVector4 HZBTestViewRect;    // In full resolution
 
    FUintVector4    FirstPersonTransformRowsExceptRow2Z; // Packed into half floats
    FVector3f       PrevPreViewTranslationHZBHigh;
    uint32          FirstPersonTransformRow2Z;
    FVector3f       PrevPreViewTranslationHZBLow;
    uint32          PrevFirstPersonTransformRow2Z;
    FUintVector4    PrevFirstPersonTransformRowsExceptRow2Z; // Packed into half floats
    FVector2f       DynamicDepthCullRange;
    uint32          LightingChannelMask;
    int32           SceneRendererPrimaryViewId; // The primary view ID either refers to this view itself, OR it refers (in the case of a secondsry, shadow view mostly) to the relevant primary view.
 
    void UpdateLODScales(const float NaniteMaxPixelsPerEdge, const float MinPixelsPerEdgeHW);
};
 
class FPackedViewArray
{
public:
    using ArrayType = TArray<FPackedView, SceneRenderingAllocator>;
    using TaskLambdaType = TFunction<void(ArrayType&)>;
 
    static FPackedViewArray* Create(FRDGBuilder& GraphBuilder, const FPackedView& View);
 
    static FPackedViewArray* Create(FRDGBuilder& GraphBuilder, uint32 NumViews, ArrayType&& Views);
 
    static FPackedViewArray* CreateWithSetupTask(FRDGBuilder& GraphBuilder, uint32 NumViews, TaskLambdaType&& TaskLambda, UE::Tasks::FPipe* Pipe = nullptr, bool bExecuteInTask = true);
 
    const ArrayType& GetViews() const
    {
        SetupTask.Wait();
        check(Views.Num() == NumViews);
        return Views;
    }
 
    const uint32 NumViews;
 
    UE::Tasks::FTask GetSetupTask() const
    {
        return SetupTask;
    }
 
private:
    FPackedViewArray(uint32 InNumViews)
        : NumViews(InNumViews)
    {}
 
    // Packed views containing all expanded mips.
    ArrayType Views;
 
    // The task that is generating the Views data array, if any.
    mutable UE::Tasks::FTask SetupTask;
 
    RDG_FRIEND_ALLOCATOR_FRIEND(FPackedViewArray);
};
 
struct FPackedViewParams
{
    FViewMatrices ViewMatrices;
    FViewMatrices PrevViewMatrices;
    FIntRect ViewRect;
    FIntPoint RasterContextSize;
    uint32 StreamingPriorityCategory = 0;
    float MinBoundsRadius = 0.0f;
    float LODScaleFactor = 1.0f;
    float ViewLODDistanceFactor = 1.0f;
    uint32 Flags = NANITE_VIEW_FLAG_NEAR_CLIP;
 
    int32 TargetLayerIndex = INDEX_NONE;
    int32 PrevTargetLayerIndex = INDEX_NONE;
    int32 TargetMipLevel = 0;
    int32 TargetMipCount = 1;
 
    float RangeBasedCullingDistance = 0.0f; // not used unless the flag NANITE_VIEW_FLAG_DISTANCE_CULL is set
 
    FIntRect HZBTestViewRect = {0, 0, 0, 0};
 
    float MaxPixelsPerEdgeMultipler = 1.0f;
 
    bool bUseCullingViewOverrides = false;
    FVector CullingViewOrigin = FVector::ZeroVector;
    float CullingViewScreenMultipleSq = 0.0f;
    float CullingViewMinRadiusTestFactorSq = 0.0f;  // not used unless the flag NANITE_VIEW_MIN_SCREEN_RADIUS_CULL is set and support is compiled into the culling shader
 
    FPlane GlobalClippingPlane = {0.0f, 0.0f, 0.0f, 0.0f};
 
    // Identifies the bit in the GPUScene::InstanceVisibilityMaskBuffer associated with the current view.
    // Visibility mask buffer may be used if this is non-zero.
    uint32 InstanceOcclusionQueryMask = 0;
    uint32 LightingChannelMask = 0b111; // All channels are visible by default
    bool bUseLightingChannelMask = false;
    bool bUseCurrentPreTranslationForHZB = false;
 
    int32 SceneRendererPrimaryViewId = -1;
    // clip-space Far/Near extra culling range for dynamic geometry (for VSM)
    // discards geometry that fails the culling test See FBoxCull::Frustum
    // Defaults to (0.0f, FLT_MAX) which means no extra culling 
    FVector2f DynamicDepthCullRange = FVector2f(0.0f, FLT_MAX);
};
 
// Helper function to setup the overrides for a culling view. 
// This is used for shadow views that have an associated "main" view that drives distance/screensize elements of the culling.
void SetCullingViewOverrides(FViewInfo const* InCullingView, Nanite::FPackedViewParams& InOutParams);
 
FPackedView CreatePackedView(const FPackedViewParams& Params);
 
// Convenience function to pull relevant packed view parameters out of a FViewInfo
FPackedViewParams CreateViewParamsFromViewInfo
(
    const FViewInfo& View,
    FIntPoint RasterContextSize,
    uint32 Flags,
    uint32 StreamingPriorityCategory,
    float MinBoundsRadius,
    float MaxPixelsPerEdgeMultipler,
    const FIntRect* InHZBTestViewRect
);
 
// Convenience function to pull relevant packed view parameters out of a FViewInfo and create a packed view
FPackedView CreatePackedViewFromViewInfo(
    const FViewInfo& View,
    FIntPoint RasterContextSize,
    uint32 Flags,
    uint32 StreamingPriorityCategory = 0,
    float MinBoundsRadius = 0.0f,
    float MaxPixelsPerEdgeMultipler = 1.0f,
    const FIntRect* InHZBTestViewRect = nullptr,
    bool bUseCurrentPreTranslationForHZB = false
);
 
bool ShouldDrawSceneViewsInOneNanitePass(const FViewInfo& View);
 
struct FVisualizeResult
{
    FRDGTextureRef ModeOutput;
    FName ModeName;
    int32 ModeID;
    uint8 bCompositeScene : 1;
    uint8 bSkippedTile    : 1;
};
 
struct FBinningData
{
    uint32 BinCount = 0;
 
    FRDGBufferRef DataBuffer = nullptr;
    FRDGBufferRef MetaBuffer = nullptr;
    FRDGBufferRef IndirectArgs = nullptr;
};
 
/*
 * GPU side buffers containing Nanite resource data.
 */
class FGlobalResources : public FRenderResource
{
public:
    struct PassBuffers
    {
        // Used for statistics
        TRefCountPtr<FRDGPooledBuffer> StatsRasterizeArgsSWHWBuffer;
    };
 
    // Used for statistics
    uint32 StatsRenderFlags = 0;
    uint32 StatsDebugFlags = 0;
 
    const int32 MaxPickingBuffers = 4;
    int32 PickingBufferWriteIndex = 0;
    int32 PickingBufferNumPending = 0;
    TArray<TUniquePtr<FRHIGPUBufferReadback>> PickingBuffers;
 
    TRefCountPtr<FRDGPooledBuffer>  CandidateNodesBuffer;
    TRefCountPtr<FRDGPooledBuffer>  ClusterBatchesBuffer;
 
public:
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    virtual void ReleaseRHI() override;
 
    void Update(FRDGBuilder& GraphBuilder); // Called once per frame before any Nanite rendering has occurred.
 
    static uint32 GetMaxCandidateClusters();
    static uint32 GetMaxClusterBatches();
    static uint32 GetMaxVisibleClusters();
    static uint32 GetMaxNodes();
    static uint32 GetMaxCandidatePatches();
    static uint32 GetMaxVisiblePatches();
    static uint32 GetMaxVisibleAssemblyParts();
 
    static uint32 GetFixedFunctionBinMask();
 
    static bool UseExtendedClusterSize();
    static uint32 GetCandidateNodeSize(bool bPostPass);
    static uint32 GetCandidateClusterSize();
    static uint32 GetMaxVisibleClusterSize();
 
    inline PassBuffers& GetMainPassBuffers() { return MainPassBuffers; }
    inline PassBuffers& GetPostPassBuffers() { return PostPassBuffers; }
 
    TRefCountPtr<FRDGPooledBuffer>&  GetStatsBufferRef() { return StatsBuffer; }
    TRefCountPtr<FRDGPooledBuffer>&  GetShadingBinDataBufferRef() { return ShadingBinDataBuffer; }
    TRefCountPtr<IPooledRenderTarget>& GetFastClearTileVisRef() { return FastClearTileVis; }
 
#if !UE_BUILD_SHIPPING
    FFeedbackManager* GetFeedbackManager() { return FeedbackManager; }
#endif
private:
    PassBuffers MainPassBuffers;
    PassBuffers PostPassBuffers;
 
    // Used for statistics
    TRefCountPtr<FRDGPooledBuffer> StatsBuffer;
 
    // Used for visualizations
    TRefCountPtr<FRDGPooledBuffer> ShadingBinDataBuffer;
    TRefCountPtr<IPooledRenderTarget> FastClearTileVis;
 
#if !UE_BUILD_SHIPPING
    FFeedbackManager* FeedbackManager = nullptr;
#endif
};
 
extern TGlobalResource< FGlobalResources > GGlobalResources;
 
} // namespace Nanite
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FNaniteShadingUniformParameters, )
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer,      ClusterPageData)
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer,      VisibleClustersSWHW)
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer,      HierarchyBuffer)
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer,      AssemblyTransforms)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D<uint>,           ShadingMask)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D<UlongType>,      VisBuffer64)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D<UlongType>,      DbgBuffer64)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D<uint>,           DbgBuffer32)
 
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer,      ShadingBinData)
 
    // Multi view
    SHADER_PARAMETER(uint32,                                                MultiViewEnabled)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<uint>,                 MultiViewIndices)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<float4>,               MultiViewRectScaleOffsets)
    SHADER_PARAMETER_RDG_BUFFER_SRV(StructuredBuffer<FPackedNaniteView>,    InViews)
END_SHADER_PARAMETER_STRUCT()
 
extern TRDGUniformBufferRef<FNaniteShadingUniformParameters> CreateDebugNaniteShadingUniformBuffer(FRDGBuilder& GraphBuilder);
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FNaniteRasterUniformParameters, )
    SHADER_PARAMETER(FIntVector4,   PageConstants)
    SHADER_PARAMETER(uint32,        MaxNodes)
    SHADER_PARAMETER(uint32,        MaxVisibleClusters)
    SHADER_PARAMETER(uint32,        MaxCandidatePatches)
    SHADER_PARAMETER(uint32,        MaxPatchesPerGroup)
    SHADER_PARAMETER(uint32,        MeshPass)
    SHADER_PARAMETER(float,         InvDiceRate)
    SHADER_PARAMETER(uint32,        RenderFlags)
    SHADER_PARAMETER(uint32,        DebugFlags)
END_SHADER_PARAMETER_STRUCT()
 
extern TRDGUniformBufferRef<FNaniteRasterUniformParameters> CreateDebugNaniteRasterUniformBuffer(FRDGBuilder& GraphBuilder);
 
BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FNaniteRayTracingUniformParameters, RENDERER_API)
    SHADER_PARAMETER(FIntVector4,   PageConstants)
    SHADER_PARAMETER(uint32,        MaxNodes)
 
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer, ClusterPageData)
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer, HierarchyBuffer)
    SHADER_PARAMETER_RDG_BUFFER_SRV(ByteAddressBuffer, RayTracingDataBuffer)
 
END_SHADER_PARAMETER_STRUCT()
 
class FNaniteGlobalShader : public FGlobalShader
{
public:
    FNaniteGlobalShader() = default;
    FNaniteGlobalShader(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
    : FGlobalShader(Initializer)
    {
    }
    
    static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters)
    {
        return DoesPlatformSupportNanite(Parameters.Platform);
    }
 
    static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
        
        OutEnvironment.SetDefine(TEXT("VF_SUPPORTS_PRIMITIVE_SCENE_DATA"), 1);
 
        // Use the spline mesh texture when possible for performance
        OutEnvironment.SetDefine(TEXT("USE_SPLINE_MESH_SCENE_RESOURCES"), UseSplineMeshSceneResources(Parameters.Platform));
 
        // Force shader model 6.0+
        OutEnvironment.CompilerFlags.Add(CFLAG_ForceDXC);
        OutEnvironment.CompilerFlags.Add(CFLAG_HLSL2021);
        OutEnvironment.CompilerFlags.Add(CFLAG_WarningsAsErrors);
    }
};
 
class FNaniteMaterialShader : public FMaterialShader
{
public:
    FNaniteMaterialShader() = default;
    FNaniteMaterialShader(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
    : FMaterialShader(Initializer)
    {
    }
 
    static bool IsVertexProgrammable(const FMaterialShaderParameters& MaterialParameters, bool bHWRasterShader)
    {
        const bool bPixelProgrammable = IsPixelProgrammable(MaterialParameters);
        const bool bHasVertexUVs = bPixelProgrammable && (MaterialParameters.bHasVertexInterpolator || MaterialParameters.NumCustomizedUVs > 0);
        const bool bHasTessellation = (!bHWRasterShader && MaterialParameters.bIsTessellationEnabled);
        return MaterialParameters.bHasVertexPositionOffsetConnected || bHasVertexUVs || bHasTessellation || MaterialParameters.bHasMaterialCacheOutput || MaterialParameters.bHasFirstPersonInterpolation;
    }
 
    static bool IsVertexProgrammable(uint32 MaterialBitFlags)
    {
        return (MaterialBitFlags & NANITE_MATERIAL_VERTEX_PROGRAMMABLE_FLAGS);
    }
 
    static bool IsPixelProgrammable(const FMaterialShaderParameters& MaterialParameters)
    {
        return MaterialParameters.bIsMasked || MaterialParameters.bHasPixelDepthOffsetConnected;
    }
 
    static bool IsPixelProgrammable(uint32 MaterialBitFlags)
    {
        return (MaterialBitFlags & NANITE_MATERIAL_PIXEL_PROGRAMMABLE_FLAGS);
    }
 
    static bool ShouldCompileProgrammablePermutation(
        const FMaterialShaderParameters& MaterialParameters,
        bool bPermutationVertexProgrammable,
        bool bPermutationPixelProgrammable,
        bool bHWRasterShader)
    {
        if (MaterialParameters.bIsDefaultMaterial)
        {
            return true;
        }
 
        // Custom materials should compile only the specific combination that is actually used
        // TODO: The status of material attributes on the FMaterialShaderParameters is determined without knowledge of any static
        // switches' values, and therefore when true could represent the set of materials that both enable them and do not. We could
        // isolate a narrower set of required shaders if FMaterialShaderParameters reflected the status after static switches are
        // applied.
        //return IsVertexProgrammable(MaterialParameters, bHWRasterShader) == bPermutationVertexProgrammable && 
        //      IsPixelProgrammable(MaterialParameters) == bPermutationPixelProgrammable;
        return  (IsVertexProgrammable(MaterialParameters, bHWRasterShader) || !bPermutationVertexProgrammable) &&
                (IsPixelProgrammable(MaterialParameters) || !bPermutationPixelProgrammable) &&
                (bPermutationVertexProgrammable || bPermutationPixelProgrammable);
    }
 
 
    static bool ShouldCompilePixelPermutation(const FMaterialShaderPermutationParameters& Parameters)
    {
        // Always compile default material as the fast opaque "fixed function" raster path
        bool bValidMaterial = Parameters.MaterialParameters.bIsDefaultMaterial;
 
        // Compile this pixel shader if it requires programmable raster
        if (Parameters.MaterialParameters.bIsUsedWithNanite && FNaniteMaterialShader::IsPixelProgrammable(Parameters.MaterialParameters))
        {
            bValidMaterial = true;
        }
 
        return
            DoesPlatformSupportNanite(Parameters.Platform) &&
            Parameters.MaterialParameters.MaterialDomain == MD_Surface &&
            bValidMaterial;
    }
    
    static bool ShouldCompileVertexPermutation(const FMaterialShaderPermutationParameters& Parameters)
    {
        // Always compile default material as the fast opaque "fixed function" raster path
        bool bValidMaterial = Parameters.MaterialParameters.bIsDefaultMaterial;
 
        // Compile this vertex shader if it requires programmable raster
        static const bool bHWRasterShader = true; // all vertex permutations are HWRaster
        if (Parameters.MaterialParameters.bIsUsedWithNanite &&
            FNaniteMaterialShader::IsVertexProgrammable(Parameters.MaterialParameters, bHWRasterShader))
        {
            bValidMaterial = true;
        }
 
        return
            DoesPlatformSupportNanite(Parameters.Platform) &&
            Parameters.MaterialParameters.MaterialDomain == MD_Surface &&
            bValidMaterial;
    }
    
    static bool ShouldCompileComputePermutation(const FMaterialShaderPermutationParameters& Parameters)
    {
        // Always compile default material as the fast opaque "fixed function" raster path
        bool bValidMaterial = Parameters.MaterialParameters.bIsDefaultMaterial;
 
        // Compile this compute shader if it requires programmable raster
        static const bool bHWRasterShader = false; // all compute permutations are SWRaster
        if (Parameters.MaterialParameters.bIsUsedWithNanite &&
            (IsVertexProgrammable(Parameters.MaterialParameters, bHWRasterShader) || IsPixelProgrammable(Parameters.MaterialParameters)))
        {
            bValidMaterial = true;
        }
 
        return
            DoesPlatformSupportNanite(Parameters.Platform) &&
            Parameters.MaterialParameters.MaterialDomain == MD_Surface &&
            bValidMaterial;
    }
 
    static void ModifyCompilationEnvironment(const FMaterialShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment)
    {
        FMaterialShader::ModifyCompilationEnvironment(Parameters, OutEnvironment);
 
        // Force shader model 6.0+
        OutEnvironment.CompilerFlags.Add(CFLAG_ForceDXC);
        OutEnvironment.CompilerFlags.Add(CFLAG_HLSL2021);
        OutEnvironment.CompilerFlags.Add(CFLAG_ShaderBundle);
        OutEnvironment.CompilerFlags.Add(CFLAG_RootConstants);
        OutEnvironment.CompilerFlags.Add(CFLAG_SupportsMinimalBindless);
 
        OutEnvironment.SetDefine(TEXT("VF_SUPPORTS_PRIMITIVE_SCENE_DATA"), 1);
        OutEnvironment.SetDefine(TEXT("NANITE_MATERIAL_SHADER"), 1);
 
        OutEnvironment.SetDefine(TEXT("IS_NANITE_RASTER_PASS"), 1);
        OutEnvironment.SetDefine(TEXT("IS_NANITE_PASS"), 1);
 
        OutEnvironment.SetDefine(TEXT("NANITE_USE_SHADING_UNIFORM_BUFFER"), 0);
        OutEnvironment.SetDefine(TEXT("NANITE_USE_RASTER_UNIFORM_BUFFER"), 1);
        OutEnvironment.SetDefine(TEXT("NANITE_USE_VIEW_UNIFORM_BUFFER"), 0);
 
        // Force definitions of GetObjectWorldPosition(), etc..
        OutEnvironment.SetDefine(TEXT("HAS_PRIMITIVE_UNIFORM_BUFFER"), 1);
 
        OutEnvironment.SetDefine(TEXT("ALWAYS_EVALUATE_WORLD_POSITION_OFFSET"),
            Parameters.MaterialParameters.bAlwaysEvaluateWorldPositionOffset ? 1 : 0);
        
        // Use the spline mesh texture when possible for performance
        OutEnvironment.SetDefine(TEXT("USE_SPLINE_MESH_SCENE_RESOURCES"), UseSplineMeshSceneResources(Parameters.Platform));
    }
};
 
class FMaterialRenderProxy;
 
class FHWRasterizePS;
class FHWRasterizeVS;
class FHWRasterizeMS;
class FMicropolyRasterizeCS;
 
struct FNaniteRasterPipeline
{
    const FMaterialRenderProxy* RasterMaterial = nullptr;
 
    FDisplacementScaling DisplacementScaling;
    FDisplacementFadeRange DisplacementFadeRange;
 
    bool bIsTwoSided : 1 = false;
    bool bWPOEnabled : 1 = false;
    bool bDisplacementEnabled : 1 = false;
    bool bPerPixelEval : 1 = false;
    bool bSplineMesh : 1 = false;
    bool bSkinnedMesh : 1 = false;
    bool bVoxel : 1 = false;
    bool bHasWPODistance : 1 = false;
    bool bHasPixelDistance : 1 = false;
    bool bHasDisplacementFadeOut : 1 = false;
    bool bFixedDisplacementFallback : 1 = false;
    bool bCastShadow : 1 = false;
    bool bVertexUVs : 1 = false;
    bool bFirstPersonLerp : 1 = false;
 
    static FNaniteRasterPipeline GetFixedFunctionPipeline(uint8 BinMask);
 
    uint32 GetPipelineHash() const;
    bool GetFallbackPipeline(FNaniteRasterPipeline& OutFallback) const;
 
    FORCENOINLINE friend uint32 GetTypeHash(const FNaniteRasterPipeline& Other)
    {
        return Other.GetPipelineHash();
    }
};
 
struct FNaniteRasterBin
{
    int32  BinId = INDEX_NONE;
    uint16 BinIndex = 0xFFFFu;
 
    inline bool operator==(const FNaniteRasterBin& Other) const
    {
        return Other.BinId == BinId && Other.BinIndex == BinIndex;
    }
    
    inline bool operator!=(const FNaniteRasterBin& Other) const
    {
        return !(*this == Other);
    }
 
    inline bool IsValid() const
    {
        return *this != FNaniteRasterBin();
    }
};
 
struct FNaniteRasterMaterialCacheKey
{
    union
    {
        struct
        {
            uint32 FeatureLevel                 : 3;
            uint32 bWPOEnabled                  : 1;
            uint32 bPerPixelEval                : 1;
            uint32 bUseMeshShader               : 1;
            uint32 bUsePrimitiveShader          : 1;
            uint32 bDisplacementEnabled         : 1;
            uint32 bVisualizeActive             : 1;
            uint32 bHasVirtualShadowMap         : 1;
            uint32 bIsDepthOnly                 : 1;
            uint32 bIsTwoSided                  : 1;
            uint32 bCastShadow                  : 1;
            uint32 bVoxel                       : 1;
            uint32 bSplineMesh                  : 1;
            uint32 bSkinnedMesh                 : 1;
            uint32 bFixedDisplacementFallback   : 1;
            uint32 bUseWorkGraphSW              : 1;
            uint32 bUseWorkGraphHW              : 1;
            uint32 Unused                       : 13;
        };
 
        uint32 Packed = 0;
    };
 
    bool operator < (FNaniteRasterMaterialCacheKey Other) const
    {
        return Packed < Other.Packed;
    }
 
    bool operator == (FNaniteRasterMaterialCacheKey Other) const
    {
        return Packed == Other.Packed;
    }
 
    bool operator != (FNaniteRasterMaterialCacheKey Other) const
    {
        return Packed != Other.Packed;
    }
};
 
static_assert((int32)ERHIFeatureLevel::Num <= 8);
static_assert(sizeof(FNaniteRasterMaterialCacheKey) == sizeof(uint32));
 
inline uint32 GetTypeHash(const FNaniteRasterMaterialCacheKey& Key)
{
    return Key.Packed;
}
 
struct FNaniteRasterMaterialCache
{
    const FMaterial* VertexMaterial = nullptr;
    const FMaterial* PixelMaterial = nullptr;
    const FMaterial* ComputeMaterial = nullptr;
    const FMaterialRenderProxy* VertexMaterialProxy = nullptr;
    const FMaterialRenderProxy* PixelMaterialProxy = nullptr;
    const FMaterialRenderProxy* ComputeMaterialProxy = nullptr;
 
    TShaderRef<FHWRasterizePS> RasterPixelShader;
    TShaderRef<FHWRasterizeVS> RasterVertexShader;
    TShaderRef<FHWRasterizeMS> RasterMeshShader;
    TShaderRef<FMicropolyRasterizeCS> ClusterComputeShader;
    TShaderRef<FMicropolyRasterizeCS> PatchComputeShader;
 
    TOptional<uint32> MaterialBitFlags;
    TOptional<FDisplacementScaling> DisplacementScaling;
    TOptional<FDisplacementFadeRange> DisplacementFadeRange;
 
    bool bFinalized = false;
};
 
struct FNaniteRasterEntry
{
    mutable TMap<FNaniteRasterMaterialCacheKey, FNaniteRasterMaterialCache> CacheMap;
 
    FNaniteRasterPipeline RasterPipeline{};
    uint32 ReferenceCount = 0;
    uint16 BinIndex = 0xFFFFu;
};
 
struct FNaniteRasterEntryKeyFuncs : TDefaultMapHashableKeyFuncs<FNaniteRasterPipeline, FNaniteRasterEntry, false>
{
    static inline bool Matches(KeyInitType A, KeyInitType B)
    {
        return A.GetPipelineHash() == B.GetPipelineHash() && A.RasterMaterial == B.RasterMaterial;
    }
 
    static inline uint32 GetKeyHash(KeyInitType Key)
    {
        return Key.GetPipelineHash();
    }
};
 
using FNaniteRasterPipelineMap = Experimental::TRobinHoodHashMap<FNaniteRasterPipeline, FNaniteRasterEntry, FNaniteRasterEntryKeyFuncs>;
 
class FNaniteRasterBinIndexTranslator
{
public:
    FNaniteRasterBinIndexTranslator() = default;
 
    uint16 Translate(uint16 BinIndex) const
    {
        return BinIndex < RegularBinCount ? BinIndex : RevertBinIndex(BinIndex) + RegularBinCount;
    }
 
private:
    friend class FNaniteRasterPipelines;
 
    uint32 RegularBinCount;
 
    FNaniteRasterBinIndexTranslator(uint32 InRegularBinCount)
        : RegularBinCount(InRegularBinCount)
    {}
 
    static uint16 RevertBinIndex(uint16 BinIndex)
    {
        return NANITE_INVALID_RASTER_BIN - BinIndex - 1;
    }
};
 
class FNaniteRasterPipelines
{
public:
    typedef Experimental::FHashType FRasterHash;
    typedef Experimental::FHashElementId FRasterId;
 
public:
    FNaniteRasterPipelines();
    ~FNaniteRasterPipelines();
 
    void AllocateFixedFunctionBins();
    void ReleaseFixedFunctionBins();
    void ReloadFixedFunctionBins();
 
    uint16 AllocateBin(bool bPerPixelEval);
    void ReleaseBin(uint16 BinIndex);
 
    bool IsBinAllocated(uint16 BinIndex) const;
 
    uint32 GetRegularBinCount() const;
    uint32 GetBinCount() const;
 
    FNaniteRasterBin Register(const FNaniteRasterPipeline& InRasterPipeline);
    void Unregister(const FNaniteRasterBin& InRasterBin);
 
    inline const FNaniteRasterPipelineMap& GetRasterPipelineMap() const
    {
        return PipelineMap;
    }
 
    inline FNaniteRasterBinIndexTranslator GetBinIndexTranslator() const
    {
        return FNaniteRasterBinIndexTranslator(GetRegularBinCount());
    }
 
    void RegisterBinForCustomPass(uint16 BinIndex);
    void UnregisterBinForCustomPass(uint16 BinIndex);
    bool ShouldBinRenderInCustomPass(uint16 BinIndex) const;
 
private:
    TBitArray<> PipelineBins;
    TBitArray<> PerPixelEvalPipelineBins;
    TArray<uint32> CustomPassRefCounts;
    TArray<uint32> PerPixelEvalCustomPassRefCounts;
    FNaniteRasterPipelineMap PipelineMap;
 
    struct FFixedFunctionBin
    {
        FNaniteRasterBin RasterBin;
        uint8 BinMask;
    };
 
    TArray<FFixedFunctionBin, TInlineAllocator<6u>> FixedFunctionBins;
};
 
struct FNaniteShadingBin
{
    int32  BinId = INDEX_NONE;
    uint16 BinIndex = 0xFFFFu;
 
    inline bool operator==(const FNaniteShadingBin& Other) const
    {
        return Other.BinId == BinId && Other.BinIndex == BinIndex;
    }
 
    inline bool operator!=(const FNaniteShadingBin& Other) const
    {
        return !(*this == Other);
    }
 
    inline bool IsValid() const
    {
        return *this != FNaniteShadingBin();
    }
};
 
struct FNaniteBasePassData;
struct FNaniteLumenCardData;
struct FNaniteMaterialCacheData;
class FMeshDrawShaderBindings;
 
struct FNaniteShadingPipeline
{
    TPimplPtr<FNaniteBasePassData, EPimplPtrMode::DeepCopy> BasePassData;
    TPimplPtr<FNaniteLumenCardData, EPimplPtrMode::DeepCopy> LumenCardData;
    TPimplPtr<FNaniteMaterialCacheData, EPimplPtrMode::DeepCopy> MaterialCacheData;
    TPimplPtr<FMeshDrawShaderBindings, EPimplPtrMode::DeepCopy> ShaderBindings;
 
    const FMaterialRenderProxy* MaterialProxy = nullptr;
    const FMaterial* Material = nullptr;
    FRHIComputeShader* ComputeShader = nullptr;
    FRHIWorkGraphShader* WorkGraphShader = nullptr;
 
#if WITH_DEBUG_VIEW_MODES
    uint32 InstructionCount = 0;
    uint32 LWCComplexity = 0;
#endif
 
    uint32 BoundTargetMask = 0u;
    uint32 ShaderBindingsHash = 0u;
    uint32 MaterialBitFlags = 0x0u;
 
    // Shading flags
    union
    {
        struct
        {
            uint16 bIsTwoSided : 1;
            uint16 bIsMasked : 1;
            uint16 bNoDerivativeOps : 1;
            uint16 bVoxel : 1;
            uint16 bPadding : 12;
        };
 
        uint16 ShadingFlagsHash = 0;
    };
 
    inline uint32 GetPipelineHash() const
    {
        // Ignoring the lower 4 bits since they are likely zero anyway.
        // Higher bits are more significant in 64 bit builds.
        uint64 PipelineHash = uint64(reinterpret_cast<UPTRINT>(MaterialProxy) >> 4);
 
        // Combine shader flags hash and material hash
        PipelineHash = CityHash128to64({ PipelineHash, ShadingFlagsHash });
 
        // Combine with bound target mask
        PipelineHash = CityHash128to64({ PipelineHash, BoundTargetMask });
 
        // Combine with shader bindings hash
        PipelineHash = CityHash128to64({ PipelineHash, ShaderBindingsHash });
 
        return HashCombineFast(uint32(PipelineHash & 0xFFFFFFFF), uint32((PipelineHash >> 32) & 0xFFFFFFFF));
    }
 
    FORCENOINLINE friend uint32 GetTypeHash(const FNaniteShadingPipeline& Other)
    {
        return Other.GetPipelineHash();
    }
};
 
struct FNaniteShadingEntry
{
    TSharedPtr<FNaniteShadingPipeline> ShadingPipeline;
    uint32 ReferenceCount = 0;
    uint16 BinIndex = 0xFFFFu;
};
 
struct FNaniteShadingEntryKeyFuncs : TDefaultMapHashableKeyFuncs<FNaniteShadingPipeline, FNaniteShadingEntry, false>
{
    static inline bool Matches(KeyInitType A, KeyInitType B)
    {
        return A.GetPipelineHash() == B.GetPipelineHash() && A.MaterialProxy == B.MaterialProxy;
    }
 
    static inline uint32 GetKeyHash(KeyInitType Key)
    {
        return Key.GetPipelineHash();
    }
};
 
using FNaniteShadingPipelineMap = Experimental::TRobinHoodHashMap<FNaniteShadingPipeline, FNaniteShadingEntry, FNaniteShadingEntryKeyFuncs>;
 
class FNaniteShadingPipelines
{
public:
    typedef Experimental::FHashType FShadingHash;
    typedef Experimental::FHashElementId FShadingId;
 
public:
    FNaniteShadingPipelines();
    ~FNaniteShadingPipelines();
 
    uint16 AllocateBin();
    void ReleaseBin(uint16 BinIndex);
 
    bool IsBinAllocated(uint16 BinIndex) const;
 
    uint32 GetBinCount() const;
 
    FNaniteShadingBin Register(const FNaniteShadingPipeline& InShadingPipeline);
    void Unregister(const FNaniteShadingBin& InShadingBin);
 
    inline const FNaniteShadingPipelineMap& GetShadingPipelineMap() const
    {
        return PipelineMap;
    }
 
    bool bBuildCommands = true;
 
    FPrimitiveViewRelevance CombinedRelevance;
 
    void BuildIdList();
    const TConstArrayView<const FShadingId> GetIdList() const;
 
    void ComputeRelevance(ERHIFeatureLevel::Type InFeatureLevel);
 
private:
    TBitArray<> PipelineBins;
    FNaniteShadingPipelineMap PipelineMap;
    TArray<FShadingId> ShadingIdList;
    bool bBuildIdList = true;
};
 
struct FNaniteShadingCommand
{
    TSharedPtr<FNaniteShadingPipeline> Pipeline;
    FUint32Vector4 PassData;
    uint16 ShadingBin = 0xFFFFu;
    bool bVisible = true;
 
    // The PSO precache state - updated at dispatch time and can be used to skip command when still precaching
    EPSOPrecacheResult PSOPrecacheState = EPSOPrecacheResult::Unknown;
};
 
struct FNaniteShadingCommands
{
    using FMetaBufferArray = TArray<FUintVector4, SceneRenderingAllocator>;
 
    uint32 MaxShadingBin = 0u;
    uint32 NumCommands = 0u;
    uint32 BoundTargetMask = 0x0u;
    FShaderBundleRHIRef ShaderBundle;
    TArray<FNaniteShadingCommand> Commands;
    TArray<int32> CommandLookup;
    FMetaBufferArray MetaBufferData;
 
    UE::Tasks::FTask SetupTask;
    UE::Tasks::FTask BuildCommandsTask;
};
 
extern bool ShouldRenderNanite(const FScene* Scene, const FViewInfo& View, bool bCheckForAtomicSupport = true);
 
extern bool WouldRenderNanite(const FScene* Scene, const FViewInfo& View, bool bCheckForAtomicSupport = true, bool bCheckForProjectSetting = true);
 
extern bool UseComputeDepthExport();