BoundShaderStateCache.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    BoundShaderStateCache.h: Bound shader state cache definition.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "RHI.h"
 
class FBoundShaderStateKey
{
public:
    FBoundShaderStateKey(
        FRHIVertexDeclaration* InVertexDeclaration,
        FRHIVertexShader* InVertexShader,
        FRHIPixelShader* InPixelShader,
        FRHIGeometryShader* InGeometryShader = nullptr
        )
        : VertexDeclaration(InVertexDeclaration)
        , VertexShader(InVertexShader)
        , PixelShader(InPixelShader)
        , GeometryShader(InGeometryShader)
    {}
 
    FBoundShaderStateKey(
        FRHIMeshShader* InMeshShader,
        FRHIAmplificationShader* InAmplificationShader,
        FRHIPixelShader* InPixelShader
    )
        : MeshShader(InMeshShader)
        , AmplificationShader(InAmplificationShader)
        , PixelShader(InPixelShader)
    {}
 
    inline FRHIVertexShader*   GetVertexShader() const   { return VertexShader; }
    inline FRHIMeshShader*     GetMeshShader() const   { return MeshShader; }
    inline FRHIAmplificationShader*   GetAmplificationShader() const   { return AmplificationShader; }
    inline FRHIPixelShader*    GetPixelShader() const    { return PixelShader; }
    inline FRHIGeometryShader* GetGeometryShader() const { return GeometryShader; }
 
    inline FRHIVertexDeclaration* GetVertexDeclaration() const { return VertexDeclaration; }
 
private:
    FVertexDeclarationRHIRef VertexDeclaration;
    FVertexShaderRHIRef VertexShader;
    FMeshShaderRHIRef MeshShader;
    FAmplificationShaderRHIRef AmplificationShader;
    FPixelShaderRHIRef PixelShader;
    FGeometryShaderRHIRef GeometryShader;
 
    friend class FBoundShaderStateLookupKey;
};
 
// Non-reference-counted version of shader state key.
// This structure is used as the actual key type for TMap, which avoids reference counting overhead during lookup.
// Note that FCachedBoundShaderStateLink contains a full-fat reference-counted FBoundShaderStateKey, ensuring
// correct lifetime management.
class FBoundShaderStateLookupKey
{
public:
 
    // Note: implicit cast is allowed/expected for this constructor
    FBoundShaderStateLookupKey(const FBoundShaderStateKey& Key)
        : VertexDeclaration(Key.VertexDeclaration.GetReference())
        , VertexShader(Key.VertexShader.GetReference())
        , MeshShader(Key.MeshShader.GetReference())
        , AmplificationShader(Key.AmplificationShader.GetReference())
        , PixelShader(Key.PixelShader.GetReference())
        , GeometryShader(Key.GeometryShader.GetReference())
    {}
 
    FBoundShaderStateLookupKey(
        FRHIVertexDeclaration* InVertexDeclaration,
        FRHIVertexShader* InVertexShader,
        FRHIPixelShader* InPixelShader,
        FRHIGeometryShader* InGeometryShader = nullptr
    )
        : VertexDeclaration(InVertexDeclaration)
        , VertexShader(InVertexShader)
        , PixelShader(InPixelShader)
        , GeometryShader(InGeometryShader)
    {}
 
    FBoundShaderStateLookupKey(
        FRHIMeshShader* InMeshShader,
        FRHIAmplificationShader* InAmplificationShader,
        FRHIPixelShader* InPixelShader
    )
        : MeshShader(InMeshShader)
        , AmplificationShader(InAmplificationShader)
        , PixelShader(InPixelShader)
    {}
 
    friend bool operator == (const FBoundShaderStateLookupKey& A, const FBoundShaderStateLookupKey& B)
    {
        return  A.VertexDeclaration == B.VertexDeclaration &&
            A.VertexShader == B.VertexShader &&
            A.MeshShader == B.MeshShader &&
            A.AmplificationShader == B.AmplificationShader &&
            A.PixelShader == B.PixelShader &&
            A.GeometryShader == B.GeometryShader;
    }
 
    friend uint32 GetTypeHash(const FBoundShaderStateLookupKey& Key)
    {
        return GetTypeHash(Key.VertexDeclaration) ^
            GetTypeHash(Key.VertexShader) ^
            GetTypeHash(Key.MeshShader) ^
            GetTypeHash(Key.AmplificationShader) ^
            GetTypeHash(Key.PixelShader) ^
            GetTypeHash(Key.GeometryShader);
    }
 
private:
    const FRHIVertexDeclaration* VertexDeclaration = nullptr;
    const FRHIVertexShader* VertexShader = nullptr;
    const FRHIMeshShader* MeshShader = nullptr;
    const FRHIAmplificationShader* AmplificationShader = nullptr;
    const FRHIPixelShader* PixelShader = nullptr;
    const FRHIGeometryShader* GeometryShader = nullptr;
};
 
