MeshBatch.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/ArrayView.h"
#include "EngineDefines.h"
#include "Engine/EngineTypes.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
// previously included by GPUSceneWriter.h
#include "ShaderParameterMacros.h"
#include "ShaderParameters.h"
#endif
#include "HitProxies.h"
#include "RHIDefinitions.h"
#include "SceneDefinitions.h"
#include "VT/RuntimeVirtualTextureEnum.h"
#include "RHIResources.h"
 
 
#define USE_MESH_BATCH_VALIDATION !UE_BUILD_SHIPPING
 
class FIndexBuffer;
class FLightCacheInterface;
class FMaterial;
class FMaterialRenderProxy;
class FPrimitiveSceneProxy;
class FPrimitiveUniformShaderParameters;
class FVertexFactory;
struct FInstanceDynamicData;
struct FInstanceSceneData;
struct FMaterialShaderParameters;
struct FRenderBounds;
template<typename TBufferStruct> class TUniformBuffer;
class FShaderParametersMetadata;
class FGPUSceneWriteDelegate;
 
class FGPUSceneWriteDelegateRef
{
public:
    inline bool IsBound() const { return GPUSceneWriteDelegate != nullptr; }
 
    inline FGPUSceneWriteDelegate* operator->() const
    {
        check( IsBound() );
        return GPUSceneWriteDelegate;
    }
 
private:
    friend class FGPUSceneWriteDelegate;
    FGPUSceneWriteDelegate* GPUSceneWriteDelegate = nullptr;
};
 
enum class EGPUSceneGPUWritePass : int8
{
    None = -1,
 
    PostOpaqueRendering,
 
    Num
};
 
enum EPrimitiveIdMode
{
    PrimID_FromPrimitiveSceneInfo       = 0,
 
    PrimID_DynamicPrimitiveShaderData   = 1,
 
    PrimID_ForceZero                    = 2,
 
    PrimID_Num                          = 4,
    PrimID_NumBits                      = 2,
};
 
// Flag used to mark a primtive ID as dynamic, and thus needing translation (by adding the offset from the dynamic primitive collector).
inline constexpr int32 GPrimIDDynamicFlag = 1 << 31;
 
struct FMeshBatchElementDynamicIndexBuffer
{
    FIndexBuffer* IndexBuffer = nullptr;
    uint32 FirstIndex : 24;
    uint32 PrimitiveType : PT_NumBits;
 
    inline bool IsValid() const
    {
        return IndexBuffer != NULL;
    }
};
 
ENGINE_API bool AreCompressedTransformsSupported();
 
struct FMeshBatchDynamicPrimitiveData
{
    TConstArrayView<FInstanceSceneData> InstanceSceneData;
    TConstArrayView<FInstanceDynamicData> InstanceDynamicData;
    TConstArrayView<FRenderBounds> InstanceLocalBounds;
    TConstArrayView<float> InstanceCustomData;
    FGPUSceneWriteDelegateRef DataWriterGPU;        
    EGPUSceneGPUWritePass DataWriterGPUPass = EGPUSceneGPUWritePass::None;
    uint16 PayloadDataFlags = 0;
    uint32 NumInstanceCustomDataFloats = 0;
 
    inline void SetPayloadDataFlags(uint16 Flags, bool bValue)
    {
        if (bValue)
        {
            PayloadDataFlags |= Flags;
        }
        else
        {
            PayloadDataFlags &= ~Flags;
        }
    }
    
    inline void EnableInstanceDynamicData(bool bEnable)  { SetPayloadDataFlags(INSTANCE_SCENE_DATA_FLAG_HAS_DYNAMIC_DATA, bEnable); }
    inline void EnableInstanceSkinningData(bool bEnable) { SetPayloadDataFlags(INSTANCE_SCENE_DATA_FLAG_HAS_SKINNING_DATA, bEnable); }
    inline void EnableInstanceLocalBounds(bool bEnable)  { SetPayloadDataFlags(INSTANCE_SCENE_DATA_FLAG_HAS_LOCAL_BOUNDS, bEnable); }
    inline void SetNumInstanceCustomDataFloats(uint32 NumFloats)
    {
        SetPayloadDataFlags(INSTANCE_SCENE_DATA_FLAG_HAS_CUSTOM_DATA, NumFloats > 0);
        NumInstanceCustomDataFloats = NumFloats;
    }
 
