RenderGraphSlot.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "RenderResource.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Event.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine {
 
    class Slot {
    public:
        enum class Type {
            Input,
            Output
        };
 
    protected:
        RenderTask& mTask;
 
        const StringView mName;
 
    public:
        explicit Slot(RenderTask* task, const StringView name) : Slot(*task, name) {}
        explicit Slot(RenderTask& task, StringView name);
        ~Slot();
 
    public:
        [[nodiscard]] RenderTask& getRenderTask() const { return mTask; }
 
        [[nodiscard]] StringView getName() const { return mName; }
 
        [[nodiscard]] virtual RenderResourceType getResourceType() const = 0;
 
    public:
        [[nodiscard]] virtual Type getType() const = 0;
 
        [[nodiscard]] bool isInput() const { return getType() == Type::Input; }
 
        [[nodiscard]] InputSlot& asInput();
        [[nodiscard]] const InputSlot& asInput() const;
 
        [[nodiscard]] bool isOutput() const { return getType() == Type::Output; }
 
        [[nodiscard]] OutputSlot& asOutput();
        [[nodiscard]] const OutputSlot& asOutput() const;
 
    public:
        [[nodiscard]] virtual Connection* getConnection(Slot& slot) const = 0;
 
        [[nodiscard]] bool isConnected(Slot& slot) const;
 
        static ConnectionPtr connect(InputSlot& input, OutputSlot& output);
 
        friend ConnectionPtr connect(InputSlot& input, OutputSlot& output) { return Slot::connect(input, output); }
 
        static bool disconnect(InputSlot& input, OutputSlot& output);
 
        friend bool disconnect(InputSlot& input, OutputSlot& output) { return Slot::disconnect(input, output); }
 
        UInt32 disconnectAll();
 
        [[nodiscard]] virtual bool supports(Slot& slot) const;
 
    protected:
        [[nodiscard]] virtual bool shouldConnect(Slot& slot) const;
 
        virtual void willConnect(Slot& slot);
 
        virtual void didConnect(Connection& connection) {}
 
        [[nodiscard]] virtual bool shouldDisconnect(Connection& connection) const;
 
        virtual void willDisconnect(Connection& connection) {}
 
        virtual void didDisconnect(Connection& slot) {}
 
    public:
        Event<void(Connection&)> onConnect;
 
        Event<void(Connection&)> onDisconnect;
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    class InputSlot : public Slot {
    public:
        InputSlot(RenderTask* task, const StringView name) : InputSlot(*task, name) {}
        InputSlot(RenderTask& task, StringView name);
        ~InputSlot();
 
    public:
        [[nodiscard]] Type getType() const final { return Type::Input; }
 
    public:
        [[nodiscard]] Connection* getConnection(Slot& slot) const override;
 
        ConnectionPtr connect(OutputSlot& output);
 
        [[nodiscard]] bool supports(Slot& slot) const override;
 
        [[nodiscard]] virtual const ConnectionPtr& getConnection() const = 0;
 
        [[nodiscard]] OutputSlot* getConnectedSlot() const;
 
    protected:
        [[nodiscard]] bool shouldDisconnect(Connection& connection) const override;
    };
 
    class OutputSlot : public Slot {
    public:
        OutputSlot(RenderTask* task, const StringView name) : OutputSlot(*task, name) {}
        OutputSlot(RenderTask& task, StringView name);
        ~OutputSlot();
 
    public:
        [[nodiscard]] Type getType() const final { return Type::Output; }
 
    public:
        [[nodiscard]] Connection* getConnection(Slot& slot) const override;
 
        ConnectionPtr connect(InputSlot& input);
 
        [[nodiscard]] bool supports(Slot& slot) const override;
 
        [[nodiscard]] virtual const Vector<ConnectionPtr>& getConnections() const = 0;
 
    protected:
        [[nodiscard]] bool shouldDisconnect(Connection& connection) const override;
    };
 
    class Connection : public RefCounted<Connection> {
    public:
        enum class Status {
            Connected,
            Disconnected
        };
 
    private:
        InputSlot& mInput;
 
        OutputSlot& mOutput;
 
        Status mStatus = Status::Disconnected;
 
    public:
        explicit Connection(InputSlot& input, OutputSlot& output) : mInput(input), mOutput(output) {}
        ~Connection();
 
    public:
        InputSlot& getInput() const { return mInput; }
 
        OutputSlot& getOutput() const { return mOutput; }
 
        Status getStatus() const noexcept { return mStatus; }
 
        bool isConnected() const noexcept { return getStatus() == Status::Connected; }
 
        bool isDisconnected() const noexcept { return getStatus() == Status::Disconnected; }
 
    public:
        void disconnect();
 
    protected:
        friend class Slot;
        void didConnect();
        void didDisconnect();
    };
 
    [[nodiscard]] inline InputSlot& Slot::asInput() { return static_cast<InputSlot&>(*this); }
    [[nodiscard]] inline const InputSlot& Slot::asInput() const { return static_cast<const InputSlot&>(*this); }
    [[nodiscard]] inline OutputSlot& Slot::asOutput() { return static_cast<OutputSlot&>(*this); }
    [[nodiscard]] inline const OutputSlot& Slot::asOutput() const { return static_cast<const OutputSlot&>(*this); }
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    class BasicInputSlot : public InputSlot {
    private:
        ConnectionPtr mConnection;
 
    public:
        using InputSlot::InputSlot;
 
    public:
        [[nodiscard]] const ConnectionPtr& getConnection() const final { return mConnection; }
 
    protected:
        void didConnect(Connection& connection) override;
 
        void didDisconnect(Connection& slot) override;
    };
 
    class BasicOutputSlot : public OutputSlot {
    public:
        Vector<ConnectionPtr> mConnections;
 
    public:
        using OutputSlot::OutputSlot;
 
    public:
        [[nodiscard]] const Vector<ConnectionPtr>& getConnections() const final { return mConnections; }
 
    protected:
        void didConnect(Connection& connection) override;
 
        void didDisconnect(Connection& slot) override;
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    template<typename P, typename RT> class TSlot : public P {
    public:
        using P::P;
 
    public:
        [[nodiscard]] RenderResourceType getResourceType() const final { return RT::resourceType; }
    };
 
    template<typename RT> class TInput final : public TSlot<BasicInputSlot, RT> {
    public:
        using TSlot<BasicInputSlot, RT>::TSlot;
 
    public:
        ConnectionPtr operator=(TSlot<BasicOutputSlot, RT>& slot) { return connect(*this, slot); }
    };
 
    template<typename RT> class TOutput final : public TSlot<BasicOutputSlot, RT> {
    public:
        using TSlot<BasicOutputSlot, RT>::TSlot;
 
    public:
        ConnectionPtr operator=(TSlot<BasicInputSlot, RT>& slot) { return connect(*this, slot); }
    };
 
    using ImageInput = TInput<ImageRenderResource>;
 
    using BufferInput = TInput<BufferRenderResource>;
 
    using ImageOutput = TOutput<ImageRenderResource>;
 
    using BufferOutput = TOutput<BufferRenderResource>;
 
} // namespace CeresEngine