Relintai/tile_map_backport
1
0
Fork 0
mirror of https://github.com/Relintai/tile_map_backport.git synced 2024-11-05 10:11:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

Prefix every editor plugin class With R, and add them to the build.

Browse Source
This commit is contained in:
Relintai 2021-12-11 19:54:47 +01:00
parent 96f4de946d
commit 8ab8064f1b
19 changed files with 579 additions and 582 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
SCsub
View File

@ -8,9 +8,6 @@ env.add_source_files(env.modules_sources,"array_lt_op.cpp")
env.add_source_files(env.modules_sources,"rtile_set.cpp") env.add_source_files(env.modules_sources,"rtile_set.cpp")
env.add_source_files(env.modules_sources,"rtile_map.cpp") env.add_source_files(env.modules_sources,"rtile_map.cpp")
#if env["tools"]: if env["tools"]:
# env.add_source_files(env.modules_sources, "skeleton_editor_plugin_remover.cpp") env.add_source_files(env.modules_sources, "tile_editor/*.cpp")
# env.add_source_files(env.modules_sources, "skeleton_editor_plugin.cpp")
# env.add_source_files(env.modules_sources, "spatial_editor_gizmos.cpp")
# env.add_source_files(env.modules_sources, "skeleton_editor_module_plugin.cpp")

28
tile_editor/atlas_merging_dialog.cpp
View File