    inline uint32 GetPayloadFloat4Stride() const
    {
        uint32 Total = 0;
        
        if (PayloadDataFlags & INSTANCE_SCENE_DATA_FLAG_HAS_LOCAL_BOUNDS)
        {
            Total += 2;
        }
        else if (PayloadDataFlags & (INSTANCE_SCENE_DATA_FLAG_HAS_HIERARCHY_OFFSET | INSTANCE_SCENE_DATA_FLAG_HAS_SKINNING_DATA))
        {
            Total += 1;
        }
 
        if (PayloadDataFlags & INSTANCE_SCENE_DATA_FLAG_HAS_DYNAMIC_DATA)
        {
            if (AreCompressedTransformsSupported())
            {
                Total += 2;
            }
            else
            {
                Total += 3;
            }
        }
 
        if (PayloadDataFlags & INSTANCE_SCENE_DATA_FLAG_HAS_EDITOR_DATA)
        {
            Total += 1;
        }
 
        if (PayloadDataFlags & INSTANCE_SCENE_DATA_FLAG_HAS_LIGHTSHADOW_UV_BIAS)
        {
            Total += 1;
        }
        
        if (PayloadDataFlags & INSTANCE_SCENE_DATA_FLAG_HAS_CUSTOM_DATA)
        {
            Total += FMath::DivideAndRoundUp(NumInstanceCustomDataFloats, 4u);
        }
 
        return Total;
    }
 
    inline void Validate(uint32 NumInstances) const
    {
#if DO_CHECK
        // Ensure array views are sized exactly for all instances, or are empty and there is a GPU writer
        const bool bGPUWrite = DataWriterGPU.IsBound();
        checkf(uint32(InstanceSceneData.Num()) == NumInstances || (bGPUWrite && InstanceSceneData.Num() == 0),
            TEXT("DynamicPrimitiveData provided should have %u instances in InstanceSceneData. Found %d"),
            NumInstances, InstanceSceneData.Num());
        if (PayloadDataFlags & INSTANCE_SCENE_DATA_FLAG_HAS_DYNAMIC_DATA)
        {
            checkf(uint32(InstanceDynamicData.Num()) == NumInstances || (bGPUWrite && InstanceDynamicData.Num() == 0),
                TEXT("DynamicPrimitiveData provided should have %u elements in InstanceDynamicData. Found %d"),
                NumInstances, InstanceDynamicData.Num());
        }
        if (PayloadDataFlags & INSTANCE_SCENE_DATA_FLAG_HAS_CUSTOM_DATA)
        {
            checkf(NumInstanceCustomDataFloats > 0,
                TEXT("DynamicPrimitiveData provided has the custom data flag set, but NumInstanceCustomDataFloats == 0"));
            checkf(uint32(InstanceCustomData.Num()) == NumInstances * NumInstanceCustomDataFloats || (bGPUWrite && InstanceCustomData.Num() == 0),
                TEXT("DynamicPrimitiveData provided should have %u elements in InstanceCustomData. Found %d"),
                NumInstances * NumInstanceCustomDataFloats, InstanceCustomData.Num());
        }
#endif
    }
};
 
struct FMeshBatchElement
{
    FRHIUniformBuffer* PrimitiveUniformBuffer;
 
    const TUniformBuffer<FPrimitiveUniformShaderParameters>* PrimitiveUniformBufferResource;
 
    FUniformBufferRHIRef LooseParametersUniformBuffer;
 
    const FIndexBuffer* IndexBuffer;
 
    FMeshBatchElementDynamicIndexBuffer DynamicIndexBuffer;
 
    union 
    {
        uint32* InstanceRuns;
        const class FSplineMeshSceneProxy* SplineMeshSceneProxy;
    };
    const void* UserData;
 
    // Meaning depends on the vertex factory, e.g. FGPUSkinPassthroughVertexFactory: element index in FGPUSkinCache::CachedElements
    void* VertexFactoryUserData;
 
    FRHIBuffer* IndirectArgsBuffer;
    uint32 IndirectArgsOffset;
 
    EPrimitiveIdMode PrimitiveIdMode : PrimID_NumBits + 1;
 
    uint32 FirstIndex;
    uint32 NumPrimitives;
 
    uint32 NumInstances;
    uint32 BaseVertexIndex;
    uint32 MinVertexIndex;
    uint32 MaxVertexIndex;
    int32 UserIndex;
    float MinScreenSize;
    float MaxScreenSize;
 
    uint32 InstancedLODIndex : 4;
    uint32 InstancedLODRange : 4;
    uint32 bUserDataIsColorVertexBuffer : 1;
    uint32 bIsSplineProxy : 1;
    uint32 bIsInstanceRuns : 1;
    uint32 bForceInstanceCulling : 1;
    uint32 bPreserveInstanceOrder : 1;
    uint32 bFetchInstanceCountFromScene : 1;
 
#if UE_ENABLE_DEBUG_DRAWING
    int32 VisualizeElementIndex : 8;
    FColor SkinCacheDebugColor = FColor::White;
#endif
 
