AnimTestbed/tests/AnimGraphResourceTests.cc

//
// Created by martin on 04.02.22.
//

#include "AnimGraphResource.h"
#include "catch.hpp"

TEST_CASE("BasicGraph", "[AnimGraphResource]") {
  AnimGraphResource graph_resource;

  graph_resource.clear();
  graph_resource.m_name = "WalkRunBlendGraph";

  // Prepare graph inputs and outputs
  size_t walk_node_index =
      graph_resource.addNode(AnimNodeResourceFactory("AnimSampler"));
  size_t run_node_index =
      graph_resource.addNode(AnimNodeResourceFactory("AnimSampler"));
  size_t blend_node_index =
      graph_resource.addNode(AnimNodeResourceFactory("Blend2"));

  AnimNodeResource& walk_node = graph_resource.m_nodes[walk_node_index];
  walk_node.m_name = "WalkAnim";
  AnimNodeResource& run_node = graph_resource.m_nodes[run_node_index];
  walk_node.m_name = "RunAnim";
  AnimNodeResource& blend_node = graph_resource.m_nodes[blend_node_index];
  walk_node.m_name = "BlendWalkRun";

  AnimNodeResource& graph_node = graph_resource.m_nodes[0];
  graph_node.m_socket_accessor->RegisterInput<AnimData>("GraphOutput", nullptr);

  REQUIRE(graph_node.m_socket_accessor->m_inputs.size() == 1);
  REQUIRE(blend_node.m_socket_accessor->GetInputIndex("Input0") == 0);
  REQUIRE(blend_node.m_socket_accessor->GetInputIndex("Input1") == 1);

  AnimGraphConnection walk_to_blend;
  walk_to_blend.m_source_node_index = walk_node_index;
  walk_to_blend.m_source_socket_index =
      walk_node.m_socket_accessor->GetOutputIndex("Output");
  walk_to_blend.m_target_node_index = blend_node_index;
  walk_to_blend.m_target_socket_index =
      blend_node.m_socket_accessor->GetInputIndex("Input0");
  graph_resource.m_connections.push_back(walk_to_blend);

  AnimGraphConnection run_to_blend;
  run_to_blend.m_source_node_index = run_node_index;
  run_to_blend.m_source_socket_index =
      run_node.m_socket_accessor->GetOutputIndex("Output");
  run_to_blend.m_target_node_index = blend_node_index;
  run_to_blend.m_target_socket_index =
      blend_node.m_socket_accessor->GetInputIndex("Input1");
  graph_resource.m_connections.push_back(run_to_blend);

  AnimGraphConnection blend_to_output;
  blend_to_output.m_source_node_index = blend_node_index;
  blend_to_output.m_source_socket_index =
      blend_node.m_socket_accessor->GetOutputIndex("Output");
  blend_to_output.m_target_node_index = 0;
  blend_to_output.m_target_socket_index =
      graph_node.m_socket_accessor->GetInputIndex("GraphOutput");
  graph_resource.m_connections.push_back(blend_to_output);

  graph_resource.saveToFile("WalkGraph.animgraph.json");

  AnimGraph graph = AnimGraph::createFromResource(graph_resource);

  for (size_t i = 0; i < graph.m_nodes.size(); i++) {
    const AnimNode* node = graph.m_nodes[i];
    std::cout << node->m_name << " [" << node->m_node_type_name << "]"
              << std::endl;
  }

  REQUIRE(graph.m_nodes.size() == 5);
  REQUIRE(graph.m_nodes[0]->m_node_type_name == "BlendTree");
  REQUIRE(graph.m_nodes[1]->m_node_type_name == "BlendTree");
  REQUIRE(graph.m_nodes[2]->m_node_type_name == "AnimSampler");
  REQUIRE(graph.m_nodes[3]->m_node_type_name == "AnimSampler");
  REQUIRE(graph.m_nodes[4]->m_node_type_name == "Blend2");

  // connections within the graph
  AnimSamplerNode* anim_sampler_instance0 =
      dynamic_cast<AnimSamplerNode*>(graph.m_nodes[2]);
  AnimSamplerNode* anim_sampler_instance1 =
      dynamic_cast<AnimSamplerNode*>(graph.m_nodes[3]);
  Blend2Node* blend2_instance = dynamic_cast<Blend2Node*>(graph.m_nodes[4]);
  CHECK(anim_sampler_instance0->m_output == &blend2_instance->m_input0);
  CHECK(anim_sampler_instance1->m_output == &blend2_instance->m_input1);

  // connections from graph to the graph node
  CHECK(graph.m_socket_accessor->m_inputs.size() == 1);
  CHECK(graph.m_socket_accessor->FindInputSocket("GraphOutput"));
  CHECK(
      reinterpret_cast<char*>(blend2_instance->m_output)
      == graph.GetOutput("GraphOutput"));

  // check node input dependencies
  size_t anim_sampler_index0 = graph.getAnimNodeIndex(anim_sampler_instance0);
  size_t anim_sampler_index1 = graph.getAnimNodeIndex(anim_sampler_instance1);
  size_t blend_index = graph.getAnimNodeIndex(blend2_instance);

  CHECK(graph.m_node_inputs[anim_sampler_index0].size() == 0);
  CHECK(graph.m_node_inputs[anim_sampler_index1].size() == 0);
  CHECK(graph.m_node_inputs[blend_index].size() == 2);
  CHECK(graph.m_node_inputs[blend_index][0] == anim_sampler_instance0);
  CHECK(graph.m_node_inputs[blend_index][1] == anim_sampler_instance1);
}

