summaryrefslogtreecommitdiff
path: root/editor/plugins
diff options
context:
space:
mode:
Diffstat (limited to 'editor/plugins')
-rw-r--r--editor/plugins/tiles/tile_data_editors.cpp117
-rw-r--r--editor/plugins/tiles/tile_data_editors.h11
-rw-r--r--editor/plugins/tiles/tile_set_atlas_source_editor.cpp187
-rw-r--r--editor/plugins/tiles/tile_set_atlas_source_editor.h36
4 files changed, 335 insertions, 16 deletions
diff --git a/editor/plugins/tiles/tile_data_editors.cpp b/editor/plugins/tiles/tile_data_editors.cpp
index e9d80bb4b8..a215939de9 100644
--- a/editor/plugins/tiles/tile_data_editors.cpp
+++ b/editor/plugins/tiles/tile_data_editors.cpp
@@ -125,7 +125,14 @@ void GenericTilePolygonEditor::_base_control_draw() {
Color grid_color = EditorSettings::get_singleton()->get("editors/tiles_editor/grid_color");
const Ref<Texture2D> handle = get_theme_icon(SNAME("EditorPathSharpHandle"), SNAME("EditorIcons"));
const Ref<Texture2D> add_handle = get_theme_icon(SNAME("EditorHandleAdd"), SNAME("EditorIcons"));
+ const Ref<StyleBox> focus_stylebox = get_theme_stylebox(SNAME("Focus"), SNAME("EditorStyles"));
+ // Draw the focus rectangle.
+ if (base_control->has_focus()) {
+ base_control->draw_style_box(focus_stylebox, Rect2(Vector2(), base_control->get_size()));
+ }
+
+ // Draw tile-related things.
Size2 tile_size = tile_set->get_tile_size();
Transform2D xform;
@@ -240,9 +247,10 @@ void GenericTilePolygonEditor::_zoom_changed() {
}
void GenericTilePolygonEditor::_advanced_menu_item_pressed(int p_item_pressed) {
+ UndoRedo *undo_redo = use_undo_redo ? editor_undo_redo : memnew(UndoRedo);
switch (p_item_pressed) {
case RESET_TO_DEFAULT_TILE: {
- undo_redo->create_action(TTR("Edit Polygons"));
+ undo_redo->create_action(TTR("Reset Polygons"));
undo_redo->add_do_method(this, "clear_polygons");
Vector<Vector2> polygon = tile_set->get_tile_shape_polygon();
for (int i = 0; i < polygon.size(); i++) {
@@ -260,7 +268,7 @@ void GenericTilePolygonEditor::_advanced_menu_item_pressed(int p_item_pressed) {
undo_redo->commit_action(true);
} break;
case CLEAR_TILE: {
- undo_redo->create_action(TTR("Edit Polygons"));
+ undo_redo->create_action(TTR("Clear Polygons"));
undo_redo->add_do_method(this, "clear_polygons");
undo_redo->add_do_method(base_control, "update");
undo_redo->add_do_method(this, "emit_signal", "polygons_changed");
@@ -272,9 +280,50 @@ void GenericTilePolygonEditor::_advanced_menu_item_pressed(int p_item_pressed) {
undo_redo->add_undo_method(this, "emit_signal", "polygons_changed");
undo_redo->commit_action(true);
} break;
+ case ROTATE_RIGHT:
+ case ROTATE_LEFT:
+ case FLIP_HORIZONTALLY:
+ case FLIP_VERTICALLY: {
+ undo_redo->create_action(TTR("Rotate Polygons Left"));
+ for (unsigned int i = 0; i < polygons.size(); i++) {
+ Vector<Point2> new_polygon;
+ for (int point_index = 0; point_index < polygons[i].size(); point_index++) {
+ Vector2 point = polygons[i][point_index];
+ switch (p_item_pressed) {
+ case ROTATE_RIGHT: {
+ point = Vector2(-point.y, point.x);
+ } break;
+ case ROTATE_LEFT: {
+ point = Vector2(point.y, -point.x);
+ } break;
+ case FLIP_HORIZONTALLY: {
+ point = Vector2(-point.x, point.y);
+ } break;
+ case FLIP_VERTICALLY: {
+ point = Vector2(point.x, -point.y);
+ } break;
+ default:
+ break;
+ }
+ new_polygon.push_back(point);
+ }
+ undo_redo->add_do_method(this, "set_polygon", i, new_polygon);
+ }
+ undo_redo->add_do_method(base_control, "update");
+ undo_redo->add_do_method(this, "emit_signal", "polygons_changed");
+ for (unsigned int i = 0; i < polygons.size(); i++) {
+ undo_redo->add_undo_method(this, "set_polygon", polygons[i]);
+ }
+ undo_redo->add_undo_method(base_control, "update");
+ undo_redo->add_undo_method(this, "emit_signal", "polygons_changed");
+ undo_redo->commit_action(true);
+ } break;
default:
break;
}
+ if (!use_undo_redo) {
+ memdelete(undo_redo);
+ }
}
void GenericTilePolygonEditor::_grab_polygon_point(Vector2 p_pos, const Transform2D &p_polygon_xform, int &r_polygon_index, int &r_point_index) {
@@ -359,6 +408,7 @@ void GenericTilePolygonEditor::_snap_to_half_pixel(Point2 &r_point) {
}
void GenericTilePolygonEditor::_base_control_gui_input(Ref<InputEvent> p_event) {
+ UndoRedo *undo_redo = use_undo_redo ? editor_undo_redo : memnew(UndoRedo);
real_t grab_threshold = EDITOR_GET("editors/polygon_editor/point_grab_radius");
hovered_polygon_index = -1;
@@ -549,21 +599,47 @@ void GenericTilePolygonEditor::_base_control_gui_input(Ref<InputEvent> p_event)
}
base_control->update();
+
+ if (!use_undo_redo) {
+ memdelete(undo_redo);
+ }
+}
+
+void GenericTilePolygonEditor::set_use_undo_redo(bool p_use_undo_redo) {
+ use_undo_redo = p_use_undo_redo;
}
void GenericTilePolygonEditor::set_tile_set(Ref<TileSet> p_tile_set) {
- if (tile_set != p_tile_set) {
- // Set the default tile shape
- clear_polygons();
- if (p_tile_set.is_valid()) {
- Vector<Vector2> polygon = p_tile_set->get_tile_shape_polygon();
- for (int i = 0; i < polygon.size(); i++) {
- polygon.write[i] = polygon[i] * p_tile_set->get_tile_size();
- }
- add_polygon(polygon);
+ ERR_FAIL_COND(!p_tile_set.is_valid());
+ if (tile_set == p_tile_set) {
+ return;
+ }
+
+ // Set the default tile shape
+ clear_polygons();
+ if (p_tile_set.is_valid()) {
+ Vector<Vector2> polygon = p_tile_set->get_tile_shape_polygon();
+ for (int i = 0; i < polygon.size(); i++) {
+ polygon.write[i] = polygon[i] * p_tile_set->get_tile_size();
}
+ add_polygon(polygon);
}
+
tile_set = p_tile_set;
+
+ // Set the default zoom value.
+ int default_control_y_size = 200 * EDSCALE;
+ Vector2 zoomed_tile = editor_zoom_widget->get_zoom() * tile_set->get_tile_size();
+ while (zoomed_tile.y < default_control_y_size) {
+ editor_zoom_widget->set_zoom_by_increments(6, false);
+ zoomed_tile = editor_zoom_widget->get_zoom() * tile_set->get_tile_size();
+ }
+ while (zoomed_tile.y > default_control_y_size) {
+ editor_zoom_widget->set_zoom_by_increments(-6, false);
+ zoomed_tile = editor_zoom_widget->get_zoom() * tile_set->get_tile_size();
+ }
+ editor_zoom_widget->set_zoom_by_increments(-6, false);
+ _zoom_changed();
}
void GenericTilePolygonEditor::set_background(Ref<Texture2D> p_texture, Rect2 p_region, Vector2 p_offset, bool p_flip_h, bool p_flip_v, bool p_transpose, Color p_modulate) {
@@ -644,6 +720,12 @@ void GenericTilePolygonEditor::_notification(int p_what) {
button_center_view->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon(SNAME("CenterView"), SNAME("EditorIcons")));
button_pixel_snap->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon(SNAME("Snap"), SNAME("EditorIcons")));
button_advanced_menu->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon(SNAME("GuiTabMenuHl"), SNAME("EditorIcons")));
+
+ PopupMenu *p = button_advanced_menu->get_popup();
+ p->set_item_icon(p->get_item_index(ROTATE_RIGHT), get_theme_icon(SNAME("RotateRight"), SNAME("EditorIcons")));
+ p->set_item_icon(p->get_item_index(ROTATE_LEFT), get_theme_icon(SNAME("RotateLeft"), SNAME("EditorIcons")));
+ p->set_item_icon(p->get_item_index(FLIP_HORIZONTALLY), get_theme_icon(SNAME("MirrorX"), SNAME("EditorIcons")));
+ p->set_item_icon(p->get_item_index(FLIP_VERTICALLY), get_theme_icon(SNAME("MirrorY"), SNAME("EditorIcons")));
break;
}
}
@@ -670,18 +752,21 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
button_create->set_toggle_mode(true);
button_create->set_button_group(tools_button_group);
button_create->set_pressed(true);
+ button_create->set_tooltip(TTR("Add polygon tool"));
toolbar->add_child(button_create);
button_edit = memnew(Button);
button_edit->set_flat(true);
button_edit->set_toggle_mode(true);
button_edit->set_button_group(tools_button_group);
+ button_edit->set_tooltip(TTR("Edit points tool"));
toolbar->add_child(button_edit);
button_delete = memnew(Button);
button_delete->set_flat(true);
button_delete->set_toggle_mode(true);
button_delete->set_button_group(tools_button_group);
+ button_delete->set_tooltip(TTR("Delete points tool"));
toolbar->add_child(button_delete);
button_advanced_menu = memnew(MenuButton);
@@ -689,7 +774,13 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
button_advanced_menu->set_toggle_mode(true);
button_advanced_menu->get_popup()->add_item(TTR("Reset to default tile shape"), RESET_TO_DEFAULT_TILE);
button_advanced_menu->get_popup()->add_item(TTR("Clear"), CLEAR_TILE);
+ button_advanced_menu->get_popup()->add_separator();
+ button_advanced_menu->get_popup()->add_icon_item(get_theme_icon(SNAME("RotateRight"), SNAME("EditorIcons")), TTR("Rotate Right"), ROTATE_RIGHT);
+ button_advanced_menu->get_popup()->add_icon_item(get_theme_icon(SNAME("RotateLeft"), SNAME("EditorIcons")), TTR("Rotate Left"), ROTATE_LEFT);
+ button_advanced_menu->get_popup()->add_icon_item(get_theme_icon(SNAME("MirrorX"), SNAME("EditorIcons")), TTR("Flip Horizontally"), FLIP_HORIZONTALLY);
+ button_advanced_menu->get_popup()->add_icon_item(get_theme_icon(SNAME("MirrorY"), SNAME("EditorIcons")), TTR("Flip Vertically"), FLIP_VERTICALLY);
button_advanced_menu->get_popup()->connect("id_pressed", callable_mp(this, &GenericTilePolygonEditor::_advanced_menu_item_pressed));
+ button_advanced_menu->set_focus_mode(FOCUS_ALL);
toolbar->add_child(button_advanced_menu);
toolbar->add_child(memnew(VSeparator));
@@ -698,6 +789,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
button_pixel_snap->set_flat(true);
button_pixel_snap->set_toggle_mode(true);
button_pixel_snap->set_pressed(true);
+ button_pixel_snap->set_tooltip(TTR("Snap to half-pixel"));
toolbar->add_child(button_pixel_snap);
Control *root = memnew(Control);
@@ -717,6 +809,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
base_control->connect("draw", callable_mp(this, &GenericTilePolygonEditor::_base_control_draw));
base_control->connect("gui_input", callable_mp(this, &GenericTilePolygonEditor::_base_control_gui_input));
base_control->set_clip_contents(true);
+ base_control->set_focus_mode(Control::FOCUS_CLICK);
root->add_child(base_control);
editor_zoom_widget = memnew(EditorZoomWidget);
@@ -1432,7 +1525,7 @@ TileDataCollisionEditor::TileDataCollisionEditor() {
angular_velocity_editor->connect("property_changed", callable_mp(this, &TileDataCollisionEditor::_property_value_changed).unbind(1));
angular_velocity_editor->update_property();
add_child(angular_velocity_editor);
- property_editors["angular_velocity"] = linear_velocity_editor;
+ property_editors["angular_velocity"] = angular_velocity_editor;
_polygons_changed();
}
diff --git a/editor/plugins/tiles/tile_data_editors.h b/editor/plugins/tiles/tile_data_editors.h
index acb4c5882d..3fc5e738bb 100644
--- a/editor/plugins/tiles/tile_data_editors.h
+++ b/editor/plugins/tiles/tile_data_editors.h
@@ -94,7 +94,8 @@ private:
LocalVector<Vector<Point2>> polygons;
bool multiple_polygon_mode = false;
- UndoRedo *undo_redo = EditorNode::get_undo_redo();
+ bool use_undo_redo = true;
+ UndoRedo *editor_undo_redo = EditorNode::get_undo_redo();
// UI
int hovered_polygon_index = -1;
@@ -108,7 +109,7 @@ private:
DRAG_TYPE_CREATE_POINT,
DRAG_TYPE_PAN,
};
- DragType drag_type;
+ DragType drag_type = DRAG_TYPE_NONE;
int drag_polygon_index;
int drag_point_index;
Vector2 drag_last_pos;
@@ -143,6 +144,10 @@ private:
enum AdvancedMenuOption {
RESET_TO_DEFAULT_TILE,
CLEAR_TILE,
+ ROTATE_RIGHT,
+ ROTATE_LEFT,
+ FLIP_HORIZONTALLY,
+ FLIP_VERTICALLY,
};
void _base_control_draw();
@@ -161,6 +166,8 @@ protected:
static void _bind_methods();
public:
+ void set_use_undo_redo(bool p_use_undo_redo);
+
void set_tile_set(Ref<TileSet> p_tile_set);
void set_background(Ref<Texture2D> p_texture, Rect2 p_region = Rect2(), Vector2 p_offset = Vector2(), bool p_flip_h = false, bool p_flip_v = false, bool p_transpose = false, Color p_modulate = Color(1.0, 1.0, 1.0, 0.0));
diff --git a/editor/plugins/tiles/tile_set_atlas_source_editor.cpp b/editor/plugins/tiles/tile_set_atlas_source_editor.cpp
index ae744f697b..e54a57b130 100644
--- a/editor/plugins/tiles/tile_set_atlas_source_editor.cpp
+++ b/editor/plugins/tiles/tile_set_atlas_source_editor.cpp
@@ -2061,7 +2061,7 @@ void TileSetAtlasSourceEditor::_undo_redo_inspector_callback(Object *p_undo_redo
int new_polygons_count = p_new_value;
int old_polygons_count = tile_data_proxy->get(vformat("physics_layer_%d/polygons_count", layer_index));
if (new_polygons_count < old_polygons_count) {
- for (int i = new_polygons_count - 1; i < old_polygons_count; i++) {
+ for (int i = new_polygons_count; i < old_polygons_count; i++) {
ADD_UNDO(tile_data_proxy, vformat("physics_layer_%d/polygon_%d/points", layer_index, i));
ADD_UNDO(tile_data_proxy, vformat("physics_layer_%d/polygon_%d/one_way", layer_index, i));
ADD_UNDO(tile_data_proxy, vformat("physics_layer_%d/polygon_%d/one_way_margin", layer_index, i));
@@ -2534,9 +2534,194 @@ TileSetAtlasSourceEditor::TileSetAtlasSourceEditor() {
right_panel->add_child(tile_atlas_view_missing_source_label);
EditorNode::get_singleton()->get_editor_data().add_undo_redo_inspector_hook_callback(callable_mp(this, &TileSetAtlasSourceEditor::_undo_redo_inspector_callback));
+
+ // Inspector plugin.
+ Ref<EditorInspectorPluginTileData> tile_data_inspector_plugin;
+ tile_data_inspector_plugin.instantiate();
+ EditorInspector::add_inspector_plugin(tile_data_inspector_plugin);
}
TileSetAtlasSourceEditor::~TileSetAtlasSourceEditor() {
memdelete(tile_proxy_object);
memdelete(atlas_source_proxy_object);
}
+
+////// EditorPropertyTilePolygon //////
+
+void EditorPropertyTilePolygon::_add_focusable_children(Node *p_node) {
+ Control *control = Object::cast_to<Control>(p_node);
+ if (control && control->get_focus_mode() != Control::FOCUS_NONE) {
+ add_focusable(control);
+ }
+ for (int i = 0; i < p_node->get_child_count(); i++) {
+ _add_focusable_children(p_node->get_child(i));
+ }
+}
+
+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") {
+ Ref<NavigationPolygon> navigation_polygon;
+ if (generic_tile_polygon_editor->get_polygon_count() >= 1) {
+ navigation_polygon.instantiate();
+ for (int i = 0; i < generic_tile_polygon_editor->get_polygon_count(); i++) {
+ Vector<Vector2> polygon = generic_tile_polygon_editor->get_polygon(i);
+ navigation_polygon->add_outline(polygon);
+ }
+ navigation_polygon->make_polygons_from_outlines();
+ }
+ 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));
+ values.push_back(generic_tile_polygon_editor->get_polygon(i));
+ }
+ emit_signal("multiple_properties_changed", changed_properties, values, false);
+ }
+ }
+}
+
+void EditorPropertyTilePolygon::update_property() {
+ TileSetAtlasSourceEditor::AtlasTileProxyObject *atlas_tile_proxy_object = Object::cast_to<TileSetAtlasSourceEditor::AtlasTileProxyObject>(get_edited_object());
+ ERR_FAIL_COND(!atlas_tile_proxy_object);
+ ERR_FAIL_COND(atlas_tile_proxy_object->get_edited_tiles().is_empty());
+
+ TileSetAtlasSource *tile_set_atlas_source = atlas_tile_proxy_object->get_edited_tile_set_atlas_source();
+ generic_tile_polygon_editor->set_tile_set(Ref<TileSet>(tile_set_atlas_source->get_tile_set()));
+
+ // Set the background
+ Vector2i coords = atlas_tile_proxy_object->get_edited_tiles().front()->get().tile;
+ int alternative = atlas_tile_proxy_object->get_edited_tiles().front()->get().alternative;
+ TileData *tile_data = Object::cast_to<TileData>(tile_set_atlas_source->get_tile_data(coords, alternative));
+ generic_tile_polygon_editor->set_background(tile_set_atlas_source->get_texture(), tile_set_atlas_source->get_tile_texture_region(coords), tile_set_atlas_source->get_tile_effective_texture_offset(coords, alternative), tile_data->get_flip_h(), tile_data->get_flip_v(), tile_data->get_transpose(), tile_data->get_modulate());
+
+ // Reset the polygons.
+ generic_tile_polygon_editor->clear_polygons();
+
+ if (String(count_property).is_empty()) {
+ if (base_type == "OccluderPolygon2D") {
+ // Single OccluderPolygon2D.
+ Ref<OccluderPolygon2D> occluder = get_edited_object()->get(get_edited_property());
+ 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.
+ Ref<NavigationPolygon> navigation_polygon = get_edited_object()->get(get_edited_property());
+ generic_tile_polygon_editor->clear_polygons();
+ if (navigation_polygon.is_valid()) {
+ for (int i = 0; i < navigation_polygon->get_outline_count(); i++) {
+ generic_tile_polygon_editor->add_polygon(navigation_polygon->get_outline(i));
+ }
+ }
+ }
+ } else {
+ int count = get_edited_object()->get(count_property);
+ if (base_type.is_empty()) {
+ // Multiple array of vertices.
+ generic_tile_polygon_editor->clear_polygons();
+ for (int i = 0; i < count; i++) {
+ generic_tile_polygon_editor->add_polygon(get_edited_object()->get(vformat(element_pattern, i)));
+ }
+ }
+ }
+}
+
+void EditorPropertyTilePolygon::setup_single_mode(const StringName &p_property, const String &p_base_type) {
+ set_object_and_property(nullptr, p_property);
+ base_type = p_base_type;
+
+ generic_tile_polygon_editor->set_multiple_polygon_mode(false);
+}
+
+void EditorPropertyTilePolygon::setup_multiple_mode(const StringName &p_property, const StringName &p_count_property, const String &p_element_pattern, const String &p_base_type) {
+ set_object_and_property(nullptr, p_property);
+ count_property = p_count_property;
+ element_pattern = p_element_pattern;
+ base_type = p_base_type;
+
+ generic_tile_polygon_editor->set_multiple_polygon_mode(true);
+}
+
+EditorPropertyTilePolygon::EditorPropertyTilePolygon() {
+ // Setup the polygon editor.
+ generic_tile_polygon_editor = memnew(GenericTilePolygonEditor);
+ generic_tile_polygon_editor->set_use_undo_redo(false);
+ generic_tile_polygon_editor->clear_polygons();
+ add_child(generic_tile_polygon_editor);
+ generic_tile_polygon_editor->connect("polygons_changed", callable_mp(this, &EditorPropertyTilePolygon::_polygons_changed));
+
+ // Add all focussable children of generic_tile_polygon_editor as focussable.
+ _add_focusable_children(generic_tile_polygon_editor);
+}
+
+////// EditorInspectorPluginTileData //////
+
+bool EditorInspectorPluginTileData::can_handle(Object *p_object) {
+ return Object::cast_to<TileSetAtlasSourceEditor::AtlasTileProxyObject>(p_object) != nullptr;
+}
+
+bool EditorInspectorPluginTileData::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const uint32_t p_usage, const bool p_wide) {
+ 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()) {
+ // 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") {
+ EditorPropertyTilePolygon *ep = memnew(EditorPropertyTilePolygon);
+ ep->setup_single_mode(p_path, "OccluderPolygon2D");
+ add_property_editor(p_path, ep);
+ 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();
+ ERR_FAIL_COND_V(layer_index < 0, false);
+ if (components[1] == "polygons_count") {
+ EditorPropertyTilePolygon *ep = memnew(EditorPropertyTilePolygon);
+ ep->setup_multiple_mode(vformat("physics_layer_%d/polygons", layer_index), vformat("physics_layer_%d/polygons_count", layer_index), vformat("physics_layer_%d/polygon_%%d/points", layer_index), "");
+ Vector<String> properties;
+ properties.push_back(p_path);
+ int count = p_object->get(vformat("physics_layer_%d/polygons_count", layer_index));
+ for (int i = 0; i < count; i++) {
+ properties.push_back(vformat(vformat("physics_layer_%d/polygon_%d/points", layer_index, i)));
+ }
+ add_property_editor_for_multiple_properties("Polygons", properties, ep);
+ return true;
+ } 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] == "points") {
+ return true;
+ }
+ }
+ } else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_int()) {
+ // Navigation layers.
+ int layer_index = components[0].trim_prefix("navigation_layer_").to_int();
+ ERR_FAIL_COND_V(layer_index < 0, false);
+ if (components[1] == "polygon") {
+ EditorPropertyTilePolygon *ep = memnew(EditorPropertyTilePolygon);
+ ep->setup_single_mode(p_path, "NavigationPolygon");
+ add_property_editor(p_path, ep);
+ return true;
+ }
+ }
+ return false;
+}
diff --git a/editor/plugins/tiles/tile_set_atlas_source_editor.h b/editor/plugins/tiles/tile_set_atlas_source_editor.h
index ea6f2847ae..bd1fd2e7d0 100644
--- a/editor/plugins/tiles/tile_set_atlas_source_editor.h
+++ b/editor/plugins/tiles/tile_set_atlas_source_editor.h
@@ -43,7 +43,7 @@ class TileSet;
class TileSetAtlasSourceEditor : public HBoxContainer {
GDCLASS(TileSetAtlasSourceEditor, HBoxContainer);
-private:
+public:
// A class to store which tiles are selected.
struct TileSelection {
Vector2i tile = TileSetSource::INVALID_ATLAS_COORDS;
@@ -99,6 +99,9 @@ private:
static void _bind_methods();
public:
+ TileSetAtlasSource *get_edited_tile_set_atlas_source() const { return tile_set_atlas_source; };
+ Set<TileSelection> get_edited_tiles() const { return tiles; };
+
// Update the proxyed object.
void edit(TileSetAtlasSource *p_tile_set_atlas_source, Set<TileSelection> p_tiles = Set<TileSelection>());
@@ -107,6 +110,7 @@ private:
}
};
+private:
Ref<TileSet> tile_set;
TileSetAtlasSource *tile_set_atlas_source = nullptr;
int tile_set_atlas_source_id = TileSet::INVALID_SOURCE;
@@ -281,4 +285,34 @@ public:
~TileSetAtlasSourceEditor();
};
+class EditorPropertyTilePolygon : public EditorProperty {
+ GDCLASS(EditorPropertyTilePolygon, EditorProperty);
+
+ StringName count_property;
+ String element_pattern;
+ String base_type;
+
+ void _add_focusable_children(Node *p_node);
+
+ GenericTilePolygonEditor *generic_tile_polygon_editor;
+ void _polygons_changed();
+
+public:
+ virtual void update_property() override;
+ void setup_single_mode(const StringName &p_property, const String &p_base_type);
+ void setup_multiple_mode(const StringName &p_property, const StringName &p_count_property, const String &p_element_pattern, const String &p_base_type);
+ EditorPropertyTilePolygon();
+};
+
+class EditorInspectorPluginTileData : public EditorInspectorPlugin {
+ GDCLASS(EditorInspectorPluginTileData, EditorInspectorPlugin);
+
+ void _occlusion_polygon_set_callback();
+ void _polygons_changed(Object *p_generic_tile_polygon_editor, Object *p_object, const String &p_path);
+
+public:
+ virtual bool can_handle(Object *p_object) override;
+ virtual bool parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const uint32_t p_usage, const bool p_wide = false) override;
+};
+
#endif // TILE_SET_ATLAS_SOURCE_EDITOR_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-16 06:22:01 +0000