    const FMeshBatchDynamicPrimitiveData* DynamicPrimitiveData;
    uint32 DynamicPrimitiveIndex;
    uint32 DynamicPrimitiveInstanceSceneDataOffset;
 
    inline int32 GetNumPrimitives() const
    {
        if (bIsInstanceRuns && InstanceRuns)
        {
            int32 Count = 0;
            for (uint32 Run = 0; Run < NumInstances; Run++)
            {
                Count += NumPrimitives * (InstanceRuns[Run * 2 + 1] - InstanceRuns[Run * 2] + 1);
            }
            return Count;
        }
        else
        {
            return NumPrimitives * NumInstances;
        }
    }
 
    FMeshBatchElement()
    :   PrimitiveUniformBuffer(nullptr)
    ,   PrimitiveUniformBufferResource(nullptr)
    ,   IndexBuffer(nullptr)
    ,   InstanceRuns(nullptr)
    ,   UserData(nullptr)
    ,   VertexFactoryUserData(nullptr)
    ,   IndirectArgsBuffer(nullptr)
    ,   IndirectArgsOffset(0)
    ,   PrimitiveIdMode(PrimID_FromPrimitiveSceneInfo)
    ,   NumInstances(1)
    ,   BaseVertexIndex(0)
    ,   UserIndex(-1)
    ,   MinScreenSize(0.0f)
    ,   MaxScreenSize(1.0f)
    ,   InstancedLODIndex(0)
    ,   InstancedLODRange(0)
    ,   bUserDataIsColorVertexBuffer(false)
    ,   bIsSplineProxy(false)
    ,   bIsInstanceRuns(false)
    ,   bForceInstanceCulling(false)
    ,   bPreserveInstanceOrder(false)
    ,   bFetchInstanceCountFromScene(false)
#if UE_ENABLE_DEBUG_DRAWING
    ,   VisualizeElementIndex(INDEX_NONE)
#endif
    ,   DynamicPrimitiveData(nullptr)
    ,   DynamicPrimitiveIndex(INDEX_NONE)
    ,   DynamicPrimitiveInstanceSceneDataOffset(INDEX_NONE)
    {
    }
};
 
// Helper functions for hair strands shaders
ENGINE_API bool IsHairStrandsGeometrySupported(const EShaderPlatform Platform);
ENGINE_API bool IsCompatibleWithHairStrands(const FMaterial* Material, const ERHIFeatureLevel::Type FeatureLevel);
ENGINE_API bool IsCompatibleWithHairStrands(EShaderPlatform Platform, const FMaterialShaderParameters& Parameters);
 
struct FMeshBatch
{
    TArray<FMeshBatchElement,TInlineAllocator<1> > Elements;
 
    const FVertexFactory* VertexFactory;
 
    const FMaterialRenderProxy* MaterialRenderProxy;
 
    // can be NULL
    const FLightCacheInterface* LCI;
 
    FHitProxyId BatchHitProxyId;
 
    int32 DynamicMeshBoundsIndex = INDEX_NONE;
 
    UE_DEPRECATED(5.6, "This is not used by the renderer.")
    float TessellationDisablingShadowMapMeshSize;
 
    int32 SegmentIndex;
 
    /* Mesh Id in a primitive. Used for stable sorting of draws belonging to the same primitive. **/
    uint16 MeshIdInPrimitive;
 
    int8 LODIndex;
 
    uint32 ReverseCulling : 1;
    uint32 bDisableBackfaceCulling : 1;
 
    uint32 CastShadow       : 1;    // Whether it can be used in shadow renderpasses.
    uint32 bUseForMaterial  : 1;    // Whether it can be used in renderpasses requiring material outputs.
    uint32 bUseForDepthPass : 1;    // Whether it can be used in depth pass.
    uint32 bUseAsOccluder   : 1;    // Hint whether this mesh is a good occluder.
    uint32 bWireframe       : 1;
    // e.g. PT_TriangleList(default), PT_LineList, ..
    uint32 Type : PT_NumBits;
    // e.g. SDPG_World (default), SDPG_Foreground
    uint32 DepthPriorityGroup : SDPG_NumBits;
 
    uint32 bCanApplyViewModeOverrides : 1;
 
    uint32 bUseWireframeSelectionColoring : 1;
 
    uint32 bUseSelectionOutline : 1;
 
    uint32 bSelectable : 1;
    
    uint32 bDitheredLODTransition : 1;
 
    uint32 bRenderToVirtualTexture : 1;
    uint32 RuntimeVirtualTextureMaterialType : RuntimeVirtualTexture::MaterialType_NumBits;
    
    uint32 bOverlayMaterial : 1;
 
#if RHI_RAYTRACING
    uint32 CastRayTracedShadow : 1; // Whether it casts ray traced shadow.
    uint32 bForceTwoSidedInRayTracing : 1;  // Whether segment should be considered two sided in ray tracing regardless of material.
#endif
 