TEST_CASE("InputAttributeConversion", "[AnimGraphResource]") {
  int node_id = 3321;
  int input_index = 221;
  int output_index = 125;
  int parsed_node_id;
  int parsed_input_index;
  int parsed_output_index;

  int attribute_id = GenerateInputAttributeId(node_id, input_index);
  SplitInputAttributeId(attribute_id, &parsed_node_id, &parsed_input_index);
  CHECK(node_id == parsed_node_id);
  CHECK(input_index == parsed_input_index);

  attribute_id = GenerateOutputAttributeId(node_id, output_index);
  SplitOutputAttributeId(attribute_id, &parsed_node_id, &parsed_output_index);
  CHECK(node_id == parsed_node_id);
  CHECK(output_index == parsed_output_index);
}

TEST_CASE("ResourceSaveLoadGraphInputs", "[AnimGraphResource]") {
  AnimGraphResource graph_resource_origin;

  graph_resource_origin.clear();
  graph_resource_origin.m_name = "TestInputOutputGraph";

  AnimNodeResource& graph_output_node = graph_resource_origin.m_nodes[0];
  graph_output_node.m_socket_accessor->RegisterInput<AnimData>(
      "GraphOutput",
      nullptr);
  graph_output_node.m_socket_accessor->RegisterInput<float>(
      "SomeFloatOutput",
      nullptr);

  AnimNodeResource& graph_input_node = graph_resource_origin.m_nodes[1];
  graph_input_node.m_socket_accessor->RegisterOutput<AnimData>(
      "GraphAnimInput",
      nullptr);
  graph_input_node.m_socket_accessor->RegisterOutput<float>(
      "GraphFloatInput",
      nullptr);
  graph_input_node.m_socket_accessor->RegisterOutput<bool>(
      "GraphBoolInput",
      nullptr);

  WHEN("Saving and loading graph resource") {
    const char* filename = "ResourceSaveLoadGraphInputs.json";
    graph_resource_origin.saveToFile(filename);

    AnimGraphResource graph_resource_loaded;
    graph_resource_loaded.loadFromFile(filename);

    const AnimNodeResource& graph_loaded_output_node =
        graph_resource_loaded.m_nodes[0];
    const AnimNodeResource& graph_loaded_input_node =
        graph_resource_loaded.m_nodes[1];

    THEN("Graph inputs and outputs must be in loaded resource as well.") {
      REQUIRE(
          graph_output_node.m_socket_accessor->m_inputs.size()
          == graph_loaded_output_node.m_socket_accessor->m_inputs.size());

      REQUIRE(
          graph_input_node.m_socket_accessor->m_outputs.size()
          == graph_loaded_input_node.m_socket_accessor->m_outputs.size());

      REQUIRE(
          graph_loaded_input_node.m_socket_accessor->FindOutputSocket(
              "GraphAnimInput")
          != nullptr);
      REQUIRE(
          graph_loaded_input_node.m_socket_accessor->FindOutputSocket(
              "GraphFloatInput")
          != nullptr);
      REQUIRE(
          graph_loaded_input_node.m_socket_accessor->FindOutputSocket(
              "GraphBoolInput")
          != nullptr);

      REQUIRE(
          graph_loaded_output_node.m_socket_accessor->FindInputSocket(
              "GraphOutput")
          != nullptr);
      REQUIRE(
          graph_loaded_output_node.m_socket_accessor->FindInputSocket(
              "SomeFloatOutput")
          != nullptr);
    }

    WHEN("Instantiating an AnimGraph") {
      AnimGraph anim_graph =
          AnimGraph::createFromResource(graph_resource_loaded);
      REQUIRE(
          anim_graph.GetOutput("GraphOutput") == anim_graph.m_output_buffer);
      REQUIRE(
          anim_graph.GetOutput("SomeFloatOutput")
          == anim_graph.m_output_buffer + sizeof(AnimData));

      REQUIRE(anim_graph.GetInput("GraphAnimInput") == nullptr);
      REQUIRE(anim_graph.GetInput("GraphFloatInput") == nullptr);
      REQUIRE(anim_graph.GetInput("GraphBoolInput") == nullptr);
    }
  }

  WHEN("Connecting input to output and instantiating the graph") {
    AnimNodeResource& graph_output_node = graph_resource_origin.m_nodes[0];
    AnimNodeResource& graph_input_node = graph_resource_origin.m_nodes[1];

    REQUIRE(graph_resource_origin.connectSockets(
        graph_input_node,
        "GraphAnimInput",
        graph_output_node,
        "GraphOutput"));

    AnimGraph anim_graph = AnimGraph::createFromResource(graph_resource_origin);

    void* graph_anim_input_ptr = anim_graph.GetInput("GraphAnimInput");
    void* graph_output_ptr = anim_graph.GetOutput("GraphOutput");

    REQUIRE(graph_anim_input_ptr == graph_output_ptr);
    REQUIRE(graph_output_ptr == anim_graph.m_output_buffer);

    REQUIRE(
        anim_graph.GetInput("GraphAnimInput")
        == anim_graph.GetOutput("GraphOutput"));
  }
}

