4124 lines
119 KiB
C++
4124 lines
119 KiB
C++
/*************************************************************************/
|
|
/* animation_editor.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2018 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_editor.h"
|
|
|
|
#include "editor/plugins/animation_player_editor_plugin.h"
|
|
#include "editor_node.h"
|
|
#include "editor_settings.h"
|
|
#include "io/resource_saver.h"
|
|
#include "os/keyboard.h"
|
|
#include "os/os.h"
|
|
#include "pair.h"
|
|
#include "scene/gui/separator.h"
|
|
#include "scene/main/viewport.h"
|
|
|
|
/* Missing to fix:
|
|
|
|
*Set
|
|
*Find better source for hint for edited value keys
|
|
* + button on track to add a key
|
|
* when clicked for first time, erase selection of not selected at first
|
|
* automatically create discrete/continuous tracks!!
|
|
*when create track do undo/redo
|
|
*/
|
|
|
|
class AnimationCurveEdit : public Control {
|
|
GDCLASS(AnimationCurveEdit, Control);
|
|
|
|
public:
|
|
enum Mode {
|
|
MODE_DISABLED,
|
|
MODE_SINGLE,
|
|
MODE_MULTIPLE
|
|
};
|
|
|
|
private:
|
|
Set<float> multiples;
|
|
float transition;
|
|
Mode mode;
|
|
|
|
LineEdit *value_edit;
|
|
|
|
void _notification(int p_what) {
|
|
|
|
if (p_what == NOTIFICATION_DRAW) {
|
|
|
|
RID ci = get_canvas_item();
|
|
|
|
Size2 s = get_size();
|
|
Rect2 r(Point2(), s);
|
|
|
|
//r=r.grow(3);
|
|
Ref<StyleBox> sb = get_stylebox("normal", "LineEdit");
|
|
sb->draw(ci, r);
|
|
r.size -= sb->get_minimum_size();
|
|
r.position += sb->get_offset();
|
|
//VisualServer::get_singleton()->canvas_item_add
|
|
|
|
Ref<Font> f = get_font("font", "Label");
|
|
r = r.grow(-2);
|
|
Color color = get_color("font_color", "Label");
|
|
|
|
int points = 48;
|
|
if (mode == MODE_MULTIPLE) {
|
|
|
|
Color mcolor = color;
|
|
mcolor.a *= 0.3;
|
|
|
|
Set<float>::Element *E = multiples.front();
|
|
for (int j = 0; j < 16; j++) {
|
|
|
|
if (!E)
|
|
break;
|
|
|
|
float prev = 1.0;
|
|
float exp = E->get();
|
|
bool flip = false; //hint_text=="attenuation";
|
|
|
|
for (int i = 1; i <= points; i++) {
|
|
|
|
float ifl = i / float(points);
|
|
float iflp = (i - 1) / float(points);
|
|
|
|
float h = 1.0 - Math::ease(ifl, exp);
|
|
|
|
if (flip) {
|
|
ifl = 1.0 - ifl;
|
|
iflp = 1.0 - iflp;
|
|
}
|
|
|
|
VisualServer::get_singleton()->canvas_item_add_line(ci, r.position + Point2(iflp * r.size.width, prev * r.size.height), r.position + Point2(ifl * r.size.width, h * r.size.height), mcolor);
|
|
prev = h;
|
|
}
|
|
|
|
E = E->next();
|
|
}
|
|
}
|
|
|
|
float exp = transition;
|
|
if (mode != MODE_DISABLED) {
|
|
|
|
float prev = 1.0;
|
|
|
|
bool flip = false; //hint_text=="attenuation";
|
|
|
|
for (int i = 1; i <= points; i++) {
|
|
|
|
float ifl = i / float(points);
|
|
float iflp = (i - 1) / float(points);
|
|
|
|
float h = 1.0 - Math::ease(ifl, exp);
|
|
|
|
if (flip) {
|
|
ifl = 1.0 - ifl;
|
|
iflp = 1.0 - iflp;
|
|
}
|
|
|
|
VisualServer::get_singleton()->canvas_item_add_line(ci, r.position + Point2(iflp * r.size.width, prev * r.size.height), r.position + Point2(ifl * r.size.width, h * r.size.height), color);
|
|
prev = h;
|
|
}
|
|
}
|
|
|
|
if (mode == MODE_DISABLED) {
|
|
f->draw(ci, Point2(5, 5 + f->get_ascent()), TTR("Disabled"), color);
|
|
} else if (mode == MODE_MULTIPLE) {
|
|
f->draw(ci, Point2(5, 5 + f->get_ascent() + value_edit->get_size().height), TTR("All Selection"), color);
|
|
}
|
|
}
|
|
}
|
|
|
|
void _gui_input(const Ref<InputEvent> &p_ev) {
|
|
|
|
Ref<InputEventMouseMotion> mm = p_ev;
|
|
if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_LEFT) {
|
|
|
|
if (mode == MODE_DISABLED)
|
|
return;
|
|
|
|
value_edit->release_focus();
|
|
|
|
float rel = mm->get_relative().x;
|
|
if (rel == 0)
|
|
return;
|
|
|
|
bool flip = false;
|
|
|
|
if (flip)
|
|
rel = -rel;
|
|
|
|
float val = transition;
|
|
if (val == 0)
|
|
return;
|
|
bool sg = val < 0;
|
|
val = Math::absf(val);
|
|
|
|
val = Math::log(val) / Math::log((float)2.0);
|
|
//logspace
|
|
val += rel * 0.05;
|
|
//
|
|
|
|
val = Math::pow((float)2.0, val);
|
|
if (sg)
|
|
val = -val;
|
|
|
|
force_transition(val);
|
|
}
|
|
}
|
|
|
|
void _edit_value_changed(const String &p_value_str) {
|
|
|
|
force_transition(p_value_str.to_float());
|
|
}
|
|
|
|
public:
|
|
static void _bind_methods() {
|
|
|
|
//ClassDB::bind_method("_update_obj",&AnimationKeyEdit::_update_obj);
|
|
ClassDB::bind_method("_gui_input", &AnimationCurveEdit::_gui_input);
|
|
ClassDB::bind_method("_edit_value_changed", &AnimationCurveEdit::_edit_value_changed);
|
|
ADD_SIGNAL(MethodInfo("transition_changed"));
|
|
}
|
|
|
|
void set_mode(Mode p_mode) {
|
|
|
|
mode = p_mode;
|
|
value_edit->set_visible(mode != MODE_DISABLED);
|
|
update();
|
|
}
|
|
|
|
void clear_multiples() {
|
|
multiples.clear();
|
|
update();
|
|
}
|
|
void set_multiple(float p_transition) {
|
|
|
|
multiples.insert(p_transition);
|
|
}
|
|
|
|
void set_transition(float p_transition) {
|
|
transition = Math::stepify(p_transition, 0.01);
|
|
value_edit->set_text(String::num(transition));
|
|
update();
|
|
}
|
|
|
|
float get_transition() const {
|
|
return transition;
|
|
}
|
|
|
|
void force_transition(float p_value) {
|
|
if (mode == MODE_DISABLED)
|
|
return;
|
|
set_transition(p_value);
|
|
emit_signal("transition_changed", p_value);
|
|
}
|
|
|
|
AnimationCurveEdit() {
|
|
|
|
transition = 1.0;
|
|
set_default_cursor_shape(CURSOR_HSPLIT);
|
|
mode = MODE_DISABLED;
|
|
|
|
value_edit = memnew(LineEdit);
|
|
value_edit->hide();
|
|
value_edit->connect("text_entered", this, "_edit_value_changed");
|
|
add_child(value_edit);
|
|
}
|
|
};
|
|
|
|
class AnimationKeyEdit : public Object {
|
|
|
|
GDCLASS(AnimationKeyEdit, Object);
|
|
|
|
public:
|
|
bool setting;
|
|
bool hidden;
|
|
|
|
static void _bind_methods() {
|
|
|
|
ClassDB::bind_method("_update_obj", &AnimationKeyEdit::_update_obj);
|
|
ClassDB::bind_method("_key_ofs_changed", &AnimationKeyEdit::_key_ofs_changed);
|
|
}
|
|
|
|
//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 (hidden)
|
|
return;
|
|
if (!(animation == p_anim))
|
|
return;
|
|
notify_change();
|
|
}
|
|
|
|
void _key_ofs_changed(const Ref<Animation> &p_anim, float from, float to) {
|
|
if (hidden)
|
|
return;
|
|
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") {
|
|
|
|
float new_time = p_value;
|
|
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);
|
|
float 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[idx] = Variant::construct(t, (const Variant **)ptrs, 1, err);
|
|
} else {
|
|
|
|
args[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[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;
|
|
}
|
|
|
|
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 == "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;
|
|
}
|
|
|
|
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);
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
if (animation->track_get_type(track)!=Animation::TYPE_METHOD)
|
|
p_list->push_back( PropertyInfo( Variant::REAL, "easing", PROPERTY_HINT_EXP_EASING));
|
|
*/
|
|
}
|
|
|
|
UndoRedo *undo_redo;
|
|
Ref<Animation> animation;
|
|
int track;
|
|
float key_ofs;
|
|
|
|
PropertyInfo hint;
|
|
NodePath base;
|
|
|
|
void notify_change() {
|
|
|
|
_change_notify();
|
|
}
|
|
|
|
AnimationKeyEdit() {
|
|
hidden = true;
|
|
key_ofs = 0;
|
|
track = -1;
|
|
setting = false;
|
|
}
|
|
};
|
|
|
|
void AnimationKeyEditor::_menu_add_track(int p_type) {
|
|
|
|
ERR_FAIL_COND(!animation.is_valid());
|
|
|
|
switch (p_type) {
|
|
|
|
case ADD_TRACK_MENU_ADD_CALL_TRACK: {
|
|
if (root) {
|
|
call_select->popup_centered_ratio();
|
|
break;
|
|
}
|
|
} break;
|
|
case ADD_TRACK_MENU_ADD_VALUE_TRACK:
|
|
case ADD_TRACK_MENU_ADD_TRANSFORM_TRACK: {
|
|
|
|
undo_redo->create_action(TTR("Anim Add Track"));
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", p_type);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), ".");
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_anim_duplicate_keys(bool transpose) {
|
|
//duplicait!
|
|
if (selection.size() && animation.is_valid() && selected_track >= 0 && selected_track < 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 ? selected_track : 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_pos - 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;
|
|
track_editor->update();
|
|
_edit_if_single_selection();
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_menu_track(int p_type) {
|
|
|
|
ERR_FAIL_COND(!animation.is_valid());
|
|
|
|
last_menu_track_opt = p_type;
|
|
switch (p_type) {
|
|
|
|
case TRACK_MENU_SCALE:
|
|
case TRACK_MENU_SCALE_PIVOT: {
|
|
|
|
scale_dialog->popup_centered(Size2(200, 100));
|
|
} break;
|
|
case TRACK_MENU_MOVE_UP: {
|
|
|
|
int idx = selected_track;
|
|
if (idx > 0 && idx < animation->get_track_count()) {
|
|
undo_redo->create_action(TTR("Move Anim Track Up"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_move_down", idx);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_move_up", idx - 1);
|
|
undo_redo->commit_action();
|
|
selected_track = idx - 1;
|
|
}
|
|
|
|
} break;
|
|
case TRACK_MENU_MOVE_DOWN: {
|
|
|
|
int idx = selected_track;
|
|
if (idx >= 0 && idx < animation->get_track_count() - 1) {
|
|
undo_redo->create_action(TTR("Move Anim Track Down"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_move_up", idx);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_move_down", idx + 1);
|
|
undo_redo->commit_action();
|
|
selected_track = idx + 1;
|
|
}
|
|
|
|
} break;
|
|
case TRACK_MENU_REMOVE: {
|
|
|
|
int idx = selected_track;
|
|
if (idx >= 0 && idx < animation->get_track_count()) {
|
|
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();
|
|
}
|
|
|
|
} break;
|
|
case TRACK_MENU_DUPLICATE:
|
|
case TRACK_MENU_DUPLICATE_TRANSPOSE: {
|
|
|
|
_anim_duplicate_keys(p_type == TRACK_MENU_DUPLICATE_TRANSPOSE);
|
|
} break;
|
|
case TRACK_MENU_SET_ALL_TRANS_LINEAR:
|
|
case TRACK_MENU_SET_ALL_TRANS_CONSTANT:
|
|
case TRACK_MENU_SET_ALL_TRANS_OUT:
|
|
case TRACK_MENU_SET_ALL_TRANS_IN:
|
|
case TRACK_MENU_SET_ALL_TRANS_INOUT:
|
|
case TRACK_MENU_SET_ALL_TRANS_OUTIN: {
|
|
|
|
if (!selection.size() || !animation.is_valid())
|
|
break;
|
|
|
|
float t = 0;
|
|
switch (p_type) {
|
|
case TRACK_MENU_SET_ALL_TRANS_LINEAR: t = 1.0; break;
|
|
case TRACK_MENU_SET_ALL_TRANS_CONSTANT: t = 0.0; break;
|
|
case TRACK_MENU_SET_ALL_TRANS_OUT: t = 0.5; break;
|
|
case TRACK_MENU_SET_ALL_TRANS_IN: t = 2.0; break;
|
|
case TRACK_MENU_SET_ALL_TRANS_INOUT: t = -0.5; break;
|
|
case TRACK_MENU_SET_ALL_TRANS_OUTIN: t = -2.0; break;
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Set Transitions to:") + " " + rtos(t));
|
|
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
const SelectedKey &sk = E->key();
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_key_transition", sk.track, sk.key, t);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_key_transition", sk.track, sk.key, animation->track_get_key_transition(sk.track, sk.key));
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
} break;
|
|
case TRACK_MENU_NEXT_STEP: {
|
|
|
|
if (animation.is_null())
|
|
break;
|
|
float step = animation->get_step();
|
|
if (step == 0)
|
|
step = 1;
|
|
|
|
float pos = timeline_pos;
|
|
|
|
pos = Math::stepify(pos + step, step);
|
|
if (pos > animation->get_length())
|
|
pos = animation->get_length();
|
|
timeline_pos = pos;
|
|
track_pos->update();
|
|
emit_signal("timeline_changed", pos, true);
|
|
|
|
} break;
|
|
case TRACK_MENU_PREV_STEP: {
|
|
if (animation.is_null())
|
|
break;
|
|
float step = animation->get_step();
|
|
if (step == 0)
|
|
step = 1;
|
|
|
|
float pos = timeline_pos;
|
|
pos = Math::stepify(pos - step, step);
|
|
if (pos < 0)
|
|
pos = 0;
|
|
timeline_pos = pos;
|
|
track_pos->update();
|
|
emit_signal("timeline_changed", pos, true);
|
|
|
|
} break;
|
|
|
|
case TRACK_MENU_OPTIMIZE: {
|
|
|
|
optimize_dialog->popup_centered(Size2(250, 180));
|
|
} break;
|
|
case TRACK_MENU_CLEAN_UP: {
|
|
|
|
cleanup_dialog->popup_centered_minsize(Size2(300, 0));
|
|
} break;
|
|
case TRACK_MENU_CLEAN_UP_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;
|
|
case CURVE_SET_LINEAR: {
|
|
curve_edit->force_transition(1.0);
|
|
|
|
} break;
|
|
case CURVE_SET_IN: {
|
|
|
|
curve_edit->force_transition(4.0);
|
|
|
|
} break;
|
|
case CURVE_SET_OUT: {
|
|
|
|
curve_edit->force_transition(0.25);
|
|
} break;
|
|
case CURVE_SET_INOUT: {
|
|
curve_edit->force_transition(-4);
|
|
|
|
} break;
|
|
case CURVE_SET_OUTIN: {
|
|
|
|
curve_edit->force_transition(-0.25);
|
|
} break;
|
|
case CURVE_SET_CONSTANT: {
|
|
|
|
curve_edit->force_transition(0);
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_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_paths();
|
|
}
|
|
|
|
void AnimationKeyEditor::_animation_optimize() {
|
|
|
|
animation->optimize(optimize_linear_error->get_value(), optimize_angular_error->get_value(), optimize_max_angle->get_value());
|
|
track_editor->update();
|
|
undo_redo->clear_history();
|
|
}
|
|
|
|
float AnimationKeyEditor::_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 AnimationKeyEditor::_track_position_draw() {
|
|
|
|
if (!animation.is_valid()) {
|
|
return;
|
|
}
|
|
|
|
Ref<StyleBox> style = get_stylebox("normal", "TextEdit");
|
|
Size2 size = track_editor->get_size() - style->get_minimum_size();
|
|
Size2 ofs = style->get_offset();
|
|
|
|
int settings_limit = size.width - right_data_size_cache;
|
|
int name_limit = settings_limit * name_column_ratio;
|
|
|
|
float keys_from = h_scroll->get_value();
|
|
float zoom_scale = _get_zoom_scale();
|
|
float keys_to = keys_from + (settings_limit - name_limit) / zoom_scale;
|
|
|
|
//will move to separate control! (for speedup)
|
|
if (timeline_pos >= keys_from && timeline_pos < keys_to) {
|
|
//draw position
|
|
int pixel = (timeline_pos - h_scroll->get_value()) * zoom_scale;
|
|
pixel += name_limit;
|
|
track_pos->draw_line(ofs + Point2(pixel, 0), ofs + Point2(pixel, size.height), get_color("accent_color", "Editor"));
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_track_editor_draw() {
|
|
|
|
if (animation.is_valid() && animation->get_track_count()) {
|
|
if (selected_track < 0)
|
|
selected_track = 0;
|
|
else if (selected_track >= animation->get_track_count())
|
|
selected_track = animation->get_track_count() - 1;
|
|
}
|
|
|
|
track_pos->update();
|
|
Control *te = track_editor;
|
|
Ref<StyleBox> style = get_stylebox("normal", "TextEdit");
|
|
te->draw_style_box(style, Rect2(Point2(), track_editor->get_size()));
|
|
|
|
if (te->has_focus()) {
|
|
te->draw_style_box(get_stylebox("bg_focus", "Tree"), Rect2(Point2(), track_editor->get_size()));
|
|
}
|
|
|
|
if (!animation.is_valid()) {
|
|
v_scroll->hide();
|
|
h_scroll->hide();
|
|
menu_add_track->set_disabled(true);
|
|
menu_track->set_disabled(true);
|
|
edit_button->set_disabled(true);
|
|
key_editor_tab->hide();
|
|
move_up_button->set_disabled(true);
|
|
move_down_button->set_disabled(true);
|
|
remove_button->set_disabled(true);
|
|
|
|
return;
|
|
}
|
|
|
|
menu_add_track->set_disabled(false);
|
|
menu_track->set_disabled(false);
|
|
edit_button->set_disabled(false);
|
|
move_up_button->set_disabled(false);
|
|
move_down_button->set_disabled(false);
|
|
remove_button->set_disabled(false);
|
|
if (edit_button->is_pressed())
|
|
key_editor_tab->show();
|
|
|
|
te_drawing = true;
|
|
|
|
Size2 size = te->get_size() - style->get_minimum_size();
|
|
Size2 ofs = style->get_offset();
|
|
|
|
Ref<Font> font = te->get_font("font", "Tree");
|
|
int sep = get_constant("vseparation", "Tree");
|
|
int hsep = get_constant("hseparation", "Tree");
|
|
Color color = get_color("font_color", "Tree");
|
|
Color sepcolor = color;
|
|
sepcolor.a = 0.2;
|
|
Color timecolor = color;
|
|
timecolor.a = 0.2;
|
|
Color hover_color = color;
|
|
hover_color.a = 0.05;
|
|
Color select_color = color;
|
|
select_color.a = 0.1;
|
|
Color invalid_path_color = get_color("error_color", "Editor");
|
|
Color track_select_color = get_color("highlighted_font_color", "Editor");
|
|
|
|
Ref<Texture> remove_icon = get_icon("Remove", "EditorIcons");
|
|
Ref<Texture> move_up_icon = get_icon("MoveUp", "EditorIcons");
|
|
Ref<Texture> move_down_icon = get_icon("MoveDown", "EditorIcons");
|
|
Ref<Texture> remove_icon_hl = get_icon("RemoveHl", "EditorIcons");
|
|
Ref<Texture> move_up_icon_hl = get_icon("MoveUpHl", "EditorIcons");
|
|
Ref<Texture> move_down_icon_hl = get_icon("MoveDownHl", "EditorIcons");
|
|
Ref<Texture> add_key_icon = get_icon("TrackAddKey", "EditorIcons");
|
|
Ref<Texture> add_key_icon_hl = get_icon("TrackAddKeyHl", "EditorIcons");
|
|
Ref<Texture> down_icon = get_icon("select_arrow", "Tree");
|
|
Ref<Texture> checked = get_icon("checked", "Tree");
|
|
Ref<Texture> unchecked = get_icon("unchecked", "Tree");
|
|
|
|
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[3] = {
|
|
get_icon("TrackContinuous", "EditorIcons"),
|
|
get_icon("TrackDiscrete", "EditorIcons"),
|
|
get_icon("TrackTrigger", "EditorIcons")
|
|
};
|
|
Ref<Texture> type_icon[3] = {
|
|
get_icon("KeyValue", "EditorIcons"),
|
|
get_icon("KeyXform", "EditorIcons"),
|
|
get_icon("KeyCall", "EditorIcons")
|
|
};
|
|
|
|
Ref<Texture> valid_icon = get_icon("KeyValid", "EditorIcons");
|
|
Ref<Texture> invalid_icon = get_icon("KeyInvalid", "EditorIcons");
|
|
const Color modulate_selected = Color(0x84 / 255.0, 0xc2 / 255.0, 0xff / 255.0);
|
|
|
|
Ref<Texture> hsize_icon = get_icon("Hsize", "EditorIcons");
|
|
|
|
int right_separator_ofs = right_data_size_cache;
|
|
|
|
int h = font->get_height() + sep;
|
|
|
|
int fit = (size.height / h) - 1;
|
|
int total = animation->get_track_count();
|
|
if (total < fit) {
|
|
v_scroll->hide();
|
|
v_scroll->set_max(total);
|
|
v_scroll->set_page(fit);
|
|
} else {
|
|
v_scroll->show();
|
|
v_scroll->set_max(total);
|
|
v_scroll->set_page(fit);
|
|
}
|
|
|
|
int left_check_ofs = checked->get_width();
|
|
int settings_limit = size.width - right_separator_ofs;
|
|
int name_limit = settings_limit * name_column_ratio;
|
|
|
|
Color linecolor = color;
|
|
linecolor.a = 0.2;
|
|
te->draw_line(ofs + Point2(name_limit, 0), ofs + Point2(name_limit, size.height), linecolor);
|
|
te->draw_line(ofs + Point2(settings_limit, 0), ofs + Point2(settings_limit, size.height), linecolor);
|
|
te->draw_texture(hsize_icon, ofs + Point2(name_limit - hsize_icon->get_width() - hsep, (h - hsize_icon->get_height()) / 2));
|
|
|
|
te->draw_line(ofs + Point2(0, h), ofs + Point2(size.width, h), linecolor);
|
|
// draw time
|
|
|
|
float keys_from;
|
|
float keys_to;
|
|
float zoom_scale;
|
|
|
|
{
|
|
|
|
int zoomw = settings_limit - name_limit;
|
|
|
|
float scale = _get_zoom_scale();
|
|
zoom_scale = scale;
|
|
|
|
float l = animation->get_length();
|
|
if (l <= 0)
|
|
l = 0.001; //avoid crashor
|
|
|
|
int end_px = (l - h_scroll->get_value()) * scale;
|
|
int begin_px = -h_scroll->get_value() * scale;
|
|
Color notimecol = get_color("dark_color_2", "Editor");
|
|
|
|
{
|
|
|
|
te->draw_rect(Rect2(ofs + Point2(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;
|
|
|
|
te->draw_rect(Rect2(ofs + Point2(name_limit + begin_px, 0), Point2(end_px - begin_px - 1, h)), timecolor);
|
|
}
|
|
}
|
|
|
|
keys_from = h_scroll->get_value();
|
|
keys_to = keys_from + zoomw / scale;
|
|
|
|
{
|
|
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 (beg < time_min)
|
|
time_min = beg;
|
|
float end = animation->track_get_key_time(i, animation->track_get_key_count(i) - 1);
|
|
if (end > time_max)
|
|
time_max = end;
|
|
}
|
|
}
|
|
|
|
float extra = (zoomw / scale) * 0.5;
|
|
|
|
if (time_min < -0.001)
|
|
time_min -= extra;
|
|
time_max += extra;
|
|
h_scroll->set_min(time_min);
|
|
h_scroll->set_max(time_max);
|
|
|
|
if (zoomw / scale < (time_max - time_min)) {
|
|
h_scroll->show();
|
|
|
|
} else {
|
|
|
|
h_scroll->hide();
|
|
}
|
|
}
|
|
|
|
h_scroll->set_page(zoomw / scale);
|
|
|
|
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;
|
|
|
|
while (!step_found) {
|
|
|
|
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;
|
|
}
|
|
|
|
for (int i = 0; i < zoomw; i++) {
|
|
|
|
float pos = h_scroll->get_value() + double(i) / scale;
|
|
float prev = h_scroll->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;
|
|
te->draw_line(ofs + Point2(name_limit + i, 0), ofs + Point2(name_limit + i, h), linecolor);
|
|
te->draw_string(font, ofs + Point2(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);
|
|
}
|
|
}
|
|
}
|
|
|
|
color.a *= 0.5;
|
|
|
|
for (int i = 0; i < fit; i++) {
|
|
|
|
//this code sucks, i always forget how it works
|
|
|
|
int idx = v_scroll->get_value() + i;
|
|
if (idx >= animation->get_track_count())
|
|
break;
|
|
int y = h + i * h + sep;
|
|
|
|
bool prop_exists = false;
|
|
Variant::Type valid_type = Variant::NIL;
|
|
Object *obj = NULL;
|
|
|
|
RES res;
|
|
Vector<StringName> leftover_path;
|
|
|
|
Node *node = root ? root->get_node_and_resource(animation->track_get_path(idx), res, leftover_path) : (Node *)NULL;
|
|
|
|
if (res.is_valid()) {
|
|
obj = res.ptr();
|
|
} else if (node) {
|
|
obj = node;
|
|
}
|
|
|
|
if (obj && animation->track_get_type(idx) == Animation::TYPE_VALUE) {
|
|
// While leftover_path might be still empty, we wouldn't be able to get here anyway
|
|
valid_type = obj->get_static_property_type_indexed(leftover_path, &prop_exists);
|
|
}
|
|
|
|
// Draw background color of the whole track
|
|
if (/*mouse_over.over!=MouseOver::OVER_NONE &&*/ idx == mouse_over.track) {
|
|
Color sepc = hover_color;
|
|
te->draw_rect(Rect2(ofs + Point2(0, y), Size2(size.width, h - 1)), sepc);
|
|
}
|
|
|
|
if (selected_track == idx) {
|
|
Color tc = select_color;
|
|
//tc.a*=0.7;
|
|
te->draw_rect(Rect2(ofs + Point2(0, y), Size2(size.width - 1, h - 1)), tc);
|
|
}
|
|
|
|
// Draw track enabled state check box
|
|
Ref<Texture> check_box = animation->track_is_enabled(idx) ? checked : unchecked;
|
|
te->draw_texture(check_box, ofs + Point2(0, y + (h - checked->get_height()) / 2).floor());
|
|
|
|
// Draw track type glyph and node path
|
|
te->draw_texture(type_icon[animation->track_get_type(idx)], ofs + Point2(left_check_ofs + sep, y + (h - type_icon[0]->get_height()) / 2).floor());
|
|
NodePath np = animation->track_get_path(idx);
|
|
Node *n = root ? root->get_node(np) : (Node *)NULL;
|
|
Color ncol = color;
|
|
if (n && editor_selection->is_selected(n))
|
|
ncol = track_select_color;
|
|
te->draw_string(font, Point2(ofs + Point2(left_check_ofs + sep + type_icon[0]->get_width() + sep, y + font->get_ascent() + (sep / 2))).floor(), np, ncol, name_limit - (left_check_ofs + sep) - (type_icon[0]->get_width() + sep) - 5);
|
|
|
|
// Draw separator line below track area
|
|
if (!obj)
|
|
te->draw_line(ofs + Point2(0, y + h / 2), ofs + Point2(name_limit, y + h / 2), invalid_path_color);
|
|
|
|
te->draw_line(ofs + Point2(0, y + h), ofs + Point2(size.width, y + h), sepcolor);
|
|
|
|
Point2 icon_ofs = ofs + Point2(size.width, y + (h - remove_icon->get_height()) / 2).floor();
|
|
icon_ofs.y += 4 * EDSCALE;
|
|
|
|
/* icon_ofs.x-=remove_icon->get_width();
|
|
|
|
te->draw_texture((mouse_over.over==MouseOver::OVER_REMOVE && mouse_over.track==idx)?remove_icon_hl:remove_icon,icon_ofs);
|
|
icon_ofs.x-=hsep;
|
|
icon_ofs.x-=move_down_icon->get_width();
|
|
te->draw_texture((mouse_over.over==MouseOver::OVER_DOWN && mouse_over.track==idx)?move_down_icon_hl:move_down_icon,icon_ofs);
|
|
icon_ofs.x-=hsep;
|
|
icon_ofs.x-=move_up_icon->get_width();
|
|
te->draw_texture((mouse_over.over==MouseOver::OVER_UP && mouse_over.track==idx)?move_up_icon_hl:move_up_icon,icon_ofs);
|
|
icon_ofs.x-=hsep;
|
|
te->draw_line(Point2(icon_ofs.x,ofs.y+y),Point2(icon_ofs.x,ofs.y+y+h),sepcolor);
|
|
|
|
icon_ofs.x-=hsep;
|
|
*/
|
|
track_ofs[0] = size.width - icon_ofs.x + ofs.x;
|
|
icon_ofs.x -= down_icon->get_width();
|
|
te->draw_texture(down_icon, icon_ofs - Size2(0, 4 * EDSCALE));
|
|
|
|
int wrap_type = animation->track_get_interpolation_loop_wrap(idx) ? 1 : 0;
|
|
icon_ofs.x -= hsep;
|
|
icon_ofs.x -= wrap_icon[wrap_type]->get_width();
|
|
te->draw_texture(wrap_icon[wrap_type], icon_ofs);
|
|
|
|
icon_ofs.x -= hsep;
|
|
te->draw_line(Point2(icon_ofs.x, ofs.y + y), Point2(icon_ofs.x, ofs.y + y + h), sepcolor);
|
|
|
|
track_ofs[1] = size.width - icon_ofs.x + ofs.x;
|
|
|
|
icon_ofs.x -= down_icon->get_width();
|
|
te->draw_texture(down_icon, icon_ofs - Size2(0, 4 * EDSCALE));
|
|
|
|
int interp_type = animation->track_get_interpolation_type(idx);
|
|
ERR_CONTINUE(interp_type < 0 || interp_type >= 3);
|
|
icon_ofs.x -= hsep;
|
|
icon_ofs.x -= interp_icon[interp_type]->get_width();
|
|
te->draw_texture(interp_icon[interp_type], icon_ofs);
|
|
|
|
icon_ofs.x -= hsep;
|
|
te->draw_line(Point2(icon_ofs.x, ofs.y + y), Point2(icon_ofs.x, ofs.y + y + h), sepcolor);
|
|
|
|
track_ofs[2] = size.width - icon_ofs.x + ofs.x;
|
|
|
|
if (animation->track_get_type(idx) == Animation::TYPE_VALUE) {
|
|
|
|
int umode = animation->value_track_get_update_mode(idx);
|
|
|
|
icon_ofs.x -= hsep;
|
|
icon_ofs.x -= down_icon->get_width();
|
|
te->draw_texture(down_icon, icon_ofs - Size2(0, 4 * EDSCALE));
|
|
|
|
icon_ofs.x -= hsep;
|
|
icon_ofs.x -= cont_icon[umode]->get_width();
|
|
te->draw_texture(cont_icon[umode], icon_ofs);
|
|
} else {
|
|
|
|
icon_ofs.x -= hsep * 2 + cont_icon[0]->get_width() + down_icon->get_width();
|
|
}
|
|
|
|
icon_ofs.x -= hsep;
|
|
te->draw_line(Point2(icon_ofs.x, ofs.y + y), Point2(icon_ofs.x, ofs.y + y + h), sepcolor);
|
|
|
|
track_ofs[3] = size.width - icon_ofs.x + ofs.x;
|
|
|
|
icon_ofs.x -= hsep;
|
|
icon_ofs.x -= add_key_icon->get_width();
|
|
te->draw_texture((mouse_over.over == MouseOver::OVER_ADD_KEY && mouse_over.track == idx) ? add_key_icon_hl : add_key_icon, icon_ofs);
|
|
track_ofs[4] = size.width - icon_ofs.x + ofs.x;
|
|
|
|
//draw the keys;
|
|
int tt = animation->track_get_type(idx);
|
|
float key_vofs = Math::floor((float)(h - type_icon[tt]->get_height()) / 2);
|
|
float key_hofs = -Math::floor((float)type_icon[tt]->get_height() / 2);
|
|
|
|
int kc = animation->track_get_key_count(idx);
|
|
bool first = true;
|
|
|
|
for (int i = 0; i < kc; i++) {
|
|
|
|
float time = animation->track_get_key_time(idx, i);
|
|
if (time < keys_from)
|
|
continue;
|
|
if (time > keys_to) {
|
|
|
|
if (first && i > 0 && animation->track_get_key_value(idx, i) == animation->track_get_key_value(idx, i - 1)) {
|
|
//draw whole line
|
|
te->draw_line(ofs + Vector2(name_limit, y + h / 2), ofs + Point2(settings_limit, y + h / 2), color);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
float x = key_hofs + name_limit + (time - keys_from) * zoom_scale;
|
|
|
|
Ref<Texture> tex = type_icon[tt];
|
|
Color modulate = Color(1, 1, 1);
|
|
|
|
bool is_hover = false;
|
|
bool is_selected = false;
|
|
|
|
SelectedKey sk;
|
|
sk.key = i;
|
|
sk.track = idx;
|
|
if (selection.has(sk)) {
|
|
|
|
if (click.click == ClickOver::CLICK_MOVE_KEYS)
|
|
continue;
|
|
is_selected = true;
|
|
}
|
|
|
|
if (mouse_over.over == MouseOver::OVER_KEY && mouse_over.track == idx && mouse_over.over_key == i)
|
|
is_hover = true;
|
|
|
|
Variant value = animation->track_get_key_value(idx, i);
|
|
|
|
if (prop_exists && !Variant::can_convert(value.get_type(), valid_type)) {
|
|
|
|
tex = invalid_icon;
|
|
if (is_hover)
|
|
modulate = Color(1.5, 1.5, 1.5);
|
|
else
|
|
modulate = Color(1, 1, 1);
|
|
} else if (is_selected) {
|
|
|
|
tex = valid_icon;
|
|
modulate = modulate_selected;
|
|
if (is_hover)
|
|
modulate = modulate.lightened(0.2);
|
|
} else if (is_hover) {
|
|
|
|
tex = valid_icon;
|
|
modulate = Color(1, 1, 1);
|
|
}
|
|
|
|
if (first && i > 0 && value == animation->track_get_key_value(idx, i - 1)) {
|
|
|
|
te->draw_line(ofs + Vector2(name_limit, y + h / 2), ofs + Point2(x, y + h / 2), color);
|
|
}
|
|
|
|
if (i < kc - 1 && value == animation->track_get_key_value(idx, i + 1)) {
|
|
float x_n = key_hofs + name_limit + (animation->track_get_key_time(idx, i + 1) - keys_from) * zoom_scale;
|
|
|
|
x_n = MIN(x_n, settings_limit);
|
|
te->draw_line(ofs + Point2(x_n, y + h / 2), ofs + Point2(x, y + h / 2), color);
|
|
}
|
|
|
|
te->draw_texture(tex, ofs + Point2(x, y + key_vofs).floor(), modulate);
|
|
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
switch (click.click) {
|
|
case ClickOver::CLICK_SELECT_KEYS: {
|
|
|
|
Color box_color = get_color("accent_color", "Editor");
|
|
box_color.a = 0.35;
|
|
te->draw_rect(Rect2(click.at, click.to - click.at), box_color);
|
|
|
|
} break;
|
|
case ClickOver::CLICK_MOVE_KEYS: {
|
|
|
|
float from_t = 1e20;
|
|
|
|
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;
|
|
}
|
|
|
|
float motion = from_t + (click.to.x - click.at.x) / zoom_scale;
|
|
if (step->get_value())
|
|
motion = Math::stepify(motion, step->get_value());
|
|
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.front(); E; E = E->next()) {
|
|
|
|
int idx = E->key().track;
|
|
int i = idx - (int)v_scroll->get_value();
|
|
if (i < 0 || i >= fit)
|
|
continue;
|
|
int y = h + i * h + sep;
|
|
|
|
float key_vofs = Math::floor((float)(h - valid_icon->get_height()) / 2);
|
|
float key_hofs = -Math::floor((float)valid_icon->get_height() / 2);
|
|
|
|
float time = animation->track_get_key_time(idx, E->key().key);
|
|
float diff = time - from_t;
|
|
|
|
float t = motion + diff;
|
|
|
|
float x = (t - keys_from) * zoom_scale;
|
|
//x+=click.to.x - click.at.x;
|
|
if (x < 0 || x >= (settings_limit - name_limit))
|
|
continue;
|
|
|
|
x += name_limit;
|
|
|
|
te->draw_texture(valid_icon, ofs + Point2(x + key_hofs, y + key_vofs).floor(), modulate_selected);
|
|
}
|
|
} break;
|
|
default: {};
|
|
}
|
|
|
|
te_drawing = false;
|
|
}
|
|
|
|
void AnimationKeyEditor::_track_name_changed(const String &p_name) {
|
|
|
|
ERR_FAIL_COND(!animation.is_valid());
|
|
undo_redo->create_action(TTR("Anim Track Rename"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", track_name_editing, p_name);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_path", track_name_editing, animation->track_get_path(track_name_editing));
|
|
undo_redo->commit_action();
|
|
track_name->hide();
|
|
}
|
|
|
|
void AnimationKeyEditor::_track_menu_selected(int p_idx) {
|
|
|
|
ERR_FAIL_COND(!animation.is_valid());
|
|
|
|
if (interp_editing != -1) {
|
|
|
|
ERR_FAIL_INDEX(interp_editing, animation->get_track_count());
|
|
undo_redo->create_action(TTR("Anim Track Change Interpolation"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_type", interp_editing, p_idx);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_interpolation_type", interp_editing, animation->track_get_interpolation_type(interp_editing));
|
|
undo_redo->commit_action();
|
|
} else if (cont_editing != -1) {
|
|
|
|
ERR_FAIL_INDEX(cont_editing, animation->get_track_count());
|
|
|
|
undo_redo->create_action(TTR("Anim Track Change Value Mode"));
|
|
undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", cont_editing, p_idx);
|
|
undo_redo->add_undo_method(animation.ptr(), "value_track_set_update_mode", cont_editing, animation->value_track_get_update_mode(cont_editing));
|
|
undo_redo->commit_action();
|
|
} else if (wrap_editing != -1) {
|
|
|
|
ERR_FAIL_INDEX(wrap_editing, animation->get_track_count());
|
|
|
|
undo_redo->create_action(TTR("Anim Track Change Wrap Mode"));
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_loop_wrap", wrap_editing, p_idx ? true : false);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_interpolation_loop_wrap", wrap_editing, animation->track_get_interpolation_loop_wrap(wrap_editing));
|
|
undo_redo->commit_action();
|
|
} else {
|
|
switch (p_idx) {
|
|
|
|
case RIGHT_MENU_DUPLICATE:
|
|
_anim_duplicate_keys();
|
|
break;
|
|
case RIGHT_MENU_DUPLICATE_TRANSPOSE:
|
|
_anim_duplicate_keys(true);
|
|
break;
|
|
case RIGHT_MENU_REMOVE:
|
|
_anim_delete_keys();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct _AnimMoveRestore {
|
|
|
|
int track;
|
|
float time;
|
|
Variant key;
|
|
float transition;
|
|
};
|
|
|
|
void AnimationKeyEditor::_clear_selection_for_anim(const Ref<Animation> &p_anim) {
|
|
|
|
if (!(animation == p_anim))
|
|
return;
|
|
//selection.clear();
|
|
_clear_selection();
|
|
}
|
|
|
|
void AnimationKeyEditor::_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);
|
|
}
|
|
|
|
PropertyInfo AnimationKeyEditor::_find_hint_for_track(int p_idx, NodePath &r_base_path) {
|
|
|
|
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())
|
|
return PropertyInfo();
|
|
|
|
Variant property_info_base;
|
|
if (res.is_valid())
|
|
property_info_base = res;
|
|
else if (node)
|
|
property_info_base = node;
|
|
|
|
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();
|
|
}
|
|
|
|
void AnimationKeyEditor::_curve_transition_changed(float p_what) {
|
|
|
|
if (selection.size() == 0)
|
|
return;
|
|
if (selection.size() == 1)
|
|
undo_redo->create_action(TTR("Edit Node Curve"), UndoRedo::MERGE_ENDS);
|
|
else
|
|
undo_redo->create_action(TTR("Edit Selection Curve"), UndoRedo::MERGE_ENDS);
|
|
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.front(); E; E = E->next()) {
|
|
|
|
int track = E->key().track;
|
|
int key = E->key().key;
|
|
float prev_val = animation->track_get_key_transition(track, key);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_key_transition", track, key, p_what);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_key_transition", track, key, prev_val);
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
void AnimationKeyEditor::_toggle_edit_curves() {
|
|
|
|
if (edit_button->is_pressed())
|
|
key_editor_tab->show();
|
|
else
|
|
key_editor_tab->hide();
|
|
}
|
|
|
|
bool AnimationKeyEditor::_edit_if_single_selection() {
|
|
|
|
if (selection.size() != 1) {
|
|
|
|
if (selection.size() == 0) {
|
|
curve_edit->set_mode(AnimationCurveEdit::MODE_DISABLED);
|
|
//print_line("disable");
|
|
} else {
|
|
|
|
curve_edit->set_mode(AnimationCurveEdit::MODE_MULTIPLE);
|
|
curve_edit->set_transition(1.0);
|
|
curve_edit->clear_multiples();
|
|
//add all
|
|
for (Map<SelectedKey, KeyInfo>::Element *E = selection.front(); E; E = E->next()) {
|
|
|
|
curve_edit->set_multiple(animation->track_get_key_transition(E->key().track, E->key().key));
|
|
}
|
|
//print_line("multiple");
|
|
}
|
|
return false;
|
|
}
|
|
curve_edit->set_mode(AnimationCurveEdit::MODE_SINGLE);
|
|
//print_line("regular");
|
|
|
|
int idx = selection.front()->key().track;
|
|
int key = selection.front()->key().key;
|
|
{
|
|
|
|
key_edit->animation = animation;
|
|
key_edit->track = idx;
|
|
key_edit->key_ofs = animation->track_get_key_time(idx, key);
|
|
key_edit->hint = _find_hint_for_track(idx, key_edit->base);
|
|
key_edit->notify_change();
|
|
|
|
curve_edit->set_transition(animation->track_get_key_transition(idx, key));
|
|
|
|
/*key_edit_dialog->set_size( Size2( 200,200) );
|
|
key_edit_dialog->set_position( track_editor->get_global_position() + ofs + mpos +Point2(-100,20));
|
|
key_edit_dialog->popup();*/
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void AnimationKeyEditor::_anim_delete_keys() {
|
|
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();
|
|
accept_event();
|
|
_edit_if_single_selection();
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_track_editor_gui_input(const Ref<InputEvent> &p_input) {
|
|
|
|
Control *te = track_editor;
|
|
Ref<StyleBox> style = get_stylebox("normal", "TextEdit");
|
|
|
|
if (!animation.is_valid()) {
|
|
return;
|
|
}
|
|
|
|
Size2 size = te->get_size() - style->get_minimum_size();
|
|
Size2 ofs = style->get_offset();
|
|
|
|
Ref<Font> font = te->get_font("font", "Tree");
|
|
int sep = get_constant("vseparation", "Tree");
|
|
int hsep = get_constant("hseparation", "Tree");
|
|
Ref<Texture> remove_icon = get_icon("Remove", "EditorIcons");
|
|
Ref<Texture> move_up_icon = get_icon("MoveUp", "EditorIcons");
|
|
Ref<Texture> move_down_icon = get_icon("MoveDown", "EditorIcons");
|
|
Ref<Texture> down_icon = get_icon("select_arrow", "Tree");
|
|
Ref<Texture> hsize_icon = get_icon("Hsize", "EditorIcons");
|
|
Ref<Texture> add_key_icon = get_icon("TrackAddKey", "EditorIcons");
|
|
Ref<Texture> check_icon = get_icon("checked", "Tree");
|
|
|
|
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[3] = {
|
|
get_icon("TrackContinuous", "EditorIcons"),
|
|
get_icon("TrackDiscrete", "EditorIcons"),
|
|
get_icon("TrackTrigger", "EditorIcons")
|
|
};
|
|
Ref<Texture> type_icon[3] = {
|
|
get_icon("KeyValue", "EditorIcons"),
|
|
get_icon("KeyXform", "EditorIcons"),
|
|
get_icon("KeyCall", "EditorIcons")
|
|
};
|
|
int right_separator_ofs = right_data_size_cache;
|
|
|
|
int h = font->get_height() + sep;
|
|
|
|
int fit = (size.height / h) - 1;
|
|
int total = animation->get_track_count();
|
|
if (total < fit) {
|
|
v_scroll->hide();
|
|
} else {
|
|
v_scroll->show();
|
|
v_scroll->set_max(total);
|
|
v_scroll->set_page(fit);
|
|
}
|
|
|
|
int left_check_ofs = check_icon->get_width();
|
|
int settings_limit = size.width - right_separator_ofs;
|
|
int name_limit = settings_limit * name_column_ratio;
|
|
|
|
Ref<InputEventKey> key = p_input;
|
|
if (key.is_valid()) {
|
|
|
|
if (key->get_scancode() == KEY_D && key->is_pressed() && key->get_command()) {
|
|
|
|
if (key->get_shift())
|
|
_menu_track(TRACK_MENU_DUPLICATE_TRANSPOSE);
|
|
else
|
|
_menu_track(TRACK_MENU_DUPLICATE);
|
|
|
|
accept_event();
|
|
|
|
} else if (key->get_scancode() == KEY_DELETE && key->is_pressed() && click.click == ClickOver::CLICK_NONE) {
|
|
|
|
_anim_delete_keys();
|
|
} else if (animation.is_valid() && animation->get_track_count() > 0) {
|
|
|
|
if (key->is_pressed() && (key->is_action("ui_up") || key->is_action("ui_page_up"))) {
|
|
|
|
if (key->is_action("ui_up"))
|
|
selected_track--;
|
|
if (v_scroll->is_visible_in_tree() && key->is_action("ui_page_up"))
|
|
selected_track--;
|
|
|
|
if (selected_track < 0)
|
|
selected_track = 0;
|
|
|
|
if (v_scroll->is_visible_in_tree()) {
|
|
if (v_scroll->get_value() > selected_track)
|
|
v_scroll->set_value(selected_track);
|
|
}
|
|
|
|
track_editor->update();
|
|
accept_event();
|
|
}
|
|
|
|
if (key->is_pressed() && (key->is_action("ui_down") || key->is_action("ui_page_down"))) {
|
|
|
|
if (key->is_action("ui_down"))
|
|
selected_track++;
|
|
else if (v_scroll->is_visible_in_tree() && key->is_action("ui_page_down"))
|
|
selected_track += v_scroll->get_page();
|
|
|
|
if (selected_track >= animation->get_track_count())
|
|
selected_track = animation->get_track_count() - 1;
|
|
|
|
if (v_scroll->is_visible_in_tree() && v_scroll->get_page() + v_scroll->get_value() < selected_track + 1) {
|
|
v_scroll->set_value(selected_track - v_scroll->get_page() + 1);
|
|
}
|
|
|
|
track_editor->update();
|
|
accept_event();
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<InputEventMouseButton> mb = p_input;
|
|
|
|
if (mb.is_valid()) {
|
|
|
|
if (mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed()) {
|
|
|
|
if (mb->get_command()) {
|
|
|
|
zoom->set_value(zoom->get_value() + zoom->get_step());
|
|
} else {
|
|
|
|
v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * mb->get_factor() / 8);
|
|
}
|
|
}
|
|
|
|
if (mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed()) {
|
|
|
|
if (mb->get_command()) {
|
|
|
|
zoom->set_value(zoom->get_value() - zoom->get_step());
|
|
} else {
|
|
|
|
v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * mb->get_factor() / 8);
|
|
}
|
|
}
|
|
|
|
if (mb->get_button_index() == BUTTON_WHEEL_RIGHT && mb->is_pressed()) {
|
|
|
|
h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * mb->get_factor() / 8);
|
|
}
|
|
|
|
if (mb->get_button_index() == BUTTON_WHEEL_LEFT && mb->is_pressed()) {
|
|
|
|
v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * mb->get_factor() / 8);
|
|
}
|
|
|
|
if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed()) {
|
|
|
|
Point2 mpos = mb->get_position() - ofs;
|
|
|
|
if (selection.size() == 0) {
|
|
// Auto-select on right-click if nothing is selected
|
|
// Note: This code is pretty much duplicated from the left click code,
|
|
// both codes could be moved into a function to avoid the duplicated code.
|
|
Point2 mpos = mb->get_position() - ofs;
|
|
|
|
if (mpos.y < h) {
|
|
return;
|
|
}
|
|
|
|
mpos.y -= h;
|
|
|
|
int idx = mpos.y / h;
|
|
idx += v_scroll->get_value();
|
|
if (idx < 0 || idx >= animation->get_track_count())
|
|
return;
|
|
|
|
if (mpos.x < name_limit) {
|
|
} else if (mpos.x < settings_limit) {
|
|
float pos = mpos.x - name_limit;
|
|
pos /= _get_zoom_scale();
|
|
pos += h_scroll->get_value();
|
|
float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0;
|
|
|
|
int kidx = animation->track_find_key(idx, pos);
|
|
int kidx_n = kidx + 1;
|
|
int key = -1;
|
|
|
|
if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) {
|
|
|
|
float kpos = animation->track_get_key_time(idx, kidx);
|
|
if (ABS(pos - kpos) <= w_time) {
|
|
|
|
key = kidx;
|
|
}
|
|
}
|
|
|
|
if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) {
|
|
|
|
float kpos = animation->track_get_key_time(idx, kidx_n);
|
|
if (ABS(pos - kpos) <= w_time) {
|
|
|
|
key = kidx_n;
|
|
}
|
|
}
|
|
|
|
if (key == -1) {
|
|
|
|
click.click = ClickOver::CLICK_SELECT_KEYS;
|
|
click.at = mb->get_position();
|
|
click.to = click.at;
|
|
click.shift = mb->get_shift();
|
|
selected_track = idx;
|
|
track_editor->update();
|
|
//drag select region
|
|
return;
|
|
}
|
|
|
|
SelectedKey sk;
|
|
sk.track = idx;
|
|
sk.key = key;
|
|
KeyInfo ki;
|
|
ki.pos = animation->track_get_key_time(idx, key);
|
|
click.shift = mb->get_shift();
|
|
click.selk = sk;
|
|
|
|
if (!mb->get_shift() && !selection.has(sk))
|
|
_clear_selection();
|
|
|
|
selection.insert(sk, ki);
|
|
|
|
click.click = ClickOver::CLICK_MOVE_KEYS;
|
|
click.at = mb->get_position();
|
|
click.to = click.at;
|
|
update();
|
|
selected_track = idx;
|
|
track_editor->update();
|
|
|
|
if (_edit_if_single_selection() && mb->get_command()) {
|
|
edit_button->set_pressed(true);
|
|
key_editor_tab->show();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (selection.size()) {
|
|
// User has right clicked and we have a selection, show a popup menu with options
|
|
track_menu->clear();
|
|
track_menu->set_size(Point2(1, 1));
|
|
track_menu->add_item(TTR("Duplicate Selection"), RIGHT_MENU_DUPLICATE);
|
|
track_menu->add_item(TTR("Duplicate Transposed"), RIGHT_MENU_DUPLICATE_TRANSPOSE);
|
|
track_menu->add_item(TTR("Remove Selection"), RIGHT_MENU_REMOVE);
|
|
|
|
track_menu->set_position(te->get_global_position() + mpos);
|
|
|
|
interp_editing = -1;
|
|
cont_editing = -1;
|
|
wrap_editing = -1;
|
|
|
|
track_menu->popup();
|
|
}
|
|
}
|
|
|
|
if (mb->get_button_index() == BUTTON_LEFT && !(mb->get_button_mask() & ~BUTTON_MASK_LEFT)) {
|
|
|
|
if (mb->is_pressed()) {
|
|
|
|
Point2 mpos = mb->get_position() - ofs;
|
|
|
|
if (mpos.y < h) {
|
|
|
|
if (mpos.x < name_limit && mpos.x > (name_limit - hsep - hsize_icon->get_width())) {
|
|
|
|
click.click = ClickOver::CLICK_RESIZE_NAMES;
|
|
click.at = mb->get_position();
|
|
click.to = click.at;
|
|
click.at.y = name_limit;
|
|
}
|
|
|
|
if (mpos.x >= name_limit && mpos.x < settings_limit) {
|
|
//seek
|
|
//int zoomw = settings_limit-name_limit;
|
|
float scale = _get_zoom_scale();
|
|
float pos = h_scroll->get_value() + (mpos.x - name_limit) / scale;
|
|
if (animation->get_step())
|
|
pos = Math::stepify(pos, animation->get_step());
|
|
|
|
if (pos < 0)
|
|
pos = 0;
|
|
if (pos >= animation->get_length())
|
|
pos = animation->get_length();
|
|
timeline_pos = pos;
|
|
click.click = ClickOver::CLICK_DRAG_TIMELINE;
|
|
click.at = mb->get_position();
|
|
click.to = click.at;
|
|
emit_signal("timeline_changed", pos, false);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
mpos.y -= h;
|
|
|
|
int idx = mpos.y / h;
|
|
idx += v_scroll->get_value();
|
|
if (idx < 0)
|
|
return;
|
|
|
|
if (idx >= animation->get_track_count()) {
|
|
|
|
if (mpos.x >= name_limit && mpos.x < settings_limit) {
|
|
|
|
click.click = ClickOver::CLICK_SELECT_KEYS;
|
|
click.at = mb->get_position();
|
|
click.to = click.at;
|
|
//drag select region
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (mpos.x < left_check_ofs) {
|
|
// Checkbox on the very left to enable/disable tracks.
|
|
|
|
animation->track_set_enabled(idx, !animation->track_is_enabled(idx));
|
|
|
|
} else if (mpos.x < name_limit - (type_icon[0]->get_width() / 2.0)) {
|
|
//name column
|
|
|
|
// area
|
|
if (idx != selected_track) {
|
|
|
|
selected_track = idx;
|
|
track_editor->update();
|
|
return;
|
|
}
|
|
|
|
Rect2 area(ofs.x + left_check_ofs + sep, ofs.y + ((int(mpos.y) / h) + 1) * h, name_limit - left_check_ofs - sep, h);
|
|
track_name->set_text(animation->track_get_path(idx));
|
|
track_name->set_position(te->get_global_position() + area.position);
|
|
track_name->set_size(area.size);
|
|
track_name->show_modal();
|
|
track_name->grab_focus();
|
|
track_name->select_all();
|
|
track_name_editing = idx;
|
|
|
|
} else if (mpos.x < settings_limit) {
|
|
|
|
float pos = mpos.x - name_limit;
|
|
pos /= _get_zoom_scale();
|
|
pos += h_scroll->get_value();
|
|
float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0;
|
|
|
|
int kidx = animation->track_find_key(idx, pos);
|
|
int kidx_n = kidx + 1;
|
|
int key = -1;
|
|
|
|
if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) {
|
|
|
|
float kpos = animation->track_get_key_time(idx, kidx);
|
|
if (ABS(pos - kpos) <= w_time) {
|
|
|
|
key = kidx;
|
|
}
|
|
}
|
|
|
|
if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) {
|
|
|
|
float kpos = animation->track_get_key_time(idx, kidx_n);
|
|
if (ABS(pos - kpos) <= w_time) {
|
|
|
|
key = kidx_n;
|
|
}
|
|
}
|
|
|
|
if (key == -1) {
|
|
|
|
click.click = ClickOver::CLICK_SELECT_KEYS;
|
|
click.at = mb->get_position();
|
|
click.to = click.at;
|
|
click.shift = mb->get_shift();
|
|
selected_track = idx;
|
|
track_editor->update();
|
|
//drag select region
|
|
return;
|
|
}
|
|
|
|
SelectedKey sk;
|
|
sk.track = idx;
|
|
sk.key = key;
|
|
KeyInfo ki;
|
|
ki.pos = animation->track_get_key_time(idx, key);
|
|
click.shift = mb->get_shift();
|
|
click.selk = sk;
|
|
|
|
if (!mb->get_shift() && !selection.has(sk))
|
|
_clear_selection();
|
|
|
|
selection.insert(sk, ki);
|
|
|
|
click.click = ClickOver::CLICK_MOVE_KEYS;
|
|
click.at = mb->get_position();
|
|
click.to = click.at;
|
|
update();
|
|
selected_track = idx;
|
|
track_editor->update();
|
|
|
|
if (_edit_if_single_selection() && mb->get_command()) {
|
|
edit_button->set_pressed(true);
|
|
key_editor_tab->show();
|
|
}
|
|
} else {
|
|
//button column
|
|
int ofsx = size.width - mpos.x;
|
|
if (ofsx < 0)
|
|
return;
|
|
/*
|
|
if (ofsx < remove_icon->get_width()) {
|
|
|
|
undo_redo->create_action("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_continuous",idx,animation->value_track_is_continuous(idx));
|
|
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
ofsx-=hsep+remove_icon->get_width();
|
|
|
|
if (ofsx < move_down_icon->get_width()) {
|
|
|
|
if (idx < animation->get_track_count() -1) {
|
|
undo_redo->create_action("Move Anim Track Down");
|
|
undo_redo->add_do_method(animation.ptr(),"track_move_up",idx);
|
|
undo_redo->add_undo_method(animation.ptr(),"track_move_down",idx+1);
|
|
undo_redo->commit_action();
|
|
}
|
|
return;
|
|
}
|
|
|
|
ofsx-=hsep+move_down_icon->get_width();
|
|
|
|
if (ofsx < move_up_icon->get_width()) {
|
|
|
|
if (idx >0) {
|
|
undo_redo->create_action("Move Anim Track Up");
|
|
undo_redo->add_do_method(animation.ptr(),"track_move_down",idx);
|
|
undo_redo->add_undo_method(animation.ptr(),"track_move_up",idx-1);
|
|
undo_redo->commit_action();
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
ofsx-=hsep*3+move_up_icon->get_width();
|
|
*/
|
|
|
|
if (ofsx < track_ofs[1]) {
|
|
|
|
track_menu->clear();
|
|
track_menu->set_size(Point2(1, 1));
|
|
static const char *interp_name[2] = { "Clamp Loop Interp", "Wrap Loop Interp" };
|
|
for (int i = 0; i < 2; i++) {
|
|
track_menu->add_icon_item(wrap_icon[i], interp_name[i]);
|
|
}
|
|
|
|
int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h;
|
|
int popup_x = size.width - track_ofs[1];
|
|
|
|
track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y));
|
|
|
|
wrap_editing = idx;
|
|
interp_editing = -1;
|
|
cont_editing = -1;
|
|
|
|
track_menu->popup();
|
|
|
|
return;
|
|
}
|
|
|
|
if (ofsx < track_ofs[2]) {
|
|
|
|
track_menu->clear();
|
|
track_menu->set_size(Point2(1, 1));
|
|
static const char *interp_name[3] = { "Nearest", "Linear", "Cubic" };
|
|
for (int i = 0; i < 3; i++) {
|
|
track_menu->add_icon_item(interp_icon[i], interp_name[i]);
|
|
}
|
|
|
|
int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h;
|
|
int popup_x = size.width - track_ofs[2];
|
|
|
|
track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y));
|
|
|
|
interp_editing = idx;
|
|
cont_editing = -1;
|
|
wrap_editing = -1;
|
|
|
|
track_menu->popup();
|
|
|
|
return;
|
|
}
|
|
|
|
if (ofsx < track_ofs[3]) {
|
|
|
|
track_menu->clear();
|
|
track_menu->set_size(Point2(1, 1));
|
|
String cont_name[3] = { TTR("Continuous"), TTR("Discrete"), TTR("Trigger") };
|
|
for (int i = 0; i < 3; i++) {
|
|
track_menu->add_icon_item(cont_icon[i], cont_name[i]);
|
|
}
|
|
|
|
int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h;
|
|
int popup_x = size.width - track_ofs[3];
|
|
|
|
track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y));
|
|
|
|
interp_editing = -1;
|
|
wrap_editing = -1;
|
|
cont_editing = idx;
|
|
|
|
track_menu->popup();
|
|
|
|
return;
|
|
}
|
|
|
|
if (ofsx < track_ofs[4]) {
|
|
|
|
Animation::TrackType tt = animation->track_get_type(idx);
|
|
|
|
float pos = timeline_pos;
|
|
int existing = animation->track_find_key(idx, pos, true);
|
|
|
|
Variant newval;
|
|
|
|
if (tt == Animation::TYPE_TRANSFORM) {
|
|
Dictionary d;
|
|
d["location"] = Vector3();
|
|
d["rotation"] = Quat();
|
|
d["scale"] = Vector3();
|
|
newval = d;
|
|
|
|
} else if (tt == Animation::TYPE_METHOD) {
|
|
|
|
Dictionary d;
|
|
d["method"] = "";
|
|
d["args"] = Vector<Variant>();
|
|
|
|
newval = d;
|
|
} else if (tt == Animation::TYPE_VALUE) {
|
|
|
|
NodePath np;
|
|
PropertyInfo inf = _find_hint_for_track(idx, np);
|
|
if (inf.type != Variant::NIL) {
|
|
|
|
Variant::CallError err;
|
|
newval = Variant::construct(inf.type, NULL, 0, err);
|
|
}
|
|
|
|
if (newval.get_type() == Variant::NIL) {
|
|
//popup a new type
|
|
cvi_track = idx;
|
|
cvi_pos = pos;
|
|
|
|
type_menu->set_position(get_global_position() + mpos + ofs);
|
|
type_menu->popup();
|
|
return;
|
|
}
|
|
}
|
|
|
|
undo_redo->create_action(TTR("Anim Add Key"));
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", idx, pos, newval, 1);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", idx, pos);
|
|
|
|
if (existing != -1) {
|
|
Variant v = animation->track_get_key_value(idx, existing);
|
|
float trans = animation->track_get_key_transition(idx, existing);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", idx, pos, v, trans);
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (click.click) {
|
|
case ClickOver::CLICK_SELECT_KEYS: {
|
|
|
|
float zoom_scale = _get_zoom_scale();
|
|
float keys_from = h_scroll->get_value();
|
|
float keys_to = keys_from + (settings_limit - name_limit) / zoom_scale;
|
|
|
|
float from_time = keys_from + (click.at.x - (name_limit + ofs.x)) / zoom_scale;
|
|
float to_time = keys_from + (click.to.x - (name_limit + ofs.x)) / zoom_scale;
|
|
|
|
if (to_time < from_time)
|
|
SWAP(from_time, to_time);
|
|
|
|
if (from_time > keys_to || to_time < keys_from)
|
|
break;
|
|
|
|
if (from_time < keys_from)
|
|
from_time = keys_from;
|
|
|
|
if (to_time >= keys_to)
|
|
to_time = keys_to;
|
|
|
|
int from_track = int(click.at.y - ofs.y - h - sep) / h + v_scroll->get_value();
|
|
int to_track = int(click.to.y - ofs.y - h - sep) / h + v_scroll->get_value();
|
|
int from_mod = int(click.at.y - ofs.y - sep) % h;
|
|
int to_mod = int(click.to.y - ofs.y - sep) % h;
|
|
|
|
if (to_track < from_track) {
|
|
|
|
SWAP(from_track, to_track);
|
|
SWAP(from_mod, to_mod);
|
|
}
|
|
|
|
if ((from_mod > (h / 2)) && ((click.at.y - ofs.y) >= (h + sep))) {
|
|
from_track++;
|
|
}
|
|
|
|
if (to_mod < h / 2) {
|
|
to_track--;
|
|
}
|
|
|
|
if (from_track > to_track) {
|
|
if (!click.shift)
|
|
_clear_selection();
|
|
_edit_if_single_selection();
|
|
break;
|
|
}
|
|
|
|
int tracks_from = v_scroll->get_value();
|
|
int tracks_to = v_scroll->get_value() + fit - 1;
|
|
if (tracks_to >= animation->get_track_count())
|
|
tracks_to = animation->get_track_count() - 1;
|
|
|
|
tracks_from = 0;
|
|
tracks_to = animation->get_track_count() - 1;
|
|
if (to_track > tracks_to)
|
|
to_track = tracks_to;
|
|
if (from_track < tracks_from)
|
|
from_track = tracks_from;
|
|
|
|
if (from_track > tracks_to || to_track < tracks_from) {
|
|
if (!click.shift)
|
|
_clear_selection();
|
|
_edit_if_single_selection();
|
|
break;
|
|
}
|
|
|
|
if (!click.shift)
|
|
_clear_selection();
|
|
|
|
int higher_track = 0x7FFFFFFF;
|
|
for (int i = from_track; i <= to_track; i++) {
|
|
|
|
int kc = animation->track_get_key_count(i);
|
|
for (int j = 0; j < kc; j++) {
|
|
|
|
float t = animation->track_get_key_time(i, j);
|
|
if (t < from_time)
|
|
continue;
|
|
if (t > to_time)
|
|
break;
|
|
|
|
if (i < higher_track)
|
|
higher_track = i;
|
|
|
|
SelectedKey sk;
|
|
sk.track = i;
|
|
sk.key = j;
|
|
KeyInfo ki;
|
|
ki.pos = t;
|
|
selection[sk] = ki;
|
|
}
|
|
}
|
|
|
|
if (higher_track != 0x7FFFFFFF) {
|
|
selected_track = higher_track;
|
|
track_editor->update();
|
|
}
|
|
|
|
_edit_if_single_selection();
|
|
|
|
} break;
|
|
case ClickOver::CLICK_MOVE_KEYS: {
|
|
|
|
if (selection.empty())
|
|
break;
|
|
if (click.at == click.to) {
|
|
|
|
if (!click.shift) {
|
|
|
|
KeyInfo ki = selection[click.selk];
|
|
_clear_selection();
|
|
selection[click.selk] = ki;
|
|
_edit_if_single_selection();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
float from_t = 1e20;
|
|
|
|
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;
|
|
}
|
|
|
|
float motion = from_t + (click.to.x - click.at.x) / _get_zoom_scale();
|
|
if (step->get_value())
|
|
motion = Math::stepify(motion, step->get_value());
|
|
|
|
undo_redo->create_action(TTR("Anim Move 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 + 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 = E->get().pos - from_t + 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 = E->get().pos + -from_t + 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);
|
|
}
|
|
|
|
// 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 = oldpos - from_t + 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();
|
|
_edit_if_single_selection();
|
|
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
//button released
|
|
click.click = ClickOver::CLICK_NONE;
|
|
track_editor->update();
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<InputEventMouseMotion> mm = p_input;
|
|
|
|
if (mm.is_valid()) {
|
|
|
|
mouse_over.over = MouseOver::OVER_NONE;
|
|
mouse_over.track = -1;
|
|
te->update();
|
|
track_editor->set_tooltip("");
|
|
|
|
if (!track_editor->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field()))
|
|
track_editor->call_deferred("grab_focus");
|
|
|
|
if (click.click != ClickOver::CLICK_NONE) {
|
|
|
|
switch (click.click) {
|
|
case ClickOver::CLICK_RESIZE_NAMES: {
|
|
|
|
float base = click.at.y;
|
|
float clickp = click.at.x - ofs.x;
|
|
float dif = base - clickp;
|
|
|
|
float target = mm->get_position().x + dif - ofs.x;
|
|
|
|
float ratio = target / settings_limit;
|
|
|
|
if (ratio > 0.9)
|
|
ratio = 0.9;
|
|
else if (ratio < 0.2)
|
|
ratio = 0.2;
|
|
|
|
name_column_ratio = ratio;
|
|
|
|
} break;
|
|
case ClickOver::CLICK_DRAG_TIMELINE: {
|
|
|
|
Point2 mpos = mm->get_position() - ofs;
|
|
/*
|
|
if (mpos.x<name_limit)
|
|
mpos.x=name_limit;
|
|
if (mpos.x>settings_limit)
|
|
mpos.x=settings_limit;
|
|
*/
|
|
|
|
//int zoomw = settings_limit-name_limit;
|
|
float scale = _get_zoom_scale();
|
|
float pos = h_scroll->get_value() + (mpos.x - name_limit) / scale;
|
|
if (animation->get_step()) {
|
|
pos = Math::stepify(pos, animation->get_step());
|
|
}
|
|
if (pos < 0)
|
|
pos = 0;
|
|
if (pos >= animation->get_length())
|
|
pos = animation->get_length();
|
|
|
|
if (pos < h_scroll->get_value()) {
|
|
h_scroll->set_value(pos);
|
|
} else if (pos > h_scroll->get_value() + (settings_limit - name_limit) / scale) {
|
|
h_scroll->set_value(pos - (settings_limit - name_limit) / scale);
|
|
}
|
|
|
|
timeline_pos = pos;
|
|
emit_signal("timeline_changed", pos, true);
|
|
|
|
} break;
|
|
case ClickOver::CLICK_SELECT_KEYS: {
|
|
|
|
click.to = mm->get_position();
|
|
if (click.to.y < h && click.at.y > h && mm->get_relative().y < 0) {
|
|
|
|
float prev = v_scroll->get_value();
|
|
v_scroll->set_value(v_scroll->get_value() - 1);
|
|
if (prev != v_scroll->get_value())
|
|
click.at.y += h;
|
|
}
|
|
if (click.to.y > size.height && click.at.y < size.height && mm->get_relative().y > 0) {
|
|
|
|
float prev = v_scroll->get_value();
|
|
v_scroll->set_value(v_scroll->get_value() + 1);
|
|
if (prev != v_scroll->get_value())
|
|
click.at.y -= h;
|
|
}
|
|
|
|
} break;
|
|
case ClickOver::CLICK_MOVE_KEYS: {
|
|
|
|
click.to = mm->get_position();
|
|
} break;
|
|
default: {}
|
|
}
|
|
|
|
return;
|
|
} else if (mm->get_button_mask() & BUTTON_MASK_MIDDLE) {
|
|
|
|
int rel = mm->get_relative().x;
|
|
float relf = rel / _get_zoom_scale();
|
|
h_scroll->set_value(h_scroll->get_value() - relf);
|
|
}
|
|
|
|
if (mm->get_button_mask() == 0) {
|
|
|
|
Point2 mpos = mm->get_position() - ofs;
|
|
|
|
if (mpos.y < h) {
|
|
return;
|
|
}
|
|
|
|
mpos.y -= h;
|
|
|
|
int idx = mpos.y / h;
|
|
idx += v_scroll->get_value();
|
|
if (idx < 0 || idx >= animation->get_track_count())
|
|
return;
|
|
|
|
mouse_over.track = idx;
|
|
|
|
if (mpos.x < name_limit) {
|
|
//name column
|
|
|
|
mouse_over.over = MouseOver::OVER_NAME;
|
|
|
|
} else if (mpos.x < settings_limit) {
|
|
|
|
float pos = mpos.x - name_limit;
|
|
pos /= _get_zoom_scale();
|
|
pos += h_scroll->get_value();
|
|
float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0;
|
|
|
|
int kidx = animation->track_find_key(idx, pos);
|
|
int kidx_n = kidx + 1;
|
|
|
|
bool found = false;
|
|
|
|
if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) {
|
|
|
|
float kpos = animation->track_get_key_time(idx, kidx);
|
|
if (ABS(pos - kpos) <= w_time) {
|
|
|
|
mouse_over.over = MouseOver::OVER_KEY;
|
|
mouse_over.track = idx;
|
|
mouse_over.over_key = kidx;
|
|
found = true;
|
|
}
|
|
}
|
|
|
|
if (!found && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) {
|
|
|
|
float kpos = animation->track_get_key_time(idx, kidx_n);
|
|
if (ABS(pos - kpos) <= w_time) {
|
|
|
|
mouse_over.over = MouseOver::OVER_KEY;
|
|
mouse_over.track = idx;
|
|
mouse_over.over_key = kidx_n;
|
|
found = true;
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
|
|
String text;
|
|
text = "time: " + rtos(animation->track_get_key_time(idx, mouse_over.over_key)) + "\n";
|
|
|
|
switch (animation->track_get_type(idx)) {
|
|
|
|
case Animation::TYPE_TRANSFORM: {
|
|
|
|
Dictionary d = animation->track_get_key_value(idx, mouse_over.over_key);
|
|
if (d.has("location"))
|
|
text += "location: " + 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(idx, mouse_over.over_key);
|
|
//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(idx), 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";
|
|
}
|
|
|
|
} break;
|
|
case Animation::TYPE_METHOD: {
|
|
|
|
Dictionary d = animation->track_get_key_value(idx, mouse_over.over_key);
|
|
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;
|
|
}
|
|
text += "easing: " + rtos(animation->track_get_key_transition(idx, mouse_over.over_key));
|
|
|
|
track_editor->set_tooltip(text);
|
|
return;
|
|
}
|
|
|
|
} else {
|
|
//button column
|
|
int ofsx = size.width - mpos.x;
|
|
if (ofsx < 0)
|
|
return;
|
|
/*
|
|
if (ofsx < remove_icon->get_width()) {
|
|
|
|
mouse_over.over=MouseOver::OVER_REMOVE;
|
|
|
|
return;
|
|
}
|
|
|
|
ofsx-=hsep+remove_icon->get_width();
|
|
|
|
if (ofsx < move_down_icon->get_width()) {
|
|
|
|
mouse_over.over=MouseOver::OVER_DOWN;
|
|
return;
|
|
}
|
|
|
|
ofsx-=hsep+move_down_icon->get_width();
|
|
|
|
if (ofsx < move_up_icon->get_width()) {
|
|
|
|
mouse_over.over=MouseOver::OVER_UP;
|
|
return;
|
|
}
|
|
|
|
ofsx-=hsep*3+move_up_icon->get_width();
|
|
|
|
*/
|
|
|
|
if (ofsx < down_icon->get_width() + wrap_icon[0]->get_width() + hsep * 3) {
|
|
|
|
mouse_over.over = MouseOver::OVER_WRAP;
|
|
return;
|
|
}
|
|
|
|
ofsx -= hsep * 3 + wrap_icon[0]->get_width() + down_icon->get_width();
|
|
|
|
if (ofsx < down_icon->get_width() + interp_icon[0]->get_width() + hsep * 3) {
|
|
|
|
mouse_over.over = MouseOver::OVER_INTERP;
|
|
return;
|
|
}
|
|
|
|
ofsx -= hsep * 2 + interp_icon[0]->get_width() + down_icon->get_width();
|
|
|
|
if (ofsx < down_icon->get_width() + cont_icon[0]->get_width() + hsep * 3) {
|
|
|
|
mouse_over.over = MouseOver::OVER_VALUE;
|
|
return;
|
|
}
|
|
|
|
ofsx -= hsep * 3 + cont_icon[0]->get_width() + down_icon->get_width();
|
|
|
|
if (ofsx < add_key_icon->get_width()) {
|
|
|
|
mouse_over.over = MouseOver::OVER_ADD_KEY;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<InputEventMagnifyGesture> magnify_gesture = p_input;
|
|
if (magnify_gesture.is_valid()) {
|
|
zoom->set_value(zoom->get_value() * magnify_gesture->get_factor());
|
|
}
|
|
|
|
Ref<InputEventPanGesture> pan_gesture = p_input;
|
|
if (pan_gesture.is_valid()) {
|
|
|
|
h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * pan_gesture->get_delta().x / 8);
|
|
v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * pan_gesture->get_delta().y / 8);
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_notification(int p_what) {
|
|
|
|
switch (p_what) {
|
|
case NOTIFICATION_VISIBILITY_CHANGED: {
|
|
|
|
EditorNode::get_singleton()->update_keying();
|
|
emit_signal("keying_changed");
|
|
} break;
|
|
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
|
|
key_editor->edit(key_edit);
|
|
|
|
zoomicon->set_custom_minimum_size(Size2(24 * EDSCALE, 0));
|
|
zoomicon->set_stretch_mode(TextureRect::STRETCH_KEEP_CENTERED);
|
|
|
|
menu_track->set_icon(get_icon("Tools", "EditorIcons"));
|
|
menu_track->get_popup()->add_item(TTR("Scale Selection"), TRACK_MENU_SCALE);
|
|
menu_track->get_popup()->add_item(TTR("Scale From Cursor"), TRACK_MENU_SCALE_PIVOT);
|
|
menu_track->get_popup()->add_separator();
|
|
menu_track->get_popup()->add_item(TTR("Duplicate Selection"), TRACK_MENU_DUPLICATE);
|
|
menu_track->get_popup()->add_item(TTR("Duplicate Transposed"), TRACK_MENU_DUPLICATE_TRANSPOSE);
|
|
menu_track->get_popup()->add_separator();
|
|
menu_track->get_popup()->add_item(TTR("Goto Next Step"), TRACK_MENU_NEXT_STEP, KEY_MASK_CMD | KEY_RIGHT);
|
|
menu_track->get_popup()->add_item(TTR("Goto Prev Step"), TRACK_MENU_PREV_STEP, KEY_MASK_CMD | KEY_LEFT);
|
|
menu_track->get_popup()->add_separator();
|
|
PopupMenu *tpp = memnew(PopupMenu);
|
|
tpp->add_item(TTR("Linear"), TRACK_MENU_SET_ALL_TRANS_LINEAR);
|
|
tpp->add_item(TTR("Constant"), TRACK_MENU_SET_ALL_TRANS_CONSTANT);
|
|
tpp->add_item(TTR("In"), TRACK_MENU_SET_ALL_TRANS_IN);
|
|
tpp->add_item(TTR("Out"), TRACK_MENU_SET_ALL_TRANS_OUT);
|
|
tpp->add_item(TTR("In-Out"), TRACK_MENU_SET_ALL_TRANS_INOUT);
|
|
tpp->add_item(TTR("Out-In"), TRACK_MENU_SET_ALL_TRANS_OUTIN);
|
|
tpp->set_name(TTR("Transitions"));
|
|
tpp->connect("id_pressed", this, "_menu_track");
|
|
optimize_dialog->connect("confirmed", this, "_animation_optimize");
|
|
|
|
menu_track->get_popup()->add_child(tpp);
|
|
|
|
menu_track->get_popup()->add_item(TTR("Optimize Animation"), TRACK_MENU_OPTIMIZE);
|
|
menu_track->get_popup()->add_item(TTR("Clean-Up Animation"), TRACK_MENU_CLEAN_UP);
|
|
|
|
curve_linear->connect("pressed", this, "_menu_track", varray(CURVE_SET_LINEAR));
|
|
curve_in->connect("pressed", this, "_menu_track", varray(CURVE_SET_IN));
|
|
curve_out->connect("pressed", this, "_menu_track", varray(CURVE_SET_OUT));
|
|
curve_inout->connect("pressed", this, "_menu_track", varray(CURVE_SET_INOUT));
|
|
curve_outin->connect("pressed", this, "_menu_track", varray(CURVE_SET_OUTIN));
|
|
curve_constant->connect("pressed", this, "_menu_track", varray(CURVE_SET_CONSTANT));
|
|
|
|
edit_button->connect("pressed", this, "_toggle_edit_curves");
|
|
|
|
curve_edit->connect("transition_changed", this, "_curve_transition_changed");
|
|
call_select->connect("selected", this, "_add_call_track");
|
|
|
|
_update_menu();
|
|
|
|
} break;
|
|
|
|
case NOTIFICATION_THEME_CHANGED: {
|
|
zoomicon->set_texture(get_icon("Zoom", "EditorIcons"));
|
|
|
|
menu_add_track->set_icon(get_icon("Add", "EditorIcons"));
|
|
|
|
menu_track->set_icon(get_icon("Tools", "EditorIcons"));
|
|
|
|
menu_add_track->get_popup()->set_item_icon(ADD_TRACK_MENU_ADD_VALUE_TRACK, get_icon("KeyValue", "EditorIcons"));
|
|
menu_add_track->get_popup()->set_item_icon(ADD_TRACK_MENU_ADD_TRANSFORM_TRACK, get_icon("KeyXform", "EditorIcons"));
|
|
menu_add_track->get_popup()->set_item_icon(ADD_TRACK_MENU_ADD_CALL_TRACK, get_icon("KeyCall", "EditorIcons"));
|
|
|
|
curve_linear->set_icon(get_icon("CurveLinear", "EditorIcons"));
|
|
curve_in->set_icon(get_icon("CurveIn", "EditorIcons"));
|
|
curve_out->set_icon(get_icon("CurveOut", "EditorIcons"));
|
|
curve_inout->set_icon(get_icon("CurveInOut", "EditorIcons"));
|
|
curve_outin->set_icon(get_icon("CurveOutIn", "EditorIcons"));
|
|
curve_constant->set_icon(get_icon("CurveConstant", "EditorIcons"));
|
|
|
|
move_up_button->set_icon(get_icon("MoveUp", "EditorIcons"));
|
|
move_down_button->set_icon(get_icon("MoveDown", "EditorIcons"));
|
|
remove_button->set_icon(get_icon("Remove", "EditorIcons"));
|
|
edit_button->set_icon(get_icon("EditKey", "EditorIcons"));
|
|
|
|
loop->set_icon(get_icon("Loop", "EditorIcons"));
|
|
|
|
{
|
|
|
|
right_data_size_cache = 0;
|
|
int hsep = get_constant("hseparation", "Tree");
|
|
Ref<Texture> remove_icon = get_icon("Remove", "EditorIcons");
|
|
Ref<Texture> move_up_icon = get_icon("MoveUp", "EditorIcons");
|
|
Ref<Texture> move_down_icon = get_icon("MoveDown", "EditorIcons");
|
|
Ref<Texture> down_icon = get_icon("select_arrow", "Tree");
|
|
Ref<Texture> add_key_icon = get_icon("TrackAddKey", "EditorIcons");
|
|
Ref<Texture> interp_icon[3] = {
|
|
get_icon("InterpRaw", "EditorIcons"),
|
|
get_icon("InterpLinear", "EditorIcons"),
|
|
get_icon("InterpCubic", "EditorIcons")
|
|
};
|
|
Ref<Texture> cont_icon[3] = {
|
|
get_icon("TrackContinuous", "EditorIcons"),
|
|
get_icon("TrackDiscrete", "EditorIcons"),
|
|
get_icon("TrackTrigger", "EditorIcons")
|
|
};
|
|
|
|
Ref<Texture> wrap_icon[2] = {
|
|
get_icon("InterpWrapClamp", "EditorIcons"),
|
|
get_icon("InterpWrapLoop", "EditorIcons"),
|
|
};
|
|
right_data_size_cache = down_icon->get_width() * 3 + add_key_icon->get_width() + interp_icon[0]->get_width() + cont_icon[0]->get_width() + wrap_icon[0]->get_width() + hsep * 9;
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_scroll_changed(double) {
|
|
|
|
if (te_drawing)
|
|
return;
|
|
|
|
track_editor->update();
|
|
}
|
|
|
|
void AnimationKeyEditor::_update_paths() {
|
|
|
|
if (animation.is_valid()) {
|
|
//timeline->set_max(animation->get_length());
|
|
//timeline->set_step(0.01);
|
|
track_editor->update();
|
|
length->set_value(animation->get_length());
|
|
step->set_value(animation->get_step());
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_root_removed() {
|
|
|
|
root = NULL;
|
|
}
|
|
|
|
void AnimationKeyEditor::_update_menu() {
|
|
|
|
updating = true;
|
|
|
|
if (animation.is_valid()) {
|
|
|
|
length->set_value(animation->get_length());
|
|
loop->set_pressed(animation->has_loop());
|
|
step->set_value(animation->get_step());
|
|
}
|
|
|
|
track_editor->update();
|
|
updating = false;
|
|
}
|
|
void AnimationKeyEditor::_clear_selection() {
|
|
|
|
selection.clear();
|
|
key_edit->animation = Ref<Animation>();
|
|
key_edit->track = 0;
|
|
key_edit->key_ofs = 0;
|
|
key_edit->hint = PropertyInfo();
|
|
key_edit->base = NodePath();
|
|
key_edit->notify_change();
|
|
}
|
|
|
|
void AnimationKeyEditor::set_animation(const Ref<Animation> &p_anim) {
|
|
|
|
if (animation.is_valid())
|
|
animation->disconnect("changed", this, "_update_paths");
|
|
animation = p_anim;
|
|
if (animation.is_valid())
|
|
animation->connect("changed", this, "_update_paths");
|
|
|
|
timeline_pos = 0;
|
|
_clear_selection();
|
|
_update_paths();
|
|
|
|
_update_menu();
|
|
selected_track = -1;
|
|
_edit_if_single_selection();
|
|
|
|
EditorNode::get_singleton()->update_keying();
|
|
}
|
|
|
|
void AnimationKeyEditor::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);
|
|
}
|
|
|
|
Node *AnimationKeyEditor::get_root() const {
|
|
|
|
return root;
|
|
}
|
|
|
|
void AnimationKeyEditor::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 AnimationKeyEditor::has_keying() const {
|
|
|
|
return keying;
|
|
}
|
|
|
|
void AnimationKeyEditor::_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->set_text(vformat(TTR("Create NEW track for %s and insert key?"), p_id.query));
|
|
else
|
|
insert_confirm->set_text(vformat(TTR("Create %d NEW tracks and insert keys?"), insert_data.size()));
|
|
|
|
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 AnimationKeyEditor::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 AnimationKeyEditor::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);
|
|
|
|
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
|
|
|
|
int track_idx = -1;
|
|
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
if (animation->track_get_type(i) != Animation::TYPE_VALUE)
|
|
continue;
|
|
if (animation->track_get_path(i) != np)
|
|
continue;
|
|
|
|
track_idx = i;
|
|
break;
|
|
}
|
|
|
|
if (p_only_if_exists && track_idx == -1)
|
|
return;
|
|
InsertData id;
|
|
id.path = np;
|
|
id.track_idx = track_idx;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_VALUE;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = false;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
}
|
|
|
|
void AnimationKeyEditor::insert_value_key(const String &p_property, const Variant &p_value, bool p_advance) {
|
|
|
|
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);
|
|
|
|
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
|
|
|
|
int track_idx = -1;
|
|
|
|
for (int i = 0; i < animation->get_track_count(); i++) {
|
|
|
|
if (animation->track_get_type(i) != Animation::TYPE_VALUE)
|
|
continue;
|
|
if (animation->track_get_path(i) != np)
|
|
continue;
|
|
|
|
track_idx = i;
|
|
break;
|
|
}
|
|
|
|
InsertData id;
|
|
id.path = np;
|
|
id.track_idx = track_idx;
|
|
id.value = p_value;
|
|
id.type = Animation::TYPE_VALUE;
|
|
id.query = "property '" + p_property + "'";
|
|
id.advance = p_advance;
|
|
//dialog insert
|
|
_query_insert(id);
|
|
}
|
|
|
|
void AnimationKeyEditor::_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_data.pop_front();
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
int AnimationKeyEditor::_confirm_insert(InsertData p_id, int p_last_track) {
|
|
|
|
if (p_last_track == -1)
|
|
p_last_track = animation->get_track_count();
|
|
|
|
bool created = false;
|
|
if (p_id.track_idx < 0) {
|
|
|
|
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) {
|
|
//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::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_pos;
|
|
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;
|
|
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->add_do_method(this, "update");
|
|
undo_redo->add_undo_method(this, "update");
|
|
undo_redo->add_do_method(track_editor, "update");
|
|
undo_redo->add_undo_method(track_editor, "update");
|
|
undo_redo->add_do_method(track_pos, "update");
|
|
undo_redo->add_undo_method(track_pos, "update");
|
|
|
|
undo_redo->commit_action();
|
|
|
|
return p_last_track;
|
|
}
|
|
|
|
Ref<Animation> AnimationKeyEditor::get_current_animation() const {
|
|
|
|
return animation;
|
|
}
|
|
|
|
void AnimationKeyEditor::_animation_len_changed(float p_len) {
|
|
|
|
if (updating)
|
|
return;
|
|
|
|
if (!animation.is_null()) {
|
|
|
|
undo_redo->create_action(TTR("Change Anim Len"));
|
|
undo_redo->add_do_method(animation.ptr(), "set_length", p_len);
|
|
undo_redo->add_undo_method(animation.ptr(), "set_length", animation->get_length());
|
|
undo_redo->add_do_method(this, "_animation_len_update");
|
|
undo_redo->add_undo_method(this, "_animation_len_update");
|
|
undo_redo->commit_action();
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_animation_len_update() {
|
|
|
|
if (!animation.is_null())
|
|
emit_signal(alc, animation->get_length());
|
|
}
|
|
|
|
void AnimationKeyEditor::_animation_changed() {
|
|
if (updating)
|
|
return;
|
|
_update_menu();
|
|
}
|
|
|
|
void AnimationKeyEditor::_animation_loop_changed() {
|
|
|
|
if (updating)
|
|
return;
|
|
|
|
if (!animation.is_null()) {
|
|
|
|
undo_redo->create_action(TTR("Change Anim Loop"));
|
|
undo_redo->add_do_method(animation.ptr(), "set_loop", loop->is_pressed());
|
|
undo_redo->add_undo_method(animation.ptr(), "set_loop", !loop->is_pressed());
|
|
undo_redo->commit_action();
|
|
}
|
|
}
|
|
|
|
void AnimationKeyEditor::_create_value_item(int p_type) {
|
|
|
|
undo_redo->create_action(TTR("Anim Create Typed Value Key"));
|
|
|
|
Variant::CallError ce;
|
|
Variant v = Variant::construct(Variant::Type(p_type), NULL, 0, ce);
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", cvi_track, cvi_pos, v);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", cvi_track, cvi_pos);
|
|
|
|
int existing = animation->track_find_key(cvi_track, cvi_pos, true);
|
|
|
|
if (existing != -1) {
|
|
Variant v = animation->track_get_key_value(cvi_track, existing);
|
|
float trans = animation->track_get_key_transition(cvi_track, existing);
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", cvi_track, cvi_pos, v, trans);
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
void AnimationKeyEditor::set_anim_pos(float p_pos) {
|
|
|
|
if (animation.is_null())
|
|
return;
|
|
timeline_pos = p_pos;
|
|
update();
|
|
track_pos->update();
|
|
track_editor->update();
|
|
}
|
|
|
|
void AnimationKeyEditor::_pane_drag(const Point2 &p_delta) {
|
|
|
|
Size2 ecs = ec->get_custom_minimum_size();
|
|
ecs.y -= p_delta.y;
|
|
if (ecs.y < 100)
|
|
ecs.y = 100;
|
|
ec->set_custom_minimum_size(ecs);
|
|
}
|
|
|
|
void AnimationKeyEditor::_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_pos;
|
|
|
|
pos = Math::stepify(pos + step, step);
|
|
if (pos > animation->get_length())
|
|
pos = animation->get_length();
|
|
timeline_pos = pos;
|
|
track_pos->update();
|
|
emit_signal("timeline_changed", pos, true);
|
|
}
|
|
insert_queue = false;
|
|
}
|
|
|
|
void AnimationKeyEditor::_step_changed(float p_len) {
|
|
|
|
updating = true;
|
|
if (!animation.is_null()) {
|
|
animation->set_step(p_len);
|
|
emit_signal("animation_step_changed", animation->get_step());
|
|
}
|
|
updating = false;
|
|
}
|
|
|
|
void AnimationKeyEditor::_scale() {
|
|
|
|
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 == TRACK_MENU_SCALE_PIVOT) {
|
|
pivot = timeline_pos;
|
|
|
|
} 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);
|
|
}
|
|
|
|
// 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();
|
|
}
|
|
|
|
void AnimationKeyEditor::_add_call_track(const NodePath &p_base) {
|
|
|
|
Node *base = EditorNode::get_singleton()->get_edited_scene();
|
|
if (!base)
|
|
return;
|
|
Node *from = base->get_node(p_base);
|
|
if (!from || !root)
|
|
return;
|
|
|
|
NodePath path = root->get_path_to(from);
|
|
|
|
//print_line("root: "+String(root->get_path()));
|
|
//print_line("path: "+String(path));
|
|
|
|
undo_redo->create_action(TTR("Anim Add Call Track"));
|
|
undo_redo->add_do_method(animation.ptr(), "add_track", Animation::TYPE_METHOD);
|
|
undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), path);
|
|
undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
|
|
undo_redo->commit_action();
|
|
}
|
|
|
|
void AnimationKeyEditor::cleanup() {
|
|
|
|
set_animation(Ref<Animation>());
|
|
}
|
|
|
|
void AnimationKeyEditor::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("_root_removed"), &AnimationKeyEditor::_root_removed);
|
|
ClassDB::bind_method(D_METHOD("_scale"), &AnimationKeyEditor::_scale);
|
|
ClassDB::bind_method(D_METHOD("set_root"), &AnimationKeyEditor::set_root);
|
|
|
|
//ClassDB::bind_method(D_METHOD("_confirm_insert"),&AnimationKeyEditor::_confirm_insert);
|
|
ClassDB::bind_method(D_METHOD("_confirm_insert_list"), &AnimationKeyEditor::_confirm_insert_list);
|
|
|
|
ClassDB::bind_method(D_METHOD("_update_paths"), &AnimationKeyEditor::_update_paths);
|
|
ClassDB::bind_method(D_METHOD("_track_editor_draw"), &AnimationKeyEditor::_track_editor_draw);
|
|
|
|
ClassDB::bind_method(D_METHOD("_animation_changed"), &AnimationKeyEditor::_animation_changed);
|
|
ClassDB::bind_method(D_METHOD("_scroll_changed"), &AnimationKeyEditor::_scroll_changed);
|
|
ClassDB::bind_method(D_METHOD("_track_editor_gui_input"), &AnimationKeyEditor::_track_editor_gui_input);
|
|
ClassDB::bind_method(D_METHOD("_track_name_changed"), &AnimationKeyEditor::_track_name_changed);
|
|
ClassDB::bind_method(D_METHOD("_track_menu_selected"), &AnimationKeyEditor::_track_menu_selected);
|
|
ClassDB::bind_method(D_METHOD("_menu_add_track"), &AnimationKeyEditor::_menu_add_track);
|
|
ClassDB::bind_method(D_METHOD("_menu_track"), &AnimationKeyEditor::_menu_track);
|
|
ClassDB::bind_method(D_METHOD("_clear_selection_for_anim"), &AnimationKeyEditor::_clear_selection_for_anim);
|
|
ClassDB::bind_method(D_METHOD("_select_at_anim"), &AnimationKeyEditor::_select_at_anim);
|
|
ClassDB::bind_method(D_METHOD("_track_position_draw"), &AnimationKeyEditor::_track_position_draw);
|
|
ClassDB::bind_method(D_METHOD("_insert_delay"), &AnimationKeyEditor::_insert_delay);
|
|
ClassDB::bind_method(D_METHOD("_step_changed"), &AnimationKeyEditor::_step_changed);
|
|
|
|
ClassDB::bind_method(D_METHOD("_animation_loop_changed"), &AnimationKeyEditor::_animation_loop_changed);
|
|
ClassDB::bind_method(D_METHOD("_animation_len_changed"), &AnimationKeyEditor::_animation_len_changed);
|
|
ClassDB::bind_method(D_METHOD("_create_value_item"), &AnimationKeyEditor::_create_value_item);
|
|
ClassDB::bind_method(D_METHOD("_pane_drag"), &AnimationKeyEditor::_pane_drag);
|
|
|
|
ClassDB::bind_method(D_METHOD("_animation_len_update"), &AnimationKeyEditor::_animation_len_update);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_animation"), &AnimationKeyEditor::set_animation);
|
|
ClassDB::bind_method(D_METHOD("_animation_optimize"), &AnimationKeyEditor::_animation_optimize);
|
|
ClassDB::bind_method(D_METHOD("_curve_transition_changed"), &AnimationKeyEditor::_curve_transition_changed);
|
|
ClassDB::bind_method(D_METHOD("_toggle_edit_curves"), &AnimationKeyEditor::_toggle_edit_curves);
|
|
ClassDB::bind_method(D_METHOD("_add_call_track"), &AnimationKeyEditor::_add_call_track);
|
|
|
|
ADD_SIGNAL(MethodInfo("resource_selected", PropertyInfo(Variant::OBJECT, "res"), PropertyInfo(Variant::STRING, "prop")));
|
|
ADD_SIGNAL(MethodInfo("keying_changed"));
|
|
ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::REAL, "position"), PropertyInfo(Variant::BOOL, "drag")));
|
|
ADD_SIGNAL(MethodInfo("animation_len_changed", PropertyInfo(Variant::REAL, "len")));
|
|
ADD_SIGNAL(MethodInfo("animation_step_changed", PropertyInfo(Variant::REAL, "step")));
|
|
ADD_SIGNAL(MethodInfo("key_edited", PropertyInfo(Variant::INT, "track"), PropertyInfo(Variant::INT, "key")));
|
|
}
|
|
|
|
AnimationKeyEditor::AnimationKeyEditor() {
|
|
|
|
alc = "animation_len_changed";
|
|
editor_selection = EditorNode::get_singleton()->get_editor_selection();
|
|
|
|
selected_track = -1;
|
|
updating = false;
|
|
te_drawing = false;
|
|
undo_redo = EditorNode::get_singleton()->get_undo_redo();
|
|
history = EditorNode::get_singleton()->get_editor_history();
|
|
|
|
ec = memnew(Control);
|
|
ec->set_custom_minimum_size(Size2(0, 150) * EDSCALE);
|
|
add_child(ec);
|
|
ec->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
h_scroll = memnew(HScrollBar);
|
|
h_scroll->connect("value_changed", this, "_scroll_changed");
|
|
add_child(h_scroll);
|
|
h_scroll->set_value(0);
|
|
|
|
HBoxContainer *hb = memnew(HBoxContainer);
|
|
add_child(hb);
|
|
|
|
root = NULL;
|
|
//menu = memnew( MenuButton );
|
|
//menu->set_flat(true);
|
|
//menu->set_position(Point2());
|
|
//add_child(menu);
|
|
|
|
zoomicon = memnew(TextureRect);
|
|
hb->add_child(zoomicon);
|
|
zoomicon->set_tooltip(TTR("Animation zoom."));
|
|
|
|
zoom = memnew(HSlider);
|
|
//hb->add_child(zoom);
|
|
zoom->set_step(0.01);
|
|
zoom->set_min(0.0);
|
|
zoom->set_max(2.0);
|
|
zoom->set_value(1.0);
|
|
zoom->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
zoom->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
zoom->set_stretch_ratio(2);
|
|
hb->add_child(zoom);
|
|
zoom->connect("value_changed", this, "_scroll_changed");
|
|
zoom->set_tooltip(TTR("Animation zoom."));
|
|
|
|
hb->add_child(memnew(VSeparator));
|
|
|
|
Label *l = memnew(Label);
|
|
l->set_text(TTR("Length (s):"));
|
|
hb->add_child(l);
|
|
|
|
length = memnew(SpinBox);
|
|
length->set_min(0.01);
|
|
length->set_max(10000);
|
|
length->set_step(0.01);
|
|
length->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
length->set_stretch_ratio(1);
|
|
length->set_tooltip(TTR("Animation length (in seconds)."));
|
|
|
|
hb->add_child(length);
|
|
length->connect("value_changed", this, "_animation_len_changed");
|
|
|
|
l = memnew(Label);
|
|
l->set_text(TTR("Step (s):"));
|
|
hb->add_child(l);
|
|
|
|
step = memnew(SpinBox);
|
|
step->set_min(0.00);
|
|
step->set_max(128);
|
|
step->set_step(0.01);
|
|
step->set_value(0.0);
|
|
step->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
step->set_stretch_ratio(1);
|
|
step->set_tooltip(TTR("Cursor step snap (in seconds)."));
|
|
|
|
hb->add_child(step);
|
|
step->connect("value_changed", this, "_step_changed");
|
|
|
|
loop = memnew(ToolButton);
|
|
loop->set_toggle_mode(true);
|
|
loop->connect("pressed", this, "_animation_loop_changed");
|
|
hb->add_child(loop);
|
|
loop->set_tooltip(TTR("Enable/Disable looping in animation."));
|
|
|
|
hb->add_child(memnew(VSeparator));
|
|
|
|
menu_add_track = memnew(MenuButton);
|
|
hb->add_child(menu_add_track);
|
|
menu_add_track->get_popup()->connect("id_pressed", this, "_menu_add_track");
|
|
menu_add_track->set_tooltip(TTR("Add new tracks."));
|
|
menu_add_track->get_popup()->add_icon_item(get_icon("KeyValue", "EditorIcons"), "Add Normal Track", ADD_TRACK_MENU_ADD_VALUE_TRACK);
|
|
menu_add_track->get_popup()->add_icon_item(get_icon("KeyXform", "EditorIcons"), "Add Transform Track", ADD_TRACK_MENU_ADD_TRANSFORM_TRACK);
|
|
menu_add_track->get_popup()->add_icon_item(get_icon("KeyCall", "EditorIcons"), "Add Call Func Track", ADD_TRACK_MENU_ADD_CALL_TRACK);
|
|
|
|
move_up_button = memnew(ToolButton);
|
|
hb->add_child(move_up_button);
|
|
move_up_button->connect("pressed", this, "_menu_track", make_binds(TRACK_MENU_MOVE_UP));
|
|
move_up_button->set_focus_mode(FOCUS_NONE);
|
|
move_up_button->set_disabled(true);
|
|
move_up_button->set_tooltip(TTR("Move current track up."));
|
|
|
|
move_down_button = memnew(ToolButton);
|
|
hb->add_child(move_down_button);
|
|
move_down_button->connect("pressed", this, "_menu_track", make_binds(TRACK_MENU_MOVE_DOWN));
|
|
move_down_button->set_focus_mode(FOCUS_NONE);
|
|
move_down_button->set_disabled(true);
|
|
move_down_button->set_tooltip(TTR("Move current track down."));
|
|
|
|
remove_button = memnew(ToolButton);
|
|
hb->add_child(remove_button);
|
|
remove_button->connect("pressed", this, "_menu_track", make_binds(TRACK_MENU_REMOVE));
|
|
remove_button->set_focus_mode(FOCUS_NONE);
|
|
remove_button->set_disabled(true);
|
|
remove_button->set_tooltip(TTR("Remove selected track."));
|
|
|
|
hb->add_child(memnew(VSeparator));
|
|
|
|
menu_track = memnew(MenuButton);
|
|
hb->add_child(menu_track);
|
|
menu_track->get_popup()->connect("id_pressed", this, "_menu_track");
|
|
menu_track->set_tooltip(TTR("Track tools"));
|
|
|
|
edit_button = memnew(ToolButton);
|
|
edit_button->set_toggle_mode(true);
|
|
edit_button->set_focus_mode(FOCUS_NONE);
|
|
edit_button->set_disabled(true);
|
|
|
|
hb->add_child(edit_button);
|
|
edit_button->set_tooltip(TTR("Enable editing of individual keys by clicking them."));
|
|
|
|
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"));
|
|
|
|
/*keying = memnew( Button );
|
|
keying->set_toggle_mode(true);
|
|
//keying->set_text("Keys");
|
|
keying->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,60);
|
|
keying->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,10);
|
|
keying->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,55);
|
|
keying->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,10);
|
|
//add_child(keying);
|
|
keying->connect("pressed",this,"_keying_toggled");
|
|
*/
|
|
|
|
/* l = memnew( Label );
|
|
l->set_text("Base: ");
|
|
l->set_position(Point2(0,3));
|
|
//dr_panel->add_child(l);*/
|
|
|
|
//menu->get_popup()->connect("id_pressed",this,"_menu_callback");
|
|
|
|
hb = memnew(HBoxContainer);
|
|
hb->set_anchors_and_margins_preset(Control::PRESET_WIDE);
|
|
ec->add_child(hb);
|
|
hb->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
track_editor = memnew(Control);
|
|
track_editor->connect("draw", this, "_track_editor_draw");
|
|
hb->add_child(track_editor);
|
|
track_editor->connect("gui_input", this, "_track_editor_gui_input");
|
|
track_editor->set_focus_mode(Control::FOCUS_ALL);
|
|
track_editor->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
track_pos = memnew(Control);
|
|
track_pos->set_anchors_and_margins_preset(Control::PRESET_WIDE);
|
|
track_pos->set_mouse_filter(MOUSE_FILTER_IGNORE);
|
|
track_editor->add_child(track_pos);
|
|
track_pos->connect("draw", this, "_track_position_draw");
|
|
|
|
select_anim_warning = memnew(Label);
|
|
track_editor->add_child(select_anim_warning);
|
|
select_anim_warning->set_anchors_and_margins_preset(Control::PRESET_WIDE);
|
|
select_anim_warning->set_text(TTR("Select an AnimationPlayer from the Scene Tree to edit animations."));
|
|
select_anim_warning->set_autowrap(true);
|
|
select_anim_warning->set_align(Label::ALIGN_CENTER);
|
|
select_anim_warning->set_valign(Label::VALIGN_CENTER);
|
|
|
|
v_scroll = memnew(VScrollBar);
|
|
hb->add_child(v_scroll);
|
|
v_scroll->connect("value_changed", this, "_scroll_changed");
|
|
v_scroll->set_value(0);
|
|
|
|
key_editor_tab = memnew(TabContainer);
|
|
key_editor_tab->set_tab_align(TabContainer::ALIGN_LEFT);
|
|
hb->add_child(key_editor_tab);
|
|
key_editor_tab->set_custom_minimum_size(Size2(200, 0) * EDSCALE);
|
|
|
|
key_editor = memnew(PropertyEditor);
|
|
key_editor->hide_top_label();
|
|
key_editor->set_name(TTR("Key"));
|
|
key_editor_tab->add_child(key_editor);
|
|
|
|
key_edit = memnew(AnimationKeyEdit);
|
|
key_edit->undo_redo = undo_redo;
|
|
//key_edit->ke_dialog=key_edit_dialog;
|
|
|
|
type_menu = memnew(PopupMenu);
|
|
type_menu->set_pass_on_modal_close_click(false);
|
|
add_child(type_menu);
|
|
for (int i = 0; i < Variant::VARIANT_MAX; i++)
|
|
type_menu->add_item(Variant::get_type_name(Variant::Type(i)), i);
|
|
type_menu->connect("id_pressed", this, "_create_value_item");
|
|
|
|
VBoxContainer *curve_vb = memnew(VBoxContainer);
|
|
curve_vb->set_name(TTR("Transition"));
|
|
HBoxContainer *curve_hb = memnew(HBoxContainer);
|
|
curve_vb->add_child(curve_hb);
|
|
|
|
curve_linear = memnew(ToolButton);
|
|
curve_linear->set_focus_mode(FOCUS_NONE);
|
|
curve_hb->add_child(curve_linear);
|
|
curve_in = memnew(ToolButton);
|
|
curve_in->set_focus_mode(FOCUS_NONE);
|
|
curve_hb->add_child(curve_in);
|
|
curve_out = memnew(ToolButton);
|
|
curve_out->set_focus_mode(FOCUS_NONE);
|
|
curve_hb->add_child(curve_out);
|
|
curve_inout = memnew(ToolButton);
|
|
curve_inout->set_focus_mode(FOCUS_NONE);
|
|
curve_hb->add_child(curve_inout);
|
|
curve_outin = memnew(ToolButton);
|
|
curve_outin->set_focus_mode(FOCUS_NONE);
|
|
curve_hb->add_child(curve_outin);
|
|
curve_constant = memnew(ToolButton);
|
|
curve_constant->set_focus_mode(FOCUS_NONE);
|
|
curve_hb->add_child(curve_constant);
|
|
|
|
curve_edit = memnew(AnimationCurveEdit);
|
|
curve_vb->add_child(curve_edit);
|
|
curve_edit->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
key_editor_tab->add_child(curve_vb);
|
|
|
|
track_name = memnew(LineEdit);
|
|
track_name->set_as_toplevel(true);
|
|
track_name->hide();
|
|
add_child(track_name);
|
|
track_name->connect("text_entered", this, "_track_name_changed");
|
|
track_menu = memnew(PopupMenu);
|
|
track_menu->set_pass_on_modal_close_click(false);
|
|
add_child(track_menu);
|
|
track_menu->connect("id_pressed", this, "_track_menu_selected");
|
|
|
|
key_editor_tab->hide();
|
|
|
|
last_idx = 1;
|
|
|
|
_update_menu();
|
|
|
|
insert_confirm = memnew(ConfirmationDialog);
|
|
add_child(insert_confirm);
|
|
insert_confirm->connect("confirmed", this, "_confirm_insert_list");
|
|
|
|
click.click = ClickOver::CLICK_NONE;
|
|
|
|
name_column_ratio = 0.3;
|
|
timeline_pos = 0;
|
|
|
|
keying = false;
|
|
insert_frame = 0;
|
|
insert_query = false;
|
|
insert_queue = false;
|
|
|
|
editor_selection->connect("selection_changed", track_editor, "update");
|
|
|
|
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, "_scale");
|
|
add_child(scale_dialog);
|
|
|
|
call_select = memnew(SceneTreeDialog);
|
|
add_child(call_select);
|
|
call_select->set_title(TTR("Call Functions in Which Node?"));
|
|
|
|
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, "_menu_track", varray(TRACK_MENU_CLEAN_UP_CONFIRM));
|
|
|
|
track_editor->set_clip_contents(true);
|
|
}
|
|
|
|
AnimationKeyEditor::~AnimationKeyEditor() {
|
|
|
|
memdelete(key_edit);
|
|
}
|