diff --git a/editor/plugins/gradient_texture_2d_editor_plugin.cpp b/editor/plugins/gradient_texture_2d_editor_plugin.cpp index e91afe28ee8b..3df8aeaa1491 100644 --- a/editor/plugins/gradient_texture_2d_editor_plugin.cpp +++ b/editor/plugins/gradient_texture_2d_editor_plugin.cpp @@ -39,145 +39,191 @@ #include "scene/gui/flow_container.h" #include "scene/gui/separator.h" -Point2 GradientTexture2DEditorRect::_get_handle_position(const Handle p_handle) { +void GradientTexture2DEdit::_on_mouse_exited() { + if (hovered != HANDLE_NONE) { + hovered = HANDLE_NONE; + queue_redraw(); + } +} + +Point2 GradientTexture2DEdit::_get_handle_pos(const Handle p_handle) { // Get the handle's mouse position in pixels relative to offset. - return (p_handle == HANDLE_FILL_FROM ? texture->get_fill_from() : texture->get_fill_to()).clamp(Vector2(), Vector2(1, 1)) * size; + return (p_handle == HANDLE_FROM ? texture->get_fill_from() : texture->get_fill_to()).clamp(Vector2(), Vector2(1, 1)) * size; } -void GradientTexture2DEditorRect::_update_fill_position() { - if (handle == HANDLE_NONE) { - return; +GradientTexture2DEdit::Handle GradientTexture2DEdit::get_handle_at(const Vector2 &p_pos) { + Point2 from_pos = _get_handle_pos(HANDLE_FROM); + Point2 to_pos = _get_handle_pos(HANDLE_TO); + // If both handles are at the position, grab the one that's closer. + if (p_pos.distance_squared_to(from_pos) < p_pos.distance_squared_to(to_pos)) { + return Rect2(from_pos.round() - handle_size / 2, handle_size).has_point(p_pos) ? HANDLE_FROM : HANDLE_NONE; + } else { + return Rect2(to_pos.round() - handle_size / 2, handle_size).has_point(p_pos) ? HANDLE_TO : HANDLE_NONE; } +} - // Update the texture's fill_from/fill_to property based on mouse input. - Vector2 percent = ((get_local_mouse_position() - offset) / size).clamp(Vector2(), Vector2(1, 1)); - if (snap_enabled) { - percent = (percent - Vector2(0.5, 0.5)).snapped(Vector2(snap_size, snap_size)) + Vector2(0.5, 0.5); +void GradientTexture2DEdit::set_fill_pos(const Vector2 &p_pos) { + if (p_pos.is_equal_approx(initial_grab_pos)) { + return; } - String property_name = handle == HANDLE_FILL_FROM ? "fill_from" : "fill_to"; - + const StringName property_name = (grabbed == HANDLE_FROM) ? "fill_from" : "fill_to"; EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton(); - undo_redo->create_action(vformat(TTR("Set %s"), property_name), UndoRedo::MERGE_ENDS); - undo_redo->add_do_property(texture.ptr(), property_name, percent); - undo_redo->add_undo_property(texture.ptr(), property_name, handle == HANDLE_FILL_FROM ? texture->get_fill_from() : texture->get_fill_to()); + undo_redo->create_action(TTR("Move GradientTexture2D Fill Point")); + undo_redo->add_do_property(texture.ptr(), property_name, p_pos); + undo_redo->add_undo_property(texture.ptr(), property_name, initial_grab_pos); undo_redo->commit_action(); } -void GradientTexture2DEditorRect::gui_input(const Ref &p_event) { - // Grab/release handle. +void GradientTexture2DEdit::gui_input(const Ref &p_event) { const Ref mb = p_event; - if (mb.is_valid() && mb->get_button_index() == MouseButton::LEFT) { - if (mb->is_pressed()) { - Point2 mouse_position = mb->get_position() - offset; - if (Rect2(_get_handle_position(HANDLE_FILL_FROM).round() - handle_size / 2, handle_size).has_point(mouse_position)) { - handle = HANDLE_FILL_FROM; - } else if (Rect2(_get_handle_position(HANDLE_FILL_TO).round() - handle_size / 2, handle_size).has_point(mouse_position)) { - handle = HANDLE_FILL_TO; + if (mb.is_valid()) { + if (mb->get_button_index() == MouseButton::LEFT) { + if (mb->is_pressed()) { + grabbed = get_handle_at(mb->get_position() - offset); + + if (grabbed != HANDLE_NONE) { + initial_grab_pos = _get_handle_pos(grabbed) / size; + queue_redraw(); + } } else { - handle = HANDLE_NONE; + // Release the handle. + if (grabbed != HANDLE_NONE) { + set_fill_pos(_get_handle_pos(grabbed) / size); + grabbed = HANDLE_NONE; + queue_redraw(); + } } - } else { - _update_fill_position(); - handle = HANDLE_NONE; + } + + if (grabbed != HANDLE_NONE && mb->is_pressed() && mb->get_button_index() == MouseButton::RIGHT) { + texture->set((grabbed == HANDLE_FROM) ? SNAME("fill_from") : SNAME("fill_to"), initial_grab_pos); + grabbed = HANDLE_NONE; + queue_redraw(); } } // Move handle. const Ref mm = p_event; if (mm.is_valid()) { - _update_fill_position(); + Vector2 mpos = mm->get_position() - offset; + + Handle handle_at_mpos = get_handle_at(mpos); + if (hovered != handle_at_mpos) { + hovered = handle_at_mpos; + queue_redraw(); + } + + if (grabbed == HANDLE_NONE) { + return; + } + + Vector2 new_pos = (mpos / size).clamp(Vector2(0, 0), Vector2(1, 1)); + if (snap_enabled || mm->is_ctrl_pressed()) { + new_pos = new_pos.snapped(Vector2(1.0 / snap_count, 1.0 / snap_count)); + } + + // Allow to snap to an axis with Shift. + if (mm->is_shift_pressed()) { + Vector2 initial_mpos = initial_grab_pos * size; + if (Math::abs(mpos.x - initial_mpos.x) > Math::abs(mpos.y - initial_mpos.y)) { + new_pos.y = initial_grab_pos.y; + } else { + new_pos.x = initial_grab_pos.x; + } + } + // Do it directly from the texture so there's no undo/redo until the handle is released. + texture->set((grabbed == HANDLE_FROM) ? SNAME("fill_from") : SNAME("fill_to"), new_pos); } } -void GradientTexture2DEditorRect::set_texture(Ref &p_texture) { +void GradientTexture2DEdit::set_texture(Ref &p_texture) { texture = p_texture; texture->connect("changed", callable_mp((CanvasItem *)this, &CanvasItem::queue_redraw)); } -void GradientTexture2DEditorRect::set_snap_enabled(bool p_snap_enabled) { +void GradientTexture2DEdit::set_snap_enabled(bool p_snap_enabled) { snap_enabled = p_snap_enabled; queue_redraw(); + if (texture.is_valid()) { + if (snap_enabled) { + texture->set_meta(SNAME("_snap_enabled"), true); + } else { + texture->remove_meta(SNAME("_snap_enabled")); + } + } } -void GradientTexture2DEditorRect::set_snap_size(float p_snap_size) { - snap_size = p_snap_size; +void GradientTexture2DEdit::set_snap_count(int p_snap_count) { + snap_count = p_snap_count; queue_redraw(); + if (texture.is_valid()) { + if (snap_count != GradientTexture2DEditor::DEFAULT_SNAP) { + texture->set_meta(SNAME("_snap_count"), snap_count); + } else { + texture->remove_meta(SNAME("_snap_count")); + } + } } -void GradientTexture2DEditorRect::_notification(int p_what) { +void GradientTexture2DEdit::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: + connect("mouse_exited", callable_mp(this, &GradientTexture2DEdit::_on_mouse_exited)); + [[fallthrough]]; case NOTIFICATION_THEME_CHANGED: { checkerboard->set_texture(get_theme_icon(SNAME("GuiMiniCheckerboard"), SNAME("EditorIcons"))); } break; - case NOTIFICATION_DRAW: { - if (texture.is_null()) { - return; - } - - const Ref fill_from_icon = get_theme_icon(SNAME("EditorPathSmoothHandle"), SNAME("EditorIcons")); - const Ref fill_to_icon = get_theme_icon(SNAME("EditorPathSharpHandle"), SNAME("EditorIcons")); - handle_size = fill_from_icon->get_size(); - - Size2 rect_size = get_size(); - - // Get the size and position to draw the texture and handles at. - // Subtract handle sizes so they stay inside the preview, but keep the texture's aspect ratio. - Size2 available_size = rect_size - handle_size; - Size2 ratio = available_size / texture->get_size(); - size = MIN(ratio.x, ratio.y) * texture->get_size(); - offset = ((rect_size - size) / 2).round(); - - checkerboard->set_rect(Rect2(offset, size)); - - draw_set_transform(offset); - draw_texture_rect(texture, Rect2(Point2(), size)); - - // Draw grid snap lines. - if (snap_enabled) { - const Color primary_line_color = Color(0.5, 0.5, 0.5, 0.9); - const Color line_color = Color(0.5, 0.5, 0.5, 0.5); + _draw(); + } break; + } +} - // Draw border and centered axis lines. - draw_rect(Rect2(Point2(), size), primary_line_color, false); - draw_line(Point2(size.width / 2, 0), Point2(size.width / 2, size.height), primary_line_color); - draw_line(Point2(0, size.height / 2), Point2(size.width, size.height / 2), primary_line_color); +void GradientTexture2DEdit::_draw() { + if (texture.is_null()) { + return; + } - // Draw vertical lines. - int prev_idx = 0; - for (int x = 0; x < size.width; x++) { - int idx = int((x / size.width - 0.5) / snap_size); + const Ref fill_from_icon = get_theme_icon(SNAME("EditorPathSmoothHandle"), SNAME("EditorIcons")); + const Ref fill_to_icon = get_theme_icon(SNAME("EditorPathSharpHandle"), SNAME("EditorIcons")); + handle_size = fill_from_icon->get_size(); - if (x > 0 && prev_idx != idx) { - draw_line(Point2(x, 0), Point2(x, size.height), line_color); - } + Size2 rect_size = get_size(); - prev_idx = idx; - } + // Get the size and position to draw the texture and handles at. + // Subtract handle sizes so they stay inside the preview, but keep the texture's aspect ratio. + Size2 available_size = rect_size - handle_size; + Size2 ratio = available_size / texture->get_size(); + size = MIN(ratio.x, ratio.y) * texture->get_size(); + offset = ((rect_size - size) / 2).round(); - // Draw horizontal lines. - prev_idx = 0; - for (int y = 0; y < size.height; y++) { - int idx = int((y / size.height - 0.5) / snap_size); + checkerboard->set_rect(Rect2(offset, size)); - if (y > 0 && prev_idx != idx) { - draw_line(Point2(0, y), Point2(size.width, y), line_color); - } + draw_set_transform(offset); + draw_texture_rect(texture, Rect2(Point2(), size)); - prev_idx = idx; - } - } + // Draw grid snap lines. + if (snap_enabled || (Input::get_singleton()->is_key_pressed(Key::CTRL) && grabbed != HANDLE_NONE)) { + const Color line_color = Color(0.5, 0.5, 0.5, 0.5); - // Draw handles. - draw_texture(fill_from_icon, (_get_handle_position(HANDLE_FILL_FROM) - handle_size / 2).round()); - draw_texture(fill_to_icon, (_get_handle_position(HANDLE_FILL_TO) - handle_size / 2).round()); - } break; + for (int idx = 0; idx < snap_count + 1; idx++) { + float x = float(idx * size.width) / snap_count; + float y = float(idx * size.height) / snap_count; + draw_line(Point2(x, 0), Point2(x, size.height), line_color); + draw_line(Point2(0, y), Point2(size.width, y), line_color); + } } + + // Draw handles. + const Color focus_modulate = Color(0.5, 1, 2); + bool modulate_handle_from = grabbed == HANDLE_FROM || (grabbed != HANDLE_FROM && hovered == HANDLE_FROM); + bool modulate_handle_to = grabbed == HANDLE_TO || (grabbed != HANDLE_TO && hovered == HANDLE_TO); + draw_texture(fill_from_icon, (_get_handle_pos(HANDLE_FROM) - handle_size / 2).round(), modulate_handle_from ? focus_modulate : Color(1, 1, 1)); + draw_texture(fill_to_icon, (_get_handle_pos(HANDLE_TO) - handle_size / 2).round(), modulate_handle_to ? focus_modulate : Color(1, 1, 1)); } -GradientTexture2DEditorRect::GradientTexture2DEditorRect() { +GradientTexture2DEdit::GradientTexture2DEdit() { checkerboard = memnew(TextureRect); checkerboard->set_stretch_mode(TextureRect::STRETCH_TILE); checkerboard->set_expand_mode(TextureRect::EXPAND_IGNORE_SIZE); @@ -189,6 +235,8 @@ GradientTexture2DEditorRect::GradientTexture2DEditorRect() { /////////////////////// +const int GradientTexture2DEditor::DEFAULT_SNAP = 10; + void GradientTexture2DEditor::_reverse_button_pressed() { EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton(); undo_redo->create_action(TTR("Swap GradientTexture2D Fill Points")); @@ -201,12 +249,11 @@ void GradientTexture2DEditor::_reverse_button_pressed() { void GradientTexture2DEditor::_set_snap_enabled(bool p_enabled) { texture_editor_rect->set_snap_enabled(p_enabled); - - snap_size_edit->set_visible(p_enabled); + snap_count_edit->set_visible(p_enabled); } -void GradientTexture2DEditor::_set_snap_size(float p_snap_size) { - texture_editor_rect->set_snap_size(MAX(p_snap_size, 0.01)); +void GradientTexture2DEditor::_set_snap_count(int p_snap_count) { + texture_editor_rect->set_snap_count(p_snap_count); } void GradientTexture2DEditor::set_texture(Ref &p_texture) { @@ -221,6 +268,11 @@ void GradientTexture2DEditor::_notification(int p_what) { reverse_button->set_icon(get_theme_icon(SNAME("ReverseGradient"), SNAME("EditorIcons"))); snap_button->set_icon(get_theme_icon(SNAME("SnapGrid"), SNAME("EditorIcons"))); } break; + case NOTIFICATION_READY: { + // Set snapping settings based on the texture's meta. + snap_button->set_pressed(texture->get_meta("_snap_enabled", false)); + snap_count_edit->set_value(texture->get_meta("_snap_count", DEFAULT_SNAP)); + } break; } } @@ -241,21 +293,20 @@ GradientTexture2DEditor::GradientTexture2DEditor() { toolbar->add_child(snap_button); snap_button->connect("toggled", callable_mp(this, &GradientTexture2DEditor::_set_snap_enabled)); - snap_size_edit = memnew(EditorSpinSlider); - snap_size_edit->set_min(0.01); - snap_size_edit->set_max(0.5); - snap_size_edit->set_step(0.01); - snap_size_edit->set_value(0.1); - snap_size_edit->set_custom_minimum_size(Size2(65 * EDSCALE, 0)); - toolbar->add_child(snap_size_edit); - snap_size_edit->connect("value_changed", callable_mp(this, &GradientTexture2DEditor::_set_snap_size)); + snap_count_edit = memnew(EditorSpinSlider); + snap_count_edit->set_min(2); + snap_count_edit->set_max(100); + snap_count_edit->set_value(DEFAULT_SNAP); + snap_count_edit->set_custom_minimum_size(Size2(65 * EDSCALE, 0)); + toolbar->add_child(snap_count_edit); + snap_count_edit->connect("value_changed", callable_mp(this, &GradientTexture2DEditor::_set_snap_count)); - texture_editor_rect = memnew(GradientTexture2DEditorRect); + texture_editor_rect = memnew(GradientTexture2DEdit); add_child(texture_editor_rect); set_mouse_filter(MOUSE_FILTER_STOP); _set_snap_enabled(snap_button->is_pressed()); - _set_snap_size(snap_size_edit->get_value()); + _set_snap_count(snap_count_edit->get_value()); } /////////////////////// diff --git a/editor/plugins/gradient_texture_2d_editor_plugin.h b/editor/plugins/gradient_texture_2d_editor_plugin.h index 0b496b210e03..5f693f58736d 100644 --- a/editor/plugins/gradient_texture_2d_editor_plugin.h +++ b/editor/plugins/gradient_texture_2d_editor_plugin.h @@ -37,39 +37,48 @@ class Button; class EditorSpinSlider; -class GradientTexture2DEditorRect : public Control { - GDCLASS(GradientTexture2DEditorRect, Control); +class GradientTexture2DEdit : public Control { + GDCLASS(GradientTexture2DEdit, Control); enum Handle { HANDLE_NONE, - HANDLE_FILL_FROM, - HANDLE_FILL_TO + HANDLE_FROM, + HANDLE_TO }; Ref texture; bool snap_enabled = false; - float snap_size = 0; + int snap_count = 0; TextureRect *checkerboard = nullptr; - Handle handle = HANDLE_NONE; + Handle hovered = HANDLE_NONE; + Handle grabbed = HANDLE_NONE; + Point2 initial_grab_pos; + Size2 handle_size; Point2 offset; Size2 size; - Point2 _get_handle_position(const Handle p_handle); - void _update_fill_position(); + Point2 _get_handle_pos(const Handle p_handle); + Handle get_handle_at(const Vector2 &p_pos); + void set_fill_pos(const Vector2 &p_pos); + virtual void gui_input(const Ref &p_event) override; + void _on_mouse_exited(); + + void _draw(); + protected: void _notification(int p_what); public: void set_texture(Ref &p_texture); void set_snap_enabled(bool p_snap_enabled); - void set_snap_size(float p_snap_size); + void set_snap_count(int p_snap_count); - GradientTexture2DEditorRect(); + GradientTexture2DEdit(); }; class GradientTexture2DEditor : public VBoxContainer { @@ -79,17 +88,18 @@ class GradientTexture2DEditor : public VBoxContainer { Button *reverse_button = nullptr; Button *snap_button = nullptr; - EditorSpinSlider *snap_size_edit = nullptr; - GradientTexture2DEditorRect *texture_editor_rect = nullptr; + EditorSpinSlider *snap_count_edit = nullptr; + GradientTexture2DEdit *texture_editor_rect = nullptr; void _reverse_button_pressed(); void _set_snap_enabled(bool p_enabled); - void _set_snap_size(float p_snap_size); + void _set_snap_count(int p_snap_count); protected: void _notification(int p_what); public: + static const int DEFAULT_SNAP; void set_texture(Ref &p_texture); GradientTexture2DEditor();