gui_node_view_types.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_base_types.h>     // int2, float3x2, color4f
#include <gui_core/gui_id.h>
#include <gui_core/input/gui_command_manager.h>          // CommandMode
#include <gui_core/input/gui_pointer_drag.h>
#include <gui_core/graphics/gui_custom_draw_context.h>   // VisualColorStyleIndex
 
#include <gui_controls/gui_widget_state_types.h>          // DoubleClickTracker
 
#include <functional>
#include <optional>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
// Node-view (graph editor) data model. The caller owns one NodeView per view.
 
namespace tachyon
{

    struct PropertyEndpoint
    {
        int nodeIdx = -1;   
        int propIdx = -1;   

        bool valid() const { return nodeIdx >= 0 && propIdx >= 0; }
        bool operator==(const PropertyEndpoint&) const = default;
    };

    struct NodeProperty
    {
        std::optional<PropertyEndpoint> input;

        bool output = false;

        std::function<void()> renderBody;

        tachyon::color4f socketColor{ 0.9f, 0.9f, 0.9f, 1.0f };

        int rowSpan = 1;

        std::string                  name;
        std::string                  type;
        std::function<std::string()> value;
    };

    struct NodeModel
    {
        tachyon::ID                    stableID     = tachyon::ID::Invalid();
 
        std::string                title;        
        std::string                category;
        tachyon::color4f               categoryColor = {};
        tachyon::int2                  pos          = {};
        tachyon::int2                  startPos     = {};   
        tachyon::int2                  lastSize     = {};   
        bool                       collapsed    = false;   
        bool                       reroute      = false;
        std::vector<NodeProperty>  properties;              
    };

    struct PendingConnection
    {
        bool             active        = false;  
        PropertyEndpoint source        = {};
        bool             fromInput     = false;  
        tachyon::int2        currentScreen = {};   
        PropertyEndpoint target        = {};
        std::optional<PropertyEndpoint> detachedInput; 
    };

    enum class WireHandle : uint8_t { None, LaneX, ExitX, EntryX, LaneY };

    struct WireLane
    {
        int32_t offset = 0;   
        int32_t index  = 0;   
        int32_t count  = 1;   
 
        bool operator==(const WireLane&) const = default;
    };

    struct WireRouteOverrides
    {
        std::optional<int32_t> laneX;    
        std::optional<int32_t> exitX;    
        std::optional<int32_t> entryX;   
        std::optional<int32_t> laneY;    
        WireLane               lane;     
 
        bool operator==(const WireRouteOverrides&) const = default;
    };

    struct WireSegmentHandle
    {
        tachyon::int2  a{}, b{}; 
        WireHandle role     = WireHandle::None;  
        bool       vertical = false;
    };

    struct WireRoute
    {
        std::vector<tachyon::int2>         points;   
        std::vector<WireSegmentHandle> handles;
    };

    struct CachedWireHandle
    {
        uint32_t   wireKey  = 0;
        WireHandle role     = WireHandle::None;
        bool       vertical = false;
        tachyon::int2  a{}, b{};
    };

    struct NodeViewEdit
    {
        struct Move     { int node = -1; tachyon::int2 from {}, to {}; };
        struct Rewire   { PropertyEndpoint input, from, to; };
        struct Collapse { int node = -1; bool from = false, to = false; };
        struct Lanes    { uint32_t wireKey = 0; WireRouteOverrides from, to; };
        struct Node
        {
            int        index = -1;
            bool       added = true;
            NodeModel  node;
            std::vector<std::pair<PropertyEndpoint, int>>          fed;
            std::vector<std::pair<uint32_t, WireRouteOverrides>> lanes;   
        };
 
        std::vector<Move>     moves;
        std::vector<Rewire>   rewires;
        std::vector<Collapse> collapses;
        std::vector<Lanes>    lanes;
        std::vector<Node>     nodes;

        bool empty() const { return moves.empty() && rewires.empty() && collapses.empty() && lanes.empty() && nodes.empty(); }
    };

    struct DrawnWire
    {
        uint32_t                      wireKey = 0;
        std::vector<tachyon::int2> points;
    };

    struct WireSegmentDrag
    {
        tachyon::PointerDrag press;   
        uint32_t   wireKey    = 0;
        WireHandle role       = WireHandle::None;
        bool       vertical   = false;
        int32_t    startValue  = 0;   
        WireRouteOverrides lanesBefore {}; 
    };
 

    struct NodeView
    {
        std::vector<NodeModel>  nodes;   

        std::vector<std::string>        breadcrumb;
        std::function<void(int)>        onBreadcrumb;   
        bool                            showZoomControls = true;   
        bool                            showMinimap      = true;   

        float                           minimapScale  = 0.0f;
        tachyon::float2              minimapOrigin {};
 
        PendingConnection       pendingConnection;   
        tachyon::float3x2           transform;                  
        tachyon::int2               lastInnerSize{ 0, 0 };      
        tachyon::IntRect            lastCanvasRect {};
        tachyon::ID                 revealedFocusID = tachyon::ID::Invalid();   
        CommandMode             commandMode = CommandMode::Default;
        std::vector<int>        ordering;

        std::unordered_set<tachyon::ID>     selectedNodeIDs;
        tachyon::ID                         lastClickedNodeID = tachyon::ID::Invalid();

        DoubleClickTracker              nodeDoubleClick;

        tachyon::PointerDrag                marquee;
        tachyon::int2                       marqueeCurrentScreen {};
        std::unordered_set<tachyon::ID>     marqueeBaseSelection;     
        bool                            marqueeShift = false;     
        bool                            marqueeCtrl  = false;

        std::unordered_map<uint32_t, WireRouteOverrides> wireOverrides;
        std::vector<CachedWireHandle>                    wireHandleCache;
        WireSegmentDrag                                  wireDrag;

        std::optional<uint32_t> hoveredWire;
        std::function<void(const NodeViewEdit&)> onEdit;
        std::function<void(PropertyEndpoint from, bool fromOutput, float2 canvasPos)> onWireDroppedOnCanvas;
        std::optional<uint32_t> wireMenuWire;          
        float2                  wireMenuPos {};        
        std::function<void(float2 canvasPos)> onCanvasContextMenu;
        std::function<void(int node)>         onNodeContextMenu;
        std::optional<float2>      canvasMenuPos;      
        std::optional<tachyon::ID> nodeMenuNode;       
        tachyon::PointerDrag pan;                 
        tachyon::float3x2    panStart {};         
        tachyon::PointerDrag nodeDrag;            
        tachyon::PointerDrag minimapDrag;         
        tachyon::float3x2    minimapStart {};     

        std::function<bool(const NodeView& view,
                           PropertyEndpoint output,
                           PropertyEndpoint input)> canConnect;

        std::unordered_map<uint32_t, tachyon::VisualColorStyleIndex> wireColorStyles;
        uint32_t wireColorStylesGeneration = 0; 
    };

}