gui_node_view_helpers.h

Go to the documentation of this file.

#pragma once
 
#include <gui_controls/gui_node_view_types.h>   // NodeModel, NodeView
 
#include <gui_core/gui_base_types.h>
#include <gui_core/gui_id.h>
 
#include <span>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace tachyon
{
 
    class CustomDrawContext;
    struct LineStyle;

    float NodeViewZoom(const NodeView& view);
    void  ZoomNodeView(NodeView& view, float factor, int2 pivot = {});
    void  SetNodeViewCenter(NodeView& view, float2 center, float zoom);
    void  FrameAllNodes(NodeView& view);
    void  ScrollNodeIntoView(NodeView& view, int nodeIdx, int32_t margin);

    void RenderCanvasGrid(CustomDrawContext& ctx, int32_t baseGridSize,
                          color4f dotColor, float dotSize, int2 originOffset = {},
                          IntRect clipCurrent = {});
 
    // --- Canvas grid lattice ----------------------------------------------
    // Lines fall on origin + k*grid; snap to the line at-or-below / at-or-above /
    // nearest a value. grid must be > 0.

    constexpr int32_t FloorDiv(int32_t a, int32_t b)
    {
        int32_t q = a / b, r = a % b;
        if (r != 0 && ((r < 0) != (b < 0))) --q;
        return q;
    }

    constexpr int32_t GridLineLE(int32_t v, int32_t origin, int32_t grid)
    {
        return origin + FloorDiv(v - origin, grid) * grid;
    }

    constexpr int32_t GridLineGE(int32_t v, int32_t origin, int32_t grid)
    {
        const int32_t d = GridLineLE(v, origin, grid);
        return (d == v) ? d : d + grid;
    }

    constexpr int32_t GridLineNearest(int32_t v, int32_t origin, int32_t grid)
    {
        const int32_t d = GridLineLE(v, origin, grid);
        return ((v - d) * 2 <= grid) ? d : d + grid;
    }

    WireRoute BuildWireRoute(int2 outPt, int2 inPt,
                             IntRect srcRect, IntRect tgtRect,
                             int32_t grid, int2 gridOrigin,
                             const WireRouteOverrides& overrides = {});

    constexpr uint32_t WireKey(int targetNode, int targetProp)
    {
        return ((uint32_t)targetNode << 16) | (uint32_t)(uint16_t)targetProp;
    }

    constexpr PropertyEndpoint WireInput(uint32_t wireKey)
    {
        return { int(wireKey >> 16), int(wireKey & 0xFFFFu) };
    }

    std::optional<uint32_t> WireAt(std::span<const DrawnWire> wires, int2 p, float tolerance);
 
    // Edits: the node view makes its changes through these, so what it reports is what it did.

    void ApplyNodeViewEdit(NodeView& view, const NodeViewEdit& edit, bool undo = false);
    void CommitNodeViewEdit(NodeView& view, const NodeViewEdit& edit);
    NodeViewEdit ConnectEdit(const NodeView& view, PropertyEndpoint output, PropertyEndpoint input);
    NodeViewEdit DisconnectEdit(const NodeView& view, PropertyEndpoint input);
    NodeViewEdit AddNodeEdit(const NodeView& view, NodeModel node, int index = -1);
    NodeViewEdit RemoveNodesEdit(const NodeView& view, std::span<const int> indices);
    NodeViewEdit RerouteWireEdit(const NodeView& view, uint32_t wireKey, ID stableID, int2 pos);

    std::unordered_map<uint32_t, WireLane> ComputeWireLaneOffsets(const NodeView& view,
                                                                  PropertyEndpoint pendingOut = {},
                                                                  PropertyEndpoint pendingIn  = {});

    WireRoute BuildPendingWireRoute(int2 outPt, IntRect srcRect, int2 cursor,
                                    std::optional<int2> inPt, IntRect tgtRect,
                                    int32_t grid, int2 gridOrigin, WireLane lane = {});
    WireRoute BuildPendingWireRouteToInput(int2 inPt, IntRect tgtRect, int2 cursor,
                                           std::optional<int2> outPt, IntRect srcRect,
                                           int32_t grid, int2 gridOrigin, WireLane lane = {});

    bool ConnectionAllowed(const NodeView& view, PropertyEndpoint out, PropertyEndpoint in);

    PropertyEndpoint FirstInputAccepting(const NodeView& view, PropertyEndpoint output, int nodeIdx);
    PropertyEndpoint FirstOutputAccepting(const NodeView& view, PropertyEndpoint input, int nodeIdx);

    int NodeAtCanvasPos(const NodeView& view, float2 canvasPos);

    void ConnectSockets(NodeView& view, PropertyEndpoint output, PropertyEndpoint input);

    void BringNodeToFront(std::vector<int>& ordering, int n);

    float2 NodeViewScreenToCanvas(const float3x2& viewTransform, IntRect canvasInnerRectScreen, int2 screen);
    float2 NodeViewScreenToCanvas(const NodeView& view, int2 screen);
    float2 NodeViewCanvasToScreen(const NodeView& view, float2 canvasPos);

    std::unordered_set<ID> ComputeNodesInMarquee(
        std::span<const NodeModel> nodes,
        IntRect                    canvasInnerRectScreen,
        const float3x2&            viewTransform,
        int2                       marqueeStartScreen,
        int2                       marqueeCurrentScreen);
}