BatchedElements.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    BatchedElements.h: Batched element rendering.
=============================================================================*/
 
#pragma once
 
#include "Engine/EngineTypes.h"
#include "Templates/RefCounting.h"
#include "RenderResource.h"
#include "Containers/DynamicRHIResourceArray.h"
#include "Math/DoubleFloat.h"
 
class FGraphicsPipelineStateInitializer;
class FHitProxyId;
class FRHICommandList;
class FSceneView;
 
struct FBatchedPoint;
struct FMeshPassProcessorRenderState;
struct FDFRelativeViewMatrices;
 
enum EBlendMode : int;
enum ESimpleElementBlendMode : int;
 
namespace EBlendModeFilter
{
    enum Type
    {
        None = 0,
        OpaqueAndMasked = 1,
        Translucent = 2,
        All = (OpaqueAndMasked | Translucent)
    };
};
 
struct FSimpleElementVertex
{
    // Store LWC-scale positions per-vertex
    // Could potentially optimize this by storing a global batch offset, along with relative position per-vertex, but this would be more complicated
    // Could also pack this structure to save some space, W component of position is currently unused for example
    FDFVector4 Position;
    FVector2f TextureCoordinate;
    FLinearColor Color;
    FColor HitProxyIdColor;
 
    ENGINE_API FSimpleElementVertex();
 
    ENGINE_API FSimpleElementVertex(const FVector4f& InPosition, const FVector2f& InTextureCoordinate, const FLinearColor& InColor, const FColor& InHitProxyColor);
    ENGINE_API FSimpleElementVertex(const FVector4f& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, const FColor& InHitProxyColor);
    ENGINE_API FSimpleElementVertex(const FVector3f& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, const FColor& InHitProxyColor);
    ENGINE_API FSimpleElementVertex(const FVector4d& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, const FColor& InHitProxyColor);
    ENGINE_API FSimpleElementVertex(const FVector3d& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, const FColor& InHitProxyColor);
 
    ENGINE_API FSimpleElementVertex(const FVector4f& InPosition, const FVector2f& InTextureCoordinate, const FLinearColor& InColor, FHitProxyId InHitProxyId);
    ENGINE_API FSimpleElementVertex(const FVector4f& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, FHitProxyId InHitProxyId);
    ENGINE_API FSimpleElementVertex(const FVector3f& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, FHitProxyId InHitProxyId);
    ENGINE_API FSimpleElementVertex(const FVector4d& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, FHitProxyId InHitProxyId);
    ENGINE_API FSimpleElementVertex(const FVector3d& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, FHitProxyId InHitProxyId);
};
 
class FSimpleElementVertexDeclaration : public FRenderResource
{
public:
    FVertexDeclarationRHIRef VertexDeclarationRHI;
 
    ENGINE_API FSimpleElementVertexDeclaration();
    ENGINE_API FSimpleElementVertexDeclaration(FSimpleElementVertexDeclaration&&);
    ENGINE_API virtual ~FSimpleElementVertexDeclaration();
 
    ENGINE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    ENGINE_API virtual void ReleaseRHI() override;
};
 
extern ENGINE_API TGlobalResource<FSimpleElementVertexDeclaration> GSimpleElementVertexDeclaration;
 
 
 
class FBatchedElementParameters
    : public FRefCountedObject
{
 
public:
 
    // LWC_TODO - InTransform should be a FMatrix44f, and/or should extend this with a method that takes FRelativeViewMatrices, to allow LWC-aware rendering with customized shaders
    virtual void BindShaders(FRHICommandList& RHICmdList, FGraphicsPipelineStateInitializer& GraphicsPSOInit, ERHIFeatureLevel::Type InFeatureLevel, const FMatrix& InTransform, const float InGamma, const FMatrix& ColorWeights, const FTexture* Texture) = 0;
 
};
 
 
 
class FBatchedElements
{
public:
    ENGINE_API FBatchedElements();
 
    ENGINE_API void AddLine(const FVector& Start,const FVector& End,const FLinearColor& Color,FHitProxyId HitProxyId, float Thickness = 0.0f, float DepthBias = 0.0f, bool bScreenSpace = false);
 
    ENGINE_API void AddTranslucentLine(const FVector& Start, const FVector& End, const FLinearColor& Color, FHitProxyId HitProxyId, float Thickness = 0.0f, float DepthBias = 0.0f, bool bScreenSpace = false);
 
    ENGINE_API void AddPoint(const FVector& Position,float Size,const FLinearColor& Color,FHitProxyId HitProxyId);
 
    ENGINE_API int32 AddVertex(const FVector4& InPosition, const FVector2D& InTextureCoordinate, const FLinearColor& InColor, FHitProxyId HitProxyId);
    ENGINE_API int32 AddVertexf(const FVector4f& InPosition, const FVector2f& InTextureCoordinate, const FLinearColor& InColor, FHitProxyId HitProxyId);
 
    ENGINE_API void AddTriangle(int32 V0,int32 V1,int32 V2,const FTexture* Texture,EBlendMode BlendMode);
 
    ENGINE_API void AddTriangle(int32 V0, int32 V1, int32 V2, const FTexture* Texture, ESimpleElementBlendMode BlendMode, const FDepthFieldGlowInfo& GlowInfo = FDepthFieldGlowInfo());
 
    ENGINE_API void AddTriangle(int32 V0,int32 V1,int32 V2,FBatchedElementParameters* BatchedElementParameters,ESimpleElementBlendMode BlendMode);
 
    ENGINE_API void AddReserveTriangles(int32 NumMeshTriangles,const FTexture* Texture,ESimpleElementBlendMode BlendMode);
 
    ENGINE_API void ReserveTriangles(int32 NumMeshTriangles,const FTexture* Texture,ESimpleElementBlendMode BlendMode);
    
