From d0e09d84f085c5bffdd5ad06d335be20c246e954 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pedro=20J=2E=20Est=C3=A9banez?= Date: Mon, 30 Oct 2017 19:43:19 +0100 Subject: [PATCH] Implement onion skinning for the animation editor --- editor/editor_settings.cpp | 2 + .../animation_player_editor_plugin.cpp | 452 +++++++++++++++++- .../plugins/animation_player_editor_plugin.h | 66 ++- scene/animation/animation_player.cpp | 11 + scene/animation/animation_player.h | 3 + scene/main/scene_tree.cpp | 10 +- scene/main/scene_tree.h | 3 +- 7 files changed, 538 insertions(+), 9 deletions(-) diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp index 582bb977b8..910c06053e 100644 --- a/editor/editor_settings.cpp +++ b/editor/editor_settings.cpp @@ -462,6 +462,8 @@ void EditorSettings::_load_defaults(Ref p_extra_config) { _initial_set("editors/animation/autorename_animation_tracks", true); _initial_set("editors/animation/confirm_insert_track", true); + _initial_set("editors/animation/onion_layers_past_color", Color(1, 0, 0)); + _initial_set("editors/animation/onion_layers_future_color", Color(0, 1, 0)); _initial_set("docks/property_editor/texture_preview_width", 48); _initial_set("docks/property_editor/auto_refresh_interval", 0.3); diff --git a/editor/plugins/animation_player_editor_plugin.cpp b/editor/plugins/animation_player_editor_plugin.cpp index 2b9c625aa4..019e32f847 100644 --- a/editor/plugins/animation_player_editor_plugin.cpp +++ b/editor/plugins/animation_player_editor_plugin.cpp @@ -36,6 +36,12 @@ #include "os/keyboard.h" #include "project_settings.h" +// For onion skinning +#include "editor/plugins/canvas_item_editor_plugin.h" +#include "editor/plugins/spatial_editor_plugin.h" +#include "scene/main/viewport.h" +#include "servers/visual_server.h" + void AnimationPlayerEditor::_node_removed(Node *p_node) { if (player && player == p_node) { @@ -98,6 +104,8 @@ void AnimationPlayerEditor::_notification(int p_what) { tool_anim->get_popup()->connect("id_pressed", this, "_animation_tool_menu"); + onion_skinning->get_popup()->connect("id_pressed", this, "_onion_skinning_menu"); + blend_editor.next->connect("item_selected", this, "_blend_editor_next_changed"); get_tree()->connect("node_removed", this, "_node_removed"); @@ -132,6 +140,7 @@ void AnimationPlayerEditor::_notification(int p_what) { resource_edit_anim->set_icon(get_icon("EditResource", "EditorIcons")); pin->set_icon(get_icon("Pin", "EditorIcons")); tool_anim->set_icon(get_icon("Tools", "EditorIcons")); + onion_skinning->set_icon(get_icon("Onion", "EditorIcons")); } break; } @@ -809,6 +818,7 @@ void AnimationPlayerEditor::_update_player() { resource_edit_anim->set_disabled(animlist.size() == 0); save_anim->set_disabled(animlist.size() == 0); tool_anim->set_disabled(player == NULL); + onion_skinning->set_disabled(player == NULL); int active_idx = -1; for (List::Element *E = animlist.front(); E; E = E->next()) { @@ -855,6 +865,9 @@ void AnimationPlayerEditor::_update_player() { void AnimationPlayerEditor::edit(AnimationPlayer *p_player) { + if (onion.enabled) + _start_onion_skinning(); + if (player && pin->is_pressed()) return; //ignore, pinned player = p_player; @@ -869,6 +882,55 @@ void AnimationPlayerEditor::edit(AnimationPlayer *p_player) { } } +void AnimationPlayerEditor::forward_force_draw_over_viewport(Control *p_overlay) { + + if (!onion.can_overlay) + return; + + // Can happen on viewport resize, at least + if (!_are_onion_layers_valid()) + return; + + RID ci = p_overlay->get_canvas_item(); + Rect2 src_rect = p_overlay->get_global_rect(); + // Re-flip since captures are already flipped + src_rect.position.y = onion.capture_size.y - (src_rect.position.y + src_rect.size.y); + src_rect.size.y *= -1; + + Rect2 dst_rect = Rect2(Point2(), p_overlay->get_size()); + + float alpha_step = 1.0 / (onion.steps + 1); + + int cidx = 0; + if (onion.past) { + float alpha = 0; + do { + alpha += alpha_step; + + if (onion.captures_valid[cidx]) { + VS::get_singleton()->canvas_item_add_texture_rect_region( + ci, dst_rect, VS::get_singleton()->viewport_get_texture(onion.captures[cidx]), src_rect, Color(1, 1, 1, alpha)); + } + + cidx++; + } while (cidx < onion.steps); + } + if (onion.future) { + float alpha = 1; + int base_cidx = cidx; + do { + alpha -= alpha_step; + + if (onion.captures_valid[cidx]) { + VS::get_singleton()->canvas_item_add_texture_rect_region( + ci, dst_rect, VS::get_singleton()->viewport_get_texture(onion.captures[cidx]), src_rect, Color(1, 1, 1, alpha)); + } + + cidx++; + } while (cidx < base_cidx + onion.steps); // In case there's the present capture at the end, skip it + } +} + void AnimationPlayerEditor::_animation_duplicate() { if (!animation->get_item_count()) @@ -1100,6 +1162,70 @@ void AnimationPlayerEditor::_animation_save_menu(int p_option) { } } +void AnimationPlayerEditor::_onion_skinning_menu(int p_option) { + + PopupMenu *menu = onion_skinning->get_popup(); + int idx = menu->get_item_index(p_option); + + switch (p_option) { + + case ONION_SKINNING_ENABLE: { + + onion.enabled = !onion.enabled; + menu->set_item_checked(idx, onion.enabled); + + if (onion.enabled) + _start_onion_skinning(); + else + _stop_onion_skinning(); + + } break; + + case ONION_SKINNING_PAST: { + + // Ensure at least one of past/future is checjed + onion.past = onion.future ? !onion.past : true; + menu->set_item_checked(idx, onion.past); + } break; + + case ONION_SKINNING_FUTURE: { + + // Ensure at least one of past/future is checjed + onion.future = onion.past ? !onion.future : true; + menu->set_item_checked(idx, onion.future); + } break; + + case ONION_SKINNING_1_STEP: // Fall-through + case ONION_SKINNING_2_STEPS: + case ONION_SKINNING_3_STEPS: { + + onion.steps = (p_option - ONION_SKINNING_1_STEP) + 1; + int one_frame_idx = menu->get_item_index(ONION_SKINNING_1_STEP); + for (int i = 0; i <= ONION_SKINNING_LAST_STEPS_OPTION - ONION_SKINNING_1_STEP; i++) { + menu->set_item_checked(one_frame_idx + i, onion.steps == i + 1); + } + } break; + + case ONION_SKINNING_DIFFERENCES_ONLY: { + + onion.differences_only = !onion.differences_only; + menu->set_item_checked(idx, onion.differences_only); + } break; + + case ONION_SKINNING_FORCE_WHITE_MODULATE: { + + onion.force_white_modulate = !onion.force_white_modulate; + menu->set_item_checked(idx, onion.force_white_modulate); + } break; + + case ONION_SKINNING_INCLUDE_GIZMOS: { + + onion.include_gizmos = !onion.include_gizmos; + menu->set_item_checked(idx, onion.include_gizmos); + } break; + } +} + void AnimationPlayerEditor::_unhandled_key_input(const Ref &p_ev) { Ref k = p_ev; @@ -1126,6 +1252,237 @@ void AnimationPlayerEditor::_unhandled_key_input(const Ref &p_ev) { } } +void AnimationPlayerEditor::_editor_visibility_changed() { + + if (is_visible()) { + _start_onion_skinning(); + } +} + +bool AnimationPlayerEditor::_are_onion_layers_valid() { + + ERR_FAIL_COND_V(!onion.past && !onion.future, false); + + Point2 capture_size = get_tree()->get_root()->get_size(); + return onion.captures.size() == onion.get_needed_capture_count() && onion.capture_size == capture_size; +} + +void AnimationPlayerEditor::_allocate_onion_layers() { + + _free_onion_layers(); + + int captures = onion.get_needed_capture_count(); + Point2 capture_size = get_tree()->get_root()->get_size(); + + onion.captures.resize(captures); + onion.captures_valid.resize(captures); + + for (int i = 0; i < captures; i++) { + bool is_present = onion.differences_only && i == captures - 1; + + // Each capture is a viewport with a canvas item attached that renders a full-size rect with the contents of the main viewport + onion.captures[i] = VS::get_singleton()->viewport_create(); + VS::get_singleton()->viewport_set_usage(onion.captures[i], VS::VIEWPORT_USAGE_2D); + VS::get_singleton()->viewport_set_size(onion.captures[i], capture_size.width, capture_size.height); + VS::get_singleton()->viewport_set_update_mode(onion.captures[i], VS::VIEWPORT_UPDATE_ALWAYS); + VS::get_singleton()->viewport_set_transparent_background(onion.captures[i], !is_present); + VS::get_singleton()->viewport_set_vflip(onion.captures[i], true); + VS::get_singleton()->viewport_attach_canvas(onion.captures[i], onion.capture.canvas); + } + + // Reset the capture canvas item to the current root viewport texture (defensive) + VS::get_singleton()->canvas_item_clear(onion.capture.canvas_item); + VS::get_singleton()->canvas_item_add_texture_rect(onion.capture.canvas_item, Rect2(Point2(), capture_size), get_tree()->get_root()->get_texture()->get_rid()); + + onion.capture_size = capture_size; +} + +void AnimationPlayerEditor::_free_onion_layers() { + + for (int i = 0; i < onion.captures.size(); i++) { + if (onion.captures[i].is_valid()) { + VS::get_singleton()->free(onion.captures[i]); + } + } + onion.captures.clear(); + onion.captures_valid.clear(); +} + +void AnimationPlayerEditor::_prepare_onion_layers_1() { + + // This would be called per viewport and we want to act once only + int64_t frame = get_tree()->get_frame(); + if (frame == onion.last_frame) + return; + + if (!onion.enabled || !is_processing() || !is_visible() || !get_player()) { + _stop_onion_skinning(); + return; + } + + onion.last_frame = frame; + + // Refresh viewports with no onion layers overlaid + onion.can_overlay = false; + plugin->update_overlays(); + + if (player->is_playing()) + return; + + // And go to next step afterwards + call_deferred("_prepare_onion_layers_2"); +} + +void AnimationPlayerEditor::_prepare_onion_layers_2() { + + Ref anim = player->get_animation(player->get_current_animation()); + if (!anim.is_valid()) + return; + + if (!_are_onion_layers_valid()) + _allocate_onion_layers(); + + // Hide superfluous elements that would make the overlay unnecessary cluttered + Dictionary canvas_edit_state; + Dictionary spatial_edit_state; + if (SpatialEditor::get_singleton()->is_visible()) { + // 3D + spatial_edit_state = SpatialEditor::get_singleton()->get_state(); + Dictionary new_state = spatial_edit_state.copy(); + new_state["show_grid"] = false; + new_state["show_origin"] = false; + Array orig_vp = spatial_edit_state["viewports"]; + Array vp; + vp.resize(4); + for (int i = 0; i < vp.size(); i++) { + Dictionary d = ((Dictionary)orig_vp[i]).copy(); + d["use_environment"] = false; + d["doppler"] = false; + d["gizmos"] = onion.include_gizmos ? d["gizmos"] : Variant(false); + d["information"] = false; + vp[i] = d; + } + new_state["viewports"] = vp; + // TODO: Save/restore only affected entries + SpatialEditor::get_singleton()->set_state(new_state); + } else { // CanvasItemEditor + // 2D + canvas_edit_state = CanvasItemEditor::get_singleton()->get_state(); + Dictionary new_state = canvas_edit_state.copy(); + new_state["show_grid"] = false; + new_state["show_rulers"] = false; + new_state["show_guides"] = false; + new_state["show_helpers"] = false; + // TODO: Save/restore only affected entries + CanvasItemEditor::get_singleton()->set_state(new_state); + } + + // Tweak the root viewport to ensure it's rendered before our target + RID root_vp = get_tree()->get_root()->get_viewport_rid(); + Rect2 root_vp_screen_rect = get_tree()->get_root()->get_attach_to_screen_rect(); + VS::get_singleton()->viewport_attach_to_screen(root_vp, Rect2()); + VS::get_singleton()->viewport_set_update_mode(root_vp, VS::VIEWPORT_UPDATE_ALWAYS); + + RID present_rid; + if (onion.differences_only) { + // Capture present scene as it is + VS::get_singleton()->canvas_item_set_material(onion.capture.canvas_item, RID()); + present_rid = onion.captures[onion.captures.size() - 1]; + VS::get_singleton()->viewport_set_active(present_rid, true); + VS::get_singleton()->viewport_set_parent_viewport(root_vp, present_rid); + VS::get_singleton()->draw(false); + VS::get_singleton()->viewport_set_active(present_rid, false); + } + + // Backup current animation state + AnimatedValuesBackup values_backup = player->backup_animated_values(); + float cpos = player->get_current_animation_position(); + + // Render every past/future step with the capture shader + + VS::get_singleton()->canvas_item_set_material(onion.capture.canvas_item, onion.capture.material->get_rid()); + onion.capture.material->set_shader_param("bkg_color", GLOBAL_GET("rendering/environment/default_clear_color")); + onion.capture.material->set_shader_param("differences_only", onion.differences_only); + onion.capture.material->set_shader_param("present", onion.differences_only ? VS::get_singleton()->viewport_get_texture(present_rid) : RID()); + + int step_off_a = onion.past ? -onion.steps : 0; + int step_off_b = onion.future ? onion.steps : 0; + int cidx = 0; + onion.capture.material->set_shader_param("dir_color", onion.force_white_modulate ? Color(1, 1, 1) : Color(EDITOR_GET("editors/animation/onion_layers_past_color"))); + for (int step_off = step_off_a; step_off <= step_off_b; step_off++) { + + if (step_off == 0) { + // Skip present step and switch to the color of future + if (!onion.force_white_modulate) + onion.capture.material->set_shader_param("dir_color", EDITOR_GET("editors/animation/onion_layers_future_color")); + continue; + } + + float pos = cpos + step_off * anim->get_step(); + + bool valid = anim->has_loop() || pos >= 0 && pos <= anim->get_length(); + onion.captures_valid[cidx] = valid; + if (valid) { + player->seek(pos, true); + get_tree()->flush_transform_notifications(); // Needed for transforms of Spatials + values_backup.update_skeletons(); // Needed for Skeletons + + VS::get_singleton()->viewport_set_active(onion.captures[cidx], true); + VS::get_singleton()->viewport_set_parent_viewport(root_vp, onion.captures[cidx]); + VS::get_singleton()->draw(false); + VS::get_singleton()->viewport_set_active(onion.captures[cidx], false); + } + + cidx++; + } + + // Restore root viewport + VS::get_singleton()->viewport_set_parent_viewport(root_vp, RID()); + VS::get_singleton()->viewport_attach_to_screen(root_vp, root_vp_screen_rect); + VS::get_singleton()->viewport_set_update_mode(root_vp, VS::VIEWPORT_UPDATE_WHEN_VISIBLE); + + // Restore animation state + // (Seeking with update=true wouldn't do the trick because the current value of the properties + // may not match their value for the current point in the animation) + player->seek(cpos, false); + player->restore_animated_values(values_backup); + + // Restor state of main editors + if (SpatialEditor::get_singleton()->is_visible()) { + // 3D + SpatialEditor::get_singleton()->set_state(spatial_edit_state); + } else { // CanvasItemEditor + // 2D + CanvasItemEditor::get_singleton()->set_state(canvas_edit_state); + } + + // Update viewports with skin layers overlaid for the actual engine loop render + onion.can_overlay = true; + plugin->update_overlays(); +} + +void AnimationPlayerEditor::_start_onion_skinning() { + + // FIXME: Using "idle_frame" makes onion layers update one frame behing the current + if (!get_tree()->is_connected("idle_frame", this, "call_deferred")) { + get_tree()->connect("idle_frame", this, "call_deferred", varray("_prepare_onion_layers_1")); + } +} + +void AnimationPlayerEditor::_stop_onion_skinning() { + + if (get_tree()->is_connected("idle_frame", this, "call_deferred")) { + + get_tree()->disconnect("idle_frame", this, "call_deferred"); + + _free_onion_layers(); + + // Clean up the overlay + onion.can_overlay = false; + plugin->update_overlays(); + } +} + void AnimationPlayerEditor::_bind_methods() { ClassDB::bind_method(D_METHOD("_gui_input"), &AnimationPlayerEditor::_gui_input); @@ -1165,6 +1522,10 @@ void AnimationPlayerEditor::_bind_methods() { ClassDB::bind_method(D_METHOD("_unhandled_key_input"), &AnimationPlayerEditor::_unhandled_key_input); ClassDB::bind_method(D_METHOD("_animation_tool_menu"), &AnimationPlayerEditor::_animation_tool_menu); ClassDB::bind_method(D_METHOD("_animation_save_menu"), &AnimationPlayerEditor::_animation_save_menu); + ClassDB::bind_method(D_METHOD("_onion_skinning_menu"), &AnimationPlayerEditor::_onion_skinning_menu); + ClassDB::bind_method(D_METHOD("_editor_visibility_changed"), &AnimationPlayerEditor::_editor_visibility_changed); + ClassDB::bind_method(D_METHOD("_prepare_onion_layers_1"), &AnimationPlayerEditor::_prepare_onion_layers_1); + ClassDB::bind_method(D_METHOD("_prepare_onion_layers_2"), &AnimationPlayerEditor::_prepare_onion_layers_2); } AnimationPlayerEditor *AnimationPlayerEditor::singleton = NULL; @@ -1173,8 +1534,10 @@ AnimationPlayer *AnimationPlayerEditor::get_player() const { return player; } -AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor) { + +AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor, AnimationPlayerEditorPlugin *p_plugin) { editor = p_editor; + plugin = p_plugin; singleton = this; updating = false; @@ -1301,6 +1664,29 @@ AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor) { //tool_anim->get_popup()->add_item("Edit Anim Resource",TOOL_PASTE_ANIM); hb->add_child(tool_anim); + onion_skinning = memnew(MenuButton); + //onion_skinning->set_flat(false); + onion_skinning->set_tooltip(TTR("Onion Skinning")); + onion_skinning->get_popup()->add_check_shortcut(ED_SHORTCUT("animation_player_editor/onion_skinning", TTR("Enable Onion Skinning")), ONION_SKINNING_ENABLE); + onion_skinning->get_popup()->add_separator(); + onion_skinning->get_popup()->add_item(TTR("Directions"), -1); + onion_skinning->get_popup()->set_item_disabled(onion_skinning->get_popup()->get_item_count() - 1, true); + onion_skinning->get_popup()->add_check_item(TTR("Past"), ONION_SKINNING_PAST); + onion_skinning->get_popup()->set_item_checked(onion_skinning->get_popup()->get_item_count() - 1, true); + onion_skinning->get_popup()->add_check_item(TTR("Future"), ONION_SKINNING_FUTURE); + onion_skinning->get_popup()->add_separator(); + onion_skinning->get_popup()->add_item(TTR("Depth"), -1); + onion_skinning->get_popup()->set_item_disabled(onion_skinning->get_popup()->get_item_count() - 1, true); + onion_skinning->get_popup()->add_check_item(TTR("1 step"), ONION_SKINNING_1_STEP); + onion_skinning->get_popup()->set_item_checked(onion_skinning->get_popup()->get_item_count() - 1, true); + onion_skinning->get_popup()->add_check_item(TTR("2 steps"), ONION_SKINNING_2_STEPS); + onion_skinning->get_popup()->add_check_item(TTR("3 steps"), ONION_SKINNING_3_STEPS); + onion_skinning->get_popup()->add_separator(); + onion_skinning->get_popup()->add_check_item(TTR("Differences Only"), ONION_SKINNING_DIFFERENCES_ONLY); + onion_skinning->get_popup()->add_check_item(TTR("Force White Modulate"), ONION_SKINNING_FORCE_WHITE_MODULATE); + onion_skinning->get_popup()->add_check_item(TTR("Include Gizmos (3D)"), ONION_SKINNING_INCLUDE_GIZMOS); + hb->add_child(onion_skinning); + pin = memnew(ToolButton); pin->set_toggle_mode(true); hb->add_child(pin); @@ -1387,6 +1773,68 @@ AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor) { key_editor->connect("animation_step_changed", this, "_animation_key_editor_anim_step_changed"); _update_player(); + + // Onion skinning + + key_editor->connect("visibility_changed", this, "_editor_visibility_changed"); + + onion.enabled = false; + onion.past = true; + onion.future = false; + onion.steps = 1; + onion.differences_only = false; + onion.force_white_modulate = false; + onion.include_gizmos = false; + + onion.last_frame = 0; + onion.can_overlay = false; + onion.capture_size = Size2(); + onion.capture.canvas = VS::get_singleton()->canvas_create(); + onion.capture.canvas_item = VS::get_singleton()->canvas_item_create(); + VS::get_singleton()->canvas_item_set_parent(onion.capture.canvas_item, onion.capture.canvas); + + onion.capture.material = Ref(memnew(ShaderMaterial)); + + onion.capture.shader = Ref(memnew(Shader)); + onion.capture.shader->set_code(" \ + shader_type canvas_item; \ + \ + uniform vec4 bkg_color; \ + uniform vec4 dir_color; \ + uniform bool differences_only; \ + uniform sampler2D present; \ + \ + float zero_if_equal(vec4 a, vec4 b) { \ + return smoothstep(0.0, 0.005, length(a.rgb - b.rgb) / sqrt(3.0)); \ + } \ + \ + void fragment() { \ + vec4 capture_samp = texture(TEXTURE, UV); \ + vec4 present_samp = texture(present, UV); \ + float bkg_mask = zero_if_equal(capture_samp, bkg_color); \ + float diff_mask = 1.0 - zero_if_equal(present_samp, bkg_color); \ + diff_mask = min(1.0, diff_mask + float(!differences_only)); \ + COLOR = vec4(capture_samp.rgb * dir_color.rgb, bkg_mask * diff_mask); \ + } \ + "); + VS::get_singleton()->material_set_shader(onion.capture.material->get_rid(), onion.capture.shader->get_rid()); +} + +AnimationPlayerEditor::~AnimationPlayerEditor() { + + _free_onion_layers(); + VS::get_singleton()->free(onion.capture.canvas); + VS::get_singleton()->free(onion.capture.canvas_item); +} + +void AnimationPlayerEditorPlugin::_notification(int p_what) { + + switch (p_what) { + case NOTIFICATION_ENTER_TREE: { + + set_force_draw_over_forwarding_enabled(); + } break; + } } void AnimationPlayerEditorPlugin::edit(Object *p_object) { @@ -1420,7 +1868,7 @@ void AnimationPlayerEditorPlugin::make_visible(bool p_visible) { AnimationPlayerEditorPlugin::AnimationPlayerEditorPlugin(EditorNode *p_node) { editor = p_node; - anim_editor = memnew(AnimationPlayerEditor(editor)); + anim_editor = memnew(AnimationPlayerEditor(editor, this)); anim_editor->set_undo_redo(editor->get_undo_redo()); editor->add_bottom_panel_item(TTR("Animation"), anim_editor); diff --git a/editor/plugins/animation_player_editor_plugin.h b/editor/plugins/animation_player_editor_plugin.h index cea6b05ed4..1a1e92d7b7 100644 --- a/editor/plugins/animation_player_editor_plugin.h +++ b/editor/plugins/animation_player_editor_plugin.h @@ -42,11 +42,13 @@ @author Juan Linietsky */ class AnimationKeyEditor; +class AnimationPlayerEditorPlugin; class AnimationPlayerEditor : public VBoxContainer { GDCLASS(AnimationPlayerEditor, VBoxContainer); EditorNode *editor; + AnimationPlayerEditorPlugin *plugin; AnimationPlayer *player; enum { @@ -55,6 +57,19 @@ class AnimationPlayerEditor : public VBoxContainer { TOOL_EDIT_RESOURCE }; + enum { + ONION_SKINNING_ENABLE, + ONION_SKINNING_PAST, + ONION_SKINNING_FUTURE, + ONION_SKINNING_1_STEP, + ONION_SKINNING_2_STEPS, + ONION_SKINNING_3_STEPS, + ONION_SKINNING_LAST_STEPS_OPTION = ONION_SKINNING_3_STEPS, + ONION_SKINNING_DIFFERENCES_ONLY, + ONION_SKINNING_FORCE_WHITE_MODULATE, + ONION_SKINNING_INCLUDE_GIZMOS, + }; + enum { ANIM_SAVE, ANIM_SAVE_AS @@ -84,6 +99,7 @@ class AnimationPlayerEditor : public VBoxContainer { Button *blend_anim; Button *remove_anim; MenuButton *tool_anim; + MenuButton *onion_skinning; ToolButton *pin; SpinBox *frame; LineEdit *scale; @@ -115,6 +131,36 @@ class AnimationPlayerEditor : public VBoxContainer { AnimationKeyEditor *key_editor; + // Onion skinning + struct { + // Settings + bool enabled; + bool past; + bool future; + int steps; + bool differences_only; + bool force_white_modulate; + bool include_gizmos; + + int get_needed_capture_count() const { + // 'Differences only' needs a capture of the present + return (past && future ? 2 * steps : steps) + (differences_only ? 1 : 0); + } + + // Rendering + int64_t last_frame; + int can_overlay; + Size2 capture_size; + Vector captures; + Vector captures_valid; + struct { + RID canvas; + RID canvas_item; + Ref material; + Ref shader; + } capture; + } onion; + void _select_anim_by_name(const String &p_anim); void _play_pressed(); void _play_from_pressed(); @@ -161,8 +207,19 @@ class AnimationPlayerEditor : public VBoxContainer { void _unhandled_key_input(const Ref &p_ev); void _animation_tool_menu(int p_option); void _animation_save_menu(int p_option); + void _onion_skinning_menu(int p_option); + + void _editor_visibility_changed(); + bool _are_onion_layers_valid(); + void _allocate_onion_layers(); + void _free_onion_layers(); + void _prepare_onion_layers_1(); + void _prepare_onion_layers_2(); + void _start_onion_skinning(); + void _stop_onion_skinning(); AnimationPlayerEditor(); + ~AnimationPlayerEditor(); protected: void _notification(int p_what); @@ -182,7 +239,9 @@ public: void set_undo_redo(UndoRedo *p_undo_redo) { undo_redo = p_undo_redo; } void edit(AnimationPlayer *p_player); - AnimationPlayerEditor(EditorNode *p_editor); + void forward_force_draw_over_viewport(Control *p_overlay); + + AnimationPlayerEditor(EditorNode *p_editor, AnimationPlayerEditorPlugin *p_plugin); }; class AnimationPlayerEditorPlugin : public EditorPlugin { @@ -192,6 +251,9 @@ class AnimationPlayerEditorPlugin : public EditorPlugin { AnimationPlayerEditor *anim_editor; EditorNode *editor; +protected: + void _notification(int p_what); + public: virtual Dictionary get_state() const { return anim_editor->get_state(); } virtual void set_state(const Dictionary &p_state) { anim_editor->set_state(p_state); } @@ -202,6 +264,8 @@ public: virtual bool handles(Object *p_object) const; virtual void make_visible(bool p_visible); + virtual void forward_force_draw_over_viewport(Control *p_overlay) { anim_editor->forward_force_draw_over_viewport(p_overlay); } + AnimationPlayerEditorPlugin(EditorNode *p_node); ~AnimationPlayerEditorPlugin(); }; diff --git a/scene/animation/animation_player.cpp b/scene/animation/animation_player.cpp index ea445b1573..206f3ccca2 100644 --- a/scene/animation/animation_player.cpp +++ b/scene/animation/animation_player.cpp @@ -33,6 +33,17 @@ #include "message_queue.h" #include "scene/scene_string_names.h" +#ifdef TOOLS_ENABLED +void AnimatedValuesBackup::update_skeletons() { + + for (int i = 0; i < entries.size(); i++) { + if (entries[i].bone_idx != -1) { + Object::cast_to(entries[i].object)->notification(Skeleton::NOTIFICATION_UPDATE_SKELETON); + } + } +} +#endif + bool AnimationPlayer::_set(const StringName &p_name, const Variant &p_value) { String name = p_name; diff --git a/scene/animation/animation_player.h b/scene/animation/animation_player.h index 4a347f49ea..e39afcf199 100644 --- a/scene/animation/animation_player.h +++ b/scene/animation/animation_player.h @@ -50,6 +50,9 @@ class AnimatedValuesBackup { Vector entries; friend class AnimationPlayer; + +public: + void update_skeletons(); }; #endif diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp index d4be683a2b..b8dba96551 100644 --- a/scene/main/scene_tree.cpp +++ b/scene/main/scene_tree.cpp @@ -127,7 +127,7 @@ void SceneTree::remove_from_group(const StringName &p_group, Node *p_node) { group_map.erase(E); } -void SceneTree::_flush_transform_notifications() { +void SceneTree::flush_transform_notifications() { SelfList *n = xform_change_list.first(); while (n) { @@ -448,7 +448,7 @@ bool SceneTree::iteration(float p_time) { current_frame++; - _flush_transform_notifications(); + flush_transform_notifications(); MainLoop::iteration(p_time); physics_process_time = p_time; @@ -459,7 +459,7 @@ bool SceneTree::iteration(float p_time) { _notify_group_pause("physics_process", Node::NOTIFICATION_PHYSICS_PROCESS); _flush_ugc(); MessageQueue::get_singleton()->flush(); //small little hack - _flush_transform_notifications(); + flush_transform_notifications(); call_group_flags(GROUP_CALL_REALTIME, "_viewports", "update_worlds"); root_lock--; @@ -487,7 +487,7 @@ bool SceneTree::idle(float p_time) { MessageQueue::get_singleton()->flush(); //small little hack - _flush_transform_notifications(); + flush_transform_notifications(); _notify_group_pause("idle_process_internal", Node::NOTIFICATION_INTERNAL_PROCESS); _notify_group_pause("idle_process", Node::NOTIFICATION_PROCESS); @@ -503,7 +503,7 @@ bool SceneTree::idle(float p_time) { _flush_ugc(); MessageQueue::get_singleton()->flush(); //small little hack - _flush_transform_notifications(); //transforms after world update, to avoid unnecessary enter/exit notifications + flush_transform_notifications(); //transforms after world update, to avoid unnecessary enter/exit notifications call_group_flags(GROUP_CALL_REALTIME, "_viewports", "update_worlds"); root_lock--; diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h index bc3efdc42f..7898dc065a 100644 --- a/scene/main/scene_tree.h +++ b/scene/main/scene_tree.h @@ -157,7 +157,6 @@ private: Map > unique_group_calls; bool ugc_locked; void _flush_ugc(); - void _flush_transform_notifications(); _FORCE_INLINE_ void _update_group_order(Group &g); void _update_listener(); @@ -344,6 +343,8 @@ public: void notify_group(const StringName &p_group, int p_notification); void set_group(const StringName &p_group, const String &p_name, const Variant &p_value); + void flush_transform_notifications(); + virtual void input_text(const String &p_text); virtual void input_event(const Ref &p_event); virtual void init();