AIEditorNodeRenderer.cpp

Go to the documentation of this file.

/**
 * @file AIEditorNodeRenderer.cpp
 * @brief Implementation of AIEditorNodeRenderer
 * @author Olympe Engine
 * @date 2026-02-18
 */
 
#include "AIEditorNodeRenderer.h"
#include "../../third_party/imgui/imgui.h"
#include "../../third_party/imnodes/imnodes.h"
#include <cmath>
 
namespace Olympe {
namespace AI {
 
 
 
// ============================================================================
// Node Rendering
// ============================================================================
 
void AIEditorNodeRenderer::RenderNode(
    const NodeGraph::NodeData& nodeData,
    bool isSelected,
    bool isExecuting,
    const NodeGraph::NodeAnnotation* annotation)
{
    BTNodeRegistry& registry = BTNodeRegistry::Get();
    const BTNodeTypeInfo* typeInfo = registry.GetNodeTypeInfo(nodeData.type);
    
    if (typeInfo == nullptr) {
        return;
    }
    
    // Begin node
    int iNodeId = static_cast<int>(nodeData.id.value);
 
    // Pulsed amber/yellow outline when the node is currently executing.
    if (isExecuting) {
        float t = 0.5f + 0.5f * std::sin(static_cast<float>(ImGui::GetTime()) * 4.0f);
        float alpha = 0.6f + 0.4f * t;
        ImU32 pulseColor = IM_COL32(
            static_cast<int>(180.0f + t * 75.0f),
            static_cast<int>(140.0f + t * 115.0f),
            10,
            static_cast<int>(alpha * 255.0f));
        ImNodes::PushColorStyle(ImNodesCol_NodeOutline, pulseColor);
    }
 
    ImNodes::BeginNode(iNodeId);
    
    // Title bar with color
    ImNodes::BeginNodeTitleBar();
    uint32_t color = typeInfo->color;
    
    // Highlight if executing
    if (isExecuting) {
        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 0.0f, 1.0f));
    }
    
    ImGui::TextColored(
        ImVec4(
            ((color >> 16) & 0xFF) / 255.0f,
            ((color >> 8) & 0xFF) / 255.0f,
            ((color >> 0) & 0xFF) / 255.0f,
            ((color >> 24) & 0xFF) / 255.0f
        ),
        "%s %s", typeInfo->icon.c_str(), nodeData.name.c_str()
    );
    
    if (isExecuting) {
        ImGui::PopStyleColor();
    }
    
    // Phase 2.0 - Breakpoint indicator (red dot) and comment badge
    if (annotation != nullptr)
    {
        if (annotation->hasBreakpoint)
        {
            ImGui::SameLine();
            ImGui::TextColored(ImVec4(1.0f, 0.15f, 0.15f, 1.0f), "[B]");
        }
        if (!annotation->comment.empty())
        {
            ImGui::SameLine();
            ImGui::TextColored(ImVec4(1.0f, 1.0f, 0.4f, 1.0f), "[C]");
            if (ImGui::IsItemHovered())
            {
                ImGui::SetTooltip("%s", annotation->comment.c_str());
            }
        }
    }
    
    ImNodes::EndNodeTitleBar();
 
    // Use 2-column layout to align input pins (left) with output pins (right) on the same Y
    ImGui::Columns(2, "ai_node_pins", false);
    ImGui::SetColumnWidth(0, 80.0f);
 
    // ---- LEFT COLUMN: Input Pins ----
    // Input pin (for composites and decorators)
    if (typeInfo->category == BTNodeCategory::Composite ||
        typeInfo->category == BTNodeCategory::Decorator) {
        int inputPinId = GetInputPinId(nodeData.id);
        ImNodes::BeginInputAttribute(inputPinId);
        ImGui::Text("In");
        ImNodes::EndInputAttribute();
    }
 
    // Parameters
    for (auto it = nodeData.parameters.begin(); it != nodeData.parameters.end(); ++it) {
        ImGui::Text("%s: %s", it->first.c_str(), it->second.c_str());
    }
 
    // ---- RIGHT COLUMN: Output Pins ----
    ImGui::NextColumn();
 
    // Output pins (for nodes that can have children)
    if (typeInfo->category == BTNodeCategory::Composite ||
        typeInfo->category == BTNodeCategory::Decorator) {
        int outputPinId = GetOutputPinId(nodeData.id);
        ImNodes::BeginOutputAttribute(outputPinId);
        ImGui::Text("Out");
        ImNodes::EndOutputAttribute();
    }
 
    ImGui::Columns(1);  // End columns
    
    ImNodes::EndNode();
 
    // Pop pulsed outline style pushed before BeginNode.
    if (isExecuting) {
        ImNodes::PopColorStyle();
    }
 
    // Set node position
    ImNodes::SetNodeGridSpacePos(iNodeId, ImVec2(nodeData.position.x, nodeData.position.y));
    
    // Tooltip on hover
    int hoveredNode = -1;
    if (ImNodes::IsNodeHovered(&hoveredNode) && hoveredNode == iNodeId) {
        RenderNodeTooltip(nodeData);
    }
    
    (void)isSelected; // Unused for now
}
 
void AIEditorNodeRenderer::RenderNodeTooltip(const NodeGraph::NodeData& nodeData)
{
    BTNodeRegistry& registry = BTNodeRegistry::Get();
    const BTNodeTypeInfo* typeInfo = registry.GetNodeTypeInfo(nodeData.type);
    
    if (typeInfo != nullptr) {
        ImGui::SetTooltip("%s", typeInfo->description.c_str());
    }
}
 
// ============================================================================
// Pin ID Helpers
// ============================================================================
 
int AIEditorNodeRenderer::GetInputPinId(NodeGraph::NodeId nodeId)
{
    return static_cast<int>(nodeId.value) * 1000;
}
 
int AIEditorNodeRenderer::GetOutputPinId(NodeGraph::NodeId nodeId)
{
    return static_cast<int>(nodeId.value) * 1000 + 1;
}
 
int AIEditorNodeRenderer::GetChildPinId(NodeGraph::NodeId nodeId, int childIndex)
{
    return static_cast<int>(nodeId.value) * 1000 + 10 + childIndex;
}
 
} // namespace AI
} // namespace Olympe