godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Improvements to Gradient2D Editor

This commit is contained in:
VolTer 2023-01-04 17:14:49 +02:00
parent 64eeb04d2c
commit 39b79bbd1e
2 changed files with 185 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

273
editor/plugins/gradient_texture_2d_editor_plugin.cpp
View File

@ -39,145 +39,191 @@
#include "scene/gui/flow_container.h"
#include "scene/gui/separator.h"
Point2 GradientTexture2DEditorRect::_get_handle_position(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;
void GradientTexture2DEdit::_on_mouse_exited() {
if (hovered != HANDLE_NONE) {
hovered = HANDLE_NONE;
queue_redraw();
}
}
void GradientTexture2DEditorRect::_update_fill_position() {
if (handle == HANDLE_NONE) {
Point2 GradientTexture2DEdit::_get_handle_pos(const Handle p_handle) {
// Get the handle's mouse position in pixels relative to offset.
return (p_handle == HANDLE_FROM ? texture->get_fill_from() : texture->get_fill_to()).clamp(Vector2(), Vector2(1, 1)) * size;
}
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;
}
}
void GradientTexture2DEdit::set_fill_pos(const Vector2 &p_pos) {
if (p_pos.is_equal_approx(initial_grab_pos)) {
return;
}
// 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);
}
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<InputEvent> &p_event) {
// Grab/release handle.
void GradientTexture2DEdit::gui_input(const Ref<InputEvent> &p_event) {
const Ref<InputEventMouseButton> 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<InputEventMouseMotion> 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<GradientTexture2D> &p_texture) {
void GradientTexture2DEdit::set_texture(Ref<GradientTexture2D> &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<Texture2D> fill_from_icon = get_theme_icon(SNAME("EditorPathSmoothHandle"), SNAME("EditorIcons"));
const Ref<Texture2D> 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 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);
// 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);
if (x > 0 && prev_idx != idx) {
draw_line(Point2(x, 0), Point2(x, size.height), line_color);
}
prev_idx = idx;
}
// Draw horizontal lines.
prev_idx = 0;
for (int y = 0; y < size.height; y++) {
int idx = int((y / size.height - 0.5) / snap_size);
if (y > 0 && prev_idx != idx) {
draw_line(Point2(0, y), Point2(size.width, y), line_color);
}
prev_idx = idx;
}
}
// 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());
_draw();
} break;
}
}
GradientTexture2DEditorRect::GradientTexture2DEditorRect() {
void GradientTexture2DEdit::_draw() {
if (texture.is_null()) {
return;
}
const Ref<Texture2D> fill_from_icon = get_theme_icon(SNAME("EditorPathSmoothHandle"), SNAME("EditorIcons"));
const Ref<Texture2D> 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 || (Input::get_singleton()->is_key_pressed(Key::CTRL) && grabbed != HANDLE_NONE)) {
const Color line_color = Color(0.5, 0.5, 0.5, 0.5);
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));
}
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<GradientTexture2D> &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());
}
///////////////////////

36
editor/plugins/gradient_texture_2d_editor_plugin.h
View File

@ -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<GradientTexture2D> 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<InputEvent> &p_event) override;
void _on_mouse_exited();
void _draw();
protected:
void _notification(int p_what);
public:
void set_texture(Ref<GradientTexture2D> &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<GradientTexture2D> &p_texture);
GradientTexture2DEditor();