292 lines
9.1 KiB
C
292 lines
9.1 KiB
C
|
//
|
||
|
// Created by martin on 25.03.22.
|
||
|
//
|
||
|
|
||
|
#ifndef ANIMTESTBED_ANIMGRAPH_H
|
||
|
#define ANIMTESTBED_ANIMGRAPH_H
|
||
|
|
||
|
#include "AnimGraphResource.h"
|
||
|
|
||
|
//
|
||
|
// AnimGraph (Runtime)
|
||
|
//
|
||
|
struct AnimGraph {
|
||
|
AnimData m_local_transforms;
|
||
|
|
||
|
std::vector<AnimNode*> m_nodes;
|
||
|
std::vector<AnimNode*> m_eval_ordered_nodes;
|
||
|
std::vector<std::vector<NodeInput> > m_node_inputs;
|
||
|
NodeSocketAccessorBase* m_socket_accessor;
|
||
|
char* m_input_buffer = nullptr;
|
||
|
char* m_output_buffer = nullptr;
|
||
|
|
||
|
std::vector<Socket>& getGraphOutputs() { return m_socket_accessor->m_inputs; }
|
||
|
std::vector<Socket>& getGraphInputs() { return m_socket_accessor->m_outputs; }
|
||
|
|
||
|
~AnimGraph() {
|
||
|
delete[] m_input_buffer;
|
||
|
delete[] m_output_buffer;
|
||
|
|
||
|
for (int i = 0; i < m_nodes.size(); i++) {
|
||
|
delete m_nodes[i];
|
||
|
}
|
||
|
|
||
|
delete m_socket_accessor;
|
||
|
}
|
||
|
|
||
|
void updateOrderedNodes();
|
||
|
void markActiveNodes();
|
||
|
bool checkIsNodeActive(AnimNode* node) {
|
||
|
return node->m_state != AnimNodeEvalState::Deactivated;
|
||
|
}
|
||
|
void evalSyncTracks();
|
||
|
void updateTime(float dt);
|
||
|
void evaluate();
|
||
|
void reset() {
|
||
|
for (size_t i = 0, n = m_nodes.size(); i < n; i++) {
|
||
|
m_nodes[i]->m_time_now = 0.f;
|
||
|
m_nodes[i]->m_time_last = 0.f;
|
||
|
m_nodes[i]->m_state = AnimNodeEvalState::Undefined;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void* getOutput(const std::string& name) const;
|
||
|
void* getInput(const std::string& name) const;
|
||
|
|
||
|
int getNodeEvalOrderIndex(const AnimNode* node) {
|
||
|
for (size_t i = 0, n = m_eval_ordered_nodes.size(); i < n; i++) {
|
||
|
if (m_eval_ordered_nodes[i] == node) {
|
||
|
return i;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return -1;
|
||
|
}
|
||
|
AnimNode* getAnimNodeForInput(
|
||
|
size_t node_index,
|
||
|
const std::string& input_name) {
|
||
|
assert(node_index < m_nodes.size());
|
||
|
assert(node_index < m_node_inputs.size());
|
||
|
|
||
|
std::vector<NodeInput>& node_inputs = m_node_inputs[node_index];
|
||
|
for (size_t i = 0, n = node_inputs.size(); i < n; i++) {
|
||
|
if (node_inputs[i].m_input_name == input_name) {
|
||
|
return node_inputs[i].m_node;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return nullptr;
|
||
|
}
|
||
|
|
||
|
AnimNode* getAnimNode(const char* name) {
|
||
|
for (size_t i = 0; i < m_nodes.size(); i++) {
|
||
|
if (m_nodes[i]->m_name == name) {
|
||
|
return m_nodes[i];
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return nullptr;
|
||
|
}
|
||
|
|
||
|
static AnimGraph createFromResource(const AnimGraphResource& resource) {
|
||
|
AnimGraph result;
|
||
|
|
||
|
// create nodes
|
||
|
for (int i = 0; i < resource.m_nodes.size(); i++) {
|
||
|
const AnimNodeResource& node_resource = 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;
|
||
|
result.m_nodes.push_back(node);
|
||
|
|
||
|
assert(node_resource.m_socket_accessor != nullptr);
|
||
|
result.m_node_inputs.push_back(std::vector<NodeInput>());
|
||
|
std::vector<NodeInput>& node_inputs = result.m_node_inputs.back();
|
||
|
|
||
|
for (int j = 0, n = node_resource.m_socket_accessor->m_inputs.size();
|
||
|
j < n;
|
||
|
j++) {
|
||
|
const Socket& input_socket =
|
||
|
node_resource.m_socket_accessor->m_inputs[j];
|
||
|
|
||
|
NodeInput input;
|
||
|
input.m_node = nullptr;
|
||
|
input.m_type = input_socket.m_type;
|
||
|
input.m_input_name = input_socket.m_name;
|
||
|
|
||
|
node_inputs.push_back(input);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Prepare graph inputs
|
||
|
result.m_socket_accessor =
|
||
|
AnimNodeAccessorFactory("BlendTree", result.m_nodes[0]);
|
||
|
result.m_socket_accessor->m_outputs =
|
||
|
resource.m_nodes[1].m_socket_accessor->m_outputs;
|
||
|
result.m_socket_accessor->m_inputs =
|
||
|
resource.m_nodes[0].m_socket_accessor->m_inputs;
|
||
|
|
||
|
// inputs
|
||
|
int input_block_size = 0;
|
||
|
std::vector<Socket>& graph_inputs = result.getGraphInputs();
|
||
|
for (int i = 0; i < graph_inputs.size(); i++) {
|
||
|
input_block_size += sizeof(void*);
|
||
|
}
|
||
|
result.m_input_buffer = new char[input_block_size];
|
||
|
memset(result.m_input_buffer, 0, input_block_size);
|
||
|
|
||
|
int input_block_offset = 0;
|
||
|
for (int i = 0; i < graph_inputs.size(); i++) {
|
||
|
if (graph_inputs[i].m_type == SocketType::SocketTypeAnimation) {
|
||
|
}
|
||
|
graph_inputs[i].m_value.ptr =
|
||
|
(void*)&result.m_input_buffer[input_block_offset];
|
||
|
input_block_offset += sizeof(void*);
|
||
|
}
|
||
|
|
||
|
// outputs
|
||
|
int output_block_size = 0;
|
||
|
std::vector<Socket>& graph_outputs = result.getGraphOutputs();
|
||
|
for (int i = 0; i < graph_outputs.size(); i++) {
|
||
|
output_block_size += graph_outputs[i].m_type_size;
|
||
|
}
|
||
|
result.m_output_buffer = new char[output_block_size];
|
||
|
memset(result.m_output_buffer, 0, output_block_size);
|
||
|
|
||
|
int output_block_offset = 0;
|
||
|
for (int i = 0; i < graph_outputs.size(); i++) {
|
||
|
if (graph_outputs[i].m_type == SocketType::SocketTypeAnimation) {
|
||
|
}
|
||
|
graph_outputs[i].m_value.ptr =
|
||
|
(void*)&result.m_output_buffer[output_block_offset];
|
||
|
output_block_offset += graph_outputs[i].m_type_size;
|
||
|
}
|
||
|
|
||
|
// connect the nodes
|
||
|
for (int i = 0; i < resource.m_connections.size(); i++) {
|
||
|
const AnimGraphConnection& connection = resource.m_connections[i];
|
||
|
std::string source_node_type = "";
|
||
|
std::string target_node_type = "";
|
||
|
std::string source_node_name = "";
|
||
|
std::string target_node_name = "";
|
||
|
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.m_source_node != nullptr) {
|
||
|
size_t node_index = resource.getNodeIndex(*connection.m_source_node);
|
||
|
if (node_index == -1) {
|
||
|
std::cerr << "Could not find source node index." << std::endl;
|
||
|
continue;
|
||
|
}
|
||
|
source_node = result.m_nodes[node_index];
|
||
|
source_node_name = source_node->m_name;
|
||
|
source_node_type = source_node->m_node_type_name;
|
||
|
if (node_index == 1) {
|
||
|
source_node_accessor = result.m_socket_accessor;
|
||
|
} else {
|
||
|
source_node_accessor =
|
||
|
AnimNodeAccessorFactory(source_node_type, source_node);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (connection.m_target_node != nullptr) {
|
||
|
size_t node_index = resource.getNodeIndex(*connection.m_target_node);
|
||
|
if (node_index == -1) {
|
||
|
std::cerr << "Could not find source node index." << std::endl;
|
||
|
continue;
|
||
|
}
|
||
|
target_node = result.m_nodes[node_index];
|
||
|
target_node_name = target_node->m_name;
|
||
|
target_node_type = target_node->m_node_type_name;
|
||
|
if (node_index == 0) {
|
||
|
target_node_accessor = result.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
|
||
|
//
|
||
|
if (connection.m_source_socket == nullptr) {
|
||
|
std::cerr << "Invalid source socket for connection " << i << "."
|
||
|
<< std::endl;
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
if (connection.m_target_socket == nullptr) {
|
||
|
std::cerr << "Invalid source socket for connection " << i << "."
|
||
|
<< std::endl;
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
source_socket_index = source_node_accessor->GetOutputIndex(
|
||
|
connection.m_source_socket->m_name);
|
||
|
if (source_socket_index == -1) {
|
||
|
std::cerr << "Invalid source socket "
|
||
|
<< connection.m_source_socket->m_name << " for node "
|
||
|
<< connection.m_source_node->m_name << "." << std::endl;
|
||
|
continue;
|
||
|
}
|
||
|
const Socket* source_socket =
|
||
|
&source_node_accessor->m_outputs[source_socket_index];
|
||
|
|
||
|
target_socket_index = target_node_accessor->GetInputIndex(
|
||
|
connection.m_target_socket->m_name);
|
||
|
if (target_socket_index == -1) {
|
||
|
std::cerr << "Invalid target socket "
|
||
|
<< connection.m_target_socket->m_name << " for node "
|
||
|
<< connection.m_target_node->m_name << "." << std::endl;
|
||
|
continue;
|
||
|
}
|
||
|
const 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.
|
||
|
//
|
||
|
(*source_socket->m_value.ptr_ptr) = target_socket->m_value.ptr;
|
||
|
|
||
|
size_t target_node_index = target_node->m_index;
|
||
|
|
||
|
std::vector<NodeInput>& node_inputs =
|
||
|
result.m_node_inputs[target_node_index];
|
||
|
for (int j = 0, n = node_inputs.size(); j < n; j++) {
|
||
|
if (node_inputs[j].m_input_name == target_socket->m_name) {
|
||
|
node_inputs[j].m_node = source_node;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (target_node_accessor != result.m_socket_accessor) {
|
||
|
delete target_node_accessor;
|
||
|
}
|
||
|
|
||
|
if (source_node_accessor != result.m_socket_accessor) {
|
||
|
delete source_node_accessor;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
result.updateOrderedNodes();
|
||
|
result.reset();
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
#endif //ANIMTESTBED_ANIMGRAPH_H
|