TEST_CASE("GraphInputOutputConnectivity", "[AnimGraphResource]") {
  AnimGraphResource graph_resource;

  graph_resource.clear();
  graph_resource.m_name = "TestGraphInputOutputConnectivity";

  AnimNodeResource& graph_output_node = graph_resource.m_nodes[0];
  graph_output_node.m_socket_accessor->RegisterInput<float>(
      "GraphFloatOutput",
      nullptr);
  graph_output_node.m_socket_accessor->RegisterInput<AnimData>(
      "GraphAnimOutput",
      nullptr);

  AnimNodeResource& graph_input_node = graph_resource.m_nodes[1];
  graph_input_node.m_socket_accessor->RegisterOutput<float>(
      "GraphFloatInput",
      nullptr);
  graph_input_node.m_socket_accessor->RegisterOutput<AnimData>(
      "GraphAnimInput0",
      nullptr);
  graph_input_node.m_socket_accessor->RegisterOutput<AnimData>(
      "GraphAnimInput1",
      nullptr);

  WHEN("Connecting float input with float output") {
    REQUIRE(graph_resource.connectSockets(
        graph_resource.getGraphInputNode(),
        "GraphFloatInput",
        graph_resource.getGraphOutputNode(),
        "GraphFloatOutput"));

    AnimGraph anim_graph = AnimGraph::createFromResource(graph_resource);

    THEN ("Writing to the input pointer changes the value of the output.") {
      float* float_input_ptr = (float*)anim_graph.GetInput("GraphFloatInput");
      REQUIRE(float_input_ptr != nullptr);
      *float_input_ptr = 23.123f;

      float* float_output_ptr =
          (float*)anim_graph.GetOutput("GraphFloatOutput");
      REQUIRE(float_output_ptr != nullptr);
      CHECK(*float_output_ptr == Approx(23.123f));
    }
  }

  WHEN("Connecting adding a Blend2 node") {
    size_t blend2_node_index = graph_resource.addNode(AnimNodeResourceFactory("Blend2"));
    AnimNodeResource& blend2_node_resource = graph_resource.m_nodes[blend2_node_index];

    REQUIRE(graph_resource.connectSockets(
        graph_resource.getGraphInputNode(),
        "GraphFloatInput",
        blend2_node_resource,
        "Weight"));

    THEN ("Connected float input points to the blend weight.") {
      AnimGraph anim_graph = AnimGraph::createFromResource(graph_resource);
      Blend2Node* blend2_node = dynamic_cast<Blend2Node*>(anim_graph.m_nodes[blend2_node_index]);

      REQUIRE (*anim_graph.m_socket_accessor->m_outputs[0].m_value.ptr_ptr == &blend2_node->m_blend_weight);
      float* float_input_ptr = (float*)anim_graph.GetInput("GraphFloatInput");
      REQUIRE (float_input_ptr == &blend2_node->m_blend_weight);
    }


    WHEN ("Connecting AnimData inputs to blend2 node and blend2 output to graph output.") {
      REQUIRE(graph_resource.connectSockets(
          graph_resource.getGraphInputNode(),
          "GraphAnimInput0",
          blend2_node_resource,
          "Input0"));

      REQUIRE(graph_resource.connectSockets(
          graph_resource.getGraphInputNode(),
          "GraphAnimInput1",
          blend2_node_resource,
          "Input1"));

      REQUIRE(graph_resource.connectSockets(
          blend2_node_resource,
          "Output",
          graph_resource.getGraphOutputNode(),
          "GraphAnimOutput"
          ));

      THEN("AnimData from output gets blended and result is written to Output.") {
        AnimGraph anim_graph = AnimGraph::createFromResource(graph_resource);
        Blend2Node* blend2_node = dynamic_cast<Blend2Node*>(anim_graph.m_nodes[blend2_node_index]);

        AnimData* graph_input0 = (AnimData*) anim_graph.GetInput("GraphAnimInput0");
        REQUIRE(graph_input0 == &blend2_node->m_input0);

        AnimData* graph_input1 = (AnimData*) anim_graph.GetInput("GraphAnimInput1");
        REQUIRE(graph_input1 == &blend2_node->m_input1);

        AnimData* graph_output = (AnimData*) anim_graph.GetOutput("GraphAnimOutput");
        REQUIRE(graph_output == blend2_node->m_output);
      }
    }
  }
}