From bcfb0a09f89f6734e2404acd68505dc45b402ee6 Mon Sep 17 00:00:00 2001 From: Mariano Suligoy Date: Sat, 21 Oct 2017 22:42:23 -0300 Subject: [PATCH] Implement auto-tiling --- editor/plugins/spatial_editor_plugin.cpp | 8 +- editor/plugins/spatial_editor_plugin.h | 3 +- editor/plugins/tile_map_editor_plugin.cpp | 14 + editor/plugins/tile_map_editor_plugin.h | 2 + editor/plugins/tile_set_editor_plugin.cpp | 1140 ++++++++++++++++++++- editor/plugins/tile_set_editor_plugin.h | 119 +++ scene/2d/tile_map.cpp | 241 ++++- scene/2d/tile_map.h | 29 +- scene/resources/tile_set.cpp | 397 ++++++- scene/resources/tile_set.h | 80 +- 10 files changed, 1990 insertions(+), 43 deletions(-) diff --git a/editor/plugins/spatial_editor_plugin.cpp b/editor/plugins/spatial_editor_plugin.cpp index b3d3d5e13a..4852f6c4d6 100644 --- a/editor/plugins/spatial_editor_plugin.cpp +++ b/editor/plugins/spatial_editor_plugin.cpp @@ -4572,9 +4572,9 @@ VSplitContainer *SpatialEditor::get_shader_split() { return shader_split; } -HSplitContainer *SpatialEditor::get_palette_split() { +HBoxContainer *SpatialEditor::get_palette_split() { - return palette_split; + return palette_split_container; } void SpatialEditor::_request_gizmo(Object *p_obj) { @@ -4851,6 +4851,10 @@ SpatialEditor::SpatialEditor(EditorNode *p_editor) { palette_split->set_v_size_flags(SIZE_EXPAND_FILL); vbc->add_child(palette_split); + palette_split_container = memnew(HBoxContainer); + palette_split_container->set_v_size_flags(SIZE_EXPAND_FILL); + palette_split->add_child(palette_split_container); + shader_split = memnew(VSplitContainer); shader_split->set_h_size_flags(SIZE_EXPAND_FILL); palette_split->add_child(shader_split); diff --git a/editor/plugins/spatial_editor_plugin.h b/editor/plugins/spatial_editor_plugin.h index c986e45f43..6ee6a81d44 100644 --- a/editor/plugins/spatial_editor_plugin.h +++ b/editor/plugins/spatial_editor_plugin.h @@ -405,6 +405,7 @@ private: SpatialEditorViewport *viewports[VIEWPORTS_COUNT]; VSplitContainer *shader_split; HSplitContainer *palette_split; + HBoxContainer *palette_split_container; ///// @@ -593,7 +594,7 @@ public: void add_control_to_menu_panel(Control *p_control); VSplitContainer *get_shader_split(); - HSplitContainer *get_palette_split(); + HBoxContainer *get_palette_split(); Spatial *get_selected() { return selected; } diff --git a/editor/plugins/tile_map_editor_plugin.cpp b/editor/plugins/tile_map_editor_plugin.cpp index ffddd8a3a9..4092fd3994 100644 --- a/editor/plugins/tile_map_editor_plugin.cpp +++ b/editor/plugins/tile_map_editor_plugin.cpp @@ -187,10 +187,13 @@ void TileMapEditor::_set_cell(const Point2i &p_pos, int p_value, bool p_flip_h, if (p_with_undo) { undo_redo->add_do_method(node, "set_cellv", Point2(p_pos), p_value, p_flip_h, p_flip_v, p_transpose); + undo_redo->add_do_method(node, "make_bitmask_area_dirty", Point2(p_pos)); undo_redo->add_undo_method(node, "set_cellv", Point2(p_pos), prev_val, prev_flip_h, prev_flip_v, prev_transpose); + undo_redo->add_undo_method(node, "make_bitmask_area_dirty", Point2(p_pos)); } else { node->set_cell(p_pos.x, p_pos.y, p_value, p_flip_h, p_flip_v, p_transpose); + node->update_bitmask_area(Point2(p_pos)); } } @@ -306,6 +309,12 @@ void TileMapEditor::_update_palette() { if (tex.is_valid()) { Rect2 region = tileset->tile_get_region(entries[i].id); + if (tileset->tile_get_is_autotile(entries[i].id)) { + int spacing = tileset->autotile_get_spacing(entries[i].id); + region.size = tileset->autotile_get_size(entries[i].id); + region.position += (region.size + Vector2(spacing, spacing)) * tileset->autotile_get_icon_coordinate(entries[i].id); + } + if (!region.has_no_area()) palette->set_item_icon_region(palette->get_item_count() - 1, region); @@ -499,6 +508,11 @@ void TileMapEditor::_draw_cell(int p_cell, const Point2i &p_point, bool p_flip_h Vector2 tile_ofs = node->get_tileset()->tile_get_texture_offset(p_cell); Rect2 r = node->get_tileset()->tile_get_region(p_cell); + if (node->get_tileset()->tile_get_is_autotile(p_cell)) { + int spacing = node->get_tileset()->autotile_get_spacing(p_cell); + r.size = node->get_tileset()->autotile_get_size(p_cell); + r.position += (r.size + Vector2(spacing, spacing)) * node->get_tileset()->autotile_get_icon_coordinate(p_cell); + } Size2 sc = p_xform.get_scale(); Rect2 rect = Rect2(); diff --git a/editor/plugins/tile_map_editor_plugin.h b/editor/plugins/tile_map_editor_plugin.h index 73474a3f3d..c7a5bf0cc6 100644 --- a/editor/plugins/tile_map_editor_plugin.h +++ b/editor/plugins/tile_map_editor_plugin.h @@ -137,6 +137,8 @@ class TileMapEditor : public VBoxContainer { bool flip_h; bool flip_v; bool transpose; + int auto_x; + int auto_y; }; List copydata; diff --git a/editor/plugins/tile_set_editor_plugin.cpp b/editor/plugins/tile_set_editor_plugin.cpp index f2f71ba6b1..bbed7ff98d 100644 --- a/editor/plugins/tile_set_editor_plugin.cpp +++ b/editor/plugins/tile_set_editor_plugin.cpp @@ -29,6 +29,7 @@ /*************************************************************************/ #include "tile_set_editor_plugin.h" +#include "editor/plugins/canvas_item_editor_plugin.h" #include "scene/2d/physics_body_2d.h" #include "scene/2d/sprite.h" @@ -271,6 +272,7 @@ void TileSetEditorPlugin::edit(Object *p_node) { if (Object::cast_to(p_node)) { tileset_editor->edit(Object::cast_to(p_node)); tileset_editor->show(); + autotile_editor->edit(p_node); } else tileset_editor->hide(); } @@ -282,19 +284,1151 @@ bool TileSetEditorPlugin::handles(Object *p_node) const { void TileSetEditorPlugin::make_visible(bool p_visible) { - if (p_visible) + if (p_visible) { tileset_editor->show(); - else + autotile_button->show(); + autotile_editor->side_panel->show(); + if (autotile_button->is_pressed()) { + autotile_editor->show(); + } + } else { tileset_editor->hide(); + autotile_editor->side_panel->hide(); + autotile_editor->hide(); + autotile_button->hide(); + } } TileSetEditorPlugin::TileSetEditorPlugin(EditorNode *p_node) { tileset_editor = memnew(TileSetEditor(p_node)); - p_node->get_viewport()->add_child(tileset_editor); + add_control_to_container(CONTAINER_CANVAS_EDITOR_MENU, tileset_editor); tileset_editor->set_anchors_and_margins_preset(Control::PRESET_WIDE); tileset_editor->set_anchor(MARGIN_BOTTOM, Control::ANCHOR_BEGIN); 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("Autotiles", autotile_editor); + autotile_button->hide(); +} + +AutotileEditor::AutotileEditor(EditorNode *p_editor) { + + editor = p_editor; + + //Side Panel + side_panel = memnew(Control); + side_panel->set_name("Autotiles"); + + 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(02, 200)); + autotile_list->connect("item_selected", this, "_on_autotile_selected"); + split->add_child(autotile_list); + + property_editor = memnew(PropertyEditor); + property_editor->set_v_size_flags(SIZE_EXPAND_FILL); + property_editor->set_h_size_flags(SIZE_EXPAND_FILL); + split->add_child(property_editor); + + helper = memnew(AutotileEditorHelper(this)); + property_editor->edit(helper); + + // Editor + + dragging_point = -1; + creating_shape = false; + + set_custom_minimum_size(Size2(0, 150)); + + VBoxContainer *main_vb = memnew(VBoxContainer); + add_child(main_vb); + main_vb->set_anchors_and_margins_preset(Control::PRESET_WIDE); + + HBoxContainer *tool_hb = memnew(HBoxContainer); + Ref g(memnew(ButtonGroup)); + + String label[EDITMODE_MAX] = { "Icon", "Bitmask", "Collision", "Occlusion", "Navigation", "Priority" }; + + for (int i = 0; i < (int)EDITMODE_MAX; i++) { + tool_editmode[i] = memnew(Button); + tool_editmode[i]->set_text(label[i]); + tool_editmode[i]->set_toggle_mode(true); + tool_editmode[i]->set_button_group(g); + Vector args; + args.push_back(i); + 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); + + main_vb->add_child(tool_hb); + main_vb->add_child(memnew(HSeparator)); + + toolbar = memnew(HBoxContainer); + for (int i = 0; i < (int)TOOLBAR_MAX; i++) { + tool_containers[i] = memnew(HBoxContainer); + toolbar->add_child(tool_containers[i]); + tool_containers[i]->hide(); + } + + Ref tg(memnew(ButtonGroup)); + + tools[TOOL_SELECT] = memnew(ToolButton); + tool_containers[TOOLBAR_DUMMY]->add_child(tools[TOOL_SELECT]); + tools[TOOL_SELECT]->set_tooltip("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); + tool_containers[TOOLBAR_DUMMY]->show(); + + Vector p; + tools[BITMASK_COPY] = memnew(ToolButton); + p.push_back((int)BITMASK_COPY); + tools[BITMASK_COPY]->connect("pressed", this, "_on_tool_clicked", p); + tool_containers[TOOLBAR_BITMASK]->add_child(tools[BITMASK_COPY]); + tools[BITMASK_PASTE] = memnew(ToolButton); + p = Vector(); + p.push_back((int)BITMASK_PASTE); + tools[BITMASK_PASTE]->connect("pressed", this, "_on_tool_clicked", p); + tool_containers[TOOLBAR_BITMASK]->add_child(tools[BITMASK_PASTE]); + tools[BITMASK_CLEAR] = memnew(ToolButton); + p = Vector(); + p.push_back((int)BITMASK_CLEAR); + tools[BITMASK_CLEAR]->connect("pressed", this, "_on_tool_clicked", p); + tool_containers[TOOLBAR_BITMASK]->add_child(tools[BITMASK_CLEAR]); + + tools[SHAPE_NEW_POLYGON] = memnew(ToolButton); + tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_NEW_POLYGON]); + tools[SHAPE_NEW_POLYGON]->set_toggle_mode(true); + tools[SHAPE_NEW_POLYGON]->set_button_group(tg); + tool_containers[TOOLBAR_SHAPE]->add_child(memnew(VSeparator)); + tools[SHAPE_DELETE] = memnew(ToolButton); + p = Vector(); + 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]); + //tools[SHAPE_CREATE_FROM_NOT_BITMASKED] = memnew(ToolButton); + //tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_CREATE_FROM_NOT_BITMASKED]); + tool_containers[TOOLBAR_SHAPE]->add_change_receptor(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); + tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_KEEP_INSIDE_TILE]); + tools[SHAPE_SNAP_TO_BITMASK_GRID] = memnew(ToolButton); + tools[SHAPE_SNAP_TO_BITMASK_GRID]->set_toggle_mode(true); + tools[SHAPE_SNAP_TO_BITMASK_GRID]->set_pressed(true); + tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_SNAP_TO_BITMASK_GRID]); + + spin_priority = memnew(SpinBox); + spin_priority->set_min(1); + spin_priority->set_max(255); + spin_priority->set_step(1); + spin_priority->set_custom_minimum_size(Size2(100, 0)); + spin_priority->connect("value_changed", this, "_on_priority_changed"); + spin_priority->hide(); + toolbar->add_child(spin_priority); + + Control *separator = memnew(Control); + separator->set_h_size_flags(SIZE_EXPAND_FILL); + toolbar->add_child(separator); + + tools[ZOOM_OUT] = memnew(ToolButton); + p = Vector(); + p.push_back((int)ZOOM_OUT); + tools[ZOOM_OUT]->connect("pressed", this, "_on_tool_clicked", p); + toolbar->add_child(tools[ZOOM_OUT]); + tools[ZOOM_1] = memnew(ToolButton); + p = Vector(); + p.push_back((int)ZOOM_1); + tools[ZOOM_1]->connect("pressed", this, "_on_tool_clicked", p); + toolbar->add_child(tools[ZOOM_1]); + tools[ZOOM_IN] = memnew(ToolButton); + p = Vector(); + p.push_back((int)ZOOM_IN); + tools[ZOOM_IN]->connect("pressed", this, "_on_tool_clicked", p); + toolbar->add_child(tools[ZOOM_IN]); + + main_vb->add_child(toolbar); + + ScrollContainer *scroll = memnew(ScrollContainer); + main_vb->add_child(scroll); + scroll->set_v_size_flags(SIZE_EXPAND_FILL); + + workspace_container = memnew(Control); + scroll->add_child(workspace_container); + + workspace = memnew(Control); + workspace->connect("draw", this, "_on_workspace_draw"); + workspace->connect("gui_input", this, "_on_workspace_input"); + workspace_container->add_child(workspace); + + preview = memnew(Sprite); + workspace->add_child(preview); + preview->set_centered(false); + preview->set_draw_behind_parent(true); + preview->set_region(true); +} + +void AutotileEditor::_bind_methods() { + + 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); +} + +void AutotileEditor::_notification(int p_what) { + + 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_SNAP_TO_BITMASK_GRID]->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")); + } +} + +void AutotileEditor::_on_autotile_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); + } else { + current_item_index = -1; + preview->set_texture(NULL); + workspace->set_custom_minimum_size(Size2i()); + } + helper->_change_notify(""); + workspace->update(); +} + +void AutotileEditor::_on_edit_mode_changed(int p_edit_mode) { + + edit_mode = (EditMode)p_edit_mode; + switch (edit_mode) { + case EDITMODE_BITMASK: { + tool_containers[TOOLBAR_DUMMY]->show(); + tool_containers[TOOLBAR_BITMASK]->show(); + tool_containers[TOOLBAR_SHAPE]->hide(); + tools[TOOL_SELECT]->set_pressed(true); + tools[TOOL_SELECT]->set_tooltip("LMB: set bit on.\nRMB: set bit off."); + spin_priority->hide(); + } break; + case EDITMODE_COLLISION: + case EDITMODE_NAVIGATION: + case EDITMODE_OCCLUSION: { + tool_containers[TOOLBAR_DUMMY]->show(); + tool_containers[TOOLBAR_BITMASK]->hide(); + tool_containers[TOOLBAR_SHAPE]->show(); + tools[TOOL_SELECT]->set_tooltip("Select current edited sub-tile."); + spin_priority->hide(); + } break; + default: { + tool_containers[TOOLBAR_DUMMY]->show(); + tool_containers[TOOLBAR_BITMASK]->hide(); + tool_containers[TOOLBAR_SHAPE]->hide(); + if (edit_mode == EDITMODE_ICON) { + tools[TOOL_SELECT]->set_tooltip("Select sub-tile to use as icon, this will be also used on invalid autotile bindings."); + spin_priority->hide(); + } else { + tools[TOOL_SELECT]->set_tooltip("Select sub-tile to change it's priority."); + spin_priority->show(); + } + } break; + } + workspace->update(); +} + +void AutotileEditor::_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()); + 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()); + draw_highlight_tile(coord); + } break; + case EDITMODE_BITMASK: { + c = Color(1, 0, 0, 0.5); + for (float x = 0; x < region.size.x / (spacing + size.x); x++) { + 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) { + if (mask & TileSet::BIND_TOPLEFT) { + workspace->draw_rect(Rect2(anchor, size / 2), c); + } + if (mask & TileSet::BIND_TOPRIGHT) { + workspace->draw_rect(Rect2(anchor + Vector2(size.x / 2, 0), size / 2), c); + } + if (mask & TileSet::BIND_BOTTOMLEFT) { + workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 2), size / 2), c); + } + 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) { + if (mask & TileSet::BIND_TOPLEFT) { + workspace->draw_rect(Rect2(anchor, size / 3), c); + } + if (mask & TileSet::BIND_TOP) { + workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, 0), size / 3), c); + } + if (mask & TileSet::BIND_TOPRIGHT) { + workspace->draw_rect(Rect2(anchor + Vector2((size.x / 3) * 2, 0), size / 3), c); + } + if (mask & TileSet::BIND_LEFT) { + workspace->draw_rect(Rect2(anchor + Vector2(0, size.y / 3), size / 3), c); + } + if (mask & TileSet::BIND_CENTER) { + workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, size.y / 3), size / 3), c); + } + if (mask & TileSet::BIND_RIGHT) { + workspace->draw_rect(Rect2(anchor + Vector2((size.x / 3) * 2, size.y / 3), size / 3), c); + } + if (mask & TileSet::BIND_BOTTOMLEFT) { + workspace->draw_rect(Rect2(anchor + Vector2(0, (size.y / 3) * 2), size / 3), c); + } + if (mask & TileSet::BIND_BOTTOM) { + workspace->draw_rect(Rect2(anchor + Vector2(size.x / 3, (size.y / 3) * 2), size / 3), c); + } + if (mask & TileSet::BIND_BOTTOMRIGHT) { + workspace->draw_rect(Rect2(anchor + (size / 3) * 2, size / 3), c); + } + } + } + } + } break; + case EDITMODE_COLLISION: + case EDITMODE_OCCLUSION: + case EDITMODE_NAVIGATION: { + Vector2 coord = edited_shape_coord; + draw_highlight_tile(coord); + draw_polygon_shapes(); + } 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); + Vector queue_others; + int total = 0; + for (Map::Element *E = tile_set->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()); + if (E->key() != edited_shape_coord) { + queue_others.push_back(E->key()); + } + } + } + spin_priority->set_suffix(" / " + String::num(total, 0)); + draw_highlight_tile(edited_shape_coord, queue_others); + } 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); + } + 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 += spacing; + } + } +} + +#define MIN_DISTANCE_SQUARED 10 +void AutotileEditor::_on_workspace_input(const Ref &p_ie) { + + if (get_current_tile() >= 0 && !tile_set.is_null()) { + Ref mb = p_ie; + Ref 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()); + 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()); + 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); + workspace->update(); + } + } + } break; + case EDITMODE_BITMASK: { + if (mb.is_valid()) { + if (mb->is_pressed()) { + if (dragging) { + return; + } + if (mb->get_button_index() == BUTTON_RIGHT || mb->get_button_index() == BUTTON_LEFT) { + dragging = true; + erasing = (mb->get_button_index() == BUTTON_RIGHT); + 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) { + if (pos.x < size.x / 2) { + if (pos.y < size.y / 2) { + bit = TileSet::BIND_TOPLEFT; + } else { + bit = TileSet::BIND_BOTTOMLEFT; + } + } else { + if (pos.y < size.y / 2) { + bit = TileSet::BIND_TOPRIGHT; + } else { + bit = TileSet::BIND_BOTTOMRIGHT; + } + } + } else if (tile_set->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; + } else if (pos.y > (size.y / 3) * 2) { + bit = TileSet::BIND_BOTTOMLEFT; + } else { + bit = TileSet::BIND_LEFT; + } + } else if (pos.x > (size.x / 3) * 2) { + if (pos.y < size.y / 3) { + bit = TileSet::BIND_TOPRIGHT; + } else if (pos.y > (size.y / 3) * 2) { + bit = TileSet::BIND_BOTTOMRIGHT; + } else { + bit = TileSet::BIND_RIGHT; + } + } else { + if (pos.y < size.y / 3) { + bit = TileSet::BIND_TOP; + } else if (pos.y > (size.y / 3) * 2) { + bit = TileSet::BIND_BOTTOM; + } else { + bit = TileSet::BIND_CENTER; + } + } + } + uint16_t mask = tile_set->autotile_get_bitmask(get_current_tile(), coord); + if (erasing) { + mask &= ~bit; + } else { + mask |= bit; + } + tile_set->autotile_set_bitmask(get_current_tile(), coord, mask); + workspace->update(); + } + } else { + if ((erasing && mb->get_button_index() == BUTTON_RIGHT) || (!erasing && mb->get_button_index() == BUTTON_LEFT)) { + dragging = false; + erasing = false; + } + } + } + if (mm.is_valid()) { + if (dragging) { + 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) { + if (pos.x < size.x / 2) { + if (pos.y < size.y / 2) { + bit = TileSet::BIND_TOPLEFT; + } else { + bit = TileSet::BIND_BOTTOMLEFT; + } + } else { + if (pos.y < size.y / 2) { + bit = TileSet::BIND_TOPRIGHT; + } else { + bit = TileSet::BIND_BOTTOMRIGHT; + } + } + } else if (tile_set->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; + } else if (pos.y > (size.y / 3) * 2) { + bit = TileSet::BIND_BOTTOMLEFT; + } else { + bit = TileSet::BIND_LEFT; + } + } else if (pos.x > (size.x / 3) * 2) { + if (pos.y < size.y / 3) { + bit = TileSet::BIND_TOPRIGHT; + } else if (pos.y > (size.y / 3) * 2) { + bit = TileSet::BIND_BOTTOMRIGHT; + } else { + bit = TileSet::BIND_RIGHT; + } + } else { + if (pos.y < size.y / 3) { + bit = TileSet::BIND_TOP; + } else if (pos.y > (size.y / 3) * 2) { + bit = TileSet::BIND_BOTTOM; + } else { + bit = TileSet::BIND_CENTER; + } + } + } + uint16_t mask = tile_set->autotile_get_bitmask(get_current_tile(), coord); + if (erasing) { + mask &= ~bit; + } else { + mask |= bit; + } + tile_set->autotile_set_bitmask(get_current_tile(), coord, mask); + workspace->update(); + } + } + } break; + case EDITMODE_COLLISION: + 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); + if (tools[TOOL_SELECT]->is_pressed()) { + if (mb.is_valid()) { + if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { + if (edit_mode != EDITMODE_PRIORITY && current_shape.size() > 0) { + for (int i = 0; i < current_shape.size(); i++) { + if ((current_shape[i] - mb->get_position()).length_squared() <= MIN_DISTANCE_SQUARED) { + dragging_point = i; + workspace->update(); + return; + } + } + } + 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); + shape_anchor = edited_shape_coord; + shape_anchor.x *= (size.x + spacing); + shape_anchor.y *= (size.y + spacing); + 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 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 { + if (edit_mode == EDITMODE_COLLISION) { + Vector sd = tile_set->tile_get_shapes(get_current_tile()); + for (int i = 0; i < sd.size(); i++) { + if (sd[i].autotile_coord == coord) { + Ref shape = sd[i].shape; + if (shape.is_valid()) { + //FIXME: i need a way to know if the point is countained on the polygon instead of the rect + Rect2 bounding_rect; + PoolVector2Array polygon; + bounding_rect.position = shape->get_segments()[0]; + for (int j = 0; j < shape->get_segments().size(); j += 2) { + polygon.push_back(shape->get_segments()[j] + shape_anchor); + bounding_rect.expand_to(shape->get_segments()[j] + shape_anchor); + } + if (bounding_rect.has_point(mb->get_position())) { + current_shape = polygon; + edited_collision_shape = shape; + } + } + } + } + } + } + workspace->update(); + } else if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { + if (edit_mode == EDITMODE_COLLISION) { + if (dragging_point >= 0) { + dragging_point = -1; + + PoolVector segments; + segments.resize(current_shape.size() * 2); + PoolVector::Write w = segments.write(); + + for (int i = 0; i < current_shape.size(); i++) { + w[(i << 1) + 0] = current_shape[i] - shape_anchor; + w[(i << 1) + 1] = current_shape[(i + 1) % current_shape.size()] - shape_anchor; + } + + w = PoolVector::Write(); + edited_collision_shape->set_segments(segments); + + workspace->update(); + } + } else if (edit_mode == EDITMODE_OCCLUSION) { + if (dragging_point >= 0) { + dragging_point = -1; + + PoolVector polygon; + polygon.resize(current_shape.size()); + PoolVector::Write w = polygon.write(); + + for (int i = 0; i < current_shape.size(); i++) { + w[i] = current_shape[i] - shape_anchor; + } + + w = PoolVector::Write(); + edited_occlusion_shape->set_polygon(polygon); + + workspace->update(); + } + } else if (edit_mode == EDITMODE_NAVIGATION) { + if (dragging_point >= 0) { + dragging_point = -1; + + PoolVector polygon; + Vector indices; + polygon.resize(current_shape.size()); + PoolVector::Write w = polygon.write(); + + for (int i = 0; i < current_shape.size(); i++) { + w[i] = current_shape[i] - shape_anchor; + indices.push_back(i); + } + + w = PoolVector::Write(); + edited_navigation_shape->set_vertices(polygon); + edited_navigation_shape->add_polygon(indices); + + workspace->update(); + } + } + } + } else if (mm.is_valid()) { + if (dragging_point >= 0) { + current_shape.set(dragging_point, snap_point(mm->get_position())); + workspace->update(); + } + } + } 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(); + pos = snap_point(pos); + if (creating_shape) { + if (current_shape.size() > 0) { + if ((pos - current_shape[0]).length_squared() <= MIN_DISTANCE_SQUARED) { + if (current_shape.size() > 2) { + close_shape(shape_anchor); + workspace->update(); + return; + } + } + } + current_shape.push_back(pos); + workspace->update(); + } else { + creating_shape = true; + current_shape.resize(0); + current_shape.push_back(snap_point(pos)); + } + } else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) { + if (creating_shape) { + close_shape(shape_anchor); + } + } + } else if (mm.is_valid()) { + if (creating_shape) { + workspace->update(); + } + } + } + } break; + } + } +} + +void AutotileEditor::_on_tool_clicked(int p_tool) { + if (p_tool == BITMASK_COPY) { + bitmask_map_copy = tile_set->autotile_get_bitmask_map(get_current_tile()); + } else if (p_tool == BITMASK_PASTE) { + tile_set->autotile_clear_bitmask_map(get_current_tile()); + for (Map::Element *E = bitmask_map_copy.front(); E; E = E->next()) { + tile_set->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()); + workspace->update(); + } else if (p_tool == SHAPE_DELETE) { + if (!edited_collision_shape.is_null()) { + Vector sd = tile_set->tile_get_shapes(get_current_tile()); + int index; + for (int i = 0; i < sd.size(); i++) { + if (sd[i].shape == edited_collision_shape) { + index = i; + break; + } + } + if (index >= 0) { + sd.remove(index); + tile_set->tile_set_shapes(get_current_tile(), sd); + edited_collision_shape.unref(); + current_shape.resize(0); + workspace->update(); + } + } + } else if (p_tool == ZOOM_OUT) { + float scale = workspace->get_scale().x; + if (scale > 0.1) { + scale /= 2; + workspace->set_scale(Vector2(scale, scale)); + workspace_container->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); + } 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); + } +} + +void AutotileEditor::_on_priority_changed(float val) { + tile_set->autotile_set_subtile_priority(get_current_tile(), edited_shape_coord, (int)val); + workspace->update(); +} + +void AutotileEditor::draw_highlight_tile(Vector2 coord, const Vector &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()); + 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)); + workspace->draw_rect(Rect2(0, coord.y, coord.x, size.y), Color(0.5, 0.5, 0.5, 0.5)); + workspace->draw_rect(Rect2(coord.x + size.x, coord.y, region.size.x - coord.x - size.x, size.y), Color(0.5, 0.5, 0.5, 0.5)); + workspace->draw_rect(Rect2(0, coord.y + size.y, region.size.x, region.size.y - size.y - coord.y), Color(0.5, 0.5, 0.5, 0.5)); + coord += Vector2(1, 1); + workspace->draw_rect(Rect2(coord, size - Vector2(2, 2)), Color(1, 0, 0), false); + for (int i = 0; i < other_highlighted.size(); i++) { + coord = other_highlighted[i]; + coord.x *= (size.x + spacing); + coord.y *= (size.y + spacing); + coord += Vector2(1, 1); + workspace->draw_rect(Rect2(coord, size - Vector2(2, 2)), Color(1, 0, 0), false); + } +} + +void AutotileEditor::draw_polygon_shapes() { + + int t_id = get_current_tile(); + if (t_id < 0) + return; + + switch (edit_mode) { + case EDITMODE_COLLISION: { + Vector sd = tile_set->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; + Ref 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) { + 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 polygon; + Vector colors; + if (shape == edited_collision_shape) { + 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_segments().size(); j += 2) { + polygon.push_back(shape->get_segments()[j] + anchor); + colors.push_back(c_bg); + } + } + workspace->draw_polygon(polygon, colors); + if (coord == edited_shape_coord) { + for (int j = 0; j < shape->get_segments().size(); j += 2) { + workspace->draw_line(shape->get_segments()[j] + anchor, shape->get_segments()[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], 5, Color(1, 0, 0)); + } + } + } + } + } + } break; + case EDITMODE_OCCLUSION: { + Map > map = tile_set->autotile_get_light_oclusion_map(t_id); + for (Map >::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 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); + } + Vector polygon; + Vector colors; + if (shape == edited_occlusion_shape) { + 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); + } + } + 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) { + for (int j = 0; j < current_shape.size(); j++) { + workspace->draw_circle(current_shape[j], 5, Color(1, 0, 0)); + } + } + } + } + } + } break; + case EDITMODE_NAVIGATION: { + Map > map = tile_set->autotile_get_navigation_map(t_id); + for (Map >::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 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 polygon; + Vector colors; + if (shape == edited_navigation_shape) { + 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 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); + } + } + workspace->draw_polygon(polygon, colors); + if (coord == edited_shape_coord) { + if (shape->get_polygon_count() > 0) { + PoolVector 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) { + for (int j = 0; j < current_shape.size(); j++) { + workspace->draw_circle(current_shape[j], 5, Color(1, 0, 0)); + } + } + } + } + } + } + } break; + } + if (creating_shape) { + for (int j = 0; j < current_shape.size() - 1; j++) { + workspace->draw_line(current_shape[j], current_shape[j + 1], Color(0, 1, 1), 1, true); + } + workspace->draw_line(current_shape[current_shape.size() - 1], snap_point(workspace->get_local_mouse_position()), Color(0, 1, 1), 1, true); + } +} + +void AutotileEditor::close_shape(const Vector2 &shape_anchor) { + + creating_shape = false; + + if (edit_mode == EDITMODE_COLLISION) { + Ref shape = memnew(ConcavePolygonShape2D); + + PoolVector segments; + segments.resize(current_shape.size() * 2); + PoolVector::Write w = segments.write(); + + for (int i = 0; i < current_shape.size(); i++) { + w[(i << 1) + 0] = current_shape[i] - shape_anchor; + w[(i << 1) + 1] = current_shape[(i + 1) % current_shape.size()] - shape_anchor; + } + + w = PoolVector::Write(); + shape->set_segments(segments); + + tile_set->tile_add_shape(get_current_tile(), shape, Transform2D(), false, edited_shape_coord); + edited_collision_shape = shape; + tools[TOOL_SELECT]->set_pressed(true); + workspace->update(); + } else if (edit_mode == EDITMODE_OCCLUSION) { + Ref shape = memnew(OccluderPolygon2D); + + PoolVector polygon; + polygon.resize(current_shape.size()); + PoolVector::Write w = polygon.write(); + + for (int i = 0; i < current_shape.size(); i++) { + w[i] = current_shape[i] - shape_anchor; + } + + w = PoolVector::Write(); + shape->set_polygon(polygon); + + tile_set->autotile_set_light_occluder(get_current_tile(), shape, edited_shape_coord); + edited_occlusion_shape = shape; + tools[TOOL_SELECT]->set_pressed(true); + workspace->update(); + } else if (edit_mode == EDITMODE_NAVIGATION) { + Ref shape = memnew(NavigationPolygon); + + PoolVector polygon; + Vector indices; + polygon.resize(current_shape.size()); + PoolVector::Write w = polygon.write(); + + for (int i = 0; i < current_shape.size(); i++) { + w[i] = current_shape[i] - shape_anchor; + indices.push_back(i); + } + + w = PoolVector::Write(); + shape->set_vertices(polygon); + shape->add_polygon(indices); + tile_set->autotile_set_navigation_polygon(get_current_tile(), shape, edited_shape_coord); + edited_navigation_shape = shape; + tools[TOOL_SELECT]->set_pressed(true); + workspace->update(); + } +} + +Vector2 AutotileEditor::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 anchor = coord; + anchor.x *= (tile_size.x + spacing); + anchor.y *= (tile_size.y + spacing); + Rect2 region(anchor, tile_size); + if (tools[SHAPE_KEEP_INSIDE_TILE]->is_pressed()) { + if (p.x < region.position.x) + p.x = region.position.x; + if (p.y < region.position.y) + p.y = region.position.y; + if (p.x > region.position.x + region.size.x) + p.x = region.position.x + region.size.x; + if (p.y > region.position.y + region.size.y) + p.y = region.position.y + region.size.y; + } + if (tools[SHAPE_SNAP_TO_BITMASK_GRID]->is_pressed()) { + Vector2 p2 = p; + if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) { + p2.x = Math::stepify(p2.x, tile_size.x / 2); + p2.y = Math::stepify(p2.y, tile_size.y / 2); + if ((p2 - p).length_squared() <= MAX(tile_size.y / 4, MIN_DISTANCE_SQUARED)) { + p = p2; + } + } else if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) { + p2.x = Math::stepify(p2.x, tile_size.x / 3); + p2.y = Math::stepify(p2.y, tile_size.y / 3); + if ((p2 - p).length_squared() <= MAX(tile_size.y / 6, MIN_DISTANCE_SQUARED)) { + p = p2; + } + } + } + p.floor(); + return p; +} + +void AutotileEditor::edit(Object *p_node) { + + tile_set = Ref(Object::cast_to(p_node)); + helper->set_tileset(tile_set); + + autotile_list->clear(); + List ids; + tile_set->get_tile_list(&ids); + for (List::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); + region.position += pos; + autotile_list->set_item_icon_region(autotile_list->get_item_count() - 1, region); + } + } + if (autotile_list->get_item_count() > 0) { + autotile_list->select(0); + _on_autotile_selected(0); + } + helper->_change_notify(""); +} + +int AutotileEditor::get_current_tile() { + + if (autotile_list->get_selected_items().size() == 0) + return -1; + else + return autotile_list->get_item_metadata(autotile_list->get_selected_items()[0]); +} + +void AutotileEditorHelper::set_tileset(const Ref &p_tileset) { + + tile_set = p_tileset; +} + +bool AutotileEditorHelper::_set(const StringName &p_name, const Variant &p_value) { + + if (autotile_editor->get_current_tile() < 0 || tile_set.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); + } else if (name.left(7) == "layout/") { + tile_set->set(String::num(autotile_editor->get_current_tile(), 0) + "/autotile" + name.right(6), p_value, &v); + } + if (v) { + tile_set->_change_notify(""); + autotile_editor->workspace->update(); + } + return v; +} + +bool AutotileEditorHelper::_get(const StringName &p_name, Variant &r_ret) const { + + if (autotile_editor->get_current_tile() < 0 || tile_set.is_null()) + return false; + + String name = p_name.operator String(); + if (name == "bitmask_mode") { + r_ret = tile_set->get(String::num(autotile_editor->get_current_tile(), 0) + "/autotile/bitmask_mode"); + } else if (name.left(7) == "layout/") { + bool v; + r_ret = tile_set->get(String::num(autotile_editor->get_current_tile(), 0) + "/autotile" + name.right(6), &v); + return v; + } +} + +void AutotileEditorHelper::_get_property_list(List *p_list) const { + + if (autotile_editor->get_current_tile() < 0 || tile_set.is_null()) + return; + + p_list->push_back(PropertyInfo(Variant::INT, "bitmask_mode", PROPERTY_HINT_ENUM, "2x2,3x3")); + p_list->push_back(PropertyInfo(Variant::VECTOR2, "layout/tile_size")); + p_list->push_back(PropertyInfo(Variant::INT, "layout/spacing", PROPERTY_HINT_RANGE, "0,256,1")); +} + +AutotileEditorHelper::AutotileEditorHelper(AutotileEditor *p_autotile_editor) { + + autotile_editor = p_autotile_editor; } diff --git a/editor/plugins/tile_set_editor_plugin.h b/editor/plugins/tile_set_editor_plugin.h index 677ee05b55..d60d0d5c3c 100644 --- a/editor/plugins/tile_set_editor_plugin.h +++ b/editor/plugins/tile_set_editor_plugin.h @@ -32,10 +32,126 @@ #include "editor/editor_name_dialog.h" #include "editor/editor_node.h" +#include "scene/2d/sprite.h" +#include "scene/resources/concave_polygon_shape_2d.h" #include "scene/resources/tile_set.h" +class AutotileEditorHelper; +class AutotileEditor : public Control { + + friend class TileSetEditorPlugin; + friend class AutotileEditorHelper; + GDCLASS(AutotileEditor, Control); + + enum EditMode { + EDITMODE_ICON, + EDITMODE_BITMASK, + EDITMODE_COLLISION, + EDITMODE_OCCLUSION, + EDITMODE_NAVIGATION, + EDITMODE_PRIORITY, + EDITMODE_MAX + }; + + enum AutotileToolbars { + TOOLBAR_DUMMY, + TOOLBAR_BITMASK, + TOOLBAR_SHAPE, + TOOLBAR_MAX + }; + + enum AutotileTools { + TOOL_SELECT, + BITMASK_COPY, + BITMASK_PASTE, + BITMASK_CLEAR, + SHAPE_NEW_POLYGON, + SHAPE_DELETE, + SHAPE_CREATE_FROM_BITMASK, + SHAPE_CREATE_FROM_NOT_BITMASK, + SHAPE_KEEP_INSIDE_TILE, + SHAPE_SNAP_TO_BITMASK_GRID, + ZOOM_OUT, + ZOOM_1, + ZOOM_IN, + TOOL_MAX + }; + + Ref tile_set; + Ref edited_collision_shape; + Ref edited_occlusion_shape; + Ref edited_navigation_shape; + + EditorNode *editor; + + int current_item_index; + Sprite *preview; + Control *workspace_container; + Control *workspace; + Button *tool_editmode[EDITMODE_MAX]; + HBoxContainer *tool_containers[TOOLBAR_MAX]; + HBoxContainer *toolbar; + ToolButton *tools[TOOL_MAX]; + SpinBox *spin_priority; + EditMode edit_mode; + + bool creating_shape; + int dragging_point; + Vector2 edited_shape_coord; + PoolVector2Array current_shape; + Map bitmask_map_copy; + + Control *side_panel; + ItemList *autotile_list; + PropertyEditor *property_editor; + AutotileEditorHelper *helper; + + AutotileEditor(EditorNode *p_editor); + +protected: + static void _bind_methods(); + void _notification(int p_what); + +private: + void _on_autotile_selected(int p_index); + void _on_edit_mode_changed(int p_edit_mode); + void _on_workspace_draw(); + void _on_workspace_input(const Ref &p_ie); + void _on_tool_clicked(int p_tool); + void _on_priority_changed(float val); + + void draw_highlight_tile(Vector2 coord, const Vector &other_highlighted = Vector()); + void draw_grid(const Vector2 &size, int spacing); + void draw_polygon_shapes(); + void close_shape(const Vector2 &shape_anchor); + Vector2 snap_point(const Vector2 &point); + + void edit(Object *p_node); + int get_current_tile(); +}; + +class AutotileEditorHelper : public Object { + + friend class AutotileEditor; + GDCLASS(AutotileEditorHelper, Object); + + Ref tile_set; + AutotileEditor *autotile_editor; + +public: + void set_tileset(const Ref &p_tileset); + +protected: + bool _set(const StringName &p_name, const Variant &p_value); + bool _get(const StringName &p_name, Variant &r_ret) const; + void _get_property_list(List *p_list) const; + + AutotileEditorHelper(AutotileEditor *p_autotile_editor); +}; + class TileSetEditor : public Control { + friend class TileSetEditorPlugin; GDCLASS(TileSetEditor, Control); Ref tileset; @@ -77,8 +193,11 @@ class TileSetEditorPlugin : public EditorPlugin { GDCLASS(TileSetEditorPlugin, EditorPlugin); TileSetEditor *tileset_editor; + AutotileEditor *autotile_editor; EditorNode *editor; + ToolButton *autotile_button; + public: virtual String get_name() const { return "TileSet"; } bool has_main_screen() const { return false; } diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp index f067b5a187..f8bc27ccf6 100644 --- a/scene/2d/tile_map.cpp +++ b/scene/2d/tile_map.cpp @@ -365,6 +365,11 @@ void TileMap::_update_dirty_quadrants() { } Rect2 r = tile_set->tile_get_region(c.id); + if (tile_set->tile_get_is_autotile(c.id)) { + int spacing = tile_set->autotile_get_spacing(c.id); + r.size = tile_set->autotile_get_size(c.id); + r.position += (r.size + Vector2(spacing, spacing)) * Vector2(c.autotile_coord_x, c.autotile_coord_y); + } Size2 s = tex->get_size(); if (r == Rect2()) @@ -456,21 +461,23 @@ void TileMap::_update_dirty_quadrants() { for (int i = 0; i < shapes.size(); i++) { Ref shape = shapes[i].shape; if (shape.is_valid()) { - Transform2D xform; - xform.set_origin(offset.floor()); + if (!tile_set->tile_get_is_autotile(c.id) || (shapes[i].autotile_coord.x == c.autotile_coord_x && shapes[i].autotile_coord.y == c.autotile_coord_y)) { + Transform2D xform; + xform.set_origin(offset.floor()); - Vector2 shape_ofs = tile_set->tile_get_shape_offset(c.id, i); + Vector2 shape_ofs = tile_set->tile_get_shape_offset(c.id, i); - _fix_cell_transform(xform, c, shape_ofs + center_ofs, s); + _fix_cell_transform(xform, c, shape_ofs + center_ofs, s); - if (debug_canvas_item.is_valid()) { - vs->canvas_item_add_set_transform(debug_canvas_item, xform); - shape->draw(debug_canvas_item, debug_collision_color); + if (debug_canvas_item.is_valid()) { + vs->canvas_item_add_set_transform(debug_canvas_item, xform); + shape->draw(debug_canvas_item, debug_collision_color); + } + ps->body_add_shape(q.body, shape->get_rid(), xform); + ps->body_set_shape_metadata(q.body, shape_idx, Vector2(E->key().x, E->key().y)); + ps->body_set_shape_as_one_way_collision(q.body, shape_idx, shapes[i].one_way_collision); + shape_idx++; } - ps->body_add_shape(q.body, shape->get_rid(), xform); - ps->body_set_shape_metadata(q.body, shape_idx, Vector2(E->key().x, E->key().y)); - ps->body_set_shape_as_one_way_collision(q.body, shape_idx, shapes[i].one_way_collision); - shape_idx++; } } @@ -479,9 +486,17 @@ void TileMap::_update_dirty_quadrants() { } if (navigation) { - Ref navpoly = tile_set->tile_get_navigation_polygon(c.id); + Ref navpoly; + Vector2 npoly_ofs; + if (tile_set->tile_get_is_autotile(c.id)) { + navpoly = tile_set->autotile_get_navigation_polygon(c.id, Vector2(c.autotile_coord_x, c.autotile_coord_y)); + npoly_ofs = Vector2(); + } else { + navpoly = tile_set->tile_get_navigation_polygon(c.id); + npoly_ofs = tile_set->tile_get_navigation_polygon_offset(c.id); + } + if (navpoly.is_valid()) { - Vector2 npoly_ofs = tile_set->tile_get_navigation_polygon_offset(c.id); Transform2D xform; xform.set_origin(offset.floor() + q.pos); _fix_cell_transform(xform, c, npoly_ofs + center_ofs, s); @@ -495,10 +510,17 @@ void TileMap::_update_dirty_quadrants() { } } - Ref occluder = tile_set->tile_get_light_occluder(c.id); + Ref occluder; + Vector2 occluder_ofs; + if (tile_set->tile_get_is_autotile(c.id)) { + occluder = tile_set->autotile_get_light_occluder(c.id, Vector2(c.autotile_coord_x, c.autotile_coord_y)); + occluder_ofs = tile_set->tile_get_occluder_offset(c.id); + } else { + occluder = tile_set->tile_get_light_occluder(c.id); + occluder_ofs = Vector2(); + } if (occluder.is_valid()) { - Vector2 occluder_ofs = tile_set->tile_get_occluder_offset(c.id); Transform2D xform; xform.set_origin(offset.floor() + q.pos); _fix_cell_transform(xform, c, occluder_ofs + center_ofs, s); @@ -656,7 +678,7 @@ void TileMap::set_cellv(const Vector2 &p_pos, int p_tile, bool p_flip_x, bool p_ set_cell(p_pos.x, p_pos.y, p_tile, p_flip_x, p_flip_y, p_transpose); } -void TileMap::set_cell(int p_x, int p_y, int p_tile, bool p_flip_x, bool p_flip_y, bool p_transpose) { +void TileMap::set_cell(int p_x, int p_y, int p_tile, bool p_flip_x, bool p_flip_y, bool p_transpose, Vector2 p_autotile_coord) { PosKey pk(p_x, p_y); @@ -702,15 +724,105 @@ void TileMap::set_cell(int p_x, int p_y, int p_tile, bool p_flip_x, bool p_flip_ c.flip_h = p_flip_x; c.flip_v = p_flip_y; c.transpose = p_transpose; + c.autotile_coord_x = (uint16_t)p_autotile_coord.x; + c.autotile_coord_y = (uint16_t)p_autotile_coord.y; _make_quadrant_dirty(Q); used_size_cache_dirty = true; } int TileMap::get_cellv(const Vector2 &p_pos) const { + return get_cell(p_pos.x, p_pos.y); } +void TileMap::make_bitmask_area_dirty(const Vector2 &p_pos) { + + for (int x = p_pos.x - 1; x <= p_pos.x + 1; x++) { + for (int y = p_pos.y - 1; x <= p_pos.y + 1; y++) { + PosKey p(x, y); + if (dirty_bitmask.find(p) == NULL) { + dirty_bitmask.push_back(p); + } + } + } +} + +void TileMap::update_bitmask_area(const Vector2 &p_pos) { + + for (int x = p_pos.x - 1; x <= p_pos.x + 1; x++) { + for (int y = p_pos.y - 1; y <= p_pos.y + 1; y++) { + update_cell_bitmask(x, y); + } + } +} + +void TileMap::update_cell_bitmask(int p_x, int p_y) { + + PosKey p(p_x, p_y); + Map::Element *E = tile_map.find(p); + if (E != NULL) { + int id = get_cell(p_x, p_y); + if (tile_set->tile_get_is_autotile(id)) { + uint16_t mask = 0; + if (tile_set->autotile_get_bitmask_mode(id) == TileSet::BITMASK_2X2) { + if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) { + mask |= TileSet::BIND_TOPLEFT; + } + if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) { + mask |= TileSet::BIND_TOPRIGHT; + } + if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) { + mask |= TileSet::BIND_BOTTOMLEFT; + } + if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) { + mask |= TileSet::BIND_BOTTOMRIGHT; + } + } else if (tile_set->autotile_get_bitmask_mode(id) == TileSet::BITMASK_3X3) { + if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) { + mask |= TileSet::BIND_TOPLEFT; + } + if (tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1))) { + mask |= TileSet::BIND_TOP; + } + if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) { + mask |= TileSet::BIND_TOPRIGHT; + } + if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) { + mask |= TileSet::BIND_LEFT; + } + mask |= TileSet::BIND_CENTER; + if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) { + mask |= TileSet::BIND_RIGHT; + } + if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) { + mask |= TileSet::BIND_BOTTOMLEFT; + } + if (tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1))) { + mask |= TileSet::BIND_BOTTOM; + } + if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) { + mask |= TileSet::BIND_BOTTOMRIGHT; + } + } + Vector2 coord = tile_set->autotile_get_subtile_for_bitmask(id, mask, this, Vector2(p_x, p_y)); + E->get().autotile_coord_x = (int)coord.x; + E->get().autotile_coord_y = (int)coord.y; + } else { + E->get().autotile_coord_x = 0; + E->get().autotile_coord_y = 0; + } + } +} + +void TileMap::update_dirty_bitmask() { + + while (dirty_bitmask.size() > 0) { + update_cell_bitmask(dirty_bitmask[0].x, dirty_bitmask[0].y); + dirty_bitmask.pop_front(); + } +} + int TileMap::get_cell(int p_x, int p_y) const { PosKey pk(p_x, p_y); @@ -756,6 +868,30 @@ bool TileMap::is_cell_transposed(int p_x, int p_y) const { return E->get().transpose; } +int TileMap::get_cell_autotile_coord_x(int p_x, int p_y) const { + + PosKey pk(p_x, p_y); + + const Map::Element *E = tile_map.find(pk); + + if (!E) + return 0; + + return E->get().autotile_coord_x; +} + +int TileMap::get_cell_autotile_coord_y(int p_x, int p_y) const { + + PosKey pk(p_x, p_y); + + const Map::Element *E = tile_map.find(pk); + + if (!E) + return 0; + + return E->get().autotile_coord_y; +} + void TileMap::_recreate_quadrants() { _clear_quadrants(); @@ -823,11 +959,13 @@ void TileMap::_set_tile_data(const PoolVector &p_data) { int c = p_data.size(); PoolVector::Read r = p_data.read(); - for (int i = 0; i < c; i += 2) { + int offset = (format == FORMAT_2_1_5) ? 3 : 2; + + for (int i = 0; i < c; i += offset) { const uint8_t *ptr = (const uint8_t *)&r[i]; - uint8_t local[8]; - for (int j = 0; j < 8; j++) + uint8_t local[12]; + for (int j = 0; j < ((format == FORMAT_2_1_5) ? 12 : 8); j++) local[j] = ptr[j]; #ifdef BIG_ENDIAN_ENABLED @@ -836,6 +974,11 @@ void TileMap::_set_tile_data(const PoolVector &p_data) { SWAP(local[1], local[2]); SWAP(local[4], local[7]); SWAP(local[5], local[6]); + //TODO: ask someone to check this... + if (FORMAT == FORMAT_2_1_5) { + SWAP(local[8], local[11]); + SWAP(local[9], local[10]); + } #endif int16_t x = decode_uint16(&local[0]); @@ -845,24 +988,28 @@ void TileMap::_set_tile_data(const PoolVector &p_data) { bool flip_v = v & (1 << 30); bool transpose = v & (1 << 31); v &= (1 << 29) - 1; - + int16_t coord_x; + int16_t coord_y; + if (format == FORMAT_2_1_5) { + coord_x = decode_uint16(&local[8]); + coord_y = decode_uint16(&local[10]); + } /* if (x<-20 || y <-20 || x>4000 || y>4000) continue; */ - set_cell(x, y, v, flip_h, flip_v, transpose); + set_cell(x, y, v, flip_h, flip_v, transpose, Vector2(coord_x, coord_y)); } } PoolVector TileMap::_get_tile_data() const { PoolVector data; - data.resize(tile_map.size() * 2); + data.resize(tile_map.size() * 3); PoolVector::Write w = data.write(); int idx = 0; for (const Map::Element *E = tile_map.front(); E; E = E->next()) { - uint8_t *ptr = (uint8_t *)&w[idx]; encode_uint16(E->key().x, &ptr[0]); encode_uint16(E->key().y, &ptr[2]); @@ -873,9 +1020,10 @@ PoolVector TileMap::_get_tile_data() const { val |= (1 << 30); if (E->get().transpose) val |= (1 << 31); - encode_uint32(val, &ptr[4]); - idx += 2; + encode_uint16(E->get().autotile_coord_x, &ptr[8]); + encode_uint16(E->get().autotile_coord_y, &ptr[10]); + idx += 3; } w = PoolVector::Write(); @@ -1119,10 +1267,50 @@ Vector2 TileMap::_map_to_world(int p_x, int p_y, bool p_ignore_ofs) const { } return ret; } + +bool TileMap::_set(const StringName &p_name, const Variant &p_value) { + + if (p_name == "format") { + if (p_value.get_type() == Variant::INT) { + format = (DataFormat)(p_value.operator int64_t()); + return true; + } + } else if (p_name == "tile_data") { + if (p_value.is_array()) { + _set_tile_data(p_value); + return true; + } + return false; + } + return false; +} + +bool TileMap::_get(const StringName &p_name, Variant &r_ret) const { + + if (p_name == "format") { + r_ret = FORMAT_2_1_5; + return true; + } else if (p_name == "tile_data") { + r_ret = _get_tile_data(); + return true; + } + return false; +} + +void TileMap::_get_property_list(List *p_list) const { + + PropertyInfo p(Variant::INT, "format", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR); + p_list->push_back(p); + + p = PropertyInfo(Variant::OBJECT, "tile_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR); + p_list->push_back(p); +} + Vector2 TileMap::map_to_world(const Vector2 &p_pos, bool p_ignore_ofs) const { return _map_to_world(p_pos.x, p_pos.y, p_ignore_ofs); } + Vector2 TileMap::world_to_map(const Vector2 &p_pos) const { Vector2 ret = get_cell_transform().affine_inverse().xform(p_pos); @@ -1357,8 +1545,6 @@ void TileMap::_bind_methods() { ADD_GROUP("Occluder", "occluder_"); ADD_PROPERTY(PropertyInfo(Variant::INT, "occluder_light_mask", PROPERTY_HINT_LAYERS_2D_RENDER), "set_occluder_light_mask", "get_occluder_light_mask"); - ADD_GROUP("", ""); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_tile_data", "_get_tile_data"); ADD_SIGNAL(MethodInfo("settings_changed")); @@ -1398,6 +1584,7 @@ TileMap::TileMap() { y_sort_mode = false; occluder_light_mask = 1; clip_uv = false; + format = FORMAT_2_1_4; //Always initialize with the lowest format fp_adjust = 0.00001; tile_origin = TILE_ORIGIN_TOP_LEFT; diff --git a/scene/2d/tile_map.h b/scene/2d/tile_map.h index 9e14ec838a..a0ca2e6a35 100644 --- a/scene/2d/tile_map.h +++ b/scene/2d/tile_map.h @@ -60,6 +60,11 @@ public: }; private: + enum DataFormat { + FORMAT_2_1_4 = 0, + FORMAT_2_1_5 + }; + Ref tile_set; Size2i cell_size; int quadrant_size; @@ -81,6 +86,8 @@ private: //using a more precise comparison so the regions can be sorted later bool operator<(const PosKey &p_k) const { return (y == p_k.y) ? x < p_k.x : y < p_k.y; } + bool operator==(const PosKey &p_k) const { return (y == p_k.y && x == p_k.x); } + PosKey(int16_t p_x, int16_t p_y) { x = p_x; y = p_y; @@ -98,13 +105,17 @@ private: bool flip_h : 1; bool flip_v : 1; bool transpose : 1; + int16_t autotile_coord_x : 16; + int16_t autotile_coord_y : 16; }; - uint32_t _u32t; - Cell() { _u32t = 0; } + uint64_t _u64t; + Cell() { _u64t = 0; } }; Map tile_map; + List dirty_bitmask; + struct Quadrant { Vector2 pos; @@ -167,6 +178,7 @@ private: float bounce; uint32_t collision_layer; uint32_t collision_mask; + DataFormat format; TileOrigin tile_origin; @@ -198,6 +210,10 @@ private: _FORCE_INLINE_ Vector2 _map_to_world(int p_x, int p_y, bool p_ignore_ofs = false) const; protected: + bool _set(const StringName &p_name, const Variant &p_value); + bool _get(const StringName &p_name, Variant &r_ret) const; + void _get_property_list(List *p_list) const; + void _notification(int p_what); static void _bind_methods(); @@ -220,17 +236,24 @@ public: void set_center_y(bool p_enable); bool get_center_y() const; - void set_cell(int p_x, int p_y, int p_tile, bool p_flip_x = false, bool p_flip_y = false, bool p_transpose = false); + void set_cell(int p_x, int p_y, int p_tile, bool p_flip_x = false, bool p_flip_y = false, bool p_transpose = false, Vector2 p_autotile_coord = Vector2()); int get_cell(int p_x, int p_y) const; bool is_cell_x_flipped(int p_x, int p_y) const; bool is_cell_y_flipped(int p_x, int p_y) const; bool is_cell_transposed(int p_x, int p_y) const; + int get_cell_autotile_coord_x(int p_x, int p_y) const; + int get_cell_autotile_coord_y(int p_x, int p_y) const; void set_cellv(const Vector2 &p_pos, int p_tile, bool p_flip_x = false, bool p_flip_y = false, bool p_transpose = false); int get_cellv(const Vector2 &p_pos) const; Rect2 _edit_get_rect() const; + void make_bitmask_area_dirty(const Vector2 &p_pos); + void update_bitmask_area(const Vector2 &p_pos); + void update_cell_bitmask(int p_x, int p_y); + void update_dirty_bitmask(); + void set_collision_layer(uint32_t p_layer); uint32_t get_collision_layer() const; diff --git a/scene/resources/tile_set.cpp b/scene/resources/tile_set.cpp index 29ac7852bf..657d5f6c80 100644 --- a/scene/resources/tile_set.cpp +++ b/scene/resources/tile_set.cpp @@ -28,6 +28,7 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "tile_set.h" +#include "array.h" bool TileSet::_set(const StringName &p_name, const Variant &p_value) { @@ -55,7 +56,74 @@ bool TileSet::_set(const StringName &p_name, const Variant &p_value) { tile_set_modulate(id, p_value); else if (what == "region") tile_set_region(id, p_value); - else if (what == "shape") + else if (what == "is_autotile") + tile_set_is_autotile(id, p_value); + else if (what.left(9) == "autotile/") { + what = what.right(9); + if (what == "bitmask_mode") + autotile_set_bitmask_mode(id, (BitmaskMode)((int)p_value)); + else if (what == "icon_coordinate") + autotile_set_icon_coordinate(id, p_value); + else if (what == "tile_size") + autotile_set_size(id, p_value); + else if (what == "spacing") + autotile_set_spacing(id, p_value); + else if (what == "bitmask_flags") { + tile_map[id].autotile_data.flags.clear(); + if (p_value.is_array()) { + Array p = p_value; + Vector2 last_coord; + while (p.size() > 0) { + if (p[0].get_type() == Variant::VECTOR2) { + last_coord = p[0]; + } else if (p[0].get_type() == Variant::INT) { + autotile_set_bitmask(id, last_coord, p[0]); + } + p.pop_front(); + } + } + } else if (what == "occluder_map") { + tile_map[id].autotile_data.ocludder_map.clear(); + Array p = p_value; + Vector2 last_coord; + while (p.size() > 0) { + if (p[0].get_type() == Variant::VECTOR2) { + last_coord = p[0]; + } else if (p[0].get_type() == Variant::OBJECT) { + autotile_set_light_occluder(id, p[0], last_coord); + } + p.pop_front(); + } + } else if (what == "navpoly_map") { + tile_map[id].autotile_data.navpoly_map.clear(); + Array p = p_value; + Vector2 last_coord; + while (p.size() > 0) { + if (p[0].get_type() == Variant::VECTOR2) { + last_coord = p[0]; + } else if (p[0].get_type() == Variant::OBJECT) { + autotile_set_navigation_polygon(id, p[0], last_coord); + } + p.pop_front(); + } + } else if (what == "priority_map") { + tile_map[id].autotile_data.priority_map.clear(); + Array p = p_value; + Vector3 val; + Vector2 v; + int priority; + while (p.size() > 0) { + val = p[0]; + if (val.z > 1) { + v.x = val.x; + v.y = val.y; + priority = (int)val.z; + tile_map[id].autotile_data.priority_map[v] = priority; + } + p.pop_front(); + } + } + } else if (what == "shape") tile_set_shape(id, 0, p_value); else if (what == "shape_offset") tile_set_shape_offset(id, 0, p_value); @@ -105,7 +173,54 @@ bool TileSet::_get(const StringName &p_name, Variant &r_ret) const { r_ret = tile_get_modulate(id); else if (what == "region") r_ret = tile_get_region(id); - else if (what == "shape") + else if (what == "is_autotile") + r_ret = tile_get_is_autotile(id); + else if (what.left(9) == "autotile/") { + what = what.right(9); + if (what == "bitmask_mode") + r_ret = autotile_get_bitmask_mode(id); + else if (what == "icon_coordinate") + r_ret = autotile_get_icon_coordinate(id); + else if (what == "tile_size") + r_ret = autotile_get_size(id); + else if (what == "spacing") + r_ret = autotile_get_spacing(id); + else if (what == "bitmask_flags") { + Array p; + for (Map::Element *E = tile_map[id].autotile_data.flags.front(); E; E = E->next()) { + p.push_back(E->key()); + p.push_back(E->value()); + } + r_ret = p; + } else if (what == "occluder_map") { + Array p; + for (Map >::Element *E = tile_map[id].autotile_data.ocludder_map.front(); E; E = E->next()) { + p.push_back(E->key()); + p.push_back(E->value()); + } + r_ret = p; + } else if (what == "navpoly_map") { + Array p; + for (Map >::Element *E = tile_map[id].autotile_data.navpoly_map.front(); E; E = E->next()) { + p.push_back(E->key()); + p.push_back(E->value()); + } + r_ret = p; + } else if (what == "priority_map") { + Array p; + Vector3 v; + for (Map::Element *E = tile_map[id].autotile_data.priority_map.front(); E; E = E->next()) { + if (E->value() > 1) { + //Dont save default value + v.x = E->key().x; + v.y = E->key().y; + v.z = E->value(); + p.push_back(v); + } + } + r_ret = p; + } + } else if (what == "shape") r_ret = tile_get_shape(id, 0); else if (what == "shape_offset") r_ret = tile_get_shape_offset(id, 0); @@ -142,6 +257,17 @@ void TileSet::_get_property_list(List *p_list) const { p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial")); p_list->push_back(PropertyInfo(Variant::COLOR, pre + "modulate")); p_list->push_back(PropertyInfo(Variant::RECT2, pre + "region")); + p_list->push_back(PropertyInfo(Variant::BOOL, pre + "is_autotile", PROPERTY_HINT_NONE, "")); + if (tile_get_is_autotile(id)) { + p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/bitmask_mode", PROPERTY_HINT_ENUM, "2X2,3X3", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/icon_coordinate", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/tile_size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/spacing", PROPERTY_HINT_RANGE, "0,256,1", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/bitmask_flags", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/occluder_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/navpoly_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/priority_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR)); + } p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "occluder_offset")); p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "occluder", PROPERTY_HINT_RESOURCE_TYPE, "OccluderPolygon2D")); p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "navigation_offset")); @@ -158,10 +284,25 @@ void TileSet::create_tile(int p_id) { ERR_FAIL_COND(tile_map.has(p_id)); tile_map[p_id] = TileData(); + tile_map[p_id].autotile_data = AutotileData(); _change_notify(""); emit_changed(); } +void TileSet::autotile_set_bitmask_mode(int p_id, BitmaskMode p_mode) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + tile_map[p_id].autotile_data.bitmask_mode = p_mode; + _change_notify(""); + emit_changed(); +} + +TileSet::BitmaskMode TileSet::autotile_get_bitmask_mode(int p_id) const { + + ERR_FAIL_COND_V(!tile_map.has(p_id), BITMASK_2X2); + return tile_map[p_id].autotile_data.bitmask_mode; +} + void TileSet::tile_set_texture(int p_id, const Ref &p_texture) { ERR_FAIL_COND(!tile_map.has(p_id)); @@ -240,6 +381,152 @@ Rect2 TileSet::tile_get_region(int p_id) const { return tile_map[p_id].region; } +void TileSet::tile_set_is_autotile(int p_id, bool p_is_autotile) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + tile_map[p_id].is_autotile = p_is_autotile; + _change_notify(""); + emit_changed(); +} + +bool TileSet::tile_get_is_autotile(int p_id) const { + + ERR_FAIL_COND_V(!tile_map.has(p_id), false); + return tile_map[p_id].is_autotile; +} + +void TileSet::autotile_set_icon_coordinate(int p_id, Vector2 coord) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + tile_map[p_id].autotile_data.icon_coord = coord; + emit_changed(); +} + +Vector2 TileSet::autotile_get_icon_coordinate(int p_id) const { + + ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2()); + return tile_map[p_id].autotile_data.icon_coord; +} + +void TileSet::autotile_set_spacing(int p_id, int p_spacing) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + ERR_FAIL_COND(p_spacing < 0); + tile_map[p_id].autotile_data.spacing = p_spacing; + emit_changed(); +} + +int TileSet::autotile_get_spacing(int p_id) const { + + ERR_FAIL_COND_V(!tile_map.has(p_id), 0); + return tile_map[p_id].autotile_data.spacing; +} + +void TileSet::autotile_set_size(int p_id, Size2 p_size) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + ERR_FAIL_COND(p_size.x <= 0 || p_size.y <= 0); + tile_map[p_id].autotile_data.size = p_size; +} + +Size2 TileSet::autotile_get_size(int p_id) const { + + ERR_FAIL_COND_V(!tile_map.has(p_id), Size2()); + return tile_map[p_id].autotile_data.size; +} + +void TileSet::autotile_clear_bitmask_map(int p_id) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + tile_map[p_id].autotile_data.flags.clear(); +} + +void TileSet::autotile_set_subtile_priority(int p_id, const Vector2 &p_coord, int p_priority) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + ERR_FAIL_COND(p_priority <= 0); + tile_map[p_id].autotile_data.priority_map[p_coord] = p_priority; +} + +int TileSet::autotile_get_subtile_priority(int p_id, const Vector2 &p_coord) { + + ERR_FAIL_COND_V(!tile_map.has(p_id), 1); + if (tile_map[p_id].autotile_data.priority_map.has(p_coord)) { + return tile_map[p_id].autotile_data.priority_map[p_coord]; + } + //When not custom priority set return the default value + return 1; +} + +const Map &TileSet::autotile_get_priority_map(int p_id) const { + + static Map dummy; + ERR_FAIL_COND_V(!tile_map.has(p_id), dummy); + return tile_map[p_id].autotile_data.priority_map; +} + +void TileSet::autotile_set_bitmask(int p_id, Vector2 p_coord, uint16_t p_flag) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + if (p_flag == 0) { + if (tile_map[p_id].autotile_data.flags.has(p_coord)) + tile_map[p_id].autotile_data.flags.erase(p_coord); + } else { + tile_map[p_id].autotile_data.flags[p_coord] = p_flag; + } +} + +uint16_t TileSet::autotile_get_bitmask(int p_id, Vector2 p_coord) { + + ERR_FAIL_COND_V(!tile_map.has(p_id), 0); + if (!tile_map[p_id].autotile_data.flags.has(p_coord)) { + return 0; + } + return tile_map[p_id].autotile_data.flags[p_coord]; +} + +const Map &TileSet::autotile_get_bitmask_map(int p_id) { + + static Map dummy; + ERR_FAIL_COND_V(!tile_map.has(p_id), dummy); + return tile_map[p_id].autotile_data.flags; +} + +Vector2 TileSet::autotile_get_subtile_for_bitmask(int p_id, uint16_t p_bitmask, const Node *p_tilemap_node, const Vector2 &p_tile_location) { + + ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2()); + //First try to forward selection to script + if (p_tilemap_node->get_class_name() == "TileMap") { + if (get_script_instance() != NULL) { + if (get_script_instance()->has_method("_forward_subtile_selection")) { + Variant ret = get_script_instance()->call("_forward_subtile_selection", p_id, p_bitmask, p_tilemap_node, p_tile_location); + if (ret.get_type() == Variant::VECTOR2) { + return ret; + } + } + } + } + + List coords; + uint16_t mask; + for (Map::Element *E = tile_map[p_id].autotile_data.flags.front(); E; E = E->next()) { + mask = E->get(); + if (tile_map[p_id].autotile_data.bitmask_mode == BITMASK_2X2) { + mask &= (BIND_BOTTOMLEFT | BIND_BOTTOMRIGHT | BIND_TOPLEFT | BIND_TOPRIGHT); + } + if (mask == p_bitmask) { + for (int i = 0; i < autotile_get_subtile_priority(p_id, E->key()); i++) { + coords.push_back(E->key()); + } + } + } + if (coords.size() == 0) { + return autotile_get_icon_coordinate(p_id); + } else { + return coords[Math::random(0, (int)coords.size())]; + } +} + void TileSet::tile_set_name(int p_id, const String &p_name) { ERR_FAIL_COND(!tile_map.has(p_id)); @@ -257,7 +544,7 @@ void TileSet::tile_clear_shapes(int p_id) { tile_map[p_id].shapes_data.clear(); } -void TileSet::tile_add_shape(int p_id, const Ref &p_shape, const Transform2D &p_transform, bool p_one_way) { +void TileSet::tile_add_shape(int p_id, const Ref &p_shape, const Transform2D &p_transform, bool p_one_way, const Vector2 &p_autotile_coord) { ERR_FAIL_COND(!tile_map.has(p_id)); @@ -265,15 +552,17 @@ void TileSet::tile_add_shape(int p_id, const Ref &p_shape, const Transf new_data.shape = p_shape; new_data.shape_transform = p_transform; new_data.one_way_collision = p_one_way; + new_data.autotile_coord = p_autotile_coord; tile_map[p_id].shapes_data.push_back(new_data); -}; +} + int TileSet::tile_get_shape_count(int p_id) const { ERR_FAIL_COND_V(!tile_map.has(p_id), 0); return tile_map[p_id].shapes_data.size(); -}; +} void TileSet::tile_set_shape(int p_id, int p_shape_id, const Ref &p_shape) { @@ -351,6 +640,26 @@ Ref TileSet::tile_get_light_occluder(int p_id) const { return tile_map[p_id].occluder; } +void TileSet::autotile_set_light_occluder(int p_id, const Ref &p_light_occluder, const Vector2 &p_coord) { + ERR_FAIL_COND(!tile_map.has(p_id)); + if (p_light_occluder.is_null()) { + if (tile_map[p_id].autotile_data.ocludder_map.has(p_coord)) { + tile_map[p_id].autotile_data.ocludder_map.erase(p_coord); + } + } else { + tile_map[p_id].autotile_data.ocludder_map[p_coord] = p_light_occluder; + } +} + +Ref TileSet::autotile_get_light_occluder(int p_id, const Vector2 &p_coord) const { + ERR_FAIL_COND_V(!tile_map.has(p_id), Ref()); + if (!tile_map[p_id].autotile_data.ocludder_map.has(p_coord)) { + return Ref(); + } else { + return tile_map[p_id].autotile_data.ocludder_map[p_coord]; + } +} + void TileSet::tile_set_navigation_polygon_offset(int p_id, const Vector2 &p_offset) { ERR_FAIL_COND(!tile_map.has(p_id)); @@ -358,6 +667,7 @@ void TileSet::tile_set_navigation_polygon_offset(int p_id, const Vector2 &p_offs } Vector2 TileSet::tile_get_navigation_polygon_offset(int p_id) const { + ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2()); return tile_map[p_id].navigation_polygon_offset; } @@ -374,6 +684,42 @@ Ref TileSet::tile_get_navigation_polygon(int p_id) const { return tile_map[p_id].navigation_polygon; } +const Map > &TileSet::autotile_get_light_oclusion_map(int p_id) const { + + static Map > dummy; + ERR_FAIL_COND_V(!tile_map.has(p_id), dummy); + return tile_map[p_id].autotile_data.ocludder_map; +} + +void TileSet::autotile_set_navigation_polygon(int p_id, const Ref &p_navigation_polygon, const Vector2 &p_coord) { + + ERR_FAIL_COND(!tile_map.has(p_id)); + if (p_navigation_polygon.is_null()) { + if (tile_map[p_id].autotile_data.navpoly_map.has(p_coord)) { + tile_map[p_id].autotile_data.navpoly_map.erase(p_coord); + } + } else { + tile_map[p_id].autotile_data.navpoly_map[p_coord] = p_navigation_polygon; + } +} + +Ref TileSet::autotile_get_navigation_polygon(int p_id, const Vector2 &p_coord) const { + + ERR_FAIL_COND_V(!tile_map.has(p_id), Ref()); + if (!tile_map[p_id].autotile_data.navpoly_map.has(p_coord)) { + return Ref(); + } else { + return tile_map[p_id].autotile_data.navpoly_map[p_coord]; + } +} + +const Map > &TileSet::autotile_get_navigation_map(int p_id) const { + + static Map > dummy; + ERR_FAIL_COND_V(!tile_map.has(p_id), dummy); + return tile_map[p_id].autotile_data.navpoly_map; +} + void TileSet::tile_set_occluder_offset(int p_id, const Vector2 &p_offset) { ERR_FAIL_COND(!tile_map.has(p_id)); @@ -381,6 +727,7 @@ void TileSet::tile_set_occluder_offset(int p_id, const Vector2 &p_offset) { } Vector2 TileSet::tile_get_occluder_offset(int p_id) const { + ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2()); return tile_map[p_id].occluder_offset; } @@ -405,6 +752,7 @@ void TileSet::_tile_set_shapes(int p_id, const Array &p_shapes) { Vector shapes_data; Transform2D default_transform = tile_get_shape_transform(p_id, 0); bool default_one_way = tile_get_shape_one_way(p_id, 0); + Vector2 default_autotile_coord = Vector2(); for (int i = 0; i < p_shapes.size(); i++) { ShapeData s = ShapeData(); @@ -415,6 +763,7 @@ void TileSet::_tile_set_shapes(int p_id, const Array &p_shapes) { s.shape = shape; s.shape_transform = default_transform; s.one_way_collision = default_one_way; + s.autotile_coord = default_autotile_coord; } else if (p_shapes[i].get_type() == Variant::DICTIONARY) { Dictionary d = p_shapes[i]; @@ -435,6 +784,11 @@ void TileSet::_tile_set_shapes(int p_id, const Array &p_shapes) { else s.one_way_collision = default_one_way; + if (d.has("autotile_coord") && d["autotile_coord"].get_type() == Variant::VECTOR2) + s.autotile_coord = d["autotile_coord"]; + else + s.autotile_coord = default_autotile_coord; + } else { ERR_EXPLAIN("Expected an array of objects or dictionaries for tile_set_shapes"); ERR_CONTINUE(true); @@ -457,6 +811,7 @@ Array TileSet::_tile_get_shapes(int p_id) const { shape_data["shape"] = data[i].shape; shape_data["shape_transform"] = data[i].shape_transform; shape_data["one_way"] = data[i].one_way_collision; + shape_data["autotile_coord"] = data[i].autotile_coord; arr.push_back(shape_data); } @@ -487,6 +842,21 @@ bool TileSet::has_tile(int p_id) const { return tile_map.has(p_id); } +bool TileSet::is_tile_bound(int p_drawn_id, int p_neighbor_id) { + + if (p_drawn_id == p_neighbor_id) { + return true; + } else if (get_script_instance() != NULL) { + if (get_script_instance()->has_method("_is_tile_bound")) { + Variant ret = get_script_instance()->call("_is_tile_bound", p_drawn_id, p_neighbor_id); + if (ret.get_type() == Variant::BOOL) { + return ret; + } + } + } + return false; +} + void TileSet::remove_tile(int p_id) { ERR_FAIL_COND(!tile_map.has(p_id)); @@ -523,6 +893,8 @@ void TileSet::clear() { void TileSet::_bind_methods() { ClassDB::bind_method(D_METHOD("create_tile", "id"), &TileSet::create_tile); + ClassDB::bind_method(D_METHOD("autotile_set_bitmask_mode", "mode"), &TileSet::autotile_set_bitmask_mode); + ClassDB::bind_method(D_METHOD("autotile_get_bitmask_mode"), &TileSet::autotile_get_bitmask_mode); ClassDB::bind_method(D_METHOD("tile_set_name", "id", "name"), &TileSet::tile_set_name); ClassDB::bind_method(D_METHOD("tile_get_name", "id"), &TileSet::tile_get_name); ClassDB::bind_method(D_METHOD("tile_set_texture", "id", "texture"), &TileSet::tile_set_texture); @@ -559,6 +931,21 @@ void TileSet::_bind_methods() { ClassDB::bind_method(D_METHOD("get_last_unused_tile_id"), &TileSet::get_last_unused_tile_id); ClassDB::bind_method(D_METHOD("find_tile_by_name", "name"), &TileSet::find_tile_by_name); ClassDB::bind_method(D_METHOD("get_tiles_ids"), &TileSet::_get_tiles_ids); + + BIND_VMETHOD(MethodInfo("_is_tile_bound", PropertyInfo(Variant::INT, "drawn_id"), PropertyInfo(Variant::INT, "neighbor_id"))); + BIND_VMETHOD(MethodInfo("_forward_subtile_selection", PropertyInfo(Variant::INT, "autotile_id"), PropertyInfo(Variant::INT, "bitmask"), PropertyInfo(Variant::OBJECT, "tilemap", PROPERTY_HINT_NONE, "TileMap"), PropertyInfo(Variant::VECTOR2, "tile_location"))); + + BIND_ENUM_CONSTANT(BITMASK_2X2); + BIND_ENUM_CONSTANT(BITMASK_3X3); + + BIND_ENUM_CONSTANT(BIND_TOPLEFT); + BIND_ENUM_CONSTANT(BIND_TOP); + BIND_ENUM_CONSTANT(BIND_TOPRIGHT); + BIND_ENUM_CONSTANT(BIND_LEFT); + BIND_ENUM_CONSTANT(BIND_RIGHT); + BIND_ENUM_CONSTANT(BIND_BOTTOMLEFT); + BIND_ENUM_CONSTANT(BIND_BOTTOM); + BIND_ENUM_CONSTANT(BIND_BOTTOMRIGHT); } TileSet::TileSet() { diff --git a/scene/resources/tile_set.h b/scene/resources/tile_set.h index 3ef3f00cef..18b62c778d 100644 --- a/scene/resources/tile_set.h +++ b/scene/resources/tile_set.h @@ -30,6 +30,7 @@ #ifndef TILE_SET_H #define TILE_SET_H +#include "core/array.h" #include "resource.h" #include "scene/2d/light_occluder_2d.h" #include "scene/2d/navigation_polygon.h" @@ -44,6 +45,7 @@ public: struct ShapeData { Ref shape; Transform2D shape_transform; + Vector2 autotile_coord; bool one_way_collision; ShapeData() { @@ -51,6 +53,40 @@ public: } }; + enum BitmaskMode { + BITMASK_2X2, + BITMASK_3X3 + }; + + enum AutotileBindings { + BIND_TOPLEFT = 1, + BIND_TOP = 2, + BIND_TOPRIGHT = 4, + BIND_LEFT = 8, + BIND_CENTER = 16, + BIND_RIGHT = 32, + BIND_BOTTOMLEFT = 64, + BIND_BOTTOM = 128, + BIND_BOTTOMRIGHT = 256 + }; + + struct AutotileData { + BitmaskMode bitmask_mode; + int spacing; + Size2 size; + Vector2 icon_coord; + Map flags; + Map > ocludder_map; + Map > navpoly_map; + Map priority_map; + + // Default size to prevent invalid value + explicit AutotileData() + : size(64, 64), icon_coord(0, 0) { + bitmask_mode = BITMASK_2X2; + } + }; + private: struct TileData { @@ -66,10 +102,12 @@ private: Ref navigation_polygon; Ref material; Color modulate; + bool is_autotile; + AutotileData autotile_data; // Default modulate for back-compat explicit TileData() - : modulate(1, 1, 1) {} + : modulate(1, 1, 1), is_autotile(false) {} }; Map tile_map; @@ -87,6 +125,9 @@ protected: public: void create_tile(int p_id); + void autotile_set_bitmask_mode(int p_id, BitmaskMode p_mode); + BitmaskMode autotile_get_bitmask_mode(int p_id) const; + void tile_set_name(int p_id, const String &p_name); String tile_get_name(int p_id) const; @@ -102,6 +143,28 @@ public: void tile_set_region(int p_id, const Rect2 &p_region); Rect2 tile_get_region(int p_id) const; + void tile_set_is_autotile(int p_id, bool p_is_autotile); + bool tile_get_is_autotile(int p_id) const; + + void autotile_set_icon_coordinate(int p_id, Vector2 coord); + Vector2 autotile_get_icon_coordinate(int p_id) const; + + void autotile_set_spacing(int p_id, int p_spacing); + int autotile_get_spacing(int p_id) const; + + void autotile_set_size(int p_id, Size2 p_size); + Size2 autotile_get_size(int p_id) const; + + void autotile_clear_bitmask_map(int p_id); + void autotile_set_subtile_priority(int p_id, const Vector2 &p_coord, int p_priority); + int autotile_get_subtile_priority(int p_id, const Vector2 &p_coord); + const Map &autotile_get_priority_map(int p_id) const; + + void autotile_set_bitmask(int p_id, Vector2 p_coord, uint16_t p_flag); + uint16_t autotile_get_bitmask(int p_id, Vector2 p_coord); + const Map &autotile_get_bitmask_map(int p_id); + Vector2 autotile_get_subtile_for_bitmask(int p_id, uint16_t p_bitmask, const Node *p_tilemap_node = NULL, const Vector2 &p_tile_location = Vector2()); + void tile_set_shape(int p_id, int p_shape_id, const Ref &p_shape); Ref tile_get_shape(int p_id, int p_shape_id) const; @@ -115,7 +178,7 @@ public: bool tile_get_shape_one_way(int p_id, int p_shape_id) const; void tile_clear_shapes(int p_id); - void tile_add_shape(int p_id, const Ref &p_shape, const Transform2D &p_transform, bool p_one_way = false); + void tile_add_shape(int p_id, const Ref &p_shape, const Transform2D &p_transform, bool p_one_way = false, const Vector2 &p_autotile_coord = Vector2()); int tile_get_shape_count(int p_id) const; void tile_set_shapes(int p_id, const Vector &p_shapes); @@ -133,16 +196,26 @@ public: void tile_set_light_occluder(int p_id, const Ref &p_light_occluder); Ref tile_get_light_occluder(int p_id) const; + void autotile_set_light_occluder(int p_id, const Ref &p_light_occluder, const Vector2 &p_coord); + Ref autotile_get_light_occluder(int p_id, const Vector2 &p_coord) const; + const Map > &autotile_get_light_oclusion_map(int p_id) const; + void tile_set_navigation_polygon_offset(int p_id, const Vector2 &p_offset); Vector2 tile_get_navigation_polygon_offset(int p_id) const; void tile_set_navigation_polygon(int p_id, const Ref &p_navigation_polygon); Ref tile_get_navigation_polygon(int p_id) const; + void autotile_set_navigation_polygon(int p_id, const Ref &p_navigation_polygon, const Vector2 &p_coord); + Ref autotile_get_navigation_polygon(int p_id, const Vector2 &p_coord) const; + const Map > &autotile_get_navigation_map(int p_id) const; + void remove_tile(int p_id); bool has_tile(int p_id) const; + bool is_tile_bound(int p_drawn_id, int p_neighbor_id); + int find_tile_by_name(const String &p_name) const; void get_tile_list(List *p_tiles) const; @@ -153,4 +226,7 @@ public: TileSet(); }; +VARIANT_ENUM_CAST(TileSet::AutotileBindings); +VARIANT_ENUM_CAST(TileSet::BitmaskMode); + #endif // TILE_SET_H