5223 lines
158 KiB
C++
5223 lines
158 KiB
C++
/*************************************************************************/
|
|
/* animation_track_editor.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "animation_track_editor.h"
|
|
|
|
#include "animation_track_editor_plugins.h"
|
|
#include "core/os/keyboard.h"
|
|
#include "editor/animation_bezier_editor.h"
|
|
#include "editor/plugins/animation_player_editor_plugin.h"
|
|
#include "editor_node.h"
|
|
#include "editor_scale.h"
|
|
#include "scene/main/viewport.h"
|
|
#include "servers/audio/audio_stream.h"
|
|
|
|
class AnimationTrackKeyEdit : public Object {
|
|
|
|
GDCLASS(AnimationTrackKeyEdit, Object);
|
|
|
|
public:
|
|
bool setting;
|
|
|
|
bool _hide_script_from_inspector() {
|
|
return true;
|
|
}
|
|
|
|
bool _dont_undo_redo() {
|
|
return true;
|
|
}
|
|
|
|
static void _bind_methods() {
|
|
|
|
ClassDB::bind_method("_update_obj", &AnimationTrackKeyEdit::_update_obj);
|
|
ClassDB::bind_method("_key_ofs_changed", &AnimationTrackKeyEdit::_key_ofs_changed);
|
|
ClassDB::bind_method("_hide_script_from_inspector", &AnimationTrackKeyEdit::_hide_script_from_inspector);
|
|
ClassDB::bind_method("get_root_path", &AnimationTrackKeyEdit::get_root_path);
|
|
ClassDB::bind_method("_dont_undo_redo", &AnimationTrackKeyEdit::_dont_undo_redo);
|
|
}
|
|
|
|
//PopupDialog *ke_dialog;
|
|
|
|
void _fix_node_path(Variant &value) {
|
|
|
|
NodePath np = value;
|
|
|
|
if (np == NodePath())
|
|
return;
|
|
|
|
Node *root = EditorNode::get_singleton()->get_tree()->get_root();
|
|
|
|
Node *np_node = root->get_node(np);
|
|
ERR_FAIL_COND(!np_node);
|
|
|
|
Node *edited_node = root->get_node(base);
|
|
ERR_FAIL_COND(!edited_node);
|
|
|
|
value = edited_node->get_path_to(np_node);
|
|
}
|
|
|
|
void _update_obj(const Ref<Animation> &p_anim) {
|
|
if (setting)
|
|
return;
|
|
if (!(animation == p_anim))
|
|
return;
|
|
|
|
notify_change();
|
|
}
|
|
|
|
void _key_ofs_changed(const Ref<Animation> &p_anim, float from, float to) {
|
|
if (!(animation == p_anim))
|
|
return;
|
|
if (from != key_ofs)
|
|
return;
|
|
key_ofs = to;
|
|
if (setting)
|
|
return;
|
|
notify_change();
|
|
}
|
|
|
|
bool _set(const StringName &p_name, const Variant &p_value) {
|
|
|
|
int key = animation->track_find_key(track, key_ofs, true);
|
|
ERR_FAIL_COND_V(key == -1, false);
|
|
|
|
String name = p_name;
|
|
if (name == "time" || name == "frame") {
|
|
|
|
float new_time = p_value;
|
|
|
|
if (name == "frame") {
|
|
float fps = animation->get_step();
|
|
if (fps > 0) {
|
|
fps = 1.0 / fps;
|
|
}
|
|
new_time /= fps;
|
|
}
|
|
if (new_time == key_ofs)
|
|
return true;
|
|
|
|
int existing = animation->track_find_key(track, new_time, true);
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Time"), UndoRedo::MERGE_ENDS);
|
|
|
|
Variant val = animation->track_get_key_value(track, key);
|
|
float trans = animation->track_get_key_transition(track, key);
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key", track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", track, new_time, val, trans);
|
|
undo_redo->add_do_method(this, "_key_ofs_changed", animation, key_ofs, new_time);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", track, new_time);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", track, key_ofs, val, trans);
|
|
undo_redo->add_undo_method(this, "_key_ofs_changed", animation, new_time, key_ofs);
|
|
|
|
if (existing != -1) {
|
|
Variant v = animation->track_get_key_value(track, existing);
|
|
trans = animation->track_get_key_transition(track, existing);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", track, new_time, v, trans);
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
setting = false;
|
|
|
|
return true;
|
|
} else if (name == "easing") {
|
|
|
|
float val = p_value;
|
|
float prev_val = animation->track_get_key_transition(track, key);
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Transition"), UndoRedo::MERGE_ENDS);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_key_transition", track, key, val);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_key_transition", track, key, prev_val);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
setting = false;
|
|
return true;
|
|
}
|
|
|
|
switch (animation->track_get_type(track)) {
|
|
|
|
case Animation::TYPE_TRANSFORM: {
|
|
|
|
Dictionary d_old = animation->track_get_key_value(track, key);
|
|
Dictionary d_new = d_old;
|
|
d_new[p_name] = p_value;
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Transform"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_key_value", track, key, d_new);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_key_value", track, key, d_old);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
|
|
} break;
|
|
case Animation::TYPE_VALUE: {
|
|
|
|
if (name == "value") {
|
|
|
|
Variant value = p_value;
|
|
|
|
if (value.get_type() == Variant::NODE_PATH) {
|
|
|
|
_fix_node_path(value);
|
|
}
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
Variant prev = animation->track_get_key_value(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_key_value", track, key, value);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_key_value", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_METHOD: {
|
|
|
|
Dictionary d_old = animation->track_get_key_value(track, key);
|
|
Dictionary d_new = d_old;
|
|
|
|
bool change_notify_deserved = false;
|
|
bool mergeable = false;
|
|
|
|
if (name == "name") {
|
|
|
|
d_new["method"] = p_value;
|
|
}
|
|
|
|
if (name == "arg_count") {
|
|
|
|
Vector<Variant> args = d_old["args"];
|
|
args.resize(p_value);
|
|
d_new["args"] = args;
|
|
change_notify_deserved = true;
|
|
}
|
|
|
|
if (name.begins_with("args/")) {
|
|
|
|
Vector<Variant> args = d_old["args"];
|
|
int idx = name.get_slice("/", 1).to_int();
|
|
ERR_FAIL_INDEX_V(idx, args.size(), false);
|
|
|
|
String what = name.get_slice("/", 2);
|
|
if (what == "type") {
|
|
Variant::Type t = Variant::Type(int(p_value));
|
|
|
|
if (t != args[idx].get_type()) {
|
|
Variant::CallError err;
|
|
if (Variant::can_convert(args[idx].get_type(), t)) {
|
|
Variant old = args[idx];
|
|
Variant *ptrs[1] = { &old };
|
|
args.write[idx] = Variant::construct(t, (const Variant **)ptrs, 1, err);
|
|
} else {
|
|
|
|
args.write[idx] = Variant::construct(t, NULL, 0, err);
|
|
}
|
|
change_notify_deserved = true;
|
|
d_new["args"] = args;
|
|
}
|
|
}
|
|
if (what == "value") {
|
|
|
|
Variant value = p_value;
|
|
if (value.get_type() == Variant::NODE_PATH) {
|
|
|
|
_fix_node_path(value);
|
|
}
|
|
|
|
args.write[idx] = value;
|
|
d_new["args"] = args;
|
|
mergeable = true;
|
|
}
|
|
}
|
|
|
|
if (mergeable)
|
|
undo_redo->create_action(TTR("Anim Change Call"), UndoRedo::MERGE_ENDS);
|
|
else
|
|
undo_redo->create_action(TTR("Anim Change Call"));
|
|
|
|
Variant prev = animation->track_get_key_value(track, key);
|
|
setting = true;
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_key_value", track, key, d_new);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_key_value", track, key, d_old);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
if (change_notify_deserved)
|
|
notify_change();
|
|
return true;
|
|
} break;
|
|
case Animation::TYPE_BEZIER: {
|
|
|
|
if (name == "value") {
|
|
|
|
Variant value = p_value;
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
float prev = animation->bezier_track_get_key_value(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "bezier_track_set_key_value", track, key, value);
|
|
undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_value", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
}
|
|
if (name == "in_handle") {
|
|
|
|
Variant value = p_value;
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
Vector2 prev = animation->bezier_track_get_key_in_handle(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "bezier_track_set_in_handle", track, key, value);
|
|
undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_in_handle", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
}
|
|
if (name == "out_handle") {
|
|
|
|
Variant value = p_value;
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
Vector2 prev = animation->bezier_track_get_key_out_handle(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "bezier_track_set_out_handle", track, key, value);
|
|
undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_out_handle", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_AUDIO: {
|
|
|
|
if (name == "stream") {
|
|
|
|
Ref<AudioStream> stream = p_value;
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
RES prev = animation->audio_track_get_key_stream(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "audio_track_set_key_stream", track, key, stream);
|
|
undo_redo->add_undo_method(animation.ptr(), "audio_track_set_key_stream", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
}
|
|
if (name == "start_offset") {
|
|
|
|
float value = p_value;
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
float prev = animation->audio_track_get_key_start_offset(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "audio_track_set_key_start_offset", track, key, value);
|
|
undo_redo->add_undo_method(animation.ptr(), "audio_track_set_key_start_offset", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
}
|
|
if (name == "end_offset") {
|
|
|
|
float value = p_value;
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
float prev = animation->audio_track_get_key_end_offset(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "audio_track_set_key_end_offset", track, key, value);
|
|
undo_redo->add_undo_method(animation.ptr(), "audio_track_set_key_end_offset", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
|
|
setting = false;
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_ANIMATION: {
|
|
|
|
if (name == "animation") {
|
|
|
|
StringName anim_name = p_value;
|
|
|
|
setting = true;
|
|
undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
|
|
StringName prev = animation->animation_track_get_key_animation(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "animation_track_set_key_animation", track, key, anim_name);
|
|
undo_redo->add_undo_method(animation.ptr(), "animation_track_set_key_animation", track, key, prev);
|
|
undo_redo->add_do_method(this, "_update_obj", animation);
|
|
undo_redo->add_undo_method(this, "_update_obj", animation);
|
|
undo_redo->commit_action();
|
|
setting = false;
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool _get(const StringName &p_name, Variant &r_ret) const {
|
|
|
|
int key = animation->track_find_key(track, key_ofs, true);
|
|
ERR_FAIL_COND_V(key == -1, false);
|
|
|
|
String name = p_name;
|
|
if (name == "time") {
|
|
r_ret = key_ofs;
|
|
return true;
|
|
} else if (name == "frame") {
|
|
float fps = animation->get_step();
|
|
if (fps > 0) {
|
|
fps = 1.0 / fps;
|
|
}
|
|
r_ret = key_ofs * fps;
|
|
return true;
|
|
} else if (name == "easing") {
|
|
r_ret = animation->track_get_key_transition(track, key);
|
|
return true;
|
|
}
|
|
|
|
switch (animation->track_get_type(track)) {
|
|
|
|
case Animation::TYPE_TRANSFORM: {
|
|
|
|
Dictionary d = animation->track_get_key_value(track, key);
|
|
ERR_FAIL_COND_V(!d.has(name), false);
|
|
r_ret = d[p_name];
|
|
return true;
|
|
|
|
} break;
|
|
case Animation::TYPE_VALUE: {
|
|
|
|
if (name == "value") {
|
|
r_ret = animation->track_get_key_value(track, key);
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_METHOD: {
|
|
|
|
Dictionary d = animation->track_get_key_value(track, key);
|
|
|
|
if (name == "name") {
|
|
|
|
ERR_FAIL_COND_V(!d.has("method"), false);
|
|
r_ret = d["method"];
|
|
return true;
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!d.has("args"), false);
|
|
|
|
Vector<Variant> args = d["args"];
|
|
|
|
if (name == "arg_count") {
|
|
|
|
r_ret = args.size();
|
|
return true;
|
|
}
|
|
|
|
if (name.begins_with("args/")) {
|
|
|
|
int idx = name.get_slice("/", 1).to_int();
|
|
ERR_FAIL_INDEX_V(idx, args.size(), false);
|
|
|
|
String what = name.get_slice("/", 2);
|
|
if (what == "type") {
|
|
r_ret = args[idx].get_type();
|
|
return true;
|
|
}
|
|
if (what == "value") {
|
|
r_ret = args[idx];
|
|
return true;
|
|
}
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_BEZIER: {
|
|
|
|
if (name == "value") {
|
|
r_ret = animation->bezier_track_get_key_value(track, key);
|
|
return true;
|
|
}
|
|
if (name == "in_handle") {
|
|
r_ret = animation->bezier_track_get_key_in_handle(track, key);
|
|
return true;
|
|
}
|
|
if (name == "out_handle") {
|
|
r_ret = animation->bezier_track_get_key_out_handle(track, key);
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_AUDIO: {
|
|
|
|
if (name == "stream") {
|
|
r_ret = animation->audio_track_get_key_stream(track, key);
|
|
return true;
|
|
}
|
|
if (name == "start_offset") {
|
|
r_ret = animation->audio_track_get_key_start_offset(track, key);
|
|
return true;
|
|
}
|
|
if (name == "end_offset") {
|
|
r_ret = animation->audio_track_get_key_end_offset(track, key);
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_ANIMATION: {
|
|
|
|
if (name == "animation") {
|
|
r_ret = animation->animation_track_get_key_animation(track, key);
|
|
return true;
|
|
}
|
|
|
|
} break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
void _get_property_list(List<PropertyInfo> *p_list) const {
|
|
|
|
if (animation.is_null())
|
|
return;
|
|
|
|
ERR_FAIL_INDEX(track, animation->get_track_count());
|
|
int key = animation->track_find_key(track, key_ofs, true);
|
|
ERR_FAIL_COND(key == -1);
|
|
|
|
if (use_fps && animation->get_step() > 0) {
|
|
float max_frame = animation->get_length() / animation->get_step();
|
|
p_list->push_back(PropertyInfo(Variant::REAL, "frame", PROPERTY_HINT_RANGE, "0," + rtos(max_frame) + ",0.01"));
|
|
} else {
|
|
p_list->push_back(PropertyInfo(Variant::REAL, "time", PROPERTY_HINT_RANGE, "0," + rtos(animation->get_length()) + ",0.01"));
|
|
}
|
|
|
|
switch (animation->track_get_type(track)) {
|
|
|
|
case Animation::TYPE_TRANSFORM: {
|
|
|
|
p_list->push_back(PropertyInfo(Variant::VECTOR3, "location"));
|
|
p_list->push_back(PropertyInfo(Variant::QUAT, "rotation"));
|
|
p_list->push_back(PropertyInfo(Variant::VECTOR3, "scale"));
|
|
|
|
} break;
|
|
case Animation::TYPE_VALUE: {
|
|
|
|
Variant v = animation->track_get_key_value(track, key);
|
|
|
|
if (hint.type != Variant::NIL) {
|
|
|
|
PropertyInfo pi = hint;
|
|
pi.name = "value";
|
|
p_list->push_back(pi);
|
|
} else {
|
|
|
|
PropertyHint hint = PROPERTY_HINT_NONE;
|
|
String hint_string;
|
|
|
|
if (v.get_type() == Variant::OBJECT) {
|
|
//could actually check the object property if exists..? yes i will!
|
|
Ref<Resource> res = v;
|
|
if (res.is_valid()) {
|
|
|
|
hint = PROPERTY_HINT_RESOURCE_TYPE;
|
|
hint_string = res->get_class();
|
|
}
|
|
}
|
|
|
|
if (v.get_type() != Variant::NIL)
|
|
p_list->push_back(PropertyInfo(v.get_type(), "value", hint, hint_string));
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_METHOD: {
|
|
|
|
p_list->push_back(PropertyInfo(Variant::STRING, "name"));
|
|
p_list->push_back(PropertyInfo(Variant::INT, "arg_count", PROPERTY_HINT_RANGE, "0,5,1"));
|
|
|
|
Dictionary d = animation->track_get_key_value(track, key);
|
|
ERR_FAIL_COND(!d.has("args"));
|
|
Vector<Variant> args = d["args"];
|
|
String vtypes;
|
|
for (int i = 0; i < Variant::VARIANT_MAX; i++) {
|
|
|
|
if (i > 0)
|
|
vtypes += ",";
|
|
vtypes += Variant::get_type_name(Variant::Type(i));
|
|
}
|
|
|
|
for (int i = 0; i < args.size(); i++) {
|
|
|
|
p_list->push_back(PropertyInfo(Variant::INT, "args/" + itos(i) + "/type", PROPERTY_HINT_ENUM, vtypes));
|
|
if (args[i].get_type() != Variant::NIL)
|
|
p_list->push_back(PropertyInfo(args[i].get_type(), "args/" + itos(i) + "/value"));
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_BEZIER: {
|
|
|
|
p_list->push_back(PropertyInfo(Variant::REAL, "value"));
|
|
p_list->push_back(PropertyInfo(Variant::VECTOR2, "in_handle"));
|
|
p_list->push_back(PropertyInfo(Variant::VECTOR2, "out_handle"));
|
|
|
|
} break;
|
|
case Animation::TYPE_AUDIO: {
|
|
|
|
p_list->push_back(PropertyInfo(Variant::OBJECT, "stream", PROPERTY_HINT_RESOURCE_TYPE, "AudioStream"));
|
|
p_list->push_back(PropertyInfo(Variant::REAL, "start_offset", PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater"));
|
|
p_list->push_back(PropertyInfo(Variant::REAL, "end_offset", PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater"));
|
|
|
|
} break;
|
|
case Animation::TYPE_ANIMATION: {
|
|
|
|
String animations;
|
|
|
|
if (root_path && root_path->has_node(animation->track_get_path(track))) {
|
|
|
|
AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(root_path->get_node(animation->track_get_path(track)));
|
|
if (ap) {
|
|
List<StringName> anims;
|
|
ap->get_animation_list(&anims);
|
|
for (List<StringName>::Element *E = anims.front(); E; E = E->next()) {
|
|
if (animations != String()) {
|
|
animations += ",";
|
|
}
|
|
|
|
animations += String(E->get());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (animations != String()) {
|
|
animations += ",";
|
|
}
|
|
animations += "[stop]";
|
|
|
|
p_list->push_back(PropertyInfo(Variant::STRING, "animation", PROPERTY_HINT_ENUM, animations));
|
|
|
|
} break;
|
|
}
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
|
|
p_list->push_back(PropertyInfo(Variant::REAL, "easing", PROPERTY_HINT_EXP_EASING));
|
|
}
|
|
}
|
|
|
|
UndoRedo *undo_redo;
|
|
Ref<Animation> animation;
|
|
int track;
|
|
float key_ofs;
|
|
Node *root_path;
|
|
|
|
PropertyInfo hint;
|
|
NodePath base;
|
|
bool use_fps;
|
|
|
|
void notify_change() {
|
|
|
|
_change_notify();
|
|
}
|
|
|
|
Node *get_root_path() {
|
|
return root_path;
|
|
}
|
|
|
|
void set_use_fps(bool p_enable) {
|
|
use_fps = p_enable;
|
|
_change_notify();
|
|
}
|
|
|
|
AnimationTrackKeyEdit() {
|
|
use_fps = false;
|
|
key_ofs = 0;
|
|
track = -1;
|
|
setting = false;
|
|
root_path = NULL;
|
|
}
|
|
};
|
|
|
|
void AnimationTimelineEdit::_zoom_changed(double) {
|
|
|
|
update();
|
|
play_position->update();
|
|
emit_signal("zoom_changed");
|
|
}
|
|
|
|
float AnimationTimelineEdit::get_zoom_scale() const {
|
|
|
|
float zv = zoom->get_value();
|
|
if (zv < 1) {
|
|
zv = 1.0 - zv;
|
|
return Math::pow(1.0f + zv, 8.0f) * 100;
|
|
} else {
|
|
return 1.0 / Math::pow(zv, 8.0f) * 100;
|
|
}
|
|
}
|
|
|
|
void AnimationTimelineEdit::_anim_length_changed(double p_new_len) {
|
|
|
|
if (editing)
|
|
return;
|
|
|
|
p_new_len = MAX(0.001, p_new_len);
|
|
if (use_fps && animation->get_step() > 0) {
|
|
p_new_len *= animation->get_step();
|
|
}
|
|
|
|
editing = true;
|
|
undo_redo->create_action(TTR("Change Animation Length"));
|
|
undo_redo->add_do_method(animation.ptr(), "set_length", p_new_len);
|
|
undo_redo->add_undo_method(animation.ptr(), "set_length", animation->get_length());
|
|
undo_redo->commit_action();
|
|
editing = false;
|
|
update();
|
|
|
|
emit_signal("length_changed", p_new_len);
|
|
}
|
|
|
|
void AnimationTimelineEdit::_anim_loop_pressed() {
|
|
|
|
undo_redo->create_action(TTR("Change Animation Loop"));
|
|
undo_redo->add_do_method(animation.ptr(), "set_loop", loop->is_pressed());
|
|
undo_redo->add_undo_method(animation.ptr(), "set_loop", animation->has_loop());
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
int AnimationTimelineEdit::get_buttons_width() const {
|
|
|
|
Ref<Texture> interp_mode = get_icon("TrackContinuous", "EditorIcons");
|
|
Ref<Texture> interp_type = get_icon("InterpRaw", "EditorIcons");
|
|
Ref<Texture> loop_type = get_icon("InterpWrapClamp", "EditorIcons");
|
|
Ref<Texture> remove_icon = get_icon("Remove", "EditorIcons");
|
|
Ref<Texture> down_icon = get_icon("select_arrow", "Tree");
|
|
|
|
int total_w = interp_mode->get_width() + interp_type->get_width() + loop_type->get_width() + remove_icon->get_width();
|
|
total_w += (down_icon->get_width() + 4 * EDSCALE) * 4;
|
|
|
|
return total_w;
|
|
}
|
|
|
|
int AnimationTimelineEdit::get_name_limit() const {
|
|
|
|
Ref<Texture> hsize_icon = get_icon("Hsize", "EditorIcons");
|
|
|
|
int limit = MAX(name_limit, add_track->get_minimum_size().width + hsize_icon->get_width());
|
|
|
|
limit = MIN(limit, get_size().width - get_buttons_width() - 1);
|
|
|
|
return limit;
|
|
}
|
|
|
|
void AnimationTimelineEdit::_notification(int p_what) {
|
|
|
|
if (p_what == NOTIFICATION_ENTER_TREE) {
|
|
add_track->set_icon(get_icon("Add", "EditorIcons"));
|
|
loop->set_icon(get_icon("Loop", "EditorIcons"));
|
|
time_icon->set_texture(get_icon("Time", "EditorIcons"));
|
|
|
|
add_track->get_popup()->clear();
|
|
add_track->get_popup()->add_icon_item(get_icon("KeyValue", "EditorIcons"), TTR("Property Track"));
|
|
add_track->get_popup()->add_icon_item(get_icon("KeyXform", "EditorIcons"), TTR("3D Transform Track"));
|
|
add_track->get_popup()->add_icon_item(get_icon("KeyCall", "EditorIcons"), TTR("Call Method Track"));
|
|
add_track->get_popup()->add_icon_item(get_icon("KeyBezier", "EditorIcons"), TTR("Bezier Curve Track"));
|
|
add_track->get_popup()->add_icon_item(get_icon("KeyAudio", "EditorIcons"), TTR("Audio Playback Track"));
|
|
add_track->get_popup()->add_icon_item(get_icon("KeyAnimation", "EditorIcons"), TTR("Animation Playback Track"));
|
|
}
|
|
|
|
if (p_what == NOTIFICATION_RESIZED) {
|
|
len_hb->set_position(Vector2(get_size().width - get_buttons_width(), 0));
|
|
len_hb->set_size(Size2(get_buttons_width(), get_size().height));
|
|
}
|
|
|
|
if (p_what == NOTIFICATION_DRAW) {
|
|
|
|
int key_range = get_size().width - get_buttons_width() - get_name_limit();
|
|
|
|
if (!animation.is_valid())
|
|
return;
|
|
|
|
Ref<Font> font = get_font("font", "Label");
|
|
Color color = get_color("font_color", "Label");
|
|
|
|
int zoomw = key_range;
|
|
float scale = get_zoom_scale();
|
|
int h = get_size().height;
|
|
|
|
float l = animation->get_length();
|
|
if (l <= 0)
|
|
l = 0.001; //avoid crashor
|
|
|
|
Ref<Texture> hsize_icon = get_icon("Hsize", "EditorIcons");
|
|
hsize_rect = Rect2(get_name_limit() - hsize_icon->get_width() - 2 * EDSCALE, (get_size().height - hsize_icon->get_height()) / 2, hsize_icon->get_width(), hsize_icon->get_height());
|
|
draw_texture(hsize_icon, hsize_rect.position);
|
|
|
|
{
|
|
float time_min = 0;
|
|
float time_max = animation->get_length();
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
if (animation->track_get_key_count(i) > 0) {
|
|
|
|
float beg = animation->track_get_key_time(i, 0);
|
|
/*if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {
|
|
beg += animation->bezier_track_get_key_in_handle(i, 0).x;
|
|
}* not worth it since they have no use */
|
|
|
|
if (beg < time_min)
|
|
time_min = beg;
|
|
|
|
float end = animation->track_get_key_time(i, animation->track_get_key_count(i) - 1);
|
|
/*if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {
|
|
end += animation->bezier_track_get_key_out_handle(i, animation->track_get_key_count(i) - 1).x;
|
|
} not worth it since they have no use */
|
|
|
|
if (end > time_max)
|
|
time_max = end;
|
|
}
|
|
}
|
|
|
|
float extra = (zoomw / scale) * 0.5;
|
|
|
|
//if (time_min < -0.001)
|
|
// time_min -= extra;
|
|
time_max += extra;
|
|
set_min(time_min);
|
|
set_max(time_max);
|
|
|
|
if (zoomw / scale < (time_max - time_min)) {
|
|
hscroll->show();
|
|
|
|
} else {
|
|
|
|
hscroll->hide();
|
|
}
|
|
}
|
|
|
|
set_page(zoomw / scale);
|
|
|
|
int end_px = (l - get_value()) * scale;
|
|
int begin_px = -get_value() * scale;
|
|
Color notimecol = get_color("dark_color_2", "Editor");
|
|
Color timecolor = color;
|
|
timecolor.a = 0.2;
|
|
Color linecolor = color;
|
|
linecolor.a = 0.2;
|
|
|
|
{
|
|
|
|
draw_rect(Rect2(Point2(get_name_limit(), 0), Point2(zoomw - 1, h)), notimecol);
|
|
|
|
if (begin_px < zoomw && end_px > 0) {
|
|
|
|
if (begin_px < 0)
|
|
begin_px = 0;
|
|
if (end_px > zoomw)
|
|
end_px = zoomw;
|
|
|
|
draw_rect(Rect2(Point2(get_name_limit() + begin_px, 0), Point2(end_px - begin_px - 1, h)), timecolor);
|
|
}
|
|
}
|
|
|
|
Color color_time_sec = color;
|
|
Color color_time_dec = color;
|
|
color_time_dec.a *= 0.5;
|
|
#define SC_ADJ 100
|
|
int min = 30;
|
|
int dec = 1;
|
|
int step = 1;
|
|
int decimals = 2;
|
|
bool step_found = false;
|
|
|
|
const int period_width = font->get_char_size('.').width;
|
|
int max_digit_width = font->get_char_size('0').width;
|
|
for (int i = 1; i <= 9; i++) {
|
|
const int digit_width = font->get_char_size('0' + i).width;
|
|
max_digit_width = MAX(digit_width, max_digit_width);
|
|
}
|
|
const int max_sc = int(Math::ceil(zoomw / scale));
|
|
const int max_sc_width = String::num(max_sc).length() * max_digit_width;
|
|
|
|
while (!step_found) {
|
|
|
|
min = max_sc_width;
|
|
if (decimals > 0)
|
|
min += period_width + max_digit_width * decimals;
|
|
|
|
static const int _multp[3] = { 1, 2, 5 };
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
step = (_multp[i] * dec);
|
|
if (step * scale / SC_ADJ > min) {
|
|
step_found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (step_found)
|
|
break;
|
|
dec *= 10;
|
|
decimals--;
|
|
if (decimals < 0)
|
|
decimals = 0;
|
|
}
|
|
|
|
if (use_fps) {
|
|
|
|
float step_size = animation->get_step();
|
|
if (step_size > 0) {
|
|
|
|
int prev_frame_ofs = -10000000;
|
|
|
|
for (int i = 0; i < zoomw; i++) {
|
|
|
|
float pos = get_value() + double(i) / scale;
|
|
float prev = get_value() + (double(i) - 1.0) / scale;
|
|
|
|
int frame = pos / step_size;
|
|
int prev_frame = prev / step_size;
|
|
|
|
bool sub = Math::floor(prev) == Math::floor(pos);
|
|
|
|
if (frame != prev_frame && i >= prev_frame_ofs) {
|
|
|
|
draw_line(Point2(get_name_limit() + i, 0), Point2(get_name_limit() + i, h), linecolor, Math::round(EDSCALE));
|
|
|
|
draw_string(font, Point2(get_name_limit() + i + 3 * EDSCALE, (h - font->get_height()) / 2 + font->get_ascent()).floor(), itos(frame), sub ? color_time_dec : color_time_sec, zoomw - i);
|
|
prev_frame_ofs = i + font->get_string_size(itos(frame)).x + 5 * EDSCALE;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
for (int i = 0; i < zoomw; i++) {
|
|
|
|
float pos = get_value() + double(i) / scale;
|
|
float prev = get_value() + (double(i) - 1.0) / scale;
|
|
|
|
int sc = int(Math::floor(pos * SC_ADJ));
|
|
int prev_sc = int(Math::floor(prev * SC_ADJ));
|
|
bool sub = (sc % SC_ADJ);
|
|
|
|
if ((sc / step) != (prev_sc / step) || (prev_sc < 0 && sc >= 0)) {
|
|
|
|
int scd = sc < 0 ? prev_sc : sc;
|
|
draw_line(Point2(get_name_limit() + i, 0), Point2(get_name_limit() + i, h), linecolor, Math::round(EDSCALE));
|
|
draw_string(font, Point2(get_name_limit() + i + 3, (h - font->get_height()) / 2 + font->get_ascent()).floor(), String::num((scd - (scd % step)) / double(SC_ADJ), decimals), sub ? color_time_dec : color_time_sec, zoomw - i);
|
|
}
|
|
}
|
|
}
|
|
|
|
draw_line(Vector2(0, get_size().height), get_size(), linecolor, Math::round(EDSCALE));
|
|
}
|
|
}
|
|
|
|
void AnimationTimelineEdit::set_animation(const Ref<Animation> &p_animation) {
|
|
animation = p_animation;
|
|
if (animation.is_valid()) {
|
|
len_hb->show();
|
|
add_track->show();
|
|
play_position->show();
|
|
} else {
|
|
len_hb->hide();
|
|
add_track->hide();
|
|
play_position->hide();
|
|
}
|
|
update();
|
|
update_values();
|
|
}
|
|
|
|
Size2 AnimationTimelineEdit::get_minimum_size() const {
|
|
|
|
Size2 ms = add_track->get_minimum_size();
|
|
Ref<Font> font = get_font("font", "Label");
|
|
ms.height = MAX(ms.height, font->get_height());
|
|
ms.width = get_buttons_width() + add_track->get_minimum_size().width + get_icon("Hsize", "EditorIcons")->get_width() + 2;
|
|
return ms;
|
|
}
|
|
|
|
void AnimationTimelineEdit::set_undo_redo(UndoRedo *p_undo_redo) {
|
|
undo_redo = p_undo_redo;
|
|
}
|
|
|
|
void AnimationTimelineEdit::set_zoom(Range *p_zoom) {
|
|
zoom = p_zoom;
|
|
zoom->connect("value_changed", this, "_zoom_changed");
|
|
}
|
|
|
|
void AnimationTimelineEdit::set_play_position(float p_pos) {
|
|
|
|
play_position_pos = p_pos;
|
|
play_position->update();
|
|
}
|
|
|
|
float AnimationTimelineEdit::get_play_position() const {
|
|
return play_position_pos;
|
|
}
|
|
|
|
void AnimationTimelineEdit::update_play_position() {
|
|
play_position->update();
|
|
}
|
|
|
|
void AnimationTimelineEdit::update_values() {
|
|
|
|
if (!animation.is_valid() || editing)
|
|
return;
|
|
|
|
editing = true;
|
|
if (use_fps && animation->get_step() > 0) {
|
|
length->set_value(animation->get_length() / animation->get_step());
|
|
} else {
|
|
length->set_value(animation->get_length());
|
|
}
|
|
loop->set_pressed(animation->has_loop());
|
|
editing = false;
|
|
}
|
|
|
|
void AnimationTimelineEdit::_play_position_draw() {
|
|
|
|
if (!animation.is_valid() || play_position_pos < 0)
|
|
return;
|
|
|
|
float scale = get_zoom_scale();
|
|
int h = play_position->get_size().height;
|
|
|
|
int px = (-get_value() + play_position_pos) * scale + get_name_limit();
|
|
|
|
if (px >= get_name_limit() && px < (play_position->get_size().width - get_buttons_width())) {
|
|
Color color = get_color("accent_color", "Editor");
|
|
play_position->draw_line(Point2(px, 0), Point2(px, h), color, Math::round(EDSCALE));
|
|
}
|
|
}
|
|
|
|
void AnimationTimelineEdit::_gui_input(const Ref<InputEvent> &p_event) {
|
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
|
|
|
if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && hsize_rect.has_point(mb->get_position())) {
|
|
|
|
dragging_hsize = true;
|
|
dragging_hsize_from = mb->get_position().x;
|
|
dragging_hsize_at = name_limit;
|
|
}
|
|
|
|
if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && dragging_hsize) {
|
|
dragging_hsize = false;
|
|
}
|
|
if (mb.is_valid() && mb->get_position().x > get_name_limit() && mb->get_position().x < (get_size().width - get_buttons_width())) {
|
|
|
|
if (!panning_timeline && mb->get_button_index() == BUTTON_LEFT) {
|
|
int x = mb->get_position().x - get_name_limit();
|
|
|
|
float ofs = x / get_zoom_scale() + get_value();
|
|
emit_signal("timeline_changed", ofs, false);
|
|
dragging_timeline = true;
|
|
}
|
|
if (!dragging_timeline && mb->get_button_index() == BUTTON_MIDDLE) {
|
|
int x = mb->get_position().x - get_name_limit();
|
|
panning_timeline_from = x / get_zoom_scale();
|
|
panning_timeline = true;
|
|
panning_timeline_at = get_value();
|
|
}
|
|
}
|
|
|
|
if (dragging_timeline && mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && !mb->is_pressed()) {
|
|
dragging_timeline = false;
|
|
}
|
|
|
|
if (panning_timeline && mb.is_valid() && mb->get_button_index() == BUTTON_MIDDLE && !mb->is_pressed()) {
|
|
panning_timeline = false;
|
|
}
|
|
|
|
Ref<InputEventMouseMotion> mm = p_event;
|
|
|
|
if (mm.is_valid()) {
|
|
|
|
if (dragging_hsize) {
|
|
int ofs = mm->get_position().x - dragging_hsize_from;
|
|
name_limit = dragging_hsize_at + ofs;
|
|
update();
|
|
emit_signal("name_limit_changed");
|
|
play_position->update();
|
|
}
|
|
if (dragging_timeline) {
|
|
int x = mm->get_position().x - get_name_limit();
|
|
float ofs = x / get_zoom_scale() + get_value();
|
|
emit_signal("timeline_changed", ofs, false);
|
|
}
|
|
if (panning_timeline) {
|
|
int x = mm->get_position().x - get_name_limit();
|
|
float ofs = x / get_zoom_scale();
|
|
float diff = ofs - panning_timeline_from;
|
|
set_value(panning_timeline_at - diff);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AnimationTimelineEdit::set_use_fps(bool p_use_fps) {
|
|
use_fps = p_use_fps;
|
|
update_values();
|
|
update();
|
|
}
|
|
bool AnimationTimelineEdit::is_using_fps() const {
|
|
return use_fps;
|
|
}
|
|
|
|
void AnimationTimelineEdit::set_hscroll(HScrollBar *p_hscroll) {
|
|
|
|
hscroll = p_hscroll;
|
|
}
|
|
|
|
void AnimationTimelineEdit::_track_added(int p_track) {
|
|
emit_signal("track_added", p_track);
|
|
}
|
|
|
|
void AnimationTimelineEdit::_bind_methods() {
|
|
ClassDB::bind_method("_zoom_changed", &AnimationTimelineEdit::_zoom_changed);
|
|
ClassDB::bind_method("_anim_length_changed", &AnimationTimelineEdit::_anim_length_changed);
|
|
ClassDB::bind_method("_anim_loop_pressed", &AnimationTimelineEdit::_anim_loop_pressed);
|
|
ClassDB::bind_method("_play_position_draw", &AnimationTimelineEdit::_play_position_draw);
|
|
ClassDB::bind_method("_gui_input", &AnimationTimelineEdit::_gui_input);
|
|
ClassDB::bind_method("_track_added", &AnimationTimelineEdit::_track_added);
|
|
|
|
ADD_SIGNAL(MethodInfo("zoom_changed"));
|
|
ADD_SIGNAL(MethodInfo("name_limit_changed"));
|
|
ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::REAL, "position"), PropertyInfo(Variant::BOOL, "drag")));
|
|
ADD_SIGNAL(MethodInfo("track_added", PropertyInfo(Variant::INT, "track")));
|
|
ADD_SIGNAL(MethodInfo("length_changed", PropertyInfo(Variant::REAL, "size")));
|
|
}
|
|
|
|
AnimationTimelineEdit::AnimationTimelineEdit() {
|
|
|
|
use_fps = false;
|
|
editing = false;
|
|
name_limit = 150;
|
|
zoom = NULL;
|
|
|
|
play_position_pos = 0;
|
|
play_position = memnew(Control);
|
|
play_position->set_mouse_filter(MOUSE_FILTER_PASS);
|
|
add_child(play_position);
|
|
play_position->set_anchors_and_margins_preset(PRESET_WIDE);
|
|
play_position->connect("draw", this, "_play_position_draw");
|
|
|
|
add_track = memnew(MenuButton);
|
|
add_track->set_position(Vector2(0, 0));
|
|
add_child(add_track);
|
|
add_track->set_text(TTR("Add Track"));
|
|
|
|
len_hb = memnew(HBoxContainer);
|
|
|
|
Control *expander = memnew(Control);
|
|
expander->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
len_hb->add_child(expander);
|
|
time_icon = memnew(TextureRect);
|
|
time_icon->set_v_size_flags(SIZE_SHRINK_CENTER);
|
|
time_icon->set_tooltip(TTR("Animation Length Time (seconds)"));
|
|
len_hb->add_child(time_icon);
|
|
length = memnew(EditorSpinSlider);
|
|
length->set_min(0.001);
|
|
length->set_max(36000);
|
|
length->set_step(0.01);
|
|
length->set_allow_greater(true);
|
|
length->set_custom_minimum_size(Vector2(70 * EDSCALE, 0));
|
|
length->set_hide_slider(true);
|
|
length->set_tooltip(TTR("Animation Length Time (seconds)"));
|
|
length->connect("value_changed", this, "_anim_length_changed");
|
|
len_hb->add_child(length);
|
|
loop = memnew(ToolButton);
|
|
loop->set_tooltip(TTR("Animation Looping"));
|
|
loop->connect("pressed", this, "_anim_loop_pressed");
|
|
loop->set_toggle_mode(true);
|
|
len_hb->add_child(loop);
|
|
add_child(len_hb);
|
|
|
|
add_track->hide();
|
|
add_track->get_popup()->connect("index_pressed", this, "_track_added");
|
|
len_hb->hide();
|
|
|
|
panning_timeline = false;
|
|
dragging_timeline = false;
|
|
dragging_hsize = false;
|
|
}
|
|
|
|
////////////////////////////////////
|
|
|
|
void AnimationTrackEdit::_notification(int p_what) {
|
|
if (p_what == NOTIFICATION_DRAW) {
|
|
if (animation.is_null())
|
|
return;
|
|
ERR_FAIL_INDEX(track, animation->get_track_count());
|
|
|
|
int limit = timeline->get_name_limit();
|
|
|
|
if (has_focus()) {
|
|
Color accent = get_color("accent_color", "Editor");
|
|
accent.a *= 0.7;
|
|
draw_rect(Rect2(Point2(), get_size()), accent, false);
|
|
}
|
|
|
|
Ref<Font> font = get_font("font", "Label");
|
|
Color color = get_color("font_color", "Label");
|
|
Ref<Texture> type_icons[6] = {
|
|
get_icon("KeyValue", "EditorIcons"),
|
|
get_icon("KeyXform", "EditorIcons"),
|
|
get_icon("KeyCall", "EditorIcons"),
|
|
get_icon("KeyBezier", "EditorIcons"),
|
|
get_icon("KeyAudio", "EditorIcons"),
|
|
get_icon("KeyAnimation", "EditorIcons")
|
|
};
|
|
int hsep = get_constant("hseparation", "ItemList");
|
|
Color linecolor = color;
|
|
linecolor.a = 0.2;
|
|
|
|
// NAMES AND ICONS //
|
|
|
|
{
|
|
|
|
Ref<Texture> check = animation->track_is_enabled(track) ? get_icon("checked", "CheckBox") : get_icon("unchecked", "CheckBox");
|
|
|
|
int ofs = in_group ? check->get_width() : 0; //not the best reference for margin but..
|
|
|
|
check_rect = Rect2(Point2(ofs, int(get_size().height - check->get_height()) / 2), check->get_size());
|
|
|
|
draw_texture(check, check_rect.position);
|
|
|
|
ofs += check->get_width() + hsep;
|
|
|
|
Ref<Texture> type_icon = type_icons[animation->track_get_type(track)];
|
|
|
|
draw_texture(type_icon, Point2(ofs, int(get_size().height - type_icon->get_height()) / 2));
|
|
ofs += type_icon->get_width() + hsep;
|
|
|
|
NodePath path = animation->track_get_path(track);
|
|
|
|
Node *node = NULL;
|
|
|
|
if (root && root->has_node(path)) {
|
|
node = root->get_node(path);
|
|
}
|
|
|
|
String text;
|
|
Color text_color = color;
|
|
if (node && EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
|
|
text_color = get_color("accent_color", "Editor");
|
|
}
|
|
|
|
if (in_group) {
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_METHOD) {
|
|
text = TTR("Functions:");
|
|
} else if (animation->track_get_type(track) == Animation::TYPE_AUDIO) {
|
|
text = TTR("Audio Clips:");
|
|
} else if (animation->track_get_type(track) == Animation::TYPE_ANIMATION) {
|
|
text = TTR("Anim Clips:");
|
|
} else {
|
|
Vector<StringName> sn = path.get_subnames();
|
|
for (int i = 0; i < sn.size(); i++) {
|
|
if (i > 0) {
|
|
text += ".";
|
|
}
|
|
text += sn[i];
|
|
}
|
|
}
|
|
text_color.a *= 0.7;
|
|
} else if (node) {
|
|
Ref<Texture> icon;
|
|
if (has_icon(node->get_class(), "EditorIcons")) {
|
|
icon = get_icon(node->get_class(), "EditorIcons");
|
|
} else {
|
|
icon = get_icon("Node", "EditorIcons");
|
|
}
|
|
|
|
draw_texture(icon, Point2(ofs, int(get_size().height - icon->get_height()) / 2));
|
|
icon_cache = icon;
|
|
|
|
text = node->get_name();
|
|
ofs += hsep;
|
|
ofs += icon->get_width();
|
|
Vector<StringName> sn = path.get_subnames();
|
|
for (int i = 0; i < sn.size(); i++) {
|
|
text += ".";
|
|
text += sn[i];
|
|
}
|
|
} else {
|
|
icon_cache = type_icon;
|
|
|
|
text = path;
|
|
}
|
|
|
|
path_cache = text;
|
|
|
|
path_rect = Rect2(ofs, 0, limit - ofs - hsep, get_size().height);
|
|
|
|
Vector2 string_pos = Point2(ofs, (get_size().height - font->get_height()) / 2 + font->get_ascent());
|
|
string_pos = string_pos.floor();
|
|
draw_string(font, string_pos, text, text_color, limit - ofs - hsep);
|
|
|
|
draw_line(Point2(limit, 0), Point2(limit, get_size().height), linecolor, Math::round(EDSCALE));
|
|
}
|
|
|
|
// KEYFAMES //
|
|
|
|
draw_bg(limit, get_size().width - timeline->get_buttons_width());
|
|
|
|
{
|
|
|
|
float scale = timeline->get_zoom_scale();
|
|
int limit_end = get_size().width - timeline->get_buttons_width();
|
|
|
|
for (int i = 0; i < animation->track_get_key_count(track); i++) {
|
|
|
|
float offset = animation->track_get_key_time(track, i) - timeline->get_value();
|
|
if (editor->is_key_selected(track, i) && editor->is_moving_selection()) {
|
|
offset = editor->snap_time(offset + editor->get_moving_selection_offset());
|
|
}
|
|
offset = offset * scale + limit;
|
|
if (i < animation->track_get_key_count(track) - 1) {
|
|
|
|
float offset_n = animation->track_get_key_time(track, i + 1) - timeline->get_value();
|
|
if (editor->is_key_selected(track, i + 1) && editor->is_moving_selection()) {
|
|
offset_n = editor->snap_time(offset_n + editor->get_moving_selection_offset());
|
|
}
|
|
offset_n = offset_n * scale + limit;
|
|
|
|
draw_key_link(i, scale, int(offset), int(offset_n), limit, limit_end);
|
|
}
|
|
|
|
draw_key(i, scale, int(offset), editor->is_key_selected(track, i), limit, limit_end);
|
|
}
|
|
}
|
|
|
|
draw_fg(limit, get_size().width - timeline->get_buttons_width());
|
|
|
|
// BUTTONS //
|
|
{
|
|
|
|
Ref<Texture> wrap_icon[2] = {
|
|
get_icon("InterpWrapClamp", "EditorIcons"),
|
|
get_icon("InterpWrapLoop", "EditorIcons"),
|
|
};
|
|
|
|
Ref<Texture> interp_icon[3] = {
|
|
get_icon("InterpRaw", "EditorIcons"),
|
|
get_icon("InterpLinear", "EditorIcons"),
|
|
get_icon("InterpCubic", "EditorIcons")
|
|
};
|
|
Ref<Texture> cont_icon[4] = {
|
|
get_icon("TrackContinuous", "EditorIcons"),
|
|
get_icon("TrackDiscrete", "EditorIcons"),
|
|
get_icon("TrackTrigger", "EditorIcons"),
|
|
get_icon("TrackCapture", "EditorIcons")
|
|
};
|
|
|
|
int ofs = get_size().width - timeline->get_buttons_width();
|
|
|
|
Ref<Texture> down_icon = get_icon("select_arrow", "Tree");
|
|
|
|
draw_line(Point2(ofs, 0), Point2(ofs, get_size().height), linecolor, Math::round(EDSCALE));
|
|
|
|
ofs += hsep;
|
|
{
|
|
//callmode
|
|
|
|
Animation::UpdateMode update_mode;
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
|
|
update_mode = animation->value_track_get_update_mode(track);
|
|
} else {
|
|
update_mode = Animation::UPDATE_CONTINUOUS;
|
|
}
|
|
|
|
Ref<Texture> update_icon = cont_icon[update_mode];
|
|
|
|
update_mode_rect.position.x = ofs;
|
|
update_mode_rect.position.y = int(get_size().height - update_icon->get_height()) / 2;
|
|
update_mode_rect.size = update_icon->get_size();
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
|
|
draw_texture(update_icon, update_mode_rect.position);
|
|
}
|
|
//make it easier to click
|
|
update_mode_rect.position.y = 0;
|
|
update_mode_rect.size.y = get_size().height;
|
|
|
|
ofs += update_icon->get_width() + hsep;
|
|
update_mode_rect.size.x += hsep;
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
|
|
draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
|
|
update_mode_rect.size.x += down_icon->get_width();
|
|
bezier_edit_rect = Rect2();
|
|
} else if (animation->track_get_type(track) == Animation::TYPE_BEZIER) {
|
|
Ref<Texture> bezier_icon = get_icon("EditBezier", "EditorIcons");
|
|
update_mode_rect.size.x += down_icon->get_width();
|
|
bezier_edit_rect.position = update_mode_rect.position + (update_mode_rect.size - bezier_icon->get_size()) / 2;
|
|
bezier_edit_rect.size = bezier_icon->get_size();
|
|
draw_texture(bezier_icon, bezier_edit_rect.position);
|
|
update_mode_rect = Rect2();
|
|
} else {
|
|
update_mode_rect = Rect2();
|
|
bezier_edit_rect = Rect2();
|
|
}
|
|
|
|
ofs += down_icon->get_width();
|
|
draw_line(Point2(ofs + hsep * 0.5, 0), Point2(ofs + hsep * 0.5, get_size().height), linecolor, Math::round(EDSCALE));
|
|
ofs += hsep;
|
|
}
|
|
|
|
{
|
|
//interp
|
|
|
|
Animation::InterpolationType interp_mode = animation->track_get_interpolation_type(track);
|
|
|
|
Ref<Texture> icon = interp_icon[interp_mode];
|
|
|
|
interp_mode_rect.position.x = ofs;
|
|
interp_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;
|
|
interp_mode_rect.size = icon->get_size();
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
|
|
draw_texture(icon, interp_mode_rect.position);
|
|
}
|
|
//make it easier to click
|
|
interp_mode_rect.position.y = 0;
|
|
interp_mode_rect.size.y = get_size().height;
|
|
|
|
ofs += icon->get_width() + hsep;
|
|
interp_mode_rect.size.x += hsep;
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
|
|
draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
|
|
interp_mode_rect.size.x += down_icon->get_width();
|
|
} else {
|
|
interp_mode_rect = Rect2();
|
|
}
|
|
|
|
ofs += down_icon->get_width();
|
|
draw_line(Point2(ofs + hsep * 0.5, 0), Point2(ofs + hsep * 0.5, get_size().height), linecolor, Math::round(EDSCALE));
|
|
ofs += hsep;
|
|
}
|
|
|
|
{
|
|
//loop
|
|
|
|
bool loop_wrap = animation->track_get_interpolation_loop_wrap(track);
|
|
|
|
Ref<Texture> icon = wrap_icon[loop_wrap ? 1 : 0];
|
|
|
|
loop_mode_rect.position.x = ofs;
|
|
loop_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;
|
|
loop_mode_rect.size = icon->get_size();
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
|
|
draw_texture(icon, loop_mode_rect.position);
|
|
}
|
|
|
|
loop_mode_rect.position.y = 0;
|
|
loop_mode_rect.size.y = get_size().height;
|
|
|
|
ofs += icon->get_width() + hsep;
|
|
loop_mode_rect.size.x += hsep;
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
|
|
draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
|
|
loop_mode_rect.size.x += down_icon->get_width();
|
|
} else {
|
|
loop_mode_rect = Rect2();
|
|
}
|
|
|
|
ofs += down_icon->get_width();
|
|
draw_line(Point2(ofs + hsep * 0.5, 0), Point2(ofs + hsep * 0.5, get_size().height), linecolor, Math::round(EDSCALE));
|
|
ofs += hsep;
|
|
}
|
|
|
|
{
|
|
//erase
|
|
|
|
Ref<Texture> icon = get_icon("Remove", "EditorIcons");
|
|
|
|
remove_rect.position.x = ofs + ((get_size().width - ofs) - icon->get_width()) / 2;
|
|
remove_rect.position.y = int(get_size().height - icon->get_height()) / 2;
|
|
remove_rect.size = icon->get_size();
|
|
|
|
draw_texture(icon, remove_rect.position);
|
|
}
|
|
}
|
|
|
|
if (in_group) {
|
|
draw_line(Vector2(timeline->get_name_limit(), get_size().height), get_size(), linecolor, Math::round(EDSCALE));
|
|
} else {
|
|
draw_line(Vector2(0, get_size().height), get_size(), linecolor, Math::round(EDSCALE));
|
|
}
|
|
|
|
if (dropping_at != 0) {
|
|
Color drop_color = get_color("accent_color", "Editor");
|
|
if (dropping_at < 0) {
|
|
draw_line(Vector2(0, 0), Vector2(get_size().width, 0), drop_color, Math::round(EDSCALE));
|
|
} else {
|
|
draw_line(Vector2(0, get_size().height), get_size(), drop_color, Math::round(EDSCALE));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (p_what == NOTIFICATION_MOUSE_EXIT || p_what == NOTIFICATION_DRAG_END) {
|
|
cancel_drop();
|
|
}
|
|
}
|
|
|
|
int AnimationTrackEdit::get_key_height() const {
|
|
if (!animation.is_valid())
|
|
return 0;
|
|
|
|
return type_icon->get_height();
|
|
}
|
|
Rect2 AnimationTrackEdit::get_key_rect(int p_index, float p_pixels_sec) {
|
|
|
|
if (!animation.is_valid())
|
|
return Rect2();
|
|
Rect2 rect = Rect2(-type_icon->get_width() / 2, 0, type_icon->get_width(), get_size().height);
|
|
|
|
//make it a big easier to click
|
|
rect.position.x -= rect.size.x * 0.5;
|
|
rect.size.x *= 2;
|
|
return rect;
|
|
}
|
|
|
|
bool AnimationTrackEdit::is_key_selectable_by_distance() const {
|
|
return true;
|
|
}
|
|
|
|
void AnimationTrackEdit::draw_key_link(int p_index, float p_pixels_sec, int p_x, int p_next_x, int p_clip_left, int p_clip_right) {
|
|
if (p_next_x < p_clip_left)
|
|
return;
|
|
if (p_x > p_clip_right)
|
|
return;
|
|
|
|
Variant current = animation->track_get_key_value(get_track(), p_index);
|
|
Variant next = animation->track_get_key_value(get_track(), p_index + 1);
|
|
if (current != next)
|
|
return;
|
|
|
|
Color color = get_color("font_color", "Label");
|
|
color.a = 0.5;
|
|
|
|
int from_x = MAX(p_x, p_clip_left);
|
|
int to_x = MIN(p_next_x, p_clip_right);
|
|
|
|
draw_line(Point2(from_x + 1, get_size().height / 2), Point2(to_x, get_size().height / 2), color, Math::round(2 * EDSCALE));
|
|
}
|
|
|
|
void AnimationTrackEdit::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {
|
|
|
|
if (!animation.is_valid())
|
|
return;
|
|
|
|
if (p_x < p_clip_left || p_x > p_clip_right)
|
|
return;
|
|
|
|
Vector2 ofs(p_x - type_icon->get_width() / 2, int(get_size().height - type_icon->get_height()) / 2);
|
|
|
|
if (animation->track_get_type(track) == Animation::TYPE_METHOD) {
|
|
Ref<Font> font = get_font("font", "Label");
|
|
Color color = get_color("font_color", "Label");
|
|
color.a = 0.5;
|
|
|
|
Dictionary d = animation->track_get_key_value(track, p_index);
|
|
String text;
|
|
|
|
if (d.has("method"))
|
|
text += String(d["method"]);
|
|
text += "(";
|
|
Vector<Variant> args;
|
|
if (d.has("args"))
|
|
args = d["args"];
|
|
for (int i = 0; i < args.size(); i++) {
|
|
|
|
if (i > 0)
|
|
text += ", ";
|
|
text += String(args[i]);
|
|
}
|
|
text += ")";
|
|
|
|
int limit = MAX(0, p_clip_right - p_x - type_icon->get_width());
|
|
if (limit > 0) {
|
|
draw_string(font, Vector2(p_x + type_icon->get_width(), int(get_size().height - font->get_height()) / 2 + font->get_ascent()), text, color, limit);
|
|
}
|
|
}
|
|
if (p_selected) {
|
|
draw_texture(selected_icon, ofs);
|
|
} else {
|
|
draw_texture(type_icon, ofs);
|
|
}
|
|
}
|
|
|
|
//helper
|
|
void AnimationTrackEdit::draw_rect_clipped(const Rect2 &p_rect, const Color &p_color, bool p_filled) {
|
|
|
|
int clip_left = timeline->get_name_limit();
|
|
int clip_right = get_size().width - timeline->get_buttons_width();
|
|
|
|
if (p_rect.position.x > clip_right)
|
|
return;
|
|
if (p_rect.position.x + p_rect.size.x < clip_left)
|
|
return;
|
|
Rect2 clip = Rect2(clip_left, 0, clip_right - clip_left, get_size().height);
|
|
draw_rect(clip.clip(p_rect), p_color, p_filled);
|
|
}
|
|
|
|
void AnimationTrackEdit::draw_bg(int p_clip_left, int p_clip_right) {
|
|
}
|
|
|
|
void AnimationTrackEdit::draw_fg(int p_clip_left, int p_clip_right) {
|
|
}
|
|
|
|
void AnimationTrackEdit::draw_texture_clipped(const Ref<Texture> &p_texture, const Vector2 &p_pos) {
|
|
|
|
draw_texture_region_clipped(p_texture, Rect2(p_pos, p_texture->get_size()), Rect2(Point2(), p_texture->get_size()));
|
|
}
|
|
|
|
void AnimationTrackEdit::draw_texture_region_clipped(const Ref<Texture> &p_texture, const Rect2 &p_rect, const Rect2 &p_region) {
|
|
|
|
int clip_left = timeline->get_name_limit();
|
|
int clip_right = get_size().width - timeline->get_buttons_width();
|
|
|
|
//clip left and right
|
|
if (clip_left > p_rect.position.x + p_rect.size.x)
|
|
return;
|
|
if (clip_right < p_rect.position.x)
|
|
return;
|
|
|
|
Rect2 rect = p_rect;
|
|
Rect2 region = p_region;
|
|
|
|
if (clip_left > rect.position.x) {
|
|
int rect_pixels = (clip_left - rect.position.x);
|
|
int region_pixels = rect_pixels * region.size.x / rect.size.x;
|
|
|
|
rect.position.x += rect_pixels;
|
|
rect.size.x -= rect_pixels;
|
|
|
|
region.position.x += region_pixels;
|
|
region.size.x -= region_pixels;
|
|
}
|
|
|
|
if (clip_right < rect.position.x + rect.size.x) {
|
|
|
|
int rect_pixels = rect.position.x + rect.size.x - clip_right;
|
|
int region_pixels = rect_pixels * region.size.x / rect.size.x;
|
|
|
|
rect.size.x -= rect_pixels;
|
|
region.size.x -= region_pixels;
|
|
}
|
|
|
|
draw_texture_rect_region(p_texture, rect, region);
|
|
}
|
|
|
|
int AnimationTrackEdit::get_track() const {
|
|
return track;
|
|
}
|
|
|
|
Ref<Animation> AnimationTrackEdit::get_animation() const {
|
|
return animation;
|
|
}
|
|
|
|
void AnimationTrackEdit::set_animation_and_track(const Ref<Animation> &p_animation, int p_track) {
|
|
|
|
animation = p_animation;
|
|
track = p_track;
|
|
update();
|
|
|
|
Ref<Texture> type_icons[6] = {
|
|
get_icon("KeyValue", "EditorIcons"),
|
|
get_icon("KeyXform", "EditorIcons"),
|
|
get_icon("KeyCall", "EditorIcons"),
|
|
get_icon("KeyBezier", "EditorIcons"),
|
|
get_icon("KeyAudio", "EditorIcons"),
|
|
get_icon("KeyAnimation", "EditorIcons")
|
|
};
|
|
|
|
ERR_FAIL_INDEX(track, animation->get_track_count());
|
|
|
|
node_path = animation->track_get_path(p_track);
|
|
type_icon = type_icons[animation->track_get_type(track)];
|
|
selected_icon = get_icon("KeySelected", "EditorIcons");
|
|
}
|
|
|
|
NodePath AnimationTrackEdit::get_path() const {
|
|
return node_path;
|
|
}
|
|
|
|
Size2 AnimationTrackEdit::get_minimum_size() const {
|
|
|
|
Ref<Texture> texture = get_icon("Object", "EditorIcons");
|
|
Ref<Font> font = get_font("font", "Label");
|
|
int separation = get_constant("vseparation", "ItemList");
|
|
|
|
int max_h = MAX(texture->get_height(), font->get_height());
|
|
max_h = MAX(max_h, get_key_height());
|
|
|
|
return Vector2(1, max_h + separation);
|
|
}
|
|
|
|
void AnimationTrackEdit::set_undo_redo(UndoRedo *p_undo_redo) {
|
|
undo_redo = p_undo_redo;
|
|
}
|
|
|
|
void AnimationTrackEdit::set_timeline(AnimationTimelineEdit *p_timeline) {
|
|
timeline = p_timeline;
|
|
timeline->connect("zoom_changed", this, "_zoom_changed");
|
|
timeline->connect("name_limit_changed", this, "_zoom_changed");
|
|
}
|
|
void AnimationTrackEdit::set_editor(AnimationTrackEditor *p_editor) {
|
|
editor = p_editor;
|
|
}
|
|
|
|
void AnimationTrackEdit::_play_position_draw() {
|
|
|
|
if (!animation.is_valid() || play_position_pos < 0)
|
|
return;
|
|
|
|
float scale = timeline->get_zoom_scale();
|
|
int h = get_size().height;
|
|
|
|
int px = (-timeline->get_value() + play_position_pos) * scale + timeline->get_name_limit();
|
|
|
|
if (px >= timeline->get_name_limit() && px < (get_size().width - timeline->get_buttons_width())) {
|
|
Color color = get_color("accent_color", "Editor");
|
|
play_position->draw_line(Point2(px, 0), Point2(px, h), color, Math::round(EDSCALE));
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEdit::set_play_position(float p_pos) {
|
|
|
|
play_position_pos = p_pos;
|
|
play_position->update();
|
|
}
|
|
|
|
void AnimationTrackEdit::update_play_position() {
|
|
play_position->update();
|
|
}
|
|
|
|
void AnimationTrackEdit::set_root(Node *p_root) {
|
|
root = p_root;
|
|
}
|
|
void AnimationTrackEdit::_zoom_changed() {
|
|
update();
|
|
play_position->update();
|
|
}
|
|
|
|
void AnimationTrackEdit::_path_entered(const String &p_text) {
|
|
undo_redo->create_action(TTR("Change Track Path"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", track, p_text);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_path", track, animation->track_get_path(track));
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
String AnimationTrackEdit::get_tooltip(const Point2 &p_pos) const {
|
|
|
|
if (check_rect.has_point(p_pos)) {
|
|
return TTR("Toggle this track on/off.");
|
|
}
|
|
|
|
if (path_rect.has_point(p_pos)) {
|
|
return animation->track_get_path(track);
|
|
}
|
|
|
|
if (update_mode_rect.has_point(p_pos)) {
|
|
return TTR("Update Mode (How this property is set)");
|
|
}
|
|
|
|
if (interp_mode_rect.has_point(p_pos)) {
|
|
return TTR("Interpolation Mode");
|
|
}
|
|
|
|
if (loop_mode_rect.has_point(p_pos)) {
|
|
return TTR("Loop Wrap Mode (Interpolate end with beginning on loop)");
|
|
}
|
|
|
|
if (remove_rect.has_point(p_pos)) {
|
|
return TTR("Remove this track.");
|
|
}
|
|
|
|
if (p_pos.x >= timeline->get_name_limit() && p_pos.x <= (get_size().width - timeline->get_buttons_width())) {
|
|
|
|
int key_idx = -1;
|
|
float key_distance = 1e20;
|
|
|
|
for (int i = animation->track_get_key_count(track) - 1; i >= 0; i--) { //select should happen in the opposite order of drawing for more accurate overlap select
|
|
|
|
Rect2 rect = const_cast<AnimationTrackEdit *>(this)->get_key_rect(i, timeline->get_zoom_scale());
|
|
float offset = animation->track_get_key_time(track, i) - timeline->get_value();
|
|
offset = offset * timeline->get_zoom_scale() + timeline->get_name_limit();
|
|
rect.position.x += offset;
|
|
|
|
if (rect.has_point(p_pos)) {
|
|
|
|
if (const_cast<AnimationTrackEdit *>(this)->is_key_selectable_by_distance()) {
|
|
float distance = ABS(offset - p_pos.x);
|
|
if (key_idx == -1 || distance < key_distance) {
|
|
key_idx = i;
|
|
key_distance = distance;
|
|
}
|
|
} else {
|
|
//first one does it
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (key_idx != -1) {
|
|
|
|
String text = TTR("Time (s): ") + rtos(animation->track_get_key_time(track, key_idx)) + "\n";
|
|
switch (animation->track_get_type(track)) {
|
|
|
|
case Animation::TYPE_TRANSFORM: {
|
|
|
|
Dictionary d = animation->track_get_key_value(track, key_idx);
|
|
if (d.has("location"))
|
|
text += "Pos: " + String(d["location"]) + "\n";
|
|
if (d.has("rotation"))
|
|
text += "Rot: " + String(d["rotation"]) + "\n";
|
|
if (d.has("scale"))
|
|
text += "Scale: " + String(d["scale"]) + "\n";
|
|
} break;
|
|
case Animation::TYPE_VALUE: {
|
|
|
|
Variant v = animation->track_get_key_value(track, key_idx);
|
|
//text+="value: "+String(v)+"\n";
|
|
|
|
bool prop_exists = false;
|
|
Variant::Type valid_type = Variant::NIL;
|
|
Object *obj = NULL;
|
|
|
|
RES res;
|
|
Vector<StringName> leftover_path;
|
|
Node *node = root->get_node_and_resource(animation->track_get_path(track), res, leftover_path);
|
|
|
|
if (res.is_valid()) {
|
|
obj = res.ptr();
|
|
} else if (node) {
|
|
obj = node;
|
|
}
|
|
|
|
if (obj) {
|
|
valid_type = obj->get_static_property_type_indexed(leftover_path, &prop_exists);
|
|
}
|
|
|
|
text += "Type: " + Variant::get_type_name(v.get_type()) + "\n";
|
|
if (prop_exists && !Variant::can_convert(v.get_type(), valid_type)) {
|
|
text += "Value: " + String(v) + " (Invalid, expected type: " + Variant::get_type_name(valid_type) + ")\n";
|
|
} else {
|
|
text += "Value: " + String(v) + "\n";
|
|
}
|
|
text += "Easing: " + rtos(animation->track_get_key_transition(track, key_idx));
|
|
|
|
} break;
|
|
case Animation::TYPE_METHOD: {
|
|
|
|
Dictionary d = animation->track_get_key_value(track, key_idx);
|
|
if (d.has("method"))
|
|
text += String(d["method"]);
|
|
text += "(";
|
|
Vector<Variant> args;
|
|
if (d.has("args"))
|
|
args = d["args"];
|
|
for (int i = 0; i < args.size(); i++) {
|
|
|
|
if (i > 0)
|
|
text += ", ";
|
|
text += String(args[i]);
|
|
}
|
|
text += ")\n";
|
|
|
|
} break;
|
|
case Animation::TYPE_BEZIER: {
|
|
|
|
float h = animation->bezier_track_get_key_value(track, key_idx);
|
|
text += "Value: " + rtos(h) + "\n";
|
|
Vector2 ih = animation->bezier_track_get_key_in_handle(track, key_idx);
|
|
text += "In-Handle: " + ih + "\n";
|
|
Vector2 oh = animation->bezier_track_get_key_out_handle(track, key_idx);
|
|
text += "Out-Handle: " + oh + "\n";
|
|
} break;
|
|
case Animation::TYPE_AUDIO: {
|
|
|
|
String stream_name = "null";
|
|
RES stream = animation->audio_track_get_key_stream(track, key_idx);
|
|
if (stream.is_valid()) {
|
|
if (stream->get_path().is_resource_file()) {
|
|
stream_name = stream->get_path().get_file();
|
|
} else if (stream->get_name() != "") {
|
|
stream_name = stream->get_name();
|
|
} else {
|
|
stream_name = stream->get_class();
|
|
}
|
|
}
|
|
|
|
text += "Stream: " + stream_name + "\n";
|
|
float so = animation->audio_track_get_key_start_offset(track, key_idx);
|
|
text += "Start (s): " + rtos(so) + "\n";
|
|
float eo = animation->audio_track_get_key_end_offset(track, key_idx);
|
|
text += "End (s): " + rtos(eo) + "\n";
|
|
} break;
|
|
case Animation::TYPE_ANIMATION: {
|
|
|
|
String name = animation->animation_track_get_key_animation(track, key_idx);
|
|
text += "Animation Clip: " + name + "\n";
|
|
} break;
|
|
}
|
|
return text;
|
|
}
|
|
}
|
|
|
|
return Control::get_tooltip(p_pos);
|
|
}
|
|
|
|
void AnimationTrackEdit::_gui_input(const Ref<InputEvent> &p_event) {
|
|
|
|
if (p_event->is_pressed()) {
|
|
if (ED_GET_SHORTCUT("animation_editor/duplicate_selection")->is_shortcut(p_event)) {
|
|
emit_signal("duplicate_request");
|
|
accept_event();
|
|
}
|
|
|
|
if (ED_GET_SHORTCUT("animation_editor/duplicate_selection_transposed")->is_shortcut(p_event)) {
|
|
emit_signal("duplicate_transpose_request");
|
|
accept_event();
|
|
}
|
|
|
|
if (ED_GET_SHORTCUT("animation_editor/delete_selection")->is_shortcut(p_event)) {
|
|
emit_signal("delete_request");
|
|
accept_event();
|
|
}
|
|
}
|
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
|
if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
|
|
Point2 pos = mb->get_position();
|
|
|
|
if (check_rect.has_point(pos)) {
|
|
undo_redo->create_action(TTR("Toggle Track Enabled"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_enabled", track, !animation->track_is_enabled(track));
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_enabled", track, animation->track_is_enabled(track));
|
|
undo_redo->commit_action();
|
|
update();
|
|
accept_event();
|
|
}
|
|
if (path_rect.has_point(pos)) {
|
|
|
|
clicking_on_name = true;
|
|
accept_event();
|
|
}
|
|
|
|
if (update_mode_rect.has_point(pos)) {
|
|
if (!menu) {
|
|
menu = memnew(PopupMenu);
|
|
add_child(menu);
|
|
menu->connect("id_pressed", this, "_menu_selected");
|
|
}
|
|
menu->clear();
|
|
menu->add_icon_item(get_icon("TrackContinuous", "EditorIcons"), TTR("Continuous"), MENU_CALL_MODE_CONTINUOUS);
|
|
menu->add_icon_item(get_icon("TrackDiscrete", "EditorIcons"), TTR("Discrete"), MENU_CALL_MODE_DISCRETE);
|
|
menu->add_icon_item(get_icon("TrackTrigger", "EditorIcons"), TTR("Trigger"), MENU_CALL_MODE_TRIGGER);
|
|
menu->add_icon_item(get_icon("TrackCapture", "EditorIcons"), TTR("Capture"), MENU_CALL_MODE_CAPTURE);
|
|
menu->set_as_minsize();
|
|
|
|
Vector2 popup_pos = get_global_position() + update_mode_rect.position + Vector2(0, update_mode_rect.size.height);
|
|
menu->set_global_position(popup_pos);
|
|
menu->popup();
|
|
accept_event();
|
|
}
|
|
|
|
if (interp_mode_rect.has_point(pos)) {
|
|
if (!menu) {
|
|
menu = memnew(PopupMenu);
|
|
add_child(menu);
|
|
menu->connect("id_pressed", this, "_menu_selected");
|
|
}
|
|
menu->clear();
|
|
menu->add_icon_item(get_icon("InterpRaw", "EditorIcons"), TTR("Nearest"), MENU_INTERPOLATION_NEAREST);
|
|
menu->add_icon_item(get_icon("InterpLinear", "EditorIcons"), TTR("Linear"), MENU_INTERPOLATION_LINEAR);
|
|
menu->add_icon_item(get_icon("InterpCubic", "EditorIcons"), TTR("Cubic"), MENU_INTERPOLATION_CUBIC);
|
|
menu->set_as_minsize();
|
|
|
|
Vector2 popup_pos = get_global_position() + interp_mode_rect.position + Vector2(0, interp_mode_rect.size.height);
|
|
menu->set_global_position(popup_pos);
|
|
menu->popup();
|
|
accept_event();
|
|
}
|
|
|
|
if (loop_mode_rect.has_point(pos)) {
|
|
if (!menu) {
|
|
menu = memnew(PopupMenu);
|
|
add_child(menu);
|
|
menu->connect("id_pressed", this, "_menu_selected");
|
|
}
|
|
menu->clear();
|
|
menu->add_icon_item(get_icon("InterpWrapClamp", "EditorIcons"), TTR("Clamp Loop Interp"), MENU_LOOP_CLAMP);
|
|
menu->add_icon_item(get_icon("InterpWrapLoop", "EditorIcons"), TTR("Wrap Loop Interp"), MENU_LOOP_WRAP);
|
|
menu->set_as_minsize();
|
|
|
|
Vector2 popup_pos = get_global_position() + loop_mode_rect.position + Vector2(0, loop_mode_rect.size.height);
|
|
menu->set_global_position(popup_pos);
|
|
menu->popup();
|
|
accept_event();
|
|
}
|
|
|
|
if (remove_rect.has_point(pos)) {
|
|
emit_signal("remove_request", track);
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (bezier_edit_rect.has_point(pos)) {
|
|
emit_signal("bezier_edit");
|
|
accept_event();
|
|
}
|
|
|
|
//check keyframes
|
|
|
|
float scale = timeline->get_zoom_scale();
|
|
int limit = timeline->get_name_limit();
|
|
int limit_end = get_size().width - timeline->get_buttons_width();
|
|
|
|
if (pos.x >= limit && pos.x <= limit_end) {
|
|
|
|
int key_idx = -1;
|
|
float key_distance = 1e20;
|
|
|
|
for (int i = animation->track_get_key_count(track) - 1; i >= 0; i--) { //select should happen in the opposite order of drawing for more accurate overlap select
|
|
|
|
Rect2 rect = get_key_rect(i, scale);
|
|
float offset = animation->track_get_key_time(track, i) - timeline->get_value();
|
|
offset = offset * scale + limit;
|
|
rect.position.x += offset;
|
|
|
|
if (rect.has_point(pos)) {
|
|
|
|
if (is_key_selectable_by_distance()) {
|
|
float distance = ABS(offset - pos.x);
|
|
if (key_idx == -1 || distance < key_distance) {
|
|
key_idx = i;
|
|
key_distance = distance;
|
|
}
|
|
} else {
|
|
//first one does it
|
|
key_idx = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (key_idx != -1) {
|
|
if (mb->get_command() || mb->get_shift()) {
|
|
if (editor->is_key_selected(track, key_idx)) {
|
|
emit_signal("deselect_key", key_idx);
|
|
|
|
} else {
|
|
emit_signal("select_key", key_idx, false);
|
|
moving_selection_attempt = true;
|
|
select_single_attempt = -1;
|
|
moving_selection_from_ofs = (mb->get_position().x - timeline->get_name_limit()) / timeline->get_zoom_scale();
|
|
}
|
|
} else {
|
|
if (!editor->is_key_selected(track, key_idx)) {
|
|
emit_signal("select_key", key_idx, true);
|
|
select_single_attempt = -1;
|
|
} else {
|
|
select_single_attempt = key_idx;
|
|
}
|
|
|
|
moving_selection_attempt = true;
|
|
moving_selection_from_ofs = (mb->get_position().x - timeline->get_name_limit()) / timeline->get_zoom_scale();
|
|
}
|
|
accept_event();
|
|
} else {
|
|
emit_signal("clear_selection");
|
|
}
|
|
}
|
|
|
|
/*using focus instead
|
|
* if (!selected && pos.x >= timeline->get_name_limit() && pos.x < (get_size().width - timeline->get_buttons_width())) {
|
|
set_selected(true);
|
|
emit_signal("selected");
|
|
}
|
|
*/
|
|
}
|
|
|
|
if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
|
|
Point2 pos = mb->get_position();
|
|
if (pos.x >= timeline->get_name_limit() && pos.x <= get_size().width - timeline->get_buttons_width()) {
|
|
//can do something with menu too! show insert key
|
|
float offset = (pos.x - timeline->get_name_limit()) / timeline->get_zoom_scale();
|
|
if (!menu) {
|
|
menu = memnew(PopupMenu);
|
|
add_child(menu);
|
|
menu->connect("id_pressed", this, "_menu_selected");
|
|
}
|
|
|
|
menu->clear();
|
|
menu->add_icon_item(get_icon("Key", "EditorIcons"), TTR("Insert Key"), MENU_KEY_INSERT);
|
|
if (editor->is_selection_active()) {
|
|
menu->add_separator();
|
|
menu->add_icon_item(get_icon("Duplicate", "EditorIcons"), TTR("Duplicate Key(s)"), MENU_KEY_DUPLICATE);
|
|
menu->add_separator();
|
|
menu->add_icon_item(get_icon("Remove", "EditorIcons"), TTR("Delete Key(s)"), MENU_KEY_DELETE);
|
|
}
|
|
menu->set_as_minsize();
|
|
|
|
Vector2 popup_pos = get_global_transform().xform(get_local_mouse_position());
|
|
menu->set_global_position(popup_pos);
|
|
menu->popup();
|
|
|
|
insert_at_pos = offset + timeline->get_value();
|
|
accept_event();
|
|
}
|
|
}
|
|
|
|
if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && clicking_on_name) {
|
|
|
|
if (!path) {
|
|
path = memnew(LineEdit);
|
|
add_child(path);
|
|
path->set_as_toplevel(true);
|
|
path->connect("text_entered", this, "_path_entered");
|
|
}
|
|
|
|
path->set_text(animation->track_get_path(track));
|
|
Vector2 theme_ofs = path->get_stylebox("normal", "LineEdit")->get_offset();
|
|
path->set_position(get_global_position() + path_rect.position - theme_ofs);
|
|
path->set_size(path_rect.size);
|
|
path->show_modal();
|
|
path->grab_focus();
|
|
path->set_cursor_position(path->get_text().length());
|
|
clicking_on_name = false;
|
|
}
|
|
|
|
if (mb.is_valid() && moving_selection_attempt) {
|
|
|
|
if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
|
|
moving_selection_attempt = false;
|
|
if (moving_selection) {
|
|
emit_signal("move_selection_commit");
|
|
} else if (select_single_attempt != -1) {
|
|
emit_signal("select_key", select_single_attempt, true);
|
|
}
|
|
moving_selection = false;
|
|
select_single_attempt = -1;
|
|
}
|
|
|
|
if (moving_selection && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
|
|
|
|
moving_selection_attempt = false;
|
|
moving_selection = false;
|
|
emit_signal("move_selection_cancel");
|
|
}
|
|
}
|
|
|
|
Ref<InputEventMouseMotion> mm = p_event;
|
|
if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_LEFT && moving_selection_attempt) {
|
|
|
|
if (!moving_selection) {
|
|
moving_selection = true;
|
|
emit_signal("move_selection_begin");
|
|
}
|
|
|
|
float new_ofs = (mm->get_position().x - timeline->get_name_limit()) / timeline->get_zoom_scale();
|
|
emit_signal("move_selection", new_ofs - moving_selection_from_ofs);
|
|
}
|
|
}
|
|
|
|
Variant AnimationTrackEdit::get_drag_data(const Point2 &p_point) {
|
|
|
|
if (!clicking_on_name)
|
|
return Variant();
|
|
|
|
Dictionary drag_data;
|
|
drag_data["type"] = "animation_track";
|
|
drag_data["index"] = track;
|
|
|
|
ToolButton *tb = memnew(ToolButton);
|
|
tb->set_text(path_cache);
|
|
tb->set_icon(icon_cache);
|
|
set_drag_preview(tb);
|
|
|
|
clicking_on_name = false;
|
|
|
|
return drag_data;
|
|
}
|
|
|
|
bool AnimationTrackEdit::can_drop_data(const Point2 &p_point, const Variant &p_data) const {
|
|
|
|
Dictionary d = p_data;
|
|
if (!d.has("type")) {
|
|
return false;
|
|
}
|
|
|
|
String type = d["type"];
|
|
if (type != "animation_track")
|
|
return false;
|
|
|
|
if (p_point.y < get_size().height / 2) {
|
|
dropping_at = -1;
|
|
} else {
|
|
dropping_at = 1;
|
|
}
|
|
|
|
const_cast<AnimationTrackEdit *>(this)->update();
|
|
const_cast<AnimationTrackEdit *>(this)->emit_signal("drop_attempted", track);
|
|
|
|
return true;
|
|
}
|
|
void AnimationTrackEdit::drop_data(const Point2 &p_point, const Variant &p_data) {
|
|
|
|
Dictionary d = p_data;
|
|
if (!d.has("type")) {
|
|
return;
|
|
}
|
|
|
|
String type = d["type"];
|
|
if (type != "animation_track")
|
|
return;
|
|
|
|
int from_track = d["index"];
|
|
|
|
if (dropping_at < 0) {
|
|
emit_signal("dropped", from_track, track);
|
|
} else {
|
|
emit_signal("dropped", from_track, track + 1);
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEdit::_menu_selected(int p_index) {
|
|
|
|
switch (p_index) {
|
|
case MENU_CALL_MODE_CONTINUOUS:
|
|
case MENU_CALL_MODE_DISCRETE:
|
|
case MENU_CALL_MODE_TRIGGER:
|
|
case MENU_CALL_MODE_CAPTURE: {
|
|
|
|
Animation::UpdateMode update_mode = Animation::UpdateMode(p_index);
|
|
undo_redo->create_action(TTR("Change Animation Update Mode"));
|
|
undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", track, update_mode);
|
|
undo_redo->add_undo_method(animation.ptr(), "value_track_set_update_mode", track, animation->value_track_get_update_mode(track));
|
|
undo_redo->commit_action();
|
|
update();
|
|
|
|
} break;
|
|
case MENU_INTERPOLATION_NEAREST:
|
|
case MENU_INTERPOLATION_LINEAR:
|
|
case MENU_INTERPOLATION_CUBIC: {
|
|
|
|
Animation::InterpolationType interp_mode = Animation::InterpolationType(p_index - MENU_INTERPOLATION_NEAREST);
|
|
undo_redo->create_action(TTR("Change Animation Interpolation Mode"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_type", track, interp_mode);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_interpolation_type", track, animation->track_get_interpolation_type(track));
|
|
undo_redo->commit_action();
|
|
update();
|
|
} break;
|
|
case MENU_LOOP_WRAP:
|
|
case MENU_LOOP_CLAMP: {
|
|
|
|
bool loop_wrap = p_index == MENU_LOOP_WRAP;
|
|
undo_redo->create_action(TTR("Change Animation Loop Mode"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_loop_wrap", track, loop_wrap);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_interpolation_loop_wrap", track, animation->track_get_interpolation_loop_wrap(track));
|
|
undo_redo->commit_action();
|
|
update();
|
|
|
|
} break;
|
|
case MENU_KEY_INSERT: {
|
|
emit_signal("insert_key", insert_at_pos);
|
|
} break;
|
|
case MENU_KEY_DUPLICATE: {
|
|
emit_signal("duplicate_request");
|
|
|
|
} break;
|
|
case MENU_KEY_DELETE: {
|
|
emit_signal("delete_request");
|
|
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEdit::cancel_drop() {
|
|
if (dropping_at != 0) {
|
|
dropping_at = 0;
|
|
update();
|
|
}
|
|
}
|
|
void AnimationTrackEdit::set_in_group(bool p_enable) {
|
|
in_group = p_enable;
|
|
update();
|
|
}
|
|
|
|
void AnimationTrackEdit::append_to_selection(const Rect2 &p_box) {
|
|
|
|
Rect2 select_rect(timeline->get_name_limit(), 0, get_size().width - timeline->get_name_limit() - timeline->get_buttons_width(), get_size().height);
|
|
select_rect = select_rect.clip(p_box);
|
|
|
|
for (int i = animation->track_get_key_count(track) - 1; i >= 0; i--) { //select should happen in the opposite order of drawing for more accurate overlap select
|
|
|
|
Rect2 rect = const_cast<AnimationTrackEdit *>(this)->get_key_rect(i, timeline->get_zoom_scale());
|
|
float offset = animation->track_get_key_time(track, i) - timeline->get_value();
|
|
offset = offset * timeline->get_zoom_scale() + timeline->get_name_limit();
|
|
rect.position.x += offset;
|
|
|
|
if (select_rect.intersects(rect)) {
|
|
emit_signal("select_key", i, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEdit::_bind_methods() {
|
|
|
|
ClassDB::bind_method("_zoom_changed", &AnimationTrackEdit::_zoom_changed);
|
|
ClassDB::bind_method("_menu_selected", &AnimationTrackEdit::_menu_selected);
|
|
ClassDB::bind_method("_gui_input", &AnimationTrackEdit::_gui_input);
|
|
ClassDB::bind_method("_path_entered", &AnimationTrackEdit::_path_entered);
|
|
ClassDB::bind_method("_play_position_draw", &AnimationTrackEdit::_play_position_draw);
|
|
|
|
ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::REAL, "position"), PropertyInfo(Variant::BOOL, "drag")));
|
|
ADD_SIGNAL(MethodInfo("remove_request", PropertyInfo(Variant::INT, "track")));
|
|
ADD_SIGNAL(MethodInfo("dropped", PropertyInfo(Variant::INT, "from_track"), PropertyInfo(Variant::INT, "to_track")));
|
|
ADD_SIGNAL(MethodInfo("insert_key", PropertyInfo(Variant::REAL, "ofs")));
|
|
ADD_SIGNAL(MethodInfo("select_key", PropertyInfo(Variant::INT, "index"), PropertyInfo(Variant::BOOL, "single")));
|
|
ADD_SIGNAL(MethodInfo("deselect_key", PropertyInfo(Variant::INT, "index")));
|
|
ADD_SIGNAL(MethodInfo("clear_selection"));
|
|
ADD_SIGNAL(MethodInfo("bezier_edit"));
|
|
|
|
ADD_SIGNAL(MethodInfo("move_selection_begin"));
|
|
ADD_SIGNAL(MethodInfo("move_selection", PropertyInfo(Variant::REAL, "ofs")));
|
|
ADD_SIGNAL(MethodInfo("move_selection_commit"));
|
|
ADD_SIGNAL(MethodInfo("move_selection_cancel"));
|
|
|
|
ADD_SIGNAL(MethodInfo("duplicate_request"));
|
|
ADD_SIGNAL(MethodInfo("duplicate_transpose_request"));
|
|
ADD_SIGNAL(MethodInfo("delete_request"));
|
|
}
|
|
|
|
AnimationTrackEdit::AnimationTrackEdit() {
|
|
undo_redo = NULL;
|
|
timeline = NULL;
|
|
root = NULL;
|
|
path = NULL;
|
|
menu = NULL;
|
|
clicking_on_name = false;
|
|
dropping_at = 0;
|
|
|
|
in_group = false;
|
|
|
|
moving_selection_attempt = false;
|
|
moving_selection = false;
|
|
select_single_attempt = -1;
|
|
|
|
play_position_pos = 0;
|
|
play_position = memnew(Control);
|
|
play_position->set_mouse_filter(MOUSE_FILTER_PASS);
|
|
add_child(play_position);
|
|
play_position->set_anchors_and_margins_preset(PRESET_WIDE);
|
|
play_position->connect("draw", this, "_play_position_draw");
|
|
set_focus_mode(FOCUS_CLICK);
|
|
set_mouse_filter(MOUSE_FILTER_PASS); //scroll has to work too for selection
|
|
}
|
|
|
|
//////////////////////////////////////
|
|
|
|
AnimationTrackEdit *AnimationTrackEditPlugin::create_value_track_edit(Object *p_object, Variant::Type p_type, const String &p_property, PropertyHint p_hint, const String &p_hint_string, int p_usage) {
|
|
if (get_script_instance()) {
|
|
Variant args[6] = {
|
|
p_object,
|
|
p_type,
|
|
p_property,
|
|
p_hint,
|
|
p_hint_string,
|
|
p_usage
|
|
};
|
|
|
|
Variant *argptrs[6] = {
|
|
&args[0],
|
|
&args[1],
|
|
&args[2],
|
|
&args[3],
|
|
&args[4],
|
|
&args[5]
|
|
};
|
|
|
|
Variant::CallError ce;
|
|
return Object::cast_to<AnimationTrackEdit>(get_script_instance()->call("create_value_track_edit", (const Variant **)&argptrs, 6, ce).operator Object *());
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AnimationTrackEdit *AnimationTrackEditPlugin::create_audio_track_edit() {
|
|
|
|
if (get_script_instance()) {
|
|
return Object::cast_to<AnimationTrackEdit>(get_script_instance()->call("create_audio_track_edit").operator Object *());
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AnimationTrackEdit *AnimationTrackEditPlugin::create_animation_track_edit(Object *p_object) {
|
|
if (get_script_instance()) {
|
|
return Object::cast_to<AnimationTrackEdit>(get_script_instance()->call("create_animation_track_edit", p_object).operator Object *());
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
///////////////////////////////////////
|
|
|
|
void AnimationTrackEditGroup::_notification(int p_what) {
|
|
|
|
if (p_what == NOTIFICATION_DRAW) {
|
|
Ref<Font> font = get_font("font", "Label");
|
|
int separation = get_constant("hseparation", "ItemList");
|
|
Color color = get_color("font_color", "Label");
|
|
|
|
if (root && root->has_node(node)) {
|
|
Node *n = root->get_node(node);
|
|
if (n && EditorNode::get_singleton()->get_editor_selection()->is_selected(n)) {
|
|
color = get_color("accent_color", "Editor");
|
|
}
|
|
}
|
|
|
|
Color bgcol = get_color("dark_color_2", "Editor");
|
|
bgcol.a *= 0.6;
|
|
draw_rect(Rect2(Point2(), get_size()), bgcol);
|
|
Color linecolor = color;
|
|
linecolor.a = 0.2;
|
|
|
|
draw_line(Point2(), Point2(get_size().width, 0), linecolor, Math::round(EDSCALE));
|
|
draw_line(Point2(timeline->get_name_limit(), 0), Point2(timeline->get_name_limit(), get_size().height), linecolor, Math::round(EDSCALE));
|
|
draw_line(Point2(get_size().width - timeline->get_buttons_width(), 0), Point2(get_size().width - timeline->get_buttons_width(), get_size().height), linecolor, Math::round(EDSCALE));
|
|
|
|
int ofs = 0;
|
|
draw_texture(icon, Point2(ofs, int(get_size().height - icon->get_height()) / 2));
|
|
ofs += separation + icon->get_width();
|
|
draw_string(font, Point2(ofs, int(get_size().height - font->get_height()) / 2 + font->get_ascent()), node_name, color, timeline->get_name_limit() - ofs);
|
|
|
|
int px = (-timeline->get_value() + timeline->get_play_position()) * timeline->get_zoom_scale() + timeline->get_name_limit();
|
|
|
|
if (px >= timeline->get_name_limit() && px < (get_size().width - timeline->get_buttons_width())) {
|
|
Color accent = get_color("accent_color", "Editor");
|
|
draw_line(Point2(px, 0), Point2(px, get_size().height), accent, Math::round(EDSCALE));
|
|
}
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditGroup::set_type_and_name(const Ref<Texture> &p_type, const String &p_name, const NodePath &p_node) {
|
|
icon = p_type;
|
|
node_name = p_name;
|
|
node = p_node;
|
|
update();
|
|
minimum_size_changed();
|
|
}
|
|
|
|
Size2 AnimationTrackEditGroup::get_minimum_size() const {
|
|
|
|
Ref<Font> font = get_font("font", "Label");
|
|
int separation = get_constant("vseparation", "ItemList");
|
|
|
|
return Vector2(0, MAX(font->get_height(), icon->get_height()) + separation);
|
|
}
|
|
|
|
void AnimationTrackEditGroup::set_timeline(AnimationTimelineEdit *p_timeline) {
|
|
timeline = p_timeline;
|
|
timeline->connect("zoom_changed", this, "_zoom_changed");
|
|
timeline->connect("name_limit_changed", this, "_zoom_changed");
|
|
}
|
|
|
|
void AnimationTrackEditGroup::set_root(Node *p_root) {
|
|
root = p_root;
|
|
update();
|
|
}
|
|
|
|
void AnimationTrackEditGroup::_zoom_changed() {
|
|
update();
|
|
}
|
|
|
|
void AnimationTrackEditGroup::_bind_methods() {
|
|
ClassDB::bind_method("_zoom_changed", &AnimationTrackEditGroup::_zoom_changed);
|
|
}
|
|
|
|
AnimationTrackEditGroup::AnimationTrackEditGroup() {
|
|
set_mouse_filter(MOUSE_FILTER_PASS);
|
|
}
|
|
|
|
//////////////////////////////////////
|
|
|
|
void AnimationTrackEditor::add_track_edit_plugin(const Ref<AnimationTrackEditPlugin> &p_plugin) {
|
|
|
|
if (track_edit_plugins.find(p_plugin) != -1)
|
|
return;
|
|
track_edit_plugins.push_back(p_plugin);
|
|
}
|
|
|
|
void AnimationTrackEditor::remove_track_edit_plugin(const Ref<AnimationTrackEditPlugin> &p_plugin) {
|
|
|
|
track_edit_plugins.erase(p_plugin);
|
|
}
|
|
|
|
void AnimationTrackEditor::set_animation(const Ref<Animation> &p_anim) {
|
|
|
|
if (animation != p_anim && _get_track_selected() >= 0) {
|
|
track_edits[_get_track_selected()]->release_focus();
|
|
}
|
|
if (animation.is_valid()) {
|
|
animation->disconnect("changed", this, "_animation_changed");
|
|
_clear_selection();
|
|
}
|
|
animation = p_anim;
|
|
timeline->set_animation(p_anim);
|
|
|
|
_cancel_bezier_edit();
|
|
_update_tracks();
|
|
|
|
if (animation.is_valid()) {
|
|
animation->connect("changed", this, "_animation_changed");
|
|
|
|
hscroll->show();
|
|
edit->set_disabled(false);
|
|
step->set_block_signals(true);
|
|
|
|
_update_step_spinbox();
|
|
step->set_block_signals(false);
|
|
step->set_read_only(false);
|
|
snap->set_disabled(false);
|
|
snap_mode->set_disabled(true);
|
|
} else {
|
|
hscroll->hide();
|
|
edit->set_disabled(true);
|
|
step->set_block_signals(true);
|
|
step->set_value(0);
|
|
step->set_block_signals(false);
|
|
step->set_read_only(true);
|
|
snap->set_disabled(true);
|
|
snap_mode->set_disabled(false);
|
|
}
|
|
}
|
|
|
|
Ref<Animation> AnimationTrackEditor::get_current_animation() const {
|
|
|
|
return animation;
|
|
}
|
|
void AnimationTrackEditor::_root_removed(Node *p_root) {
|
|
root = NULL;
|
|
}
|
|
|
|
void AnimationTrackEditor::set_root(Node *p_root) {
|
|
if (root) {
|
|
root->disconnect("tree_exiting", this, "_root_removed");
|
|
}
|
|
|
|
root = p_root;
|
|
|
|
if (root) {
|
|
root->connect("tree_exiting", this, "_root_removed", make_binds(), CONNECT_ONESHOT);
|
|
}
|
|
|
|
_update_tracks();
|
|
}
|
|
|
|
Node *AnimationTrackEditor::get_root() const {
|
|
|
|
return root;
|
|
}
|
|
|
|
void AnimationTrackEditor::update_keying() {
|
|
bool keying_enabled = is_visible_in_tree() && animation.is_valid();
|
|
|
|
if (keying_enabled == keying)
|
|
return;
|
|
|
|
keying = keying_enabled;
|
|
//_update_menu();
|
|
emit_signal("keying_changed");
|
|
}
|
|
|
|
bool AnimationTrackEditor::has_keying() const {
|
|
return keying;
|
|
}
|
|
Dictionary AnimationTrackEditor::get_state() const {
|
|
Dictionary state;
|
|
state["fps_mode"] = timeline->is_using_fps();
|
|
state["zoom"] = zoom->get_value();
|
|
state["offset"] = timeline->get_value();
|
|
state["v_scroll"] = scroll->get_v_scrollbar()->get_value();
|
|
return state;
|
|
}
|
|
void AnimationTrackEditor::set_state(const Dictionary &p_state) {
|
|
if (p_state.has("fps_mode")) {
|
|
bool fps_mode = p_state["fps_mode"];
|
|
if (fps_mode) {
|
|
snap_mode->select(1);
|
|
} else {
|
|
snap_mode->select(0);
|
|
}
|
|
_snap_mode_changed(snap_mode->get_selected());
|
|
} else {
|
|
snap_mode->select(0);
|
|
_snap_mode_changed(snap_mode->get_selected());
|
|
}
|
|
if (p_state.has("zoom")) {
|
|
zoom->set_value(p_state["zoom"]);
|
|
} else {
|
|
zoom->set_value(1.0);
|
|
}
|
|
if (p_state.has("offset")) {
|
|
timeline->set_value(p_state["offset"]);
|
|
} else {
|
|
timeline->set_value(0);
|
|
}
|
|
if (p_state.has("v_scroll")) {
|
|
scroll->get_v_scrollbar()->set_value(p_state["v_scroll"]);
|
|
} else {
|
|
scroll->get_v_scrollbar()->set_value(0);
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::cleanup() {
|
|
set_animation(Ref<Animation>());
|
|
}
|
|
|
|
void AnimationTrackEditor::_name_limit_changed() {
|
|
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_timeline_changed(float p_new_pos, bool p_drag) {
|
|
|
|
emit_signal("timeline_changed", p_new_pos, p_drag);
|
|
}
|
|
|
|
void AnimationTrackEditor::_track_remove_request(int p_track) {
|
|
|
|
int idx = p_track;
|
|
if (idx >= 0 && idx < animation->get_track_count()) {
|
|
selection.clear();
|
|
_clear_key_edit();
|
|
//all will be updated after remove anyway, and triggering update here raises error on tracks already removed
|
|
|
|
undo_redo->create_action(TTR("Remove Anim Track"));
|
|
undo_redo->add_do_method(animation.ptr(), "remove_track", idx);
|
|
undo_redo->add_undo_method(animation.ptr(), "add_track", animation->track_get_type(idx), idx);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_path", idx, animation->track_get_path(idx));
|
|
//todo interpolation
|
|
for (int i = 0; i < animation->track_get_key_count(idx); i++) {
|
|
|
|
Variant v = animation->track_get_key_value(idx, i);
|
|
float time = animation->track_get_key_time(idx, i);
|
|
float trans = animation->track_get_key_transition(idx, i);
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", idx, time, v);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_key_transition", idx, i, trans);
|
|
}
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_interpolation_type", idx, animation->track_get_interpolation_type(idx));
|
|
if (animation->track_get_type(idx) == Animation::TYPE_VALUE) {
|
|
undo_redo->add_undo_method(animation.ptr(), "value_track_set_update_mode", idx, animation->value_track_get_update_mode(idx));
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::set_anim_pos(float p_pos) {
|
|
|
|
timeline->set_play_position(p_pos);
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->set_play_position(p_pos);
|
|
}
|
|
for (int i = 0; i < groups.size(); i++) {
|
|
groups[i]->update();
|
|
}
|
|
bezier_edit->set_play_position(p_pos);
|
|
}
|
|
|
|
void AnimationTrackEditor::_query_insert(const InsertData &p_id) {
|
|
|
|
if (insert_frame != Engine::get_singleton()->get_frames_drawn()) {
|
|
//clear insert list for the frame if frame changed
|
|
if (insert_confirm->is_visible_in_tree())
|
|
return; //do nothing
|
|
insert_data.clear();
|
|
insert_query = false;
|
|
}
|
|
insert_frame = Engine::get_singleton()->get_frames_drawn();
|
|
|
|
for (List<InsertData>::Element *E = insert_data.front(); E; E = E->next()) {
|
|
//prevent insertion of multiple tracks
|
|
if (E->get().path == p_id.path)
|
|
return; //already inserted a track for this on this frame
|
|
}
|
|
|
|
insert_data.push_back(p_id);
|
|
|
|
if (p_id.track_idx == -1) {
|
|
if (bool(EDITOR_DEF("editors/animation/confirm_insert_track", true))) {
|
|
//potential new key, does not exist
|
|
if (insert_data.size() == 1)
|
|
insert_confirm_text->set_text(vformat(TTR("Create NEW track for %s and insert key?"), p_id.query));
|
|
else
|
|
insert_confirm_text->set_text(vformat(TTR("Create %d NEW tracks and insert keys?"), insert_data.size()));
|
|
|
|
bool all_bezier = true;
|
|
for (int i = 0; i < insert_data.size(); i++) {
|
|
if (insert_data[i].type != Animation::TYPE_VALUE && insert_data[i].type != Animation::TYPE_BEZIER) {
|
|
all_bezier = false;
|
|
}
|
|
|
|
if (insert_data[i].type != Animation::TYPE_VALUE) {
|
|
continue;
|
|
}
|
|
switch (insert_data[i].value.get_type()) {
|
|
case Variant::INT:
|
|
case Variant::REAL:
|
|
case Variant::VECTOR2:
|
|
case Variant::VECTOR3:
|
|
case Variant::QUAT:
|
|
case Variant::PLANE:
|
|
case Variant::COLOR: {
|
|
//good
|
|
} break;
|
|
default: {
|
|
all_bezier = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
insert_confirm_bezier->set_visible(all_bezier);
|
|
insert_confirm->get_ok()->set_text(TTR("Create"));
|
|
insert_confirm->popup_centered_minsize();
|
|
insert_query = true;
|
|
} else {
|
|
call_deferred("_insert_delay");
|
|
insert_queue = true;
|
|
}
|
|
|
|
} else {
|
|
if (!insert_query && !insert_queue) {
|
|
call_deferred("_insert_delay");
|
|
insert_queue = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_insert_delay() {
|
|
|
|
if (insert_query) {
|
|
//discard since it's entered into query mode
|
|
insert_queue = false;
|
|
return;
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Anim Insert"));
|
|
|
|
int last_track = animation->get_track_count();
|
|
bool advance = false;
|
|
while (insert_data.size()) {
|
|
|
|
if (insert_data.front()->get().advance)
|
|
advance = true;
|
|
last_track = _confirm_insert(insert_data.front()->get(), last_track);
|
|
insert_data.pop_front();
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
if (advance) {
|
|
float step = animation->get_step();
|
|
if (step == 0)
|
|
step = 1;
|
|
|
|
float pos = timeline->get_play_position();
|
|
|
|
pos = Math::stepify(pos + step, step);
|
|
if (pos > animation->get_length())
|
|
pos = animation->get_length();
|
|
set_anim_pos(pos);
|
|
emit_signal("timeline_changed", pos, true);
|
|
}
|
|
insert_queue = false;
|
|
}
|
|
|
|
void AnimationTrackEditor::insert_transform_key(Spatial *p_node, const String &p_sub, const Transform &p_xform) {
|
|
|
|
if (!keying)
|
|
return;
|
|
if (!animation.is_valid())
|
|
return;
|
|
|
|
ERR_FAIL_COND(!root);
|
|
//let's build a node path
|
|
String path = root->get_path_to(p_node);
|
|
if (p_sub != "")
|
|
path += ":" + p_sub;
|
|
|
|
NodePath np = path;
|
|
|
|
int track_idx = -1;
|
|
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
if (animation->track_get_type(i) != Animation::TYPE_TRANSFORM)
|
|
continue;
|
|
if (animation->track_get_path(i) != np)
|
|
continue;
|
|
|
|
track_idx = i;
|
|
break;
|
|
}
|
|
|
|
InsertData id;
|
|
Dictionary val;
|
|
|
|
id.path = np;
|
|
id.track_idx = track_idx;
|
|
id.value = p_xform;
|
|
id.type = Animation::TYPE_TRANSFORM;
|
|
id.query = "node '" + p_node->get_name() + "'";
|
|
id.advance = false;
|
|
|
|
//dialog insert
|
|
|
|
_query_insert(id);
|
|
}
|
|
|
|
void AnimationTrackEditor::_insert_animation_key(NodePath p_path, const Variant &p_value) {
|
|
|
|
String path = p_path;
|
|
|
|
//animation property is a special case, always creates an animation track
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
String np = animation->track_get_path(i);
|
|
|
|
if (path == np && animation->track_get_type(i) == Animation::TYPE_ANIMATION) {
|
|
//exists
|
|
InsertData id;
|
|
id.path = path;
|
|
id.track_idx = i;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_ANIMATION;
|
|
id.query = "animation";
|
|
id.advance = false;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
return;
|
|
}
|
|
}
|
|
|
|
InsertData id;
|
|
id.path = path;
|
|
id.track_idx = -1;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_ANIMATION;
|
|
id.query = "animation";
|
|
id.advance = false;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
}
|
|
|
|
void AnimationTrackEditor::insert_node_value_key(Node *p_node, const String &p_property, const Variant &p_value, bool p_only_if_exists) {
|
|
|
|
ERR_FAIL_COND(!root);
|
|
//let's build a node path
|
|
|
|
Node *node = p_node;
|
|
|
|
String path = root->get_path_to(node);
|
|
|
|
if (Object::cast_to<AnimationPlayer>(node) && p_property == "current_animation") {
|
|
if (node == AnimationPlayerEditor::singleton->get_player()) {
|
|
EditorNode::get_singleton()->show_warning(TTR("AnimationPlayer can't animate itself, only other players."));
|
|
return;
|
|
}
|
|
_insert_animation_key(path, p_value);
|
|
return;
|
|
}
|
|
|
|
EditorHistory *history = EditorNode::get_singleton()->get_editor_history();
|
|
for (int i = 1; i < history->get_path_size(); i++) {
|
|
|
|
String prop = history->get_path_property(i);
|
|
ERR_FAIL_COND(prop == "");
|
|
path += ":" + prop;
|
|
}
|
|
|
|
path += ":" + p_property;
|
|
|
|
NodePath np = path;
|
|
|
|
//locate track
|
|
|
|
bool inserted = false;
|
|
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
if (animation->track_get_type(i) == Animation::TYPE_VALUE) {
|
|
if (animation->track_get_path(i) != np)
|
|
continue;
|
|
|
|
InsertData id;
|
|
id.path = np;
|
|
id.track_idx = i;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_VALUE;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = false;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
inserted = true;
|
|
} else if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {
|
|
|
|
Variant value;
|
|
if (animation->track_get_path(i) == np) {
|
|
value = p_value; //all good
|
|
} else {
|
|
String tpath = animation->track_get_path(i);
|
|
if (NodePath(tpath.get_basename()) == np) {
|
|
String subindex = tpath.get_extension();
|
|
value = p_value.get(subindex);
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
InsertData id;
|
|
id.path = animation->track_get_path(i);
|
|
id.track_idx = i;
|
|
id.value = value;
|
|
id.type = Animation::TYPE_BEZIER;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = false;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
inserted = true;
|
|
}
|
|
}
|
|
|
|
if (inserted || p_only_if_exists)
|
|
return;
|
|
InsertData id;
|
|
id.path = np;
|
|
id.track_idx = -1;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_VALUE;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = false;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
}
|
|
|
|
void AnimationTrackEditor::insert_value_key(const String &p_property, const Variant &p_value, bool p_advance) {
|
|
|
|
EditorHistory *history = EditorNode::get_singleton()->get_editor_history();
|
|
|
|
ERR_FAIL_COND(!root);
|
|
//let's build a node path
|
|
ERR_FAIL_COND(history->get_path_size() == 0);
|
|
Object *obj = ObjectDB::get_instance(history->get_path_object(0));
|
|
ERR_FAIL_COND(!Object::cast_to<Node>(obj));
|
|
|
|
Node *node = Object::cast_to<Node>(obj);
|
|
|
|
String path = root->get_path_to(node);
|
|
|
|
if (Object::cast_to<AnimationPlayer>(node) && p_property == "current_animation") {
|
|
if (node == AnimationPlayerEditor::singleton->get_player()) {
|
|
EditorNode::get_singleton()->show_warning(TTR("AnimationPlayer can't animate itself, only other players."));
|
|
return;
|
|
}
|
|
_insert_animation_key(path, p_value);
|
|
return;
|
|
}
|
|
|
|
for (int i = 1; i < history->get_path_size(); i++) {
|
|
|
|
String prop = history->get_path_property(i);
|
|
ERR_FAIL_COND(prop == "");
|
|
path += ":" + prop;
|
|
}
|
|
|
|
path += ":" + p_property;
|
|
|
|
NodePath np = path;
|
|
|
|
//locate track
|
|
|
|
bool inserted = false;
|
|
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
if (animation->track_get_type(i) == Animation::TYPE_VALUE) {
|
|
if (animation->track_get_path(i) != np)
|
|
continue;
|
|
|
|
InsertData id;
|
|
id.path = np;
|
|
id.track_idx = i;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_VALUE;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = p_advance;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
inserted = true;
|
|
} else if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {
|
|
|
|
Variant value;
|
|
if (animation->track_get_path(i) == np) {
|
|
value = p_value; //all good
|
|
} else {
|
|
String tpath = animation->track_get_path(i);
|
|
if (NodePath(tpath.get_basename()) == np) {
|
|
String subindex = tpath.get_extension();
|
|
value = p_value.get(subindex);
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
InsertData id;
|
|
id.path = animation->track_get_path(i);
|
|
id.track_idx = i;
|
|
id.value = value;
|
|
id.type = Animation::TYPE_BEZIER;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = p_advance;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
inserted = true;
|
|
}
|
|
}
|
|
|
|
if (!inserted) {
|
|
InsertData id;
|
|
id.path = np;
|
|
id.track_idx = -1;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_VALUE;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = p_advance;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_confirm_insert_list() {
|
|
|
|
undo_redo->create_action(TTR("Anim Create & Insert"));
|
|
|
|
int last_track = animation->get_track_count();
|
|
while (insert_data.size()) {
|
|
|
|
last_track = _confirm_insert(insert_data.front()->get(), last_track, insert_confirm_bezier->is_pressed());
|
|
insert_data.pop_front();
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
PropertyInfo AnimationTrackEditor::_find_hint_for_track(int p_idx, NodePath &r_base_path, Variant *r_current_val) {
|
|
|
|
r_base_path = NodePath();
|
|
ERR_FAIL_COND_V(!animation.is_valid(), PropertyInfo());
|
|
ERR_FAIL_INDEX_V(p_idx, animation->get_track_count(), PropertyInfo());
|
|
|
|
if (!root) {
|
|
return PropertyInfo();
|
|
}
|
|
|
|
NodePath path = animation->track_get_path(p_idx);
|
|
|
|
if (!root->has_node_and_resource(path)) {
|
|
return PropertyInfo();
|
|
}
|
|
|
|
RES res;
|
|
Vector<StringName> leftover_path;
|
|
Node *node = root->get_node_and_resource(path, res, leftover_path, true);
|
|
|
|
if (node) {
|
|
r_base_path = node->get_path();
|
|
}
|
|
|
|
if (leftover_path.empty()) {
|
|
if (r_current_val) {
|
|
if (res.is_valid()) {
|
|
*r_current_val = res;
|
|
} else if (node) {
|
|
*r_current_val = node;
|
|
}
|
|
}
|
|
return PropertyInfo();
|
|
}
|
|
|
|
Variant property_info_base;
|
|
if (res.is_valid()) {
|
|
property_info_base = res;
|
|
if (r_current_val) {
|
|
*r_current_val = res->get_indexed(leftover_path);
|
|
}
|
|
} else if (node) {
|
|
property_info_base = node;
|
|
if (r_current_val) {
|
|
*r_current_val = node->get_indexed(leftover_path);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < leftover_path.size() - 1; i++) {
|
|
property_info_base = property_info_base.get_named(leftover_path[i]);
|
|
}
|
|
|
|
List<PropertyInfo> pinfo;
|
|
property_info_base.get_property_list(&pinfo);
|
|
|
|
for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
|
|
|
|
if (E->get().name == leftover_path[leftover_path.size() - 1]) {
|
|
return E->get();
|
|
}
|
|
}
|
|
|
|
return PropertyInfo();
|
|
}
|
|
|
|
static Vector<String> _get_bezier_subindices_for_type(Variant::Type p_type, bool *r_valid = NULL) {
|
|
Vector<String> subindices;
|
|
if (r_valid) {
|
|
*r_valid = true;
|
|
}
|
|
switch (p_type) {
|
|
case Variant::INT: {
|
|
subindices.push_back("");
|
|
} break;
|
|
case Variant::REAL: {
|
|
subindices.push_back("");
|
|
} break;
|
|
case Variant::VECTOR2: {
|
|
subindices.push_back(":x");
|
|
subindices.push_back(":y");
|
|
} break;
|
|
case Variant::VECTOR3: {
|
|
subindices.push_back(":x");
|
|
subindices.push_back(":y");
|
|
subindices.push_back(":z");
|
|
} break;
|
|
case Variant::QUAT: {
|
|
subindices.push_back(":x");
|
|
subindices.push_back(":y");
|
|
subindices.push_back(":z");
|
|
subindices.push_back(":w");
|
|
} break;
|
|
case Variant::COLOR: {
|
|
subindices.push_back(":r");
|
|
subindices.push_back(":g");
|
|
subindices.push_back(":b");
|
|
subindices.push_back(":a");
|
|
} break;
|
|
case Variant::PLANE: {
|
|
subindices.push_back(":x");
|
|
subindices.push_back(":y");
|
|
subindices.push_back(":z");
|
|
subindices.push_back(":d");
|
|
} break;
|
|
default: {
|
|
if (r_valid) {
|
|
*r_valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return subindices;
|
|
}
|
|
|
|
int AnimationTrackEditor::_confirm_insert(InsertData p_id, int p_last_track, bool p_create_beziers) {
|
|
|
|
if (p_last_track == -1)
|
|
p_last_track = animation->get_track_count();
|
|
|
|
bool created = false;
|
|
if (p_id.track_idx < 0) {
|
|
|
|
if (p_create_beziers && (p_id.value.get_type() == Variant::VECTOR2 ||
|
|
p_id.value.get_type() == Variant::VECTOR3 ||
|
|
p_id.value.get_type() == Variant::QUAT ||
|
|
p_id.value.get_type() == Variant::COLOR ||
|
|
p_id.value.get_type() == Variant::PLANE)) {
|
|
|
|
Vector<String> subindices = _get_bezier_subindices_for_type(p_id.value.get_type());
|
|
|
|
for (int i = 0; i < subindices.size(); i++) {
|
|
InsertData id = p_id;
|
|
id.type = Animation::TYPE_BEZIER;
|
|
id.value = p_id.value.get(subindices[i].substr(1, subindices[i].length()));
|
|
id.path = String(p_id.path) + subindices[i];
|
|
_confirm_insert(id, p_last_track + i);
|
|
}
|
|
|
|
return p_last_track + subindices.size() - 1;
|
|
}
|
|
created = true;
|
|
undo_redo->create_action(TTR("Anim Insert Track & Key"));
|
|
Animation::UpdateMode update_mode = Animation::UPDATE_DISCRETE;
|
|
|
|
if (p_id.type == Animation::TYPE_VALUE || p_id.type == Animation::TYPE_BEZIER) {
|
|
//wants a new tack
|
|
|
|
{
|
|
//hack
|
|
NodePath np;
|
|
animation->add_track(p_id.type);
|
|
animation->track_set_path(animation->get_track_count() - 1, p_id.path);
|
|
PropertyInfo h = _find_hint_for_track(animation->get_track_count() - 1, np);
|
|
animation->remove_track(animation->get_track_count() - 1); //hack
|
|
|
|
if (h.type == Variant::REAL ||
|
|
h.type == Variant::VECTOR2 ||
|
|
h.type == Variant::RECT2 ||
|
|
h.type == Variant::VECTOR3 ||
|
|
h.type == Variant::AABB ||
|
|
h.type == Variant::QUAT ||
|
|
h.type == Variant::COLOR ||
|
|
h.type == Variant::PLANE ||
|
|
h.type == Variant::TRANSFORM2D ||
|
|
h.type == Variant::TRANSFORM) {
|
|
|
|
update_mode = Animation::UPDATE_CONTINUOUS;
|
|
}
|
|
|
|
if (h.usage & PROPERTY_USAGE_ANIMATE_AS_TRIGGER) {
|
|
update_mode = Animation::UPDATE_TRIGGER;
|
|
}
|
|
}
|
|
}
|
|
|
|
p_id.track_idx = p_last_track;
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", p_id.type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", p_id.track_idx, p_id.path);
|
|
if (p_id.type == Animation::TYPE_VALUE)
|
|
undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", p_id.track_idx, update_mode);
|
|
|
|
} else {
|
|
undo_redo->create_action(TTR("Anim Insert Key"));
|
|
}
|
|
|
|
float time = timeline->get_play_position();
|
|
Variant value;
|
|
|
|
switch (p_id.type) {
|
|
|
|
case Animation::TYPE_VALUE: {
|
|
|
|
value = p_id.value;
|
|
|
|
} break;
|
|
case Animation::TYPE_TRANSFORM: {
|
|
|
|
Transform tr = p_id.value;
|
|
Dictionary d;
|
|
d["location"] = tr.origin;
|
|
d["scale"] = tr.basis.get_scale();
|
|
d["rotation"] = Quat(tr.basis); //.orthonormalized();
|
|
value = d;
|
|
} break;
|
|
case Animation::TYPE_BEZIER: {
|
|
Array array;
|
|
array.resize(5);
|
|
array[0] = p_id.value;
|
|
array[1] = -0.25;
|
|
array[2] = 0;
|
|
array[3] = 0.25;
|
|
array[4] = 0;
|
|
value = array;
|
|
|
|
} break;
|
|
case Animation::TYPE_ANIMATION: {
|
|
value = p_id.value;
|
|
} break;
|
|
default: {
|
|
}
|
|
}
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_id.track_idx, time, value);
|
|
|
|
if (created) {
|
|
|
|
//just remove the track
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", p_last_track);
|
|
p_last_track++;
|
|
} else {
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_id.track_idx, time);
|
|
int existing = animation->track_find_key(p_id.track_idx, time, true);
|
|
if (existing != -1) {
|
|
Variant v = animation->track_get_key_value(p_id.track_idx, existing);
|
|
float trans = animation->track_get_key_transition(p_id.track_idx, existing);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", p_id.track_idx, time, v, trans);
|
|
}
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
return p_last_track;
|
|
}
|
|
|
|
void AnimationTrackEditor::show_select_node_warning(bool p_show) {
|
|
}
|
|
|
|
bool AnimationTrackEditor::is_key_selected(int p_track, int p_key) const {
|
|
|
|
SelectedKey sk;
|
|
sk.key = p_key;
|
|
sk.track = p_track;
|
|
|
|
return selection.has(sk);
|
|
}
|
|
|
|
bool AnimationTrackEditor::is_selection_active() const {
|
|
return selection.size();
|
|
}
|
|
|
|
void AnimationTrackEditor::_update_tracks() {
|
|
|
|
int selected = _get_track_selected();
|
|
|
|
while (track_vbox->get_child_count()) {
|
|
memdelete(track_vbox->get_child(0));
|
|
}
|
|
|
|
track_edits.clear();
|
|
groups.clear();
|
|
|
|
if (animation.is_null())
|
|
return;
|
|
|
|
Map<String, VBoxContainer *> group_sort;
|
|
|
|
bool use_grouping = !view_group->is_pressed();
|
|
bool use_filter = selected_filter->is_pressed();
|
|
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
AnimationTrackEdit *track_edit = NULL;
|
|
|
|
//find hint and info for plugin
|
|
|
|
if (use_filter) {
|
|
NodePath path = animation->track_get_path(i);
|
|
|
|
if (root && root->has_node(path)) {
|
|
Node *node = root->get_node(path);
|
|
if (!node) {
|
|
continue; // no node, no filter
|
|
}
|
|
if (!EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
|
|
continue; //skip track due to not selected
|
|
}
|
|
}
|
|
}
|
|
|
|
if (animation->track_get_type(i) == Animation::TYPE_VALUE) {
|
|
|
|
NodePath path = animation->track_get_path(i);
|
|
|
|
if (root && root->has_node_and_resource(path)) {
|
|
RES res;
|
|
NodePath base_path;
|
|
Vector<StringName> leftover_path;
|
|
Node *node = root->get_node_and_resource(path, res, leftover_path, true);
|
|
PropertyInfo pinfo = _find_hint_for_track(i, base_path);
|
|
|
|
Object *object = node;
|
|
if (res.is_valid()) {
|
|
object = res.ptr();
|
|
}
|
|
|
|
if (object && !leftover_path.empty()) {
|
|
if (pinfo.name.empty()) {
|
|
pinfo.name = leftover_path[leftover_path.size() - 1];
|
|
}
|
|
|
|
for (int j = 0; j < track_edit_plugins.size(); j++) {
|
|
track_edit = track_edit_plugins.write[j]->create_value_track_edit(object, pinfo.type, pinfo.name, pinfo.hint, pinfo.hint_string, pinfo.usage);
|
|
if (track_edit) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (animation->track_get_type(i) == Animation::TYPE_AUDIO) {
|
|
|
|
for (int j = 0; j < track_edit_plugins.size(); j++) {
|
|
track_edit = track_edit_plugins.write[j]->create_audio_track_edit();
|
|
if (track_edit) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (animation->track_get_type(i) == Animation::TYPE_ANIMATION) {
|
|
NodePath path = animation->track_get_path(i);
|
|
|
|
Node *node = NULL;
|
|
if (root && root->has_node(path)) {
|
|
node = root->get_node(path);
|
|
}
|
|
|
|
if (node && Object::cast_to<AnimationPlayer>(node)) {
|
|
for (int j = 0; j < track_edit_plugins.size(); j++) {
|
|
track_edit = track_edit_plugins.write[j]->create_animation_track_edit(node);
|
|
if (track_edit) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (track_edit == NULL) {
|
|
//no valid plugin_found
|
|
track_edit = memnew(AnimationTrackEdit);
|
|
}
|
|
|
|
track_edits.push_back(track_edit);
|
|
|
|
if (use_grouping) {
|
|
String base_path = animation->track_get_path(i);
|
|
base_path = base_path.get_slice(":", 0); // remove subpath
|
|
|
|
if (!group_sort.has(base_path)) {
|
|
AnimationTrackEditGroup *g = memnew(AnimationTrackEditGroup);
|
|
Ref<Texture> icon = get_icon("Node", "EditorIcons");
|
|
String name = base_path;
|
|
String tooltip;
|
|
if (root) {
|
|
Node *n = root->get_node(base_path);
|
|
if (n) {
|
|
if (has_icon(n->get_class(), "EditorIcons")) {
|
|
icon = get_icon(n->get_class(), "EditorIcons");
|
|
}
|
|
name = n->get_name();
|
|
tooltip = root->get_path_to(n);
|
|
}
|
|
}
|
|
|
|
g->set_type_and_name(icon, name, animation->track_get_path(i));
|
|
g->set_root(root);
|
|
g->set_tooltip(tooltip);
|
|
g->set_timeline(timeline);
|
|
groups.push_back(g);
|
|
VBoxContainer *vb = memnew(VBoxContainer);
|
|
vb->add_constant_override("separation", 0);
|
|
vb->add_child(g);
|
|
track_vbox->add_child(vb);
|
|
group_sort[base_path] = vb;
|
|
}
|
|
|
|
track_edit->set_in_group(true);
|
|
group_sort[base_path]->add_child(track_edit);
|
|
|
|
} else {
|
|
track_edit->set_in_group(false);
|
|
track_vbox->add_child(track_edit);
|
|
}
|
|
|
|
track_edit->set_undo_redo(undo_redo);
|
|
track_edit->set_timeline(timeline);
|
|
track_edit->set_root(root);
|
|
track_edit->set_animation_and_track(animation, i);
|
|
track_edit->set_play_position(timeline->get_play_position());
|
|
track_edit->set_editor(this);
|
|
|
|
if (selected == i) {
|
|
track_edit->grab_focus();
|
|
}
|
|
|
|
track_edit->connect("timeline_changed", this, "_timeline_changed");
|
|
track_edit->connect("remove_request", this, "_track_remove_request", varray(), CONNECT_DEFERRED);
|
|
track_edit->connect("dropped", this, "_dropped_track", varray(), CONNECT_DEFERRED);
|
|
track_edit->connect("insert_key", this, "_insert_key_from_track", varray(i), CONNECT_DEFERRED);
|
|
track_edit->connect("select_key", this, "_key_selected", varray(i), CONNECT_DEFERRED);
|
|
track_edit->connect("deselect_key", this, "_key_deselected", varray(i), CONNECT_DEFERRED);
|
|
track_edit->connect("bezier_edit", this, "_bezier_edit", varray(i), CONNECT_DEFERRED);
|
|
track_edit->connect("clear_selection", this, "_clear_selection");
|
|
track_edit->connect("move_selection_begin", this, "_move_selection_begin");
|
|
track_edit->connect("move_selection", this, "_move_selection");
|
|
track_edit->connect("move_selection_commit", this, "_move_selection_commit");
|
|
track_edit->connect("move_selection_cancel", this, "_move_selection_cancel");
|
|
|
|
track_edit->connect("duplicate_request", this, "_edit_menu_pressed", varray(EDIT_DUPLICATE_SELECTION), CONNECT_DEFERRED);
|
|
track_edit->connect("duplicate_transpose_request", this, "_edit_menu_pressed", varray(EDIT_DUPLICATE_TRANSPOSED), CONNECT_DEFERRED);
|
|
track_edit->connect("delete_request", this, "_edit_menu_pressed", varray(EDIT_DELETE_SELECTION), CONNECT_DEFERRED);
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_animation_changed() {
|
|
|
|
if (animation_changing_awaiting_update) {
|
|
return; //all will be updated, dont bother with anything
|
|
}
|
|
|
|
if (key_edit && key_edit->setting) {
|
|
//if editing a key, just update the edited track, makes refresh less costly
|
|
if (key_edit->track < track_edits.size()) {
|
|
track_edits[key_edit->track]->update();
|
|
}
|
|
return;
|
|
}
|
|
|
|
animation_changing_awaiting_update = true;
|
|
call_deferred("_animation_update");
|
|
}
|
|
|
|
void AnimationTrackEditor::_snap_mode_changed(int p_mode) {
|
|
|
|
timeline->set_use_fps(p_mode == 1);
|
|
if (key_edit) {
|
|
key_edit->set_use_fps(p_mode == 1);
|
|
}
|
|
_update_step_spinbox();
|
|
}
|
|
|
|
void AnimationTrackEditor::_update_step_spinbox() {
|
|
if (!animation.is_valid()) {
|
|
return;
|
|
}
|
|
step->set_block_signals(true);
|
|
|
|
if (timeline->is_using_fps()) {
|
|
if (animation->get_step() == 0) {
|
|
step->set_value(0);
|
|
} else {
|
|
step->set_value(1.0 / animation->get_step());
|
|
}
|
|
|
|
} else {
|
|
step->set_value(animation->get_step());
|
|
}
|
|
|
|
step->set_block_signals(false);
|
|
}
|
|
void AnimationTrackEditor::_animation_update() {
|
|
|
|
timeline->update();
|
|
timeline->update_values();
|
|
|
|
bool same = true;
|
|
|
|
if (animation.is_null()) {
|
|
return;
|
|
}
|
|
|
|
if (track_edits.size() == animation->get_track_count()) {
|
|
//check tracks are the same
|
|
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
if (track_edits[i]->get_path() != animation->track_get_path(i)) {
|
|
same = false;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
same = false;
|
|
}
|
|
|
|
if (same) {
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
for (int i = 0; i < groups.size(); i++) {
|
|
groups[i]->update();
|
|
}
|
|
} else {
|
|
_update_tracks();
|
|
}
|
|
|
|
bezier_edit->update();
|
|
|
|
_update_step_spinbox();
|
|
|
|
animation_changing_awaiting_update = false;
|
|
}
|
|
|
|
MenuButton *AnimationTrackEditor::get_edit_menu() {
|
|
return edit;
|
|
}
|
|
|
|
void AnimationTrackEditor::_notification(int p_what) {
|
|
if (p_what == NOTIFICATION_THEME_CHANGED || p_what == NOTIFICATION_ENTER_TREE) {
|
|
zoom_icon->set_texture(get_icon("Zoom", "EditorIcons"));
|
|
snap->set_icon(get_icon("Snap", "EditorIcons"));
|
|
view_group->set_icon(get_icon(view_group->is_pressed() ? "AnimationTrackList" : "AnimationTrackGroup", "EditorIcons"));
|
|
selected_filter->set_icon(get_icon("AnimationFilter", "EditorIcons"));
|
|
main_panel->add_style_override("panel", get_stylebox("bg", "Tree"));
|
|
}
|
|
|
|
if (p_what == NOTIFICATION_READY) {
|
|
EditorNode::get_singleton()->get_editor_selection()->connect("selection_changed", this, "_selection_changed");
|
|
}
|
|
|
|
if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
|
|
update_keying();
|
|
EditorNode::get_singleton()->update_keying();
|
|
emit_signal("keying_changed");
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_update_scroll(double) {
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
for (int i = 0; i < groups.size(); i++) {
|
|
groups[i]->update();
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_update_step(double p_new_step) {
|
|
|
|
undo_redo->create_action(TTR("Change Animation Step"));
|
|
float step_value = p_new_step;
|
|
if (timeline->is_using_fps()) {
|
|
if (step_value != 0.0) {
|
|
step_value = 1.0 / step_value;
|
|
}
|
|
}
|
|
undo_redo->add_do_method(animation.ptr(), "set_step", step_value);
|
|
undo_redo->add_undo_method(animation.ptr(), "set_step", animation->get_step());
|
|
step->set_block_signals(true);
|
|
undo_redo->commit_action();
|
|
step->set_block_signals(false);
|
|
emit_signal("animation_step_changed", step_value);
|
|
}
|
|
|
|
void AnimationTrackEditor::_update_length(double p_new_len) {
|
|
|
|
emit_signal("animation_len_changed", p_new_len);
|
|
}
|
|
|
|
void AnimationTrackEditor::_dropped_track(int p_from_track, int p_to_track) {
|
|
if (p_to_track >= track_edits.size()) {
|
|
p_to_track = track_edits.size() - 1;
|
|
}
|
|
|
|
if (p_from_track == p_to_track)
|
|
return;
|
|
|
|
_clear_selection();
|
|
undo_redo->create_action(TTR("Rearrange Tracks"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_swap", p_from_track, p_to_track);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_swap", p_to_track, p_from_track);
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
void AnimationTrackEditor::_new_track_node_selected(NodePath p_path) {
|
|
|
|
ERR_FAIL_COND(!root);
|
|
Node *node = get_node(p_path);
|
|
ERR_FAIL_COND(!node);
|
|
NodePath path_to = root->get_path_to(node);
|
|
|
|
if (adding_track_type == Animation::TYPE_TRANSFORM && !node->is_class("Spatial")) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Transform tracks only apply to Spatial-based nodes."));
|
|
return;
|
|
}
|
|
|
|
switch (adding_track_type) {
|
|
case Animation::TYPE_VALUE: {
|
|
adding_track_path = path_to;
|
|
prop_selector->set_type_filter(Vector<Variant::Type>());
|
|
prop_selector->select_property_from_instance(node);
|
|
} break;
|
|
case Animation::TYPE_TRANSFORM:
|
|
case Animation::TYPE_METHOD: {
|
|
|
|
undo_redo->create_action(TTR("Add Track"));
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), path_to);
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
case Animation::TYPE_BEZIER: {
|
|
|
|
Vector<Variant::Type> filter;
|
|
filter.push_back(Variant::INT);
|
|
filter.push_back(Variant::REAL);
|
|
filter.push_back(Variant::VECTOR2);
|
|
filter.push_back(Variant::VECTOR3);
|
|
filter.push_back(Variant::QUAT);
|
|
filter.push_back(Variant::PLANE);
|
|
filter.push_back(Variant::COLOR);
|
|
|
|
adding_track_path = path_to;
|
|
prop_selector->set_type_filter(filter);
|
|
prop_selector->select_property_from_instance(node);
|
|
} break;
|
|
case Animation::TYPE_AUDIO: {
|
|
|
|
if (!node->is_class("AudioStreamPlayer") && !node->is_class("AudioStreamPlayer2D") && !node->is_class("AudioStreamPlayer3D")) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Audio tracks can only point to nodes of type:\n-AudioStreamPlayer\n-AudioStreamPlayer2D\n-AudioStreamPlayer3D"));
|
|
return;
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Add Track"));
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), path_to);
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
case Animation::TYPE_ANIMATION: {
|
|
|
|
if (!node->is_class("AnimationPlayer")) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Animation tracks can only point to AnimationPlayer nodes."));
|
|
return;
|
|
}
|
|
|
|
if (node == AnimationPlayerEditor::singleton->get_player()) {
|
|
EditorNode::get_singleton()->show_warning(TTR("An animation player can't animate itself, only other players."));
|
|
return;
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Add Track"));
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), path_to);
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_add_track(int p_type) {
|
|
if (!root) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Not possible to add a new track without a root"));
|
|
return;
|
|
}
|
|
adding_track_type = p_type;
|
|
pick_track->popup_centered_ratio();
|
|
}
|
|
|
|
void AnimationTrackEditor::_new_track_property_selected(String p_name) {
|
|
|
|
String full_path = String(adding_track_path) + ":" + p_name;
|
|
|
|
if (adding_track_type == Animation::TYPE_VALUE) {
|
|
|
|
Animation::UpdateMode update_mode = Animation::UPDATE_DISCRETE;
|
|
{
|
|
//hack
|
|
NodePath np;
|
|
animation->add_track(Animation::TYPE_VALUE);
|
|
animation->track_set_path(animation->get_track_count() - 1, full_path);
|
|
PropertyInfo h = _find_hint_for_track(animation->get_track_count() - 1, np);
|
|
animation->remove_track(animation->get_track_count() - 1); //hack
|
|
if (h.type == Variant::REAL ||
|
|
h.type == Variant::VECTOR2 ||
|
|
h.type == Variant::RECT2 ||
|
|
h.type == Variant::VECTOR3 ||
|
|
h.type == Variant::AABB ||
|
|
h.type == Variant::QUAT ||
|
|
h.type == Variant::COLOR ||
|
|
h.type == Variant::PLANE ||
|
|
h.type == Variant::TRANSFORM2D ||
|
|
h.type == Variant::TRANSFORM) {
|
|
|
|
update_mode = Animation::UPDATE_CONTINUOUS;
|
|
}
|
|
|
|
if (h.usage & PROPERTY_USAGE_ANIMATE_AS_TRIGGER) {
|
|
update_mode = Animation::UPDATE_TRIGGER;
|
|
}
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Add Track"));
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), full_path);
|
|
undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", animation->get_track_count(), update_mode);
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
|
|
undo_redo->commit_action();
|
|
} else {
|
|
Vector<String> subindices;
|
|
{
|
|
//hack
|
|
NodePath np;
|
|
animation->add_track(Animation::TYPE_VALUE);
|
|
animation->track_set_path(animation->get_track_count() - 1, full_path);
|
|
PropertyInfo h = _find_hint_for_track(animation->get_track_count() - 1, np);
|
|
animation->remove_track(animation->get_track_count() - 1); //hack
|
|
bool valid;
|
|
subindices = _get_bezier_subindices_for_type(h.type, &valid);
|
|
if (!valid) {
|
|
EditorNode::get_singleton()->show_warning("Invalid track for Bezier (no suitable sub-properties)");
|
|
return;
|
|
}
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Add Bezier Track"));
|
|
int base_track = animation->get_track_count();
|
|
for (int i = 0; i < subindices.size(); i++) {
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", base_track + i, full_path + subindices[i]);
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", base_track + i);
|
|
}
|
|
undo_redo->commit_action();
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_timeline_value_changed(double) {
|
|
|
|
timeline->update_play_position();
|
|
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
track_edits[i]->update_play_position();
|
|
}
|
|
|
|
for (int i = 0; i < groups.size(); i++) {
|
|
groups[i]->update();
|
|
}
|
|
|
|
bezier_edit->update();
|
|
bezier_edit->update_play_position();
|
|
}
|
|
|
|
int AnimationTrackEditor::_get_track_selected() {
|
|
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
if (track_edits[i]->has_focus())
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void AnimationTrackEditor::_insert_key_from_track(float p_ofs, int p_track) {
|
|
|
|
ERR_FAIL_INDEX(p_track, animation->get_track_count());
|
|
|
|
if (snap->is_pressed() && step->get_value() != 0) {
|
|
p_ofs = Math::stepify(p_ofs, step->get_value());
|
|
}
|
|
while (animation->track_find_key(p_track, p_ofs, true) != -1) { //make sure insertion point is valid
|
|
p_ofs += 0.001;
|
|
}
|
|
|
|
switch (animation->track_get_type(p_track)) {
|
|
case Animation::TYPE_TRANSFORM: {
|
|
if (!root->has_node(animation->track_get_path(p_track))) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Track path is invalid, so can't add a key."));
|
|
return;
|
|
}
|
|
Spatial *base = Object::cast_to<Spatial>(root->get_node(animation->track_get_path(p_track)));
|
|
|
|
if (!base) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Track is not of type Spatial, can't insert key"));
|
|
return;
|
|
}
|
|
|
|
Transform xf = base->get_transform();
|
|
|
|
Vector3 loc = xf.get_origin();
|
|
Vector3 scale = xf.basis.get_scale_local();
|
|
Quat rot = xf.basis;
|
|
|
|
undo_redo->create_action(TTR("Add Transform Track Key"));
|
|
undo_redo->add_do_method(animation.ptr(), "transform_track_insert_key", p_track, p_ofs, loc, rot, scale);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
case Animation::TYPE_VALUE: {
|
|
|
|
NodePath bp;
|
|
Variant value;
|
|
_find_hint_for_track(p_track, bp, &value);
|
|
|
|
undo_redo->create_action(TTR("Add Track Key"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, value);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
case Animation::TYPE_METHOD: {
|
|
if (!root->has_node(animation->track_get_path(p_track))) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Track path is invalid, so can't add a method key."));
|
|
return;
|
|
}
|
|
Node *base = root->get_node(animation->track_get_path(p_track));
|
|
|
|
method_selector->select_method_from_instance(base);
|
|
|
|
insert_key_from_track_call_ofs = p_ofs;
|
|
insert_key_from_track_call_track = p_track;
|
|
|
|
} break;
|
|
case Animation::TYPE_BEZIER: {
|
|
|
|
NodePath bp;
|
|
Variant value;
|
|
_find_hint_for_track(p_track, bp, &value);
|
|
Array arr;
|
|
arr.resize(5);
|
|
arr[0] = value;
|
|
arr[1] = -0.25;
|
|
arr[2] = 0;
|
|
arr[3] = 0.25;
|
|
arr[4] = 0;
|
|
|
|
undo_redo->create_action(TTR("Add Track Key"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, arr);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
case Animation::TYPE_AUDIO: {
|
|
|
|
Dictionary ak;
|
|
ak["stream"] = RES();
|
|
ak["start_offset"] = 0;
|
|
ak["end_offset"] = 0;
|
|
|
|
undo_redo->create_action(TTR("Add Track Key"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, ak);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
|
|
undo_redo->commit_action();
|
|
} break;
|
|
case Animation::TYPE_ANIMATION: {
|
|
|
|
StringName anim = "[stop]";
|
|
|
|
undo_redo->create_action(TTR("Add Track Key"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, anim);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
|
|
undo_redo->commit_action();
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_add_method_key(const String &p_method) {
|
|
|
|
if (!root->has_node(animation->track_get_path(insert_key_from_track_call_track))) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Track path is invalid, so can't add a method key."));
|
|
return;
|
|
}
|
|
Node *base = root->get_node(animation->track_get_path(insert_key_from_track_call_track));
|
|
|
|
List<MethodInfo> minfo;
|
|
base->get_method_list(&minfo);
|
|
|
|
for (List<MethodInfo>::Element *E = minfo.front(); E; E = E->next()) {
|
|
if (E->get().name == p_method) {
|
|
|
|
Dictionary d;
|
|
d["method"] = p_method;
|
|
Array params;
|
|
int first_defarg = E->get().arguments.size() - E->get().default_arguments.size();
|
|
|
|
for (int i = 0; i < E->get().arguments.size(); i++) {
|
|
|
|
if (i >= first_defarg) {
|
|
Variant arg = E->get().default_arguments[i - first_defarg];
|
|
params.push_back(arg);
|
|
} else {
|
|
Variant::CallError ce;
|
|
Variant arg = Variant::construct(E->get().arguments[i].type, NULL, 0, ce);
|
|
params.push_back(arg);
|
|
}
|
|
}
|
|
d["args"] = params;
|
|
|
|
undo_redo->create_action(TTR("Add Method Track Key"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", insert_key_from_track_call_track, insert_key_from_track_call_ofs, d);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", insert_key_from_track_call_track, insert_key_from_track_call_ofs);
|
|
undo_redo->commit_action();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
EditorNode::get_singleton()->show_warning(TTR("Method not found in object: ") + p_method);
|
|
}
|
|
|
|
void AnimationTrackEditor::_key_selected(int p_key, bool p_single, int p_track) {
|
|
|
|
ERR_FAIL_INDEX(p_track, animation->get_track_count());
|
|
ERR_FAIL_INDEX(p_key, animation->track_get_key_count(p_track));
|
|
|
|
SelectedKey sk;
|
|
sk.key = p_key;
|
|
sk.track = p_track;
|
|
|
|
if (p_single) {
|
|
_clear_selection();
|
|
}
|
|
|
|
KeyInfo ki;
|
|
ki.pos = animation->track_get_key_time(p_track, p_key);
|
|
selection[sk] = ki;
|
|
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
|
|
_update_key_edit();
|
|
}
|
|
|
|
void AnimationTrackEditor::_key_deselected(int p_key, int p_track) {
|
|
|
|
ERR_FAIL_INDEX(p_track, animation->get_track_count());
|
|
ERR_FAIL_INDEX(p_key, animation->track_get_key_count(p_track));
|
|
|
|
SelectedKey sk;
|
|
sk.key = p_key;
|
|
sk.track = p_track;
|
|
|
|
selection.erase(sk);
|
|
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
|
|
_update_key_edit();
|
|
}
|
|
|
|
void AnimationTrackEditor::_move_selection_begin() {
|
|
moving_selection = true;
|
|
moving_selection_offset = 0;
|
|
}
|
|
|
|
void AnimationTrackEditor::_move_selection(float p_offset) {
|
|
moving_selection_offset = p_offset;
|
|
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
}
|
|
|
|
struct _AnimMoveRestore {
|
|
|
|
int track;
|
|
float time;
|
|
Variant key;
|
|
float transition;
|
|
};
|
|
//used for undo/redo
|
|
|
|
void AnimationTrackEditor::_clear_key_edit() {
|
|
if (key_edit) {
|
|
|
|
#if 0
|
|
// going back seems like the most comfortable thing to do, but it results
|
|
// in weird behaviors and crashes, because going back to animation editor
|
|
// triggers the editor setting up again itself
|
|
|
|
bool go_back = false;
|
|
if (EditorNode::get_singleton()->get_inspector()->get_edited_object() == key_edit) {
|
|
EditorNode::get_singleton()->push_item(NULL);
|
|
go_back = true;
|
|
}
|
|
|
|
memdelete(key_edit);
|
|
key_edit = NULL;
|
|
|
|
if (go_back) {
|
|
EditorNode::get_singleton()->get_inspector_dock()->go_back();
|
|
}
|
|
#else
|
|
//if key edit is the object being inspected, remove it first
|
|
if (EditorNode::get_singleton()->get_inspector()->get_edited_object() == key_edit) {
|
|
EditorNode::get_singleton()->push_item(NULL);
|
|
}
|
|
//then actually delete it
|
|
memdelete(key_edit);
|
|
key_edit = NULL;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_clear_selection() {
|
|
selection.clear();
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
_clear_key_edit();
|
|
}
|
|
|
|
void AnimationTrackEditor::_update_key_edit() {
|
|
|
|
_clear_key_edit();
|
|
if (!animation.is_valid())
|
|
return;
|
|
if (selection.size() != 1) {
|
|
return;
|
|
}
|
|
|
|
key_edit = memnew(AnimationTrackKeyEdit);
|
|
key_edit->animation = animation;
|
|
key_edit->track = selection.front()->key().track;
|
|
|
|
float ofs = animation->track_get_key_time(key_edit->track, selection.front()->key().key);
|
|
key_edit->key_ofs = ofs;
|
|
key_edit->root_path = root;
|
|
|
|
NodePath np;
|
|
key_edit->hint = _find_hint_for_track(key_edit->track, np);
|
|
key_edit->undo_redo = undo_redo;
|
|
key_edit->base = np;
|
|
|
|
EditorNode::get_singleton()->push_item(key_edit);
|
|
}
|
|
|
|
void AnimationTrackEditor::_clear_selection_for_anim(const Ref<Animation> &p_anim) {
|
|
|
|
if (!(animation == p_anim))
|
|
return;
|
|
//selection.clear();
|
|
_clear_selection();
|
|
}
|
|
|
|
void AnimationTrackEditor::_select_at_anim(const Ref<Animation> &p_anim, int p_track, float p_pos) {
|
|
|
|
if (!(animation == p_anim))
|
|
return;
|
|
|
|
int idx = animation->track_find_key(p_track, p_pos, true);
|
|
ERR_FAIL_COND(idx < 0);
|
|
|
|
SelectedKey sk;
|
|
sk.track = p_track;
|
|
sk.key = idx;
|
|
KeyInfo ki;
|
|
ki.pos = p_pos;
|
|
|
|
selection.insert(sk, ki);
|
|
}
|
|
|
|
void AnimationTrackEditor::_move_selection_commit() {
|
|
|
|
undo_redo->create_action(TTR("Anim Move Keys"));
|
|
|
|
List<_AnimMoveRestore> to_restore;
|
|
|
|
float motion = moving_selection_offset;
|
|
// 1-remove the keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key);
|
|
}
|
|
// 2- remove overlapped keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float newtime = snap_time(E->get().pos + motion);
|
|
int idx = animation->track_find_key(E->key().track, newtime, true);
|
|
if (idx == -1)
|
|
continue;
|
|
SelectedKey sk;
|
|
sk.key = idx;
|
|
sk.track = E->key().track;
|
|
if (selection.has(sk))
|
|
continue; //already in selection, don't save
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newtime);
|
|
_AnimMoveRestore amr;
|
|
|
|
amr.key = animation->track_get_key_value(E->key().track, idx);
|
|
amr.track = E->key().track;
|
|
amr.time = newtime;
|
|
amr.transition = animation->track_get_key_transition(E->key().track, idx);
|
|
|
|
to_restore.push_back(amr);
|
|
}
|
|
|
|
// 3-move the keys (re insert them)
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float newpos = snap_time(E->get().pos + motion);
|
|
/*
|
|
if (newpos<0)
|
|
continue; //no add at the beginning
|
|
*/
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", E->key().track, newpos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
|
|
}
|
|
|
|
// 4-(undo) remove inserted keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float newpos = snap_time(E->get().pos + motion);
|
|
/*
|
|
if (newpos<0)
|
|
continue; //no remove what no inserted
|
|
*/
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newpos);
|
|
}
|
|
|
|
// 5-(undo) reinsert keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->key().track, E->get().pos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
|
|
}
|
|
|
|
// 6-(undo) reinsert overlapped keys
|
|
for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) {
|
|
|
|
_AnimMoveRestore &amr = E->get();
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition);
|
|
}
|
|
|
|
undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
|
|
undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);
|
|
|
|
// 7-reselect
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float oldpos = E->get().pos;
|
|
float newpos = snap_time(oldpos + motion);
|
|
//if (newpos>=0)
|
|
undo_redo->add_do_method(this, "_select_at_anim", animation, E->key().track, newpos);
|
|
undo_redo->add_undo_method(this, "_select_at_anim", animation, E->key().track, oldpos);
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
moving_selection = false;
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
|
|
_update_key_edit();
|
|
}
|
|
void AnimationTrackEditor::_move_selection_cancel() {
|
|
|
|
moving_selection = false;
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
}
|
|
|
|
bool AnimationTrackEditor::is_moving_selection() const {
|
|
return moving_selection;
|
|
}
|
|
float AnimationTrackEditor::get_moving_selection_offset() const {
|
|
return moving_selection_offset;
|
|
}
|
|
|
|
void AnimationTrackEditor::_box_selection_draw() {
|
|
|
|
Color color = get_color("accent_color", "Editor");
|
|
color.a = 0.2;
|
|
Rect2 rect = Rect2(Point2(), box_selection->get_size());
|
|
box_selection->draw_rect(rect, color);
|
|
}
|
|
|
|
void AnimationTrackEditor::_scroll_input(const Ref<InputEvent> &p_event) {
|
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
|
|
|
if (mb.is_valid() && mb->is_pressed() && mb->get_command() && mb->get_button_index() == BUTTON_WHEEL_DOWN) {
|
|
|
|
timeline->get_zoom()->set_value(timeline->get_zoom()->get_value() * 1.05);
|
|
scroll->accept_event();
|
|
}
|
|
|
|
if (mb.is_valid() && mb->is_pressed() && mb->get_command() && mb->get_button_index() == BUTTON_WHEEL_UP) {
|
|
|
|
timeline->get_zoom()->set_value(timeline->get_zoom()->get_value() / 1.05);
|
|
scroll->accept_event();
|
|
}
|
|
|
|
if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT) {
|
|
if (mb->is_pressed()) {
|
|
box_selecting = true;
|
|
box_selecting_from = scroll->get_global_transform().xform(mb->get_position());
|
|
box_select_rect = Rect2();
|
|
} else if (box_selecting) {
|
|
|
|
if (box_selection->is_visible_in_tree()) {
|
|
//only if moved
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
|
|
Rect2 local_rect = box_select_rect;
|
|
local_rect.position -= track_edits[i]->get_global_position();
|
|
track_edits[i]->append_to_selection(local_rect);
|
|
}
|
|
|
|
if (_get_track_selected() == -1 && track_edits.size() > 0) { //minimal hack to make shortcuts work
|
|
track_edits[track_edits.size() - 1]->grab_focus();
|
|
}
|
|
} else {
|
|
_clear_selection(); //clear it
|
|
}
|
|
|
|
box_selection->hide();
|
|
box_selecting = false;
|
|
}
|
|
}
|
|
|
|
Ref<InputEventMouseMotion> mm = p_event;
|
|
|
|
if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_MIDDLE) {
|
|
|
|
timeline->set_value(timeline->get_value() - mm->get_relative().x / timeline->get_zoom_scale());
|
|
}
|
|
|
|
if (mm.is_valid() && box_selecting) {
|
|
|
|
if (!(mm->get_button_mask() & BUTTON_MASK_LEFT)) {
|
|
//no longer
|
|
box_selection->hide();
|
|
box_selecting = false;
|
|
return;
|
|
}
|
|
|
|
if (!box_selection->is_visible_in_tree()) {
|
|
if (!mm->get_shift()) {
|
|
_clear_selection(); //only append if shift is pressed
|
|
}
|
|
box_selection->show();
|
|
}
|
|
|
|
Vector2 from = box_selecting_from;
|
|
Vector2 to = scroll->get_global_transform().xform(mm->get_position());
|
|
|
|
if (from.x > to.x) {
|
|
SWAP(from.x, to.x);
|
|
}
|
|
|
|
if (from.y > to.y) {
|
|
SWAP(from.y, to.y);
|
|
}
|
|
|
|
Rect2 rect(from, to - from);
|
|
Rect2 scroll_rect = Rect2(scroll->get_global_position(), scroll->get_size());
|
|
rect = scroll_rect.clip(rect);
|
|
box_selection->set_position(rect.position);
|
|
box_selection->set_size(rect.size);
|
|
|
|
box_select_rect = rect;
|
|
|
|
if (get_local_mouse_position().y < 0) {
|
|
//avoid box selection from going up and lose focus to viewport
|
|
warp_mouse(Vector2(mm->get_position().x, 0));
|
|
}
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_cancel_bezier_edit() {
|
|
bezier_edit->hide();
|
|
scroll->show();
|
|
}
|
|
|
|
void AnimationTrackEditor::_bezier_edit(int p_for_track) {
|
|
|
|
_clear_selection(); //bezier probably wants to use a separate selection mode
|
|
bezier_edit->set_root(root);
|
|
bezier_edit->set_animation_and_track(animation, p_for_track);
|
|
scroll->hide();
|
|
bezier_edit->show();
|
|
//search everything within the track and curve- edit it
|
|
}
|
|
|
|
void AnimationTrackEditor::_anim_duplicate_keys(bool transpose) {
|
|
//duplicait!
|
|
if (selection.size() && animation.is_valid() && (!transpose || (_get_track_selected() >= 0 && _get_track_selected() < animation->get_track_count()))) {
|
|
|
|
int top_track = 0x7FFFFFFF;
|
|
float top_time = 1e10;
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
const SelectedKey &sk = E->key();
|
|
|
|
float t = animation->track_get_key_time(sk.track, sk.key);
|
|
if (t < top_time)
|
|
top_time = t;
|
|
if (sk.track < top_track)
|
|
top_track = sk.track;
|
|
}
|
|
ERR_FAIL_COND(top_track == 0x7FFFFFFF || top_time == 1e10);
|
|
|
|
//
|
|
|
|
int start_track = transpose ? _get_track_selected() : top_track;
|
|
|
|
undo_redo->create_action(TTR("Anim Duplicate Keys"));
|
|
|
|
List<Pair<int, float> > new_selection_values;
|
|
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
const SelectedKey &sk = E->key();
|
|
|
|
float t = animation->track_get_key_time(sk.track, sk.key);
|
|
|
|
float dst_time = t + (timeline->get_play_position() - top_time);
|
|
int dst_track = sk.track + (start_track - top_track);
|
|
|
|
if (dst_track < 0 || dst_track >= animation->get_track_count())
|
|
continue;
|
|
|
|
if (animation->track_get_type(dst_track) != animation->track_get_type(sk.track))
|
|
continue;
|
|
|
|
int existing_idx = animation->track_find_key(dst_track, dst_time, true);
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", dst_track, dst_time, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", dst_track, dst_time);
|
|
|
|
Pair<int, float> p;
|
|
p.first = dst_track;
|
|
p.second = dst_time;
|
|
new_selection_values.push_back(p);
|
|
|
|
if (existing_idx != -1) {
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", dst_track, dst_time, animation->track_get_key_value(dst_track, existing_idx), animation->track_get_key_transition(dst_track, existing_idx));
|
|
}
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
//reselect duplicated
|
|
|
|
Map<SelectedKey, KeyInfo> new_selection;
|
|
for (List<Pair<int, float> >::Element *E = new_selection_values.front(); E; E = E->next()) {
|
|
|
|
int track = E->get().first;
|
|
float time = E->get().second;
|
|
|
|
int existing_idx = animation->track_find_key(track, time, true);
|
|
|
|
if (existing_idx == -1)
|
|
continue;
|
|
SelectedKey sk2;
|
|
sk2.track = track;
|
|
sk2.key = existing_idx;
|
|
|
|
KeyInfo ki;
|
|
ki.pos = time;
|
|
|
|
new_selection[sk2] = ki;
|
|
}
|
|
|
|
selection = new_selection;
|
|
_update_tracks();
|
|
_update_key_edit();
|
|
}
|
|
}
|
|
void AnimationTrackEditor::_edit_menu_pressed(int p_option) {
|
|
|
|
last_menu_track_opt = p_option;
|
|
switch (p_option) {
|
|
case EDIT_COPY_TRACKS: {
|
|
track_copy_select->clear();
|
|
TreeItem *troot = track_copy_select->create_item();
|
|
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
NodePath path = animation->track_get_path(i);
|
|
Node *node = NULL;
|
|
|
|
if (root && root->has_node(path)) {
|
|
node = root->get_node(path);
|
|
}
|
|
|
|
String text;
|
|
Ref<Texture> icon = get_icon("Node", "EditorIcons");
|
|
if (node) {
|
|
if (has_icon(node->get_class(), "EditorIcons")) {
|
|
icon = get_icon(node->get_class(), "EditorIcons");
|
|
}
|
|
|
|
text = node->get_name();
|
|
Vector<StringName> sn = path.get_subnames();
|
|
for (int j = 0; j < sn.size(); j++) {
|
|
text += ".";
|
|
text += sn[j];
|
|
}
|
|
|
|
path = NodePath(node->get_path().get_names(), path.get_subnames(), true); //store full path instead for copying
|
|
} else {
|
|
text = path;
|
|
int sep = text.find(":");
|
|
if (sep != -1) {
|
|
text = text.substr(sep + 1, text.length());
|
|
}
|
|
}
|
|
|
|
switch (animation->track_get_type(i)) {
|
|
case Animation::TYPE_TRANSFORM: text += " (Transform)"; break;
|
|
case Animation::TYPE_METHOD: text += " (Methods)"; break;
|
|
case Animation::TYPE_BEZIER: text += " (Bezier)"; break;
|
|
case Animation::TYPE_AUDIO: text += " (Audio)"; break;
|
|
default: {
|
|
};
|
|
}
|
|
|
|
TreeItem *it = track_copy_select->create_item(troot);
|
|
it->set_editable(0, true);
|
|
it->set_selectable(0, true);
|
|
it->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
|
|
it->set_icon(0, icon);
|
|
it->set_text(0, text);
|
|
Dictionary md;
|
|
md["track_idx"] = i;
|
|
md["path"] = path;
|
|
it->set_metadata(0, md);
|
|
}
|
|
|
|
track_copy_dialog->popup_centered_minsize(Size2(300, 500) * EDSCALE);
|
|
} break;
|
|
case EDIT_COPY_TRACKS_CONFIRM: {
|
|
|
|
track_clipboard.clear();
|
|
TreeItem *root = track_copy_select->get_root();
|
|
if (root) {
|
|
|
|
TreeItem *it = root->get_children();
|
|
while (it) {
|
|
Dictionary md = it->get_metadata(0);
|
|
int idx = md["track_idx"];
|
|
if (it->is_checked(0) && idx >= 0 && idx < animation->get_track_count()) {
|
|
TrackClipboard tc;
|
|
tc.base_path = animation->track_get_path(idx);
|
|
tc.full_path = md["path"];
|
|
tc.track_type = animation->track_get_type(idx);
|
|
tc.interp_type = animation->track_get_interpolation_type(idx);
|
|
if (tc.track_type == Animation::TYPE_VALUE) {
|
|
tc.update_mode = animation->value_track_get_update_mode(idx);
|
|
}
|
|
tc.loop_wrap = animation->track_get_interpolation_loop_wrap(idx);
|
|
tc.enabled = animation->track_is_enabled(idx);
|
|
for (int i = 0; i < animation->track_get_key_count(idx); i++) {
|
|
TrackClipboard::Key k;
|
|
k.time = animation->track_get_key_time(idx, i);
|
|
k.value = animation->track_get_key_value(idx, i);
|
|
k.transition = animation->track_get_key_transition(idx, i);
|
|
tc.keys.push_back(k);
|
|
}
|
|
track_clipboard.push_back(tc);
|
|
}
|
|
it = it->get_next();
|
|
}
|
|
}
|
|
} break;
|
|
case EDIT_PASTE_TRACKS: {
|
|
|
|
if (track_clipboard.size() == 0) {
|
|
EditorNode::get_singleton()->show_warning(TTR("Clipboard is empty"));
|
|
break;
|
|
}
|
|
|
|
int base_track = animation->get_track_count();
|
|
undo_redo->create_action(TTR("Paste Tracks"));
|
|
for (int i = 0; i < track_clipboard.size(); i++) {
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", track_clipboard[i].track_type);
|
|
Node *exists = NULL;
|
|
NodePath path = track_clipboard[i].base_path;
|
|
|
|
if (root) {
|
|
NodePath np = track_clipboard[i].full_path;
|
|
exists = root->get_node(np);
|
|
if (exists) {
|
|
path = NodePath(root->get_path_to(exists).get_names(), track_clipboard[i].full_path.get_subnames(), false);
|
|
}
|
|
}
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", base_track, path);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_type", base_track, track_clipboard[i].interp_type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_loop_wrap", base_track, track_clipboard[i].loop_wrap);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_enabled", base_track, track_clipboard[i].enabled);
|
|
if (track_clipboard[i].track_type == Animation::TYPE_VALUE) {
|
|
undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", base_track, track_clipboard[i].update_mode);
|
|
}
|
|
|
|
for (int j = 0; j < track_clipboard[i].keys.size(); j++) {
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", base_track, track_clipboard[i].keys[j].time, track_clipboard[i].keys[j].value, track_clipboard[i].keys[j].transition);
|
|
}
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
|
|
|
|
base_track++;
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
} break;
|
|
|
|
case EDIT_SCALE_SELECTION:
|
|
case EDIT_SCALE_FROM_CURSOR: {
|
|
scale_dialog->popup_centered(Size2(200, 100) * EDSCALE);
|
|
} break;
|
|
case EDIT_SCALE_CONFIRM: {
|
|
if (selection.empty())
|
|
return;
|
|
|
|
float from_t = 1e20;
|
|
float to_t = -1e20;
|
|
float len = -1e20;
|
|
float pivot = 0;
|
|
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.front(); E; E = E->next()) {
|
|
float t = animation->track_get_key_time(E->key().track, E->key().key);
|
|
if (t < from_t)
|
|
from_t = t;
|
|
if (t > to_t)
|
|
to_t = t;
|
|
}
|
|
|
|
len = to_t - from_t;
|
|
if (last_menu_track_opt == EDIT_SCALE_FROM_CURSOR) {
|
|
pivot = timeline->get_play_position();
|
|
|
|
} else {
|
|
|
|
pivot = from_t;
|
|
}
|
|
|
|
float s = scale->get_value();
|
|
if (s == 0) {
|
|
ERR_PRINT("Can't scale to 0");
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Anim Scale Keys"));
|
|
|
|
List<_AnimMoveRestore> to_restore;
|
|
|
|
// 1-remove the keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key);
|
|
}
|
|
// 2- remove overlapped keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float newtime = (E->get().pos - from_t) * s + from_t;
|
|
int idx = animation->track_find_key(E->key().track, newtime, true);
|
|
if (idx == -1)
|
|
continue;
|
|
SelectedKey sk;
|
|
sk.key = idx;
|
|
sk.track = E->key().track;
|
|
if (selection.has(sk))
|
|
continue; //already in selection, don't save
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newtime);
|
|
_AnimMoveRestore amr;
|
|
|
|
amr.key = animation->track_get_key_value(E->key().track, idx);
|
|
amr.track = E->key().track;
|
|
amr.time = newtime;
|
|
amr.transition = animation->track_get_key_transition(E->key().track, idx);
|
|
|
|
to_restore.push_back(amr);
|
|
}
|
|
|
|
#define _NEW_POS(m_ofs) (((s > 0) ? m_ofs : from_t + (len - (m_ofs - from_t))) - pivot) * ABS(s) + from_t
|
|
// 3-move the keys (re insert them)
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float newpos = _NEW_POS(E->get().pos);
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", E->key().track, newpos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
|
|
}
|
|
|
|
// 4-(undo) remove inserted keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float newpos = _NEW_POS(E->get().pos);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newpos);
|
|
}
|
|
|
|
// 5-(undo) reinsert keys
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->key().track, E->get().pos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
|
|
}
|
|
|
|
// 6-(undo) reinsert overlapped keys
|
|
for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) {
|
|
|
|
_AnimMoveRestore &amr = E->get();
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition);
|
|
}
|
|
|
|
undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
|
|
undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);
|
|
|
|
// 7-reselect
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
float oldpos = E->get().pos;
|
|
float newpos = _NEW_POS(oldpos);
|
|
if (newpos >= 0)
|
|
undo_redo->add_do_method(this, "_select_at_anim", animation, E->key().track, newpos);
|
|
undo_redo->add_undo_method(this, "_select_at_anim", animation, E->key().track, oldpos);
|
|
}
|
|
#undef _NEW_POS
|
|
undo_redo->commit_action();
|
|
} break;
|
|
case EDIT_DUPLICATE_SELECTION: {
|
|
|
|
if (bezier_edit->is_visible()) {
|
|
bezier_edit->duplicate_selection();
|
|
break;
|
|
}
|
|
_anim_duplicate_keys(false);
|
|
} break;
|
|
case EDIT_DUPLICATE_TRANSPOSED: {
|
|
if (bezier_edit->is_visible()) {
|
|
EditorNode::get_singleton()->show_warning(TTR("This option does not work for Bezier editing, as it's only a single track."));
|
|
break;
|
|
}
|
|
_anim_duplicate_keys(true);
|
|
} break;
|
|
case EDIT_DELETE_SELECTION: {
|
|
|
|
if (bezier_edit->is_visible()) {
|
|
bezier_edit->delete_selection();
|
|
break;
|
|
}
|
|
|
|
if (selection.size()) {
|
|
undo_redo->create_action(TTR("Anim Delete Keys"));
|
|
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->key().track, E->get().pos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
|
|
}
|
|
undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
|
|
undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);
|
|
undo_redo->commit_action();
|
|
//selection.clear();
|
|
_update_key_edit();
|
|
}
|
|
} break;
|
|
case EDIT_GOTO_NEXT_STEP: {
|
|
|
|
if (animation.is_null())
|
|
break;
|
|
float step = animation->get_step();
|
|
if (step == 0)
|
|
step = 1;
|
|
|
|
float pos = timeline->get_play_position();
|
|
|
|
pos = Math::stepify(pos + step, step);
|
|
if (pos > animation->get_length())
|
|
pos = animation->get_length();
|
|
set_anim_pos(pos);
|
|
|
|
emit_signal("timeline_changed", pos, true);
|
|
|
|
} break;
|
|
case EDIT_GOTO_PREV_STEP: {
|
|
if (animation.is_null())
|
|
break;
|
|
float step = animation->get_step();
|
|
if (step == 0)
|
|
step = 1;
|
|
|
|
float pos = timeline->get_play_position();
|
|
pos = Math::stepify(pos - step, step);
|
|
if (pos < 0)
|
|
pos = 0;
|
|
set_anim_pos(pos);
|
|
emit_signal("timeline_changed", pos, true);
|
|
|
|
} break;
|
|
case EDIT_OPTIMIZE_ANIMATION: {
|
|
optimize_dialog->popup_centered(Size2(250, 180) * EDSCALE);
|
|
|
|
} break;
|
|
case EDIT_OPTIMIZE_ANIMATION_CONFIRM: {
|
|
animation->optimize(optimize_linear_error->get_value(), optimize_angular_error->get_value(), optimize_max_angle->get_value());
|
|
_update_tracks();
|
|
undo_redo->clear_history();
|
|
|
|
} break;
|
|
case EDIT_CLEAN_UP_ANIMATION: {
|
|
cleanup_dialog->popup_centered_minsize(Size2(300, 0) * EDSCALE);
|
|
|
|
} break;
|
|
case EDIT_CLEAN_UP_ANIMATION_CONFIRM: {
|
|
if (cleanup_all->is_pressed()) {
|
|
List<StringName> names;
|
|
AnimationPlayerEditor::singleton->get_player()->get_animation_list(&names);
|
|
for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
|
|
_cleanup_animation(AnimationPlayerEditor::singleton->get_player()->get_animation(E->get()));
|
|
}
|
|
} else {
|
|
_cleanup_animation(animation);
|
|
}
|
|
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationTrackEditor::_cleanup_animation(Ref<Animation> p_animation) {
|
|
|
|
for (int i = 0; i < p_animation->get_track_count(); i++) {
|
|
|
|
bool prop_exists = false;
|
|
Variant::Type valid_type = Variant::NIL;
|
|
Object *obj = NULL;
|
|
|
|
RES res;
|
|
Vector<StringName> leftover_path;
|
|
|
|
Node *node = root->get_node_and_resource(p_animation->track_get_path(i), res, leftover_path);
|
|
|
|
if (res.is_valid()) {
|
|
obj = res.ptr();
|
|
} else if (node) {
|
|
obj = node;
|
|
}
|
|
|
|
if (obj && p_animation->track_get_type(i) == Animation::TYPE_VALUE) {
|
|
valid_type = obj->get_static_property_type_indexed(leftover_path, &prop_exists);
|
|
}
|
|
|
|
if (!obj && cleanup_tracks->is_pressed()) {
|
|
|
|
p_animation->remove_track(i);
|
|
i--;
|
|
continue;
|
|
}
|
|
|
|
if (!prop_exists || p_animation->track_get_type(i) != Animation::TYPE_VALUE || cleanup_keys->is_pressed() == false)
|
|
continue;
|
|
|
|
for (int j = 0; j < p_animation->track_get_key_count(i); j++) {
|
|
|
|
Variant v = p_animation->track_get_key_value(i, j);
|
|
|
|
if (!Variant::can_convert(v.get_type(), valid_type)) {
|
|
p_animation->track_remove_key(i, j);
|
|
j--;
|
|
}
|
|
}
|
|
|
|
if (p_animation->track_get_key_count(i) == 0 && cleanup_tracks->is_pressed()) {
|
|
p_animation->remove_track(i);
|
|
i--;
|
|
}
|
|
}
|
|
|
|
undo_redo->clear_history();
|
|
_update_tracks();
|
|
}
|
|
|
|
void AnimationTrackEditor::_view_group_toggle() {
|
|
_update_tracks();
|
|
view_group->set_icon(get_icon(view_group->is_pressed() ? "AnimationTrackList" : "AnimationTrackGroup", "EditorIcons"));
|
|
}
|
|
|
|
void AnimationTrackEditor::_selection_changed() {
|
|
|
|
if (selected_filter->is_pressed()) {
|
|
_update_tracks(); //needs updatin
|
|
} else {
|
|
for (int i = 0; i < track_edits.size(); i++) {
|
|
track_edits[i]->update();
|
|
}
|
|
|
|
for (int i = 0; i < groups.size(); i++) {
|
|
groups[i]->update();
|
|
}
|
|
}
|
|
}
|
|
|
|
float AnimationTrackEditor::snap_time(float p_value) {
|
|
|
|
if (snap->is_pressed()) {
|
|
p_value = Math::stepify(p_value, step->get_value());
|
|
}
|
|
|
|
return p_value;
|
|
}
|
|
|
|
void AnimationTrackEditor::_bind_methods() {
|
|
|
|
ClassDB::bind_method("_animation_changed", &AnimationTrackEditor::_animation_changed);
|
|
ClassDB::bind_method("_animation_update", &AnimationTrackEditor::_animation_update);
|
|
ClassDB::bind_method("_timeline_changed", &AnimationTrackEditor::_timeline_changed);
|
|
ClassDB::bind_method("_track_remove_request", &AnimationTrackEditor::_track_remove_request);
|
|
ClassDB::bind_method("_name_limit_changed", &AnimationTrackEditor::_name_limit_changed);
|
|
ClassDB::bind_method("_update_scroll", &AnimationTrackEditor::_update_scroll);
|
|
ClassDB::bind_method("_update_tracks", &AnimationTrackEditor::_update_tracks);
|
|
ClassDB::bind_method("_update_step", &AnimationTrackEditor::_update_step);
|
|
ClassDB::bind_method("_update_length", &AnimationTrackEditor::_update_length);
|
|
ClassDB::bind_method("_dropped_track", &AnimationTrackEditor::_dropped_track);
|
|
ClassDB::bind_method("_add_track", &AnimationTrackEditor::_add_track);
|
|
ClassDB::bind_method("_new_track_node_selected", &AnimationTrackEditor::_new_track_node_selected);
|
|
ClassDB::bind_method("_new_track_property_selected", &AnimationTrackEditor::_new_track_property_selected);
|
|
ClassDB::bind_method("_root_removed", &AnimationTrackEditor::_root_removed);
|
|
ClassDB::bind_method("_confirm_insert_list", &AnimationTrackEditor::_confirm_insert_list);
|
|
ClassDB::bind_method("_insert_delay", &AnimationTrackEditor::_insert_delay);
|
|
ClassDB::bind_method("_timeline_value_changed", &AnimationTrackEditor::_timeline_value_changed);
|
|
ClassDB::bind_method("_insert_key_from_track", &AnimationTrackEditor::_insert_key_from_track);
|
|
ClassDB::bind_method("_add_method_key", &AnimationTrackEditor::_add_method_key);
|
|
ClassDB::bind_method("_key_selected", &AnimationTrackEditor::_key_selected);
|
|
ClassDB::bind_method("_key_deselected", &AnimationTrackEditor::_key_deselected);
|
|
ClassDB::bind_method("_clear_selection", &AnimationTrackEditor::_clear_selection);
|
|
ClassDB::bind_method("_move_selection_begin", &AnimationTrackEditor::_move_selection_begin);
|
|
ClassDB::bind_method("_move_selection", &AnimationTrackEditor::_move_selection);
|
|
ClassDB::bind_method("_move_selection_commit", &AnimationTrackEditor::_move_selection_commit);
|
|
ClassDB::bind_method("_move_selection_cancel", &AnimationTrackEditor::_move_selection_cancel);
|
|
ClassDB::bind_method("_clear_selection_for_anim", &AnimationTrackEditor::_clear_selection_for_anim);
|
|
ClassDB::bind_method("_select_at_anim", &AnimationTrackEditor::_select_at_anim);
|
|
ClassDB::bind_method("_scroll_input", &AnimationTrackEditor::_scroll_input);
|
|
ClassDB::bind_method("_box_selection_draw", &AnimationTrackEditor::_box_selection_draw);
|
|
ClassDB::bind_method("_bezier_edit", &AnimationTrackEditor::_bezier_edit);
|
|
ClassDB::bind_method("_cancel_bezier_edit", &AnimationTrackEditor::_cancel_bezier_edit);
|
|
ClassDB::bind_method("_edit_menu_pressed", &AnimationTrackEditor::_edit_menu_pressed);
|
|
ClassDB::bind_method("_view_group_toggle", &AnimationTrackEditor::_view_group_toggle);
|
|
ClassDB::bind_method("_selection_changed", &AnimationTrackEditor::_selection_changed);
|
|
ClassDB::bind_method("_snap_mode_changed", &AnimationTrackEditor::_snap_mode_changed);
|
|
|
|
ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::REAL, "position"), PropertyInfo(Variant::BOOL, "drag")));
|
|
ADD_SIGNAL(MethodInfo("keying_changed"));
|
|
ADD_SIGNAL(MethodInfo("animation_len_changed", PropertyInfo(Variant::REAL, "len")));
|
|
ADD_SIGNAL(MethodInfo("animation_step_changed", PropertyInfo(Variant::REAL, "step")));
|
|
}
|
|
|
|
AnimationTrackEditor::AnimationTrackEditor() {
|
|
root = NULL;
|
|
|
|
undo_redo = EditorNode::get_singleton()->get_undo_redo();
|
|
|
|
main_panel = memnew(PanelContainer);
|
|
add_child(main_panel);
|
|
main_panel->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
HBoxContainer *timeline_scroll = memnew(HBoxContainer);
|
|
main_panel->add_child(timeline_scroll);
|
|
timeline_scroll->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
VBoxContainer *timeline_vbox = memnew(VBoxContainer);
|
|
timeline_scroll->add_child(timeline_vbox);
|
|
timeline_vbox->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
timeline_vbox->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
timeline_vbox->add_constant_override("separation", 0);
|
|
|
|
timeline = memnew(AnimationTimelineEdit);
|
|
timeline->set_undo_redo(undo_redo);
|
|
timeline_vbox->add_child(timeline);
|
|
timeline->connect("timeline_changed", this, "_timeline_changed");
|
|
timeline->connect("name_limit_changed", this, "_name_limit_changed");
|
|
timeline->connect("track_added", this, "_add_track");
|
|
timeline->connect("value_changed", this, "_timeline_value_changed");
|
|
timeline->connect("length_changed", this, "_update_length");
|
|
|
|
scroll = memnew(ScrollContainer);
|
|
timeline_vbox->add_child(scroll);
|
|
scroll->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
VScrollBar *sb = scroll->get_v_scrollbar();
|
|
scroll->remove_child(sb);
|
|
timeline_scroll->add_child(sb); //move here so timeline and tracks are always aligned
|
|
scroll->connect("gui_input", this, "_scroll_input");
|
|
|
|
bezier_edit = memnew(AnimationBezierTrackEdit);
|
|
timeline_vbox->add_child(bezier_edit);
|
|
bezier_edit->set_undo_redo(undo_redo);
|
|
bezier_edit->set_editor(this);
|
|
bezier_edit->set_timeline(timeline);
|
|
bezier_edit->hide();
|
|
bezier_edit->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
bezier_edit->connect("close_request", this, "_cancel_bezier_edit");
|
|
|
|
timeline_vbox->set_custom_minimum_size(Size2(0, 150) * EDSCALE);
|
|
|
|
hscroll = memnew(HScrollBar);
|
|
hscroll->share(timeline);
|
|
hscroll->hide();
|
|
hscroll->connect("value_changed", this, "_update_scroll");
|
|
timeline_vbox->add_child(hscroll);
|
|
timeline->set_hscroll(hscroll);
|
|
|
|
track_vbox = memnew(VBoxContainer);
|
|
scroll->add_child(track_vbox);
|
|
track_vbox->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
scroll->set_enable_h_scroll(false);
|
|
scroll->set_enable_v_scroll(true);
|
|
track_vbox->add_constant_override("separation", 0);
|
|
|
|
//timeline_vbox->add_child(memnew(HSeparator));
|
|
HBoxContainer *bottom_hb = memnew(HBoxContainer);
|
|
add_child(bottom_hb);
|
|
bottom_hb->add_spacer();
|
|
|
|
selected_filter = memnew(ToolButton);
|
|
selected_filter->connect("pressed", this, "_view_group_toggle"); //same function works the same
|
|
selected_filter->set_toggle_mode(true);
|
|
selected_filter->set_tooltip(TTR("Only show tracks from nodes selected in tree."));
|
|
|
|
bottom_hb->add_child(selected_filter);
|
|
|
|
view_group = memnew(ToolButton);
|
|
view_group->connect("pressed", this, "_view_group_toggle");
|
|
view_group->set_toggle_mode(true);
|
|
view_group->set_tooltip(TTR("Group tracks by node or display them as plain list."));
|
|
|
|
bottom_hb->add_child(view_group);
|
|
bottom_hb->add_child(memnew(VSeparator));
|
|
|
|
snap = memnew(ToolButton);
|
|
snap->set_text(TTR("Snap: "));
|
|
bottom_hb->add_child(snap);
|
|
snap->set_disabled(true);
|
|
snap->set_toggle_mode(true);
|
|
snap->set_pressed(true);
|
|
|
|
step = memnew(EditorSpinSlider);
|
|
step->set_min(0);
|
|
step->set_max(1000000);
|
|
step->set_step(0.01);
|
|
step->set_hide_slider(true);
|
|
step->set_custom_minimum_size(Size2(100, 0) * EDSCALE);
|
|
step->set_tooltip(TTR("Animation step value."));
|
|
bottom_hb->add_child(step);
|
|
step->connect("value_changed", this, "_update_step");
|
|
step->set_read_only(true);
|
|
|
|
snap_mode = memnew(OptionButton);
|
|
snap_mode->add_item(TTR("Seconds"));
|
|
snap_mode->add_item(TTR("FPS"));
|
|
bottom_hb->add_child(snap_mode);
|
|
snap_mode->connect("item_selected", this, "_snap_mode_changed");
|
|
snap_mode->set_disabled(true);
|
|
|
|
bottom_hb->add_child(memnew(VSeparator));
|
|
|
|
zoom_icon = memnew(TextureRect);
|
|
zoom_icon->set_v_size_flags(SIZE_SHRINK_CENTER);
|
|
bottom_hb->add_child(zoom_icon);
|
|
zoom = memnew(HSlider);
|
|
zoom->set_step(0.01);
|
|
zoom->set_min(0.0);
|
|
zoom->set_max(2.0);
|
|
zoom->set_value(1.0);
|
|
zoom->set_custom_minimum_size(Size2(200, 0) * EDSCALE);
|
|
zoom->set_v_size_flags(SIZE_SHRINK_CENTER);
|
|
bottom_hb->add_child(zoom);
|
|
timeline->set_zoom(zoom);
|
|
|
|
edit = memnew(MenuButton);
|
|
edit->set_text(TTR("Edit"));
|
|
edit->set_flat(false);
|
|
edit->set_disabled(true);
|
|
edit->set_tooltip(TTR("Animation properties."));
|
|
edit->get_popup()->add_item(TTR("Copy Tracks"), EDIT_COPY_TRACKS);
|
|
edit->get_popup()->add_item(TTR("Paste Tracks"), EDIT_PASTE_TRACKS);
|
|
edit->get_popup()->add_separator();
|
|
edit->get_popup()->add_item(TTR("Scale Selection"), EDIT_SCALE_SELECTION);
|
|
edit->get_popup()->add_item(TTR("Scale From Cursor"), EDIT_SCALE_FROM_CURSOR);
|
|
edit->get_popup()->add_separator();
|
|
edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/duplicate_selection", TTR("Duplicate Selection"), KEY_MASK_CMD | KEY_D), EDIT_DUPLICATE_SELECTION);
|
|
edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/duplicate_selection_transposed", TTR("Duplicate Transposed"), KEY_MASK_SHIFT | KEY_MASK_CMD | KEY_D), EDIT_DUPLICATE_TRANSPOSED);
|
|
edit->get_popup()->set_item_shortcut_disabled(edit->get_popup()->get_item_index(EDIT_DUPLICATE_SELECTION), true);
|
|
edit->get_popup()->set_item_shortcut_disabled(edit->get_popup()->get_item_index(EDIT_DUPLICATE_TRANSPOSED), true);
|
|
edit->get_popup()->add_separator();
|
|
edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/delete_selection", TTR("Delete Selection"), KEY_DELETE), EDIT_DELETE_SELECTION);
|
|
edit->get_popup()->set_item_shortcut_disabled(edit->get_popup()->get_item_index(EDIT_DELETE_SELECTION), true);
|
|
//this shortcut will be checked from the track itself. so no need to enable it here (will conflict with scenetree dock)
|
|
|
|
edit->get_popup()->add_separator();
|
|
edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/goto_next_step", TTR("Go to Next Step"), KEY_MASK_CMD | KEY_RIGHT), EDIT_GOTO_NEXT_STEP);
|
|
edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/goto_prev_step", TTR("Go to Previous Step"), KEY_MASK_CMD | KEY_LEFT), EDIT_GOTO_PREV_STEP);
|
|
edit->get_popup()->add_separator();
|
|
edit->get_popup()->add_item(TTR("Optimize Animation"), EDIT_OPTIMIZE_ANIMATION);
|
|
edit->get_popup()->add_item(TTR("Clean-Up Animation"), EDIT_CLEAN_UP_ANIMATION);
|
|
|
|
edit->get_popup()->connect("id_pressed", this, "_edit_menu_pressed");
|
|
|
|
pick_track = memnew(SceneTreeDialog);
|
|
add_child(pick_track);
|
|
pick_track->set_title(TTR("Pick the node that will be animated:"));
|
|
pick_track->connect("selected", this, "_new_track_node_selected");
|
|
prop_selector = memnew(PropertySelector);
|
|
add_child(prop_selector);
|
|
prop_selector->connect("selected", this, "_new_track_property_selected");
|
|
|
|
method_selector = memnew(PropertySelector);
|
|
add_child(method_selector);
|
|
method_selector->connect("selected", this, "_add_method_key");
|
|
|
|
inserting = false;
|
|
insert_query = false;
|
|
insert_frame = 0;
|
|
insert_queue = false;
|
|
|
|
insert_confirm = memnew(ConfirmationDialog);
|
|
add_child(insert_confirm);
|
|
insert_confirm->connect("confirmed", this, "_confirm_insert_list");
|
|
VBoxContainer *icvb = memnew(VBoxContainer);
|
|
insert_confirm->add_child(icvb);
|
|
insert_confirm_text = memnew(Label);
|
|
icvb->add_child(insert_confirm_text);
|
|
insert_confirm_bezier = memnew(CheckBox);
|
|
insert_confirm_bezier->set_text(TTR("Use Bezier Curves"));
|
|
icvb->add_child(insert_confirm_bezier);
|
|
keying = false;
|
|
moving_selection = 0;
|
|
key_edit = NULL;
|
|
|
|
box_selection = memnew(Control);
|
|
add_child(box_selection);
|
|
box_selection->set_as_toplevel(true);
|
|
box_selection->set_mouse_filter(MOUSE_FILTER_IGNORE);
|
|
box_selection->hide();
|
|
box_selection->connect("draw", this, "_box_selection_draw");
|
|
box_selecting = false;
|
|
|
|
//default plugins
|
|
|
|
Ref<AnimationTrackEditDefaultPlugin> def_plugin;
|
|
def_plugin.instance();
|
|
add_track_edit_plugin(def_plugin);
|
|
|
|
//dialogs
|
|
|
|
optimize_dialog = memnew(ConfirmationDialog);
|
|
add_child(optimize_dialog);
|
|
optimize_dialog->set_title(TTR("Anim. Optimizer"));
|
|
VBoxContainer *optimize_vb = memnew(VBoxContainer);
|
|
optimize_dialog->add_child(optimize_vb);
|
|
|
|
optimize_linear_error = memnew(SpinBox);
|
|
optimize_linear_error->set_max(1.0);
|
|
optimize_linear_error->set_min(0.001);
|
|
optimize_linear_error->set_step(0.001);
|
|
optimize_linear_error->set_value(0.05);
|
|
optimize_vb->add_margin_child(TTR("Max. Linear Error:"), optimize_linear_error);
|
|
optimize_angular_error = memnew(SpinBox);
|
|
optimize_angular_error->set_max(1.0);
|
|
optimize_angular_error->set_min(0.001);
|
|
optimize_angular_error->set_step(0.001);
|
|
optimize_angular_error->set_value(0.01);
|
|
|
|
optimize_vb->add_margin_child(TTR("Max. Angular Error:"), optimize_angular_error);
|
|
optimize_max_angle = memnew(SpinBox);
|
|
optimize_vb->add_margin_child(TTR("Max Optimizable Angle:"), optimize_max_angle);
|
|
optimize_max_angle->set_max(360.0);
|
|
optimize_max_angle->set_min(0.0);
|
|
optimize_max_angle->set_step(0.1);
|
|
optimize_max_angle->set_value(22);
|
|
|
|
optimize_dialog->get_ok()->set_text(TTR("Optimize"));
|
|
optimize_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_CLEAN_UP_ANIMATION_CONFIRM));
|
|
|
|
//
|
|
|
|
cleanup_dialog = memnew(ConfirmationDialog);
|
|
add_child(cleanup_dialog);
|
|
VBoxContainer *cleanup_vb = memnew(VBoxContainer);
|
|
cleanup_dialog->add_child(cleanup_vb);
|
|
|
|
cleanup_keys = memnew(CheckButton);
|
|
cleanup_keys->set_text(TTR("Remove invalid keys"));
|
|
cleanup_keys->set_pressed(true);
|
|
cleanup_vb->add_child(cleanup_keys);
|
|
|
|
cleanup_tracks = memnew(CheckButton);
|
|
cleanup_tracks->set_text(TTR("Remove unresolved and empty tracks"));
|
|
cleanup_tracks->set_pressed(true);
|
|
cleanup_vb->add_child(cleanup_tracks);
|
|
|
|
cleanup_all = memnew(CheckButton);
|
|
cleanup_all->set_text(TTR("Clean-up all animations"));
|
|
cleanup_vb->add_child(cleanup_all);
|
|
|
|
cleanup_dialog->set_title(TTR("Clean-Up Animation(s) (NO UNDO!)"));
|
|
cleanup_dialog->get_ok()->set_text(TTR("Clean-Up"));
|
|
|
|
cleanup_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_CLEAN_UP_ANIMATION_CONFIRM));
|
|
|
|
//
|
|
scale_dialog = memnew(ConfirmationDialog);
|
|
VBoxContainer *vbc = memnew(VBoxContainer);
|
|
scale_dialog->add_child(vbc);
|
|
|
|
scale = memnew(SpinBox);
|
|
scale->set_min(-99999);
|
|
scale->set_max(99999);
|
|
scale->set_step(0.001);
|
|
vbc->add_margin_child(TTR("Scale Ratio:"), scale);
|
|
scale_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_SCALE_CONFIRM));
|
|
add_child(scale_dialog);
|
|
|
|
track_copy_dialog = memnew(ConfirmationDialog);
|
|
add_child(track_copy_dialog);
|
|
track_copy_dialog->set_title(TTR("Select tracks to copy:"));
|
|
track_copy_dialog->get_ok()->set_text(TTR("Copy"));
|
|
|
|
track_copy_select = memnew(Tree);
|
|
track_copy_select->set_hide_root(true);
|
|
track_copy_dialog->add_child(track_copy_select);
|
|
track_copy_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_COPY_TRACKS_CONFIRM));
|
|
animation_changing_awaiting_update = false;
|
|
}
|
|
|
|
AnimationTrackEditor::~AnimationTrackEditor() {
|
|
if (key_edit) {
|
|
memdelete(key_edit);
|
|
}
|
|
}
|