hertog/godot-module-template
Template
2
1
Fork 1
Code Issues 2 Pull requests 2 Projects Releases Packages Wiki Activity Actions

feat: updated engine version to 4.4-rc1

Browse source
This commit is contained in:
Sara 2025-02-23 14:38:14 +01:00
parent ee00efde1f
commit 21ba8e33af
5459 changed files with 1128836 additions and 198305 deletions
Download patch file Download diff file Expand all files Collapse all files

1
engine/editor/plugins/tiles/SCsub
View file

@ -1,4 +1,5 @@
#!/usr/bin/env python
from misc.utility.scons_hints import *
Import("env")

14
engine/editor/plugins/tiles/atlas_merging_dialog.cpp
View file

@ -30,7 +30,6 @@
#include "atlas_merging_dialog.h"
#include "editor/editor_properties_vector.h"
#include "editor/editor_undo_redo_manager.h"
#include "editor/gui/editor_file_dialog.h"
#include "editor/themes/editor_scale.h"
@ -178,7 +177,7 @@ void AtlasMergingDialog::_update_texture() {
}
void AtlasMergingDialog::_merge_confirmed(const String &p_path) {
ERR_FAIL_COND(!merged.is_valid());
ERR_FAIL_COND(merged.is_null());
Ref<ImageTexture> output_image_texture = merged->get_texture();
output_image_texture->get_image()->save_png(p_path);
@ -217,7 +216,7 @@ void AtlasMergingDialog::_merge_confirmed(const String &p_path) {
}
}
undo_redo->commit_action();
commited_actions_count++;
committed_actions_count++;
hide();
}
@ -229,10 +228,10 @@ void AtlasMergingDialog::ok_pressed() {
void AtlasMergingDialog::cancel_pressed() {
EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
for (int i = 0; i < commited_actions_count; i++) {
for (int i = 0; i < committed_actions_count; i++) {
undo_redo->undo();
}
commited_actions_count = 0;
committed_actions_count = 0;
}
void AtlasMergingDialog::custom_action(const String &p_action) {
@ -270,7 +269,7 @@ void AtlasMergingDialog::_notification(int p_what) {
}
void AtlasMergingDialog::update_tile_set(Ref<TileSet> p_tile_set) {
ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(p_tile_set.is_null());
tile_set = p_tile_set;
atlas_merging_atlases_list->clear();
@ -290,7 +289,7 @@ void AtlasMergingDialog::update_tile_set(Ref<TileSet> p_tile_set) {
get_ok_button()->set_disabled(true);
merge_button->set_disabled(true);
commited_actions_count = 0;
committed_actions_count = 0;
}
AtlasMergingDialog::AtlasMergingDialog() {
@ -318,6 +317,7 @@ AtlasMergingDialog::AtlasMergingDialog() {
atlas_merging_atlases_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST_WITH_MIPMAPS);
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_theme_type_variation("ItemListSecondary");
atlas_merging_atlases_list->connect("multi_selected", callable_mp(this, &AtlasMergingDialog::_update_texture).unbind(2));
atlas_merging_h_split_container->add_child(atlas_merging_atlases_list);

2
engine/editor/plugins/tiles/atlas_merging_dialog.h
View file

@ -44,7 +44,7 @@ class AtlasMergingDialog : public ConfirmationDialog {
GDCLASS(AtlasMergingDialog, ConfirmationDialog);
private:
int commited_actions_count = 0;
int committed_actions_count = 0;
bool delete_original_atlases = true;
Ref<TileSetAtlasSource> merged;
LocalVector<HashMap<Vector2i, Vector2i>> merged_mapping;

15
engine/editor/plugins/tiles/tile_atlas_view.cpp
View file

@ -30,8 +30,6 @@
#include "tile_atlas_view.h"
#include "core/input/input.h"
#include "core/os/keyboard.h"
#include "editor/editor_settings.h"
#include "editor/themes/editor_scale.h"
#include "scene/2d/tile_map.h"
@ -41,7 +39,7 @@
#include "scene/gui/view_panner.h"
void TileAtlasView::gui_input(const Ref<InputEvent> &p_event) {
if (panner->gui_input(p_event)) {
if (panner->gui_input(p_event, get_global_rect())) {
accept_event();
}
}
@ -372,7 +370,7 @@ void TileAtlasView::_draw_base_tiles_shape_grid() {
for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) {
Vector2i tile_id = tile_set_atlas_source->get_tile_id(i);
Vector2 in_tile_base_offset = tile_set_atlas_source->get_tile_data(tile_id, 0)->get_texture_origin();
if (tile_set_atlas_source->is_position_in_tile_texture_region(tile_id, 0, -tile_shape_size / 2) && tile_set_atlas_source->is_position_in_tile_texture_region(tile_id, 0, tile_shape_size / 2 - Vector2(1, 1))) {
if (tile_set_atlas_source->is_rect_in_tile_texture_region(tile_id, 0, Rect2(Vector2(-tile_shape_size) / 2, tile_shape_size))) {
for (int frame = 0; frame < tile_set_atlas_source->get_tile_animation_frames_count(tile_id); frame++) {
Color color = grid_color;
if (frame > 0) {
@ -496,13 +494,13 @@ void TileAtlasView::set_atlas_source(TileSet *p_tile_set, TileSetAtlasSource *p_
float TileAtlasView::get_zoom() const {
return zoom_widget->get_zoom();
};
}
void TileAtlasView::set_transform(float p_zoom, Vector2i p_panning) {
zoom_widget->set_zoom(p_zoom);
panning = p_panning;
_update_zoom_and_panning();
};
}
void TileAtlasView::set_padding(Side p_side, int p_padding) {
ERR_FAIL_COND(p_padding < 0);
@ -515,7 +513,7 @@ Vector2i TileAtlasView::get_atlas_tile_coords_at_pos(const Vector2 p_pos, bool p
}
Ref<Texture2D> texture = tile_set_atlas_source->get_texture();
if (!texture.is_valid()) {
if (texture.is_null()) {
return TileSetSource::INVALID_ATLAS_COORDS;
}
@ -615,10 +613,11 @@ void TileAtlasView::_notification(int p_what) {
}
case NOTIFICATION_ENTER_TREE: {
panner->setup((ViewPanner::ControlScheme)EDITOR_GET("editors/panning/sub_editors_panning_scheme").operator int(), ED_GET_SHORTCUT("canvas_item_editor/pan_view"), bool(EDITOR_GET("editors/panning/simple_panning")));
panner->setup_warped_panning(get_viewport(), EDITOR_GET("editors/panning/warped_mouse_panning"));
} break;
case NOTIFICATION_THEME_CHANGED: {
button_center_view->set_icon(theme_cache.center_view_icon);
button_center_view->set_button_icon(theme_cache.center_view_icon);
} break;
}
}

8
engine/editor/plugins/tiles/tile_atlas_view.h
View file

@ -135,8 +135,8 @@ public:
void set_padding(Side p_side, int p_padding);
// Left side.
void set_texture_grid_visible(bool p_visible) { base_tiles_texture_grid->set_visible(p_visible); };
void set_tile_shape_grid_visible(bool p_visible) { base_tiles_shape_grid->set_visible(p_visible); };
void set_texture_grid_visible(bool p_visible) { base_tiles_texture_grid->set_visible(p_visible); }
void set_tile_shape_grid_visible(bool p_visible) { base_tiles_shape_grid->set_visible(p_visible); }
Vector2i get_atlas_tile_coords_at_pos(const Vector2 p_pos, bool p_clamp = false) const;
@ -148,7 +148,7 @@ public:
}
p_control->set_anchors_and_offsets_preset(Control::PRESET_FULL_RECT);
p_control->set_mouse_filter(Control::MOUSE_FILTER_PASS);
};
}
// Right side.
Vector3i get_alternative_tile_at_pos(const Vector2 p_pos) const;
@ -162,7 +162,7 @@ public:
}
p_control->set_anchors_and_offsets_preset(Control::PRESET_FULL_RECT);
p_control->set_mouse_filter(Control::MOUSE_FILTER_PASS);
};
}
// Redraw everything.
void queue_redraw();

145
engine/editor/plugins/tiles/tile_data_editors.cpp
View file

@ -64,7 +64,7 @@ void TileDataEditor::_tile_set_changed_deferred_update() {
}
TileData *TileDataEditor::_get_tile_data(TileMapCell p_cell) {
ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr);
ERR_FAIL_COND_V(tile_set.is_null(), nullptr);
ERR_FAIL_COND_V(!tile_set->has_source(p_cell.source_id), nullptr);
TileData *td = nullptr;
@ -129,7 +129,7 @@ void DummyObject::clear_dummy_properties() {
}
void GenericTilePolygonEditor::_base_control_draw() {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
real_t grab_threshold = EDITOR_GET("editors/polygon_editor/point_grab_radius");
@ -165,10 +165,14 @@ void GenericTilePolygonEditor::_base_control_draw() {
base_control->draw_set_transform_matrix(xform);
// Draw fill rect under texture region.
Rect2 texture_rect(-background_region.size / 2, background_region.size);
Rect2 texture_rect(Vector2(), background_region.size);
if (tile_data) {
texture_rect.position -= tile_data->get_texture_origin();
if (tile_data->get_transpose()) {
texture_rect.size = Size2(texture_rect.size.y, texture_rect.size.x);
}
}
texture_rect.position -= texture_rect.size / 2; // Half-size offset must be applied after transposing.
base_control->draw_rect(texture_rect, Color(1, 1, 1, 0.3));
// Draw the background.
@ -180,18 +184,14 @@ void GenericTilePolygonEditor::_base_control_draw() {
if (tile_data->get_flip_v()) {
region_size.y = -region_size.y;
}
base_control->draw_texture_rect_region(background_atlas_source->get_texture(), Rect2(-background_region.size / 2 - tile_data->get_texture_origin(), region_size), background_region, tile_data->get_modulate(), tile_data->get_transpose());
// Destination rect position must account for transposing, size must not.
base_control->draw_texture_rect_region(background_atlas_source->get_texture(), Rect2(texture_rect.position, region_size), background_region, tile_data->get_modulate(), tile_data->get_transpose());
}
// Compute and draw the grid area.
Rect2 grid_area = Rect2(-base_tile_size / 2, base_tile_size);
if (tile_data) {
grid_area.expand_to(-background_region.get_size() / 2 - tile_data->get_texture_origin());
grid_area.expand_to(background_region.get_size() / 2 - tile_data->get_texture_origin());
} else {
grid_area.expand_to(-background_region.get_size() / 2);
grid_area.expand_to(background_region.get_size() / 2);
}
grid_area.expand_to(texture_rect.position);
grid_area.expand_to(texture_rect.get_end());
base_control->draw_rect(grid_area, Color(1, 1, 1, 0.3), false);
// Draw grid.
@ -452,7 +452,7 @@ void GenericTilePolygonEditor::_grab_polygon_segment_point(Vector2 p_pos, const
}
void GenericTilePolygonEditor::_snap_to_tile_shape(Point2 &r_point, float &r_current_snapped_dist, float p_snap_dist) {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
Vector<Point2> polygon = tile_set->get_tile_shape_polygon();
for (int i = 0; i < polygon.size(); i++) {
@ -523,6 +523,21 @@ void GenericTilePolygonEditor::_base_control_gui_input(Ref<InputEvent> p_event)
xform.set_origin(base_control->get_size() / 2 + panning);
xform.set_scale(Vector2(editor_zoom_widget->get_zoom(), editor_zoom_widget->get_zoom()));
Ref<InputEventPanGesture> pan_gesture = p_event;
if (pan_gesture.is_valid()) {
panning += pan_gesture->get_delta() * 8;
drag_last_pos = Vector2();
button_center_view->set_disabled(panning.is_zero_approx());
accept_event();
}
Ref<InputEventMagnifyGesture> magnify_gesture = p_event;
if (magnify_gesture.is_valid()) {
editor_zoom_widget->set_zoom(editor_zoom_widget->get_zoom() * magnify_gesture->get_factor());
_zoom_changed();
accept_event();
}
Ref<InputEventMouseMotion> mm = p_event;
if (mm.is_valid()) {
if (drag_type == DRAG_TYPE_DRAG_POINT) {
@ -707,7 +722,7 @@ void GenericTilePolygonEditor::_base_control_gui_input(Ref<InputEvent> p_event)
void GenericTilePolygonEditor::_set_snap_option(int p_index) {
current_snap_option = p_index;
button_pixel_snap->set_icon(button_pixel_snap->get_popup()->get_item_icon(p_index));
button_pixel_snap->set_button_icon(button_pixel_snap->get_popup()->get_item_icon(p_index));
snap_subdivision->set_visible(p_index == SNAP_GRID);
if (initializing) {
@ -736,7 +751,7 @@ void GenericTilePolygonEditor::set_use_undo_redo(bool p_use_undo_redo) {
}
void GenericTilePolygonEditor::set_tile_set(Ref<TileSet> p_tile_set) {
ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(p_tile_set.is_null());
if (tile_set == p_tile_set) {
return;
}
@ -859,17 +874,22 @@ void GenericTilePolygonEditor::_notification(int p_what) {
button_expand->set_pressed_no_signal(false);
}
} break;
case NOTIFICATION_READY: {
get_parent()->connect(SceneStringName(tree_exited), callable_mp(TileSetEditor::get_singleton(), &TileSetEditor::remove_expanded_editor));
} break;
case NOTIFICATION_THEME_CHANGED: {
button_expand->set_icon(get_editor_theme_icon(SNAME("DistractionFree")));
button_create->set_icon(get_editor_theme_icon(SNAME("CurveCreate")));
button_edit->set_icon(get_editor_theme_icon(SNAME("CurveEdit")));
button_delete->set_icon(get_editor_theme_icon(SNAME("CurveDelete")));
button_center_view->set_icon(get_editor_theme_icon(SNAME("CenterView")));
button_advanced_menu->set_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
button_expand->set_button_icon(get_editor_theme_icon(SNAME("DistractionFree")));
button_create->set_button_icon(get_editor_theme_icon(SNAME("CurveCreate")));
button_edit->set_button_icon(get_editor_theme_icon(SNAME("CurveEdit")));
button_delete->set_button_icon(get_editor_theme_icon(SNAME("CurveDelete")));
button_center_view->set_button_icon(get_editor_theme_icon(SNAME("CenterView")));
button_advanced_menu->set_button_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
button_pixel_snap->get_popup()->set_item_icon(0, get_editor_theme_icon(SNAME("SnapDisable")));
button_pixel_snap->get_popup()->set_item_icon(1, get_editor_theme_icon(SNAME("Snap")));
button_pixel_snap->get_popup()->set_item_icon(2, get_editor_theme_icon(SNAME("SnapGrid")));
button_pixel_snap->set_icon(button_pixel_snap->get_popup()->get_item_icon(current_snap_option));
button_pixel_snap->set_button_icon(button_pixel_snap->get_popup()->get_item_icon(current_snap_option));
PopupMenu *p = button_advanced_menu->get_popup();
p->set_item_icon(p->get_item_index(ROTATE_RIGHT), get_editor_theme_icon(SNAME("RotateRight")));
@ -898,17 +918,17 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
tools_button_group.instantiate();
button_expand = memnew(Button);
button_expand->set_theme_type_variation("FlatButton");
button_expand->set_theme_type_variation(SceneStringName(FlatButton));
button_expand->set_toggle_mode(true);
button_expand->set_pressed(false);
button_expand->set_tooltip_text(TTR("Expand editor"));
button_expand->connect("toggled", callable_mp(this, &GenericTilePolygonEditor::_toggle_expand));
button_expand->connect(SceneStringName(toggled), callable_mp(this, &GenericTilePolygonEditor::_toggle_expand));
toolbar->add_child(button_expand);
toolbar->add_child(memnew(VSeparator));
button_create = memnew(Button);
button_create->set_theme_type_variation("FlatButton");
button_create->set_theme_type_variation(SceneStringName(FlatButton));
button_create->set_toggle_mode(true);
button_create->set_button_group(tools_button_group);
button_create->set_pressed(true);
@ -916,14 +936,14 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
toolbar->add_child(button_create);
button_edit = memnew(Button);
button_edit->set_theme_type_variation("FlatButton");
button_edit->set_theme_type_variation(SceneStringName(FlatButton));
button_edit->set_toggle_mode(true);
button_edit->set_button_group(tools_button_group);
button_edit->set_tooltip_text(TTR("Edit points tool"));
toolbar->add_child(button_edit);
button_delete = memnew(Button);
button_delete->set_theme_type_variation("FlatButton");
button_delete->set_theme_type_variation(SceneStringName(FlatButton));
button_delete->set_toggle_mode(true);
button_delete->set_button_group(tools_button_group);
button_delete->set_tooltip_text(TTR("Delete points tool"));
@ -995,7 +1015,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
button_center_view->set_anchors_and_offsets_preset(Control::PRESET_TOP_RIGHT, Control::PRESET_MODE_MINSIZE, 5);
button_center_view->set_grow_direction_preset(Control::PRESET_TOP_RIGHT);
button_center_view->connect(SceneStringName(pressed), callable_mp(this, &GenericTilePolygonEditor::_center_view));
button_center_view->set_theme_type_variation("FlatButton");
button_center_view->set_theme_type_variation(SceneStringName(FlatButton));
button_center_view->set_tooltip_text(TTR("Center View"));
button_center_view->set_disabled(true);
root->add_child(button_center_view);
@ -1080,11 +1100,10 @@ void TileDataDefaultEditor::forward_draw_over_atlas(TileAtlasView *p_tile_atlas_
}
p_canvas_item->draw_set_transform_matrix(Transform2D());
}
};
}
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(TileAtlasView *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) {
Ref<InputEventMouseMotion> mm = p_event;
@ -1342,7 +1361,7 @@ void TileDataDefaultEditor::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: {
picker_button->set_icon(get_editor_theme_icon(SNAME("ColorPick")));
picker_button->set_button_icon(get_editor_theme_icon(SNAME("ColorPick")));
tile_bool_checked = get_editor_theme_icon(SNAME("TileChecked"));
tile_bool_unchecked = get_editor_theme_icon(SNAME("TileUnchecked"));
} break;
@ -1360,7 +1379,7 @@ TileDataDefaultEditor::TileDataDefaultEditor() {
add_child(label);
picker_button = memnew(Button);
picker_button->set_theme_type_variation("FlatButton");
picker_button->set_theme_type_variation(SceneStringName(FlatButton));
picker_button->set_toggle_mode(true);
picker_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/picker"));
toolbar->add_child(picker_button);
@ -1385,10 +1404,8 @@ void TileDataTextureOriginEditor::draw_over_tile(CanvasItem *p_canvas_item, Tran
TileSetSource *source = *(tile_set->get_source(p_cell.source_id));
TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
if (atlas_source->is_position_in_tile_texture_region(p_cell.get_atlas_coords(), p_cell.alternative_tile, -tile_set_tile_size / 2) && atlas_source->is_position_in_tile_texture_region(p_cell.get_atlas_coords(), p_cell.alternative_tile, tile_set_tile_size / 2 - Vector2(1, 1))) {
Transform2D tile_xform;
tile_xform.set_scale(tile_set_tile_size);
tile_set->draw_tile_shape(p_canvas_item, p_transform * tile_xform, color);
if (atlas_source->is_rect_in_tile_texture_region(p_cell.get_atlas_coords(), p_cell.alternative_tile, Rect2(Vector2(-tile_set_tile_size) / 2, tile_set_tile_size))) {
tile_set->draw_tile_shape(p_canvas_item, p_transform.scaled_local(tile_set_tile_size), color);
}
if (atlas_source->is_position_in_tile_texture_region(p_cell.get_atlas_coords(), p_cell.alternative_tile, Vector2())) {
@ -1469,30 +1486,36 @@ void TileDataOcclusionShapeEditor::draw_over_tile(CanvasItem *p_canvas_item, Tra
debug_occlusion_color.push_back(color);
RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), p_transform);
Ref<OccluderPolygon2D> occluder = tile_data->get_occluder(occlusion_layer);
if (occluder.is_valid() && occluder->get_polygon().size() >= 3) {
p_canvas_item->draw_polygon(Variant(occluder->get_polygon()), debug_occlusion_color);
for (int i = 0; i < tile_data->get_occluder_polygons_count(occlusion_layer); i++) {
Ref<OccluderPolygon2D> occluder = tile_data->get_occluder_polygon(occlusion_layer, i);
if (occluder.is_valid() && occluder->get_polygon().size() >= 3) {
p_canvas_item->draw_polygon(Variant(occluder->get_polygon()), debug_occlusion_color);
}
}
RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), Transform2D());
}
Variant TileDataOcclusionShapeEditor::_get_painted_value() {
Ref<OccluderPolygon2D> occluder_polygon;
if (polygon_editor->get_polygon_count() >= 1) {
Array polygons;
for (int i = 0; i < polygon_editor->get_polygon_count(); i++) {
Ref<OccluderPolygon2D> occluder_polygon;
occluder_polygon.instantiate();
occluder_polygon->set_polygon(polygon_editor->get_polygon(0));
occluder_polygon->set_polygon(polygon_editor->get_polygon(i));
polygons.push_back(occluder_polygon);
}
return occluder_polygon;
return polygons;
}
void TileDataOcclusionShapeEditor::_set_painted_value(TileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) {
TileData *tile_data = p_tile_set_atlas_source->get_tile_data(p_coords, p_alternative_tile);
ERR_FAIL_NULL(tile_data);
Ref<OccluderPolygon2D> occluder_polygon = tile_data->get_occluder(occlusion_layer);
polygon_editor->clear_polygons();
if (occluder_polygon.is_valid()) {
polygon_editor->add_polygon(occluder_polygon->get_polygon());
for (int i = 0; i < tile_data->get_occluder_polygons_count(occlusion_layer); i++) {
Ref<OccluderPolygon2D> occluder_polygon = tile_data->get_occluder_polygon(occlusion_layer, i);
if (occluder_polygon.is_valid()) {
polygon_editor->add_polygon(occluder_polygon->get_polygon());
}
}
polygon_editor->set_background_tile(p_tile_set_atlas_source, p_coords, p_alternative_tile);
}
@ -1500,8 +1523,13 @@ void TileDataOcclusionShapeEditor::_set_painted_value(TileSetAtlasSource *p_tile
void TileDataOcclusionShapeEditor::_set_value(TileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile, const Variant &p_value) {
TileData *tile_data = p_tile_set_atlas_source->get_tile_data(p_coords, p_alternative_tile);
ERR_FAIL_NULL(tile_data);
Ref<OccluderPolygon2D> occluder_polygon = p_value;
tile_data->set_occluder(occlusion_layer, occluder_polygon);
Array polygons = p_value;
tile_data->set_occluder_polygons_count(occlusion_layer, polygons.size());
for (int i = 0; i < polygons.size(); i++) {
Ref<OccluderPolygon2D> occluder_polygon = polygons[i];
tile_data->set_occluder_polygon(occlusion_layer, i, occluder_polygon);
}
polygon_editor->set_background_tile(p_tile_set_atlas_source, p_coords, p_alternative_tile);
}
@ -1509,7 +1537,11 @@ void TileDataOcclusionShapeEditor::_set_value(TileSetAtlasSource *p_tile_set_atl
Variant TileDataOcclusionShapeEditor::_get_value(TileSetAtlasSource *p_tile_set_atlas_source, Vector2 p_coords, int p_alternative_tile) {
TileData *tile_data = p_tile_set_atlas_source->get_tile_data(p_coords, p_alternative_tile);
ERR_FAIL_NULL_V(tile_data, Variant());
return tile_data->get_occluder(occlusion_layer);
Array polygons;
for (int i = 0; i < tile_data->get_occluder_polygons_count(occlusion_layer); i++) {
polygons.push_back(tile_data->get_occluder_polygon(occlusion_layer, i));
}
return polygons;
}
void TileDataOcclusionShapeEditor::_setup_undo_redo_action(TileSetAtlasSource *p_tile_set_atlas_source, const HashMap<TileMapCell, Variant, TileMapCell> &p_previous_values, const Variant &p_new_value) {
@ -1535,6 +1567,7 @@ void TileDataOcclusionShapeEditor::_notification(int p_what) {
TileDataOcclusionShapeEditor::TileDataOcclusionShapeEditor() {
polygon_editor = memnew(GenericTilePolygonEditor);
polygon_editor->set_multiple_polygon_mode(true);
add_child(polygon_editor);
}
@ -1819,7 +1852,7 @@ void TileDataCollisionEditor::draw_over_tile(CanvasItem *p_canvas_item, Transfor
}
void TileDataTerrainsEditor::_update_terrain_selector() {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
// Update the terrain set selector.
Vector<String> options;
@ -1872,7 +1905,7 @@ void TileDataTerrainsEditor::_property_value_changed(const StringName &p_propert
}
void TileDataTerrainsEditor::_tile_set_changed() {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
// Fix if wrong values are selected.
int terrain_set = int(dummy_object->get("terrain_set"));
@ -1890,7 +1923,7 @@ void TileDataTerrainsEditor::_tile_set_changed() {
}
void TileDataTerrainsEditor::forward_draw_over_atlas(TileAtlasView *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_null());
// Draw the hovered terrain bit, or the whole tile if it has the wrong terrain set.
Vector2i hovered_coords = TileSetSource::INVALID_ATLAS_COORDS;
@ -2077,7 +2110,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) {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
// Draw the hovered terrain bit, or the whole tile if it has the wrong terrain set.
Vector2i hovered_coords = TileSetSource::INVALID_ATLAS_COORDS;
@ -2834,7 +2867,7 @@ void TileDataTerrainsEditor::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE:
case NOTIFICATION_THEME_CHANGED: {
picker_button->set_icon(get_editor_theme_icon(SNAME("ColorPick")));
picker_button->set_button_icon(get_editor_theme_icon(SNAME("ColorPick")));
} break;
}
}
@ -2847,7 +2880,7 @@ TileDataTerrainsEditor::TileDataTerrainsEditor() {
// Toolbar
picker_button = memnew(Button);
picker_button->set_theme_type_variation("FlatButton");
picker_button->set_theme_type_variation(SceneStringName(FlatButton));
picker_button->set_toggle_mode(true);
picker_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/picker"));
toolbar->add_child(picker_button);

19
engine/editor/plugins/tiles/tile_data_editors.h
View file

@ -36,7 +36,6 @@
#include "editor/editor_properties.h"
#include "scene/2d/tile_map.h"
#include "scene/gui/box_container.h"
#include "scene/gui/panel_container.h"
class Label;
class MenuButton;
@ -54,7 +53,7 @@ private:
protected:
Ref<TileSet> tile_set;
TileData *_get_tile_data(TileMapCell p_cell);
virtual void _tile_set_changed(){};
virtual void _tile_set_changed() {}
static void _bind_methods();
@ -62,14 +61,14 @@ public:
void set_tile_set(Ref<TileSet> p_tile_set);
// Input to handle painting.
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_alternatives(TileAtlasView *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_alternatives_gui_input(TileAtlasView *p_tile_atlas_view, TileSetAtlasSource *p_tile_atlas_source, const Ref<InputEvent> &p_event){};
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_alternatives(TileAtlasView *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_alternatives_gui_input(TileAtlasView *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.
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) {}
};
class DummyObject : public Object {
@ -238,7 +237,7 @@ protected:
virtual void _setup_undo_redo_action(TileSetAtlasSource *p_tile_set_atlas_source, const HashMap<TileMapCell, Variant, TileMapCell> &p_previous_values, const Variant &p_new_value);
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_alternatives(TileAtlasView *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;
@ -375,7 +374,7 @@ protected:
void _notification(int p_what);
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_alternatives(TileAtlasView *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;

156
engine/editor/plugins/tiles/tile_map_layer_editor.cpp
View file

@ -39,9 +39,7 @@
#include "editor/multi_node_edit.h"
#include "editor/plugins/canvas_item_editor_plugin.h"
#include "editor/themes/editor_scale.h"
#include "scene/2d/camera_2d.h"
#include "scene/2d/tile_map_layer.h"
#include "scene/gui/center_container.h"
#include "scene/gui/split_container.h"
#include "core/input/input.h"
@ -86,8 +84,7 @@ void TileMapLayerEditorTilesPlugin::_update_toolbar() {
transform_toolbar->show();
tools_settings_vsep_2->show();
random_tile_toggle->show();
scatter_label->show();
scatter_spinbox->show();
scatter_controls_container->set_visible(random_tile_toggle->is_pressed());
} else {
tools_settings_vsep->show();
picker_button->show();
@ -96,8 +93,7 @@ void TileMapLayerEditorTilesPlugin::_update_toolbar() {
tools_settings_vsep_2->show();
bucket_contiguous_checkbox->show();
random_tile_toggle->show();
scatter_label->show();
scatter_spinbox->show();
scatter_controls_container->set_visible(random_tile_toggle->is_pressed());
}
}
@ -225,7 +221,7 @@ void TileMapLayerEditorTilesPlugin::_update_tile_set_sources_list() {
if (item_text.is_empty()) {
item_text = vformat(TTR("Unknown Type Source (ID: %d)"), source_id);
}
if (!texture.is_valid()) {
if (texture.is_null()) {
texture = missing_atlas_texture_icon;
}
@ -505,21 +501,21 @@ void TileMapLayerEditorTilesPlugin::_scenes_list_lmb_empty_clicked(const Vector2
}
void TileMapLayerEditorTilesPlugin::_update_theme() {
source_sort_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Sort")));
select_tool_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("ToolSelect")));
paint_tool_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Edit")));
line_tool_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Line")));
rect_tool_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Rectangle")));
bucket_tool_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Bucket")));
source_sort_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Sort")));
select_tool_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("ToolSelect")));
paint_tool_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Edit")));
line_tool_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Line")));
rect_tool_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Rectangle")));
bucket_tool_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Bucket")));
picker_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("ColorPick")));
erase_button->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Eraser")));
random_tile_toggle->set_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("RandomNumberGenerator")));
picker_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("ColorPick")));
erase_button->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("Eraser")));
random_tile_toggle->set_button_icon(tiles_bottom_panel->get_editor_theme_icon(SNAME("RandomNumberGenerator")));
transform_button_rotate_left->set_icon(tiles_bottom_panel->get_editor_theme_icon("RotateLeft"));
transform_button_rotate_right->set_icon(tiles_bottom_panel->get_editor_theme_icon("RotateRight"));
transform_button_flip_h->set_icon(tiles_bottom_panel->get_editor_theme_icon("MirrorX"));
transform_button_flip_v->set_icon(tiles_bottom_panel->get_editor_theme_icon("MirrorY"));
transform_button_rotate_left->set_button_icon(tiles_bottom_panel->get_editor_theme_icon("RotateLeft"));
transform_button_rotate_right->set_button_icon(tiles_bottom_panel->get_editor_theme_icon("RotateRight"));
transform_button_flip_h->set_button_icon(tiles_bottom_panel->get_editor_theme_icon("MirrorX"));
transform_button_flip_v->set_button_icon(tiles_bottom_panel->get_editor_theme_icon("MirrorY"));
missing_atlas_texture_icon = tiles_bottom_panel->get_editor_theme_icon(SNAME("TileSet"));
_update_tile_set_sources_list();
@ -804,6 +800,7 @@ void TileMapLayerEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p
Transform2D xform = CanvasItemEditor::get_singleton()->get_canvas_transform() * edited_layer->get_global_transform_with_canvas();
Vector2 mpos = edited_layer->get_local_mouse_position();
Vector2i tile_shape_size = tile_set->get_tile_size();
bool drawing_rect = false;
// Draw the selection.
if ((tiles_bottom_panel->is_visible_in_tree() || patterns_bottom_panel->is_visible_in_tree()) && tool_buttons_group->get_pressed_button() == select_tool_button) {
@ -897,6 +894,7 @@ void TileMapLayerEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p
} else if (drag_type == DRAG_TYPE_RECT) {
// Preview for a rect pattern.
preview = _draw_rect(tile_set->local_to_map(drag_start_mouse_pos), tile_set->local_to_map(mpos), drag_erasing);
drawing_rect = !preview.is_empty();
expand_grid = true;
} else if (tool_buttons_group->get_pressed_button() == bucket_tool_button && drag_type == DRAG_TYPE_NONE) {
// Preview for a fill pattern.
@ -1007,7 +1005,7 @@ void TileMapLayerEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p
Point2 msgpos = Point2(20 * EDSCALE, p_overlay->get_size().y - 20 * EDSCALE);
String text = tile_set->local_to_map(edited_layer->get_local_mouse_position());
if (drag_type == DRAG_TYPE_RECT) {
if (drawing_rect) {
Vector2i size = tile_set->local_to_map(edited_layer->get_local_mouse_position()) - tile_set->local_to_map(drag_start_mouse_pos);
text += vformat(" %s (%dx%d)", TTR("Drawing Rect:"), ABS(size.x) + 1, ABS(size.y) + 1);
}
@ -1366,11 +1364,13 @@ void TileMapLayerEditorTilesPlugin::_stop_dragging() {
Vector2i coords;
HashMap<Vector2i, TileMapCell> cells_undo;
for (int i = 0; i < selection_used_cells.size(); i++) {
coords = tile_set->map_pattern(top_left, selection_used_cells[i], selection_pattern);
cells_undo[coords] = TileMapCell(drag_modified[coords].source_id, drag_modified[coords].get_atlas_coords(), drag_modified[coords].alternative_tile);
coords = tile_set->map_pattern(top_left + offset, selection_used_cells[i], selection_pattern);
cells_undo[coords] = TileMapCell(edited_layer->get_cell_source_id(coords), edited_layer->get_cell_atlas_coords(coords), edited_layer->get_cell_alternative_tile(coords));
}
for (int i = 0; i < selection_used_cells.size(); i++) {
coords = tile_set->map_pattern(top_left, selection_used_cells[i], selection_pattern);
cells_undo[coords] = TileMapCell(drag_modified[coords].source_id, drag_modified[coords].get_atlas_coords(), drag_modified[coords].alternative_tile);
}
// Build the list of cells to do.
HashMap<Vector2i, TileMapCell> cells_do;
@ -1550,6 +1550,7 @@ int TileMapLayerEditorTilesPlugin::_get_transformed_alternative(int p_alternativ
case TRANSFORM_ROTATE_RIGHT: {
// A matrix with every possible flip/transpose combination, sorted by what comes next when you rotate.
const LocalVector<bool> rotation_matrix = {
// NOLINTBEGIN(modernize-use-bool-literals)
0, 0, 0,
0, 1, 1,
1, 1, 0,
@ -1558,6 +1559,7 @@ int TileMapLayerEditorTilesPlugin::_get_transformed_alternative(int p_alternativ
0, 0, 1,
0, 1, 0,
1, 1, 1
// NOLINTEND(modernize-use-bool-literals)
};
for (int i = 0; i < 8; i++) {
@ -2206,16 +2208,16 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
tool_buttons_group.instantiate();
select_tool_button = memnew(Button);
select_tool_button->set_theme_type_variation("FlatButton");
select_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
select_tool_button->set_toggle_mode(true);
select_tool_button->set_button_group(tool_buttons_group);
select_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/selection_tool", TTR("Selection"), Key::S));
select_tool_button->set_shortcut(ED_SHORTCUT("tiles_editor/selection_tool", TTRC("Selection Tool"), Key::S));
select_tool_button->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_update_toolbar));
tilemap_tiles_tools_buttons->add_child(select_tool_button);
viewport_shortcut_buttons.push_back(select_tool_button);
paint_tool_button = memnew(Button);
paint_tool_button->set_theme_type_variation("FlatButton");
paint_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
paint_tool_button->set_toggle_mode(true);
paint_tool_button->set_button_group(tool_buttons_group);
paint_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/paint_tool"));
@ -2225,7 +2227,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
viewport_shortcut_buttons.push_back(paint_tool_button);
line_tool_button = memnew(Button);
line_tool_button->set_theme_type_variation("FlatButton");
line_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
line_tool_button->set_toggle_mode(true);
line_tool_button->set_button_group(tool_buttons_group);
// TRANSLATORS: This refers to the line tool in the tilemap editor.
@ -2235,7 +2237,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
viewport_shortcut_buttons.push_back(line_tool_button);
rect_tool_button = memnew(Button);
rect_tool_button->set_theme_type_variation("FlatButton");
rect_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
rect_tool_button->set_toggle_mode(true);
rect_tool_button->set_button_group(tool_buttons_group);
rect_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/rect_tool"));
@ -2244,7 +2246,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
viewport_shortcut_buttons.push_back(rect_tool_button);
bucket_tool_button = memnew(Button);
bucket_tool_button->set_theme_type_variation("FlatButton");
bucket_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
bucket_tool_button->set_toggle_mode(true);
bucket_tool_button->set_button_group(tool_buttons_group);
bucket_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/bucket_tool"));
@ -2262,7 +2264,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
// Picker
picker_button = memnew(Button);
picker_button->set_theme_type_variation("FlatButton");
picker_button->set_theme_type_variation(SceneStringName(FlatButton));
picker_button->set_toggle_mode(true);
picker_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/picker"));
Key key = (OS::get_singleton()->has_feature("macos") || OS::get_singleton()->has_feature("web_macos") || OS::get_singleton()->has_feature("web_ios")) ? Key::META : Key::CTRL;
@ -2273,10 +2275,10 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
// Erase button.
erase_button = memnew(Button);
erase_button->set_theme_type_variation("FlatButton");
erase_button->set_theme_type_variation(SceneStringName(FlatButton));
erase_button->set_toggle_mode(true);
erase_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/eraser"));
erase_button->set_tooltip_text(TTR("Alternatively use RMB to erase tiles."));
erase_button->set_tooltip_text(TTRC("Alternatively use RMB to erase tiles."));
erase_button->connect(SceneStringName(pressed), callable_mp(CanvasItemEditor::get_singleton(), &CanvasItemEditor::update_viewport));
tools_settings->add_child(erase_button);
viewport_shortcut_buttons.push_back(erase_button);
@ -2287,29 +2289,29 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
transform_toolbar->add_child(memnew(VSeparator));
transform_button_rotate_left = memnew(Button);
transform_button_rotate_left->set_theme_type_variation("FlatButton");
transform_button_rotate_left->set_shortcut(ED_SHORTCUT("tiles_editor/rotate_tile_left", TTR("Rotate Tile Left"), Key::Z));
transform_button_rotate_left->set_theme_type_variation(SceneStringName(FlatButton));
transform_button_rotate_left->set_shortcut(ED_SHORTCUT("tiles_editor/rotate_tile_left", TTRC("Rotate Tile Left"), Key::Z));
transform_toolbar->add_child(transform_button_rotate_left);
transform_button_rotate_left->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_ROTATE_LEFT));
viewport_shortcut_buttons.push_back(transform_button_rotate_left);
transform_button_rotate_right = memnew(Button);
transform_button_rotate_right->set_theme_type_variation("FlatButton");
transform_button_rotate_right->set_shortcut(ED_SHORTCUT("tiles_editor/rotate_tile_right", TTR("Rotate Tile Right"), Key::X));
transform_button_rotate_right->set_theme_type_variation(SceneStringName(FlatButton));
transform_button_rotate_right->set_shortcut(ED_SHORTCUT("tiles_editor/rotate_tile_right", TTRC("Rotate Tile Right"), Key::X));
transform_toolbar->add_child(transform_button_rotate_right);
transform_button_rotate_right->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_ROTATE_RIGHT));
viewport_shortcut_buttons.push_back(transform_button_rotate_right);
transform_button_flip_h = memnew(Button);
transform_button_flip_h->set_theme_type_variation("FlatButton");
transform_button_flip_h->set_shortcut(ED_SHORTCUT("tiles_editor/flip_tile_horizontal", TTR("Flip Tile Horizontally"), Key::C));
transform_button_flip_h->set_theme_type_variation(SceneStringName(FlatButton));
transform_button_flip_h->set_shortcut(ED_SHORTCUT("tiles_editor/flip_tile_horizontal", TTRC("Flip Tile Horizontally"), Key::C));
transform_toolbar->add_child(transform_button_flip_h);
transform_button_flip_h->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_FLIP_H));
viewport_shortcut_buttons.push_back(transform_button_flip_h);
transform_button_flip_v = memnew(Button);
transform_button_flip_v->set_theme_type_variation("FlatButton");
transform_button_flip_v->set_shortcut(ED_SHORTCUT("tiles_editor/flip_tile_vertical", TTR("Flip Tile Vertically"), Key::V));
transform_button_flip_v->set_theme_type_variation(SceneStringName(FlatButton));
transform_button_flip_v->set_shortcut(ED_SHORTCUT("tiles_editor/flip_tile_vertical", TTRC("Flip Tile Vertically"), Key::V));
transform_toolbar->add_child(transform_button_flip_v);
transform_button_flip_v->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditorTilesPlugin::_apply_transform).bind(TRANSFORM_FLIP_V));
viewport_shortcut_buttons.push_back(transform_button_flip_v);
@ -2327,10 +2329,10 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
// Random tile checkbox.
random_tile_toggle = memnew(Button);
random_tile_toggle->set_theme_type_variation("FlatButton");
random_tile_toggle->set_theme_type_variation(SceneStringName(FlatButton));
random_tile_toggle->set_toggle_mode(true);
random_tile_toggle->set_tooltip_text(TTR("Place Random Tile"));
random_tile_toggle->connect("toggled", callable_mp(this, &TileMapLayerEditorTilesPlugin::_on_random_tile_checkbox_toggled));
random_tile_toggle->connect(SceneStringName(toggled), callable_mp(this, &TileMapLayerEditorTilesPlugin::_on_random_tile_checkbox_toggled));
tools_settings->add_child(random_tile_toggle);
// Random tile scattering.
@ -2368,7 +2370,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
tiles_bottom_panel->set_name(TTR("Tiles"));
missing_source_label = memnew(Label);
missing_source_label->set_text(TTR("This TileMap's TileSet has no source configured. Go to the TileSet bottom panel to add one."));
missing_source_label->set_text(TTR("This TileMap's TileSet has no Tile Source configured. Go to the TileSet bottom panel to add one."));
missing_source_label->set_h_size_flags(Control::SIZE_EXPAND_FILL);
missing_source_label->set_v_size_flags(Control::SIZE_EXPAND_FILL);
missing_source_label->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER);
@ -2413,6 +2415,7 @@ TileMapLayerEditorTilesPlugin::TileMapLayerEditorTilesPlugin() {
sources_list->set_stretch_ratio(0.25);
sources_list->set_custom_minimum_size(Size2(70, 0) * EDSCALE);
sources_list->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
sources_list->set_theme_type_variation("ItemListSecondary");
sources_list->connect(SceneStringName(item_selected), callable_mp(this, &TileMapLayerEditorTilesPlugin::_update_source_display).unbind(1));
sources_list->connect(SceneStringName(item_selected), callable_mp(TilesEditorUtils::get_singleton(), &TilesEditorUtils::set_sources_lists_current));
sources_list->connect("item_activated", callable_mp(TilesEditorUtils::get_singleton(), &TilesEditorUtils::display_tile_set_editor_panel).unbind(1));
@ -3344,7 +3347,9 @@ void TileMapLayerEditorTerrainsPlugin::_update_terrains_tree() {
terrains_tree->create_item();
const TileMapLayer *edited_layer = _get_edited_layer();
ERR_FAIL_NULL(edited_layer);
if (!edited_layer) {
return;
}
Ref<TileSet> tile_set = edited_layer->get_tile_set();
if (tile_set.is_null()) {
@ -3486,13 +3491,13 @@ void TileMapLayerEditorTerrainsPlugin::_update_tiles_list() {
}
void TileMapLayerEditorTerrainsPlugin::_update_theme() {
paint_tool_button->set_icon(main_vbox_container->get_editor_theme_icon(SNAME("Edit")));
line_tool_button->set_icon(main_vbox_container->get_editor_theme_icon(SNAME("Line")));
rect_tool_button->set_icon(main_vbox_container->get_editor_theme_icon(SNAME("Rectangle")));
bucket_tool_button->set_icon(main_vbox_container->get_editor_theme_icon(SNAME("Bucket")));
paint_tool_button->set_button_icon(main_vbox_container->get_editor_theme_icon(SNAME("Edit")));
line_tool_button->set_button_icon(main_vbox_container->get_editor_theme_icon(SNAME("Line")));
rect_tool_button->set_button_icon(main_vbox_container->get_editor_theme_icon(SNAME("Rectangle")));
bucket_tool_button->set_button_icon(main_vbox_container->get_editor_theme_icon(SNAME("Bucket")));
picker_button->set_icon(main_vbox_container->get_editor_theme_icon(SNAME("ColorPick")));
erase_button->set_icon(main_vbox_container->get_editor_theme_icon(SNAME("Eraser")));
picker_button->set_button_icon(main_vbox_container->get_editor_theme_icon(SNAME("ColorPick")));
erase_button->set_button_icon(main_vbox_container->get_editor_theme_icon(SNAME("Eraser")));
_update_tiles_list();
}
@ -3529,6 +3534,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() {
terrains_tree->set_custom_minimum_size(Size2(70, 0) * EDSCALE);
terrains_tree->set_texture_filter(CanvasItem::TEXTURE_FILTER_NEAREST);
terrains_tree->set_hide_root(true);
terrains_tree->set_theme_type_variation("ItemListSecondary");
terrains_tree->connect(SceneStringName(item_selected), callable_mp(this, &TileMapLayerEditorTerrainsPlugin::_update_tiles_list));
tilemap_tab_terrains->add_child(terrains_tree);
@ -3549,7 +3555,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() {
tool_buttons_group.instantiate();
paint_tool_button = memnew(Button);
paint_tool_button->set_theme_type_variation("FlatButton");
paint_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
paint_tool_button->set_toggle_mode(true);
paint_tool_button->set_button_group(tool_buttons_group);
paint_tool_button->set_pressed(true);
@ -3559,7 +3565,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() {
viewport_shortcut_buttons.push_back(paint_tool_button);
line_tool_button = memnew(Button);
line_tool_button->set_theme_type_variation("FlatButton");
line_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
line_tool_button->set_toggle_mode(true);
line_tool_button->set_button_group(tool_buttons_group);
line_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/line_tool"));
@ -3568,7 +3574,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() {
viewport_shortcut_buttons.push_back(line_tool_button);
rect_tool_button = memnew(Button);
rect_tool_button->set_theme_type_variation("FlatButton");
rect_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
rect_tool_button->set_toggle_mode(true);
rect_tool_button->set_button_group(tool_buttons_group);
rect_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/rect_tool"));
@ -3577,7 +3583,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() {
viewport_shortcut_buttons.push_back(rect_tool_button);
bucket_tool_button = memnew(Button);
bucket_tool_button->set_theme_type_variation("FlatButton");
bucket_tool_button->set_theme_type_variation(SceneStringName(FlatButton));
bucket_tool_button->set_toggle_mode(true);
bucket_tool_button->set_button_group(tool_buttons_group);
bucket_tool_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/bucket_tool"));
@ -3596,7 +3602,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() {
// Picker
picker_button = memnew(Button);
picker_button->set_theme_type_variation("FlatButton");
picker_button->set_theme_type_variation(SceneStringName(FlatButton));
picker_button->set_toggle_mode(true);
picker_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/picker"));
picker_button->connect(SceneStringName(pressed), callable_mp(CanvasItemEditor::get_singleton(), &CanvasItemEditor::update_viewport));
@ -3605,7 +3611,7 @@ TileMapLayerEditorTerrainsPlugin::TileMapLayerEditorTerrainsPlugin() {
// Erase button.
erase_button = memnew(Button);
erase_button->set_theme_type_variation("FlatButton");
erase_button->set_theme_type_variation(SceneStringName(FlatButton));
erase_button->set_toggle_mode(true);
erase_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/eraser"));
erase_button->connect(SceneStringName(pressed), callable_mp(CanvasItemEditor::get_singleton(), &CanvasItemEditor::update_viewport));
@ -3676,6 +3682,11 @@ void TileMapLayerEditor::_node_change(Node *p_node) {
void TileMapLayerEditor::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_READY: {
toggle_grid_button->set_pressed_no_signal(EDITOR_GET("editors/tiles_editor/display_grid"));
toggle_highlight_selected_layer_button->set_pressed_no_signal(EDITOR_GET("editors/tiles_editor/highlight_selected_layer"));
} break;
case NOTIFICATION_ENTER_TREE: {
get_tree()->connect("node_added", callable_mp(this, &TileMapLayerEditor::_node_change));
get_tree()->connect("node_removed", callable_mp(this, &TileMapLayerEditor::_node_change));
@ -3689,12 +3700,12 @@ void TileMapLayerEditor::_notification(int p_what) {
case NOTIFICATION_THEME_CHANGED: {
missing_tile_texture = get_editor_theme_icon(SNAME("StatusWarning"));
warning_pattern_texture = get_editor_theme_icon(SNAME("WarningPattern"));
advanced_menu_button->set_icon(get_editor_theme_icon(SNAME("Tools")));
select_previous_layer->set_icon(get_editor_theme_icon(SNAME("MoveUp")));
select_next_layer->set_icon(get_editor_theme_icon(SNAME("MoveDown")));
select_all_layers->set_icon(get_editor_theme_icon(SNAME("FileList")));
toggle_grid_button->set_icon(get_editor_theme_icon(SNAME("Grid")));
toggle_highlight_selected_layer_button->set_icon(get_editor_theme_icon(SNAME("TileMapHighlightSelected")));
advanced_menu_button->set_button_icon(get_editor_theme_icon(SNAME("Tools")));
select_previous_layer->set_button_icon(get_editor_theme_icon(SNAME("MoveUp")));
select_next_layer->set_button_icon(get_editor_theme_icon(SNAME("MoveDown")));
select_all_layers->set_button_icon(get_editor_theme_icon(SNAME("FileList")));
toggle_grid_button->set_button_icon(get_editor_theme_icon(SNAME("Grid")));
toggle_highlight_selected_layer_button->set_button_icon(get_editor_theme_icon(SNAME("TileMapHighlightSelected")));
} break;
case NOTIFICATION_INTERNAL_PROCESS: {
@ -4409,8 +4420,8 @@ TileMapLayerEditor::TileMapLayerEditor() {
set_process_internal(true);
// Shortcuts.
ED_SHORTCUT("tiles_editor/select_next_layer", TTR("Select Next Tile Map Layer"), Key::PAGEDOWN);
ED_SHORTCUT("tiles_editor/select_previous_layer", TTR("Select Previous Tile Map Layer"), Key::PAGEUP);
ED_SHORTCUT("tiles_editor/select_next_layer", TTRC("Select Next Tile Map Layer"), Key::PAGEDOWN);
ED_SHORTCUT("tiles_editor/select_previous_layer", TTRC("Select Previous Tile Map Layer"), Key::PAGEUP);
// TileMap editor plugins
tile_map_editor_plugins.push_back(memnew(TileMapLayerEditorTilesPlugin));
@ -4463,19 +4474,19 @@ TileMapLayerEditor::TileMapLayerEditor() {
layer_selection_hbox->add_child(layers_selection_button);
select_previous_layer = memnew(Button);
select_previous_layer->set_theme_type_variation("FlatButton");
select_previous_layer->set_theme_type_variation(SceneStringName(FlatButton));
select_previous_layer->set_tooltip_text(TTR("Select previous layer"));
select_previous_layer->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditor::_select_previous_layer_pressed));
layer_selection_hbox->add_child(select_previous_layer);
select_next_layer = memnew(Button);
select_next_layer->set_theme_type_variation("FlatButton");
select_next_layer->set_theme_type_variation(SceneStringName(FlatButton));
select_next_layer->set_tooltip_text(TTR("Select next layer"));
select_next_layer->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditor::_select_next_layer_pressed));
layer_selection_hbox->add_child(select_next_layer);
select_all_layers = memnew(Button);
select_all_layers->set_theme_type_variation("FlatButton");
select_all_layers->set_theme_type_variation(SceneStringName(FlatButton));
select_all_layers->set_text(TTR("Select all layers"));
select_all_layers->connect(SceneStringName(pressed), callable_mp(this, &TileMapLayerEditor::_select_all_layers_pressed));
select_all_layers->set_tooltip_text(TTR("Select all TileMapLayers in scene"));
@ -4483,10 +4494,9 @@ TileMapLayerEditor::TileMapLayerEditor() {
// Highlighting selected layer.
toggle_highlight_selected_layer_button = memnew(Button);
toggle_highlight_selected_layer_button->set_theme_type_variation("FlatButton");
toggle_highlight_selected_layer_button->set_theme_type_variation(SceneStringName(FlatButton));
toggle_highlight_selected_layer_button->set_toggle_mode(true);
toggle_highlight_selected_layer_button->set_pressed(true);
toggle_highlight_selected_layer_button->connect("toggled", callable_mp(this, &TileMapLayerEditor::_highlight_selected_layer_button_toggled));
toggle_highlight_selected_layer_button->connect(SceneStringName(toggled), callable_mp(this, &TileMapLayerEditor::_highlight_selected_layer_button_toggled));
toggle_highlight_selected_layer_button->set_tooltip_text(TTR("Highlight Selected TileMap Layer"));
tile_map_toolbar->add_child(toggle_highlight_selected_layer_button);
@ -4494,16 +4504,16 @@ TileMapLayerEditor::TileMapLayerEditor() {
// Grid toggle.
toggle_grid_button = memnew(Button);
toggle_grid_button->set_theme_type_variation("FlatButton");
toggle_grid_button->set_theme_type_variation(SceneStringName(FlatButton));
toggle_grid_button->set_toggle_mode(true);
toggle_grid_button->set_tooltip_text(TTR("Toggle grid visibility."));
toggle_grid_button->connect("toggled", callable_mp(this, &TileMapLayerEditor::_on_grid_toggled));
toggle_grid_button->connect(SceneStringName(toggled), callable_mp(this, &TileMapLayerEditor::_on_grid_toggled));
tile_map_toolbar->add_child(toggle_grid_button);
// Advanced settings menu button.
advanced_menu_button = memnew(MenuButton);
advanced_menu_button->set_flat(false);
advanced_menu_button->set_theme_type_variation("FlatButton");
advanced_menu_button->set_theme_type_variation(SceneStringName(FlatButton));
advanced_menu_button->get_popup()->add_item(TTR("Automatically Replace Tiles with Proxies"), ADVANCED_MENU_REPLACE_WITH_PROXIES);
advanced_menu_button->get_popup()->add_item(TTR("Extract TileMap layers as individual TileMapLayer nodes"), ADVANCED_MENU_EXTRACT_TILE_MAP_LAYERS);
advanced_menu_button->get_popup()->connect(SceneStringName(id_pressed), callable_mp(this, &TileMapLayerEditor::_advanced_menu_button_id_pressed));

11
engine/editor/plugins/tiles/tile_map_layer_editor.h
View file

@ -34,7 +34,6 @@
#include "tile_atlas_view.h"
#include "core/os/thread.h"
#include "core/typedefs.h"
#include "scene/2d/tile_map.h"
#include "scene/gui/box_container.h"
#include "scene/gui/check_box.h"
@ -63,12 +62,12 @@ public:
virtual Vector<TabData> get_tabs() const {
return Vector<TabData>();
};
}
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) { return false; };
virtual void forward_canvas_draw_over_viewport(Control *p_overlay){};
virtual void tile_set_changed(){};
virtual void edit(ObjectID p_tile_map_layer_id){};
virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) { return false; }
virtual void forward_canvas_draw_over_viewport(Control *p_overlay) {}
virtual void tile_set_changed() {}
virtual void edit(ObjectID p_tile_map_layer_id) {}
};
class TileMapLayerEditorTilesPlugin : public TileMapLayerSubEditorPlugin {

14
engine/editor/plugins/tiles/tile_proxies_manager_dialog.cpp
View file

@ -33,8 +33,6 @@
#include "editor/editor_properties_vector.h"
#include "editor/editor_settings.h"
#include "editor/editor_undo_redo_manager.h"
#include "editor/themes/editor_scale.h"
#include "scene/gui/dialogs.h"
#include "scene/gui/popup_menu.h"
#include "scene/gui/separator.h"
@ -87,7 +85,7 @@ void TileProxiesManagerDialog::_delete_selected_bindings() {
undo_redo->add_undo_method(this, "_update_lists");
undo_redo->commit_action();
commited_actions_count += 1;
committed_actions_count += 1;
}
void TileProxiesManagerDialog::_update_lists() {
@ -193,7 +191,7 @@ void TileProxiesManagerDialog::_add_button_pressed() {
undo_redo->add_do_method(this, "_update_lists");
undo_redo->add_undo_method(this, "_update_lists");
undo_redo->commit_action();
commited_actions_count++;
committed_actions_count++;
}
}
@ -308,10 +306,10 @@ void TileProxiesManagerDialog::_unhandled_key_input(Ref<InputEvent> p_event) {
void TileProxiesManagerDialog::cancel_pressed() {
EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
for (int i = 0; i < commited_actions_count; i++) {
for (int i = 0; i < committed_actions_count; i++) {
undo_redo->undo();
}
commited_actions_count = 0;
committed_actions_count = 0;
}
void TileProxiesManagerDialog::_bind_methods() {
@ -320,9 +318,9 @@ void TileProxiesManagerDialog::_bind_methods() {
}
void TileProxiesManagerDialog::update_tile_set(Ref<TileSet> p_tile_set) {
ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(p_tile_set.is_null());
tile_set = p_tile_set;
commited_actions_count = 0;
committed_actions_count = 0;
_update_lists();
}

4
engine/editor/plugins/tiles/tile_proxies_manager_dialog.h
View file

@ -32,9 +32,9 @@
#define TILE_PROXIES_MANAGER_DIALOG_H
#include "editor/editor_properties.h"
#include "scene/2d/tile_map.h"
#include "scene/gui/dialogs.h"
#include "scene/gui/item_list.h"
#include "scene/resources/2d/tile_set.h"
class EditorPropertyVector2i;
class EditorUndoRedoManager;
@ -43,7 +43,7 @@ class TileProxiesManagerDialog : public ConfirmationDialog {
GDCLASS(TileProxiesManagerDialog, ConfirmationDialog);
private:
int commited_actions_count = 0;
int committed_actions_count = 0;
Ref<TileSet> tile_set;
TileMapCell from;

205
engine/editor/plugins/tiles/tile_set_atlas_source_editor.cpp
View file

@ -39,16 +39,11 @@
#include "editor/editor_undo_redo_manager.h"
#include "editor/gui/editor_toaster.h"
#include "editor/plugins/tiles/tile_set_editor.h"
#include "editor/progress_dialog.h"
#include "editor/themes/editor_scale.h"
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#include "scene/gui/control.h"
#include "scene/gui/item_list.h"
#include "scene/gui/separator.h"
#include "scene/gui/split_container.h"
#include "scene/gui/tab_container.h"
#include "core/math/geometry_2d.h"
#include "core/os/keyboard.h"
@ -91,7 +86,7 @@ bool TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_set(const StringN
}
bool TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_get(const StringName &p_name, Variant &r_ret) const {
if (!tile_set_atlas_source.is_valid()) {
if (tile_set_atlas_source.is_null()) {
return false;
}
if (p_name == "id") {
@ -124,7 +119,7 @@ void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::_bind_methods() {
}
void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::edit(Ref<TileSet> p_tile_set, Ref<TileSetAtlasSource> p_tile_set_atlas_source, int p_source_id) {
ERR_FAIL_COND(!p_tile_set_atlas_source.is_valid());
ERR_FAIL_COND(p_tile_set_atlas_source.is_null());
ERR_FAIL_COND(p_source_id < 0);
ERR_FAIL_COND(p_tile_set.is_valid() && p_tile_set->get_source(p_source_id) != p_tile_set_atlas_source);
@ -153,7 +148,7 @@ void TileSetAtlasSourceEditor::TileSetAtlasSourceProxyObject::edit(Ref<TileSet>
// -- Proxy object used by the tile inspector --
bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_set(const StringName &p_name, const Variant &p_value) {
if (!tile_set_atlas_source.is_valid()) {
if (tile_set_atlas_source.is_null()) {
return false;
}
@ -310,7 +305,7 @@ bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_set(const StringName &p_na
}
bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_get(const StringName &p_name, Variant &r_ret) const {
if (!tile_set_atlas_source.is_valid()) {
if (tile_set_atlas_source.is_null()) {
return false;
}
@ -397,7 +392,7 @@ bool TileSetAtlasSourceEditor::AtlasTileProxyObject::_get(const StringName &p_na
}
void TileSetAtlasSourceEditor::AtlasTileProxyObject::_get_property_list(List<PropertyInfo> *p_list) const {
if (!tile_set_atlas_source.is_valid()) {
if (tile_set_atlas_source.is_null()) {
return;
}
@ -444,10 +439,10 @@ void TileSetAtlasSourceEditor::AtlasTileProxyObject::_get_property_list(List<Pro
// Get the list of properties common to all tiles (similar to what's done in MultiNodeEdit).
struct PropertyId {
int occurence_id = 0;
int occurrence_id = 0;
String property;
bool operator<(const PropertyId &p_other) const {
return occurence_id == p_other.occurence_id ? property < p_other.property : occurence_id < p_other.occurence_id;
return occurrence_id == p_other.occurrence_id ? property < p_other.property : occurrence_id < p_other.occurrence_id;
}
};
struct PLData {
@ -507,7 +502,7 @@ void TileSetAtlasSourceEditor::AtlasTileProxyObject::_get_property_list(List<Pro
}
void TileSetAtlasSourceEditor::AtlasTileProxyObject::edit(Ref<TileSetAtlasSource> p_tile_set_atlas_source, const RBSet<TileSelection> &p_tiles) {
ERR_FAIL_COND(!p_tile_set_atlas_source.is_valid());
ERR_FAIL_COND(p_tile_set_atlas_source.is_null());
ERR_FAIL_COND(p_tiles.is_empty());
for (const TileSelection &E : p_tiles) {
ERR_FAIL_COND(E.tile == TileSetSource::INVALID_ATLAS_COORDS);
@ -976,40 +971,44 @@ void TileSetAtlasSourceEditor::_update_atlas_view() {
tile_create_help->set_visible(tools_button_group->get_pressed_button() == tool_setup_atlas_source_button);
}
Vector2i pos;
Vector2 texture_region_base_size = tile_set_atlas_source->get_texture_region_size();
int texture_region_base_size_min = MIN(texture_region_base_size.x, texture_region_base_size.y);
for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) {
Vector2i tile_id = tile_set_atlas_source->get_tile_id(i);
int alternative_count = tile_set_atlas_source->get_alternative_tiles_count(tile_id);
if (alternative_count > 1) {
// Compute the right extremity of alternative.
int y_increment = 0;
pos.x = 0;
for (int j = 1; j < alternative_count; j++) {
int alternative_id = tile_set_atlas_source->get_alternative_tile_id(tile_id, j);
Rect2i rect = tile_atlas_view->get_alternative_tile_rect(tile_id, alternative_id);
pos.x = MAX(pos.x, rect.get_end().x);
y_increment = MAX(y_increment, rect.size.y);
if (tools_button_group->get_pressed_button() != tool_paint_button) {
Vector2i pos;
Vector2 texture_region_base_size = tile_set_atlas_source->get_texture_region_size();
int texture_region_base_size_min = MIN(texture_region_base_size.x, texture_region_base_size.y);
for (int i = 0; i < tile_set_atlas_source->get_tiles_count(); i++) {
Vector2i tile_id = tile_set_atlas_source->get_tile_id(i);
int alternative_count = tile_set_atlas_source->get_alternative_tiles_count(tile_id);
if (alternative_count > 1) {
// Compute the right extremity of alternative.
int y_increment = 0;
pos.x = 0;
for (int j = 1; j < alternative_count; j++) {
int alternative_id = tile_set_atlas_source->get_alternative_tile_id(tile_id, j);
Rect2i rect = tile_atlas_view->get_alternative_tile_rect(tile_id, alternative_id);
pos.x = MAX(pos.x, rect.get_end().x);
y_increment = MAX(y_increment, rect.size.y);
}
// Create and position the button.
Button *button = memnew(Button);
button->set_flat(true);
button->set_button_icon(get_editor_theme_icon(SNAME("Add")));
button->add_theme_style_override(CoreStringName(normal), memnew(StyleBoxEmpty));
button->add_theme_style_override(SceneStringName(hover), memnew(StyleBoxEmpty));
button->add_theme_style_override("focus", memnew(StyleBoxEmpty));
button->add_theme_style_override(SceneStringName(pressed), memnew(StyleBoxEmpty));
button->add_theme_constant_override("align_to_largest_stylebox", false);
button->set_mouse_filter(Control::MOUSE_FILTER_PASS);
button->connect(SceneStringName(pressed), callable_mp(this, &TileSetAtlasSourceEditor::_tile_alternatives_create_button_pressed).bind(tile_id));
button->set_rect(Rect2(Vector2(pos.x, pos.y + (y_increment - texture_region_base_size.y) / 2.0), Vector2(texture_region_base_size_min, texture_region_base_size_min)));
button->set_expand_icon(true);
alternative_tiles_control->add_child(button);
pos.y += y_increment;
}
// Create and position the button.
Button *button = memnew(Button);
button->set_flat(true);
button->set_icon(get_editor_theme_icon(SNAME("Add")));
button->add_theme_style_override(CoreStringName(normal), memnew(StyleBoxEmpty));
button->add_theme_style_override("hover", memnew(StyleBoxEmpty));
button->add_theme_style_override("focus", memnew(StyleBoxEmpty));
button->add_theme_style_override(SceneStringName(pressed), memnew(StyleBoxEmpty));
button->connect(SceneStringName(pressed), callable_mp(tile_set_atlas_source, &TileSetAtlasSource::create_alternative_tile).bind(tile_id, TileSetSource::INVALID_TILE_ALTERNATIVE));
button->set_rect(Rect2(Vector2(pos.x, pos.y + (y_increment - texture_region_base_size.y) / 2.0), Vector2(texture_region_base_size_min, texture_region_base_size_min)));
button->set_expand_icon(true);
alternative_tiles_control->add_child(button);
pos.y += y_increment;
}
tile_atlas_view->set_padding(Side::SIDE_RIGHT, texture_region_base_size_min);
}
tile_atlas_view->set_padding(Side::SIDE_RIGHT, texture_region_base_size_min);
// Redraw everything.
tile_atlas_control->queue_redraw();
@ -1699,7 +1698,7 @@ void TileSetAtlasSourceEditor::_menu_option(int p_option) {
void TileSetAtlasSourceEditor::shortcut_input(const Ref<InputEvent> &p_event) {
// Check for shortcuts.
if (ED_IS_SHORTCUT("tiles_editor/delete_tile", p_event)) {
if (ED_IS_SHORTCUT("tiles_editor/delete", p_event)) {
if (tools_button_group->get_pressed_button() == tool_select_button && !selection.is_empty()) {
_menu_option(TILE_DELETE);
accept_event();
@ -2014,6 +2013,17 @@ void TileSetAtlasSourceEditor::_tile_alternatives_control_mouse_exited() {
alternative_tiles_control_unscaled->queue_redraw();
}
void TileSetAtlasSourceEditor::_tile_alternatives_create_button_pressed(const Vector2i &p_atlas_coords) {
EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton();
// FIXME: Doesn't undo changes to `next_alternative_id` counter.
undo_redo->create_action(TTR("Create tile alternatives"));
int next_id = tile_set_atlas_source->get_next_alternative_tile_id(p_atlas_coords);
undo_redo->add_do_method(tile_set_atlas_source, "create_alternative_tile", p_atlas_coords, next_id);
undo_redo->add_undo_method(tile_set_atlas_source, "remove_alternative_tile", p_atlas_coords, next_id);
undo_redo->commit_action();
}
void TileSetAtlasSourceEditor::_tile_alternatives_control_draw() {
// Update the hovered alternative tile.
if (tools_button_group->get_pressed_button() == tool_select_button) {
@ -2167,7 +2177,7 @@ Vector2i TileSetAtlasSourceEditor::_get_drag_offset_tile_coords(const Vector2i &
}
void TileSetAtlasSourceEditor::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_null());
ERR_FAIL_NULL(p_tile_set_atlas_source);
ERR_FAIL_COND(p_source_id < 0);
ERR_FAIL_COND(p_tile_set->get_source(p_source_id) != p_tile_set_atlas_source);
@ -2441,12 +2451,12 @@ void TileSetAtlasSourceEditor::_notification(int p_what) {
} break;
case NOTIFICATION_THEME_CHANGED: {
tool_setup_atlas_source_button->set_icon(get_editor_theme_icon(SNAME("Tools")));
tool_select_button->set_icon(get_editor_theme_icon(SNAME("ToolSelect")));
tool_paint_button->set_icon(get_editor_theme_icon(SNAME("Paint")));
tool_setup_atlas_source_button->set_button_icon(get_editor_theme_icon(SNAME("Tools")));
tool_select_button->set_button_icon(get_editor_theme_icon(SNAME("ToolSelect")));
tool_paint_button->set_button_icon(get_editor_theme_icon(SNAME("Paint")));
tools_settings_erase_button->set_icon(get_editor_theme_icon(SNAME("Eraser")));
tool_advanced_menu_button->set_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
tools_settings_erase_button->set_button_icon(get_editor_theme_icon(SNAME("Eraser")));
tool_advanced_menu_button->set_button_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
outside_tiles_warning->set_texture(get_editor_theme_icon(SNAME("StatusWarning")));
resize_handle = get_editor_theme_icon(SNAME("EditorHandle"));
@ -2527,7 +2537,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tool_setup_atlas_source_button = memnew(Button);
tool_setup_atlas_source_button->set_text(TTR("Setup"));
tool_setup_atlas_source_button->set_theme_type_variation("FlatButton");
tool_setup_atlas_source_button->set_theme_type_variation(SceneStringName(FlatButton));
tool_setup_atlas_source_button->set_toggle_mode(true);
tool_setup_atlas_source_button->set_pressed(true);
tool_setup_atlas_source_button->set_button_group(tools_button_group);
@ -2536,7 +2546,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tool_select_button = memnew(Button);
tool_select_button->set_text(TTR("Select"));
tool_select_button->set_theme_type_variation("FlatButton");
tool_select_button->set_theme_type_variation(SceneStringName(FlatButton));
tool_select_button->set_toggle_mode(true);
tool_select_button->set_pressed(false);
tool_select_button->set_button_group(tools_button_group);
@ -2545,7 +2555,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tool_paint_button = memnew(Button);
tool_paint_button->set_text(TTR("Paint"));
tool_paint_button->set_theme_type_variation("FlatButton");
tool_paint_button->set_theme_type_variation(SceneStringName(FlatButton));
tool_paint_button->set_toggle_mode(true);
tool_paint_button->set_button_group(tools_button_group);
toolbox->add_child(tool_paint_button);
@ -2612,7 +2622,6 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
atlas_source_inspector->set_v_size_flags(SIZE_EXPAND_FILL);
atlas_source_inspector->set_show_categories(false, true);
atlas_source_inspector->set_use_doc_hints(true);
atlas_source_inspector->add_inspector_plugin(memnew(TileSourceInspectorPlugin));
middle_vbox_container->add_child(atlas_source_inspector);
// -- Right side --
@ -2627,7 +2636,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tool_settings->add_child(tool_settings_tile_data_toolbar_container);
tools_settings_erase_button = memnew(Button);
tools_settings_erase_button->set_theme_type_variation("FlatButton");
tools_settings_erase_button->set_theme_type_variation(SceneStringName(FlatButton));
tools_settings_erase_button->set_toggle_mode(true);
tools_settings_erase_button->set_shortcut(ED_GET_SHORTCUT("tiles_editor/eraser"));
tools_settings_erase_button->set_shortcut_context(this);
@ -2712,7 +2721,7 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
tile_atlas_control_unscaled->set_mouse_filter(Control::MOUSE_FILTER_IGNORE);
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_GET_SHORTCUT("tiles_editor/delete"), TILE_DELETE);
alternative_tile_popup_menu->connect(SceneStringName(id_pressed), callable_mp(this, &TileSetAtlasSourceEditor::_menu_option));
tile_atlas_view->add_child(alternative_tile_popup_menu);
@ -2740,9 +2749,8 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
add_child(confirm_auto_create_tiles);
// Inspector plugin.
Ref<EditorInspectorPluginTileData> tile_data_inspector_plugin;
tile_data_inspector_plugin.instantiate();
EditorInspector::add_inspector_plugin(tile_data_inspector_plugin);
EditorInspector::add_inspector_plugin(memnew(EditorInspectorPluginTileData));
EditorInspector::add_inspector_plugin(memnew(TileSourceInspectorPlugin));
}
TileSetAtlasSourceEditor::~TileSetAtlasSourceEditor() {
@ -2770,15 +2778,7 @@ void EditorPropertyTilePolygon::_add_focusable_children(Node *p_node) {
void EditorPropertyTilePolygon::_polygons_changed() {
if (String(count_property).is_empty()) {
if (base_type == "OccluderPolygon2D") {
// Single OccluderPolygon2D.
Ref<OccluderPolygon2D> occluder;
if (generic_tile_polygon_editor->get_polygon_count() >= 1) {
occluder.instantiate();
occluder->set_polygon(generic_tile_polygon_editor->get_polygon(0));
}
emit_changed(get_edited_property(), occluder);
} else if (base_type == "NavigationPolygon") {
if (base_type == "NavigationPolygon") {
Ref<NavigationPolygon> navigation_polygon;
if (generic_tile_polygon_editor->get_polygon_count() >= 1) {
navigation_polygon.instantiate();
@ -2800,19 +2800,24 @@ void EditorPropertyTilePolygon::_polygons_changed() {
emit_changed(get_edited_property(), navigation_polygon);
}
} else {
if (base_type.is_empty()) {
// Multiple array of vertices.
Vector<String> changed_properties;
Array values;
int count = generic_tile_polygon_editor->get_polygon_count();
changed_properties.push_back(count_property);
values.push_back(count);
for (int i = 0; i < count; i++) {
changed_properties.push_back(vformat(element_pattern, i));
// Multiple array of vertices or OccluderPolygon2D.
Vector<String> changed_properties;
Array values;
int count = generic_tile_polygon_editor->get_polygon_count();
changed_properties.push_back(count_property);
values.push_back(count);
for (int i = 0; i < count; i++) {
changed_properties.push_back(vformat(element_pattern, i));
if (base_type.is_empty()) {
values.push_back(generic_tile_polygon_editor->get_polygon(i));
} else if (base_type == "OccluderPolygon2D") {
Ref<OccluderPolygon2D> occluder;
occluder.instantiate();
occluder->set_polygon(generic_tile_polygon_editor->get_polygon(i));
values.push_back(occluder);
}
emit_signal(SNAME("multiple_properties_changed"), changed_properties, values, false);
}
emit_signal(SNAME("multiple_properties_changed"), changed_properties, values, false);
}
}
@ -2836,15 +2841,8 @@ void EditorPropertyTilePolygon::update_property() {
generic_tile_polygon_editor->clear_polygons();
if (String(count_property).is_empty()) {
if (base_type == "OccluderPolygon2D") {
// Single OccluderPolygon2D.
Ref<OccluderPolygon2D> occluder = get_edited_property_value();
generic_tile_polygon_editor->clear_polygons();
if (occluder.is_valid()) {
generic_tile_polygon_editor->add_polygon(occluder->get_polygon());
}
} else if (base_type == "NavigationPolygon") {
// Single OccluderPolygon2D.
if (base_type == "NavigationPolygon") {
// Single NavigationPolygon.
Ref<NavigationPolygon> navigation_polygon = get_edited_property_value();
generic_tile_polygon_editor->clear_polygons();
if (navigation_polygon.is_valid()) {
@ -2861,6 +2859,15 @@ void EditorPropertyTilePolygon::update_property() {
for (int i = 0; i < count; i++) {
generic_tile_polygon_editor->add_polygon(get_edited_object()->get(vformat(element_pattern, i)));
}
} else if (base_type == "OccluderPolygon2D") {
// Multiple OccluderPolygon2D.
generic_tile_polygon_editor->clear_polygons();
for (int i = 0; i < count; i++) {
Ref<OccluderPolygon2D> occluder = get_edited_object()->get(vformat(element_pattern, i));
if (occluder.is_valid()) {
generic_tile_polygon_editor->add_polygon(occluder->get_polygon());
}
}
}
}
}
@ -2901,16 +2908,30 @@ bool EditorInspectorPluginTileData::can_handle(Object *p_object) {
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 BitField<PropertyUsageFlags> p_usage, const bool p_wide) {
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.
int layer_index = components[0].trim_prefix("occlusion_layer_").to_int();
ERR_FAIL_COND_V(layer_index < 0, false);
if (components[1] == "polygon") {
if (components[1] == "polygons_count") {
EditorPropertyTilePolygon *ep = memnew(EditorPropertyTilePolygon);
ep->setup_single_mode(p_path, "OccluderPolygon2D");
add_property_editor(p_path, ep);
ep->setup_multiple_mode(vformat("occlusion_layer_%d/polygons", layer_index), vformat("occlusion_layer_%d/polygons_count", layer_index), vformat("occlusion_layer_%d/polygon_%%d/polygon", layer_index), "OccluderPolygon2D");
Vector<String> properties;
properties.push_back(p_path);
int count = p_object->get(vformat("occlusion_layer_%d/polygons_count", layer_index));
for (int i = 0; i < count; i++) {
properties.push_back(vformat("occlusion_layer_%d/polygon_%d/polygon", layer_index, i));
}
add_property_editor_for_multiple_properties("Polygons", properties, ep);
return true;
}
// We keep the original editor for now, but here is the code that could be used if we need a custom editor for each polygon:
/*else if (components.size() == 3 && components[1].begins_with("polygon_") && components[1].trim_prefix("polygon_").is_valid_int()) {
int polygon_index = components[1].trim_prefix("polygon_").to_int();
ERR_FAIL_COND_V(polygon_index < 0, false);
if (components[2] == "polygon") {
return true;
}
}*/
} else if (components.size() >= 2 && components[0].begins_with("physics_layer_") && components[0].trim_prefix("physics_layer_").is_valid_int()) {
// Physics layers.
int layer_index = components[0].trim_prefix("physics_layer_").to_int();

13
engine/editor/plugins/tiles/tile_set_atlas_source_editor.h
View file

@ -80,7 +80,7 @@ public:
int get_id() const;
void edit(Ref<TileSet> p_tile_set, Ref<TileSetAtlasSource> p_tile_set_atlas_source, int p_source_id);
Ref<TileSetAtlasSource> get_edited() { return tile_set_atlas_source; };
Ref<TileSetAtlasSource> get_edited() { return tile_set_atlas_source; }
};
// -- Proxy object for a tile, needed by the inspector --
@ -91,7 +91,7 @@ public:
TileSetAtlasSourceEditor *tiles_set_atlas_source_editor = nullptr;
Ref<TileSetAtlasSource> tile_set_atlas_source;
RBSet<TileSelection> tiles = RBSet<TileSelection>();
RBSet<TileSelection> tiles;
protected:
bool _set(const StringName &p_name, const Variant &p_value);
@ -101,10 +101,10 @@ public:
static void _bind_methods();
public:
Ref<TileSetAtlasSource> get_edited_tile_set_atlas_source() const { return tile_set_atlas_source; };
RBSet<TileSelection> get_edited_tiles() const { return tiles; };
Ref<TileSetAtlasSource> get_edited_tile_set_atlas_source() const { return tile_set_atlas_source; }
RBSet<TileSelection> get_edited_tiles() const { return tiles; }
// Update the proxyed object.
// Update the proxied object.
void edit(Ref<TileSetAtlasSource> p_tile_set_atlas_source, const RBSet<TileSelection> &p_tiles = RBSet<TileSelection>());
AtlasTileProxyObject(TileSetAtlasSourceEditor *p_tiles_set_atlas_source_editor) {
@ -177,7 +177,7 @@ private:
DRAG_TYPE_MAY_POPUP_MENU,
// Warning: keep in this order.
// WARNING: Keep in this order.
DRAG_TYPE_RESIZE_TOP_LEFT,
DRAG_TYPE_RESIZE_TOP,
DRAG_TYPE_RESIZE_TOP_RIGHT,
@ -253,6 +253,7 @@ private:
PopupMenu *alternative_tile_popup_menu = nullptr;
Control *alternative_tiles_control = nullptr;
Control *alternative_tiles_control_unscaled = nullptr;
void _tile_alternatives_create_button_pressed(const Vector2i &p_atlas_coords);
void _tile_alternatives_control_draw();
void _tile_alternatives_control_unscaled_draw();
void _tile_alternatives_control_mouse_exited();

39
engine/editor/plugins/tiles/tile_set_editor.cpp
View file

@ -44,12 +44,11 @@
#include "scene/gui/box_container.h"
#include "scene/gui/control.h"
#include "scene/gui/dialogs.h"
#include "scene/gui/tab_container.h"
TileSetEditor *TileSetEditor::singleton = nullptr;
void TileSetEditor::_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_null());
if (!_can_drop_data_fw(p_point, p_data, p_from)) {
return;
@ -64,7 +63,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 {
ERR_FAIL_COND_V(!tile_set.is_valid(), false);
ERR_FAIL_COND_V(tile_set.is_null(), false);
if (read_only) {
return false;
@ -203,7 +202,7 @@ void TileSetEditor::_update_sources_list(int force_selected_id) {
if (item_text.is_empty()) {
item_text = vformat(TTR("Unknown Type Source (ID: %d)"), source_id);
}
if (!texture.is_valid()) {
if (texture.is_null()) {
texture = missing_texture_texture;
}
@ -241,7 +240,7 @@ void TileSetEditor::_update_sources_list(int force_selected_id) {
}
void TileSetEditor::_source_selected(int p_source_index) {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
// Update the selected source.
sources_delete_button->set_disabled(p_source_index < 0 || read_only);
@ -273,7 +272,7 @@ void TileSetEditor::_source_selected(int p_source_index) {
}
void TileSetEditor::_source_delete_pressed() {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
// Update the selected source.
int to_delete = sources_list->get_item_metadata(sources_list->get_current());
@ -291,7 +290,7 @@ void TileSetEditor::_source_delete_pressed() {
}
void TileSetEditor::_source_add_id_pressed(int p_id_pressed) {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
switch (p_id_pressed) {
case 0: {
@ -329,7 +328,7 @@ void TileSetEditor::_source_add_id_pressed(int p_id_pressed) {
}
void TileSetEditor::_sources_advanced_menu_id_pressed(int p_id_pressed) {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
switch (p_id_pressed) {
case 0: {
@ -366,10 +365,10 @@ void TileSetEditor::_set_source_sort(int p_sort) {
void TileSetEditor::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_THEME_CHANGED: {
sources_delete_button->set_icon(get_editor_theme_icon(SNAME("Remove")));
sources_add_button->set_icon(get_editor_theme_icon(SNAME("Add")));
source_sort_button->set_icon(get_editor_theme_icon(SNAME("Sort")));
sources_advanced_menu_button->set_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
sources_delete_button->set_button_icon(get_editor_theme_icon(SNAME("Remove")));
sources_add_button->set_button_icon(get_editor_theme_icon(SNAME("Add")));
source_sort_button->set_button_icon(get_editor_theme_icon(SNAME("Sort")));
sources_advanced_menu_button->set_button_icon(get_editor_theme_icon(SNAME("GuiTabMenuHl")));
missing_texture_texture = get_editor_theme_icon(SNAME("TileSet"));
expanded_area->add_theme_style_override(SceneStringName(panel), get_theme_stylebox(SceneStringName(panel), "Tree"));
_update_sources_list();
@ -406,7 +405,7 @@ void TileSetEditor::_notification(int p_what) {
}
void TileSetEditor::_patterns_item_list_gui_input(const Ref<InputEvent> &p_event) {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
if (EditorNode::get_singleton()->is_resource_read_only(tile_set)) {
return;
@ -437,7 +436,7 @@ void TileSetEditor::_pattern_preview_done(Ref<TileMapPattern> p_pattern, Ref<Tex
}
void TileSetEditor::_update_patterns_list() {
ERR_FAIL_COND(!tile_set.is_valid());
ERR_FAIL_COND(tile_set.is_null());
// Recreate the items.
patterns_item_list->clear();
@ -818,7 +817,7 @@ TileSetEditor::TileSetEditor() {
tabs_bar = memnew(TabBar);
tabs_bar->set_tab_alignment(TabBar::ALIGNMENT_CENTER);
tabs_bar->set_clip_tabs(false);
tabs_bar->add_tab(TTR("Tiles"));
tabs_bar->add_tab(TTR("Tile Sources"));
tabs_bar->add_tab(TTR("Patterns"));
tabs_bar->connect("tab_changed", callable_mp(this, &TileSetEditor::_tab_changed));
@ -845,7 +844,7 @@ TileSetEditor::TileSetEditor() {
source_sort_button = memnew(MenuButton);
source_sort_button->set_flat(false);
source_sort_button->set_theme_type_variation("FlatButton");
source_sort_button->set_theme_type_variation(SceneStringName(FlatButton));
source_sort_button->set_tooltip_text(TTR("Sort Sources"));
PopupMenu *p = source_sort_button->get_popup();
@ -861,6 +860,7 @@ TileSetEditor::TileSetEditor() {
sources_list->set_fixed_icon_size(Size2(60, 60) * EDSCALE);
sources_list->set_h_size_flags(SIZE_EXPAND_FILL);
sources_list->set_v_size_flags(SIZE_EXPAND_FILL);
sources_list->set_theme_type_variation("ItemListSecondary");
sources_list->connect(SceneStringName(item_selected), callable_mp(this, &TileSetEditor::_source_selected));
sources_list->connect(SceneStringName(item_selected), callable_mp(TilesEditorUtils::get_singleton(), &TilesEditorUtils::set_sources_lists_current));
sources_list->connect(SceneStringName(visibility_changed), callable_mp(TilesEditorUtils::get_singleton(), &TilesEditorUtils::synchronize_sources_list).bind(sources_list, source_sort_button));
@ -875,14 +875,14 @@ TileSetEditor::TileSetEditor() {
split_container_left_side->add_child(sources_bottom_actions);
sources_delete_button = memnew(Button);
sources_delete_button->set_theme_type_variation("FlatButton");
sources_delete_button->set_theme_type_variation(SceneStringName(FlatButton));
sources_delete_button->set_disabled(true);
sources_delete_button->connect(SceneStringName(pressed), callable_mp(this, &TileSetEditor::_source_delete_pressed));
sources_bottom_actions->add_child(sources_delete_button);
sources_add_button = memnew(MenuButton);
sources_add_button->set_flat(false);
sources_add_button->set_theme_type_variation("FlatButton");
sources_add_button->set_theme_type_variation(SceneStringName(FlatButton));
sources_add_button->get_popup()->add_item(TTR("Atlas"));
sources_add_button->get_popup()->set_item_tooltip(-1, TTR("A palette of tiles made from a texture."));
sources_add_button->get_popup()->add_item(TTR("Scenes Collection"));
@ -892,7 +892,7 @@ TileSetEditor::TileSetEditor() {
sources_advanced_menu_button = memnew(MenuButton);
sources_advanced_menu_button->set_flat(false);
sources_advanced_menu_button->set_theme_type_variation("FlatButton");
sources_advanced_menu_button->set_theme_type_variation(SceneStringName(FlatButton));
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()->connect(SceneStringName(id_pressed), callable_mp(this, &TileSetEditor::_sources_advanced_menu_id_pressed));
@ -946,6 +946,7 @@ TileSetEditor::TileSetEditor() {
patterns_item_list->set_max_text_lines(2);
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_theme_type_variation("ItemListSecondary");
patterns_item_list->connect(SceneStringName(gui_input), callable_mp(this, &TileSetEditor::_patterns_item_list_gui_input));
main_vb->add_child(patterns_item_list);
patterns_item_list->hide();

15
engine/editor/plugins/tiles/tile_set_scenes_collection_source_editor.cpp
View file

@ -104,7 +104,7 @@ void TileSetScenesCollectionSourceEditor::TileSetScenesCollectionProxyObject::_b
}
void TileSetScenesCollectionSourceEditor::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_null());
ERR_FAIL_NULL(p_tile_set_scenes_collection_source);
ERR_FAIL_COND(p_source_id < 0);
ERR_FAIL_COND(p_tile_set->get_source(p_source_id) != p_tile_set_scenes_collection_source);
@ -367,8 +367,8 @@ void TileSetScenesCollectionSourceEditor::_notification(int p_what) {
} break;
case NOTIFICATION_THEME_CHANGED: {
scene_tile_add_button->set_icon(get_editor_theme_icon(SNAME("Add")));
scene_tile_delete_button->set_icon(get_editor_theme_icon(SNAME("Remove")));
scene_tile_add_button->set_button_icon(get_editor_theme_icon(SNAME("Add")));
scene_tile_delete_button->set_button_icon(get_editor_theme_icon(SNAME("Remove")));
_update_scenes_list();
} break;
@ -398,7 +398,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) {
ERR_FAIL_COND(!p_tile_set.is_valid());
ERR_FAIL_COND(p_tile_set.is_null());
ERR_FAIL_NULL(p_tile_set_scenes_collection_source);
ERR_FAIL_COND(p_source_id < 0);
ERR_FAIL_COND(p_tile_set->get_source(p_source_id) != p_tile_set_scenes_collection_source);
@ -534,7 +534,6 @@ TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() {
scenes_collection_source_inspector = memnew(EditorInspector);
scenes_collection_source_inspector->set_vertical_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);
scenes_collection_source_inspector->set_use_doc_hints(true);
scenes_collection_source_inspector->add_inspector_plugin(memnew(TileSourceInspectorPlugin));
middle_vbox_container->add_child(scenes_collection_source_inspector);
// Tile inspector.
@ -572,15 +571,17 @@ TileSetScenesCollectionSourceEditor::TileSetScenesCollectionSourceEditor() {
right_vbox_container->add_child(scenes_bottom_actions);
scene_tile_add_button = memnew(Button);
scene_tile_add_button->set_theme_type_variation("FlatButton");
scene_tile_add_button->set_theme_type_variation(SceneStringName(FlatButton));
scene_tile_add_button->connect(SceneStringName(pressed), callable_mp(this, &TileSetScenesCollectionSourceEditor::_source_add_pressed));
scenes_bottom_actions->add_child(scene_tile_add_button);
scene_tile_delete_button = memnew(Button);
scene_tile_delete_button->set_theme_type_variation("FlatButton");
scene_tile_delete_button->set_theme_type_variation(SceneStringName(FlatButton));
scene_tile_delete_button->set_disabled(true);
scene_tile_delete_button->connect(SceneStringName(pressed), callable_mp(this, &TileSetScenesCollectionSourceEditor::_source_delete_pressed));
scenes_bottom_actions->add_child(scene_tile_delete_button);
EditorInspector::add_inspector_plugin(memnew(TileSourceInspectorPlugin));
}
TileSetScenesCollectionSourceEditor::~TileSetScenesCollectionSourceEditor() {

2
engine/editor/plugins/tiles/tile_set_scenes_collection_source_editor.h
View file

@ -85,7 +85,7 @@ private:
static void _bind_methods();
public:
// Update the proxyed object.
// Update the proxied object.
void edit(TileSetScenesCollectionSource *p_tile_set_atlas_source, int p_scene_id);
SceneTileProxyObject(TileSetScenesCollectionSourceEditor *p_tiles_set_scenes_collection_source_editor) {

36
engine/editor/plugins/tiles/tiles_editor_plugin.cpp
View file

@ -45,10 +45,8 @@
#include "editor/themes/editor_scale.h"
#include "scene/2d/tile_map.h"
#include "scene/2d/tile_map_layer.h"
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#include "scene/gui/control.h"
#include "scene/gui/separator.h"
#include "scene/resources/2d/tile_set.h"
#include "scene/resources/image_texture.h"
@ -57,7 +55,7 @@ TileMapEditorPlugin *tile_map_plugin_singleton = nullptr;
TileSetEditorPlugin *tile_set_plugin_singleton = nullptr;
void TilesEditorUtils::_preview_frame_started() {
RS::get_singleton()->request_frame_drawn_callback(callable_mp(const_cast<TilesEditorUtils *>(this), &TilesEditorUtils::_pattern_preview_done));
RS::get_singleton()->request_frame_drawn_callback(callable_mp(this, &TilesEditorUtils::_pattern_preview_done));
}
void TilesEditorUtils::_pattern_preview_done() {
@ -130,7 +128,7 @@ void TilesEditorUtils::_thread() {
// Add the viewport at the last moment to avoid rendering too early.
callable_mp((Node *)EditorNode::get_singleton(), &Node::add_child).call_deferred(viewport, false, Node::INTERNAL_MODE_DISABLED);
RS::get_singleton()->connect(SNAME("frame_pre_draw"), callable_mp(const_cast<TilesEditorUtils *>(this), &TilesEditorUtils::_preview_frame_started), Object::CONNECT_ONE_SHOT);
RS::get_singleton()->connect(SNAME("frame_pre_draw"), callable_mp(this, &TilesEditorUtils::_preview_frame_started), Object::CONNECT_ONE_SHOT);
pattern_preview_done.wait();
@ -147,8 +145,8 @@ void TilesEditorUtils::_thread() {
}
void TilesEditorUtils::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_pattern.is_valid());
ERR_FAIL_COND(p_tile_set.is_null());
ERR_FAIL_COND(p_pattern.is_null());
{
MutexLock lock(pattern_preview_mutex);
pattern_preview_queue.push_back({ p_tile_set, p_pattern, p_callback });
@ -304,18 +302,18 @@ TilesEditorUtils::TilesEditorUtils() {
// Pattern preview generation thread.
pattern_preview_thread.start(_thread_func, this);
ED_SHORTCUT("tiles_editor/cut", TTR("Cut"), KeyModifierMask::CMD_OR_CTRL | Key::X);
ED_SHORTCUT("tiles_editor/copy", TTR("Copy"), KeyModifierMask::CMD_OR_CTRL | Key::C);
ED_SHORTCUT("tiles_editor/paste", TTR("Paste"), KeyModifierMask::CMD_OR_CTRL | Key::V);
ED_SHORTCUT("tiles_editor/cancel", TTR("Cancel"), Key::ESCAPE);
ED_SHORTCUT("tiles_editor/delete", TTR("Delete"), Key::KEY_DELETE);
ED_SHORTCUT("tiles_editor/cut", TTRC("Cut"), KeyModifierMask::CMD_OR_CTRL | Key::X);
ED_SHORTCUT("tiles_editor/copy", TTRC("Copy"), KeyModifierMask::CMD_OR_CTRL | Key::C);
ED_SHORTCUT("tiles_editor/paste", TTRC("Paste"), KeyModifierMask::CMD_OR_CTRL | Key::V);
ED_SHORTCUT("tiles_editor/cancel", TTRC("Cancel"), Key::ESCAPE);
ED_SHORTCUT("tiles_editor/delete", TTRC("Delete"), Key::KEY_DELETE);
ED_SHORTCUT("tiles_editor/paint_tool", TTR("Paint"), Key::D);
ED_SHORTCUT("tiles_editor/line_tool", TTR("Line", "Tool"), Key::L);
ED_SHORTCUT("tiles_editor/rect_tool", TTR("Rect"), Key::R);
ED_SHORTCUT("tiles_editor/bucket_tool", TTR("Bucket"), Key::B);
ED_SHORTCUT("tiles_editor/eraser", TTR("Eraser"), Key::E);
ED_SHORTCUT("tiles_editor/picker", TTR("Picker"), Key::P);
ED_SHORTCUT("tiles_editor/paint_tool", TTRC("Paint Tool"), Key::D);
ED_SHORTCUT("tiles_editor/line_tool", TTRC("Line Tool"), Key::L);
ED_SHORTCUT("tiles_editor/rect_tool", TTRC("Rect Tool"), Key::R);
ED_SHORTCUT("tiles_editor/bucket_tool", TTRC("Bucket Tool"), Key::B);
ED_SHORTCUT("tiles_editor/eraser", TTRC("Eraser Tool"), Key::E);
ED_SHORTCUT("tiles_editor/picker", TTRC("Picker Tool"), Key::P);
}
TilesEditorUtils::~TilesEditorUtils() {
@ -499,7 +497,7 @@ TileMapEditorPlugin::TileMapEditorPlugin() {
editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE);
editor->hide();
button = EditorNode::get_bottom_panel()->add_item(TTR("TileMap"), editor, ED_SHORTCUT_AND_COMMAND("bottom_panels/toggle_tile_map_bottom_panel", TTR("Toggle TileMap Bottom Panel")));
button = EditorNode::get_bottom_panel()->add_item(TTR("TileMap"), editor, ED_SHORTCUT_AND_COMMAND("bottom_panels/toggle_tile_map_bottom_panel", TTRC("Toggle TileMap Bottom Panel")));
button->hide();
}
@ -550,7 +548,7 @@ TileSetEditorPlugin::TileSetEditorPlugin() {
editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE);
editor->hide();
button = EditorNode::get_bottom_panel()->add_item(TTR("TileSet"), editor, ED_SHORTCUT_AND_COMMAND("bottom_panels/toggle_tile_set_bottom_panel", TTR("Toggle TileSet Bottom Panel")));
button = EditorNode::get_bottom_panel()->add_item(TTR("TileSet"), editor, ED_SHORTCUT_AND_COMMAND("bottom_panels/toggle_tile_set_bottom_panel", TTRC("Toggle TileSet Bottom Panel")));
button->hide();
}

2
engine/editor/plugins/tiles/tiles_editor_plugin.h
View file

@ -32,9 +32,7 @@
#define TILES_EDITOR_PLUGIN_H
#include "editor/plugins/editor_plugin.h"
#include "scene/gui/box_container.h"
#include "tile_atlas_view.h"
#include "tile_map_layer_editor.h"
#include "tile_set_editor.h"