animation_track_editor.cpp | Explore in Territory

/**************************************************************************/
/*  animation_track_editor.cpp                                            */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "animation_track_editor.h"

#include "animation_track_editor_plugins.h"
#include "core/error/error_macros.h"
#include "core/input/input.h"
#include "editor/animation_bezier_editor.h"
#include "editor/editor_node.h"
#include "editor/editor_settings.h"
#include "editor/editor_string_names.h"
#include "editor/editor_undo_redo_manager.h"
#include "editor/gui/editor_spin_slider.h"
#include "editor/gui/editor_validation_panel.h"
#include "editor/gui/scene_tree_editor.h"
#include "editor/inspector_dock.h"
#include "editor/multi_node_edit.h"
#include "editor/plugins/animation_player_editor_plugin.h"
#include "editor/themes/editor_scale.h"
#include "scene/3d/mesh_instance_3d.h"
#include "scene/animation/animation_player.h"
#include "scene/animation/tween.h"
#include "scene/gui/check_box.h"
#include "scene/gui/color_picker.h"
#include "scene/gui/grid_container.h"
#include "scene/gui/option_button.h"
#include "scene/gui/panel_container.h"
#include "scene/gui/separator.h"
#include "scene/gui/slider.h"
#include "scene/gui/spin_box.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/view_panner.h"
#include "scene/main/window.h"
#include "servers/audio/audio_stream.h"

constexpr double FPS_DECIMAL = …;
constexpr double SECOND_DECIMAL = …;
constexpr double FPS_STEP_FRACTION = …;

void AnimationTrackKeyEdit::_bind_methods() { … }

void AnimationTrackKeyEdit::_fix_node_path(Variant &value) { … }

void AnimationTrackKeyEdit::_update_obj(const Ref<Animation> &p_anim) { … }

void AnimationTrackKeyEdit::_key_ofs_changed(const Ref<Animation> &p_anim, float from, float to) { … }

bool AnimationTrackKeyEdit::_set(const StringName &p_name, const Variant &p_value) { … }

bool AnimationTrackKeyEdit::_get(const StringName &p_name, Variant &r_ret) const { … }

void AnimationTrackKeyEdit::_get_property_list(List<PropertyInfo> *p_list) const { … }

void AnimationTrackKeyEdit::notify_change() { … }

Node *AnimationTrackKeyEdit::get_root_path() { … }

void AnimationTrackKeyEdit::set_use_fps(bool p_enable) { … }

void AnimationMultiTrackKeyEdit::_bind_methods() { … }

void AnimationMultiTrackKeyEdit::_fix_node_path(Variant &value, NodePath &base) { … }

void AnimationMultiTrackKeyEdit::_update_obj(const Ref<Animation> &p_anim) { … }

void AnimationMultiTrackKeyEdit::_key_ofs_changed(const Ref<Animation> &p_anim, float from, float to) { … }

bool AnimationMultiTrackKeyEdit::_set(const StringName &p_name, const Variant &p_value) { … }

bool AnimationMultiTrackKeyEdit::_get(const StringName &p_name, Variant &r_ret) const { … }

void AnimationMultiTrackKeyEdit::_get_property_list(List<PropertyInfo> *p_list) const { … }

void AnimationMultiTrackKeyEdit::notify_change() { … }

Node *AnimationMultiTrackKeyEdit::get_root_path() { … }

void AnimationMultiTrackKeyEdit::set_use_fps(bool p_enable) { … }

void AnimationTimelineEdit::_zoom_changed(double) { … }

float AnimationTimelineEdit::get_zoom_scale() const { … }

float AnimationTimelineEdit::_get_zoom_scale(double p_zoom_value) const { … }

void AnimationTimelineEdit::_anim_length_changed(double p_new_len) { … }

void AnimationTimelineEdit::_anim_loop_pressed() { … }

int AnimationTimelineEdit::get_buttons_width() const { … }

int AnimationTimelineEdit::get_name_limit() const { … }

void AnimationTimelineEdit::_notification(int p_what) { … }

void AnimationTimelineEdit::set_animation(const Ref<Animation> &p_animation, bool p_read_only) { … }

Size2 AnimationTimelineEdit::get_minimum_size() const { … }

void AnimationTimelineEdit::set_zoom(Range *p_zoom) { … }

void AnimationTimelineEdit::auto_fit() { … }

void AnimationTimelineEdit::_scroll_to_start() { … }

