d95794ec8a
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".
2206 lines
76 KiB
C++
2206 lines
76 KiB
C++
/**************************************************************************/
|
|
/* animation_state_machine_editor.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_state_machine_editor.h"
|
|
|
|
#include "core/config/project_settings.h"
|
|
#include "core/input/input.h"
|
|
#include "core/io/resource_loader.h"
|
|
#include "core/math/geometry_2d.h"
|
|
#include "core/os/keyboard.h"
|
|
#include "editor/editor_file_dialog.h"
|
|
#include "editor/editor_node.h"
|
|
#include "editor/editor_scale.h"
|
|
#include "editor/editor_settings.h"
|
|
#include "editor/editor_undo_redo_manager.h"
|
|
#include "scene/animation/animation_blend_tree.h"
|
|
#include "scene/animation/animation_player.h"
|
|
#include "scene/gui/menu_button.h"
|
|
#include "scene/gui/option_button.h"
|
|
#include "scene/gui/panel.h"
|
|
#include "scene/gui/panel_container.h"
|
|
#include "scene/gui/separator.h"
|
|
#include "scene/gui/tree.h"
|
|
#include "scene/main/viewport.h"
|
|
#include "scene/main/window.h"
|
|
|
|
bool AnimationNodeStateMachineEditor::can_edit(const Ref<AnimationNode> &p_node) {
|
|
Ref<AnimationNodeStateMachine> ansm = p_node;
|
|
return ansm.is_valid();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::edit(const Ref<AnimationNode> &p_node) {
|
|
state_machine = p_node;
|
|
|
|
read_only = false;
|
|
|
|
if (state_machine.is_valid()) {
|
|
read_only = EditorNode::get_singleton()->is_resource_read_only(state_machine);
|
|
|
|
selected_transition_from = StringName();
|
|
selected_transition_to = StringName();
|
|
selected_transition_index = -1;
|
|
selected_multi_transition = TransitionLine();
|
|
selected_node = StringName();
|
|
selected_nodes.clear();
|
|
_update_mode();
|
|
_update_graph();
|
|
}
|
|
|
|
tool_create->set_disabled(read_only);
|
|
tool_connect->set_disabled(read_only);
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_state_machine_gui_input(const Ref<InputEvent> &p_event) {
|
|
AnimationTree *tree = AnimationTreeEditor::get_singleton()->get_animation_tree();
|
|
if (!tree) {
|
|
return;
|
|
}
|
|
|
|
Ref<AnimationNodeStateMachinePlayback> playback = tree->get(AnimationTreeEditor::get_singleton()->get_base_path() + "playback");
|
|
if (playback.is_null()) {
|
|
return;
|
|
}
|
|
|
|
Ref<InputEventKey> k = p_event;
|
|
if (tool_select->is_pressed() && k.is_valid() && k->is_pressed() && k->get_keycode() == Key::KEY_DELETE && !k->is_echo()) {
|
|
if (selected_node != StringName() || !selected_nodes.is_empty() || selected_transition_to != StringName() || selected_transition_from != StringName()) {
|
|
if (!read_only) {
|
|
_erase_selected();
|
|
}
|
|
accept_event();
|
|
}
|
|
}
|
|
|
|
// Group selected nodes on a state machine
|
|
if (tool_select->is_pressed() && k.is_valid() && k->is_pressed() && k->is_ctrl_pressed() && !k->is_shift_pressed() && k->get_keycode() == Key::G && !k->is_echo()) {
|
|
_group_selected_nodes();
|
|
}
|
|
|
|
// Ungroup state machine
|
|
if (tool_select->is_pressed() && k.is_valid() && k->is_pressed() && k->is_ctrl_pressed() && k->is_shift_pressed() && k->get_keycode() == Key::G && !k->is_echo()) {
|
|
_ungroup_selected_nodes();
|
|
}
|
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
|
|
|
// Add new node
|
|
if (!read_only) {
|
|
if (mb.is_valid() && mb->is_pressed() && !box_selecting && !connecting && ((tool_select->is_pressed() && mb->get_button_index() == MouseButton::RIGHT) || (tool_create->is_pressed() && mb->get_button_index() == MouseButton::LEFT))) {
|
|
connecting_from = StringName();
|
|
_open_menu(mb->get_position());
|
|
}
|
|
}
|
|
|
|
// Select node or push a field inside
|
|
if (mb.is_valid() && !mb->is_shift_pressed() && !mb->is_ctrl_pressed() && mb->is_pressed() && tool_select->is_pressed() && mb->get_button_index() == MouseButton::LEFT) {
|
|
selected_transition_from = StringName();
|
|
selected_transition_to = StringName();
|
|
selected_transition_index = -1;
|
|
selected_multi_transition = TransitionLine();
|
|
selected_node = StringName();
|
|
|
|
for (int i = node_rects.size() - 1; i >= 0; i--) { //inverse to draw order
|
|
if (node_rects[i].play.has_point(mb->get_position())) { //edit name
|
|
if (play_mode->get_selected() == 1 || !playback->is_playing()) {
|
|
//start
|
|
playback->start(node_rects[i].node_name);
|
|
} else {
|
|
//travel
|
|
playback->travel(node_rects[i].node_name);
|
|
}
|
|
state_machine_draw->queue_redraw();
|
|
return;
|
|
}
|
|
|
|
if (!read_only) {
|
|
if (node_rects[i].name.has_point(mb->get_position()) && state_machine->can_edit_node(node_rects[i].node_name)) { // edit name
|
|
Ref<StyleBox> line_sb = get_theme_stylebox(SNAME("normal"), SNAME("LineEdit"));
|
|
|
|
Rect2 edit_rect = node_rects[i].name;
|
|
edit_rect.position -= line_sb->get_offset();
|
|
edit_rect.size += line_sb->get_minimum_size();
|
|
|
|
name_edit_popup->set_position(state_machine_draw->get_screen_position() + edit_rect.position);
|
|
name_edit_popup->set_size(edit_rect.size);
|
|
name_edit->set_text(node_rects[i].node_name);
|
|
name_edit_popup->popup();
|
|
name_edit->grab_focus();
|
|
name_edit->select_all();
|
|
|
|
prev_name = node_rects[i].node_name;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (node_rects[i].edit.has_point(mb->get_position())) { //edit name
|
|
call_deferred(SNAME("_open_editor"), node_rects[i].node_name);
|
|
return;
|
|
}
|
|
|
|
if (node_rects[i].node.has_point(mb->get_position())) { //select node since nothing else was selected
|
|
selected_node = node_rects[i].node_name;
|
|
|
|
if (!selected_nodes.has(selected_node)) {
|
|
selected_nodes.clear();
|
|
}
|
|
|
|
selected_nodes.insert(selected_node);
|
|
|
|
Ref<AnimationNode> anode = state_machine->get_node(selected_node);
|
|
EditorNode::get_singleton()->push_item(anode.ptr(), "", true);
|
|
state_machine_draw->queue_redraw();
|
|
dragging_selected_attempt = true;
|
|
dragging_selected = false;
|
|
drag_from = mb->get_position();
|
|
snap_x = StringName();
|
|
snap_y = StringName();
|
|
_update_mode();
|
|
return;
|
|
}
|
|
}
|
|
|
|
//test the lines now
|
|
int closest = -1;
|
|
float closest_d = 1e20;
|
|
for (int i = 0; i < transition_lines.size(); i++) {
|
|
Vector2 s[2] = {
|
|
transition_lines[i].from,
|
|
transition_lines[i].to
|
|
};
|
|
Vector2 cpoint = Geometry2D::get_closest_point_to_segment(mb->get_position(), s);
|
|
float d = cpoint.distance_to(mb->get_position());
|
|
if (d > transition_lines[i].width) {
|
|
continue;
|
|
}
|
|
|
|
if (d < closest_d) {
|
|
closest = i;
|
|
closest_d = d;
|
|
}
|
|
}
|
|
|
|
if (closest >= 0) {
|
|
selected_transition_from = transition_lines[closest].from_node;
|
|
selected_transition_to = transition_lines[closest].to_node;
|
|
selected_transition_index = closest;
|
|
|
|
Ref<AnimationNodeStateMachineTransition> tr = state_machine->get_transition(closest);
|
|
EditorNode::get_singleton()->push_item(tr.ptr(), "", true);
|
|
|
|
if (!transition_lines[closest].multi_transitions.is_empty()) {
|
|
selected_transition_index = -1;
|
|
selected_multi_transition = transition_lines[closest];
|
|
|
|
Ref<EditorAnimationMultiTransitionEdit> multi;
|
|
multi.instantiate();
|
|
multi->add_transition(selected_transition_from, selected_transition_to, tr);
|
|
|
|
for (int i = 0; i < transition_lines[closest].multi_transitions.size(); i++) {
|
|
int index = transition_lines[closest].multi_transitions[i].transition_index;
|
|
|
|
Ref<AnimationNodeStateMachineTransition> transition = state_machine->get_transition(index);
|
|
StringName from = transition_lines[closest].multi_transitions[i].from_node;
|
|
StringName to = transition_lines[closest].multi_transitions[i].to_node;
|
|
|
|
multi->add_transition(from, to, transition);
|
|
}
|
|
EditorNode::get_singleton()->push_item(multi.ptr(), "", true);
|
|
}
|
|
}
|
|
|
|
state_machine_draw->queue_redraw();
|
|
_update_mode();
|
|
}
|
|
|
|
// End moving node
|
|
if (mb.is_valid() && dragging_selected_attempt && mb->get_button_index() == MouseButton::LEFT && !mb->is_pressed()) {
|
|
if (dragging_selected) {
|
|
Ref<AnimationNode> an = state_machine->get_node(selected_node);
|
|
updating = true;
|
|
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action(TTR("Move Node"));
|
|
|
|
for (int i = 0; i < node_rects.size(); i++) {
|
|
if (!selected_nodes.has(node_rects[i].node_name)) {
|
|
continue;
|
|
}
|
|
|
|
undo_redo->add_do_method(state_machine.ptr(), "set_node_position", node_rects[i].node_name, state_machine->get_node_position(node_rects[i].node_name) + drag_ofs / EDSCALE);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "set_node_position", node_rects[i].node_name, state_machine->get_node_position(node_rects[i].node_name));
|
|
}
|
|
|
|
undo_redo->add_do_method(this, "_update_graph");
|
|
undo_redo->add_undo_method(this, "_update_graph");
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
}
|
|
snap_x = StringName();
|
|
snap_y = StringName();
|
|
|
|
dragging_selected_attempt = false;
|
|
dragging_selected = false;
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
// Connect nodes
|
|
if (mb.is_valid() && ((tool_select->is_pressed() && mb->is_shift_pressed()) || tool_connect->is_pressed()) && mb->get_button_index() == MouseButton::LEFT && mb->is_pressed()) {
|
|
for (int i = node_rects.size() - 1; i >= 0; i--) { //inverse to draw order
|
|
if (node_rects[i].node.has_point(mb->get_position())) { //select node since nothing else was selected
|
|
connecting = true;
|
|
connection_follows_cursor = true;
|
|
connecting_from = node_rects[i].node_name;
|
|
connecting_to = mb->get_position();
|
|
connecting_to_node = StringName();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// End connecting nodes
|
|
if (mb.is_valid() && connecting && mb->get_button_index() == MouseButton::LEFT && !mb->is_pressed()) {
|
|
if (connecting_to_node != StringName()) {
|
|
Ref<AnimationNode> node = state_machine->get_node(connecting_to_node);
|
|
Ref<AnimationNodeStateMachine> anodesm = node;
|
|
Ref<AnimationNodeEndState> end_node = node;
|
|
|
|
if (state_machine->has_transition(connecting_from, connecting_to_node) && state_machine->can_edit_node(connecting_to_node) && !anodesm.is_valid()) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Transition exists!"));
|
|
connecting = false;
|
|
} else {
|
|
if (anodesm.is_valid() || end_node.is_valid()) {
|
|
_open_connect_menu(mb->get_position());
|
|
} else {
|
|
_add_transition();
|
|
}
|
|
}
|
|
} else {
|
|
_open_menu(mb->get_position());
|
|
}
|
|
connecting_to_node = StringName();
|
|
connection_follows_cursor = false;
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
// Start box selecting
|
|
if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == MouseButton::LEFT && tool_select->is_pressed()) {
|
|
box_selecting = true;
|
|
box_selecting_from = box_selecting_to = state_machine_draw->get_local_mouse_position();
|
|
box_selecting_rect = Rect2(MIN(box_selecting_from.x, box_selecting_to.x),
|
|
MIN(box_selecting_from.y, box_selecting_to.y),
|
|
ABS(box_selecting_from.x - box_selecting_to.x),
|
|
ABS(box_selecting_from.y - box_selecting_to.y));
|
|
|
|
if (mb->is_ctrl_pressed() || mb->is_shift_pressed()) {
|
|
previous_selected = selected_nodes;
|
|
} else {
|
|
selected_nodes.clear();
|
|
previous_selected.clear();
|
|
}
|
|
}
|
|
|
|
// End box selecting
|
|
if (mb.is_valid() && mb->get_button_index() == MouseButton::LEFT && !mb->is_pressed() && box_selecting) {
|
|
box_selecting = false;
|
|
state_machine_draw->queue_redraw();
|
|
_update_mode();
|
|
}
|
|
|
|
Ref<InputEventMouseMotion> mm = p_event;
|
|
|
|
// Pan window
|
|
if (mm.is_valid() && (mm->get_button_mask() & MouseButton::MASK_MIDDLE) != MouseButton::NONE) {
|
|
h_scroll->set_value(h_scroll->get_value() - mm->get_relative().x);
|
|
v_scroll->set_value(v_scroll->get_value() - mm->get_relative().y);
|
|
}
|
|
|
|
// Move mouse while connecting
|
|
if (mm.is_valid() && connecting && connection_follows_cursor && !read_only) {
|
|
connecting_to = mm->get_position();
|
|
connecting_to_node = StringName();
|
|
state_machine_draw->queue_redraw();
|
|
|
|
for (int i = node_rects.size() - 1; i >= 0; i--) { //inverse to draw order
|
|
if (node_rects[i].node_name != connecting_from && node_rects[i].node.has_point(connecting_to)) { //select node since nothing else was selected
|
|
connecting_to_node = node_rects[i].node_name;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Move mouse while moving a node
|
|
if (mm.is_valid() && dragging_selected_attempt && !read_only) {
|
|
dragging_selected = true;
|
|
drag_ofs = mm->get_position() - drag_from;
|
|
snap_x = StringName();
|
|
snap_y = StringName();
|
|
{
|
|
//snap
|
|
Vector2 cpos = state_machine->get_node_position(selected_node) + drag_ofs / EDSCALE;
|
|
List<StringName> nodes;
|
|
state_machine->get_node_list(&nodes);
|
|
|
|
float best_d_x = 1e20;
|
|
float best_d_y = 1e20;
|
|
|
|
for (const StringName &E : nodes) {
|
|
if (E == selected_node) {
|
|
continue;
|
|
}
|
|
Vector2 npos = state_machine->get_node_position(E);
|
|
|
|
float d_x = ABS(npos.x - cpos.x);
|
|
if (d_x < MIN(5, best_d_x)) {
|
|
drag_ofs.x -= cpos.x - npos.x;
|
|
best_d_x = d_x;
|
|
snap_x = E;
|
|
}
|
|
|
|
float d_y = ABS(npos.y - cpos.y);
|
|
if (d_y < MIN(5, best_d_y)) {
|
|
drag_ofs.y -= cpos.y - npos.y;
|
|
best_d_y = d_y;
|
|
snap_y = E;
|
|
}
|
|
}
|
|
}
|
|
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
// Move mouse while moving box select
|
|
if (mm.is_valid() && box_selecting) {
|
|
box_selecting_to = state_machine_draw->get_local_mouse_position();
|
|
|
|
box_selecting_rect = Rect2(MIN(box_selecting_from.x, box_selecting_to.x),
|
|
MIN(box_selecting_from.y, box_selecting_to.y),
|
|
ABS(box_selecting_from.x - box_selecting_to.x),
|
|
ABS(box_selecting_from.y - box_selecting_to.y));
|
|
|
|
for (int i = 0; i < node_rects.size(); i++) {
|
|
bool in_box = node_rects[i].node.intersects(box_selecting_rect);
|
|
|
|
if (in_box) {
|
|
if (previous_selected.has(node_rects[i].node_name)) {
|
|
selected_nodes.erase(node_rects[i].node_name);
|
|
} else {
|
|
selected_nodes.insert(node_rects[i].node_name);
|
|
}
|
|
} else {
|
|
if (previous_selected.has(node_rects[i].node_name)) {
|
|
selected_nodes.insert(node_rects[i].node_name);
|
|
} else {
|
|
selected_nodes.erase(node_rects[i].node_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
if (mm.is_valid()) {
|
|
state_machine_draw->grab_focus();
|
|
|
|
String new_over_node;
|
|
int new_over_node_what = -1;
|
|
if (tool_select->is_pressed()) {
|
|
for (int i = node_rects.size() - 1; i >= 0; i--) { // Inverse to draw order.
|
|
|
|
if (!state_machine->can_edit_node(node_rects[i].node_name)) {
|
|
continue; // start/end node can't be edited
|
|
}
|
|
|
|
if (node_rects[i].node.has_point(mm->get_position())) {
|
|
new_over_node = node_rects[i].node_name;
|
|
if (node_rects[i].play.has_point(mm->get_position())) {
|
|
new_over_node_what = 0;
|
|
} else if (node_rects[i].edit.has_point(mm->get_position())) {
|
|
new_over_node_what = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (new_over_node != over_node || new_over_node_what != over_node_what) {
|
|
over_node = new_over_node;
|
|
over_node_what = new_over_node_what;
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
// set tooltip for transition
|
|
if (tool_select->is_pressed()) {
|
|
int closest = -1;
|
|
float closest_d = 1e20;
|
|
for (int i = 0; i < transition_lines.size(); i++) {
|
|
Vector2 s[2] = {
|
|
transition_lines[i].from,
|
|
transition_lines[i].to
|
|
};
|
|
Vector2 cpoint = Geometry2D::get_closest_point_to_segment(mm->get_position(), s);
|
|
float d = cpoint.distance_to(mm->get_position());
|
|
if (d > transition_lines[i].width) {
|
|
continue;
|
|
}
|
|
|
|
if (d < closest_d) {
|
|
closest = i;
|
|
closest_d = d;
|
|
}
|
|
}
|
|
|
|
if (closest >= 0) {
|
|
String from = String(transition_lines[closest].from_node);
|
|
String to = String(transition_lines[closest].to_node);
|
|
String tooltip = from + " -> " + to;
|
|
|
|
for (int i = 0; i < transition_lines[closest].multi_transitions.size(); i++) {
|
|
from = String(transition_lines[closest].multi_transitions[i].from_node);
|
|
to = String(transition_lines[closest].multi_transitions[i].to_node);
|
|
tooltip += "\n" + from + " -> " + to;
|
|
}
|
|
state_machine_draw->set_tooltip_text(tooltip);
|
|
} else {
|
|
state_machine_draw->set_tooltip_text("");
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<InputEventPanGesture> pan_gesture = p_event;
|
|
if (pan_gesture.is_valid()) {
|
|
h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * pan_gesture->get_delta().x / 8);
|
|
v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * pan_gesture->get_delta().y / 8);
|
|
}
|
|
}
|
|
|
|
Control::CursorShape AnimationNodeStateMachineEditor::get_cursor_shape(const Point2 &p_pos) const {
|
|
Control::CursorShape cursor_shape = get_default_cursor_shape();
|
|
if (!read_only) {
|
|
// Put ibeam (text cursor) over names to make it clearer that they are editable.
|
|
Transform2D xform = panel->get_transform() * state_machine_draw->get_transform();
|
|
Point2 pos = xform.xform_inv(p_pos);
|
|
|
|
for (int i = node_rects.size() - 1; i >= 0; i--) { // Inverse to draw order.
|
|
if (node_rects[i].node.has_point(pos)) {
|
|
if (node_rects[i].name.has_point(pos)) {
|
|
if (state_machine->can_edit_node(node_rects[i].node_name)) {
|
|
cursor_shape = Control::CURSOR_IBEAM;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return cursor_shape;
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_group_selected_nodes() {
|
|
if (!selected_nodes.is_empty()) {
|
|
if (selected_nodes.size() == 1 && (*selected_nodes.begin() == state_machine->start_node || *selected_nodes.begin() == state_machine->end_node))
|
|
return;
|
|
|
|
Ref<AnimationNodeStateMachine> group_sm = memnew(AnimationNodeStateMachine);
|
|
Vector2 group_position;
|
|
|
|
Vector<NodeUR> nodes_ur;
|
|
Vector<TransitionUR> transitions_ur;
|
|
|
|
int base = 1;
|
|
String base_name = group_sm->get_caption();
|
|
String group_name = base_name;
|
|
|
|
while (state_machine->has_node(group_name) && !selected_nodes.has(group_name)) {
|
|
base++;
|
|
group_name = base_name + " " + itos(base);
|
|
}
|
|
|
|
updating = true;
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action("Group");
|
|
|
|
// Move selected nodes to the new state machine
|
|
for (const StringName &E : selected_nodes) {
|
|
if (!state_machine->can_edit_node(E)) {
|
|
continue;
|
|
}
|
|
|
|
Ref<AnimationNode> node = state_machine->get_node(E);
|
|
Vector2 node_position = state_machine->get_node_position(E);
|
|
group_position += node_position;
|
|
|
|
NodeUR new_node;
|
|
new_node.name = E;
|
|
new_node.node = node;
|
|
new_node.position = node_position;
|
|
|
|
nodes_ur.push_back(new_node);
|
|
}
|
|
|
|
// Add the transitions to the new state machine
|
|
for (int i = 0; i < state_machine->get_transition_count(); i++) {
|
|
String from = state_machine->get_transition_from(i);
|
|
String to = state_machine->get_transition_to(i);
|
|
|
|
String local_from = from.get_slicec('/', 0);
|
|
String local_to = to.get_slicec('/', 0);
|
|
|
|
String old_from = from;
|
|
String old_to = to;
|
|
|
|
bool from_selected = false;
|
|
bool to_selected = false;
|
|
|
|
if (selected_nodes.has(local_from) && local_from != state_machine->start_node) {
|
|
from_selected = true;
|
|
}
|
|
if (selected_nodes.has(local_to) && local_to != state_machine->end_node) {
|
|
to_selected = true;
|
|
}
|
|
if (!from_selected && !to_selected) {
|
|
continue;
|
|
}
|
|
|
|
Ref<AnimationNodeStateMachineTransition> tr = state_machine->get_transition(i);
|
|
|
|
if (!from_selected) {
|
|
from = "../" + old_from;
|
|
}
|
|
if (!to_selected) {
|
|
to = "../" + old_to;
|
|
}
|
|
|
|
TransitionUR new_tr;
|
|
new_tr.new_from = from;
|
|
new_tr.new_to = to;
|
|
new_tr.old_from = old_from;
|
|
new_tr.old_to = old_to;
|
|
new_tr.transition = tr;
|
|
|
|
transitions_ur.push_back(new_tr);
|
|
}
|
|
|
|
for (int i = 0; i < nodes_ur.size(); i++) {
|
|
undo_redo->add_do_method(state_machine.ptr(), "remove_node", nodes_ur[i].name);
|
|
undo_redo->add_undo_method(group_sm.ptr(), "remove_node", nodes_ur[i].name);
|
|
}
|
|
|
|
undo_redo->add_do_method(state_machine.ptr(), "add_node", group_name, group_sm, group_position / nodes_ur.size());
|
|
undo_redo->add_undo_method(state_machine.ptr(), "remove_node", group_name);
|
|
|
|
for (int i = 0; i < nodes_ur.size(); i++) {
|
|
undo_redo->add_do_method(group_sm.ptr(), "add_node", nodes_ur[i].name, nodes_ur[i].node, nodes_ur[i].position);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "add_node", nodes_ur[i].name, nodes_ur[i].node, nodes_ur[i].position);
|
|
}
|
|
|
|
for (int i = 0; i < transitions_ur.size(); i++) {
|
|
undo_redo->add_do_method(group_sm.ptr(), "add_transition", transitions_ur[i].new_from, transitions_ur[i].new_to, transitions_ur[i].transition);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "add_transition", transitions_ur[i].old_from, transitions_ur[i].old_to, transitions_ur[i].transition);
|
|
}
|
|
|
|
undo_redo->add_do_method(this, "_update_graph");
|
|
undo_redo->add_undo_method(this, "_update_graph");
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
|
|
selected_nodes.clear();
|
|
selected_nodes.insert(group_name);
|
|
state_machine_draw->queue_redraw();
|
|
accept_event();
|
|
_update_mode();
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_ungroup_selected_nodes() {
|
|
bool find = false;
|
|
HashSet<StringName> new_selected_nodes;
|
|
|
|
for (const StringName &E : selected_nodes) {
|
|
Ref<AnimationNodeStateMachine> group_sm = state_machine->get_node(E);
|
|
|
|
if (group_sm.is_valid()) {
|
|
find = true;
|
|
|
|
Vector2 group_position = state_machine->get_node_position(E);
|
|
StringName group_name = E;
|
|
|
|
List<AnimationNode::ChildNode> nodes;
|
|
group_sm->get_child_nodes(&nodes);
|
|
|
|
Vector<NodeUR> nodes_ur;
|
|
Vector<TransitionUR> transitions_ur;
|
|
|
|
updating = true;
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action("Ungroup");
|
|
|
|
// Move all child nodes to current state machine
|
|
for (int i = 0; i < nodes.size(); i++) {
|
|
if (!group_sm->can_edit_node(nodes[i].name)) {
|
|
continue;
|
|
}
|
|
|
|
Vector2 node_position = group_sm->get_node_position(nodes[i].name);
|
|
|
|
NodeUR new_node;
|
|
new_node.name = nodes[i].name;
|
|
new_node.position = node_position;
|
|
new_node.node = nodes[i].node;
|
|
|
|
nodes_ur.push_back(new_node);
|
|
}
|
|
|
|
for (int i = 0; i < group_sm->get_transition_count(); i++) {
|
|
String from = group_sm->get_transition_from(i);
|
|
String to = group_sm->get_transition_to(i);
|
|
Ref<AnimationNodeStateMachineTransition> tr = group_sm->get_transition(i);
|
|
|
|
TransitionUR new_tr;
|
|
new_tr.new_from = from.replace_first("../", "");
|
|
new_tr.new_to = to.replace_first("../", "");
|
|
new_tr.old_from = from;
|
|
new_tr.old_to = to;
|
|
new_tr.transition = tr;
|
|
|
|
transitions_ur.push_back(new_tr);
|
|
}
|
|
|
|
for (int i = 0; i < nodes_ur.size(); i++) {
|
|
undo_redo->add_do_method(group_sm.ptr(), "remove_node", nodes_ur[i].name);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "remove_node", nodes_ur[i].name);
|
|
}
|
|
|
|
undo_redo->add_do_method(state_machine.ptr(), "remove_node", group_name);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "add_node", group_name, group_sm, group_position);
|
|
|
|
for (int i = 0; i < nodes_ur.size(); i++) {
|
|
new_selected_nodes.insert(nodes_ur[i].name);
|
|
undo_redo->add_do_method(state_machine.ptr(), "add_node", nodes_ur[i].name, nodes_ur[i].node, nodes_ur[i].position);
|
|
undo_redo->add_undo_method(group_sm.ptr(), "add_node", nodes_ur[i].name, nodes_ur[i].node, nodes_ur[i].position);
|
|
}
|
|
|
|
for (int i = 0; i < transitions_ur.size(); i++) {
|
|
if (transitions_ur[i].old_from != state_machine->start_node && transitions_ur[i].old_to != state_machine->end_node) {
|
|
undo_redo->add_do_method(state_machine.ptr(), "add_transition", transitions_ur[i].new_from, transitions_ur[i].new_to, transitions_ur[i].transition);
|
|
}
|
|
|
|
undo_redo->add_undo_method(group_sm.ptr(), "add_transition", transitions_ur[i].old_from, transitions_ur[i].old_to, transitions_ur[i].transition);
|
|
}
|
|
|
|
for (int i = 0; i < state_machine->get_transition_count(); i++) {
|
|
String from = state_machine->get_transition_from(i);
|
|
String to = state_machine->get_transition_to(i);
|
|
Ref<AnimationNodeStateMachineTransition> tr = state_machine->get_transition(i);
|
|
|
|
if (from == group_name || to == group_name) {
|
|
undo_redo->add_undo_method(state_machine.ptr(), "add_transition", from, to, tr);
|
|
}
|
|
}
|
|
|
|
undo_redo->add_do_method(this, "_update_graph");
|
|
undo_redo->add_undo_method(this, "_update_graph");
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
}
|
|
}
|
|
|
|
if (find) {
|
|
selected_nodes = new_selected_nodes;
|
|
selected_node = StringName();
|
|
state_machine_draw->queue_redraw();
|
|
accept_event();
|
|
_update_mode();
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_open_menu(const Vector2 &p_position) {
|
|
AnimationTree *tree = AnimationTreeEditor::get_singleton()->get_animation_tree();
|
|
if (!tree) {
|
|
return;
|
|
}
|
|
|
|
menu->clear();
|
|
animations_menu->clear();
|
|
animations_to_add.clear();
|
|
List<StringName> classes;
|
|
classes.sort_custom<StringName::AlphCompare>();
|
|
|
|
ClassDB::get_inheriters_from_class("AnimationRootNode", &classes);
|
|
menu->add_submenu_item(TTR("Add Animation"), "animations");
|
|
|
|
if (tree->has_node(tree->get_animation_player())) {
|
|
AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(tree->get_node(tree->get_animation_player()));
|
|
if (ap) {
|
|
List<StringName> names;
|
|
ap->get_animation_list(&names);
|
|
for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
|
|
animations_menu->add_icon_item(get_theme_icon("Animation", "EditorIcons"), E->get());
|
|
animations_to_add.push_back(E->get());
|
|
}
|
|
}
|
|
}
|
|
|
|
for (List<StringName>::Element *E = classes.front(); E; E = E->next()) {
|
|
String name = String(E->get()).replace_first("AnimationNode", "");
|
|
if (name == "Animation" || name == "StartState" || name == "EndState") {
|
|
continue; // nope
|
|
}
|
|
int idx = menu->get_item_count();
|
|
menu->add_item(vformat(TTR("Add %s"), name), idx);
|
|
menu->set_item_metadata(idx, E->get());
|
|
}
|
|
Ref<AnimationNode> clipb = EditorSettings::get_singleton()->get_resource_clipboard();
|
|
|
|
if (clipb.is_valid()) {
|
|
menu->add_separator();
|
|
menu->add_item(TTR("Paste"), MENU_PASTE);
|
|
}
|
|
menu->add_separator();
|
|
menu->add_item(TTR("Load..."), MENU_LOAD_FILE);
|
|
|
|
menu->set_position(state_machine_draw->get_screen_transform().xform(p_position));
|
|
menu->popup();
|
|
add_node_pos = p_position / EDSCALE + state_machine->get_graph_offset();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_open_connect_menu(const Vector2 &p_position) {
|
|
ERR_FAIL_COND(connecting_to_node == StringName());
|
|
|
|
Ref<AnimationNode> node = state_machine->get_node(connecting_to_node);
|
|
Ref<AnimationNodeStateMachine> anodesm = node;
|
|
Ref<AnimationNodeEndState> end_node = node;
|
|
ERR_FAIL_COND(!anodesm.is_valid() && !end_node.is_valid());
|
|
|
|
connect_menu->clear();
|
|
state_machine_menu->clear();
|
|
end_menu->clear();
|
|
nodes_to_connect.clear();
|
|
|
|
for (int i = connect_menu->get_child_count() - 1; i >= 0; i--) {
|
|
Node *child = connect_menu->get_child(i);
|
|
|
|
if (child->is_class("PopupMenu")) {
|
|
connect_menu->remove_child(child);
|
|
}
|
|
}
|
|
|
|
connect_menu->reset_size();
|
|
state_machine_menu->reset_size();
|
|
end_menu->reset_size();
|
|
|
|
if (anodesm.is_valid()) {
|
|
_create_submenu(connect_menu, anodesm, connecting_to_node, connecting_to_node);
|
|
} else {
|
|
_create_submenu(connect_menu, state_machine, connecting_to_node, connecting_to_node, true);
|
|
}
|
|
|
|
connect_menu->add_submenu_item(TTR("To") + " Animation", connecting_to_node);
|
|
|
|
if (state_machine_menu->get_item_count() > 0 || !end_node.is_valid()) {
|
|
connect_menu->add_submenu_item(TTR("To") + " StateMachine", "state_machines");
|
|
connect_menu->add_child(state_machine_menu);
|
|
}
|
|
|
|
if (end_node.is_valid()) {
|
|
connect_menu->add_submenu_item(TTR("To") + " End", "end_nodes");
|
|
connect_menu->add_child(end_menu);
|
|
} else {
|
|
state_machine_menu->add_item(connecting_to_node, nodes_to_connect.size());
|
|
}
|
|
|
|
nodes_to_connect.push_back(connecting_to_node);
|
|
|
|
if (nodes_to_connect.size() == 1) {
|
|
_add_transition();
|
|
return;
|
|
}
|
|
|
|
connect_menu->set_position(state_machine_draw->get_screen_transform().xform(p_position));
|
|
connect_menu->popup();
|
|
}
|
|
|
|
bool AnimationNodeStateMachineEditor::_create_submenu(PopupMenu *p_menu, Ref<AnimationNodeStateMachine> p_nodesm, const StringName &p_name, const StringName &p_path, bool from_root, Vector<Ref<AnimationNodeStateMachine>> p_parents) {
|
|
String prev_path;
|
|
Vector<Ref<AnimationNodeStateMachine>> parents = p_parents;
|
|
|
|
if (from_root && p_nodesm->get_prev_state_machine() == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
if (from_root) {
|
|
AnimationNodeStateMachine *prev = p_nodesm->get_prev_state_machine();
|
|
|
|
while (prev != nullptr) {
|
|
parents.push_back(prev);
|
|
p_nodesm = Ref<AnimationNodeStateMachine>(prev);
|
|
prev_path += "../";
|
|
prev = prev->get_prev_state_machine();
|
|
}
|
|
end_menu->add_item("Root", nodes_to_connect.size());
|
|
nodes_to_connect.push_back(prev_path + state_machine->end_node);
|
|
prev_path.remove_at(prev_path.size() - 1);
|
|
}
|
|
|
|
List<StringName> nodes;
|
|
p_nodesm->get_node_list(&nodes);
|
|
|
|
PopupMenu *nodes_menu = memnew(PopupMenu);
|
|
nodes_menu->set_name(p_name);
|
|
nodes_menu->connect("id_pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_connect_to));
|
|
p_menu->add_child(nodes_menu);
|
|
|
|
bool node_added = false;
|
|
for (const StringName &E : nodes) {
|
|
if (p_nodesm->can_edit_node(E)) {
|
|
Ref<AnimationNodeStateMachine> ansm = p_nodesm->get_node(E);
|
|
|
|
String path;
|
|
if (from_root) {
|
|
path = prev_path + "/" + E;
|
|
} else {
|
|
path = String(p_path) + "/" + E;
|
|
}
|
|
|
|
if (ansm == state_machine) {
|
|
end_menu->add_item(E, nodes_to_connect.size());
|
|
nodes_to_connect.push_back(state_machine->end_node);
|
|
continue;
|
|
}
|
|
|
|
if (ansm.is_valid()) {
|
|
bool parent_found = false;
|
|
|
|
for (int i = 0; i < parents.size(); i++) {
|
|
if (parents[i] == ansm) {
|
|
path = path.replace_first("/../" + E, "");
|
|
parent_found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (parent_found) {
|
|
end_menu->add_item(E, nodes_to_connect.size());
|
|
nodes_to_connect.push_back(path + "/" + state_machine->end_node);
|
|
} else {
|
|
state_machine_menu->add_item(E, nodes_to_connect.size());
|
|
nodes_to_connect.push_back(path);
|
|
}
|
|
|
|
if (_create_submenu(nodes_menu, ansm, E, path, false, parents)) {
|
|
nodes_menu->add_submenu_item(E, E);
|
|
node_added = true;
|
|
}
|
|
} else {
|
|
nodes_menu->add_item(E, nodes_to_connect.size());
|
|
nodes_to_connect.push_back(path);
|
|
node_added = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return node_added;
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_stop_connecting() {
|
|
connecting = false;
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_delete_selected() {
|
|
TreeItem *item = delete_tree->get_next_selected(nullptr);
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
while (item) {
|
|
if (!updating) {
|
|
updating = true;
|
|
selected_multi_transition = TransitionLine();
|
|
undo_redo->create_action("Transition(s) Removed");
|
|
}
|
|
|
|
Vector<String> path = item->get_text(0).split(" -> ");
|
|
|
|
selected_transition_from = path[0];
|
|
selected_transition_to = path[1];
|
|
_erase_selected(true);
|
|
|
|
item = delete_tree->get_next_selected(item);
|
|
}
|
|
|
|
if (updating) {
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_delete_all() {
|
|
Vector<TransitionLine> multi_transitions = selected_multi_transition.multi_transitions;
|
|
selected_multi_transition = TransitionLine();
|
|
|
|
updating = true;
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action("Transition(s) Removed");
|
|
_erase_selected(true);
|
|
for (int i = 0; i < multi_transitions.size(); i++) {
|
|
selected_transition_from = multi_transitions[i].from_node;
|
|
selected_transition_to = multi_transitions[i].to_node;
|
|
_erase_selected(true);
|
|
}
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
|
|
delete_window->hide();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_delete_tree_draw() {
|
|
TreeItem *item = delete_tree->get_next_selected(nullptr);
|
|
while (item) {
|
|
delete_window->get_cancel_button()->set_disabled(false);
|
|
return;
|
|
}
|
|
delete_window->get_cancel_button()->set_disabled(true);
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_file_opened(const String &p_file) {
|
|
file_loaded = ResourceLoader::load(p_file);
|
|
if (file_loaded.is_valid()) {
|
|
_add_menu_type(MENU_LOAD_FILE_CONFIRM);
|
|
} else {
|
|
EditorNode::get_singleton()->show_warning(TTR("This type of node can't be used. Only animation nodes are allowed."));
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_add_menu_type(int p_index) {
|
|
String base_name;
|
|
Ref<AnimationRootNode> node;
|
|
|
|
if (p_index == MENU_LOAD_FILE) {
|
|
open_file->clear_filters();
|
|
List<String> filters;
|
|
ResourceLoader::get_recognized_extensions_for_type("AnimationRootNode", &filters);
|
|
for (const String &E : filters) {
|
|
open_file->add_filter("*." + E);
|
|
}
|
|
open_file->popup_file_dialog();
|
|
return;
|
|
} else if (p_index == MENU_LOAD_FILE_CONFIRM) {
|
|
node = file_loaded;
|
|
file_loaded.unref();
|
|
} else if (p_index == MENU_PASTE) {
|
|
node = EditorSettings::get_singleton()->get_resource_clipboard();
|
|
|
|
} else {
|
|
String type = menu->get_item_metadata(p_index);
|
|
|
|
Object *obj = ClassDB::instantiate(type);
|
|
ERR_FAIL_COND(!obj);
|
|
AnimationNode *an = Object::cast_to<AnimationNode>(obj);
|
|
ERR_FAIL_COND(!an);
|
|
|
|
node = Ref<AnimationNode>(an);
|
|
base_name = type.replace_first("AnimationNode", "");
|
|
}
|
|
|
|
if (!node.is_valid()) {
|
|
EditorNode::get_singleton()->show_warning(TTR("This type of node can't be used. Only root nodes are allowed."));
|
|
return;
|
|
}
|
|
|
|
if (base_name.is_empty()) {
|
|
base_name = node->get_class().replace_first("AnimationNode", "");
|
|
}
|
|
|
|
int base = 1;
|
|
String name = base_name;
|
|
while (state_machine->has_node(name)) {
|
|
base++;
|
|
name = base_name + " " + itos(base);
|
|
}
|
|
|
|
updating = true;
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action(TTR("Add Node and Transition"));
|
|
undo_redo->add_do_method(state_machine.ptr(), "add_node", name, node, add_node_pos);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "remove_node", name);
|
|
connecting_to_node = name;
|
|
_add_transition(true);
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_add_animation_type(int p_index) {
|
|
Ref<AnimationNodeAnimation> anim;
|
|
anim.instantiate();
|
|
|
|
anim->set_animation(animations_to_add[p_index]);
|
|
|
|
String base_name = animations_to_add[p_index].validate_node_name();
|
|
int base = 1;
|
|
String name = base_name;
|
|
while (state_machine->has_node(name)) {
|
|
base++;
|
|
name = base_name + " " + itos(base);
|
|
}
|
|
|
|
updating = true;
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action(TTR("Add Node and Transition"));
|
|
undo_redo->add_do_method(state_machine.ptr(), "add_node", name, anim, add_node_pos);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "remove_node", name);
|
|
connecting_to_node = name;
|
|
_add_transition(true);
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_connect_to(int p_index) {
|
|
connecting_to_node = nodes_to_connect[p_index];
|
|
_add_transition();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_add_transition(const bool p_nested_action) {
|
|
if (connecting_from != StringName() && connecting_to_node != StringName()) {
|
|
if (state_machine->has_transition(connecting_from, connecting_to_node)) {
|
|
EditorNode::get_singleton()->show_warning("Transition exists!");
|
|
connecting = false;
|
|
return;
|
|
}
|
|
|
|
Ref<AnimationNodeStateMachineTransition> tr;
|
|
tr.instantiate();
|
|
tr->set_advance_mode(auto_advance->is_pressed() ? AnimationNodeStateMachineTransition::AdvanceMode::ADVANCE_MODE_AUTO : AnimationNodeStateMachineTransition::AdvanceMode::ADVANCE_MODE_ENABLED);
|
|
tr->set_switch_mode(AnimationNodeStateMachineTransition::SwitchMode(switch_mode->get_selected()));
|
|
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
if (!p_nested_action) {
|
|
updating = true;
|
|
undo_redo->create_action(TTR("Add Transition"));
|
|
}
|
|
|
|
undo_redo->add_do_method(state_machine.ptr(), "add_transition", connecting_from, connecting_to_node, tr);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "remove_transition", connecting_from, connecting_to_node);
|
|
undo_redo->add_do_method(this, "_update_graph");
|
|
undo_redo->add_undo_method(this, "_update_graph");
|
|
|
|
if (!p_nested_action) {
|
|
undo_redo->commit_action();
|
|
updating = false;
|
|
}
|
|
|
|
selected_transition_from = connecting_from;
|
|
selected_transition_to = connecting_to_node;
|
|
selected_transition_index = transition_lines.size();
|
|
|
|
EditorNode::get_singleton()->push_item(tr.ptr(), "", true);
|
|
_update_mode();
|
|
}
|
|
|
|
connecting = false;
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_connection_draw(const Vector2 &p_from, const Vector2 &p_to, AnimationNodeStateMachineTransition::SwitchMode p_mode, bool p_enabled, bool p_selected, bool p_travel, bool p_auto_advance, bool p_multi_transitions) {
|
|
Color linecolor = get_theme_color(SNAME("font_color"), SNAME("Label"));
|
|
Color icon_color(1, 1, 1);
|
|
Color accent = get_theme_color(SNAME("accent_color"), SNAME("Editor"));
|
|
|
|
if (!p_enabled) {
|
|
linecolor.a *= 0.2;
|
|
icon_color.a *= 0.2;
|
|
accent.a *= 0.6;
|
|
}
|
|
|
|
const Ref<Texture2D> icons[6] = {
|
|
get_theme_icon(SNAME("TransitionImmediateBig"), SNAME("EditorIcons")),
|
|
get_theme_icon(SNAME("TransitionSyncBig"), SNAME("EditorIcons")),
|
|
get_theme_icon(SNAME("TransitionEndBig"), SNAME("EditorIcons")),
|
|
get_theme_icon(SNAME("TransitionImmediateAutoBig"), SNAME("EditorIcons")),
|
|
get_theme_icon(SNAME("TransitionSyncAutoBig"), SNAME("EditorIcons")),
|
|
get_theme_icon(SNAME("TransitionEndAutoBig"), SNAME("EditorIcons"))
|
|
};
|
|
|
|
if (p_selected) {
|
|
state_machine_draw->draw_line(p_from, p_to, accent, 6);
|
|
}
|
|
|
|
if (p_travel) {
|
|
linecolor = accent;
|
|
linecolor.set_hsv(1.0, linecolor.get_s(), linecolor.get_v());
|
|
}
|
|
|
|
state_machine_draw->draw_line(p_from, p_to, linecolor, 2);
|
|
|
|
Ref<Texture2D> icon = icons[p_mode + (p_auto_advance ? 3 : 0)];
|
|
|
|
Transform2D xf;
|
|
xf.columns[0] = (p_to - p_from).normalized();
|
|
xf.columns[1] = xf.columns[0].orthogonal();
|
|
xf.columns[2] = (p_from + p_to) * 0.5 - xf.columns[1] * icon->get_height() * 0.5 - xf.columns[0] * icon->get_height() * 0.5;
|
|
|
|
state_machine_draw->draw_set_transform_matrix(xf);
|
|
if (p_multi_transitions) {
|
|
state_machine_draw->draw_texture(icons[0], Vector2(-icon->get_width(), 0), icon_color);
|
|
state_machine_draw->draw_texture(icons[0], Vector2(), icon_color);
|
|
state_machine_draw->draw_texture(icons[0], Vector2(icon->get_width(), 0), icon_color);
|
|
} else {
|
|
state_machine_draw->draw_texture(icon, Vector2(), icon_color);
|
|
}
|
|
state_machine_draw->draw_set_transform_matrix(Transform2D());
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_clip_src_line_to_rect(Vector2 &r_from, const Vector2 &p_to, const Rect2 &p_rect) {
|
|
if (p_to == r_from) {
|
|
return;
|
|
}
|
|
|
|
//this could be optimized...
|
|
Vector2 n = (p_to - r_from).normalized();
|
|
while (p_rect.has_point(r_from)) {
|
|
r_from += n;
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_clip_dst_line_to_rect(const Vector2 &p_from, Vector2 &r_to, const Rect2 &p_rect) {
|
|
if (r_to == p_from) {
|
|
return;
|
|
}
|
|
|
|
//this could be optimized...
|
|
Vector2 n = (r_to - p_from).normalized();
|
|
while (p_rect.has_point(r_to)) {
|
|
r_to -= n;
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_state_machine_draw() {
|
|
AnimationTree *tree = AnimationTreeEditor::get_singleton()->get_animation_tree();
|
|
if (!tree) {
|
|
return;
|
|
}
|
|
|
|
Ref<AnimationNodeStateMachinePlayback> playback = tree->get(AnimationTreeEditor::get_singleton()->get_base_path() + "playback");
|
|
|
|
Ref<StyleBoxFlat> style = get_theme_stylebox(SNAME("state_machine_frame"), SNAME("GraphNode"));
|
|
Ref<StyleBoxFlat> style_selected = get_theme_stylebox(SNAME("state_machine_selected_frame"), SNAME("GraphNode"));
|
|
|
|
Ref<Font> font = get_theme_font(SNAME("title_font"), SNAME("GraphNode"));
|
|
int font_size = get_theme_font_size(SNAME("title_font_size"), SNAME("GraphNode"));
|
|
Color font_color = get_theme_color(SNAME("title_color"), SNAME("GraphNode"));
|
|
Ref<Texture2D> play = get_theme_icon(SNAME("Play"), SNAME("EditorIcons"));
|
|
Ref<Texture2D> edit = get_theme_icon(SNAME("Edit"), SNAME("EditorIcons"));
|
|
Color accent = get_theme_color(SNAME("accent_color"), SNAME("Editor"));
|
|
Color linecolor = get_theme_color(SNAME("font_color"), SNAME("Label"));
|
|
linecolor.a *= 0.3;
|
|
Ref<StyleBox> playing_overlay = get_theme_stylebox(SNAME("position"), SNAME("GraphNode"));
|
|
|
|
Ref<StyleBoxFlat> start_overlay = style->duplicate();
|
|
start_overlay->set_border_width_all(1 * EDSCALE);
|
|
start_overlay->set_border_color(Color::html("#80f6cf"));
|
|
|
|
Ref<StyleBoxFlat> end_overlay = style->duplicate();
|
|
end_overlay->set_border_width_all(1 * EDSCALE);
|
|
end_overlay->set_border_color(Color::html("#f26661"));
|
|
|
|
bool playing = false;
|
|
StringName current;
|
|
StringName blend_from;
|
|
Vector<StringName> travel_path;
|
|
|
|
if (playback.is_valid()) {
|
|
playing = playback->is_playing();
|
|
current = playback->get_current_node();
|
|
blend_from = playback->get_blend_from_node();
|
|
travel_path = playback->get_travel_path();
|
|
}
|
|
|
|
if (state_machine_draw->has_focus()) {
|
|
state_machine_draw->draw_rect(Rect2(Point2(), state_machine_draw->get_size()), accent, false);
|
|
}
|
|
int sep = 3 * EDSCALE;
|
|
|
|
List<StringName> nodes;
|
|
state_machine->get_node_list(&nodes);
|
|
|
|
node_rects.clear();
|
|
Rect2 scroll_range;
|
|
|
|
//snap lines
|
|
if (dragging_selected) {
|
|
Vector2 from = (state_machine->get_node_position(selected_node) * EDSCALE) + drag_ofs - state_machine->get_graph_offset() * EDSCALE;
|
|
if (snap_x != StringName()) {
|
|
Vector2 to = (state_machine->get_node_position(snap_x) * EDSCALE) - state_machine->get_graph_offset() * EDSCALE;
|
|
state_machine_draw->draw_line(from, to, linecolor, 2);
|
|
}
|
|
if (snap_y != StringName()) {
|
|
Vector2 to = (state_machine->get_node_position(snap_y) * EDSCALE) - state_machine->get_graph_offset() * EDSCALE;
|
|
state_machine_draw->draw_line(from, to, linecolor, 2);
|
|
}
|
|
}
|
|
|
|
//pre pass nodes so we know the rectangles
|
|
for (const StringName &E : nodes) {
|
|
Ref<AnimationNode> anode = state_machine->get_node(E);
|
|
String name = E;
|
|
bool needs_editor = AnimationTreeEditor::get_singleton()->can_edit(anode);
|
|
Ref<StyleBox> sb = selected_nodes.has(E) ? style_selected : style;
|
|
|
|
Size2 s = sb->get_minimum_size();
|
|
int strsize = font->get_string_size(name, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width;
|
|
s.width += strsize;
|
|
s.height += MAX(font->get_height(font_size), play->get_height());
|
|
s.width += sep + play->get_width();
|
|
|
|
if (needs_editor) {
|
|
s.width += sep + edit->get_width();
|
|
}
|
|
|
|
Vector2 offset;
|
|
offset += state_machine->get_node_position(E) * EDSCALE;
|
|
|
|
if (selected_nodes.has(E) && dragging_selected) {
|
|
offset += drag_ofs;
|
|
}
|
|
|
|
offset -= s / 2;
|
|
offset = offset.floor();
|
|
|
|
//prepre rect
|
|
|
|
NodeRect nr;
|
|
nr.node = Rect2(offset, s);
|
|
nr.node_name = E;
|
|
|
|
scroll_range = scroll_range.merge(nr.node); //merge with range
|
|
|
|
//now scroll it to draw
|
|
nr.node.position -= state_machine->get_graph_offset() * EDSCALE;
|
|
|
|
node_rects.push_back(nr);
|
|
}
|
|
|
|
transition_lines.clear();
|
|
|
|
//draw connecting line for potential new transition
|
|
if (connecting) {
|
|
Vector2 from = (state_machine->get_node_position(connecting_from) * EDSCALE) - state_machine->get_graph_offset() * EDSCALE;
|
|
Vector2 to;
|
|
if (connecting_to_node != StringName()) {
|
|
to = (state_machine->get_node_position(connecting_to_node) * EDSCALE) - state_machine->get_graph_offset() * EDSCALE;
|
|
} else {
|
|
to = connecting_to;
|
|
}
|
|
|
|
for (int i = 0; i < node_rects.size(); i++) {
|
|
if (node_rects[i].node_name == connecting_from) {
|
|
_clip_src_line_to_rect(from, to, node_rects[i].node);
|
|
}
|
|
if (node_rects[i].node_name == connecting_to_node) {
|
|
_clip_dst_line_to_rect(from, to, node_rects[i].node);
|
|
}
|
|
}
|
|
|
|
_connection_draw(from, to, AnimationNodeStateMachineTransition::SwitchMode(switch_mode->get_selected()), true, false, false, false, false);
|
|
}
|
|
|
|
Ref<Texture2D> tr_reference_icon = get_theme_icon(SNAME("TransitionImmediateBig"), SNAME("EditorIcons"));
|
|
float tr_bidi_offset = int(tr_reference_icon->get_height() * 0.8);
|
|
|
|
//draw transition lines
|
|
for (int i = 0; i < state_machine->get_transition_count(); i++) {
|
|
TransitionLine tl;
|
|
tl.transition_index = i;
|
|
tl.from_node = state_machine->get_transition_from(i);
|
|
StringName local_from = String(tl.from_node).get_slicec('/', 0);
|
|
local_from = local_from == ".." ? state_machine->start_node : local_from;
|
|
Vector2 ofs_from = (dragging_selected && selected_nodes.has(local_from)) ? drag_ofs : Vector2();
|
|
tl.from = (state_machine->get_node_position(local_from) * EDSCALE) + ofs_from - state_machine->get_graph_offset() * EDSCALE;
|
|
|
|
tl.to_node = state_machine->get_transition_to(i);
|
|
StringName local_to = String(tl.to_node).get_slicec('/', 0);
|
|
local_to = local_to == ".." ? state_machine->end_node : local_to;
|
|
Vector2 ofs_to = (dragging_selected && selected_nodes.has(local_to)) ? drag_ofs : Vector2();
|
|
tl.to = (state_machine->get_node_position(local_to) * EDSCALE) + ofs_to - state_machine->get_graph_offset() * EDSCALE;
|
|
|
|
Ref<AnimationNodeStateMachineTransition> tr = state_machine->get_transition(i);
|
|
tl.disabled = bool(tr->get_advance_mode() == AnimationNodeStateMachineTransition::ADVANCE_MODE_DISABLED);
|
|
tl.auto_advance = bool(tr->get_advance_mode() == AnimationNodeStateMachineTransition::ADVANCE_MODE_AUTO);
|
|
tl.advance_condition_name = tr->get_advance_condition_name();
|
|
tl.advance_condition_state = false;
|
|
tl.mode = tr->get_switch_mode();
|
|
tl.width = tr_bidi_offset;
|
|
tl.travel = false;
|
|
tl.hidden = false;
|
|
|
|
if (state_machine->has_local_transition(local_to, local_from)) { //offset if same exists
|
|
Vector2 offset = -(tl.from - tl.to).normalized().orthogonal() * tr_bidi_offset;
|
|
tl.from += offset;
|
|
tl.to += offset;
|
|
}
|
|
|
|
for (int j = 0; j < node_rects.size(); j++) {
|
|
if (node_rects[j].node_name == local_from) {
|
|
_clip_src_line_to_rect(tl.from, tl.to, node_rects[j].node);
|
|
}
|
|
if (node_rects[j].node_name == local_to) {
|
|
_clip_dst_line_to_rect(tl.from, tl.to, node_rects[j].node);
|
|
}
|
|
}
|
|
|
|
tl.selected = selected_transition_from == tl.from_node && selected_transition_to == tl.to_node;
|
|
|
|
if (blend_from == local_from && current == local_to) {
|
|
tl.travel = true;
|
|
}
|
|
|
|
if (travel_path.size()) {
|
|
if (current == local_from && travel_path[0] == local_to) {
|
|
tl.travel = true;
|
|
} else {
|
|
for (int j = 0; j < travel_path.size() - 1; j++) {
|
|
if (travel_path[j] == local_from && travel_path[j + 1] == local_to) {
|
|
tl.travel = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
StringName fullpath = AnimationTreeEditor::get_singleton()->get_base_path() + String(tl.advance_condition_name);
|
|
if (tl.advance_condition_name != StringName() && bool(tree->get(fullpath))) {
|
|
tl.advance_condition_state = true;
|
|
tl.auto_advance = true;
|
|
}
|
|
|
|
// check if already have this local transition
|
|
for (int j = 0; j < transition_lines.size(); j++) {
|
|
StringName from = String(transition_lines[j].from_node).get_slicec('/', 0);
|
|
StringName to = String(transition_lines[j].to_node).get_slicec('/', 0);
|
|
from = from == ".." ? state_machine->start_node : from;
|
|
to = to == ".." ? state_machine->end_node : to;
|
|
|
|
if (from == local_from && to == local_to) {
|
|
tl.hidden = true;
|
|
transition_lines.write[j].disabled = transition_lines[j].disabled && tl.disabled;
|
|
transition_lines.write[j].multi_transitions.push_back(tl);
|
|
}
|
|
}
|
|
transition_lines.push_back(tl);
|
|
}
|
|
|
|
for (int i = 0; i < transition_lines.size(); i++) {
|
|
TransitionLine tl = transition_lines[i];
|
|
if (!tl.hidden) {
|
|
_connection_draw(tl.from, tl.to, tl.mode, !tl.disabled, tl.selected, tl.travel, tl.auto_advance, !tl.multi_transitions.is_empty());
|
|
}
|
|
}
|
|
|
|
//draw actual nodes
|
|
for (int i = 0; i < node_rects.size(); i++) {
|
|
String name = node_rects[i].node_name;
|
|
Ref<AnimationNode> anode = state_machine->get_node(name);
|
|
bool needs_editor = AnimationTreeEditor::get_singleton()->can_edit(anode);
|
|
Ref<StyleBox> sb = selected_nodes.has(name) ? style_selected : style;
|
|
int strsize = font->get_string_size(name, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width;
|
|
NodeRect &nr = node_rects.write[i];
|
|
|
|
Vector2 offset = nr.node.position;
|
|
int h = nr.node.size.height;
|
|
|
|
//prepre rect
|
|
|
|
//now scroll it to draw
|
|
state_machine_draw->draw_style_box(sb, nr.node);
|
|
|
|
if (state_machine->start_node == name) {
|
|
state_machine_draw->draw_style_box(sb == style_selected ? style_selected : start_overlay, nr.node);
|
|
}
|
|
|
|
if (state_machine->end_node == name) {
|
|
state_machine_draw->draw_style_box(sb == style_selected ? style_selected : end_overlay, nr.node);
|
|
}
|
|
|
|
if (playing && (blend_from == name || current == name || travel_path.has(name))) {
|
|
state_machine_draw->draw_style_box(playing_overlay, nr.node);
|
|
}
|
|
|
|
offset.x += sb->get_offset().x;
|
|
|
|
nr.play.position = offset + Vector2(0, (h - play->get_height()) / 2).floor();
|
|
nr.play.size = play->get_size();
|
|
|
|
Ref<Texture2D> play_tex = play;
|
|
|
|
if (over_node == name && over_node_what == 0) {
|
|
state_machine_draw->draw_texture(play_tex, nr.play.position, accent);
|
|
} else {
|
|
state_machine_draw->draw_texture(play_tex, nr.play.position);
|
|
}
|
|
|
|
offset.x += sep + play->get_width();
|
|
|
|
nr.name.position = offset + Vector2(0, (h - font->get_height(font_size)) / 2).floor();
|
|
nr.name.size = Vector2(strsize, font->get_height(font_size));
|
|
|
|
state_machine_draw->draw_string(font, nr.name.position + Vector2(0, font->get_ascent(font_size)), name, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, font_color);
|
|
offset.x += strsize + sep;
|
|
|
|
if (needs_editor) {
|
|
nr.edit.position = offset + Vector2(0, (h - edit->get_height()) / 2).floor();
|
|
nr.edit.size = edit->get_size();
|
|
|
|
if (over_node == name && over_node_what == 1) {
|
|
state_machine_draw->draw_texture(edit, nr.edit.position, accent);
|
|
} else {
|
|
state_machine_draw->draw_texture(edit, nr.edit.position);
|
|
}
|
|
}
|
|
}
|
|
|
|
//draw box select
|
|
if (box_selecting) {
|
|
state_machine_draw->draw_rect(box_selecting_rect, Color(0.7, 0.7, 1.0, 0.3));
|
|
}
|
|
|
|
scroll_range.position -= state_machine_draw->get_size();
|
|
scroll_range.size += state_machine_draw->get_size() * 2.0;
|
|
|
|
//adjust scrollbars
|
|
updating = true;
|
|
h_scroll->set_min(scroll_range.position.x);
|
|
h_scroll->set_max(scroll_range.position.x + scroll_range.size.x);
|
|
h_scroll->set_page(state_machine_draw->get_size().x);
|
|
h_scroll->set_value(state_machine->get_graph_offset().x);
|
|
|
|
v_scroll->set_min(scroll_range.position.y);
|
|
v_scroll->set_max(scroll_range.position.y + scroll_range.size.y);
|
|
v_scroll->set_page(state_machine_draw->get_size().y);
|
|
v_scroll->set_value(state_machine->get_graph_offset().y);
|
|
updating = false;
|
|
|
|
state_machine_play_pos->queue_redraw();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_state_machine_pos_draw() {
|
|
AnimationTree *tree = AnimationTreeEditor::get_singleton()->get_animation_tree();
|
|
if (!tree) {
|
|
return;
|
|
}
|
|
|
|
Ref<AnimationNodeStateMachinePlayback> playback = tree->get(AnimationTreeEditor::get_singleton()->get_base_path() + "playback");
|
|
|
|
if (!playback.is_valid() || !playback->is_playing()) {
|
|
return;
|
|
}
|
|
|
|
if (playback->get_current_node() == state_machine->start_node || playback->get_current_node() == state_machine->end_node) {
|
|
return;
|
|
}
|
|
|
|
int idx = -1;
|
|
for (int i = 0; i < node_rects.size(); i++) {
|
|
if (node_rects[i].node_name == playback->get_current_node()) {
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (idx == -1) {
|
|
return;
|
|
}
|
|
|
|
const NodeRect &nr = node_rects[idx];
|
|
|
|
Vector2 from;
|
|
from.x = nr.play.position.x;
|
|
from.y = (nr.play.position.y + nr.play.size.y + nr.node.position.y + nr.node.size.y) * 0.5;
|
|
|
|
Vector2 to;
|
|
if (nr.edit.size.x) {
|
|
to.x = nr.edit.position.x + nr.edit.size.x;
|
|
} else {
|
|
to.x = nr.name.position.x + nr.name.size.x;
|
|
}
|
|
to.y = from.y;
|
|
|
|
float len = MAX(0.0001, current_length);
|
|
|
|
float pos = CLAMP(play_pos, 0, len);
|
|
float c = pos / len;
|
|
Color fg = get_theme_color(SNAME("font_color"), SNAME("Label"));
|
|
Color bg = fg;
|
|
bg.a *= 0.3;
|
|
|
|
state_machine_play_pos->draw_line(from, to, bg, 2);
|
|
|
|
to = from.lerp(to, c);
|
|
|
|
state_machine_play_pos->draw_line(from, to, fg, 2);
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_update_graph() {
|
|
if (updating) {
|
|
return;
|
|
}
|
|
|
|
updating = true;
|
|
|
|
state_machine_draw->queue_redraw();
|
|
|
|
updating = false;
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_notification(int p_what) {
|
|
switch (p_what) {
|
|
case NOTIFICATION_ENTER_TREE:
|
|
case NOTIFICATION_THEME_CHANGED:
|
|
case NOTIFICATION_LAYOUT_DIRECTION_CHANGED:
|
|
case NOTIFICATION_TRANSLATION_CHANGED: {
|
|
error_panel->add_theme_style_override("panel", get_theme_stylebox(SNAME("panel"), SNAME("Tree")));
|
|
error_label->add_theme_color_override("font_color", get_theme_color(SNAME("error_color"), SNAME("Editor")));
|
|
panel->add_theme_style_override("panel", get_theme_stylebox(SNAME("panel"), SNAME("Tree")));
|
|
|
|
tool_select->set_icon(get_theme_icon(SNAME("ToolSelect"), SNAME("EditorIcons")));
|
|
tool_create->set_icon(get_theme_icon(SNAME("ToolAddNode"), SNAME("EditorIcons")));
|
|
tool_connect->set_icon(get_theme_icon(SNAME("ToolConnect"), SNAME("EditorIcons")));
|
|
|
|
switch_mode->clear();
|
|
switch_mode->add_icon_item(get_theme_icon(SNAME("TransitionImmediate"), SNAME("EditorIcons")), TTR("Immediate"));
|
|
switch_mode->add_icon_item(get_theme_icon(SNAME("TransitionSync"), SNAME("EditorIcons")), TTR("Sync"));
|
|
switch_mode->add_icon_item(get_theme_icon(SNAME("TransitionEnd"), SNAME("EditorIcons")), TTR("At End"));
|
|
|
|
auto_advance->set_icon(get_theme_icon(SNAME("AutoPlay"), SNAME("EditorIcons")));
|
|
|
|
tool_erase->set_icon(get_theme_icon(SNAME("Remove"), SNAME("EditorIcons")));
|
|
tool_group->set_icon(get_theme_icon(SNAME("Group"), SNAME("EditorIcons")));
|
|
tool_ungroup->set_icon(get_theme_icon(SNAME("Ungroup"), SNAME("EditorIcons")));
|
|
|
|
play_mode->clear();
|
|
play_mode->add_icon_item(get_theme_icon(SNAME("PlayTravel"), SNAME("EditorIcons")), TTR("Travel"));
|
|
play_mode->add_icon_item(get_theme_icon(SNAME("Play"), SNAME("EditorIcons")), TTR("Immediate"));
|
|
} break;
|
|
|
|
case NOTIFICATION_PROCESS: {
|
|
AnimationTree *tree = AnimationTreeEditor::get_singleton()->get_animation_tree();
|
|
if (!tree) {
|
|
return;
|
|
}
|
|
|
|
String error;
|
|
|
|
Ref<AnimationNodeStateMachinePlayback> playback = tree->get(AnimationTreeEditor::get_singleton()->get_base_path() + "playback");
|
|
|
|
if (error_time > 0) {
|
|
error = error_text;
|
|
error_time -= get_process_delta_time();
|
|
} else if (!tree->is_active()) {
|
|
error = TTR("AnimationTree is inactive.\nActivate to enable playback, check node warnings if activation fails.");
|
|
} else if (tree->is_state_invalid()) {
|
|
error = tree->get_invalid_state_reason();
|
|
/*} else if (state_machine->get_parent().is_valid() && state_machine->get_parent()->is_class("AnimationNodeStateMachine")) {
|
|
if (state_machine->get_start_node() == StringName() || state_machine->get_end_node() == StringName()) {
|
|
error = TTR("Start and end nodes are needed for a sub-transition.");
|
|
}*/
|
|
} else if (playback.is_null()) {
|
|
error = vformat(TTR("No playback resource set at path: %s."), AnimationTreeEditor::get_singleton()->get_base_path() + "playback");
|
|
}
|
|
|
|
if (error != error_label->get_text()) {
|
|
error_label->set_text(error);
|
|
if (!error.is_empty()) {
|
|
error_panel->show();
|
|
} else {
|
|
error_panel->hide();
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < transition_lines.size(); i++) {
|
|
int tidx = -1;
|
|
for (int j = 0; j < state_machine->get_transition_count(); j++) {
|
|
if (transition_lines[i].from_node == state_machine->get_transition_from(j) && transition_lines[i].to_node == state_machine->get_transition_to(j)) {
|
|
tidx = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (tidx == -1) { //missing transition, should redraw
|
|
state_machine_draw->queue_redraw();
|
|
break;
|
|
}
|
|
|
|
if (transition_lines[i].disabled != bool(state_machine->get_transition(tidx)->get_advance_mode() == AnimationNodeStateMachineTransition::ADVANCE_MODE_DISABLED)) {
|
|
state_machine_draw->queue_redraw();
|
|
break;
|
|
}
|
|
|
|
if (transition_lines[i].auto_advance != bool(state_machine->get_transition(tidx)->get_advance_mode() == AnimationNodeStateMachineTransition::ADVANCE_MODE_AUTO)) {
|
|
state_machine_draw->queue_redraw();
|
|
break;
|
|
}
|
|
|
|
if (transition_lines[i].advance_condition_name != state_machine->get_transition(tidx)->get_advance_condition_name()) {
|
|
state_machine_draw->queue_redraw();
|
|
break;
|
|
}
|
|
|
|
if (transition_lines[i].mode != state_machine->get_transition(tidx)->get_switch_mode()) {
|
|
state_machine_draw->queue_redraw();
|
|
break;
|
|
}
|
|
|
|
bool acstate = transition_lines[i].advance_condition_name != StringName() && bool(tree->get(AnimationTreeEditor::get_singleton()->get_base_path() + String(transition_lines[i].advance_condition_name)));
|
|
|
|
if (transition_lines[i].advance_condition_state != acstate) {
|
|
state_machine_draw->queue_redraw();
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool same_travel_path = true;
|
|
Vector<StringName> tp;
|
|
bool is_playing = false;
|
|
StringName current_node;
|
|
StringName blend_from_node;
|
|
play_pos = 0;
|
|
current_length = 0;
|
|
|
|
if (playback.is_valid()) {
|
|
tp = playback->get_travel_path();
|
|
is_playing = playback->is_playing();
|
|
current_node = playback->get_current_node();
|
|
blend_from_node = playback->get_blend_from_node();
|
|
play_pos = playback->get_current_play_pos();
|
|
current_length = playback->get_current_length();
|
|
}
|
|
|
|
{
|
|
if (last_travel_path.size() != tp.size()) {
|
|
same_travel_path = false;
|
|
} else {
|
|
for (int i = 0; i < last_travel_path.size(); i++) {
|
|
if (last_travel_path[i] != tp[i]) {
|
|
same_travel_path = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//redraw if travel state changed
|
|
if (!same_travel_path || last_active != is_playing || last_current_node != current_node || last_blend_from_node != blend_from_node) {
|
|
state_machine_draw->queue_redraw();
|
|
last_travel_path = tp;
|
|
last_current_node = current_node;
|
|
last_active = is_playing;
|
|
last_blend_from_node = blend_from_node;
|
|
state_machine_play_pos->queue_redraw();
|
|
}
|
|
|
|
{
|
|
if (current_node != StringName() && state_machine->has_node(current_node)) {
|
|
String next = current_node;
|
|
Ref<AnimationNodeStateMachine> anodesm = state_machine->get_node(next);
|
|
Ref<AnimationNodeStateMachinePlayback> current_node_playback;
|
|
|
|
while (anodesm.is_valid()) {
|
|
current_node_playback = tree->get(AnimationTreeEditor::get_singleton()->get_base_path() + next + "/playback");
|
|
next += "/" + current_node_playback->get_current_node();
|
|
anodesm = anodesm->get_node(current_node_playback->get_current_node());
|
|
}
|
|
|
|
// when current_node is a state machine, use playback of current_node to set play_pos
|
|
if (current_node_playback.is_valid()) {
|
|
play_pos = current_node_playback->get_current_play_pos();
|
|
current_length = current_node_playback->get_current_length();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (last_play_pos != play_pos) {
|
|
last_play_pos = play_pos;
|
|
state_machine_play_pos->queue_redraw();
|
|
}
|
|
} break;
|
|
|
|
case NOTIFICATION_VISIBILITY_CHANGED: {
|
|
over_node = StringName();
|
|
set_process(is_visible_in_tree());
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_open_editor(const String &p_name) {
|
|
AnimationTreeEditor::get_singleton()->enter_editor(p_name);
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_removed_from_graph() {
|
|
EditorNode::get_singleton()->edit_item(nullptr);
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_name_edited(const String &p_text) {
|
|
const String &new_name = p_text;
|
|
|
|
ERR_FAIL_COND(new_name.is_empty() || new_name.contains(".") || new_name.contains("/"));
|
|
|
|
if (new_name == prev_name) {
|
|
return; // Nothing to do.
|
|
}
|
|
|
|
const String &base_name = new_name;
|
|
int base = 1;
|
|
String name = base_name;
|
|
while (state_machine->has_node(name)) {
|
|
base++;
|
|
name = base_name + " " + itos(base);
|
|
}
|
|
|
|
updating = true;
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action(TTR("Node Renamed"));
|
|
undo_redo->add_do_method(state_machine.ptr(), "rename_node", prev_name, name);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "rename_node", name, prev_name);
|
|
undo_redo->add_do_method(this, "_update_graph");
|
|
undo_redo->add_undo_method(this, "_update_graph");
|
|
undo_redo->commit_action();
|
|
name_edit_popup->hide();
|
|
updating = false;
|
|
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_name_edited_focus_out() {
|
|
if (updating) {
|
|
return;
|
|
}
|
|
|
|
_name_edited(name_edit->get_text());
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_scroll_changed(double) {
|
|
if (updating) {
|
|
return;
|
|
}
|
|
|
|
state_machine->set_graph_offset(Vector2(h_scroll->get_value(), v_scroll->get_value()));
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_erase_selected(const bool p_nested_action) {
|
|
if (!selected_nodes.is_empty()) {
|
|
if (!p_nested_action) {
|
|
updating = true;
|
|
}
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action(TTR("Node Removed"));
|
|
|
|
for (int i = 0; i < node_rects.size(); i++) {
|
|
if (node_rects[i].node_name == state_machine->start_node || node_rects[i].node_name == state_machine->end_node) {
|
|
continue;
|
|
}
|
|
|
|
if (!selected_nodes.has(node_rects[i].node_name)) {
|
|
continue;
|
|
}
|
|
|
|
undo_redo->add_do_method(state_machine.ptr(), "remove_node", node_rects[i].node_name);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "add_node", node_rects[i].node_name,
|
|
state_machine->get_node(node_rects[i].node_name),
|
|
state_machine->get_node_position(node_rects[i].node_name));
|
|
|
|
for (int j = 0; j < state_machine->get_transition_count(); j++) {
|
|
String from = state_machine->get_transition_from(j);
|
|
String to = state_machine->get_transition_to(j);
|
|
String local_from = from.get_slicec('/', 0);
|
|
String local_to = to.get_slicec('/', 0);
|
|
|
|
if (local_from == node_rects[i].node_name || local_to == node_rects[i].node_name) {
|
|
undo_redo->add_undo_method(state_machine.ptr(), "add_transition", from, to, state_machine->get_transition(j));
|
|
}
|
|
}
|
|
}
|
|
|
|
undo_redo->add_do_method(this, "_update_graph");
|
|
undo_redo->add_undo_method(this, "_update_graph");
|
|
undo_redo->commit_action();
|
|
|
|
if (!p_nested_action) {
|
|
updating = false;
|
|
}
|
|
|
|
selected_nodes.clear();
|
|
}
|
|
|
|
if (!selected_multi_transition.multi_transitions.is_empty()) {
|
|
delete_tree->clear();
|
|
|
|
TreeItem *root = delete_tree->create_item();
|
|
|
|
TreeItem *item = delete_tree->create_item(root);
|
|
item->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
|
|
item->set_text(0, String(selected_transition_from) + " -> " + selected_transition_to);
|
|
item->set_editable(0, true);
|
|
|
|
for (int i = 0; i < selected_multi_transition.multi_transitions.size(); i++) {
|
|
String from = selected_multi_transition.multi_transitions[i].from_node;
|
|
String to = selected_multi_transition.multi_transitions[i].to_node;
|
|
|
|
item = delete_tree->create_item(root);
|
|
item->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
|
|
item->set_text(0, from + " -> " + to);
|
|
item->set_editable(0, true);
|
|
}
|
|
|
|
delete_window->popup_centered(Vector2(400, 200));
|
|
return;
|
|
}
|
|
|
|
if (selected_transition_to != StringName() && selected_transition_from != StringName() && state_machine->has_transition(selected_transition_from, selected_transition_to)) {
|
|
Ref<AnimationNodeStateMachineTransition> tr = state_machine->get_transition(state_machine->find_transition(selected_transition_from, selected_transition_to));
|
|
if (!p_nested_action) {
|
|
updating = true;
|
|
}
|
|
Ref<EditorUndoRedoManager> &undo_redo = EditorNode::get_undo_redo();
|
|
undo_redo->create_action(TTR("Transition Removed"));
|
|
undo_redo->add_do_method(state_machine.ptr(), "remove_transition", selected_transition_from, selected_transition_to);
|
|
undo_redo->add_undo_method(state_machine.ptr(), "add_transition", selected_transition_from, selected_transition_to, tr);
|
|
undo_redo->add_do_method(this, "_update_graph");
|
|
undo_redo->add_undo_method(this, "_update_graph");
|
|
undo_redo->commit_action();
|
|
if (!p_nested_action) {
|
|
updating = false;
|
|
}
|
|
selected_transition_from = StringName();
|
|
selected_transition_to = StringName();
|
|
selected_transition_index = -1;
|
|
selected_multi_transition = TransitionLine();
|
|
}
|
|
|
|
state_machine_draw->queue_redraw();
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_update_mode() {
|
|
if (tool_select->is_pressed()) {
|
|
selection_tools_hb->show();
|
|
bool nothing_selected = selected_nodes.is_empty() && selected_transition_from == StringName() && selected_transition_to == StringName();
|
|
bool start_end_selected = selected_nodes.size() == 1 && (*selected_nodes.begin() == state_machine->start_node || *selected_nodes.begin() == state_machine->end_node);
|
|
tool_erase->set_disabled(nothing_selected || start_end_selected || read_only);
|
|
|
|
if (selected_nodes.is_empty() || start_end_selected || read_only) {
|
|
tool_group->set_disabled(true);
|
|
tool_group->set_visible(true);
|
|
tool_ungroup->set_visible(false);
|
|
} else {
|
|
Ref<AnimationNodeStateMachine> ansm = state_machine->get_node(*selected_nodes.begin());
|
|
|
|
if (selected_nodes.size() == 1 && ansm.is_valid()) {
|
|
tool_group->set_disabled(true);
|
|
tool_group->set_visible(false);
|
|
tool_ungroup->set_visible(true);
|
|
} else {
|
|
tool_group->set_disabled(false);
|
|
tool_group->set_visible(true);
|
|
tool_ungroup->set_visible(false);
|
|
}
|
|
}
|
|
} else {
|
|
selection_tools_hb->hide();
|
|
}
|
|
|
|
if (tool_connect->is_pressed()) {
|
|
transition_tools_hb->show();
|
|
} else {
|
|
transition_tools_hb->hide();
|
|
}
|
|
}
|
|
|
|
void AnimationNodeStateMachineEditor::_bind_methods() {
|
|
ClassDB::bind_method("_update_graph", &AnimationNodeStateMachineEditor::_update_graph);
|
|
ClassDB::bind_method("_removed_from_graph", &AnimationNodeStateMachineEditor::_removed_from_graph);
|
|
ClassDB::bind_method("_open_editor", &AnimationNodeStateMachineEditor::_open_editor);
|
|
ClassDB::bind_method("_connect_to", &AnimationNodeStateMachineEditor::_connect_to);
|
|
ClassDB::bind_method("_stop_connecting", &AnimationNodeStateMachineEditor::_stop_connecting);
|
|
ClassDB::bind_method("_delete_selected", &AnimationNodeStateMachineEditor::_delete_selected);
|
|
ClassDB::bind_method("_delete_all", &AnimationNodeStateMachineEditor::_delete_all);
|
|
ClassDB::bind_method("_delete_tree_draw", &AnimationNodeStateMachineEditor::_delete_tree_draw);
|
|
}
|
|
|
|
AnimationNodeStateMachineEditor *AnimationNodeStateMachineEditor::singleton = nullptr;
|
|
|
|
AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() {
|
|
singleton = this;
|
|
|
|
HBoxContainer *top_hb = memnew(HBoxContainer);
|
|
add_child(top_hb);
|
|
|
|
Ref<ButtonGroup> bg;
|
|
bg.instantiate();
|
|
|
|
tool_select = memnew(Button);
|
|
tool_select->set_flat(true);
|
|
top_hb->add_child(tool_select);
|
|
tool_select->set_toggle_mode(true);
|
|
tool_select->set_button_group(bg);
|
|
tool_select->set_pressed(true);
|
|
tool_select->set_tooltip_text(TTR("Select and move nodes.\nRMB: Add node at position clicked.\nShift+LMB+Drag: Connects the selected node with another node or creates a new node if you select an area without nodes."));
|
|
tool_select->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), CONNECT_DEFERRED);
|
|
|
|
tool_create = memnew(Button);
|
|
tool_create->set_flat(true);
|
|
top_hb->add_child(tool_create);
|
|
tool_create->set_toggle_mode(true);
|
|
tool_create->set_button_group(bg);
|
|
tool_create->set_tooltip_text(TTR("Create new nodes."));
|
|
tool_create->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), CONNECT_DEFERRED);
|
|
|
|
tool_connect = memnew(Button);
|
|
tool_connect->set_flat(true);
|
|
top_hb->add_child(tool_connect);
|
|
tool_connect->set_toggle_mode(true);
|
|
tool_connect->set_button_group(bg);
|
|
tool_connect->set_tooltip_text(TTR("Connect nodes."));
|
|
tool_connect->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), CONNECT_DEFERRED);
|
|
|
|
// Context-sensitive selection tools:
|
|
selection_tools_hb = memnew(HBoxContainer);
|
|
top_hb->add_child(selection_tools_hb);
|
|
selection_tools_hb->add_child(memnew(VSeparator));
|
|
|
|
tool_group = memnew(Button);
|
|
tool_group->set_flat(true);
|
|
tool_group->set_tooltip_text(TTR("Group Selected Node(s)") + " (Ctrl+G)");
|
|
tool_group->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_group_selected_nodes));
|
|
tool_group->set_disabled(true);
|
|
selection_tools_hb->add_child(tool_group);
|
|
|
|
tool_ungroup = memnew(Button);
|
|
tool_ungroup->set_flat(true);
|
|
tool_ungroup->set_tooltip_text(TTR("Ungroup Selected Node") + " (Ctrl+Shift+G)");
|
|
tool_ungroup->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_ungroup_selected_nodes));
|
|
tool_ungroup->set_visible(false);
|
|
selection_tools_hb->add_child(tool_ungroup);
|
|
|
|
tool_erase = memnew(Button);
|
|
tool_erase->set_flat(true);
|
|
tool_erase->set_tooltip_text(TTR("Remove selected node or transition."));
|
|
tool_erase->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_erase_selected).bind(false));
|
|
tool_erase->set_disabled(true);
|
|
selection_tools_hb->add_child(tool_erase);
|
|
|
|
transition_tools_hb = memnew(HBoxContainer);
|
|
top_hb->add_child(transition_tools_hb);
|
|
transition_tools_hb->add_child(memnew(VSeparator));
|
|
|
|
transition_tools_hb->add_child(memnew(Label(TTR("Transition:"))));
|
|
switch_mode = memnew(OptionButton);
|
|
transition_tools_hb->add_child(switch_mode);
|
|
|
|
auto_advance = memnew(Button);
|
|
auto_advance->set_flat(true);
|
|
auto_advance->set_tooltip_text(TTR("New Transitions Should Auto Advance"));
|
|
auto_advance->set_toggle_mode(true);
|
|
auto_advance->set_pressed(true);
|
|
transition_tools_hb->add_child(auto_advance);
|
|
|
|
//
|
|
|
|
top_hb->add_spacer();
|
|
|
|
top_hb->add_child(memnew(Label(TTR("Play Mode:"))));
|
|
play_mode = memnew(OptionButton);
|
|
top_hb->add_child(play_mode);
|
|
|
|
panel = memnew(PanelContainer);
|
|
panel->set_clip_contents(true);
|
|
panel->set_mouse_filter(Control::MOUSE_FILTER_PASS);
|
|
add_child(panel);
|
|
panel->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
state_machine_draw = memnew(Control);
|
|
panel->add_child(state_machine_draw);
|
|
state_machine_draw->connect("gui_input", callable_mp(this, &AnimationNodeStateMachineEditor::_state_machine_gui_input));
|
|
state_machine_draw->connect("draw", callable_mp(this, &AnimationNodeStateMachineEditor::_state_machine_draw));
|
|
state_machine_draw->set_focus_mode(FOCUS_ALL);
|
|
state_machine_draw->set_mouse_filter(Control::MOUSE_FILTER_PASS);
|
|
|
|
state_machine_play_pos = memnew(Control);
|
|
state_machine_draw->add_child(state_machine_play_pos);
|
|
state_machine_play_pos->set_mouse_filter(MOUSE_FILTER_PASS); //pass all to parent
|
|
state_machine_play_pos->set_anchors_and_offsets_preset(PRESET_FULL_RECT);
|
|
state_machine_play_pos->connect("draw", callable_mp(this, &AnimationNodeStateMachineEditor::_state_machine_pos_draw));
|
|
|
|
v_scroll = memnew(VScrollBar);
|
|
state_machine_draw->add_child(v_scroll);
|
|
v_scroll->set_anchors_and_offsets_preset(PRESET_RIGHT_WIDE);
|
|
v_scroll->connect("value_changed", callable_mp(this, &AnimationNodeStateMachineEditor::_scroll_changed));
|
|
|
|
h_scroll = memnew(HScrollBar);
|
|
state_machine_draw->add_child(h_scroll);
|
|
h_scroll->set_anchors_and_offsets_preset(PRESET_BOTTOM_WIDE);
|
|
h_scroll->set_offset(SIDE_RIGHT, -v_scroll->get_size().x * EDSCALE);
|
|
h_scroll->connect("value_changed", callable_mp(this, &AnimationNodeStateMachineEditor::_scroll_changed));
|
|
|
|
error_panel = memnew(PanelContainer);
|
|
add_child(error_panel);
|
|
error_label = memnew(Label);
|
|
error_panel->add_child(error_label);
|
|
error_panel->hide();
|
|
|
|
set_custom_minimum_size(Size2(0, 300 * EDSCALE));
|
|
|
|
menu = memnew(PopupMenu);
|
|
add_child(menu);
|
|
menu->connect("id_pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_add_menu_type));
|
|
menu->connect("popup_hide", callable_mp(this, &AnimationNodeStateMachineEditor::_stop_connecting));
|
|
|
|
animations_menu = memnew(PopupMenu);
|
|
menu->add_child(animations_menu);
|
|
animations_menu->set_name("animations");
|
|
animations_menu->connect("index_pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_add_animation_type));
|
|
|
|
connect_menu = memnew(PopupMenu);
|
|
add_child(connect_menu);
|
|
connect_menu->connect("id_pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_connect_to));
|
|
connect_menu->connect("popup_hide", callable_mp(this, &AnimationNodeStateMachineEditor::_stop_connecting));
|
|
|
|
state_machine_menu = memnew(PopupMenu);
|
|
state_machine_menu->set_name("state_machines");
|
|
state_machine_menu->connect("id_pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_connect_to));
|
|
connect_menu->add_child(state_machine_menu);
|
|
|
|
end_menu = memnew(PopupMenu);
|
|
end_menu->set_name("end_nodes");
|
|
end_menu->connect("id_pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_connect_to));
|
|
connect_menu->add_child(end_menu);
|
|
|
|
name_edit_popup = memnew(Popup);
|
|
add_child(name_edit_popup);
|
|
name_edit = memnew(LineEdit);
|
|
name_edit_popup->add_child(name_edit);
|
|
name_edit->set_anchors_and_offsets_preset(PRESET_FULL_RECT);
|
|
name_edit->connect("text_submitted", callable_mp(this, &AnimationNodeStateMachineEditor::_name_edited));
|
|
name_edit->connect("focus_exited", callable_mp(this, &AnimationNodeStateMachineEditor::_name_edited_focus_out));
|
|
|
|
open_file = memnew(EditorFileDialog);
|
|
add_child(open_file);
|
|
open_file->set_title(TTR("Open Animation Node"));
|
|
open_file->set_file_mode(EditorFileDialog::FILE_MODE_OPEN_FILE);
|
|
open_file->connect("file_selected", callable_mp(this, &AnimationNodeStateMachineEditor::_file_opened));
|
|
|
|
delete_window = memnew(ConfirmationDialog);
|
|
delete_window->set_flag(Window::FLAG_RESIZE_DISABLED, true);
|
|
add_child(delete_window);
|
|
|
|
delete_tree = memnew(Tree);
|
|
delete_tree->set_hide_root(true);
|
|
delete_tree->connect("draw", callable_mp(this, &AnimationNodeStateMachineEditor::_delete_tree_draw));
|
|
delete_window->add_child(delete_tree);
|
|
|
|
Button *ok = delete_window->get_cancel_button();
|
|
ok->set_text(TTR("Delete Selected"));
|
|
ok->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_delete_selected));
|
|
|
|
Button *delete_all = delete_window->add_button(TTR("Delete All"), true);
|
|
delete_all->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_delete_all));
|
|
|
|
over_node_what = -1;
|
|
dragging_selected_attempt = false;
|
|
connecting = false;
|
|
selected_transition_index = -1;
|
|
|
|
last_active = false;
|
|
|
|
error_time = 0;
|
|
}
|
|
|
|
void EditorAnimationMultiTransitionEdit::add_transition(const StringName &p_from, const StringName &p_to, Ref<AnimationNodeStateMachineTransition> p_transition) {
|
|
Transition tr;
|
|
tr.from = p_from;
|
|
tr.to = p_to;
|
|
tr.transition = p_transition;
|
|
transitions.push_back(tr);
|
|
}
|
|
|
|
bool EditorAnimationMultiTransitionEdit::_set(const StringName &p_name, const Variant &p_property) {
|
|
int index = String(p_name).get_slicec('/', 0).to_int();
|
|
StringName prop = String(p_name).get_slicec('/', 1);
|
|
|
|
bool found;
|
|
transitions.write[index].transition->set(prop, p_property, &found);
|
|
if (found) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool EditorAnimationMultiTransitionEdit::_get(const StringName &p_name, Variant &r_property) const {
|
|
int index = String(p_name).get_slicec('/', 0).to_int();
|
|
StringName prop = String(p_name).get_slicec('/', 1);
|
|
|
|
if (prop == "transition_path") {
|
|
r_property = String(transitions[index].from) + " -> " + transitions[index].to;
|
|
return true;
|
|
}
|
|
|
|
bool found;
|
|
r_property = transitions[index].transition->get(prop, &found);
|
|
if (found) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void EditorAnimationMultiTransitionEdit::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
for (int i = 0; i < transitions.size(); i++) {
|
|
List<PropertyInfo> plist;
|
|
transitions[i].transition->get_property_list(&plist, true);
|
|
|
|
PropertyInfo prop_transition_path;
|
|
prop_transition_path.type = Variant::STRING;
|
|
prop_transition_path.name = itos(i) + "/" + "transition_path";
|
|
p_list->push_back(prop_transition_path);
|
|
|
|
for (List<PropertyInfo>::Element *F = plist.front(); F; F = F->next()) {
|
|
if (F->get().name == "script" || F->get().name == "resource_name" || F->get().name == "resource_path" || F->get().name == "resource_local_to_scene") {
|
|
continue;
|
|
}
|
|
|
|
if (F->get().usage != PROPERTY_USAGE_DEFAULT) {
|
|
continue;
|
|
}
|
|
|
|
PropertyInfo prop = F->get();
|
|
prop.name = itos(i) + "/" + prop.name;
|
|
|
|
p_list->push_back(prop);
|
|
}
|
|
}
|
|
}
|