    uint32 bViewDependentArguments : 1;
 
    uint32 bUseForWaterInfoTextureDepth : 1;
    
    uint32 bUseForLumenSurfaceCacheCapture : 1;
 
#if UE_ENABLE_DEBUG_DRAWING
    int8 VisualizeHLODIndex;
 
    int8 VisualizeLODIndex;
#endif
 
    ENGINE_API bool IsTranslucent(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    // todo: can be optimized with a single function that returns multiple states (Translucent, Decal, Masked) 
    ENGINE_API bool IsDecal(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    ENGINE_API bool IsDualBlend(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    ENGINE_API bool UseForHairStrands(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    ENGINE_API bool IsMasked(ERHIFeatureLevel::Type InFeatureLevel) const;
 
    inline int32 GetNumPrimitives() const
    {
        int32 Count = 0;
        for (int32 ElementIdx = 0; ElementIdx < Elements.Num(); ++ElementIdx)
        {
            Count += Elements[ElementIdx].GetNumPrimitives();
        }
        return Count;
    }
 
    inline bool HasAnyDrawCalls() const
    {
        for (int32 ElementIdx = 0; ElementIdx < Elements.Num(); ++ElementIdx)
        {
            if (Elements[ElementIdx].GetNumPrimitives() > 0 || Elements[ElementIdx].IndirectArgsBuffer || Elements[ElementIdx].bFetchInstanceCountFromScene)
            {
                return true;
            }
        }
        return false;
    }
 
    ENGINE_API void PreparePrimitiveUniformBuffer(const FPrimitiveSceneProxy* PrimitiveSceneProxy, ERHIFeatureLevel::Type FeatureLevel);
 
#if USE_MESH_BATCH_VALIDATION
    ENGINE_API bool Validate(const FPrimitiveSceneProxy* SceneProxy, ERHIFeatureLevel::Type FeatureLevel) const;
#else
    inline bool Validate(const FPrimitiveSceneProxy* SceneProxy, ERHIFeatureLevel::Type FeatureLevel) const { return true; }
#endif
 
    // Disable deprecation warnings for TessellationDisablingShadowMapMeshSize.
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
 
    FMeshBatch()
    :   VertexFactory(nullptr)
    ,   MaterialRenderProxy(nullptr)
    ,   LCI(nullptr)
    ,   TessellationDisablingShadowMapMeshSize(0.0f)
    ,   SegmentIndex(INDEX_NONE)
    ,   MeshIdInPrimitive(0)
    ,   LODIndex(INDEX_NONE)
    ,   ReverseCulling(false)
    ,   bDisableBackfaceCulling(false)
    ,   CastShadow(true)
    ,   bUseForMaterial(true)
    ,   bUseForDepthPass(true)
    ,   bUseAsOccluder(true)
    ,   bWireframe(false)
    ,   Type(PT_TriangleList)
    ,   DepthPriorityGroup(SDPG_World)
    ,   bCanApplyViewModeOverrides(false)
    ,   bUseWireframeSelectionColoring(false)
    ,   bUseSelectionOutline(true)
    ,   bSelectable(true)
    ,   bDitheredLODTransition(false)
    ,   bRenderToVirtualTexture(false)
    ,   RuntimeVirtualTextureMaterialType(0)
    ,   bOverlayMaterial(false)
#if RHI_RAYTRACING
    ,   CastRayTracedShadow(true)
    ,   bForceTwoSidedInRayTracing(false)
#endif
    ,   bViewDependentArguments(false)
    ,   bUseForWaterInfoTextureDepth(false)
    ,   bUseForLumenSurfaceCacheCapture(false)
#if (!(UE_BUILD_SHIPPING || UE_BUILD_TEST) || WITH_EDITOR)
    ,   VisualizeHLODIndex(INDEX_NONE)
#endif
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    ,   VisualizeLODIndex(INDEX_NONE)
#endif
    {
        // By default always add the first element.
        Elements.AddDefaulted();
    }
 
    // Need to do these explicitly as clang otherwise produces deprecation warnings for the _implicit_ ctors & operators
    FMeshBatch(FMeshBatch&) = default;
    ~FMeshBatch() = default;
    FMeshBatch(const FMeshBatch&) = default;
    FMeshBatch(FMeshBatch&&) = default;
    FMeshBatch& operator=(const FMeshBatch&) = default;
    FMeshBatch& operator=(FMeshBatch&&) = default;
 
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
};
 
struct FUniformBufferValue
{
    const FShaderParametersMetadata* Type = nullptr;
    FRHIUniformBuffer* UniformBuffer;
};