1426cd3b3a
As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see". Backported from #70885.
962 lines
33 KiB
C++
962 lines
33 KiB
C++
/**************************************************************************/
|
|
/* animation_node_state_machine.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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_node_state_machine.h"
|
|
|
|
/////////////////////////////////////////////////
|
|
|
|
void AnimationNodeStateMachineTransition::set_switch_mode(SwitchMode p_mode) {
|
|
switch_mode = p_mode;
|
|
}
|
|
|
|
AnimationNodeStateMachineTransition::SwitchMode AnimationNodeStateMachineTransition::get_switch_mode() const {
|
|
return switch_mode;
|
|
}
|
|
|
|
void AnimationNodeStateMachineTransition::set_auto_advance(bool p_enable) {
|
|
auto_advance = p_enable;
|
|
}
|
|
|
|
bool AnimationNodeStateMachineTransition::has_auto_advance() const {
|
|
return auto_advance;
|
|
}
|
|
|
|
void AnimationNodeStateMachineTransition::set_advance_condition(const StringName &p_condition) {
|
|
String cs = p_condition;
|
|
ERR_FAIL_COND(cs.find("/") != -1 || cs.find(":") != -1);
|
|
advance_condition = p_condition;
|
|
if (cs != String()) {
|
|
advance_condition_name = "conditions/" + cs;
|
|
} else {
|
|
advance_condition_name = StringName();
|
|
}
|
|
emit_signal("advance_condition_changed");
|
|
}
|
|
|
|
StringName AnimationNodeStateMachineTransition::get_advance_condition() const {
|
|
return advance_condition;
|
|
}
|
|
|
|
StringName AnimationNodeStateMachineTransition::get_advance_condition_name() const {
|
|
return advance_condition_name;
|
|
}
|
|
|
|
void AnimationNodeStateMachineTransition::set_xfade_time(float p_xfade) {
|
|
ERR_FAIL_COND(p_xfade < 0);
|
|
xfade = p_xfade;
|
|
emit_changed();
|
|
}
|
|
|
|
float AnimationNodeStateMachineTransition::get_xfade_time() const {
|
|
return xfade;
|
|
}
|
|
|
|
void AnimationNodeStateMachineTransition::set_disabled(bool p_disabled) {
|
|
disabled = p_disabled;
|
|
emit_changed();
|
|
}
|
|
|
|
bool AnimationNodeStateMachineTransition::is_disabled() const {
|
|
return disabled;
|
|
}
|
|
|
|
void AnimationNodeStateMachineTransition::set_priority(int p_priority) {
|
|
priority = p_priority;
|
|
emit_changed();
|
|
}
|
|
|
|
int AnimationNodeStateMachineTransition::get_priority() const {
|
|
return priority;
|
|
}
|
|
|
|
void AnimationNodeStateMachineTransition::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("set_switch_mode", "mode"), &AnimationNodeStateMachineTransition::set_switch_mode);
|
|
ClassDB::bind_method(D_METHOD("get_switch_mode"), &AnimationNodeStateMachineTransition::get_switch_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_auto_advance", "auto_advance"), &AnimationNodeStateMachineTransition::set_auto_advance);
|
|
ClassDB::bind_method(D_METHOD("has_auto_advance"), &AnimationNodeStateMachineTransition::has_auto_advance);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_advance_condition", "name"), &AnimationNodeStateMachineTransition::set_advance_condition);
|
|
ClassDB::bind_method(D_METHOD("get_advance_condition"), &AnimationNodeStateMachineTransition::get_advance_condition);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_xfade_time", "secs"), &AnimationNodeStateMachineTransition::set_xfade_time);
|
|
ClassDB::bind_method(D_METHOD("get_xfade_time"), &AnimationNodeStateMachineTransition::get_xfade_time);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_disabled", "disabled"), &AnimationNodeStateMachineTransition::set_disabled);
|
|
ClassDB::bind_method(D_METHOD("is_disabled"), &AnimationNodeStateMachineTransition::is_disabled);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_priority", "priority"), &AnimationNodeStateMachineTransition::set_priority);
|
|
ClassDB::bind_method(D_METHOD("get_priority"), &AnimationNodeStateMachineTransition::get_priority);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "switch_mode", PROPERTY_HINT_ENUM, "Immediate,Sync,AtEnd"), "set_switch_mode", "get_switch_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_advance"), "set_auto_advance", "has_auto_advance");
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "advance_condition"), "set_advance_condition", "get_advance_condition");
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "xfade_time", PROPERTY_HINT_RANGE, "0,240,0.01"), "set_xfade_time", "get_xfade_time");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "priority", PROPERTY_HINT_RANGE, "0,32,1"), "set_priority", "get_priority");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disabled"), "set_disabled", "is_disabled");
|
|
|
|
BIND_ENUM_CONSTANT(SWITCH_MODE_IMMEDIATE);
|
|
BIND_ENUM_CONSTANT(SWITCH_MODE_SYNC);
|
|
BIND_ENUM_CONSTANT(SWITCH_MODE_AT_END);
|
|
|
|
ADD_SIGNAL(MethodInfo("advance_condition_changed"));
|
|
}
|
|
|
|
AnimationNodeStateMachineTransition::AnimationNodeStateMachineTransition() {
|
|
switch_mode = SWITCH_MODE_IMMEDIATE;
|
|
auto_advance = false;
|
|
xfade = 0;
|
|
disabled = false;
|
|
priority = 1;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
|
|
void AnimationNodeStateMachinePlayback::travel(const StringName &p_state) {
|
|
start_request_travel = true;
|
|
start_request = p_state;
|
|
stop_request = false;
|
|
}
|
|
|
|
void AnimationNodeStateMachinePlayback::start(const StringName &p_state) {
|
|
start_request_travel = false;
|
|
start_request = p_state;
|
|
stop_request = false;
|
|
}
|
|
void AnimationNodeStateMachinePlayback::stop() {
|
|
stop_request = true;
|
|
}
|
|
bool AnimationNodeStateMachinePlayback::is_playing() const {
|
|
return playing;
|
|
}
|
|
StringName AnimationNodeStateMachinePlayback::get_current_node() const {
|
|
return current;
|
|
}
|
|
StringName AnimationNodeStateMachinePlayback::get_blend_from_node() const {
|
|
return fading_from;
|
|
}
|
|
Vector<StringName> AnimationNodeStateMachinePlayback::get_travel_path() const {
|
|
return path;
|
|
}
|
|
float AnimationNodeStateMachinePlayback::get_current_play_pos() const {
|
|
return pos_current;
|
|
}
|
|
float AnimationNodeStateMachinePlayback::get_current_length() const {
|
|
return len_current;
|
|
}
|
|
|
|
bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_state_machine, const StringName &p_travel) {
|
|
ERR_FAIL_COND_V(!playing, false);
|
|
ERR_FAIL_COND_V(!p_state_machine->states.has(p_travel), false);
|
|
ERR_FAIL_COND_V(!p_state_machine->states.has(current), false);
|
|
|
|
path.clear(); //a new one will be needed
|
|
|
|
if (current == p_travel) {
|
|
return true; //nothing to do
|
|
}
|
|
|
|
Vector2 current_pos = p_state_machine->states[current].position;
|
|
Vector2 target_pos = p_state_machine->states[p_travel].position;
|
|
|
|
Map<StringName, AStarCost> cost_map;
|
|
|
|
List<int> open_list;
|
|
|
|
//build open list
|
|
for (int i = 0; i < p_state_machine->transitions.size(); i++) {
|
|
if (p_state_machine->transitions[i].from == current) {
|
|
open_list.push_back(i);
|
|
float cost = p_state_machine->states[p_state_machine->transitions[i].to].position.distance_to(current_pos);
|
|
cost *= p_state_machine->transitions[i].transition->get_priority();
|
|
AStarCost ap;
|
|
ap.prev = current;
|
|
ap.distance = cost;
|
|
cost_map[p_state_machine->transitions[i].to] = ap;
|
|
|
|
if (p_state_machine->transitions[i].to == p_travel) { //prematurely found it! :D
|
|
path.push_back(p_travel);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//begin astar
|
|
bool found_route = false;
|
|
while (!found_route) {
|
|
if (open_list.size() == 0) {
|
|
return false; //no path found
|
|
}
|
|
|
|
//find the last cost transition
|
|
List<int>::Element *least_cost_transition = nullptr;
|
|
float least_cost = 1e20;
|
|
|
|
for (List<int>::Element *E = open_list.front(); E; E = E->next()) {
|
|
float cost = cost_map[p_state_machine->transitions[E->get()].to].distance;
|
|
cost += p_state_machine->states[p_state_machine->transitions[E->get()].to].position.distance_to(target_pos);
|
|
|
|
if (cost < least_cost) {
|
|
least_cost_transition = E;
|
|
least_cost = cost;
|
|
}
|
|
}
|
|
|
|
StringName transition_prev = p_state_machine->transitions[least_cost_transition->get()].from;
|
|
StringName transition = p_state_machine->transitions[least_cost_transition->get()].to;
|
|
|
|
for (int i = 0; i < p_state_machine->transitions.size(); i++) {
|
|
if (p_state_machine->transitions[i].from != transition || p_state_machine->transitions[i].to == transition_prev) {
|
|
continue; //not interested on those
|
|
}
|
|
|
|
float distance = p_state_machine->states[p_state_machine->transitions[i].from].position.distance_to(p_state_machine->states[p_state_machine->transitions[i].to].position);
|
|
distance *= p_state_machine->transitions[i].transition->get_priority();
|
|
distance += cost_map[p_state_machine->transitions[i].from].distance;
|
|
|
|
if (cost_map.has(p_state_machine->transitions[i].to)) {
|
|
//oh this was visited already, can we win the cost?
|
|
if (distance < cost_map[p_state_machine->transitions[i].to].distance) {
|
|
cost_map[p_state_machine->transitions[i].to].distance = distance;
|
|
cost_map[p_state_machine->transitions[i].to].prev = p_state_machine->transitions[i].from;
|
|
}
|
|
} else {
|
|
//add to open list
|
|
AStarCost ac;
|
|
ac.prev = p_state_machine->transitions[i].from;
|
|
ac.distance = distance;
|
|
cost_map[p_state_machine->transitions[i].to] = ac;
|
|
|
|
open_list.push_back(i);
|
|
|
|
if (p_state_machine->transitions[i].to == p_travel) {
|
|
found_route = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (found_route) {
|
|
break;
|
|
}
|
|
|
|
open_list.erase(least_cost_transition);
|
|
}
|
|
|
|
//make path
|
|
StringName at = p_travel;
|
|
while (at != current) {
|
|
path.push_back(at);
|
|
at = cost_map[at].prev;
|
|
}
|
|
|
|
path.invert();
|
|
|
|
return true;
|
|
}
|
|
|
|
float AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_state_machine, float p_time, bool p_seek) {
|
|
//if not playing and it can restart, then restart
|
|
if (!playing && start_request == StringName()) {
|
|
if (!stop_request && p_state_machine->start_node) {
|
|
start(p_state_machine->start_node);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (playing && stop_request) {
|
|
stop_request = false;
|
|
playing = false;
|
|
return 0;
|
|
}
|
|
|
|
bool play_start = false;
|
|
|
|
if (start_request != StringName()) {
|
|
if (start_request_travel) {
|
|
if (!playing) {
|
|
if (!stop_request && p_state_machine->start_node) {
|
|
// can restart, just postpone traveling
|
|
path.clear();
|
|
current = p_state_machine->start_node;
|
|
playing = true;
|
|
play_start = true;
|
|
} else {
|
|
// stopped, invalid state
|
|
String node_name = start_request;
|
|
start_request = StringName(); //clear start request
|
|
ERR_FAIL_V_MSG(0, "Can't travel to '" + node_name + "' if state machine is not playing. Maybe you need to enable Autoplay on Load for one of the nodes in your state machine or call .start() first?");
|
|
}
|
|
} else {
|
|
if (!_travel(p_state_machine, start_request)) {
|
|
// can't travel, then teleport
|
|
path.clear();
|
|
current = start_request;
|
|
}
|
|
start_request = StringName(); //clear start request
|
|
}
|
|
} else {
|
|
// teleport to start
|
|
if (p_state_machine->states.has(start_request)) {
|
|
path.clear();
|
|
current = start_request;
|
|
playing = true;
|
|
play_start = true;
|
|
start_request = StringName(); //clear start request
|
|
} else {
|
|
StringName node = start_request;
|
|
start_request = StringName(); //clear start request
|
|
ERR_FAIL_V_MSG(0, "No such node: '" + node + "'");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool do_start = (p_seek && p_time == 0) || play_start || current == StringName();
|
|
|
|
if (do_start) {
|
|
if (p_state_machine->start_node != StringName() && p_seek && p_time == 0) {
|
|
current = p_state_machine->start_node;
|
|
}
|
|
|
|
len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, 1.0, AnimationNode::FILTER_IGNORE, false);
|
|
pos_current = 0;
|
|
}
|
|
|
|
if (!p_state_machine->states.has(current)) {
|
|
playing = false; //current does not exist
|
|
current = StringName();
|
|
return 0;
|
|
}
|
|
float fade_blend = 1.0;
|
|
|
|
if (fading_from != StringName()) {
|
|
if (!p_state_machine->states.has(fading_from)) {
|
|
fading_from = StringName();
|
|
} else {
|
|
if (!p_seek) {
|
|
fading_pos += p_time;
|
|
}
|
|
fade_blend = MIN(1.0, fading_pos / fading_time);
|
|
if (fade_blend >= 1.0) {
|
|
fading_from = StringName();
|
|
}
|
|
}
|
|
}
|
|
|
|
float rem = p_state_machine->blend_node(current, p_state_machine->states[current].node, p_time, p_seek, fade_blend, AnimationNode::FILTER_IGNORE, false);
|
|
|
|
if (fading_from != StringName()) {
|
|
p_state_machine->blend_node(fading_from, p_state_machine->states[fading_from].node, p_time, p_seek, 1.0 - fade_blend, AnimationNode::FILTER_IGNORE, false);
|
|
}
|
|
|
|
//guess playback position
|
|
if (rem > len_current) { // weird but ok
|
|
len_current = rem;
|
|
}
|
|
|
|
{ //advance and loop check
|
|
float next_pos = len_current - rem;
|
|
end_loop = next_pos < pos_current;
|
|
pos_current = next_pos; //looped
|
|
}
|
|
|
|
//find next
|
|
StringName next;
|
|
float next_xfade = 0;
|
|
AnimationNodeStateMachineTransition::SwitchMode switch_mode = AnimationNodeStateMachineTransition::SWITCH_MODE_IMMEDIATE;
|
|
|
|
if (path.size()) {
|
|
for (int i = 0; i < p_state_machine->transitions.size(); i++) {
|
|
if (p_state_machine->transitions[i].from == current && p_state_machine->transitions[i].to == path[0]) {
|
|
next_xfade = p_state_machine->transitions[i].transition->get_xfade_time();
|
|
switch_mode = p_state_machine->transitions[i].transition->get_switch_mode();
|
|
next = path[0];
|
|
}
|
|
}
|
|
} else {
|
|
float priority_best = 1e20;
|
|
int auto_advance_to = -1;
|
|
for (int i = 0; i < p_state_machine->transitions.size(); i++) {
|
|
bool auto_advance = false;
|
|
if (p_state_machine->transitions[i].transition->has_auto_advance()) {
|
|
auto_advance = true;
|
|
}
|
|
StringName advance_condition_name = p_state_machine->transitions[i].transition->get_advance_condition_name();
|
|
if (advance_condition_name != StringName() && bool(p_state_machine->get_parameter(advance_condition_name))) {
|
|
auto_advance = true;
|
|
}
|
|
|
|
if (p_state_machine->transitions[i].from == current && auto_advance) {
|
|
if (p_state_machine->transitions[i].transition->get_priority() <= priority_best) {
|
|
priority_best = p_state_machine->transitions[i].transition->get_priority();
|
|
auto_advance_to = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (auto_advance_to != -1) {
|
|
next = p_state_machine->transitions[auto_advance_to].to;
|
|
next_xfade = p_state_machine->transitions[auto_advance_to].transition->get_xfade_time();
|
|
switch_mode = p_state_machine->transitions[auto_advance_to].transition->get_switch_mode();
|
|
}
|
|
}
|
|
|
|
//if next, see when to transition
|
|
if (next != StringName()) {
|
|
bool goto_next = false;
|
|
|
|
if (switch_mode == AnimationNodeStateMachineTransition::SWITCH_MODE_AT_END) {
|
|
goto_next = next_xfade >= (len_current - pos_current) || end_loop;
|
|
if (end_loop) {
|
|
next_xfade = 0;
|
|
}
|
|
} else {
|
|
goto_next = fading_from == StringName();
|
|
}
|
|
|
|
if (goto_next) { //end_loop should be used because fade time may be too small or zero and animation may have looped
|
|
|
|
if (next_xfade) {
|
|
//time to fade, baby
|
|
fading_from = current;
|
|
fading_time = next_xfade;
|
|
fading_pos = 0;
|
|
} else {
|
|
fading_from = StringName();
|
|
fading_pos = 0;
|
|
}
|
|
|
|
if (path.size()) { //if it came from path, remove path
|
|
path.remove(0);
|
|
}
|
|
current = next;
|
|
if (switch_mode == AnimationNodeStateMachineTransition::SWITCH_MODE_SYNC) {
|
|
len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, 0, AnimationNode::FILTER_IGNORE, false);
|
|
pos_current = MIN(pos_current, len_current);
|
|
p_state_machine->blend_node(current, p_state_machine->states[current].node, pos_current, true, 0, AnimationNode::FILTER_IGNORE, false);
|
|
|
|
} else {
|
|
len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, 0, AnimationNode::FILTER_IGNORE, false);
|
|
pos_current = 0;
|
|
}
|
|
|
|
rem = len_current; //so it does not show 0 on transition
|
|
}
|
|
}
|
|
|
|
//compute time left for transitions by using the end node
|
|
if (p_state_machine->end_node != StringName() && p_state_machine->end_node != current) {
|
|
rem = p_state_machine->blend_node(p_state_machine->end_node, p_state_machine->states[p_state_machine->end_node].node, 0, true, 0, AnimationNode::FILTER_IGNORE, false);
|
|
}
|
|
|
|
return rem;
|
|
}
|
|
|
|
void AnimationNodeStateMachinePlayback::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("travel", "to_node"), &AnimationNodeStateMachinePlayback::travel);
|
|
ClassDB::bind_method(D_METHOD("start", "node"), &AnimationNodeStateMachinePlayback::start);
|
|
ClassDB::bind_method(D_METHOD("stop"), &AnimationNodeStateMachinePlayback::stop);
|
|
ClassDB::bind_method(D_METHOD("is_playing"), &AnimationNodeStateMachinePlayback::is_playing);
|
|
ClassDB::bind_method(D_METHOD("get_current_node"), &AnimationNodeStateMachinePlayback::get_current_node);
|
|
ClassDB::bind_method(D_METHOD("get_current_play_position"), &AnimationNodeStateMachinePlayback::get_current_play_pos);
|
|
ClassDB::bind_method(D_METHOD("get_current_length"), &AnimationNodeStateMachinePlayback::get_current_length);
|
|
ClassDB::bind_method(D_METHOD("get_travel_path"), &AnimationNodeStateMachinePlayback::get_travel_path);
|
|
}
|
|
|
|
AnimationNodeStateMachinePlayback::AnimationNodeStateMachinePlayback() {
|
|
set_local_to_scene(true); //only one per instanced scene
|
|
|
|
playing = false;
|
|
len_current = 0;
|
|
fading_time = 0;
|
|
stop_request = false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////
|
|
|
|
void AnimationNodeStateMachine::get_parameter_list(List<PropertyInfo> *r_list) const {
|
|
r_list->push_back(PropertyInfo(Variant::OBJECT, playback, PROPERTY_HINT_RESOURCE_TYPE, "AnimationNodeStateMachinePlayback", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
|
|
List<StringName> advance_conditions;
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
StringName ac = transitions[i].transition->get_advance_condition_name();
|
|
if (ac != StringName() && advance_conditions.find(ac) == nullptr) {
|
|
advance_conditions.push_back(ac);
|
|
}
|
|
}
|
|
|
|
advance_conditions.sort_custom<StringName::AlphCompare>();
|
|
for (List<StringName>::Element *E = advance_conditions.front(); E; E = E->next()) {
|
|
r_list->push_back(PropertyInfo(Variant::BOOL, E->get()));
|
|
}
|
|
}
|
|
|
|
Variant AnimationNodeStateMachine::get_parameter_default_value(const StringName &p_parameter) const {
|
|
if (p_parameter == playback) {
|
|
Ref<AnimationNodeStateMachinePlayback> p;
|
|
p.instance();
|
|
return p;
|
|
} else {
|
|
return false; //advance condition
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachine::add_node(const StringName &p_name, Ref<AnimationNode> p_node, const Vector2 &p_position) {
|
|
ERR_FAIL_COND(states.has(p_name));
|
|
ERR_FAIL_COND(p_node.is_null());
|
|
ERR_FAIL_COND(String(p_name).find("/") != -1);
|
|
|
|
State state;
|
|
state.node = p_node;
|
|
state.position = p_position;
|
|
|
|
states[p_name] = state;
|
|
|
|
emit_changed();
|
|
emit_signal("tree_changed");
|
|
|
|
p_node->connect("tree_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
|
|
}
|
|
|
|
void AnimationNodeStateMachine::replace_node(const StringName &p_name, Ref<AnimationNode> p_node) {
|
|
ERR_FAIL_COND(states.has(p_name) == false);
|
|
ERR_FAIL_COND(p_node.is_null());
|
|
ERR_FAIL_COND(String(p_name).find("/") != -1);
|
|
|
|
{
|
|
Ref<AnimationNode> node = states[p_name].node;
|
|
if (node.is_valid()) {
|
|
node->disconnect("tree_changed", this, "_tree_changed");
|
|
}
|
|
}
|
|
|
|
states[p_name].node = p_node;
|
|
|
|
emit_changed();
|
|
emit_signal("tree_changed");
|
|
|
|
p_node->connect("tree_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
|
|
}
|
|
|
|
Ref<AnimationNode> AnimationNodeStateMachine::get_node(const StringName &p_name) const {
|
|
ERR_FAIL_COND_V(!states.has(p_name), Ref<AnimationNode>());
|
|
|
|
return states[p_name].node;
|
|
}
|
|
|
|
StringName AnimationNodeStateMachine::get_node_name(const Ref<AnimationNode> &p_node) const {
|
|
for (Map<StringName, State>::Element *E = states.front(); E; E = E->next()) {
|
|
if (E->get().node == p_node) {
|
|
return E->key();
|
|
}
|
|
}
|
|
|
|
ERR_FAIL_V(StringName());
|
|
}
|
|
|
|
void AnimationNodeStateMachine::get_child_nodes(List<ChildNode> *r_child_nodes) {
|
|
Vector<StringName> nodes;
|
|
|
|
for (Map<StringName, State>::Element *E = states.front(); E; E = E->next()) {
|
|
nodes.push_back(E->key());
|
|
}
|
|
|
|
nodes.sort_custom<StringName::AlphCompare>();
|
|
|
|
for (int i = 0; i < nodes.size(); i++) {
|
|
ChildNode cn;
|
|
cn.name = nodes[i];
|
|
cn.node = states[cn.name].node;
|
|
r_child_nodes->push_back(cn);
|
|
}
|
|
}
|
|
|
|
bool AnimationNodeStateMachine::has_node(const StringName &p_name) const {
|
|
return states.has(p_name);
|
|
}
|
|
void AnimationNodeStateMachine::remove_node(const StringName &p_name) {
|
|
ERR_FAIL_COND(!states.has(p_name));
|
|
|
|
{
|
|
Ref<AnimationNode> node = states[p_name].node;
|
|
|
|
ERR_FAIL_COND(node.is_null());
|
|
|
|
node->disconnect("tree_changed", this, "_tree_changed");
|
|
}
|
|
|
|
states.erase(p_name);
|
|
//path.erase(p_name);
|
|
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
if (transitions[i].from == p_name || transitions[i].to == p_name) {
|
|
transitions.write[i].transition->disconnect("advance_condition_changed", this, "_tree_changed");
|
|
transitions.remove(i);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
if (start_node == p_name) {
|
|
start_node = StringName();
|
|
}
|
|
|
|
if (end_node == p_name) {
|
|
end_node = StringName();
|
|
}
|
|
|
|
/*if (playing && current == p_name) {
|
|
stop();
|
|
}*/
|
|
|
|
emit_changed();
|
|
emit_signal("tree_changed");
|
|
}
|
|
|
|
void AnimationNodeStateMachine::rename_node(const StringName &p_name, const StringName &p_new_name) {
|
|
ERR_FAIL_COND(!states.has(p_name));
|
|
ERR_FAIL_COND(states.has(p_new_name));
|
|
|
|
states[p_new_name] = states[p_name];
|
|
states.erase(p_name);
|
|
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
if (transitions[i].from == p_name) {
|
|
transitions.write[i].from = p_new_name;
|
|
}
|
|
|
|
if (transitions[i].to == p_name) {
|
|
transitions.write[i].to = p_new_name;
|
|
}
|
|
}
|
|
|
|
if (start_node == p_name) {
|
|
start_node = p_new_name;
|
|
}
|
|
|
|
if (end_node == p_name) {
|
|
end_node = p_new_name;
|
|
}
|
|
|
|
/*if (playing && current == p_name) {
|
|
current = p_new_name;
|
|
}*/
|
|
|
|
//path.clear(); //clear path
|
|
emit_signal("tree_changed");
|
|
}
|
|
|
|
void AnimationNodeStateMachine::get_node_list(List<StringName> *r_nodes) const {
|
|
List<StringName> nodes;
|
|
for (Map<StringName, State>::Element *E = states.front(); E; E = E->next()) {
|
|
nodes.push_back(E->key());
|
|
}
|
|
nodes.sort_custom<StringName::AlphCompare>();
|
|
|
|
for (List<StringName>::Element *E = nodes.front(); E; E = E->next()) {
|
|
r_nodes->push_back(E->get());
|
|
}
|
|
}
|
|
|
|
bool AnimationNodeStateMachine::has_transition(const StringName &p_from, const StringName &p_to) const {
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
if (transitions[i].from == p_from && transitions[i].to == p_to) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int AnimationNodeStateMachine::find_transition(const StringName &p_from, const StringName &p_to) const {
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
if (transitions[i].from == p_from && transitions[i].to == p_to) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void AnimationNodeStateMachine::add_transition(const StringName &p_from, const StringName &p_to, const Ref<AnimationNodeStateMachineTransition> &p_transition) {
|
|
ERR_FAIL_COND(p_from == p_to);
|
|
ERR_FAIL_COND(!states.has(p_from));
|
|
ERR_FAIL_COND(!states.has(p_to));
|
|
ERR_FAIL_COND(p_transition.is_null());
|
|
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
ERR_FAIL_COND(transitions[i].from == p_from && transitions[i].to == p_to);
|
|
}
|
|
|
|
Transition tr;
|
|
tr.from = p_from;
|
|
tr.to = p_to;
|
|
tr.transition = p_transition;
|
|
|
|
tr.transition->connect("advance_condition_changed", this, "_tree_changed", varray(), CONNECT_REFERENCE_COUNTED);
|
|
|
|
transitions.push_back(tr);
|
|
}
|
|
|
|
Ref<AnimationNodeStateMachineTransition> AnimationNodeStateMachine::get_transition(int p_transition) const {
|
|
ERR_FAIL_INDEX_V(p_transition, transitions.size(), Ref<AnimationNodeStateMachineTransition>());
|
|
return transitions[p_transition].transition;
|
|
}
|
|
StringName AnimationNodeStateMachine::get_transition_from(int p_transition) const {
|
|
ERR_FAIL_INDEX_V(p_transition, transitions.size(), StringName());
|
|
return transitions[p_transition].from;
|
|
}
|
|
StringName AnimationNodeStateMachine::get_transition_to(int p_transition) const {
|
|
ERR_FAIL_INDEX_V(p_transition, transitions.size(), StringName());
|
|
return transitions[p_transition].to;
|
|
}
|
|
|
|
int AnimationNodeStateMachine::get_transition_count() const {
|
|
return transitions.size();
|
|
}
|
|
void AnimationNodeStateMachine::remove_transition(const StringName &p_from, const StringName &p_to) {
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
if (transitions[i].from == p_from && transitions[i].to == p_to) {
|
|
transitions.write[i].transition->disconnect("advance_condition_changed", this, "_tree_changed");
|
|
transitions.remove(i);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*if (playing) {
|
|
path.clear();
|
|
}*/
|
|
}
|
|
|
|
void AnimationNodeStateMachine::remove_transition_by_index(int p_transition) {
|
|
ERR_FAIL_INDEX(p_transition, transitions.size());
|
|
transitions.write[p_transition].transition->disconnect("advance_condition_changed", this, "_tree_changed");
|
|
transitions.remove(p_transition);
|
|
/*if (playing) {
|
|
path.clear();
|
|
}*/
|
|
}
|
|
|
|
void AnimationNodeStateMachine::set_start_node(const StringName &p_node) {
|
|
ERR_FAIL_COND(p_node != StringName() && !states.has(p_node));
|
|
start_node = p_node;
|
|
}
|
|
|
|
String AnimationNodeStateMachine::get_start_node() const {
|
|
return start_node;
|
|
}
|
|
|
|
void AnimationNodeStateMachine::set_end_node(const StringName &p_node) {
|
|
ERR_FAIL_COND(p_node != StringName() && !states.has(p_node));
|
|
end_node = p_node;
|
|
}
|
|
|
|
String AnimationNodeStateMachine::get_end_node() const {
|
|
return end_node;
|
|
}
|
|
|
|
void AnimationNodeStateMachine::set_graph_offset(const Vector2 &p_offset) {
|
|
graph_offset = p_offset;
|
|
}
|
|
|
|
Vector2 AnimationNodeStateMachine::get_graph_offset() const {
|
|
return graph_offset;
|
|
}
|
|
|
|
float AnimationNodeStateMachine::process(float p_time, bool p_seek) {
|
|
Ref<AnimationNodeStateMachinePlayback> playback = get_parameter(this->playback);
|
|
ERR_FAIL_COND_V(playback.is_null(), 0.0);
|
|
|
|
return playback->process(this, p_time, p_seek);
|
|
}
|
|
|
|
String AnimationNodeStateMachine::get_caption() const {
|
|
return "StateMachine";
|
|
}
|
|
|
|
void AnimationNodeStateMachine::_notification(int p_what) {
|
|
}
|
|
|
|
Ref<AnimationNode> AnimationNodeStateMachine::get_child_by_name(const StringName &p_name) {
|
|
return get_node(p_name);
|
|
}
|
|
|
|
bool AnimationNodeStateMachine::_set(const StringName &p_name, const Variant &p_value) {
|
|
String name = p_name;
|
|
if (name.begins_with("states/")) {
|
|
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 (states.has(node_name)) {
|
|
states[node_name].position = p_value;
|
|
}
|
|
return true;
|
|
}
|
|
} else if (name == "transitions") {
|
|
Array trans = p_value;
|
|
ERR_FAIL_COND_V(trans.size() % 3 != 0, false);
|
|
|
|
for (int i = 0; i < trans.size(); i += 3) {
|
|
add_transition(trans[i], trans[i + 1], trans[i + 2]);
|
|
}
|
|
return true;
|
|
} else if (name == "start_node") {
|
|
set_start_node(p_value);
|
|
return true;
|
|
} else if (name == "end_node") {
|
|
set_end_node(p_value);
|
|
return true;
|
|
} else if (name == "graph_offset") {
|
|
set_graph_offset(p_value);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool AnimationNodeStateMachine::_get(const StringName &p_name, Variant &r_ret) const {
|
|
String name = p_name;
|
|
if (name.begins_with("states/")) {
|
|
String node_name = name.get_slicec('/', 1);
|
|
String what = name.get_slicec('/', 2);
|
|
|
|
if (what == "node") {
|
|
if (states.has(node_name)) {
|
|
r_ret = states[node_name].node;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (what == "position") {
|
|
if (states.has(node_name)) {
|
|
r_ret = states[node_name].position;
|
|
return true;
|
|
}
|
|
}
|
|
} else if (name == "transitions") {
|
|
Array trans;
|
|
trans.resize(transitions.size() * 3);
|
|
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
trans[i * 3 + 0] = transitions[i].from;
|
|
trans[i * 3 + 1] = transitions[i].to;
|
|
trans[i * 3 + 2] = transitions[i].transition;
|
|
}
|
|
|
|
r_ret = trans;
|
|
return true;
|
|
} else if (name == "start_node") {
|
|
r_ret = get_start_node();
|
|
return true;
|
|
} else if (name == "end_node") {
|
|
r_ret = get_end_node();
|
|
return true;
|
|
} else if (name == "graph_offset") {
|
|
r_ret = get_graph_offset();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
void AnimationNodeStateMachine::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
List<StringName> names;
|
|
for (Map<StringName, State>::Element *E = states.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();
|
|
p_list->push_back(PropertyInfo(Variant::OBJECT, "states/" + name + "/node", PROPERTY_HINT_RESOURCE_TYPE, "AnimationNode", PROPERTY_USAGE_NOEDITOR));
|
|
p_list->push_back(PropertyInfo(Variant::VECTOR2, "states/" + name + "/position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
|
|
}
|
|
|
|
p_list->push_back(PropertyInfo(Variant::ARRAY, "transitions", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
|
|
p_list->push_back(PropertyInfo(Variant::STRING, "start_node", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
|
|
p_list->push_back(PropertyInfo(Variant::STRING, "end_node", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
|
|
p_list->push_back(PropertyInfo(Variant::VECTOR2, "graph_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
|
|
}
|
|
|
|
void AnimationNodeStateMachine::set_node_position(const StringName &p_name, const Vector2 &p_position) {
|
|
ERR_FAIL_COND(!states.has(p_name));
|
|
states[p_name].position = p_position;
|
|
}
|
|
|
|
Vector2 AnimationNodeStateMachine::get_node_position(const StringName &p_name) const {
|
|
ERR_FAIL_COND_V(!states.has(p_name), Vector2());
|
|
return states[p_name].position;
|
|
}
|
|
|
|
void AnimationNodeStateMachine::_tree_changed() {
|
|
emit_signal("tree_changed");
|
|
}
|
|
|
|
void AnimationNodeStateMachine::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("add_node", "name", "node", "position"), &AnimationNodeStateMachine::add_node, DEFVAL(Vector2()));
|
|
ClassDB::bind_method(D_METHOD("replace_node", "name", "node"), &AnimationNodeStateMachine::replace_node);
|
|
ClassDB::bind_method(D_METHOD("get_node", "name"), &AnimationNodeStateMachine::get_node);
|
|
ClassDB::bind_method(D_METHOD("remove_node", "name"), &AnimationNodeStateMachine::remove_node);
|
|
ClassDB::bind_method(D_METHOD("rename_node", "name", "new_name"), &AnimationNodeStateMachine::rename_node);
|
|
ClassDB::bind_method(D_METHOD("has_node", "name"), &AnimationNodeStateMachine::has_node);
|
|
ClassDB::bind_method(D_METHOD("get_node_name", "node"), &AnimationNodeStateMachine::get_node_name);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_node_position", "name", "position"), &AnimationNodeStateMachine::set_node_position);
|
|
ClassDB::bind_method(D_METHOD("get_node_position", "name"), &AnimationNodeStateMachine::get_node_position);
|
|
|
|
ClassDB::bind_method(D_METHOD("has_transition", "from", "to"), &AnimationNodeStateMachine::has_transition);
|
|
ClassDB::bind_method(D_METHOD("add_transition", "from", "to", "transition"), &AnimationNodeStateMachine::add_transition);
|
|
ClassDB::bind_method(D_METHOD("get_transition", "idx"), &AnimationNodeStateMachine::get_transition);
|
|
ClassDB::bind_method(D_METHOD("get_transition_from", "idx"), &AnimationNodeStateMachine::get_transition_from);
|
|
ClassDB::bind_method(D_METHOD("get_transition_to", "idx"), &AnimationNodeStateMachine::get_transition_to);
|
|
ClassDB::bind_method(D_METHOD("get_transition_count"), &AnimationNodeStateMachine::get_transition_count);
|
|
ClassDB::bind_method(D_METHOD("remove_transition_by_index", "idx"), &AnimationNodeStateMachine::remove_transition_by_index);
|
|
ClassDB::bind_method(D_METHOD("remove_transition", "from", "to"), &AnimationNodeStateMachine::remove_transition);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_start_node", "name"), &AnimationNodeStateMachine::set_start_node);
|
|
ClassDB::bind_method(D_METHOD("get_start_node"), &AnimationNodeStateMachine::get_start_node);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_end_node", "name"), &AnimationNodeStateMachine::set_end_node);
|
|
ClassDB::bind_method(D_METHOD("get_end_node"), &AnimationNodeStateMachine::get_end_node);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_graph_offset", "offset"), &AnimationNodeStateMachine::set_graph_offset);
|
|
ClassDB::bind_method(D_METHOD("get_graph_offset"), &AnimationNodeStateMachine::get_graph_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("_tree_changed"), &AnimationNodeStateMachine::_tree_changed);
|
|
}
|
|
|
|
AnimationNodeStateMachine::AnimationNodeStateMachine() {
|
|
playback = "playback";
|
|
}
|