diff --git a/doc/classes/ParticleProcessMaterial.xml b/doc/classes/ParticleProcessMaterial.xml index aa2026084966..3e2d939e108d 100644 --- a/doc/classes/ParticleProcessMaterial.xml +++ b/doc/classes/ParticleProcessMaterial.xml @@ -9,6 +9,14 @@ + + + + + Returns the minimum and maximum values of the given [param param] as a vector. + The [code]x[/code] component of the returned vector corresponds to minimum and the [code]y[/code] component corresponds to maximum. + + @@ -37,6 +45,15 @@ Returns [code]true[/code] if the specified particle flag is enabled. See [enum ParticleFlags] for options. + + + + + + Sets the minimum and maximum values of the given [param param]. + The [code]x[/code] component of the argument vector corresponds to minimum and the [code]y[/code] component corresponds to maximum. + + diff --git a/editor/editor_inspector.cpp b/editor/editor_inspector.cpp index 3fa90b3d8191..59816a0eca9c 100644 --- a/editor/editor_inspector.cpp +++ b/editor/editor_inspector.cpp @@ -149,6 +149,9 @@ void EditorProperty::_notification(int p_what) { if (c->is_set_as_top_level()) { continue; } + if (!c->is_visible()) { + continue; + } if (c == bottom_editor) { continue; } diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp index cdaa0c036da3..a5a5c9742694 100644 --- a/editor/editor_node.cpp +++ b/editor/editor_node.cpp @@ -146,6 +146,7 @@ #include "editor/plugins/mesh_library_editor_plugin.h" #include "editor/plugins/node_3d_editor_plugin.h" #include "editor/plugins/packed_scene_translation_parser_plugin.h" +#include "editor/plugins/particle_process_material_editor_plugin.h" #include "editor/plugins/root_motion_editor_plugin.h" #include "editor/plugins/script_text_editor.h" #include "editor/plugins/text_editor.h" @@ -6974,6 +6975,10 @@ EditorNode::EditorNode() { Ref smp; smp.instantiate(); EditorInspector::add_inspector_plugin(smp); + + Ref ppm; + ppm.instantiate(); + EditorInspector::add_inspector_plugin(ppm); } editor_selection = memnew(EditorSelection); diff --git a/editor/icons/RangeSliderLeft.svg b/editor/icons/RangeSliderLeft.svg new file mode 100644 index 000000000000..7647db64ffcb --- /dev/null +++ b/editor/icons/RangeSliderLeft.svg @@ -0,0 +1 @@ + diff --git a/editor/icons/RangeSliderRight.svg b/editor/icons/RangeSliderRight.svg new file mode 100644 index 000000000000..3b46592c14fe --- /dev/null +++ b/editor/icons/RangeSliderRight.svg @@ -0,0 +1 @@ + diff --git a/editor/plugins/particle_process_material_editor_plugin.cpp b/editor/plugins/particle_process_material_editor_plugin.cpp new file mode 100644 index 000000000000..e696da3f5ead --- /dev/null +++ b/editor/plugins/particle_process_material_editor_plugin.cpp @@ -0,0 +1,471 @@ +/**************************************************************************/ +/* 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 "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 &p_event) { + Ref mb = p_event; + Ref 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 = EditorSettings::get_singleton()->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{ 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(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 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 mat = Ref(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; +} diff --git a/editor/plugins/particle_process_material_editor_plugin.h b/editor/plugins/particle_process_material_editor_plugin.h new file mode 100644 index 000000000000..0d9725397e29 --- /dev/null +++ b/editor/plugins/particle_process_material_editor_plugin.h @@ -0,0 +1,138 @@ +/**************************************************************************/ +/* particle_process_material_editor_plugin.h */ +/**************************************************************************/ +/* 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. */ +/**************************************************************************/ + +#ifndef PARTICLE_PROCESS_MATERIAL_EDITOR_PLUGIN_H +#define PARTICLE_PROCESS_MATERIAL_EDITOR_PLUGIN_H + +#include "editor/editor_plugin.h" +#include "editor/editor_properties.h" + +class Button; +class EditorSpinSlider; +class Label; +class ParticleProcessMaterial; +class Range; +class VBoxContainer; + +class ParticleProcessMaterialMinMaxPropertyEditor : public EditorProperty { + GDCLASS(ParticleProcessMaterialMinMaxPropertyEditor, EditorProperty); + + enum class Hover { + NONE, + LEFT, + RIGHT, + MIDDLE, + }; + + enum class Drag { + NONE, + LEFT, + RIGHT, + MIDDLE, + SCALE, + }; + + enum class Mode { + RANGE, + MIDPOINT, + }; + + Ref range_slider_left_icon; + Ref range_slider_right_icon; + + Color background_color; + Color normal_color; + Color hovered_color; + Color drag_color; + Color midpoint_color; + + Control *range_edit_widget = nullptr; + Button *toggle_mode_button = nullptr; + Range *min_range = nullptr; + Range *max_range = nullptr; + + EditorSpinSlider *min_edit = nullptr; + EditorSpinSlider *max_edit = nullptr; + + Vector2 edit_size; + Vector2 margin; + Vector2 usable_area; + + Vector2 property_range; + + bool mouse_inside = false; + Hover hover = Hover::NONE; + + Drag drag = Drag::NONE; + float drag_from_value = 0.0; + float drag_midpoint = 0.0; + float drag_origin = 0.0; + + Mode slider_mode = Mode::RANGE; + + void _update_sizing(); + void _range_edit_draw(); + void _range_edit_gui_input(const Ref &p_event); + void _set_mouse_inside(bool p_inside); + + float _get_min_ratio() const; + float _get_max_ratio() const; + float _get_left_offset() const; + float _get_right_offset() const; + Rect2 _get_middle_rect() const; + + void _set_clamped_values(float p_min, float p_max); + void _sync_property(); + + void _update_mode(); + void _toggle_mode(bool p_edit_mode); + void _update_slider_values(); + void _sync_sliders(float, const EditorSpinSlider *p_changed_slider); + float _get_max_spread() const; + +protected: + void _notification(int p_what); + +public: + void setup(float p_min, float p_max, float p_step, bool p_allow_less, bool p_allow_greater, bool p_degrees); + virtual void update_property() override; + + ParticleProcessMaterialMinMaxPropertyEditor(); +}; + +class EditorInspectorParticleProcessMaterialPlugin : public EditorInspectorPlugin { + GDCLASS(EditorInspectorParticleProcessMaterialPlugin, EditorInspectorPlugin); + +public: + virtual bool can_handle(Object *p_object) override; + virtual bool 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 p_usage, const bool p_wide = false) override; +}; + +#endif // PARTICLE_PROCESS_MATERIAL_EDITOR_PLUGIN_H diff --git a/scene/resources/particle_process_material.cpp b/scene/resources/particle_process_material.cpp index 4ed1980826b0..5acb08de14d1 100644 --- a/scene/resources/particle_process_material.cpp +++ b/scene/resources/particle_process_material.cpp @@ -35,6 +35,7 @@ Mutex ParticleProcessMaterial::material_mutex; SelfList::List *ParticleProcessMaterial::dirty_materials = nullptr; HashMap ParticleProcessMaterial::shader_map; +RBSet ParticleProcessMaterial::min_max_properties; ParticleProcessMaterial::ShaderNames *ParticleProcessMaterial::shader_names = nullptr; void ParticleProcessMaterial::init_shaders() { @@ -1181,6 +1182,10 @@ bool ParticleProcessMaterial::_is_shader_dirty() const { return element.in_list(); } +bool ParticleProcessMaterial::has_min_max_property(const String &p_name) { + return min_max_properties.has(p_name); +} + void ParticleProcessMaterial::set_direction(Vector3 p_direction) { direction = p_direction; RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->direction, direction); @@ -1217,6 +1222,15 @@ Vector3 ParticleProcessMaterial::get_velocity_pivot() { return velocity_pivot; } +void ParticleProcessMaterial::set_param(Parameter p_param, const Vector2 &p_value) { + set_param_min(p_param, p_value.x); + set_param_max(p_param, p_value.y); +} + +Vector2 ParticleProcessMaterial::get_param(Parameter p_param) const { + return Vector2(get_param_min(p_param), get_param_max(p_param)); +} + void ParticleProcessMaterial::set_param_min(Parameter p_param, float p_value) { ERR_FAIL_INDEX(p_param, PARAM_MAX); @@ -1805,11 +1819,9 @@ void ParticleProcessMaterial::_validate_property(PropertyInfo &p_property) const p_property.name == "turbulence_noise_speed" || p_property.name == "turbulence_noise_speed_random" || p_property.name == "turbulence_influence_over_life" || - p_property.name == "turbulence_influence_min" || - p_property.name == "turbulence_influence_max" || - p_property.name == "turbulence_initial_displacement_min" || - p_property.name == "turbulence_initial_displacement_max") { - p_property.usage = PROPERTY_USAGE_NO_EDITOR; + p_property.name == "turbulence_influence" || + p_property.name == "turbulence_initial_displacement") { + p_property.usage &= ~PROPERTY_USAGE_EDITOR; } } @@ -1829,6 +1841,10 @@ void ParticleProcessMaterial::_validate_property(PropertyInfo &p_property) const if ((p_property.name == "orbit_velocity_min" || p_property.name == "orbit_velocity_max") && (!tex_parameters[PARAM_ORBIT_VELOCITY].is_valid() && !particle_flags[PARTICLE_FLAG_DISABLE_Z])) { p_property.usage = PROPERTY_USAGE_NO_EDITOR; } + + if (p_property.usage & PROPERTY_USAGE_EDITOR && (p_property.name.ends_with("_min") || p_property.name.ends_with("_max"))) { + p_property.usage &= ~PROPERTY_USAGE_EDITOR; + } } void ParticleProcessMaterial::set_sub_emitter_mode(SubEmitterMode p_sub_emitter_mode) { @@ -1942,6 +1958,9 @@ void ParticleProcessMaterial::_bind_methods() { ClassDB::bind_method(D_METHOD("set_flatness", "amount"), &ParticleProcessMaterial::set_flatness); ClassDB::bind_method(D_METHOD("get_flatness"), &ParticleProcessMaterial::get_flatness); + ClassDB::bind_method(D_METHOD("set_param", "param", "value"), &ParticleProcessMaterial::set_param); + ClassDB::bind_method(D_METHOD("get_param", "param"), &ParticleProcessMaterial::get_param); + ClassDB::bind_method(D_METHOD("set_param_min", "param", "value"), &ParticleProcessMaterial::set_param_min); ClassDB::bind_method(D_METHOD("get_param_min", "param"), &ParticleProcessMaterial::get_param_min); @@ -2064,6 +2083,12 @@ void ParticleProcessMaterial::_bind_methods() { ClassDB::bind_method(D_METHOD("set_collision_bounce", "bounce"), &ParticleProcessMaterial::set_collision_bounce); ClassDB::bind_method(D_METHOD("get_collision_bounce"), &ParticleProcessMaterial::get_collision_bounce); +#define ADD_MIN_MAX_PROPERTY(m_property, m_range, m_parameter_name) \ + ADD_PROPERTYI(PropertyInfo(Variant::VECTOR2, m_property, PROPERTY_HINT_RANGE, m_range, PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_INTERNAL), "set_param", "get_param", m_parameter_name); \ + ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, m_property "_min", PROPERTY_HINT_RANGE, m_range), "set_param_min", "get_param_min", m_parameter_name); \ + ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, m_property "_max", PROPERTY_HINT_RANGE, m_range), "set_param_max", "get_param_max", m_parameter_name); \ + min_max_properties.insert(m_property); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "lifetime_randomness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_lifetime_randomness", "get_lifetime_randomness"); ADD_GROUP("Particle Flags", "particle_flag_"); ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "particle_flag_align_y"), "set_particle_flag", "get_particle_flag", PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY); @@ -2086,8 +2111,7 @@ void ParticleProcessMaterial::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "emission_ring_radius"), "set_emission_ring_radius", "get_emission_ring_radius"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "emission_ring_inner_radius"), "set_emission_ring_inner_radius", "get_emission_ring_inner_radius"); ADD_SUBGROUP("Angle", ""); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angle_min", PROPERTY_HINT_RANGE, "-720,720,0.1,or_less,or_greater,degrees"), "set_param_min", "get_param_min", PARAM_ANGLE); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angle_max", PROPERTY_HINT_RANGE, "-720,720,0.1,or_less,or_greater,degrees"), "set_param_max", "get_param_max", PARAM_ANGLE); + ADD_MIN_MAX_PROPERTY("angle", "-720,720,0.1,or_less,or_greater,degrees", PARAM_ANGLE); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "angle_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ANGLE); ADD_SUBGROUP("Velocity", ""); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "inherit_velocity_ratio", PROPERTY_HINT_RANGE, "0.0,1.0,0.001,or_less,or_greater"), "set_inherit_velocity_ratio", "get_inherit_velocity_ratio"); @@ -2095,25 +2119,20 @@ void ParticleProcessMaterial::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "direction"), "set_direction", "get_direction"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "spread", PROPERTY_HINT_RANGE, "0,180,0.001"), "set_spread", "get_spread"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "flatness", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_flatness", "get_flatness"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "initial_velocity_min", PROPERTY_HINT_RANGE, "0,1000,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_INITIAL_LINEAR_VELOCITY); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "initial_velocity_max", PROPERTY_HINT_RANGE, "0,1000,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_INITIAL_LINEAR_VELOCITY); + ADD_MIN_MAX_PROPERTY("initial_velocity", "0,1000,0.01,or_less,or_greater", PARAM_INITIAL_LINEAR_VELOCITY); ADD_GROUP("Animated Velocity", ""); ADD_SUBGROUP("Velocity Limit", ""); ADD_SUBGROUP("Angular Velocity", "angular_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_velocity_min", PROPERTY_HINT_RANGE, "-720,720,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_ANGULAR_VELOCITY); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "angular_velocity_max", PROPERTY_HINT_RANGE, "-720,720,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_ANGULAR_VELOCITY); + ADD_MIN_MAX_PROPERTY("angular_velocity", "-720,720,0.01,or_less,or_greater", PARAM_ANGULAR_VELOCITY); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "angular_velocity_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ANGULAR_VELOCITY); ADD_SUBGROUP("Directional Velocity", "directional_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "directional_velocity_min", PROPERTY_HINT_RANGE, "-720,720,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_DIRECTIONAL_VELOCITY); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "directional_velocity_max", PROPERTY_HINT_RANGE, "-720,720,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_DIRECTIONAL_VELOCITY); + ADD_MIN_MAX_PROPERTY("directional_velocity", "-720,720,0.01,or_less,or_greater", PARAM_DIRECTIONAL_VELOCITY); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "directional_velocity_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveXYZTexture"), "set_param_texture", "get_param_texture", PARAM_DIRECTIONAL_VELOCITY); ADD_SUBGROUP("Orbit Velocity", "orbit_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "orbit_velocity_min", PROPERTY_HINT_RANGE, "-2,2,0.001,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_ORBIT_VELOCITY); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "orbit_velocity_max", PROPERTY_HINT_RANGE, "-2,2,0.001,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_ORBIT_VELOCITY); + ADD_MIN_MAX_PROPERTY("orbit_velocity", "-2,2,0.001,or_less,or_greater", PARAM_ORBIT_VELOCITY); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "orbit_velocity_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture,CurveXYZTexture"), "set_param_texture", "get_param_texture", PARAM_ORBIT_VELOCITY); ADD_SUBGROUP("Radial Velocity", "radial_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "radial_velocity_min", PROPERTY_HINT_RANGE, "-1000,1000,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_RADIAL_VELOCITY); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "radial_velocity_max", PROPERTY_HINT_RANGE, "-1000,1000,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_RADIAL_VELOCITY); + ADD_MIN_MAX_PROPERTY("radial_velocity", "-1000,1000,0.01,or_less,or_greater", PARAM_RADIAL_VELOCITY); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "radial_velocity_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_RADIAL_VELOCITY); ADD_SUBGROUP("Velocity Limit", ""); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "velocity_limit_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_velocity_limit_curve", "get_velocity_limit_curve"); @@ -2121,32 +2140,26 @@ void ParticleProcessMaterial::_bind_methods() { ADD_SUBGROUP("Gravity", ""); ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "gravity"), "set_gravity", "get_gravity"); ADD_SUBGROUP("Linear Accel", "linear_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_accel_min", PROPERTY_HINT_RANGE, "-100,100,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_LINEAR_ACCEL); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "linear_accel_max", PROPERTY_HINT_RANGE, "-100,100,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_LINEAR_ACCEL); + ADD_MIN_MAX_PROPERTY("linear_accel", "-100,100,0.01,or_less,or_greater", PARAM_LINEAR_ACCEL); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "linear_accel_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_LINEAR_ACCEL); ADD_SUBGROUP("Radial Accel", "radial_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "radial_accel_min", PROPERTY_HINT_RANGE, "-100,100,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_RADIAL_ACCEL); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "radial_accel_max", PROPERTY_HINT_RANGE, "-100,100,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_RADIAL_ACCEL); + ADD_MIN_MAX_PROPERTY("radial_accel", "-100,100,0.01,or_less,or_greater", PARAM_RADIAL_ACCEL); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "radial_accel_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_RADIAL_ACCEL); ADD_SUBGROUP("Tangential Accel", "tangential_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "tangential_accel_min", PROPERTY_HINT_RANGE, "-100,100,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_TANGENTIAL_ACCEL); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "tangential_accel_max", PROPERTY_HINT_RANGE, "-100,100,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_TANGENTIAL_ACCEL); + ADD_MIN_MAX_PROPERTY("tangential_accel", "-100,100,0.01,or_less,or_greater", PARAM_TANGENTIAL_ACCEL); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "tangential_accel_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_TANGENTIAL_ACCEL); ADD_SUBGROUP("Damping", ""); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "damping_min", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_param_min", "get_param_min", PARAM_DAMPING); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "damping_max", PROPERTY_HINT_RANGE, "0,100,0.001,or_greater"), "set_param_max", "get_param_max", PARAM_DAMPING); + ADD_MIN_MAX_PROPERTY("damping", "0,100,0.001,or_greater", PARAM_DAMPING); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "damping_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_DAMPING); ADD_SUBGROUP("Attractor Interaction", "attractor_interaction_"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "attractor_interaction_enabled"), "set_attractor_interaction_enabled", "is_attractor_interaction_enabled"); ADD_GROUP("Display", ""); ADD_SUBGROUP("Scale", ""); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "scale_min", PROPERTY_HINT_RANGE, "0,1000,0.01,or_greater"), "set_param_min", "get_param_min", PARAM_SCALE); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "scale_max", PROPERTY_HINT_RANGE, "0,1000,0.01,or_greater"), "set_param_max", "get_param_max", PARAM_SCALE); + ADD_MIN_MAX_PROPERTY("scale", "0,1000,0.01,or_greater", PARAM_SCALE); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "scale_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture,CurveXYZTexture"), "set_param_texture", "get_param_texture", PARAM_SCALE); ADD_SUBGROUP("Scale Over Velocity", ""); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "scale_over_velocity_min", PROPERTY_HINT_RANGE, "0,1000,0.01,or_greater"), "set_param_min", "get_param_min", PARAM_SCALE_OVER_VELOCITY); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "scale_over_velocity_max", PROPERTY_HINT_RANGE, "0,1000,0.01,or_greater"), "set_param_max", "get_param_max", PARAM_SCALE_OVER_VELOCITY); + ADD_MIN_MAX_PROPERTY("scale_over_velocity", "0,1000,0.01,or_greater", PARAM_SCALE_OVER_VELOCITY); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "scale_over_velocity_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture,CurveXYZTexture"), "set_param_texture", "get_param_texture", PARAM_SCALE_OVER_VELOCITY); ADD_SUBGROUP("Color Curves", ""); @@ -2156,15 +2169,12 @@ void ParticleProcessMaterial::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "alpha_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_alpha_curve", "get_alpha_curve"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "emission_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_emission_curve", "get_emission_curve"); ADD_SUBGROUP("Hue Variation", "hue_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "hue_variation_min", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_param_min", "get_param_min", PARAM_HUE_VARIATION); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "hue_variation_max", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_param_max", "get_param_max", PARAM_HUE_VARIATION); + ADD_MIN_MAX_PROPERTY("hue_variation", "-1,1,0.01", PARAM_HUE_VARIATION); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "hue_variation_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_HUE_VARIATION); ADD_SUBGROUP("Animation", "anim_"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anim_speed_min", PROPERTY_HINT_RANGE, "0,16,0.01,or_less,or_greater"), "set_param_min", "get_param_min", PARAM_ANIM_SPEED); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anim_speed_max", PROPERTY_HINT_RANGE, "0,16,0.01,or_less,or_greater"), "set_param_max", "get_param_max", PARAM_ANIM_SPEED); + ADD_MIN_MAX_PROPERTY("anim_speed", "0,16,0.01,or_less,or_greater", PARAM_ANIM_SPEED); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "anim_speed_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ANIM_SPEED); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anim_offset_min", PROPERTY_HINT_RANGE, "0,1,0.0001"), "set_param_min", "get_param_min", PARAM_ANIM_OFFSET); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anim_offset_max", PROPERTY_HINT_RANGE, "0,1,0.0001"), "set_param_max", "get_param_max", PARAM_ANIM_OFFSET); + ADD_MIN_MAX_PROPERTY("anim_offset", "0,1,0.0001", PARAM_ANIM_OFFSET); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "anim_offset_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_ANIM_OFFSET); ADD_GROUP("Turbulence", "turbulence_"); @@ -2173,10 +2183,8 @@ void ParticleProcessMaterial::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "turbulence_noise_scale", PROPERTY_HINT_RANGE, "0,10,0.001,or_greater"), "set_turbulence_noise_scale", "get_turbulence_noise_scale"); ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "turbulence_noise_speed"), "set_turbulence_noise_speed", "get_turbulence_noise_speed"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "turbulence_noise_speed_random", PROPERTY_HINT_RANGE, "0,4,0.01"), "set_turbulence_noise_speed_random", "get_turbulence_noise_speed_random"); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "turbulence_influence_min", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_param_min", "get_param_min", PARAM_TURB_VEL_INFLUENCE); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "turbulence_influence_max", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_param_max", "get_param_max", PARAM_TURB_VEL_INFLUENCE); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "turbulence_initial_displacement_min", PROPERTY_HINT_RANGE, "-100,100,0.1"), "set_param_min", "get_param_min", PARAM_TURB_INIT_DISPLACEMENT); - ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "turbulence_initial_displacement_max", PROPERTY_HINT_RANGE, "-100,100,0.1"), "set_param_max", "get_param_max", PARAM_TURB_INIT_DISPLACEMENT); + ADD_MIN_MAX_PROPERTY("turbulence_influence", "0,1,0.001", PARAM_TURB_VEL_INFLUENCE); + ADD_MIN_MAX_PROPERTY("turbulence_initial_displacement", "-100,100,0.1", PARAM_TURB_INIT_DISPLACEMENT); ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "turbulence_influence_over_life", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_TURB_INFLUENCE_OVER_LIFE); ADD_GROUP("Collision", "collision_"); @@ -2237,6 +2245,8 @@ void ParticleProcessMaterial::_bind_methods() { BIND_ENUM_CONSTANT(COLLISION_RIGID); BIND_ENUM_CONSTANT(COLLISION_HIDE_ON_CONTACT); BIND_ENUM_CONSTANT(COLLISION_MAX); + +#undef ADD_MIN_MAX_PROPERTY } ParticleProcessMaterial::ParticleProcessMaterial() : diff --git a/scene/resources/particle_process_material.h b/scene/resources/particle_process_material.h index 5ed8b61c77bd..94b2009654b5 100644 --- a/scene/resources/particle_process_material.h +++ b/scene/resources/particle_process_material.h @@ -149,6 +149,7 @@ class ParticleProcessMaterial : public Material { }; static HashMap shader_map; + static RBSet min_max_properties; MaterialKey current_key; @@ -361,6 +362,8 @@ class ParticleProcessMaterial : public Material { void _validate_property(PropertyInfo &p_property) const; public: + static bool has_min_max_property(const String &p_name); + void set_direction(Vector3 p_direction); Vector3 get_direction() const; @@ -373,6 +376,9 @@ class ParticleProcessMaterial : public Material { void set_velocity_pivot(const Vector3 &p_pivot); Vector3 get_velocity_pivot(); + void set_param(Parameter p_param, const Vector2 &p_value); + Vector2 get_param(Parameter p_param) const; + void set_param_min(Parameter p_param, float p_value); float get_param_min(Parameter p_param) const;