void AnimationTimelineEdit::set_track_edit(AnimationTrackEdit *p_track_edit) { … }

void AnimationTimelineEdit::set_play_position(float p_pos) { … }

float AnimationTimelineEdit::get_play_position() const { … }

void AnimationTimelineEdit::update_play_position() { … }

void AnimationTimelineEdit::update_values() { … }

void AnimationTimelineEdit::_play_position_draw() { … }

void AnimationTimelineEdit::gui_input(const Ref<InputEvent> &p_event) { … }

Control::CursorShape AnimationTimelineEdit::get_cursor_shape(const Point2 &p_pos) const { … }

void AnimationTimelineEdit::_pan_callback(Vector2 p_scroll_vec, Ref<InputEvent> p_event) { … }

void AnimationTimelineEdit::_zoom_callback(float p_zoom_factor, Vector2 p_origin, Ref<InputEvent> p_event) { … }

void AnimationTimelineEdit::set_use_fps(bool p_use_fps) { … }

bool AnimationTimelineEdit::is_using_fps() const { … }

void AnimationTimelineEdit::set_hscroll(HScrollBar *p_hscroll) { … }

void AnimationTimelineEdit::_track_added(int p_track) { … }

void AnimationTimelineEdit::_bind_methods() { … }

AnimationTimelineEdit::AnimationTimelineEdit() { … }

////////////////////////////////////

void AnimationTrackEdit::_notification(int p_what) { … }

int AnimationTrackEdit::get_key_height() const { … }

Rect2 AnimationTrackEdit::get_key_rect(int p_index, float p_pixels_sec) { … }

bool AnimationTrackEdit::is_key_selectable_by_distance() const { … }

void AnimationTrackEdit::draw_key_link(int p_index, float p_pixels_sec, int p_x, int p_next_x, int p_clip_left, int p_clip_right) { … }

void AnimationTrackEdit::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) { … }

// Helper.
void AnimationTrackEdit::draw_rect_clipped(const Rect2 &p_rect, const Color &p_color, bool p_filled) { … }

void AnimationTrackEdit::draw_bg(int p_clip_left, int p_clip_right) { … }

void AnimationTrackEdit::draw_fg(int p_clip_left, int p_clip_right) { … }

void AnimationTrackEdit::draw_texture_region_clipped(const Ref<Texture2D> &p_texture, const Rect2 &p_rect, const Rect2 &p_region) { … }

int AnimationTrackEdit::get_track() const { … }

Ref<Animation> AnimationTrackEdit::get_animation() const { … }

void AnimationTrackEdit::set_animation_and_track(const Ref<Animation> &p_animation, int p_track, bool p_read_only) { … }

NodePath AnimationTrackEdit::get_path() const { … }

Size2 AnimationTrackEdit::get_minimum_size() const { … }

void AnimationTrackEdit::set_timeline(AnimationTimelineEdit *p_timeline) { … }

void AnimationTrackEdit::set_editor(AnimationTrackEditor *p_editor) { … }

void AnimationTrackEdit::_play_position_draw() { … }

void AnimationTrackEdit::set_play_position(float p_pos) { … }

void AnimationTrackEdit::update_play_position() { … }

void AnimationTrackEdit::set_root(Node *p_root) { … }

void AnimationTrackEdit::_zoom_changed() { … }

void AnimationTrackEdit::_path_submitted(const String &p_text) { … }

bool AnimationTrackEdit::_is_value_key_valid(const Variant &p_key_value, Variant::Type &r_valid_type) const { … }

Ref<Texture2D> AnimationTrackEdit::_get_key_type_icon() const { … }

String AnimationTrackEdit::get_tooltip(const Point2 &p_pos) const { … }

void AnimationTrackEdit::gui_input(const Ref<InputEvent> &p_event) { … }

bool AnimationTrackEdit::_try_select_at_ui_pos(const Point2 &p_pos, bool p_aggregate, bool p_deselectable) { … }

Variant AnimationTrackEdit::get_drag_data(const Point2 &p_point) { … }

bool AnimationTrackEdit::can_drop_data(const Point2 &p_point, const Variant &p_data) const { … }

void AnimationTrackEdit::drop_data(const Point2 &p_point, const Variant &p_data) { … }

void AnimationTrackEdit::_menu_selected(int p_index) { … }

void AnimationTrackEdit::cancel_drop() { … }

void AnimationTrackEdit::set_in_group(bool p_enable) { … }

