New evaluation scheme.

- Animation Data are always referenced via a pointer in nodes. - Animation Data storage pointers are injected from graph when node is evaluated. - Node value outputs always stored in node. - Node value inputs always referenced via pointer. References are created when instantiating the graph.
2022-04-01 13:19:54 +02:00
parent abddbea62b
commit 08ae84fcb4
8 changed files with 559 additions and 431 deletions
@@ -169,38 +169,34 @@ AnimNodeResource sAnimGraphNodeFromJson(const json& json_node) {
 }

 //
-// AnimGraphConnection <-> Json
+// AnimGraphConnectionResource <-> Json
 //
-json sAnimGraphConnectionToJson(const AnimGraphResource& graph_resource, const AnimGraphConnection& connection) {
+json sAnimGraphConnectionToJson(
+    const AnimGraphResource& graph_resource,
+    const AnimGraphConnectionResource& connection) {
  json result;

-  result["type"] = "AnimGraphConnection";
+  result["type"] = "AnimGraphConnectionResource";

-  const AnimNodeResource* source_node = connection.m_source_node;
-  result["source_node_index"] = graph_resource.getNodeIndex(*source_node);
-  result["source_socket_index"] = source_node->m_socket_accessor->GetOutputIndex(connection.m_source_socket->m_name);
+  result["source_node_index"] = connection.source_node_index;
+  result["source_socket_name"] = connection.source_socket_name;

-  const AnimNodeResource* target_node = connection.m_source_node;
-  result["source_node_index"] = graph_resource.getNodeIndex(*target_node);
-  result["source_socket_index"] = target_node->m_socket_accessor->GetInputIndex(connection.m_target_node->m_name);
+  result["target_node_index"] = connection.target_node_index;
+  result["target_socket_name"] = connection.target_socket_name;

  return result;
 }

-AnimGraphConnection sAnimGraphConnectionFromJson(const AnimGraphResource& graph_resource, const json& json_node) {
-  AnimGraphConnection connection;
+AnimGraphConnectionResource sAnimGraphConnectionFromJson(
+    const AnimGraphResource& graph_resource,
+    const json& json_node) {
+  AnimGraphConnectionResource connection;

-  int source_node_index = json_node["source_node_index"];
-  connection.m_source_node = &graph_resource.m_nodes[source_node_index];
-  int source_socket_index = json_node["source_socket_index"];
-  connection.m_source_socket = &connection.m_source_node->m_socket_accessor->m_outputs[source_socket_index];
+  connection.source_node_index = json_node["source_node_index"];
+  connection.source_socket_name = json_node["source_socket_name"];

-  
-  int target_node_index = json_node["target_node_index"];
-  connection.m_target_node = &graph_resource.m_nodes[target_node_index];
-  
-  int target_socket_index = json_node["target_socket_index"];
-  connection.m_target_socket = &connection.m_target_node->m_socket_accessor->m_outputs[target_socket_index];
+  connection.target_node_index = json_node["target_node_index"];
+  connection.target_socket_name = json_node["target_socket_name"];

  return connection;
 }
@@ -243,7 +239,7 @@ bool AnimGraphResource::saveToFile(const char* filename) const {
  }

  for (size_t i = 0; i < m_connections.size(); i++) {
-    const AnimGraphConnection& connection = m_connections[i];
+    const AnimGraphConnectionResource& connection = m_connections[i];
    result["connections"][i] = sAnimGraphConnectionToJson(*this, connection);
  }

@@ -294,7 +290,7 @@ bool AnimGraphResource::loadFromFile(const char* filename) {
  clearNodes();

  m_name = json_data["name"];
-  
+
  // Load nodes
  for (size_t i = 0; i < json_data["nodes"].size(); i++) {
    const json& json_node = json_data["nodes"][i];
@@ -308,7 +304,7 @@ bool AnimGraphResource::loadFromFile(const char* filename) {
    AnimNodeResource node = sAnimGraphNodeFromJson(json_node);
    m_nodes.push_back(node);
  }
-  
+
  // Setup graph inputs and outputs
  const json& graph_outputs = json_data["nodes"][0]["inputs"];
  for (size_t i = 0; i < graph_outputs.size(); i++) {
@@ -316,7 +312,7 @@ bool AnimGraphResource::loadFromFile(const char* filename) {
    graph_node.m_socket_accessor->m_inputs.push_back(
        sJsonToSocket(graph_outputs[i]));
  }
-  
+
  const json& graph_inputs = json_data["nodes"][1]["outputs"];
  for (size_t i = 0; i < graph_inputs.size(); i++) {
    AnimNodeResource& graph_node = m_nodes[1];
@@ -327,17 +323,196 @@ bool AnimGraphResource::loadFromFile(const char* filename) {
  // Load connections
  for (size_t i = 0; i < json_data["connections"].size(); i++) {
    const json& json_connection = json_data["connections"][i];
-    if (json_connection["type"] != "AnimGraphConnection") {
-      std::cerr << "Invalid json object. Expected type 'AnimGraphConnection' "
-                   "but got '"
-                << json_connection["type"] << "'." << std::endl;
+    if (json_connection["type"] != "AnimGraphConnectionResource") {
+      std::cerr
+          << "Invalid json object. Expected type 'AnimGraphConnectionResource' "
+             "but got '"
+          << json_connection["type"] << "'." << std::endl;
      return false;
    }

-    AnimGraphConnection connection =
+    AnimGraphConnectionResource connection =
        sAnimGraphConnectionFromJson(*this, json_connection);
    m_connections.push_back(connection);
  }

  return true;
-}
+}
+
+AnimGraph AnimGraphResource::createInstance() const {
+  AnimGraph result;
+
+  createRuntimeNodeInstances(result);
+  prepareGraphIOData(result);
+  connectRuntimeNodes(result);
+
+  result.updateOrderedNodes();
+  result.reset();
+
+  return result;
+}
+
+void AnimGraphResource::createRuntimeNodeInstances(AnimGraph& instance) const {
+  for (int i = 0; i < m_nodes.size(); i++) {
+    const AnimNodeResource& node_resource = m_nodes[i];
+    AnimNode* node = AnimNodeFactory(node_resource.m_type_name.c_str());
+    node->m_name = node_resource.m_name;
+    node->m_node_type_name = node_resource.m_type_name;
+    node->m_index = i;
+    instance.m_nodes.push_back(node);
+
+    // runtime node connections
+    instance.m_node_input_connections.push_back(
+        std::vector<AnimGraphConnection>());
+    instance.m_node_output_connections.push_back(
+        std::vector<AnimGraphConnection>());
+  }
+}
+
+void AnimGraphResource::prepareGraphIOData(AnimGraph& instance) const {
+  instance.m_socket_accessor =
+      AnimNodeAccessorFactory("BlendTree", instance.m_nodes[0]);
+  instance.m_socket_accessor->m_outputs =
+      m_nodes[1].m_socket_accessor->m_outputs;
+  instance.m_socket_accessor->m_inputs = m_nodes[0].m_socket_accessor->m_inputs;
+
+  // inputs
+  int input_block_size = 0;
+  std::vector<Socket>& graph_inputs = instance.getGraphInputs();
+  for (int i = 0; i < graph_inputs.size(); i++) {
+    input_block_size += sizeof(void*);
+  }
+  instance.m_input_buffer = new char[input_block_size];
+  memset(instance.m_input_buffer, 0, input_block_size);
+
+  int input_block_offset = 0;
+  for (int i = 0; i < graph_inputs.size(); i++) {
+    graph_inputs[i].m_value.ptr =
+        (void*)&instance.m_input_buffer[input_block_offset];
+    input_block_offset += sizeof(void*);
+  }
+
+  // outputs
+  int output_block_size = 0;
+  std::vector<Socket>& graph_outputs = instance.getGraphOutputs();
+  for (int i = 0; i < graph_outputs.size(); i++) {
+    output_block_size += graph_outputs[i].m_type_size;
+  }
+  instance.m_output_buffer = new char[output_block_size];
+  memset(instance.m_output_buffer, 0, output_block_size);
+
+  int output_block_offset = 0;
+  for (int i = 0; i < graph_outputs.size(); i++) {
+    graph_outputs[i].m_value.ptr =
+        (void*)&instance.m_output_buffer[output_block_offset];
+    output_block_offset += graph_outputs[i].m_type_size;
+  }
+}
+
+void AnimGraphResource::connectRuntimeNodes(AnimGraph& instance) const {
+  for (int i = 0; i < m_connections.size(); i++) {
+    const AnimGraphConnectionResource& connection = m_connections[i];
+    std::string source_node_type = "";
+    std::string target_node_type = "";
+    AnimNode* source_node = nullptr;
+    AnimNode* target_node = nullptr;
+    NodeSocketAccessorBase* source_node_accessor = nullptr;
+    NodeSocketAccessorBase* target_node_accessor = nullptr;
+    SocketType source_type;
+    SocketType target_type;
+    size_t source_socket_index = -1;
+    size_t target_socket_index = -1;
+
+    if (connection.source_node_index < 0
+        || connection.source_node_index >= m_nodes.size()) {
+      std::cerr << "Could not find source node index." << std::endl;
+      continue;
+    }
+
+    source_node = instance.m_nodes[connection.source_node_index];
+    source_node_type = source_node->m_node_type_name;
+    if (connection.source_node_index == 1) {
+      source_node_accessor = instance.m_socket_accessor;
+    } else {
+      source_node_accessor =
+          AnimNodeAccessorFactory(source_node_type, source_node);
+    }
+
+    if (connection.target_node_index < 0
+        || connection.target_node_index >= m_nodes.size()) {
+      std::cerr << "Could not find source node index." << std::endl;
+      continue;
+    }
+
+    target_node = instance.m_nodes[connection.target_node_index];
+    target_node_type = target_node->m_node_type_name;
+    if (connection.target_node_index == 0) {
+      target_node_accessor = instance.m_socket_accessor;
+    } else {
+      target_node_accessor =
+          AnimNodeAccessorFactory(target_node_type, target_node);
+    }
+
+    assert(source_node != nullptr);
+    assert(target_node != nullptr);
+
+    //
+    // Map resource node sockets to graph instance node sockets
+    //
+    source_socket_index =
+        source_node_accessor->GetOutputIndex(connection.source_socket_name);
+    if (source_socket_index == -1) {
+      std::cerr << "Invalid source socket " << connection.source_socket_name
+                << " for node " << source_node->m_name << "." << std::endl;
+      continue;
+    }
+    Socket* source_socket =
+        &source_node_accessor->m_outputs[source_socket_index];
+
+    target_socket_index =
+        target_node_accessor->GetInputIndex(connection.target_socket_name);
+    if (target_socket_index == -1) {
+      std::cerr << "Invalid target socket " << connection.target_socket_name
+                << " for node " << target_node->m_name << "." << std::endl;
+      continue;
+    }
+    Socket* target_socket =
+        &target_node_accessor->m_inputs[target_socket_index];
+
+    if (source_socket->m_type != target_socket->m_type) {
+      std::cerr << "Cannot connect sockets: invalid types!" << std::endl;
+    }
+
+    //
+    // Wire up outputs to inputs.
+    //
+    (*target_socket->m_value.ptr_ptr) = source_socket->m_value.ptr;
+    //      (*source_socket->m_value.ptr_ptr) = target_socket->m_value.ptr;
+
+    size_t target_node_index = target_node->m_index;
+
+    // Register the runtime connection
+    AnimGraphConnection runtime_connection = {
+        source_node,
+        *source_socket,
+        target_node,
+        *target_socket};
+
+    std::vector<AnimGraphConnection>& target_input_connections =
+        instance.m_node_input_connections[target_node_index];
+    target_input_connections.push_back(runtime_connection);
+
+    std::vector<AnimGraphConnection>& source_output_connections =
+        instance.m_node_output_connections[source_node->m_index];
+    source_output_connections.push_back(runtime_connection);
+
+    if (target_node_accessor != instance.m_socket_accessor) {
+      delete target_node_accessor;
+    }
+
+    if (source_node_accessor != instance.m_socket_accessor) {
+      delete source_node_accessor;
+    }
+  }
+}
+