AnimTestbed/src/AnimGraph/AnimGraphEditor.cc

//
// Created by martin on 11.02.22.
//

#include "AnimGraphEditor.h"

#include <sstream>

#include "3rdparty/imgui-node-editor/imgui_node_editor.h"
#include "AnimGraphResource.h"
#include "SkinnedMesh.h"
#include "imgui.h"
#include "imnodes.h"
#include "misc/cpp/imgui_stdlib.h"

static AnimGraphResource sGraphGresource = AnimGraphResource();
static bool sGraphLoadedThisFrame = false;

ImNodesPinShape sGetSocketShapeFromSocketType(const SocketType& socket_type) {
  switch (socket_type) {
    case SocketType::SocketTypeAnimation:
      return ImNodesPinShape_QuadFilled;
    case SocketType::SocketTypeInt:
      return ImNodesPinShape_CircleFilled;
    case SocketType::SocketTypeFloat:
      return ImNodesPinShape_CircleFilled;
    case SocketType::SocketTypeVec3:
      return ImNodesPinShape_TriangleFilled;
    case SocketType::SocketTypeQuat:
      return ImNodesPinShape_Triangle;
    case SocketType::SocketTypeBool:
      return ImNodesPinShape_Circle;
    default:
      break;
  }

  return ImNodesPinShape_Quad;
}

void NodeSocketEditor(Socket& socket) {
  int mode_current = static_cast<int>(socket.m_type);
  ImGui::InputText("Name", &socket.m_name);
  if (ImGui::Combo(
          "Type",
          &mode_current,
          SocketTypeNames,
          sizeof(SocketTypeNames) / sizeof(char*))) {
    socket.m_type = static_cast<SocketType>(mode_current);
  }
}

void RemoveBlendTreeConnectionsForSocket(
    BlendTreeResource& blend_tree_resource,
    AnimNodeResource* node_resource,
    Socket& socket) {
  const BlendTreeConnectionResource* connection =
      blend_tree_resource.FindConnectionForSocket(node_resource, socket.m_name);
  while (connection != nullptr) {
    blend_tree_resource.DisconnectSockets(
        blend_tree_resource.GetNode(connection->source_node_index),
        connection->source_socket_name,
        blend_tree_resource.GetNode(connection->target_node_index),
        connection->target_socket_name);

    connection = blend_tree_resource.FindConnectionForSocket(
        node_resource,
        socket.m_name);
  }
}

void SyncTrackEditor(SyncTrack* sync_track) {
  ImGui::SliderFloat("duration", &sync_track->m_duration, 0.001f, 10.f);

  ImGui::Text("Marker");
  ImGui::SameLine();
  ImGui::Text("%d", sync_track->m_num_intervals);
  ImGui::SameLine();
  if (ImGui::Button("+")) {
    if (sync_track->m_num_intervals < cSyncTrackMaxIntervals) {
      sync_track->m_num_intervals++;
    }
  }
  ImGui::SameLine();
  if (ImGui::Button("-")) {
    if (sync_track->m_num_intervals > 0) {
      sync_track->m_num_intervals--;
    }
  }

  ImGui::Text("Marker:");
  for (int i = 0; i < sync_track->m_num_intervals; i++) {
    ImGui::Text("%2d:", i);
    ImGui::SameLine();
    std::ostringstream marker_stream;
    marker_stream << i;
    ImGui::SliderFloat(
        marker_stream.str().c_str(),
        &sync_track->m_sync_markers[i],
        0.f,
        1.f);
  }

  if (ImGui::Button("Update Intervals")) {
    sync_track->CalcIntervals();
  }
}