void AnimationTrackEdit::append_to_selection(const Rect2 &p_box, bool p_deselection) { … }

void AnimationTrackEdit::_bind_methods() { … }

AnimationTrackEdit::AnimationTrackEdit() { … }

//////////////////////////////////////

AnimationTrackEdit *AnimationTrackEditPlugin::create_value_track_edit(Object *p_object, Variant::Type p_type, const String &p_property, PropertyHint p_hint, const String &p_hint_string, int p_usage) { … }

AnimationTrackEdit *AnimationTrackEditPlugin::create_audio_track_edit() { … }

AnimationTrackEdit *AnimationTrackEditPlugin::create_animation_track_edit(Object *p_object) { … }

///////////////////////////////////////

void AnimationTrackEditGroup::_notification(int p_what) { … }

void AnimationTrackEditGroup::gui_input(const Ref<InputEvent> &p_event) { … }

void AnimationTrackEditGroup::set_type_and_name(const Ref<Texture2D> &p_type, const String &p_name, const NodePath &p_node) { … }

Size2 AnimationTrackEditGroup::get_minimum_size() const { … }

void AnimationTrackEditGroup::set_timeline(AnimationTimelineEdit *p_timeline) { … }

void AnimationTrackEditGroup::set_root(Node *p_root) { … }

void AnimationTrackEditGroup::set_editor(AnimationTrackEditor *p_editor) { … }

void AnimationTrackEditGroup::_zoom_changed() { … }

AnimationTrackEditGroup::AnimationTrackEditGroup() { … }

//////////////////////////////////////

void AnimationTrackEditor::add_track_edit_plugin(const Ref<AnimationTrackEditPlugin> &p_plugin) { … }

void AnimationTrackEditor::remove_track_edit_plugin(const Ref<AnimationTrackEditPlugin> &p_plugin) { … }

void AnimationTrackEditor::set_animation(const Ref<Animation> &p_anim, bool p_read_only) { … }

void AnimationTrackEditor::_check_bezier_exist() { … }

Ref<Animation> AnimationTrackEditor::get_current_animation() const { … }

void AnimationTrackEditor::_root_removed() { … }

void AnimationTrackEditor::set_root(Node *p_root) { … }

Node *AnimationTrackEditor::get_root() const { … }

void AnimationTrackEditor::update_keying() { … }

bool AnimationTrackEditor::has_keying() const { … }

Dictionary AnimationTrackEditor::get_state() const { … }

void AnimationTrackEditor::set_state(const Dictionary &p_state) { … }

void AnimationTrackEditor::cleanup() { … }

void AnimationTrackEditor::_name_limit_changed() { … }

void AnimationTrackEditor::_timeline_changed(float p_new_pos, bool p_timeline_only) { … }

void AnimationTrackEditor::_track_remove_request(int p_track) { … }

void AnimationTrackEditor::_animation_track_remove_request(int p_track, Ref<Animation> p_from_animation) { … }

void AnimationTrackEditor::_track_grab_focus(int p_track) { … }

void AnimationTrackEditor::set_anim_pos(float p_pos) { … }

static bool track_type_is_resettable(Animation::TrackType p_type) { … }

void AnimationTrackEditor::make_insert_queue() { … }

void AnimationTrackEditor::commit_insert_queue() { … }

void AnimationTrackEditor::_query_insert(const InsertData &p_id) { … }

void AnimationTrackEditor::_insert_track(bool p_reset_wanted, bool p_create_beziers) { … }

void AnimationTrackEditor::insert_transform_key(Node3D *p_node, const String &p_sub, const Animation::TrackType p_type, const Variant &p_value) { … }

bool AnimationTrackEditor::has_track(Node3D *p_node, const String &p_sub, const Animation::TrackType p_type) { … }

void AnimationTrackEditor::_insert_animation_key(NodePath p_path, const Variant &p_value) { … }

void AnimationTrackEditor::insert_node_value_key(Node *p_node, const String &p_property, bool p_only_if_exists, bool p_advance) { … }

PackedStringArray AnimationTrackEditor::get_selected_section() const { … }

bool AnimationTrackEditor::is_marker_selected(const StringName &p_marker) const { … }

bool AnimationTrackEditor::is_marker_moving_selection() const { … }

float AnimationTrackEditor::get_marker_moving_selection_offset() const { … }

void AnimationTrackEditor::insert_value_key(const String &p_property, bool p_advance) { … }

