virtualx-engine/editor/plugins/particle_process_material_editor_plugin.cpp

/**************************************************************************/
/*  particle_process_material_editor_plugin.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 "particle_process_material_editor_plugin.h"

#include "editor/editor_property_name_processor.h"
#include "editor/editor_settings.h"
#include "editor/editor_string_names.h"
#include "editor/gui/editor_spin_slider.h"
#include "editor/themes/editor_theme_manager.h"
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#include "scene/gui/label.h"
#include "scene/resources/particle_process_material.h"

void ParticleProcessMaterialMinMaxPropertyEditor::_update_sizing() {
	edit_size = range_edit_widget->get_size();
	margin = Vector2(range_slider_left_icon->get_width(), (edit_size.y - range_slider_left_icon->get_height()) * 0.5);
	usable_area = edit_size - margin * 2;
}

void ParticleProcessMaterialMinMaxPropertyEditor::_range_edit_draw() {
	ERR_FAIL_COND(range_slider_left_icon.is_null());
	ERR_FAIL_COND(range_slider_right_icon.is_null());
	_update_sizing();

	bool widget_active = mouse_inside || drag != Drag::NONE;

	// FIXME: Need to offset by 1 due to some outline bug.
	range_edit_widget->draw_rect(Rect2(margin + Vector2(1, 1), usable_area - Vector2(1, 1)), widget_active ? background_color.lerp(normal_color, 0.3) : background_color, false, 1.0);

	Color draw_color;

	if (widget_active) {
		float icon_offset = _get_left_offset() - range_slider_left_icon->get_width() - 1;

		if (drag == Drag::LEFT || drag == Drag::SCALE) {
			draw_color = drag_color;
		} else if (hover == Hover::LEFT) {
			draw_color = hovered_color;
		} else {
			draw_color = normal_color;
		}
		range_edit_widget->draw_texture(range_slider_left_icon, Vector2(icon_offset, margin.y), draw_color);

		icon_offset = _get_right_offset();

		if (drag == Drag::RIGHT || drag == Drag::SCALE) {
			draw_color = drag_color;
		} else if (hover == Hover::RIGHT) {
			draw_color = hovered_color;
		} else {
			draw_color = normal_color;
		}
		range_edit_widget->draw_texture(range_slider_right_icon, Vector2(icon_offset, margin.y), draw_color);
	}

	if (drag == Drag::MIDDLE || drag == Drag::SCALE) {
		draw_color = drag_color;
	} else if (hover == Hover::MIDDLE) {
		draw_color = hovered_color;
	} else {
		draw_color = normal_color;
	}
	range_edit_widget->draw_rect(_get_middle_rect(), draw_color);

	Rect2 midpoint_rect(Vector2(margin.x + usable_area.x * (_get_min_ratio() + _get_max_ratio()) * 0.5 - 1, margin.y + 2),
			Vector2(2, usable_area.y - 4));

	range_edit_widget->draw_rect(midpoint_rect, midpoint_color);
}

void ParticleProcessMaterialMinMaxPropertyEditor::_range_edit_gui_input(const Ref<InputEvent> &p_event) {
	Ref<InputEventMouseButton> mb = p_event;
	Ref<InputEventMouseMotion> mm = p_event;

	// Prevent unnecessary computations.
	if ((mb.is_null() || mb->get_button_index() != MouseButton::LEFT) && (mm.is_null())) {
		return;
	}

	ERR_FAIL_COND(range_slider_left_icon.is_null());
	ERR_FAIL_COND(range_slider_right_icon.is_null());
	_update_sizing();

	if (mb.is_valid()) {
		const Drag prev_drag = drag;

		if (mb->is_pressed()) {
			if (mb->is_shift_pressed()) {
				drag = Drag::SCALE;
				drag_from_value = (max_range->get_value() - min_range->get_value()) * 0.5;
				drag_midpoint = (max_range->get_value() + min_range->get_value()) * 0.5;
			} else if (hover == Hover::LEFT) {
				drag = Drag::LEFT;
				drag_from_value = min_range->get_value();
			} else if (hover == Hover::RIGHT) {
				drag = Drag::RIGHT;
				drag_from_value = max_range->get_value();
			} else {
				drag = Drag::MIDDLE;
				drag_from_value = min_range->get_value();
			}
			drag_origin = mb->get_position().x;
		} else {
			drag = Drag::NONE;
		}

		if (drag != prev_drag) {
			range_edit_widget->queue_redraw();
		}
	}

	float property_length = property_range.y - property_range.x;
	if (mm.is_valid()) {
		switch (drag) {
			case Drag::NONE: {
				const Hover prev_hover = hover;
				float left_icon_offset = _get_left_offset() - range_slider_left_icon->get_width() - 1;

				if (Rect2(Vector2(left_icon_offset, 0), range_slider_left_icon->get_size()).has_point(mm->get_position())) {
					hover = Hover::LEFT;
				} else if (Rect2(Vector2(_get_right_offset(), 0), range_slider_right_icon->get_size()).has_point(mm->get_position())) {
					hover = Hover::RIGHT;
				} else if (_get_middle_rect().has_point(mm->get_position())) {
					hover = Hover::MIDDLE;
				} else {
					hover = Hover::NONE;
				}

				if (hover != prev_hover) {
					range_edit_widget->queue_redraw();
				}
			} break;

			case Drag::LEFT:
			case Drag::RIGHT: {
				float new_value = drag_from_value + (mm->get_position().x - drag_origin) / usable_area.x * property_length;
				if (drag == Drag::LEFT) {
					new_value = MIN(new_value, max_range->get_value());
					_set_clamped_values(new_value, max_range->get_value());
				} else {
					new_value = MAX(new_value, min_range->get_value());
					_set_clamped_values(min_range->get_value(), new_value);
				}
			} break;

			case Drag::MIDDLE: {
				float delta = (mm->get_position().x - drag_origin) / usable_area.x * property_length;
				float diff = max_range->get_value() - min_range->get_value();
				delta = CLAMP(drag_from_value + delta, property_range.x, property_range.y - diff) - drag_from_value;
				_set_clamped_values(drag_from_value + delta, drag_from_value + delta + diff);
			} break;

			case Drag::SCALE: {
				float delta = (mm->get_position().x - drag_origin) / usable_area.x * property_length + drag_from_value;
				_set_clamped_values(MIN(drag_midpoint, drag_midpoint - delta), MAX(drag_midpoint, drag_midpoint + delta));
			} break;
		}
	}
}

void ParticleProcessMaterialMinMaxPropertyEditor::_set_mouse_inside(bool p_inside) {
	mouse_inside = p_inside;
	if (!p_inside) {
		hover = Hover::NONE;
	}
	range_edit_widget->queue_redraw();
}

float ParticleProcessMaterialMinMaxPropertyEditor::_get_min_ratio() const {
	return (min_range->get_value() - property_range.x) / (property_range.y - property_range.x);
}

float ParticleProcessMaterialMinMaxPropertyEditor::_get_max_ratio() const {
	return (max_range->get_value() - property_range.x) / (property_range.y - property_range.x);
}

float ParticleProcessMaterialMinMaxPropertyEditor::_get_left_offset() const {
	return margin.x + usable_area.x * _get_min_ratio();
}

float ParticleProcessMaterialMinMaxPropertyEditor::_get_right_offset() const {
	return margin.x + usable_area.x * _get_max_ratio();
}

Rect2 ParticleProcessMaterialMinMaxPropertyEditor::_get_middle_rect() const {
	if (Math::is_equal_approx(min_range->get_value(), max_range->get_value())) {
		return Rect2();
	}

	return Rect2(
			Vector2(_get_left_offset() - 1, margin.y),
			Vector2(usable_area.x * (_get_max_ratio() - _get_min_ratio()) + 1, usable_area.y));
}

void ParticleProcessMaterialMinMaxPropertyEditor::_set_clamped_values(float p_min, float p_max) {
	// This is required for editing widget in case the properties have or_less or or_greater hint.
	min_range->set_value(MAX(p_min, property_range.x));
	max_range->set_value(MIN(p_max, property_range.y));
	_update_slider_values();
	_sync_property();
}

void ParticleProcessMaterialMinMaxPropertyEditor::_sync_property() {
	const Vector2 value = Vector2(min_range->get_value(), max_range->get_value());
	emit_changed(get_edited_property(), value, "", true);
	range_edit_widget->queue_redraw();
}

void ParticleProcessMaterialMinMaxPropertyEditor::_update_mode() {
	max_edit->set_read_only(false);

	switch (slider_mode) {
		case Mode::RANGE: {
			min_edit->set_label("min");
			max_edit->set_label("max");
			max_edit->set_block_signals(true);
			max_edit->set_min(max_range->get_min());
			max_edit->set_max(max_range->get_max());
			max_edit->set_block_signals(false);

			min_edit->set_allow_lesser(min_range->is_lesser_allowed());
			min_edit->set_allow_greater(min_range->is_greater_allowed());
			max_edit->set_allow_lesser(max_range->is_lesser_allowed());
			max_edit->set_allow_greater(max_range->is_greater_allowed());
		} break;

		case Mode::MIDPOINT: {
			min_edit->set_label("val");
			max_edit->set_label(U"±");
			max_edit->set_block_signals(true);
			max_edit->set_min(0);
			max_edit->set_block_signals(false);

			min_edit->set_allow_lesser(min_range->is_lesser_allowed());
			min_edit->set_allow_greater(max_range->is_greater_allowed());
			max_edit->set_allow_lesser(false);
			max_edit->set_allow_greater(min_range->is_lesser_allowed() && max_range->is_greater_allowed());
		} break;
	}
	_update_slider_values();
}

void ParticleProcessMaterialMinMaxPropertyEditor::_toggle_mode(bool p_edit_mode) {
	slider_mode = p_edit_mode ? Mode::MIDPOINT : Mode::RANGE;
	EditorSettings::get_singleton()->set_project_metadata("editor_metadata", "particle_spin_mode", int(slider_mode));
	_update_mode();
}

void ParticleProcessMaterialMinMaxPropertyEditor::_update_slider_values() {
	switch (slider_mode) {
		case Mode::RANGE: {
			min_edit->set_value_no_signal(min_range->get_value());
			max_edit->set_value_no_signal(max_range->get_value());
		} break;

		case Mode::MIDPOINT: {
			min_edit->set_value_no_signal((min_range->get_value() + max_range->get_value()) * 0.5);
			max_edit->set_value_no_signal((max_range->get_value() - min_range->get_value()) * 0.5);

			max_edit->set_block_signals(true);
			max_edit->set_max(_get_max_spread());
			max_edit->set_read_only(max_edit->get_max() == 0);
			max_edit->set_block_signals(false);
		} break;
	}
}

void ParticleProcessMaterialMinMaxPropertyEditor::_sync_sliders(float, const EditorSpinSlider *p_changed_slider) {
	switch (slider_mode) {
		case Mode::RANGE: {
			if (p_changed_slider == max_edit) {
				min_edit->set_value_no_signal(MIN(min_edit->get_value(), max_edit->get_value()));
			}
			min_range->set_value(min_edit->get_value());
			if (p_changed_slider == min_edit) {
				max_edit->set_value_no_signal(MAX(min_edit->get_value(), max_edit->get_value()));
			}
			max_range->set_value(max_edit->get_value());
			_sync_property();
		} break;

		case Mode::MIDPOINT: {
			if (p_changed_slider == min_edit) {
				max_edit->set_block_signals(true); // If max changes, value may change.
				max_edit->set_max(_get_max_spread());
				max_edit->set_read_only(max_edit->get_max() == 0);
				max_edit->set_block_signals(false);
			}
			min_range->set_value(min_edit->get_value() - max_edit->get_value());
			max_range->set_value(min_edit->get_value() + max_edit->get_value());
			_sync_property();
		} break;
	}

	property_range.x = MIN(min_range->get_value(), min_range->get_min());
	property_range.y = MAX(max_range->get_value(), max_range->get_max());
}

float ParticleProcessMaterialMinMaxPropertyEditor::_get_max_spread() const {
	float max_spread = max_range->get_max() - min_range->get_min();

	if (max_edit->is_greater_allowed()) {
		return max_spread;
	}

	if (!min_edit->is_lesser_allowed()) {
		max_spread = MIN(max_spread, min_edit->get_value() - min_edit->get_min());
	}

	if (!min_edit->is_greater_allowed()) {
		max_spread = MIN(max_spread, min_edit->get_max() - min_edit->get_value());
	}

	return max_spread;
}

void ParticleProcessMaterialMinMaxPropertyEditor::_notification(int p_what) {
	switch (p_what) {
		case NOTIFICATION_THEME_CHANGED: {
			toggle_mode_button->set_icon(get_editor_theme_icon(SNAME("Anchor")));
			range_slider_left_icon = get_editor_theme_icon(SNAME("RangeSliderLeft"));
			range_slider_right_icon = get_editor_theme_icon(SNAME("RangeSliderRight"));

			min_edit->add_theme_color_override(SNAME("label_color"), get_theme_color(SNAME("property_color_x"), EditorStringName(Editor)));
			max_edit->add_theme_color_override(SNAME("label_color"), get_theme_color(SNAME("property_color_y"), EditorStringName(Editor)));

			const bool dark_theme = EditorThemeManager::is_dark_theme();
			const Color accent_color = get_theme_color(SNAME("accent_color"), EditorStringName(Editor));
			background_color = dark_theme ? Color(0.3, 0.3, 0.3) : Color(0.7, 0.7, 0.7);
			normal_color = dark_theme ? Color(0.5, 0.5, 0.5) : Color(0.8, 0.8, 0.8);
			hovered_color = dark_theme ? Color(0.8, 0.8, 0.8) : Color(0.6, 0.6, 0.6);
			drag_color = hovered_color.lerp(accent_color, 0.8);
			midpoint_color = dark_theme ? Color(1, 1, 1) : Color(0, 0, 0);

			range_edit_widget->set_custom_minimum_size(Vector2(0, range_slider_left_icon->get_height() + 8));
		} break;
	}
}

void ParticleProcessMaterialMinMaxPropertyEditor::setup(float p_min, float p_max, float p_step, bool p_allow_less, bool p_allow_greater, bool p_degrees) {
	property_range = Vector2(p_min, p_max);

	// Initially all Ranges share properties.
	for (Range *range : Vector<Range *>{ min_range, min_edit, max_range, max_edit }) {
		range->set_min(p_min);
		range->set_max(p_max);
		range->set_step(p_step);
		range->set_allow_lesser(p_allow_less);
		range->set_allow_greater(p_allow_greater);
	}

	if (p_degrees) {
		min_edit->set_suffix(U" \u00B0");
		max_edit->set_suffix(U" \u00B0");
	}
	_update_mode();
}

void ParticleProcessMaterialMinMaxPropertyEditor::update_property() {
	const Vector2i value = get_edited_property_value();
	min_range->set_value(value.x);
	max_range->set_value(value.y);
	_update_slider_values();
	range_edit_widget->queue_redraw();
}

ParticleProcessMaterialMinMaxPropertyEditor::ParticleProcessMaterialMinMaxPropertyEditor() {
	VBoxContainer *content_vb = memnew(VBoxContainer);
	content_vb->add_theme_constant_override(SNAME("separation"), 0);
	add_child(content_vb);

	// Helper Range objects to keep absolute min and max values.
	min_range = memnew(Range);
	min_range->hide();
	add_child(min_range);

	max_range = memnew(Range);
	max_range->hide();
	add_child(max_range);

	// Range edit widget.
	HBoxContainer *hb = memnew(HBoxContainer);
	content_vb->add_child(hb);

	range_edit_widget = memnew(Control);
	range_edit_widget->set_h_size_flags(SIZE_EXPAND_FILL);
	range_edit_widget->set_tooltip_text(TTR("Hold Shift to scale around midpoint instead of moving."));
	hb->add_child(range_edit_widget);
	range_edit_widget->connect(SNAME("draw"), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_range_edit_draw));
	range_edit_widget->connect(SNAME("gui_input"), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_range_edit_gui_input));
	range_edit_widget->connect(SNAME("mouse_entered"), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_set_mouse_inside).bind(true));
	range_edit_widget->connect(SNAME("mouse_exited"), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_set_mouse_inside).bind(false));

	// Range controls for actual editing. Their min/max may depend on editing mode.
	hb = memnew(HBoxContainer);
	content_vb->add_child(hb);

	min_edit = memnew(EditorSpinSlider);
	min_edit->set_h_size_flags(SIZE_EXPAND_FILL);
	hb->add_child(min_edit);
	min_edit->connect(SNAME("value_changed"), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_sync_sliders).bind(min_edit));

	max_edit = memnew(EditorSpinSlider);
	max_edit->set_h_size_flags(SIZE_EXPAND_FILL);
	hb->add_child(max_edit);
	max_edit->connect(SNAME("value_changed"), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_sync_sliders).bind(max_edit));

	toggle_mode_button = memnew(Button);
	toggle_mode_button->set_toggle_mode(true);
	toggle_mode_button->set_tooltip_text(TTR("Toggle between minimum/maximum and base value/spread modes."));
	hb->add_child(toggle_mode_button);
	toggle_mode_button->connect(SNAME("toggled"), callable_mp(this, &ParticleProcessMaterialMinMaxPropertyEditor::_toggle_mode));

	set_bottom_editor(content_vb);
}

bool EditorInspectorParticleProcessMaterialPlugin::can_handle(Object *p_object) {
	return Object::cast_to<ParticleProcessMaterial>(p_object);
}

bool EditorInspectorParticleProcessMaterialPlugin::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField<PropertyUsageFlags> p_usage, const bool p_wide) {
	if (!ParticleProcessMaterial::has_min_max_property(p_path)) {
		return false;
	}
	ERR_FAIL_COND_V(p_hint != PROPERTY_HINT_RANGE, false);

	Ref<ParticleProcessMaterial> mat = Ref<ParticleProcessMaterial>(p_object);
	ERR_FAIL_COND_V(mat.is_null(), false);

	PackedStringArray range_hint = p_hint_text.split(",");
	float min = range_hint[0].to_float();
	float max = range_hint[1].to_float();
	float step = range_hint[2].to_float();
	bool allow_less = range_hint.find("or_less", 3) > -1;
	bool allow_greater = range_hint.find("or_greater", 3) > -1;
	bool degrees = range_hint.find("degrees", 3) > -1;

	ParticleProcessMaterialMinMaxPropertyEditor *ed = memnew(ParticleProcessMaterialMinMaxPropertyEditor);
	ed->setup(min, max, step, allow_less, allow_greater, degrees);
	add_property_editor(p_path, ed);

	return true;
}