class FCachedBoundShaderStateLink
{
public:
 
    FRHIBoundShaderState* BoundShaderState;
 
    RHI_API FCachedBoundShaderStateLink(
        FRHIVertexDeclaration* VertexDeclaration,
        FRHIVertexShader* VertexShader,
        FRHIPixelShader* PixelShader,
        FRHIBoundShaderState* InBoundShaderState,
        bool bAddToSingleThreadedCache = true
        );
 
    RHI_API FCachedBoundShaderStateLink(
        FRHIVertexDeclaration* VertexDeclaration,
        FRHIVertexShader* VertexShader,
        FRHIPixelShader* PixelShader,
        FRHIGeometryShader* GeometryShader,
        FRHIBoundShaderState* InBoundShaderState,
        bool bAddToSingleThreadedCache = true
    );
 
    RHI_API FCachedBoundShaderStateLink(
        FRHIMeshShader* MeshShader,
        FRHIAmplificationShader* AmplificationShader,
        FRHIPixelShader* PixelShader,
        FRHIBoundShaderState* InBoundShaderState,
        bool bAddToSingleThreadedCache = true
    );
 
    RHI_API ~FCachedBoundShaderStateLink();
 
    inline FRHIVertexShader*   GetVertexShader() const   { return Key.GetVertexShader(); }
    inline FRHIMeshShader*     GetMeshShader() const     { return Key.GetMeshShader(); }
    inline FRHIAmplificationShader* GetAmplificationShader() const { return Key.GetAmplificationShader(); }
    inline FRHIPixelShader*    GetPixelShader() const    { return Key.GetPixelShader(); }
    inline FRHIGeometryShader* GetGeometryShader() const { return Key.GetGeometryShader(); }
 
    inline FRHIVertexDeclaration* GetVertexDeclaration() const { return Key.GetVertexDeclaration(); }
 
protected:
    FBoundShaderStateKey Key;
    bool bAddedToSingleThreadedCache;
};
 
 
extern RHI_API FCachedBoundShaderStateLink* GetCachedBoundShaderState(
    FRHIVertexDeclaration* VertexDeclaration,
    FRHIVertexShader* VertexShader,
    FRHIPixelShader* PixelShader,
    FRHIGeometryShader* GeometryShader = nullptr,
    FRHIMeshShader* MeshShader = nullptr,
    FRHIAmplificationShader* AmplificationShader = nullptr
    );
 
extern RHI_API void EmptyCachedBoundShaderStates();
 
class FCachedBoundShaderStateLink_Threadsafe : public FCachedBoundShaderStateLink
{
public:
    FCachedBoundShaderStateLink_Threadsafe(
        FRHIVertexDeclaration* VertexDeclaration,
        FRHIVertexShader* VertexShader,
        FRHIPixelShader* PixelShader,
        FRHIBoundShaderState* InBoundShaderState
        )
        : FCachedBoundShaderStateLink(VertexDeclaration, VertexShader, PixelShader, InBoundShaderState, false)
    {
    }
 
    FCachedBoundShaderStateLink_Threadsafe(
        FRHIVertexDeclaration* VertexDeclaration,
        FRHIVertexShader* VertexShader,
        FRHIPixelShader* PixelShader,
        FRHIGeometryShader* GeometryShader,
        FRHIBoundShaderState* InBoundShaderState
        )
        : FCachedBoundShaderStateLink(VertexDeclaration, VertexShader, PixelShader, GeometryShader, InBoundShaderState, false)
    {
    }
 
    FCachedBoundShaderStateLink_Threadsafe(
        FRHIMeshShader* MeshShader,
        FRHIAmplificationShader* AmplificationShader,
        FRHIPixelShader* PixelShader,
        FRHIBoundShaderState* InBoundShaderState
    )
        : FCachedBoundShaderStateLink(MeshShader, AmplificationShader, PixelShader, InBoundShaderState, false)
    {
    }
 
    RHI_API void AddToCache();
    RHI_API void RemoveFromCache();
};
 
extern RHI_API FBoundShaderStateRHIRef GetCachedBoundShaderState_Threadsafe(
    FRHIVertexDeclaration* VertexDeclaration,
    FRHIVertexShader* VertexShader,
    FRHIPixelShader* PixelShader,
    FRHIGeometryShader* GeometryShader = nullptr,
    FRHIMeshShader* MeshShader = nullptr,
    FRHIAmplificationShader* AmplificationShader = nullptr
    );