Ref<Animation> AnimationTrackEditor::_create_and_get_reset_animation() { … }

void AnimationTrackEditor::_confirm_insert_list() { … }

PropertyInfo AnimationTrackEditor::_find_hint_for_track(int p_idx, NodePath &r_base_path, Variant *r_current_val) { … }

static Vector<String> _get_bezier_subindices_for_type(Variant::Type p_type, bool *r_valid = nullptr) { … }

AnimationTrackEditor::TrackIndices AnimationTrackEditor::_confirm_insert(InsertData p_id, TrackIndices p_next_tracks, bool p_reset_wanted, Ref<Animation> p_reset_anim, bool p_create_beziers) { … }

void AnimationTrackEditor::show_select_node_warning(bool p_show) { … }

void AnimationTrackEditor::show_dummy_player_warning(bool p_show) { … }

void AnimationTrackEditor::show_inactive_player_warning(bool p_show) { … }

bool AnimationTrackEditor::is_key_selected(int p_track, int p_key) const { … }

bool AnimationTrackEditor::is_selection_active() const { … }

bool AnimationTrackEditor::is_key_clipboard_active() const { … }

bool AnimationTrackEditor::is_snap_timeline_enabled() const { … }

bool AnimationTrackEditor::is_snap_keys_enabled() const { … }

bool AnimationTrackEditor::is_bezier_editor_active() const { … }

bool AnimationTrackEditor::can_add_reset_key() const { … }

void AnimationTrackEditor::_update_tracks() { … }

void AnimationTrackEditor::_redraw_tracks() { … }

void AnimationTrackEditor::_redraw_groups() { … }

void AnimationTrackEditor::_animation_changed() { … }

void AnimationTrackEditor::_snap_mode_changed(int p_mode) { … }

void AnimationTrackEditor::_update_step_spinbox() { … }

void AnimationTrackEditor::_animation_update() { … }

MenuButton *AnimationTrackEditor::get_edit_menu() { … }

void AnimationTrackEditor::_notification(int p_what) { … }

void AnimationTrackEditor::_update_scroll(double) { … }

void AnimationTrackEditor::_update_step(double p_new_step) { … }

void AnimationTrackEditor::_update_length(double p_new_len) { … }

void AnimationTrackEditor::_dropped_track(int p_from_track, int p_to_track) { … }

void AnimationTrackEditor::_new_track_node_selected(NodePath p_path) { … }

void AnimationTrackEditor::_add_track(int p_type) { … }

void AnimationTrackEditor::_fetch_value_track_options(const NodePath &p_path, Animation::UpdateMode *r_update_mode, Animation::InterpolationType *r_interpolation_type, bool *r_loop_wrap) { … }

void AnimationTrackEditor::_new_track_property_selected(const String &p_name) { … }

void AnimationTrackEditor::_timeline_value_changed(double) { … }

int AnimationTrackEditor::_get_track_selected() { … }

void AnimationTrackEditor::_insert_key_from_track(float p_ofs, int p_track) { … }

void AnimationTrackEditor::_add_method_key(const String &p_method) { … }

void AnimationTrackEditor::_key_selected(int p_key, bool p_single, int p_track) { … }

void AnimationTrackEditor::_key_deselected(int p_key, int p_track) { … }

void AnimationTrackEditor::_move_selection_begin() { … }

void AnimationTrackEditor::_move_selection(float p_offset) { … }

struct _AnimMoveRestore { … };
// Used for undo/redo.

void AnimationTrackEditor::_clear_key_edit() { … }

void AnimationTrackEditor::_clear_selection(bool p_update) { … }

void AnimationTrackEditor::_update_key_edit() { … }

void AnimationTrackEditor::_clear_selection_for_anim(const Ref<Animation> &p_anim) { … }

void AnimationTrackEditor::_select_at_anim(const Ref<Animation> &p_anim, int p_track, float p_pos) { … }

void AnimationTrackEditor::_move_selection_commit() { … }

void AnimationTrackEditor::_move_selection_cancel() { … }

bool AnimationTrackEditor::is_moving_selection() const { … }

float AnimationTrackEditor::get_moving_selection_offset() const { … }

void AnimationTrackEditor::_box_selection_draw() { … }

void AnimationTrackEditor::_scroll_input(const Ref<InputEvent> &p_event) { … }

void AnimationTrackEditor::_toggle_bezier_edit() { … }

void AnimationTrackEditor::_scroll_changed(const Vector2 &p_val) { … }

