int limit = timeline->get_name_limit();

int right_limit = get_size().width;

RBMap<real_t, int> key_order;

for (int i = 0; i < animation->track_get_key_count(p_track); i++) {

int to_x = (offset_n - timeline->get_value()) * scale + limit;

int point_end = to_x;

continue;

}

continue;

}

float h;

if (j == point_end) {

} else if (j == point_start) {

int iterations = 10;

float low = 0;

float high = 1;

for (int k = 0; k < iterations; k++) {

float middle = (low + high) / 2.0;

}

}

Vector2 low_pos = start.bezier_interpolate(out_handle, in_handle, end, low);

Vector2 high_pos = start.bezier_interpolate(out_handle, in_handle, end, high);

int limit = timeline->get_name_limit();

if (has_focus()) {

}

int right_limit = get_size().width;

int margin = 0;

RBMap<int, Color> subtrack_colors;

Vector<int> tracks = E.value;

{

NodePath path = animation->track_get_path(tracks[0]);

Ref<Texture2D> icon = EditorNode::get_singleton()->get_object_icon(node, "Node");

text = node->get_name();

TextLine text_buf = TextLine(text, font, font_size);

int h = MAX(text_buf.get_size().y, icon->get_height());

draw_texture(icon, Point2(ofs, vofs + int(h - icon->get_height()) / 2.0));

margin = icon->get_width();

string_pos = string_pos.floor();

text_buf.draw(get_canvas_item(), string_pos, color);

}

}

Ref<Texture2D> remove = get_editor_theme_icon(SNAME("Remove"));

Ref<Texture2D> lock = get_editor_theme_icon(SNAME("Lock"));

Ref<Texture2D> unlock = get_editor_theme_icon(SNAME("Unlock"));

Ref<Texture2D> visibility_visible = get_editor_theme_icon(SNAME("GuiVisibilityVisible"));

Ref<Texture2D> visibility_hidden = get_editor_theme_icon(SNAME("GuiVisibilityHidden"));

Ref<Texture2D> solo = get_editor_theme_icon(SNAME("AudioBusSolo"));

for (int i = 0; i < tracks.size(); ++i) {

int current_track = tracks[i];

Color cc = color;

TextLine text_buf = TextLine(path, font, font_size);

cc.a *= 0.7;

float h;

track_color.set_hsv(h, 0.2, 0.8);

}

track_color.a = 0.5;

subtrack_colors[current_track] = track_color;

subtracks[current_track] = rect;

} else {

if (locked_tracks.has(selected_track)) {

selected_track_color.set_hsv(h, 0.0, 0.4);

} else {

}

}

text_buf.draw(get_canvas_item(), string_pos, cc);

float icon_start_height = vofs + rect.size.y / 2.0;

subtrack_icons[current_track] = track_icons;

}

}

float scale = (min_left_scale * 2) * timeline_v_zoom;

float step = Math::pow(10.0, Math::round(Math::log(scale / 5.0) / Math::log(10.0))) * 5.0;

iv -= 1;

}

if (!first && iv != prev_iv) {

lc.a *= 0.5;

draw_line(Point2(limit, i), Point2(right_limit, i), lc, Math::round(EDSCALE));

Color c = color;

}

}

float scale = timeline->get_zoom_scale();

Ref<Texture2D> point = get_editor_theme_icon(SNAME("KeyValue"));

for (const KeyValue<int, Color> &E : subtrack_colors) {

}

if (track_count > 0 && !hidden_tracks.has(selected_track)) {

_draw_track(selected_track, selected_track_color);

}

}

{

edit_points.clear();

float scale = timeline->get_zoom_scale();

// Check if the curves for a track are displayed in the editor (not hidden). Includes the check on the track visibility.

bool AnimationBezierTrackEdit::_is_track_curves_displayed(int p_track_index) {

if (!_is_track_displayed(p_track_index)) {

return false;

}

if (hidden_tracks.has(p_track_index)) {

return false;

}

int px = (-timeline->get_value() + play_position_pos) * scale + limit;

if (px >= limit && px < (get_size().width)) {

play_position->draw_line(Point2(px, 0), Point2(px, h), color, Math::round(2 * EDSCALE));

}

}

}

}

