aboutsummaryrefslogtreecommitdiff
path: root/editor/plugins/tile_set_editor_plugin.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'editor/plugins/tile_set_editor_plugin.cpp')
-rw-r--r--editor/plugins/tile_set_editor_plugin.cpp1041
1 files changed, 645 insertions, 396 deletions
diff --git a/editor/plugins/tile_set_editor_plugin.cpp b/editor/plugins/tile_set_editor_plugin.cpp
index 1dedf9245..385fa24ad 100644
--- a/editor/plugins/tile_set_editor_plugin.cpp
+++ b/editor/plugins/tile_set_editor_plugin.cpp
@@ -37,6 +37,9 @@
void TileSetEditor::edit(const Ref<TileSet> &p_tileset) {
tileset = p_tileset;
+ tileset->add_change_receptor(this);
+
+ update_tile_list();
}
void TileSetEditor::_import_node(Node *p_node, Ref<TileSet> p_library) {
@@ -146,6 +149,7 @@ void TileSetEditor::_import_node(Node *p_node, Ref<TileSet> p_library) {
p_library->tile_set_light_occluder(id, occluder);
p_library->tile_set_occluder_offset(id, -phys_offset);
p_library->tile_set_navigation_polygon_offset(id, -phys_offset);
+ p_library->tile_set_z_index(id, mi->get_z_index());
}
}
@@ -188,6 +192,7 @@ void TileSetEditor::_name_dialog_confirm(const String &name) {
if (tileset->has_tile(id)) {
tileset->remove_tile(id);
+ update_tile_list();
} else {
err_dialog->set_text(TTR("Could not find tile:") + " " + name);
err_dialog->popup_centered(Size2(300, 60));
@@ -202,8 +207,9 @@ void TileSetEditor::_menu_cbk(int p_option) {
switch (p_option) {
case MENU_OPTION_ADD_ITEM: {
-
tileset->create_tile(tileset->get_last_unused_tile_id());
+ tileset->tile_set_name(tileset->get_last_unused_tile_id() - 1, itos(tileset->get_last_unused_tile_id() - 1));
+ update_tile_list();
} break;
case MENU_OPTION_REMOVE_ITEM: {
@@ -235,106 +241,77 @@ void TileSetEditor::_bind_methods() {
ClassDB::bind_method("_menu_cbk", &TileSetEditor::_menu_cbk);
ClassDB::bind_method("_menu_confirm", &TileSetEditor::_menu_confirm);
ClassDB::bind_method("_name_dialog_confirm", &TileSetEditor::_name_dialog_confirm);
+ ClassDB::bind_method("_on_tile_list_selected", &TileSetEditor::_on_tile_list_selected);
+ ClassDB::bind_method("_on_edit_mode_changed", &TileSetEditor::_on_edit_mode_changed);
+ ClassDB::bind_method("_on_workspace_overlay_draw", &TileSetEditor::_on_workspace_overlay_draw);
+ ClassDB::bind_method("_on_workspace_draw", &TileSetEditor::_on_workspace_draw);
+ ClassDB::bind_method("_on_workspace_input", &TileSetEditor::_on_workspace_input);
+ ClassDB::bind_method("_on_tool_clicked", &TileSetEditor::_on_tool_clicked);
+ ClassDB::bind_method("_on_priority_changed", &TileSetEditor::_on_priority_changed);
+ ClassDB::bind_method("_on_grid_snap_toggled", &TileSetEditor::_on_grid_snap_toggled);
+ ClassDB::bind_method("_set_snap_step_x", &TileSetEditor::_set_snap_step_x);
+ ClassDB::bind_method("_set_snap_step_y", &TileSetEditor::_set_snap_step_y);
+ ClassDB::bind_method("_set_snap_off_x", &TileSetEditor::_set_snap_off_x);
+ ClassDB::bind_method("_set_snap_off_y", &TileSetEditor::_set_snap_off_y);
+ ClassDB::bind_method("_set_snap_sep_x", &TileSetEditor::_set_snap_sep_x);
+ ClassDB::bind_method("_set_snap_sep_y", &TileSetEditor::_set_snap_sep_y);
}
-TileSetEditor::TileSetEditor(EditorNode *p_editor) {
-
- menu = memnew(MenuButton);
- CanvasItemEditor::get_singleton()->add_control_to_menu_panel(menu);
- menu->hide();
- menu->set_text(TTR("Tile Set"));
- menu->get_popup()->add_item(TTR("Add Item"), MENU_OPTION_ADD_ITEM);
- menu->get_popup()->add_item(TTR("Remove Item"), MENU_OPTION_REMOVE_ITEM);
- menu->get_popup()->add_separator();
- menu->get_popup()->add_item(TTR("Create from Scene"), MENU_OPTION_CREATE_FROM_SCENE);
- menu->get_popup()->add_item(TTR("Merge from Scene"), MENU_OPTION_MERGE_FROM_SCENE);
- menu->get_popup()->connect("id_pressed", this, "_menu_cbk");
- editor = p_editor;
- cd = memnew(ConfirmationDialog);
- add_child(cd);
- cd->get_ok()->connect("pressed", this, "_menu_confirm");
-
- nd = memnew(EditorNameDialog);
- add_child(nd);
- nd->set_hide_on_ok(true);
- nd->get_line_edit()->set_margin(MARGIN_TOP, 28);
- nd->connect("name_confirmed", this, "_name_dialog_confirm");
-
- err_dialog = memnew(AcceptDialog);
- add_child(err_dialog);
- err_dialog->set_title(TTR("Error"));
-}
-
-void TileSetEditorPlugin::edit(Object *p_node) {
-
- if (Object::cast_to<TileSet>(p_node)) {
- tileset_editor->edit(Object::cast_to<TileSet>(p_node));
- tileset_editor->show();
- autotile_editor->edit(p_node);
- } else
- tileset_editor->hide();
-}
-
-bool TileSetEditorPlugin::handles(Object *p_node) const {
-
- return p_node->is_class("TileSet");
-}
-
-void TileSetEditorPlugin::make_visible(bool p_visible) {
-
- if (p_visible) {
- tileset_editor->show();
- tileset_editor->menu->show();
- autotile_button->show();
- autotile_editor->side_panel->show();
- if (autotile_button->is_pressed()) {
- autotile_editor->show();
- }
- } else {
- tileset_editor->hide();
- tileset_editor->menu->hide();
- autotile_editor->side_panel->hide();
- autotile_editor->hide();
- autotile_button->hide();
+void TileSetEditor::_notification(int p_what) {
+ if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
+ tools[TOOL_SELECT]->set_icon(get_icon("ToolSelect", "EditorIcons"));
+ tools[BITMASK_COPY]->set_icon(get_icon("Duplicate", "EditorIcons"));
+ tools[BITMASK_PASTE]->set_icon(get_icon("Override", "EditorIcons"));
+ tools[BITMASK_CLEAR]->set_icon(get_icon("Clear", "EditorIcons"));
+ tools[SHAPE_NEW_POLYGON]->set_icon(get_icon("CollisionPolygon2D", "EditorIcons"));
+ tools[SHAPE_DELETE]->set_icon(get_icon("Remove", "EditorIcons"));
+ tools[SHAPE_KEEP_INSIDE_TILE]->set_icon(get_icon("Snap", "EditorIcons"));
+ tools[SHAPE_GRID_SNAP]->set_icon(get_icon("SnapGrid", "EditorIcons"));
+ tools[ZOOM_OUT]->set_icon(get_icon("ZoomLess", "EditorIcons"));
+ tools[ZOOM_1]->set_icon(get_icon("ZoomReset", "EditorIcons"));
+ tools[ZOOM_IN]->set_icon(get_icon("ZoomMore", "EditorIcons"));
}
}
-TileSetEditorPlugin::TileSetEditorPlugin(EditorNode *p_node) {
-
- tileset_editor = memnew(TileSetEditor(p_node));
-
- add_control_to_container(CONTAINER_CANVAS_EDITOR_MENU, tileset_editor);
- tileset_editor->set_anchors_and_margins_preset(Control::PRESET_TOP_WIDE);
- tileset_editor->set_end(Point2(0, 22));
- tileset_editor->hide();
-
- autotile_editor = memnew(AutotileEditor(p_node));
- add_control_to_container(CONTAINER_CANVAS_EDITOR_SIDE, autotile_editor->side_panel);
- autotile_editor->side_panel->set_anchors_and_margins_preset(Control::PRESET_WIDE);
- autotile_editor->side_panel->set_custom_minimum_size(Size2(200, 0));
- autotile_editor->side_panel->hide();
- autotile_button = p_node->add_bottom_panel_item(TTR("Autotiles"), autotile_editor);
- autotile_button->hide();
+void TileSetEditor::_changed_callback(Object *p_changed, const char *p_prop) {
+ if (p_prop == StringName("region")) {
+ update_tile_list_icon();
+ preview->set_region_rect(tileset->tile_get_region(get_current_tile()));
+ } else if (p_prop == StringName("name")) {
+ update_tile_list_icon();
+ } else if (p_prop == StringName("texture") || p_prop == StringName("modulate") || p_prop == StringName("tile_mode")) {
+ _on_tile_list_selected(get_current_tile());
+ workspace->update();
+ preview->set_texture(tileset->tile_get_texture(get_current_tile()));
+ preview->set_modulate(tileset->tile_get_modulate(get_current_tile()));
+ preview->set_region_rect(tileset->tile_get_region(get_current_tile()));
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE)
+ property_editor->show();
+ else
+ property_editor->hide();
+ texture_region_editor->_edit_region();
+ update_tile_list_icon();
+ } else if (p_prop == StringName("autotile")) {
+ workspace->update();
+ }
}
-AutotileEditor::AutotileEditor(EditorNode *p_editor) {
-
- editor = p_editor;
+void TileSetEditor::initialize_bottom_editor() {
//Side Panel
side_panel = memnew(Control);
- side_panel->set_name("Autotiles");
+ side_panel->set_name("Tile Set");
VSplitContainer *split = memnew(VSplitContainer);
side_panel->add_child(split);
split->set_anchors_and_margins_preset(Control::PRESET_WIDE);
- autotile_list = memnew(ItemList);
- autotile_list->set_v_size_flags(SIZE_EXPAND_FILL);
- autotile_list->set_h_size_flags(SIZE_EXPAND_FILL);
- autotile_list->set_custom_minimum_size(Size2(10, 200));
- autotile_list->connect("item_selected", this, "_on_autotile_selected");
- split->add_child(autotile_list);
+ tile_list = memnew(ItemList);
+ tile_list->set_v_size_flags(SIZE_EXPAND_FILL);
+ tile_list->set_h_size_flags(SIZE_EXPAND_FILL);
+ tile_list->set_custom_minimum_size(Size2(10, 200));
+ tile_list->connect("item_selected", this, "_on_tile_list_selected");
+ split->add_child(tile_list);
property_editor = memnew(PropertyEditor);
property_editor->set_v_size_flags(SIZE_EXPAND_FILL);
@@ -342,25 +319,29 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
property_editor->set_custom_minimum_size(Size2(10, 70));
split->add_child(property_editor);
- helper = memnew(AutotileEditorHelper(this));
+ helper = memnew(TileSetEditorHelper(this));
property_editor->call_deferred("edit", helper);
+ helper->add_change_receptor(this);
//Editor
+ //Bottom Panel
+ bottom_panel = memnew(Control);
+ bottom_panel->set_name("Tile Set Bottom Editor");
dragging_point = -1;
creating_shape = false;
snap_step = Vector2(32, 32);
- set_custom_minimum_size(Size2(0, 150));
+ bottom_panel->set_custom_minimum_size(Size2(0, 150));
VBoxContainer *main_vb = memnew(VBoxContainer);
- add_child(main_vb);
+ bottom_panel->add_child(main_vb);
main_vb->set_anchors_and_margins_preset(Control::PRESET_WIDE);
HBoxContainer *tool_hb = memnew(HBoxContainer);
Ref<ButtonGroup> g(memnew(ButtonGroup));
- String label[EDITMODE_MAX] = { "Icon", "Bitmask", "Collision", "Occlusion", "Navigation", "Priority" };
+ String label[EDITMODE_MAX] = { "Collision", "Occlusion", "Navigation", "Bitmask", "Priority", "Icon" };
for (int i = 0; i < (int)EDITMODE_MAX; i++) {
tool_editmode[i] = memnew(Button);
@@ -372,7 +353,8 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
tool_editmode[i]->connect("pressed", this, "_on_edit_mode_changed", args);
tool_hb->add_child(tool_editmode[i]);
}
- tool_editmode[EDITMODE_ICON]->set_pressed(true);
+ tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
+ edit_mode = EDITMODE_COLLISION;
main_vb->add_child(tool_hb);
main_vb->add_child(memnew(HSeparator));
@@ -386,15 +368,17 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
Ref<ButtonGroup> tg(memnew(ButtonGroup));
+ Vector<Variant> p;
tools[TOOL_SELECT] = memnew(ToolButton);
tool_containers[TOOLBAR_DUMMY]->add_child(tools[TOOL_SELECT]);
tools[TOOL_SELECT]->set_tooltip(TTR("Select sub-tile to use as icon, this will be also used on invalid autotile bindings."));
tools[TOOL_SELECT]->set_toggle_mode(true);
tools[TOOL_SELECT]->set_button_group(tg);
tools[TOOL_SELECT]->set_pressed(true);
+ p.push_back((int)TOOL_SELECT);
+ tools[TOOL_SELECT]->connect("pressed", this, "_on_tool_clicked", p);
tool_containers[TOOLBAR_DUMMY]->show();
- Vector<Variant> p;
tools[BITMASK_COPY] = memnew(ToolButton);
p.push_back((int)BITMASK_COPY);
tools[BITMASK_COPY]->connect("pressed", this, "_on_tool_clicked", p);
@@ -420,7 +404,7 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
p.push_back((int)SHAPE_DELETE);
tools[SHAPE_DELETE]->connect("pressed", this, "_on_tool_clicked", p);
tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_DELETE]);
- tool_containers[TOOLBAR_SHAPE]->add_change_receptor(memnew(VSeparator));
+ tool_containers[TOOLBAR_SHAPE]->add_child(memnew(VSeparator));
tools[SHAPE_KEEP_INSIDE_TILE] = memnew(ToolButton);
tools[SHAPE_KEEP_INSIDE_TILE]->set_toggle_mode(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_pressed(true);
@@ -507,6 +491,8 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
spin_priority->hide();
toolbar->add_child(spin_priority);
+ tool_containers[TOOLBAR_SHAPE]->show();
+
Control *separator = memnew(Control);
separator->set_h_size_flags(SIZE_EXPAND_FILL);
toolbar->add_child(separator);
@@ -536,10 +522,15 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
workspace_container = memnew(Control);
scroll->add_child(workspace_container);
+ workspace_overlay = memnew(Control);
+ workspace_overlay->connect("draw", this, "_on_workspace_overlay_draw");
+ workspace_container->add_child(workspace_overlay);
+
workspace = memnew(Control);
workspace->connect("draw", this, "_on_workspace_draw");
workspace->connect("gui_input", this, "_on_workspace_input");
- workspace_container->add_child(workspace);
+ workspace->set_draw_behind_parent(true);
+ workspace_overlay->add_child(workspace);
preview = memnew(Sprite);
workspace->add_child(preview);
@@ -548,66 +539,64 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
preview->set_region(true);
}
-void AutotileEditor::_bind_methods() {
+TileSetEditor::TileSetEditor(EditorNode *p_editor) {
- ClassDB::bind_method("_on_autotile_selected", &AutotileEditor::_on_autotile_selected);
- ClassDB::bind_method("_on_edit_mode_changed", &AutotileEditor::_on_edit_mode_changed);
- ClassDB::bind_method("_on_workspace_draw", &AutotileEditor::_on_workspace_draw);
- ClassDB::bind_method("_on_workspace_input", &AutotileEditor::_on_workspace_input);
- ClassDB::bind_method("_on_tool_clicked", &AutotileEditor::_on_tool_clicked);
- ClassDB::bind_method("_on_priority_changed", &AutotileEditor::_on_priority_changed);
- ClassDB::bind_method("_on_grid_snap_toggled", &AutotileEditor::_on_grid_snap_toggled);
- ClassDB::bind_method("_set_snap_step_x", &AutotileEditor::_set_snap_step_x);
- ClassDB::bind_method("_set_snap_step_y", &AutotileEditor::_set_snap_step_y);
- ClassDB::bind_method("_set_snap_off_x", &AutotileEditor::_set_snap_off_x);
- ClassDB::bind_method("_set_snap_off_y", &AutotileEditor::_set_snap_off_y);
- ClassDB::bind_method("_set_snap_sep_x", &AutotileEditor::_set_snap_sep_x);
- ClassDB::bind_method("_set_snap_sep_y", &AutotileEditor::_set_snap_sep_y);
-}
+ menu = memnew(MenuButton);
+ CanvasItemEditor::get_singleton()->add_control_to_menu_panel(menu);
+ menu->hide();
+ menu->set_text(TTR("Tile Set"));
+ menu->get_popup()->add_item(TTR("Add Item"), MENU_OPTION_ADD_ITEM);
+ menu->get_popup()->add_item(TTR("Remove Item"), MENU_OPTION_REMOVE_ITEM);
+ menu->get_popup()->add_separator();
+ menu->get_popup()->add_item(TTR("Create from Scene"), MENU_OPTION_CREATE_FROM_SCENE);
+ menu->get_popup()->add_item(TTR("Merge from Scene"), MENU_OPTION_MERGE_FROM_SCENE);
+ menu->get_popup()->connect("id_pressed", this, "_menu_cbk");
+ editor = p_editor;
+ cd = memnew(ConfirmationDialog);
+ add_child(cd);
+ cd->get_ok()->connect("pressed", this, "_menu_confirm");
-void AutotileEditor::_notification(int p_what) {
+ nd = memnew(EditorNameDialog);
+ add_child(nd);
+ nd->set_hide_on_ok(true);
+ nd->get_line_edit()->set_margin(MARGIN_TOP, 28);
+ nd->connect("name_confirmed", this, "_name_dialog_confirm");
- if (p_what == NOTIFICATION_ENTER_TREE) {
- tools[TOOL_SELECT]->set_icon(get_icon("ToolSelect", "EditorIcons"));
- tools[BITMASK_COPY]->set_icon(get_icon("Duplicate", "EditorIcons"));
- tools[BITMASK_PASTE]->set_icon(get_icon("Override", "EditorIcons"));
- tools[BITMASK_CLEAR]->set_icon(get_icon("Clear", "EditorIcons"));
- tools[SHAPE_NEW_POLYGON]->set_icon(get_icon("CollisionPolygon2D", "EditorIcons"));
- tools[SHAPE_DELETE]->set_icon(get_icon("Remove", "EditorIcons"));
- tools[SHAPE_KEEP_INSIDE_TILE]->set_icon(get_icon("Snap", "EditorIcons"));
- tools[SHAPE_GRID_SNAP]->set_icon(get_icon("SnapGrid", "EditorIcons"));
- tools[ZOOM_OUT]->set_icon(get_icon("ZoomLess", "EditorIcons"));
- tools[ZOOM_1]->set_icon(get_icon("ZoomReset", "EditorIcons"));
- tools[ZOOM_IN]->set_icon(get_icon("ZoomMore", "EditorIcons"));
- }
-}
+ err_dialog = memnew(AcceptDialog);
+ add_child(err_dialog);
+ err_dialog->set_title(TTR("Error"));
-void AutotileEditor::_changed_callback(Object *p_changed, const char *p_prop) {
- if (p_prop == StringName("texture") || p_prop == StringName("is_autotile")) {
- edit(tile_set.ptr());
- autotile_list->update();
- workspace->update();
- }
+ draw_handles = false;
+
+ initialize_bottom_editor();
}
-void AutotileEditor::_on_autotile_selected(int p_index) {
+TileSetEditor::~TileSetEditor() {
+ if (helper)
+ memdelete(helper);
+}
+void TileSetEditor::_on_tile_list_selected(int p_index) {
if (get_current_tile() >= 0) {
current_item_index = p_index;
- preview->set_texture(tile_set->tile_get_texture(get_current_tile()));
- preview->set_region_rect(tile_set->tile_get_region(get_current_tile()));
- workspace->set_custom_minimum_size(tile_set->tile_get_region(get_current_tile()).size);
+ preview->set_texture(tileset->tile_get_texture(get_current_tile()));
+ preview->set_modulate(tileset->tile_get_modulate(get_current_tile()));
+ preview->set_region_rect(tileset->tile_get_region(get_current_tile()));
+ workspace->set_custom_minimum_size(tileset->tile_get_region(get_current_tile()).size);
+ update_workspace_tile_mode();
} else {
current_item_index = -1;
preview->set_texture(NULL);
workspace->set_custom_minimum_size(Size2i());
}
+ texture_region_editor->selected_tile = get_current_tile();
+ texture_region_editor->_edit_region();
+ helper->selected_tile = get_current_tile();
helper->_change_notify("");
workspace->update();
}
-void AutotileEditor::_on_edit_mode_changed(int p_edit_mode) {
-
+void TileSetEditor::_on_edit_mode_changed(int p_edit_mode) {
edit_mode = (EditMode)p_edit_mode;
switch (edit_mode) {
case EDITMODE_BITMASK: {
@@ -627,7 +616,6 @@ void AutotileEditor::_on_edit_mode_changed(int p_edit_mode) {
tools[TOOL_SELECT]->set_tooltip(TTR("Select current edited sub-tile."));
spin_priority->hide();
- current_shape = PoolVector2Array();
select_coord(edited_shape_coord);
} break;
default: {
@@ -646,17 +634,17 @@ void AutotileEditor::_on_edit_mode_changed(int p_edit_mode) {
workspace->update();
}
-void AutotileEditor::_on_workspace_draw() {
+void TileSetEditor::_on_workspace_draw() {
- if (get_current_tile() >= 0 && !tile_set.is_null()) {
- int spacing = tile_set->autotile_get_spacing(get_current_tile());
- Vector2 size = tile_set->autotile_get_size(get_current_tile());
- Rect2i region = tile_set->tile_get_region(get_current_tile());
+ if (get_current_tile() >= 0 && !tileset.is_null()) {
+ int spacing = tileset->autotile_get_spacing(get_current_tile());
+ Vector2 size = tileset->autotile_get_size(get_current_tile());
+ Rect2i region = tileset->tile_get_region(get_current_tile());
Color c(0.347214, 0.722656, 0.617063);
switch (edit_mode) {
case EDITMODE_ICON: {
- Vector2 coord = tile_set->autotile_get_icon_coordinate(get_current_tile());
+ Vector2 coord = tileset->autotile_get_icon_coordinate(get_current_tile());
draw_highlight_tile(coord);
} break;
case EDITMODE_BITMASK: {
@@ -665,8 +653,8 @@ void AutotileEditor::_on_workspace_draw() {
for (float y = 0; y < region.size.y / (spacing + size.y); y++) {
Vector2 coord(x, y);
Point2 anchor(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
- uint16_t mask = tile_set->autotile_get_bitmask(get_current_tile(), coord);
- if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
+ uint16_t mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
+ if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
if (mask & TileSet::BIND_TOPLEFT) {
workspace->draw_rect(Rect2(anchor, size / 2), c);
}
@@ -679,7 +667,7 @@ void AutotileEditor::_on_workspace_draw() {
if (mask & TileSet::BIND_BOTTOMRIGHT) {
workspace->draw_rect(Rect2(anchor + size / 2, size / 2), c);
}
- } else if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) {
+ } else if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) {
if (mask & TileSet::BIND_TOPLEFT) {
workspace->draw_rect(Rect2(anchor, size / 3), c);
}
@@ -714,19 +702,21 @@ void AutotileEditor::_on_workspace_draw() {
case EDITMODE_COLLISION:
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION: {
- Vector2 coord = edited_shape_coord;
- draw_highlight_tile(coord);
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
+ Vector2 coord = edited_shape_coord;
+ draw_highlight_tile(coord);
+ }
draw_polygon_shapes();
draw_grid_snap();
} break;
case EDITMODE_PRIORITY: {
- spin_priority->set_value(tile_set->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord));
- uint16_t mask = tile_set->autotile_get_bitmask(get_current_tile(), edited_shape_coord);
+ spin_priority->set_value(tileset->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord));
+ uint16_t mask = tileset->autotile_get_bitmask(get_current_tile(), edited_shape_coord);
Vector<Vector2> queue_others;
int total = 0;
- for (Map<Vector2, uint16_t>::Element *E = tile_set->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
+ for (Map<Vector2, uint16_t>::Element *E = tileset->autotile_get_bitmask_map(get_current_tile()).front(); E; E = E->next()) {
if (E->value() == mask) {
- total += tile_set->autotile_get_subtile_priority(get_current_tile(), E->key());
+ total += tileset->autotile_get_subtile_priority(get_current_tile(), E->key());
if (E->key() != edited_shape_coord) {
queue_others.push_back(E->key());
}
@@ -737,53 +727,69 @@ void AutotileEditor::_on_workspace_draw() {
} break;
}
- float j = -size.x; //make sure to draw at 0
- while (j < region.size.x) {
- j += size.x;
- if (spacing <= 0) {
- workspace->draw_line(Point2(j, 0), Point2(j, region.size.y), c);
- } else {
- workspace->draw_rect(Rect2(Point2(j, 0), Size2(spacing, region.size.y)), c);
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
+ float j = -size.x; //make sure to draw at 0
+ while (j < region.size.x) {
+ j += size.x;
+ if (spacing <= 0) {
+ workspace->draw_line(Point2(j, 0), Point2(j, region.size.y), c);
+ } else {
+ workspace->draw_rect(Rect2(Point2(j, 0), Size2(spacing, region.size.y)), c);
+ }
+ j += spacing;
}
- j += spacing;
- }
- j = -size.y; //make sure to draw at 0
- while (j < region.size.y) {
- j += size.y;
- if (spacing <= 0) {
- workspace->draw_line(Point2(0, j), Point2(region.size.x, j), c);
- } else {
- workspace->draw_rect(Rect2(Point2(0, j), Size2(region.size.x, spacing)), c);
+ j = -size.y; //make sure to draw at 0
+ while (j < region.size.y) {
+ j += size.y;
+ if (spacing <= 0) {
+ workspace->draw_line(Point2(0, j), Point2(region.size.x, j), c);
+ } else {
+ workspace->draw_rect(Rect2(Point2(0, j), Size2(region.size.x, spacing)), c);
+ }
+ j += spacing;
}
- j += spacing;
}
}
+ workspace_overlay->update();
}
-#define MIN_DISTANCE_SQUARED 10
-void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
+void TileSetEditor::_on_workspace_overlay_draw() {
- if (get_current_tile() >= 0 && !tile_set.is_null()) {
+ int t_id = get_current_tile();
+ if (t_id < 0 || !draw_handles)
+ return;
+
+ Ref<Texture> handle = get_icon("EditorHandle", "EditorIcons");
+
+ for (int i = 0; i < current_shape.size(); i++) {
+ workspace_overlay->draw_texture(handle, current_shape[i] * workspace->get_scale().x - handle->get_size() * 0.5);
+ }
+}
+
+#define MIN_DISTANCE_SQUARED 6
+void TileSetEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
+
+ if (get_current_tile() >= 0 && !tileset.is_null()) {
Ref<InputEventMouseButton> mb = p_ie;
Ref<InputEventMouseMotion> mm = p_ie;
static bool dragging;
static bool erasing;
- int spacing = tile_set->autotile_get_spacing(get_current_tile());
- Vector2 size = tile_set->autotile_get_size(get_current_tile());
+ int spacing = tileset->autotile_get_spacing(get_current_tile());
+ Vector2 size = tileset->autotile_get_size(get_current_tile());
switch (edit_mode) {
case EDITMODE_ICON: {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
Vector2 coord((int)(mb->get_position().x / (spacing + size.x)), (int)(mb->get_position().y / (spacing + size.y)));
- tile_set->autotile_set_icon_coordinate(get_current_tile(), coord);
- Rect2 region = tile_set->tile_get_region(get_current_tile());
+ tileset->autotile_set_icon_coordinate(get_current_tile(), coord);
+ Rect2 region = tileset->tile_get_region(get_current_tile());
region.size = size;
coord.x *= (spacing + size.x);
coord.y *= (spacing + size.y);
region.position += coord;
- autotile_list->set_item_icon_region(current_item_index, region);
+ tile_list->set_item_icon_region(current_item_index, region);
workspace->update();
}
}
@@ -800,8 +806,8 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
Vector2 coord((int)(mb->get_position().x / (spacing + size.x)), (int)(mb->get_position().y / (spacing + size.y)));
Vector2 pos(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
pos = mb->get_position() - pos;
- uint16_t bit;
- if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
+ uint16_t bit = 0;
+ if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
if (pos.x < size.x / 2) {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPLEFT;
@@ -815,7 +821,7 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
bit = TileSet::BIND_BOTTOMRIGHT;
}
}
- } else if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) {
+ } else if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) {
if (pos.x < size.x / 3) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPLEFT;
@@ -842,13 +848,13 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
}
}
}
- uint16_t mask = tile_set->autotile_get_bitmask(get_current_tile(), coord);
+ uint16_t mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
if (erasing) {
mask &= ~bit;
} else {
mask |= bit;
}
- tile_set->autotile_set_bitmask(get_current_tile(), coord, mask);
+ tileset->autotile_set_bitmask(get_current_tile(), coord, mask);
workspace->update();
}
} else {
@@ -863,8 +869,8 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
Vector2 coord((int)(mm->get_position().x / (spacing + size.x)), (int)(mm->get_position().y / (spacing + size.y)));
Vector2 pos(coord.x * (spacing + size.x), coord.y * (spacing + size.y));
pos = mm->get_position() - pos;
- uint16_t bit;
- if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
+ uint16_t bit = 0;
+ if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
if (pos.x < size.x / 2) {
if (pos.y < size.y / 2) {
bit = TileSet::BIND_TOPLEFT;
@@ -878,7 +884,7 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
bit = TileSet::BIND_BOTTOMRIGHT;
}
}
- } else if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) {
+ } else if (tileset->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) {
if (pos.x < size.x / 3) {
if (pos.y < size.y / 3) {
bit = TileSet::BIND_TOPLEFT;
@@ -905,13 +911,13 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
}
}
}
- uint16_t mask = tile_set->autotile_get_bitmask(get_current_tile(), coord);
+ uint16_t mask = tileset->autotile_get_bitmask(get_current_tile(), coord);
if (erasing) {
mask &= ~bit;
} else {
mask |= bit;
}
- tile_set->autotile_set_bitmask(get_current_tile(), coord, mask);
+ tileset->autotile_set_bitmask(get_current_tile(), coord, mask);
workspace->update();
}
}
@@ -920,9 +926,12 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
case EDITMODE_OCCLUSION:
case EDITMODE_NAVIGATION:
case EDITMODE_PRIORITY: {
- Vector2 shape_anchor = edited_shape_coord;
- shape_anchor.x *= (size.x + spacing);
- shape_anchor.y *= (size.y + spacing);
+ Vector2 shape_anchor = Vector2(0, 0);
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
+ shape_anchor = edited_shape_coord;
+ shape_anchor.x *= (size.x + spacing);
+ shape_anchor.y *= (size.y + spacing);
+ }
if (tools[TOOL_SELECT]->is_pressed()) {
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
@@ -935,23 +944,25 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
}
}
}
- Vector2 coord((int)(mb->get_position().x / (spacing + size.x)), (int)(mb->get_position().y / (spacing + size.y)));
- if (edited_shape_coord != coord) {
- edited_shape_coord = coord;
- edited_occlusion_shape = tile_set->autotile_get_light_occluder(get_current_tile(), edited_shape_coord);
- edited_navigation_shape = tile_set->autotile_get_navigation_polygon(get_current_tile(), edited_shape_coord);
- Vector<TileSet::ShapeData> sd = tile_set->tile_get_shapes(get_current_tile());
- bool found_collision_shape = false;
- for (int i = 0; i < sd.size(); i++) {
- if (sd[i].autotile_coord == coord) {
- edited_collision_shape = sd[i].shape;
- found_collision_shape = true;
- break;
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
+ Vector2 coord((int)(mb->get_position().x / (spacing + size.x)), (int)(mb->get_position().y / (spacing + size.y)));
+ if (edited_shape_coord != coord) {
+ edited_shape_coord = coord;
+ edited_occlusion_shape = tileset->autotile_get_light_occluder(get_current_tile(), edited_shape_coord);
+ edited_navigation_shape = tileset->autotile_get_navigation_polygon(get_current_tile(), edited_shape_coord);
+ Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(get_current_tile());
+ bool found_collision_shape = false;
+ for (int i = 0; i < sd.size(); i++) {
+ if (sd[i].autotile_coord == coord) {
+ edited_collision_shape = sd[i].shape;
+ found_collision_shape = true;
+ break;
+ }
}
+ if (!found_collision_shape)
+ edited_collision_shape = Ref<ConvexPolygonShape2D>(NULL);
+ select_coord(edited_shape_coord);
}
- if (!found_collision_shape)
- edited_collision_shape = Ref<ConvexPolygonShape2D>(NULL);
- select_coord(edited_shape_coord);
}
workspace->update();
} else if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
@@ -1019,6 +1030,7 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
}
}
} else if (tools[SHAPE_NEW_POLYGON]->is_pressed()) {
+
if (mb.is_valid()) {
if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
Vector2 pos = mb->get_position();
@@ -1039,14 +1051,14 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
int t_id = get_current_tile();
if (t_id >= 0) {
if (edit_mode == EDITMODE_COLLISION) {
- Vector<TileSet::ShapeData> sd = tile_set->tile_get_shapes(t_id);
+ Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(t_id);
for (int i = 0; i < sd.size(); i++) {
- if (sd[i].autotile_coord == edited_shape_coord) {
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE || sd[i].autotile_coord == edited_shape_coord) {
Ref<ConvexPolygonShape2D> shape = sd[i].shape;
if (!shape.is_null()) {
sd.remove(i);
- tile_set->tile_set_shapes(get_current_tile(), sd);
+ tileset->tile_set_shapes(get_current_tile(), sd);
edited_collision_shape = Ref<Shape2D>();
workspace->update();
}
@@ -1054,25 +1066,30 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
}
}
} else if (edit_mode == EDITMODE_OCCLUSION) {
- Map<Vector2, Ref<OccluderPolygon2D> > map = tile_set->autotile_get_light_oclusion_map(t_id);
- for (Map<Vector2, Ref<OccluderPolygon2D> >::Element *E = map.front(); E; E = E->next()) {
- if (E->key() == edited_shape_coord) {
- tile_set->autotile_set_light_occluder(get_current_tile(), Ref<OccluderPolygon2D>(), edited_shape_coord);
- break;
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
+ Map<Vector2, Ref<OccluderPolygon2D> > map = tileset->autotile_get_light_oclusion_map(t_id);
+ for (Map<Vector2, Ref<OccluderPolygon2D> >::Element *E = map.front(); E; E = E->next()) {
+ if (E->key() == edited_shape_coord) {
+ tileset->autotile_set_light_occluder(get_current_tile(), Ref<OccluderPolygon2D>(), edited_shape_coord);
+ break;
+ }
}
- }
+ } else
+ tileset->tile_set_light_occluder(t_id, Ref<OccluderPolygon2D>());
edited_occlusion_shape = Ref<OccluderPolygon2D>();
workspace->update();
} else if (edit_mode == EDITMODE_NAVIGATION) {
- Map<Vector2, Ref<NavigationPolygon> > map = tile_set->autotile_get_navigation_map(t_id);
- for (Map<Vector2, Ref<NavigationPolygon> >::Element *E = map.front(); E; E = E->next()) {
- if (E->key() == edited_shape_coord) {
- tile_set->autotile_set_navigation_polygon(t_id, Ref<NavigationPolygon>(), edited_shape_coord);
- break;
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
+ Map<Vector2, Ref<NavigationPolygon> > map = tileset->autotile_get_navigation_map(t_id);
+ for (Map<Vector2, Ref<NavigationPolygon> >::Element *E = map.front(); E; E = E->next()) {
+ if (E->key() == edited_shape_coord) {
+ tileset->autotile_set_navigation_polygon(t_id, Ref<NavigationPolygon>(), edited_shape_coord);
+ break;
+ }
}
- }
-
+ } else
+ tileset->tile_set_navigation_polygon(t_id, Ref<NavigationPolygon>());
edited_navigation_shape = Ref<NavigationPolygon>();
workspace->update();
}
@@ -1108,17 +1125,17 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
}
}
-void AutotileEditor::_on_tool_clicked(int p_tool) {
+void TileSetEditor::_on_tool_clicked(int p_tool) {
if (p_tool == BITMASK_COPY) {
- bitmask_map_copy = tile_set->autotile_get_bitmask_map(get_current_tile());
+ bitmask_map_copy = tileset->autotile_get_bitmask_map(get_current_tile());
} else if (p_tool == BITMASK_PASTE) {
- tile_set->autotile_clear_bitmask_map(get_current_tile());
+ tileset->autotile_clear_bitmask_map(get_current_tile());
for (Map<Vector2, uint16_t>::Element *E = bitmask_map_copy.front(); E; E = E->next()) {
- tile_set->autotile_set_bitmask(get_current_tile(), E->key(), E->value());
+ tileset->autotile_set_bitmask(get_current_tile(), E->key(), E->value());
}
workspace->update();
} else if (p_tool == BITMASK_CLEAR) {
- tile_set->autotile_clear_bitmask_map(get_current_tile());
+ tileset->autotile_clear_bitmask_map(get_current_tile());
workspace->update();
} else if (p_tool == SHAPE_DELETE) {
if (creating_shape) {
@@ -1129,8 +1146,8 @@ void AutotileEditor::_on_tool_clicked(int p_tool) {
switch (edit_mode) {
case EDITMODE_COLLISION: {
if (!edited_collision_shape.is_null()) {
- Vector<TileSet::ShapeData> sd = tile_set->tile_get_shapes(get_current_tile());
- int index;
+ Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(get_current_tile());
+ int index = -1;
for (int i = 0; i < sd.size(); i++) {
if (sd[i].shape == edited_collision_shape) {
index = i;
@@ -1139,7 +1156,7 @@ void AutotileEditor::_on_tool_clicked(int p_tool) {
}
if (index >= 0) {
sd.remove(index);
- tile_set->tile_set_shapes(get_current_tile(), sd);
+ tileset->tile_set_shapes(get_current_tile(), sd);
edited_collision_shape = Ref<Shape2D>();
current_shape.resize(0);
workspace->update();
@@ -1148,7 +1165,7 @@ void AutotileEditor::_on_tool_clicked(int p_tool) {
} break;
case EDITMODE_NAVIGATION: {
if (!edited_navigation_shape.is_null()) {
- tile_set->autotile_set_navigation_polygon(get_current_tile(), Ref<NavigationPolygon>(), edited_shape_coord);
+ tileset->autotile_set_navigation_polygon(get_current_tile(), Ref<NavigationPolygon>(), edited_shape_coord);
edited_navigation_shape = Ref<NavigationPolygon>();
current_shape.resize(0);
workspace->update();
@@ -1156,7 +1173,7 @@ void AutotileEditor::_on_tool_clicked(int p_tool) {
} break;
case EDITMODE_OCCLUSION: {
if (!edited_occlusion_shape.is_null()) {
- tile_set->autotile_set_light_occluder(get_current_tile(), Ref<OccluderPolygon2D>(), edited_shape_coord);
+ tileset->autotile_set_light_occluder(get_current_tile(), Ref<OccluderPolygon2D>(), edited_shape_coord);
edited_occlusion_shape = Ref<OccluderPolygon2D>();
current_shape.resize(0);
workspace->update();
@@ -1170,24 +1187,34 @@ void AutotileEditor::_on_tool_clicked(int p_tool) {
scale /= 2;
workspace->set_scale(Vector2(scale, scale));
workspace_container->set_custom_minimum_size(preview->get_region_rect().size * scale);
+ workspace_overlay->set_custom_minimum_size(preview->get_region_rect().size * scale);
}
} else if (p_tool == ZOOM_1) {
workspace->set_scale(Vector2(1, 1));
workspace_container->set_custom_minimum_size(preview->get_region_rect().size);
+ workspace_overlay->set_custom_minimum_size(preview->get_region_rect().size);
} else if (p_tool == ZOOM_IN) {
float scale = workspace->get_scale().x;
scale *= 2;
workspace->set_scale(Vector2(scale, scale));
workspace_container->set_custom_minimum_size(preview->get_region_rect().size * scale);
+ workspace_overlay->set_custom_minimum_size(preview->get_region_rect().size * scale);
+ } else if (p_tool == TOOL_SELECT) {
+ if (creating_shape) {
+ //Cancel Creation
+ creating_shape = false;
+ current_shape.resize(0);
+ workspace->update();
+ }
}
}
-void AutotileEditor::_on_priority_changed(float val) {
- tile_set->autotile_set_subtile_priority(get_current_tile(), edited_shape_coord, (int)val);
+void TileSetEditor::_on_priority_changed(float val) {
+ tileset->autotile_set_subtile_priority(get_current_tile(), edited_shape_coord, (int)val);
workspace->update();
}
-void AutotileEditor::_on_grid_snap_toggled(bool p_val) {
+void TileSetEditor::_on_grid_snap_toggled(bool p_val) {
if (p_val)
hb_grid->show();
else
@@ -1195,40 +1222,40 @@ void AutotileEditor::_on_grid_snap_toggled(bool p_val) {
workspace->update();
}
-void AutotileEditor::_set_snap_step_x(float p_val) {
+void TileSetEditor::_set_snap_step_x(float p_val) {
snap_step.x = p_val;
workspace->update();
}
-void AutotileEditor::_set_snap_step_y(float p_val) {
+void TileSetEditor::_set_snap_step_y(float p_val) {
snap_step.y = p_val;
workspace->update();
}
-void AutotileEditor::_set_snap_off_x(float p_val) {
+void TileSetEditor::_set_snap_off_x(float p_val) {
snap_offset.x = p_val;
workspace->update();
}
-void AutotileEditor::_set_snap_off_y(float p_val) {
+void TileSetEditor::_set_snap_off_y(float p_val) {
snap_offset.y = p_val;
workspace->update();
}
-void AutotileEditor::_set_snap_sep_x(float p_val) {
+void TileSetEditor::_set_snap_sep_x(float p_val) {
snap_separation.x = p_val;
workspace->update();
}
-void AutotileEditor::_set_snap_sep_y(float p_val) {
+void TileSetEditor::_set_snap_sep_y(float p_val) {
snap_separation.y = p_val;
workspace->update();
}
-void AutotileEditor::draw_highlight_tile(Vector2 coord, const Vector<Vector2> &other_highlighted) {
+void TileSetEditor::draw_highlight_tile(Vector2 coord, const Vector<Vector2> &other_highlighted) {
- Vector2 size = tile_set->autotile_get_size(get_current_tile());
- int spacing = tile_set->autotile_get_spacing(get_current_tile());
- Rect2 region = tile_set->tile_get_region(get_current_tile());
+ Vector2 size = tileset->autotile_get_size(get_current_tile());
+ int spacing = tileset->autotile_get_spacing(get_current_tile());
+ Rect2 region = tileset->tile_get_region(get_current_tile());
coord.x *= (size.x + spacing);
coord.y *= (size.y + spacing);
workspace->draw_rect(Rect2(0, 0, region.size.x, coord.y), Color(0.5, 0.5, 0.5, 0.5));
@@ -1246,7 +1273,7 @@ void AutotileEditor::draw_highlight_tile(Vector2 coord, const Vector<Vector2> &o
}
}
-void AutotileEditor::draw_grid_snap() {
+void TileSetEditor::draw_grid_snap() {
if (tools[SHAPE_GRID_SNAP]->is_pressed()) {
Color grid_color = Color(0.39, 0, 1, 0.2f);
Size2 s = workspace->get_size();
@@ -1287,27 +1314,33 @@ void AutotileEditor::draw_grid_snap() {
}
}
-void AutotileEditor::draw_polygon_shapes() {
+void TileSetEditor::draw_polygon_shapes() {
int t_id = get_current_tile();
if (t_id < 0)
return;
+ draw_handles = false;
+
switch (edit_mode) {
case EDITMODE_COLLISION: {
- Vector<TileSet::ShapeData> sd = tile_set->tile_get_shapes(t_id);
+ Vector<TileSet::ShapeData> sd = tileset->tile_get_shapes(t_id);
for (int i = 0; i < sd.size(); i++) {
- Vector2 coord = sd[i].autotile_coord;
- Vector2 anchor = tile_set->autotile_get_size(t_id);
- anchor.x += tile_set->autotile_get_spacing(t_id);
- anchor.y += tile_set->autotile_get_spacing(t_id);
- anchor.x *= coord.x;
- anchor.y *= coord.y;
+ Vector2 coord = Vector2(0, 0);
+ Vector2 anchor = Vector2(0, 0);
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE) {
+ coord = sd[i].autotile_coord;
+ anchor = tileset->autotile_get_size(t_id);
+ anchor.x += tileset->autotile_get_spacing(t_id);
+ anchor.y += tileset->autotile_get_spacing(t_id);
+ anchor.x *= coord.x;
+ anchor.y *= coord.y;
+ }
Ref<ConvexPolygonShape2D> shape = sd[i].shape;
if (shape.is_valid()) {
Color c_bg;
Color c_border;
- if (coord == edited_shape_coord && sd[i].shape == edited_collision_shape) {
+ if ((tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE || coord == edited_shape_coord) && sd[i].shape == edited_collision_shape) {
c_bg = Color(0, 1, 1, 0.5);
c_border = Color(0, 1, 1);
} else {
@@ -1330,62 +1363,82 @@ void AutotileEditor::draw_polygon_shapes() {
if (polygon.size() > 2) {
workspace->draw_polygon(polygon, colors);
}
- if (coord == edited_shape_coord) {
+ if (coord == edited_shape_coord || tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
for (int j = 0; j < shape->get_points().size() - 1; j++) {
workspace->draw_line(shape->get_points()[j] + anchor, shape->get_points()[j + 1] + anchor, c_border, 1, true);
}
if (shape == edited_collision_shape) {
- for (int j = 0; j < current_shape.size(); j++) {
- workspace->draw_circle(current_shape[j], 8 / workspace->get_scale().x, Color(1, 0, 0, 0.7f));
- }
+ draw_handles = true;
}
}
}
}
} break;
case EDITMODE_OCCLUSION: {
- Map<Vector2, Ref<OccluderPolygon2D> > map = tile_set->autotile_get_light_oclusion_map(t_id);
- for (Map<Vector2, Ref<OccluderPolygon2D> >::Element *E = map.front(); E; E = E->next()) {
- Vector2 coord = E->key();
- Vector2 anchor = tile_set->autotile_get_size(t_id);
- anchor.x += tile_set->autotile_get_spacing(t_id);
- anchor.y += tile_set->autotile_get_spacing(t_id);
- anchor.x *= coord.x;
- anchor.y *= coord.y;
- Ref<OccluderPolygon2D> shape = E->value();
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
+ Ref<OccluderPolygon2D> shape = edited_occlusion_shape;
if (shape.is_valid()) {
- Color c_bg;
- Color c_border;
- if (coord == edited_shape_coord && shape == edited_occlusion_shape) {
- c_bg = Color(0, 1, 1, 0.5);
- c_border = Color(0, 1, 1);
- } else {
- c_bg = Color(0.9, 0.7, 0.07, 0.5);
- c_border = Color(0.9, 0.7, 0.07, 1);
- }
+ Color c_bg = Color(0, 1, 1, 0.5);
+ Color c_border = Color(0, 1, 1);
+
Vector<Vector2> polygon;
Vector<Color> colors;
- if (shape == edited_occlusion_shape && current_shape.size() > 2) {
- for (int j = 0; j < current_shape.size(); j++) {
- polygon.push_back(current_shape[j]);
- colors.push_back(c_bg);
- }
- } else {
- for (int j = 0; j < shape->get_polygon().size(); j++) {
- polygon.push_back(shape->get_polygon()[j] + anchor);
- colors.push_back(c_bg);
- }
+ for (int j = 0; j < shape->get_polygon().size(); j++) {
+ polygon.push_back(shape->get_polygon()[j]);
+ colors.push_back(c_bg);
}
workspace->draw_polygon(polygon, colors);
- if (coord == edited_shape_coord) {
- for (int j = 0; j < shape->get_polygon().size() - 1; j++) {
- workspace->draw_line(shape->get_polygon()[j] + anchor, shape->get_polygon()[j + 1] + anchor, c_border, 1, true);
+
+ for (int j = 0; j < shape->get_polygon().size() - 1; j++) {
+ workspace->draw_line(shape->get_polygon()[j], shape->get_polygon()[j + 1], c_border, 1, true);
+ }
+ workspace->draw_line(shape->get_polygon()[shape->get_polygon().size() - 1], shape->get_polygon()[0], c_border, 1, true);
+ if (shape == edited_occlusion_shape) {
+ draw_handles = true;
+ }
+ }
+ } else {
+ Map<Vector2, Ref<OccluderPolygon2D> > map = tileset->autotile_get_light_oclusion_map(t_id);
+ for (Map<Vector2, Ref<OccluderPolygon2D> >::Element *E = map.front(); E; E = E->next()) {
+ Vector2 coord = E->key();
+ Vector2 anchor = tileset->autotile_get_size(t_id);
+ anchor.x += tileset->autotile_get_spacing(t_id);
+ anchor.y += tileset->autotile_get_spacing(t_id);
+ anchor.x *= coord.x;
+ anchor.y *= coord.y;
+ Ref<OccluderPolygon2D> shape = E->value();
+ if (shape.is_valid()) {
+ Color c_bg;
+ Color c_border;
+ if (coord == edited_shape_coord && shape == edited_occlusion_shape) {
+ c_bg = Color(0, 1, 1, 0.5);
+ c_border = Color(0, 1, 1);
+ } else {
+ c_bg = Color(0.9, 0.7, 0.07, 0.5);
+ c_border = Color(0.9, 0.7, 0.07, 1);
}
- workspace->draw_line(shape->get_polygon()[shape->get_polygon().size() - 1] + anchor, shape->get_polygon()[0] + anchor, c_border, 1, true);
- if (shape == edited_occlusion_shape) {
+ Vector<Vector2> polygon;
+ Vector<Color> colors;
+ if (shape == edited_occlusion_shape && current_shape.size() > 2) {
for (int j = 0; j < current_shape.size(); j++) {
- workspace->draw_circle(current_shape[j], 8 / workspace->get_scale().x, Color(1, 0, 0));
+ polygon.push_back(current_shape[j]);
+ colors.push_back(c_bg);
+ }
+ } else {
+ for (int j = 0; j < shape->get_polygon().size(); j++) {
+ polygon.push_back(shape->get_polygon()[j] + anchor);
+ colors.push_back(c_bg);
+ }
+ }
+ workspace->draw_polygon(polygon, colors);
+ if (coord == edited_shape_coord) {
+ for (int j = 0; j < shape->get_polygon().size() - 1; j++) {
+ workspace->draw_line(shape->get_polygon()[j] + anchor, shape->get_polygon()[j + 1] + anchor, c_border, 1, true);
+ }
+ workspace->draw_line(shape->get_polygon()[shape->get_polygon().size() - 1] + anchor, shape->get_polygon()[0] + anchor, c_border, 1, true);
+ if (shape == edited_occlusion_shape) {
+ draw_handles = true;
}
}
}
@@ -1393,49 +1446,77 @@ void AutotileEditor::draw_polygon_shapes() {
}
} break;
case EDITMODE_NAVIGATION: {
- Map<Vector2, Ref<NavigationPolygon> > map = tile_set->autotile_get_navigation_map(t_id);
- for (Map<Vector2, Ref<NavigationPolygon> >::Element *E = map.front(); E; E = E->next()) {
- Vector2 coord = E->key();
- Vector2 anchor = tile_set->autotile_get_size(t_id);
- anchor.x += tile_set->autotile_get_spacing(t_id);
- anchor.y += tile_set->autotile_get_spacing(t_id);
- anchor.x *= coord.x;
- anchor.y *= coord.y;
- Ref<NavigationPolygon> shape = E->value();
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
+ Ref<NavigationPolygon> shape = edited_navigation_shape;
+
if (shape.is_valid()) {
- Color c_bg;
- Color c_border;
- if (coord == edited_shape_coord && shape == edited_navigation_shape) {
- c_bg = Color(0, 1, 1, 0.5);
- c_border = Color(0, 1, 1);
- } else {
- c_bg = Color(0.9, 0.7, 0.07, 0.5);
- c_border = Color(0.9, 0.7, 0.07, 1);
- }
+ Color c_bg = Color(0, 1, 1, 0.5);
+ Color c_border = Color(0, 1, 1);
+
Vector<Vector2> polygon;
Vector<Color> colors;
- if (shape == edited_navigation_shape && current_shape.size() > 2) {
- for (int j = 0; j < current_shape.size(); j++) {
- polygon.push_back(current_shape[j]);
- colors.push_back(c_bg);
- }
- } else if (shape->get_polygon_count() > 0) {
+
+ PoolVector<Vector2> vertices = shape->get_vertices();
+ for (int j = 0; j < shape->get_polygon(0).size(); j++) {
+ polygon.push_back(vertices[shape->get_polygon(0)[j]]);
+ colors.push_back(c_bg);
+ }
+ workspace->draw_polygon(polygon, colors);
+
+ if (shape->get_polygon_count() > 0) {
PoolVector<Vector2> vertices = shape->get_vertices();
- for (int j = 0; j < shape->get_polygon(0).size(); j++) {
- polygon.push_back(vertices[shape->get_polygon(0)[j]] + anchor);
- colors.push_back(c_bg);
+ for (int j = 0; j < shape->get_polygon(0).size() - 1; j++) {
+ workspace->draw_line(vertices[shape->get_polygon(0)[j]], vertices[shape->get_polygon(0)[j + 1]], c_border, 1, true);
+ }
+ if (shape == edited_navigation_shape) {
+ draw_handles = true;
}
}
- workspace->draw_polygon(polygon, colors);
- if (coord == edited_shape_coord) {
- if (shape->get_polygon_count() > 0) {
+ }
+
+ } else {
+ Map<Vector2, Ref<NavigationPolygon> > map = tileset->autotile_get_navigation_map(t_id);
+ for (Map<Vector2, Ref<NavigationPolygon> >::Element *E = map.front(); E; E = E->next()) {
+ Vector2 coord = E->key();
+ Vector2 anchor = tileset->autotile_get_size(t_id);
+ anchor.x += tileset->autotile_get_spacing(t_id);
+ anchor.y += tileset->autotile_get_spacing(t_id);
+ anchor.x *= coord.x;
+ anchor.y *= coord.y;
+ Ref<NavigationPolygon> shape = E->value();
+ if (shape.is_valid()) {
+ Color c_bg;
+ Color c_border;
+ if (coord == edited_shape_coord && shape == edited_navigation_shape) {
+ c_bg = Color(0, 1, 1, 0.5);
+ c_border = Color(0, 1, 1);
+ } else {
+ c_bg = Color(0.9, 0.7, 0.07, 0.5);
+ c_border = Color(0.9, 0.7, 0.07, 1);
+ }
+ Vector<Vector2> polygon;
+ Vector<Color> colors;
+ if (shape == edited_navigation_shape && current_shape.size() > 2) {
+ for (int j = 0; j < current_shape.size(); j++) {
+ polygon.push_back(current_shape[j]);
+ colors.push_back(c_bg);
+ }
+ } else if (shape->get_polygon_count() > 0) {
PoolVector<Vector2> vertices = shape->get_vertices();
- for (int j = 0; j < shape->get_polygon(0).size() - 1; j++) {
- workspace->draw_line(vertices[shape->get_polygon(0)[j]] + anchor, vertices[shape->get_polygon(0)[j + 1]] + anchor, c_border, 1, true);
+ for (int j = 0; j < shape->get_polygon(0).size(); j++) {
+ polygon.push_back(vertices[shape->get_polygon(0)[j]] + anchor);
+ colors.push_back(c_bg);
}
- if (shape == edited_navigation_shape) {
- for (int j = 0; j < current_shape.size(); j++) {
- workspace->draw_circle(current_shape[j], 8 / workspace->get_scale().x, Color(1, 0, 0));
+ }
+ workspace->draw_polygon(polygon, colors);
+ if (coord == edited_shape_coord) {
+ if (shape->get_polygon_count() > 0) {
+ PoolVector<Vector2> vertices = shape->get_vertices();
+ for (int j = 0; j < shape->get_polygon(0).size() - 1; j++) {
+ workspace->draw_line(vertices[shape->get_polygon(0)[j]] + anchor, vertices[shape->get_polygon(0)[j + 1]] + anchor, c_border, 1, true);
+ }
+ if (shape == edited_navigation_shape) {
+ draw_handles = true;
}
}
}
@@ -1452,7 +1533,7 @@ void AutotileEditor::draw_polygon_shapes() {
}
}
-void AutotileEditor::close_shape(const Vector2 &shape_anchor) {
+void TileSetEditor::close_shape(const Vector2 &shape_anchor) {
creating_shape = false;
@@ -1477,7 +1558,11 @@ void AutotileEditor::close_shape(const Vector2 &shape_anchor) {
shape->set_points(segments);
- tile_set->tile_add_shape(get_current_tile(), shape, Transform2D(), false, edited_shape_coord);
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE)
+ tileset->tile_add_shape(get_current_tile(), shape, Transform2D(), false, edited_shape_coord);
+ else
+ tileset->tile_set_shape(get_current_tile(), 0, shape);
+
edited_collision_shape = shape;
}
@@ -1497,7 +1582,10 @@ void AutotileEditor::close_shape(const Vector2 &shape_anchor) {
w = PoolVector<Vector2>::Write();
shape->set_polygon(polygon);
- tile_set->autotile_set_light_occluder(get_current_tile(), shape, edited_shape_coord);
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE)
+ tileset->autotile_set_light_occluder(get_current_tile(), shape, edited_shape_coord);
+ else
+ tileset->tile_set_light_occluder(get_current_tile(), shape);
edited_occlusion_shape = shape;
tools[TOOL_SELECT]->set_pressed(true);
workspace->update();
@@ -1517,55 +1605,99 @@ void AutotileEditor::close_shape(const Vector2 &shape_anchor) {
w = PoolVector<Vector2>::Write();
shape->set_vertices(polygon);
shape->add_polygon(indices);
- tile_set->autotile_set_navigation_polygon(get_current_tile(), shape, edited_shape_coord);
+
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::AUTO_TILE)
+ tileset->autotile_set_navigation_polygon(get_current_tile(), shape, edited_shape_coord);
+ else
+ tileset->tile_set_navigation_polygon(get_current_tile(), shape);
edited_navigation_shape = shape;
tools[TOOL_SELECT]->set_pressed(true);
workspace->update();
}
+ tileset->_change_notify("");
}
-void AutotileEditor::select_coord(const Vector2 &coord) {
- int spacing = tile_set->autotile_get_spacing(get_current_tile());
- Vector2 size = tile_set->autotile_get_size(get_current_tile());
- Vector2 shape_anchor = coord;
- shape_anchor.x *= (size.x + spacing);
- shape_anchor.y *= (size.y + spacing);
- if (edit_mode == EDITMODE_COLLISION) {
- current_shape.resize(0);
- if (edited_collision_shape.is_valid()) {
- for (int j = 0; j < edited_collision_shape->get_points().size(); j++) {
- current_shape.push_back(edited_collision_shape->get_points()[j] + shape_anchor);
+void TileSetEditor::select_coord(const Vector2 &coord) {
+ current_shape = PoolVector2Array();
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
+ if (edited_collision_shape != tileset->tile_get_shape(get_current_tile(), 0))
+ edited_collision_shape = tileset->tile_get_shape(get_current_tile(), 0);
+ if (edited_occlusion_shape != tileset->tile_get_light_occluder(get_current_tile()))
+ edited_occlusion_shape = tileset->tile_get_light_occluder(get_current_tile());
+ if (edited_navigation_shape != tileset->tile_get_navigation_polygon(get_current_tile()))
+ edited_navigation_shape = tileset->tile_get_navigation_polygon(get_current_tile());
+
+ if (edit_mode == EDITMODE_COLLISION) {
+ current_shape.resize(0);
+ if (edited_collision_shape.is_valid()) {
+ for (int i = 0; i < edited_collision_shape->get_points().size(); i++) {
+ current_shape.push_back(edited_collision_shape->get_points()[i]);
+ }
}
- }
- } else if (edit_mode == EDITMODE_OCCLUSION) {
- current_shape.resize(0);
- if (edited_occlusion_shape.is_valid()) {
- for (int i = 0; i < edited_occlusion_shape->get_polygon().size(); i++) {
- current_shape.push_back(edited_occlusion_shape->get_polygon()[i] + shape_anchor);
+ } else if (edit_mode == EDITMODE_OCCLUSION) {
+ current_shape.resize(0);
+ if (edited_occlusion_shape.is_valid()) {
+ for (int i = 0; i < edited_occlusion_shape->get_polygon().size(); i++) {
+ current_shape.push_back(edited_occlusion_shape->get_polygon()[i]);
+ }
+ }
+ } else if (edit_mode == EDITMODE_NAVIGATION) {
+ current_shape.resize(0);
+ if (edited_navigation_shape.is_valid()) {
+ if (edited_navigation_shape->get_polygon_count() > 0) {
+ PoolVector<Vector2> vertices = edited_navigation_shape->get_vertices();
+ for (int i = 0; i < edited_navigation_shape->get_polygon(0).size(); i++) {
+ current_shape.push_back(vertices[edited_navigation_shape->get_polygon(0)[i]]);
+ }
+ }
}
}
- } else if (edit_mode == EDITMODE_NAVIGATION) {
- current_shape.resize(0);
- if (edited_navigation_shape.is_valid()) {
- if (edited_navigation_shape->get_polygon_count() > 0) {
- PoolVector<Vector2> vertices = edited_navigation_shape->get_vertices();
- for (int i = 0; i < edited_navigation_shape->get_polygon(0).size(); i++) {
- current_shape.push_back(vertices[edited_navigation_shape->get_polygon(0)[i]] + shape_anchor);
+ } else {
+ int spacing = tileset->autotile_get_spacing(get_current_tile());
+ Vector2 size = tileset->autotile_get_size(get_current_tile());
+ Vector2 shape_anchor = coord;
+ shape_anchor.x *= (size.x + spacing);
+ shape_anchor.y *= (size.y + spacing);
+ if (edit_mode == EDITMODE_COLLISION) {
+ current_shape.resize(0);
+ if (edited_collision_shape.is_valid()) {
+ for (int j = 0; j < edited_collision_shape->get_points().size(); j++) {
+ current_shape.push_back(edited_collision_shape->get_points()[j] + shape_anchor);
+ }
+ }
+ } else if (edit_mode == EDITMODE_OCCLUSION) {
+ current_shape.resize(0);
+ if (edited_occlusion_shape.is_valid()) {
+ for (int i = 0; i < edited_occlusion_shape->get_polygon().size(); i++) {
+ current_shape.push_back(edited_occlusion_shape->get_polygon()[i] + shape_anchor);
+ }
+ }
+ } else if (edit_mode == EDITMODE_NAVIGATION) {
+ current_shape.resize(0);
+ if (edited_navigation_shape.is_valid()) {
+ if (edited_navigation_shape->get_polygon_count() > 0) {
+ PoolVector<Vector2> vertices = edited_navigation_shape->get_vertices();
+ for (int i = 0; i < edited_navigation_shape->get_polygon(0).size(); i++) {
+ current_shape.push_back(vertices[edited_navigation_shape->get_polygon(0)[i]] + shape_anchor);
+ }
}
}
}
}
}
-Vector2 AutotileEditor::snap_point(const Vector2 &point) {
+Vector2 TileSetEditor::snap_point(const Vector2 &point) {
Vector2 p = point;
Vector2 coord = edited_shape_coord;
- Vector2 tile_size = tile_set->autotile_get_size(get_current_tile());
- int spacing = tile_set->autotile_get_spacing(get_current_tile());
+ Vector2 tile_size = tileset->autotile_get_size(get_current_tile());
+ int spacing = tileset->autotile_get_spacing(get_current_tile());
Vector2 anchor = coord;
anchor.x *= (tile_size.x + spacing);
anchor.y *= (tile_size.y + spacing);
Rect2 region(anchor, tile_size);
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE)
+ region.position = Point2(0, 0);
+
if (tools[SHAPE_GRID_SNAP]->is_pressed()) {
p.x = Math::snap_scalar_seperation(snap_offset.x, snap_step.x, p.x, snap_separation.x);
p.y = Math::snap_scalar_seperation(snap_offset.y, snap_step.y, p.y, snap_separation.y);
@@ -1583,86 +1715,138 @@ Vector2 AutotileEditor::snap_point(const Vector2 &point) {
return p;
}
-void AutotileEditor::edit(Object *p_node) {
+void TileSetEditor::update_tile_list() {
+ int selected_tile = get_current_tile();
+
+ if (selected_tile < 0)
+ selected_tile = 0;
- tile_set = Ref<TileSet>(Object::cast_to<TileSet>(p_node));
- tile_set->add_change_receptor(this);
- helper->set_tileset(tile_set);
+ helper->set_tileset(tileset);
- autotile_list->clear();
+ tile_list->clear();
List<int> ids;
- tile_set->get_tile_list(&ids);
+ tileset->get_tile_list(&ids);
for (List<int>::Element *E = ids.front(); E; E = E->next()) {
- if (tile_set->tile_get_is_autotile(E->get())) {
- autotile_list->add_item(tile_set->tile_get_name(E->get()));
- autotile_list->set_item_metadata(autotile_list->get_item_count() - 1, E->get());
- autotile_list->set_item_icon(autotile_list->get_item_count() - 1, tile_set->tile_get_texture(E->get()));
- Rect2 region = tile_set->tile_get_region(E->get());
- region.size = tile_set->autotile_get_size(E->get());
- Vector2 pos = tile_set->autotile_get_icon_coordinate(E->get());
- pos.x *= (tile_set->autotile_get_spacing(E->get()) + region.size.x);
- pos.y *= (tile_set->autotile_get_spacing(E->get()) + region.size.y);
+ tile_list->add_item(tileset->tile_get_name(E->get()));
+ tile_list->set_item_metadata(tile_list->get_item_count() - 1, E->get());
+ tile_list->set_item_icon(tile_list->get_item_count() - 1, tileset->tile_get_texture(E->get()));
+ Rect2 region = tileset->tile_get_region(E->get());
+ if (tileset->tile_get_tile_mode(E->get()) == TileSet::AUTO_TILE) {
+ region.size = tileset->autotile_get_size(E->get());
+ Vector2 pos = tileset->autotile_get_icon_coordinate(E->get());
+ pos.x *= (tileset->autotile_get_spacing(E->get()) + region.size.x);
+ pos.y *= (tileset->autotile_get_spacing(E->get()) + region.size.y);
region.position += pos;
- autotile_list->set_item_icon_region(autotile_list->get_item_count() - 1, region);
}
+ tile_list->set_item_icon_region(tile_list->get_item_count() - 1, region);
+ tile_list->set_item_icon_modulate(tile_list->get_item_count() - 1, tileset->tile_get_modulate(E->get()));
}
- if (autotile_list->get_item_count() > 0) {
- autotile_list->select(0);
- _on_autotile_selected(0);
+ if (tile_list->get_item_count() > 0 && selected_tile < tile_list->get_item_count()) {
+ tile_list->select(selected_tile);
+ _on_tile_list_selected(selected_tile);
}
helper->_change_notify("");
}
-int AutotileEditor::get_current_tile() {
+void TileSetEditor::update_tile_list_icon() {
+ List<int> ids;
+ tileset->get_tile_list(&ids);
+ int current_idx = 0;
+ for (List<int>::Element *E = ids.front(); E; E = E->next()) {
+ if (current_idx >= tile_list->get_item_count())
+ break;
+
+ Rect2 region = tileset->tile_get_region(E->get());
+ if (tileset->tile_get_tile_mode(E->get()) == TileSet::AUTO_TILE) {
+ region.size = tileset->autotile_get_size(E->get());
+ Vector2 pos = tileset->autotile_get_icon_coordinate(E->get());
+ pos.x *= (tileset->autotile_get_spacing(E->get()) + region.size.x);
+ pos.y *= (tileset->autotile_get_spacing(E->get()) + region.size.y);
+ region.position += pos;
+ }
+ tile_list->set_item_metadata(current_idx, E->get());
+ tile_list->set_item_icon(current_idx, tileset->tile_get_texture(E->get()));
+ tile_list->set_item_icon_region(current_idx, region);
+ tile_list->set_item_icon_modulate(current_idx, tileset->tile_get_modulate(E->get()));
+ tile_list->set_item_text(current_idx, tileset->tile_get_name(E->get()));
+ current_idx += 1;
+ }
+ tile_list->update();
+}
- if (autotile_list->get_selected_items().size() == 0)
+void TileSetEditor::update_workspace_tile_mode() {
+ if (get_current_tile() < 0)
+ return;
+ if (tileset->tile_get_tile_mode(get_current_tile()) == TileSet::SINGLE_TILE) {
+ if (tool_editmode[EDITMODE_ICON]->is_pressed() || tool_editmode[EDITMODE_PRIORITY]->is_pressed() || tool_editmode[EDITMODE_BITMASK]->is_pressed()) {
+ tool_editmode[EDITMODE_COLLISION]->set_pressed(true);
+ _on_edit_mode_changed(EDITMODE_COLLISION);
+ } else {
+ select_coord(Vector2(0, 0));
+ }
+
+ tool_editmode[EDITMODE_ICON]->hide();
+ tool_editmode[EDITMODE_BITMASK]->hide();
+ tool_editmode[EDITMODE_PRIORITY]->hide();
+ property_editor->hide();
+ } else {
+ tool_editmode[EDITMODE_ICON]->show();
+ tool_editmode[EDITMODE_BITMASK]->show();
+ tool_editmode[EDITMODE_PRIORITY]->show();
+ property_editor->show();
+ }
+}
+
+int TileSetEditor::get_current_tile() {
+ if (tile_list->get_selected_items().size() == 0)
return -1;
else
- return autotile_list->get_item_metadata(autotile_list->get_selected_items()[0]);
+ return tile_list->get_item_metadata(tile_list->get_selected_items()[0]);
}
-void AutotileEditorHelper::set_tileset(const Ref<TileSet> &p_tileset) {
+void TileSetEditorHelper::set_tileset(const Ref<TileSet> &p_tileset) {
- tile_set = p_tileset;
+ tileset = p_tileset;
}
-bool AutotileEditorHelper::_set(const StringName &p_name, const Variant &p_value) {
+bool TileSetEditorHelper::_set(const StringName &p_name, const Variant &p_value) {
- if (autotile_editor->get_current_tile() < 0 || tile_set.is_null())
+ if (selected_tile < 0 || tileset.is_null())
return false;
String name = p_name.operator String();
bool v = false;
if (name == "bitmask_mode") {
- tile_set->set(String::num(autotile_editor->get_current_tile(), 0) + "/autotile/bitmask_mode", p_value, &v);
+ tileset->set(String::num(selected_tile, 0) + "/autotile/bitmask_mode", p_value, &v);
} else if (name.left(7) == "layout/") {
- tile_set->set(String::num(autotile_editor->get_current_tile(), 0) + "/autotile" + name.right(6), p_value, &v);
+ tileset->set(String::num(selected_tile, 0) + "/autotile" + name.right(6), p_value, &v);
}
if (v) {
- tile_set->_change_notify("");
- autotile_editor->workspace->update();
+ tileset->_change_notify("autotile");
}
return v;
}
-bool AutotileEditorHelper::_get(const StringName &p_name, Variant &r_ret) const {
+bool TileSetEditorHelper::_get(const StringName &p_name, Variant &r_ret) const {
- if (autotile_editor->get_current_tile() < 0 || tile_set.is_null())
+ if (selected_tile < 0 || tileset.is_null())
+ return false;
+ if (!tileset->has_tile(selected_tile))
return false;
String name = p_name.operator String();
bool v = false;
if (name == "bitmask_mode") {
- r_ret = tile_set->get(String::num(autotile_editor->get_current_tile(), 0) + "/autotile/bitmask_mode", &v);
+ r_ret = tileset->get(String::num(selected_tile, 0) + "/autotile/bitmask_mode", &v);
} else if (name.left(7) == "layout/") {
- r_ret = tile_set->get(String::num(autotile_editor->get_current_tile(), 0) + "/autotile" + name.right(6), &v);
+ r_ret = tileset->get(String::num(selected_tile, 0) + "/autotile" + name.right(6), &v);
}
return v;
}
-void AutotileEditorHelper::_get_property_list(List<PropertyInfo> *p_list) const {
+void TileSetEditorHelper::_get_property_list(List<PropertyInfo> *p_list) const {
- if (autotile_editor->get_current_tile() < 0 || tile_set.is_null())
+ if (selected_tile < 0 || tileset.is_null())
return;
p_list->push_back(PropertyInfo(Variant::INT, "bitmask_mode", PROPERTY_HINT_ENUM, "2x2,3x3"));
@@ -1670,7 +1854,72 @@ void AutotileEditorHelper::_get_property_list(List<PropertyInfo> *p_list) const
p_list->push_back(PropertyInfo(Variant::INT, "layout/spacing", PROPERTY_HINT_RANGE, "0,256,1"));
}
-AutotileEditorHelper::AutotileEditorHelper(AutotileEditor *p_autotile_editor) {
+TileSetEditorHelper::TileSetEditorHelper(TileSetEditor *p_tileset_editor) {
+
+ tileset_editor = p_tileset_editor;
+ selected_tile = -1;
+}
+
+void TileSetEditorPlugin::edit(Object *p_node) {
+
+ if (Object::cast_to<TileSet>(p_node)) {
+ tileset_editor->edit(Object::cast_to<TileSet>(p_node));
+ tileset_editor->show();
+ tileset_editor->texture_region_editor->edit(p_node);
+ } else
+ tileset_editor->hide();
+}
+
+bool TileSetEditorPlugin::handles(Object *p_node) const {
+
+ return p_node->is_class("TileSet");
+}
+
+void TileSetEditorPlugin::make_visible(bool p_visible) {
+
+ if (p_visible) {
+ tileset_editor->show();
+ tileset_editor->menu->show();
+ tileset_editor_button->show();
+ tileset_editor->side_panel->show();
+ if (tileset_editor_button->is_pressed()) {
+ tileset_editor->bottom_panel->show();
+ }
+ texture_region_button->show();
+ if (texture_region_button->is_pressed())
+ tileset_editor->texture_region_editor->show();
+ } else {
+ tileset_editor->hide();
+ tileset_editor->menu->hide();
+ tileset_editor->side_panel->hide();
+ tileset_editor->bottom_panel->hide();
+ tileset_editor_button->hide();
+ texture_region_button->hide();
+ tileset_editor->texture_region_editor->hide();
+ }
+}
+
+TileSetEditorPlugin::TileSetEditorPlugin(EditorNode *p_node) {
+
+ tileset_editor = memnew(TileSetEditor(p_node));
+
+ add_control_to_container(CONTAINER_CANVAS_EDITOR_MENU, tileset_editor);
+ tileset_editor->set_anchors_and_margins_preset(Control::PRESET_TOP_WIDE);
+ tileset_editor->set_end(Point2(0, 22));
+ tileset_editor->hide();
+
+ tileset_editor->texture_region_editor = memnew(TextureRegionEditor(p_node));
+ texture_region_button = p_node->add_bottom_panel_item(TTR("Texture Region"), tileset_editor->texture_region_editor);
+ texture_region_button->set_tooltip(TTR("Texture Region Editor"));
+
+ tileset_editor->texture_region_editor->set_custom_minimum_size(Size2(0, 200));
+ tileset_editor->texture_region_editor->hide();
+ texture_region_button->hide();
- autotile_editor = p_autotile_editor;
+ add_control_to_container(CONTAINER_CANVAS_EDITOR_SIDE, tileset_editor->side_panel);
+ tileset_editor->side_panel->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+ tileset_editor->side_panel->set_custom_minimum_size(Size2(200, 0));
+ tileset_editor->side_panel->hide();
+ tileset_editor_button = p_node->add_bottom_panel_item(TTR("Tile Set"), tileset_editor->bottom_panel);
+ tileset_editor_button->hide();
}
generated by cgit v1.2.3-70-g09d2 (git 2.51.2) at 2025-11-08 18:12:53 +0000