GraphNode.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 "GraphSocket.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/UUID.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine {
 
    class GraphNode : public RefCounted<GraphNode> {
    protected:
        Graph* mGraph;
 
        UUID mUUID;
        String mDisplayName;
 
        Vector<GraphSocket*> mInputs;
        Vector<GraphSocket*> mOutputs;
        Vector<GraphSocketPtr> mSockets;
 
    public:
        Event<void()> onChange;
 
        Event<void(GraphSocket&)> onSocketAdded;
        Event<void(GraphSocket&)> onSocketRemoved;
 
        Event<void(GraphConnection&)> onConnect;
        Event<void(GraphConnection&)> onDisconnect;
 
    public:
        explicit GraphNode(Graph& graph, const UUID& uuid) : mGraph(&graph), mUUID(uuid) {}
        virtual ~GraphNode() noexcept = default;
 
    public:
        [[nodiscard]] Graph* getGraph() const noexcept { return mGraph; }
 
        [[nodiscard]] const UUID& getUUID() const noexcept { return mUUID; }
 
        [[nodiscard]] StringView getDisplayName() const noexcept { return mDisplayName; }
 
        void setDisplayName(String displayName);
 
        [[nodiscard]] StringView getNodeTypeName() const;
 
    public: // Socket management
        [[nodiscard]] GraphSocket* getSocket(StringView name) const;
 
        const Vector<GraphSocket*>& getInputSockets() const noexcept { return mInputs; };
 
        const Vector<GraphSocket*>& getOutputs() const noexcept { return mOutputs; };
 
        const Vector<GraphSocketPtr>& getSockets() const noexcept { return mSockets; };
 
        [[nodiscard]] GraphSocket& addSocket(String name, GraphSocketDirection direction);
 
        template<typename T> [[nodiscard]] GraphSocket& addSocket(String name, const GraphSocketDirection direction) { return addSocket(std::move(name), direction); }
 
        [[nodiscard]] GraphSocket& addInputSocket(String name) { return addSocket(std::move(name), GraphSocketDirection::Input); }
 
        template<typename T> [[nodiscard]] GraphSocket& addInputSocket(String name) { return addInputSocket(std::move(name)); }
 
        [[nodiscard]] GraphSocket& addOutputSocket(String name) { return addSocket(std::move(name), GraphSocketDirection::Output); }
 
        template<typename T> [[nodiscard]] GraphSocket& addOutputSocket(String name) { return addOutputSocket(std::move(name)); }
 
        void removeSocket(GraphSocket& socket);
        void removeSocket(StringView name);
 
        void forEachSocket(std::function<void(GraphSocket&)> function);
 
    public: // Graph interface
        friend class Graph;
 
        void onAttach(Graph& graph, const UUID& uuid);
        void onDetach(const Graph& graph);
 
    public: // Change tracking
        void markAsChanged();
    };
 
} // namespace CeresEngine