void AnimationTrackEditor::_v_scroll_changed(float p_val) { … }

void AnimationTrackEditor::_h_scroll_changed(float p_val) { … }

void AnimationTrackEditor::_pan_callback(Vector2 p_scroll_vec, Ref<InputEvent> p_event) { … }

void AnimationTrackEditor::_zoom_callback(float p_zoom_factor, Vector2 p_origin, Ref<InputEvent> p_event) { … }

void AnimationTrackEditor::_cancel_bezier_edit() { … }

void AnimationTrackEditor::_bezier_edit(int p_for_track) { … }

void AnimationTrackEditor::_bezier_track_set_key_handle_mode(Animation *p_anim, int p_track, int p_index, Animation::HandleMode p_mode, Animation::HandleSetMode p_set_mode) { … }

void AnimationTrackEditor::_anim_duplicate_keys(float p_ofs, bool p_ofs_valid, int p_track) { … }

void AnimationTrackEditor::_anim_copy_keys(bool p_cut) { … }

void AnimationTrackEditor::_set_key_clipboard(int p_top_track, float p_top_time, RBMap<SelectedKey, KeyInfo> &p_keys) { … }

void AnimationTrackEditor::_anim_paste_keys(float p_ofs, bool p_ofs_valid, int p_track) { … }

bool AnimationTrackEditor::_is_track_compatible(int p_target_track_idx, Variant::Type p_source_value_type, Animation::TrackType p_source_track_type) { … }

void AnimationTrackEditor::_edit_menu_about_to_popup() { … }

void AnimationTrackEditor::goto_prev_step(bool p_from_mouse_event) { … }

void AnimationTrackEditor::goto_next_step(bool p_from_mouse_event, bool p_timeline_only) { … }

void AnimationTrackEditor::_edit_menu_pressed(int p_option) { … }

void AnimationTrackEditor::_cleanup_animation(Ref<Animation> p_animation) { … }

void AnimationTrackEditor::_view_group_toggle() { … }

bool AnimationTrackEditor::is_grouping_tracks() { … }

void AnimationTrackEditor::_auto_fit() { … }

void AnimationTrackEditor::_auto_fit_bezier() { … }

void AnimationTrackEditor::_selection_changed() { … }

void AnimationTrackEditor::_update_snap_unit() { … }

float AnimationTrackEditor::snap_time(float p_value, bool p_relative) { … }

void AnimationTrackEditor::_show_imported_anim_warning() { … }

void AnimationTrackEditor::_show_dummy_player_warning() { … }

void AnimationTrackEditor::_show_inactive_player_warning() { … }

void AnimationTrackEditor::_select_all_tracks_for_copy() { … }

void AnimationTrackEditor::_bind_methods() { … }

void AnimationTrackEditor::_pick_track_filter_text_changed(const String &p_newtext) { … }

void AnimationTrackEditor::_pick_track_select_recursive(TreeItem *p_item, const String &p_filter, Vector<Node *> &p_select_candidates) { … }

AnimationTrackEditor::AnimationTrackEditor() { … }

AnimationTrackEditor::~AnimationTrackEditor() { … }

// AnimationTrackKeyEditEditorPlugin.

void AnimationTrackKeyEditEditor::_time_edit_entered() { … }

void AnimationTrackKeyEditEditor::_time_edit_exited() { … }

AnimationTrackKeyEditEditor::AnimationTrackKeyEditEditor(Ref<Animation> p_animation, int p_track, real_t p_key_ofs, bool p_use_fps) { … }

AnimationTrackKeyEditEditor::~AnimationTrackKeyEditEditor() { … }

void AnimationMarkerEdit::_zoom_changed() { … }

void AnimationMarkerEdit::_menu_selected(int p_index) { … }

void AnimationMarkerEdit::_play_position_draw() { … }

bool AnimationMarkerEdit::_try_select_at_ui_pos(const Point2 &p_pos, bool p_aggregate, bool p_deselectable) { … }

bool AnimationMarkerEdit::_is_ui_pos_in_current_section(const Point2 &p_pos) { … }

HBoxContainer *AnimationMarkerEdit::_create_hbox_labeled_control(const String &p_text, Control *p_control) const { … }

void AnimationMarkerEdit::_update_key_edit() { … }

void AnimationMarkerEdit::_clear_key_edit() { … }

void AnimationMarkerEdit::_bind_methods() { … }

void AnimationMarkerEdit::_notification(int p_what) { … }