void SkinnedMeshWidget(SkinnedMesh* skinned_mesh) {
  if (ImGui::TreeNode("Bones")) {
    for (int i = 0; i < skinned_mesh->m_skeleton.num_joints(); i++) {
      ImGui::Text("%s", skinned_mesh->m_skeleton.joint_names()[i]);
    }
    ImGui::TreePop();
  }

  ImGui::Text("Animations");

  const char* items[255] = {0};
  static int selected = -1;
  for (int i = 0; i < skinned_mesh->m_animations.size(); i++) {
    items[i] = skinned_mesh->m_animation_names[i].c_str();
  }

  ImGui::Combo(
      "Animation",
      &selected,
      items,
      skinned_mesh->m_animations.size());

  ImGui::Text("Sync Track");
  if (selected >= 0 && selected < skinned_mesh->m_animations.size()) {
    SyncTrackEditor(&skinned_mesh->m_animation_sync_track[selected]);
    skinned_mesh->m_override_anim = selected;

    ImGui::Checkbox("Override Animation", &skinned_mesh->m_sync_track_override);
    if (skinned_mesh->m_sync_track_override) {
      ImGui::SliderFloat("Ratio", &skinned_mesh->m_override_ratio, 0.f, 1.f);

      ozz::animation::SamplingJob sampling_job;
      sampling_job.animation = skinned_mesh->m_animations[selected];
      sampling_job.context = &skinned_mesh->m_sampling_context;
      sampling_job.ratio = skinned_mesh->m_override_ratio;
      sampling_job.output = make_span(skinned_mesh->m_local_matrices);
      if (!sampling_job.Run()) {
        ozz::log::Err() << "Error sampling animation." << std::endl;
      }
    }
  }
}

void AnimGraphEditorRenderSidebar(
    BlendTreeResource& blend_tree_resource,
    AnimNodeResource* node_resource) {
  ImGui::Text("[%s]", node_resource->m_node_type_name.c_str());

  char node_name_buffer[256];
  memset(node_name_buffer, 0, sizeof(node_name_buffer));
  strncpy(
      node_name_buffer,
      node_resource->m_name.c_str(),
      std::min(node_resource->m_name.size(), sizeof(node_name_buffer)));

  if (ImGui::InputText("Name", node_name_buffer, sizeof(node_name_buffer))) {
    node_resource->m_name = node_name_buffer;
  }

  int num_properties = node_resource->m_socket_accessor->m_properties.size();
  for (int i = 0; i < num_properties; i++) {
    Socket& property = node_resource->m_socket_accessor->m_properties[i];
    if (property.m_type == SocketType::SocketTypeInt) {
      ImGui::InputInt(
          property.m_name.c_str(),
          reinterpret_cast<int*>(&property.m_value.int_value),
          1);
    } else if (property.m_type == SocketType::SocketTypeFloat) {
      ImGui::SliderFloat(
          property.m_name.c_str(),
          reinterpret_cast<float*>(&property.m_value.float_value),
          -100.f,
          100.f);
    } else if (property.m_type == SocketType::SocketTypeBool) {
      bool flag_value = property.GetValue<bool>();
      if (ImGui::Checkbox(property.m_name.c_str(), &flag_value)) {
        property.SetValue(flag_value);
      }
    } else if (property.m_type == SocketType::SocketTypeString) {
      char string_buf[1024];
      memset(string_buf, '\0', sizeof(string_buf));
      memcpy(
          string_buf,
          property.m_value_string.c_str(),
          std::min(
              static_cast<size_t>(1024),
              property.m_value_string.size() + 1));
      if (ImGui::InputText(
              property.m_name.c_str(),
              string_buf,
              sizeof(string_buf))) {
        property.m_value_string = string_buf;
      }
    }
  }

  if (node_resource == blend_tree_resource.GetGraphOutputNode()) {
    ImGui::Text("Outputs");

    // Graph outputs are the inputs of the output node!
    std::vector<Socket>& outputs = node_resource->m_socket_accessor->m_inputs;

    std::vector<Socket>::iterator iter = outputs.begin();
    while (iter != outputs.end()) {
      Socket& output = *iter;
      ImGui::PushID(&output);
      NodeSocketEditor(output);
      if (ImGui::Button("X")) {
        RemoveBlendTreeConnectionsForSocket(
            blend_tree_resource,
            node_resource,
            output);
        iter = outputs.erase(iter);
      } else {
        iter++;
      }
      ImGui::PopID();
    }
  }

  if (node_resource == blend_tree_resource.GetGraphInputNode()) {
    ImGui::Text("Inputs");

    // Graph inputs are the outputs of the input node!
    std::vector<Socket>& inputs = node_resource->m_socket_accessor->m_outputs;

    std::vector<Socket>::iterator iter = inputs.begin();
    while (iter != inputs.end()) {
      Socket& input = *iter;
      ImGui::PushID(&input);
      NodeSocketEditor(input);
      if (ImGui::Button("X")) {
        RemoveBlendTreeConnectionsForSocket(
            blend_tree_resource,
            node_resource,
            input);
        iter = inputs.erase(iter);
      } else {
        iter++;
      }
      ImGui::PopID();
    }
  }
}

