martin/godot_synced_blend_tree
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP: blend tree evaluation setup and tests

Browse Source
This commit is contained in:
Martin Felis 2025-12-10 09:22:33 +01:00
parent 5880dde6ec
commit 0d916c98dd
3 changed files with 175 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
doc/design.md
View File

@ -60,10 +60,10 @@ invalid.
flowchart LR
AnimationB --> TimeScale("TimeScale
----
*scale*")
AnimationA --> Blend2
TimeScale --> Blend2
Blend2 --> Output
*scale*")
AnimationA --> Blend2
TimeScale --> Blend2
Blend2 --> Output
```
A Blend Tree always has a designated output node where the time delta is specified as an input and after the Blend Tree
@ -90,9 +90,24 @@ before performing the actual evaluation. Essentially the Blend Tree has to call
3. UpdateTime(): right to left
4. Evaluate(): left to right
To simplify implementation of nodes we enforce the following rule: all nodes only operate on data they own and any other
data (e.g. inputs and outputs) are specified via arguments. This keeps the nodes dumb and pushes bookkeeping of data
that is only needed during evaluation to the Blend Tree.
### Ownership of evaluation data (inputs and outputs)
Except for the output node of a Blend Tree the following properties hold:
* all Blend Tree nodes only operate on properties they own and any other data (e.g. inputs and outputs) are specified via arguments to `SyncedAnimationNode::evaluate(context, inputs, output)`
function of the node.
*
Advantages:
* Simplifies nodes and pushes complexities to the Blend Tree and State Machine class.
* Simplifies testing of nodes
* Resulting API could be exposed to GDScript such that custom nodes could be implemented in GDScript.
Disadvantages:
* Data has to be managed by the Blend Tree => additional bookkeeping
*
### Blend Tree Evaluation

148
synced_animation_node.h
View File

@ -163,33 +163,124 @@ public:
}
};
class SyncedBlendTree : public SyncedAnimationNode {
Vector<Ref<SyncedAnimationNode>> nodes;
struct Connection {
const Ref<SyncedAnimationNode> source_node = nullptr;
const Ref<SyncedAnimationNode> target_node = nullptr;
const StringName target_socket_name = "";
};
Vector<Connection> connections;
Vector<int> node_parent;
Vector<int> node_eval_order;
void _update_eval_order() {
// TODO: proof of concept code: currently assume nodes are properly added, though this is not guaranteed.
node_eval_order.clear();
for (int i = 0; i < nodes.size(); i++) {
node_eval_order.push_back(i);
}
class AnimationBlend2Node : public SyncedAnimationNode {
public:
void get_input_names(Vector<StringName> &inputs) override {
inputs.push_back("Input0");
inputs.push_back("Input1");
}
};
struct BlendTreeConnection {
const Ref<SyncedAnimationNode> source_node = nullptr;
const Ref<SyncedAnimationNode> target_node = nullptr;
const StringName target_port_name = "";
};
struct SortedTreeConstructor {
Vector<HashSet<SyncedAnimationNode*>> node_subgraph;
Vector<Ref<SyncedAnimationNode>> nodes;
Vector<BlendTreeConnection> connections;
SortedTreeConstructor() {
Ref<OutputNode> output_node;
output_node.instantiate();
output_node->name = "Output";
add_node(output_node);
}
Ref<SyncedAnimationNode> get_output_node() {
return nodes[0];
}
int get_node_index(const Ref<SyncedAnimationNode> node) {
for (int i = 0; i < nodes.size(); i++) {
if (nodes[i] == node) {
return i;
}
}
return -1;
}
void add_node(const Ref<SyncedAnimationNode>& node) {
nodes.push_back(node);
node_subgraph.push_back(HashSet<SyncedAnimationNode*>());
}
bool add_connection(const Ref<SyncedAnimationNode>& source_node, const Ref<SyncedAnimationNode>& target_node, const StringName& target_port_name) {
if (!is_connection_valid(source_node, target_node, target_port_name)) {
return false;
}
// check for loops
int source_node_index = get_node_index(source_node);
if (node_subgraph.get(source_node_index).has(target_node.ptr())) {
return false;
}
int target_node_index = get_node_index(target_node);
node_subgraph.get(target_node_index).insert(source_node.ptr());
return true;
}
bool is_connection_valid(const Ref<SyncedAnimationNode>& source_node, const Ref<SyncedAnimationNode>& target_node, StringName target_port_name) {
if (get_node_index(source_node) == -1) {
print_error("Cannot connect nodes: source node not found.");
return false;
}
if (get_node_index(target_node) == -1) {
print_error("Cannot connect nodes: target node not found.");
return false;
}
if (target_node == get_output_node() && connections.size() > 0) {
print_error("Cannot add connection to output node: output node is already connected");
return false;
}
Vector<StringName> target_inputs;
target_node->get_input_names(target_inputs);
if (!target_inputs.has(target_port_name)) {
print_error("Cannot connect nodes: target port not found.");
return false;
}
return true;
}
};
class SyncedBlendTree : public SyncedAnimationNode {
Vector<Ref<SyncedAnimationNode>> tree_nodes;
Vector<Vector<int>> tree_node_subgraph;
Vector<BlendTreeConnection> tree_connections;
Vector<Ref<SyncedAnimationNode>> nodes;
Vector<int> node_parent_index;
Vector<Vector<int>> node_subgraph;
Vector<Vector<Ref<SyncedAnimationNode>>> node_input_nodes;
Vector<Vector<Ref<AnimationData>>> node_input_data;
Vector<Ref<AnimationData>> node_output_data;
void _setup_graph_evaluation() {
// After this functions we must have:
// * nodes sorted by evaluation order
// * node_parent filled
// * Arrays for node_input_data and node_output_data are filled with empty values
}
public:
SyncedBlendTree() {
Ref<OutputNode> output_node;
output_node.instantiate();
output_node->name = "Output";
nodes.push_back(output_node);
node_eval_order.push_back(0);
}
Ref<SyncedAnimationNode> get_output_node() {
@ -213,8 +304,14 @@ public:
}
bool connect_nodes(const Ref<SyncedAnimationNode>& source_node, const Ref<SyncedAnimationNode>& target_node, StringName target_socket_name) {
_update_eval_order();
if (!is_connection_valid(source_node, target_node, target_socket_name)) {
return false;
}
return false;
}
bool is_connection_valid(const Ref<SyncedAnimationNode>& source_node, const Ref<SyncedAnimationNode>& target_node, StringName target_socket_name) {
if (get_node_index(source_node) == -1) {
print_error("Cannot connect nodes: source node not found.");
return false;
@ -225,6 +322,11 @@ public:
return false;
}
if (target_node == get_output_node() && tree_connections.size() > 0) {
print_error("Cannot add connection to output node: output node is already connected");
return false;
}
Vector<StringName> target_inputs;
target_node->get_input_names(target_inputs);
@ -236,10 +338,6 @@ public:
return true;
}
void sort_nodes_by_evaluation_order() {
// TODO: sort nodes and node_parent s.t. for node i all children have index > i.
}
// overrides from SyncedAnimationNode
void initialize(GraphEvaluationContext &context) override {
for (Ref<SyncedAnimationNode> node : nodes) {

32
tests/test_synced_animation_graph.h
View File

@ -55,7 +55,35 @@ struct SyncedAnimationGraphFixture {
namespace TestSyncedAnimationGraph {
TEST_CASE_FIXTURE(SyncedAnimationGraphFixture, "[SceneTree][SyncedAnimationGraph] SimpleAnimationSamplerTest") {
TEST_CASE("[SyncedAnimationGraph] TestBlendTreeConstruction") {
SortedTreeConstructor tree_constructor;
Ref<AnimationSamplerNode> animation_sampler_node0;
animation_sampler_node0.instantiate();
animation_sampler_node0->name = "Sampler0";
tree_constructor.add_node(animation_sampler_node0);
Ref<AnimationSamplerNode> animation_sampler_node1;
animation_sampler_node1.instantiate();
animation_sampler_node1->name = "Sampler1";
tree_constructor.add_node(animation_sampler_node1);
Ref<AnimationBlend2Node> node_blend0;
node_blend0.instantiate();
node_blend0->name = "Blend2";
tree_constructor.add_node(node_blend0);
Ref<AnimationBlend2Node> node_blend1;
node_blend1.instantiate();
node_blend1->name = "Blend2";
tree_constructor.add_node(node_blend1);
CHECK(tree_constructor.add_connection(animation_sampler_node0, node_blend0, "Input0"));
CHECK(tree_constructor.add_connection(node_blend1, node_blend0, "Input1"));
CHECK(!tree_constructor.add_connection(node_blend1, node_blend0, "Input1"));
}
TEST_CASE_FIXTURE(SyncedAnimationGraphFixture, "[SceneTree][SyncedAnimationGraph] SimpleAnimationSamplerTest" * doctest::skip(true)) {
Ref<AnimationSamplerNode> animation_sampler_node;
animation_sampler_node.instantiate();
animation_sampler_node->animation_name = "animation_library/TestAnimation";
@ -77,7 +105,7 @@ TEST_CASE_FIXTURE(SyncedAnimationGraphFixture, "[SceneTree][SyncedAnimationGraph
CHECK(hip_bone_position.z == doctest::Approx(0.03));
}
TEST_CASE_FIXTURE(SyncedAnimationGraphFixture, "[SceneTree][SyncedAnimationGraph] SimpleBlendTreeTest") {
TEST_CASE_FIXTURE(SyncedAnimationGraphFixture, "[SceneTree][SyncedAnimationGraph] SimpleBlendTreeTest" * doctest::skip(true)) {
Ref<SyncedBlendTree> synced_blend_tree_node;
synced_blend_tree_node.instantiate();