GPUMessaging.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "RenderGraphDefinitions.h"
#include "ShaderParameterMacros.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTemplate.h"
 
class FRDGBufferUAV;
class FRDGBuilder;
 
#define GPU_MESSAGE_SCOPE(GraphBuilder) GPUMessage::FScope GPUMessageScope_(GraphBuilder);
 
namespace GPUMessage
{
 
class FSocket;
class FSystem;
 
class FScope
{
public:
    RENDERCORE_API FScope(FRDGBuilder& GraphBuilder);
    RENDERCORE_API ~FScope();
 
private:
    FRDGBuilder& GraphBuilder;
 
    static bool bRecursionCheck;
};
 
using FMessageId = TRDGHandle<FSocket, uint32>;
 
class FSocket
{
public:
    FSocket() = default;
 
    FSocket(FSocket&& Other)
    {
        *this = MoveTemp(Other);
    }
 
    FSocket& operator=(FSocket&& Other)
    {
        Reset();
        MessageId = Other.MessageId;
        Other.MessageId = FMessageId::Null;
        return *this;
    }
 
    ~FSocket()
    {
        Reset();
    }
 
    const FMessageId GetMessageId() const { return MessageId; }
 
    RENDERCORE_API void Reset();
 
private:
    FSocket(FMessageId InMessageId)
        : MessageId(InMessageId)
    {}
 
    FMessageId MessageId;
 
    friend FSystem;
};
 
class FReader
{
public:
    const FMessageId MessageId;
 
    template <typename DataType>
    DataType Read(const DataType& DefaultValue = {})
    {
        if (ensure(ReadOffset < PayloadSize))
        {
            return PayloadData[ReadOffset++];
        }
        return DefaultValue;
    }
 
    // Read up to N elements
    TConstArrayView<uint32> ReadCount(int32 Count)
    {
        TConstArrayView<uint32> Payload(PayloadData, PayloadSize);
        Payload.MidInline(ReadOffset, Count);
        ReadOffset += Payload.Num();
        return Payload;
    }
 
    uint32 GetPayloadSize() const { return PayloadSize; }
 
private:
    FReader(FMessageId InMessageId, uint32 InPayloadSize, const uint32* InPayloadData)
        : MessageId(InMessageId)
        , PayloadSize(InPayloadSize)
        , PayloadData(InPayloadData)
    {}
 
    const uint32 PayloadSize;
    const uint32* PayloadData;
 
    uint32 ReadOffset = 0;
 
    friend FSystem;
};
 
class FHandler
{
public:
    FHandler(const TCHAR* InName)
        : Name(InName)
    {}
 
    virtual ~FHandler() = default;
 
    virtual void Execute(FReader Message) = 0;
 
    const TCHAR* GetName() const { return Name; }
 
private:
    const TCHAR* Name;
};
 
template <typename LambdaType>
class TLambdaHandler : public FHandler
{
public:
    TLambdaHandler(const TCHAR* InDebugId, LambdaType&& InLambda)
        : FHandler(InDebugId)
        , Lambda(MoveTemp(InLambda))
    {}
 
    virtual void Execute(FReader Message) override
    {
        Lambda(Message);
    }
 
private:
    LambdaType Lambda;
};
 
 
extern RENDERCORE_API FSocket RegisterHandler(const TSharedPtr<FHandler>& Handler);
 
template <typename LambdaType>
FSocket RegisterHandler(const TCHAR* MessageDebugId, LambdaType&& Lambda)
{
    return RegisterHandler(TSharedPtr<FHandler>(new TLambdaHandler(MessageDebugId, MoveTemp(Lambda))));
}
 
BEGIN_SHADER_PARAMETER_STRUCT(FParameters, RENDERCORE_API)
    SHADER_PARAMETER_RDG_BUFFER_UAV(RWStructuredBuffer<uint>, GPUMessageDataBuffer)
    SHADER_PARAMETER(uint32, GPUMessageDataBufferSize)
END_SHADER_PARAMETER_STRUCT()
 
 
extern RENDERCORE_API FParameters GetShaderParameters(FRDGBuilder& GraphBuilder);
 
 
} // GPUMessage