void AnimGraphEditorClear() {
  sGraphGresource.Clear();
  sGraphGresource.m_blend_tree_resource.InitGraphConnectors();
  sGraphGresource.m_graph_type_name = "BlendTree";
}

void AnimGraphEditorUpdate(ax::NodeEditor::EditorContext* context) {
  ImGui::BeginMenuBar();
  if (ImGui::Button("Save")) {
    sGraphGresource.SaveToFile("editor_graph.json");
  }
  if (ImGui::Button("Load")) {
    sGraphGresource.LoadFromFile("editor_graph.json");
    sGraphLoadedThisFrame = true;
  }
  if (ImGui::Button("Clear")) {
    AnimGraphEditorClear();
  }
  char graph_name_buffer[256];
  memset(graph_name_buffer, 0, sizeof(graph_name_buffer));
  strncpy(
      graph_name_buffer,
      sGraphGresource.m_name.c_str(),
      sizeof(graph_name_buffer));
  if (ImGui::InputText("Name", graph_name_buffer, sizeof(graph_name_buffer))) {
    sGraphGresource.m_name = graph_name_buffer;
  }

  ImGui::EndMenuBar();

  //
  // Node editor canvas
  //
  ax::NodeEditor::SetCurrentEditor(context);
  ax::NodeEditor::Begin("Graph Editor");

#if 1
  for (size_t node_id = 0,
              n = sGraphGresource.m_blend_tree_resource.GetNumNodes();
       node_id < n;
       node_id++) {
    AnimNodeResource* node_resource =
        sGraphGresource.m_blend_tree_resource.GetNode(node_id);

    if (node_id == 0 || node_id == 1) {
      // continue;
    }

    if (sGraphLoadedThisFrame) {
      ax::NodeEditor::SetNodePosition(
          node_id,
          ImVec2(node_resource->m_position[0], node_resource->m_position[1]));
    }
    ax::NodeEditor::BeginNode(node_id);
    ImGui::Text("%s", node_resource->m_node_type_name.c_str());

    // Inputs
    std::vector<Socket>& node_inputs =
        node_resource->m_socket_accessor->m_inputs;
    for (size_t j = 0, ni = node_inputs.size(); j < ni; j++) {
      Socket& socket = node_inputs[j];
      ax::NodeEditor::BeginPin(
          NodeIndexAndSocketIndexToInputPinId(
              static_cast<int>(node_id),
              static_cast<int>(j)),
          ax::NodeEditor::PinKind::Input);
      ImGui::Text("%s", socket.m_name.c_str());
      ax::NodeEditor::EndPin();
    }

    // Outputs
    std::vector<Socket>& node_outputs =
        node_resource->m_socket_accessor->m_outputs;
    for (size_t j = 0, ni = node_outputs.size(); j < ni; j++) {
      Socket& socket = node_outputs[j];
      ax::NodeEditor::BeginPin(
          NodeIndexAndSocketIndexToOutputPinId(
              static_cast<int>(node_id),
              static_cast<int>(j)),
          ax::NodeEditor::PinKind::Output);
      ImGui::Text("%s", socket.m_name.c_str());
      ax::NodeEditor::EndPin();
    }

    ax::NodeEditor::EndNode();

    ImVec2 node_position = ax::NodeEditor::GetNodePosition(node_id);
    node_resource->m_position[0] = node_position.x;
    node_resource->m_position[1] = node_position.y;
  }

  int link_id = 0;
  for (size_t connection_id = 0,
              n = sGraphGresource.m_blend_tree_resource.GetNumConnections();
       connection_id < n;
       connection_id++) {
    const BlendTreeConnectionResource* connection_resource =
        sGraphGresource.m_blend_tree_resource.GetConnection(connection_id);

    const AnimNodeResource* source_node_resource =
        sGraphGresource.m_blend_tree_resource.GetNode(
            connection_resource->source_node_index);
    int source_socket_index =
        source_node_resource->m_socket_accessor->GetOutputIndex(
            connection_resource->source_socket_name.c_str());

    const AnimNodeResource* target_node_resource =
        sGraphGresource.m_blend_tree_resource.GetNode(
            connection_resource->target_node_index);
    int target_socket_index =
        target_node_resource->m_socket_accessor->GetInputIndex(
            connection_resource->target_socket_name.c_str());

    int source_socket_pin_id = NodeIndexAndSocketIndexToOutputPinId(
        static_cast<int>(connection_resource->source_node_index),
        source_socket_index);
    int target_socket_pin_id = NodeIndexAndSocketIndexToInputPinId(
        static_cast<int>(connection_resource->target_node_index),
        target_socket_index);

    ax::NodeEditor::Link(link_id++, source_socket_pin_id, target_socket_pin_id);
  }

#endif

#if 1
  // Create Connections
  if (ax::NodeEditor::BeginCreate()) {
    ax::NodeEditor::PinId input_pin_id, output_pin_id;
    if (ax::NodeEditor::QueryNewLink(&input_pin_id, &output_pin_id)) {
      if (input_pin_id && output_pin_id) {
        if (ax::NodeEditor::AcceptNewItem()) {
          int source_node_index;
          int source_node_socket_index;

          OutputPinIdToNodeIndexAndSocketIndex(
              input_pin_id.Get(),
              &source_node_index,
              &source_node_socket_index);

          const AnimNodeResource* source_node =
              sGraphGresource.m_blend_tree_resource.GetNode(source_node_index);
          if (source_node->m_socket_accessor->m_outputs.size()
              < source_node_socket_index) {
            source_node_socket_index = -1;
          }

          int target_node_index;
          int target_node_socket_index;

          InputPinIdToNodeIndexAndSocketIndex(
              output_pin_id.Get(),
              &target_node_index,
              &target_node_socket_index);

          const AnimNodeResource* target_node =
              sGraphGresource.m_blend_tree_resource.GetNode(target_node_index);
          if (target_node->m_socket_accessor->m_inputs.size()
              < target_node_socket_index) {
            target_node_socket_index = -1;
          }

          if (source_node_socket_index == -1
              || target_node_socket_index == -1) {
            ax::NodeEditor::RejectNewItem();
          } else {
            const std::string& source_socket_name =
                source_node->m_socket_accessor
                    ->m_outputs[source_node_socket_index]
                    .m_name;

            const std::string& target_socket_name =
                target_node->m_socket_accessor
                    ->m_inputs[target_node_socket_index]
                    .m_name;

            sGraphGresource.m_blend_tree_resource.ConnectSockets(
                source_node,
                source_socket_name,
                target_node,
                target_socket_name);
          }
        }
      }
    }
  }
  ax::NodeEditor::EndCreate();
#endif

  // Popup menu
  {
    const bool open_popup = ImGui::IsMouseReleased(ImGuiMouseButton_Right);

    ImVec2 popup_mouse_position = ImGui::GetMousePos();

    ax::NodeEditor::Suspend();
    if (open_popup) {
      ImGui::OpenPopup("add node");
    }
    ax::NodeEditor::Resume();

    ax::NodeEditor::Suspend();
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.f, 8.f));
    if (ImGui::BeginPopup("add node")) {
      std::string node_type_name = "";
      if (ImGui::MenuItem("AnimSampler")) {
        node_type_name = "AnimSampler";
      }

      if (ImGui::MenuItem("Blend2")) {
        node_type_name = "Blend2";
      }

      if (ImGui::MenuItem("SpeedScale")) {
        node_type_name = "SpeedScale";
      }

      if (ImGui::MenuItem("LockTranslationNode")) {
        node_type_name = "LockTranslationNode";
      }

      if (ImGui::MenuItem("MathAddNode")) {
        node_type_name = "MathAddNode";
      }

      if (ImGui::MenuItem("MathFloatToVec3Node")) {
        node_type_name = "MathFloatToVec3Node";
      }

      if (ImGui::MenuItem("ConstScalarNode")) {
        node_type_name = "ConstScalarNode";
      }

      if (node_type_name.empty()) {
        AnimNodeResource* node_resource =
            AnimNodeResourceFactory(node_type_name);
        size_t node_id = sGraphGresource.m_blend_tree_resource.GetNumNodes();
        ax::NodeEditor::SetNodePosition(node_id, popup_mouse_position);
        sGraphGresource.m_blend_tree_resource.AddNode(node_resource);
      }

      ImGui::EndPopup();
    }
    ImGui::PopStyleVar();
    ax::NodeEditor::Resume();
  }

  ax::NodeEditor::End();

  sGraphLoadedThisFrame = false;

  ax::NodeEditor::SetCurrentEditor(nullptr);
}