if (mb->get_position().x >= limit && mb->get_position().x < get_size().width && mb->is_command_or_control_pressed()) {

float h = (get_size().height / 2.0 - mb->get_position().y) * timeline_v_zoom + timeline_v_scroll;

Array new_point = animation->make_default_bezier_key(h);

undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_time", selected_track, time);

undo_redo->commit_action();

int index = animation->track_find_key(selected_track, time, Animation::FIND_MODE_APPROX);

ERR_FAIL_COND(index == -1);

_clear_selection();

return;

}

if (mb->get_position().x >= limit && mb->get_position().x < get_size().width) {

box_selecting_attempt = true;

box_selecting = false;

if (box_selecting_attempt && mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == MouseButton::LEFT) {

if (box_selecting) {

if (!box_selecting_add) {

_clear_selection();

}

}

}

} else {

int track_count = animation->get_track_count();

real_t animation_length = animation->get_length();

real_t time = ((mb->get_position().x - limit) / timeline->get_zoom_scale()) + timeline->get_value();

List<AnimMoveRestore> to_restore;

List<Animation::HandleMode> to_restore_handle_modes;

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);

}

for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {

real_t newtime = animation->track_get_key_time(E->get().first, E->get().second) + moving_selection_offset.x;

}

if (selection.has(IntPair(E->get().first, idx))) {

}

undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_time", E->get().first, newtime);

to_restore_handle_modes.push_back(animation->bezier_track_get_key_handle_mode(E->get().first, idx));

}

for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {

real_t newpos = animation->track_get_key_time(E->get().first, E->get().second) + moving_selection_offset.x;

Array key = animation->track_get_key_value(E->get().first, E->get().second);

animation->bezier_track_get_key_handle_mode(E->get().first, E->get().second));

}

for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {

real_t newpos = animation->track_get_key_time(E->get().first, E->get().second) + moving_selection_offset.x;

undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_time", E->get().first, newpos);

}

for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {

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);

animation->bezier_track_get_key_handle_mode(E->get().first, E->get().second));

}

List<AnimMoveRestore>::ConstIterator restore_itr = to_restore.begin();

List<Animation::HandleMode>::ConstIterator handle_itr = to_restore_handle_modes.begin();

for (; restore_itr != to_restore.end() && handle_itr != to_restore_handle_modes.end(); ++restore_itr, ++handle_itr) {

undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);

undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);

int i = 0;

for (SelectionSet::Element *E = selection.back(); E; E = E->prev()) {

real_t oldpos = animation->track_get_key_time(E->get().first, E->get().second);

box_selection_to = mm->get_position();

if (get_local_mouse_position().y < 0) {

warp_mouse(Vector2(get_local_mouse_position().x, 0));

}

queue_redraw();

}

int AnimationTimelineEdit::get_buttons_width() const {

int total_w = interp_mode->get_width() + interp_type->get_width() + loop_type->get_width() + remove_icon->get_width();

return total_w;

}

int AnimationTimelineEdit::get_name_limit() const {

Ref<Texture2D> hsize_icon = get_editor_theme_icon(SNAME("Hsize"));

limit = MIN(limit, get_size().width - get_buttons_width() - 1);

return;

}

int zoomw = key_range;

float scale = get_zoom_scale();

}

Ref<Texture2D> hsize_icon = get_editor_theme_icon(SNAME("Hsize"));

draw_texture(hsize_icon, hsize_rect.position);

{

int end_px = (l - get_value()) * scale;

int begin_px = -get_value() * scale;

{

if (begin_px < zoomw && end_px > 0) {

if (begin_px < 0) {

end_px = zoomw;

}

}

}

#define SC_ADJ 100

int dec = 1;

int step = 1;

bool sub = Math::floor(prev) == Math::floor(pos);

if (frame != prev_frame && i >= prev_frame_ofs) {

}

}

}