void AnimationMarkerEdit::gui_input(const Ref<InputEvent> &p_event) { … }

String AnimationMarkerEdit::get_tooltip(const Point2 &p_pos) const { … }

int AnimationMarkerEdit::get_key_height() const { … }

Rect2 AnimationMarkerEdit::get_key_rect(float p_pixels_sec) const { … }

PackedStringArray AnimationMarkerEdit::get_selected_section() const { … }

bool AnimationMarkerEdit::is_marker_selected(const StringName &p_marker) const { … }

bool AnimationMarkerEdit::is_key_selectable_by_distance() const { … }

void AnimationMarkerEdit::draw_key(const StringName &p_name, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) { … }

void AnimationMarkerEdit::draw_bg(int p_clip_left, int p_clip_right) { … }

void AnimationMarkerEdit::draw_fg(int p_clip_left, int p_clip_right) { … }

Ref<Animation> AnimationMarkerEdit::get_animation() const { … }

void AnimationMarkerEdit::set_animation(const Ref<Animation> &p_animation, bool p_read_only) { … }

Size2 AnimationMarkerEdit::get_minimum_size() const { … }

void AnimationMarkerEdit::set_timeline(AnimationTimelineEdit *p_timeline) { … }

void AnimationMarkerEdit::set_editor(AnimationTrackEditor *p_editor) { … }

void AnimationMarkerEdit::set_play_position(float p_pos) { … }

void AnimationMarkerEdit::update_play_position() { … }

void AnimationMarkerEdit::set_use_fps(bool p_use_fps) { … }

void AnimationMarkerEdit::_move_selection_begin() { … }

void AnimationMarkerEdit::_move_selection(float p_offset) { … }

void AnimationMarkerEdit::_move_selection_commit() { … }

void AnimationMarkerEdit::_delete_selected_markers() { … }

void AnimationMarkerEdit::_move_selection_cancel() { … }

void AnimationMarkerEdit::_clear_selection(bool p_update) { … }

void AnimationMarkerEdit::_clear_selection_for_anim(const Ref<Animation> &p_anim) { … }

void AnimationMarkerEdit::_select_key(const StringName &p_name, bool is_single) { … }

void AnimationMarkerEdit::_deselect_key(const StringName &p_name) { … }

void AnimationMarkerEdit::_insert_marker(float p_ofs) { … }

void AnimationMarkerEdit::_rename_marker(const StringName &p_name) { … }

void AnimationMarkerEdit::_marker_insert_confirmed() { … }

void AnimationMarkerEdit::_marker_insert_new_name_changed(const String &p_text) { … }

void AnimationMarkerEdit::_marker_rename_confirmed() { … }

void AnimationMarkerEdit::_marker_rename_new_name_changed(const String &p_text) { … }

AnimationMarkerEdit::AnimationMarkerEdit() { … }

AnimationMarkerEdit::~AnimationMarkerEdit() { … }

float AnimationMarkerKeyEdit::get_time() const { … }

void AnimationMarkerKeyEdit::_bind_methods() { … }

void AnimationMarkerKeyEdit::_set_marker_name(const StringName &p_name) { … }

bool AnimationMarkerKeyEdit::_set(const StringName &p_name, const Variant &p_value) { … }

bool AnimationMarkerKeyEdit::_get(const StringName &p_name, Variant &r_ret) const { … }

void AnimationMarkerKeyEdit::_get_property_list(List<PropertyInfo> *p_list) const { … }

void AnimationMultiMarkerKeyEdit::_bind_methods() { … }

bool AnimationMultiMarkerKeyEdit::_set(const StringName &p_name, const Variant &p_value) { … }

bool AnimationMultiMarkerKeyEdit::_get(const StringName &p_name, Variant &r_ret) const { … }

void AnimationMultiMarkerKeyEdit::_get_property_list(List<PropertyInfo> *p_list) const { … }

// AnimationMarkerKeyEditEditorPlugin

void AnimationMarkerKeyEditEditor::_time_edit_entered() { … }

void AnimationMarkerKeyEditEditor::_time_edit_exited() { … }

AnimationMarkerKeyEditEditor::AnimationMarkerKeyEditEditor(Ref<Animation> p_animation, const StringName &p_name, bool p_use_fps) { … }

AnimationMarkerKeyEditEditor::~AnimationMarkerKeyEditEditor() { … }
godot/editor/animation_track_editor.cpp