void LegacyAnimGraphEditorUpdate() {
  ImGui::BeginMenuBar();
  if (ImGui::Button("Save")) {
    sGraphGresource.SaveToFile("editor_graph.json");
  }
  if (ImGui::Button("Load")) {
    sGraphGresource.LoadFromFile("editor_graph.json");

    for (size_t i = 0, n = sGraphGresource.m_blend_tree_resource.GetNumNodes();
         i < n;
         i++) {
      const AnimNodeResource* node_resource =
          sGraphGresource.m_blend_tree_resource.GetNode(i);
      ImNodes::SetNodeGridSpacePos(
          i,
          ImVec2(node_resource->m_position[0], node_resource->m_position[1]));
    }
  }
  if (ImGui::Button("Clear")) {
    sGraphGresource.Clear();
  }
  char graph_name_buffer[256];
  memset(graph_name_buffer, 0, sizeof(graph_name_buffer));
  strncpy(
      graph_name_buffer,
      sGraphGresource.m_name.c_str(),
      sizeof(graph_name_buffer));
  if (ImGui::InputText("Name", graph_name_buffer, sizeof(graph_name_buffer))) {
    sGraphGresource.m_name = graph_name_buffer;
  }

  ImGui::EndMenuBar();

  ImGui::Columns(2);

  //
  // Node editor canvas
  //
  ImNodes::BeginNodeEditor();

  // Popup menu
  {
    const bool open_popup =
        ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows)
        && ImNodes::IsEditorHovered()
        && ImGui::IsMouseReleased(ImGuiMouseButton_Right);

    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.f, 8.f));
    if (!ImGui::IsAnyItemHovered() && open_popup) {
      ImGui::OpenPopup("add node");
    }

    if (ImGui::BeginPopup("add node")) {
      const ImVec2 click_pos = ImGui::GetMousePosOnOpeningCurrentPopup();
      std::string node_type_name = "";
      if (ImGui::MenuItem("AnimSampler")) {
        node_type_name = "AnimSampler";
      }

      if (ImGui::MenuItem("Blend2")) {
        node_type_name = "Blend2";
      }

      if (ImGui::MenuItem("SpeedScale")) {
        node_type_name = "SpeedScale";
      }

      if (ImGui::MenuItem("LockTranslationNode")) {
        node_type_name = "LockTranslationNode";
      }

      if (ImGui::MenuItem("MathAddNode")) {
        node_type_name = "MathAddNode";
      }

      if (ImGui::MenuItem("MathFloatToVec3Node")) {
        node_type_name = "MathFloatToVec3Node";
      }

      if (ImGui::MenuItem("ConstScalarNode")) {
        node_type_name = "ConstScalarNode";
      }

      if (node_type_name != "") {
        AnimNodeResource* node_resource =
            AnimNodeResourceFactory(node_type_name);
        size_t node_id = sGraphGresource.m_blend_tree_resource.GetNumNodes();
        ImNodes::SetNodeScreenSpacePos(node_id, ImGui::GetMousePos());
        sGraphGresource.m_blend_tree_resource.AddNode(node_resource);
      }

      ImGui::EndPopup();
    }

    ImGui::PopStyleVar(ImGuiStyleVar_WindowPadding);
  }

  for (size_t i = 0, n = sGraphGresource.m_blend_tree_resource.GetNumNodes();
       i < n;
       i++) {
    AnimNodeResource* node_resource =
        sGraphGresource.m_blend_tree_resource.GetNode(i);

    ImNodes::BeginNode(i);
    ImGui::PushItemWidth(110.0f);

    // Header
    ImNodes::BeginNodeTitleBar();
    if (node_resource
        == sGraphGresource.m_blend_tree_resource.GetGraphOutputNode()) {
      ImGui::TextUnformatted("Graph Outputs");
    } else if (
        node_resource
        == sGraphGresource.m_blend_tree_resource.GetGraphInputNode()) {
      ImGui::TextUnformatted("Graph Inputs");
    } else {
      ImGui::TextUnformatted(node_resource->m_node_type_name.c_str());
    }
    ImNodes::EndNodeTitleBar();

    // Inputs
    std::vector<Socket>& node_inputs =
        node_resource->m_socket_accessor->m_inputs;
    for (size_t j = 0, ni = node_inputs.size(); j < ni; j++) {
      Socket& socket = node_inputs[j];

      ImColor socket_color = ImColor(255, 255, 255, 255);
      if (socket.m_flags & SocketFlagAffectsTime) {
        socket_color = ImColor(255, 128, 128, 255);
      }

      ImNodes::BeginInputAttribute(
          GenerateInputAttributeId(i, j),
          sGetSocketShapeFromSocketType(socket.m_type),
          socket_color);
      ImGui::TextUnformatted(socket.m_name.c_str());

      bool socket_connected =
          sGraphGresource.m_blend_tree_resource.IsSocketConnected(
              node_resource,
              socket.m_name);
      if (!socket_connected && (socket.m_type == SocketType::SocketTypeFloat)) {
        ImGui::SameLine();
        float socket_value = socket.m_value.float_value;
        ImGui::PushItemWidth(
            130.0f - ImGui::CalcTextSize(socket.m_name.c_str()).x);
        if (ImGui::DragFloat("##hidelabel", &socket_value, 0.01f)) {
          socket.SetValue(socket_value);
        }
        ImGui::PopItemWidth();
      }

      if (!socket_connected && (socket.m_type == SocketType::SocketTypeInt)) {
        ImGui::SameLine();
        int socket_value = socket.m_value.int_value;
        ImGui::PushItemWidth(
            130.0f - ImGui::CalcTextSize(socket.m_name.c_str()).x);
        if (ImGui::InputInt("##hidelabel", &socket_value, 1)) {
          socket.SetValue(socket_value);
        }
        ImGui::PopItemWidth();
      }

      ImNodes::PushAttributeFlag(
          ImNodesAttributeFlags_EnableLinkDetachWithDragClick);
      ImNodes::EndInputAttribute();
    }

    // Outputs
    const std::vector<Socket>& node_outputs =
        node_resource->m_socket_accessor->m_outputs;
    for (size_t j = 0, ni = node_outputs.size(); j < ni; j++) {
      const Socket& socket = node_outputs[j];
      ImNodes::BeginOutputAttribute(
          GenerateOutputAttributeId(i, j),
          sGetSocketShapeFromSocketType(socket.m_type),
          ImColor(255, 255, 255, 255));
      ImGui::TextUnformatted(socket.m_name.c_str());
      ImNodes::PushAttributeFlag(
          ImNodesAttributeFlags_EnableLinkDetachWithDragClick);
      ImNodes::EndInputAttribute();
    }

    // Graph output node
    if (i == 0) {
      if (ImGui::Button("+Output")) {
        AnimNodeResource* graph_output_node =
            sGraphGresource.m_blend_tree_resource.GetGraphOutputNode();

        static float bla = 0.f;
        std::string socket_name = "Output";
        socket_name += std::to_string(
            graph_output_node->m_socket_accessor->m_inputs.size());
        graph_output_node->m_socket_accessor->RegisterInput<float>(
            socket_name.c_str(),
            nullptr);
      }
    } else if (i == 1) {
      if (ImGui::Button("+Input")) {
        AnimNodeResource* graph_input_node =
            sGraphGresource.m_blend_tree_resource.GetGraphInputNode();

        static float bla = 0.f;
        std::string socket_name = "Input";
        socket_name += std::to_string(
            graph_input_node->m_socket_accessor->m_outputs.size());
        graph_input_node->m_socket_accessor->RegisterOutput<float>(
            socket_name.c_str(),
            nullptr);
      }
    }

    // Save state in node resource
    ImVec2 node_pos = ImNodes::GetNodeGridSpacePos(i);
    node_resource->m_position[0] = node_pos[0];
    node_resource->m_position[1] = node_pos[1];
    ImGui::PopItemWidth();

    ImNodes::EndNode();

    // Ensure flags such as SocketFlagAffectsTime are properly set.
    node_resource->m_socket_accessor->UpdateFlags();
  }

  for (size_t i = 0,
              n = sGraphGresource.m_blend_tree_resource.GetNumConnections();
       i < n;
       i++) {
    const BlendTreeConnectionResource* connection =
        sGraphGresource.m_blend_tree_resource.GetConnection(i);
    int start_attr, end_attr;

    const AnimNodeResource* source_node =
        sGraphGresource.m_blend_tree_resource.GetNode(
            connection->source_node_index);
    int source_socket_index = source_node->m_socket_accessor->GetOutputIndex(
        connection->source_socket_name.c_str());

    const AnimNodeResource* target_node =
        sGraphGresource.m_blend_tree_resource.GetNode(
            connection->target_node_index);
    int target_socket_index = target_node->m_socket_accessor->GetInputIndex(
        connection->target_socket_name.c_str());

    start_attr = GenerateOutputAttributeId(
        connection->source_node_index,
        source_socket_index);
    end_attr = GenerateInputAttributeId(
        connection->target_node_index,
        target_socket_index);

    ImNodes::Link(i, start_attr, end_attr);
  }

  ImNodes::EndNodeEditor();

  // Handle newly created links.
  int start_attr, end_attr;
  if (ImNodes::IsLinkCreated(&start_attr, &end_attr)) {
    int node_start_id;
    int node_start_output_index;
    SplitOutputAttributeId(
        start_attr,
        &node_start_id,
        &node_start_output_index);

    int node_end_id;
    int node_end_input_index;
    SplitInputAttributeId(end_attr, &node_end_id, &node_end_input_index);

    BlendTreeConnectionResource connection;
    connection.source_node_index = node_start_id;
    const AnimNodeResource* source_node =
        sGraphGresource.m_blend_tree_resource.GetNode(node_start_id);
    connection.source_socket_name =
        source_node->m_socket_accessor->m_outputs[node_start_output_index]
            .m_name;

    connection.target_node_index = node_end_id;
    const AnimNodeResource* target_node =
        sGraphGresource.m_blend_tree_resource.GetNode(node_end_id);
    connection.target_socket_name =
        target_node->m_socket_accessor->m_inputs[node_end_input_index].m_name;

    sGraphGresource.m_blend_tree_resource.ConnectSockets(
        source_node,
        connection.source_socket_name,
        target_node,
        connection.target_socket_name);
  }

  if (ImGui::IsKeyPressed(ImGuiKey_Delete, false)) {
    std::cerr << "Delete key!" << std::endl;
  }

  // Handle link detachements.
  int link_id = 0;
  if (ImNodes::IsLinkDestroyed(&link_id)) {
    BlendTreeConnectionResource* connection =
        sGraphGresource.m_blend_tree_resource.GetConnection(link_id);
    AnimNodeResource* source_node =
        sGraphGresource.m_blend_tree_resource.GetNode(
            connection->source_node_index);
    AnimNodeResource* target_node =
        sGraphGresource.m_blend_tree_resource.GetNode(
            connection->target_node_index);
    sGraphGresource.m_blend_tree_resource.DisconnectSockets(
        source_node,
        connection->source_socket_name,
        target_node,
        connection->target_socket_name);
  }

  int selected_nodes[ImNodes::NumSelectedNodes()];
  ImNodes::GetSelectedNodes(selected_nodes);

  //
  // Sidebar
  //
  ImGui::NextColumn();

  if (ImNodes::NumSelectedNodes() == 1) {
    if (selected_nodes[0]
        < sGraphGresource.m_blend_tree_resource.GetNumNodes()) {
      AnimNodeResource* selected_node =
          sGraphGresource.m_blend_tree_resource.GetNode(selected_nodes[0]);
      AnimGraphEditorRenderSidebar(
          sGraphGresource.m_blend_tree_resource,
          selected_node);
    }
  }

  ImGui::Columns(1);
}

void AnimGraphEditorGetRuntimeGraph(AnimGraphBlendTree& blend_tree) {
  sGraphGresource.CreateBlendTreeInstance(blend_tree);
}