if ((sc / step) != (prev_sc / step) || (prev_sc < 0 && sc >= 0)) {

int scd = sc < 0 ? prev_sc : sc;

}

}

}

update_values();

} break;

}

Size2 AnimationTimelineEdit::get_minimum_size() const {

Size2 ms = add_track->get_minimum_size();

ms.height = MAX(ms.height, font->get_height(font_size));

return ms;

}

int limit = timeline->get_name_limit();

if (track % 2 == 1) {

// Draw a background over odd lines to make long lists of tracks easier to read.

}

if (hovered) {

// Draw hover feedback.

}

if (has_focus()) {

// Offside so the horizontal sides aren't cutoff.

}

{

Ref<Texture2D> check = animation->track_is_enabled(track) ? get_theme_icon(SNAME("checked"), SNAME("CheckBox")) : get_theme_icon(SNAME("unchecked"), SNAME("CheckBox"));

draw_texture(check, check_rect.position);

Ref<Texture2D> key_type_icon = _get_key_type_icon();

NodePath anim_path = animation->track_get_path(track);

Node *node = nullptr;

Ref<Texture2D> icon = EditorNode::get_singleton()->get_object_icon(node, "Node");

const Vector2 icon_size = Vector2(1, 1) * get_theme_constant(SNAME("class_icon_size"), EditorStringName(Editor));

icon_cache = icon;

text = String() + node->get_name() + ":" + anim_path.get_concatenated_subnames();

ofs += icon_size.x;

} else {

path_cache = text;

Vector2 string_pos = Point2(ofs, (get_size().height - font->get_height(font_size)) / 2 + font->get_ascent(font_size));

string_pos = string_pos.floor();

}

{

float scale = timeline->get_zoom_scale();

for (int i = 0; i < animation->track_get_key_count(track); i++) {

float offset = animation->track_get_key_time(track, i) - timeline->get_value();

}

}

