2018-08-29 20:38:13 +00:00
|
|
|
/*************************************************************************/
|
|
|
|
/* animation_bezier_editor.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* https://godotengine.org */
|
|
|
|
/*************************************************************************/
|
2022-01-03 20:27:34 +00:00
|
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
2018-08-29 20:38:13 +00:00
|
|
|
/* */
|
|
|
|
/* 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. */
|
|
|
|
/*************************************************************************/
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
#include "animation_bezier_editor.h"
|
|
|
|
|
2018-09-02 21:40:51 +00:00
|
|
|
#include "editor/editor_node.h"
|
2022-02-12 01:46:22 +00:00
|
|
|
#include "editor/editor_scale.h"
|
2022-03-25 17:06:46 +00:00
|
|
|
#include "editor/editor_undo_redo_manager.h"
|
2022-01-13 16:19:15 +00:00
|
|
|
#include "scene/gui/view_panner.h"
|
2020-09-03 11:22:16 +00:00
|
|
|
#include "scene/resources/text_line.h"
|
2018-09-02 21:40:51 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
#include <limits.h>
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
float AnimationBezierTrackEdit::_bezier_h_to_pixel(float p_h) {
|
|
|
|
float h = p_h;
|
|
|
|
h = (h - v_scroll) / v_zoom;
|
2022-08-22 10:45:30 +00:00
|
|
|
h = (get_size().height / 2.0) - h;
|
2018-06-07 15:46:14 +00:00
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::_draw_track(int p_track, const Color &p_color) {
|
|
|
|
float scale = timeline->get_zoom_scale();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
int limit = timeline->get_name_limit();
|
2021-11-09 15:05:28 +00:00
|
|
|
int right_limit = get_size().width;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
//selection may have altered the order of keys
|
2022-08-22 10:45:30 +00:00
|
|
|
RBMap<real_t, int> key_order;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < animation->track_get_key_count(p_track); i++) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t ofs = animation->track_get_key_time(p_track, i);
|
2021-11-09 15:05:28 +00:00
|
|
|
if (moving_selection && selection.has(IntPair(p_track, i))) {
|
2018-06-07 15:46:14 +00:00
|
|
|
ofs += moving_selection_offset.x;
|
|
|
|
}
|
|
|
|
|
|
|
|
key_order[ofs] = i;
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
for (RBMap<real_t, int>::Element *E = key_order.front(); E; E = E->next()) {
|
2018-06-07 15:46:14 +00:00
|
|
|
int i = E->get();
|
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!E->next()) {
|
2018-06-07 15:46:14 +00:00
|
|
|
break;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
int i_n = E->next()->get();
|
|
|
|
|
|
|
|
float offset = animation->track_get_key_time(p_track, i);
|
|
|
|
float height = animation->bezier_track_get_key_value(p_track, i);
|
|
|
|
Vector2 out_handle = animation->bezier_track_get_key_out_handle(p_track, i);
|
2022-08-22 10:45:30 +00:00
|
|
|
if (p_track == moving_handle_track && (moving_handle == -1 || moving_handle == 1) && moving_handle_key == i) {
|
2018-06-07 15:46:14 +00:00
|
|
|
out_handle = moving_handle_right;
|
|
|
|
}
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
if (moving_selection && selection.has(IntPair(p_track, i))) {
|
2018-06-07 15:46:14 +00:00
|
|
|
offset += moving_selection_offset.x;
|
|
|
|
height += moving_selection_offset.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
out_handle += Vector2(offset, height);
|
|
|
|
|
|
|
|
float offset_n = animation->track_get_key_time(p_track, i_n);
|
|
|
|
float height_n = animation->bezier_track_get_key_value(p_track, i_n);
|
|
|
|
Vector2 in_handle = animation->bezier_track_get_key_in_handle(p_track, i_n);
|
2022-08-22 10:45:30 +00:00
|
|
|
if (p_track == moving_handle_track && (moving_handle == -1 || moving_handle == 1) && moving_handle_key == i_n) {
|
2018-06-07 15:46:14 +00:00
|
|
|
in_handle = moving_handle_left;
|
|
|
|
}
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
if (moving_selection && selection.has(IntPair(p_track, i_n))) {
|
2018-06-07 15:46:14 +00:00
|
|
|
offset_n += moving_selection_offset.x;
|
|
|
|
height_n += moving_selection_offset.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
in_handle += Vector2(offset_n, height_n);
|
|
|
|
|
|
|
|
Vector2 start(offset, height);
|
|
|
|
Vector2 end(offset_n, height_n);
|
|
|
|
|
|
|
|
int from_x = (offset - timeline->get_value()) * scale + limit;
|
|
|
|
int point_start = from_x;
|
|
|
|
int to_x = (offset_n - timeline->get_value()) * scale + limit;
|
|
|
|
int point_end = to_x;
|
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (from_x > right_limit) { //not visible
|
2018-06-07 15:46:14 +00:00
|
|
|
continue;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (to_x < limit) { //not visible
|
2018-06-07 15:46:14 +00:00
|
|
|
continue;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
from_x = MAX(from_x, limit);
|
|
|
|
to_x = MIN(to_x, right_limit);
|
|
|
|
|
|
|
|
Vector<Vector2> lines;
|
|
|
|
|
|
|
|
Vector2 prev_pos;
|
|
|
|
|
|
|
|
for (int j = from_x; j <= to_x; j++) {
|
|
|
|
float t = (j - limit) / scale + timeline->get_value();
|
|
|
|
|
|
|
|
float h;
|
|
|
|
|
|
|
|
if (j == point_end) {
|
|
|
|
h = end.y; //make sure it always connects
|
|
|
|
} else if (j == point_start) {
|
|
|
|
h = start.y; //make sure it always connects
|
|
|
|
} else { //custom interpolation, used because it needs to show paths affected by moving the selection or handles
|
|
|
|
int iterations = 10;
|
|
|
|
float low = 0;
|
|
|
|
float high = 1;
|
|
|
|
|
|
|
|
//narrow high and low as much as possible
|
|
|
|
for (int k = 0; k < iterations; k++) {
|
2022-08-22 10:45:30 +00:00
|
|
|
float middle = (low + high) / 2.0;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-06-27 17:41:32 +00:00
|
|
|
Vector2 interp = start.bezier_interpolate(out_handle, in_handle, end, middle);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
if (interp.x < t) {
|
|
|
|
low = middle;
|
|
|
|
} else {
|
|
|
|
high = middle;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//interpolate the result:
|
2022-06-27 17:41:32 +00:00
|
|
|
Vector2 low_pos = start.bezier_interpolate(out_handle, in_handle, end, low);
|
|
|
|
Vector2 high_pos = start.bezier_interpolate(out_handle, in_handle, end, high);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
float c = (t - low_pos.x) / (high_pos.x - low_pos.x);
|
|
|
|
|
2020-03-16 09:07:33 +00:00
|
|
|
h = low_pos.lerp(high_pos, c).y;
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
h = _bezier_h_to_pixel(h);
|
|
|
|
|
|
|
|
Vector2 pos(j, h);
|
|
|
|
|
|
|
|
if (j > from_x) {
|
|
|
|
lines.push_back(prev_pos);
|
|
|
|
lines.push_back(pos);
|
|
|
|
}
|
|
|
|
prev_pos = pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lines.size() >= 2) {
|
2021-05-09 07:54:15 +00:00
|
|
|
draw_multiline(lines, p_color, Math::round(EDSCALE));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::_draw_line_clipped(const Vector2 &p_from, const Vector2 &p_to, const Color &p_color, int p_clip_left, int p_clip_right) {
|
|
|
|
Vector2 from = p_from;
|
|
|
|
Vector2 to = p_to;
|
|
|
|
|
2021-09-03 14:02:53 +00:00
|
|
|
if (from.x == to.x && from.y == to.y) {
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
if (to.x < from.x) {
|
|
|
|
SWAP(to, from);
|
|
|
|
}
|
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (to.x < p_clip_left) {
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (from.x > p_clip_right) {
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
if (to.x > p_clip_right) {
|
|
|
|
float c = (p_clip_right - from.x) / (to.x - from.x);
|
2020-03-16 09:07:33 +00:00
|
|
|
to = from.lerp(to, c);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (from.x < p_clip_left) {
|
|
|
|
float c = (p_clip_left - from.x) / (to.x - from.x);
|
2020-03-16 09:07:33 +00:00
|
|
|
from = from.lerp(to, c);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
2021-05-09 07:54:15 +00:00
|
|
|
draw_line(from, to, p_color, Math::round(EDSCALE));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::_notification(int p_what) {
|
2022-02-15 23:52:32 +00:00
|
|
|
switch (p_what) {
|
|
|
|
case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: {
|
|
|
|
panner->setup((ViewPanner::ControlScheme)EDITOR_GET("editors/panning/animation_editors_panning_scheme").operator int(), ED_GET_SHORTCUT("canvas_item_editor/pan_view"), bool(EditorSettings::get_singleton()->get("editors/panning/simple_panning")));
|
|
|
|
} break;
|
|
|
|
|
|
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
|
|
panner->setup((ViewPanner::ControlScheme)EDITOR_GET("editors/panning/animation_editors_panning_scheme").operator int(), ED_GET_SHORTCUT("canvas_item_editor/pan_view"), bool(EditorSettings::get_singleton()->get("editors/panning/simple_panning")));
|
2022-08-29 09:04:31 +00:00
|
|
|
[[fallthrough]];
|
|
|
|
}
|
2022-02-15 23:52:32 +00:00
|
|
|
case NOTIFICATION_THEME_CHANGED: {
|
|
|
|
bezier_icon = get_theme_icon(SNAME("KeyBezierPoint"), SNAME("EditorIcons"));
|
|
|
|
bezier_handle_icon = get_theme_icon(SNAME("KeyBezierHandle"), SNAME("EditorIcons"));
|
|
|
|
selected_icon = get_theme_icon(SNAME("KeyBezierSelected"), SNAME("EditorIcons"));
|
|
|
|
} break;
|
|
|
|
|
|
|
|
case NOTIFICATION_DRAW: {
|
|
|
|
if (animation.is_null()) {
|
|
|
|
return;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int limit = timeline->get_name_limit();
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (has_focus()) {
|
|
|
|
Color accent = get_theme_color(SNAME("accent_color"), SNAME("Editor"));
|
|
|
|
accent.a *= 0.7;
|
|
|
|
draw_rect(Rect2(Point2(), get_size()), accent, false, Math::round(EDSCALE));
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Ref<Font> font = get_theme_font(SNAME("font"), SNAME("Label"));
|
|
|
|
int font_size = get_theme_font_size(SNAME("font_size"), SNAME("Label"));
|
|
|
|
Color color = get_theme_color(SNAME("font_color"), SNAME("Label"));
|
2022-04-14 21:20:28 +00:00
|
|
|
int hsep = get_theme_constant(SNAME("h_separation"), SNAME("ItemList"));
|
|
|
|
int vsep = get_theme_constant(SNAME("v_separation"), SNAME("ItemList"));
|
2022-02-15 23:52:32 +00:00
|
|
|
Color linecolor = color;
|
|
|
|
linecolor.a = 0.2;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
draw_line(Point2(limit, 0), Point2(limit, get_size().height), linecolor, Math::round(EDSCALE));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int right_limit = get_size().width;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int vofs = vsep;
|
|
|
|
int margin = 0;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-13 13:04:37 +00:00
|
|
|
RBMap<int, Color> subtrack_colors;
|
2022-02-15 23:52:32 +00:00
|
|
|
Color selected_track_color;
|
|
|
|
subtracks.clear();
|
|
|
|
subtrack_icons.clear();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-05-13 13:04:37 +00:00
|
|
|
RBMap<String, Vector<int>> track_indices;
|
2022-02-15 23:52:32 +00:00
|
|
|
int track_count = animation->get_track_count();
|
|
|
|
for (int i = 0; i < track_count; ++i) {
|
|
|
|
if (animation->track_get_type(i) != Animation::TrackType::TYPE_BEZIER) {
|
|
|
|
continue;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
String base_path = animation->track_get_path(i);
|
|
|
|
if (is_filtered) {
|
|
|
|
if (root && root->has_node(base_path)) {
|
|
|
|
Node *node = root->get_node(base_path);
|
|
|
|
if (!node) {
|
|
|
|
continue; // No node, no filter.
|
|
|
|
}
|
|
|
|
if (!EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
|
|
|
|
continue; // Skip track due to not selected.
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int end = base_path.find(":");
|
|
|
|
if (end != -1) {
|
|
|
|
base_path = base_path.substr(0, end + 1);
|
|
|
|
}
|
|
|
|
Vector<int> indices = track_indices.has(base_path) ? track_indices[base_path] : Vector<int>();
|
|
|
|
indices.push_back(i);
|
|
|
|
track_indices[base_path] = indices;
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
for (const KeyValue<String, Vector<int>> &E : track_indices) {
|
|
|
|
String base_path = E.key;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector<int> tracks = E.value;
|
2019-07-01 10:59:42 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
// NAMES AND ICON
|
|
|
|
{
|
|
|
|
NodePath path = animation->track_get_path(tracks[0]);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Node *node = nullptr;
|
2020-09-03 11:22:16 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (root && root->has_node(path)) {
|
|
|
|
node = root->get_node(path);
|
|
|
|
}
|
2020-09-03 11:22:16 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
String text;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (node) {
|
|
|
|
int ofs = 0;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Ref<Texture2D> icon = EditorNode::get_singleton()->get_object_icon(node, "Node");
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
text = node->get_name();
|
|
|
|
ofs += hsep;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
TextLine text_buf = TextLine(text, font, font_size);
|
|
|
|
text_buf.set_width(limit - ofs - icon->get_width() - hsep);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int h = MAX(text_buf.get_size().y, icon->get_height());
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
draw_texture(icon, Point2(ofs, vofs + int(h - icon->get_height()) / 2.0));
|
2022-02-15 23:52:32 +00:00
|
|
|
ofs += icon->get_width();
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
margin = icon->get_width();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector2 string_pos = Point2(ofs, vofs);
|
|
|
|
string_pos = string_pos.floor();
|
|
|
|
text_buf.draw(get_canvas_item(), string_pos, color);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
vofs += h + vsep;
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
Color dc = get_theme_color(SNAME("disabled_font_color"), SNAME("Editor"));
|
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Ref<Texture2D> remove = get_theme_icon(SNAME("Remove"), SNAME("EditorIcons"));
|
|
|
|
float remove_hpos = limit - hsep - remove->get_width();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Ref<Texture2D> lock = get_theme_icon(SNAME("Lock"), SNAME("EditorIcons"));
|
|
|
|
Ref<Texture2D> unlock = get_theme_icon(SNAME("Unlock"), SNAME("EditorIcons"));
|
|
|
|
float lock_hpos = remove_hpos - hsep - lock->get_width();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Ref<Texture2D> visible = get_theme_icon(SNAME("GuiVisibilityVisible"), SNAME("EditorIcons"));
|
|
|
|
Ref<Texture2D> hidden = get_theme_icon(SNAME("GuiVisibilityHidden"), SNAME("EditorIcons"));
|
|
|
|
float visibility_hpos = lock_hpos - hsep - visible->get_width();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Ref<Texture2D> solo = get_theme_icon(SNAME("AudioBusSolo"), SNAME("EditorIcons"));
|
|
|
|
float solo_hpos = visibility_hpos - hsep - solo->get_width();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
float buttons_width = remove->get_width() + lock->get_width() + visible->get_width() + solo->get_width() + hsep * 3;
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
for (int i = 0; i < tracks.size(); ++i) {
|
|
|
|
// RELATED TRACKS TITLES
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int current_track = tracks[i];
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
String path = animation->track_get_path(current_track);
|
|
|
|
path = path.replace_first(base_path, "");
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Color cc = color;
|
|
|
|
TextLine text_buf = TextLine(path, font, font_size);
|
|
|
|
text_buf.set_width(limit - margin - buttons_width);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Rect2 rect = Rect2(margin, vofs, solo_hpos - hsep - solo->get_width(), text_buf.get_size().y + vsep);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
cc.a *= 0.7;
|
|
|
|
float h;
|
|
|
|
if (path.ends_with(":x")) {
|
|
|
|
h = 0;
|
|
|
|
} else if (path.ends_with(":y")) {
|
|
|
|
h = 0.33f;
|
|
|
|
} else if (path.ends_with(":z")) {
|
|
|
|
h = 0.66f;
|
2021-11-09 15:05:28 +00:00
|
|
|
} else {
|
2022-02-15 23:52:32 +00:00
|
|
|
uint32_t hash = path.hash();
|
|
|
|
hash = ((hash >> 16) ^ hash) * 0x45d9f3b;
|
|
|
|
hash = ((hash >> 16) ^ hash) * 0x45d9f3b;
|
|
|
|
hash = (hash >> 16) ^ hash;
|
|
|
|
h = (hash % 65535) / 65536.0;
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2022-02-15 23:52:32 +00:00
|
|
|
|
|
|
|
if (current_track != selected_track) {
|
|
|
|
Color track_color;
|
|
|
|
if (locked_tracks.has(current_track)) {
|
|
|
|
track_color.set_hsv(h, 0, 0.4);
|
|
|
|
} else {
|
|
|
|
track_color.set_hsv(h, 0.2, 0.8);
|
|
|
|
}
|
|
|
|
track_color.a = 0.5;
|
|
|
|
draw_rect(Rect2(0, vofs, margin - hsep, text_buf.get_size().y * 0.8), track_color);
|
|
|
|
subtrack_colors[current_track] = track_color;
|
|
|
|
|
|
|
|
subtracks[current_track] = rect;
|
2021-11-09 15:05:28 +00:00
|
|
|
} else {
|
2022-02-15 23:52:32 +00:00
|
|
|
Color ac = get_theme_color(SNAME("accent_color"), SNAME("Editor"));
|
|
|
|
ac.a = 0.5;
|
|
|
|
draw_rect(rect, ac);
|
|
|
|
if (locked_tracks.has(selected_track)) {
|
|
|
|
selected_track_color.set_hsv(h, 0.0, 0.4);
|
|
|
|
} else {
|
|
|
|
selected_track_color.set_hsv(h, 0.8, 0.8);
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector2 string_pos = Point2(margin, vofs);
|
|
|
|
text_buf.draw(get_canvas_item(), string_pos, cc);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
float icon_start_height = vofs + rect.size.y / 2.0;
|
|
|
|
Rect2 remove_rect = Rect2(remove_hpos, icon_start_height - remove->get_height() / 2.0, remove->get_width(), remove->get_height());
|
2022-05-04 00:17:08 +00:00
|
|
|
if (read_only) {
|
|
|
|
draw_texture(remove, remove_rect.position, dc);
|
|
|
|
} else {
|
|
|
|
draw_texture(remove, remove_rect.position);
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
Rect2 lock_rect = Rect2(lock_hpos, icon_start_height - lock->get_height() / 2.0, lock->get_width(), lock->get_height());
|
2022-02-15 23:52:32 +00:00
|
|
|
if (locked_tracks.has(current_track)) {
|
|
|
|
draw_texture(lock, lock_rect.position);
|
|
|
|
} else {
|
|
|
|
draw_texture(unlock, lock_rect.position);
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
Rect2 visible_rect = Rect2(visibility_hpos, icon_start_height - visible->get_height() / 2.0, visible->get_width(), visible->get_height());
|
2022-02-15 23:52:32 +00:00
|
|
|
if (hidden_tracks.has(current_track)) {
|
|
|
|
draw_texture(hidden, visible_rect.position);
|
|
|
|
} else {
|
|
|
|
draw_texture(visible, visible_rect.position);
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
Rect2 solo_rect = Rect2(solo_hpos, icon_start_height - solo->get_height() / 2.0, solo->get_width(), solo->get_height());
|
2022-02-15 23:52:32 +00:00
|
|
|
draw_texture(solo, solo_rect.position);
|
2020-09-03 11:22:16 +00:00
|
|
|
|
2022-05-13 13:04:37 +00:00
|
|
|
RBMap<int, Rect2> track_icons;
|
2022-02-15 23:52:32 +00:00
|
|
|
track_icons[REMOVE_ICON] = remove_rect;
|
|
|
|
track_icons[LOCK_ICON] = lock_rect;
|
|
|
|
track_icons[VISIBILITY_ICON] = visible_rect;
|
|
|
|
track_icons[SOLO_ICON] = solo_rect;
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
subtrack_icons[current_track] = track_icons;
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
vofs += text_buf.get_size().y + vsep;
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Color accent = get_theme_color(SNAME("accent_color"), SNAME("Editor"));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
{ //guides
|
|
|
|
float min_left_scale = font->get_height(font_size) + vsep;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
float scale = (min_left_scale * 2) * v_zoom;
|
|
|
|
float step = Math::pow(10.0, Math::round(Math::log(scale / 5.0) / Math::log(10.0))) * 5.0;
|
|
|
|
scale = Math::snapped(scale, step);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
while (scale / v_zoom < min_left_scale * 2) {
|
|
|
|
scale += step;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
bool first = true;
|
|
|
|
int prev_iv = 0;
|
|
|
|
for (int i = font->get_height(font_size); i < get_size().height; i++) {
|
2022-08-22 10:45:30 +00:00
|
|
|
float ofs = get_size().height / 2.0 - i;
|
2022-02-15 23:52:32 +00:00
|
|
|
ofs *= v_zoom;
|
|
|
|
ofs += v_scroll;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int iv = int(ofs / scale);
|
|
|
|
if (ofs < 0) {
|
|
|
|
iv -= 1;
|
|
|
|
}
|
|
|
|
if (!first && iv != prev_iv) {
|
|
|
|
Color lc = linecolor;
|
|
|
|
lc.a *= 0.5;
|
|
|
|
draw_line(Point2(limit, i), Point2(right_limit, i), lc, Math::round(EDSCALE));
|
|
|
|
Color c = color;
|
|
|
|
c.a *= 0.5;
|
|
|
|
draw_string(font, Point2(limit + 8, i - 2), TS->format_number(rtos(Math::snapped((iv + 1) * scale, step))), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, c);
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
first = false;
|
|
|
|
prev_iv = iv;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
{ //draw OTHER curves
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
float scale = timeline->get_zoom_scale();
|
|
|
|
Ref<Texture2D> point = get_theme_icon(SNAME("KeyValue"), SNAME("EditorIcons"));
|
|
|
|
for (const KeyValue<int, Color> &E : subtrack_colors) {
|
|
|
|
if (hidden_tracks.has(E.key)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
_draw_track(E.key, E.value);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
for (int i = 0; i < animation->track_get_key_count(E.key); i++) {
|
|
|
|
float offset = animation->track_get_key_time(E.key, i);
|
|
|
|
float value = animation->bezier_track_get_key_value(E.key, i);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector2 pos((offset - timeline->get_value()) * scale + limit, _bezier_h_to_pixel(value));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (pos.x >= limit && pos.x <= right_limit) {
|
2022-08-22 10:45:30 +00:00
|
|
|
draw_texture(point, pos - point->get_size() / 2.0, E.value);
|
2022-02-15 23:52:32 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (track_count > 0 && !hidden_tracks.has(selected_track)) {
|
|
|
|
//draw edited curve
|
|
|
|
_draw_track(selected_track, selected_track_color);
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
//draw editor handles
|
|
|
|
{
|
|
|
|
edit_points.clear();
|
|
|
|
float scale = timeline->get_zoom_scale();
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
for (int i = 0; i < track_count; ++i) {
|
|
|
|
if (animation->track_get_type(i) != Animation::TrackType::TYPE_BEZIER || hidden_tracks.has(i)) {
|
|
|
|
continue;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (hidden_tracks.has(i) || locked_tracks.has(i)) {
|
|
|
|
continue;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
int key_count = animation->track_get_key_count(i);
|
|
|
|
String path = animation->track_get_path(i);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (is_filtered) {
|
|
|
|
if (root && root->has_node(path)) {
|
|
|
|
Node *node = root->get_node(path);
|
|
|
|
if (!node) {
|
|
|
|
continue; // No node, no filter.
|
|
|
|
}
|
|
|
|
if (!EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
|
|
|
|
continue; // Skip track due to not selected.
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
for (int j = 0; j < key_count; ++j) {
|
|
|
|
float offset = animation->track_get_key_time(i, j);
|
|
|
|
float value = animation->bezier_track_get_key_value(i, j);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (moving_selection && selection.has(IntPair(i, j))) {
|
|
|
|
offset += moving_selection_offset.x;
|
|
|
|
value += moving_selection_offset.y;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector2 pos((offset - timeline->get_value()) * scale + limit, _bezier_h_to_pixel(value));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector2 in_vec = animation->bezier_track_get_key_in_handle(i, j);
|
2022-08-22 10:45:30 +00:00
|
|
|
|
|
|
|
if ((moving_handle == 1 || moving_handle == -1) && moving_handle_track == i && moving_handle_key == j) {
|
2022-02-15 23:52:32 +00:00
|
|
|
in_vec = moving_handle_left;
|
|
|
|
}
|
|
|
|
Vector2 pos_in(((offset + in_vec.x) - timeline->get_value()) * scale + limit, _bezier_h_to_pixel(value + in_vec.y));
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector2 out_vec = animation->bezier_track_get_key_out_handle(i, j);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
if ((moving_handle == 1 || moving_handle == -1) && moving_handle_track == i && moving_handle_key == j) {
|
2022-02-15 23:52:32 +00:00
|
|
|
out_vec = moving_handle_right;
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
Vector2 pos_out(((offset + out_vec.x) - timeline->get_value()) * scale + limit, _bezier_h_to_pixel(value + out_vec.y));
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (i == selected_track || selection.has(IntPair(i, j))) {
|
|
|
|
_draw_line_clipped(pos, pos_in, accent, limit, right_limit);
|
|
|
|
_draw_line_clipped(pos, pos_out, accent, limit, right_limit);
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
EditPoint ep;
|
|
|
|
ep.track = i;
|
|
|
|
ep.key = j;
|
|
|
|
if (pos.x >= limit && pos.x <= right_limit) {
|
2022-08-22 10:45:30 +00:00
|
|
|
ep.point_rect.position = (pos - bezier_icon->get_size() / 2.0).floor();
|
2022-02-15 23:52:32 +00:00
|
|
|
ep.point_rect.size = bezier_icon->get_size();
|
|
|
|
if (selection.has(IntPair(i, j))) {
|
|
|
|
draw_texture(selected_icon, ep.point_rect.position);
|
|
|
|
draw_string(font, ep.point_rect.position + Vector2(8, -font->get_height(font_size) - 8), TTR("Time:") + " " + TS->format_number(rtos(Math::snapped(offset, 0.001))), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, accent);
|
|
|
|
draw_string(font, ep.point_rect.position + Vector2(8, -8), TTR("Value:") + " " + TS->format_number(rtos(Math::snapped(value, 0.001))), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, accent);
|
|
|
|
} else {
|
|
|
|
Color track_color = Color(1, 1, 1, 1);
|
|
|
|
if (i != selected_track) {
|
|
|
|
track_color = subtrack_colors[i];
|
|
|
|
}
|
|
|
|
draw_texture(bezier_icon, ep.point_rect.position, track_color);
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2022-02-15 23:52:32 +00:00
|
|
|
ep.point_rect = ep.point_rect.grow(ep.point_rect.size.width * 0.5);
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2022-08-22 10:45:30 +00:00
|
|
|
ep.point_rect = ep.point_rect.grow(ep.point_rect.size.width * 0.5);
|
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (i == selected_track || selection.has(IntPair(i, j))) {
|
2022-08-22 10:45:30 +00:00
|
|
|
if (animation->bezier_track_get_key_handle_mode(i, j) != Animation::HANDLE_MODE_LINEAR) {
|
|
|
|
if (pos_in.x >= limit && pos_in.x <= right_limit) {
|
|
|
|
ep.in_rect.position = (pos_in - bezier_handle_icon->get_size() / 2.0).floor();
|
|
|
|
ep.in_rect.size = bezier_handle_icon->get_size();
|
|
|
|
draw_texture(bezier_handle_icon, ep.in_rect.position);
|
|
|
|
ep.in_rect = ep.in_rect.grow(ep.in_rect.size.width * 0.5);
|
|
|
|
}
|
|
|
|
if (pos_out.x >= limit && pos_out.x <= right_limit) {
|
|
|
|
ep.out_rect.position = (pos_out - bezier_handle_icon->get_size() / 2.0).floor();
|
|
|
|
ep.out_rect.size = bezier_handle_icon->get_size();
|
|
|
|
draw_texture(bezier_handle_icon, ep.out_rect.position);
|
|
|
|
ep.out_rect = ep.out_rect.grow(ep.out_rect.size.width * 0.5);
|
|
|
|
}
|
2022-02-15 23:52:32 +00:00
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2022-02-15 23:52:32 +00:00
|
|
|
if (!locked_tracks.has(i)) {
|
|
|
|
edit_points.push_back(ep);
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
for (int i = 0; i < edit_points.size(); ++i) {
|
|
|
|
if (edit_points[i].track == selected_track) {
|
|
|
|
EditPoint ep = edit_points[i];
|
|
|
|
edit_points.remove_at(i);
|
|
|
|
edit_points.insert(0, ep);
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-15 23:52:32 +00:00
|
|
|
if (box_selecting) {
|
|
|
|
Vector2 bs_from = box_selection_from;
|
|
|
|
Vector2 bs_to = box_selection_to;
|
|
|
|
if (bs_from.x > bs_to.x) {
|
|
|
|
SWAP(bs_from.x, bs_to.x);
|
|
|
|
}
|
|
|
|
if (bs_from.y > bs_to.y) {
|
|
|
|
SWAP(bs_from.y, bs_to.y);
|
|
|
|
}
|
|
|
|
draw_rect(
|
|
|
|
Rect2(bs_from, bs_to - bs_from),
|
|
|
|
get_theme_color(SNAME("box_selection_fill_color"), SNAME("Editor")));
|
|
|
|
draw_rect(
|
|
|
|
Rect2(bs_from, bs_to - bs_from),
|
|
|
|
get_theme_color(SNAME("box_selection_stroke_color"), SNAME("Editor")),
|
|
|
|
false,
|
|
|
|
Math::round(EDSCALE));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
2022-02-15 23:52:32 +00:00
|
|
|
} break;
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ref<Animation> AnimationBezierTrackEdit::get_animation() const {
|
|
|
|
return animation;
|
|
|
|
}
|
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
void AnimationBezierTrackEdit::set_animation_and_track(const Ref<Animation> &p_animation, int p_track, bool p_read_only) {
|
2018-06-07 15:46:14 +00:00
|
|
|
animation = p_animation;
|
2022-05-04 00:17:08 +00:00
|
|
|
read_only = p_read_only;
|
2021-11-09 15:05:28 +00:00
|
|
|
selected_track = p_track;
|
2018-06-07 15:46:14 +00:00
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
|
|
|
Size2 AnimationBezierTrackEdit::get_minimum_size() const {
|
|
|
|
return Vector2(1, 1);
|
|
|
|
}
|
|
|
|
|
2022-03-25 17:06:46 +00:00
|
|
|
void AnimationBezierTrackEdit::set_undo_redo(Ref<EditorUndoRedoManager> p_undo_redo) {
|
2018-06-07 15:46:14 +00:00
|
|
|
undo_redo = p_undo_redo;
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::set_timeline(AnimationTimelineEdit *p_timeline) {
|
|
|
|
timeline = p_timeline;
|
2020-02-21 17:28:45 +00:00
|
|
|
timeline->connect("zoom_changed", callable_mp(this, &AnimationBezierTrackEdit::_zoom_changed));
|
2021-11-09 15:05:28 +00:00
|
|
|
timeline->connect("name_limit_changed", callable_mp(this, &AnimationBezierTrackEdit::_zoom_changed));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
2020-05-14 12:29:06 +00:00
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
void AnimationBezierTrackEdit::set_editor(AnimationTrackEditor *p_editor) {
|
|
|
|
editor = p_editor;
|
2022-07-28 20:56:41 +00:00
|
|
|
connect("clear_selection", Callable(editor, "_clear_selection").bind(false));
|
|
|
|
connect("select_key", Callable(editor, "_key_selected"), CONNECT_DEFERRED);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::_play_position_draw() {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!animation.is_valid() || play_position_pos < 0) {
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
float scale = timeline->get_zoom_scale();
|
|
|
|
int h = get_size().height;
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
int limit = timeline->get_name_limit();
|
|
|
|
|
|
|
|
int px = (-timeline->get_value() + play_position_pos) * scale + limit;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
if (px >= limit && px < (get_size().width)) {
|
2021-07-17 21:22:52 +00:00
|
|
|
Color color = get_theme_color(SNAME("accent_color"), SNAME("Editor"));
|
2020-07-02 02:52:21 +00:00
|
|
|
play_position->draw_line(Point2(px, 0), Point2(px, h), color, Math::round(2 * EDSCALE));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
void AnimationBezierTrackEdit::set_play_position(real_t p_pos) {
|
2018-06-07 15:46:14 +00:00
|
|
|
play_position_pos = p_pos;
|
|
|
|
play_position->update();
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::update_play_position() {
|
|
|
|
play_position->update();
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::set_root(Node *p_root) {
|
|
|
|
root = p_root;
|
|
|
|
}
|
2020-05-14 12:29:06 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
void AnimationBezierTrackEdit::set_filtered(bool p_filtered) {
|
|
|
|
is_filtered = p_filtered;
|
|
|
|
if (animation == nullptr) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
String base_path = animation->track_get_path(selected_track);
|
|
|
|
if (is_filtered) {
|
|
|
|
if (root && root->has_node(base_path)) {
|
|
|
|
Node *node = root->get_node(base_path);
|
|
|
|
if (!node || !EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
|
|
|
|
for (int i = 0; i < animation->get_track_count(); ++i) {
|
|
|
|
if (animation->track_get_type(i) != Animation::TrackType::TYPE_BEZIER) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
base_path = animation->track_get_path(i);
|
|
|
|
if (root && root->has_node(base_path)) {
|
|
|
|
node = root->get_node(base_path);
|
|
|
|
if (!node) {
|
|
|
|
continue; // No node, no filter.
|
|
|
|
}
|
|
|
|
if (!EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
|
|
|
|
continue; // Skip track due to not selected.
|
|
|
|
}
|
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
set_animation_and_track(animation, i, read_only);
|
2021-11-09 15:05:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
void AnimationBezierTrackEdit::_zoom_changed() {
|
|
|
|
update();
|
2020-07-02 19:07:28 +00:00
|
|
|
play_position->update();
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
void AnimationBezierTrackEdit::_update_locked_tracks_after(int p_track) {
|
|
|
|
if (locked_tracks.has(p_track)) {
|
|
|
|
locked_tracks.erase(p_track);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector<int> updated_locked_tracks;
|
2022-05-18 23:43:40 +00:00
|
|
|
for (const int &E : locked_tracks) {
|
|
|
|
updated_locked_tracks.push_back(E);
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
|
|
|
locked_tracks.clear();
|
|
|
|
for (int i = 0; i < updated_locked_tracks.size(); ++i) {
|
|
|
|
if (updated_locked_tracks[i] > p_track) {
|
|
|
|
locked_tracks.insert(updated_locked_tracks[i] - 1);
|
|
|
|
} else {
|
|
|
|
locked_tracks.insert(updated_locked_tracks[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::_update_hidden_tracks_after(int p_track) {
|
|
|
|
if (hidden_tracks.has(p_track)) {
|
|
|
|
hidden_tracks.erase(p_track);
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector<int> updated_hidden_tracks;
|
2022-05-18 23:43:40 +00:00
|
|
|
for (const int &E : hidden_tracks) {
|
|
|
|
updated_hidden_tracks.push_back(E);
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
|
|
|
hidden_tracks.clear();
|
|
|
|
for (int i = 0; i < updated_hidden_tracks.size(); ++i) {
|
|
|
|
if (updated_hidden_tracks[i] > p_track) {
|
|
|
|
hidden_tracks.insert(updated_hidden_tracks[i] - 1);
|
|
|
|
} else {
|
|
|
|
hidden_tracks.insert(updated_hidden_tracks[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
String AnimationBezierTrackEdit::get_tooltip(const Point2 &p_pos) const {
|
|
|
|
return Control::get_tooltip(p_pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::_clear_selection() {
|
|
|
|
selection.clear();
|
2021-07-17 21:22:52 +00:00
|
|
|
emit_signal(SNAME("clear_selection"));
|
2018-06-07 15:46:14 +00:00
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
void AnimationBezierTrackEdit::_change_selected_keys_handle_mode(Animation::HandleMode p_mode, bool p_auto) {
|
2021-09-03 14:02:53 +00:00
|
|
|
undo_redo->create_action(TTR("Update Selected Key Handles"));
|
2022-08-22 10:45:30 +00:00
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
const IntPair track_key_pair = E->get();
|
|
|
|
undo_redo->add_undo_method(editor, "_bezier_track_set_key_handle_mode", animation.ptr(), track_key_pair.first, track_key_pair.second, animation->bezier_track_get_key_handle_mode(track_key_pair.first, track_key_pair.second), Animation::HANDLE_SET_MODE_NONE);
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_in_handle", track_key_pair.first, track_key_pair.second, animation->bezier_track_get_key_in_handle(track_key_pair.first, track_key_pair.second));
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_out_handle", track_key_pair.first, track_key_pair.second, animation->bezier_track_get_key_out_handle(track_key_pair.first, track_key_pair.second));
|
|
|
|
undo_redo->add_do_method(editor, "_bezier_track_set_key_handle_mode", animation.ptr(), track_key_pair.first, track_key_pair.second, p_mode, p_auto ? Animation::HANDLE_SET_MODE_AUTO : Animation::HANDLE_SET_MODE_RESET);
|
2021-09-03 14:02:53 +00:00
|
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
void AnimationBezierTrackEdit::_clear_selection_for_anim(const Ref<Animation> &p_anim) {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!(animation == p_anim)) {
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
_clear_selection();
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
void AnimationBezierTrackEdit::_select_at_anim(const Ref<Animation> &p_anim, int p_track, real_t p_pos) {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!(animation == p_anim)) {
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
int idx = animation->track_find_key(p_track, p_pos, true);
|
|
|
|
ERR_FAIL_COND(idx < 0);
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
selection.insert(IntPair(p_track, idx));
|
2022-08-22 10:45:30 +00:00
|
|
|
emit_signal(SNAME("select_key"), idx, true, p_track);
|
2018-06-07 15:46:14 +00:00
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2021-08-22 15:37:22 +00:00
|
|
|
void AnimationBezierTrackEdit::gui_input(const Ref<InputEvent> &p_event) {
|
2021-04-05 06:52:21 +00:00
|
|
|
ERR_FAIL_COND(p_event.is_null());
|
|
|
|
|
2022-01-13 16:19:15 +00:00
|
|
|
if (panner->gui_input(p_event)) {
|
|
|
|
accept_event();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
if (p_event->is_pressed()) {
|
2021-08-03 15:27:45 +00:00
|
|
|
if (ED_GET_SHORTCUT("animation_editor/duplicate_selection")->matches_event(p_event)) {
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
duplicate_selection();
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
accept_event();
|
|
|
|
}
|
|
|
|
|
2021-08-03 15:27:45 +00:00
|
|
|
if (ED_GET_SHORTCUT("animation_editor/delete_selection")->matches_event(p_event)) {
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
delete_selection();
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
accept_event();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
Ref<InputEventKey> key_press = p_event;
|
|
|
|
|
|
|
|
if (key_press.is_valid() && key_press->is_pressed()) {
|
|
|
|
if (ED_GET_SHORTCUT("animation_bezier_editor/focus")->matches_event(p_event)) {
|
|
|
|
SelectionSet focused_keys;
|
|
|
|
if (selection.is_empty()) {
|
|
|
|
for (int i = 0; i < edit_points.size(); ++i) {
|
|
|
|
IntPair key_pair = IntPair(edit_points[i].track, edit_points[i].key);
|
|
|
|
focused_keys.insert(key_pair);
|
|
|
|
}
|
|
|
|
} else {
|
2022-05-19 15:00:06 +00:00
|
|
|
for (const IntPair &E : selection) {
|
|
|
|
focused_keys.insert(E);
|
|
|
|
if (E.second > 0) {
|
|
|
|
IntPair previous_key = IntPair(E.first, E.second - 1);
|
2021-11-09 15:05:28 +00:00
|
|
|
focused_keys.insert(previous_key);
|
|
|
|
}
|
2022-05-19 15:00:06 +00:00
|
|
|
if (E.second < animation->track_get_key_count(E.first) - 1) {
|
|
|
|
IntPair next_key = IntPair(E.first, E.second + 1);
|
2021-11-09 15:05:28 +00:00
|
|
|
focused_keys.insert(next_key);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (focused_keys.is_empty()) {
|
|
|
|
accept_event();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t minimum_time = INFINITY;
|
|
|
|
real_t maximum_time = -INFINITY;
|
|
|
|
real_t minimum_value = INFINITY;
|
|
|
|
real_t maximum_value = -INFINITY;
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-05-19 15:00:06 +00:00
|
|
|
for (const IntPair &E : selection) {
|
|
|
|
IntPair key_pair = E;
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t time = animation->track_get_key_time(key_pair.first, key_pair.second);
|
|
|
|
real_t value = animation->bezier_track_get_key_value(key_pair.first, key_pair.second);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
|
|
|
minimum_time = MIN(time, minimum_time);
|
|
|
|
maximum_time = MAX(time, maximum_time);
|
|
|
|
minimum_value = MIN(value, minimum_value);
|
|
|
|
maximum_value = MAX(value, maximum_value);
|
|
|
|
}
|
|
|
|
|
|
|
|
float width = get_size().width - timeline->get_name_limit() - timeline->get_buttons_width();
|
|
|
|
float padding = width * 0.1;
|
2022-08-22 10:45:30 +00:00
|
|
|
float desired_scale = (width - padding / 2.0) / (maximum_time - minimum_time);
|
|
|
|
minimum_time = MAX(0, minimum_time - (padding / 2.0) / desired_scale);
|
2021-11-09 15:05:28 +00:00
|
|
|
|
|
|
|
float zv = Math::pow(100 / desired_scale, 0.125f);
|
|
|
|
if (zv < 1) {
|
|
|
|
zv = Math::pow(desired_scale / 100, 0.125f) - 1;
|
|
|
|
zv = 1 - zv;
|
|
|
|
}
|
|
|
|
float zoom_value = timeline->get_zoom()->get_max() - zv;
|
|
|
|
|
|
|
|
timeline->get_zoom()->set_value(zoom_value);
|
|
|
|
timeline->call_deferred("set_value", minimum_time);
|
|
|
|
|
|
|
|
v_scroll = (maximum_value + minimum_value) / 2.0;
|
|
|
|
v_zoom = (maximum_value - minimum_value) / ((get_size().height - timeline->get_size().height) * 0.9);
|
|
|
|
|
|
|
|
update();
|
|
|
|
accept_event();
|
|
|
|
return;
|
|
|
|
} else if (ED_GET_SHORTCUT("animation_bezier_editor/select_all_keys")->matches_event(p_event)) {
|
|
|
|
for (int i = 0; i < edit_points.size(); ++i) {
|
|
|
|
selection.insert(IntPair(edit_points[i].track, edit_points[i].key));
|
|
|
|
}
|
|
|
|
|
|
|
|
update();
|
|
|
|
accept_event();
|
|
|
|
return;
|
|
|
|
} else if (ED_GET_SHORTCUT("animation_bezier_editor/deselect_all_keys")->matches_event(p_event)) {
|
|
|
|
selection.clear();
|
|
|
|
|
|
|
|
update();
|
|
|
|
accept_event();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
2021-11-09 15:05:28 +00:00
|
|
|
int limit = timeline->get_name_limit();
|
2021-08-13 21:31:57 +00:00
|
|
|
if (mb.is_valid() && mb->get_button_index() == MouseButton::RIGHT && mb->is_pressed()) {
|
2018-06-07 15:46:14 +00:00
|
|
|
menu_insert_key = mb->get_position();
|
2021-11-09 15:05:28 +00:00
|
|
|
if (menu_insert_key.x >= limit && menu_insert_key.x <= get_size().width) {
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
Vector2 popup_pos = get_screen_position() + mb->get_position();
|
2019-04-30 09:29:18 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
menu->clear();
|
|
|
|
if (!locked_tracks.has(selected_track) || locked_tracks.has(selected_track)) {
|
|
|
|
menu->add_icon_item(bezier_icon, TTR("Insert Key Here"), MENU_KEY_INSERT);
|
|
|
|
}
|
|
|
|
if (selection.size()) {
|
|
|
|
menu->add_separator();
|
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("Duplicate"), SNAME("EditorIcons")), TTR("Duplicate Selected Key(s)"), MENU_KEY_DUPLICATE);
|
|
|
|
menu->add_separator();
|
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("Remove"), SNAME("EditorIcons")), TTR("Delete Selected Key(s)"), MENU_KEY_DELETE);
|
|
|
|
menu->add_separator();
|
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("BezierHandlesFree"), SNAME("EditorIcons")), TTR("Make Handles Free"), MENU_KEY_SET_HANDLE_FREE);
|
2022-08-22 10:45:30 +00:00
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("BezierHandlesLinear"), SNAME("EditorIcons")), TTR("Make Handles Linear"), MENU_KEY_SET_HANDLE_LINEAR);
|
2022-05-04 00:17:08 +00:00
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("BezierHandlesBalanced"), SNAME("EditorIcons")), TTR("Make Handles Balanced"), MENU_KEY_SET_HANDLE_BALANCED);
|
2022-08-22 10:45:30 +00:00
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("BezierHandlesMirror"), SNAME("EditorIcons")), TTR("Make Handles Mirrored"), MENU_KEY_SET_HANDLE_MIRRORED);
|
|
|
|
menu->add_separator();
|
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("BezierHandlesBalanced"), SNAME("EditorIcons")), TTR("Make Handles Balanced (Auto Tangent)"), MENU_KEY_SET_HANDLE_AUTO_BALANCED);
|
|
|
|
menu->add_icon_item(get_theme_icon(SNAME("BezierHandlesMirror"), SNAME("EditorIcons")), TTR("Make Handles Mirrored (Auto Tangent)"), MENU_KEY_SET_HANDLE_AUTO_MIRRORED);
|
2022-05-04 00:17:08 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
if (menu->get_item_count()) {
|
|
|
|
menu->reset_size();
|
|
|
|
menu->set_position(popup_pos);
|
|
|
|
menu->popup();
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2019-04-30 09:29:18 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
2021-08-13 21:31:57 +00:00
|
|
|
if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == MouseButton::LEFT) {
|
2021-08-09 20:13:42 +00:00
|
|
|
for (const KeyValue<int, Rect2> &E : subtracks) {
|
|
|
|
if (E.value.has_point(mb->get_position())) {
|
2021-11-09 15:05:28 +00:00
|
|
|
if (!locked_tracks.has(E.key) && !hidden_tracks.has(E.key)) {
|
2022-05-04 00:17:08 +00:00
|
|
|
set_animation_and_track(animation, E.key, read_only);
|
2021-11-09 15:05:28 +00:00
|
|
|
_clear_selection();
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-13 13:04:37 +00:00
|
|
|
for (const KeyValue<int, RBMap<int, Rect2>> &E : subtrack_icons) {
|
2021-11-09 15:05:28 +00:00
|
|
|
int track = E.key;
|
2022-05-13 13:04:37 +00:00
|
|
|
RBMap<int, Rect2> track_icons = E.value;
|
2021-11-09 15:05:28 +00:00
|
|
|
for (const KeyValue<int, Rect2> &I : track_icons) {
|
|
|
|
if (I.value.has_point(mb->get_position())) {
|
|
|
|
if (I.key == REMOVE_ICON) {
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
undo_redo->create_action("Remove Bezier Track");
|
|
|
|
|
|
|
|
undo_redo->add_do_method(this, "_update_locked_tracks_after", track);
|
|
|
|
undo_redo->add_do_method(this, "_update_hidden_tracks_after", track);
|
|
|
|
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "remove_track", track);
|
|
|
|
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "add_track", Animation::TrackType::TYPE_BEZIER, track);
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_set_path", track, animation->track_get_path(track));
|
|
|
|
|
|
|
|
for (int i = 0; i < animation->track_get_key_count(track); ++i) {
|
|
|
|
undo_redo->add_undo_method(
|
2022-08-22 10:45:30 +00:00
|
|
|
this,
|
|
|
|
"_bezier_track_insert_key",
|
|
|
|
track,
|
|
|
|
animation->track_get_key_time(track, i),
|
2022-05-04 00:17:08 +00:00
|
|
|
animation->bezier_track_get_key_value(track, i),
|
|
|
|
animation->bezier_track_get_key_in_handle(track, i),
|
|
|
|
animation->bezier_track_get_key_out_handle(track, i),
|
|
|
|
animation->bezier_track_get_key_handle_mode(track, i));
|
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->commit_action();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
selected_track = CLAMP(selected_track, 0, animation->get_track_count() - 1);
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
} else if (I.key == LOCK_ICON) {
|
|
|
|
if (locked_tracks.has(track)) {
|
|
|
|
locked_tracks.erase(track);
|
|
|
|
} else {
|
|
|
|
locked_tracks.insert(track);
|
|
|
|
if (selected_track == track) {
|
|
|
|
for (int i = 0; i < animation->get_track_count(); ++i) {
|
|
|
|
if (!locked_tracks.has(i) && animation->track_get_type(i) == Animation::TrackType::TYPE_BEZIER) {
|
2022-05-04 00:17:08 +00:00
|
|
|
set_animation_and_track(animation, i, read_only);
|
2021-11-09 15:05:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
update();
|
|
|
|
return;
|
|
|
|
} else if (I.key == VISIBILITY_ICON) {
|
|
|
|
if (hidden_tracks.has(track)) {
|
|
|
|
hidden_tracks.erase(track);
|
|
|
|
} else {
|
|
|
|
hidden_tracks.insert(track);
|
|
|
|
if (selected_track == track) {
|
|
|
|
for (int i = 0; i < animation->get_track_count(); ++i) {
|
|
|
|
if (!hidden_tracks.has(i) && animation->track_get_type(i) == Animation::TrackType::TYPE_BEZIER) {
|
2022-05-04 00:17:08 +00:00
|
|
|
set_animation_and_track(animation, i, read_only);
|
2021-11-09 15:05:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector<int> visible_tracks;
|
|
|
|
for (int i = 0; i < animation->get_track_count(); ++i) {
|
|
|
|
if (!hidden_tracks.has(i) && animation->track_get_type(i) == Animation::TrackType::TYPE_BEZIER) {
|
|
|
|
visible_tracks.push_back(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (visible_tracks.size() == 1) {
|
|
|
|
solo_track = visible_tracks[0];
|
|
|
|
} else {
|
|
|
|
solo_track = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
update();
|
|
|
|
return;
|
|
|
|
} else if (I.key == SOLO_ICON) {
|
|
|
|
if (solo_track == track) {
|
|
|
|
solo_track = -1;
|
|
|
|
|
|
|
|
hidden_tracks.clear();
|
|
|
|
} else {
|
|
|
|
if (hidden_tracks.has(track)) {
|
|
|
|
hidden_tracks.erase(track);
|
|
|
|
}
|
|
|
|
for (int i = 0; i < animation->get_track_count(); ++i) {
|
|
|
|
if (animation->track_get_type(i) == Animation::TrackType::TYPE_BEZIER) {
|
|
|
|
if (i != track && !hidden_tracks.has(i)) {
|
|
|
|
hidden_tracks.insert(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
set_animation_and_track(animation, track, read_only);
|
2021-11-09 15:05:28 +00:00
|
|
|
solo_track = track;
|
|
|
|
}
|
|
|
|
update();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
for (int i = 0; i < edit_points.size(); i++) {
|
|
|
|
//first check point
|
|
|
|
//command makes it ignore the main point, so control point editors can be force-edited
|
|
|
|
//path 2D editing in the 3D and 2D editors works the same way
|
2021-04-24 20:33:50 +00:00
|
|
|
if (!mb->is_command_pressed()) {
|
2018-06-07 15:46:14 +00:00
|
|
|
if (edit_points[i].point_rect.has_point(mb->get_position())) {
|
2021-11-09 15:05:28 +00:00
|
|
|
IntPair pair = IntPair(edit_points[i].track, edit_points[i].key);
|
2021-04-24 20:33:50 +00:00
|
|
|
if (mb->is_shift_pressed()) {
|
2018-06-07 15:46:14 +00:00
|
|
|
//add to selection
|
2021-11-09 15:05:28 +00:00
|
|
|
if (selection.has(pair)) {
|
|
|
|
selection.erase(pair);
|
2018-06-07 15:46:14 +00:00
|
|
|
} else {
|
2021-11-09 15:05:28 +00:00
|
|
|
selection.insert(pair);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
update();
|
2021-11-09 15:05:28 +00:00
|
|
|
select_single_attempt = IntPair(-1, -1);
|
|
|
|
} else if (selection.has(pair)) {
|
2018-06-07 15:46:14 +00:00
|
|
|
moving_selection_attempt = true;
|
|
|
|
moving_selection = false;
|
2021-11-09 15:05:28 +00:00
|
|
|
moving_selection_from_key = pair.second;
|
|
|
|
moving_selection_from_track = pair.first;
|
2022-08-22 10:45:30 +00:00
|
|
|
moving_handle_track = pair.first;
|
|
|
|
moving_handle_left = animation->bezier_track_get_key_in_handle(pair.first, pair.second);
|
|
|
|
moving_handle_right = animation->bezier_track_get_key_out_handle(pair.first, pair.second);
|
2018-06-07 15:46:14 +00:00
|
|
|
moving_selection_offset = Vector2();
|
2021-11-09 15:05:28 +00:00
|
|
|
select_single_attempt = pair;
|
2018-06-07 15:46:14 +00:00
|
|
|
update();
|
|
|
|
} else {
|
|
|
|
moving_selection_attempt = true;
|
|
|
|
moving_selection = true;
|
2021-11-09 15:05:28 +00:00
|
|
|
moving_selection_from_key = pair.second;
|
|
|
|
moving_selection_from_track = pair.first;
|
2018-06-07 15:46:14 +00:00
|
|
|
moving_selection_offset = Vector2();
|
2022-08-22 10:45:30 +00:00
|
|
|
moving_handle_track = pair.first;
|
|
|
|
moving_handle_left = animation->bezier_track_get_key_in_handle(pair.first, pair.second);
|
|
|
|
moving_handle_right = animation->bezier_track_get_key_out_handle(pair.first, pair.second);
|
2018-06-07 15:46:14 +00:00
|
|
|
selection.clear();
|
2021-11-09 15:05:28 +00:00
|
|
|
selection.insert(pair);
|
2022-08-22 10:45:30 +00:00
|
|
|
set_animation_and_track(animation, pair.first, read_only);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
if (edit_points[i].in_rect.has_point(mb->get_position())) {
|
|
|
|
moving_handle = -1;
|
|
|
|
moving_handle_key = edit_points[i].key;
|
|
|
|
moving_handle_track = edit_points[i].track;
|
|
|
|
moving_handle_left = animation->bezier_track_get_key_in_handle(edit_points[i].track, edit_points[i].key);
|
|
|
|
moving_handle_right = animation->bezier_track_get_key_out_handle(edit_points[i].track, edit_points[i].key);
|
|
|
|
update();
|
|
|
|
return;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
if (edit_points[i].out_rect.has_point(mb->get_position())) {
|
|
|
|
moving_handle = 1;
|
|
|
|
moving_handle_key = edit_points[i].key;
|
|
|
|
moving_handle_track = edit_points[i].track;
|
|
|
|
moving_handle_left = animation->bezier_track_get_key_in_handle(edit_points[i].track, edit_points[i].key);
|
|
|
|
moving_handle_right = animation->bezier_track_get_key_out_handle(edit_points[i].track, edit_points[i].key);
|
|
|
|
update();
|
|
|
|
return;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//insert new point
|
2021-11-09 15:05:28 +00:00
|
|
|
if (mb->get_position().x >= limit && mb->get_position().x < get_size().width && mb->is_command_pressed()) {
|
2018-06-07 15:46:14 +00:00
|
|
|
Array new_point;
|
2022-08-22 10:45:30 +00:00
|
|
|
new_point.resize(5);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
float h = (get_size().height / 2.0 - mb->get_position().y) * v_zoom + v_scroll;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
new_point[0] = h;
|
|
|
|
new_point[1] = -0.25;
|
|
|
|
new_point[2] = 0;
|
|
|
|
new_point[3] = 0.25;
|
|
|
|
new_point[4] = 0;
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t time = ((mb->get_position().x - limit) / timeline->get_zoom_scale()) + timeline->get_value();
|
2021-11-09 15:05:28 +00:00
|
|
|
while (animation->track_find_key(selected_track, time, true) != -1) {
|
2018-06-07 15:46:14 +00:00
|
|
|
time += 0.001;
|
|
|
|
}
|
|
|
|
|
2019-02-21 19:41:01 +00:00
|
|
|
undo_redo->create_action(TTR("Add Bezier Point"));
|
2022-08-22 10:45:30 +00:00
|
|
|
undo_redo->add_do_method(animation.ptr(), "bezier_track_insert_key", selected_track, time, new_point);
|
2021-11-09 15:05:28 +00:00
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_time", selected_track, time);
|
2018-06-07 15:46:14 +00:00
|
|
|
undo_redo->commit_action();
|
|
|
|
|
|
|
|
//then attempt to move
|
2021-11-09 15:05:28 +00:00
|
|
|
int index = animation->track_find_key(selected_track, time, true);
|
2018-06-07 15:46:14 +00:00
|
|
|
ERR_FAIL_COND(index == -1);
|
|
|
|
_clear_selection();
|
2021-11-09 15:05:28 +00:00
|
|
|
selection.insert(IntPair(selected_track, index));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
moving_selection_attempt = true;
|
|
|
|
moving_selection = false;
|
|
|
|
moving_selection_from_key = index;
|
2021-11-09 15:05:28 +00:00
|
|
|
moving_selection_from_track = selected_track;
|
2018-06-07 15:46:14 +00:00
|
|
|
moving_selection_offset = Vector2();
|
2021-11-09 15:05:28 +00:00
|
|
|
select_single_attempt = IntPair(-1, -1);
|
2018-06-07 15:46:14 +00:00
|
|
|
update();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
//box select
|
2021-11-09 15:05:28 +00:00
|
|
|
if (mb->get_position().x >= limit && mb->get_position().x < get_size().width) {
|
2018-06-07 15:46:14 +00:00
|
|
|
box_selecting_attempt = true;
|
|
|
|
box_selecting = false;
|
|
|
|
box_selecting_add = false;
|
|
|
|
box_selection_from = mb->get_position();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-13 21:31:57 +00:00
|
|
|
if (box_selecting_attempt && mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == MouseButton::LEFT) {
|
2018-06-07 15:46:14 +00:00
|
|
|
if (box_selecting) {
|
|
|
|
//do actual select
|
|
|
|
if (!box_selecting_add) {
|
|
|
|
_clear_selection();
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector2 bs_from = box_selection_from;
|
|
|
|
Vector2 bs_to = box_selection_to;
|
|
|
|
if (bs_from.x > bs_to.x) {
|
|
|
|
SWAP(bs_from.x, bs_to.x);
|
|
|
|
}
|
|
|
|
if (bs_from.y > bs_to.y) {
|
|
|
|
SWAP(bs_from.y, bs_to.y);
|
|
|
|
}
|
|
|
|
Rect2 selection_rect(bs_from, bs_to - bs_from);
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
bool track_set = false;
|
2018-06-07 15:46:14 +00:00
|
|
|
for (int i = 0; i < edit_points.size(); i++) {
|
|
|
|
if (edit_points[i].point_rect.intersects(selection_rect)) {
|
2021-11-09 15:05:28 +00:00
|
|
|
selection.insert(IntPair(edit_points[i].track, edit_points[i].key));
|
|
|
|
if (!track_set) {
|
|
|
|
track_set = true;
|
2022-05-04 00:17:08 +00:00
|
|
|
set_animation_and_track(animation, edit_points[i].track, read_only);
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
_clear_selection(); //clicked and nothing happened, so clear the selection
|
2021-11-09 15:05:28 +00:00
|
|
|
|
|
|
|
//select by clicking on curve
|
|
|
|
int track_count = animation->get_track_count();
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t animation_length = animation->get_length();
|
2021-11-09 15:05:28 +00:00
|
|
|
animation->set_length(real_t(INT_MAX)); //bezier_track_interpolate doesn't find keys if they exist beyond anim length
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t time = ((mb->get_position().x - limit) / timeline->get_zoom_scale()) + timeline->get_value();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < track_count; ++i) {
|
|
|
|
if (animation->track_get_type(i) != Animation::TrackType::TYPE_BEZIER || hidden_tracks.has(i) || locked_tracks.has(i)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
float track_h = animation->bezier_track_interpolate(i, time);
|
|
|
|
float track_height = _bezier_h_to_pixel(track_h);
|
|
|
|
|
|
|
|
if (abs(mb->get_position().y - track_height) < 10) {
|
2022-05-04 00:17:08 +00:00
|
|
|
set_animation_and_track(animation, i, read_only);
|
2021-11-09 15:05:28 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
animation->set_length(animation_length);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
2021-11-09 15:05:28 +00:00
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
box_selecting_attempt = false;
|
|
|
|
box_selecting = false;
|
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2021-08-13 21:31:57 +00:00
|
|
|
if (moving_selection_attempt && mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == MouseButton::LEFT) {
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
if (moving_selection) {
|
|
|
|
//combit it
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->create_action(TTR("Move Bezier Points"));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
List<AnimMoveRestore> to_restore;
|
2022-08-22 10:45:30 +00:00
|
|
|
List<Animation::HandleMode> to_restore_handle_modes;
|
2022-05-04 00:17:08 +00:00
|
|
|
// 1-remove the keys
|
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->get().first, E->get().second);
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2022-05-04 00:17:08 +00:00
|
|
|
// 2- remove overlapped keys
|
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t newtime = editor->snap_time(animation->track_get_key_time(E->get().first, E->get().second) + moving_selection_offset.x);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
int idx = animation->track_find_key(E->get().first, newtime, true);
|
|
|
|
if (idx == -1) {
|
|
|
|
continue;
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
if (selection.has(IntPair(E->get().first, idx))) {
|
|
|
|
continue; //already in selection, don't save
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_time", E->get().first, newtime);
|
|
|
|
AnimMoveRestore amr;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
amr.key = animation->track_get_key_value(E->get().first, idx);
|
|
|
|
amr.track = E->get().first;
|
|
|
|
amr.time = newtime;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
to_restore.push_back(amr);
|
2022-08-22 10:45:30 +00:00
|
|
|
to_restore_handle_modes.push_back(animation->bezier_track_get_key_handle_mode(E->get().first, idx));
|
2022-05-04 00:17:08 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
// 3-move the keys (re insert them)
|
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t newpos = editor->snap_time(animation->track_get_key_time(E->get().first, E->get().second) + moving_selection_offset.x);
|
2022-05-04 00:17:08 +00:00
|
|
|
Array key = animation->track_get_key_value(E->get().first, E->get().second);
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t h = key[0];
|
2022-05-04 00:17:08 +00:00
|
|
|
h += moving_selection_offset.y;
|
|
|
|
key[0] = h;
|
2022-08-22 10:45:30 +00:00
|
|
|
undo_redo->add_do_method(
|
|
|
|
this,
|
|
|
|
"_bezier_track_insert_key",
|
|
|
|
E->get().first,
|
|
|
|
newpos,
|
|
|
|
key[0],
|
|
|
|
Vector2(key[1], key[2]),
|
|
|
|
Vector2(key[3], key[4]),
|
|
|
|
animation->bezier_track_get_key_handle_mode(E->get().first, E->get().second));
|
2022-05-04 00:17:08 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
// 4-(undo) remove inserted keys
|
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t newpos = editor->snap_time(animation->track_get_key_time(E->get().first, E->get().second) + moving_selection_offset.x);
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_time", E->get().first, newpos);
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
// 5-(undo) reinsert keys
|
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t oldpos = animation->track_get_key_time(E->get().first, E->get().second);
|
|
|
|
Array key = animation->track_get_key_value(E->get().first, E->get().second);
|
|
|
|
undo_redo->add_undo_method(
|
|
|
|
this,
|
|
|
|
"_bezier_track_insert_key",
|
|
|
|
E->get().first,
|
|
|
|
oldpos,
|
|
|
|
key[0],
|
|
|
|
Vector2(key[1], key[2]),
|
|
|
|
Vector2(key[3], key[4]),
|
|
|
|
animation->bezier_track_get_key_handle_mode(E->get().first, E->get().second));
|
2022-05-04 00:17:08 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
// 6-(undo) reinsert overlapped keys
|
2022-08-22 10:45:30 +00:00
|
|
|
for (int i = 0; i < to_restore.size(); i++) {
|
|
|
|
const AnimMoveRestore &amr = to_restore[i];
|
|
|
|
Array key = amr.key;
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, 1);
|
2022-08-22 10:45:30 +00:00
|
|
|
undo_redo->add_undo_method(
|
|
|
|
this,
|
|
|
|
"_bezier_track_insert_key",
|
|
|
|
amr.track,
|
|
|
|
amr.time,
|
|
|
|
key[0],
|
|
|
|
Vector2(key[1], key[2]),
|
|
|
|
Vector2(key[3], key[4]),
|
|
|
|
to_restore_handle_modes[i]);
|
2022-05-04 00:17:08 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
|
|
|
|
undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
// 7-reselect
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t oldpos = animation->track_get_key_time(E->get().first, E->get().second);
|
|
|
|
real_t newpos = editor->snap_time(oldpos + moving_selection_offset.x);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->add_do_method(this, "_select_at_anim", animation, E->get().first, newpos);
|
|
|
|
undo_redo->add_undo_method(this, "_select_at_anim", animation, E->get().first, oldpos);
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->commit_action();
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
moving_selection = false;
|
|
|
|
} else if (select_single_attempt != IntPair(-1, -1)) {
|
|
|
|
selection.clear();
|
|
|
|
selection.insert(select_single_attempt);
|
|
|
|
set_animation_and_track(animation, select_single_attempt.first, read_only);
|
|
|
|
}
|
|
|
|
|
|
|
|
moving_selection_attempt = false;
|
|
|
|
update();
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Ref<InputEventMouseMotion> mm = p_event;
|
|
|
|
if (moving_selection_attempt && mm.is_valid()) {
|
|
|
|
if (!moving_selection) {
|
|
|
|
moving_selection = true;
|
2021-11-09 15:05:28 +00:00
|
|
|
select_single_attempt = IntPair(-1, -1);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
float y = (get_size().height / 2.0 - mm->get_position().y) * v_zoom + v_scroll;
|
2021-11-09 15:05:28 +00:00
|
|
|
float x = editor->snap_time(((mm->get_position().x - limit) / timeline->get_zoom_scale()) + timeline->get_value());
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
moving_selection_offset = Vector2(x - animation->track_get_key_time(moving_selection_from_track, moving_selection_from_key), y - animation->bezier_track_get_key_value(moving_selection_from_track, moving_selection_from_key));
|
|
|
|
}
|
2022-08-22 10:45:30 +00:00
|
|
|
|
|
|
|
additional_moving_handle_lefts.clear();
|
|
|
|
additional_moving_handle_rights.clear();
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (box_selecting_attempt && mm.is_valid()) {
|
|
|
|
if (!box_selecting) {
|
|
|
|
box_selecting = true;
|
2021-04-24 20:33:50 +00:00
|
|
|
box_selecting_add = mm->is_shift_pressed();
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
box_selection_to = mm->get_position();
|
|
|
|
|
|
|
|
if (get_local_mouse_position().y < 0) {
|
|
|
|
//avoid cursor from going too above, so it does not lose focus with viewport
|
|
|
|
warp_mouse(Vector2(get_local_mouse_position().x, 0));
|
|
|
|
}
|
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
if ((moving_handle == 1 || moving_handle == -1) && mm.is_valid()) {
|
|
|
|
float y = (get_size().height / 2.0 - mm->get_position().y) * v_zoom + v_scroll;
|
2021-05-09 07:54:15 +00:00
|
|
|
float x = editor->snap_time((mm->get_position().x - timeline->get_name_limit()) / timeline->get_zoom_scale()) + timeline->get_value();
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
Vector2 key_pos = Vector2(animation->track_get_key_time(selected_track, moving_handle_key), animation->bezier_track_get_key_value(selected_track, moving_handle_key));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
Vector2 moving_handle_value = Vector2(x, y) - key_pos;
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
moving_handle_left = animation->bezier_track_get_key_in_handle(moving_handle_track, moving_handle_key);
|
|
|
|
moving_handle_right = animation->bezier_track_get_key_out_handle(moving_handle_track, moving_handle_key);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
if (moving_handle == -1) {
|
|
|
|
moving_handle_left = moving_handle_value;
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
Animation::HandleMode handle_mode = animation->bezier_track_get_key_handle_mode(moving_handle_track, moving_handle_key);
|
|
|
|
|
|
|
|
if (handle_mode == Animation::HANDLE_MODE_BALANCED) {
|
|
|
|
real_t ratio = timeline->get_zoom_scale() * v_zoom;
|
2021-09-03 14:02:53 +00:00
|
|
|
Transform2D xform;
|
|
|
|
xform.set_scale(Vector2(1.0, 1.0 / ratio));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-09-03 14:02:53 +00:00
|
|
|
Vector2 vec_out = xform.xform(moving_handle_right);
|
|
|
|
Vector2 vec_in = xform.xform(moving_handle_left);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-09-03 14:02:53 +00:00
|
|
|
moving_handle_right = xform.affine_inverse().xform(-vec_in.normalized() * vec_out.length());
|
2022-08-22 10:45:30 +00:00
|
|
|
} else if (handle_mode == Animation::HANDLE_MODE_MIRRORED) {
|
|
|
|
moving_handle_right = -moving_handle_left;
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
2021-09-03 14:02:53 +00:00
|
|
|
} else if (moving_handle == 1) {
|
|
|
|
moving_handle_right = moving_handle_value;
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
Animation::HandleMode handle_mode = animation->bezier_track_get_key_handle_mode(moving_handle_track, moving_handle_key);
|
|
|
|
|
|
|
|
if (handle_mode == Animation::HANDLE_MODE_BALANCED) {
|
|
|
|
real_t ratio = timeline->get_zoom_scale() * v_zoom;
|
2021-09-03 14:02:53 +00:00
|
|
|
Transform2D xform;
|
|
|
|
xform.set_scale(Vector2(1.0, 1.0 / ratio));
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-09-03 14:02:53 +00:00
|
|
|
Vector2 vec_in = xform.xform(moving_handle_left);
|
|
|
|
Vector2 vec_out = xform.xform(moving_handle_right);
|
|
|
|
|
|
|
|
moving_handle_left = xform.affine_inverse().xform(-vec_out.normalized() * vec_in.length());
|
2022-08-22 10:45:30 +00:00
|
|
|
} else if (handle_mode == Animation::HANDLE_MODE_MIRRORED) {
|
|
|
|
moving_handle_left = -moving_handle_right;
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
2021-09-03 14:02:53 +00:00
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
if ((moving_handle == -1 || moving_handle == 1) && mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == MouseButton::LEFT) {
|
2022-05-04 00:17:08 +00:00
|
|
|
if (!read_only) {
|
|
|
|
undo_redo->create_action(TTR("Move Bezier Points"));
|
|
|
|
if (moving_handle == -1) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t ratio = timeline->get_zoom_scale() * v_zoom;
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->add_do_method(animation.ptr(), "bezier_track_set_key_in_handle", moving_handle_track, moving_handle_key, moving_handle_left, ratio);
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_in_handle", moving_handle_track, moving_handle_key, animation->bezier_track_get_key_in_handle(moving_handle_track, moving_handle_key), ratio);
|
|
|
|
} else if (moving_handle == 1) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t ratio = timeline->get_zoom_scale() * v_zoom;
|
2022-05-04 00:17:08 +00:00
|
|
|
undo_redo->add_do_method(animation.ptr(), "bezier_track_set_key_out_handle", moving_handle_track, moving_handle_key, moving_handle_right, ratio);
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_out_handle", moving_handle_track, moving_handle_key, animation->bezier_track_get_key_out_handle(moving_handle_track, moving_handle_key), ratio);
|
|
|
|
}
|
|
|
|
undo_redo->commit_action();
|
|
|
|
moving_handle = 0;
|
|
|
|
update();
|
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-23 12:49:53 +00:00
|
|
|
void AnimationBezierTrackEdit::_scroll_callback(Vector2 p_scroll_vec, bool p_alt) {
|
2022-01-13 16:19:15 +00:00
|
|
|
_pan_callback(-p_scroll_vec * 32);
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::_pan_callback(Vector2 p_scroll_vec) {
|
|
|
|
v_scroll += p_scroll_vec.y * v_zoom;
|
|
|
|
v_scroll = CLAMP(v_scroll, -100000, 100000);
|
|
|
|
timeline->set_value(timeline->get_value() - p_scroll_vec.x / timeline->get_zoom_scale());
|
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2022-01-19 18:59:12 +00:00
|
|
|
void AnimationBezierTrackEdit::_zoom_callback(Vector2 p_scroll_vec, Vector2 p_origin, bool p_alt) {
|
2022-01-13 16:19:15 +00:00
|
|
|
const float v_zoom_orig = v_zoom;
|
2022-01-19 18:59:12 +00:00
|
|
|
if (p_alt) {
|
|
|
|
// Alternate zoom (doesn't affect timeline).
|
|
|
|
if (p_scroll_vec.y > 0) {
|
|
|
|
v_zoom = MIN(v_zoom * 1.2, 100000);
|
|
|
|
} else {
|
|
|
|
v_zoom = MAX(v_zoom / 1.2, 0.000001);
|
|
|
|
}
|
2022-01-13 16:19:15 +00:00
|
|
|
} else {
|
2022-01-19 18:59:12 +00:00
|
|
|
if (p_scroll_vec.y > 0) {
|
|
|
|
timeline->get_zoom()->set_value(timeline->get_zoom()->get_value() / 1.05);
|
|
|
|
} else {
|
|
|
|
timeline->get_zoom()->set_value(timeline->get_zoom()->get_value() * 1.05);
|
|
|
|
}
|
2022-01-13 16:19:15 +00:00
|
|
|
}
|
2022-08-22 10:45:30 +00:00
|
|
|
v_scroll = v_scroll + (p_origin.y - get_size().y / 2.0) * (v_zoom - v_zoom_orig);
|
2022-01-13 16:19:15 +00:00
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
void AnimationBezierTrackEdit::_menu_selected(int p_index) {
|
|
|
|
switch (p_index) {
|
|
|
|
case MENU_KEY_INSERT: {
|
2021-11-09 15:05:28 +00:00
|
|
|
if (animation->get_track_count() > 0) {
|
|
|
|
Array new_point;
|
2022-08-22 10:45:30 +00:00
|
|
|
new_point.resize(5);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
float h = (get_size().height / 2.0 - menu_insert_key.y) * v_zoom + v_scroll;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
new_point[0] = h;
|
|
|
|
new_point[1] = -0.25;
|
|
|
|
new_point[2] = 0;
|
|
|
|
new_point[3] = 0.25;
|
|
|
|
new_point[4] = 0;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
int limit = timeline->get_name_limit();
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t time = ((menu_insert_key.x - limit) / timeline->get_zoom_scale()) + timeline->get_value();
|
2021-11-09 15:05:28 +00:00
|
|
|
|
|
|
|
while (animation->track_find_key(selected_track, time, true) != -1) {
|
|
|
|
time += 0.001;
|
|
|
|
}
|
|
|
|
|
|
|
|
undo_redo->create_action(TTR("Add Bezier Point"));
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", selected_track, time, new_point);
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_time", selected_track, time);
|
|
|
|
undo_redo->commit_action();
|
2022-08-22 10:45:30 +00:00
|
|
|
update();
|
2021-11-09 15:05:28 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
} break;
|
|
|
|
case MENU_KEY_DUPLICATE: {
|
|
|
|
duplicate_selection();
|
|
|
|
} break;
|
|
|
|
case MENU_KEY_DELETE: {
|
|
|
|
delete_selection();
|
|
|
|
} break;
|
2021-09-03 14:02:53 +00:00
|
|
|
case MENU_KEY_SET_HANDLE_FREE: {
|
|
|
|
_change_selected_keys_handle_mode(Animation::HANDLE_MODE_FREE);
|
|
|
|
} break;
|
2022-08-22 10:45:30 +00:00
|
|
|
case MENU_KEY_SET_HANDLE_LINEAR: {
|
|
|
|
_change_selected_keys_handle_mode(Animation::HANDLE_MODE_LINEAR);
|
|
|
|
} break;
|
2021-09-03 14:02:53 +00:00
|
|
|
case MENU_KEY_SET_HANDLE_BALANCED: {
|
|
|
|
_change_selected_keys_handle_mode(Animation::HANDLE_MODE_BALANCED);
|
|
|
|
} break;
|
2022-08-22 10:45:30 +00:00
|
|
|
case MENU_KEY_SET_HANDLE_MIRRORED: {
|
|
|
|
_change_selected_keys_handle_mode(Animation::HANDLE_MODE_MIRRORED);
|
|
|
|
} break;
|
|
|
|
case MENU_KEY_SET_HANDLE_AUTO_BALANCED: {
|
|
|
|
_change_selected_keys_handle_mode(Animation::HANDLE_MODE_BALANCED, true);
|
|
|
|
} break;
|
|
|
|
case MENU_KEY_SET_HANDLE_AUTO_MIRRORED: {
|
|
|
|
_change_selected_keys_handle_mode(Animation::HANDLE_MODE_MIRRORED, true);
|
|
|
|
} break;
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::duplicate_selection() {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (selection.size() == 0) {
|
2018-06-07 15:46:14 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t top_time = 1e10;
|
2021-11-09 15:05:28 +00:00
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t t = animation->track_get_key_time(E->get().first, E->get().second);
|
2020-05-14 14:41:43 +00:00
|
|
|
if (t < top_time) {
|
2018-06-07 15:46:14 +00:00
|
|
|
top_time = t;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
undo_redo->create_action(TTR("Anim Duplicate Keys"));
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
List<Pair<int, real_t>> new_selection_values;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t t = animation->track_get_key_time(E->get().first, E->get().second);
|
|
|
|
real_t dst_time = t + (timeline->get_play_position() - top_time);
|
2021-11-09 15:05:28 +00:00
|
|
|
int existing_idx = animation->track_find_key(E->get().first, dst_time, true);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_insert_key", E->get().first, dst_time, animation->track_get_key_value(E->get().first, E->get().second), animation->track_get_key_transition(E->get().first, E->get().second));
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_time", E->get().first, dst_time);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
Pair<int, real_t> p;
|
2021-11-09 15:05:28 +00:00
|
|
|
p.first = E->get().first;
|
2018-06-07 15:46:14 +00:00
|
|
|
p.second = dst_time;
|
|
|
|
new_selection_values.push_back(p);
|
|
|
|
|
|
|
|
if (existing_idx != -1) {
|
2021-11-09 15:05:28 +00:00
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->get().first, dst_time, animation->track_get_key_value(E->get().first, existing_idx), animation->track_get_key_transition(E->get().first, existing_idx));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
undo_redo->commit_action();
|
|
|
|
|
|
|
|
//reselect duplicated
|
|
|
|
|
|
|
|
selection.clear();
|
2022-08-22 10:45:30 +00:00
|
|
|
for (const Pair<int, real_t> &E : new_selection_values) {
|
2021-07-16 03:45:57 +00:00
|
|
|
int track = E.first;
|
2022-08-22 10:45:30 +00:00
|
|
|
real_t time = E.second;
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
int existing_idx = animation->track_find_key(track, time, true);
|
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (existing_idx == -1) {
|
2018-06-07 15:46:14 +00:00
|
|
|
continue;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-06-07 15:46:14 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
selection.insert(IntPair(track, existing_idx));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
|
|
|
void AnimationBezierTrackEdit::delete_selection() {
|
|
|
|
if (selection.size()) {
|
|
|
|
undo_redo->create_action(TTR("Anim Delete Keys"));
|
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {
|
|
|
|
undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->get().first, E->get().second);
|
|
|
|
undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->get().first, animation->track_get_key_time(E->get().first, E->get().second), animation->track_get_key_value(E->get().first, E->get().second), 1);
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|
|
|
|
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();
|
2021-09-03 14:02:53 +00:00
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
//selection.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-22 10:45:30 +00:00
|
|
|
void AnimationBezierTrackEdit::_bezier_track_insert_key(int p_track, double p_time, real_t p_value, const Vector2 &p_in_handle, const Vector2 &p_out_handle, const Animation::HandleMode p_handle_mode) {
|
|
|
|
ERR_FAIL_COND(animation.is_null());
|
|
|
|
int idx = animation->bezier_track_insert_key(p_track, p_time, p_value, p_in_handle, p_out_handle);
|
|
|
|
animation->bezier_track_set_key_handle_mode(p_track, idx, p_handle_mode);
|
|
|
|
}
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
void AnimationBezierTrackEdit::_bind_methods() {
|
2022-08-22 10:45:30 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("_clear_selection"), &AnimationBezierTrackEdit::_clear_selection);
|
|
|
|
ClassDB::bind_method(D_METHOD("_clear_selection_for_anim"), &AnimationBezierTrackEdit::_clear_selection_for_anim);
|
|
|
|
ClassDB::bind_method(D_METHOD("_select_at_anim"), &AnimationBezierTrackEdit::_select_at_anim);
|
|
|
|
ClassDB::bind_method(D_METHOD("_update_hidden_tracks_after"), &AnimationBezierTrackEdit::_update_hidden_tracks_after);
|
|
|
|
ClassDB::bind_method(D_METHOD("_update_locked_tracks_after"), &AnimationBezierTrackEdit::_update_locked_tracks_after);
|
|
|
|
ClassDB::bind_method(D_METHOD("_bezier_track_insert_key"), &AnimationBezierTrackEdit::_bezier_track_insert_key);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
|
|
|
ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::FLOAT, "position"), PropertyInfo(Variant::BOOL, "drag")));
|
2018-06-07 15:46:14 +00:00
|
|
|
ADD_SIGNAL(MethodInfo("remove_request", PropertyInfo(Variant::INT, "track")));
|
2022-04-14 21:20:28 +00:00
|
|
|
ADD_SIGNAL(MethodInfo("insert_key", PropertyInfo(Variant::FLOAT, "offset")));
|
2022-08-22 10:45:30 +00:00
|
|
|
ADD_SIGNAL(MethodInfo("select_key", PropertyInfo(Variant::INT, "index"), PropertyInfo(Variant::BOOL, "single"), PropertyInfo(Variant::INT, "track")));
|
2018-06-07 15:46:14 +00:00
|
|
|
ADD_SIGNAL(MethodInfo("clear_selection"));
|
|
|
|
ADD_SIGNAL(MethodInfo("close_request"));
|
|
|
|
|
|
|
|
ADD_SIGNAL(MethodInfo("move_selection_begin"));
|
2022-04-14 21:20:28 +00:00
|
|
|
ADD_SIGNAL(MethodInfo("move_selection", PropertyInfo(Variant::FLOAT, "offset")));
|
2018-06-07 15:46:14 +00:00
|
|
|
ADD_SIGNAL(MethodInfo("move_selection_commit"));
|
|
|
|
ADD_SIGNAL(MethodInfo("move_selection_cancel"));
|
|
|
|
}
|
|
|
|
|
|
|
|
AnimationBezierTrackEdit::AnimationBezierTrackEdit() {
|
2022-01-13 16:19:15 +00:00
|
|
|
panner.instantiate();
|
|
|
|
panner->set_callbacks(callable_mp(this, &AnimationBezierTrackEdit::_scroll_callback), callable_mp(this, &AnimationBezierTrackEdit::_pan_callback), callable_mp(this, &AnimationBezierTrackEdit::_zoom_callback));
|
|
|
|
|
2018-06-07 15:46:14 +00:00
|
|
|
play_position = memnew(Control);
|
|
|
|
play_position->set_mouse_filter(MOUSE_FILTER_PASS);
|
|
|
|
add_child(play_position);
|
2022-03-19 00:02:57 +00:00
|
|
|
play_position->set_anchors_and_offsets_preset(PRESET_FULL_RECT);
|
2020-02-21 17:28:45 +00:00
|
|
|
play_position->connect("draw", callable_mp(this, &AnimationBezierTrackEdit::_play_position_draw));
|
2018-06-07 15:46:14 +00:00
|
|
|
set_focus_mode(FOCUS_CLICK);
|
|
|
|
|
|
|
|
set_clip_contents(true);
|
2021-08-26 12:44:01 +00:00
|
|
|
|
2021-11-09 15:05:28 +00:00
|
|
|
ED_SHORTCUT("animation_bezier_editor/focus", TTR("Focus"), Key::F);
|
|
|
|
ED_SHORTCUT("animation_bezier_editor/select_all_keys", TTR("Select All Keys"), KeyModifierMask::CMD | Key::A);
|
|
|
|
ED_SHORTCUT("animation_bezier_editor/deselect_all_keys", TTR("Deselect All Keys"), KeyModifierMask::CMD | KeyModifierMask::SHIFT | Key::A);
|
2018-06-07 15:46:14 +00:00
|
|
|
|
|
|
|
menu = memnew(PopupMenu);
|
|
|
|
add_child(menu);
|
2020-02-21 17:28:45 +00:00
|
|
|
menu->connect("id_pressed", callable_mp(this, &AnimationBezierTrackEdit::_menu_selected));
|
2018-06-07 15:46:14 +00:00
|
|
|
}
|