1271 lines
38 KiB
C++
1271 lines
38 KiB
C++
/*************************************************************************/
|
|
/* animation_blend_tree.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "animation_blend_tree.h"
|
|
#include "scene/scene_string_names.h"
|
|
|
|
void AnimationNodeAnimation::set_animation(const StringName &p_name) {
|
|
animation = p_name;
|
|
_change_notify("animation");
|
|
}
|
|
|
|
StringName AnimationNodeAnimation::get_animation() const {
|
|
return animation;
|
|
}
|
|
|
|
Vector<String> (*AnimationNodeAnimation::get_editable_animation_list)() = NULL;
|
|
|
|
void AnimationNodeAnimation::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::REAL, time, PROPERTY_HINT_NONE, "", 0));
|
|
}
|
|
void AnimationNodeAnimation::_validate_property(PropertyInfo &property) const {
|
|
|
|
if (property.name == "animation" && get_editable_animation_list) {
|
|
Vector<String> names = get_editable_animation_list();
|
|
String anims;
|
|
for (int i = 0; i < names.size(); i++) {
|
|
|
|
if (i > 0) {
|
|
anims += ",";
|
|
}
|
|
anims += String(names[i]);
|
|
}
|
|
if (anims != String()) {
|
|
property.hint = PROPERTY_HINT_ENUM;
|
|
property.hint_string = anims;
|
|
}
|
|
}
|
|
}
|
|
|
|
float AnimationNodeAnimation::process(float p_time, bool p_seek) {
|
|
|
|
AnimationPlayer *ap = state->player;
|
|
ERR_FAIL_COND_V(!ap, 0);
|
|
|
|
float time = get_parameter(this->time);
|
|
|
|
if (!ap->has_animation(animation)) {
|
|
|
|
AnimationNodeBlendTree *tree = Object::cast_to<AnimationNodeBlendTree>(parent);
|
|
if (tree) {
|
|
String name = tree->get_node_name(Ref<AnimationNodeAnimation>(this));
|
|
make_invalid(vformat(RTR("On BlendTree node '%s', animation not found: '%s'"), name, animation));
|
|
|
|
} else {
|
|
make_invalid(vformat(RTR("Animation not found: '%s'"), animation));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
Ref<Animation> anim = ap->get_animation(animation);
|
|
|
|
float step;
|
|
|
|
if (p_seek) {
|
|
time = p_time;
|
|
step = 0;
|
|
} else {
|
|
time = MAX(0, time + p_time);
|
|
step = p_time;
|
|
}
|
|
|
|
float anim_size = anim->get_length();
|
|
|
|
if (anim->has_loop()) {
|
|
|
|
if (anim_size) {
|
|
time = Math::fposmod(time, anim_size);
|
|
}
|
|
|
|
} else if (time > anim_size) {
|
|
|
|
time = anim_size;
|
|
}
|
|
|
|
blend_animation(animation, time, step, p_seek, 1.0);
|
|
|
|
set_parameter(this->time, time);
|
|
|
|
return anim_size - time;
|
|
}
|
|
|
|
String AnimationNodeAnimation::get_caption() const {
|
|
return "Animation";
|
|
}
|
|
|
|
void AnimationNodeAnimation::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("set_animation", "name"), &AnimationNodeAnimation::set_animation);
|
|
ClassDB::bind_method(D_METHOD("get_animation"), &AnimationNodeAnimation::get_animation);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "animation"), "set_animation", "get_animation");
|
|
}
|
|
|
|
AnimationNodeAnimation::AnimationNodeAnimation() {
|
|
last_version = 0;
|
|
skip = false;
|
|
time = "time";
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
|
|
void AnimationNodeOneShot::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::BOOL, active));
|
|
r_list->push_back(PropertyInfo(Variant::BOOL, prev_active, PROPERTY_HINT_NONE, "", 0));
|
|
r_list->push_back(PropertyInfo(Variant::REAL, time, PROPERTY_HINT_NONE, "", 0));
|
|
r_list->push_back(PropertyInfo(Variant::REAL, remaining, PROPERTY_HINT_NONE, "", 0));
|
|
r_list->push_back(PropertyInfo(Variant::REAL, time_to_restart, PROPERTY_HINT_NONE, "", 0));
|
|
}
|
|
|
|
Variant AnimationNodeOneShot::get_parameter_default_value(const StringName &p_parameter) const {
|
|
if (p_parameter == active || p_parameter == prev_active) {
|
|
return false;
|
|
} else if (p_parameter == time_to_restart) {
|
|
return -1;
|
|
} else {
|
|
return 0.0;
|
|
}
|
|
}
|
|
|
|
void AnimationNodeOneShot::set_fadein_time(float p_time) {
|
|
|
|
fade_in = p_time;
|
|
}
|
|
|
|
void AnimationNodeOneShot::set_fadeout_time(float p_time) {
|
|
|
|
fade_out = p_time;
|
|
}
|
|
|
|
float AnimationNodeOneShot::get_fadein_time() const {
|
|
|
|
return fade_in;
|
|
}
|
|
float AnimationNodeOneShot::get_fadeout_time() const {
|
|
|
|
return fade_out;
|
|
}
|
|
|
|
void AnimationNodeOneShot::set_autorestart(bool p_active) {
|
|
|
|
autorestart = p_active;
|
|
}
|
|
void AnimationNodeOneShot::set_autorestart_delay(float p_time) {
|
|
|
|
autorestart_delay = p_time;
|
|
}
|
|
void AnimationNodeOneShot::set_autorestart_random_delay(float p_time) {
|
|
|
|
autorestart_random_delay = p_time;
|
|
}
|
|
|
|
bool AnimationNodeOneShot::has_autorestart() const {
|
|
|
|
return autorestart;
|
|
}
|
|
float AnimationNodeOneShot::get_autorestart_delay() const {
|
|
|
|
return autorestart_delay;
|
|
}
|
|
float AnimationNodeOneShot::get_autorestart_random_delay() const {
|
|
|
|
return autorestart_random_delay;
|
|
}
|
|
|
|
void AnimationNodeOneShot::set_mix_mode(MixMode p_mix) {
|
|
|
|
mix = p_mix;
|
|
}
|
|
AnimationNodeOneShot::MixMode AnimationNodeOneShot::get_mix_mode() const {
|
|
|
|
return mix;
|
|
}
|
|
|
|
String AnimationNodeOneShot::get_caption() const {
|
|
return "OneShot";
|
|
}
|
|
|
|
bool AnimationNodeOneShot::has_filter() const {
|
|
return true;
|
|
}
|
|
|
|
float AnimationNodeOneShot::process(float p_time, bool p_seek) {
|
|
|
|
bool active = get_parameter(this->active);
|
|
bool prev_active = get_parameter(this->prev_active);
|
|
float time = get_parameter(this->time);
|
|
float remaining = get_parameter(this->remaining);
|
|
float time_to_restart = get_parameter(this->time_to_restart);
|
|
|
|
if (!active) {
|
|
//make it as if this node doesn't exist, pass input 0 by.
|
|
if (prev_active) {
|
|
set_parameter(this->prev_active, false);
|
|
}
|
|
if (time_to_restart >= 0.0 && !p_seek) {
|
|
time_to_restart -= p_time;
|
|
if (time_to_restart < 0) {
|
|
//restart
|
|
set_parameter(this->active, true);
|
|
active = true;
|
|
}
|
|
set_parameter(this->time_to_restart, time_to_restart);
|
|
}
|
|
|
|
if (!active) {
|
|
return blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
|
|
}
|
|
}
|
|
|
|
bool os_seek = p_seek;
|
|
|
|
if (p_seek)
|
|
time = p_time;
|
|
bool do_start = !prev_active;
|
|
|
|
if (do_start) {
|
|
time = 0;
|
|
os_seek = true;
|
|
set_parameter(this->prev_active, true);
|
|
}
|
|
|
|
float blend;
|
|
|
|
if (time < fade_in) {
|
|
|
|
if (fade_in > 0)
|
|
blend = time / fade_in;
|
|
else
|
|
blend = 0; //wtf
|
|
|
|
} else if (!do_start && remaining < fade_out) {
|
|
|
|
if (fade_out)
|
|
blend = (remaining / fade_out);
|
|
else
|
|
blend = 1.0;
|
|
} else
|
|
blend = 1.0;
|
|
|
|
float main_rem;
|
|
if (mix == MIX_MODE_ADD) {
|
|
main_rem = blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
|
|
} else {
|
|
main_rem = blend_input(0, p_time, p_seek, 1.0 - blend, FILTER_BLEND, !sync);
|
|
}
|
|
|
|
float os_rem = blend_input(1, os_seek ? time : p_time, os_seek, blend, FILTER_PASS, false);
|
|
|
|
if (do_start) {
|
|
remaining = os_rem;
|
|
}
|
|
|
|
if (!p_seek) {
|
|
time += p_time;
|
|
remaining = os_rem;
|
|
if (remaining <= 0) {
|
|
set_parameter(this->active, false);
|
|
set_parameter(this->prev_active, false);
|
|
if (autorestart) {
|
|
float restart_sec = autorestart_delay + Math::randf() * autorestart_random_delay;
|
|
set_parameter(this->time_to_restart, restart_sec);
|
|
}
|
|
}
|
|
}
|
|
|
|
set_parameter(this->time, time);
|
|
set_parameter(this->remaining, remaining);
|
|
|
|
return MAX(main_rem, remaining);
|
|
}
|
|
void AnimationNodeOneShot::set_use_sync(bool p_sync) {
|
|
|
|
sync = p_sync;
|
|
}
|
|
|
|
bool AnimationNodeOneShot::is_using_sync() const {
|
|
|
|
return sync;
|
|
}
|
|
|
|
void AnimationNodeOneShot::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("set_fadein_time", "time"), &AnimationNodeOneShot::set_fadein_time);
|
|
ClassDB::bind_method(D_METHOD("get_fadein_time"), &AnimationNodeOneShot::get_fadein_time);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_fadeout_time", "time"), &AnimationNodeOneShot::set_fadeout_time);
|
|
ClassDB::bind_method(D_METHOD("get_fadeout_time"), &AnimationNodeOneShot::get_fadeout_time);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_autorestart", "enable"), &AnimationNodeOneShot::set_autorestart);
|
|
ClassDB::bind_method(D_METHOD("has_autorestart"), &AnimationNodeOneShot::has_autorestart);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_autorestart_delay", "enable"), &AnimationNodeOneShot::set_autorestart_delay);
|
|
ClassDB::bind_method(D_METHOD("get_autorestart_delay"), &AnimationNodeOneShot::get_autorestart_delay);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_autorestart_random_delay", "enable"), &AnimationNodeOneShot::set_autorestart_random_delay);
|
|
ClassDB::bind_method(D_METHOD("get_autorestart_random_delay"), &AnimationNodeOneShot::get_autorestart_random_delay);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_mix_mode", "mode"), &AnimationNodeOneShot::set_mix_mode);
|
|
ClassDB::bind_method(D_METHOD("get_mix_mode"), &AnimationNodeOneShot::get_mix_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeOneShot::set_use_sync);
|
|
ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeOneShot::is_using_sync);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "fadein_time", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_fadein_time", "get_fadein_time");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "fadeout_time", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_fadeout_time", "get_fadeout_time");
|
|
|
|
ADD_GROUP("autorestart_", "Auto Restart");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "autorestart"), "set_autorestart", "has_autorestart");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "autorestart_delay", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_autorestart_delay", "get_autorestart_delay");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "autorestart_random_delay", PROPERTY_HINT_RANGE, "0,60,0.01,or_greater"), "set_autorestart_random_delay", "get_autorestart_random_delay");
|
|
|
|
ADD_GROUP("", "");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
|
|
|
|
BIND_ENUM_CONSTANT(MIX_MODE_BLEND)
|
|
BIND_ENUM_CONSTANT(MIX_MODE_ADD)
|
|
}
|
|
|
|
AnimationNodeOneShot::AnimationNodeOneShot() {
|
|
|
|
add_input("in");
|
|
add_input("shot");
|
|
|
|
fade_in = 0.1;
|
|
fade_out = 0.1;
|
|
autorestart = false;
|
|
autorestart_delay = 1;
|
|
|
|
mix = MIX_MODE_BLEND;
|
|
sync = false;
|
|
|
|
active = "active";
|
|
prev_active = "prev_active";
|
|
time = "time";
|
|
remaining = "remaining";
|
|
time_to_restart = "time_to_restart";
|
|
}
|
|
|
|
////////////////////////////////////////////////
|
|
|
|
void AnimationNodeAdd2::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::REAL, add_amount, PROPERTY_HINT_RANGE, "0,1,0.01"));
|
|
}
|
|
Variant AnimationNodeAdd2::get_parameter_default_value(const StringName &p_parameter) const {
|
|
return 0;
|
|
}
|
|
|
|
String AnimationNodeAdd2::get_caption() const {
|
|
return "Add2";
|
|
}
|
|
void AnimationNodeAdd2::set_use_sync(bool p_sync) {
|
|
|
|
sync = p_sync;
|
|
}
|
|
|
|
bool AnimationNodeAdd2::is_using_sync() const {
|
|
|
|
return sync;
|
|
}
|
|
|
|
bool AnimationNodeAdd2::has_filter() const {
|
|
|
|
return true;
|
|
}
|
|
|
|
float AnimationNodeAdd2::process(float p_time, bool p_seek) {
|
|
|
|
float amount = get_parameter(add_amount);
|
|
float rem0 = blend_input(0, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
|
|
blend_input(1, p_time, p_seek, amount, FILTER_PASS, !sync);
|
|
|
|
return rem0;
|
|
}
|
|
|
|
void AnimationNodeAdd2::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeAdd2::set_use_sync);
|
|
ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeAdd2::is_using_sync);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
|
|
}
|
|
|
|
AnimationNodeAdd2::AnimationNodeAdd2() {
|
|
|
|
add_amount = "add_amount";
|
|
add_input("in");
|
|
add_input("add");
|
|
sync = false;
|
|
}
|
|
|
|
////////////////////////////////////////////////
|
|
|
|
void AnimationNodeAdd3::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::REAL, add_amount, PROPERTY_HINT_RANGE, "-1,1,0.01"));
|
|
}
|
|
Variant AnimationNodeAdd3::get_parameter_default_value(const StringName &p_parameter) const {
|
|
return 0;
|
|
}
|
|
|
|
String AnimationNodeAdd3::get_caption() const {
|
|
return "Add3";
|
|
}
|
|
void AnimationNodeAdd3::set_use_sync(bool p_sync) {
|
|
|
|
sync = p_sync;
|
|
}
|
|
|
|
bool AnimationNodeAdd3::is_using_sync() const {
|
|
|
|
return sync;
|
|
}
|
|
|
|
bool AnimationNodeAdd3::has_filter() const {
|
|
|
|
return true;
|
|
}
|
|
|
|
float AnimationNodeAdd3::process(float p_time, bool p_seek) {
|
|
|
|
float amount = get_parameter(add_amount);
|
|
blend_input(0, p_time, p_seek, MAX(0, -amount), FILTER_PASS, !sync);
|
|
float rem0 = blend_input(1, p_time, p_seek, 1.0, FILTER_IGNORE, !sync);
|
|
blend_input(2, p_time, p_seek, MAX(0, amount), FILTER_PASS, !sync);
|
|
|
|
return rem0;
|
|
}
|
|
|
|
void AnimationNodeAdd3::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeAdd3::set_use_sync);
|
|
ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeAdd3::is_using_sync);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
|
|
}
|
|
|
|
AnimationNodeAdd3::AnimationNodeAdd3() {
|
|
|
|
add_amount = "add_amount";
|
|
add_input("-add");
|
|
add_input("in");
|
|
add_input("+add");
|
|
sync = false;
|
|
}
|
|
/////////////////////////////////////////////
|
|
|
|
void AnimationNodeBlend2::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::REAL, blend_amount, PROPERTY_HINT_RANGE, "0,1,0.01"));
|
|
}
|
|
Variant AnimationNodeBlend2::get_parameter_default_value(const StringName &p_parameter) const {
|
|
return 0; //for blend amount
|
|
}
|
|
|
|
String AnimationNodeBlend2::get_caption() const {
|
|
return "Blend2";
|
|
}
|
|
|
|
float AnimationNodeBlend2::process(float p_time, bool p_seek) {
|
|
|
|
float amount = get_parameter(blend_amount);
|
|
|
|
float rem0 = blend_input(0, p_time, p_seek, 1.0 - amount, FILTER_BLEND, !sync);
|
|
float rem1 = blend_input(1, p_time, p_seek, amount, FILTER_PASS, !sync);
|
|
|
|
return amount > 0.5 ? rem1 : rem0; //hacky but good enough
|
|
}
|
|
|
|
void AnimationNodeBlend2::set_use_sync(bool p_sync) {
|
|
|
|
sync = p_sync;
|
|
}
|
|
|
|
bool AnimationNodeBlend2::is_using_sync() const {
|
|
|
|
return sync;
|
|
}
|
|
|
|
bool AnimationNodeBlend2::has_filter() const {
|
|
|
|
return true;
|
|
}
|
|
void AnimationNodeBlend2::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeBlend2::set_use_sync);
|
|
ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeBlend2::is_using_sync);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
|
|
}
|
|
AnimationNodeBlend2::AnimationNodeBlend2() {
|
|
blend_amount = "blend_amount";
|
|
add_input("in");
|
|
add_input("blend");
|
|
sync = false;
|
|
}
|
|
|
|
//////////////////////////////////////
|
|
|
|
void AnimationNodeBlend3::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::REAL, blend_amount, PROPERTY_HINT_RANGE, "-1,1,0.01"));
|
|
}
|
|
Variant AnimationNodeBlend3::get_parameter_default_value(const StringName &p_parameter) const {
|
|
return 0; //for blend amount
|
|
}
|
|
|
|
String AnimationNodeBlend3::get_caption() const {
|
|
return "Blend3";
|
|
}
|
|
|
|
void AnimationNodeBlend3::set_use_sync(bool p_sync) {
|
|
|
|
sync = p_sync;
|
|
}
|
|
|
|
bool AnimationNodeBlend3::is_using_sync() const {
|
|
|
|
return sync;
|
|
}
|
|
|
|
float AnimationNodeBlend3::process(float p_time, bool p_seek) {
|
|
|
|
float amount = get_parameter(blend_amount);
|
|
float rem0 = blend_input(0, p_time, p_seek, MAX(0, -amount), FILTER_IGNORE, !sync);
|
|
float rem1 = blend_input(1, p_time, p_seek, 1.0 - ABS(amount), FILTER_IGNORE, !sync);
|
|
float rem2 = blend_input(2, p_time, p_seek, MAX(0, amount), FILTER_IGNORE, !sync);
|
|
|
|
return amount > 0.5 ? rem2 : (amount < -0.5 ? rem0 : rem1); //hacky but good enough
|
|
}
|
|
|
|
void AnimationNodeBlend3::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("set_use_sync", "enable"), &AnimationNodeBlend3::set_use_sync);
|
|
ClassDB::bind_method(D_METHOD("is_using_sync"), &AnimationNodeBlend3::is_using_sync);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync"), "set_use_sync", "is_using_sync");
|
|
}
|
|
AnimationNodeBlend3::AnimationNodeBlend3() {
|
|
blend_amount = "blend_amount";
|
|
add_input("-blend");
|
|
add_input("in");
|
|
add_input("+blend");
|
|
sync = false;
|
|
}
|
|
|
|
/////////////////////////////////
|
|
|
|
void AnimationNodeTimeScale::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::REAL, scale, PROPERTY_HINT_RANGE, "0,32,0.01,or_greater"));
|
|
}
|
|
Variant AnimationNodeTimeScale::get_parameter_default_value(const StringName &p_parameter) const {
|
|
return 1.0; //initial timescale
|
|
}
|
|
|
|
String AnimationNodeTimeScale::get_caption() const {
|
|
return "TimeScale";
|
|
}
|
|
|
|
float AnimationNodeTimeScale::process(float p_time, bool p_seek) {
|
|
|
|
float scale = get_parameter(this->scale);
|
|
if (p_seek) {
|
|
return blend_input(0, p_time, true, 1.0, FILTER_IGNORE, false);
|
|
} else {
|
|
return blend_input(0, p_time * scale, false, 1.0, FILTER_IGNORE, false);
|
|
}
|
|
}
|
|
|
|
void AnimationNodeTimeScale::_bind_methods() {
|
|
}
|
|
AnimationNodeTimeScale::AnimationNodeTimeScale() {
|
|
scale = "scale";
|
|
add_input("in");
|
|
}
|
|
|
|
////////////////////////////////////
|
|
|
|
void AnimationNodeTimeSeek::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::REAL, seek_pos, PROPERTY_HINT_RANGE, "-1,3600,0.01,or_greater"));
|
|
}
|
|
Variant AnimationNodeTimeSeek::get_parameter_default_value(const StringName &p_parameter) const {
|
|
return 1.0; //initial timescale
|
|
}
|
|
|
|
String AnimationNodeTimeSeek::get_caption() const {
|
|
return "Seek";
|
|
}
|
|
|
|
float AnimationNodeTimeSeek::process(float p_time, bool p_seek) {
|
|
|
|
float seek_pos = get_parameter(this->seek_pos);
|
|
if (p_seek) {
|
|
return blend_input(0, p_time, true, 1.0, FILTER_IGNORE, false);
|
|
} else if (seek_pos >= 0) {
|
|
float ret = blend_input(0, seek_pos, true, 1.0, FILTER_IGNORE, false);
|
|
set_parameter(this->seek_pos, -1.0); //reset
|
|
_change_notify("seek_pos");
|
|
return ret;
|
|
} else {
|
|
return blend_input(0, p_time, false, 1.0, FILTER_IGNORE, false);
|
|
}
|
|
}
|
|
|
|
void AnimationNodeTimeSeek::_bind_methods() {
|
|
}
|
|
|
|
AnimationNodeTimeSeek::AnimationNodeTimeSeek() {
|
|
add_input("in");
|
|
seek_pos = "seek_position";
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
|
|
void AnimationNodeTransition::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
|
|
String anims;
|
|
for (int i = 0; i < enabled_inputs; i++) {
|
|
if (i > 0) {
|
|
anims += ",";
|
|
}
|
|
anims += inputs[i].name;
|
|
}
|
|
|
|
r_list->push_back(PropertyInfo(Variant::INT, current, PROPERTY_HINT_ENUM, anims));
|
|
r_list->push_back(PropertyInfo(Variant::INT, prev_current, PROPERTY_HINT_NONE, "", 0));
|
|
r_list->push_back(PropertyInfo(Variant::INT, prev, PROPERTY_HINT_NONE, "", 0));
|
|
r_list->push_back(PropertyInfo(Variant::REAL, time, PROPERTY_HINT_NONE, "", 0));
|
|
r_list->push_back(PropertyInfo(Variant::REAL, prev_xfading, PROPERTY_HINT_NONE, "", 0));
|
|
}
|
|
Variant AnimationNodeTransition::get_parameter_default_value(const StringName &p_parameter) const {
|
|
if (p_parameter == time || p_parameter == prev_xfading) {
|
|
return 0.0;
|
|
} else if (p_parameter == prev || p_parameter == prev_current) {
|
|
return -1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
String AnimationNodeTransition::get_caption() const {
|
|
return "Transition";
|
|
}
|
|
|
|
void AnimationNodeTransition::_update_inputs() {
|
|
while (get_input_count() < enabled_inputs) {
|
|
add_input(inputs[get_input_count()].name);
|
|
}
|
|
|
|
while (get_input_count() > enabled_inputs) {
|
|
remove_input(get_input_count() - 1);
|
|
}
|
|
}
|
|
|
|
void AnimationNodeTransition::set_enabled_inputs(int p_inputs) {
|
|
ERR_FAIL_INDEX(p_inputs, MAX_INPUTS);
|
|
enabled_inputs = p_inputs;
|
|
_update_inputs();
|
|
}
|
|
|
|
int AnimationNodeTransition::get_enabled_inputs() {
|
|
return enabled_inputs;
|
|
}
|
|
|
|
void AnimationNodeTransition::set_input_as_auto_advance(int p_input, bool p_enable) {
|
|
ERR_FAIL_INDEX(p_input, MAX_INPUTS);
|
|
inputs[p_input].auto_advance = p_enable;
|
|
}
|
|
|
|
bool AnimationNodeTransition::is_input_set_as_auto_advance(int p_input) const {
|
|
ERR_FAIL_INDEX_V(p_input, MAX_INPUTS, false);
|
|
return inputs[p_input].auto_advance;
|
|
}
|
|
|
|
void AnimationNodeTransition::set_input_caption(int p_input, const String &p_name) {
|
|
ERR_FAIL_INDEX(p_input, MAX_INPUTS);
|
|
inputs[p_input].name = p_name;
|
|
set_input_name(p_input, p_name);
|
|
}
|
|
|
|
String AnimationNodeTransition::get_input_caption(int p_input) const {
|
|
ERR_FAIL_INDEX_V(p_input, MAX_INPUTS, String());
|
|
return inputs[p_input].name;
|
|
}
|
|
|
|
#if 0
|
|
Ref<AnimationNodeBlendTree> tree = get_parent();
|
|
|
|
if (tree.is_valid() && current >= 0) {
|
|
prev = current;
|
|
prev_xfading = xfade;
|
|
time = 0;
|
|
current = p_current;
|
|
switched = true;
|
|
_change_notify("current");
|
|
} else {
|
|
current = p_current;
|
|
}
|
|
#endif
|
|
|
|
void AnimationNodeTransition::set_cross_fade_time(float p_fade) {
|
|
xfade = p_fade;
|
|
}
|
|
|
|
float AnimationNodeTransition::get_cross_fade_time() const {
|
|
return xfade;
|
|
}
|
|
|
|
float AnimationNodeTransition::process(float p_time, bool p_seek) {
|
|
|
|
int current = get_parameter(this->current);
|
|
int prev = get_parameter(this->prev);
|
|
int prev_current = get_parameter(this->prev_current);
|
|
|
|
float time = get_parameter(this->time);
|
|
float prev_xfading = get_parameter(this->prev_xfading);
|
|
|
|
bool switched = current != prev_current;
|
|
|
|
if (switched) {
|
|
set_parameter(this->prev_current, current);
|
|
set_parameter(this->prev, prev_current);
|
|
|
|
prev = prev_current;
|
|
prev_xfading = xfade;
|
|
time = 0;
|
|
switched = true;
|
|
}
|
|
|
|
if (current < 0 || current >= enabled_inputs || prev >= enabled_inputs) {
|
|
return 0;
|
|
}
|
|
|
|
float rem = 0;
|
|
|
|
if (prev < 0) { // process current animation, check for transition
|
|
|
|
rem = blend_input(current, p_time, p_seek, 1.0, FILTER_IGNORE, false);
|
|
|
|
if (p_seek)
|
|
time = p_time;
|
|
else
|
|
time += p_time;
|
|
|
|
if (inputs[current].auto_advance && rem <= xfade) {
|
|
|
|
set_parameter(this->current, (current + 1) % enabled_inputs);
|
|
}
|
|
|
|
} else { // cross-fading from prev to current
|
|
|
|
float blend = xfade ? (prev_xfading / xfade) : 1;
|
|
|
|
if (!p_seek && switched) { //just switched, seek to start of current
|
|
|
|
rem = blend_input(current, 0, true, 1.0 - blend, FILTER_IGNORE, false);
|
|
} else {
|
|
|
|
rem = blend_input(current, p_time, p_seek, 1.0 - blend, FILTER_IGNORE, false);
|
|
}
|
|
|
|
if (p_seek) { // don't seek prev animation
|
|
blend_input(prev, 0, false, blend, FILTER_IGNORE, false);
|
|
time = p_time;
|
|
} else {
|
|
blend_input(prev, p_time, false, blend, FILTER_IGNORE, false);
|
|
time += p_time;
|
|
prev_xfading -= p_time;
|
|
if (prev_xfading < 0) {
|
|
set_parameter(this->prev, -1);
|
|
}
|
|
}
|
|
}
|
|
|
|
set_parameter(this->time, time);
|
|
set_parameter(this->prev_xfading, prev_xfading);
|
|
|
|
return rem;
|
|
}
|
|
|
|
void AnimationNodeTransition::_validate_property(PropertyInfo &property) const {
|
|
|
|
if (property.name.begins_with("input_")) {
|
|
String n = property.name.get_slicec('/', 0).get_slicec('_', 1);
|
|
if (n != "count") {
|
|
int idx = n.to_int();
|
|
if (idx >= enabled_inputs) {
|
|
property.usage = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
AnimationNode::_validate_property(property);
|
|
}
|
|
|
|
void AnimationNodeTransition::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("set_enabled_inputs", "amount"), &AnimationNodeTransition::set_enabled_inputs);
|
|
ClassDB::bind_method(D_METHOD("get_enabled_inputs"), &AnimationNodeTransition::get_enabled_inputs);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_input_as_auto_advance", "input", "enable"), &AnimationNodeTransition::set_input_as_auto_advance);
|
|
ClassDB::bind_method(D_METHOD("is_input_set_as_auto_advance", "input"), &AnimationNodeTransition::is_input_set_as_auto_advance);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_input_caption", "input", "caption"), &AnimationNodeTransition::set_input_caption);
|
|
ClassDB::bind_method(D_METHOD("get_input_caption", "input"), &AnimationNodeTransition::get_input_caption);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_cross_fade_time", "time"), &AnimationNodeTransition::set_cross_fade_time);
|
|
ClassDB::bind_method(D_METHOD("get_cross_fade_time"), &AnimationNodeTransition::get_cross_fade_time);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "input_count", PROPERTY_HINT_RANGE, "0,64,1", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_enabled_inputs", "get_enabled_inputs");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "xfade_time", PROPERTY_HINT_RANGE, "0,120,0.01"), "set_cross_fade_time", "get_cross_fade_time");
|
|
|
|
for (int i = 0; i < MAX_INPUTS; i++) {
|
|
ADD_PROPERTYI(PropertyInfo(Variant::STRING, "input_" + itos(i) + "/name"), "set_input_caption", "get_input_caption", i);
|
|
ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "input_" + itos(i) + "/auto_advance"), "set_input_as_auto_advance", "is_input_set_as_auto_advance", i);
|
|
}
|
|
}
|
|
|
|
AnimationNodeTransition::AnimationNodeTransition() {
|
|
|
|
prev_xfading = "prev_xfading";
|
|
prev = "prev";
|
|
time = "time";
|
|
current = "current";
|
|
prev_current = "prev_current";
|
|
xfade = 0.0;
|
|
|
|
enabled_inputs = 0;
|
|
for (int i = 0; i < MAX_INPUTS; i++) {
|
|
inputs[i].auto_advance = false;
|
|
inputs[i].name = "state " + itos(i);
|
|
}
|
|
}
|
|
|
|
/////////////////////
|
|
|
|
String AnimationNodeOutput::get_caption() const {
|
|
return "Output";
|
|
}
|
|
|
|
float AnimationNodeOutput::process(float p_time, bool p_seek) {
|
|
return blend_input(0, p_time, p_seek, 1.0);
|
|
}
|
|
|
|
AnimationNodeOutput::AnimationNodeOutput() {
|
|
add_input("output");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////
|
|
void AnimationNodeBlendTree::add_node(const StringName &p_name, Ref<AnimationNode> p_node, const Vector2 &p_position) {
|
|
|
|
ERR_FAIL_COND(nodes.has(p_name));
|
|
ERR_FAIL_COND(p_node.is_null());
|
|
ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output);
|
|
ERR_FAIL_COND(String(p_name).find("/") != -1);
|
|
|
|
Node n;
|
|
n.node = p_node;
|
|
n.position = p_position;
|
|
n.connections.resize(n.node->get_input_count());
|
|
nodes[p_name] = n;
|
|
|
|
emit_changed();
|
|
emit_signal("tree_changed");
|
|
|
|
p_node->connect("tree_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
|
|
p_node->connect("changed", this, "_node_changed", varray(p_name), CONNECT_REFERENCE_COUNTED);
|
|
}
|
|
|
|
Ref<AnimationNode> AnimationNodeBlendTree::get_node(const StringName &p_name) const {
|
|
|
|
ERR_FAIL_COND_V(!nodes.has(p_name), Ref<AnimationNode>());
|
|
|
|
return nodes[p_name].node;
|
|
}
|
|
|
|
StringName AnimationNodeBlendTree::get_node_name(const Ref<AnimationNode> &p_node) const {
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
if (E->get().node == p_node) {
|
|
return E->key();
|
|
}
|
|
}
|
|
|
|
ERR_FAIL_V(StringName());
|
|
}
|
|
|
|
void AnimationNodeBlendTree::set_node_position(const StringName &p_node, const Vector2 &p_position) {
|
|
ERR_FAIL_COND(!nodes.has(p_node));
|
|
nodes[p_node].position = p_position;
|
|
}
|
|
|
|
Vector2 AnimationNodeBlendTree::get_node_position(const StringName &p_node) const {
|
|
ERR_FAIL_COND_V(!nodes.has(p_node), Vector2());
|
|
return nodes[p_node].position;
|
|
}
|
|
|
|
void AnimationNodeBlendTree::get_child_nodes(List<ChildNode> *r_child_nodes) {
|
|
Vector<StringName> ns;
|
|
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
ns.push_back(E->key());
|
|
}
|
|
|
|
ns.sort_custom<StringName::AlphCompare>();
|
|
|
|
for (int i = 0; i < ns.size(); i++) {
|
|
ChildNode cn;
|
|
cn.name = ns[i];
|
|
cn.node = nodes[cn.name].node;
|
|
r_child_nodes->push_back(cn);
|
|
}
|
|
}
|
|
|
|
bool AnimationNodeBlendTree::has_node(const StringName &p_name) const {
|
|
return nodes.has(p_name);
|
|
}
|
|
Vector<StringName> AnimationNodeBlendTree::get_node_connection_array(const StringName &p_name) const {
|
|
|
|
ERR_FAIL_COND_V(!nodes.has(p_name), Vector<StringName>());
|
|
return nodes[p_name].connections;
|
|
}
|
|
void AnimationNodeBlendTree::remove_node(const StringName &p_name) {
|
|
|
|
ERR_FAIL_COND(!nodes.has(p_name));
|
|
ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output); //can't delete output
|
|
|
|
{
|
|
Ref<AnimationNode> node = nodes[p_name].node;
|
|
node->disconnect("tree_changed", this, "_tree_changed");
|
|
node->disconnect("changed", this, "_node_changed");
|
|
}
|
|
|
|
nodes.erase(p_name);
|
|
|
|
//erase connections to name
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
for (int i = 0; i < E->get().connections.size(); i++) {
|
|
if (E->get().connections[i] == p_name) {
|
|
E->get().connections.write[i] = StringName();
|
|
}
|
|
}
|
|
}
|
|
|
|
emit_changed();
|
|
emit_signal("tree_changed");
|
|
}
|
|
|
|
void AnimationNodeBlendTree::rename_node(const StringName &p_name, const StringName &p_new_name) {
|
|
|
|
ERR_FAIL_COND(!nodes.has(p_name));
|
|
ERR_FAIL_COND(nodes.has(p_new_name));
|
|
ERR_FAIL_COND(p_name == SceneStringNames::get_singleton()->output);
|
|
ERR_FAIL_COND(p_new_name == SceneStringNames::get_singleton()->output);
|
|
|
|
nodes[p_name].node->disconnect("changed", this, "_node_changed");
|
|
|
|
nodes[p_new_name] = nodes[p_name];
|
|
nodes.erase(p_name);
|
|
|
|
//rename connections
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
|
|
for (int i = 0; i < E->get().connections.size(); i++) {
|
|
if (E->get().connections[i] == p_name) {
|
|
E->get().connections.write[i] = p_new_name;
|
|
}
|
|
}
|
|
}
|
|
//connection must be done with new name
|
|
nodes[p_new_name].node->connect("changed", this, "_node_changed", varray(p_new_name), CONNECT_REFERENCE_COUNTED);
|
|
|
|
emit_signal("tree_changed");
|
|
}
|
|
|
|
void AnimationNodeBlendTree::connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) {
|
|
|
|
ERR_FAIL_COND(!nodes.has(p_output_node));
|
|
ERR_FAIL_COND(!nodes.has(p_input_node));
|
|
ERR_FAIL_COND(p_output_node == SceneStringNames::get_singleton()->output);
|
|
ERR_FAIL_COND(p_input_node == p_output_node);
|
|
|
|
Ref<AnimationNode> input = nodes[p_input_node].node;
|
|
ERR_FAIL_INDEX(p_input_index, nodes[p_input_node].connections.size());
|
|
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
for (int i = 0; i < E->get().connections.size(); i++) {
|
|
StringName output = E->get().connections[i];
|
|
ERR_FAIL_COND(output == p_output_node);
|
|
}
|
|
}
|
|
|
|
nodes[p_input_node].connections.write[p_input_index] = p_output_node;
|
|
|
|
emit_changed();
|
|
}
|
|
|
|
void AnimationNodeBlendTree::disconnect_node(const StringName &p_node, int p_input_index) {
|
|
|
|
ERR_FAIL_COND(!nodes.has(p_node));
|
|
|
|
Ref<AnimationNode> input = nodes[p_node].node;
|
|
ERR_FAIL_INDEX(p_input_index, nodes[p_node].connections.size());
|
|
|
|
nodes[p_node].connections.write[p_input_index] = StringName();
|
|
}
|
|
|
|
AnimationNodeBlendTree::ConnectionError AnimationNodeBlendTree::can_connect_node(const StringName &p_input_node, int p_input_index, const StringName &p_output_node) const {
|
|
|
|
if (!nodes.has(p_output_node) || p_output_node == SceneStringNames::get_singleton()->output) {
|
|
return CONNECTION_ERROR_NO_OUTPUT;
|
|
}
|
|
|
|
if (!nodes.has(p_input_node)) {
|
|
return CONNECTION_ERROR_NO_INPUT;
|
|
}
|
|
|
|
if (!nodes.has(p_input_node)) {
|
|
return CONNECTION_ERROR_SAME_NODE;
|
|
}
|
|
|
|
Ref<AnimationNode> input = nodes[p_input_node].node;
|
|
|
|
if (p_input_index < 0 || p_input_index >= nodes[p_input_node].connections.size()) {
|
|
return CONNECTION_ERROR_NO_INPUT_INDEX;
|
|
}
|
|
|
|
if (nodes[p_input_node].connections[p_input_index] != StringName()) {
|
|
return CONNECTION_ERROR_CONNECTION_EXISTS;
|
|
}
|
|
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
for (int i = 0; i < E->get().connections.size(); i++) {
|
|
StringName output = E->get().connections[i];
|
|
if (output == p_output_node) {
|
|
return CONNECTION_ERROR_CONNECTION_EXISTS;
|
|
}
|
|
}
|
|
}
|
|
return CONNECTION_OK;
|
|
}
|
|
|
|
void AnimationNodeBlendTree::get_node_connections(List<NodeConnection> *r_connections) const {
|
|
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
for (int i = 0; i < E->get().connections.size(); i++) {
|
|
StringName output = E->get().connections[i];
|
|
if (output != StringName()) {
|
|
NodeConnection nc;
|
|
nc.input_node = E->key();
|
|
nc.input_index = i;
|
|
nc.output_node = output;
|
|
r_connections->push_back(nc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
String AnimationNodeBlendTree::get_caption() const {
|
|
return "BlendTree";
|
|
}
|
|
|
|
float AnimationNodeBlendTree::process(float p_time, bool p_seek) {
|
|
|
|
Ref<AnimationNodeOutput> output = nodes[SceneStringNames::get_singleton()->output].node;
|
|
return _blend_node("output", nodes[SceneStringNames::get_singleton()->output].connections, this, output, p_time, p_seek, 1.0);
|
|
}
|
|
|
|
void AnimationNodeBlendTree::get_node_list(List<StringName> *r_list) {
|
|
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
r_list->push_back(E->key());
|
|
}
|
|
}
|
|
|
|
void AnimationNodeBlendTree::set_graph_offset(const Vector2 &p_graph_offset) {
|
|
|
|
graph_offset = p_graph_offset;
|
|
}
|
|
|
|
Vector2 AnimationNodeBlendTree::get_graph_offset() const {
|
|
|
|
return graph_offset;
|
|
}
|
|
|
|
Ref<AnimationNode> AnimationNodeBlendTree::get_child_by_name(const StringName &p_name) {
|
|
return get_node(p_name);
|
|
}
|
|
|
|
bool AnimationNodeBlendTree::_set(const StringName &p_name, const Variant &p_value) {
|
|
|
|
String name = p_name;
|
|
if (name.begins_with("nodes/")) {
|
|
|
|
String node_name = name.get_slicec('/', 1);
|
|
String what = name.get_slicec('/', 2);
|
|
|
|
if (what == "node") {
|
|
Ref<AnimationNode> anode = p_value;
|
|
if (anode.is_valid()) {
|
|
add_node(node_name, p_value);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (what == "position") {
|
|
|
|
if (nodes.has(node_name)) {
|
|
nodes[node_name].position = p_value;
|
|
}
|
|
return true;
|
|
}
|
|
} else if (name == "node_connections") {
|
|
|
|
Array conns = p_value;
|
|
ERR_FAIL_COND_V(conns.size() % 3 != 0, false);
|
|
|
|
for (int i = 0; i < conns.size(); i += 3) {
|
|
connect_node(conns[i], conns[i + 1], conns[i + 2]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool AnimationNodeBlendTree::_get(const StringName &p_name, Variant &r_ret) const {
|
|
|
|
String name = p_name;
|
|
if (name.begins_with("nodes/")) {
|
|
String node_name = name.get_slicec('/', 1);
|
|
String what = name.get_slicec('/', 2);
|
|
|
|
if (what == "node") {
|
|
if (nodes.has(node_name)) {
|
|
r_ret = nodes[node_name].node;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (what == "position") {
|
|
|
|
if (nodes.has(node_name)) {
|
|
r_ret = nodes[node_name].position;
|
|
return true;
|
|
}
|
|
}
|
|
} else if (name == "node_connections") {
|
|
List<NodeConnection> nc;
|
|
get_node_connections(&nc);
|
|
Array conns;
|
|
conns.resize(nc.size() * 3);
|
|
|
|
int idx = 0;
|
|
for (List<NodeConnection>::Element *E = nc.front(); E; E = E->next()) {
|
|
conns[idx * 3 + 0] = E->get().input_node;
|
|
conns[idx * 3 + 1] = E->get().input_index;
|
|
conns[idx * 3 + 2] = E->get().output_node;
|
|
idx++;
|
|
}
|
|
|
|
r_ret = conns;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
void AnimationNodeBlendTree::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
|
|
List<StringName> names;
|
|
for (Map<StringName, Node>::Element *E = nodes.front(); E; E = E->next()) {
|
|
names.push_back(E->key());
|
|
}
|
|
names.sort_custom<StringName::AlphCompare>();
|
|
|
|
for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
|
|
String name = E->get();
|
|
if (name != "output") {
|
|
p_list->push_back(PropertyInfo(Variant::OBJECT, "nodes/" + name + "/node", PROPERTY_HINT_RESOURCE_TYPE, "AnimationNode", PROPERTY_USAGE_NOEDITOR));
|
|
}
|
|
p_list->push_back(PropertyInfo(Variant::VECTOR2, "nodes/" + name + "/position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
|
|
}
|
|
|
|
p_list->push_back(PropertyInfo(Variant::ARRAY, "node_connections", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
|
|
}
|
|
|
|
void AnimationNodeBlendTree::_tree_changed() {
|
|
emit_signal("tree_changed");
|
|
}
|
|
|
|
void AnimationNodeBlendTree::_node_changed(const StringName &p_node) {
|
|
|
|
ERR_FAIL_COND(!nodes.has(p_node));
|
|
nodes[p_node].connections.resize(nodes[p_node].node->get_input_count());
|
|
}
|
|
|
|
void AnimationNodeBlendTree::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("add_node", "name", "node", "position"), &AnimationNodeBlendTree::add_node, DEFVAL(Vector2()));
|
|
ClassDB::bind_method(D_METHOD("get_node", "name"), &AnimationNodeBlendTree::get_node);
|
|
ClassDB::bind_method(D_METHOD("remove_node", "name"), &AnimationNodeBlendTree::remove_node);
|
|
ClassDB::bind_method(D_METHOD("rename_node", "name", "new_name"), &AnimationNodeBlendTree::rename_node);
|
|
ClassDB::bind_method(D_METHOD("has_node", "name"), &AnimationNodeBlendTree::has_node);
|
|
ClassDB::bind_method(D_METHOD("connect_node", "input_node", "input_index", "output_node"), &AnimationNodeBlendTree::connect_node);
|
|
ClassDB::bind_method(D_METHOD("disconnect_node", "input_node", "input_index"), &AnimationNodeBlendTree::disconnect_node);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_node_position", "name", "position"), &AnimationNodeBlendTree::set_node_position);
|
|
ClassDB::bind_method(D_METHOD("get_node_position", "name"), &AnimationNodeBlendTree::get_node_position);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_graph_offset", "offset"), &AnimationNodeBlendTree::set_graph_offset);
|
|
ClassDB::bind_method(D_METHOD("get_graph_offset"), &AnimationNodeBlendTree::get_graph_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("_tree_changed"), &AnimationNodeBlendTree::_tree_changed);
|
|
ClassDB::bind_method(D_METHOD("_node_changed", "node"), &AnimationNodeBlendTree::_node_changed);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "graph_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_graph_offset", "get_graph_offset");
|
|
|
|
BIND_CONSTANT(CONNECTION_OK);
|
|
BIND_CONSTANT(CONNECTION_ERROR_NO_INPUT);
|
|
BIND_CONSTANT(CONNECTION_ERROR_NO_INPUT_INDEX);
|
|
BIND_CONSTANT(CONNECTION_ERROR_NO_OUTPUT);
|
|
BIND_CONSTANT(CONNECTION_ERROR_SAME_NODE);
|
|
BIND_CONSTANT(CONNECTION_ERROR_CONNECTION_EXISTS);
|
|
}
|
|
|
|
AnimationNodeBlendTree::AnimationNodeBlendTree() {
|
|
|
|
Ref<AnimationNodeOutput> output;
|
|
output.instance();
|
|
Node n;
|
|
n.node = output;
|
|
n.position = Vector2(300, 150);
|
|
n.connections.resize(1);
|
|
nodes["output"] = n;
|
|
}
|
|
|
|
AnimationNodeBlendTree::~AnimationNodeBlendTree() {
|
|
}
|