@ -35,11 +35,11 @@
#include "scene/gui/control.h" #include "scene/gui/control.h"
#include "scene/gui/split_container.h" #include "scene/gui/split_container.h"
void AtlasMergingDialog::_property_changed(const StringName &p_property, const Variant &p_value, const String &p_field, bool p_changing) { void RAtlasMergingDialog::_property_changed(const StringName &p_property, const Variant &p_value, const String &p_field, bool p_changing) {
_set(p_property, p_value); _set(p_property, p_value);
} }
void AtlasMergingDialog::_generate_merged(Vector<Ref<TileSetAtlasSource>> p_atlas_sources, int p_max_columns) { void RAtlasMergingDialog::_generate_merged(Vector<Ref<TileSetAtlasSource>> p_atlas_sources, int p_max_columns) {
merged.instantiate(); merged.instantiate();
merged_mapping.clear(); merged_mapping.clear();
@ -124,7 +124,7 @@ void AtlasMergingDialog::_generate_merged(Vector<Ref<TileSetAtlasSource>> p_atla
} }
} }
void AtlasMergingDialog::_update_texture() { void RAtlasMergingDialog::_update_texture() {
Vector<int> selected = atlas_merging_atlases_list->get_selected_items(); Vector<int> selected = atlas_merging_atlases_list->get_selected_items();
if (selected.size() >= 2) { if (selected.size() >= 2) {
Vector<Ref<TileSetAtlasSource>> to_merge; Vector<Ref<TileSetAtlasSource>> to_merge;
@ -148,7 +148,7 @@ void AtlasMergingDialog::_update_texture() {
} }
} }
void AtlasMergingDialog::_merge_confirmed(String p_path) { void RAtlasMergingDialog::_merge_confirmed(String p_path) {
ERR_FAIL_COND(!merged.is_valid()); ERR_FAIL_COND(!merged.is_valid());
Ref<ImageTexture> output_image_texture = merged->get_texture(); Ref<ImageTexture> output_image_texture = merged->get_texture();
@ -190,26 +190,26 @@ void AtlasMergingDialog::_merge_confirmed(String p_path) {
hide(); hide();
} }
void AtlasMergingDialog::ok_pressed() { void RAtlasMergingDialog::ok_pressed() {
delete_original_atlases = false; delete_original_atlases = false;
editor_file_dialog->popup_file_dialog(); editor_file_dialog->popup_file_dialog();
} }
void AtlasMergingDialog::cancel_pressed() { void RAtlasMergingDialog::cancel_pressed() {
for (int i = 0; i < commited_actions_count; i++) { for (int i = 0; i < commited_actions_count; i++) {
undo_redo->undo(); undo_redo->undo();
} }
commited_actions_count = 0; commited_actions_count = 0;
} }
void AtlasMergingDialog::custom_action(const String &p_action) { void RAtlasMergingDialog::custom_action(const String &p_action) {
if (p_action == "merge") { if (p_action == "merge") {
delete_original_atlases = true; delete_original_atlases = true;
editor_file_dialog->popup_file_dialog(); editor_file_dialog->popup_file_dialog();
} }
} }
bool AtlasMergingDialog::_set(const StringName &p_name, const Variant &p_value) { bool RAtlasMergingDialog::_set(const StringName &p_name, const Variant &p_value) {
if (p_name == "next_line_after_column" && p_value.get_type() == Variant::INT) { if (p_name == "next_line_after_column" && p_value.get_type() == Variant::INT) {
next_line_after_column = p_value; next_line_after_column = p_value;
_update_texture(); _update_texture();
@ -218,7 +218,7 @@ bool AtlasMergingDialog::_set(const StringName &p_name, const Variant &p_value)
return false; return false;
} }
bool AtlasMergingDialog::_get(const StringName &p_name, Variant &r_ret) const { bool RAtlasMergingDialog::_get(const StringName &p_name, Variant &r_ret) const {
if (p_name == "next_line_after_column") { if (p_name == "next_line_after_column") {
r_ret = next_line_after_column; r_ret = next_line_after_column;
return true; return true;
@ -226,7 +226,7 @@ bool AtlasMergingDialog::_get(const StringName &p_name, Variant &r_ret) const {
return false; return false;
} }
void AtlasMergingDialog::update_tile_set(Ref<TileSet> p_tile_set) { void RAtlasMergingDialog::update_tile_set(Ref<TileSet> p_tile_set) {
ERR_FAIL_COND(!p_tile_set.is_valid()); ERR_FAIL_COND(!p_tile_set.is_valid());
tile_set = p_tile_set; tile_set = p_tile_set;
@ -250,7 +250,7 @@ void AtlasMergingDialog::update_tile_set(Ref<TileSet> p_tile_set) {
commited_actions_count = 0; commited_actions_count = 0;
} }
AtlasMergingDialog::AtlasMergingDialog() { RAtlasMergingDialog::RAtlasMergingDialog() {
// Atlas merging window. // Atlas merging window.
set_title(TTR("Atlas Merging")); set_title(TTR("Atlas Merging"));
set_hide_on_ok(false); set_hide_on_ok(false);
@ -274,7 +274,7 @@ AtlasMergingDialog::AtlasMergingDialog() {
atlas_merging_atlases_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST); atlas_merging_atlases_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
atlas_merging_atlases_list->set_custom_minimum_size(Size2(100, 200)); atlas_merging_atlases_list->set_custom_minimum_size(Size2(100, 200));
atlas_merging_atlases_list->set_select_mode(ItemList::SELECT_MULTI); atlas_merging_atlases_list->set_select_mode(ItemList::SELECT_MULTI);
atlas_merging_atlases_list->connect("multi_selected", callable_mp(this, &AtlasMergingDialog::_update_texture).unbind(2)); atlas_merging_atlases_list->connect("multi_selected", callable_mp(this, &RAtlasMergingDialog::_update_texture).unbind(2));
atlas_merging_h_split_container->add_child(atlas_merging_atlases_list); atlas_merging_h_split_container->add_child(atlas_merging_atlases_list);
VBoxContainer *atlas_merging_right_panel = memnew(VBoxContainer); VBoxContainer *atlas_merging_right_panel = memnew(VBoxContainer);
@ -290,7 +290,7 @@ AtlasMergingDialog::AtlasMergingDialog() {
columns_editor_property->set_label(TTR("Next Line After Column")); columns_editor_property->set_label(TTR("Next Line After Column"));
columns_editor_property->set_object_and_property(this, "next_line_after_column"); columns_editor_property->set_object_and_property(this, "next_line_after_column");
columns_editor_property->update_property(); columns_editor_property->update_property();
columns_editor_property->connect("property_changed", callable_mp(this, &AtlasMergingDialog::_property_changed)); columns_editor_property->connect("property_changed", callable_mp(this, &RAtlasMergingDialog::_property_changed));
atlas_merging_right_panel->add_child(columns_editor_property); atlas_merging_right_panel->add_child(columns_editor_property);
// Preview. // Preview.
@ -318,6 +318,6 @@ AtlasMergingDialog::AtlasMergingDialog() {
editor_file_dialog = memnew(EditorFileDialog); editor_file_dialog = memnew(EditorFileDialog);
editor_file_dialog->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE); editor_file_dialog->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE);
editor_file_dialog->add_filter("*.png"); editor_file_dialog->add_filter("*.png");
editor_file_dialog->connect("file_selected", callable_mp(this, &AtlasMergingDialog::_merge_confirmed)); editor_file_dialog->connect("file_selected", callable_mp(this, &RAtlasMergingDialog::_merge_confirmed));
add_child(editor_file_dialog); add_child(editor_file_dialog);
} }

10
tile_editor/atlas_merging_dialog.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef ATLAS_MERGING_DIALOG_H #ifndef RATLAS_MERGING_DIALOG_H
#define ATLAS_MERGING_DIALOG_H #define RATLAS_MERGING_DIALOG_H
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_properties.h" #include "editor/editor_properties.h"
@ -39,8 +39,8 @@
#include "scene/gui/texture_rect.h" #include "scene/gui/texture_rect.h"
#include "scene/resources/tile_set.h" #include "scene/resources/tile_set.h"
class AtlasMergingDialog : public ConfirmationDialog { class RAtlasMergingDialog : public ConfirmationDialog {
GDCLASS(AtlasMergingDialog, ConfirmationDialog); GDCLASS(RAtlasMergingDialog, ConfirmationDialog);
private: private:
int commited_actions_count = 0; int commited_actions_count = 0;
@ -80,7 +80,7 @@ protected:
public: public:
void update_tile_set(Ref<TileSet> p_tile_set); void update_tile_set(Ref<TileSet> p_tile_set);
AtlasMergingDialog(); RAtlasMergingDialog();
}; };
#endif // ATLAS_MERGING_DIALOG_H #endif // ATLAS_MERGING_DIALOG_H

74
tile_editor/tile_atlas_view.cpp
View File

@ -41,7 +41,7 @@
#include "editor/editor_scale.h" #include "editor/editor_scale.h"
#include "editor/editor_settings.h" #include "editor/editor_settings.h"
void TileAtlasView::gui_input(const Ref<InputEvent> &p_event) { void RTileAtlasView::gui_input(const Ref<InputEvent> &p_event) {
Ref<InputEventMouseButton> mb = p_event; Ref<InputEventMouseButton> mb = p_event;
if (mb.is_valid()) { if (mb.is_valid()) {
drag_type = DRAG_TYPE_NONE; drag_type = DRAG_TYPE_NONE;
@ -90,7 +90,7 @@ void TileAtlasView::gui_input(const Ref<InputEvent> &p_event) {
} }
} }
Size2i TileAtlasView::_compute_base_tiles_control_size() { Size2i RTileAtlasView::_compute_base_tiles_control_size() {
// Update the texture. // Update the texture.
Vector2i size; Vector2i size;
Ref<Texture2D> texture = tile_set_atlas_source->get_texture(); Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
@ -100,7 +100,7 @@ Size2i TileAtlasView::_compute_base_tiles_control_size() {
return size; return size;
} }
Size2i TileAtlasView::_compute_alternative_tiles_control_size() { Size2i RTileAtlasView::_compute_alternative_tiles_control_size() {
Vector2i size; Vector2i size;
for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) { for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) {
Vector2i tile_id = tile_set_atlas_source->get_tile_id(i); Vector2i tile_id = tile_set_atlas_source->get_tile_id(i);
@ -120,7 +120,7 @@ Size2i TileAtlasView::_compute_alternative_tiles_control_size() {
return size; return size;
} }
void TileAtlasView::_update_zoom_and_panning(bool p_zoom_on_mouse_pos) { void RTileAtlasView::_update_zoom_and_panning(bool p_zoom_on_mouse_pos) {
float zoom = zoom_widget->get_zoom(); float zoom = zoom_widget->get_zoom();
// Compute the minimum sizes. // Compute the minimum sizes.
@ -172,19 +172,19 @@ void TileAtlasView::_update_zoom_and_panning(bool p_zoom_on_mouse_pos) {
center_container->set_size(center_container->get_minimum_size()); center_container->set_size(center_container->get_minimum_size());
} }
void TileAtlasView::_zoom_widget_changed() { void RTileAtlasView::_zoom_widget_changed() {
_update_zoom_and_panning(); _update_zoom_and_panning();
emit_signal(SNAME("transform_changed"), zoom_widget->get_zoom(), panning); emit_signal(SNAME("transform_changed"), zoom_widget->get_zoom(), panning);
} }
void TileAtlasView::_center_view() { void RTileAtlasView::_center_view() {
panning = Vector2(); panning = Vector2();
button_center_view->set_disabled(true); button_center_view->set_disabled(true);
_update_zoom_and_panning(); _update_zoom_and_panning();
emit_signal(SNAME("transform_changed"), zoom_widget->get_zoom(), panning); emit_signal(SNAME("transform_changed"), zoom_widget->get_zoom(), panning);
} }
void TileAtlasView::_base_tiles_root_control_gui_input(const Ref<InputEvent> &p_event) { void RTileAtlasView::_base_tiles_root_control_gui_input(const Ref<InputEvent> &p_event) {
base_tiles_root_control->set_tooltip(""); base_tiles_root_control->set_tooltip("");
Ref<InputEventMouseMotion> mm = p_event; Ref<InputEventMouseMotion> mm = p_event;
@ -200,7 +200,7 @@ void TileAtlasView::_base_tiles_root_control_gui_input(const Ref<InputEvent> &p_
} }
} }
void TileAtlasView::_draw_base_tiles() { void RTileAtlasView::_draw_base_tiles() {
Ref<Texture2D> texture = tile_set_atlas_source->get_texture(); Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) { if (texture.is_valid()) {
Vector2i margins = tile_set_atlas_source->get_margins(); Vector2i margins = tile_set_atlas_source->get_margins();
@ -291,7 +291,7 @@ void TileAtlasView::_draw_base_tiles() {
} }
} }
void TileAtlasView::_draw_base_tiles_texture_grid() { void RTileAtlasView::_draw_base_tiles_texture_grid() {
Ref<Texture2D> texture = tile_set_atlas_source->get_texture(); Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) { if (texture.is_valid()) {
Vector2i margins = tile_set_atlas_source->get_margins(); Vector2i margins = tile_set_atlas_source->get_margins();
@ -321,7 +321,7 @@ void TileAtlasView::_draw_base_tiles_texture_grid() {
} }
} }
void TileAtlasView::_draw_base_tiles_shape_grid() { void RTileAtlasView::_draw_base_tiles_shape_grid() {
// Draw the shapes. // Draw the shapes.
Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color"); Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color");
Vector2i tile_shape_size = tile_set->get_tile_size(); Vector2i tile_shape_size = tile_set->get_tile_size();
@ -343,7 +343,7 @@ void TileAtlasView::_draw_base_tiles_shape_grid() {
} }
} }
void TileAtlasView::_alternative_tiles_root_control_gui_input(const Ref<InputEvent> &p_event) { void RTileAtlasView::_alternative_tiles_root_control_gui_input(const Ref<InputEvent> &p_event) {
alternative_tiles_root_control->set_tooltip(""); alternative_tiles_root_control->set_tooltip("");
Ref<InputEventMouseMotion> mm = p_event; Ref<InputEventMouseMotion> mm = p_event;
@ -358,7 +358,7 @@ void TileAtlasView::_alternative_tiles_root_control_gui_input(const Ref<InputEve
} }
} }
void TileAtlasView::_draw_alternatives() { void RTileAtlasView::_draw_alternatives() {
// Draw the alternative tiles. // Draw the alternative tiles.
Ref<Texture2D> texture = tile_set_atlas_source->get_texture(); Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) { if (texture.is_valid()) {
@ -397,19 +397,19 @@ void TileAtlasView::_draw_alternatives() {
} }
} }
void TileAtlasView::_draw_background_left() { void RTileAtlasView::_draw_background_left() {
Ref<Texture2D> texture = get_theme_icon(SNAME("Checkerboard"), SNAME("EditorIcons")); Ref<Texture2D> texture = get_theme_icon(SNAME("Checkerboard"), SNAME("EditorIcons"));
background_left->set_size(base_tiles_root_control->get_custom_minimum_size()); background_left->set_size(base_tiles_root_control->get_custom_minimum_size());
background_left->draw_texture_rect(texture, Rect2(Vector2(), background_left->get_size()), true); background_left->draw_texture_rect(texture, Rect2(Vector2(), background_left->get_size()), true);
} }
void TileAtlasView::_draw_background_right() { void RTileAtlasView::_draw_background_right() {
Ref<Texture2D> texture = get_theme_icon(SNAME("Checkerboard"), SNAME("EditorIcons")); Ref<Texture2D> texture = get_theme_icon(SNAME("Checkerboard"), SNAME("EditorIcons"));
background_right->set_size(alternative_tiles_root_control->get_custom_minimum_size()); background_right->set_size(alternative_tiles_root_control->get_custom_minimum_size());
background_right->draw_texture_rect(texture, Rect2(Vector2(), background_right->get_size()), true); background_right->draw_texture_rect(texture, Rect2(Vector2(), background_right->get_size()), true);
} }
void TileAtlasView::set_atlas_source(TileSet *p_tile_set, TileSetAtlasSource *p_tile_set_atlas_source, int p_source_id) { void RTileAtlasView::set_atlas_source(TileSet *p_tile_set, TileSetAtlasSource *p_tile_set_atlas_source, int p_source_id) {
ERR_FAIL_COND(!p_tile_set); ERR_FAIL_COND(!p_tile_set);
ERR_FAIL_COND(!p_tile_set_atlas_source); ERR_FAIL_COND(!p_tile_set_atlas_source);
ERR_FAIL_COND(p_source_id < 0); ERR_FAIL_COND(p_source_id < 0);
@ -456,22 +456,22 @@ void TileAtlasView::set_atlas_source(TileSet *p_tile_set, TileSetAtlasSource *p_
background_right->update(); background_right->update();
} }
float TileAtlasView::get_zoom() const { float RTileAtlasView::get_zoom() const {
return zoom_widget->get_zoom(); return zoom_widget->get_zoom();
}; };
void TileAtlasView::set_transform(float p_zoom, Vector2i p_panning) { void RTileAtlasView::set_transform(float p_zoom, Vector2i p_panning) {
zoom_widget->set_zoom(p_zoom); zoom_widget->set_zoom(p_zoom);
panning = p_panning; panning = p_panning;
_update_zoom_and_panning(); _update_zoom_and_panning();
}; };
void TileAtlasView::set_padding(Side p_side, int p_padding) { void RTileAtlasView::set_padding(Side p_side, int p_padding) {
ERR_FAIL_COND(p_padding < 0); ERR_FAIL_COND(p_padding < 0);
margin_container_paddings[p_side] = p_padding; margin_container_paddings[p_side] = p_padding;
} }
Vector2i TileAtlasView::get_atlas_tile_coords_at_pos(const Vector2 p_pos) const { Vector2i RTileAtlasView::get_atlas_tile_coords_at_pos(const Vector2 p_pos) const {
Ref<Texture2D> texture = tile_set_atlas_source->get_texture(); Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
if (texture.is_valid()) { if (texture.is_valid()) {
Vector2i margins = tile_set_atlas_source->get_margins(); Vector2i margins = tile_set_atlas_source->get_margins();
@ -488,7 +488,7 @@ Vector2i TileAtlasView::get_atlas_tile_coords_at_pos(const Vector2 p_pos) const
return TileSetSource::INVALID_ATLAS_COORDS; return TileSetSource::INVALID_ATLAS_COORDS;
} }
void TileAtlasView::_update_alternative_tiles_rect_cache() { void RTileAtlasView::_update_alternative_tiles_rect_cache() {
alternative_tiles_rect_cache.clear(); alternative_tiles_rect_cache.clear();
Rect2i current; Rect2i current;
@ -518,7 +518,7 @@ void TileAtlasView::_update_alternative_tiles_rect_cache() {
} }
} }
Vector3i TileAtlasView::get_alternative_tile_at_pos(const Vector2 p_pos) const { Vector3i RTileAtlasView::get_alternative_tile_at_pos(const Vector2 p_pos) const {
for (const KeyValue<Vector2, Map<int, Rect2i>> &E_coords : alternative_tiles_rect_cache) { for (const KeyValue<Vector2, Map<int, Rect2i>> &E_coords : alternative_tiles_rect_cache) {
for (const KeyValue<int, Rect2i> &E_alternative : E_coords.value) { for (const KeyValue<int, Rect2i> &E_alternative : E_coords.value) {
if (E_alternative.value.has_point(p_pos)) { if (E_alternative.value.has_point(p_pos)) {
@ -530,14 +530,14 @@ Vector3i TileAtlasView::get_alternative_tile_at_pos(const Vector2 p_pos) const {
return Vector3i(TileSetSource::INVALID_ATLAS_COORDS.x, TileSetSource::INVALID_ATLAS_COORDS.y, TileSetSource::INVALID_TILE_ALTERNATIVE); return Vector3i(TileSetSource::INVALID_ATLAS_COORDS.x, TileSetSource::INVALID_ATLAS_COORDS.y, TileSetSource::INVALID_TILE_ALTERNATIVE);
} }
Rect2i TileAtlasView::get_alternative_tile_rect(const Vector2i p_coords, int p_alternative_tile) { Rect2i RTileAtlasView::get_alternative_tile_rect(const Vector2i p_coords, int p_alternative_tile) {
ERR_FAIL_COND_V_MSG(!alternative_tiles_rect_cache.has(p_coords), Rect2i(), vformat("No cached rect for tile coords:%s", p_coords)); ERR_FAIL_COND_V_MSG(!alternative_tiles_rect_cache.has(p_coords), Rect2i(), vformat("No cached rect for tile coords:%s", p_coords));
ERR_FAIL_COND_V_MSG(!alternative_tiles_rect_cache[p_coords].has(p_alternative_tile), Rect2i(), vformat("No cached rect for tile coords:%s alternative_id:%d", p_coords, p_alternative_tile)); ERR_FAIL_COND_V_MSG(!alternative_tiles_rect_cache[p_coords].has(p_alternative_tile), Rect2i(), vformat("No cached rect for tile coords:%s alternative_id:%d", p_coords, p_alternative_tile));
return alternative_tiles_rect_cache[p_coords][p_alternative_tile]; return alternative_tiles_rect_cache[p_coords][p_alternative_tile];
} }
void TileAtlasView::update() { void RTileAtlasView::update() {
base_tiles_draw->update(); base_tiles_draw->update();
base_tiles_texture_grid->update(); base_tiles_texture_grid->update();
base_tiles_shape_grid->update(); base_tiles_shape_grid->update();
@ -546,7 +546,7 @@ void TileAtlasView::update() {
background_right->update(); background_right->update();
} }
void TileAtlasView::_notification(int p_what) { void RTileAtlasView::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_READY: case NOTIFICATION_READY:
button_center_view->set_icon(get_theme_icon(SNAME("CenterView"), SNAME("EditorIcons"))); button_center_view->set_icon(get_theme_icon(SNAME("CenterView"), SNAME("EditorIcons")));
@ -554,11 +554,11 @@ void TileAtlasView::_notification(int p_what) {
} }
} }
void TileAtlasView::_bind_methods() { void RTileAtlasView::_bind_methods() {
ADD_SIGNAL(MethodInfo("transform_changed", PropertyInfo(Variant::FLOAT, "zoom"), PropertyInfo(Variant::VECTOR2, "scroll"))); ADD_SIGNAL(MethodInfo("transform_changed", PropertyInfo(Variant::FLOAT, "zoom"), PropertyInfo(Variant::VECTOR2, "scroll")));
} }
TileAtlasView::TileAtlasView() { RTileAtlasView::RTileAtlasView() {
set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST); set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
Panel *panel = memnew(Panel); Panel *panel = memnew(Panel);
@ -573,12 +573,12 @@ TileAtlasView::TileAtlasView() {
zoom_widget = memnew(EditorZoomWidget); zoom_widget = memnew(EditorZoomWidget);
add_child(zoom_widget); add_child(zoom_widget);
zoom_widget->set_anchors_and_offsets_preset(Control::PRESET_TOP_LEFT, Control::PRESET_MODE_MINSIZE, 2 * EDSCALE); zoom_widget->set_anchors_and_offsets_preset(Control::PRESET_TOP_LEFT, Control::PRESET_MODE_MINSIZE, 2 * EDSCALE);
zoom_widget->connect("zoom_changed", callable_mp(this, &TileAtlasView::_zoom_widget_changed).unbind(1)); zoom_widget->connect("zoom_changed", callable_mp(this, &RTileAtlasView::_zoom_widget_changed).unbind(1));
button_center_view = memnew(Button); button_center_view = memnew(Button);
button_center_view->set_icon(get_theme_icon(SNAME("CenterView"), SNAME("EditorIcons"))); button_center_view->set_icon(get_theme_icon(SNAME("CenterView"), SNAME("EditorIcons")));
button_center_view->set_anchors_and_offsets_preset(Control::PRESET_TOP_RIGHT, Control::PRESET_MODE_MINSIZE, 5); button_center_view->set_anchors_and_offsets_preset(Control::PRESET_TOP_RIGHT, Control::PRESET_MODE_MINSIZE, 5);
button_center_view->connect("pressed", callable_mp(this, &TileAtlasView::_center_view)); button_center_view->connect("pressed", callable_mp(this, &RTileAtlasView::_center_view));
button_center_view->set_flat(true); button_center_view->set_flat(true);
button_center_view->set_disabled(true); button_center_view->set_disabled(true);
button_center_view->set_tooltip(TTR("Center View")); button_center_view->set_tooltip(TTR("Center View"));
@ -587,7 +587,7 @@ TileAtlasView::TileAtlasView() {
center_container = memnew(CenterContainer); center_container = memnew(CenterContainer);
center_container->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); center_container->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
center_container->set_anchors_preset(Control::PRESET_CENTER); center_container->set_anchors_preset(Control::PRESET_CENTER);
center_container->connect("gui_input", callable_mp(this, &TileAtlasView::gui_input)); center_container->connect("gui_input", callable_mp(this, &RTileAtlasView::gui_input));
panel->add_child(center_container); panel->add_child(center_container);
missing_source_label = memnew(Label); missing_source_label = memnew(Label);
@ -622,14 +622,14 @@ TileAtlasView::TileAtlasView() {
base_tiles_root_control = memnew(Control); base_tiles_root_control = memnew(Control);
base_tiles_root_control->set_mouse_filter(Control::MOUSE_FILTER_PASS); base_tiles_root_control->set_mouse_filter(Control::MOUSE_FILTER_PASS);
base_tiles_root_control->set_v_size_flags(Control::SIZE_EXPAND_FILL); base_tiles_root_control->set_v_size_flags(Control::SIZE_EXPAND_FILL);
base_tiles_root_control->connect("gui_input", callable_mp(this, &TileAtlasView::_base_tiles_root_control_gui_input)); base_tiles_root_control->connect("gui_input", callable_mp(this, &RTileAtlasView::_base_tiles_root_control_gui_input));
left_vbox->add_child(base_tiles_root_control); left_vbox->add_child(base_tiles_root_control);
background_left = memnew(Control); background_left = memnew(Control);
background_left->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); background_left->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
background_left->set_anchors_and_offsets_preset(Control::PRESET_WIDE); background_left->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
background_left->set_texture_repeat(TextureRepeat::TEXTURE_REPEAT_ENABLED); background_left->set_texture_repeat(TextureRepeat::TEXTURE_REPEAT_ENABLED);
background_left->connect("draw", callable_mp(this, &TileAtlasView::_draw_background_left)); background_left->connect("draw", callable_mp(this, &RTileAtlasView::_draw_background_left));
base_tiles_root_control->add_child(background_left); base_tiles_root_control->add_child(background_left);
base_tiles_drawing_root = memnew(Control); base_tiles_drawing_root = memnew(Control);
@ -641,19 +641,19 @@ TileAtlasView::TileAtlasView() {
base_tiles_draw = memnew(Control); base_tiles_draw = memnew(Control);
base_tiles_draw->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); base_tiles_draw->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
base_tiles_draw->set_anchors_and_offsets_preset(Control::PRESET_WIDE); base_tiles_draw->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
base_tiles_draw->connect("draw", callable_mp(this, &TileAtlasView::_draw_base_tiles)); base_tiles_draw->connect("draw", callable_mp(this, &RTileAtlasView::_draw_base_tiles));
base_tiles_drawing_root->add_child(base_tiles_draw); base_tiles_drawing_root->add_child(base_tiles_draw);
base_tiles_texture_grid = memnew(Control); base_tiles_texture_grid = memnew(Control);
base_tiles_texture_grid->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); base_tiles_texture_grid->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
base_tiles_texture_grid->set_anchors_and_offsets_preset(Control::PRESET_WIDE); base_tiles_texture_grid->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
base_tiles_texture_grid->connect("draw", callable_mp(this, &TileAtlasView::_draw_base_tiles_texture_grid)); base_tiles_texture_grid->connect("draw", callable_mp(this, &RTileAtlasView::_draw_base_tiles_texture_grid));
base_tiles_drawing_root->add_child(base_tiles_texture_grid); base_tiles_drawing_root->add_child(base_tiles_texture_grid);
base_tiles_shape_grid = memnew(Control); base_tiles_shape_grid = memnew(Control);
base_tiles_shape_grid->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); base_tiles_shape_grid->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
base_tiles_shape_grid->set_anchors_and_offsets_preset(Control::PRESET_WIDE); base_tiles_shape_grid->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
base_tiles_shape_grid->connect("draw", callable_mp(this, &TileAtlasView::_draw_base_tiles_shape_grid)); base_tiles_shape_grid->connect("draw", callable_mp(this, &RTileAtlasView::_draw_base_tiles_shape_grid));
base_tiles_drawing_root->add_child(base_tiles_shape_grid); base_tiles_drawing_root->add_child(base_tiles_shape_grid);
// Alternative tiles. // Alternative tiles.
@ -665,13 +665,13 @@ TileAtlasView::TileAtlasView() {
alternative_tiles_root_control = memnew(Control); alternative_tiles_root_control = memnew(Control);
alternative_tiles_root_control->set_mouse_filter(Control::MOUSE_FILTER_PASS); alternative_tiles_root_control->set_mouse_filter(Control::MOUSE_FILTER_PASS);
alternative_tiles_root_control->connect("gui_input", callable_mp(this, &TileAtlasView::_alternative_tiles_root_control_gui_input)); alternative_tiles_root_control->connect("gui_input", callable_mp(this, &RTileAtlasView::_alternative_tiles_root_control_gui_input));
right_vbox->add_child(alternative_tiles_root_control); right_vbox->add_child(alternative_tiles_root_control);
background_right = memnew(Control); background_right = memnew(Control);
background_right->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); background_right->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
background_right->set_texture_repeat(TextureRepeat::TEXTURE_REPEAT_ENABLED); background_right->set_texture_repeat(TextureRepeat::TEXTURE_REPEAT_ENABLED);
background_right->connect("draw", callable_mp(this, &TileAtlasView::_draw_background_right)); background_right->connect("draw", callable_mp(this, &RTileAtlasView::_draw_background_right));
alternative_tiles_root_control->add_child(background_right); alternative_tiles_root_control->add_child(background_right);
@ -682,6 +682,6 @@ TileAtlasView::TileAtlasView() {
alternatives_draw = memnew(Control); alternatives_draw = memnew(Control);
alternatives_draw->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); alternatives_draw->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
alternatives_draw->connect("draw", callable_mp(this, &TileAtlasView::_draw_alternatives)); alternatives_draw->connect("draw", callable_mp(this, &RTileAtlasView::_draw_alternatives));
alternative_tiles_drawing_root->add_child(alternatives_draw); alternative_tiles_drawing_root->add_child(alternatives_draw);
} }

10
tile_editor/tile_atlas_view.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILE_ATLAS_VIEW_H #ifndef RTILE_ATLAS_VIEW_H
#define TILE_ATLAS_VIEW_H #define RTILE_ATLAS_VIEW_H
#include "editor/editor_zoom_widget.h" #include "editor/editor_zoom_widget.h"
#include "scene/gui/box_container.h" #include "scene/gui/box_container.h"
@ -41,8 +41,8 @@
#include "scene/gui/texture_rect.h" #include "scene/gui/texture_rect.h"
#include "scene/resources/tile_set.h" #include "scene/resources/tile_set.h"
class TileAtlasView : public Control { class RTileAtlasView : public Control {
GDCLASS(TileAtlasView, Control); GDCLASS(RTileAtlasView, Control);
private: private:
TileSet *tile_set; TileSet *tile_set;
@ -150,7 +150,7 @@ public:
// Update everything. // Update everything.
void update(); void update();
TileAtlasView(); RTileAtlasView();
}; };
#endif // TILE_ATLAS_VIEW #endif // TILE_ATLAS_VIEW

48
tile_editor/tile_data_editors.cpp
View File

@ -38,19 +38,19 @@
#include "editor/editor_properties.h" #include "editor/editor_properties.h"
#include "editor/editor_scale.h" #include "editor/editor_scale.h"
void TileDataEditor::_tile_set_changed_plan_update() { void RTileDataEditor::_tile_set_changed_plan_update() {
_tile_set_changed_update_needed = true; _tile_set_changed_update_needed = true;
call_deferred("_tile_set_changed_deferred_update"); call_deferred("_tile_set_changed_deferred_update");
} }
void TileDataEditor::_tile_set_changed_deferred_update() { void RTileDataEditor::_tile_set_changed_deferred_update() {
if (_tile_set_changed_update_needed) { if (_tile_set_changed_update_needed) {
_tile_set_changed(); _tile_set_changed();
_tile_set_changed_update_needed = false; _tile_set_changed_update_needed = false;
} }
} }
TileData *TileDataEditor::_get_tile_data(TileMapCell p_cell) { TileData *RTileDataEditor::_get_tile_data(TileMapCell p_cell) {
ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr); ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr);
ERR_FAIL_COND_V(!tile_set->has_source(p_cell.source_id), nullptr); ERR_FAIL_COND_V(!tile_set->has_source(p_cell.source_id), nullptr);
@ -66,19 +66,19 @@ TileData *TileDataEditor::_get_tile_data(TileMapCell p_cell) {
return td; return td;
} }
void TileDataEditor::_bind_methods() { void RTileDataEditor::_bind_methods() {
ClassDB::bind_method(D_METHOD("_tile_set_changed_deferred_update"), &TileDataEditor::_tile_set_changed_deferred_update); ClassDB::bind_method(D_METHOD("_tile_set_changed_deferred_update"), &RTileDataEditor::_tile_set_changed_deferred_update);
ADD_SIGNAL(MethodInfo("needs_redraw")); ADD_SIGNAL(MethodInfo("needs_redraw"));
} }
void TileDataEditor::set_tile_set(Ref<TileSet> p_tile_set) { void RTileDataEditor::set_tile_set(Ref<TileSet> p_tile_set) {
if (tile_set.is_valid()) { if (tile_set.is_valid()) {
tile_set->disconnect("changed", callable_mp(this, &TileDataEditor::_tile_set_changed_plan_update)); tile_set->disconnect("changed", callable_mp(this, &RTileDataEditor::_tile_set_changed_plan_update));
} }
tile_set = p_tile_set; tile_set = p_tile_set;
if (tile_set.is_valid()) { if (tile_set.is_valid()) {
tile_set->connect("changed", callable_mp(this, &TileDataEditor::_tile_set_changed_plan_update)); tile_set->connect("changed", callable_mp(this, &RTileDataEditor::_tile_set_changed_plan_update));
} }
_tile_set_changed_plan_update(); _tile_set_changed_plan_update();
} }
@ -866,7 +866,7 @@ void TileDataDefaultEditor::_setup_undo_redo_action(TileSetAtlasSource *p_tile_s
} }
} }
void TileDataDefaultEditor::forward_draw_over_atlas(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) { void TileDataDefaultEditor::forward_draw_over_atlas(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) {
if (drag_type == DRAG_TYPE_PAINT_RECT) { if (drag_type == DRAG_TYPE_PAINT_RECT) {
Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color"); Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color");
Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0); Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0);
@ -901,11 +901,11 @@ void TileDataDefaultEditor::forward_draw_over_atlas(TileAtlasView *p_tile_atlas_
} }
}; };
void TileDataDefaultEditor::forward_draw_over_alternatives(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform){ void TileDataDefaultEditor::forward_draw_over_alternatives(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform){
}; };
void TileDataDefaultEditor::forward_painting_atlas_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) { void TileDataDefaultEditor::forward_painting_atlas_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) {
Ref<InputEventMouseMotion> mm = p_event; Ref<InputEventMouseMotion> mm = p_event;
if (mm.is_valid()) { if (mm.is_valid()) {
if (drag_type == DRAG_TYPE_PAINT) { if (drag_type == DRAG_TYPE_PAINT) {
@ -995,7 +995,7 @@ void TileDataDefaultEditor::forward_painting_atlas_gui_input(TileAtlasView *p_ti
} }
} }
void TileDataDefaultEditor::forward_painting_alternatives_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) { void TileDataDefaultEditor::forward_painting_alternatives_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) {
Ref<InputEventMouseMotion> mm = p_event; Ref<InputEventMouseMotion> mm = p_event;
if (mm.is_valid()) { if (mm.is_valid()) {
if (drag_type == DRAG_TYPE_PAINT) { if (drag_type == DRAG_TYPE_PAINT) {
@ -1079,8 +1079,8 @@ void TileDataDefaultEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform2
Rect2 rect = p_transform.xform(Rect2(Vector2(-size / 2, -size / 2), Vector2(size, size))); Rect2 rect = p_transform.xform(Rect2(Vector2(-size / 2, -size / 2), Vector2(size, size)));
p_canvas_item->draw_rect(rect, value); p_canvas_item->draw_rect(rect, value);
} else { } else {
Ref<Font> font = TileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), SNAME("EditorFonts")); Ref<Font> font = RTileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), SNAME("EditorFonts"));
int font_size = TileSetEditor::get_singleton()->get_theme_font_size(SNAME("bold_size"), SNAME("EditorFonts")); int font_size = RTileSetEditor::get_singleton()->get_theme_font_size(SNAME("bold_size"), SNAME("EditorFonts"));
String text; String text;
switch (value.get_type()) { switch (value.get_type()) {
case Variant::INT: case Variant::INT:
@ -1217,7 +1217,7 @@ void TileDataPositionEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform
Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0); Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0);
color = selection_color; color = selection_color;
} }
Ref<Texture2D> position_icon = TileSetEditor::get_singleton()->get_theme_icon(SNAME("EditorPosition"), SNAME("EditorIcons")); Ref<Texture2D> position_icon = RTileSetEditor::get_singleton()->get_theme_icon(SNAME("EditorPosition"), SNAME("EditorIcons"));
p_canvas_item->draw_texture(position_icon, p_transform.xform(Vector2(value)) - position_icon->get_size() / 2, color); p_canvas_item->draw_texture(position_icon, p_transform.xform(Vector2(value)) - position_icon->get_size() / 2, color);
} }
@ -1231,7 +1231,7 @@ void TileDataYSortEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform2D
Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0); Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0);
color = selection_color; color = selection_color;
} }
Ref<Texture2D> position_icon = TileSetEditor::get_singleton()->get_theme_icon(SNAME("EditorPosition"), SNAME("EditorIcons")); Ref<Texture2D> position_icon = RTileSetEditor::get_singleton()->get_theme_icon(SNAME("EditorPosition"), SNAME("EditorIcons"));
p_canvas_item->draw_texture(position_icon, p_transform.xform(Vector2(0, tile_data->get_y_sort_origin())) - position_icon->get_size() / 2, color); p_canvas_item->draw_texture(position_icon, p_transform.xform(Vector2(0, tile_data->get_y_sort_origin())) - position_icon->get_size() / 2, color);
} }
@ -1631,7 +1631,7 @@ void TileDataTerrainsEditor::_tile_set_changed() {
_update_terrain_selector(); _update_terrain_selector();
} }
void TileDataTerrainsEditor::forward_draw_over_atlas(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) { void TileDataTerrainsEditor::forward_draw_over_atlas(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
// Draw the hovered terrain bit, or the whole tile if it has the wrong terrain set. // Draw the hovered terrain bit, or the whole tile if it has the wrong terrain set.
@ -1675,8 +1675,8 @@ void TileDataTerrainsEditor::forward_draw_over_atlas(TileAtlasView *p_tile_atlas
} }
// Dim terrains with wrong terrain set. // Dim terrains with wrong terrain set.
Ref<Font> font = TileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), SNAME("EditorFonts")); Ref<Font> font = RTileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), SNAME("EditorFonts"));
int font_size = TileSetEditor::get_singleton()->get_theme_font_size(SNAME("bold_size"), SNAME("EditorFonts")); int font_size = RTileSetEditor::get_singleton()->get_theme_font_size(SNAME("bold_size"), SNAME("EditorFonts"));
for (int i = 0; i < p_tile_set_atlas_source->get_tiles_count(); i++) { for (int i = 0; i < p_tile_set_atlas_source->get_tiles_count(); i++) {
Vector2i coords = p_tile_set_atlas_source->get_tile_id(i); Vector2i coords = p_tile_set_atlas_source->get_tile_id(i);
if (coords != hovered_coords) { if (coords != hovered_coords) {
@ -1803,7 +1803,7 @@ void TileDataTerrainsEditor::forward_draw_over_atlas(TileAtlasView *p_tile_atlas
} }
} }
void TileDataTerrainsEditor::forward_draw_over_alternatives(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) { void TileDataTerrainsEditor::forward_draw_over_alternatives(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
// Draw the hovered terrain bit, or the whole tile if it has the wrong terrain set. // Draw the hovered terrain bit, or the whole tile if it has the wrong terrain set.
@ -1849,8 +1849,8 @@ void TileDataTerrainsEditor::forward_draw_over_alternatives(TileAtlasView *p_til
} }
// Dim terrains with wrong terrain set. // Dim terrains with wrong terrain set.
Ref<Font> font = TileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), SNAME("EditorFonts")); Ref<Font> font = RTileSetEditor::get_singleton()->get_theme_font(SNAME("bold"), SNAME("EditorFonts"));
int font_size = TileSetEditor::get_singleton()->get_theme_font_size(SNAME("bold_size"), SNAME("EditorFonts")); int font_size = RTileSetEditor::get_singleton()->get_theme_font_size(SNAME("bold_size"), SNAME("EditorFonts"));
for (int i = 0; i < p_tile_set_atlas_source->get_tiles_count(); i++) { for (int i = 0; i < p_tile_set_atlas_source->get_tiles_count(); i++) {
Vector2i coords = p_tile_set_atlas_source->get_tile_id(i); Vector2i coords = p_tile_set_atlas_source->get_tile_id(i);
for (int j = 1; j < p_tile_set_atlas_source->get_alternative_tiles_count(coords); j++) { for (int j = 1; j < p_tile_set_atlas_source->get_alternative_tiles_count(coords); j++) {
@ -1885,7 +1885,7 @@ void TileDataTerrainsEditor::forward_draw_over_alternatives(TileAtlasView *p_til
p_canvas_item->draw_set_transform_matrix(Transform2D()); p_canvas_item->draw_set_transform_matrix(Transform2D());
} }
void TileDataTerrainsEditor::forward_painting_atlas_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) { void TileDataTerrainsEditor::forward_painting_atlas_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) {
Ref<InputEventMouseMotion> mm = p_event; Ref<InputEventMouseMotion> mm = p_event;
if (mm.is_valid()) { if (mm.is_valid()) {
if (drag_type == DRAG_TYPE_PAINT_TERRAIN_SET) { if (drag_type == DRAG_TYPE_PAINT_TERRAIN_SET) {
@ -2228,7 +2228,7 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(TileAtlasView *p_t
} }
} }
void TileDataTerrainsEditor::forward_painting_alternatives_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) { void TileDataTerrainsEditor::forward_painting_alternatives_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_set_atlas_source, const Ref<InputEvent> &p_event) {
Ref<InputEventMouseMotion> mm = p_event; Ref<InputEventMouseMotion> mm = p_event;
if (mm.is_valid()) { if (mm.is_valid()) {
if (drag_type == DRAG_TYPE_PAINT_TERRAIN_SET) { if (drag_type == DRAG_TYPE_PAINT_TERRAIN_SET) {

40
tile_editor/tile_data_editors.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILE_DATA_EDITORS_H #ifndef RTILE_DATA_EDITORS_H
#define TILE_DATA_EDITORS_H #define RTILE_DATA_EDITORS_H
#include "tile_atlas_view.h" #include "tile_atlas_view.h"
@ -41,8 +41,8 @@
#include "scene/gui/control.h" #include "scene/gui/control.h"
#include "scene/gui/label.h" #include "scene/gui/label.h"
class TileDataEditor : public VBoxContainer { class RTileDataEditor : public VBoxContainer {
GDCLASS(TileDataEditor, VBoxContainer); GDCLASS(RTileDataEditor, VBoxContainer);
private: private:
bool _tile_set_changed_update_needed = false; bool _tile_set_changed_update_needed = false;
@ -61,10 +61,10 @@ public:
// Input to handle painting. // Input to handle painting.
virtual Control *get_toolbar() { return nullptr; }; virtual Control *get_toolbar() { return nullptr; };
virtual void forward_draw_over_atlas(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform){}; virtual void forward_draw_over_atlas(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform){};
virtual void forward_draw_over_alternatives(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform){}; virtual void forward_draw_over_alternatives(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform){};
virtual void forward_painting_atlas_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event){}; virtual void forward_painting_atlas_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event){};
virtual void forward_painting_alternatives_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event){}; virtual void forward_painting_alternatives_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event){};
// Used to draw the tile data property value over a tile. // Used to draw the tile data property value over a tile.
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, TileMapCell p_cell, bool p_selected = false){}; virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, TileMapCell p_cell, bool p_selected = false){};
@ -184,8 +184,8 @@ public:
GenericTilePolygonEditor(); GenericTilePolygonEditor();
}; };
class TileDataDefaultEditor : public TileDataEditor { class TileDataDefaultEditor : public RTileDataEditor {
GDCLASS(TileDataDefaultEditor, TileDataEditor); GDCLASS(TileDataDefaultEditor, RTileDataEditor);
private: private:
// Toolbar // Toolbar
@ -230,10 +230,10 @@ protected:
public: public:
virtual Control *get_toolbar() override { return toolbar; }; virtual Control *get_toolbar() override { return toolbar; };
virtual void forward_draw_over_atlas(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override; virtual void forward_draw_over_atlas(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_draw_over_alternatives(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override; virtual void forward_draw_over_alternatives(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_painting_atlas_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override; virtual void forward_painting_atlas_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void forward_painting_alternatives_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override; virtual void forward_painting_alternatives_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, TileMapCell p_cell, bool p_selected = false) override; virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, TileMapCell p_cell, bool p_selected = false) override;
void setup_property_editor(Variant::Type p_type, String p_property, String p_label = "", Variant p_default_value = Variant()); void setup_property_editor(Variant::Type p_type, String p_property, String p_label = "", Variant p_default_value = Variant());
@ -330,8 +330,8 @@ public:
~TileDataCollisionEditor(); ~TileDataCollisionEditor();
}; };
class TileDataTerrainsEditor : public TileDataEditor { class TileDataTerrainsEditor : public RTileDataEditor {
GDCLASS(TileDataTerrainsEditor, TileDataEditor); GDCLASS(TileDataTerrainsEditor, RTileDataEditor);
private: private:
// Toolbar // Toolbar
@ -371,10 +371,10 @@ protected:
public: public:
virtual Control *get_toolbar() override { return toolbar; }; virtual Control *get_toolbar() override { return toolbar; };
virtual void forward_draw_over_atlas(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override; virtual void forward_draw_over_atlas(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_draw_over_alternatives(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override; virtual void forward_draw_over_alternatives(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, CanvasItem *p_canvas_item, Transform2D p_transform) override;
virtual void forward_painting_atlas_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override; virtual void forward_painting_atlas_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void forward_painting_alternatives_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override; virtual void forward_painting_alternatives_gui_input(RTileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event) override;
virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, TileMapCell p_cell, bool p_selected = false) override; virtual void draw_over_tile(CanvasItem *p_canvas_item, Transform2D p_transform, TileMapCell p_cell, bool p_selected = false) override;
TileDataTerrainsEditor(); TileDataTerrainsEditor();

296
tile_editor/tile_map_editor.cpp
View File

@ -44,22 +44,22 @@
#include "core/math/geometry_2d.h" #include "core/math/geometry_2d.h"
#include "core/os/keyboard.h" #include "core/os/keyboard.h"
void TileMapEditorTilesPlugin::tile_set_changed() { void RTileMapEditorTilesPlugin::tile_set_changed() {
_update_fix_selected_and_hovered(); _update_fix_selected_and_hovered();
_update_tile_set_sources_list(); _update_tile_set_sources_list();
_update_source_display(); _update_source_display();
_update_patterns_list(); _update_patterns_list();
} }
void TileMapEditorTilesPlugin::_on_random_tile_checkbox_toggled(bool p_pressed) { void RTileMapEditorTilesPlugin::_on_random_tile_checkbox_toggled(bool p_pressed) {
scatter_spinbox->set_editable(p_pressed); scatter_spinbox->set_editable(p_pressed);
} }
void TileMapEditorTilesPlugin::_on_scattering_spinbox_changed(double p_value) { void RTileMapEditorTilesPlugin::_on_scattering_spinbox_changed(double p_value) {
scattering = p_value; scattering = p_value;
} }
void TileMapEditorTilesPlugin::_update_toolbar() { void RTileMapEditorTilesPlugin::_update_toolbar() {
// Stop draggig if needed. // Stop draggig if needed.
_stop_dragging(); _stop_dragging();
@ -106,14 +106,14 @@ void TileMapEditorTilesPlugin::_update_toolbar() {
} }
} }
Vector<TileMapEditorPlugin::TabData> TileMapEditorTilesPlugin::get_tabs() const { Vector<RTileMapEditorPlugin::TabData> RTileMapEditorTilesPlugin::get_tabs() const {
Vector<TileMapEditorPlugin::TabData> tabs; Vector<RTileMapEditorPlugin::TabData> tabs;
tabs.push_back({ toolbar, tiles_bottom_panel }); tabs.push_back({ toolbar, tiles_bottom_panel });
tabs.push_back({ toolbar, patterns_bottom_panel }); tabs.push_back({ toolbar, patterns_bottom_panel });
return tabs; return tabs;
} }
void TileMapEditorTilesPlugin::_tab_changed() { void RTileMapEditorTilesPlugin::_tab_changed() {
if (tiles_bottom_panel->is_visible_in_tree()) { if (tiles_bottom_panel->is_visible_in_tree()) {
_update_selection_pattern_from_tileset_tiles_selection(); _update_selection_pattern_from_tileset_tiles_selection();
} else if (patterns_bottom_panel->is_visible_in_tree()) { } else if (patterns_bottom_panel->is_visible_in_tree()) {
@ -121,7 +121,7 @@ void TileMapEditorTilesPlugin::_tab_changed() {
} }
} }
void TileMapEditorTilesPlugin::_update_tile_set_sources_list() { void RTileMapEditorTilesPlugin::_update_tile_set_sources_list() {
// Update the sources. // Update the sources.
int old_current = sources_list->get_current(); int old_current = sources_list->get_current();
sources_list->clear(); sources_list->clear();
@ -194,10 +194,10 @@ void TileMapEditorTilesPlugin::_update_tile_set_sources_list() {
} }
// Synchronize // Synchronize
TilesEditorPlugin::get_singleton()->set_sources_lists_current(sources_list->get_current()); RTilesEditorPlugin::get_singleton()->set_sources_lists_current(sources_list->get_current());
} }
void TileMapEditorTilesPlugin::_update_source_display() { void RTileMapEditorTilesPlugin::_update_source_display() {
// Update the atlas display. // Update the atlas display.
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
@ -244,7 +244,7 @@ void TileMapEditorTilesPlugin::_update_source_display() {
} }
} }
void TileMapEditorTilesPlugin::_patterns_item_list_gui_input(const Ref<InputEvent> &p_event) { void RTileMapEditorTilesPlugin::_patterns_item_list_gui_input(const Ref<InputEvent> &p_event) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -278,7 +278,7 @@ void TileMapEditorTilesPlugin::_patterns_item_list_gui_input(const Ref<InputEven
} }
} }
void TileMapEditorTilesPlugin::_pattern_preview_done(Ref<TileMapPattern> p_pattern, Ref<Texture2D> p_texture) { void RTileMapEditorTilesPlugin::_pattern_preview_done(Ref<TileMapPattern> p_pattern, Ref<Texture2D> p_texture) {
// TODO optimize ? // TODO optimize ?
for (int i = 0; i < patterns_item_list->get_item_count(); i++) { for (int i = 0; i < patterns_item_list->get_item_count(); i++) {
if (patterns_item_list->get_item_metadata(i) == p_pattern) { if (patterns_item_list->get_item_metadata(i) == p_pattern) {
@ -288,7 +288,7 @@ void TileMapEditorTilesPlugin::_pattern_preview_done(Ref<TileMapPattern> p_patte
} }
} }
void TileMapEditorTilesPlugin::_update_patterns_list() { void RTileMapEditorTilesPlugin::_update_patterns_list() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -304,7 +304,7 @@ void TileMapEditorTilesPlugin::_update_patterns_list() {
for (int i = 0; i < tile_set->get_patterns_count(); i++) { for (int i = 0; i < tile_set->get_patterns_count(); i++) {
int id = patterns_item_list->add_item(""); int id = patterns_item_list->add_item("");
patterns_item_list->set_item_metadata(id, tile_set->get_pattern(i)); patterns_item_list->set_item_metadata(id, tile_set->get_pattern(i));
TilesEditorPlugin::get_singleton()->queue_pattern_preview(tile_set, tile_set->get_pattern(i), callable_mp(this, &TileMapEditorTilesPlugin::_pattern_preview_done)); RTilesEditorPlugin::get_singleton()->queue_pattern_preview(tile_set, tile_set->get_pattern(i), callable_mp(this, &RTileMapEditorTilesPlugin::_pattern_preview_done));
} }
// Update the label visibility. // Update the label visibility.
@ -319,7 +319,7 @@ void TileMapEditorTilesPlugin::_update_patterns_list() {
select_last_pattern = false; select_last_pattern = false;
} }
void TileMapEditorTilesPlugin::_update_atlas_view() { void RTileMapEditorTilesPlugin::_update_atlas_view() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -336,11 +336,11 @@ void TileMapEditorTilesPlugin::_update_atlas_view() {
ERR_FAIL_COND(!atlas_source); ERR_FAIL_COND(!atlas_source);
tile_atlas_view->set_atlas_source(*tile_map->get_tileset(), atlas_source, source_id); tile_atlas_view->set_atlas_source(*tile_map->get_tileset(), atlas_source, source_id);
TilesEditorPlugin::get_singleton()->synchronize_atlas_view(tile_atlas_view); RTilesEditorPlugin::get_singleton()->synchronize_atlas_view(tile_atlas_view);
tile_atlas_control->update(); tile_atlas_control->update();
} }
void TileMapEditorTilesPlugin::_update_scenes_collection_view() { void RTileMapEditorTilesPlugin::_update_scenes_collection_view() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -386,7 +386,7 @@ void TileMapEditorTilesPlugin::_update_scenes_collection_view() {
scene_tiles_list->set_fixed_icon_size(Vector2(int_size, int_size)); scene_tiles_list->set_fixed_icon_size(Vector2(int_size, int_size));
} }
void TileMapEditorTilesPlugin::_scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, Variant p_ud) { void RTileMapEditorTilesPlugin::_scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, Variant p_ud) {
int index = p_ud; int index = p_ud;
if (index >= 0 && index < scene_tiles_list->get_item_count()) { if (index >= 0 && index < scene_tiles_list->get_item_count()) {
@ -394,7 +394,7 @@ void TileMapEditorTilesPlugin::_scene_thumbnail_done(const String &p_path, const
} }
} }
void TileMapEditorTilesPlugin::_scenes_list_multi_selected(int p_index, bool p_selected) { void RTileMapEditorTilesPlugin::_scenes_list_multi_selected(int p_index, bool p_selected) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -430,7 +430,7 @@ void TileMapEditorTilesPlugin::_scenes_list_multi_selected(int p_index, bool p_s
_update_selection_pattern_from_tileset_tiles_selection(); _update_selection_pattern_from_tileset_tiles_selection();
} }
void TileMapEditorTilesPlugin::_scenes_list_nothing_selected() { void RTileMapEditorTilesPlugin::_scenes_list_nothing_selected() {
scene_tiles_list->deselect_all(); scene_tiles_list->deselect_all();
tile_set_selection.clear(); tile_set_selection.clear();
tile_map_selection.clear(); tile_map_selection.clear();
@ -438,7 +438,7 @@ void TileMapEditorTilesPlugin::_scenes_list_nothing_selected() {
_update_selection_pattern_from_tileset_tiles_selection(); _update_selection_pattern_from_tileset_tiles_selection();
} }
void TileMapEditorTilesPlugin::_update_theme() { void RTileMapEditorTilesPlugin::_update_theme() {
select_tool_button->set_icon(tiles_bottom_panel->get_theme_icon(SNAME("ToolSelect"), SNAME("EditorIcons"))); select_tool_button->set_icon(tiles_bottom_panel->get_theme_icon(SNAME("ToolSelect"), SNAME("EditorIcons")));
paint_tool_button->set_icon(tiles_bottom_panel->get_theme_icon(SNAME("Edit"), SNAME("EditorIcons"))); paint_tool_button->set_icon(tiles_bottom_panel->get_theme_icon(SNAME("Edit"), SNAME("EditorIcons")));
line_tool_button->set_icon(tiles_bottom_panel->get_theme_icon(SNAME("CurveLinear"), SNAME("EditorIcons"))); line_tool_button->set_icon(tiles_bottom_panel->get_theme_icon(SNAME("CurveLinear"), SNAME("EditorIcons")));
@ -451,7 +451,7 @@ void TileMapEditorTilesPlugin::_update_theme() {
missing_atlas_texture_icon = tiles_bottom_panel->get_theme_icon(SNAME("TileSet"), SNAME("EditorIcons")); missing_atlas_texture_icon = tiles_bottom_panel->get_theme_icon(SNAME("TileSet"), SNAME("EditorIcons"));
} }
bool TileMapEditorTilesPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p_event) { bool RTileMapEditorTilesPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p_event) {
if (!(tiles_bottom_panel->is_visible_in_tree() || patterns_bottom_panel->is_visible_in_tree())) { if (!(tiles_bottom_panel->is_visible_in_tree() || patterns_bottom_panel->is_visible_in_tree())) {
// If the bottom editor is not visible, we ignore inputs. // If the bottom editor is not visible, we ignore inputs.
return false; return false;
@ -557,7 +557,7 @@ bool TileMapEditorTilesPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p
_fix_invalid_tiles_in_tile_map_selection(); _fix_invalid_tiles_in_tile_map_selection();
} break; } break;
case DRAG_TYPE_BUCKET: { case DRAG_TYPE_BUCKET: {
Vector<Vector2i> line = TileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_last_mouse_pos), tile_map->world_to_map(mpos)); Vector<Vector2i> line = RTileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_last_mouse_pos), tile_map->world_to_map(mpos));
for (int i = 0; i < line.size(); i++) { for (int i = 0; i < line.size(); i++) {
if (!drag_modified.has(line[i])) { if (!drag_modified.has(line[i])) {
Map<Vector2i, TileMapCell> to_draw = _draw_bucket_fill(line[i], bucket_contiguous_checkbox->is_pressed(), drag_erasing); Map<Vector2i, TileMapCell> to_draw = _draw_bucket_fill(line[i], bucket_contiguous_checkbox->is_pressed(), drag_erasing);
@ -653,7 +653,7 @@ bool TileMapEditorTilesPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p
drag_type = DRAG_TYPE_BUCKET; drag_type = DRAG_TYPE_BUCKET;
drag_start_mouse_pos = mpos; drag_start_mouse_pos = mpos;
drag_modified.clear(); drag_modified.clear();
Vector<Vector2i> line = TileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_last_mouse_pos), tile_map->world_to_map(mpos)); Vector<Vector2i> line = RTileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_last_mouse_pos), tile_map->world_to_map(mpos));
for (int i = 0; i < line.size(); i++) { for (int i = 0; i < line.size(); i++) {
if (!drag_modified.has(line[i])) { if (!drag_modified.has(line[i])) {
Map<Vector2i, TileMapCell> to_draw = _draw_bucket_fill(line[i], bucket_contiguous_checkbox->is_pressed(), drag_erasing); Map<Vector2i, TileMapCell> to_draw = _draw_bucket_fill(line[i], bucket_contiguous_checkbox->is_pressed(), drag_erasing);
@ -690,7 +690,7 @@ bool TileMapEditorTilesPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p
return false; return false;
} }
void TileMapEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p_overlay) { void RTileMapEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p_overlay) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -910,12 +910,12 @@ void TileMapEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p_over
} }
} }
void TileMapEditorTilesPlugin::_mouse_exited_viewport() { void RTileMapEditorTilesPlugin::_mouse_exited_viewport() {
has_mouse = false; has_mouse = false;
CanvasItemEditor::get_singleton()->update_viewport(); CanvasItemEditor::get_singleton()->update_viewport();
} }
TileMapCell TileMapEditorTilesPlugin::_pick_random_tile(Ref<TileMapPattern> p_pattern) { TileMapCell RTileMapEditorTilesPlugin::_pick_random_tile(Ref<TileMapPattern> p_pattern) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return TileMapCell(); return TileMapCell();
@ -967,7 +967,7 @@ TileMapCell TileMapEditorTilesPlugin::_pick_random_tile(Ref<TileMapPattern> p_pa
return TileMapCell(); return TileMapCell();
} }
Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_line(Vector2 p_start_drag_mouse_pos, Vector2 p_from_mouse_pos, Vector2 p_to_mouse_pos, bool p_erase) { Map<Vector2i, TileMapCell> RTileMapEditorTilesPlugin::_draw_line(Vector2 p_start_drag_mouse_pos, Vector2 p_from_mouse_pos, Vector2 p_to_mouse_pos, bool p_erase) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Map<Vector2i, TileMapCell>(); return Map<Vector2i, TileMapCell>();
@ -989,7 +989,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_line(Vector2 p_start_
// Paint the tiles on the tile map. // Paint the tiles on the tile map.
if (!p_erase && random_tile_checkbox->is_pressed()) { if (!p_erase && random_tile_checkbox->is_pressed()) {
// Paint a random tile. // Paint a random tile.
Vector<Vector2i> line = TileMapEditor::get_line(tile_map, tile_map->world_to_map(p_from_mouse_pos), tile_map->world_to_map(p_to_mouse_pos)); Vector<Vector2i> line = RTileMapEditor::get_line(tile_map, tile_map->world_to_map(p_from_mouse_pos), tile_map->world_to_map(p_to_mouse_pos));
for (int i = 0; i < line.size(); i++) { for (int i = 0; i < line.size(); i++) {
output.insert(line[i], _pick_random_tile(pattern)); output.insert(line[i], _pick_random_tile(pattern));
} }
@ -1003,7 +1003,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_line(Vector2 p_start_
TypedArray<Vector2i> used_cells = pattern->get_used_cells(); TypedArray<Vector2i> used_cells = pattern->get_used_cells();
Vector2i offset = Vector2i(Math::posmod(drag_start_cell.x, pattern->get_size().x), Math::posmod(drag_start_cell.y, pattern->get_size().y)); // Note: no posmodv for Vector2i for now. Meh.s Vector2i offset = Vector2i(Math::posmod(drag_start_cell.x, pattern->get_size().x), Math::posmod(drag_start_cell.y, pattern->get_size().y)); // Note: no posmodv for Vector2i for now. Meh.s
Vector<Vector2i> line = TileMapEditor::get_line(tile_map, (last_hovered_cell - offset) / pattern->get_size(), (new_hovered_cell - offset) / pattern->get_size()); Vector<Vector2i> line = RTileMapEditor::get_line(tile_map, (last_hovered_cell - offset) / pattern->get_size(), (new_hovered_cell - offset) / pattern->get_size());
for (int i = 0; i < line.size(); i++) { for (int i = 0; i < line.size(); i++) {
Vector2i top_left = line[i] * pattern->get_size() + offset; Vector2i top_left = line[i] * pattern->get_size() + offset;
for (int j = 0; j < used_cells.size(); j++) { for (int j = 0; j < used_cells.size(); j++) {
@ -1016,7 +1016,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_line(Vector2 p_start_
return output; return output;
} }
Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_rect(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) { Map<Vector2i, TileMapCell> RTileMapEditorTilesPlugin::_draw_rect(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Map<Vector2i, TileMapCell>(); return Map<Vector2i, TileMapCell>();
@ -1075,7 +1075,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_rect(Vector2i p_start
return output; return output;
} }
Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_bucket_fill(Vector2i p_coords, bool p_contiguous, bool p_erase) { Map<Vector2i, TileMapCell> RTileMapEditorTilesPlugin::_draw_bucket_fill(Vector2i p_coords, bool p_contiguous, bool p_erase) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Map<Vector2i, TileMapCell>(); return Map<Vector2i, TileMapCell>();
@ -1187,7 +1187,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTilesPlugin::_draw_bucket_fill(Vector2i
return output; return output;
} }
void TileMapEditorTilesPlugin::_stop_dragging() { void RTileMapEditorTilesPlugin::_stop_dragging() {
if (drag_type == DRAG_TYPE_NONE) { if (drag_type == DRAG_TYPE_NONE) {
return; return;
} }
@ -1387,7 +1387,7 @@ void TileMapEditorTilesPlugin::_stop_dragging() {
drag_type = DRAG_TYPE_NONE; drag_type = DRAG_TYPE_NONE;
} }
void TileMapEditorTilesPlugin::_update_fix_selected_and_hovered() { void RTileMapEditorTilesPlugin::_update_fix_selected_and_hovered() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
hovered_tile.source_id = TileSet::INVALID_SOURCE; hovered_tile.source_id = TileSet::INVALID_SOURCE;
@ -1455,7 +1455,7 @@ void TileMapEditorTilesPlugin::_update_fix_selected_and_hovered() {
} }
} }
void TileMapEditorTilesPlugin::_fix_invalid_tiles_in_tile_map_selection() { void RTileMapEditorTilesPlugin::_fix_invalid_tiles_in_tile_map_selection() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1474,7 +1474,7 @@ void TileMapEditorTilesPlugin::_fix_invalid_tiles_in_tile_map_selection() {
} }
} }
void TileMapEditorTilesPlugin::_update_selection_pattern_from_tilemap_selection() { void RTileMapEditorTilesPlugin::_update_selection_pattern_from_tilemap_selection() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1496,7 +1496,7 @@ void TileMapEditorTilesPlugin::_update_selection_pattern_from_tilemap_selection(
selection_pattern = tile_map->get_pattern(tile_map_layer, coords_array); selection_pattern = tile_map->get_pattern(tile_map_layer, coords_array);
} }
void TileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_tiles_selection() { void RTileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_tiles_selection() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1569,7 +1569,7 @@ void TileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_tiles_sele
CanvasItemEditor::get_singleton()->update_viewport(); CanvasItemEditor::get_singleton()->update_viewport();
} }
void TileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection() { void RTileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1593,7 +1593,7 @@ void TileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_se
CanvasItemEditor::get_singleton()->update_viewport(); CanvasItemEditor::get_singleton()->update_viewport();
} }
void TileMapEditorTilesPlugin::_update_tileset_selection_from_selection_pattern() { void RTileMapEditorTilesPlugin::_update_tileset_selection_from_selection_pattern() {
tile_set_selection.clear(); tile_set_selection.clear();
TypedArray<Vector2i> used_cells = selection_pattern->get_used_cells(); TypedArray<Vector2i> used_cells = selection_pattern->get_used_cells();
for (int i = 0; i < used_cells.size(); i++) { for (int i = 0; i < used_cells.size(); i++) {
@ -1607,7 +1607,7 @@ void TileMapEditorTilesPlugin::_update_tileset_selection_from_selection_pattern(
alternative_tiles_control->update(); alternative_tiles_control->update();
} }
void TileMapEditorTilesPlugin::_tile_atlas_control_draw() { void RTileMapEditorTilesPlugin::_tile_atlas_control_draw() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1683,7 +1683,7 @@ void TileMapEditorTilesPlugin::_tile_atlas_control_draw() {
} }
} }
void TileMapEditorTilesPlugin::_tile_atlas_control_mouse_exited() { void RTileMapEditorTilesPlugin::_tile_atlas_control_mouse_exited() {
hovered_tile.source_id = TileSet::INVALID_SOURCE; hovered_tile.source_id = TileSet::INVALID_SOURCE;
hovered_tile.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS); hovered_tile.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS);
hovered_tile.alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE; hovered_tile.alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE;
@ -1691,7 +1691,7 @@ void TileMapEditorTilesPlugin::_tile_atlas_control_mouse_exited() {
tile_atlas_control->update(); tile_atlas_control->update();
} }
void TileMapEditorTilesPlugin::_tile_atlas_control_gui_input(const Ref<InputEvent> &p_event) { void RTileMapEditorTilesPlugin::_tile_atlas_control_gui_input(const Ref<InputEvent> &p_event) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1797,7 +1797,7 @@ void TileMapEditorTilesPlugin::_tile_atlas_control_gui_input(const Ref<InputEven
} }
} }
void TileMapEditorTilesPlugin::_tile_alternatives_control_draw() { void RTileMapEditorTilesPlugin::_tile_alternatives_control_draw() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1842,7 +1842,7 @@ void TileMapEditorTilesPlugin::_tile_alternatives_control_draw() {
} }
} }
void TileMapEditorTilesPlugin::_tile_alternatives_control_mouse_exited() { void RTileMapEditorTilesPlugin::_tile_alternatives_control_mouse_exited() {
hovered_tile.source_id = TileSet::INVALID_SOURCE; hovered_tile.source_id = TileSet::INVALID_SOURCE;
hovered_tile.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS); hovered_tile.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS);
hovered_tile.alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE; hovered_tile.alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE;
@ -1850,7 +1850,7 @@ void TileMapEditorTilesPlugin::_tile_alternatives_control_mouse_exited() {
alternative_tiles_control->update(); alternative_tiles_control->update();
} }
void TileMapEditorTilesPlugin::_tile_alternatives_control_gui_input(const Ref<InputEvent> &p_event) { void RTileMapEditorTilesPlugin::_tile_alternatives_control_gui_input(const Ref<InputEvent> &p_event) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -1916,7 +1916,7 @@ void TileMapEditorTilesPlugin::_tile_alternatives_control_gui_input(const Ref<In
} }
} }
void TileMapEditorTilesPlugin::_set_tile_map_selection(const TypedArray<Vector2i> &p_selection) { void RTileMapEditorTilesPlugin::_set_tile_map_selection(const TypedArray<Vector2i> &p_selection) {
tile_map_selection.clear(); tile_map_selection.clear();
for (int i = 0; i < p_selection.size(); i++) { for (int i = 0; i < p_selection.size(); i++) {
tile_map_selection.insert(p_selection[i]); tile_map_selection.insert(p_selection[i]);
@ -1926,7 +1926,7 @@ void TileMapEditorTilesPlugin::_set_tile_map_selection(const TypedArray<Vector2i
CanvasItemEditor::get_singleton()->update_viewport(); CanvasItemEditor::get_singleton()->update_viewport();
} }
TypedArray<Vector2i> TileMapEditorTilesPlugin::_get_tile_map_selection() const { TypedArray<Vector2i> RTileMapEditorTilesPlugin::_get_tile_map_selection() const {
TypedArray<Vector2i> output; TypedArray<Vector2i> output;
for (Set<Vector2i>::Element *E = tile_map_selection.front(); E; E = E->next()) { for (Set<Vector2i>::Element *E = tile_map_selection.front(); E; E = E->next()) {
output.push_back(E->get()); output.push_back(E->get());
@ -1934,7 +1934,7 @@ TypedArray<Vector2i> TileMapEditorTilesPlugin::_get_tile_map_selection() const {
return output; return output;
} }
void TileMapEditorTilesPlugin::edit(ObjectID p_tile_map_id, int p_tile_map_layer) { void RTileMapEditorTilesPlugin::edit(ObjectID p_tile_map_id, int p_tile_map_layer) {
_stop_dragging(); // Avoids staying in a wrong drag state. _stop_dragging(); // Avoids staying in a wrong drag state.
if (tile_map_id != p_tile_map_id) { if (tile_map_id != p_tile_map_id) {
@ -1950,14 +1950,14 @@ void TileMapEditorTilesPlugin::edit(ObjectID p_tile_map_id, int p_tile_map_layer
tile_map_layer = p_tile_map_layer; tile_map_layer = p_tile_map_layer;
} }
void TileMapEditorTilesPlugin::_bind_methods() { void RTileMapEditorTilesPlugin::_bind_methods() {
ClassDB::bind_method(D_METHOD("_scene_thumbnail_done"), &TileMapEditorTilesPlugin::_scene_thumbnail_done); ClassDB::bind_method(D_METHOD("_scene_thumbnail_done"), &RTileMapEditorTilesPlugin::_scene_thumbnail_done);
ClassDB::bind_method(D_METHOD("_set_tile_map_selection", "selection"), &TileMapEditorTilesPlugin::_set_tile_map_selection); ClassDB::bind_method(D_METHOD("_set_tile_map_selection", "selection"), &RTileMapEditorTilesPlugin::_set_tile_map_selection);
ClassDB::bind_method(D_METHOD("_get_tile_map_selection"), &TileMapEditorTilesPlugin::_get_tile_map_selection); ClassDB::bind_method(D_METHOD("_get_tile_map_selection"), &RTileMapEditorTilesPlugin::_get_tile_map_selection);
} }
TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() { RTileMapEditorTilesPlugin::RTileMapEditorTilesPlugin() {
CanvasItemEditor::get_singleton()->get_viewport_control()->connect("mouse_exited", callable_mp(this, &TileMapEditorTilesPlugin::_mouse_exited_viewport)); CanvasItemEditor::get_singleton()->get_viewport_control()->connect("mouse_exited", callable_mp(this, &RTileMapEditorTilesPlugin::_mouse_exited_viewport));
// --- Shortcuts --- // --- Shortcuts ---
ED_SHORTCUT("tiles_editor/cut", TTR("Cut"), KeyModifierMask::CMD | Key::X); ED_SHORTCUT("tiles_editor/cut", TTR("Cut"), KeyModifierMask::CMD | Key::X);
@ -1983,7 +1983,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
select_tool_button->set_toggle_mode(true); select_tool_button->set_toggle_mode(true);
select_tool_button->set_button_group(tool_buttons_group); select_tool_button->set_button_group(tool_buttons_group);
select_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/selection_tool", "Selection", Key::S)); select_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/selection_tool", "Selection", Key::S));
select_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTilesPlugin::_update_toolbar)); select_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTilesPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(select_tool_button); tilemap_tiles_tools_buttons->add_child(select_tool_button);
paint_tool_button = memnew(Button); paint_tool_button = memnew(Button);
@ -1992,7 +1992,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
paint_tool_button->set_button_group(tool_buttons_group); paint_tool_button->set_button_group(tool_buttons_group);
paint_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/paint_tool", "Paint", Key::D)); paint_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/paint_tool", "Paint", Key::D));
paint_tool_button->set_tooltip(TTR("Shift: Draw line.") + "\n" + TTR("Shift+Ctrl: Draw rectangle.")); paint_tool_button->set_tooltip(TTR("Shift: Draw line.") + "\n" + TTR("Shift+Ctrl: Draw rectangle."));
paint_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTilesPlugin::_update_toolbar)); paint_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTilesPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(paint_tool_button); tilemap_tiles_tools_buttons->add_child(paint_tool_button);
line_tool_button = memnew(Button); line_tool_button = memnew(Button);
@ -2000,7 +2000,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
line_tool_button->set_toggle_mode(true); line_tool_button->set_toggle_mode(true);
line_tool_button->set_button_group(tool_buttons_group); line_tool_button->set_button_group(tool_buttons_group);
line_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/line_tool", "Line", Key::L)); line_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/line_tool", "Line", Key::L));
line_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTilesPlugin::_update_toolbar)); line_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTilesPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(line_tool_button); tilemap_tiles_tools_buttons->add_child(line_tool_button);
rect_tool_button = memnew(Button); rect_tool_button = memnew(Button);
@ -2008,7 +2008,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
rect_tool_button->set_toggle_mode(true); rect_tool_button->set_toggle_mode(true);
rect_tool_button->set_button_group(tool_buttons_group); rect_tool_button->set_button_group(tool_buttons_group);
rect_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/rect_tool", "Rect", Key::R)); rect_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/rect_tool", "Rect", Key::R));
rect_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTilesPlugin::_update_toolbar)); rect_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTilesPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(rect_tool_button); tilemap_tiles_tools_buttons->add_child(rect_tool_button);
bucket_tool_button = memnew(Button); bucket_tool_button = memnew(Button);
@ -2016,7 +2016,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
bucket_tool_button->set_toggle_mode(true); bucket_tool_button->set_toggle_mode(true);
bucket_tool_button->set_button_group(tool_buttons_group); bucket_tool_button->set_button_group(tool_buttons_group);
bucket_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/bucket_tool", "Bucket", Key::B)); bucket_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/bucket_tool", "Bucket", Key::B));
bucket_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTilesPlugin::_update_toolbar)); bucket_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTilesPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(bucket_tool_button); tilemap_tiles_tools_buttons->add_child(bucket_tool_button);
toolbar->add_child(tilemap_tiles_tools_buttons); toolbar->add_child(tilemap_tiles_tools_buttons);
@ -2060,7 +2060,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
random_tile_checkbox = memnew(CheckBox); random_tile_checkbox = memnew(CheckBox);
random_tile_checkbox->set_flat(true); random_tile_checkbox->set_flat(true);
random_tile_checkbox->set_text(TTR("Place Random Tile")); random_tile_checkbox->set_text(TTR("Place Random Tile"));
random_tile_checkbox->connect("toggled", callable_mp(this, &TileMapEditorTilesPlugin::_on_random_tile_checkbox_toggled)); random_tile_checkbox->connect("toggled", callable_mp(this, &RTileMapEditorTilesPlugin::_on_random_tile_checkbox_toggled));
tools_settings->add_child(random_tile_checkbox); tools_settings->add_child(random_tile_checkbox);
// Random tile scattering. // Random tile scattering.
@ -2075,7 +2075,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
scatter_spinbox->set_step(0.001); scatter_spinbox->set_step(0.001);
scatter_spinbox->set_tooltip(TTR("Defines the probability of painting nothing instead of a randomly selected tile.")); scatter_spinbox->set_tooltip(TTR("Defines the probability of painting nothing instead of a randomly selected tile."));
scatter_spinbox->get_line_edit()->add_theme_constant_override("minimum_character_width", 4); scatter_spinbox->get_line_edit()->add_theme_constant_override("minimum_character_width", 4);
scatter_spinbox->connect("value_changed", callable_mp(this, &TileMapEditorTilesPlugin::_on_scattering_spinbox_changed)); scatter_spinbox->connect("value_changed", callable_mp(this, &RTileMapEditorTilesPlugin::_on_scattering_spinbox_changed));
tools_settings->add_child(scatter_spinbox); tools_settings->add_child(scatter_spinbox);
_on_random_tile_checkbox_toggled(false); _on_random_tile_checkbox_toggled(false);
@ -2086,10 +2086,10 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
// --- Bottom panel tiles --- // --- Bottom panel tiles ---
tiles_bottom_panel = memnew(VBoxContainer); tiles_bottom_panel = memnew(VBoxContainer);
tiles_bottom_panel->connect("tree_entered", callable_mp(this, &TileMapEditorTilesPlugin::_update_theme)); tiles_bottom_panel->connect("tree_entered", callable_mp(this, &RTileMapEditorTilesPlugin::_update_theme));
tiles_bottom_panel->connect("theme_changed", callable_mp(this, &TileMapEditorTilesPlugin::_update_theme)); tiles_bottom_panel->connect("theme_changed", callable_mp(this, &RTileMapEditorTilesPlugin::_update_theme));
tiles_bottom_panel->connect("visibility_changed", callable_mp(this, &TileMapEditorTilesPlugin::_stop_dragging)); tiles_bottom_panel->connect("visibility_changed", callable_mp(this, &RTileMapEditorTilesPlugin::_stop_dragging));
tiles_bottom_panel->connect("visibility_changed", callable_mp(this, &TileMapEditorTilesPlugin::_tab_changed)); tiles_bottom_panel->connect("visibility_changed", callable_mp(this, &RTileMapEditorTilesPlugin::_tab_changed));
tiles_bottom_panel->set_name(TTR("Tiles")); tiles_bottom_panel->set_name(TTR("Tiles"));
missing_source_label = memnew(Label); missing_source_label = memnew(Label);
@ -2112,31 +2112,31 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
sources_list->set_stretch_ratio(0.25); sources_list->set_stretch_ratio(0.25);
sources_list->set_custom_minimum_size(Size2i(70, 0) * EDSCALE); sources_list->set_custom_minimum_size(Size2i(70, 0) * EDSCALE);
sources_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST); sources_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
sources_list->connect("item_selected", callable_mp(this, &TileMapEditorTilesPlugin::_update_fix_selected_and_hovered).unbind(1)); sources_list->connect("item_selected", callable_mp(this, &RTileMapEditorTilesPlugin::_update_fix_selected_and_hovered).unbind(1));
sources_list->connect("item_selected", callable_mp(this, &TileMapEditorTilesPlugin::_update_source_display).unbind(1)); sources_list->connect("item_selected", callable_mp(this, &RTileMapEditorTilesPlugin::_update_source_display).unbind(1));
sources_list->connect("item_selected", callable_mp(TilesEditorPlugin::get_singleton(), &TilesEditorPlugin::set_sources_lists_current)); sources_list->connect("item_selected", callable_mp(RTilesEditorPlugin::get_singleton(), &RTilesEditorPlugin::set_sources_lists_current));
sources_list->connect("visibility_changed", callable_mp(TilesEditorPlugin::get_singleton(), &TilesEditorPlugin::synchronize_sources_list), varray(sources_list)); sources_list->connect("visibility_changed", callable_mp(RTilesEditorPlugin::get_singleton(), &RTilesEditorPlugin::synchronize_sources_list), varray(sources_list));
atlas_sources_split_container->add_child(sources_list); atlas_sources_split_container->add_child(sources_list);
// Tile atlas source. // Tile atlas source.
tile_atlas_view = memnew(TileAtlasView); tile_atlas_view = memnew(RTileAtlasView);
tile_atlas_view->set_h_size_flags(Control::SIZE_EXPAND_FILL); tile_atlas_view->set_h_size_flags(Control::SIZE_EXPAND_FILL);
tile_atlas_view->set_v_size_flags(Control::SIZE_EXPAND_FILL); tile_atlas_view->set_v_size_flags(Control::SIZE_EXPAND_FILL);
tile_atlas_view->set_texture_grid_visible(false); tile_atlas_view->set_texture_grid_visible(false);
tile_atlas_view->set_tile_shape_grid_visible(false); tile_atlas_view->set_tile_shape_grid_visible(false);
tile_atlas_view->connect("transform_changed", callable_mp(TilesEditorPlugin::get_singleton(), &TilesEditorPlugin::set_atlas_view_transform)); tile_atlas_view->connect("transform_changed", callable_mp(RTilesEditorPlugin::get_singleton(), &RTilesEditorPlugin::set_atlas_view_transform));
atlas_sources_split_container->add_child(tile_atlas_view); atlas_sources_split_container->add_child(tile_atlas_view);
tile_atlas_control = memnew(Control); tile_atlas_control = memnew(Control);
tile_atlas_control->connect("draw", callable_mp(this, &TileMapEditorTilesPlugin::_tile_atlas_control_draw)); tile_atlas_control->connect("draw", callable_mp(this, &RTileMapEditorTilesPlugin::_tile_atlas_control_draw));
tile_atlas_control->connect("mouse_exited", callable_mp(this, &TileMapEditorTilesPlugin::_tile_atlas_control_mouse_exited)); tile_atlas_control->connect("mouse_exited", callable_mp(this, &RTileMapEditorTilesPlugin::_tile_atlas_control_mouse_exited));
tile_atlas_control->connect("gui_input", callable_mp(this, &TileMapEditorTilesPlugin::_tile_atlas_control_gui_input)); tile_atlas_control->connect("gui_input", callable_mp(this, &RTileMapEditorTilesPlugin::_tile_atlas_control_gui_input));
tile_atlas_view->add_control_over_atlas_tiles(tile_atlas_control); tile_atlas_view->add_control_over_atlas_tiles(tile_atlas_control);
alternative_tiles_control = memnew(Control); alternative_tiles_control = memnew(Control);
alternative_tiles_control->connect("draw", callable_mp(this, &TileMapEditorTilesPlugin::_tile_alternatives_control_draw)); alternative_tiles_control->connect("draw", callable_mp(this, &RTileMapEditorTilesPlugin::_tile_alternatives_control_draw));
alternative_tiles_control->connect("mouse_exited", callable_mp(this, &TileMapEditorTilesPlugin::_tile_alternatives_control_mouse_exited)); alternative_tiles_control->connect("mouse_exited", callable_mp(this, &RTileMapEditorTilesPlugin::_tile_alternatives_control_mouse_exited));
alternative_tiles_control->connect("gui_input", callable_mp(this, &TileMapEditorTilesPlugin::_tile_alternatives_control_gui_input)); alternative_tiles_control->connect("gui_input", callable_mp(this, &RTileMapEditorTilesPlugin::_tile_alternatives_control_gui_input));
tile_atlas_view->add_control_over_alternative_tiles(alternative_tiles_control); tile_atlas_view->add_control_over_alternative_tiles(alternative_tiles_control);
// Scenes collection source. // Scenes collection source.
@ -2145,8 +2145,8 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
scene_tiles_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); scene_tiles_list->set_v_size_flags(Control::SIZE_EXPAND_FILL);
scene_tiles_list->set_drag_forwarding(this); scene_tiles_list->set_drag_forwarding(this);
scene_tiles_list->set_select_mode(ItemList::SELECT_MULTI); scene_tiles_list->set_select_mode(ItemList::SELECT_MULTI);
scene_tiles_list->connect("multi_selected", callable_mp(this, &TileMapEditorTilesPlugin::_scenes_list_multi_selected)); scene_tiles_list->connect("multi_selected", callable_mp(this, &RTileMapEditorTilesPlugin::_scenes_list_multi_selected));
scene_tiles_list->connect("nothing_selected", callable_mp(this, &TileMapEditorTilesPlugin::_scenes_list_nothing_selected)); scene_tiles_list->connect("nothing_selected", callable_mp(this, &RTileMapEditorTilesPlugin::_scenes_list_nothing_selected));
scene_tiles_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST); scene_tiles_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
atlas_sources_split_container->add_child(scene_tiles_list); atlas_sources_split_container->add_child(scene_tiles_list);
@ -2163,7 +2163,7 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
// --- Bottom panel patterns --- // --- Bottom panel patterns ---
patterns_bottom_panel = memnew(VBoxContainer); patterns_bottom_panel = memnew(VBoxContainer);
patterns_bottom_panel->set_name(TTR("Patterns")); patterns_bottom_panel->set_name(TTR("Patterns"));
patterns_bottom_panel->connect("visibility_changed", callable_mp(this, &TileMapEditorTilesPlugin::_tab_changed)); patterns_bottom_panel->connect("visibility_changed", callable_mp(this, &RTileMapEditorTilesPlugin::_tab_changed));
int thumbnail_size = 64; int thumbnail_size = 64;
patterns_item_list = memnew(ItemList); patterns_item_list = memnew(ItemList);
@ -2173,10 +2173,10 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
patterns_item_list->set_max_text_lines(2); patterns_item_list->set_max_text_lines(2);
patterns_item_list->set_fixed_icon_size(Size2(thumbnail_size, thumbnail_size)); patterns_item_list->set_fixed_icon_size(Size2(thumbnail_size, thumbnail_size));
patterns_item_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); patterns_item_list->set_v_size_flags(Control::SIZE_EXPAND_FILL);
patterns_item_list->connect("gui_input", callable_mp(this, &TileMapEditorTilesPlugin::_patterns_item_list_gui_input)); patterns_item_list->connect("gui_input", callable_mp(this, &RTileMapEditorTilesPlugin::_patterns_item_list_gui_input));
patterns_item_list->connect("item_selected", callable_mp(this, &TileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection).unbind(1)); patterns_item_list->connect("item_selected", callable_mp(this, &RTileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection).unbind(1));
patterns_item_list->connect("item_activated", callable_mp(this, &TileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection)); patterns_item_list->connect("item_activated", callable_mp(this, &RTileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection));
patterns_item_list->connect("nothing_selected", callable_mp(this, &TileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection)); patterns_item_list->connect("nothing_selected", callable_mp(this, &RTileMapEditorTilesPlugin::_update_selection_pattern_from_tileset_pattern_selection));
patterns_bottom_panel->add_child(patterns_item_list); patterns_bottom_panel->add_child(patterns_item_list);
patterns_help_label = memnew(Label); patterns_help_label = memnew(Label);
@ -2188,16 +2188,16 @@ TileMapEditorTilesPlugin::TileMapEditorTilesPlugin() {
_update_source_display(); _update_source_display();
} }
TileMapEditorTilesPlugin::~TileMapEditorTilesPlugin() { RTileMapEditorTilesPlugin::~RTileMapEditorTilesPlugin() {
} }
void TileMapEditorTerrainsPlugin::tile_set_changed() { void RTileMapEditorTerrainsPlugin::tile_set_changed() {
_update_terrains_cache(); _update_terrains_cache();
_update_terrains_tree(); _update_terrains_tree();
_update_tiles_list(); _update_tiles_list();
} }
void TileMapEditorTerrainsPlugin::_update_toolbar() { void RTileMapEditorTerrainsPlugin::_update_toolbar() {
// Hide all settings. // Hide all settings.
for (int i = 0; i < tools_settings->get_child_count(); i++) { for (int i = 0; i < tools_settings->get_child_count(); i++) {
Object::cast_to<CanvasItem>(tools_settings->get_child(i))->hide(); Object::cast_to<CanvasItem>(tools_settings->get_child(i))->hide();
@ -2231,13 +2231,13 @@ void TileMapEditorTerrainsPlugin::_update_toolbar() {
} }
} }
Vector<TileMapEditorPlugin::TabData> TileMapEditorTerrainsPlugin::get_tabs() const { Vector<RTileMapEditorPlugin::TabData> RTileMapEditorTerrainsPlugin::get_tabs() const {
Vector<TileMapEditorPlugin::TabData> tabs; Vector<RTileMapEditorPlugin::TabData> tabs;
tabs.push_back({ toolbar, main_vbox_container }); tabs.push_back({ toolbar, main_vbox_container });
return tabs; return tabs;
} }
Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_terrains(const Map<Vector2i, TileSet::TerrainsPattern> &p_to_paint, int p_terrain_set) const { Map<Vector2i, TileMapCell> RTileMapEditorTerrainsPlugin::_draw_terrains(const Map<Vector2i, TileSet::TerrainsPattern> &p_to_paint, int p_terrain_set) const {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Map<Vector2i, TileMapCell>(); return Map<Vector2i, TileMapCell>();
@ -2350,7 +2350,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_terrains(const Map
return output; return output;
} }
Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_line(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) { Map<Vector2i, TileMapCell> RTileMapEditorTerrainsPlugin::_draw_line(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Map<Vector2i, TileMapCell>(); return Map<Vector2i, TileMapCell>();
@ -2368,7 +2368,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_line(Vector2i p_st
terrains_pattern = selected_terrains_pattern; terrains_pattern = selected_terrains_pattern;
} }
Vector<Vector2i> line = TileMapEditor::get_line(tile_map, p_start_cell, p_end_cell); Vector<Vector2i> line = RTileMapEditor::get_line(tile_map, p_start_cell, p_end_cell);
Map<Vector2i, TileSet::TerrainsPattern> to_draw; Map<Vector2i, TileSet::TerrainsPattern> to_draw;
for (int i = 0; i < line.size(); i++) { for (int i = 0; i < line.size(); i++) {
to_draw[line[i]] = terrains_pattern; to_draw[line[i]] = terrains_pattern;
@ -2376,7 +2376,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_line(Vector2i p_st
return _draw_terrains(to_draw, selected_terrain_set); return _draw_terrains(to_draw, selected_terrain_set);
} }
Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_rect(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) { Map<Vector2i, TileMapCell> RTileMapEditorTerrainsPlugin::_draw_rect(Vector2i p_start_cell, Vector2i p_end_cell, bool p_erase) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Map<Vector2i, TileMapCell>(); return Map<Vector2i, TileMapCell>();
@ -2408,7 +2408,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_rect(Vector2i p_st
return _draw_terrains(to_draw, selected_terrain_set); return _draw_terrains(to_draw, selected_terrain_set);
} }
Set<Vector2i> TileMapEditorTerrainsPlugin::_get_cells_for_bucket_fill(Vector2i p_coords, bool p_contiguous) { Set<Vector2i> RTileMapEditorTerrainsPlugin::_get_cells_for_bucket_fill(Vector2i p_coords, bool p_contiguous) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Set<Vector2i>(); return Set<Vector2i>();
@ -2519,7 +2519,7 @@ Set<Vector2i> TileMapEditorTerrainsPlugin::_get_cells_for_bucket_fill(Vector2i p
return output; return output;
} }
Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_bucket_fill(Vector2i p_coords, bool p_contiguous, bool p_erase) { Map<Vector2i, TileMapCell> RTileMapEditorTerrainsPlugin::_draw_bucket_fill(Vector2i p_coords, bool p_contiguous, bool p_erase) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return Map<Vector2i, TileMapCell>(); return Map<Vector2i, TileMapCell>();
@ -2546,7 +2546,7 @@ Map<Vector2i, TileMapCell> TileMapEditorTerrainsPlugin::_draw_bucket_fill(Vector
return _draw_terrains(to_draw, selected_terrain_set); return _draw_terrains(to_draw, selected_terrain_set);
} }
void TileMapEditorTerrainsPlugin::_stop_dragging() { void RTileMapEditorTerrainsPlugin::_stop_dragging() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -2672,12 +2672,12 @@ void TileMapEditorTerrainsPlugin::_stop_dragging() {
drag_type = DRAG_TYPE_NONE; drag_type = DRAG_TYPE_NONE;
} }
void TileMapEditorTerrainsPlugin::_mouse_exited_viewport() { void RTileMapEditorTerrainsPlugin::_mouse_exited_viewport() {
has_mouse = false; has_mouse = false;
CanvasItemEditor::get_singleton()->update_viewport(); CanvasItemEditor::get_singleton()->update_viewport();
} }
void TileMapEditorTerrainsPlugin::_update_selection() { void RTileMapEditorTerrainsPlugin::_update_selection() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -2709,7 +2709,7 @@ void TileMapEditorTerrainsPlugin::_update_selection() {
} }
} }
bool TileMapEditorTerrainsPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p_event) { bool RTileMapEditorTerrainsPlugin::forward_canvas_gui_input(const Ref<InputEvent> &p_event) {
if (!main_vbox_container->is_visible_in_tree()) { if (!main_vbox_container->is_visible_in_tree()) {
// If the bottom editor is not visible, we ignore inputs. // If the bottom editor is not visible, we ignore inputs.
return false; return false;
@ -2816,7 +2816,7 @@ bool TileMapEditorTerrainsPlugin::forward_canvas_gui_input(const Ref<InputEvent>
drag_type = DRAG_TYPE_BUCKET; drag_type = DRAG_TYPE_BUCKET;
drag_start_mouse_pos = mpos; drag_start_mouse_pos = mpos;
drag_modified.clear(); drag_modified.clear();
Vector<Vector2i> line = TileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_last_mouse_pos), tile_map->world_to_map(mpos)); Vector<Vector2i> line = RTileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_last_mouse_pos), tile_map->world_to_map(mpos));
for (int i = 0; i < line.size(); i++) { for (int i = 0; i < line.size(); i++) {
if (!drag_modified.has(line[i])) { if (!drag_modified.has(line[i])) {
Map<Vector2i, TileMapCell> to_draw = _draw_bucket_fill(line[i], bucket_contiguous_checkbox->is_pressed(), drag_erasing); Map<Vector2i, TileMapCell> to_draw = _draw_bucket_fill(line[i], bucket_contiguous_checkbox->is_pressed(), drag_erasing);
@ -2850,7 +2850,7 @@ bool TileMapEditorTerrainsPlugin::forward_canvas_gui_input(const Ref<InputEvent>
return false; return false;
} }
void TileMapEditorTerrainsPlugin::forward_canvas_draw_over_viewport(Control *p_overlay) { void RTileMapEditorTerrainsPlugin::forward_canvas_draw_over_viewport(Control *p_overlay) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -2899,7 +2899,7 @@ void TileMapEditorTerrainsPlugin::forward_canvas_draw_over_viewport(Control *p_o
preview.insert(tile_map->world_to_map(drag_last_mouse_pos)); preview.insert(tile_map->world_to_map(drag_last_mouse_pos));
} else if (drag_type == DRAG_TYPE_LINE) { } else if (drag_type == DRAG_TYPE_LINE) {
// Preview for a line. // Preview for a line.
Vector<Vector2i> line = TileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_start_mouse_pos), tile_map->world_to_map(drag_last_mouse_pos)); Vector<Vector2i> line = RTileMapEditor::get_line(tile_map, tile_map->world_to_map(drag_start_mouse_pos), tile_map->world_to_map(drag_last_mouse_pos));
for (int i = 0; i < line.size(); i++) { for (int i = 0; i < line.size(); i++) {
preview.insert(line[i]); preview.insert(line[i]);
} }
@ -2979,7 +2979,7 @@ void TileMapEditorTerrainsPlugin::forward_canvas_draw_over_viewport(Control *p_o
} }
} }
void TileMapEditorTerrainsPlugin::_update_terrains_cache() { void RTileMapEditorTerrainsPlugin::_update_terrains_cache() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -3038,7 +3038,7 @@ void TileMapEditorTerrainsPlugin::_update_terrains_cache() {
} }
} }
void TileMapEditorTerrainsPlugin::_update_terrains_tree() { void RTileMapEditorTerrainsPlugin::_update_terrains_tree() {
terrains_tree->clear(); terrains_tree->clear();
terrains_tree->create_item(); terrains_tree->create_item();
@ -3086,7 +3086,7 @@ void TileMapEditorTerrainsPlugin::_update_terrains_tree() {
} }
} }
void TileMapEditorTerrainsPlugin::_update_tiles_list() { void RTileMapEditorTerrainsPlugin::_update_tiles_list() {
terrains_tile_list->clear(); terrains_tile_list->clear();
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
@ -3172,7 +3172,7 @@ void TileMapEditorTerrainsPlugin::_update_tiles_list() {
} }
} }
void TileMapEditorTerrainsPlugin::_update_theme() { void RTileMapEditorTerrainsPlugin::_update_theme() {
paint_tool_button->set_icon(main_vbox_container->get_theme_icon(SNAME("Edit"), SNAME("EditorIcons"))); paint_tool_button->set_icon(main_vbox_container->get_theme_icon(SNAME("Edit"), SNAME("EditorIcons")));
line_tool_button->set_icon(main_vbox_container->get_theme_icon(SNAME("CurveLinear"), SNAME("EditorIcons"))); line_tool_button->set_icon(main_vbox_container->get_theme_icon(SNAME("CurveLinear"), SNAME("EditorIcons")));
rect_tool_button->set_icon(main_vbox_container->get_theme_icon(SNAME("Rectangle"), SNAME("EditorIcons"))); rect_tool_button->set_icon(main_vbox_container->get_theme_icon(SNAME("Rectangle"), SNAME("EditorIcons")));
@ -3182,7 +3182,7 @@ void TileMapEditorTerrainsPlugin::_update_theme() {
erase_button->set_icon(main_vbox_container->get_theme_icon(SNAME("Eraser"), SNAME("EditorIcons"))); erase_button->set_icon(main_vbox_container->get_theme_icon(SNAME("Eraser"), SNAME("EditorIcons")));
} }
void TileMapEditorTerrainsPlugin::edit(ObjectID p_tile_map_id, int p_tile_map_layer) { void RTileMapEditorTerrainsPlugin::edit(ObjectID p_tile_map_id, int p_tile_map_layer) {
_stop_dragging(); // Avoids staying in a wrong drag state. _stop_dragging(); // Avoids staying in a wrong drag state.
tile_map_id = p_tile_map_id; tile_map_id = p_tile_map_id;
@ -3193,10 +3193,10 @@ void TileMapEditorTerrainsPlugin::edit(ObjectID p_tile_map_id, int p_tile_map_la
_update_tiles_list(); _update_tiles_list();
} }
TileMapEditorTerrainsPlugin::TileMapEditorTerrainsPlugin() { RTileMapEditorTerrainsPlugin::RTileMapEditorTerrainsPlugin() {
main_vbox_container = memnew(VBoxContainer); main_vbox_container = memnew(VBoxContainer);
main_vbox_container->connect("tree_entered", callable_mp(this, &TileMapEditorTerrainsPlugin::_update_theme)); main_vbox_container->connect("tree_entered", callable_mp(this, &RTileMapEditorTerrainsPlugin::_update_theme));
main_vbox_container->connect("theme_changed", callable_mp(this, &TileMapEditorTerrainsPlugin::_update_theme)); main_vbox_container->connect("theme_changed", callable_mp(this, &RTileMapEditorTerrainsPlugin::_update_theme));
main_vbox_container->set_name("Terrains"); main_vbox_container->set_name("Terrains");
HSplitContainer *tilemap_tab_terrains = memnew(HSplitContainer); HSplitContainer *tilemap_tab_terrains = memnew(HSplitContainer);
@ -3210,7 +3210,7 @@ TileMapEditorTerrainsPlugin::TileMapEditorTerrainsPlugin() {
terrains_tree->set_custom_minimum_size(Size2i(70, 0) * EDSCALE); terrains_tree->set_custom_minimum_size(Size2i(70, 0) * EDSCALE);
terrains_tree->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST); terrains_tree->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
terrains_tree->set_hide_root(true); terrains_tree->set_hide_root(true);
terrains_tree->connect("item_selected", callable_mp(this, &TileMapEditorTerrainsPlugin::_update_tiles_list)); terrains_tree->connect("item_selected", callable_mp(this, &RTileMapEditorTerrainsPlugin::_update_tiles_list));
tilemap_tab_terrains->add_child(terrains_tree); tilemap_tab_terrains->add_child(terrains_tree);
terrains_tile_list = memnew(ItemList); terrains_tile_list = memnew(ItemList);
@ -3234,7 +3234,7 @@ TileMapEditorTerrainsPlugin::TileMapEditorTerrainsPlugin() {
paint_tool_button->set_button_group(tool_buttons_group); paint_tool_button->set_button_group(tool_buttons_group);
paint_tool_button->set_pressed(true); paint_tool_button->set_pressed(true);
paint_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/paint_tool", "Paint", Key::D)); paint_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/paint_tool", "Paint", Key::D));
paint_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTerrainsPlugin::_update_toolbar)); paint_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTerrainsPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(paint_tool_button); tilemap_tiles_tools_buttons->add_child(paint_tool_button);
line_tool_button = memnew(Button); line_tool_button = memnew(Button);
@ -3242,7 +3242,7 @@ TileMapEditorTerrainsPlugin::TileMapEditorTerrainsPlugin() {
line_tool_button->set_toggle_mode(true); line_tool_button->set_toggle_mode(true);
line_tool_button->set_button_group(tool_buttons_group); line_tool_button->set_button_group(tool_buttons_group);
line_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/line_tool", "Line", Key::L)); line_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/line_tool", "Line", Key::L));
line_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTerrainsPlugin::_update_toolbar)); line_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTerrainsPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(line_tool_button); tilemap_tiles_tools_buttons->add_child(line_tool_button);
rect_tool_button = memnew(Button); rect_tool_button = memnew(Button);
@ -3250,7 +3250,7 @@ TileMapEditorTerrainsPlugin::TileMapEditorTerrainsPlugin() {
rect_tool_button->set_toggle_mode(true); rect_tool_button->set_toggle_mode(true);
rect_tool_button->set_button_group(tool_buttons_group); rect_tool_button->set_button_group(tool_buttons_group);
rect_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/rect_tool", "Rect", Key::R)); rect_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/rect_tool", "Rect", Key::R));
rect_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTerrainsPlugin::_update_toolbar)); rect_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTerrainsPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(rect_tool_button); tilemap_tiles_tools_buttons->add_child(rect_tool_button);
bucket_tool_button = memnew(Button); bucket_tool_button = memnew(Button);
@ -3258,7 +3258,7 @@ TileMapEditorTerrainsPlugin::TileMapEditorTerrainsPlugin() {
bucket_tool_button->set_toggle_mode(true); bucket_tool_button->set_toggle_mode(true);
bucket_tool_button->set_button_group(tool_buttons_group); bucket_tool_button->set_button_group(tool_buttons_group);
bucket_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/bucket_tool", "Bucket", Key::B)); bucket_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/bucket_tool", "Bucket", Key::B));
bucket_tool_button->connect("pressed", callable_mp(this, &TileMapEditorTerrainsPlugin::_update_toolbar)); bucket_tool_button->connect("pressed", callable_mp(this, &RTileMapEditorTerrainsPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(bucket_tool_button); tilemap_tiles_tools_buttons->add_child(bucket_tool_button);
toolbar->add_child(tilemap_tiles_tools_buttons); toolbar->add_child(tilemap_tiles_tools_buttons);
@ -3298,10 +3298,10 @@ TileMapEditorTerrainsPlugin::TileMapEditorTerrainsPlugin() {
tools_settings->add_child(bucket_contiguous_checkbox); tools_settings->add_child(bucket_contiguous_checkbox);
} }
TileMapEditorTerrainsPlugin::~TileMapEditorTerrainsPlugin() { RTileMapEditorTerrainsPlugin::~RTileMapEditorTerrainsPlugin() {
} }
void TileMapEditor::_notification(int p_what) { void RTileMapEditor::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_TREE: case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_THEME_CHANGED:
@ -3337,11 +3337,11 @@ void TileMapEditor::_notification(int p_what) {
} }
} }
void TileMapEditor::_on_grid_toggled(bool p_pressed) { void RTileMapEditor::_on_grid_toggled(bool p_pressed) {
EditorSettings::get_singleton()->set("editors/tiles_editor/display_grid", p_pressed); EditorSettings::get_singleton()->set("editors/tiles_editor/display_grid", p_pressed);
} }
void TileMapEditor::_layers_selection_button_draw() { void RTileMapEditor::_layers_selection_button_draw() {
if (!has_theme_icon(SNAME("arrow"), SNAME("OptionButton"))) { if (!has_theme_icon(SNAME("arrow"), SNAME("OptionButton"))) {
return; return;
} }
@ -3385,7 +3385,7 @@ void TileMapEditor::_layers_selection_button_draw() {
arrow->draw_rect(ci, dst_rect, false, clr); arrow->draw_rect(ci, dst_rect, false, clr);
} }
void TileMapEditor::_layers_selection_button_pressed() { void RTileMapEditor::_layers_selection_button_pressed() {
if (!layers_selection_popup->is_visible()) { if (!layers_selection_popup->is_visible()) {
Size2 size = layers_selection_popup->get_contents_minimum_size(); Size2 size = layers_selection_popup->get_contents_minimum_size();
size.x = MAX(size.x, layers_selection_button->get_size().x); size.x = MAX(size.x, layers_selection_button->get_size().x);
@ -3397,12 +3397,12 @@ void TileMapEditor::_layers_selection_button_pressed() {
} }
} }
void TileMapEditor::_layers_selection_id_pressed(int p_id) { void RTileMapEditor::_layers_selection_id_pressed(int p_id) {
tile_map_layer = p_id; tile_map_layer = p_id;
_update_layers_selection(); _update_layers_selection();
} }
void TileMapEditor::_advanced_menu_button_id_pressed(int p_id) { void RTileMapEditor::_advanced_menu_button_id_pressed(int p_id) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -3435,7 +3435,7 @@ void TileMapEditor::_advanced_menu_button_id_pressed(int p_id) {
} }
} }
void TileMapEditor::_update_bottom_panel() { void RTileMapEditor::_update_bottom_panel() {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -3452,7 +3452,7 @@ void TileMapEditor::_update_bottom_panel() {
} }
} }
Vector<Vector2i> TileMapEditor::get_line(TileMap *p_tile_map, Vector2i p_from_cell, Vector2i p_to_cell) { Vector<Vector2i> RTileMapEditor::get_line(TileMap *p_tile_map, Vector2i p_from_cell, Vector2i p_to_cell) {
ERR_FAIL_COND_V(!p_tile_map, Vector<Vector2i>()); ERR_FAIL_COND_V(!p_tile_map, Vector<Vector2i>());
Ref<TileSet> tile_set = p_tile_map->get_tileset(); Ref<TileSet> tile_set = p_tile_map->get_tileset();
@ -3525,11 +3525,11 @@ Vector<Vector2i> TileMapEditor::get_line(TileMap *p_tile_map, Vector2i p_from_ce
} }
} }
void TileMapEditor::_tile_map_changed() { void RTileMapEditor::_tile_map_changed() {
tileset_changed_needs_update = true; tileset_changed_needs_update = true;
} }
void TileMapEditor::_tab_changed(int p_tab_id) { void RTileMapEditor::_tab_changed(int p_tab_id) {
// Make the plugin edit the correct tilemap. // Make the plugin edit the correct tilemap.
tabs_plugins[tabs_bar->get_current_tab()]->edit(tile_map_id, tile_map_layer); tabs_plugins[tabs_bar->get_current_tab()]->edit(tile_map_id, tile_map_layer);
@ -3553,7 +3553,7 @@ void TileMapEditor::_tab_changed(int p_tab_id) {
CanvasItemEditor::get_singleton()->update_viewport(); CanvasItemEditor::get_singleton()->update_viewport();
} }
void TileMapEditor::_layers_select_next_or_previous(bool p_next) { void RTileMapEditor::_layers_select_next_or_previous(bool p_next) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -3580,7 +3580,7 @@ void TileMapEditor::_layers_select_next_or_previous(bool p_next) {
_update_layers_selection(); _update_layers_selection();
} }
void TileMapEditor::_update_layers_selection() { void RTileMapEditor::_update_layers_selection() {
layers_selection_popup->clear(); layers_selection_popup->clear();
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
@ -3639,7 +3639,7 @@ void TileMapEditor::_update_layers_selection() {
tabs_plugins[tabs_bar->get_current_tab()]->edit(tile_map_id, tile_map_layer); tabs_plugins[tabs_bar->get_current_tab()]->edit(tile_map_id, tile_map_layer);
} }
void TileMapEditor::_move_tile_map_array_element(Object *p_undo_redo, Object *p_edited, String p_array_prefix, int p_from_index, int p_to_pos) { void RTileMapEditor::_move_tile_map_array_element(Object *p_undo_redo, Object *p_edited, String p_array_prefix, int p_from_index, int p_to_pos) {
UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo); UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo);
ERR_FAIL_COND(!undo_redo); ERR_FAIL_COND(!undo_redo);
@ -3711,7 +3711,7 @@ void TileMapEditor::_move_tile_map_array_element(Object *p_undo_redo, Object *p_
} }
} }
bool TileMapEditor::forward_canvas_gui_input(const Ref<InputEvent> &p_event) { bool RTileMapEditor::forward_canvas_gui_input(const Ref<InputEvent> &p_event) {
if (ED_IS_SHORTCUT("tiles_editor/select_next_layer", p_event) && p_event->is_pressed()) { if (ED_IS_SHORTCUT("tiles_editor/select_next_layer", p_event) && p_event->is_pressed()) {
_layers_select_next_or_previous(true); _layers_select_next_or_previous(true);
return true; return true;
@ -3725,7 +3725,7 @@ bool TileMapEditor::forward_canvas_gui_input(const Ref<InputEvent> &p_event) {
return tabs_plugins[tabs_bar->get_current_tab()]->forward_canvas_gui_input(p_event); return tabs_plugins[tabs_bar->get_current_tab()]->forward_canvas_gui_input(p_event);
} }
void TileMapEditor::forward_canvas_draw_over_viewport(Control *p_overlay) { void RTileMapEditor::forward_canvas_draw_over_viewport(Control *p_overlay) {
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (!tile_map) { if (!tile_map) {
return; return;
@ -3860,7 +3860,7 @@ void TileMapEditor::forward_canvas_draw_over_viewport(Control *p_overlay) {
tabs_plugins[tabs_bar->get_current_tab()]->forward_canvas_draw_over_viewport(p_overlay); tabs_plugins[tabs_bar->get_current_tab()]->forward_canvas_draw_over_viewport(p_overlay);
} }
void TileMapEditor::edit(TileMap *p_tile_map) { void RTileMapEditor::edit(TileMap *p_tile_map) {
if (p_tile_map && p_tile_map->get_instance_id() == tile_map_id) { if (p_tile_map && p_tile_map->get_instance_id() == tile_map_id) {
return; return;
} }
@ -3873,7 +3873,7 @@ void TileMapEditor::edit(TileMap *p_tile_map) {
} }
// Disconnect to changes. // Disconnect to changes.
tile_map->disconnect("changed", callable_mp(this, &TileMapEditor::_tile_map_changed)); tile_map->disconnect("changed", callable_mp(this, &RTileMapEditor::_tile_map_changed));
} }
if (p_tile_map) { if (p_tile_map) {
@ -3881,8 +3881,8 @@ void TileMapEditor::edit(TileMap *p_tile_map) {
tile_map_id = p_tile_map->get_instance_id(); tile_map_id = p_tile_map->get_instance_id();
tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
// Connect to changes. // Connect to changes.
if (!tile_map->is_connected("changed", callable_mp(this, &TileMapEditor::_tile_map_changed))) { if (!tile_map->is_connected("changed", callable_mp(this, &RTileMapEditor::_tile_map_changed))) {
tile_map->connect("changed", callable_mp(this, &TileMapEditor::_tile_map_changed)); tile_map->connect("changed", callable_mp(this, &RTileMapEditor::_tile_map_changed));
} }
} else { } else {
tile_map_id = ObjectID(); tile_map_id = ObjectID();
@ -3896,7 +3896,7 @@ void TileMapEditor::edit(TileMap *p_tile_map) {
_tile_map_changed(); _tile_map_changed();
} }
TileMapEditor::TileMapEditor() { RTileMapEditor::RTileMapEditor() {
set_process_internal(true); set_process_internal(true);
// Shortcuts. // Shortcuts.
@ -3904,21 +3904,21 @@ TileMapEditor::TileMapEditor() {
ED_SHORTCUT("tiles_editor/select_previous_layer", TTR("Select Previous Tile Map Layer"), Key::PAGEDOWN); ED_SHORTCUT("tiles_editor/select_previous_layer", TTR("Select Previous Tile Map Layer"), Key::PAGEDOWN);
// TileMap editor plugins // TileMap editor plugins
tile_map_editor_plugins.push_back(memnew(TileMapEditorTilesPlugin)); tile_map_editor_plugins.push_back(memnew(RTileMapEditorTilesPlugin));
tile_map_editor_plugins.push_back(memnew(TileMapEditorTerrainsPlugin)); tile_map_editor_plugins.push_back(memnew(RTileMapEditorTerrainsPlugin));
// TabBar. // TabBar.
tabs_bar = memnew(TabBar); tabs_bar = memnew(TabBar);
tabs_bar->set_clip_tabs(false); tabs_bar->set_clip_tabs(false);
for (int plugin_index = 0; plugin_index < tile_map_editor_plugins.size(); plugin_index++) { for (int plugin_index = 0; plugin_index < tile_map_editor_plugins.size(); plugin_index++) {
Vector<TileMapEditorPlugin::TabData> tabs_vector = tile_map_editor_plugins[plugin_index]->get_tabs(); Vector<RTileMapEditorPlugin::TabData> tabs_vector = tile_map_editor_plugins[plugin_index]->get_tabs();
for (int tab_index = 0; tab_index < tabs_vector.size(); tab_index++) { for (int tab_index = 0; tab_index < tabs_vector.size(); tab_index++) {
tabs_bar->add_tab(tabs_vector[tab_index].panel->get_name()); tabs_bar->add_tab(tabs_vector[tab_index].panel->get_name());
tabs_data.push_back(tabs_vector[tab_index]); tabs_data.push_back(tabs_vector[tab_index]);
tabs_plugins.push_back(tile_map_editor_plugins[plugin_index]); tabs_plugins.push_back(tile_map_editor_plugins[plugin_index]);
} }
} }
tabs_bar->connect("tab_changed", callable_mp(this, &TileMapEditor::_tab_changed)); tabs_bar->connect("tab_changed", callable_mp(this, &RTileMapEditor::_tab_changed));
// --- TileMap toolbar --- // --- TileMap toolbar ---
tile_map_toolbar = memnew(HBoxContainer); tile_map_toolbar = memnew(HBoxContainer);
@ -3943,13 +3943,13 @@ TileMapEditor::TileMapEditor() {
// Layer selector. // Layer selector.
layers_selection_popup = memnew(PopupMenu); layers_selection_popup = memnew(PopupMenu);
layers_selection_popup->connect("id_pressed", callable_mp(this, &TileMapEditor::_layers_selection_id_pressed)); layers_selection_popup->connect("id_pressed", callable_mp(this, &RTileMapEditor::_layers_selection_id_pressed));
layers_selection_popup->set_close_on_parent_focus(false); layers_selection_popup->set_close_on_parent_focus(false);
layers_selection_button = memnew(Button); layers_selection_button = memnew(Button);
layers_selection_button->set_toggle_mode(true); layers_selection_button->set_toggle_mode(true);
layers_selection_button->connect("draw", callable_mp(this, &TileMapEditor::_layers_selection_button_draw)); layers_selection_button->connect("draw", callable_mp(this, &RTileMapEditor::_layers_selection_button_draw));
layers_selection_button->connect("pressed", callable_mp(this, &TileMapEditor::_layers_selection_button_pressed)); layers_selection_button->connect("pressed", callable_mp(this, &RTileMapEditor::_layers_selection_button_pressed));
layers_selection_button->connect("hidden", callable_mp((Window *)layers_selection_popup, &Popup::hide)); layers_selection_button->connect("hidden", callable_mp((Window *)layers_selection_popup, &Popup::hide));
layers_selection_button->set_tooltip(TTR("Tile Map Layer")); layers_selection_button->set_tooltip(TTR("Tile Map Layer"));
layers_selection_button->add_child(layers_selection_popup); layers_selection_button->add_child(layers_selection_popup);
@ -3959,7 +3959,7 @@ TileMapEditor::TileMapEditor() {
toogle_highlight_selected_layer_button->set_flat(true); toogle_highlight_selected_layer_button->set_flat(true);
toogle_highlight_selected_layer_button->set_toggle_mode(true); toogle_highlight_selected_layer_button->set_toggle_mode(true);
toogle_highlight_selected_layer_button->set_pressed(true); toogle_highlight_selected_layer_button->set_pressed(true);
toogle_highlight_selected_layer_button->connect("pressed", callable_mp(this, &TileMapEditor::_update_layers_selection)); toogle_highlight_selected_layer_button->connect("pressed", callable_mp(this, &RTileMapEditor::_update_layers_selection));
toogle_highlight_selected_layer_button->set_tooltip(TTR("Highlight Selected TileMap Layer")); toogle_highlight_selected_layer_button->set_tooltip(TTR("Highlight Selected TileMap Layer"));
tile_map_toolbar->add_child(toogle_highlight_selected_layer_button); tile_map_toolbar->add_child(toogle_highlight_selected_layer_button);
@ -3970,14 +3970,14 @@ TileMapEditor::TileMapEditor() {
toggle_grid_button->set_flat(true); toggle_grid_button->set_flat(true);
toggle_grid_button->set_toggle_mode(true); toggle_grid_button->set_toggle_mode(true);
toggle_grid_button->set_tooltip(TTR("Toggle grid visibility.")); toggle_grid_button->set_tooltip(TTR("Toggle grid visibility."));
toggle_grid_button->connect("toggled", callable_mp(this, &TileMapEditor::_on_grid_toggled)); toggle_grid_button->connect("toggled", callable_mp(this, &RTileMapEditor::_on_grid_toggled));
tile_map_toolbar->add_child(toggle_grid_button); tile_map_toolbar->add_child(toggle_grid_button);
// Advanced settings menu button. // Advanced settings menu button.
advanced_menu_button = memnew(MenuButton); advanced_menu_button = memnew(MenuButton);
advanced_menu_button->set_flat(true); advanced_menu_button->set_flat(true);
advanced_menu_button->get_popup()->add_item(TTR("Automatically Replace Tiles with Proxies")); advanced_menu_button->get_popup()->add_item(TTR("Automatically Replace Tiles with Proxies"));
advanced_menu_button->get_popup()->connect("id_pressed", callable_mp(this, &TileMapEditor::_advanced_menu_button_id_pressed)); advanced_menu_button->get_popup()->connect("id_pressed", callable_mp(this, &RTileMapEditor::_advanced_menu_button_id_pressed));
tile_map_toolbar->add_child(advanced_menu_button); tile_map_toolbar->add_child(advanced_menu_button);
missing_tileset_label = memnew(Label); missing_tileset_label = memnew(Label);
@ -3999,10 +3999,10 @@ TileMapEditor::TileMapEditor() {
_tab_changed(0); _tab_changed(0);
// Registers UndoRedo inspector callback. // Registers UndoRedo inspector callback.
EditorNode::get_singleton()->get_editor_data().add_move_array_element_function(SNAME("TileMap"), callable_mp(this, &TileMapEditor::_move_tile_map_array_element)); EditorNode::get_singleton()->get_editor_data().add_move_array_element_function(SNAME("TileMap"), callable_mp(this, &RTileMapEditor::_move_tile_map_array_element));
} }
TileMapEditor::~TileMapEditor() { RTileMapEditor::~RTileMapEditor() {
for (int i = 0; i < tile_map_editor_plugins.size(); i++) { for (int i = 0; i < tile_map_editor_plugins.size(); i++) {
memdelete(tile_map_editor_plugins[i]); memdelete(tile_map_editor_plugins[i]);
} }

38
tile_editor/tile_map_editor.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILE_MAP_EDITOR_H #ifndef RTILE_MAP_EDITOR_H
#define TILE_MAP_EDITOR_H #define RTILE_MAP_EDITOR_H
#include "tile_atlas_view.h" #include "tile_atlas_view.h"
@ -40,7 +40,7 @@
#include "scene/gui/box_container.h" #include "scene/gui/box_container.h"
#include "scene/gui/tab_bar.h" #include "scene/gui/tab_bar.h"
class TileMapEditorPlugin : public Object { class RTileMapEditorPlugin : public Object {
public: public:
struct TabData { struct TabData {
Control *toolbar; Control *toolbar;
@ -57,8 +57,8 @@ public:
virtual void edit(ObjectID p_tile_map_id, int p_tile_map_layer){}; virtual void edit(ObjectID p_tile_map_id, int p_tile_map_layer){};
}; };
class TileMapEditorTilesPlugin : public TileMapEditorPlugin { class RTileMapEditorTilesPlugin : public RTileMapEditorPlugin {
GDCLASS(TileMapEditorTilesPlugin, TileMapEditorPlugin); GDCLASS(RTileMapEditorTilesPlugin, RTileMapEditorPlugin);
private: private:
UndoRedo *undo_redo = EditorNode::get_undo_redo(); UndoRedo *undo_redo = EditorNode::get_undo_redo();
@ -153,7 +153,7 @@ private:
// Atlas sources. // Atlas sources.
TileMapCell hovered_tile; TileMapCell hovered_tile;
TileAtlasView *tile_atlas_view; RTileAtlasView *tile_atlas_view;
HSplitContainer *atlas_sources_split_container; HSplitContainer *atlas_sources_split_container;
bool tile_set_dragging_selection = false; bool tile_set_dragging_selection = false;
@ -202,12 +202,12 @@ public:
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override; virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override;
virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override; virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override;
TileMapEditorTilesPlugin(); RTileMapEditorTilesPlugin();
~TileMapEditorTilesPlugin(); ~RTileMapEditorTilesPlugin();
}; };
class TileMapEditorTerrainsPlugin : public TileMapEditorPlugin { class RTileMapEditorTerrainsPlugin : public RTileMapEditorPlugin {
GDCLASS(TileMapEditorTerrainsPlugin, TileMapEditorPlugin); GDCLASS(RTileMapEditorTerrainsPlugin, RTileMapEditorPlugin);
private: private:
UndoRedo *undo_redo = EditorNode::get_undo_redo(); UndoRedo *undo_redo = EditorNode::get_undo_redo();
@ -288,12 +288,12 @@ public:
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override; virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override;
virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override; virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override;
TileMapEditorTerrainsPlugin(); RTileMapEditorTerrainsPlugin();
~TileMapEditorTerrainsPlugin(); ~RTileMapEditorTerrainsPlugin();
}; };
class TileMapEditor : public VBoxContainer { class RTileMapEditor : public VBoxContainer {
GDCLASS(TileMapEditor, VBoxContainer); GDCLASS(RTileMapEditor, VBoxContainer);
private: private:
UndoRedo *undo_redo = EditorNode::get_undo_redo(); UndoRedo *undo_redo = EditorNode::get_undo_redo();
@ -302,7 +302,7 @@ private:
int tile_map_layer = -1; int tile_map_layer = -1;
// Vector to keep plugins. // Vector to keep plugins.
Vector<TileMapEditorPlugin *> tile_map_editor_plugins; Vector<RTileMapEditorPlugin *> tile_map_editor_plugins;
// Toolbar. // Toolbar.
HBoxContainer *tile_map_toolbar; HBoxContainer *tile_map_toolbar;
@ -323,8 +323,8 @@ private:
// Bottom panel. // Bottom panel.
Label *missing_tileset_label; Label *missing_tileset_label;
TabBar *tabs_bar; TabBar *tabs_bar;
LocalVector<TileMapEditorPlugin::TabData> tabs_data; LocalVector<RTileMapEditorPlugin::TabData> tabs_data;
LocalVector<TileMapEditorPlugin *> tabs_plugins; LocalVector<RTileMapEditorPlugin *> tabs_plugins;
void _update_bottom_panel(); void _update_bottom_panel();
// TileMap. // TileMap.
@ -352,8 +352,8 @@ public:
void edit(TileMap *p_tile_map); void edit(TileMap *p_tile_map);
TileMapEditor(); RTileMapEditor();
~TileMapEditor(); ~RTileMapEditor();
// Static functions. // Static functions.
static Vector<Vector2i> get_line(TileMap *p_tile_map, Vector2i p_from_cell, Vector2i p_to_cell); static Vector<Vector2i> get_line(TileMap *p_tile_map, Vector2i p_from_cell, Vector2i p_to_cell);

62
tile_editor/tile_proxies_manager_dialog.cpp
View File

@ -32,21 +32,21 @@
#include "editor/editor_scale.h" #include "editor/editor_scale.h"
void TileProxiesManagerDialog::_right_clicked(int p_item, Vector2 p_local_mouse_pos, Object *p_item_list) { void RTileProxiesManagerDialog::_right_clicked(int p_item, Vector2 p_local_mouse_pos, Object *p_item_list) {
ItemList *item_list = Object::cast_to<ItemList>(p_item_list); ItemList *item_list = Object::cast_to<ItemList>(p_item_list);
popup_menu->reset_size(); popup_menu->reset_size();
popup_menu->set_position(get_position() + item_list->get_global_mouse_position()); popup_menu->set_position(get_position() + item_list->get_global_mouse_position());
popup_menu->popup(); popup_menu->popup();
} }
void TileProxiesManagerDialog::_menu_id_pressed(int p_id) { void RTileProxiesManagerDialog::_menu_id_pressed(int p_id) {
if (p_id == 0) { if (p_id == 0) {
// Delete. // Delete.
_delete_selected_bindings(); _delete_selected_bindings();
} }
} }
void TileProxiesManagerDialog::_delete_selected_bindings() { void RTileProxiesManagerDialog::_delete_selected_bindings() {
undo_redo->create_action(TTR("Remove Tile Proxies")); undo_redo->create_action(TTR("Remove Tile Proxies"));
Vector<int> source_level_selected = source_level_list->get_selected_items(); Vector<int> source_level_selected = source_level_list->get_selected_items();
@ -79,7 +79,7 @@ void TileProxiesManagerDialog::_delete_selected_bindings() {
commited_actions_count += 1; commited_actions_count += 1;
} }
void TileProxiesManagerDialog::_update_lists() { void RTileProxiesManagerDialog::_update_lists() {
source_level_list->clear(); source_level_list->clear();
coords_level_list->clear(); coords_level_list->clear();
alternative_level_list->clear(); alternative_level_list->clear();
@ -109,7 +109,7 @@ void TileProxiesManagerDialog::_update_lists() {
} }
} }
void TileProxiesManagerDialog::_update_enabled_property_editors() { void RTileProxiesManagerDialog::_update_enabled_property_editors() {
if (from.source_id == TileSet::INVALID_SOURCE) { if (from.source_id == TileSet::INVALID_SOURCE) {
from.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS); from.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS);
to.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS); to.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS);
@ -141,11 +141,11 @@ void TileProxiesManagerDialog::_update_enabled_property_editors() {
alternative_to_property_editor->update_property(); alternative_to_property_editor->update_property();
} }
void TileProxiesManagerDialog::_property_changed(const String &p_path, const Variant &p_value, const String &p_name, bool p_changing) { void RTileProxiesManagerDialog::_property_changed(const String &p_path, const Variant &p_value, const String &p_name, bool p_changing) {
_set(p_path, p_value); _set(p_path, p_value);
} }
void TileProxiesManagerDialog::_add_button_pressed() { void RTileProxiesManagerDialog::_add_button_pressed() {
if (from.source_id != TileSet::INVALID_SOURCE && to.source_id != TileSet::INVALID_SOURCE) { if (from.source_id != TileSet::INVALID_SOURCE && to.source_id != TileSet::INVALID_SOURCE) {
Vector2i from_coords = from.get_atlas_coords(); Vector2i from_coords = from.get_atlas_coords();
Vector2i to_coords = to.get_atlas_coords(); Vector2i to_coords = to.get_atlas_coords();
@ -185,7 +185,7 @@ void TileProxiesManagerDialog::_add_button_pressed() {
} }
} }
void TileProxiesManagerDialog::_clear_invalid_button_pressed() { void RTileProxiesManagerDialog::_clear_invalid_button_pressed() {
undo_redo->create_action(TTR("Delete All Invalid Tile Proxies")); undo_redo->create_action(TTR("Delete All Invalid Tile Proxies"));
undo_redo->add_do_method(*tile_set, "cleanup_invalid_tile_proxies"); undo_redo->add_do_method(*tile_set, "cleanup_invalid_tile_proxies");
@ -212,7 +212,7 @@ void TileProxiesManagerDialog::_clear_invalid_button_pressed() {
undo_redo->commit_action(); undo_redo->commit_action();
} }
void TileProxiesManagerDialog::_clear_all_button_pressed() { void RTileProxiesManagerDialog::_clear_all_button_pressed() {
undo_redo->create_action(TTR("Delete All Tile Proxies")); undo_redo->create_action(TTR("Delete All Tile Proxies"));
undo_redo->add_do_method(*tile_set, "clear_tile_proxies"); undo_redo->add_do_method(*tile_set, "clear_tile_proxies");
@ -239,7 +239,7 @@ void TileProxiesManagerDialog::_clear_all_button_pressed() {
undo_redo->commit_action(); undo_redo->commit_action();
} }
bool TileProxiesManagerDialog::_set(const StringName &p_name, const Variant &p_value) { bool RTileProxiesManagerDialog::_set(const StringName &p_name, const Variant &p_value) {
if (p_name == "from_source") { if (p_name == "from_source") {
from.source_id = MAX(int(p_value), -1); from.source_id = MAX(int(p_value), -1);
} else if (p_name == "from_coords") { } else if (p_name == "from_coords") {
@ -259,7 +259,7 @@ bool TileProxiesManagerDialog::_set(const StringName &p_name, const Variant &p_v
return true; return true;
} }
bool TileProxiesManagerDialog::_get(const StringName &p_name, Variant &r_ret) const { bool RTileProxiesManagerDialog::_get(const StringName &p_name, Variant &r_ret) const {
if (p_name == "from_source") { if (p_name == "from_source") {
r_ret = from.source_id; r_ret = from.source_id;
} else if (p_name == "from_coords") { } else if (p_name == "from_coords") {
@ -278,7 +278,7 @@ bool TileProxiesManagerDialog::_get(const StringName &p_name, Variant &r_ret) co
return true; return true;
} }
void TileProxiesManagerDialog::_unhandled_key_input(Ref<InputEvent> p_event) { void RTileProxiesManagerDialog::_unhandled_key_input(Ref<InputEvent> p_event) {
ERR_FAIL_COND(p_event.is_null()); ERR_FAIL_COND(p_event.is_null());
if (p_event->is_pressed() && !p_event->is_echo() && (Object::cast_to<InputEventKey>(p_event.ptr()) || Object::cast_to<InputEventJoypadButton>(p_event.ptr()) || Object::cast_to<InputEventAction>(*p_event))) { if (p_event->is_pressed() && !p_event->is_echo() && (Object::cast_to<InputEventKey>(p_event.ptr()) || Object::cast_to<InputEventJoypadButton>(p_event.ptr()) || Object::cast_to<InputEventAction>(*p_event))) {
@ -292,26 +292,26 @@ void TileProxiesManagerDialog::_unhandled_key_input(Ref<InputEvent> p_event) {
} }
} }
void TileProxiesManagerDialog::cancel_pressed() { void RTileProxiesManagerDialog::cancel_pressed() {
for (int i = 0; i < commited_actions_count; i++) { for (int i = 0; i < commited_actions_count; i++) {
undo_redo->undo(); undo_redo->undo();
} }
commited_actions_count = 0; commited_actions_count = 0;
} }
void TileProxiesManagerDialog::_bind_methods() { void RTileProxiesManagerDialog::_bind_methods() {
ClassDB::bind_method(D_METHOD("_update_lists"), &TileProxiesManagerDialog::_update_lists); ClassDB::bind_method(D_METHOD("_update_lists"), &RTileProxiesManagerDialog::_update_lists);
ClassDB::bind_method(D_METHOD("_unhandled_key_input"), &TileProxiesManagerDialog::_unhandled_key_input); ClassDB::bind_method(D_METHOD("_unhandled_key_input"), &RTileProxiesManagerDialog::_unhandled_key_input);
} }
void TileProxiesManagerDialog::update_tile_set(Ref<TileSet> p_tile_set) { void RTileProxiesManagerDialog::update_tile_set(Ref<TileSet> p_tile_set) {
ERR_FAIL_COND(!p_tile_set.is_valid()); ERR_FAIL_COND(!p_tile_set.is_valid());
tile_set = p_tile_set; tile_set = p_tile_set;
commited_actions_count = 0; commited_actions_count = 0;
_update_lists(); _update_lists();
} }
TileProxiesManagerDialog::TileProxiesManagerDialog() { RTileProxiesManagerDialog::RTileProxiesManagerDialog() {
// Tile proxy management window. // Tile proxy management window.
set_title(TTR("Tile Proxies Management")); set_title(TTR("Tile Proxies Management"));
set_process_unhandled_key_input(true); set_process_unhandled_key_input(true);
@ -333,7 +333,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
source_level_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); source_level_list->set_v_size_flags(Control::SIZE_EXPAND_FILL);
source_level_list->set_select_mode(ItemList::SELECT_MULTI); source_level_list->set_select_mode(ItemList::SELECT_MULTI);
source_level_list->set_allow_rmb_select(true); source_level_list->set_allow_rmb_select(true);
source_level_list->connect("item_rmb_selected", callable_mp(this, &TileProxiesManagerDialog::_right_clicked), varray(source_level_list)); source_level_list->connect("item_rmb_selected", callable_mp(this, &RTileProxiesManagerDialog::_right_clicked), varray(source_level_list));
vbox_container->add_child(source_level_list); vbox_container->add_child(source_level_list);
Label *coords_level_label = memnew(Label); Label *coords_level_label = memnew(Label);
@ -344,7 +344,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
coords_level_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); coords_level_list->set_v_size_flags(Control::SIZE_EXPAND_FILL);
coords_level_list->set_select_mode(ItemList::SELECT_MULTI); coords_level_list->set_select_mode(ItemList::SELECT_MULTI);
coords_level_list->set_allow_rmb_select(true); coords_level_list->set_allow_rmb_select(true);
coords_level_list->connect("item_rmb_selected", callable_mp(this, &TileProxiesManagerDialog::_right_clicked), varray(coords_level_list)); coords_level_list->connect("item_rmb_selected", callable_mp(this, &RTileProxiesManagerDialog::_right_clicked), varray(coords_level_list));
vbox_container->add_child(coords_level_list); vbox_container->add_child(coords_level_list);
Label *alternative_level_label = memnew(Label); Label *alternative_level_label = memnew(Label);
@ -355,12 +355,12 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
alternative_level_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); alternative_level_list->set_v_size_flags(Control::SIZE_EXPAND_FILL);
alternative_level_list->set_select_mode(ItemList::SELECT_MULTI); alternative_level_list->set_select_mode(ItemList::SELECT_MULTI);
alternative_level_list->set_allow_rmb_select(true); alternative_level_list->set_allow_rmb_select(true);
alternative_level_list->connect("item_rmb_selected", callable_mp(this, &TileProxiesManagerDialog::_right_clicked), varray(alternative_level_list)); alternative_level_list->connect("item_rmb_selected", callable_mp(this, &RTileProxiesManagerDialog::_right_clicked), varray(alternative_level_list));
vbox_container->add_child(alternative_level_list); vbox_container->add_child(alternative_level_list);
popup_menu = memnew(PopupMenu); popup_menu = memnew(PopupMenu);
popup_menu->add_shortcut(ED_GET_SHORTCUT("ui_text_delete")); popup_menu->add_shortcut(ED_GET_SHORTCUT("ui_text_delete"));
popup_menu->connect("id_pressed", callable_mp(this, &TileProxiesManagerDialog::_menu_id_pressed)); popup_menu->connect("id_pressed", callable_mp(this, &RTileProxiesManagerDialog::_menu_id_pressed));
add_child(popup_menu); add_child(popup_menu);
// Add proxy panel. // Add proxy panel.
@ -382,7 +382,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
source_from_property_editor = memnew(EditorPropertyInteger); source_from_property_editor = memnew(EditorPropertyInteger);
source_from_property_editor->set_label(TTR("From Source")); source_from_property_editor->set_label(TTR("From Source"));
source_from_property_editor->set_object_and_property(this, "from_source"); source_from_property_editor->set_object_and_property(this, "from_source");
source_from_property_editor->connect("property_changed", callable_mp(this, &TileProxiesManagerDialog::_property_changed)); source_from_property_editor->connect("property_changed", callable_mp(this, &RTileProxiesManagerDialog::_property_changed));
source_from_property_editor->set_selectable(false); source_from_property_editor->set_selectable(false);
source_from_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); source_from_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
source_from_property_editor->setup(-1, 99999, 1, true, false); source_from_property_editor->setup(-1, 99999, 1, true, false);
@ -391,7 +391,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
coords_from_property_editor = memnew(EditorPropertyVector2i); coords_from_property_editor = memnew(EditorPropertyVector2i);
coords_from_property_editor->set_label(TTR("From Coords")); coords_from_property_editor->set_label(TTR("From Coords"));
coords_from_property_editor->set_object_and_property(this, "from_coords"); coords_from_property_editor->set_object_and_property(this, "from_coords");
coords_from_property_editor->connect("property_changed", callable_mp(this, &TileProxiesManagerDialog::_property_changed)); coords_from_property_editor->connect("property_changed", callable_mp(this, &RTileProxiesManagerDialog::_property_changed));
coords_from_property_editor->set_selectable(false); coords_from_property_editor->set_selectable(false);
coords_from_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); coords_from_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
coords_from_property_editor->setup(-1, 99999, true); coords_from_property_editor->setup(-1, 99999, true);
@ -401,7 +401,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
alternative_from_property_editor = memnew(EditorPropertyInteger); alternative_from_property_editor = memnew(EditorPropertyInteger);
alternative_from_property_editor->set_label(TTR("From Alternative")); alternative_from_property_editor->set_label(TTR("From Alternative"));
alternative_from_property_editor->set_object_and_property(this, "from_alternative"); alternative_from_property_editor->set_object_and_property(this, "from_alternative");
alternative_from_property_editor->connect("property_changed", callable_mp(this, &TileProxiesManagerDialog::_property_changed)); alternative_from_property_editor->connect("property_changed", callable_mp(this, &RTileProxiesManagerDialog::_property_changed));
alternative_from_property_editor->set_selectable(false); alternative_from_property_editor->set_selectable(false);
alternative_from_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); alternative_from_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
alternative_from_property_editor->setup(-1, 99999, 1, true, false); alternative_from_property_editor->setup(-1, 99999, 1, true, false);
@ -416,7 +416,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
source_to_property_editor = memnew(EditorPropertyInteger); source_to_property_editor = memnew(EditorPropertyInteger);
source_to_property_editor->set_label(TTR("To Source")); source_to_property_editor->set_label(TTR("To Source"));
source_to_property_editor->set_object_and_property(this, "to_source"); source_to_property_editor->set_object_and_property(this, "to_source");
source_to_property_editor->connect("property_changed", callable_mp(this, &TileProxiesManagerDialog::_property_changed)); source_to_property_editor->connect("property_changed", callable_mp(this, &RTileProxiesManagerDialog::_property_changed));
source_to_property_editor->set_selectable(false); source_to_property_editor->set_selectable(false);
source_to_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); source_to_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
source_to_property_editor->setup(-1, 99999, 1, true, false); source_to_property_editor->setup(-1, 99999, 1, true, false);
@ -425,7 +425,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
coords_to_property_editor = memnew(EditorPropertyVector2i); coords_to_property_editor = memnew(EditorPropertyVector2i);
coords_to_property_editor->set_label(TTR("To Coords")); coords_to_property_editor->set_label(TTR("To Coords"));
coords_to_property_editor->set_object_and_property(this, "to_coords"); coords_to_property_editor->set_object_and_property(this, "to_coords");
coords_to_property_editor->connect("property_changed", callable_mp(this, &TileProxiesManagerDialog::_property_changed)); coords_to_property_editor->connect("property_changed", callable_mp(this, &RTileProxiesManagerDialog::_property_changed));
coords_to_property_editor->set_selectable(false); coords_to_property_editor->set_selectable(false);
coords_to_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); coords_to_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
coords_to_property_editor->setup(-1, 99999, true); coords_to_property_editor->setup(-1, 99999, true);
@ -435,7 +435,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
alternative_to_property_editor = memnew(EditorPropertyInteger); alternative_to_property_editor = memnew(EditorPropertyInteger);
alternative_to_property_editor->set_label(TTR("To Alternative")); alternative_to_property_editor->set_label(TTR("To Alternative"));
alternative_to_property_editor->set_object_and_property(this, "to_alternative"); alternative_to_property_editor->set_object_and_property(this, "to_alternative");
alternative_to_property_editor->connect("property_changed", callable_mp(this, &TileProxiesManagerDialog::_property_changed)); alternative_to_property_editor->connect("property_changed", callable_mp(this, &RTileProxiesManagerDialog::_property_changed));
alternative_to_property_editor->set_selectable(false); alternative_to_property_editor->set_selectable(false);
alternative_to_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); alternative_to_property_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
alternative_to_property_editor->setup(-1, 99999, 1, true, false); alternative_to_property_editor->setup(-1, 99999, 1, true, false);
@ -445,7 +445,7 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
Button *add_button = memnew(Button); Button *add_button = memnew(Button);
add_button->set_text(TTR("Add")); add_button->set_text(TTR("Add"));
add_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER); add_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
add_button->connect("pressed", callable_mp(this, &TileProxiesManagerDialog::_add_button_pressed)); add_button->connect("pressed", callable_mp(this, &RTileProxiesManagerDialog::_add_button_pressed));
vbox_container->add_child(add_button); vbox_container->add_child(add_button);
h_separator = memnew(HSeparator); h_separator = memnew(HSeparator);
@ -462,13 +462,13 @@ TileProxiesManagerDialog::TileProxiesManagerDialog() {
Button *clear_invalid_button = memnew(Button); Button *clear_invalid_button = memnew(Button);
clear_invalid_button->set_text(TTR("Clear Invalid")); clear_invalid_button->set_text(TTR("Clear Invalid"));
clear_invalid_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER); clear_invalid_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
clear_invalid_button->connect("pressed", callable_mp(this, &TileProxiesManagerDialog::_clear_invalid_button_pressed)); clear_invalid_button->connect("pressed", callable_mp(this, &RTileProxiesManagerDialog::_clear_invalid_button_pressed));
hboxcontainer->add_child(clear_invalid_button); hboxcontainer->add_child(clear_invalid_button);
Button *clear_all_button = memnew(Button); Button *clear_all_button = memnew(Button);
clear_all_button->set_text(TTR("Clear All")); clear_all_button->set_text(TTR("Clear All"));
clear_all_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER); clear_all_button->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
clear_all_button->connect("pressed", callable_mp(this, &TileProxiesManagerDialog::_clear_all_button_pressed)); clear_all_button->connect("pressed", callable_mp(this, &RTileProxiesManagerDialog::_clear_all_button_pressed));
hboxcontainer->add_child(clear_all_button); hboxcontainer->add_child(clear_all_button);
h_separator = memnew(HSeparator); h_separator = memnew(HSeparator);

10
tile_editor/tile_proxies_manager_dialog.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILE_PROXIES_MANAGER_DIALOG_H #ifndef RTILE_PROXIES_MANAGER_DIALOG_H
#define TILE_PROXIES_MANAGER_DIALOG_H #define RTILE_PROXIES_MANAGER_DIALOG_H
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_properties.h" #include "editor/editor_properties.h"
@ -38,8 +38,8 @@
#include "scene/gui/dialogs.h" #include "scene/gui/dialogs.h"
#include "scene/gui/item_list.h" #include "scene/gui/item_list.h"
class TileProxiesManagerDialog : public ConfirmationDialog { class RTileProxiesManagerDialog : public ConfirmationDialog {
GDCLASS(TileProxiesManagerDialog, ConfirmationDialog); GDCLASS(RTileProxiesManagerDialog, ConfirmationDialog);
private: private:
int commited_actions_count = 0; int commited_actions_count = 0;
@ -84,7 +84,7 @@ protected:
public: public:
void update_tile_set(Ref<TileSet> p_tile_set); void update_tile_set(Ref<TileSet> p_tile_set);
TileProxiesManagerDialog(); RTileProxiesManagerDialog();
}; };
#endif // TILE_PROXIES_MANAGER_DIALOG_H #endif // TILE_PROXIES_MANAGER_DIALOG_H

220
tile_editor/tile_set_atlas_source_editor.cpp
View File

@ -48,7 +48,7 @@
#include "core/math/geometry_2d.h" #include "core/math/geometry_2d.h"
#include "core/os/keyboard.h" #include "core/os/keyboard.h"
void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::set_id(int p_id) { void RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::set_id(int p_id) {
ERR_FAIL_COND(p_id < 0); ERR_FAIL_COND(p_id < 0);
if (source_id == p_id) { if (source_id == p_id) {
return; return;
@ -61,11 +61,11 @@ void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::set_id(int p_id) {
emit_signal(SNAME("changed"), "id"); emit_signal(SNAME("changed"), "id");
} }
int TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::get_id() { int RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::get_id() {
return source_id; return source_id;
} }
bool TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_set(const StringName &p_name, const Variant &p_value) { bool RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_set(const StringName &p_name, const Variant &p_value) {
String name = p_name; String name = p_name;
if (name == "name") { if (name == "name") {
// Use the resource_name property to store the source's name. // Use the resource_name property to store the source's name.
@ -79,7 +79,7 @@ bool TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_set(const StringN
return valid; return valid;
} }
bool TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_get(const StringName &p_name, Variant &r_ret) const { bool RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_get(const StringName &p_name, Variant &r_ret) const {
if (!tile_set_atlas_source) { if (!tile_set_atlas_source) {
return false; return false;
} }
@ -93,7 +93,7 @@ bool TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_get(const StringN
return valid; return valid;
} }
void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_get_property_list(List<PropertyInfo> *p_list) const { void RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::STRING, "name", PROPERTY_HINT_NONE, "")); p_list->push_back(PropertyInfo(Variant::STRING, "name", PROPERTY_HINT_NONE, ""));
p_list->push_back(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D")); p_list->push_back(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"));
p_list->push_back(PropertyInfo(Variant::VECTOR2I, "margins", PROPERTY_HINT_NONE, "")); p_list->push_back(PropertyInfo(Variant::VECTOR2I, "margins", PROPERTY_HINT_NONE, ""));
@ -102,17 +102,17 @@ void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_get_property_list
p_list->push_back(PropertyInfo(Variant::BOOL, "use_texture_padding", PROPERTY_HINT_NONE, "")); p_list->push_back(PropertyInfo(Variant::BOOL, "use_texture_padding", PROPERTY_HINT_NONE, ""));
} }
void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_bind_methods() { void RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_bind_methods() {
// -- Shape and layout -- // -- Shape and layout --
ClassDB::bind_method(D_METHOD("set_id", "id"), &TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::set_id); ClassDB::bind_method(D_METHOD("set_id", "id"), &RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::set_id);
ClassDB::bind_method(D_METHOD("get_id"), &TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::get_id); ClassDB::bind_method(D_METHOD("get_id"), &RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::get_id);
ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id"); ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id");
ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what"))); ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what")));
} }
void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::edit(Ref<TileSet> p_tile_set, TileSetAtlasSource *p_tile_set_atlas_source, int p_source_id) { void RTileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::edit(Ref<TileSet> p_tile_set, TileSetAtlasSource *p_tile_set_atlas_source, int p_source_id) {
ERR_FAIL_COND(!p_tile_set.is_valid()); ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(!p_tile_set_atlas_source); ERR_FAIL_COND(!p_tile_set_atlas_source);
ERR_FAIL_COND(p_source_id < 0); ERR_FAIL_COND(p_source_id < 0);
@ -142,7 +142,7 @@ void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::edit(Ref<TileSet>
} }
// -- Proxy object used by the tile inspector -- // -- Proxy object used by the tile inspector --
bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_set(const StringName &p_name, const Variant &p_value) { bool RTileSetAtlasSourceEditor::AtlasTileProxyObject::_set(const StringName &p_name, const Variant &p_value) {
if (!tile_set_atlas_source) { if (!tile_set_atlas_source) {
return false; return false;
} }
@ -288,7 +288,7 @@ bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_set(const StringName &p_na
return any_valid; return any_valid;
} }
bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_get(const StringName &p_name, Variant &r_ret) const { bool RTileSetAtlasSourceEditor::AtlasTileProxyObject::_get(const StringName &p_name, Variant &r_ret) const {
if (!tile_set_atlas_source) { if (!tile_set_atlas_source) {
return false; return false;
} }
@ -372,7 +372,7 @@ bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_get(const StringName &p_na
return false; return false;
} }
void TileSetAtlasSourceEditor::AtlasTileProxyObject::_get_property_list(List<PropertyInfo> *p_list) const { void RTileSetAtlasSourceEditor::AtlasTileProxyObject::_get_property_list(List<PropertyInfo> *p_list) const {
if (!tile_set_atlas_source) { if (!tile_set_atlas_source) {
return; return;
} }
@ -472,7 +472,7 @@ void TileSetAtlasSourceEditor::AtlasTileProxyObject::_get_property_list(List<Pro
} }
} }
void TileSetAtlasSourceEditor::AtlasTileProxyObject::edit(TileSetAtlasSource *p_tile_set_atlas_source, Set<TileSelection> p_tiles) { void RTileSetAtlasSourceEditor::AtlasTileProxyObject::edit(TileSetAtlasSource *p_tile_set_atlas_source, Set<TileSelection> p_tiles) {
ERR_FAIL_COND(!p_tile_set_atlas_source); ERR_FAIL_COND(!p_tile_set_atlas_source);
ERR_FAIL_COND(p_tiles.is_empty()); ERR_FAIL_COND(p_tiles.is_empty());
for (Set<TileSelection>::Element *E = p_tiles.front(); E; E = E->next()) { for (Set<TileSelection>::Element *E = p_tiles.front(); E; E = E->next()) {
@ -512,17 +512,17 @@ void TileSetAtlasSourceEditor::AtlasTileProxyObject::edit(TileSetAtlasSource *p_
notify_property_list_changed(); notify_property_list_changed();
} }
void TileSetAtlasSourceEditor::AtlasTileProxyObject::_bind_methods() { void RTileSetAtlasSourceEditor::AtlasTileProxyObject::_bind_methods() {
ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what"))); ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what")));
} }
void TileSetAtlasSourceEditor::_inspector_property_selected(String p_property) { void RTileSetAtlasSourceEditor::_inspector_property_selected(String p_property) {
selected_property = p_property; selected_property = p_property;
_update_atlas_view(); _update_atlas_view();
_update_current_tile_data_editor(); _update_current_tile_data_editor();
} }
void TileSetAtlasSourceEditor::_update_tile_id_label() { void RTileSetAtlasSourceEditor::_update_tile_id_label() {
if (selection.size() == 1) { if (selection.size() == 1) {
TileSelection selected = selection.front()->get(); TileSelection selected = selection.front()->get();
tool_tile_id_label->set_text(vformat("%d, %s, %d", tile_set_atlas_source_id, selected.tile, selected.alternative)); tool_tile_id_label->set_text(vformat("%d, %s, %d", tile_set_atlas_source_id, selected.tile, selected.alternative));
@ -533,12 +533,12 @@ void TileSetAtlasSourceEditor::_update_tile_id_label() {
} }
} }
void TileSetAtlasSourceEditor::_update_source_inspector() { void RTileSetAtlasSourceEditor::_update_source_inspector() {
// Update the proxy object. // Update the proxy object.
atlas_source_proxy_object->edit(tile_set, tile_set_atlas_source, tile_set_atlas_source_id); atlas_source_proxy_object->edit(tile_set, tile_set_atlas_source, tile_set_atlas_source_id);
} }
void TileSetAtlasSourceEditor::_update_fix_selected_and_hovered_tiles() { void RTileSetAtlasSourceEditor::_update_fix_selected_and_hovered_tiles() {
// Fix selected. // Fix selected.
for (Set<TileSelection>::Element *E = selection.front(); E; E = E->next()) { for (Set<TileSelection>::Element *E = selection.front(); E; E = E->next()) {
TileSelection selected = E->get(); TileSelection selected = E->get();
@ -558,14 +558,14 @@ void TileSetAtlasSourceEditor::_update_fix_selected_and_hovered_tiles() {
} }
} }
void TileSetAtlasSourceEditor::_update_atlas_source_inspector() { void RTileSetAtlasSourceEditor::_update_atlas_source_inspector() {
// Update visibility. // Update visibility.
bool visible = tools_button_group->get_pressed_button() == tool_setup_atlas_source_button; bool visible = tools_button_group->get_pressed_button() == tool_setup_atlas_source_button;
atlas_source_inspector_label->set_visible(visible); atlas_source_inspector_label->set_visible(visible);
atlas_source_inspector->set_visible(visible); atlas_source_inspector->set_visible(visible);
} }
void TileSetAtlasSourceEditor::_update_tile_inspector() { void RTileSetAtlasSourceEditor::_update_tile_inspector() {
// Update visibility. // Update visibility.
if (tools_button_group->get_pressed_button() == tool_select_button) { if (tools_button_group->get_pressed_button() == tool_select_button) {
if (!selection.is_empty()) { if (!selection.is_empty()) {
@ -581,7 +581,7 @@ void TileSetAtlasSourceEditor::_update_tile_inspector() {
} }
} }
void TileSetAtlasSourceEditor::_update_tile_data_editors() { void RTileSetAtlasSourceEditor::_update_tile_data_editors() {
String previously_selected; String previously_selected;
if (tile_data_editors_tree && tile_data_editors_tree->get_selected()) { if (tile_data_editors_tree && tile_data_editors_tree->get_selected()) {
previously_selected = tile_data_editors_tree->get_selected()->get_metadata(0); previously_selected = tile_data_editors_tree->get_selected()->get_metadata(0);
@ -757,9 +757,9 @@ void TileSetAtlasSourceEditor::_update_tile_data_editors() {
#undef ADD_TILE_DATA_EDITOR #undef ADD_TILE_DATA_EDITOR
// Add tile data editors as children. // Add tile data editors as children.
for (KeyValue<String, TileDataEditor *> &E : tile_data_editors) { for (KeyValue<String, RTileDataEditor *> &E : tile_data_editors) {
// Tile Data Editor. // Tile Data Editor.
TileDataEditor *tile_data_editor = E.value; RTileDataEditor *tile_data_editor = E.value;
if (!tile_data_editor->is_inside_tree()) { if (!tile_data_editor->is_inside_tree()) {
tile_data_painting_editor_container->add_child(tile_data_editor); tile_data_painting_editor_container->add_child(tile_data_editor);
} }
@ -784,7 +784,7 @@ void TileSetAtlasSourceEditor::_update_tile_data_editors() {
tile_data_editors_label->set_visible(is_visible); tile_data_editors_label->set_visible(is_visible);
} }
void TileSetAtlasSourceEditor::_update_current_tile_data_editor() { void RTileSetAtlasSourceEditor::_update_current_tile_data_editor() {
// Find the property to use. // Find the property to use.
String property; String property;
if (tools_button_group->get_pressed_button() == tool_select_button && tile_inspector->is_visible() && !tile_inspector->get_selected_path().is_empty()) { if (tools_button_group->get_pressed_button() == tool_select_button && tile_inspector->is_visible() && !tile_inspector->get_selected_path().is_empty()) {
@ -803,7 +803,7 @@ void TileSetAtlasSourceEditor::_update_current_tile_data_editor() {
} }
// Hide all editors but the current one. // Hide all editors but the current one.
for (const KeyValue<String, TileDataEditor *> &E : tile_data_editors) { for (const KeyValue<String, RTileDataEditor *> &E : tile_data_editors) {
E.value->hide(); E.value->hide();
E.value->get_toolbar()->hide(); E.value->get_toolbar()->hide();
} }
@ -822,7 +822,7 @@ void TileSetAtlasSourceEditor::_update_current_tile_data_editor() {
} }
} }
void TileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_draw() { void RTileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_draw() {
if (!has_theme_icon(SNAME("arrow"), SNAME("OptionButton"))) { if (!has_theme_icon(SNAME("arrow"), SNAME("OptionButton"))) {
return; return;
} }
@ -861,14 +861,14 @@ void TileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_draw() {
arrow->draw(ci, ofs, clr); arrow->draw(ci, ofs, clr);
} }
void TileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_pressed() { void RTileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_pressed() {
Size2 size = tile_data_editor_dropdown_button->get_size(); Size2 size = tile_data_editor_dropdown_button->get_size();
tile_data_editors_popup->set_position(tile_data_editor_dropdown_button->get_screen_position() + Size2(0, size.height * get_global_transform().get_scale().y)); tile_data_editors_popup->set_position(tile_data_editor_dropdown_button->get_screen_position() + Size2(0, size.height * get_global_transform().get_scale().y));
tile_data_editors_popup->set_size(Size2(size.width, 0)); tile_data_editors_popup->set_size(Size2(size.width, 0));
tile_data_editors_popup->popup(); tile_data_editors_popup->popup();
} }
void TileSetAtlasSourceEditor::_tile_data_editors_tree_selected() { void RTileSetAtlasSourceEditor::_tile_data_editors_tree_selected() {
tile_data_editors_popup->call_deferred(SNAME("hide")); tile_data_editors_popup->call_deferred(SNAME("hide"));
_update_current_tile_data_editor(); _update_current_tile_data_editor();
tile_atlas_control->update(); tile_atlas_control->update();
@ -877,7 +877,7 @@ void TileSetAtlasSourceEditor::_tile_data_editors_tree_selected() {
alternative_tiles_control_unscaled->update(); alternative_tiles_control_unscaled->update();
} }
void TileSetAtlasSourceEditor::_update_atlas_view() { void RTileSetAtlasSourceEditor::_update_atlas_view() {
// Update the atlas display. // Update the atlas display.
tile_atlas_view->set_atlas_source(*tile_set, tile_set_atlas_source, tile_set_atlas_source_id); tile_atlas_view->set_atlas_source(*tile_set, tile_set_atlas_source, tile_set_atlas_source_id);
@ -929,10 +929,10 @@ void TileSetAtlasSourceEditor::_update_atlas_view() {
tile_atlas_view->update(); tile_atlas_view->update();
// Synchronize atlas view. // Synchronize atlas view.
TilesEditorPlugin::get_singleton()->synchronize_atlas_view(tile_atlas_view); RTilesEditorPlugin::get_singleton()->synchronize_atlas_view(tile_atlas_view);
} }
void TileSetAtlasSourceEditor::_update_toolbar() { void RTileSetAtlasSourceEditor::_update_toolbar() {
// Show the tools and settings. // Show the tools and settings.
if (tools_button_group->get_pressed_button() == tool_setup_atlas_source_button) { if (tools_button_group->get_pressed_button() == tool_setup_atlas_source_button) {
if (current_tile_data_editor_toolbar) { if (current_tile_data_editor_toolbar) {
@ -958,19 +958,19 @@ void TileSetAtlasSourceEditor::_update_toolbar() {
} }
} }
void TileSetAtlasSourceEditor::_tile_atlas_control_mouse_exited() { void RTileSetAtlasSourceEditor::_tile_atlas_control_mouse_exited() {
hovered_base_tile_coords = TileSetSource::INVALID_ATLAS_COORDS; hovered_base_tile_coords = TileSetSource::INVALID_ATLAS_COORDS;
tile_atlas_control->update(); tile_atlas_control->update();
tile_atlas_control_unscaled->update(); tile_atlas_control_unscaled->update();
tile_atlas_view->update(); tile_atlas_view->update();
} }
void TileSetAtlasSourceEditor::_tile_atlas_view_transform_changed() { void RTileSetAtlasSourceEditor::_tile_atlas_view_transform_changed() {
tile_atlas_control->update(); tile_atlas_control->update();
tile_atlas_control_unscaled->update(); tile_atlas_control_unscaled->update();
} }
void TileSetAtlasSourceEditor::_tile_atlas_control_gui_input(const Ref<InputEvent> &p_event) { void RTileSetAtlasSourceEditor::_tile_atlas_control_gui_input(const Ref<InputEvent> &p_event) {
// Update the hovered coords. // Update the hovered coords.
hovered_base_tile_coords = tile_atlas_view->get_atlas_tile_coords_at_pos(tile_atlas_control->get_local_mouse_position()); hovered_base_tile_coords = tile_atlas_view->get_atlas_tile_coords_at_pos(tile_atlas_control->get_local_mouse_position());
@ -1308,7 +1308,7 @@ void TileSetAtlasSourceEditor::_tile_atlas_control_gui_input(const Ref<InputEven
} }
} }
void TileSetAtlasSourceEditor::_end_dragging() { void RTileSetAtlasSourceEditor::_end_dragging() {
switch (drag_type) { switch (drag_type) {
case DRAG_TYPE_CREATE_TILES: case DRAG_TYPE_CREATE_TILES:
undo_redo->create_action(TTR("Create tiles")); undo_redo->create_action(TTR("Create tiles"));
@ -1522,7 +1522,7 @@ void TileSetAtlasSourceEditor::_end_dragging() {
tile_atlas_control->set_default_cursor_shape(CURSOR_ARROW); tile_atlas_control->set_default_cursor_shape(CURSOR_ARROW);
} }
Map<Vector2i, List<const PropertyInfo *>> TileSetAtlasSourceEditor::_group_properties_per_tiles(const List<PropertyInfo> &r_list, const TileSetAtlasSource *p_atlas) { Map<Vector2i, List<const PropertyInfo *>> RTileSetAtlasSourceEditor::_group_properties_per_tiles(const List<PropertyInfo> &r_list, const TileSetAtlasSource *p_atlas) {
// Group properties per tile. // Group properties per tile.
Map<Vector2i, List<const PropertyInfo *>> per_tile; Map<Vector2i, List<const PropertyInfo *>> per_tile;
for (const List<PropertyInfo>::Element *E_property = r_list.front(); E_property; E_property = E_property->next()) { for (const List<PropertyInfo>::Element *E_property = r_list.front(); E_property; E_property = E_property->next()) {
@ -1538,7 +1538,7 @@ Map<Vector2i, List<const PropertyInfo *>> TileSetAtlasSourceEditor::_group_prope
return per_tile; return per_tile;
} }
void TileSetAtlasSourceEditor::_menu_option(int p_option) { void RTileSetAtlasSourceEditor::_menu_option(int p_option) {
switch (p_option) { switch (p_option) {
case TILE_DELETE: { case TILE_DELETE: {
List<PropertyInfo> list; List<PropertyInfo> list;
@ -1630,7 +1630,7 @@ void TileSetAtlasSourceEditor::_menu_option(int p_option) {
} }
} }
void TileSetAtlasSourceEditor::_unhandled_key_input(const Ref<InputEvent> &p_event) { void RTileSetAtlasSourceEditor::_unhandled_key_input(const Ref<InputEvent> &p_event) {
// Check for shortcuts. // Check for shortcuts.
if (ED_IS_SHORTCUT("tiles_editor/delete_tile", p_event)) { if (ED_IS_SHORTCUT("tiles_editor/delete_tile", p_event)) {
if (tools_button_group->get_pressed_button() == tool_select_button && !selection.is_empty()) { if (tools_button_group->get_pressed_button() == tool_select_button && !selection.is_empty()) {
@ -1640,7 +1640,7 @@ void TileSetAtlasSourceEditor::_unhandled_key_input(const Ref<InputEvent> &p_eve
} }
} }
void TileSetAtlasSourceEditor::_set_selection_from_array(Array p_selection) { void RTileSetAtlasSourceEditor::_set_selection_from_array(Array p_selection) {
ERR_FAIL_COND((p_selection.size() % 2) != 0); ERR_FAIL_COND((p_selection.size() % 2) != 0);
selection.clear(); selection.clear();
for (int i = 0; i < p_selection.size() / 2; i++) { for (int i = 0; i < p_selection.size() / 2; i++) {
@ -1655,7 +1655,7 @@ void TileSetAtlasSourceEditor::_set_selection_from_array(Array p_selection) {
_update_current_tile_data_editor(); _update_current_tile_data_editor();
} }
Array TileSetAtlasSourceEditor::_get_selection_as_array() { Array RTileSetAtlasSourceEditor::_get_selection_as_array() {
Array output; Array output;
for (Set<TileSelection>::Element *E = selection.front(); E; E = E->next()) { for (Set<TileSelection>::Element *E = selection.front(); E; E = E->next()) {
output.push_back(E->get().tile); output.push_back(E->get().tile);
@ -1664,7 +1664,7 @@ Array TileSetAtlasSourceEditor::_get_selection_as_array() {
return output; return output;
} }
void TileSetAtlasSourceEditor::_tile_atlas_control_draw() { void RTileSetAtlasSourceEditor::_tile_atlas_control_draw() {
// Colors. // Colors.
Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color"); Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color");
Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0); Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0);
@ -1812,7 +1812,7 @@ void TileSetAtlasSourceEditor::_tile_atlas_control_draw() {
} }
} }
void TileSetAtlasSourceEditor::_tile_atlas_control_unscaled_draw() { void RTileSetAtlasSourceEditor::_tile_atlas_control_unscaled_draw() {
if (current_tile_data_editor) { if (current_tile_data_editor) {
// Draw the preview of the selected property. // Draw the preview of the selected property.
for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) { for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) {
@ -1862,7 +1862,7 @@ void TileSetAtlasSourceEditor::_tile_atlas_control_unscaled_draw() {
} }
} }
void TileSetAtlasSourceEditor::_tile_alternatives_control_gui_input(const Ref<InputEvent> &p_event) { void RTileSetAtlasSourceEditor::_tile_alternatives_control_gui_input(const Ref<InputEvent> &p_event) {
// Update the hovered alternative tile. // Update the hovered alternative tile.
hovered_alternative_tile_coords = tile_atlas_view->get_alternative_tile_at_pos(alternative_tiles_control->get_local_mouse_position()); hovered_alternative_tile_coords = tile_atlas_view->get_alternative_tile_at_pos(alternative_tiles_control->get_local_mouse_position());
@ -1937,7 +1937,7 @@ void TileSetAtlasSourceEditor::_tile_alternatives_control_gui_input(const Ref<In
} }
} }
void TileSetAtlasSourceEditor::_tile_alternatives_control_mouse_exited() { void RTileSetAtlasSourceEditor::_tile_alternatives_control_mouse_exited() {
hovered_alternative_tile_coords = Vector3i(TileSetSource::INVALID_ATLAS_COORDS.x, TileSetSource::INVALID_ATLAS_COORDS.y, TileSetSource::INVALID_TILE_ALTERNATIVE); hovered_alternative_tile_coords = Vector3i(TileSetSource::INVALID_ATLAS_COORDS.x, TileSetSource::INVALID_ATLAS_COORDS.y, TileSetSource::INVALID_TILE_ALTERNATIVE);
tile_atlas_control->update(); tile_atlas_control->update();
tile_atlas_control_unscaled->update(); tile_atlas_control_unscaled->update();
@ -1945,7 +1945,7 @@ void TileSetAtlasSourceEditor::_tile_alternatives_control_mouse_exited() {
alternative_tiles_control_unscaled->update(); alternative_tiles_control_unscaled->update();
} }
void TileSetAtlasSourceEditor::_tile_alternatives_control_draw() { void RTileSetAtlasSourceEditor::_tile_alternatives_control_draw() {
Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color"); Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color");
Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0); Color selection_color = Color().from_hsv(Math::fposmod(grid_color.get_h() + 0.5, 1.0), grid_color.get_s(), grid_color.get_v(), 1.0);
@ -1973,7 +1973,7 @@ void TileSetAtlasSourceEditor::_tile_alternatives_control_draw() {
} }
} }
void TileSetAtlasSourceEditor::_tile_alternatives_control_unscaled_draw() { void RTileSetAtlasSourceEditor::_tile_alternatives_control_unscaled_draw() {
// Draw the preview of the selected property. // Draw the preview of the selected property.
if (current_tile_data_editor) { if (current_tile_data_editor) {
// Draw the preview of the currently selected property. // Draw the preview of the currently selected property.
@ -2030,16 +2030,16 @@ void TileSetAtlasSourceEditor::_tile_alternatives_control_unscaled_draw() {
} }
} }
void TileSetAtlasSourceEditor::_tile_set_changed() { void RTileSetAtlasSourceEditor::_tile_set_changed() {
tile_set_changed_needs_update = true; tile_set_changed_needs_update = true;
} }
void TileSetAtlasSourceEditor::_tile_proxy_object_changed(String p_what) { void RTileSetAtlasSourceEditor::_tile_proxy_object_changed(String p_what) {
tile_set_changed_needs_update = false; // Avoid updating too many things. tile_set_changed_needs_update = false; // Avoid updating too many things.
_update_atlas_view(); _update_atlas_view();
} }
void TileSetAtlasSourceEditor::_atlas_source_proxy_object_changed(String p_what) { void RTileSetAtlasSourceEditor::_atlas_source_proxy_object_changed(String p_what) {
if (p_what == "texture" && !atlas_source_proxy_object->get("texture").is_null()) { if (p_what == "texture" && !atlas_source_proxy_object->get("texture").is_null()) {
confirm_auto_create_tiles->popup_centered(); confirm_auto_create_tiles->popup_centered();
} else if (p_what == "id") { } else if (p_what == "id") {
@ -2047,7 +2047,7 @@ void TileSetAtlasSourceEditor::_atlas_source_proxy_object_changed(String p_what)
} }
} }
void TileSetAtlasSourceEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Object *p_edited, String p_property, Variant p_new_value) { void RTileSetAtlasSourceEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Object *p_edited, String p_property, Variant p_new_value) {
UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo); UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo);
ERR_FAIL_COND(!undo_redo); ERR_FAIL_COND(!undo_redo);
@ -2116,7 +2116,7 @@ void TileSetAtlasSourceEditor::_undo_redo_inspector_callback(Object *p_undo_redo
#undef ADD_UNDO #undef ADD_UNDO
} }
void TileSetAtlasSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetAtlasSource *p_tile_set_atlas_source, int p_source_id) { void RTileSetAtlasSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetAtlasSource *p_tile_set_atlas_source, int p_source_id) {
ERR_FAIL_COND(!p_tile_set.is_valid()); ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(!p_tile_set_atlas_source); ERR_FAIL_COND(!p_tile_set_atlas_source);
ERR_FAIL_COND(p_source_id < 0); ERR_FAIL_COND(p_source_id < 0);
@ -2128,7 +2128,7 @@ void TileSetAtlasSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetAtlasSource
// Remove listener for old objects. // Remove listener for old objects.
if (tile_set.is_valid()) { if (tile_set.is_valid()) {
tile_set->disconnect("changed", callable_mp(this, &TileSetAtlasSourceEditor::_tile_set_changed)); tile_set->disconnect("changed", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_set_changed));
} }
// Clear the selection. // Clear the selection.
@ -2141,7 +2141,7 @@ void TileSetAtlasSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetAtlasSource
// Add the listener again. // Add the listener again.
if (tile_set.is_valid()) { if (tile_set.is_valid()) {
tile_set->connect("changed", callable_mp(this, &TileSetAtlasSourceEditor::_tile_set_changed)); tile_set->connect("changed", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_set_changed));
} }
// Update everything. // Update everything.
@ -2157,11 +2157,11 @@ void TileSetAtlasSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetAtlasSource
_update_current_tile_data_editor(); _update_current_tile_data_editor();
} }
void TileSetAtlasSourceEditor::init_source() { void RTileSetAtlasSourceEditor::init_source() {
confirm_auto_create_tiles->popup_centered(); confirm_auto_create_tiles->popup_centered();
} }
void TileSetAtlasSourceEditor::_auto_create_tiles() { void RTileSetAtlasSourceEditor::_auto_create_tiles() {
if (!tile_set_atlas_source) { if (!tile_set_atlas_source) {
return; return;
} }
@ -2205,7 +2205,7 @@ void TileSetAtlasSourceEditor::_auto_create_tiles() {
} }
} }
void TileSetAtlasSourceEditor::_auto_remove_tiles() { void RTileSetAtlasSourceEditor::_auto_remove_tiles() {
if (!tile_set_atlas_source) { if (!tile_set_atlas_source) {
return; return;
} }
@ -2266,7 +2266,7 @@ void TileSetAtlasSourceEditor::_auto_remove_tiles() {
} }
} }
void TileSetAtlasSourceEditor::_notification(int p_what) { void RTileSetAtlasSourceEditor::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_TREE: case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_THEME_CHANGED:
@ -2303,14 +2303,14 @@ void TileSetAtlasSourceEditor::_notification(int p_what) {
} }
} }
void TileSetAtlasSourceEditor::_bind_methods() { void RTileSetAtlasSourceEditor::_bind_methods() {
ClassDB::bind_method(D_METHOD("_unhandled_key_input"), &TileSetAtlasSourceEditor::_unhandled_key_input); ClassDB::bind_method(D_METHOD("_unhandled_key_input"), &RTileSetAtlasSourceEditor::_unhandled_key_input);
ClassDB::bind_method(D_METHOD("_set_selection_from_array"), &TileSetAtlasSourceEditor::_set_selection_from_array); ClassDB::bind_method(D_METHOD("_set_selection_from_array"), &RTileSetAtlasSourceEditor::_set_selection_from_array);
ADD_SIGNAL(MethodInfo("source_id_changed", PropertyInfo(Variant::INT, "source_id"))); ADD_SIGNAL(MethodInfo("source_id_changed", PropertyInfo(Variant::INT, "source_id")));
} }
TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() { RTileSetAtlasSourceEditor::RTileSetAtlasSourceEditor() {
set_process_unhandled_key_input(true); set_process_unhandled_key_input(true);
set_process_internal(true); set_process_internal(true);
@ -2335,14 +2335,14 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
middle_vbox_container->add_child(tile_inspector_label); middle_vbox_container->add_child(tile_inspector_label);
tile_proxy_object = memnew(AtlasTileProxyObject(this)); tile_proxy_object = memnew(AtlasTileProxyObject(this));
tile_proxy_object->connect("changed", callable_mp(this, &TileSetAtlasSourceEditor::_tile_proxy_object_changed)); tile_proxy_object->connect("changed", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_proxy_object_changed));
tile_inspector = memnew(EditorInspector); tile_inspector = memnew(EditorInspector);
tile_inspector->set_undo_redo(undo_redo); tile_inspector->set_undo_redo(undo_redo);
tile_inspector->set_vertical_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED); tile_inspector->set_vertical_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);
tile_inspector->edit(tile_proxy_object); tile_inspector->edit(tile_proxy_object);
tile_inspector->set_use_folding(true); tile_inspector->set_use_folding(true);
tile_inspector->connect("property_selected", callable_mp(this, &TileSetAtlasSourceEditor::_inspector_property_selected)); tile_inspector->connect("property_selected", callable_mp(this, &RTileSetAtlasSourceEditor::_inspector_property_selected));
middle_vbox_container->add_child(tile_inspector); middle_vbox_container->add_child(tile_inspector);
tile_inspector_no_tile_selected_label = memnew(Label); tile_inspector_no_tile_selected_label = memnew(Label);
@ -2358,8 +2358,8 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
middle_vbox_container->add_child(tile_data_editors_label); middle_vbox_container->add_child(tile_data_editors_label);
tile_data_editor_dropdown_button = memnew(Button); tile_data_editor_dropdown_button = memnew(Button);
tile_data_editor_dropdown_button->connect("draw", callable_mp(this, &TileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_draw)); tile_data_editor_dropdown_button->connect("draw", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_draw));
tile_data_editor_dropdown_button->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_pressed)); tile_data_editor_dropdown_button->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_data_editor_dropdown_button_pressed));
middle_vbox_container->add_child(tile_data_editor_dropdown_button); middle_vbox_container->add_child(tile_data_editor_dropdown_button);
tile_data_editor_dropdown_button->add_child(tile_data_editors_popup); tile_data_editor_dropdown_button->add_child(tile_data_editors_popup);
@ -2368,7 +2368,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tile_data_editors_tree->set_anchors_and_offsets_preset(Control::PRESET_WIDE); tile_data_editors_tree->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
tile_data_editors_tree->set_h_scroll_enabled(false); tile_data_editors_tree->set_h_scroll_enabled(false);
tile_data_editors_tree->set_v_scroll_enabled(false); tile_data_editors_tree->set_v_scroll_enabled(false);
tile_data_editors_tree->connect("item_selected", callable_mp(this, &TileSetAtlasSourceEditor::_tile_data_editors_tree_selected)); tile_data_editors_tree->connect("item_selected", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_data_editors_tree_selected));
tile_data_editors_popup->add_child(tile_data_editors_tree); tile_data_editors_popup->add_child(tile_data_editors_tree);
tile_data_painting_editor_container = memnew(VBoxContainer); tile_data_painting_editor_container = memnew(VBoxContainer);
@ -2381,7 +2381,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
middle_vbox_container->add_child(atlas_source_inspector_label); middle_vbox_container->add_child(atlas_source_inspector_label);
atlas_source_proxy_object = memnew(TileSetAtlasSourceProxyObject()); atlas_source_proxy_object = memnew(TileSetAtlasSourceProxyObject());
atlas_source_proxy_object->connect("changed", callable_mp(this, &TileSetAtlasSourceEditor::_atlas_source_proxy_object_changed)); atlas_source_proxy_object->connect("changed", callable_mp(this, &RTileSetAtlasSourceEditor::_atlas_source_proxy_object_changed));
atlas_source_inspector = memnew(EditorInspector); atlas_source_inspector = memnew(EditorInspector);
atlas_source_inspector->set_undo_redo(undo_redo); atlas_source_inspector->set_undo_redo(undo_redo);
@ -2401,19 +2401,19 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
confirm_auto_create_tiles->set_text(TTR("The atlas's texture was modified.\nWould you like to automatically create tiles in the atlas?")); confirm_auto_create_tiles->set_text(TTR("The atlas's texture was modified.\nWould you like to automatically create tiles in the atlas?"));
confirm_auto_create_tiles->get_ok_button()->set_text(TTR("Yes")); confirm_auto_create_tiles->get_ok_button()->set_text(TTR("Yes"));
confirm_auto_create_tiles->add_cancel_button()->set_text(TTR("No")); confirm_auto_create_tiles->add_cancel_button()->set_text(TTR("No"));
confirm_auto_create_tiles->connect("confirmed", callable_mp(this, &TileSetAtlasSourceEditor::_auto_create_tiles)); confirm_auto_create_tiles->connect("confirmed", callable_mp(this, &RTileSetAtlasSourceEditor::_auto_create_tiles));
add_child(confirm_auto_create_tiles); add_child(confirm_auto_create_tiles);
// -- Toolbox -- // -- Toolbox --
tools_button_group.instantiate(); tools_button_group.instantiate();
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_fix_selected_and_hovered_tiles).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_fix_selected_and_hovered_tiles).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_tile_id_label).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_tile_id_label).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_atlas_source_inspector).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_atlas_source_inspector).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_tile_inspector).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_tile_inspector).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_tile_data_editors).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_tile_data_editors).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_current_tile_data_editor).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_current_tile_data_editor).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_atlas_view).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_atlas_view).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &TileSetAtlasSourceEditor::_update_toolbar).unbind(1)); tools_button_group->connect("pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_update_toolbar).unbind(1));
toolbox = memnew(HBoxContainer); toolbox = memnew(HBoxContainer);
right_panel->add_child(toolbox); right_panel->add_child(toolbox);
@ -2462,7 +2462,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tool_advanced_menu_buttom->set_flat(true); tool_advanced_menu_buttom->set_flat(true);
tool_advanced_menu_buttom->get_popup()->add_item(TTR("Create Tiles in Non-Transparent Texture Regions"), ADVANCED_AUTO_CREATE_TILES); tool_advanced_menu_buttom->get_popup()->add_item(TTR("Create Tiles in Non-Transparent Texture Regions"), ADVANCED_AUTO_CREATE_TILES);
tool_advanced_menu_buttom->get_popup()->add_item(TTR("Remove Tiles in Fully Transparent Texture Regions"), ADVANCED_AUTO_REMOVE_TILES); tool_advanced_menu_buttom->get_popup()->add_item(TTR("Remove Tiles in Fully Transparent Texture Regions"), ADVANCED_AUTO_REMOVE_TILES);
tool_advanced_menu_buttom->get_popup()->connect("id_pressed", callable_mp(this, &TileSetAtlasSourceEditor::_menu_option)); tool_advanced_menu_buttom->get_popup()->connect("id_pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_menu_option));
toolbox->add_child(tool_advanced_menu_buttom); toolbox->add_child(tool_advanced_menu_buttom);
_update_toolbar(); _update_toolbar();
@ -2478,50 +2478,50 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
_update_tile_id_label(); _update_tile_id_label();
// Tile atlas view. // Tile atlas view.
tile_atlas_view = memnew(TileAtlasView); tile_atlas_view = memnew(RTileAtlasView);
tile_atlas_view->set_h_size_flags(SIZE_EXPAND_FILL); tile_atlas_view->set_h_size_flags(SIZE_EXPAND_FILL);
tile_atlas_view->set_v_size_flags(SIZE_EXPAND_FILL); tile_atlas_view->set_v_size_flags(SIZE_EXPAND_FILL);
tile_atlas_view->connect("transform_changed", callable_mp(TilesEditorPlugin::get_singleton(), &TilesEditorPlugin::set_atlas_view_transform)); tile_atlas_view->connect("transform_changed", callable_mp(RTilesEditorPlugin::get_singleton(), &RTilesEditorPlugin::set_atlas_view_transform));
tile_atlas_view->connect("transform_changed", callable_mp(this, &TileSetAtlasSourceEditor::_tile_atlas_view_transform_changed).unbind(2)); tile_atlas_view->connect("transform_changed", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_atlas_view_transform_changed).unbind(2));
right_panel->add_child(tile_atlas_view); right_panel->add_child(tile_atlas_view);
base_tile_popup_menu = memnew(PopupMenu); base_tile_popup_menu = memnew(PopupMenu);
base_tile_popup_menu->add_shortcut(ED_SHORTCUT("tiles_editor/delete", TTR("Delete"), Key::KEY_DELETE), TILE_DELETE); base_tile_popup_menu->add_shortcut(ED_SHORTCUT("tiles_editor/delete", TTR("Delete"), Key::KEY_DELETE), TILE_DELETE);
base_tile_popup_menu->add_item(TTR("Create an Alternative Tile"), TILE_CREATE_ALTERNATIVE); base_tile_popup_menu->add_item(TTR("Create an Alternative Tile"), TILE_CREATE_ALTERNATIVE);
base_tile_popup_menu->connect("id_pressed", callable_mp(this, &TileSetAtlasSourceEditor::_menu_option)); base_tile_popup_menu->connect("id_pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_menu_option));
tile_atlas_view->add_child(base_tile_popup_menu); tile_atlas_view->add_child(base_tile_popup_menu);
empty_base_tile_popup_menu = memnew(PopupMenu); empty_base_tile_popup_menu = memnew(PopupMenu);
empty_base_tile_popup_menu->add_item(TTR("Create a Tile"), TILE_CREATE); empty_base_tile_popup_menu->add_item(TTR("Create a Tile"), TILE_CREATE);
empty_base_tile_popup_menu->connect("id_pressed", callable_mp(this, &TileSetAtlasSourceEditor::_menu_option)); empty_base_tile_popup_menu->connect("id_pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_menu_option));
tile_atlas_view->add_child(empty_base_tile_popup_menu); tile_atlas_view->add_child(empty_base_tile_popup_menu);
tile_atlas_control = memnew(Control); tile_atlas_control = memnew(Control);
tile_atlas_control->connect("draw", callable_mp(this, &TileSetAtlasSourceEditor::_tile_atlas_control_draw)); tile_atlas_control->connect("draw", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_atlas_control_draw));
tile_atlas_control->connect("mouse_exited", callable_mp(this, &TileSetAtlasSourceEditor::_tile_atlas_control_mouse_exited)); tile_atlas_control->connect("mouse_exited", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_atlas_control_mouse_exited));
tile_atlas_control->connect("gui_input", callable_mp(this, &TileSetAtlasSourceEditor::_tile_atlas_control_gui_input)); tile_atlas_control->connect("gui_input", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_atlas_control_gui_input));
tile_atlas_view->add_control_over_atlas_tiles(tile_atlas_control); tile_atlas_view->add_control_over_atlas_tiles(tile_atlas_control);
tile_atlas_control_unscaled = memnew(Control); tile_atlas_control_unscaled = memnew(Control);
tile_atlas_control_unscaled->set_anchors_and_offsets_preset(Control::PRESET_WIDE); tile_atlas_control_unscaled->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
tile_atlas_control_unscaled->connect("draw", callable_mp(this, &TileSetAtlasSourceEditor::_tile_atlas_control_unscaled_draw)); tile_atlas_control_unscaled->connect("draw", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_atlas_control_unscaled_draw));
tile_atlas_view->add_control_over_atlas_tiles(tile_atlas_control_unscaled, false); tile_atlas_view->add_control_over_atlas_tiles(tile_atlas_control_unscaled, false);
tile_atlas_control_unscaled->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); tile_atlas_control_unscaled->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
alternative_tile_popup_menu = memnew(PopupMenu); alternative_tile_popup_menu = memnew(PopupMenu);
alternative_tile_popup_menu->add_shortcut(ED_SHORTCUT("tiles_editor/delete_tile", TTR("Delete"), Key::KEY_DELETE), TILE_DELETE); alternative_tile_popup_menu->add_shortcut(ED_SHORTCUT("tiles_editor/delete_tile", TTR("Delete"), Key::KEY_DELETE), TILE_DELETE);
alternative_tile_popup_menu->connect("id_pressed", callable_mp(this, &TileSetAtlasSourceEditor::_menu_option)); alternative_tile_popup_menu->connect("id_pressed", callable_mp(this, &RTileSetAtlasSourceEditor::_menu_option));
tile_atlas_view->add_child(alternative_tile_popup_menu); tile_atlas_view->add_child(alternative_tile_popup_menu);
alternative_tiles_control = memnew(Control); alternative_tiles_control = memnew(Control);
alternative_tiles_control->connect("draw", callable_mp(this, &TileSetAtlasSourceEditor::_tile_alternatives_control_draw)); alternative_tiles_control->connect("draw", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_alternatives_control_draw));
alternative_tiles_control->connect("mouse_exited", callable_mp(this, &TileSetAtlasSourceEditor::_tile_alternatives_control_mouse_exited)); alternative_tiles_control->connect("mouse_exited", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_alternatives_control_mouse_exited));
alternative_tiles_control->connect("gui_input", callable_mp(this, &TileSetAtlasSourceEditor::_tile_alternatives_control_gui_input)); alternative_tiles_control->connect("gui_input", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_alternatives_control_gui_input));
tile_atlas_view->add_control_over_alternative_tiles(alternative_tiles_control); tile_atlas_view->add_control_over_alternative_tiles(alternative_tiles_control);
alternative_tiles_control_unscaled = memnew(Control); alternative_tiles_control_unscaled = memnew(Control);
alternative_tiles_control_unscaled->set_anchors_and_offsets_preset(Control::PRESET_WIDE); alternative_tiles_control_unscaled->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
alternative_tiles_control_unscaled->connect("draw", callable_mp(this, &TileSetAtlasSourceEditor::_tile_alternatives_control_unscaled_draw)); alternative_tiles_control_unscaled->connect("draw", callable_mp(this, &RTileSetAtlasSourceEditor::_tile_alternatives_control_unscaled_draw));
tile_atlas_view->add_control_over_alternative_tiles(alternative_tiles_control_unscaled, false); tile_atlas_view->add_control_over_alternative_tiles(alternative_tiles_control_unscaled, false);
alternative_tiles_control_unscaled->set_mouse_filter(Control::MOUSE_FILTER_IGNORE); alternative_tiles_control_unscaled->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
@ -2534,22 +2534,22 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tile_atlas_view_missing_source_label->hide(); tile_atlas_view_missing_source_label->hide();
right_panel->add_child(tile_atlas_view_missing_source_label); right_panel->add_child(tile_atlas_view_missing_source_label);
EditorNode::get_singleton()->get_editor_data().add_undo_redo_inspector_hook_callback(callable_mp(this, &TileSetAtlasSourceEditor::_undo_redo_inspector_callback)); EditorNode::get_singleton()->get_editor_data().add_undo_redo_inspector_hook_callback(callable_mp(this, &RTileSetAtlasSourceEditor::_undo_redo_inspector_callback));
// Inspector plugin. // Inspector plugin.
Ref<EditorInspectorPluginTileData> tile_data_inspector_plugin; Ref<REditorInspectorPluginTileData> tile_data_inspector_plugin;
tile_data_inspector_plugin.instantiate(); tile_data_inspector_plugin.instantiate();
EditorInspector::add_inspector_plugin(tile_data_inspector_plugin); EditorInspector::add_inspector_plugin(tile_data_inspector_plugin);
} }
TileSetAtlasSourceEditor::~TileSetAtlasSourceEditor() { RTileSetAtlasSourceEditor::~RTileSetAtlasSourceEditor() {
memdelete(tile_proxy_object); memdelete(tile_proxy_object);
memdelete(atlas_source_proxy_object); memdelete(atlas_source_proxy_object);
} }
////// EditorPropertyTilePolygon ////// ////// REditorPropertyTilePolygon //////
void EditorPropertyTilePolygon::_add_focusable_children(Node *p_node) { void REditorPropertyTilePolygon::_add_focusable_children(Node *p_node) {
Control *control = Object::cast_to<Control>(p_node); Control *control = Object::cast_to<Control>(p_node);
if (control && control->get_focus_mode() != Control::FOCUS_NONE) { if (control && control->get_focus_mode() != Control::FOCUS_NONE) {
add_focusable(control); add_focusable(control);
@ -2559,7 +2559,7 @@ void EditorPropertyTilePolygon::_add_focusable_children(Node *p_node) {
} }
} }
void EditorPropertyTilePolygon::_polygons_changed() { void REditorPropertyTilePolygon::_polygons_changed() {
if (String(count_property).is_empty()) { if (String(count_property).is_empty()) {
if (base_type == "OccluderPolygon2D") { if (base_type == "OccluderPolygon2D") {
// Single OccluderPolygon2D. // Single OccluderPolygon2D.
@ -2598,8 +2598,8 @@ void EditorPropertyTilePolygon::_polygons_changed() {
} }
} }
void EditorPropertyTilePolygon::update_property() { void REditorPropertyTilePolygon::update_property() {
TileSetAtlasSourceEditor::AtlasTileProxyObject *atlas_tile_proxy_object = Object::cast_to<TileSetAtlasSourceEditor::AtlasTileProxyObject>(get_edited_object()); RTileSetAtlasSourceEditor::AtlasTileProxyObject *atlas_tile_proxy_object = Object::cast_to<RTileSetAtlasSourceEditor::AtlasTileProxyObject>(get_edited_object());
ERR_FAIL_COND(!atlas_tile_proxy_object); ERR_FAIL_COND(!atlas_tile_proxy_object);
ERR_FAIL_COND(atlas_tile_proxy_object->get_edited_tiles().is_empty()); ERR_FAIL_COND(atlas_tile_proxy_object->get_edited_tiles().is_empty());
@ -2645,14 +2645,14 @@ void EditorPropertyTilePolygon::update_property() {
} }
} }
void EditorPropertyTilePolygon::setup_single_mode(const StringName &p_property, const String &p_base_type) { void REditorPropertyTilePolygon::setup_single_mode(const StringName &p_property, const String &p_base_type) {
set_object_and_property(nullptr, p_property); set_object_and_property(nullptr, p_property);
base_type = p_base_type; base_type = p_base_type;
generic_tile_polygon_editor->set_multiple_polygon_mode(false); generic_tile_polygon_editor->set_multiple_polygon_mode(false);
} }
void EditorPropertyTilePolygon::setup_multiple_mode(const StringName &p_property, const StringName &p_count_property, const String &p_element_pattern, const String &p_base_type) { void REditorPropertyTilePolygon::setup_multiple_mode(const StringName &p_property, const StringName &p_count_property, const String &p_element_pattern, const String &p_base_type) {
set_object_and_property(nullptr, p_property); set_object_and_property(nullptr, p_property);
count_property = p_count_property; count_property = p_count_property;
element_pattern = p_element_pattern; element_pattern = p_element_pattern;
@ -2661,32 +2661,32 @@ void EditorPropertyTilePolygon::setup_multiple_mode(const StringName &p_property
generic_tile_polygon_editor->set_multiple_polygon_mode(true); generic_tile_polygon_editor->set_multiple_polygon_mode(true);
} }
EditorPropertyTilePolygon::EditorPropertyTilePolygon() { REditorPropertyTilePolygon::REditorPropertyTilePolygon() {
// Setup the polygon editor. // Setup the polygon editor.
generic_tile_polygon_editor = memnew(GenericTilePolygonEditor); generic_tile_polygon_editor = memnew(GenericTilePolygonEditor);
generic_tile_polygon_editor->set_use_undo_redo(false); generic_tile_polygon_editor->set_use_undo_redo(false);
generic_tile_polygon_editor->clear_polygons(); generic_tile_polygon_editor->clear_polygons();
add_child(generic_tile_polygon_editor); add_child(generic_tile_polygon_editor);
generic_tile_polygon_editor->connect("polygons_changed", callable_mp(this, &EditorPropertyTilePolygon::_polygons_changed)); generic_tile_polygon_editor->connect("polygons_changed", callable_mp(this, &REditorPropertyTilePolygon::_polygons_changed));
// Add all focussable children of generic_tile_polygon_editor as focussable. // Add all focussable children of generic_tile_polygon_editor as focussable.
_add_focusable_children(generic_tile_polygon_editor); _add_focusable_children(generic_tile_polygon_editor);
} }
////// EditorInspectorPluginTileData ////// ////// REditorInspectorPluginTileData //////
bool EditorInspectorPluginTileData::can_handle(Object *p_object) { bool REditorInspectorPluginTileData::can_handle(Object *p_object) {
return Object::cast_to<TileSetAtlasSourceEditor::AtlasTileProxyObject>(p_object) != nullptr; return Object::cast_to<RTileSetAtlasSourceEditor::AtlasTileProxyObject>(p_object) != nullptr;
} }
bool EditorInspectorPluginTileData::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const uint32_t p_usage, const bool p_wide) { bool REditorInspectorPluginTileData::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const uint32_t p_usage, const bool p_wide) {
Vector<String> components = String(p_path).split("/", true, 2); Vector<String> components = String(p_path).split("/", true, 2);
if (components.size() == 2 && components[0].begins_with("occlusion_layer_") && components[0].trim_prefix("occlusion_layer_").is_valid_int()) { if (components.size() == 2 && components[0].begins_with("occlusion_layer_") && components[0].trim_prefix("occlusion_layer_").is_valid_int()) {
// Occlusion layers. // Occlusion layers.
int layer_index = components[0].trim_prefix("occlusion_layer_").to_int(); int layer_index = components[0].trim_prefix("occlusion_layer_").to_int();
ERR_FAIL_COND_V(layer_index < 0, false); ERR_FAIL_COND_V(layer_index < 0, false);
if (components[1] == "polygon") { if (components[1] == "polygon") {
EditorPropertyTilePolygon *ep = memnew(EditorPropertyTilePolygon); REditorPropertyTilePolygon *ep = memnew(REditorPropertyTilePolygon);
ep->setup_single_mode(p_path, "OccluderPolygon2D"); ep->setup_single_mode(p_path, "OccluderPolygon2D");
add_property_editor(p_path, ep); add_property_editor(p_path, ep);
return true; return true;
@ -2696,7 +2696,7 @@ bool EditorInspectorPluginTileData::parse_property(Object *p_object, const Varia
int layer_index = components[0].trim_prefix("physics_layer_").to_int(); int layer_index = components[0].trim_prefix("physics_layer_").to_int();
ERR_FAIL_COND_V(layer_index < 0, false); ERR_FAIL_COND_V(layer_index < 0, false);
if (components[1] == "polygons_count") { if (components[1] == "polygons_count") {
EditorPropertyTilePolygon *ep = memnew(EditorPropertyTilePolygon); REditorPropertyTilePolygon *ep = memnew(REditorPropertyTilePolygon);
ep->setup_multiple_mode(vformat("physics_layer_%d/polygons", layer_index), vformat("physics_layer_%d/polygons_count", layer_index), vformat("physics_layer_%d/polygon_%%d/points", layer_index), ""); ep->setup_multiple_mode(vformat("physics_layer_%d/polygons", layer_index), vformat("physics_layer_%d/polygons_count", layer_index), vformat("physics_layer_%d/polygon_%%d/points", layer_index), "");
Vector<String> properties; Vector<String> properties;
properties.push_back(p_path); properties.push_back(p_path);
@ -2718,7 +2718,7 @@ bool EditorInspectorPluginTileData::parse_property(Object *p_object, const Varia
int layer_index = components[0].trim_prefix("navigation_layer_").to_int(); int layer_index = components[0].trim_prefix("navigation_layer_").to_int();
ERR_FAIL_COND_V(layer_index < 0, false); ERR_FAIL_COND_V(layer_index < 0, false);
if (components[1] == "polygon") { if (components[1] == "polygon") {
EditorPropertyTilePolygon *ep = memnew(EditorPropertyTilePolygon); REditorPropertyTilePolygon *ep = memnew(REditorPropertyTilePolygon);
ep->setup_single_mode(p_path, "NavigationPolygon"); ep->setup_single_mode(p_path, "NavigationPolygon");
add_property_editor(p_path, ep); add_property_editor(p_path, ep);
return true; return true;

32
tile_editor/tile_set_atlas_source_editor.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILE_SET_ATLAS_SOURCE_EDITOR_H #ifndef RTILE_SET_ATLAS_SOURCE_EDITOR_H
#define TILE_SET_ATLAS_SOURCE_EDITOR_H #define RTILE_SET_ATLAS_SOURCE_EDITOR_H
#include "tile_atlas_view.h" #include "tile_atlas_view.h"
#include "tile_data_editors.h" #include "tile_data_editors.h"
@ -40,8 +40,8 @@
class TileSet; class TileSet;
class TileSetAtlasSourceEditor : public HBoxContainer { class RTileSetAtlasSourceEditor : public HBoxContainer {
GDCLASS(TileSetAtlasSourceEditor, HBoxContainer); GDCLASS(RTileSetAtlasSourceEditor, HBoxContainer);
public: public:
// A class to store which tiles are selected. // A class to store which tiles are selected.
@ -86,7 +86,7 @@ public:
GDCLASS(AtlasTileProxyObject, Object); GDCLASS(AtlasTileProxyObject, Object);
private: private:
TileSetAtlasSourceEditor *tiles_set_atlas_source_editor; RTileSetAtlasSourceEditor *tiles_set_atlas_source_editor;
TileSetAtlasSource *tile_set_atlas_source = nullptr; TileSetAtlasSource *tile_set_atlas_source = nullptr;
Set<TileSelection> tiles = Set<TileSelection>(); Set<TileSelection> tiles = Set<TileSelection>();
@ -105,7 +105,7 @@ public:
// Update the proxyed object. // Update the proxyed object.
void edit(TileSetAtlasSource *p_tile_set_atlas_source, Set<TileSelection> p_tiles = Set<TileSelection>()); void edit(TileSetAtlasSource *p_tile_set_atlas_source, Set<TileSelection> p_tiles = Set<TileSelection>());
AtlasTileProxyObject(TileSetAtlasSourceEditor *p_tiles_set_atlas_source_editor) { AtlasTileProxyObject(RTileSetAtlasSourceEditor *p_tiles_set_atlas_source_editor) {
tiles_set_atlas_source_editor = p_tiles_set_atlas_source_editor; tiles_set_atlas_source_editor = p_tiles_set_atlas_source_editor;
} }
}; };
@ -131,8 +131,8 @@ private:
// -- Tile data editors -- // -- Tile data editors --
String current_property; String current_property;
Control *current_tile_data_editor_toolbar = nullptr; Control *current_tile_data_editor_toolbar = nullptr;
Map<String, TileDataEditor *> tile_data_editors; Map<String, RTileDataEditor *> tile_data_editors;
TileDataEditor *current_tile_data_editor = nullptr; RTileDataEditor *current_tile_data_editor = nullptr;
void _tile_data_editors_tree_selected(); void _tile_data_editors_tree_selected();
// -- Inspector -- // -- Inspector --
@ -150,7 +150,7 @@ private:
// -- Atlas view -- // -- Atlas view --
HBoxContainer *toolbox; HBoxContainer *toolbox;
Label *tile_atlas_view_missing_source_label; Label *tile_atlas_view_missing_source_label;
TileAtlasView *tile_atlas_view; RTileAtlasView *tile_atlas_view;
// Dragging // Dragging
enum DragType { enum DragType {
@ -281,12 +281,12 @@ public:
void edit(Ref<TileSet> p_tile_set, TileSetAtlasSource *p_tile_set_source, int p_source_id); void edit(Ref<TileSet> p_tile_set, TileSetAtlasSource *p_tile_set_source, int p_source_id);
void init_source(); void init_source();
TileSetAtlasSourceEditor(); RTileSetAtlasSourceEditor();
~TileSetAtlasSourceEditor(); ~RTileSetAtlasSourceEditor();
}; };
class EditorPropertyTilePolygon : public EditorProperty { class REditorPropertyTilePolygon : public EditorProperty {
GDCLASS(EditorPropertyTilePolygon, EditorProperty); GDCLASS(REditorPropertyTilePolygon, EditorProperty);
StringName count_property; StringName count_property;
String element_pattern; String element_pattern;
@ -301,11 +301,11 @@ public:
virtual void update_property() override; virtual void update_property() override;
void setup_single_mode(const StringName &p_property, const String &p_base_type); void setup_single_mode(const StringName &p_property, const String &p_base_type);
void setup_multiple_mode(const StringName &p_property, const StringName &p_count_property, const String &p_element_pattern, const String &p_base_type); void setup_multiple_mode(const StringName &p_property, const StringName &p_count_property, const String &p_element_pattern, const String &p_base_type);
EditorPropertyTilePolygon(); REditorPropertyTilePolygon();
}; };
class EditorInspectorPluginTileData : public EditorInspectorPlugin { class REditorInspectorPluginTileData : public EditorInspectorPlugin {
GDCLASS(EditorInspectorPluginTileData, EditorInspectorPlugin); GDCLASS(REditorInspectorPluginTileData, EditorInspectorPlugin);
void _occlusion_polygon_set_callback(); void _occlusion_polygon_set_callback();
void _polygons_changed(Object *p_generic_tile_polygon_editor, Object *p_object, const String &p_path); void _polygons_changed(Object *p_generic_tile_polygon_editor, Object *p_object, const String &p_path);

86
tile_editor/tile_set_editor.cpp
View File

@ -39,9 +39,9 @@
#include "scene/gui/control.h" #include "scene/gui/control.h"
#include "scene/gui/tab_container.h" #include "scene/gui/tab_container.h"
TileSetEditor *TileSetEditor::singleton = nullptr; RTileSetEditor *RTileSetEditor::singleton = nullptr;
void TileSetEditor::_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { void RTileSetEditor::_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
if (!_can_drop_data_fw(p_point, p_data, p_from)) { if (!_can_drop_data_fw(p_point, p_data, p_from)) {
@ -81,7 +81,7 @@ void TileSetEditor::_drop_data_fw(const Point2 &p_point, const Variant &p_data,
} }
} }
bool TileSetEditor::_can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const { bool RTileSetEditor::_can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
ERR_FAIL_COND_V(!tile_set.is_valid(), false); ERR_FAIL_COND_V(!tile_set.is_valid(), false);
if (p_from == sources_list) { if (p_from == sources_list) {
@ -114,7 +114,7 @@ bool TileSetEditor::_can_drop_data_fw(const Point2 &p_point, const Variant &p_da
return false; return false;
} }
void TileSetEditor::_update_sources_list(int force_selected_id) { void RTileSetEditor::_update_sources_list(int force_selected_id) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
// Get the previously selected id. // Get the previously selected id.
@ -209,10 +209,10 @@ void TileSetEditor::_update_sources_list(int force_selected_id) {
_source_selected(sources_list->get_current()); _source_selected(sources_list->get_current());
// Synchronize the lists. // Synchronize the lists.
TilesEditorPlugin::get_singleton()->set_sources_lists_current(sources_list->get_current()); RTilesEditorPlugin::get_singleton()->set_sources_lists_current(sources_list->get_current());
} }
void TileSetEditor::_source_selected(int p_source_index) { void RTileSetEditor::_source_selected(int p_source_index) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
// Update the selected source. // Update the selected source.
@ -244,7 +244,7 @@ void TileSetEditor::_source_selected(int p_source_index) {
} }
} }
void TileSetEditor::_source_delete_pressed() { void RTileSetEditor::_source_delete_pressed() {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
// Update the selected source. // Update the selected source.
@ -261,7 +261,7 @@ void TileSetEditor::_source_delete_pressed() {
_update_sources_list(); _update_sources_list();
} }
void TileSetEditor::_source_add_id_pressed(int p_id_pressed) { void RTileSetEditor::_source_add_id_pressed(int p_id_pressed) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
switch (p_id_pressed) { switch (p_id_pressed) {
@ -297,7 +297,7 @@ void TileSetEditor::_source_add_id_pressed(int p_id_pressed) {
} }
} }
void TileSetEditor::_sources_advanced_menu_id_pressed(int p_id_pressed) { void RTileSetEditor::_sources_advanced_menu_id_pressed(int p_id_pressed) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
switch (p_id_pressed) { switch (p_id_pressed) {
@ -312,7 +312,7 @@ void TileSetEditor::_sources_advanced_menu_id_pressed(int p_id_pressed) {
} }
} }
void TileSetEditor::_notification(int p_what) { void RTileSetEditor::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_TREE: case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_THEME_CHANGED:
@ -336,7 +336,7 @@ void TileSetEditor::_notification(int p_what) {
} }
} }
void TileSetEditor::_patterns_item_list_gui_input(const Ref<InputEvent> &p_event) { void RTileSetEditor::_patterns_item_list_gui_input(const Ref<InputEvent> &p_event) {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
if (ED_IS_SHORTCUT("tiles_editor/delete", p_event) && p_event->is_pressed() && !p_event->is_echo()) { if (ED_IS_SHORTCUT("tiles_editor/delete", p_event) && p_event->is_pressed() && !p_event->is_echo()) {
@ -352,7 +352,7 @@ void TileSetEditor::_patterns_item_list_gui_input(const Ref<InputEvent> &p_event
} }
} }
void TileSetEditor::_pattern_preview_done(Ref<TileMapPattern> p_pattern, Ref<Texture2D> p_texture) { void RTileSetEditor::_pattern_preview_done(Ref<TileMapPattern> p_pattern, Ref<Texture2D> p_texture) {
// TODO optimize ? // TODO optimize ?
for (int i = 0; i < patterns_item_list->get_item_count(); i++) { for (int i = 0; i < patterns_item_list->get_item_count(); i++) {
if (patterns_item_list->get_item_metadata(i) == p_pattern) { if (patterns_item_list->get_item_metadata(i) == p_pattern) {
@ -362,7 +362,7 @@ void TileSetEditor::_pattern_preview_done(Ref<TileMapPattern> p_pattern, Ref<Tex
} }
} }
void TileSetEditor::_update_patterns_list() { void RTileSetEditor::_update_patterns_list() {
ERR_FAIL_COND(!tile_set.is_valid()); ERR_FAIL_COND(!tile_set.is_valid());
// Recreate the items. // Recreate the items.
@ -370,23 +370,23 @@ void TileSetEditor::_update_patterns_list() {
for (int i = 0; i < tile_set->get_patterns_count(); i++) { for (int i = 0; i < tile_set->get_patterns_count(); i++) {
int id = patterns_item_list->add_item(""); int id = patterns_item_list->add_item("");
patterns_item_list->set_item_metadata(id, tile_set->get_pattern(i)); patterns_item_list->set_item_metadata(id, tile_set->get_pattern(i));
TilesEditorPlugin::get_singleton()->queue_pattern_preview(tile_set, tile_set->get_pattern(i), callable_mp(this, &TileSetEditor::_pattern_preview_done)); RTilesEditorPlugin::get_singleton()->queue_pattern_preview(tile_set, tile_set->get_pattern(i), callable_mp(this, &RTileSetEditor::_pattern_preview_done));
} }
// Update the label visibility. // Update the label visibility.
patterns_help_label->set_visible(patterns_item_list->get_item_count() == 0); patterns_help_label->set_visible(patterns_item_list->get_item_count() == 0);
} }
void TileSetEditor::_tile_set_changed() { void RTileSetEditor::_tile_set_changed() {
tile_set_changed_needs_update = true; tile_set_changed_needs_update = true;
} }
void TileSetEditor::_tab_changed(int p_tab_changed) { void RTileSetEditor::_tab_changed(int p_tab_changed) {
split_container->set_visible(p_tab_changed == 0); split_container->set_visible(p_tab_changed == 0);
patterns_item_list->set_visible(p_tab_changed == 1); patterns_item_list->set_visible(p_tab_changed == 1);
} }
void TileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_edited, String p_array_prefix, int p_from_index, int p_to_pos) { void RTileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_edited, String p_array_prefix, int p_from_index, int p_to_pos) {
UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo); UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo);
ERR_FAIL_COND(!undo_redo); ERR_FAIL_COND(!undo_redo);
@ -567,7 +567,7 @@ void TileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Object *p_
} }
} }
void TileSetEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Object *p_edited, String p_property, Variant p_new_value) { void RTileSetEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Object *p_edited, String p_property, Variant p_new_value) {
UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo); UndoRedo *undo_redo = Object::cast_to<UndoRedo>(p_undo_redo);
ERR_FAIL_COND(!undo_redo); ERR_FAIL_COND(!undo_redo);
@ -607,19 +607,19 @@ void TileSetEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Object *p
#undef ADD_UNDO #undef ADD_UNDO
} }
void TileSetEditor::_bind_methods() { void RTileSetEditor::_bind_methods() {
ClassDB::bind_method(D_METHOD("_can_drop_data_fw"), &TileSetEditor::_can_drop_data_fw); ClassDB::bind_method(D_METHOD("_can_drop_data_fw"), &RTileSetEditor::_can_drop_data_fw);
ClassDB::bind_method(D_METHOD("_drop_data_fw"), &TileSetEditor::_drop_data_fw); ClassDB::bind_method(D_METHOD("_drop_data_fw"), &RTileSetEditor::_drop_data_fw);
} }
void TileSetEditor::edit(Ref<TileSet> p_tile_set) { void RTileSetEditor::edit(Ref<TileSet> p_tile_set) {
if (p_tile_set == tile_set) { if (p_tile_set == tile_set) {
return; return;
} }
// Remove listener. // Remove listener.
if (tile_set.is_valid()) { if (tile_set.is_valid()) {
tile_set->disconnect("changed", callable_mp(this, &TileSetEditor::_tile_set_changed)); tile_set->disconnect("changed", callable_mp(this, &RTileSetEditor::_tile_set_changed));
} }
// Change the edited object. // Change the edited object.
@ -627,7 +627,7 @@ void TileSetEditor::edit(Ref<TileSet> p_tile_set) {
// Add the listener again. // Add the listener again.
if (tile_set.is_valid()) { if (tile_set.is_valid()) {
tile_set->connect("changed", callable_mp(this, &TileSetEditor::_tile_set_changed)); tile_set->connect("changed", callable_mp(this, &RTileSetEditor::_tile_set_changed));
_update_sources_list(); _update_sources_list();
_update_patterns_list(); _update_patterns_list();
} }
@ -637,7 +637,7 @@ void TileSetEditor::edit(Ref<TileSet> p_tile_set) {
no_source_selected_label->show(); no_source_selected_label->show();
} }
TileSetEditor::TileSetEditor() { RTileSetEditor::RTileSetEditor() {
singleton = this; singleton = this;
set_process_internal(true); set_process_internal(true);
@ -647,7 +647,7 @@ TileSetEditor::TileSetEditor() {
tabs_bar->set_clip_tabs(false); tabs_bar->set_clip_tabs(false);
tabs_bar->add_tab(TTR("Tiles")); tabs_bar->add_tab(TTR("Tiles"));
tabs_bar->add_tab(TTR("Patterns")); tabs_bar->add_tab(TTR("Patterns"));
tabs_bar->connect("tab_changed", callable_mp(this, &TileSetEditor::_tab_changed)); tabs_bar->connect("tab_changed", callable_mp(this, &RTileSetEditor::_tab_changed));
tile_set_toolbar = memnew(HBoxContainer); tile_set_toolbar = memnew(HBoxContainer);
tile_set_toolbar->set_h_size_flags(SIZE_EXPAND_FILL); tile_set_toolbar->set_h_size_flags(SIZE_EXPAND_FILL);
@ -674,9 +674,9 @@ TileSetEditor::TileSetEditor() {
sources_list->set_fixed_icon_size(Size2i(60, 60) * EDSCALE); sources_list->set_fixed_icon_size(Size2i(60, 60) * EDSCALE);
sources_list->set_h_size_flags(SIZE_EXPAND_FILL); sources_list->set_h_size_flags(SIZE_EXPAND_FILL);
sources_list->set_v_size_flags(SIZE_EXPAND_FILL); sources_list->set_v_size_flags(SIZE_EXPAND_FILL);
sources_list->connect("item_selected", callable_mp(this, &TileSetEditor::_source_selected)); sources_list->connect("item_selected", callable_mp(this, &RTileSetEditor::_source_selected));
sources_list->connect("item_selected", callable_mp(TilesEditorPlugin::get_singleton(), &TilesEditorPlugin::set_sources_lists_current)); sources_list->connect("item_selected", callable_mp(RTilesEditorPlugin::get_singleton(), &RTilesEditorPlugin::set_sources_lists_current));
sources_list->connect("visibility_changed", callable_mp(TilesEditorPlugin::get_singleton(), &TilesEditorPlugin::synchronize_sources_list), varray(sources_list)); sources_list->connect("visibility_changed", callable_mp(RTilesEditorPlugin::get_singleton(), &RTilesEditorPlugin::synchronize_sources_list), varray(sources_list));
sources_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST); sources_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
sources_list->set_drag_forwarding(this); sources_list->set_drag_forwarding(this);
split_container_left_side->add_child(sources_list); split_container_left_side->add_child(sources_list);
@ -688,27 +688,27 @@ TileSetEditor::TileSetEditor() {
sources_delete_button = memnew(Button); sources_delete_button = memnew(Button);
sources_delete_button->set_flat(true); sources_delete_button->set_flat(true);
sources_delete_button->set_disabled(true); sources_delete_button->set_disabled(true);
sources_delete_button->connect("pressed", callable_mp(this, &TileSetEditor::_source_delete_pressed)); sources_delete_button->connect("pressed", callable_mp(this, &RTileSetEditor::_source_delete_pressed));
sources_bottom_actions->add_child(sources_delete_button); sources_bottom_actions->add_child(sources_delete_button);
sources_add_button = memnew(MenuButton); sources_add_button = memnew(MenuButton);
sources_add_button->set_flat(true); sources_add_button->set_flat(true);
sources_add_button->get_popup()->add_item(TTR("Atlas")); sources_add_button->get_popup()->add_item(TTR("Atlas"));
sources_add_button->get_popup()->add_item(TTR("Scenes Collection")); sources_add_button->get_popup()->add_item(TTR("Scenes Collection"));
sources_add_button->get_popup()->connect("id_pressed", callable_mp(this, &TileSetEditor::_source_add_id_pressed)); sources_add_button->get_popup()->connect("id_pressed", callable_mp(this, &RTileSetEditor::_source_add_id_pressed));
sources_bottom_actions->add_child(sources_add_button); sources_bottom_actions->add_child(sources_add_button);
sources_advanced_menu_button = memnew(MenuButton); sources_advanced_menu_button = memnew(MenuButton);
sources_advanced_menu_button->set_flat(true); sources_advanced_menu_button->set_flat(true);
sources_advanced_menu_button->get_popup()->add_item(TTR("Open Atlas Merging Tool")); sources_advanced_menu_button->get_popup()->add_item(TTR("Open Atlas Merging Tool"));
sources_advanced_menu_button->get_popup()->add_item(TTR("Manage Tile Proxies")); sources_advanced_menu_button->get_popup()->add_item(TTR("Manage Tile Proxies"));
sources_advanced_menu_button->get_popup()->connect("id_pressed", callable_mp(this, &TileSetEditor::_sources_advanced_menu_id_pressed)); sources_advanced_menu_button->get_popup()->connect("id_pressed", callable_mp(this, &RTileSetEditor::_sources_advanced_menu_id_pressed));
sources_bottom_actions->add_child(sources_advanced_menu_button); sources_bottom_actions->add_child(sources_advanced_menu_button);
atlas_merging_dialog = memnew(AtlasMergingDialog); atlas_merging_dialog = memnew(RAtlasMergingDialog);
add_child(atlas_merging_dialog); add_child(atlas_merging_dialog);
tile_proxies_manager_dialog = memnew(TileProxiesManagerDialog); tile_proxies_manager_dialog = memnew(RTileProxiesManagerDialog);
add_child(tile_proxies_manager_dialog); add_child(tile_proxies_manager_dialog);
// Right side container. // Right side container.
@ -727,18 +727,18 @@ TileSetEditor::TileSetEditor() {
split_container_right_side->add_child(no_source_selected_label); split_container_right_side->add_child(no_source_selected_label);
// Atlases editor. // Atlases editor.
tile_set_atlas_source_editor = memnew(TileSetAtlasSourceEditor); tile_set_atlas_source_editor = memnew(RTileSetAtlasSourceEditor);
tile_set_atlas_source_editor->set_h_size_flags(SIZE_EXPAND_FILL); tile_set_atlas_source_editor->set_h_size_flags(SIZE_EXPAND_FILL);
tile_set_atlas_source_editor->set_v_size_flags(SIZE_EXPAND_FILL); tile_set_atlas_source_editor->set_v_size_flags(SIZE_EXPAND_FILL);
tile_set_atlas_source_editor->connect("source_id_changed", callable_mp(this, &TileSetEditor::_update_sources_list)); tile_set_atlas_source_editor->connect("source_id_changed", callable_mp(this, &RTileSetEditor::_update_sources_list));
split_container_right_side->add_child(tile_set_atlas_source_editor); split_container_right_side->add_child(tile_set_atlas_source_editor);
tile_set_atlas_source_editor->hide(); tile_set_atlas_source_editor->hide();
// Scenes collection editor. // Scenes collection editor.
tile_set_scenes_collection_source_editor = memnew(TileSetScenesCollectionSourceEditor); tile_set_scenes_collection_source_editor = memnew(RTileSetScenesCollectionSourceEditor);
tile_set_scenes_collection_source_editor->set_h_size_flags(SIZE_EXPAND_FILL); tile_set_scenes_collection_source_editor->set_h_size_flags(SIZE_EXPAND_FILL);
tile_set_scenes_collection_source_editor->set_v_size_flags(SIZE_EXPAND_FILL); tile_set_scenes_collection_source_editor->set_v_size_flags(SIZE_EXPAND_FILL);
tile_set_scenes_collection_source_editor->connect("source_id_changed", callable_mp(this, &TileSetEditor::_update_sources_list)); tile_set_scenes_collection_source_editor->connect("source_id_changed", callable_mp(this, &RTileSetEditor::_update_sources_list));
split_container_right_side->add_child(tile_set_scenes_collection_source_editor); split_container_right_side->add_child(tile_set_scenes_collection_source_editor);
tile_set_scenes_collection_source_editor->hide(); tile_set_scenes_collection_source_editor->hide();
@ -751,7 +751,7 @@ TileSetEditor::TileSetEditor() {
patterns_item_list->set_max_text_lines(2); patterns_item_list->set_max_text_lines(2);
patterns_item_list->set_fixed_icon_size(Size2(thumbnail_size, thumbnail_size)); patterns_item_list->set_fixed_icon_size(Size2(thumbnail_size, thumbnail_size));
patterns_item_list->set_v_size_flags(Control::SIZE_EXPAND_FILL); patterns_item_list->set_v_size_flags(Control::SIZE_EXPAND_FILL);
patterns_item_list->connect("gui_input", callable_mp(this, &TileSetEditor::_patterns_item_list_gui_input)); patterns_item_list->connect("gui_input", callable_mp(this, &RTileSetEditor::_patterns_item_list_gui_input));
add_child(patterns_item_list); add_child(patterns_item_list);
patterns_item_list->hide(); patterns_item_list->hide();
@ -761,12 +761,12 @@ TileSetEditor::TileSetEditor() {
patterns_item_list->add_child(patterns_help_label); patterns_item_list->add_child(patterns_help_label);
// Registers UndoRedo inspector callback. // Registers UndoRedo inspector callback.
EditorNode::get_singleton()->get_editor_data().add_move_array_element_function(SNAME("TileSet"), callable_mp(this, &TileSetEditor::_move_tile_set_array_element)); EditorNode::get_singleton()->get_editor_data().add_move_array_element_function(SNAME("TileSet"), callable_mp(this, &RTileSetEditor::_move_tile_set_array_element));
EditorNode::get_singleton()->get_editor_data().add_undo_redo_inspector_hook_callback(callable_mp(this, &TileSetEditor::_undo_redo_inspector_callback)); EditorNode::get_singleton()->get_editor_data().add_undo_redo_inspector_hook_callback(callable_mp(this, &RTileSetEditor::_undo_redo_inspector_callback));
} }
TileSetEditor::~TileSetEditor() { RTileSetEditor::~RTileSetEditor() {
if (tile_set.is_valid()) { if (tile_set.is_valid()) {
tile_set->disconnect("changed", callable_mp(this, &TileSetEditor::_tile_set_changed)); tile_set->disconnect("changed", callable_mp(this, &RTileSetEditor::_tile_set_changed));
} }
} }

24
tile_editor/tile_set_editor.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILE_SET_EDITOR_H #ifndef RTILE_SET_EDITOR_H
#define TILE_SET_EDITOR_H #define RTILE_SET_EDITOR_H
#include "atlas_merging_dialog.h" #include "atlas_merging_dialog.h"
#include "scene/gui/box_container.h" #include "scene/gui/box_container.h"
@ -38,10 +38,10 @@
#include "tile_set_atlas_source_editor.h" #include "tile_set_atlas_source_editor.h"
#include "tile_set_scenes_collection_source_editor.h" #include "tile_set_scenes_collection_source_editor.h"
class TileSetEditor : public VBoxContainer { class RTileSetEditor : public VBoxContainer {
GDCLASS(TileSetEditor, VBoxContainer); GDCLASS(RTileSetEditor, VBoxContainer);
static TileSetEditor *singleton; static RTileSetEditor *singleton;
private: private:
Ref<TileSet> tile_set; Ref<TileSet> tile_set;
@ -54,8 +54,8 @@ private:
// Tiles. // Tiles.
Label *no_source_selected_label; Label *no_source_selected_label;
TileSetAtlasSourceEditor *tile_set_atlas_source_editor; RTileSetAtlasSourceEditor *tile_set_atlas_source_editor;
TileSetScenesCollectionSourceEditor *tile_set_scenes_collection_source_editor; RTileSetScenesCollectionSourceEditor *tile_set_scenes_collection_source_editor;
UndoRedo *undo_redo = EditorNode::get_undo_redo(); UndoRedo *undo_redo = EditorNode::get_undo_redo();
@ -75,8 +75,8 @@ private:
void _source_add_id_pressed(int p_id_pressed); void _source_add_id_pressed(int p_id_pressed);
void _sources_advanced_menu_id_pressed(int p_id_pressed); void _sources_advanced_menu_id_pressed(int p_id_pressed);
AtlasMergingDialog *atlas_merging_dialog; RAtlasMergingDialog *atlas_merging_dialog;
TileProxiesManagerDialog *tile_proxies_manager_dialog; RTileProxiesManagerDialog *tile_proxies_manager_dialog;
// Patterns. // Patterns.
ItemList *patterns_item_list; ItemList *patterns_item_list;
@ -97,12 +97,12 @@ protected:
static void _bind_methods(); static void _bind_methods();
public: public:
_FORCE_INLINE_ static TileSetEditor *get_singleton() { return singleton; } _FORCE_INLINE_ static RTileSetEditor *get_singleton() { return singleton; }
void edit(Ref<TileSet> p_tile_set); void edit(Ref<TileSet> p_tile_set);
TileSetEditor(); RTileSetEditor();
~TileSetEditor(); ~RTileSetEditor();
}; };
#endif // TILE_SET_EDITOR_PLUGIN_H #endif // TILE_SET_EDITOR_PLUGIN_H

88
tile_editor/tile_set_scenes_collection_source_editor.cpp
View File

@ -38,7 +38,7 @@
#include "core/core_string_names.h" #include "core/core_string_names.h"
void TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::set_id(int p_id) { void RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::set_id(int p_id) {
ERR_FAIL_COND(p_id < 0); ERR_FAIL_COND(p_id < 0);
if (source_id == p_id) { if (source_id == p_id) {
return; return;
@ -51,11 +51,11 @@ void TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::se
emit_signal(SNAME("changed"), "id"); emit_signal(SNAME("changed"), "id");
} }
int TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::get_id() { int RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::get_id() {
return source_id; return source_id;
} }
bool TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_set(const StringName &p_name, const Variant &p_value) { bool RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_set(const StringName &p_name, const Variant &p_value) {
String name = p_name; String name = p_name;
if (name == "name") { if (name == "name") {
// Use the resource_name property to store the source's name. // Use the resource_name property to store the source's name.
@ -69,7 +69,7 @@ bool TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_s
return valid; return valid;
} }
bool TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_get(const StringName &p_name, Variant &r_ret) const { bool RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_get(const StringName &p_name, Variant &r_ret) const {
if (!tile_set_scenes_collection_source) { if (!tile_set_scenes_collection_source) {
return false; return false;
} }
@ -83,21 +83,21 @@ bool TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_g
return valid; return valid;
} }
void TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_get_property_list(List<PropertyInfo> *p_list) const { void RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::STRING, "name", PROPERTY_HINT_NONE, "")); p_list->push_back(PropertyInfo(Variant::STRING, "name", PROPERTY_HINT_NONE, ""));
} }
void TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_bind_methods() { void RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_bind_methods() {
// -- Shape and layout -- // -- Shape and layout --
ClassDB::bind_method(D_METHOD("set_id", "id"), &TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::set_id); ClassDB::bind_method(D_METHOD("set_id", "id"), &RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::set_id);
ClassDB::bind_method(D_METHOD("get_id"), &TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::get_id); ClassDB::bind_method(D_METHOD("get_id"), &RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::get_id);
ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id"); ADD_PROPERTY(PropertyInfo(Variant::INT, "id"), "set_id", "get_id");
ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what"))); ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what")));
} }
void TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::edit(Ref<TileSet> p_tile_set, TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_source_id) { void RTileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::edit(Ref<TileSet> p_tile_set, TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_source_id) {
ERR_FAIL_COND(!p_tile_set.is_valid()); ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(!p_tile_set_scenes_collection_source); ERR_FAIL_COND(!p_tile_set_scenes_collection_source);
ERR_FAIL_COND(p_source_id < 0); ERR_FAIL_COND(p_source_id < 0);
@ -127,7 +127,7 @@ void TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::ed
} }
// -- Proxy object used by the tile inspector -- // -- Proxy object used by the tile inspector --
bool TileSetScenesCollectionSourceEditor::SceneTileProxyObject::_set(const StringName &p_name, const Variant &p_value) { bool RTileSetScenesCollectionSourceEditor::SceneTileProxyObject::_set(const StringName &p_name, const Variant &p_value) {
if (!tile_set_scenes_collection_source) { if (!tile_set_scenes_collection_source) {
return false; return false;
} }
@ -159,7 +159,7 @@ bool TileSetScenesCollectionSourceEditor::SceneTileProxyObject::_set(const Strin
return false; return false;
} }
bool TileSetScenesCollectionSourceEditor::SceneTileProxyObject::_get(const StringName &p_name, Variant &r_ret) const { bool RTileSetScenesCollectionSourceEditor::SceneTileProxyObject::_get(const StringName &p_name, Variant &r_ret) const {
if (!tile_set_scenes_collection_source) { if (!tile_set_scenes_collection_source) {
return false; return false;
} }
@ -178,7 +178,7 @@ bool TileSetScenesCollectionSourceEditor::SceneTileProxyObject::_get(const Strin
return false; return false;
} }
void TileSetScenesCollectionSourceEditor::SceneTileProxyObject::_get_property_list(List<PropertyInfo> *p_list) const { void RTileSetScenesCollectionSourceEditor::SceneTileProxyObject::_get_property_list(List<PropertyInfo> *p_list) const {
if (!tile_set_scenes_collection_source) { if (!tile_set_scenes_collection_source) {
return; return;
} }
@ -188,7 +188,7 @@ void TileSetScenesCollectionSourceEditor::SceneTileProxyObject::_get_property_li
p_list->push_back(PropertyInfo(Variant::BOOL, "display_placeholder", PROPERTY_HINT_NONE, "")); p_list->push_back(PropertyInfo(Variant::BOOL, "display_placeholder", PROPERTY_HINT_NONE, ""));
} }
void TileSetScenesCollectionSourceEditor::SceneTileProxyObject::edit(TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_scene_id) { void RTileSetScenesCollectionSourceEditor::SceneTileProxyObject::edit(TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_scene_id) {
ERR_FAIL_COND(!p_tile_set_scenes_collection_source); ERR_FAIL_COND(!p_tile_set_scenes_collection_source);
ERR_FAIL_COND(!p_tile_set_scenes_collection_source->has_scene_tile_id(p_scene_id)); ERR_FAIL_COND(!p_tile_set_scenes_collection_source->has_scene_tile_id(p_scene_id));
@ -202,21 +202,21 @@ void TileSetScenesCollectionSourceEditor::SceneTileProxyObject::edit(TileSetScen
notify_property_list_changed(); notify_property_list_changed();
} }
void TileSetScenesCollectionSourceEditor::SceneTileProxyObject::_bind_methods() { void RTileSetScenesCollectionSourceEditor::SceneTileProxyObject::_bind_methods() {
ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what"))); ADD_SIGNAL(MethodInfo("changed", PropertyInfo(Variant::STRING, "what")));
} }
void TileSetScenesCollectionSourceEditor::_scenes_collection_source_proxy_object_changed(String p_what) { void RTileSetScenesCollectionSourceEditor::_scenes_collection_source_proxy_object_changed(String p_what) {
if (p_what == "id") { if (p_what == "id") {
emit_signal(SNAME("source_id_changed"), scenes_collection_source_proxy_object->get_id()); emit_signal(SNAME("source_id_changed"), scenes_collection_source_proxy_object->get_id());
} }
} }
void TileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed() { void RTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed() {
tile_set_scenes_collection_source_changed_needs_update = true; tile_set_scenes_collection_source_changed_needs_update = true;
} }
void TileSetScenesCollectionSourceEditor::_scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, Variant p_ud) { void RTileSetScenesCollectionSourceEditor::_scene_thumbnail_done(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, Variant p_ud) {
int index = p_ud; int index = p_ud;
if (index >= 0 && index < scene_tiles_list->get_item_count()) { if (index >= 0 && index < scene_tiles_list->get_item_count()) {
@ -224,14 +224,14 @@ void TileSetScenesCollectionSourceEditor::_scene_thumbnail_done(const String &p_
} }
} }
void TileSetScenesCollectionSourceEditor::_scenes_list_item_activated(int p_index) { void RTileSetScenesCollectionSourceEditor::_scenes_list_item_activated(int p_index) {
Ref<PackedScene> packed_scene = tile_set_scenes_collection_source->get_scene_tile_scene(scene_tiles_list->get_item_metadata(p_index)); Ref<PackedScene> packed_scene = tile_set_scenes_collection_source->get_scene_tile_scene(scene_tiles_list->get_item_metadata(p_index));
if (packed_scene.is_valid()) { if (packed_scene.is_valid()) {
EditorNode::get_singleton()->open_request(packed_scene->get_path()); EditorNode::get_singleton()->open_request(packed_scene->get_path());
} }
} }
void TileSetScenesCollectionSourceEditor::_source_add_pressed() { void RTileSetScenesCollectionSourceEditor::_source_add_pressed() {
int scene_id = tile_set_scenes_collection_source->get_next_scene_tile_id(); int scene_id = tile_set_scenes_collection_source->get_next_scene_tile_id();
undo_redo->create_action(TTR("Add a Scene Tile")); undo_redo->create_action(TTR("Add a Scene Tile"));
undo_redo->add_do_method(tile_set_scenes_collection_source, "create_scene_tile", Ref<PackedScene>(), scene_id); undo_redo->add_do_method(tile_set_scenes_collection_source, "create_scene_tile", Ref<PackedScene>(), scene_id);
@ -242,7 +242,7 @@ void TileSetScenesCollectionSourceEditor::_source_add_pressed() {
_update_tile_inspector(); _update_tile_inspector();
} }
void TileSetScenesCollectionSourceEditor::_source_delete_pressed() { void RTileSetScenesCollectionSourceEditor::_source_delete_pressed() {
Vector<int> selected_indices = scene_tiles_list->get_selected_items(); Vector<int> selected_indices = scene_tiles_list->get_selected_items();
ERR_FAIL_COND(selected_indices.size() <= 0); ERR_FAIL_COND(selected_indices.size() <= 0);
int scene_id = scene_tiles_list->get_item_metadata(selected_indices[0]); int scene_id = scene_tiles_list->get_item_metadata(selected_indices[0]);
@ -256,12 +256,12 @@ void TileSetScenesCollectionSourceEditor::_source_delete_pressed() {
_update_tile_inspector(); _update_tile_inspector();
} }
void TileSetScenesCollectionSourceEditor::_update_source_inspector() { void RTileSetScenesCollectionSourceEditor::_update_source_inspector() {
// Update the proxy object. // Update the proxy object.
scenes_collection_source_proxy_object->edit(tile_set, tile_set_scenes_collection_source, tile_set_source_id); scenes_collection_source_proxy_object->edit(tile_set, tile_set_scenes_collection_source, tile_set_source_id);
} }
void TileSetScenesCollectionSourceEditor::_update_tile_inspector() { void RTileSetScenesCollectionSourceEditor::_update_tile_inspector() {
Vector<int> selected_indices = scene_tiles_list->get_selected_items(); Vector<int> selected_indices = scene_tiles_list->get_selected_items();
bool has_atlas_tile_selected = (selected_indices.size() > 0); bool has_atlas_tile_selected = (selected_indices.size() > 0);
@ -276,12 +276,12 @@ void TileSetScenesCollectionSourceEditor::_update_tile_inspector() {
tile_inspector->set_visible(has_atlas_tile_selected); tile_inspector->set_visible(has_atlas_tile_selected);
} }
void TileSetScenesCollectionSourceEditor::_update_action_buttons() { void RTileSetScenesCollectionSourceEditor::_update_action_buttons() {
Vector<int> selected_indices = scene_tiles_list->get_selected_items(); Vector<int> selected_indices = scene_tiles_list->get_selected_items();
scene_tile_delete_button->set_disabled(selected_indices.size() <= 0); scene_tile_delete_button->set_disabled(selected_indices.size() <= 0);
} }
void TileSetScenesCollectionSourceEditor::_update_scenes_list() { void RTileSetScenesCollectionSourceEditor::_update_scenes_list() {
if (!tile_set_scenes_collection_source) { if (!tile_set_scenes_collection_source) {
return; return;
} }
@ -325,7 +325,7 @@ void TileSetScenesCollectionSourceEditor::_update_scenes_list() {
scene_tiles_list->set_fixed_icon_size(Vector2(int_size, int_size)); scene_tiles_list->set_fixed_icon_size(Vector2(int_size, int_size));
} }
void TileSetScenesCollectionSourceEditor::_notification(int p_what) { void RTileSetScenesCollectionSourceEditor::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_ENTER_TREE: case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: case NOTIFICATION_THEME_CHANGED:
@ -353,7 +353,7 @@ void TileSetScenesCollectionSourceEditor::_notification(int p_what) {
} }
} }
void TileSetScenesCollectionSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_source_id) { void RTileSetScenesCollectionSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_source_id) {
ERR_FAIL_COND(!p_tile_set.is_valid()); ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(!p_tile_set_scenes_collection_source); ERR_FAIL_COND(!p_tile_set_scenes_collection_source);
ERR_FAIL_COND(p_source_id < 0); ERR_FAIL_COND(p_source_id < 0);
@ -365,7 +365,7 @@ void TileSetScenesCollectionSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetS
// Remove listener for old objects. // Remove listener for old objects.
if (tile_set_scenes_collection_source) { if (tile_set_scenes_collection_source) {
tile_set_scenes_collection_source->disconnect("changed", callable_mp(this, &TileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed)); tile_set_scenes_collection_source->disconnect("changed", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed));
} }
// Change the edited object. // Change the edited object.
@ -375,7 +375,7 @@ void TileSetScenesCollectionSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetS
// Add the listener again. // Add the listener again.
if (tile_set_scenes_collection_source) { if (tile_set_scenes_collection_source) {
tile_set_scenes_collection_source->connect("changed", callable_mp(this, &TileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed)); tile_set_scenes_collection_source->connect("changed", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed));
} }
// Update everything. // Update everything.
@ -385,7 +385,7 @@ void TileSetScenesCollectionSourceEditor::edit(Ref<TileSet> p_tile_set, TileSetS
_update_tile_inspector(); _update_tile_inspector();
} }
void TileSetScenesCollectionSourceEditor::_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { void RTileSetScenesCollectionSourceEditor::_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
if (!_can_drop_data_fw(p_point, p_data, p_from)) { if (!_can_drop_data_fw(p_point, p_data, p_from)) {
return; return;
} }
@ -412,7 +412,7 @@ void TileSetScenesCollectionSourceEditor::_drop_data_fw(const Point2 &p_point, c
} }
} }
bool TileSetScenesCollectionSourceEditor::_can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const { bool RTileSetScenesCollectionSourceEditor::_can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
if (p_from == scene_tiles_list) { if (p_from == scene_tiles_list) {
Dictionary d = p_data; Dictionary d = p_data;
@ -443,15 +443,15 @@ bool TileSetScenesCollectionSourceEditor::_can_drop_data_fw(const Point2 &p_poin
return false; return false;
} }
void TileSetScenesCollectionSourceEditor::_bind_methods() { void RTileSetScenesCollectionSourceEditor::_bind_methods() {
ADD_SIGNAL(MethodInfo("source_id_changed", PropertyInfo(Variant::INT, "source_id"))); ADD_SIGNAL(MethodInfo("source_id_changed", PropertyInfo(Variant::INT, "source_id")));
ClassDB::bind_method(D_METHOD("_scene_thumbnail_done"), &TileSetScenesCollectionSourceEditor::_scene_thumbnail_done); ClassDB::bind_method(D_METHOD("_scene_thumbnail_done"), &RTileSetScenesCollectionSourceEditor::_scene_thumbnail_done);
ClassDB::bind_method(D_METHOD("_can_drop_data_fw"), &TileSetScenesCollectionSourceEditor::_can_drop_data_fw); ClassDB::bind_method(D_METHOD("_can_drop_data_fw"), &RTileSetScenesCollectionSourceEditor::_can_drop_data_fw);
ClassDB::bind_method(D_METHOD("_drop_data_fw"), &TileSetScenesCollectionSourceEditor::_drop_data_fw); ClassDB::bind_method(D_METHOD("_drop_data_fw"), &RTileSetScenesCollectionSourceEditor::_drop_data_fw);
} }
TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() { RTileSetScenesCollectionSourceEditor::RTileSetScenesCollectionSourceEditor() {
// -- Right side -- // -- Right side --
HSplitContainer *split_container_right_side = memnew(HSplitContainer); HSplitContainer *split_container_right_side = memnew(HSplitContainer);
split_container_right_side->set_h_size_flags(SIZE_EXPAND_FILL); split_container_right_side->set_h_size_flags(SIZE_EXPAND_FILL);
@ -473,7 +473,7 @@ TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() {
middle_vbox_container->add_child(scenes_collection_source_inspector_label); middle_vbox_container->add_child(scenes_collection_source_inspector_label);
scenes_collection_source_proxy_object = memnew(TileSetScenesCollectionProxyObject()); scenes_collection_source_proxy_object = memnew(TileSetScenesCollectionProxyObject());
scenes_collection_source_proxy_object->connect("changed", callable_mp(this, &TileSetScenesCollectionSourceEditor::_scenes_collection_source_proxy_object_changed)); scenes_collection_source_proxy_object->connect("changed", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_scenes_collection_source_proxy_object_changed));
scenes_collection_source_inspector = memnew(EditorInspector); scenes_collection_source_inspector = memnew(EditorInspector);
scenes_collection_source_inspector->set_undo_redo(undo_redo); scenes_collection_source_inspector->set_undo_redo(undo_redo);
@ -488,8 +488,8 @@ TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() {
middle_vbox_container->add_child(tile_inspector_label); middle_vbox_container->add_child(tile_inspector_label);
tile_proxy_object = memnew(SceneTileProxyObject(this)); tile_proxy_object = memnew(SceneTileProxyObject(this));
tile_proxy_object->connect("changed", callable_mp(this, &TileSetScenesCollectionSourceEditor::_update_scenes_list).unbind(1)); tile_proxy_object->connect("changed", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_update_scenes_list).unbind(1));
tile_proxy_object->connect("changed", callable_mp(this, &TileSetScenesCollectionSourceEditor::_update_action_buttons).unbind(1)); tile_proxy_object->connect("changed", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_update_action_buttons).unbind(1));
tile_inspector = memnew(EditorInspector); tile_inspector = memnew(EditorInspector);
tile_inspector->set_undo_redo(undo_redo); tile_inspector->set_undo_redo(undo_redo);
@ -506,9 +506,9 @@ TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() {
scene_tiles_list->set_h_size_flags(SIZE_EXPAND_FILL); scene_tiles_list->set_h_size_flags(SIZE_EXPAND_FILL);
scene_tiles_list->set_v_size_flags(SIZE_EXPAND_FILL); scene_tiles_list->set_v_size_flags(SIZE_EXPAND_FILL);
scene_tiles_list->set_drag_forwarding(this); scene_tiles_list->set_drag_forwarding(this);
scene_tiles_list->connect("item_selected", callable_mp(this, &TileSetScenesCollectionSourceEditor::_update_tile_inspector).unbind(1)); scene_tiles_list->connect("item_selected", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_update_tile_inspector).unbind(1));
scene_tiles_list->connect("item_selected", callable_mp(this, &TileSetScenesCollectionSourceEditor::_update_action_buttons).unbind(1)); scene_tiles_list->connect("item_selected", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_update_action_buttons).unbind(1));
scene_tiles_list->connect("item_activated", callable_mp(this, &TileSetScenesCollectionSourceEditor::_scenes_list_item_activated)); scene_tiles_list->connect("item_activated", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_scenes_list_item_activated));
scene_tiles_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST); scene_tiles_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
right_vbox_container->add_child(scene_tiles_list); right_vbox_container->add_child(scene_tiles_list);
@ -517,17 +517,17 @@ TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() {
scene_tile_add_button = memnew(Button); scene_tile_add_button = memnew(Button);
scene_tile_add_button->set_flat(true); scene_tile_add_button->set_flat(true);
scene_tile_add_button->connect("pressed", callable_mp(this, &TileSetScenesCollectionSourceEditor::_source_add_pressed)); scene_tile_add_button->connect("pressed", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_source_add_pressed));
scenes_bottom_actions->add_child(scene_tile_add_button); scenes_bottom_actions->add_child(scene_tile_add_button);
scene_tile_delete_button = memnew(Button); scene_tile_delete_button = memnew(Button);
scene_tile_delete_button->set_flat(true); scene_tile_delete_button->set_flat(true);
scene_tile_delete_button->set_disabled(true); scene_tile_delete_button->set_disabled(true);
scene_tile_delete_button->connect("pressed", callable_mp(this, &TileSetScenesCollectionSourceEditor::_source_delete_pressed)); scene_tile_delete_button->connect("pressed", callable_mp(this, &RTileSetScenesCollectionSourceEditor::_source_delete_pressed));
scenes_bottom_actions->add_child(scene_tile_delete_button); scenes_bottom_actions->add_child(scene_tile_delete_button);
} }
TileSetScenesCollectionSourceEditor::~TileSetScenesCollectionSourceEditor() { RTileSetScenesCollectionSourceEditor::~RTileSetScenesCollectionSourceEditor() {
memdelete(scenes_collection_source_proxy_object); memdelete(scenes_collection_source_proxy_object);
memdelete(tile_proxy_object); memdelete(tile_proxy_object);
} }

16
tile_editor/tile_set_scenes_collection_source_editor.h
View File

@ -28,15 +28,15 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILE_SET_SCENES_COLLECTION_SOURCE_EDITOR_H #ifndef RTILE_SET_SCENES_COLLECTION_SOURCE_EDITOR_H
#define TILE_SET_SCENES_COLLECTION_SOURCE_EDITOR_H #define RTILE_SET_SCENES_COLLECTION_SOURCE_EDITOR_H
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "scene/gui/box_container.h" #include "scene/gui/box_container.h"
#include "scene/resources/tile_set.h" #include "scene/resources/tile_set.h"
class TileSetScenesCollectionSourceEditor : public HBoxContainer { class RTileSetScenesCollectionSourceEditor : public HBoxContainer {
GDCLASS(TileSetScenesCollectionSourceEditor, HBoxContainer); GDCLASS(RTileSetScenesCollectionSourceEditor, HBoxContainer);
private: private:
// -- Proxy object for an atlas source, needed by the inspector -- // -- Proxy object for an atlas source, needed by the inspector --
@ -66,7 +66,7 @@ private:
GDCLASS(SceneTileProxyObject, Object); GDCLASS(SceneTileProxyObject, Object);
private: private:
TileSetScenesCollectionSourceEditor *tile_set_scenes_collection_source_editor; RTileSetScenesCollectionSourceEditor *tile_set_scenes_collection_source_editor;
TileSetScenesCollectionSource *tile_set_scenes_collection_source = nullptr; TileSetScenesCollectionSource *tile_set_scenes_collection_source = nullptr;
int source_id; int source_id;
@ -83,7 +83,7 @@ private:
// Update the proxyed object. // Update the proxyed object.
void edit(TileSetScenesCollectionSource *p_tile_set_atlas_source, int p_scene_id); void edit(TileSetScenesCollectionSource *p_tile_set_atlas_source, int p_scene_id);
SceneTileProxyObject(TileSetScenesCollectionSourceEditor *p_tiles_set_scenes_collection_source_editor) { SceneTileProxyObject(RTileSetScenesCollectionSourceEditor *p_tiles_set_scenes_collection_source_editor) {
tile_set_scenes_collection_source_editor = p_tiles_set_scenes_collection_source_editor; tile_set_scenes_collection_source_editor = p_tiles_set_scenes_collection_source_editor;
} }
}; };
@ -134,8 +134,8 @@ protected:
public: public:
void edit(Ref<TileSet> p_tile_set, TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_source_id); void edit(Ref<TileSet> p_tile_set, TileSetScenesCollectionSource *p_tile_set_scenes_collection_source, int p_source_id);
TileSetScenesCollectionSourceEditor(); RTileSetScenesCollectionSourceEditor();
~TileSetScenesCollectionSourceEditor(); ~RTileSetScenesCollectionSourceEditor();
}; };
#endif #endif

52
tile_editor/tiles_editor_plugin.cpp
View File

@ -45,22 +45,22 @@
#include "tile_set_editor.h" #include "tile_set_editor.h"
TilesEditorPlugin *TilesEditorPlugin::singleton = nullptr; RTilesEditorPlugin *RTilesEditorPlugin::singleton = nullptr;
void TilesEditorPlugin::_preview_frame_started() { void RTilesEditorPlugin::_preview_frame_started() {
RS::get_singleton()->request_frame_drawn_callback(callable_mp(const_cast<TilesEditorPlugin *>(this), &TilesEditorPlugin::_pattern_preview_done)); RS::get_singleton()->request_frame_drawn_callback(callable_mp(const_cast<RTilesEditorPlugin *>(this), &RTilesEditorPlugin::_pattern_preview_done));
} }
void TilesEditorPlugin::_pattern_preview_done() { void RTilesEditorPlugin::_pattern_preview_done() {
pattern_preview_done.post(); pattern_preview_done.post();
} }
void TilesEditorPlugin::_thread_func(void *ud) { void RTilesEditorPlugin::_thread_func(void *ud) {
TilesEditorPlugin *te = (TilesEditorPlugin *)ud; RTilesEditorPlugin *te = (RTilesEditorPlugin *)ud;
te->_thread(); te->_thread();
} }
void TilesEditorPlugin::_thread() { void RTilesEditorPlugin::_thread() {
pattern_thread_exited.clear(); pattern_thread_exited.clear();
while (!pattern_thread_exit.is_set()) { while (!pattern_thread_exit.is_set()) {
pattern_preview_sem.wait(); pattern_preview_sem.wait();
@ -116,7 +116,7 @@ void TilesEditorPlugin::_thread() {
// Add the viewport at the lasst moment to avoid rendering too early. // Add the viewport at the lasst moment to avoid rendering too early.
EditorNode::get_singleton()->add_child(viewport); EditorNode::get_singleton()->add_child(viewport);
RS::get_singleton()->connect(SNAME("frame_pre_draw"), callable_mp(const_cast<TilesEditorPlugin *>(this), &TilesEditorPlugin::_preview_frame_started), Vector<Variant>(), Object::CONNECT_ONESHOT); RS::get_singleton()->connect(SNAME("frame_pre_draw"), callable_mp(const_cast<RTilesEditorPlugin *>(this), &RTilesEditorPlugin::_preview_frame_started), Vector<Variant>(), Object::CONNECT_ONESHOT);
pattern_preview_done.wait(); pattern_preview_done.wait();
@ -141,11 +141,11 @@ void TilesEditorPlugin::_thread() {
pattern_thread_exited.set(); pattern_thread_exited.set();
} }
void TilesEditorPlugin::_tile_map_changed() { void RTilesEditorPlugin::_tile_map_changed() {
tile_map_changed_needs_update = true; tile_map_changed_needs_update = true;
} }
void TilesEditorPlugin::_update_editors() { void RTilesEditorPlugin::_update_editors() {
// If tile_map is not edited, we change the edited only if we are not editing a tile_set. // If tile_map is not edited, we change the edited only if we are not editing a tile_set.
tileset_editor->edit(tile_set); tileset_editor->edit(tile_set);
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
@ -159,7 +159,7 @@ void TilesEditorPlugin::_update_editors() {
CanvasItemEditor::get_singleton()->update_viewport(); CanvasItemEditor::get_singleton()->update_viewport();
} }
void TilesEditorPlugin::_notification(int p_what) { void RTilesEditorPlugin::_notification(int p_what) {
switch (p_what) { switch (p_what) {
case NOTIFICATION_INTERNAL_PROCESS: { case NOTIFICATION_INTERNAL_PROCESS: {
if (tile_map_changed_needs_update) { if (tile_map_changed_needs_update) {
@ -174,7 +174,7 @@ void TilesEditorPlugin::_notification(int p_what) {
} }
} }
void TilesEditorPlugin::make_visible(bool p_visible) { void RTilesEditorPlugin::make_visible(bool p_visible) {
if (p_visible) { if (p_visible) {
// Disable and hide invalid editors. // Disable and hide invalid editors.
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
@ -193,7 +193,7 @@ void TilesEditorPlugin::make_visible(bool p_visible) {
} }
} }
void TilesEditorPlugin::queue_pattern_preview(Ref<TileSet> p_tile_set, Ref<TileMapPattern> p_pattern, Callable p_callback) { void RTilesEditorPlugin::queue_pattern_preview(Ref<TileSet> p_tile_set, Ref<TileMapPattern> p_pattern, Callable p_callback) {
ERR_FAIL_COND(!p_tile_set.is_valid()); ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(!p_pattern.is_valid()); ERR_FAIL_COND(!p_pattern.is_valid());
{ {
@ -203,11 +203,11 @@ void TilesEditorPlugin::queue_pattern_preview(Ref<TileSet> p_tile_set, Ref<TileM
pattern_preview_sem.post(); pattern_preview_sem.post();
} }
void TilesEditorPlugin::set_sources_lists_current(int p_current) { void RTilesEditorPlugin::set_sources_lists_current(int p_current) {
atlas_sources_lists_current = p_current; atlas_sources_lists_current = p_current;
} }
void TilesEditorPlugin::synchronize_sources_list(Object *p_current) { void RTilesEditorPlugin::synchronize_sources_list(Object *p_current) {
ItemList *item_list = Object::cast_to<ItemList>(p_current); ItemList *item_list = Object::cast_to<ItemList>(p_current);
ERR_FAIL_COND(!item_list); ERR_FAIL_COND(!item_list);
@ -221,13 +221,13 @@ void TilesEditorPlugin::synchronize_sources_list(Object *p_current) {
} }
} }
void TilesEditorPlugin::set_atlas_view_transform(float p_zoom, Vector2 p_scroll) { void RTilesEditorPlugin::set_atlas_view_transform(float p_zoom, Vector2 p_scroll) {
atlas_view_zoom = p_zoom; atlas_view_zoom = p_zoom;
atlas_view_scroll = p_scroll; atlas_view_scroll = p_scroll;
} }
void TilesEditorPlugin::synchronize_atlas_view(Object *p_current) { void RTilesEditorPlugin::synchronize_atlas_view(Object *p_current) {
TileAtlasView *tile_atlas_view = Object::cast_to<TileAtlasView>(p_current); RTileAtlasView *tile_atlas_view = Object::cast_to<RTileAtlasView>(p_current);
ERR_FAIL_COND(!tile_atlas_view); ERR_FAIL_COND(!tile_atlas_view);
if (tile_atlas_view->is_visible_in_tree()) { if (tile_atlas_view->is_visible_in_tree()) {
@ -235,11 +235,11 @@ void TilesEditorPlugin::synchronize_atlas_view(Object *p_current) {
} }
} }
void TilesEditorPlugin::edit(Object *p_object) { void RTilesEditorPlugin::edit(Object *p_object) {
// Disconnect to changes. // Disconnect to changes.
TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id)); TileMap *tile_map = Object::cast_to<TileMap>(ObjectDB::get_instance(tile_map_id));
if (tile_map) { if (tile_map) {
tile_map->disconnect("changed", callable_mp(this, &TilesEditorPlugin::_tile_map_changed)); tile_map->disconnect("changed", callable_mp(this, &RTilesEditorPlugin::_tile_map_changed));
} }
// Update edited objects. // Update edited objects.
@ -267,15 +267,15 @@ void TilesEditorPlugin::edit(Object *p_object) {
// Add change listener. // Add change listener.
if (tile_map) { if (tile_map) {
tile_map->connect("changed", callable_mp(this, &TilesEditorPlugin::_tile_map_changed)); tile_map->connect("changed", callable_mp(this, &RTilesEditorPlugin::_tile_map_changed));
} }
} }
bool TilesEditorPlugin::handles(Object *p_object) const { bool RTilesEditorPlugin::handles(Object *p_object) const {
return p_object->is_class("TileMap") || p_object->is_class("TileSet"); return p_object->is_class("TileMap") || p_object->is_class("TileSet");
} }
TilesEditorPlugin::TilesEditorPlugin(EditorNode *p_node) { RTilesEditorPlugin::RTilesEditorPlugin(EditorNode *p_node) {
set_process_internal(true); set_process_internal(true);
// Update the singleton. // Update the singleton.
@ -284,14 +284,14 @@ TilesEditorPlugin::TilesEditorPlugin(EditorNode *p_node) {
editor_node = p_node; editor_node = p_node;
// Tileset editor. // Tileset editor.
tileset_editor = memnew(TileSetEditor); tileset_editor = memnew(RTileSetEditor);
tileset_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); tileset_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
tileset_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL); tileset_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
tileset_editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE); tileset_editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE);
tileset_editor->hide(); tileset_editor->hide();
// Tilemap editor. // Tilemap editor.
tilemap_editor = memnew(TileMapEditor); tilemap_editor = memnew(RTileMapEditor);
tilemap_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); tilemap_editor->set_h_size_flags(Control::SIZE_EXPAND_FILL);
tilemap_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL); tilemap_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
tilemap_editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE); tilemap_editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE);
@ -310,7 +310,7 @@ TilesEditorPlugin::TilesEditorPlugin(EditorNode *p_node) {
_update_editors(); _update_editors();
} }
TilesEditorPlugin::~TilesEditorPlugin() { RTilesEditorPlugin::~RTilesEditorPlugin() {
if (pattern_preview_thread.is_started()) { if (pattern_preview_thread.is_started()) {
pattern_thread_exit.set(); pattern_thread_exit.set();
pattern_preview_sem.post(); pattern_preview_sem.post();

20
tile_editor/tiles_editor_plugin.h
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef TILES_EDITOR_PLUGIN_H #ifndef RTILES_EDITOR_PLUGIN_H
#define TILES_EDITOR_PLUGIN_H #define RTILES_EDITOR_PLUGIN_H
#include "editor/editor_plugin.h" #include "editor/editor_plugin.h"
#include "scene/gui/box_container.h" #include "scene/gui/box_container.h"
@ -38,10 +38,10 @@
#include "tile_map_editor.h" #include "tile_map_editor.h"
#include "tile_set_editor.h" #include "tile_set_editor.h"
class TilesEditorPlugin : public EditorPlugin { class RTilesEditorPlugin : public EditorPlugin {
GDCLASS(TilesEditorPlugin, EditorPlugin); GDCLASS(RTilesEditorPlugin, EditorPlugin);
static TilesEditorPlugin *singleton; static RTilesEditorPlugin *singleton;
private: private:
EditorNode *editor_node; EditorNode *editor_node;
@ -51,10 +51,10 @@ private:
Ref<TileSet> tile_set; Ref<TileSet> tile_set;
Button *tilemap_editor_button; Button *tilemap_editor_button;
TileMapEditor *tilemap_editor; RTileMapEditor *tilemap_editor;
Button *tileset_editor_button; Button *tileset_editor_button;
TileSetEditor *tileset_editor; RTileSetEditor *tileset_editor;
void _update_editors(); void _update_editors();
@ -87,7 +87,7 @@ protected:
void _notification(int p_what); void _notification(int p_what);
public: public:
_FORCE_INLINE_ static TilesEditorPlugin *get_singleton() { return singleton; } _FORCE_INLINE_ static RTilesEditorPlugin *get_singleton() { return singleton; }
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override { return tilemap_editor->forward_canvas_gui_input(p_event); } virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) override { return tilemap_editor->forward_canvas_gui_input(p_event); }
virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override { tilemap_editor->forward_canvas_draw_over_viewport(p_overlay); } virtual void forward_canvas_draw_over_viewport(Control *p_overlay) override { tilemap_editor->forward_canvas_draw_over_viewport(p_overlay); }
@ -106,8 +106,8 @@ public:
virtual bool handles(Object *p_object) const override; virtual bool handles(Object *p_object) const override;
virtual void make_visible(bool p_visible) override; virtual void make_visible(bool p_visible) override;
TilesEditorPlugin(EditorNode *p_node); RTilesEditorPlugin(EditorNode *p_node);
~TilesEditorPlugin(); ~RTilesEditorPlugin();
}; };
#endif // TILES_EDITOR_PLUGIN_H #endif // TILES_EDITOR_PLUGIN_H