{

Ref<Texture2D> wrap_icon[2] = {

get_editor_theme_icon(SNAME("UseBlendDisable")),

};

{

// Callmode.

Ref<Texture2D> update_icon = cont_icon[update_mode];

update_mode_rect.position.x = ofs;

update_mode_rect.size = update_icon->get_size();

if (!animation->track_is_compressed(track) && animation->track_get_type(track) == Animation::TYPE_VALUE) {

update_mode_rect.position.y = 0;

update_mode_rect.size.y = get_size().height;

if (!read_only) {

if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_AUDIO) {

update_mode_rect.size.x += down_icon->get_width();

} else if (animation->track_get_type(track) == Animation::TYPE_BEZIER) {

update_mode_rect.size.x += down_icon->get_width();

}

ofs += down_icon->get_width();

}

{

Ref<Texture2D> icon = interp_icon[interp_mode];

interp_mode_rect.position.x = ofs;

interp_mode_rect.size = icon->get_size();

if (!animation->track_is_compressed(track) && (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D)) {

interp_mode_rect.position.y = 0;

interp_mode_rect.size.y = get_size().height;

if (!read_only && !animation->track_is_compressed(track) && (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D)) {

interp_mode_rect.size.x += down_icon->get_width();

} else {

interp_mode_rect = Rect2();

}

ofs += down_icon->get_width();

}

{

Ref<Texture2D> icon = wrap_icon[loop_wrap ? 1 : 0];

loop_wrap_rect.position.x = ofs;

loop_wrap_rect.size = icon->get_size();

if (!animation->track_is_compressed(track) && (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D)) {

loop_wrap_rect.position.y = 0;

loop_wrap_rect.size.y = get_size().height;

if (!read_only && !animation->track_is_compressed(track) && (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_BLEND_SHAPE || animation->track_get_type(track) == Animation::TYPE_POSITION_3D || animation->track_get_type(track) == Animation::TYPE_SCALE_3D || animation->track_get_type(track) == Animation::TYPE_ROTATION_3D)) {

loop_wrap_rect.size.x += down_icon->get_width();

} else {

loop_wrap_rect = Rect2();

}

ofs += down_icon->get_width();

}

{

Ref<Texture2D> icon = get_editor_theme_icon(animation->track_is_compressed(track) ? SNAME("Lock") : SNAME("Remove"));

remove_rect.size = icon->get_size();

if (read_only) {

}

if (in_group) {

} else {

}

if (dropping_at != 0) {

}

}

if (animation->track_get_type(track) == Animation::TYPE_METHOD) {

Color color = get_theme_color(SceneStringName(font_color), SNAME("Label"));

color.a = 0.5;

Size2 AnimationTrackEdit::get_minimum_size() const {

Ref<Texture2D> texture = get_editor_theme_icon(SNAME("Object"));

int max_h = MAX(texture->get_height(), font->get_height(font_size));

max_h = MAX(max_h, get_key_height());

}

path->set_text(animation->track_get_path(track));

moving_selection_attempt = false;

moving_selection = false;

} break;

case NOTIFICATION_DRAW: {

Color color = get_theme_color(SceneStringName(font_color), SNAME("Label"));

if (root) {

Node *n = root->get_node_or_null(node);

if (n && EditorNode::get_singleton()->get_editor_selection()->is_selected(n)) {

}

}

int px = (-timeline->get_value() + timeline->get_play_position()) * timeline->get_zoom_scale() + timeline->get_name_limit();

if (px >= timeline->get_name_limit() && px < (get_size().width - timeline->get_buttons_width())) {

draw_line(Point2(px, 0), Point2(px, get_size().height), accent, Math::round(2 * EDSCALE));

}

} break;

}

Size2 AnimationTrackEditGroup::get_minimum_size() const {

}

void AnimationTrackEditGroup::set_timeline(AnimationTimelineEdit *p_timeline) {

edit->get_popup()->set_item_icon(edit->get_popup()->get_item_index(EDIT_APPLY_RESET), get_editor_theme_icon(SNAME("Reload")));

auto_fit->set_icon(get_editor_theme_icon(SNAME("AnimationAutoFit")));

auto_fit_bezier->set_icon(get_editor_theme_icon(SNAME("AnimationAutoFitBezier")));

} break;

case NOTIFICATION_READY: {

undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);

undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);

for (RBMap<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

float oldpos = E->get().pos;

float newpos = NEW_POS(oldpos);

main_panel->add_child(timeline_scroll);

timeline_scroll->set_v_size_flags(SIZE_EXPAND_FILL);

timeline_scroll->add_child(timeline_vbox);

timeline_vbox->set_v_size_flags(SIZE_EXPAND_FILL);

timeline_vbox->set_h_size_flags(SIZE_EXPAND_FILL);

info_message = memnew(Label);

info_message->set_text(TTR("Select an AnimationPlayer node to create and edit animations."));

scroll->add_child(track_vbox);

track_vbox->set_h_size_flags(SIZE_EXPAND_FILL);

scroll->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);

HBoxContainer *bottom_hb = memnew(HBoxContainer);

add_child(bottom_hb);

bake_grid->add_child(memnew(Label(TTR("FPS:"))));

bake_grid->add_child(bake_fps);

track_copy_dialog = memnew(ConfirmationDialog);

add_child(track_copy_dialog);

track_copy_dialog->set_title(TTR("Select Tracks to Copy"));

}

}

void AnimationTrackKeyEditEditor::_time_edit_entered() {

int key = animation->track_find_key(track, key_ofs, Animation::FIND_MODE_APPROX);

ScrollContainer *scroll = nullptr;

VBoxContainer *track_vbox = nullptr;

AnimationBezierTrackEdit *bezier_edit = nullptr;

Label *info_message = nullptr;

p_theme->set_stylebox("DictionaryAddItem0", EditorStringName(EditorStyles), style_dictionary_add_item);

}

// Editor help.

{

Ref<StyleBoxFlat> style_editor_help = p_config.base_style->duplicate();