martin/AnimTestbed
1
0
Fork 0
Code Issues 11 Pull Requests Projects 1 Releases Wiki Activity

Compare commits

base: martin:eeef635c64a57a2825ea285302d05e6ef73b4061
Branches Tags
martin:main
martin:RefactorUnifiedBlendTreeStateMachineHandling
martin:AnimGraphEditor
..
compare: martin:e7314e34770be0bf001569c7c0fb502791eacdaa
Branches Tags
martin:RefactorUnifiedBlendTreeStateMachineHandling
martin:main
martin:AnimGraphEditor

No commits in common. "eeef635c64a57a2825ea285302d05e6ef73b4061" and "e7314e34770be0bf001569c7c0fb502791eacdaa" have entirely different histories.
eeef635c64 ... e7314e3477

9 changed files with 165 additions and 583 deletions
Show Stats Expand all files Collapse all files

44
src/AnimGraph/AnimGraph.cc
View File

@ -6,16 +6,6 @@
#include <cstring>
bool AnimGraph::init(AnimGraphContext& context) {
for (size_t i = 2; i < m_nodes.size(); i++) {
if (!m_nodes[i]->Init(context)) {
return false;
}
}
return true;
}
void AnimGraph::updateOrderedNodes() {
m_eval_ordered_nodes.clear();
updateOrderedNodesRecursive(0);
@ -79,6 +69,8 @@ void AnimGraph::markActiveNodes() {
}
void AnimGraph::prepareNodeEval(size_t node_index) {
AnimNode* node = m_nodes[node_index];
for (size_t i = 0, n = m_node_output_connections[node_index].size(); i < n;
i++) {
AnimGraphConnection& output_connection =
@ -88,7 +80,7 @@ void AnimGraph::prepareNodeEval(size_t node_index) {
continue;
}
(*output_connection.m_source_socket.m_reference.ptr_ptr) =
(*output_connection.m_source_socket.m_value.ptr_ptr) =
m_anim_data_work_buffer.peek();
m_anim_data_work_buffer.pop();
}
@ -102,12 +94,14 @@ void AnimGraph::prepareNodeEval(size_t node_index) {
continue;
}
(*input_connection.m_target_socket.m_reference.ptr_ptr) =
(*input_connection.m_source_socket.m_reference.ptr_ptr);
(*input_connection.m_target_socket.m_value.ptr_ptr) =
(*input_connection.m_source_socket.m_value.ptr_ptr);
}
}
void AnimGraph::finishNodeEval(size_t node_index) {
AnimNode* node = m_nodes[node_index];
for (size_t i = 0, n = m_node_input_connections[node_index].size(); i < n;
i++) {
AnimGraphConnection& input_connection =
@ -118,8 +112,8 @@ void AnimGraph::finishNodeEval(size_t node_index) {
}
m_anim_data_work_buffer.push(
static_cast<AnimData*>(input_connection.m_source_socket.m_reference.ptr));
(*input_connection.m_source_socket.m_reference.ptr_ptr) = nullptr;
static_cast<AnimData*>(input_connection.m_source_socket.m_value.ptr));
(*input_connection.m_source_socket.m_value.ptr_ptr) = nullptr;
}
}
@ -132,8 +126,8 @@ void AnimGraph::evalInputNode() {
if (graph_input_connection.m_source_socket.m_type
!= SocketType::SocketTypeAnimation) {
memcpy(
*graph_input_connection.m_target_socket.m_reference.ptr_ptr,
graph_input_connection.m_source_socket.m_reference.ptr,
*graph_input_connection.m_target_socket.m_value.ptr_ptr,
graph_input_connection.m_source_socket.m_value.ptr,
sizeof(void*));
printf("bla");
} else {
@ -150,8 +144,8 @@ void AnimGraph::evalOutputNode() {
if (graph_output_connection.m_source_socket.m_type
!= SocketType::SocketTypeAnimation) {
memcpy(
graph_output_connection.m_target_socket.m_reference.ptr,
graph_output_connection.m_source_socket.m_reference.ptr,
graph_output_connection.m_target_socket.m_value.ptr,
graph_output_connection.m_source_socket.m_value.ptr,
graph_output_connection.m_target_socket.m_type_size);
} else {
// TODO: how to deal with anim data outputs?
@ -172,7 +166,7 @@ void AnimGraph::evalSyncTracks() {
}
void AnimGraph::updateTime(float dt) {
const std::vector<AnimGraphConnection>& graph_output_inputs =
const std::vector<AnimGraphConnection> graph_output_inputs =
m_node_input_connections[0];
for (size_t i = 0, n = graph_output_inputs.size(); i < n; i++) {
AnimNode* node = graph_output_inputs[i].m_source_node;
@ -188,11 +182,11 @@ void AnimGraph::updateTime(float dt) {
}
int node_index = node->m_index;
const std::vector<AnimGraphConnection> node_input_connections =
m_node_input_connections[node_index];
float node_time_now = node->m_time_now;
float node_time_last = node->m_time_last;
const std::vector<AnimGraphConnection>& node_input_connections =
m_node_input_connections[node_index];
for (size_t i = 0, n = node_input_connections.size(); i < n; i++) {
AnimNode* input_node = node_input_connections[i].m_source_node;
@ -207,7 +201,7 @@ void AnimGraph::updateTime(float dt) {
}
}
void AnimGraph::evaluate(AnimGraphContext& context) {
void AnimGraph::evaluate() {
constexpr int eval_stack_size = 5;
int eval_stack_index = eval_stack_size;
AnimData eval_buffers[eval_stack_size];
@ -225,12 +219,10 @@ void AnimGraph::evaluate(AnimGraphContext& context) {
prepareNodeEval(node->m_index);
node->Evaluate(context);
node->Evaluate();
finishNodeEval(node->m_index);
}
evalOutputNode();
}
Socket* AnimGraph::getInputSocket(const std::string& name) {

7
src/AnimGraph/AnimGraph.h
View File

@ -66,8 +66,6 @@ struct AnimGraph {
delete m_socket_accessor;
}
bool init(AnimGraphContext& context);
void updateOrderedNodes();
void updateOrderedNodesRecursive(int node_index);
void markActiveNodes();
@ -75,6 +73,7 @@ struct AnimGraph {
return node->m_state != AnimNodeEvalState::Deactivated;
}
void evalInputNode();
void prepareNodeEval(size_t node_index);
void finishNodeEval(size_t node_index);
@ -82,7 +81,7 @@ struct AnimGraph {
void evalSyncTracks();
void updateTime(float dt);
void evaluate(AnimGraphContext& context);
void evaluate();
void reset() {
for (size_t i = 0, n = m_nodes.size(); i < n; i++) {
m_nodes[i]->m_time_now = 0.f;
@ -100,7 +99,7 @@ struct AnimGraph {
void* getInputPtr(const std::string& name) const {
const Socket* input_socket = getInputSocket(name);
if (input_socket != nullptr) {
return input_socket->m_reference.ptr;
return input_socket->m_value.ptr;
}
return nullptr;

145
src/AnimGraph/AnimGraphData.h
View File

@ -5,29 +5,18 @@
#ifndef ANIMTESTBED_ANIMGRAPHDATA_H
#define ANIMTESTBED_ANIMGRAPHDATA_H
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <iostream>
#include "SyncTrack.h"
#include "ozz/base/containers/vector.h"
#include <ozz/base/maths/soa_transform.h>
#include "ozz/animation/runtime/skeleton.h"
//
// Data types
//
struct AnimGraph;
struct AnimGraphContext {
AnimGraph* m_graph = nullptr;
ozz::animation::Skeleton* m_skeleton = nullptr;
};
struct AnimData {
ozz::vector<ozz::math::SoaTransform> m_local_matrices;
float m_bone_transforms[16];
};
typedef float Vec3[3];
@ -44,8 +33,6 @@ enum class SocketType {
SocketTypeLast
};
constexpr size_t cSocketStringValueMaxLength = 256;
static const char* SocketTypeNames[] =
{"", "Bool", "Animation", "Float", "Vec3", "Quat", "String"};
@ -55,18 +42,10 @@ struct Socket {
std::string m_name;
SocketType m_type = SocketType::SocketTypeUndefined;
union SocketValue {
bool flag;
float float_value;
float vec3[3];
float quat[4];
char str[cSocketStringValueMaxLength];
};
SocketValue m_value = { 0 };
union SocketReference {
void* ptr;
void** ptr_ptr;
};
SocketReference m_reference;
SocketValue m_value = {nullptr};
int m_flags = 0;
size_t m_type_size = 0;
};
@ -139,25 +118,22 @@ struct NodeSocketAccessorBase {
return default_value;
}
return *static_cast<T*>(socket->m_reference.ptr);
return *static_cast<T*>(socket->m_value.ptr);
}
template <typename T>
void SetSocketReferenceValue(Socket* socket, T value) {
std::cerr << "Could not find template specialization for socket type "
<< static_cast<int>(socket->m_type) << " ("
<< SocketTypeNames[static_cast<int>(socket->m_type)] << ")."
<< std::endl;
// *static_cast<T*>(socket->m_value.ptr) = value;
void SetSocketValue(
const std::vector<Socket>& sockets,
const std::string& name,
const T& value) {
const Socket* socket = FindSocket(sockets, name);
if (socket == nullptr) {
std::cerr << "Error: could not set value of socket with name " << name
<< ": no socket found." << std::endl;
return;
}
template <typename T>
void SetSocketValue(Socket* socket, T value) {
std::cerr << "Could not find template specialization for socket type "
<< static_cast<int>(socket->m_type) << " ("
<< SocketTypeNames[static_cast<int>(socket->m_type)] << ")."
<< std::endl;
// *static_cast<T*>(socket->m_value.ptr) = value;
*static_cast<T*>(socket->m_value.ptr) = value;
}
template <typename T>
@ -207,7 +183,7 @@ struct NodeSocketAccessorBase {
return false;
}
socket->m_reference.ptr = value_ptr;
socket->m_value.ptr = value_ptr;
return true;
}
@ -216,14 +192,8 @@ struct NodeSocketAccessorBase {
return RegisterSocket(m_properties, name, value);
}
template <typename T>
void SetPropertyReferenceValue(const std::string& name, T value) {
Socket* socket = FindSocket(m_properties, name);
SetSocketReferenceValue<T>(socket, value);
}
template <typename T>
void SetPropertyValue(const std::string& name, T value) {
Socket* socket = FindSocket(m_properties, name);
SetSocketValue<T>(socket, value);
void SetProperty(const std::string& name, const T& value) {
SetSocketValue(m_properties, name, value);
}
template <typename T>
T GetProperty(const std::string& name, T default_value) {
@ -270,90 +240,9 @@ struct NodeSocketAccessorBase {
}
};
//
// SetSocketReferenceValue<> specializations
//
template <>
inline void NodeSocketAccessorBase::SetSocketReferenceValue<const bool&>(Socket* socket, const bool& value) {
*static_cast<bool*>(socket->m_reference.ptr) = value;
}
template <>
inline void NodeSocketAccessorBase::SetSocketReferenceValue<const float&>(Socket* socket, const float& value) {
*static_cast<float*>(socket->m_reference.ptr) = value;
}
template <>
inline void NodeSocketAccessorBase::SetSocketReferenceValue<const Vec3&>(Socket* socket, const Vec3& value) {
static_cast<float*>(socket->m_reference.ptr)[0] = value[0];
static_cast<float*>(socket->m_reference.ptr)[1] = value[1];
static_cast<float*>(socket->m_reference.ptr)[2] = value[2];
}
template <>
inline void NodeSocketAccessorBase::SetSocketReferenceValue<const Quat&>(Socket* socket, const Quat& value) {
static_cast<float*>(socket->m_reference.ptr)[0] = value[0];
static_cast<float*>(socket->m_reference.ptr)[1] = value[1];
static_cast<float*>(socket->m_reference.ptr)[2] = value[2];
static_cast<float*>(socket->m_reference.ptr)[3] = value[3];
}
template <>
inline void NodeSocketAccessorBase::SetSocketReferenceValue<const std::string&>(Socket* socket, const std::string& value) {
*static_cast<std::string*>(socket->m_reference.ptr) = value;
}
template <>
inline void NodeSocketAccessorBase::SetSocketReferenceValue<const char*>(Socket* socket, const char* value) {
std::string value_string (value);
SetSocketReferenceValue<const std::string&>(socket, value_string);
}
//
// SetSocketValue<> specializations
//
template <>
inline void NodeSocketAccessorBase::SetSocketValue<const bool&>(Socket* socket, const bool& value) {
socket->m_value.flag = value;
}
template <>
inline void NodeSocketAccessorBase::SetSocketValue<const float&>(Socket* socket, const float& value) {
socket->m_value.float_value = value;
}
template <>
inline void NodeSocketAccessorBase::SetSocketValue<const Vec3&>(Socket* socket, const Vec3& value) {
socket->m_value.vec3[0] = value[0];
socket->m_value.vec3[1] = value[1];
socket->m_value.vec3[2] = value[2];
}
template <>
inline void NodeSocketAccessorBase::SetSocketValue<const Quat&>(Socket* socket, const Quat& value) {
socket->m_value.quat[0] = value[0];
socket->m_value.quat[1] = value[1];
socket->m_value.quat[2] = value[2];
socket->m_value.quat[3] = value[3];
}
template <>
inline void NodeSocketAccessorBase::SetSocketValue<const std::string&>(Socket* socket, const std::string& value) {
constexpr size_t string_max_length = sizeof(socket->m_value.str) - 1;
strncpy(socket->m_value.str, value.data(), string_max_length);
socket->m_value.str[value.size() > string_max_length ? string_max_length : value.size() ] = 0;
}
template <>
inline void NodeSocketAccessorBase::SetSocketValue<const char*>(Socket* socket, const char* value) {
SetSocketValue<const std::string&>(socket, value);
}
template <typename T>
struct NodeSocketAccessor : public NodeSocketAccessorBase {
virtual ~NodeSocketAccessor() {}
};
#endif //ANIMTESTBED_ANIMGRAPHDATA_H

6
src/AnimGraph/AnimGraphEditor.cc
View File

@ -83,16 +83,16 @@ void AnimGraphEditorRenderSidebar(
if (property.m_type == SocketType::SocketTypeFloat) {
ImGui::SliderFloat(
property.m_name.c_str(),
reinterpret_cast<float*>(property.m_reference.ptr),
reinterpret_cast<float*>(property.m_value.ptr),
-100.f,
100.f);
} else if (property.m_type == SocketType::SocketTypeBool) {
ImGui::Checkbox(
property.m_name.c_str(),
reinterpret_cast<bool*>(property.m_reference.ptr));
reinterpret_cast<bool*>(property.m_value.ptr));
} else if (property.m_type == SocketType::SocketTypeString) {
std::string* property_string =
reinterpret_cast<std::string*>(property.m_reference.ptr);
reinterpret_cast<std::string*>(property.m_value.ptr);
char string_buf[256];
memset(string_buf, 0, sizeof(string_buf));
strncpy(

80
src/AnimGraph/AnimGraphNodes.cc
View File

@ -3,83 +3,3 @@
//
#include "AnimGraphNodes.h"
#include "ozz/base/log.h"
#include "ozz/animation/runtime/blending_job.h"
#include "ozz/animation/runtime/animation.h"
#include "ozz/base/io/archive.h"
#include "ozz/base/io/stream.h"
void Blend2Node::Evaluate(AnimGraphContext& context) {
assert (i_input0 != nullptr);
assert (i_input1 != nullptr);
assert (i_blend_weight != nullptr);
assert (o_output != nullptr);
// perform blend
ozz::animation::BlendingJob::Layer layers[2];
layers[0].transform = make_span(i_input0->m_local_matrices);
layers[0].weight = (1.0f - *i_blend_weight);
layers[1].transform = make_span(i_input1->m_local_matrices);
layers[1].weight = (*i_blend_weight);
ozz::animation::BlendingJob blend_job;
blend_job.threshold = ozz::animation::BlendingJob().threshold;
blend_job.layers = layers;
blend_job.bind_pose = context.m_skeleton->joint_bind_poses();
blend_job.output = make_span(o_output->m_local_matrices);
if (!blend_job.Run()) {
ozz::log::Err() << "Error blending animations." << std::endl;
}
bool m_sync_blend = false;
}
//
// AnimSamplerNode
//
AnimSamplerNode::~AnimSamplerNode() noexcept {
delete m_animation;
m_animation = nullptr;
}
bool AnimSamplerNode::Init(AnimGraphContext& context) {
assert (m_animation == nullptr);
m_animation = new ozz::animation::Animation();
assert(m_filename.size() != 0);
ozz::io::File file(m_filename.c_str(), "rb");
if (!file.opened()) {
ozz::log::Err() << "Failed to open animation file " << m_filename << "."
<< std::endl;
return false;
}
ozz::io::IArchive archive(&file);
if (!archive.TestTag<ozz::animation::Animation>()) {
ozz::log::Err() << "Failed to load animation instance from file "
<< m_filename << "." << std::endl;
return false;
}
assert (context.m_skeleton != nullptr);
const int num_soa_joints = context.m_skeleton->num_soa_joints();
const int num_joints = context.m_skeleton->num_joints();
m_sampling_cache.Resize(num_joints);
return true;
}
void AnimSamplerNode::Evaluate(AnimGraphContext& context) {
assert (o_output != nullptr);
ozz::animation::SamplingJob sampling_job;
sampling_job.animation = m_animation;
sampling_job.cache = &m_sampling_cache;
sampling_job.ratio = m_time_now;
sampling_job.output = make_span(o_output->m_local_matrices);
if (!sampling_job.Run()) {
ozz::log::Err() << "Error sampling animation." << std::endl;
}
}

49
src/AnimGraph/AnimGraphNodes.h
View File

@ -9,7 +9,6 @@
#include "AnimGraphData.h"
#include "SyncTrack.h"
#include "ozz/animation/runtime/sampling_job.h"
struct AnimNode;
@ -47,8 +46,6 @@ struct AnimNode {
virtual ~AnimNode(){};
virtual bool Init(AnimGraphContext& context) { return true; };
virtual void MarkActiveInputs(const std::vector<AnimGraphConnection>& inputs) {
for (size_t i = 0, n = inputs.size(); i < n; i++) {
AnimNode* input_node = inputs[i].m_source_node;
@ -76,7 +73,7 @@ struct AnimNode {
m_state = AnimNodeEvalState::TimeUpdated;
}
virtual void Evaluate(AnimGraphContext& context){};
virtual void Evaluate(){};
};
@ -119,7 +116,26 @@ struct Blend2Node : public AnimNode {
}
}
virtual void Evaluate(AnimGraphContext& context) override;
virtual void UpdateTime(float dt, std::vector<NodeInput>& inputs) {
if (!m_sync_blend) {
m_time_now = m_time_now + dt;
}
for (size_t i = 0, n = inputs.size(); i < n; i++) {
AnimNode* input_node = inputs[i].m_node;
if (input_node == nullptr) {
continue;
}
if (input_node->m_state != AnimNodeEvalState::Deactivated) {
if (!m_sync_blend) {
input_node->m_time_now = m_time_now;
}
input_node->m_state = AnimNodeEvalState::TimeUpdated;
continue;
}
}
}
};
template <>
@ -155,21 +171,14 @@ struct NodeSocketAccessor<Blend2Node> : public NodeSocketAccessorBase {
//
struct SpeedScaleNode : public AnimNode {
AnimData* i_input = nullptr;
AnimData* o_output = nullptr;
AnimData* i_output = nullptr;
float* i_speed_scale = nullptr;
void UpdateTime(float time_last, float time_now) override {
virtual void UpdateTime(float time_last, float time_now) {
m_time_last = time_last;
m_time_now = time_last + (time_now - time_last) * (*i_speed_scale);
m_state = AnimNodeEvalState::TimeUpdated;
}
void Evaluate(AnimGraphContext& context) override {
assert (i_input != nullptr);
assert (o_output != nullptr);
o_output->m_local_matrices = i_input->m_local_matrices;
};
};
template <>
@ -182,7 +191,7 @@ struct NodeSocketAccessor<SpeedScaleNode> : public NodeSocketAccessorBase {
SocketFlags::SocketFlagAffectsTime);
RegisterInput("Input", &node->i_input);
RegisterOutput("Output", &node->o_output);
RegisterOutput("Output", &node->i_output);
}
};
@ -192,12 +201,6 @@ struct NodeSocketAccessor<SpeedScaleNode> : public NodeSocketAccessorBase {
struct AnimSamplerNode : public AnimNode {
AnimData* o_output = nullptr;
std::string m_filename;
ozz::animation::SamplingCache m_sampling_cache;
ozz::animation::Animation* m_animation = nullptr;
virtual ~AnimSamplerNode();
virtual bool Init(AnimGraphContext& context) override;
virtual void Evaluate(AnimGraphContext& context) override;
};
template <>
@ -218,7 +221,7 @@ struct MathAddNode : public AnimNode {
float* i_input1 = nullptr;
float o_output = 0.f;
void Evaluate(AnimGraphContext& context) override {
void Evaluate() override {
assert (i_input0 != nullptr);
assert (i_input1 != nullptr);
@ -246,7 +249,7 @@ struct MathFloatToVec3Node : public AnimNode {
float* i_input2 = nullptr;
Vec3 o_output = {0.f, 0.f, 0.f};
void Evaluate(AnimGraphContext& context) override {
void Evaluate() override {
assert (i_input0 != nullptr);
assert (i_input1 != nullptr);
assert (i_input2 != nullptr);

108
src/AnimGraph/AnimGraphResource.cc
View File

@ -27,23 +27,25 @@ json sSocketToJson(const Socket& socket) {
result["name"] = socket.m_name;
result["type"] = sSocketTypeToStr(socket.m_type);
if (socket.m_reference.ptr != nullptr) {
if (socket.m_value.ptr != nullptr) {
if (socket.m_type == SocketType::SocketTypeBool) {
result["value"] = socket.m_value.flag;
result["value"] = *reinterpret_cast<bool*>(socket.m_value.ptr);
} else if (socket.m_type == SocketType::SocketTypeAnimation) {
} else if (socket.m_type == SocketType::SocketTypeFloat) {
result["value"] = socket.m_value.float_value;
result["value"] = *reinterpret_cast<float*>(socket.m_value.ptr);
} else if (socket.m_type == SocketType::SocketTypeVec3) {
result["value"][0] = socket.m_value.vec3[0];
result["value"][1] = socket.m_value.vec3[1];
result["value"][2] = socket.m_value.vec3[2];
Vec3& vec3 = *reinterpret_cast<Vec3*>(socket.m_value.ptr);
result["value"][0] = vec3[0];
result["value"][1] = vec3[1];
result["value"][2] = vec3[2];
} else if (socket.m_type == SocketType::SocketTypeQuat) {
result["value"][0] = socket.m_value.quat[0];
result["value"][1] = socket.m_value.quat[1];
result["value"][2] = socket.m_value.quat[2];
result["value"][3] = socket.m_value.quat[3];
Quat& quat = *reinterpret_cast<Quat*>(socket.m_value.ptr);
result["value"][0] = quat[0];
result["value"][1] = quat[1];
result["value"][2] = quat[2];
result["value"][3] = quat[3];
} else if (socket.m_type == SocketType::SocketTypeString) {
result["value"] = std::string(socket.m_value.str);
result["value"] = *reinterpret_cast<std::string*>(socket.m_value.ptr);
} else {
std::cerr << "Invalid socket type '" << static_cast<int>(socket.m_type)
<< "'." << std::endl;
@ -55,7 +57,7 @@ json sSocketToJson(const Socket& socket) {
Socket sJsonToSocket(const json& json_data) {
Socket result;
result.m_type = SocketType::SocketTypeUndefined;
result.m_reference.ptr = nullptr;
result.m_value.ptr = nullptr;
result.m_name = json_data["name"];
std::string type_string = json_data["type"];
@ -127,30 +129,29 @@ AnimNodeResource sAnimGraphNodeFromJson(const json& json_node) {
if (sSocketTypeToStr(property.m_type) == json_property["type"]) {
if (property.m_type == SocketType::SocketTypeBool) {
property.m_value.flag = json_property["value"];
result.m_socket_accessor->SetProperty<bool>(
property.m_name,
json_property["value"]);
} else if (property.m_type == SocketType::SocketTypeAnimation) {
} else if (property.m_type == SocketType::SocketTypeFloat) {
property.m_value.float_value = json_property["value"];
result.m_socket_accessor->SetProperty<float>(
property.m_name,
json_property["value"]);
} else if (property.m_type == SocketType::SocketTypeVec3) {
property.m_value.vec3[0] = json_property["value"][0];
property.m_value.vec3[1] = json_property["value"][1];
property.m_value.vec3[2] = json_property["value"][2];
Vec3* property_vec3 = reinterpret_cast<Vec3*>(property.m_value.ptr);
(*property_vec3)[0] = json_property["value"][0];
(*property_vec3)[1] = json_property["value"][1];
(*property_vec3)[2] = json_property["value"][2];
} else if (property.m_type == SocketType::SocketTypeQuat) {
Quat* property_quat = reinterpret_cast<Quat*>(property.m_reference.ptr);
property.m_value.quat[0] = json_property["value"][0];
property.m_value.quat[1] = json_property["value"][1];
property.m_value.quat[2] = json_property["value"][2];
property.m_value.quat[3] = json_property["value"][3];
Quat* property_quat = reinterpret_cast<Quat*>(property.m_value.ptr);
(*property_quat)[0] = json_property["value"][0];
(*property_quat)[1] = json_property["value"][1];
(*property_quat)[2] = json_property["value"][2];
(*property_quat)[3] = json_property["value"][3];
} else if (property.m_type == SocketType::SocketTypeString) {
std::string value_str = json_property["value"];
size_t string_length = value_str.size();
constexpr size_t string_max_length = sizeof(property.m_value.str) - 1;
if (string_length > string_max_length) {
std::cerr << "Warning: string '" << value_str << "' too long, truncating to " << string_max_length << " bytes." << std::endl;
string_length = string_max_length;
}
memcpy (property.m_value.str, value_str.data(), string_length);
property.m_value.str[string_length] = 0;
result.m_socket_accessor->SetProperty<std::string>(
property.m_name,
json_property["value"]);
} else {
std::cerr << "Invalid type for property '" << property.m_name
<< "'. Cannot parse json to type '"
@ -344,7 +345,6 @@ AnimGraph AnimGraphResource::createInstance() const {
createRuntimeNodeInstances(result);
prepareGraphIOData(result);
connectRuntimeNodes(result);
setRuntimeNodeProperties(result);
result.updateOrderedNodes();
result.reset();
@ -387,7 +387,7 @@ void AnimGraphResource::prepareGraphIOData(AnimGraph& instance) const {
int input_block_offset = 0;
for (int i = 0; i < graph_inputs.size(); i++) {
graph_inputs[i].m_reference.ptr =
graph_inputs[i].m_value.ptr =
(void*)&instance.m_input_buffer[input_block_offset];
input_block_offset += sizeof(void*);
}
@ -403,7 +403,7 @@ void AnimGraphResource::prepareGraphIOData(AnimGraph& instance) const {
int output_block_offset = 0;
for (int i = 0; i < graph_outputs.size(); i++) {
graph_outputs[i].m_reference.ptr =
graph_outputs[i].m_value.ptr =
(void*)&instance.m_output_buffer[output_block_offset];
output_block_offset += graph_outputs[i].m_type_size;
}
@ -486,8 +486,8 @@ void AnimGraphResource::connectRuntimeNodes(AnimGraph& instance) const {
//
// Wire up outputs to inputs.
//
(*target_socket->m_reference.ptr_ptr) = source_socket->m_reference.ptr;
// (*source_socket->m_reference.ptr_ptr) = target_socket->m_reference.ptr;
(*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;
@ -516,39 +516,3 @@ void AnimGraphResource::connectRuntimeNodes(AnimGraph& instance) const {
}
}
void AnimGraphResource::setRuntimeNodeProperties(AnimGraph& instance) const {
for (int i = 2; i < m_nodes.size(); i++) {
const AnimNodeResource& node_resource = m_nodes[i];
NodeSocketAccessorBase* node_instance_accessor =
AnimNodeAccessorFactory(node_resource.m_type_name, instance.m_nodes[i]);
std::vector<Socket>& resource_properties = node_resource.m_socket_accessor->m_properties;
for (size_t j = 0, n = resource_properties.size(); j < n; j++) {
const Socket& property = resource_properties[j];
const std::string& name = property.m_name;
switch (property.m_type) {
case SocketType::SocketTypeBool:
node_instance_accessor->SetPropertyReferenceValue<const bool&>(name, property.m_value.flag);
break;
case SocketType::SocketTypeFloat:
node_instance_accessor->SetPropertyReferenceValue(name, property.m_value.float_value);
break;
case SocketType::SocketTypeVec3:
node_instance_accessor->SetPropertyReferenceValue(name, property.m_value.vec3);
break;
case SocketType::SocketTypeQuat:
node_instance_accessor->SetPropertyReferenceValue(name, property.m_value.quat);
break;
case SocketType::SocketTypeString:
node_instance_accessor->SetPropertyReferenceValue(name, property.m_value.str);
break;
default:
std::cerr << "Invalid socket type " << static_cast<int>(property.m_type) << std::endl;
}
}
delete node_instance_accessor;
}
}

2
src/AnimGraph/AnimGraphResource.h
View File

@ -141,11 +141,9 @@ struct AnimGraphResource {
}
AnimGraph createInstance() const;
void createRuntimeNodeInstances(AnimGraph& instance) const;
void prepareGraphIOData(AnimGraph& instance) const;
void connectRuntimeNodes(AnimGraph& instance) const;
void setRuntimeNodeProperties(AnimGraph& instance) const;
};
#endif //ANIMTESTBED_ANIMGRAPHRESOURCE_H

259
tests/AnimGraphResourceTests.cc
View File

@ -2,36 +2,11 @@
// Created by martin on 04.02.22.
//
#include "ozz/base/io/archive.h"
#include "ozz/base/io/stream.h"
#include "ozz/base/log.h"
#include "AnimGraph/AnimGraph.h"
#include "AnimGraph/AnimGraphEditor.h"
#include "AnimGraph/AnimGraphResource.h"
#include "catch.hpp"
bool load_skeleton (ozz::animation::Skeleton& skeleton, const char* filename) {
assert(filename);
ozz::io::File file(filename, "rb");
if (!file.opened()) {
ozz::log::Err() << "Failed to open skeleton file " << filename << "."
<< std::endl;
return false;
}
ozz::io::IArchive archive(&file);
if (!archive.TestTag<ozz::animation::Skeleton>()) {
ozz::log::Err() << "Failed to load skeleton instance from file " << filename
<< "." << std::endl;
return false;
}
// Once the tag is validated, reading cannot fail.
archive >> skeleton;
return true;
}
TEST_CASE("BasicGraph", "[AnimGraphResource]") {
AnimGraphResource graph_resource;
@ -48,9 +23,7 @@ TEST_CASE("BasicGraph", "[AnimGraphResource]") {
AnimNodeResource& walk_node = graph_resource.m_nodes[walk_node_index];
walk_node.m_name = "WalkAnim";
walk_node.m_socket_accessor->SetPropertyValue("Filename", "data/walk.anim.ozz");
AnimNodeResource& run_node = graph_resource.m_nodes[run_node_index];
run_node.m_socket_accessor->SetPropertyValue("Filename", "data/run.anim.ozz");
run_node.m_name = "RunAnim";
AnimNodeResource& blend_node = graph_resource.m_nodes[blend_node_index];
blend_node.m_name = "BlendWalkRun";
@ -62,27 +35,30 @@ TEST_CASE("BasicGraph", "[AnimGraphResource]") {
REQUIRE(blend_node.m_socket_accessor->GetInputIndex("Input0") == 0);
REQUIRE(blend_node.m_socket_accessor->GetInputIndex("Input1") == 1);
graph_resource.connectSockets(walk_node, "Output", blend_node, "Input0");
graph_resource.connectSockets(run_node, "Output", blend_node, "Input1");
graph_resource.connectSockets(
blend_node,
"Output",
graph_resource.getGraphOutputNode(),
"GraphOutput");
AnimGraphConnectionResource walk_to_blend;
walk_to_blend.source_node_index = walk_node_index;
walk_to_blend.source_socket_name = "Output";
walk_to_blend.target_node_index = blend_node_index;
walk_to_blend.target_socket_name = "Input0";
graph_resource.m_connections.push_back(walk_to_blend);
AnimGraphConnectionResource run_to_blend;
run_to_blend.source_node_index = run_node_index;
run_to_blend.source_socket_name = "Output";
run_to_blend.target_node_index = blend_node_index;
run_to_blend.target_socket_name = "Input1";
graph_resource.m_connections.push_back(run_to_blend);
AnimGraphConnectionResource blend_to_output;
blend_to_output.source_node_index = blend_node_index;
blend_to_output.source_socket_name = "Output";
blend_to_output.target_node_index = 0;
blend_to_output.target_socket_name = "GraphOutput";
graph_resource.m_connections.push_back(blend_to_output);
graph_resource.saveToFile("WalkGraph.animgraph.json");
AnimGraphResource graph_resource_loaded;
graph_resource_loaded.loadFromFile("WalkGraph.animgraph.json");
AnimGraph graph = graph_resource_loaded.createInstance();
AnimGraphContext graph_context;
graph_context.m_graph = &graph;
ozz::animation::Skeleton skeleton;
REQUIRE(load_skeleton(skeleton, "data/skeleton.ozz"));
graph_context.m_skeleton = &skeleton;
REQUIRE(graph.init(graph_context));
AnimGraph graph = graph_resource.createInstance();
REQUIRE(graph.m_nodes.size() == 5);
REQUIRE(graph.m_nodes[0]->m_node_type_name == "BlendTree");
@ -121,14 +97,7 @@ TEST_CASE("BasicGraph", "[AnimGraphResource]") {
graph.m_node_output_connections[anim_sampler_index1][0].m_target_node
== blend2_instance);
// Ensure animation sampler nodes use the correct files
REQUIRE(anim_sampler_walk->m_filename == "data/walk.anim.ozz");
REQUIRE(anim_sampler_walk->m_animation != nullptr);
REQUIRE(anim_sampler_run->m_filename == "data/run.anim.ozz");
REQUIRE(anim_sampler_run->m_animation != nullptr);
WHEN("Emulating Graph Evaluation") {
// Emulate evaluation
CHECK(graph.m_anim_data_work_buffer.m_available_data.size() == 5);
graph.prepareNodeEval(walk_node_index);
graph.finishNodeEval(walk_node_index);
@ -147,15 +116,14 @@ TEST_CASE("BasicGraph", "[AnimGraphResource]") {
graph.prepareNodeEval(0);
const Socket* graph_output_socket = graph.getOutputSocket("GraphOutput");
CHECK(blend2_instance->o_output == (*graph_output_socket->m_reference.ptr_ptr));
CHECK(blend2_instance->o_output == (*graph_output_socket->m_value.ptr_ptr));
AnimData* graph_output =
static_cast<AnimData*>(*graph_output_socket->m_reference.ptr_ptr);
static_cast<AnimData*>(*graph_output_socket->m_value.ptr_ptr);
graph.finishNodeEval(0);
CHECK(blend2_instance->o_output == nullptr);
CHECK(graph_output == (*graph_output_socket->m_reference.ptr_ptr));
CHECK(graph_output == (*graph_output_socket->m_value.ptr_ptr));
CHECK(graph.m_anim_data_work_buffer.m_available_data.size() == 5);
}
}
TEST_CASE("InputAttributeConversion", "[AnimGraphResource]") {
int node_id = 3321;
@ -182,8 +150,8 @@ TEST_CASE("ResourceSaveLoadMathGraphInputs", "[AnimGraphResource]") {
graph_resource_origin.clear();
graph_resource_origin.m_name = "TestInputOutputGraph";
size_t float_to_vec3_node_index = graph_resource_origin.addNode(
AnimNodeResourceFactory("MathFloatToVec3Node"));
size_t float_to_vec3_node_index =
graph_resource_origin.addNode(AnimNodeResourceFactory("MathFloatToVec3Node"));
AnimNodeResource& graph_output_node =
graph_resource_origin.getGraphOutputNode();
@ -232,6 +200,7 @@ TEST_CASE("ResourceSaveLoadMathGraphInputs", "[AnimGraphResource]") {
graph_output_node,
"GraphVec3Output"));
WHEN("Saving and loading graph resource") {
const char* filename = "ResourceSaveLoadGraphInputs.json";
graph_resource_origin.saveToFile(filename);
@ -271,30 +240,22 @@ TEST_CASE("ResourceSaveLoadMathGraphInputs", "[AnimGraphResource]") {
AnimGraph anim_graph = graph_resource_loaded.createInstance();
REQUIRE(anim_graph.getInputSocket("GraphFloatInput") != nullptr);
REQUIRE(
anim_graph.getInputPtr("GraphFloatInput")
== anim_graph.m_input_buffer);
REQUIRE(anim_graph.getInputPtr("GraphFloatInput") == anim_graph.m_input_buffer);
float* graph_float_input = nullptr;
graph_float_input =
static_cast<float*>(anim_graph.getInputPtr("GraphFloatInput"));
graph_float_input = static_cast<float*>(anim_graph.getInputPtr("GraphFloatInput"));
*graph_float_input = 123.456f;
AND_WHEN("Evaluating Graph") {
AnimGraphContext context = {&anim_graph, nullptr};
anim_graph.updateTime(0.f);
anim_graph.evaluate(context);
anim_graph.evaluate();
Socket* float_output_socket =
anim_graph.getOutputSocket("GraphFloatOutput");
Socket* vec3_output_socket =
anim_graph.getOutputSocket("GraphVec3Output");
Vec3& vec3_output =
*static_cast<Vec3*>(vec3_output_socket->m_reference.ptr);
anim_graph.evalOutputNode();
Socket* float_output_socket = anim_graph.getOutputSocket("GraphFloatOutput");
Socket* vec3_output_socket = anim_graph.getOutputSocket("GraphVec3Output");
Vec3& vec3_output = *static_cast<Vec3*>(vec3_output_socket->m_value.ptr);
THEN("output vector components equal the graph input vaulues") {
CHECK(vec3_output[0] == *graph_float_input);
CHECK(vec3_output[1] == *graph_float_input);
CHECK(vec3_output[2] == *graph_float_input);
@ -302,150 +263,6 @@ TEST_CASE("ResourceSaveLoadMathGraphInputs", "[AnimGraphResource]") {
}
}
}
}
}
TEST_CASE("SimpleMathEvaluations", "[AnimGraphResource]") {
AnimGraphResource graph_resource_origin;
graph_resource_origin.clear();
graph_resource_origin.m_name = "TestInputOutputGraph";
size_t math_add0_node_index =
graph_resource_origin.addNode(AnimNodeResourceFactory("MathAddNode"));
size_t math_add1_node_index =
graph_resource_origin.addNode(AnimNodeResourceFactory("MathAddNode"));
AnimNodeResource& graph_output_node =
graph_resource_origin.getGraphOutputNode();
graph_output_node.m_socket_accessor->RegisterInput<float>(
"GraphFloat0Output",
nullptr);
graph_output_node.m_socket_accessor->RegisterInput<float>(
"GraphFloat1Output",
nullptr);
graph_output_node.m_socket_accessor->RegisterInput<float>(
"GraphFloat2Output",
nullptr);
AnimNodeResource& graph_input_node =
graph_resource_origin.getGraphInputNode();
graph_input_node.m_socket_accessor->RegisterOutput<float>(
"GraphFloatInput",
nullptr);
// Prepare graph inputs and outputs
AnimNodeResource& math_add0_node =
graph_resource_origin.m_nodes[math_add0_node_index];
AnimNodeResource& math_add1_node =
graph_resource_origin.m_nodes[math_add1_node_index];
// direct output
REQUIRE(graph_resource_origin.connectSockets(
graph_input_node,
"GraphFloatInput",
graph_output_node,
"GraphFloat0Output"));
// add0 node
REQUIRE(graph_resource_origin.connectSockets(
graph_input_node,
"GraphFloatInput",
math_add0_node,
"Input0"));
REQUIRE(graph_resource_origin.connectSockets(
graph_input_node,
"GraphFloatInput",
math_add0_node,
"Input1"));
REQUIRE(graph_resource_origin.connectSockets(
math_add0_node,
"Output",
graph_output_node,
"GraphFloat1Output"));
// add1 node
REQUIRE(graph_resource_origin.connectSockets(
math_add0_node,
"Output",
math_add1_node,
"Input0"));
REQUIRE(graph_resource_origin.connectSockets(
graph_input_node,
"GraphFloatInput",
math_add1_node,
"Input1"));
REQUIRE(graph_resource_origin.connectSockets(
math_add1_node,
"Output",
graph_output_node,
"GraphFloat2Output"));
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];
WHEN("Instantiating an AnimGraph") {
AnimGraph anim_graph = graph_resource_loaded.createInstance();
REQUIRE(anim_graph.getInputSocket("GraphFloatInput") != nullptr);
REQUIRE(
anim_graph.getInputPtr("GraphFloatInput")
== anim_graph.m_input_buffer);
float* graph_float_input = nullptr;
graph_float_input =
static_cast<float*>(anim_graph.getInputPtr("GraphFloatInput"));
*graph_float_input = 123.456f;
AND_WHEN("Evaluating Graph") {
AnimGraphContext context = {&anim_graph, nullptr};
anim_graph.updateTime(0.f);
anim_graph.evaluate(context);
Socket* float0_output_socket =
anim_graph.getOutputSocket("GraphFloat0Output");
Socket* float1_output_socket =
anim_graph.getOutputSocket("GraphFloat1Output");
Socket* float2_output_socket =
anim_graph.getOutputSocket("GraphFloat2Output");
REQUIRE(float0_output_socket != nullptr);
REQUIRE(float1_output_socket != nullptr);
REQUIRE(float2_output_socket != nullptr);
float& float0_output =
*static_cast<float*>(float0_output_socket->m_reference.ptr);
float& float1_output =
*static_cast<float*>(float1_output_socket->m_reference.ptr);
float& float2_output =
*static_cast<float*>(float2_output_socket->m_reference.ptr);
THEN("output vector components equal the graph input vaulues") {
CHECK(float0_output == Approx(*graph_float_input));
CHECK(float1_output == Approx(*graph_float_input * 2.));
CHECK(float2_output == Approx(*graph_float_input * 3.));
}
}
}
}
}
/*
@ -541,7 +358,7 @@ TEST_CASE("GraphInputOutputConnectivity", "[AnimGraphResource]") {
dynamic_cast<Blend2Node*>(anim_graph.m_nodes[blend2_node_index]);
REQUIRE(
*anim_graph.m_socket_accessor->m_outputs[0].m_reference.ptr_ptr
*anim_graph.m_socket_accessor->m_outputs[0].m_value.ptr_ptr
== blend2_node->i_blend_weight);
float* float_input_ptr = (float*)anim_graph.getInput("GraphFloatInput");
REQUIRE(float_input_ptr == blend2_node->i_blend_weight);
@ -679,7 +496,7 @@ TEST_CASE("GraphInputOutputConnectivity", "[AnimGraphResource]") {
sampler_node
== anim_graph.getAnimNodeForInput(speed_scale_node_index, "Input"));
REQUIRE(speed_scale_node->o_output == blend2_node->i_input1);
REQUIRE(speed_scale_node->i_output == blend2_node->i_input1);
REQUIRE(
speed_scale_node
== anim_graph.getAnimNodeForInput(blend2_node_index, "Input1"));