    ENGINE_API void AddReserveVertices(int32 NumMeshVerts);
 
    ENGINE_API void ReserveVertices(int32 NumMeshVerts);
 
    ENGINE_API void AddReserveLines(int32 NumLines, bool bDepthBiased = false, bool bThickLines = false);
 
    ENGINE_API void AddSprite(
        const FVector& Position,
        float SizeX,
        float SizeY,
        const FTexture* Texture,
        const FLinearColor& Color,
        FHitProxyId HitProxyId,
        float U,
        float UL,
        float V,
        float VL,
        uint8 BlendMode,
        float OpacityMaskRefVal
        );
 
    ENGINE_API bool Draw(FRHICommandList& RHICmdList, const FMeshPassProcessorRenderState& DrawRenderState, ERHIFeatureLevel::Type FeatureLevel, const FSceneView& View, bool bHitTesting, float Gamma = 1.0f, EBlendModeFilter::Type Filter = EBlendModeFilter::All, uint32 NumInstances = 1) const;
 
    static ENGINE_API FSceneView CreateProxySceneView(const FMatrix& ProjectionMatrix, const FIntRect& ViewRect);
 
    inline bool HasPrimsToDraw() const
    {
        return( LineVertices.Num() || Points.Num() || Sprites.Num() || MeshElements.Num() || ThickLines.Num() || WireTris.Num() > 0 );
    }
 
    ENGINE_API void AddTriangleExtensive(int32 V0,int32 V1,int32 V2,FBatchedElementParameters* BatchedElementParameters,const FTexture* Texture,ESimpleElementBlendMode BlendMode, const FDepthFieldGlowInfo& GlowInfo = FDepthFieldGlowInfo());
 
    ENGINE_API void Clear();
 
    inline uint32 GetAllocatedSize( void ) const
    {
        return sizeof(*this) + Points.GetAllocatedSize() + WireTris.GetAllocatedSize() + WireTriVerts.GetAllocatedSize() + ThickLines.GetAllocatedSize()
            + Sprites.GetAllocatedSize() + MeshElements.GetAllocatedSize() + MeshVertices.GetAllocatedSize();
    }
 
    UE_DEPRECATED(5.4, "EnableMobileHDREncoding is no longer supported")
    void EnableMobileHDREncoding(bool bInEnableHDREncoding) {}
 
    class FAllocationInfo
    {
    public:
        FAllocationInfo() = default;
 
    private:
        int32 NumLineVertices = 0;
        int32 NumPoints = 0;
        int32 NumWireTris = 0;
        int32 NumWireTriVerts = 0;
        int32 NumThickLines = 0;
        int32 NumSprites = 0;
        int32 NumMeshElements = 0;
        int32 NumMeshVertices = 0;
 
        friend FBatchedElements;
    };
 
    ENGINE_API void AddAllocationInfo(FAllocationInfo& AllocationInfo) const;
 
    ENGINE_API void Reserve(const FAllocationInfo& AllocationInfo);
 
    ENGINE_API void Append(FBatchedElements& Other);
 
private:
 
    ENGINE_API void DrawPointElements(FRHICommandList& RHICmdList, const FMatrix& Transform, const uint32 ViewportSizeX, const uint32 ViewportSizeY, const FVector& CameraX, const FVector& CameraY, const uint32 NumInstances) const;
 
    TArray<FSimpleElementVertex> LineVertices;
 
    struct FBatchedPoint
    {
        FVector Position;
        float Size;
        FColor Color;
        FColor HitProxyColor;
    };
    TArray<FBatchedPoint> Points;
 
    struct FBatchedWireTris
    {
        float DepthBias;
    };
    TArray<FBatchedWireTris> WireTris;
 
    mutable TResourceArray<FSimpleElementVertex> WireTriVerts;
 
    struct FBatchedThickLines
    {
        FVector Start;
        FVector End;
        float Thickness;
        FLinearColor Color;
        FColor HitProxyColor;
        float DepthBias;
        uint32 bScreenSpace;
    };
    TArray<FBatchedThickLines> ThickLines;
 
    struct FBatchedSprite
    {
        FVector Position;
        float SizeX;
        float SizeY;
        const FTexture* Texture;
        FLinearColor Color;
        FColor HitProxyColor;
        float U;
        float UL;
        float V;
        float VL;
        float OpacityMaskRefVal;
        uint8 BlendMode;
    };
    TArray<FBatchedSprite> Sprites;
 
    struct FBatchedMeshElement
    {
        uint32 MinVertex;
        uint32 MaxVertex;
        TArray<uint16> Indices;
        const FTexture* Texture;
        TRefCountPtr<FBatchedElementParameters> BatchedElementParameters;
        ESimpleElementBlendMode BlendMode;
        FDepthFieldGlowInfo GlowInfo;
    };
 
    int32 MaxMeshIndicesAllowed;
    int32 MaxMeshVerticesAllowed;
 
    TArray<FBatchedMeshElement> MeshElements;
    TArray<FSimpleElementVertex> MeshVertices;
 
    ENGINE_API void PrepareShaders(
        FRHICommandList& RHICmdList,
        FGraphicsPipelineStateInitializer& GraphicsPSOInit,
        uint32 StencilRef,
        ERHIFeatureLevel::Type FeatureLevel,
        ESimpleElementBlendMode BlendMode,
        const FDFRelativeViewMatrices& ViewMatrices,
        FBatchedElementParameters* BatchedElementParameters,
        const FTexture* Texture,
        bool bHitTesting,
        float Gamma,
        const FDepthFieldGlowInfo* GlowInfo = nullptr,
        const FSceneView* View = nullptr,
        float OpacityMaskRefVal = .5f
        ) const;
};