From 3cd4b2859c9d715459325b070643773b47472324 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gilles=20Roudi=C3=A8re?= Date: Tue, 5 Mar 2024 13:55:23 +0100 Subject: [PATCH] Expose TileMapLayer --- doc/classes/EditorSettings.xml | 3 + doc/classes/TileMap.xml | 14 +- doc/classes/TileMapLayer.xml | 303 ++++++ doc/classes/TileMapLayerGroup.xml | 17 - editor/editor_node.cpp | 4 +- editor/editor_settings.cpp | 1 + editor/icons/TileMapLayer.svg | 2 +- .../plugins/tiles/tile_map_layer_editor.cpp | 578 ++++++++---- editor/plugins/tiles/tile_map_layer_editor.h | 32 +- editor/plugins/tiles/tiles_editor_plugin.cpp | 98 +- editor/plugins/tiles/tiles_editor_plugin.h | 4 +- .../4.2-stable.expected | 9 - scene/2d/tile_map.cpp | 251 ++++- scene/2d/tile_map.h | 32 +- scene/2d/tile_map_layer.cpp | 887 +++++++++--------- scene/2d/tile_map_layer.h | 143 ++- scene/2d/tile_map_layer_group.cpp | 148 --- scene/2d/tile_map_layer_group.h | 73 -- scene/main/canvas_item.cpp | 17 +- scene/main/canvas_item.h | 3 + scene/register_scene_types.cpp | 3 +- 21 files changed, 1626 insertions(+), 996 deletions(-) create mode 100644 doc/classes/TileMapLayer.xml delete mode 100644 doc/classes/TileMapLayerGroup.xml delete mode 100644 scene/2d/tile_map_layer_group.cpp delete mode 100644 scene/2d/tile_map_layer_group.h diff --git a/doc/classes/EditorSettings.xml b/doc/classes/EditorSettings.xml index 48ed191db179..9f0b86e87723 100644 --- a/doc/classes/EditorSettings.xml +++ b/doc/classes/EditorSettings.xml @@ -448,6 +448,9 @@ The color to use for the TileMap editor's grid. [b]Note:[/b] Only effective if [member editors/tiles_editor/display_grid] is [code]true[/code]. + + Highlight the currently selected TileMapLayer by dimming the other ones in the scene. + The color of a graph node's header when it belongs to the "Color" category. diff --git a/doc/classes/TileMap.xml b/doc/classes/TileMap.xml index fc19e1de4967..bc8a1d7bf174 100644 --- a/doc/classes/TileMap.xml +++ b/doc/classes/TileMap.xml @@ -1,5 +1,5 @@ - + Node for 2D tile-based maps. @@ -89,7 +89,8 @@ - Returns the tile alternative ID of the cell on layer [param layer] at [param coords]. If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies, returning the raw alternative identifier. See [method TileSet.map_tile_proxy]. + Returns the tile alternative ID of the cell on layer [param layer] at [param coords]. + If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies, returning the raw alternative identifier. See [method TileSet.map_tile_proxy]. If [param layer] is negative, the layers are accessed from the last one. @@ -100,7 +101,7 @@ Returns the tile atlas coordinates ID of the cell on layer [param layer] at coordinates [param coords]. Returns [code]Vector2i(-1, -1)[/code] if the cell does not exist. - If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies, returning the raw alternative identifier. See [method TileSet.map_tile_proxy]. + If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies, returning the raw atlas coordinate identifier. See [method TileSet.map_tile_proxy]. If [param layer] is negative, the layers are accessed from the last one. @@ -111,7 +112,7 @@ Returns the tile source ID of the cell on layer [param layer] at coordinates [param coords]. Returns [code]-1[/code] if the cell does not exist. - If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies, returning the raw alternative identifier. See [method TileSet.map_tile_proxy]. + If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies, returning the raw source identifier. See [method TileSet.map_tile_proxy]. If [param layer] is negative, the layers are accessed from the last one. @@ -123,7 +124,6 @@ Returns the [TileData] object associated with the given cell, or [code]null[/code] if the cell does not exist or is not a [TileSetAtlasSource]. If [param layer] is negative, the layers are accessed from the last one. - If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies, returning the raw alternative identifier. See [method TileSet.map_tile_proxy]. [codeblock] func get_clicked_tile_power(): var clicked_cell = tile_map.local_to_map(tile_map.get_local_mouse_position()) @@ -133,6 +133,7 @@ else: return 0 [/codeblock] + If [param use_proxies] is [code]false[/code], ignores the [TileSet]'s tile proxies. See [method TileSet.map_tile_proxy]. @@ -489,6 +490,9 @@ The quadrant size does not apply on Y-sorted layers, as tiles are be grouped by Y position instead in that case. [b]Note:[/b] As quadrants are created according to the map's coordinate system, the quadrant's "square shape" might not look like square in the TileMap's local coordinate system. + + The [TileSet] used by this [TileMap]. The textures, collisions, and additional behavior of all available tiles are stored here. + diff --git a/doc/classes/TileMapLayer.xml b/doc/classes/TileMapLayer.xml new file mode 100644 index 000000000000..bc8e259599e1 --- /dev/null +++ b/doc/classes/TileMapLayer.xml @@ -0,0 +1,303 @@ + + + + Node for 2D tile-based maps. + + + Node for 2D tile-based maps. A [TileMapLayer] uses a [TileSet] which contain a list of tiles which are used to create grid-based maps. Unlike the [TileMap] node, which is deprecated, [TileMapLayer] has only one layer of tiles. You can use several [TileMapLayer] to achieve the same result as a [TileMap] node. + For performance reasons, all TileMap updates are batched at the end of a frame. Notably, this means that scene tiles from a [TileSetScenesCollectionSource] may be initialized after their parent. This is only queued when inside the scene tree. + To force an update earlier on, call [method update_internals]. + + + + + + + + + + Called with a [TileData] object about to be used internally by the [TileMapLayer], allowing its modification at runtime. + This method is only called if [method _use_tile_data_runtime_update] is implemented and returns [code]true[/code] for the given tile [param coords]. + [b]Warning:[/b] The [param tile_data] object's sub-resources are the same as the one in the TileSet. Modifying them might impact the whole TileSet. Instead, make sure to duplicate those resources. + [b]Note:[/b] If the properties of [param tile_data] object should change over time, use [method notify_runtime_tile_data_update] to notify the [TileMapLayer] it needs an update. + + + + + + + Should return [code]true[/code] if the tile at coordinates [param coords] requires a runtime update. + [b]Warning:[/b] Make sure this function only returns [code]true[/code] when needed. Any tile processed at runtime without a need for it will imply a significant performance penalty. + [b]Note:[/b] If the result of this function should change, use [method notify_runtime_tile_data_update] to notify the [TileMapLayer] it needs an update. + + + + + + Clears all cells. + + + + + + + Erases the cell at coordinates [param coords]. + + + + + + Clears cells containing tiles that do not exist in the [member tile_set]. + + + + + + + Returns the tile alternative ID of the cell at coordinates [param coords]. + + + + + + + Returns the tile atlas coordinates ID of the cell at coordinates [param coords]. Returns [code]Vector2i(-1, -1)[/code] if the cell does not exist. + + + + + + + Returns the tile source ID of the cell at coordinates [param coords]. Returns [code]-1[/code] if the cell does not exist. + + + + + + + Returns the [TileData] object associated with the given cell, or [code]null[/code] if the cell does not exist or is not a [TileSetAtlasSource]. + [codeblock] + func get_clicked_tile_power(): + var clicked_cell = tile_map_layer.local_to_map(tile_map_layer.get_local_mouse_position()) + var data = tile_map_layer.get_cell_tile_data(clicked_cell) + if data: + return data.get_custom_data("power") + else: + return 0 + [/codeblock] + + + + + + + Returns the coordinates of the tile for given physics body [RID]. Such an [RID] can be retrieved from [method KinematicCollision2D.get_collider_rid], when colliding with a tile. + + + + + + Returns the [RID] of the [NavigationServer2D] navigation used by this [TileMapLayer]. + By default this returns the default [World2D] navigation map, unless a custom map was provided using [method set_navigation_map]. + + + + + + + + Returns the neighboring cell to the one at coordinates [param coords], identified by the [param neighbor] direction. This method takes into account the different layouts a TileMap can take. + + + + + + + Creates and returns a new [TileMapPattern] from the given array of cells. See also [method set_pattern]. + + + + + + + Returns the list of all neighboring cells to the one at [param coords]. + + + + + + Returns a [Vector2i] array with the positions of all cells containing a tile. A cell is considered empty if its source identifier equals [code]-1[/code], its atlas coordinate identifier is [code]Vector2(-1, -1)[/code] and its alternative identifier is [code]-1[/code]. + + + + + + + + + Returns a [Vector2i] array with the positions of all cells containing a tile. Tiles may be filtered according to their source ([param source_id]), their atlas coordinates ([param atlas_coords]), or alternative id ([param alternative_tile]). + If a parameter has its value set to the default one, this parameter is not used to filter a cell. Thus, if all parameters have their respective default values, this method returns the same result as [method get_used_cells]. + A cell is considered empty if its source identifier equals [code]-1[/code], its atlas coordinate identifier is [code]Vector2(-1, -1)[/code] and its alternative identifier is [code]-1[/code]. + + + + + + Returns a rectangle enclosing the used (non-empty) tiles of the map. + + + + + + + Returns whether the provided [param body] [RID] belongs to one of this [TileMapLayer]'s cells. + + + + + + + Returns the map coordinates of the cell containing the given [param local_position]. If [param local_position] is in global coordinates, consider using [method Node2D.to_local] before passing it to this method. See also [method map_to_local]. + + + + + + + + + Returns for the given coordinates [param coords_in_pattern] in a [TileMapPattern] the corresponding cell coordinates if the pattern was pasted at the [param position_in_tilemap] coordinates (see [method set_pattern]). This mapping is required as in half-offset tile shapes, the mapping might not work by calculating [code]position_in_tile_map + coords_in_pattern[/code]. + + + + + + + Returns the centered position of a cell in the [TileMapLayer]'s local coordinate space. To convert the returned value into global coordinates, use [method Node2D.to_global]. See also [method local_to_map]. + [b]Note:[/b] This may not correspond to the visual position of the tile, i.e. it ignores the [member TileData.texture_origin] property of individual tiles. + + + + + + Notifies the [TileMapLayer] node that calls to [method _use_tile_data_runtime_update] or [method _tile_data_runtime_update] will lead to different results. This will thus trigger a [TileMapLayer] update. + [b]Warning:[/b] Updating the [TileMapLayer] is computationally expensive and may impact performance. Try to limit the number of calls to this function to avoid unnecessary update. + [b]Note:[/b] This does not trigger a direct update of the [TileMapLayer], the update will be done at the end of the frame as usual (unless you call [method update_internals]). + + + + + + + + + + Sets the tile identifiers for the cell at coordinates [param coords]. Each tile of the [TileSet] is identified using three parts: + - The source identifier [param source_id] identifies a [TileSetSource] identifier. See [method TileSet.set_source_id], + - The atlas coordinate identifier [param atlas_coords] identifies a tile coordinates in the atlas (if the source is a [TileSetAtlasSource]). For [TileSetScenesCollectionSource] it should always be [code]Vector2i(0, 0)[/code], + - The alternative tile identifier [param alternative_tile] identifies a tile alternative in the atlas (if the source is a [TileSetAtlasSource]), and the scene for a [TileSetScenesCollectionSource]. + If [param source_id] is set to [code]-1[/code], [param atlas_coords] to [code]Vector2i(-1, -1)[/code], or [param alternative_tile] to [code]-1[/code], the cell will be erased. An erased cell gets [b]all[/b] its identifiers automatically set to their respective invalid values, namely [code]-1[/code], [code]Vector2i(-1, -1)[/code] and [code]-1[/code]. + + + + + + + + + + Update all the cells in the [param cells] coordinates array so that they use the given [param terrain] for the given [param terrain_set]. If an updated cell has the same terrain as one of its neighboring cells, this function tries to join the two. This function might update neighboring tiles if needed to create correct terrain transitions. + If [param ignore_empty_terrains] is true, empty terrains will be ignored when trying to find the best fitting tile for the given terrain constraints. + [b]Note:[/b] To work correctly, this method requires the [TileMapLayer]'s TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results. + + + + + + + + + + Update all the cells in the [param path] coordinates array so that they use the given [param terrain] for the given [param terrain_set]. The function will also connect two successive cell in the path with the same terrain. This function might update neighboring tiles if needed to create correct terrain transitions. + If [param ignore_empty_terrains] is true, empty terrains will be ignored when trying to find the best fitting tile for the given terrain constraints. + [b]Note:[/b] To work correctly, this method requires the [TileMapLayer]'s TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results. + + + + + + + Sets a custom [param map] as a [NavigationServer2D] navigation map. If not set, uses the default [World2D] navigation map instead. + + + + + + + + Pastes the [TileMapPattern] at the given [param position] in the tile map. See also [method get_pattern]. + + + + + + Triggers a direct update of the [TileMapLayer]. Usually, calling this function is not needed, as [TileMapLayer] node updates automatically when one of its properties or cells is modified. + However, for performance reasons, those updates are batched and delayed to the end of the frame. Calling this function will force the [TileMapLayer] to update right away instead. + [b]Warning:[/b] Updating the [TileMapLayer] is computationally expensive and may impact performance. Try to limit the number of updates and how many tiles they impact. + + + + + + Enable or disable collisions. + + + Show or hide the [TileMapLayer]'s collision shapes. If set to [constant DEBUG_VISIBILITY_MODE_DEFAULT], this depends on the show collision debug settings. + + + If [code]false[/code], disables this [TileMapLayer] completely (rendering, collision, navigation, scene tiles, etc.) + + + If [code]true[/code], navigation regions are enabled. + + + Show or hide the [TileMapLayer]'s navigation meshes. If set to [constant DEBUG_VISIBILITY_MODE_DEFAULT], this depends on the show navigation debug settings. + + + The [TileMapLayer]'s quadrant size. A quadrant is a group of tiles to be drawn together on a single canvas item, for optimization purposes. [member rendering_quadrant_size] defines the length of a square's side, in the map's coordinate system, that forms the quadrant. Thus, the default quandrant size groups together [code]16 * 16 = 256[/code] tiles. + The quadrant size does not apply on a Y-sorted [TileMapLayer], as tiles are be grouped by Y position instead in that case. + [b]Note:[/b] As quadrants are created according to the map's coordinate system, the quadrant's "square shape" might not look like square in the [TileMapLayer]'s local coordinate system. + + + The raw tile map data as a byte array. + + + The [TileSet] used by this layer. The textures, collisions, and additional behavior of all available tiles are stored here. + + + If [code]true[/code], this [TileMapLayer] collision shapes will be instantiated as kinematic bodies. This can be needed for moving [TileMapLayer] nodes (i.e. moving platforms). + + + This Y-sort origin value is added to each tile's Y-sort origin value. This allows, for example, to fake a different height level. This can be useful for top-down view games. + + + + + + Emitted when this [TileMapLayer]'s properties changes. This includes modified cells, properties, or changes made to its assigned [TileSet]. + [b]Note:[/b] This signal may be emitted very often when batch-modifying a [TileMapLayer]. Avoid executing complex processing in a connected function, and consider delaying it to the end of the frame instead (i.e. calling [method Object.call_deferred]). + + + + + + Hide the collisions or navigation debug shapes in the editor, and use the debug settings to determine their visibility in game (i.e. [member SceneTree.debug_collisions_hint] or [member SceneTree.debug_navigation_hint]). + + + Always hide the collisions or navigation debug shapes. + + + Always show the collisions or navigation debug shapes. + + + diff --git a/doc/classes/TileMapLayerGroup.xml b/doc/classes/TileMapLayerGroup.xml deleted file mode 100644 index 3787d3bb17f9..000000000000 --- a/doc/classes/TileMapLayerGroup.xml +++ /dev/null @@ -1,17 +0,0 @@ - - - - Groups a set of tile map layers together, allowing them to share a provided [TileSet]. - - - Groups together tile map layers as part or the same map, replacing the [TileMap] node. Child layers will use this node's [member tile_set]. - The editor also uses [TileMapLayerGroup] as a way to store which layers are selected in a given group. This allows highlighting the currently selected layers. - - - - - - The assigned [TileSet]. This TileSet will be applied to all child layers. - - - diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp index edb6fee75c94..03e8f3ac8486 100644 --- a/editor/editor_node.cpp +++ b/editor/editor_node.cpp @@ -2506,8 +2506,8 @@ void EditorNode::_edit_current(bool p_skip_foreign, bool p_skip_inspector_update editable_info, info_is_warning); - Object *editor_owner = is_node ? (Object *)SceneTreeDock::get_singleton() : is_resource ? (Object *)InspectorDock::get_inspector_singleton() - : (Object *)this; + Object *editor_owner = (is_node || current_obj->is_class("MultiNodeEdit")) ? (Object *)SceneTreeDock::get_singleton() : is_resource ? (Object *)InspectorDock::get_inspector_singleton() + : (Object *)this; // Take care of the main editor plugin. diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp index ee33e171e3ec..89580b83b0b4 100644 --- a/editor/editor_settings.cpp +++ b/editor/editor_settings.cpp @@ -755,6 +755,7 @@ void EditorSettings::_load_defaults(Ref p_extra_config) { // Tiles editor _initial_set("editors/tiles_editor/display_grid", true); + _initial_set("editors/tiles_editor/highlight_selected_layer", true); _initial_set("editors/tiles_editor/grid_color", Color(1.0, 0.5, 0.2, 0.5)); // Polygon editor diff --git a/editor/icons/TileMapLayer.svg b/editor/icons/TileMapLayer.svg index 1903a87e3b3d..90664dee038b 100644 --- a/editor/icons/TileMapLayer.svg +++ b/editor/icons/TileMapLayer.svg @@ -1 +1 @@ - \ No newline at end of file + \ No newline at end of file diff --git a/editor/plugins/tiles/tile_map_layer_editor.cpp b/editor/plugins/tiles/tile_map_layer_editor.cpp index ccadc0643b4a..ac4708aa0668 100644 --- a/editor/plugins/tiles/tile_map_layer_editor.cpp +++ b/editor/plugins/tiles/tile_map_layer_editor.cpp @@ -36,9 +36,9 @@ #include "editor/editor_resource_preview.h" #include "editor/editor_settings.h" #include "editor/editor_undo_redo_manager.h" +#include "editor/multi_node_edit.h" #include "editor/plugins/canvas_item_editor_plugin.h" #include "editor/themes/editor_scale.h" - #include "scene/2d/camera_2d.h" #include "scene/2d/tile_map_layer.h" #include "scene/gui/center_container.h" @@ -107,7 +107,7 @@ void TileMapLayerEditorTilesPlugin::_update_transform_buttons() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null() || selection_pattern.is_null()) { return; } @@ -171,7 +171,7 @@ void TileMapLayerEditorTilesPlugin::_update_tile_set_sources_list() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -256,7 +256,7 @@ void TileMapLayerEditorTilesPlugin::_update_source_display() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -302,7 +302,7 @@ void TileMapLayerEditorTilesPlugin::_patterns_item_list_gui_input(const Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -348,7 +348,7 @@ void TileMapLayerEditorTilesPlugin::_update_patterns_list() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -380,7 +380,7 @@ void TileMapLayerEditorTilesPlugin::_update_atlas_view() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -401,7 +401,7 @@ void TileMapLayerEditorTilesPlugin::_update_scenes_collection_view() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -459,7 +459,7 @@ void TileMapLayerEditorTilesPlugin::_scenes_list_multi_selected(int p_index, boo return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -538,7 +538,7 @@ bool TileMapLayerEditorTilesPlugin::forward_canvas_gui_input(const Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return false; } @@ -784,7 +784,7 @@ void TileMapLayerEditorTilesPlugin::forward_canvas_draw_over_viewport(Control *p return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -1021,7 +1021,7 @@ TileMapCell TileMapLayerEditorTilesPlugin::_pick_random_tile(Ref return TileMapCell(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return TileMapCell(); } @@ -1073,7 +1073,7 @@ HashMap TileMapLayerEditorTilesPlugin::_draw_line(Vector2 return HashMap(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -1122,7 +1122,7 @@ HashMap TileMapLayerEditorTilesPlugin::_draw_rect(Vector2 return HashMap(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -1181,7 +1181,7 @@ HashMap TileMapLayerEditorTilesPlugin::_draw_bucket_fill( return HashMap(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -1293,7 +1293,7 @@ void TileMapLayerEditorTilesPlugin::_stop_dragging() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -1601,7 +1601,7 @@ void TileMapLayerEditorTilesPlugin::_update_fix_selected_and_hovered() { selection_pattern.instantiate(); return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { hovered_tile.source_id = TileSet::INVALID_SOURCE; hovered_tile.set_atlas_coords(TileSetSource::INVALID_ATLAS_COORDS); @@ -1688,7 +1688,7 @@ void TileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tilemap_selec return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -1709,7 +1709,7 @@ void TileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tileset_tiles return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -1783,7 +1783,7 @@ void TileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tileset_patte return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -1822,7 +1822,7 @@ void TileMapLayerEditorTilesPlugin::_tile_atlas_control_draw() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -1901,7 +1901,7 @@ void TileMapLayerEditorTilesPlugin::_tile_atlas_control_gui_input(const Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -2007,7 +2007,7 @@ void TileMapLayerEditorTilesPlugin::_tile_alternatives_control_draw() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -2059,7 +2059,7 @@ void TileMapLayerEditorTilesPlugin::_tile_alternatives_control_gui_input(const R return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -2157,16 +2157,21 @@ void TileMapLayerEditorTilesPlugin::edit(ObjectID p_tile_map_layer_id) { // Disable sort button if the tileset is read-only TileMapLayer *edited_layer = _get_edited_layer(); + Ref tile_set; if (edited_layer) { - Ref tile_set = edited_layer->get_effective_tile_set(); + tile_set = edited_layer->get_tile_set(); if (tile_set.is_valid()) { source_sort_button->set_disabled(EditorNode::get_singleton()->is_resource_read_only(tile_set)); } } - if (edited_tile_map_layer_id != p_tile_map_layer_id) { - edited_tile_map_layer_id = p_tile_map_layer_id; + TileMapLayer *new_tile_map_layer = Object::cast_to(ObjectDB::get_instance(edited_tile_map_layer_id)); + Ref new_tile_set; + if (new_tile_map_layer) { + new_tile_set = new_tile_map_layer->get_tile_set(); + } + if (tile_set.is_valid() && tile_set != new_tile_set) { // Clear the selection. tile_set_selection.clear(); patterns_item_list->deselect_all(); @@ -2531,7 +2536,7 @@ HashMap TileMapLayerEditorTerrainsPlugin::_draw_terrain_p return HashMap(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -2583,7 +2588,7 @@ HashMap TileMapLayerEditorTerrainsPlugin::_draw_terrain_p return HashMap(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -2630,7 +2635,7 @@ HashMap TileMapLayerEditorTerrainsPlugin::_draw_line(Vect return HashMap(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -2654,7 +2659,7 @@ HashMap TileMapLayerEditorTerrainsPlugin::_draw_rect(Vect return HashMap(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -2688,7 +2693,7 @@ RBSet TileMapLayerEditorTerrainsPlugin::_get_cells_for_bucket_fill(Vec return RBSet(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return RBSet(); } @@ -2799,7 +2804,7 @@ HashMap TileMapLayerEditorTerrainsPlugin::_draw_bucket_fi return HashMap(); } - const Ref &tile_set = edited_layer->get_effective_tile_set(); + const Ref &tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return HashMap(); } @@ -2827,7 +2832,7 @@ void TileMapLayerEditorTerrainsPlugin::_stop_dragging() { return; } - const Ref &tile_set = edited_layer->get_effective_tile_set(); + const Ref &tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -2961,7 +2966,7 @@ void TileMapLayerEditorTerrainsPlugin::_update_selection() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -3013,7 +3018,7 @@ bool TileMapLayerEditorTerrainsPlugin::forward_canvas_gui_input(const Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return false; } @@ -3150,7 +3155,7 @@ void TileMapLayerEditorTerrainsPlugin::forward_canvas_draw_over_viewport(Control return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -3275,7 +3280,7 @@ void TileMapLayerEditorTerrainsPlugin::_update_terrains_cache() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -3342,7 +3347,7 @@ void TileMapLayerEditorTerrainsPlugin::_update_terrains_tree() { const TileMapLayer *edited_layer = _get_edited_layer(); ERR_FAIL_NULL(edited_layer); - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -3389,7 +3394,7 @@ void TileMapLayerEditorTerrainsPlugin::_update_tiles_list() { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -3627,57 +3632,258 @@ TileMapLayer *TileMapLayerEditor::_get_edited_layer() const { return Object::cast_to(ObjectDB::get_instance(edited_tile_map_layer_id)); } +void TileMapLayerEditor::_find_tile_map_layers_in_scene(Node *p_current, const Node *p_owner, Vector &r_list) const { + ERR_FAIL_COND(!p_current || !p_owner); + if (p_current != p_owner && p_current->get_owner() != p_owner) { + return; + } + TileMapLayer *layer = Object::cast_to(p_current); + if (layer) { + r_list.append(layer); + } + for (int i = 0; i < p_current->get_child_count(); i++) { + Node *child = p_current->get_child(i); + _find_tile_map_layers_in_scene(child, p_owner, r_list); + } +} + +void TileMapLayerEditor::_update_tile_map_layers_in_scene_list_cache() { + if (!layers_in_scene_list_cache_needs_update) { + return; + } + EditorNode *en = EditorNode::get_singleton(); + Node *edited_scene_root = en->get_edited_scene(); + if (!edited_scene_root) { + return; + } + + tile_map_layers_in_scene_cache.clear(); + _find_tile_map_layers_in_scene(edited_scene_root, edited_scene_root, tile_map_layers_in_scene_cache); + layers_in_scene_list_cache_needs_update = false; +} + +void TileMapLayerEditor::_node_change(Node *p_node) { + if (!layers_in_scene_list_cache_needs_update && p_node->is_part_of_edited_scene() && Object::cast_to(p_node)) { + layers_in_scene_list_cache_needs_update = true; + } +} + void TileMapLayerEditor::_notification(int p_what) { switch (p_what) { + case NOTIFICATION_READY: { + get_tree()->connect("node_added", callable_mp(this, &TileMapLayerEditor::_node_change)); + get_tree()->connect("node_removed", callable_mp(this, &TileMapLayerEditor::_node_change)); + } break; case NOTIFICATION_THEME_CHANGED: { missing_tile_texture = get_editor_theme_icon(SNAME("StatusWarning")); warning_pattern_texture = get_editor_theme_icon(SNAME("WarningPattern")); advanced_menu_button->set_icon(get_editor_theme_icon(SNAME("Tools"))); + select_previous_layer->set_icon(get_editor_theme_icon(SNAME("MoveUp"))); + select_next_layer->set_icon(get_editor_theme_icon(SNAME("MoveDown"))); + select_all_layers->set_icon(get_editor_theme_icon(SNAME("FileList"))); toggle_grid_button->set_icon(get_editor_theme_icon(SNAME("Grid"))); - toggle_grid_button->set_pressed(EDITOR_GET("editors/tiles_editor/display_grid")); toggle_highlight_selected_layer_button->set_icon(get_editor_theme_icon(SNAME("TileMapHighlightSelected"))); } break; case NOTIFICATION_INTERNAL_PROCESS: { - if (is_visible_in_tree() && tileset_changed_needs_update) { + if (is_visible_in_tree() && tile_map_layer_changed_needs_update) { _update_bottom_panel(); - update_layers_selector(); - _update_highlighting_toggle(); + _update_layers_selector(); tabs_plugins[tabs_bar->get_current_tab()]->tile_set_changed(); CanvasItemEditor::get_singleton()->update_viewport(); - tileset_changed_needs_update = false; + tile_map_layer_changed_needs_update = false; } } break; case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: { if (EditorSettings::get_singleton()->check_changed_settings_in_group("editors/tiles_editor")) { toggle_grid_button->set_pressed_no_signal(EDITOR_GET("editors/tiles_editor/display_grid")); + toggle_highlight_selected_layer_button->set_pressed_no_signal(EDITOR_GET("editors/tiles_editor/highlight_selected_layer")); } } break; } } -void TileMapLayerEditor::_bind_methods() { - ADD_SIGNAL(MethodInfo("change_selected_layer_request", PropertyInfo(Variant::STRING_NAME, "layer_name"))); -} - void TileMapLayerEditor::_on_grid_toggled(bool p_pressed) { EditorSettings::get_singleton()->set("editors/tiles_editor/display_grid", p_pressed); CanvasItemEditor::get_singleton()->update_viewport(); } +void TileMapLayerEditor::_select_previous_layer_pressed() { + _layers_select_next_or_previous(false); +} + +void TileMapLayerEditor::_select_next_layer_pressed() { + _layers_select_next_or_previous(true); +} + +void TileMapLayerEditor::_select_all_layers_pressed() { + EditorNode *en = EditorNode::get_singleton(); + Node *edited_scene_root = en->get_edited_scene(); + ERR_FAIL_NULL(edited_scene_root); + + en->get_editor_selection()->clear(); + if (tile_map_layers_in_scene_cache.size() == 1) { + en->edit_node(tile_map_layers_in_scene_cache[0]); + en->get_editor_selection()->add_node(tile_map_layers_in_scene_cache[0]); + } else { + _update_tile_map_layers_in_scene_list_cache(); + Ref multi_node_edit = memnew(MultiNodeEdit); + for (TileMapLayer *layer : tile_map_layers_in_scene_cache) { + multi_node_edit->add_node(edited_scene_root->get_path_to(layer)); + en->get_editor_selection()->add_node(layer); + } + en->push_item(multi_node_edit.ptr()); + } +} + void TileMapLayerEditor::_layers_selection_item_selected(int p_index) { - emit_signal("change_selected_layer_request", layers_selection_button->get_item_metadata(p_index)); + TileMapLayer *edited_layer = _get_edited_layer(); + ERR_FAIL_NULL(edited_layer); + + TileMap *tile_map = Object::cast_to(edited_layer->get_parent()); + ERR_FAIL_NULL(tile_map); + + TileMapLayer *new_edited = Object::cast_to(tile_map->get_child(p_index)); + edit(new_edited); +} + +void TileMapLayerEditor::_update_layers_selector() { + const TileMapLayer *edited_layer = _get_edited_layer(); + + // Update the selector. + layers_selection_button->clear(); + layers_selection_button->hide(); + select_all_layers->show(); + select_next_layer->set_disabled(false); + select_previous_layer->set_disabled(false); + advanced_menu_button->get_popup()->set_item_disabled(ADVANCED_MENU_EXTRACT_TILE_MAP_LAYERS, true); + if (edited_layer) { + TileMap *tile_map = Object::cast_to(edited_layer->get_parent()); + if (tile_map && edited_layer->get_index_in_tile_map() >= 0) { + // Build the list of layers. + for (int i = 0; i < tile_map->get_layers_count(); i++) { + const TileMapLayer *layer = Object::cast_to(tile_map->get_child(i)); + if (layer) { + int index = layers_selection_button->get_item_count(); + layers_selection_button->add_item(layer->get_name()); + layers_selection_button->set_item_metadata(index, layer->get_name()); + if (edited_layer == layer) { + layers_selection_button->select(index); + } + } + } + + // Disable selector if there's no layer to select. + layers_selection_button->set_disabled(false); + if (layers_selection_button->get_item_count() == 0) { + layers_selection_button->set_disabled(true); + layers_selection_button->set_text(TTR("No Layers")); + } + + // Disable next/previous if there's one or less layers. + if (layers_selection_button->get_item_count() <= 1) { + select_next_layer->set_disabled(true); + select_previous_layer->set_disabled(true); + } + layers_selection_button->show(); + select_all_layers->hide(); + + // Enable the "extract as TileMapLayer" option only if we are editing a TleMap. + advanced_menu_button->get_popup()->set_item_disabled(ADVANCED_MENU_EXTRACT_TILE_MAP_LAYERS, false); + } + } else { + select_all_layers->hide(); + select_next_layer->set_disabled(true); + select_previous_layer->set_disabled(true); + } +} + +void TileMapLayerEditor::_clear_all_layers_highlighting() { + // Note: This function might be removed if we remove the TileMap node at some point. + // All processing could be done in _update_all_layers_highlighting otherwise. + TileMapLayer *edited_layer = _get_edited_layer(); + + // Use default mode. + if (edited_layer && edited_layer->get_index_in_tile_map() >= 0) { + // For the TileMap node. + TileMap *tile_map = Object::cast_to(edited_layer->get_parent()); + if (tile_map) { + for (int i = 0; i < tile_map->get_layers_count(); i++) { + TileMapLayer *layer = Object::cast_to(tile_map->get_child(i)); + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_DEFAULT); + } + } + } else { + // For other TileMapLayer nodes. + _update_tile_map_layers_in_scene_list_cache(); + for (TileMapLayer *layer : tile_map_layers_in_scene_cache) { + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_DEFAULT); + } + } +} + +void TileMapLayerEditor::_update_all_layers_highlighting() { + EditorNode *en = EditorNode::get_singleton(); + Node *edited_scene_root = en->get_edited_scene(); + if (!edited_scene_root) { + return; + } + + // Get selected layer. + TileMapLayer *edited_layer = _get_edited_layer(); + + bool highlight_selected_layer = EDITOR_GET("editors/tiles_editor/highlight_selected_layer"); + if (edited_layer && highlight_selected_layer) { + int edited_z_index = edited_layer->get_z_index(); + + if (edited_layer->get_index_in_tile_map() >= 0) { + // For the TileMap node. + TileMap *tile_map = Object::cast_to(edited_layer->get_parent()); + ERR_FAIL_NULL(tile_map); + + bool passed = false; + for (int i = 0; i < tile_map->get_layers_count(); i++) { + TileMapLayer *layer = Object::cast_to(tile_map->get_child(i)); + if (layer == edited_layer) { + passed = true; + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_DEFAULT); + } else { + if (passed || layer->get_z_index() > edited_z_index) { + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_ABOVE); + } else { + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_BELOW); + } + } + } + } else { + // Update highlight mode for independent layers. + _update_tile_map_layers_in_scene_list_cache(); + bool passed = false; + for (TileMapLayer *layer : tile_map_layers_in_scene_cache) { + if (layer == edited_layer) { + passed = true; + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_DEFAULT); + } else { + if (passed || layer->get_z_index() > edited_z_index) { + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_ABOVE); + } else { + layer->set_highlight_mode(TileMapLayer::HIGHLIGHT_MODE_BELOW); + } + } + } + } + } } void TileMapLayerEditor::_highlight_selected_layer_button_toggled(bool p_pressed) { TileMapLayer *edited_layer = _get_edited_layer(); - ERR_FAIL_NULL(edited_layer); + if (!edited_layer) { + return; + } - TileMapLayerGroup *tile_map_layer_group = Object::cast_to(edited_layer->get_parent()); - ERR_FAIL_NULL(tile_map_layer_group); - - tile_map_layer_group->set_highlight_selected_layer(p_pressed); + EditorSettings::get_singleton()->set("editors/tiles_editor/highlight_selected_layer", p_pressed); + _update_all_layers_highlighting(); } void TileMapLayerEditor::_advanced_menu_button_id_pressed(int p_id) { @@ -3686,12 +3892,12 @@ void TileMapLayerEditor::_advanced_menu_button_id_pressed(int p_id) { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } - if (p_id == 0) { // Replace Tile Proxies + if (p_id == ADVANCED_MENU_REPLACE_WITH_PROXIES) { // Replace Tile Proxies EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton(); undo_redo->create_action(TTR("Replace Tiles with Proxies")); TypedArray used_cells = edited_layer->get_used_cells(); @@ -3709,32 +3915,75 @@ void TileMapLayerEditor::_advanced_menu_button_id_pressed(int p_id) { } } + undo_redo->commit_action(); + } else if (p_id == ADVANCED_MENU_EXTRACT_TILE_MAP_LAYERS) { // Transform internal TileMap layers into TileMapLayers. + ERR_FAIL_COND(edited_layer->get_index_in_tile_map() < 0); + + EditorNode *en = EditorNode::get_singleton(); + Node *edited_scene_root = en->get_edited_scene(); + ERR_FAIL_NULL(edited_scene_root); + + EditorUndoRedoManager *undo_redo = EditorUndoRedoManager::get_singleton(); + undo_redo->create_action(TTR("Extract TileMap layers as individual TileMapLayer nodes")); + + TileMap *tile_map = Object::cast_to(edited_layer->get_parent()); + for (int i = 0; i < tile_map->get_layers_count(); i++) { + undo_redo->add_do_method(tile_map, "remove_layer", 0); + } + + for (int i = 0; i < tile_map->get_layers_count(); i++) { + TileMapLayer *new_layer = tile_map->duplicate_layer_from_internal(i); + undo_redo->add_do_method(tile_map, "add_child", new_layer); + undo_redo->add_do_method(new_layer, "set_owner", edited_scene_root); + undo_redo->add_do_property(new_layer, "tile_set", tile_map->get_tileset()); // Workaround for a bug: #89947. + undo_redo->add_undo_method(tile_map, "remove_child", new_layer); + undo_redo->add_do_reference(new_layer); + } + + List prop_list; + tile_map->get_property_list(&prop_list); + for (PropertyInfo &prop : prop_list) { + undo_redo->add_undo_property(tile_map, prop.name, tile_map->get(prop.name)); + } undo_redo->commit_action(); } } void TileMapLayerEditor::_update_bottom_panel() { const TileMapLayer *edited_layer = _get_edited_layer(); - if (!edited_layer) { - return; + Ref tile_set; + if (edited_layer) { + tile_set = edited_layer->get_tile_set(); } - Ref tile_set = edited_layer->get_effective_tile_set(); + // Update state labels. + if (is_multi_node_edit) { + cant_edit_label->set_text(TTR("Can't edit multiple layers at once.")); + cant_edit_label->show(); + } else if (!edited_layer) { + cant_edit_label->set_text(TTR("The selected TileMap has no layer to edit.")); + cant_edit_label->show(); + } else if (!edited_layer->is_enabled() || !edited_layer->is_visible_in_tree()) { + cant_edit_label->set_text(TTR("The edited layer is disabled or invisible")); + cant_edit_label->show(); + } else if (tile_set.is_null()) { + cant_edit_label->set_text(TTR("The edited TileMap or TileMapLayer node has no TileSet resource.\nCreate or load a TileSet resource in the Tile Set property in the inspector.")); + cant_edit_label->show(); + } else { + cant_edit_label->hide(); + } - // Update the visibility of controls. - missing_tileset_label->set_visible(tile_set.is_null()); + // Update tabs visibility. for (TileMapLayerSubEditorPlugin::TabData &tab_data : tabs_data) { tab_data.panel->hide(); } - if (tile_set.is_valid()) { - tabs_data[tabs_bar->get_current_tab()].panel->show(); - } + tabs_data[tabs_bar->get_current_tab()].panel->set_visible(!cant_edit_label->is_visible()); } Vector TileMapLayerEditor::get_line(const TileMapLayer *p_tile_map_layer, Vector2i p_from_cell, Vector2i p_to_cell) { ERR_FAIL_NULL_V(p_tile_map_layer, Vector()); - Ref tile_set = p_tile_map_layer->get_effective_tile_set(); + Ref tile_set = p_tile_map_layer->get_tile_set(); ERR_FAIL_COND_V(tile_set.is_null(), Vector()); if (tile_set->get_tile_shape() == TileSet::TILE_SHAPE_SQUARE) { @@ -3805,7 +4054,7 @@ Vector TileMapLayerEditor::get_line(const TileMapLayer *p_tile_map_lay } void TileMapLayerEditor::_tile_map_layer_changed() { - tileset_changed_needs_update = true; + tile_map_layer_changed_needs_update = true; } void TileMapLayerEditor::_tab_changed(int p_tab_id) { @@ -3825,7 +4074,7 @@ void TileMapLayerEditor::_tab_changed(int p_tab_id) { TileMapLayer *tile_map_layer = _get_edited_layer(); if (tile_map_layer) { - if (tile_map_layer->get_effective_tile_set().is_valid()) { + if (tile_map_layer->get_tile_set().is_valid()) { tabs_data[tabs_bar->get_current_tab()].panel->show(); } } @@ -3841,36 +4090,38 @@ void TileMapLayerEditor::_layers_select_next_or_previous(bool p_next) { return; } - TileMapLayerGroup *tile_map_layer_group = Object::cast_to(edited_layer->get_parent()); - if (!tile_map_layer_group) { - return; - } + EditorNode *en = EditorNode::get_singleton(); + Node *edited_scene_root = en->get_edited_scene(); + ERR_FAIL_NULL(edited_scene_root); + TileMapLayer *new_selected_layer = nullptr; int inc = p_next ? 1 : -1; - int index = Math::posmod(edited_layer->get_index() + inc, tile_map_layer_group->get_child_count()); - const TileMapLayer *new_selected_layer = Object::cast_to(tile_map_layer_group->get_child(index)); - while (new_selected_layer != edited_layer) { - if (new_selected_layer && new_selected_layer->is_enabled()) { - break; + if (edited_layer->get_index_in_tile_map() >= 0) { + // Part of a TileMap. + TileMap *tile_map = Object::cast_to(edited_layer->get_parent()); + new_selected_layer = Object::cast_to(tile_map->get_child(Math::posmod(edited_layer->get_index_in_tile_map() + inc, tile_map->get_layers_count()))); + } else { + // Individual layer. + _update_tile_map_layers_in_scene_list_cache(); + int edited_index = -1; + for (int i = 0; i < tile_map_layers_in_scene_cache.size(); i++) { + if (tile_map_layers_in_scene_cache[i] == edited_layer) { + edited_index = i; + break; + } } - index = Math::posmod((index + inc), tile_map_layer_group->get_child_count()); - new_selected_layer = Object::cast_to(tile_map_layer_group->get_child(index)); + new_selected_layer = tile_map_layers_in_scene_cache[Math::posmod(edited_index + inc, tile_map_layers_in_scene_cache.size())]; } - if (new_selected_layer != edited_layer) { - emit_signal("change_selected_layer_request", new_selected_layer->get_name()); - } -} + ERR_FAIL_NULL(new_selected_layer); -void TileMapLayerEditor::_update_highlighting_toggle() { - const TileMapLayer *edited_layer = _get_edited_layer(); - if (!edited_layer) { - return; - } - - TileMapLayerGroup *tile_map_layer_group = Object::cast_to(edited_layer->get_parent()); - if (tile_map_layer_group) { - toggle_highlight_selected_layer_button->set_pressed(tile_map_layer_group->is_highlighting_selected_layer()); + if (edited_layer->get_index_in_tile_map() < 0) { + // Only if not part of a TileMap. + en->edit_node(new_selected_layer); + en->get_editor_selection()->clear(); + en->get_editor_selection()->add_node(new_selected_layer); + } else { + edit(new_selected_layer); } } @@ -3966,7 +4217,7 @@ void TileMapLayerEditor::forward_canvas_draw_over_viewport(Control *p_overlay) { return; } - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_null()) { return; } @@ -3994,29 +4245,25 @@ void TileMapLayerEditor::forward_canvas_draw_over_viewport(Control *p_overlay) { } if (!source || !source->has_tile(tile_atlas_coords) || !source->has_alternative_tile(tile_atlas_coords, tile_alternative_tile)) { - // Generate a random color from the hashed values of the tiles. - Array a = tile_set->map_tile_proxy(tile_source_id, tile_atlas_coords, tile_alternative_tile); - if (int(a[0]) == tile_source_id && Vector2i(a[1]) == tile_atlas_coords && int(a[2]) == tile_alternative_tile) { - // Only display the pattern if we have no proxy tile. - Array to_hash; - to_hash.push_back(tile_source_id); - to_hash.push_back(tile_atlas_coords); - to_hash.push_back(tile_alternative_tile); - uint32_t hash = RandomPCG(to_hash.hash()).rand(); + // Generate a random color from the hashed identifier of the tiles. + Array to_hash; + to_hash.push_back(tile_source_id); + to_hash.push_back(tile_atlas_coords); + to_hash.push_back(tile_alternative_tile); + uint32_t hash = RandomPCG(to_hash.hash()).rand(); - Color color; - color = color.from_hsv( - (float)((hash >> 24) & 0xFF) / 256.0, - Math::lerp(0.5, 1.0, (float)((hash >> 16) & 0xFF) / 256.0), - Math::lerp(0.5, 1.0, (float)((hash >> 8) & 0xFF) / 256.0), - 0.8); + Color color; + color = color.from_hsv( + (float)((hash >> 24) & 0xFF) / 256.0, + Math::lerp(0.5, 1.0, (float)((hash >> 16) & 0xFF) / 256.0), + Math::lerp(0.5, 1.0, (float)((hash >> 8) & 0xFF) / 256.0), + 0.8); - // Draw the scaled tile. - Transform2D tile_xform; - tile_xform.set_origin(tile_set->map_to_local(coords)); - tile_xform.set_scale(tile_shape_size); - tile_set->draw_tile_shape(p_overlay, xform * tile_xform, color, true, warning_pattern_texture); - } + // Display the warning pattern. + Transform2D tile_xform; + tile_xform.set_origin(tile_set->map_to_local(coords)); + tile_xform.set_scale(tile_shape_size); + tile_set->draw_tile_shape(p_overlay, xform * tile_xform, color, true, warning_pattern_texture); // Draw the warning icon. Vector2::Axis min_axis = missing_tile_texture->get_size().min_axis_index(); @@ -4092,75 +4339,50 @@ void TileMapLayerEditor::forward_canvas_draw_over_viewport(Control *p_overlay) { tabs_plugins[tabs_bar->get_current_tab()]->forward_canvas_draw_over_viewport(p_overlay); } -void TileMapLayerEditor::edit(TileMapLayer *p_tile_map_layer) { - if (p_tile_map_layer && p_tile_map_layer->get_instance_id() == edited_tile_map_layer_id) { +void TileMapLayerEditor::edit(Object *p_edited) { + if (p_edited && p_edited->get_instance_id() == edited_tile_map_layer_id) { return; } + _clear_all_layers_highlighting(); + // Disconnect to changes. TileMapLayer *tile_map_layer = _get_edited_layer(); if (tile_map_layer) { tile_map_layer->disconnect("changed", callable_mp(this, &TileMapLayerEditor::_tile_map_layer_changed)); + tile_map_layer->disconnect("visibility_changed", callable_mp(this, &TileMapLayerEditor::_tile_map_layer_changed)); } // Update the edited layer. - if (p_tile_map_layer) { + TileMapLayer *new_layer = Object::cast_to(p_edited); + if (new_layer) { // Change the edited object. - edited_tile_map_layer_id = p_tile_map_layer->get_instance_id(); + edited_tile_map_layer_id = new_layer->get_instance_id(); tile_map_layer = _get_edited_layer(); // Connect to changes. if (!tile_map_layer->is_connected("changed", callable_mp(this, &TileMapLayerEditor::_tile_map_layer_changed))) { tile_map_layer->connect("changed", callable_mp(this, &TileMapLayerEditor::_tile_map_layer_changed)); + tile_map_layer->connect("visibility_changed", callable_mp(this, &TileMapLayerEditor::_tile_map_layer_changed)); } } else { edited_tile_map_layer_id = ObjectID(); } - update_layers_selector(); - _update_highlighting_toggle(); + // Check if we are trying to use a MultiNodeEdit. + is_multi_node_edit = Object::cast_to(p_edited); - // Call the plugins. + // Call the plugins and update everything. tabs_plugins[tabs_bar->get_current_tab()]->edit(edited_tile_map_layer_id); + _update_layers_selector(); + _update_all_layers_highlighting(); _tile_map_layer_changed(); } -void TileMapLayerEditor::update_layers_selector() { - const TileMapLayer *edited_layer = _get_edited_layer(); - if (!edited_layer) { - return; - } - - TileMapLayerGroup *tile_map_layer_group = Object::cast_to(edited_layer->get_parent()); - if (tile_map_layer_group) { - // Update the selector - layers_selection_button->show(); - layers_selection_button->clear(); - - // Build the list of layers. - for (int i = 0; i < tile_map_layer_group->get_child_count(); i++) { - const TileMapLayer *layer = Object::cast_to(tile_map_layer_group->get_child(i)); - if (layer) { - int index = layers_selection_button->get_item_count(); - layers_selection_button->add_item(layer->get_name()); - layers_selection_button->set_item_disabled(index, !layer->is_enabled()); - layers_selection_button->set_item_metadata(index, layer->get_name()); - if (edited_layer == layer) { - layers_selection_button->select(index); - } - } - } - - // Disable the button if there's no layer to select. - layers_selection_button->set_disabled(false); - if (layers_selection_button->get_item_count() == 0) { - layers_selection_button->set_disabled(true); - layers_selection_button->set_text(TTR("No Layers")); - } - } else { - layers_selection_button->hide(); - } +void TileMapLayerEditor::set_show_layer_selector(bool p_show_layer_selector) { + show_layers_selector = p_show_layer_selector; + _update_layers_selector(); } TileMapLayerEditor::TileMapLayerEditor() { @@ -4210,13 +4432,36 @@ TileMapLayerEditor::TileMapLayerEditor() { tile_map_toolbar->add_child(c); // Layer selector. + layer_selection_hbox = memnew(HBoxContainer); + tile_map_toolbar->add_child(layer_selection_hbox); + layers_selection_button = memnew(OptionButton); layers_selection_button->set_custom_minimum_size(Size2(200, 0)); layers_selection_button->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_ELLIPSIS); layers_selection_button->set_tooltip_text(TTR("TileMap Layers")); layers_selection_button->connect("item_selected", callable_mp(this, &TileMapLayerEditor::_layers_selection_item_selected)); - tile_map_toolbar->add_child(layers_selection_button); + layer_selection_hbox->add_child(layers_selection_button); + select_previous_layer = memnew(Button); + select_previous_layer->set_theme_type_variation("FlatButton"); + select_previous_layer->set_tooltip_text(TTR("Select previous layer")); + select_previous_layer->connect("pressed", callable_mp(this, &TileMapLayerEditor::_select_previous_layer_pressed)); + layer_selection_hbox->add_child(select_previous_layer); + + select_next_layer = memnew(Button); + select_next_layer->set_theme_type_variation("FlatButton"); + select_next_layer->set_tooltip_text(TTR("Select next layer")); + select_next_layer->connect("pressed", callable_mp(this, &TileMapLayerEditor::_select_next_layer_pressed)); + layer_selection_hbox->add_child(select_next_layer); + + select_all_layers = memnew(Button); + select_all_layers->set_theme_type_variation("FlatButton"); + select_all_layers->set_text(TTR("Select all layers")); + select_all_layers->connect("pressed", callable_mp(this, &TileMapLayerEditor::_select_all_layers_pressed)); + select_all_layers->set_tooltip_text(TTR("Select all TileMapLayers in scene")); + layer_selection_hbox->add_child(select_all_layers); + + // Highlighting selected layer. toggle_highlight_selected_layer_button = memnew(Button); toggle_highlight_selected_layer_button->set_theme_type_variation("FlatButton"); toggle_highlight_selected_layer_button->set_toggle_mode(true); @@ -4239,18 +4484,19 @@ TileMapLayerEditor::TileMapLayerEditor() { advanced_menu_button = memnew(MenuButton); advanced_menu_button->set_flat(false); advanced_menu_button->set_theme_type_variation("FlatButton"); - advanced_menu_button->get_popup()->add_item(TTR("Automatically Replace Tiles with Proxies")); + advanced_menu_button->get_popup()->add_item(TTR("Automatically Replace Tiles with Proxies"), ADVANCED_MENU_REPLACE_WITH_PROXIES); + advanced_menu_button->get_popup()->add_item(TTR("Extract TileMap layers as individual TileMapLayer nodes"), ADVANCED_MENU_EXTRACT_TILE_MAP_LAYERS); advanced_menu_button->get_popup()->connect("id_pressed", callable_mp(this, &TileMapLayerEditor::_advanced_menu_button_id_pressed)); tile_map_toolbar->add_child(advanced_menu_button); - missing_tileset_label = memnew(Label); - missing_tileset_label->set_text(TTR("The edited TileMap node has no TileSet resource.\nCreate or load a TileSet resource in the Tile Set property in the inspector.")); - missing_tileset_label->set_h_size_flags(SIZE_EXPAND_FILL); - missing_tileset_label->set_v_size_flags(SIZE_EXPAND_FILL); - missing_tileset_label->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER); - missing_tileset_label->set_vertical_alignment(VERTICAL_ALIGNMENT_CENTER); - missing_tileset_label->hide(); - add_child(missing_tileset_label); + // A label for editing errors. + cant_edit_label = memnew(Label); + cant_edit_label->set_h_size_flags(SIZE_EXPAND_FILL); + cant_edit_label->set_v_size_flags(SIZE_EXPAND_FILL); + cant_edit_label->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER); + cant_edit_label->set_vertical_alignment(VERTICAL_ALIGNMENT_CENTER); + cant_edit_label->hide(); + add_child(cant_edit_label); for (unsigned int tab_index = 0; tab_index < tabs_data.size(); tab_index++) { add_child(tabs_data[tab_index].panel); diff --git a/editor/plugins/tiles/tile_map_layer_editor.h b/editor/plugins/tiles/tile_map_layer_editor.h index a7fea2abcfe1..26032614495e 100644 --- a/editor/plugins/tiles/tile_map_layer_editor.h +++ b/editor/plugins/tiles/tile_map_layer_editor.h @@ -339,10 +339,16 @@ class TileMapLayerEditor : public VBoxContainer { GDCLASS(TileMapLayerEditor, VBoxContainer); private: - bool tileset_changed_needs_update = false; + bool tile_map_layer_changed_needs_update = false; ObjectID edited_tile_map_layer_id; + bool is_multi_node_edit = false; + Vector tile_map_layers_in_scene_cache; + bool layers_in_scene_list_cache_needs_update = false; TileMapLayer *_get_edited_layer() const; + void _find_tile_map_layers_in_scene(Node *p_current, const Node *p_owner, Vector &r_list) const; + void _update_tile_map_layers_in_scene_list_cache(); + void _node_change(Node *p_node); // Vector to keep plugins. Vector tile_map_editor_plugins; @@ -350,20 +356,36 @@ private: // Toolbar. HFlowContainer *tile_map_toolbar = nullptr; + bool show_layers_selector = false; + + HBoxContainer *layer_selection_hbox = nullptr; + Button *select_previous_layer = nullptr; + void _select_previous_layer_pressed(); + Button *select_next_layer = nullptr; + void _select_next_layer_pressed(); + Button *select_all_layers = nullptr; + void _select_all_layers_pressed(); OptionButton *layers_selection_button = nullptr; void _layers_selection_item_selected(int p_index); + void _update_layers_selector(); Button *toggle_highlight_selected_layer_button = nullptr; + void _clear_all_layers_highlighting(); + void _update_all_layers_highlighting(); void _highlight_selected_layer_button_toggled(bool p_pressed); Button *toggle_grid_button = nullptr; void _on_grid_toggled(bool p_pressed); + enum { + ADVANCED_MENU_REPLACE_WITH_PROXIES, + ADVANCED_MENU_EXTRACT_TILE_MAP_LAYERS, + }; MenuButton *advanced_menu_button = nullptr; void _advanced_menu_button_id_pressed(int p_id); // Bottom panel. - Label *missing_tileset_label = nullptr; + Label *cant_edit_label = nullptr; TabBar *tabs_bar = nullptr; LocalVector tabs_data; LocalVector tabs_plugins; @@ -379,22 +401,20 @@ private: // Updates. void _layers_select_next_or_previous(bool p_next); - void _update_highlighting_toggle(); // Inspector undo/redo callback. void _move_tile_map_array_element(Object *p_undo_redo, Object *p_edited, const String &p_array_prefix, int p_from_index, int p_to_pos); protected: void _notification(int p_what); - static void _bind_methods(); void _draw_shape(Control *p_control, Rect2 p_region, TileSet::TileShape p_shape, TileSet::TileOffsetAxis p_offset_axis, Color p_color); public: bool forward_canvas_gui_input(const Ref &p_event); void forward_canvas_draw_over_viewport(Control *p_overlay); - void edit(TileMapLayer *p_tile_map_layer); - void update_layers_selector(); + void edit(Object *p_tile_map_layer); + void set_show_layer_selector(bool p_show_layer_selector); TileMapLayerEditor(); ~TileMapLayerEditor(); diff --git a/editor/plugins/tiles/tiles_editor_plugin.cpp b/editor/plugins/tiles/tiles_editor_plugin.cpp index ed21a2948791..c3141beb1a33 100644 --- a/editor/plugins/tiles/tiles_editor_plugin.cpp +++ b/editor/plugins/tiles/tiles_editor_plugin.cpp @@ -40,6 +40,7 @@ #include "editor/editor_settings.h" #include "editor/editor_string_names.h" #include "editor/gui/editor_bottom_panel.h" +#include "editor/multi_node_edit.h" #include "editor/plugins/canvas_item_editor_plugin.h" #include "editor/themes/editor_scale.h" #include "scene/2d/tile_map.h" @@ -336,7 +337,7 @@ void TileMapEditorPlugin::_tile_map_layer_removed() { void TileMapEditorPlugin::_update_tile_map() { TileMapLayer *edited_layer = Object::cast_to(ObjectDB::get_instance(tile_map_layer_id)); if (edited_layer) { - Ref tile_set = edited_layer->get_effective_tile_set(); + Ref tile_set = edited_layer->get_tile_set(); if (tile_set.is_valid() && tile_set_id != tile_set->get_instance_id()) { tile_set_plugin_singleton->edit(tile_set.ptr()); tile_set_plugin_singleton->make_visible(true); @@ -355,38 +356,25 @@ void TileMapEditorPlugin::_select_layer(const StringName &p_name) { ERR_FAIL_NULL(edited_layer); Node *parent = edited_layer->get_parent(); - ERR_FAIL_NULL(parent); - - TileMapLayer *new_layer = Object::cast_to(parent->get_node_or_null(String(p_name))); - edit(new_layer); + if (parent) { + TileMapLayer *new_layer = Object::cast_to(parent->get_node_or_null(String(p_name))); + edit(new_layer); + } } -void TileMapEditorPlugin::_edit_tile_map_layer(TileMapLayer *p_tile_map_layer) { +void TileMapEditorPlugin::_edit_tile_map_layer(TileMapLayer *p_tile_map_layer, bool p_show_layer_selector) { ERR_FAIL_NULL(p_tile_map_layer); editor->edit(p_tile_map_layer); - - // Update the selected layers in the TileMapLayerGroup parent node. - TileMapLayerGroup *tile_map_layer_group = Object::cast_to(p_tile_map_layer->get_parent()); - if (tile_map_layer_group) { - Vector selected; - selected.push_back(p_tile_map_layer->get_name()); - tile_map_layer_group->set_selected_layers(selected); - } + editor->set_show_layer_selector(p_show_layer_selector); // Update the object IDs. tile_map_layer_id = p_tile_map_layer->get_instance_id(); p_tile_map_layer->connect("changed", callable_mp(this, &TileMapEditorPlugin::_tile_map_layer_changed)); p_tile_map_layer->connect("tree_exited", callable_mp(this, &TileMapEditorPlugin::_tile_map_layer_removed)); - if (tile_map_layer_group) { - tile_map_group_id = tile_map_layer_group->get_instance_id(); - tile_map_layer_group->connect("child_entered_tree", callable_mp(editor, &TileMapLayerEditor::update_layers_selector).unbind(1)); - tile_map_layer_group->connect("child_exiting_tree", callable_mp(editor, &TileMapLayerEditor::update_layers_selector).unbind(1)); - tile_map_layer_group->connect("child_order_changed", callable_mp(editor, &TileMapLayerEditor::update_layers_selector)); - } // Update the edited tileset. - Ref tile_set = p_tile_map_layer->get_effective_tile_set(); + Ref tile_set = p_tile_map_layer->get_tile_set(); if (tile_set.is_valid()) { tile_set_plugin_singleton->edit(tile_set.ptr()); tile_set_plugin_singleton->make_visible(true); @@ -397,30 +385,15 @@ void TileMapEditorPlugin::_edit_tile_map_layer(TileMapLayer *p_tile_map_layer) { } } -void TileMapEditorPlugin::_edit_tile_map_layer_group(TileMapLayerGroup *p_tile_map_layer_group) { - ERR_FAIL_NULL(p_tile_map_layer_group); +void TileMapEditorPlugin::_edit_tile_map(TileMap *p_tile_map) { + ERR_FAIL_NULL(p_tile_map); - Vector selected_layers = p_tile_map_layer_group->get_selected_layers(); - - TileMapLayer *selected_layer = nullptr; - if (selected_layers.size() > 0) { - // Edit the selected layer. - selected_layer = Object::cast_to(p_tile_map_layer_group->get_node_or_null(String(selected_layers[0]))); - } - if (!selected_layer) { - // Edit the first layer found. - for (int i = 0; i < p_tile_map_layer_group->get_child_count(); i++) { - selected_layer = Object::cast_to(p_tile_map_layer_group->get_child(i)); - if (selected_layer) { - break; - } - } - } - - if (selected_layer) { - _edit_tile_map_layer(selected_layer); + if (p_tile_map->get_layers_count() > 0) { + TileMapLayer *selected_layer = Object::cast_to(p_tile_map->get_child(0)); + _edit_tile_map_layer(selected_layer, true); } else { editor->edit(nullptr); + editor->set_show_layer_selector(false); } } @@ -437,36 +410,38 @@ void TileMapEditorPlugin::edit(Object *p_object) { edited_layer->disconnect("tree_exited", callable_mp(this, &TileMapEditorPlugin::_tile_map_layer_removed)); } - TileMapLayerGroup *tile_map_group = Object::cast_to(ObjectDB::get_instance(tile_map_group_id)); - if (tile_map_group) { - tile_map_group->disconnect("child_entered_tree", callable_mp(editor, &TileMapLayerEditor::update_layers_selector).unbind(1)); - tile_map_group->disconnect("child_exiting_tree", callable_mp(editor, &TileMapLayerEditor::update_layers_selector).unbind(1)); - tile_map_group->disconnect("child_order_changed", callable_mp(editor, &TileMapLayerEditor::update_layers_selector)); - } - tile_map_group_id = ObjectID(); tile_map_layer_id = ObjectID(); tile_set_id = ObjectID(); - TileMapLayerGroup *tile_map_layer_group = Object::cast_to(p_object); + TileMap *tile_map = Object::cast_to(p_object); TileMapLayer *tile_map_layer = Object::cast_to(p_object); - if (tile_map_layer_group) { - _edit_tile_map_layer_group(tile_map_layer_group); + MultiNodeEdit *multi_node_edit = Object::cast_to(p_object); + if (tile_map) { + _edit_tile_map(tile_map); } else if (tile_map_layer) { - _edit_tile_map_layer(tile_map_layer); + _edit_tile_map_layer(tile_map_layer, false); + } else if (multi_node_edit) { + editor->edit(multi_node_edit); } else { - // Deselect the layer in the group. - if (edited_layer) { - tile_map_layer_group = Object::cast_to(edited_layer->get_parent()); - if (tile_map_layer_group) { - tile_map_layer_group->set_selected_layers(Vector()); - } - } + editor->edit(nullptr); } } bool TileMapEditorPlugin::handles(Object *p_object) const { - return Object::cast_to(p_object) != nullptr || Object::cast_to(p_object) != nullptr; + MultiNodeEdit *multi_node_edit = Object::cast_to(p_object); + Node *edited_scene = EditorNode::get_singleton()->get_edited_scene(); + if (multi_node_edit && edited_scene) { + bool only_tile_map_layers = true; + for (int i = 0; i < multi_node_edit->get_node_count(); i++) { + if (!Object::cast_to(edited_scene->get_node(multi_node_edit->get_node(i)))) { + only_tile_map_layers = false; + break; + } + } + return only_tile_map_layers; + } + return Object::cast_to(p_object) != nullptr || Object::cast_to(p_object) != nullptr; } void TileMapEditorPlugin::make_visible(bool p_visible) { @@ -509,7 +484,6 @@ TileMapEditorPlugin::TileMapEditorPlugin() { editor->set_h_size_flags(Control::SIZE_EXPAND_FILL); editor->set_v_size_flags(Control::SIZE_EXPAND_FILL); editor->set_custom_minimum_size(Size2(0, 200) * EDSCALE); - editor->connect("change_selected_layer_request", callable_mp(this, &TileMapEditorPlugin::_select_layer)); editor->hide(); button = EditorNode::get_bottom_panel()->add_item(TTR("TileMap"), editor, ED_SHORTCUT_AND_COMMAND("bottom_panels/toggle_tile_map_bottom_panel", TTR("Toggle TileMap Bottom Panel"))); diff --git a/editor/plugins/tiles/tiles_editor_plugin.h b/editor/plugins/tiles/tiles_editor_plugin.h index ac3e8986d6e8..23a6a52a5c70 100644 --- a/editor/plugins/tiles/tiles_editor_plugin.h +++ b/editor/plugins/tiles/tiles_editor_plugin.h @@ -126,8 +126,8 @@ class TileMapEditorPlugin : public EditorPlugin { void _update_tile_map(); void _select_layer(const StringName &p_name); - void _edit_tile_map_layer(TileMapLayer *p_tile_map_layer); - void _edit_tile_map_layer_group(TileMapLayerGroup *p_tile_map_layer_group); + void _edit_tile_map_layer(TileMapLayer *p_tile_map_layer, bool p_show_layer_selector); + void _edit_tile_map(TileMap *p_tile_map); protected: void _notification(int p_notification); diff --git a/misc/extension_api_validation/4.2-stable.expected b/misc/extension_api_validation/4.2-stable.expected index 8623e8eb254b..50f609389b20 100644 --- a/misc/extension_api_validation/4.2-stable.expected +++ b/misc/extension_api_validation/4.2-stable.expected @@ -99,15 +99,6 @@ Validate extension JSON: Error: Field 'classes/GLTFBufferView/methods/get_indice Change AudioStreamPlayer* is_autoplay_enabled and GLTFBufferView getters to be const. -GH-87379 --------- -Validate extension JSON: API was removed: classes/TileMap/methods/get_tileset -Validate extension JSON: API was removed: classes/TileMap/methods/set_tileset -Validate extension JSON: API was removed: classes/TileMap/properties/tile_set - -Moved to the parent TileMapLayerGroup class. No change should be necessary. - - GH-87340 -------- Validate extension JSON: JSON file: Field was added in a way that breaks compatibility 'classes/RenderingDevice/methods/screen_get_framebuffer_format': arguments diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp index f8737730ba99..bbf1d09bbc8d 100644 --- a/scene/2d/tile_map.cpp +++ b/scene/2d/tile_map.cpp @@ -32,7 +32,7 @@ #include "tile_map.compat.inc" #include "core/core_string_names.h" -#include "scene/2d/tile_map_layer.h" +#include "core/io/marshalls.h" #include "scene/gui/control.h" #define TILEMAP_CALL_FOR_LAYER(layer, function, ...) \ @@ -49,10 +49,118 @@ ERR_FAIL_INDEX_V(layer, (int)layers.size(), err_value); \ return layers[layer]->function(__VA_ARGS__); +void TileMap::_tile_set_changed() { + update_configuration_warnings(); +} + void TileMap::_emit_changed() { emit_signal(CoreStringNames::get_singleton()->changed); } +void TileMap::_set_tile_map_data_using_compatibility_format(int p_layer, TileMapDataFormat p_format, const Vector &p_data) { + ERR_FAIL_INDEX(p_layer, (int)layers.size()); + ERR_FAIL_COND(p_format >= TileMapDataFormat::TILE_MAP_DATA_FORMAT_MAX); +#ifndef DISABLE_DEPRECATED + ERR_FAIL_COND_MSG(p_format != (TileMapDataFormat)(TILE_MAP_DATA_FORMAT_MAX - 1), "Old TileMap data format detected despite DISABLE_DEPRECATED being set compilation time."); +#endif // DISABLE_DEPRECATED + + // Set data for a given tile from raw data. + int c = p_data.size(); + const int *r = p_data.ptr(); + + int offset = (p_format >= TileMapDataFormat::TILE_MAP_DATA_FORMAT_2) ? 3 : 2; + ERR_FAIL_COND_MSG(c % offset != 0, vformat("Corrupted tile data. Got size: %d. Expected modulo: %d", c, offset)); + + layers[p_layer]->clear(); + + for (int i = 0; i < c; i += offset) { + const uint8_t *ptr = (const uint8_t *)&r[i]; + uint8_t local[12]; + for (int j = 0; j < ((p_format >= TileMapDataFormat::TILE_MAP_DATA_FORMAT_2) ? 12 : 8); j++) { + local[j] = ptr[j]; + } + +#ifdef BIG_ENDIAN_ENABLED + SWAP(local[0], local[3]); + 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) { + SWAP(local[8], local[11]); + SWAP(local[9], local[10]); + } +#endif + // Extracts position in TileMap. + int16_t x = decode_uint16(&local[0]); + int16_t y = decode_uint16(&local[2]); + + if (p_format == TileMapDataFormat::TILE_MAP_DATA_FORMAT_3) { + uint16_t source_id = decode_uint16(&local[4]); + uint16_t atlas_coords_x = decode_uint16(&local[6]); + uint16_t atlas_coords_y = decode_uint16(&local[8]); + uint16_t alternative_tile = decode_uint16(&local[10]); + layers[p_layer]->set_cell(Vector2i(x, y), source_id, Vector2i(atlas_coords_x, atlas_coords_y), alternative_tile); + } else { +#ifndef DISABLE_DEPRECATED + // Previous decated format. + uint32_t v = decode_uint32(&local[4]); + // Extract the transform flags that used to be in the tilemap. + bool flip_h = v & (1UL << 29); + bool flip_v = v & (1UL << 30); + bool transpose = v & (1UL << 31); + v &= (1UL << 29) - 1; + + // Extract autotile/atlas coords. + int16_t coord_x = 0; + int16_t coord_y = 0; + if (p_format == TileMapDataFormat::TILE_MAP_DATA_FORMAT_2) { + coord_x = decode_uint16(&local[8]); + coord_y = decode_uint16(&local[10]); + } + + if (tile_set.is_valid()) { + Array a = tile_set->compatibility_tilemap_map(v, Vector2i(coord_x, coord_y), flip_h, flip_v, transpose); + if (a.size() == 3) { + layers[p_layer]->set_cell(Vector2i(x, y), a[0], a[1], a[2]); + } else { + ERR_PRINT(vformat("No valid tile in Tileset for: tile:%s coords:%s flip_h:%s flip_v:%s transpose:%s", v, Vector2i(coord_x, coord_y), flip_h, flip_v, transpose)); + } + } else { + int compatibility_alternative_tile = ((int)flip_h) + ((int)flip_v << 1) + ((int)transpose << 2); + layers[p_layer]->set_cell(Vector2i(x, y), v, Vector2i(coord_x, coord_y), compatibility_alternative_tile); + } +#endif // DISABLE_DEPRECATED + } + } +} + +Vector TileMap::_get_tile_map_data_using_compatibility_format(int p_layer) const { + ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), Vector()); + + // Export tile data to raw format. + const HashMap tile_map_layer_data = layers[p_layer]->get_tile_map_layer_data(); + Vector tile_data; + tile_data.resize(tile_map_layer_data.size() * 3); + int *w = tile_data.ptrw(); + + // Save in highest format. + + int idx = 0; + for (const KeyValue &E : tile_map_layer_data) { + uint8_t *ptr = (uint8_t *)&w[idx]; + encode_uint16((int16_t)(E.key.x), &ptr[0]); + encode_uint16((int16_t)(E.key.y), &ptr[2]); + encode_uint16(E.value.cell.source_id, &ptr[4]); + encode_uint16(E.value.cell.coord_x, &ptr[6]); + encode_uint16(E.value.cell.coord_y, &ptr[8]); + encode_uint16(E.value.cell.alternative_tile, &ptr[10]); + idx += 3; + } + + return tile_data; +} + void TileMap::_notification(int p_what) { switch (p_what) { case TileMap::NOTIFICATION_INTERNAL_PHYSICS_PROCESS: { @@ -199,6 +307,34 @@ void TileMap::draw_tile(RID p_canvas_item, const Vector2 &p_position, const Ref< } } +void TileMap::set_tileset(const Ref &p_tileset) { + if (p_tileset == tile_set) { + return; + } + + // Set the tileset, registering to its changes. + if (tile_set.is_valid()) { + tile_set->disconnect_changed(callable_mp(this, &TileMap::_tile_set_changed)); + } + + tile_set = p_tileset; + + if (tile_set.is_valid()) { + tile_set->connect_changed(callable_mp(this, &TileMap::_tile_set_changed)); + } + + for (int i = 0; i < get_child_count(); i++) { + TileMapLayer *layer = Object::cast_to(get_child(i)); + if (layer) { + layer->set_tile_set(tile_set); + } + } +} + +Ref TileMap::get_tileset() const { + return tile_set; +} + int TileMap::get_layers_count() const { return layers.size(); } @@ -215,6 +351,7 @@ void TileMap::add_layer(int p_to_pos) { layers.insert(p_to_pos, new_layer); add_child(new_layer, false, INTERNAL_MODE_FRONT); new_layer->set_name(vformat("Layer%d", p_to_pos)); + new_layer->set_tile_set(tile_set); move_child(new_layer, p_to_pos); for (uint32_t i = 0; i < layers.size(); i++) { layers[i]->set_as_tile_map_internal_node(i); @@ -251,8 +388,11 @@ void TileMap::remove_layer(int p_layer) { ERR_FAIL_INDEX(p_layer, (int)layers.size()); // Clear before removing the layer. - layers[p_layer]->queue_free(); + TileMapLayer *removed = layers[p_layer]; layers.remove_at(p_layer); + remove_child(removed); + removed->queue_free(); + for (uint32_t i = 0; i < layers.size(); i++) { layers[i]->set_as_tile_map_internal_node(i); } @@ -349,7 +489,7 @@ void TileMap::set_collision_visibility_mode(TileMap::VisibilityMode p_show_colli } collision_visibility_mode = p_show_collision; for (TileMapLayer *layer : layers) { - layer->set_collision_visibility_mode(TileMapLayer::VisibilityMode(p_show_collision)); + layer->set_collision_visibility_mode(TileMapLayer::DebugVisibilityMode(p_show_collision)); } _emit_changed(); } @@ -364,7 +504,7 @@ void TileMap::set_navigation_visibility_mode(TileMap::VisibilityMode p_show_navi } navigation_visibility_mode = p_show_navigation; for (TileMapLayer *layer : layers) { - layer->set_navigation_visibility_mode(TileMapLayer::VisibilityMode(p_show_navigation)); + layer->set_navigation_visibility_mode(TileMapLayer::DebugVisibilityMode(p_show_navigation)); } _emit_changed(); } @@ -394,19 +534,85 @@ void TileMap::erase_cell(int p_layer, const Vector2i &p_coords) { } int TileMap::get_cell_source_id(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { - TILEMAP_CALL_FOR_LAYER_V(p_layer, TileSet::INVALID_SOURCE, get_cell_source_id, p_coords, p_use_proxies); + if (p_use_proxies && tile_set.is_valid()) { + if (p_layer < 0) { + p_layer = layers.size() + p_layer; + } + ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSet::INVALID_SOURCE); + + int source_id = layers[p_layer]->get_cell_source_id(p_coords); + Vector2i atlas_coords = layers[p_layer]->get_cell_atlas_coords(p_coords); + int alternative_id = layers[p_layer]->get_cell_alternative_tile(p_coords); + + Array arr = tile_set->map_tile_proxy(source_id, atlas_coords, alternative_id); + ERR_FAIL_COND_V(arr.size() != 3, TileSet::INVALID_SOURCE); + return arr[0]; + } else { + TILEMAP_CALL_FOR_LAYER_V(p_layer, TileSet::INVALID_SOURCE, get_cell_source_id, p_coords); + } } Vector2i TileMap::get_cell_atlas_coords(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { - TILEMAP_CALL_FOR_LAYER_V(p_layer, TileSetSource::INVALID_ATLAS_COORDS, get_cell_atlas_coords, p_coords, p_use_proxies); + if (p_use_proxies && tile_set.is_valid()) { + if (p_layer < 0) { + p_layer = layers.size() + p_layer; + } + ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSetAtlasSource::INVALID_ATLAS_COORDS); + + int source_id = layers[p_layer]->get_cell_source_id(p_coords); + Vector2i atlas_coords = layers[p_layer]->get_cell_atlas_coords(p_coords); + int alternative_id = layers[p_layer]->get_cell_alternative_tile(p_coords); + + Array arr = tile_set->map_tile_proxy(source_id, atlas_coords, alternative_id); + ERR_FAIL_COND_V(arr.size() != 3, TileSetSource::INVALID_ATLAS_COORDS); + return arr[1]; + } else { + TILEMAP_CALL_FOR_LAYER_V(p_layer, TileSetSource::INVALID_ATLAS_COORDS, get_cell_atlas_coords, p_coords); + } } int TileMap::get_cell_alternative_tile(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { - TILEMAP_CALL_FOR_LAYER_V(p_layer, TileSetSource::INVALID_TILE_ALTERNATIVE, get_cell_alternative_tile, p_coords, p_use_proxies); + if (p_use_proxies && tile_set.is_valid()) { + if (p_layer < 0) { + p_layer = layers.size() + p_layer; + } + ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSetSource::INVALID_TILE_ALTERNATIVE); + + int source_id = layers[p_layer]->get_cell_source_id(p_coords); + Vector2i atlas_coords = layers[p_layer]->get_cell_atlas_coords(p_coords); + int alternative_id = layers[p_layer]->get_cell_alternative_tile(p_coords); + + Array arr = tile_set->map_tile_proxy(source_id, atlas_coords, alternative_id); + ERR_FAIL_COND_V(arr.size() != 3, TileSetSource::INVALID_TILE_ALTERNATIVE); + return arr[2]; + } else { + TILEMAP_CALL_FOR_LAYER_V(p_layer, TileSetSource::INVALID_TILE_ALTERNATIVE, get_cell_alternative_tile, p_coords); + } } TileData *TileMap::get_cell_tile_data(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { - TILEMAP_CALL_FOR_LAYER_V(p_layer, nullptr, get_cell_tile_data, p_coords, p_use_proxies); + if (p_use_proxies && tile_set.is_valid()) { + if (p_layer < 0) { + p_layer = layers.size() + p_layer; + } + ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr); + + int source_id = layers[p_layer]->get_cell_source_id(p_coords); + Vector2i atlas_coords = layers[p_layer]->get_cell_atlas_coords(p_coords); + int alternative_id = layers[p_layer]->get_cell_alternative_tile(p_coords); + + Array arr = tile_set->map_tile_proxy(source_id, atlas_coords, alternative_id); + ERR_FAIL_COND_V(arr.size() != 3, nullptr); + + Ref atlas_source = tile_set->get_source(arr[0]); + if (atlas_source.is_valid()) { + return atlas_source->get_tile_data(arr[1], arr[2]); + } else { + return nullptr; + } + } else { + TILEMAP_CALL_FOR_LAYER_V(p_layer, nullptr, get_cell_tile_data, p_coords); + } } Ref TileMap::get_pattern(int p_layer, TypedArray p_coords_array) { @@ -451,7 +657,10 @@ void TileMap::set_cells_terrain_path(int p_layer, TypedArray p_path, i } TileMapCell TileMap::get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const { - TILEMAP_CALL_FOR_LAYER_V(p_layer, TileMapCell(), get_cell, p_coords, p_use_proxies); + if (p_use_proxies) { + WARN_DEPRECATED_MSG("use_proxies is deprecated."); + } + TILEMAP_CALL_FOR_LAYER_V(p_layer, TileMapCell(), get_cell, p_coords); } Vector2i TileMap::get_coords_for_body_rid(RID p_physics_body) { @@ -478,6 +687,13 @@ void TileMap::fix_invalid_tiles() { } } +#ifdef TOOLS_ENABLED +TileMapLayer *TileMap::duplicate_layer_from_internal(int p_layer) { + ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr); + return Object::cast_to(layers[p_layer]->duplicate(DUPLICATE_USE_INSTANTIATION | DUPLICATE_FROM_EDITOR)); +} +#endif // TOOLS_ENABLED + void TileMap::clear_layer(int p_layer) { TILEMAP_CALL_FOR_LAYER(p_layer, clear) } @@ -540,10 +756,11 @@ bool TileMap::_set(const StringName &p_name, const Variant &p_value) { add_child(new_layer, false, INTERNAL_MODE_FRONT); new_layer->set_as_tile_map_internal_node(0); new_layer->set_name("Layer0"); + new_layer->set_tile_set(tile_set); new_layer->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &TileMap::_emit_changed)); layers.push_back(new_layer); } - layers[0]->set_tile_data(format, p_value); + _set_tile_map_data_using_compatibility_format(0, format, p_value); _emit_changed(); return true; } @@ -565,6 +782,7 @@ bool TileMap::_set(const StringName &p_name, const Variant &p_value) { add_child(new_layer, false, INTERNAL_MODE_FRONT); new_layer->set_as_tile_map_internal_node(index); new_layer->set_name(vformat("Layer%d", index)); + new_layer->set_tile_set(tile_set); new_layer->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &TileMap::_emit_changed)); layers.push_back(new_layer); } @@ -596,7 +814,7 @@ bool TileMap::_set(const StringName &p_name, const Variant &p_value) { set_layer_navigation_enabled(index, p_value); return true; } else if (components[1] == "tile_data") { - layers[index]->set_tile_data(format, p_value); + _set_tile_map_data_using_compatibility_format(index, format, p_value); _emit_changed(); return true; } else { @@ -609,7 +827,7 @@ bool TileMap::_set(const StringName &p_name, const Variant &p_value) { bool TileMap::_get(const StringName &p_name, Variant &r_ret) const { Vector components = String(p_name).split("/", true, 2); if (p_name == "format") { - r_ret = TileMapDataFormat::FORMAT_MAX - 1; // When saving, always save highest format. + r_ret = TileMapDataFormat::TILE_MAP_DATA_FORMAT_MAX - 1; // When saving, always save highest format. return true; } #ifndef DISABLE_DEPRECATED @@ -646,7 +864,7 @@ bool TileMap::_get(const StringName &p_name, Variant &r_ret) const { r_ret = is_layer_navigation_enabled(index); return true; } else if (components[1] == "tile_data") { - r_ret = layers[index]->get_tile_data(); + r_ret = _get_tile_map_data_using_compatibility_format(index); return true; } else { return false; @@ -899,6 +1117,9 @@ void TileMap::_bind_methods() { ClassDB::bind_method(D_METHOD("force_update", "layer"), &TileMap::force_update, DEFVAL(-1)); #endif // DISABLE_DEPRECATED + ClassDB::bind_method(D_METHOD("set_tileset", "tileset"), &TileMap::set_tileset); + ClassDB::bind_method(D_METHOD("get_tileset"), &TileMap::get_tileset); + ClassDB::bind_method(D_METHOD("set_rendering_quadrant_size", "size"), &TileMap::set_rendering_quadrant_size); ClassDB::bind_method(D_METHOD("get_rendering_quadrant_size"), &TileMap::get_rendering_quadrant_size); @@ -969,6 +1190,7 @@ void TileMap::_bind_methods() { GDVIRTUAL_BIND(_use_tile_data_runtime_update, "layer", "coords"); GDVIRTUAL_BIND(_tile_data_runtime_update, "layer", "coords", "tile_data"); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "TileSet"), "set_tileset", "get_tileset"); ADD_PROPERTY(PropertyInfo(Variant::INT, "rendering_quadrant_size", PROPERTY_HINT_RANGE, "1,128,1"), "set_rendering_quadrant_size", "get_rendering_quadrant_size"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision_animatable"), "set_collision_animatable", "is_collision_animatable"); ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_visibility_mode", PROPERTY_HINT_ENUM, "Default,Force Show,Force Hide"), "set_collision_visibility_mode", "get_collision_visibility_mode"); @@ -976,7 +1198,7 @@ void TileMap::_bind_methods() { ADD_ARRAY("layers", "layer_"); - ADD_PROPERTY_DEFAULT("format", TileMapDataFormat::FORMAT_1); + ADD_PROPERTY_DEFAULT("format", TileMapDataFormat::TILE_MAP_DATA_FORMAT_1); ADD_SIGNAL(MethodInfo(CoreStringNames::get_singleton()->changed)); @@ -990,6 +1212,7 @@ TileMap::TileMap() { add_child(new_layer, false, INTERNAL_MODE_FRONT); new_layer->set_as_tile_map_internal_node(0); new_layer->set_name("Layer0"); + new_layer->set_tile_set(tile_set); new_layer->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &TileMap::_emit_changed)); layers.push_back(new_layer); default_layer = memnew(TileMapLayer); diff --git a/scene/2d/tile_map.h b/scene/2d/tile_map.h index edea90fa95fe..41068ea97836 100644 --- a/scene/2d/tile_map.h +++ b/scene/2d/tile_map.h @@ -31,7 +31,7 @@ #ifndef TILE_MAP_H #define TILE_MAP_H -#include "scene/2d/tile_map_layer_group.h" +#include "scene/2d/tile_map_layer.h" #include "scene/resources/2d/tile_set.h" class Control; @@ -39,14 +39,14 @@ class TileMapLayer; class TerrainConstraint; enum TileMapDataFormat { - FORMAT_1 = 0, - FORMAT_2, - FORMAT_3, - FORMAT_MAX, + TILE_MAP_DATA_FORMAT_1 = 0, + TILE_MAP_DATA_FORMAT_2, + TILE_MAP_DATA_FORMAT_3, + TILE_MAP_DATA_FORMAT_MAX, }; -class TileMap : public TileMapLayerGroup { - GDCLASS(TileMap, TileMapLayerGroup) +class TileMap : public Node2D { + GDCLASS(TileMap, Node2D) public: // Kept for compatibility, but should use TileMapLayer::VisibilityMode instead. @@ -60,11 +60,12 @@ private: friend class TileSetPlugin; // A compatibility enum to specify how is the data if formatted. - mutable TileMapDataFormat format = TileMapDataFormat::FORMAT_3; + mutable TileMapDataFormat format = TileMapDataFormat::TILE_MAP_DATA_FORMAT_3; static constexpr float FP_ADJUST = 0.00001; // Properties. + Ref tile_set; int rendering_quadrant_size = 16; bool collision_animatable = false; VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT; @@ -78,8 +79,14 @@ private: Transform2D last_valid_transform; Transform2D new_transform; + void _tile_set_changed(); + void _emit_changed(); + // Kept for compatibility with TileMap. With TileMapLayers as individual nodes, the format is stored directly in the array. + void _set_tile_map_data_using_compatibility_format(int p_layer, TileMapDataFormat p_format, const Vector &p_data); + Vector _get_tile_map_data_using_compatibility_format(int p_layer) const; + protected: bool _set(const StringName &p_name, const Variant &p_value); bool _get(const StringName &p_name, Variant &r_ret) const; @@ -114,6 +121,10 @@ public: static void draw_tile(RID p_canvas_item, const Vector2 &p_position, const Ref p_tile_set, int p_atlas_source_id, const Vector2i &p_atlas_coords, int p_alternative_tile, int p_frame = -1, Color p_modulation = Color(1.0, 1.0, 1.0, 1.0), const TileData *p_tile_data_override = nullptr, real_t p_normalized_animation_offset = 0.0); + // Accessors. + void set_tileset(const Ref &p_tileset); + Ref get_tileset() const; + // Layers management. int get_layers_count() const; void add_layer(int p_to_pos); @@ -200,6 +211,11 @@ public: // Fixing and clearing methods. void fix_invalid_tiles(); +#ifdef TOOLS_ENABLED + // Moving layers outside of TileMap. + TileMapLayer *duplicate_layer_from_internal(int p_layer); +#endif // TOOLS_ENABLED + // Clears tiles from a given layer. void clear_layer(int p_layer); void clear(); diff --git a/scene/2d/tile_map_layer.cpp b/scene/2d/tile_map_layer.cpp index 84c4c43a5ad8..3f10eb76610e 100644 --- a/scene/2d/tile_map_layer.cpp +++ b/scene/2d/tile_map_layer.cpp @@ -32,6 +32,7 @@ #include "core/core_string_names.h" #include "core/io/marshalls.h" +#include "scene/2d/tile_map.h" #include "scene/gui/control.h" #include "scene/resources/world_2d.h" #include "servers/navigation_server_2d.h" @@ -51,11 +52,10 @@ Vector2i TileMapLayer::_coords_to_debug_quadrant_coords(const Vector2i &p_coords } void TileMapLayer::_debug_update() { - const Ref &tile_set = get_effective_tile_set(); RenderingServer *rs = RenderingServer::get_singleton(); // Check if we should cleanup everything. - bool forced_cleanup = in_destructor || !enabled || !tile_set.is_valid() || !is_visible_in_tree(); + bool forced_cleanup = in_destructor || !enabled || tile_set.is_null() || !is_visible_in_tree(); if (forced_cleanup) { for (KeyValue> &kv : debug_quadrant_map) { @@ -84,7 +84,7 @@ void TileMapLayer::_debug_update() { if (_debug_was_cleaned_up || anything_changed) { // Update all cells. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { CellData &cell_data = kv.value; _debug_quadrants_update_cell(cell_data, dirty_debug_quadrant_list); } @@ -179,33 +179,21 @@ void TileMapLayer::_debug_quadrants_update_cell(CellData &r_cell_data, SelfList< /////////////////////////////// Rendering ////////////////////////////////////// void TileMapLayer::_rendering_update() { - const Ref &tile_set = get_effective_tile_set(); RenderingServer *rs = RenderingServer::get_singleton(); // Check if we should cleanup everything. - bool forced_cleanup = in_destructor || !enabled || !tile_set.is_valid() || !is_visible_in_tree(); + bool forced_cleanup = in_destructor || !enabled || tile_set.is_null() || !is_visible_in_tree(); // ----------- Layer level processing ----------- if (!forced_cleanup) { // Modulate the layer. Color layer_modulate = get_modulate(); #ifdef TOOLS_ENABLED - const TileMapLayerGroup *tile_map_layer_group = Object::cast_to(get_parent()); - if (tile_map_layer_group) { - const Vector selected_layers = tile_map_layer_group->get_selected_layers(); - if (tile_map_layer_group->is_highlighting_selected_layer() && selected_layers.size() == 1 && get_name() != selected_layers[0]) { - TileMapLayer *selected_layer = Object::cast_to(tile_map_layer_group->get_node_or_null(String(selected_layers[0]))); - if (selected_layer) { - int z_selected = selected_layer->get_z_index(); - int layer_z_index = get_z_index(); - if (layer_z_index < z_selected || (layer_z_index == z_selected && get_index() < selected_layer->get_index())) { - layer_modulate = layer_modulate.darkened(0.5); - } else if (layer_z_index > z_selected || (layer_z_index == z_selected && get_index() > selected_layer->get_index())) { - layer_modulate = layer_modulate.darkened(0.5); - layer_modulate.a *= 0.3; - } - } - } + if (highlight_mode == HIGHLIGHT_MODE_BELOW) { + layer_modulate = layer_modulate.darkened(0.5); + } else if (highlight_mode == HIGHLIGHT_MODE_ABOVE) { + layer_modulate = layer_modulate.darkened(0.5); + layer_modulate.a *= 0.3; } #endif // TOOLS_ENABLED rs->canvas_item_set_modulate(get_canvas_item(), layer_modulate); @@ -219,7 +207,7 @@ void TileMapLayer::_rendering_update() { // Check if anything changed that might change the quadrant shape. // If so, recreate everything. bool quandrant_shape_changed = dirty.flags[DIRTY_FLAGS_LAYER_RENDERING_QUADRANT_SIZE] || - (is_y_sort_enabled() && (dirty.flags[DIRTY_FLAGS_LAYER_Y_SORT_ENABLED] || dirty.flags[DIRTY_FLAGS_LAYER_Y_SORT_ORIGIN] || dirty.flags[DIRTY_FLAGS_LAYER_LOCAL_TRANSFORM] || dirty.flags[DIRTY_FLAGS_LAYER_GROUP_TILE_SET])); + (is_y_sort_enabled() && (dirty.flags[DIRTY_FLAGS_LAYER_Y_SORT_ENABLED] || dirty.flags[DIRTY_FLAGS_LAYER_Y_SORT_ORIGIN] || dirty.flags[DIRTY_FLAGS_LAYER_LOCAL_TRANSFORM] || dirty.flags[DIRTY_FLAGS_TILE_SET])); // Free all quadrants. if (forced_cleanup || quandrant_shape_changed) { @@ -238,9 +226,9 @@ void TileMapLayer::_rendering_update() { if (!forced_cleanup) { // List all quadrants to update, recreating them if needed. - if (dirty.flags[DIRTY_FLAGS_LAYER_GROUP_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE] || _rendering_was_cleaned_up) { + if (dirty.flags[DIRTY_FLAGS_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE] || _rendering_was_cleaned_up) { // Update all cells. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { CellData &cell_data = kv.value; _rendering_quadrants_update_cell(cell_data, dirty_rendering_quadrant_list); } @@ -420,13 +408,13 @@ void TileMapLayer::_rendering_update() { // ----------- Occluders processing ----------- if (forced_cleanup) { // Clean everything. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _rendering_occluders_clear_cell(kv.value); } } else { - if (_rendering_was_cleaned_up || dirty.flags[DIRTY_FLAGS_LAYER_GROUP_TILE_SET]) { + if (_rendering_was_cleaned_up || dirty.flags[DIRTY_FLAGS_TILE_SET]) { // Update all cells. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _rendering_occluders_update_cell(kv.value); } } else { @@ -445,11 +433,10 @@ void TileMapLayer::_rendering_update() { void TileMapLayer::_rendering_notification(int p_what) { RenderingServer *rs = RenderingServer::get_singleton(); - const Ref &tile_set = get_effective_tile_set(); if (p_what == NOTIFICATION_TRANSFORM_CHANGED || p_what == NOTIFICATION_ENTER_CANVAS || p_what == NOTIFICATION_VISIBILITY_CHANGED) { if (tile_set.is_valid()) { Transform2D tilemap_xform = get_global_transform(); - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { const CellData &cell_data = kv.value; for (const RID &occluder : cell_data.occluders) { if (occluder.is_null()) { @@ -474,8 +461,6 @@ void TileMapLayer::_rendering_notification(int p_what) { } void TileMapLayer::_rendering_quadrants_update_cell(CellData &r_cell_data, SelfList::List &r_dirty_rendering_quadrant_list) { - const Ref &tile_set = get_effective_tile_set(); - // Check if the cell is valid and retrieve its y_sort_origin. bool is_valid = false; int tile_y_sort_origin = 0; @@ -573,7 +558,6 @@ void TileMapLayer::_rendering_occluders_clear_cell(CellData &r_cell_data) { } void TileMapLayer::_rendering_occluders_update_cell(CellData &r_cell_data) { - const Ref &tile_set = get_effective_tile_set(); RenderingServer *rs = RenderingServer::get_singleton(); // Free unused occluders then resize the occluders array. @@ -642,8 +626,7 @@ void TileMapLayer::_rendering_occluders_update_cell(CellData &r_cell_data) { #ifdef DEBUG_ENABLED void TileMapLayer::_rendering_draw_cell_debug(const RID &p_canvas_item, const Vector2 &p_quadrant_pos, const CellData &r_cell_data) { - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND(!tile_set.is_valid()); + ERR_FAIL_COND(tile_set.is_null()); if (!Engine::get_singleton()->is_editor_hint()) { return; @@ -691,19 +674,17 @@ void TileMapLayer::_rendering_draw_cell_debug(const RID &p_canvas_item, const Ve /////////////////////////////// Physics ////////////////////////////////////// void TileMapLayer::_physics_update() { - const Ref &tile_set = get_effective_tile_set(); - // Check if we should cleanup everything. - bool forced_cleanup = in_destructor || !enabled || !is_inside_tree() || !tile_set.is_valid(); + bool forced_cleanup = in_destructor || !enabled || !collision_enabled || !is_inside_tree() || tile_set.is_null(); if (forced_cleanup) { // Clean everything. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _physics_clear_cell(kv.value); } } else { - if (_physics_was_cleaned_up || dirty.flags[DIRTY_FLAGS_LAYER_GROUP_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_USE_KINEMATIC_BODIES] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE]) { + if (_physics_was_cleaned_up || dirty.flags[DIRTY_FLAGS_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_USE_KINEMATIC_BODIES] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE]) { // Update all cells. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _physics_update_cell(kv.value); } } else { @@ -721,7 +702,6 @@ void TileMapLayer::_physics_update() { } void TileMapLayer::_physics_notification(int p_what) { - const Ref &tile_set = get_effective_tile_set(); Transform2D gl_transform = get_global_transform(); PhysicsServer2D *ps = PhysicsServer2D::get_singleton(); @@ -729,7 +709,7 @@ void TileMapLayer::_physics_notification(int p_what) { case NOTIFICATION_TRANSFORM_CHANGED: // Move the collisison shapes along with the TileMap. if (is_inside_tree() && tile_set.is_valid()) { - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { const CellData &cell_data = kv.value; for (RID body : cell_data.bodies) { @@ -747,7 +727,7 @@ void TileMapLayer::_physics_notification(int p_what) { if (is_inside_tree()) { RID space = get_world_2d()->get_space(); - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { const CellData &cell_data = kv.value; for (RID body : cell_data.bodies) { @@ -774,7 +754,6 @@ void TileMapLayer::_physics_clear_cell(CellData &r_cell_data) { } void TileMapLayer::_physics_update_cell(CellData &r_cell_data) { - const Ref &tile_set = get_effective_tile_set(); Transform2D gl_transform = get_global_transform(); RID space = get_world_2d()->get_space(); PhysicsServer2D *ps = PhysicsServer2D::get_singleton(); @@ -891,8 +870,7 @@ void TileMapLayer::_physics_update_cell(CellData &r_cell_data) { #ifdef DEBUG_ENABLED void TileMapLayer::_physics_draw_cell_debug(const RID &p_canvas_item, const Vector2 &p_quadrant_pos, const CellData &r_cell_data) { // Draw the debug collision shapes. - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND(!tile_set.is_valid()); + ERR_FAIL_COND(tile_set.is_null()); if (!get_tree()) { return; @@ -900,13 +878,13 @@ void TileMapLayer::_physics_draw_cell_debug(const RID &p_canvas_item, const Vect bool show_collision = false; switch (collision_visibility_mode) { - case TileMapLayer::VISIBILITY_MODE_DEFAULT: + case TileMapLayer::DEBUG_VISIBILITY_MODE_DEFAULT: show_collision = !Engine::get_singleton()->is_editor_hint() && get_tree()->is_debugging_collisions_hint(); break; - case TileMapLayer::VISIBILITY_MODE_FORCE_HIDE: + case TileMapLayer::DEBUG_VISIBILITY_MODE_FORCE_HIDE: show_collision = false; break; - case TileMapLayer::VISIBILITY_MODE_FORCE_SHOW: + case TileMapLayer::DEBUG_VISIBILITY_MODE_FORCE_SHOW: show_collision = true; break; } @@ -948,10 +926,9 @@ void TileMapLayer::_physics_draw_cell_debug(const RID &p_canvas_item, const Vect void TileMapLayer::_navigation_update() { ERR_FAIL_NULL(NavigationServer2D::get_singleton()); NavigationServer2D *ns = NavigationServer2D::get_singleton(); - const Ref &tile_set = get_effective_tile_set(); // Check if we should cleanup everything. - bool forced_cleanup = in_destructor || !enabled || !navigation_enabled || !is_inside_tree() || !tile_set.is_valid(); + bool forced_cleanup = in_destructor || !enabled || !navigation_enabled || !is_inside_tree() || tile_set.is_null(); // ----------- Layer level processing ----------- // All this processing is kept for compatibility with the TileMap node. @@ -980,13 +957,13 @@ void TileMapLayer::_navigation_update() { // ----------- Navigation regions processing ----------- if (forced_cleanup) { // Clean everything. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _navigation_clear_cell(kv.value); } } else { - if (_navigation_was_cleaned_up || dirty.flags[DIRTY_FLAGS_LAYER_GROUP_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE] || dirty.flags[DIRTY_FLAGS_LAYER_NAVIGATION_MAP]) { + if (_navigation_was_cleaned_up || dirty.flags[DIRTY_FLAGS_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE] || dirty.flags[DIRTY_FLAGS_LAYER_NAVIGATION_MAP]) { // Update all cells. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _navigation_update_cell(kv.value); } } else { @@ -1004,11 +981,10 @@ void TileMapLayer::_navigation_update() { } void TileMapLayer::_navigation_notification(int p_what) { - const Ref &tile_set = get_effective_tile_set(); if (p_what == NOTIFICATION_TRANSFORM_CHANGED) { if (tile_set.is_valid()) { Transform2D tilemap_xform = get_global_transform(); - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { const CellData &cell_data = kv.value; // Update navigation regions transform. for (const RID ®ion : cell_data.navigation_regions) { @@ -1038,7 +1014,6 @@ void TileMapLayer::_navigation_clear_cell(CellData &r_cell_data) { } void TileMapLayer::_navigation_update_cell(CellData &r_cell_data) { - const Ref &tile_set = get_effective_tile_set(); NavigationServer2D *ns = NavigationServer2D::get_singleton(); Transform2D gl_xform = get_global_transform(); RID navigation_map = navigation_map_override.is_valid() ? navigation_map_override : get_world_2d()->get_navigation_map(); @@ -1119,13 +1094,13 @@ void TileMapLayer::_navigation_draw_cell_debug(const RID &p_canvas_item, const V // Draw the debug collision shapes. bool show_navigation = false; switch (navigation_visibility_mode) { - case TileMapLayer::VISIBILITY_MODE_DEFAULT: + case TileMapLayer::DEBUG_VISIBILITY_MODE_DEFAULT: show_navigation = !Engine::get_singleton()->is_editor_hint() && get_tree()->is_debugging_navigation_hint(); break; - case TileMapLayer::VISIBILITY_MODE_FORCE_HIDE: + case TileMapLayer::DEBUG_VISIBILITY_MODE_FORCE_HIDE: show_navigation = false; break; - case TileMapLayer::VISIBILITY_MODE_FORCE_SHOW: + case TileMapLayer::DEBUG_VISIBILITY_MODE_FORCE_SHOW: show_navigation = true; break; } @@ -1138,8 +1113,6 @@ void TileMapLayer::_navigation_draw_cell_debug(const RID &p_canvas_item, const V return; } - const Ref &tile_set = get_effective_tile_set(); - RenderingServer *rs = RenderingServer::get_singleton(); const NavigationServer2D *ns2d = NavigationServer2D::get_singleton(); @@ -1224,20 +1197,18 @@ void TileMapLayer::_navigation_draw_cell_debug(const RID &p_canvas_item, const V /////////////////////////////// Scenes ////////////////////////////////////// void TileMapLayer::_scenes_update() { - const Ref &tile_set = get_effective_tile_set(); - // Check if we should cleanup everything. - bool forced_cleanup = in_destructor || !enabled || !is_inside_tree() || !tile_set.is_valid(); + bool forced_cleanup = in_destructor || !enabled || !is_inside_tree() || tile_set.is_null(); if (forced_cleanup) { // Clean everything. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _scenes_clear_cell(kv.value); } } else { - if (_scenes_was_cleaned_up || dirty.flags[DIRTY_FLAGS_LAYER_GROUP_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE]) { + if (_scenes_was_cleaned_up || dirty.flags[DIRTY_FLAGS_TILE_SET] || dirty.flags[DIRTY_FLAGS_LAYER_IN_TREE]) { // Update all cells. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { _scenes_update_cell(kv.value); } } else { @@ -1270,8 +1241,6 @@ void TileMapLayer::_scenes_clear_cell(CellData &r_cell_data) { } void TileMapLayer::_scenes_update_cell(CellData &r_cell_data) { - const Ref &tile_set = get_effective_tile_set(); - // Clear the scene in any case. _scenes_clear_cell(r_cell_data); @@ -1312,8 +1281,7 @@ void TileMapLayer::_scenes_update_cell(CellData &r_cell_data) { #ifdef DEBUG_ENABLED void TileMapLayer::_scenes_draw_cell_debug(const RID &p_canvas_item, const Vector2 &p_quadrant_pos, const CellData &r_cell_data) { - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND(!tile_set.is_valid()); + ERR_FAIL_COND(tile_set.is_null()); if (!Engine::get_singleton()->is_editor_hint()) { return; @@ -1362,22 +1330,20 @@ void TileMapLayer::_scenes_draw_cell_debug(const RID &p_canvas_item, const Vecto ///////////////////////////////////////////////////////////////////// void TileMapLayer::_build_runtime_update_tile_data() { - const Ref &tile_set = get_effective_tile_set(); - // Check if we should cleanup everything. - bool forced_cleanup = in_destructor || !enabled || !tile_set.is_valid() || !is_visible_in_tree(); + bool forced_cleanup = in_destructor || !enabled || tile_set.is_null() || !is_visible_in_tree(); if (!forced_cleanup) { bool valid_runtime_update = GDVIRTUAL_IS_OVERRIDDEN(_use_tile_data_runtime_update) && GDVIRTUAL_IS_OVERRIDDEN(_tile_data_runtime_update); bool valid_runtime_update_for_tilemap = tile_map_node && tile_map_node->GDVIRTUAL_IS_OVERRIDDEN(_use_tile_data_runtime_update) && tile_map_node->GDVIRTUAL_IS_OVERRIDDEN(_tile_data_runtime_update); // For keeping compatibility. if (valid_runtime_update || valid_runtime_update_for_tilemap) { bool use_tilemap_for_runtime = valid_runtime_update_for_tilemap && !valid_runtime_update; - if (_runtime_update_tile_data_was_cleaned_up || dirty.flags[DIRTY_FLAGS_LAYER_GROUP_TILE_SET]) { + if (_runtime_update_tile_data_was_cleaned_up || dirty.flags[DIRTY_FLAGS_TILE_SET]) { _runtime_update_needs_all_cells_cleaned_up = true; - for (KeyValue &E : tile_map) { + for (KeyValue &E : tile_map_layer_data) { _build_runtime_update_tile_data_for_cell(E.value, use_tilemap_for_runtime); } } else if (dirty.flags[DIRTY_FLAGS_LAYER_RUNTIME_UPDATE]) { - for (KeyValue &E : tile_map) { + for (KeyValue &E : tile_map_layer_data) { _build_runtime_update_tile_data_for_cell(E.value, use_tilemap_for_runtime, true); } } else { @@ -1395,8 +1361,6 @@ void TileMapLayer::_build_runtime_update_tile_data() { } void TileMapLayer::_build_runtime_update_tile_data_for_cell(CellData &r_cell_data, bool p_use_tilemap_for_runtime, bool p_auto_add_to_dirty_list) { - const Ref &tile_set = get_effective_tile_set(); - TileMapCell &c = r_cell_data.cell; TileSetSource *source; if (tile_set->has_source(c.source_id)) { @@ -1446,7 +1410,7 @@ void TileMapLayer::_build_runtime_update_tile_data_for_cell(CellData &r_cell_dat void TileMapLayer::_clear_runtime_update_tile_data() { if (_runtime_update_needs_all_cells_cleaned_up) { - for (KeyValue &E : tile_map) { + for (KeyValue &E : tile_map_layer_data) { _clear_runtime_update_tile_data_for_cell(E.value); } _runtime_update_needs_all_cells_cleaned_up = false; @@ -1467,8 +1431,7 @@ void TileMapLayer::_clear_runtime_update_tile_data_for_cell(CellData &r_cell_dat } TileSet::TerrainsPattern TileMapLayer::_get_best_terrain_pattern_for_constraints(int p_terrain_set, const Vector2i &p_position, const RBSet &p_constraints, TileSet::TerrainsPattern p_current_pattern) const { - const Ref &tile_set = get_effective_tile_set(); - if (!tile_set.is_valid()) { + if (tile_set.is_null()) { return TileSet::TerrainsPattern(); } // Returns all tiles compatible with the given constraints. @@ -1528,8 +1491,7 @@ TileSet::TerrainsPattern TileMapLayer::_get_best_terrain_pattern_for_constraints } RBSet TileMapLayer::_get_terrain_constraints_from_added_pattern(const Vector2i &p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const { - const Ref &tile_set = get_effective_tile_set(); - if (!tile_set.is_valid()) { + if (tile_set.is_null()) { return RBSet(); } @@ -1549,8 +1511,7 @@ RBSet TileMapLayer::_get_terrain_constraints_from_added_patte } RBSet TileMapLayer::_get_terrain_constraints_from_painted_cells_list(const RBSet &p_painted, int p_terrain_set, bool p_ignore_empty_terrains) const { - const Ref &tile_set = get_effective_tile_set(); - if (!tile_set.is_valid()) { + if (tile_set.is_null()) { return RBSet(); } @@ -1636,6 +1597,12 @@ RBSet TileMapLayer::_get_terrain_constraints_from_painted_cel return constraints; } +void TileMapLayer::_tile_set_changed() { + dirty.flags[DIRTY_FLAGS_TILE_SET] = true; + _queue_internal_update(); + emit_signal(CoreStringNames::get_singleton()->changed); +} + void TileMapLayer::_renamed() { emit_signal(CoreStringNames::get_singleton()->changed); } @@ -1706,7 +1673,7 @@ void TileMapLayer::_internal_update() { // Remove cells that are empty after the cleanup. for (const Vector2i &coords : to_delete) { - tile_map.erase(coords); + tile_map_layer_data.erase(coords); } // Clear the dirty cells list. @@ -1754,12 +1721,115 @@ void TileMapLayer::_notification(int p_what) { } void TileMapLayer::_bind_methods() { + // --- Cells manipulation --- + // Generic cells manipulations and access. ClassDB::bind_method(D_METHOD("set_cell", "coords", "source_id", "atlas_coords", "alternative_tile"), &TileMapLayer::set_cell, DEFVAL(TileSet::INVALID_SOURCE), DEFVAL(TileSetSource::INVALID_ATLAS_COORDS), DEFVAL(0)); + ClassDB::bind_method(D_METHOD("erase_cell", "coords"), &TileMapLayer::erase_cell); + ClassDB::bind_method(D_METHOD("fix_invalid_tiles"), &TileMapLayer::fix_invalid_tiles); + ClassDB::bind_method(D_METHOD("clear"), &TileMapLayer::clear); + + ClassDB::bind_method(D_METHOD("get_cell_source_id", "coords"), &TileMapLayer::get_cell_source_id); + ClassDB::bind_method(D_METHOD("get_cell_atlas_coords", "coords"), &TileMapLayer::get_cell_atlas_coords); + ClassDB::bind_method(D_METHOD("get_cell_alternative_tile", "coords"), &TileMapLayer::get_cell_alternative_tile); + ClassDB::bind_method(D_METHOD("get_cell_tile_data", "coords"), &TileMapLayer::get_cell_tile_data); + + ClassDB::bind_method(D_METHOD("get_used_cells"), &TileMapLayer::get_used_cells); + ClassDB::bind_method(D_METHOD("get_used_cells_by_id", "source_id", "atlas_coords", "alternative_tile"), &TileMapLayer::get_used_cells_by_id, DEFVAL(TileSet::INVALID_SOURCE), DEFVAL(TileSetSource::INVALID_ATLAS_COORDS), DEFVAL(TileSetSource::INVALID_TILE_ALTERNATIVE)); + ClassDB::bind_method(D_METHOD("get_used_rect"), &TileMapLayer::get_used_rect); + + // Patterns. + ClassDB::bind_method(D_METHOD("get_pattern", "coords_array"), &TileMapLayer::get_pattern); + ClassDB::bind_method(D_METHOD("set_pattern", "position", "pattern"), &TileMapLayer::set_pattern); + + // Terrains. + ClassDB::bind_method(D_METHOD("set_cells_terrain_connect", "cells", "terrain_set", "terrain", "ignore_empty_terrains"), &TileMapLayer::set_cells_terrain_connect, DEFVAL(true)); + ClassDB::bind_method(D_METHOD("set_cells_terrain_path", "path", "terrain_set", "terrain", "ignore_empty_terrains"), &TileMapLayer::set_cells_terrain_path, DEFVAL(true)); + + // --- Physics helpers --- + ClassDB::bind_method(D_METHOD("has_body_rid", "body"), &TileMapLayer::has_body_rid); + ClassDB::bind_method(D_METHOD("get_coords_for_body_rid", "body"), &TileMapLayer::get_coords_for_body_rid); + + // --- Runtime --- + ClassDB::bind_method(D_METHOD("update_internals"), &TileMapLayer::update_internals); + ClassDB::bind_method(D_METHOD("notify_runtime_tile_data_update"), &TileMapLayer::notify_runtime_tile_data_update, DEFVAL(-1)); + + // --- Shortcuts to methods defined in TileSet --- + ClassDB::bind_method(D_METHOD("map_pattern", "position_in_tilemap", "coords_in_pattern", "pattern"), &TileMapLayer::map_pattern); + ClassDB::bind_method(D_METHOD("get_surrounding_cells", "coords"), &TileMapLayer::get_surrounding_cells); + ClassDB::bind_method(D_METHOD("get_neighbor_cell", "coords", "neighbor"), &TileMapLayer::get_neighbor_cell); + ClassDB::bind_method(D_METHOD("map_to_local", "map_position"), &TileMapLayer::map_to_local); + ClassDB::bind_method(D_METHOD("local_to_map", "local_position"), &TileMapLayer::local_to_map); + + // --- Accessors --- + ClassDB::bind_method(D_METHOD("set_tile_map_data_from_array", "tile_map_layer_data"), &TileMapLayer::set_tile_map_data_from_array); + ClassDB::bind_method(D_METHOD("get_tile_map_data_as_array"), &TileMapLayer::get_tile_map_data_as_array); + + ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &TileMapLayer::set_enabled); + ClassDB::bind_method(D_METHOD("is_enabled"), &TileMapLayer::is_enabled); + + ClassDB::bind_method(D_METHOD("set_tile_set", "tile_set"), &TileMapLayer::set_tile_set); + ClassDB::bind_method(D_METHOD("get_tile_set"), &TileMapLayer::get_tile_set); + + ClassDB::bind_method(D_METHOD("set_y_sort_origin", "y_sort_origin"), &TileMapLayer::set_y_sort_origin); + ClassDB::bind_method(D_METHOD("get_y_sort_origin"), &TileMapLayer::get_y_sort_origin); + ClassDB::bind_method(D_METHOD("set_rendering_quadrant_size", "size"), &TileMapLayer::set_rendering_quadrant_size); + ClassDB::bind_method(D_METHOD("get_rendering_quadrant_size"), &TileMapLayer::get_rendering_quadrant_size); + + ClassDB::bind_method(D_METHOD("set_collision_enabled", "enabled"), &TileMapLayer::set_collision_enabled); + ClassDB::bind_method(D_METHOD("is_collision_enabled"), &TileMapLayer::is_collision_enabled); + ClassDB::bind_method(D_METHOD("set_use_kinematic_bodies", "use_kinematic_bodies"), &TileMapLayer::set_use_kinematic_bodies); + ClassDB::bind_method(D_METHOD("is_using_kinematic_bodies"), &TileMapLayer::is_using_kinematic_bodies); + ClassDB::bind_method(D_METHOD("set_collision_visibility_mode", "visibility_mode"), &TileMapLayer::set_collision_visibility_mode); + ClassDB::bind_method(D_METHOD("get_collision_visibility_mode"), &TileMapLayer::get_collision_visibility_mode); + + ClassDB::bind_method(D_METHOD("set_navigation_enabled", "enabled"), &TileMapLayer::set_navigation_enabled); + ClassDB::bind_method(D_METHOD("is_navigation_enabled"), &TileMapLayer::is_navigation_enabled); + ClassDB::bind_method(D_METHOD("set_navigation_map", "map"), &TileMapLayer::set_navigation_map); + ClassDB::bind_method(D_METHOD("get_navigation_map"), &TileMapLayer::get_navigation_map); + ClassDB::bind_method(D_METHOD("set_navigation_visibility_mode", "show_navigation"), &TileMapLayer::set_navigation_visibility_mode); + ClassDB::bind_method(D_METHOD("get_navigation_visibility_mode"), &TileMapLayer::get_navigation_visibility_mode); GDVIRTUAL_BIND(_use_tile_data_runtime_update, "coords"); GDVIRTUAL_BIND(_tile_data_runtime_update, "coords", "tile_data"); + ADD_PROPERTY(PropertyInfo(Variant::PACKED_BYTE_ARRAY, "tile_map_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "set_tile_map_data_from_array", "get_tile_map_data_as_array"); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enabled"), "set_enabled", "is_enabled"); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "TileSet"), "set_tile_set", "get_tile_set"); + ADD_GROUP("Rendering", ""); + ADD_PROPERTY(PropertyInfo(Variant::INT, "y_sort_origin"), "set_y_sort_origin", "get_y_sort_origin"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "rendering_quadrant_size"), "set_rendering_quadrant_size", "get_rendering_quadrant_size"); + ADD_GROUP("Physics", ""); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision_enabled"), "set_collision_enabled", "is_collision_enabled"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_kinematic_bodies"), "set_use_kinematic_bodies", "is_using_kinematic_bodies"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_visibility_mode", PROPERTY_HINT_ENUM, "Default,Force Show,Force Hide"), "set_collision_visibility_mode", "get_collision_visibility_mode"); + ADD_GROUP("Navigation", ""); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "navigation_enabled"), "set_navigation_enabled", "is_navigation_enabled"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "navigation_visibility_mode", PROPERTY_HINT_ENUM, "Default,Force Show,Force Hide"), "set_navigation_visibility_mode", "get_navigation_visibility_mode"); + ADD_SIGNAL(MethodInfo(CoreStringNames::get_singleton()->changed)); + + ADD_PROPERTY_DEFAULT("tile_map_data_format", TileMapDataFormat::TILE_MAP_DATA_FORMAT_1); + + BIND_ENUM_CONSTANT(DEBUG_VISIBILITY_MODE_DEFAULT); + BIND_ENUM_CONSTANT(DEBUG_VISIBILITY_MODE_FORCE_HIDE); + BIND_ENUM_CONSTANT(DEBUG_VISIBILITY_MODE_FORCE_SHOW); +} + +void TileMapLayer::_update_self_texture_filter(RS::CanvasItemTextureFilter p_texture_filter) { + // Set a default texture filter for the whole tilemap. + CanvasItem::_update_self_texture_filter(p_texture_filter); + dirty.flags[DIRTY_FLAGS_LAYER_TEXTURE_FILTER] = true; + _queue_internal_update(); + emit_signal(CoreStringNames::get_singleton()->changed); +} + +void TileMapLayer::_update_self_texture_repeat(RS::CanvasItemTextureRepeat p_texture_repeat) { + // Set a default texture repeat for the whole tilemap. + CanvasItem::_update_self_texture_repeat(p_texture_repeat); + dirty.flags[DIRTY_FLAGS_LAYER_TEXTURE_REPEAT] = true; + _queue_internal_update(); + emit_signal(CoreStringNames::get_singleton()->changed); } void TileMapLayer::set_as_tile_map_internal_node(int p_index) { @@ -1776,7 +1846,6 @@ void TileMapLayer::set_as_tile_map_internal_node(int p_index) { } Rect2 TileMapLayer::get_rect(bool &r_changed) const { - const Ref &tile_set = get_effective_tile_set(); if (tile_set.is_null()) { r_changed = rect_cache != Rect2(); return Rect2(); @@ -1789,7 +1858,7 @@ Rect2 TileMapLayer::get_rect(bool &r_changed) const { if (rect_cache_dirty) { Rect2 r_total; bool first = true; - for (const KeyValue &E : tile_map) { + for (const KeyValue &E : tile_map_layer_data) { Rect2 r; r.position = tile_set->map_to_local(E.key); r.size = Size2(); @@ -1811,8 +1880,7 @@ Rect2 TileMapLayer::get_rect(bool &r_changed) const { } HashMap TileMapLayer::terrain_fill_constraints(const Vector &p_to_replace, int p_terrain_set, const RBSet &p_constraints) const { - const Ref &tile_set = get_effective_tile_set(); - if (!tile_set.is_valid()) { + if (tile_set.is_null()) { return HashMap(); } @@ -1860,8 +1928,7 @@ HashMap TileMapLayer::terrain_fill_constrain HashMap TileMapLayer::terrain_fill_connect(const Vector &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) const { HashMap output; - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND_V(!tile_set.is_valid(), output); + ERR_FAIL_COND_V(tile_set.is_null(), output); ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), output); // Build list and set of tiles that can be modified (painted and their surroundings). @@ -1966,8 +2033,7 @@ HashMap TileMapLayer::terrain_fill_connect(c HashMap TileMapLayer::terrain_fill_path(const Vector &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) const { HashMap output; - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND_V(!tile_set.is_valid(), output); + ERR_FAIL_COND_V(tile_set.is_null(), output); ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), output); // Make sure the path is correct and build the peering bit list while doing it. @@ -2040,8 +2106,7 @@ HashMap TileMapLayer::terrain_fill_path(cons HashMap TileMapLayer::terrain_fill_pattern(const Vector &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains) const { HashMap output; - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND_V(!tile_set.is_valid(), output); + ERR_FAIL_COND_V(tile_set.is_null(), output); ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), output); // Build list and set of tiles that can be modified (painted and their surroundings). @@ -2091,153 +2156,18 @@ HashMap TileMapLayer::terrain_fill_pattern(c return output; } -TileMapCell TileMapLayer::get_cell(const Vector2i &p_coords, bool p_use_proxies) const { - if (!tile_map.has(p_coords)) { +TileMapCell TileMapLayer::get_cell(const Vector2i &p_coords) const { + if (!tile_map_layer_data.has(p_coords)) { return TileMapCell(); } else { - TileMapCell c = tile_map.find(p_coords)->value.cell; - const Ref &tile_set = get_effective_tile_set(); - if (p_use_proxies && tile_set.is_valid()) { - Array proxyed = tile_set->map_tile_proxy(c.source_id, c.get_atlas_coords(), c.alternative_tile); - c.source_id = proxyed[0]; - c.set_atlas_coords(proxyed[1]); - c.alternative_tile = proxyed[2]; - } - return c; + return tile_map_layer_data.find(p_coords)->value.cell; } } -void TileMapLayer::set_tile_data(TileMapDataFormat p_format, const Vector &p_data) { - ERR_FAIL_COND(p_format > TileMapDataFormat::FORMAT_3); - - // Set data for a given tile from raw data. - - int c = p_data.size(); - const int *r = p_data.ptr(); - - int offset = (p_format >= TileMapDataFormat::FORMAT_2) ? 3 : 2; - ERR_FAIL_COND_MSG(c % offset != 0, vformat("Corrupted tile data. Got size: %s. Expected modulo: %s", offset)); - - clear(); - -#ifdef DISABLE_DEPRECATED - ERR_FAIL_COND_MSG(p_format != TileMapDataFormat::FORMAT_3, vformat("Cannot handle deprecated TileMapLayer data format version %d. This Godot version was compiled with no support for deprecated data.", p_format)); -#endif - - for (int i = 0; i < c; i += offset) { - const uint8_t *ptr = (const uint8_t *)&r[i]; - uint8_t local[12]; - for (int j = 0; j < ((p_format >= TileMapDataFormat::FORMAT_2) ? 12 : 8); j++) { - local[j] = ptr[j]; - } - -#ifdef BIG_ENDIAN_ENABLED - - SWAP(local[0], local[3]); - 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) { - SWAP(local[8], local[11]); - SWAP(local[9], local[10]); - } -#endif - // Extracts position in TileMap. - int16_t x = decode_uint16(&local[0]); - int16_t y = decode_uint16(&local[2]); - - if (p_format == TileMapDataFormat::FORMAT_3) { - uint16_t source_id = decode_uint16(&local[4]); - uint16_t atlas_coords_x = decode_uint16(&local[6]); - uint16_t atlas_coords_y = decode_uint16(&local[8]); - uint16_t alternative_tile = decode_uint16(&local[10]); - set_cell(Vector2i(x, y), source_id, Vector2i(atlas_coords_x, atlas_coords_y), alternative_tile); - } else { -#ifndef DISABLE_DEPRECATED - // Previous decated format. - - uint32_t v = decode_uint32(&local[4]); - // Extract the transform flags that used to be in the tilemap. - bool flip_h = v & (1UL << 29); - bool flip_v = v & (1UL << 30); - bool transpose = v & (1UL << 31); - v &= (1UL << 29) - 1; - - // Extract autotile/atlas coords. - int16_t coord_x = 0; - int16_t coord_y = 0; - if (p_format == TileMapDataFormat::FORMAT_2) { - coord_x = decode_uint16(&local[8]); - coord_y = decode_uint16(&local[10]); - } - - const Ref &tile_set = get_effective_tile_set(); - if (tile_set.is_valid()) { - Array a = tile_set->compatibility_tilemap_map(v, Vector2i(coord_x, coord_y), flip_h, flip_v, transpose); - if (a.size() == 3) { - set_cell(Vector2i(x, y), a[0], a[1], a[2]); - } else { - ERR_PRINT(vformat("No valid tile in Tileset for: tile:%s coords:%s flip_h:%s flip_v:%s transpose:%s", v, Vector2i(coord_x, coord_y), flip_h, flip_v, transpose)); - } - } else { - int compatibility_alternative_tile = ((int)flip_h) + ((int)flip_v << 1) + ((int)transpose << 2); - set_cell(Vector2i(x, y), v, Vector2i(coord_x, coord_y), compatibility_alternative_tile); - } -#endif - } - } -} - -Vector TileMapLayer::get_tile_data() const { - // Export tile data to raw format. - Vector tile_data; - tile_data.resize(tile_map.size() * 3); - int *w = tile_data.ptrw(); - - // Save in highest format. - - int idx = 0; - for (const KeyValue &E : tile_map) { - uint8_t *ptr = (uint8_t *)&w[idx]; - encode_uint16((int16_t)(E.key.x), &ptr[0]); - encode_uint16((int16_t)(E.key.y), &ptr[2]); - encode_uint16(E.value.cell.source_id, &ptr[4]); - encode_uint16(E.value.cell.coord_x, &ptr[6]); - encode_uint16(E.value.cell.coord_y, &ptr[8]); - encode_uint16(E.value.cell.alternative_tile, &ptr[10]); - idx += 3; - } - - return tile_data; -} - -void TileMapLayer::notify_tile_map_layer_group_change(DirtyFlags p_what) { - if (p_what == DIRTY_FLAGS_LAYER_GROUP_SELECTED_LAYERS || - p_what == DIRTY_FLAGS_LAYER_GROUP_HIGHLIGHT_SELECTED || - p_what == DIRTY_FLAGS_LAYER_GROUP_TILE_SET) { - emit_signal(CoreStringNames::get_singleton()->changed); - } - - dirty.flags[p_what] = true; - _queue_internal_update(); -} - -void TileMapLayer::update_internals() { - pending_update = true; - _deferred_internal_update(); -} - -void TileMapLayer::notify_runtime_tile_data_update() { - dirty.flags[TileMapLayer::DIRTY_FLAGS_LAYER_RUNTIME_UPDATE] = true; - _queue_internal_update(); - emit_signal(CoreStringNames::get_singleton()->changed); -} - -void TileMapLayer::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) { +void TileMapLayer::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i &p_atlas_coords, int p_alternative_tile) { // Set the current cell tile (using integer position). Vector2i pk(p_coords); - HashMap::Iterator E = tile_map.find(pk); + HashMap::Iterator E = tile_map_layer_data.find(pk); int source_id = p_source_id; Vector2i atlas_coords = p_atlas_coords; @@ -2258,7 +2188,7 @@ void TileMapLayer::set_cell(const Vector2i &p_coords, int p_source_id, const Vec // Insert a new cell in the tile map. CellData new_cell_data; new_cell_data.coords = pk; - E = tile_map.insert(pk, new_cell_data); + E = tile_map_layer_data.insert(pk, new_cell_data); } else { if (E->value.cell.source_id == source_id && E->value.cell.get_atlas_coords() == atlas_coords && E->value.cell.alternative_tile == alternative_tile) { return; // Nothing changed. @@ -2283,83 +2213,139 @@ void TileMapLayer::erase_cell(const Vector2i &p_coords) { set_cell(p_coords, TileSet::INVALID_SOURCE, TileSetSource::INVALID_ATLAS_COORDS, TileSetSource::INVALID_TILE_ALTERNATIVE); } -int TileMapLayer::get_cell_source_id(const Vector2i &p_coords, bool p_use_proxies) const { - // Get a cell source id from position. - HashMap::ConstIterator E = tile_map.find(p_coords); +void TileMapLayer::fix_invalid_tiles() { + ERR_FAIL_COND_MSG(tile_set.is_null(), "Cannot call fix_invalid_tiles() on a TileMap without a valid TileSet."); - if (!E) { - return TileSet::INVALID_SOURCE; + RBSet coords; + for (const KeyValue &E : tile_map_layer_data) { + TileSetSource *source = *tile_set->get_source(E.value.cell.source_id); + if (!source || !source->has_tile(E.value.cell.get_atlas_coords()) || !source->has_alternative_tile(E.value.cell.get_atlas_coords(), E.value.cell.alternative_tile)) { + coords.insert(E.key); + } } - - const Ref &tile_set = get_effective_tile_set(); - if (p_use_proxies && tile_set.is_valid()) { - Array proxyed = tile_set->map_tile_proxy(E->value.cell.source_id, E->value.cell.get_atlas_coords(), E->value.cell.alternative_tile); - return proxyed[0]; + for (const Vector2i &E : coords) { + set_cell(E, TileSet::INVALID_SOURCE, TileSetSource::INVALID_ATLAS_COORDS, TileSetSource::INVALID_TILE_ALTERNATIVE); } - - return E->value.cell.source_id; -} - -Vector2i TileMapLayer::get_cell_atlas_coords(const Vector2i &p_coords, bool p_use_proxies) const { - // Get a cell source id from position. - HashMap::ConstIterator E = tile_map.find(p_coords); - - if (!E) { - return TileSetSource::INVALID_ATLAS_COORDS; - } - - const Ref &tile_set = get_effective_tile_set(); - if (p_use_proxies && tile_set.is_valid()) { - Array proxyed = tile_set->map_tile_proxy(E->value.cell.source_id, E->value.cell.get_atlas_coords(), E->value.cell.alternative_tile); - return proxyed[1]; - } - - return E->value.cell.get_atlas_coords(); -} - -int TileMapLayer::get_cell_alternative_tile(const Vector2i &p_coords, bool p_use_proxies) const { - // Get a cell source id from position. - HashMap::ConstIterator E = tile_map.find(p_coords); - - if (!E) { - return TileSetSource::INVALID_TILE_ALTERNATIVE; - } - - const Ref &tile_set = get_effective_tile_set(); - if (p_use_proxies && tile_set.is_valid()) { - Array proxyed = tile_set->map_tile_proxy(E->value.cell.source_id, E->value.cell.get_atlas_coords(), E->value.cell.alternative_tile); - return proxyed[2]; - } - - return E->value.cell.alternative_tile; -} - -TileData *TileMapLayer::get_cell_tile_data(const Vector2i &p_coords, bool p_use_proxies) const { - int source_id = get_cell_source_id(p_coords, p_use_proxies); - if (source_id == TileSet::INVALID_SOURCE) { - return nullptr; - } - - const Ref &tile_set = get_effective_tile_set(); - Ref source = tile_set->get_source(source_id); - if (source.is_valid()) { - return source->get_tile_data(get_cell_atlas_coords(p_coords, p_use_proxies), get_cell_alternative_tile(p_coords, p_use_proxies)); - } - - return nullptr; } void TileMapLayer::clear() { // Remove all tiles. - for (KeyValue &kv : tile_map) { + for (KeyValue &kv : tile_map_layer_data) { erase_cell(kv.key); } used_rect_cache_dirty = true; } +int TileMapLayer::get_cell_source_id(const Vector2i &p_coords) const { + // Get a cell source id from position. + HashMap::ConstIterator E = tile_map_layer_data.find(p_coords); + + if (!E) { + return TileSet::INVALID_SOURCE; + } + + return E->value.cell.source_id; +} + +Vector2i TileMapLayer::get_cell_atlas_coords(const Vector2i &p_coords) const { + // Get a cell source id from position. + HashMap::ConstIterator E = tile_map_layer_data.find(p_coords); + + if (!E) { + return TileSetSource::INVALID_ATLAS_COORDS; + } + + return E->value.cell.get_atlas_coords(); +} + +int TileMapLayer::get_cell_alternative_tile(const Vector2i &p_coords) const { + // Get a cell source id from position. + HashMap::ConstIterator E = tile_map_layer_data.find(p_coords); + + if (!E) { + return TileSetSource::INVALID_TILE_ALTERNATIVE; + } + + return E->value.cell.alternative_tile; +} + +TileData *TileMapLayer::get_cell_tile_data(const Vector2i &p_coords) const { + int source_id = get_cell_source_id(p_coords); + if (source_id == TileSet::INVALID_SOURCE) { + return nullptr; + } + + Ref source = tile_set->get_source(source_id); + if (source.is_valid()) { + return source->get_tile_data(get_cell_atlas_coords(p_coords), get_cell_alternative_tile(p_coords)); + } + + return nullptr; +} + +TypedArray TileMapLayer::get_used_cells() const { + // Returns the cells used in the tilemap. + TypedArray a; + for (const KeyValue &E : tile_map_layer_data) { + const TileMapCell &c = E.value.cell; + if (c.source_id == TileSet::INVALID_SOURCE) { + continue; + } + a.push_back(E.key); + } + + return a; +} + +TypedArray TileMapLayer::get_used_cells_by_id(int p_source_id, const Vector2i &p_atlas_coords, int p_alternative_tile) const { + // Returns the cells used in the tilemap. + TypedArray a; + for (const KeyValue &E : tile_map_layer_data) { + const TileMapCell &c = E.value.cell; + if (c.source_id == TileSet::INVALID_SOURCE) { + continue; + } + if ((p_source_id == TileSet::INVALID_SOURCE || p_source_id == c.source_id) && + (p_atlas_coords == TileSetSource::INVALID_ATLAS_COORDS || p_atlas_coords == c.get_atlas_coords()) && + (p_alternative_tile == TileSetSource::INVALID_TILE_ALTERNATIVE || p_alternative_tile == c.alternative_tile)) { + a.push_back(E.key); + } + } + + return a; +} + +Rect2i TileMapLayer::get_used_rect() const { + // Return the rect of the currently used area. + if (used_rect_cache_dirty) { + used_rect_cache = Rect2i(); + + bool first = true; + for (const KeyValue &E : tile_map_layer_data) { + const TileMapCell &c = E.value.cell; + if (c.source_id == TileSet::INVALID_SOURCE) { + continue; + } + if (first) { + used_rect_cache = Rect2i(E.key, Size2i()); + first = false; + } else { + used_rect_cache.expand_to(E.key); + } + } + if (!first) { + // Only if we have at least one cell. + // The cache expands to top-left coordinate, so we add one full tile. + used_rect_cache.size += Vector2i(1, 1); + } + used_rect_cache_dirty = false; + } + + return used_rect_cache; +} + Ref TileMapLayer::get_pattern(TypedArray p_coords_array) { - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr); + ERR_FAIL_COND_V(tile_set.is_null(), nullptr); Ref output; output.instantiate(); @@ -2412,7 +2398,6 @@ Ref TileMapLayer::get_pattern(TypedArray p_coords_arra } void TileMapLayer::set_pattern(const Vector2i &p_position, const Ref p_pattern) { - const Ref &tile_set = get_effective_tile_set(); ERR_FAIL_COND(tile_set.is_null()); ERR_FAIL_COND(p_pattern.is_null()); @@ -2424,8 +2409,7 @@ void TileMapLayer::set_pattern(const Vector2i &p_position, const Ref p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) { - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND(!tile_set.is_valid()); + ERR_FAIL_COND(tile_set.is_null()); ERR_FAIL_INDEX(p_terrain_set, tile_set->get_terrain_sets_count()); Vector cells_vector; @@ -2464,8 +2448,7 @@ void TileMapLayer::set_cells_terrain_connect(TypedArray p_cells, int p } void TileMapLayer::set_cells_terrain_path(TypedArray p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) { - const Ref &tile_set = get_effective_tile_set(); - ERR_FAIL_COND(!tile_set.is_valid()); + ERR_FAIL_COND(tile_set.is_null()); ERR_FAIL_INDEX(p_terrain_set, tile_set->get_terrain_sets_count()); Vector vector_path; @@ -2504,65 +2487,50 @@ void TileMapLayer::set_cells_terrain_path(TypedArray p_path, int p_ter } } -TypedArray TileMapLayer::get_used_cells() const { - // Returns the cells used in the tilemap. - TypedArray a; - for (const KeyValue &E : tile_map) { - const TileMapCell &c = E.value.cell; - if (c.source_id == TileSet::INVALID_SOURCE) { - continue; - } - a.push_back(E.key); - } - - return a; +bool TileMapLayer::has_body_rid(RID p_physics_body) const { + return bodies_coords.has(p_physics_body); } -TypedArray TileMapLayer::get_used_cells_by_id(int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) const { - // Returns the cells used in the tilemap. - TypedArray a; - for (const KeyValue &E : tile_map) { - const TileMapCell &c = E.value.cell; - if (c.source_id == TileSet::INVALID_SOURCE) { - continue; - } - if ((p_source_id == TileSet::INVALID_SOURCE || p_source_id == c.source_id) && - (p_atlas_coords == TileSetSource::INVALID_ATLAS_COORDS || p_atlas_coords == c.get_atlas_coords()) && - (p_alternative_tile == TileSetSource::INVALID_TILE_ALTERNATIVE || p_alternative_tile == c.alternative_tile)) { - a.push_back(E.key); - } - } - - return a; +Vector2i TileMapLayer::get_coords_for_body_rid(RID p_physics_body) const { + const Vector2i *found = bodies_coords.getptr(p_physics_body); + ERR_FAIL_NULL_V(found, Vector2i()); + return *found; } -Rect2i TileMapLayer::get_used_rect() const { - // Return the rect of the currently used area. - if (used_rect_cache_dirty) { - used_rect_cache = Rect2i(); +void TileMapLayer::update_internals() { + pending_update = true; + _deferred_internal_update(); +} - bool first = true; - for (const KeyValue &E : tile_map) { - const TileMapCell &c = E.value.cell; - if (c.source_id == TileSet::INVALID_SOURCE) { - continue; - } - if (first) { - used_rect_cache = Rect2i(E.key.x, E.key.y, 0, 0); - first = false; - } else { - used_rect_cache.expand_to(E.key); - } - } - if (!first) { - // Only if we have at least one cell. - // The cache expands to top-left coordinate, so we add one full tile. - used_rect_cache.size += Vector2i(1, 1); - } - used_rect_cache_dirty = false; - } +void TileMapLayer::notify_runtime_tile_data_update() { + dirty.flags[TileMapLayer::DIRTY_FLAGS_LAYER_RUNTIME_UPDATE] = true; + _queue_internal_update(); + emit_signal(CoreStringNames::get_singleton()->changed); +} - return used_rect_cache; +Vector2i TileMapLayer::map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref p_pattern) { + ERR_FAIL_COND_V(tile_set.is_null(), Vector2i()); + return tile_set->map_pattern(p_position_in_tilemap, p_coords_in_pattern, p_pattern); +} + +TypedArray TileMapLayer::get_surrounding_cells(const Vector2i &p_coords) { + ERR_FAIL_COND_V(tile_set.is_null(), TypedArray()); + return tile_set->get_surrounding_cells(p_coords); +} + +Vector2i TileMapLayer::get_neighbor_cell(const Vector2i &p_coords, TileSet::CellNeighbor p_cell_neighbor) const { + ERR_FAIL_COND_V(tile_set.is_null(), Vector2i()); + return tile_set->get_neighbor_cell(p_coords, p_cell_neighbor); +} + +Vector2 TileMapLayer::map_to_local(const Vector2i &p_pos) const { + ERR_FAIL_COND_V(tile_set.is_null(), Vector2()); + return tile_set->map_to_local(p_pos); +} + +Vector2i TileMapLayer::local_to_map(const Vector2 &p_pos) const { + ERR_FAIL_COND_V(tile_set.is_null(), Vector2i()); + return tile_set->local_to_map(p_pos); } void TileMapLayer::set_enabled(bool p_enabled) { @@ -2573,16 +2541,127 @@ void TileMapLayer::set_enabled(bool p_enabled) { dirty.flags[DIRTY_FLAGS_LAYER_ENABLED] = true; _queue_internal_update(); emit_signal(CoreStringNames::get_singleton()->changed); - - if (tile_map_node) { - tile_map_node->update_configuration_warnings(); - } } bool TileMapLayer::is_enabled() const { return enabled; } +void TileMapLayer::set_tile_set(const Ref &p_tile_set) { + if (p_tile_set == tile_set) { + return; + } + + dirty.flags[DIRTY_FLAGS_TILE_SET] = true; + _queue_internal_update(); + + // Set the TileSet, registering to its changes. + if (tile_set.is_valid()) { + tile_set->disconnect_changed(callable_mp(this, &TileMapLayer::_tile_set_changed)); + } + + tile_set = p_tile_set; + + if (tile_set.is_valid()) { + tile_set->connect_changed(callable_mp(this, &TileMapLayer::_tile_set_changed)); + } + + emit_signal(CoreStringNames::get_singleton()->changed); + + // Trigger updates for TileSet's read-only status. + notify_property_list_changed(); +} + +Ref TileMapLayer::get_tile_set() const { + return tile_set; +} + +void TileMapLayer::set_highlight_mode(HighlightMode p_highlight_mode) { + if (p_highlight_mode == highlight_mode) { + return; + } + highlight_mode = p_highlight_mode; + _queue_internal_update(); +} + +TileMapLayer::HighlightMode TileMapLayer::get_highlight_mode() const { + return highlight_mode; +} + +void TileMapLayer::set_tile_map_data_from_array(const Vector &p_data) { + const int cell_data_struct_size = 12; + + int size = p_data.size(); + const uint8_t *ptr = p_data.ptr(); + + // Index in the array. + int index = 0; + + // First extract the data version. + ERR_FAIL_COND_MSG(size < 2, "Corrupted tile map data: not enough bytes."); + uint16_t format = decode_uint16(&ptr[index]); + index += 2; + ERR_FAIL_COND_MSG(format >= TileMapLayerDataFormat::TILE_MAP_LAYER_DATA_FORMAT_MAX, vformat("Unsupported tile map data format: %s. Expected format ID lower or equal to: %s", format, TileMapLayerDataFormat::TILE_MAP_LAYER_DATA_FORMAT_MAX - 1)); + + // Clear the TileMap. + clear(); + + while (index < size) { + ERR_FAIL_COND_MSG(index + cell_data_struct_size > size, vformat("Corrupted tile map data: tiles might be missing.")); + + // Get a pointer at the start of the cell data. + const uint8_t *cell_data_ptr = &ptr[index]; + + // Extracts position in TileMap. + int16_t x = decode_uint16(&cell_data_ptr[0]); + int16_t y = decode_uint16(&cell_data_ptr[2]); + + // Extracts the tile identifiers. + uint16_t source_id = decode_uint16(&cell_data_ptr[4]); + uint16_t atlas_coords_x = decode_uint16(&cell_data_ptr[6]); + uint16_t atlas_coords_y = decode_uint16(&cell_data_ptr[8]); + uint16_t alternative_tile = decode_uint16(&cell_data_ptr[10]); + + set_cell(Vector2i(x, y), source_id, Vector2i(atlas_coords_x, atlas_coords_y), alternative_tile); + index += cell_data_struct_size; + } +} + +Vector TileMapLayer::get_tile_map_data_as_array() const { + const int cell_data_struct_size = 12; + + Vector tile_map_data_array; + tile_map_data_array.resize(2 + tile_map_layer_data.size() * cell_data_struct_size); + uint8_t *ptr = tile_map_data_array.ptrw(); + + // Index in the array. + int index = 0; + + // Save the version. + encode_uint16(TileMapLayerDataFormat::TILE_MAP_LAYER_DATA_FORMAT_MAX - 1, &ptr[index]); + index += 2; + + // Save in highest format. + for (const KeyValue &E : tile_map_layer_data) { + // Get a pointer at the start of the cell data. + uint8_t *cell_data_ptr = (uint8_t *)&ptr[index]; + + // Store position in TileMap. + encode_uint16((int16_t)(E.key.x), &cell_data_ptr[0]); + encode_uint16((int16_t)(E.key.y), &cell_data_ptr[2]); + + // Store the tile identifiers. + encode_uint16(E.value.cell.source_id, &cell_data_ptr[4]); + encode_uint16(E.value.cell.coord_x, &cell_data_ptr[6]); + encode_uint16(E.value.cell.coord_y, &cell_data_ptr[8]); + encode_uint16(E.value.cell.alternative_tile, &cell_data_ptr[10]); + + index += cell_data_struct_size; + } + + return tile_map_data_array; +} + void TileMapLayer::set_self_modulate(const Color &p_self_modulate) { if (get_self_modulate() == p_self_modulate) { return; @@ -2602,9 +2681,6 @@ void TileMapLayer::set_y_sort_enabled(bool p_y_sort_enabled) { _queue_internal_update(); emit_signal(CoreStringNames::get_singleton()->changed); - if (tile_map_node) { - tile_map_node->update_configuration_warnings(); - } _update_notify_local_transform(); } @@ -2630,10 +2706,6 @@ void TileMapLayer::set_z_index(int p_z_index) { dirty.flags[DIRTY_FLAGS_LAYER_Z_INDEX] = true; _queue_internal_update(); emit_signal(CoreStringNames::get_singleton()->changed); - - if (tile_map_node) { - tile_map_node->update_configuration_warnings(); - } } void TileMapLayer::set_light_mask(int p_light_mask) { @@ -2646,22 +2718,6 @@ void TileMapLayer::set_light_mask(int p_light_mask) { emit_signal(CoreStringNames::get_singleton()->changed); } -void TileMapLayer::set_texture_filter(TextureFilter p_texture_filter) { - // Set a default texture filter for the whole tilemap. - CanvasItem::set_texture_filter(p_texture_filter); - dirty.flags[DIRTY_FLAGS_LAYER_TEXTURE_FILTER] = true; - _queue_internal_update(); - emit_signal(CoreStringNames::get_singleton()->changed); -} - -void TileMapLayer::set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) { - // Set a default texture repeat for the whole tilemap. - CanvasItem::set_texture_repeat(p_texture_repeat); - dirty.flags[DIRTY_FLAGS_LAYER_TEXTURE_REPEAT] = true; - _queue_internal_update(); - emit_signal(CoreStringNames::get_singleton()->changed); -} - void TileMapLayer::set_rendering_quadrant_size(int p_size) { if (rendering_quadrant_size == p_size) { return; @@ -2678,6 +2734,20 @@ int TileMapLayer::get_rendering_quadrant_size() const { return rendering_quadrant_size; } +void TileMapLayer::set_collision_enabled(bool p_enabled) { + if (collision_enabled == p_enabled) { + return; + } + collision_enabled = p_enabled; + dirty.flags[DIRTY_FLAGS_LAYER_COLLISION_ENABLED] = true; + _queue_internal_update(); + emit_signal(CoreStringNames::get_singleton()->changed); +} + +bool TileMapLayer::is_collision_enabled() const { + return collision_enabled; +} + void TileMapLayer::set_use_kinematic_bodies(bool p_use_kinematic_bodies) { use_kinematic_bodies = p_use_kinematic_bodies; dirty.flags[DIRTY_FLAGS_LAYER_USE_KINEMATIC_BODIES] = p_use_kinematic_bodies; @@ -2689,7 +2759,7 @@ bool TileMapLayer::is_using_kinematic_bodies() const { return use_kinematic_bodies; } -void TileMapLayer::set_collision_visibility_mode(TileMapLayer::VisibilityMode p_show_collision) { +void TileMapLayer::set_collision_visibility_mode(TileMapLayer::DebugVisibilityMode p_show_collision) { if (collision_visibility_mode == p_show_collision) { return; } @@ -2699,7 +2769,7 @@ void TileMapLayer::set_collision_visibility_mode(TileMapLayer::VisibilityMode p_ emit_signal(CoreStringNames::get_singleton()->changed); } -TileMapLayer::VisibilityMode TileMapLayer::get_collision_visibility_mode() const { +TileMapLayer::DebugVisibilityMode TileMapLayer::get_collision_visibility_mode() const { return collision_visibility_mode; } @@ -2736,7 +2806,7 @@ RID TileMapLayer::get_navigation_map() const { return RID(); } -void TileMapLayer::set_navigation_visibility_mode(TileMapLayer::VisibilityMode p_show_navigation) { +void TileMapLayer::set_navigation_visibility_mode(TileMapLayer::DebugVisibilityMode p_show_navigation) { if (navigation_visibility_mode == p_show_navigation) { return; } @@ -2746,43 +2816,10 @@ void TileMapLayer::set_navigation_visibility_mode(TileMapLayer::VisibilityMode p emit_signal(CoreStringNames::get_singleton()->changed); } -TileMapLayer::VisibilityMode TileMapLayer::get_navigation_visibility_mode() const { +TileMapLayer::DebugVisibilityMode TileMapLayer::get_navigation_visibility_mode() const { return navigation_visibility_mode; } -void TileMapLayer::fix_invalid_tiles() { - Ref tileset = get_effective_tile_set(); - ERR_FAIL_COND_MSG(tileset.is_null(), "Cannot call fix_invalid_tiles() on a TileMap without a valid TileSet."); - - RBSet coords; - for (const KeyValue &E : tile_map) { - TileSetSource *source = *tileset->get_source(E.value.cell.source_id); - if (!source || !source->has_tile(E.value.cell.get_atlas_coords()) || !source->has_alternative_tile(E.value.cell.get_atlas_coords(), E.value.cell.alternative_tile)) { - coords.insert(E.key); - } - } - for (const Vector2i &E : coords) { - set_cell(E, TileSet::INVALID_SOURCE, TileSetSource::INVALID_ATLAS_COORDS, TileSetSource::INVALID_TILE_ALTERNATIVE); - } -} - -bool TileMapLayer::has_body_rid(RID p_physics_body) const { - return bodies_coords.has(p_physics_body); -} - -Vector2i TileMapLayer::get_coords_for_body_rid(RID p_physics_body) const { - return bodies_coords[p_physics_body]; -} - -Ref TileMapLayer::get_effective_tile_set() const { - TileMapLayerGroup *tile_map_layer_group = Object::cast_to(get_parent()); - if (tile_map_layer_group) { - return tile_map_layer_group->get_tileset(); - } else { - return Ref(); - } -} - TileMapLayer::TileMapLayer() { set_notify_transform(true); } diff --git a/scene/2d/tile_map_layer.h b/scene/2d/tile_map_layer.h index c58c72949c29..da48eb38d911 100644 --- a/scene/2d/tile_map_layer.h +++ b/scene/2d/tile_map_layer.h @@ -31,10 +31,15 @@ #ifndef TILE_MAP_LAYER_H #define TILE_MAP_LAYER_H -#include "scene/2d/tile_map.h" #include "scene/resources/2d/tile_set.h" class TileSetAtlasSource; +class TileMap; + +enum TileMapLayerDataFormat { + TILE_MAP_LAYER_DATA_FORMAT_0 = 0, + TILE_MAP_LAYER_DATA_FORMAT_MAX, +}; class TerrainConstraint { private: @@ -218,14 +223,21 @@ class TileMapLayer : public Node2D { GDCLASS(TileMapLayer, Node2D); public: - enum VisibilityMode { - VISIBILITY_MODE_DEFAULT, - VISIBILITY_MODE_FORCE_SHOW, - VISIBILITY_MODE_FORCE_HIDE, + enum HighlightMode { + HIGHLIGHT_MODE_DEFAULT, + HIGHLIGHT_MODE_ABOVE, + HIGHLIGHT_MODE_BELOW, + }; + + enum DebugVisibilityMode { + DEBUG_VISIBILITY_MODE_DEFAULT, + DEBUG_VISIBILITY_MODE_FORCE_SHOW, + DEBUG_VISIBILITY_MODE_FORCE_HIDE, }; enum DirtyFlags { DIRTY_FLAGS_LAYER_ENABLED = 0, + DIRTY_FLAGS_LAYER_IN_TREE, DIRTY_FLAGS_LAYER_IN_CANVAS, DIRTY_FLAGS_LAYER_LOCAL_TRANSFORM, @@ -238,6 +250,7 @@ public: DIRTY_FLAGS_LAYER_TEXTURE_FILTER, DIRTY_FLAGS_LAYER_TEXTURE_REPEAT, DIRTY_FLAGS_LAYER_RENDERING_QUADRANT_SIZE, + DIRTY_FLAGS_LAYER_COLLISION_ENABLED, DIRTY_FLAGS_LAYER_USE_KINEMATIC_BODIES, DIRTY_FLAGS_LAYER_COLLISION_VISIBILITY_MODE, DIRTY_FLAGS_LAYER_NAVIGATION_ENABLED, @@ -249,26 +262,33 @@ public: DIRTY_FLAGS_LAYER_GROUP_SELECTED_LAYERS, DIRTY_FLAGS_LAYER_GROUP_HIGHLIGHT_SELECTED, - DIRTY_FLAGS_LAYER_GROUP_TILE_SET, + + DIRTY_FLAGS_TILE_SET, DIRTY_FLAGS_MAX, }; private: - // Exposed properties. + // Properties. + HashMap tile_map_layer_data; + bool enabled = true; + Ref tile_set; + + HighlightMode highlight_mode = HIGHLIGHT_MODE_DEFAULT; + int y_sort_origin = 0; int rendering_quadrant_size = 16; + bool collision_enabled = true; bool use_kinematic_bodies = false; - VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT; + DebugVisibilityMode collision_visibility_mode = DEBUG_VISIBILITY_MODE_DEFAULT; bool navigation_enabled = true; RID navigation_map_override; - VisibilityMode navigation_visibility_mode = VISIBILITY_MODE_DEFAULT; + DebugVisibilityMode navigation_visibility_mode = DEBUG_VISIBILITY_MODE_DEFAULT; // Internal. - HashMap tile_map; bool pending_update = false; // For keeping compatibility with TileMap. @@ -348,6 +368,8 @@ private: RBSet _get_terrain_constraints_from_added_pattern(const Vector2i &p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const; RBSet _get_terrain_constraints_from_painted_cells_list(const RBSet &p_painted, int p_terrain_set, bool p_ignore_empty_terrains) const; + void _tile_set_changed(); + void _renamed(); void _update_notify_local_transform(); @@ -358,11 +380,21 @@ private: protected: void _notification(int p_what); + static void _bind_methods(); + virtual void _update_self_texture_filter(RS::CanvasItemTextureFilter p_texture_filter) override; + virtual void _update_self_texture_repeat(RS::CanvasItemTextureRepeat p_texture_repeat) override; + public: // TileMap node. void set_as_tile_map_internal_node(int p_index); + int get_index_in_tile_map() const { + return layer_index_in_tile_map_node; + } + const HashMap &get_tile_map_layer_data() const { + return tile_map_layer_data; + } // Rect caching. Rect2 get_rect(bool &r_changed) const; @@ -374,27 +406,26 @@ public: HashMap terrain_fill_pattern(const Vector &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains = true) const; // Not exposed. // Not exposed to users. - TileMapCell get_cell(const Vector2i &p_coords, bool p_use_proxies = false) const; + TileMapCell get_cell(const Vector2i &p_coords) const; - // For TileMap node's use. - void set_tile_data(TileMapDataFormat p_format, const Vector &p_data); - Vector get_tile_data() const; - void notify_tile_map_layer_group_change(DirtyFlags p_what); + ////////////// Exposed functions ////////////// - void update_internals(); - void notify_runtime_tile_data_update(); - - // --- Exposed in TileMap --- - // Cells manipulation. - void set_cell(const Vector2i &p_coords, int p_source_id = TileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = 0); + // --- Cells manipulation --- + // Generic cells manipulations and data access. + void set_cell(const Vector2i &p_coords, int p_source_id = TileSet::INVALID_SOURCE, const Vector2i &p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = 0); void erase_cell(const Vector2i &p_coords); - - int get_cell_source_id(const Vector2i &p_coords, bool p_use_proxies = false) const; - Vector2i get_cell_atlas_coords(const Vector2i &p_coords, bool p_use_proxies = false) const; - int get_cell_alternative_tile(const Vector2i &p_coords, bool p_use_proxies = false) const; - TileData *get_cell_tile_data(const Vector2i &p_coords, bool p_use_proxies = false) const; // Helper method to make accessing the data easier. + void fix_invalid_tiles(); void clear(); + int get_cell_source_id(const Vector2i &p_coords) const; + Vector2i get_cell_atlas_coords(const Vector2i &p_coords) const; + int get_cell_alternative_tile(const Vector2i &p_coords) const; + TileData *get_cell_tile_data(const Vector2i &p_coords) const; // Helper method to make accessing the data easier. + + TypedArray get_used_cells() const; + TypedArray get_used_cells_by_id(int p_source_id = TileSet::INVALID_SOURCE, const Vector2i &p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE) const; + Rect2i get_used_rect() const; + // Patterns. Ref get_pattern(TypedArray p_coords_array); void set_pattern(const Vector2i &p_position, const Ref p_pattern); @@ -403,54 +434,62 @@ public: void set_cells_terrain_connect(TypedArray p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); void set_cells_terrain_path(TypedArray p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); - // Cells usage. - TypedArray get_used_cells() const; - TypedArray get_used_cells_by_id(int p_source_id = TileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE) const; - Rect2i get_used_rect() const; + // --- Physics helpers --- + bool has_body_rid(RID p_physics_body) const; + Vector2i get_coords_for_body_rid(RID p_physics_body) const; // For finding tiles from collision. + + // --- Runtime --- + void update_internals(); + void notify_runtime_tile_data_update(); + GDVIRTUAL1R(bool, _use_tile_data_runtime_update, Vector2i); + GDVIRTUAL2(_tile_data_runtime_update, Vector2i, TileData *); + + // --- Shortcuts to methods defined in TileSet --- + Vector2i map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref p_pattern); + TypedArray get_surrounding_cells(const Vector2i &p_coords); + Vector2i get_neighbor_cell(const Vector2i &p_coords, TileSet::CellNeighbor p_cell_neighbor) const; + Vector2 map_to_local(const Vector2i &p_pos) const; + Vector2i local_to_map(const Vector2 &p_pos) const; + + // --- Accessors --- + void set_tile_map_data_from_array(const Vector &p_data); + Vector get_tile_map_data_as_array() const; - // Layer properties. void set_enabled(bool p_enabled); bool is_enabled() const; + void set_tile_set(const Ref &p_tile_set); + Ref get_tile_set() const; + + void set_highlight_mode(HighlightMode p_highlight_mode); + HighlightMode get_highlight_mode() const; + virtual void set_self_modulate(const Color &p_self_modulate) override; virtual void set_y_sort_enabled(bool p_y_sort_enabled) override; void set_y_sort_origin(int p_y_sort_origin); int get_y_sort_origin() const; virtual void set_z_index(int p_z_index) override; virtual void set_light_mask(int p_light_mask) override; - virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter) override; - virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) override; void set_rendering_quadrant_size(int p_size); int get_rendering_quadrant_size() const; + void set_collision_enabled(bool p_enabled); + bool is_collision_enabled() const; void set_use_kinematic_bodies(bool p_use_kinematic_bodies); bool is_using_kinematic_bodies() const; - void set_collision_visibility_mode(VisibilityMode p_show_collision); - VisibilityMode get_collision_visibility_mode() const; + void set_collision_visibility_mode(DebugVisibilityMode p_show_collision); + DebugVisibilityMode get_collision_visibility_mode() const; void set_navigation_enabled(bool p_enabled); bool is_navigation_enabled() const; void set_navigation_map(RID p_map); RID get_navigation_map() const; - void set_navigation_visibility_mode(VisibilityMode p_show_navigation); - VisibilityMode get_navigation_visibility_mode() const; - - // Fixing and clearing methods. - void fix_invalid_tiles(); - - // Find coords for body. - bool has_body_rid(RID p_physics_body) const; - Vector2i get_coords_for_body_rid(RID p_physics_body) const; // For finding tiles from collision. - - // Helper. - Ref get_effective_tile_set() const; - - // Virtual function to modify the TileData at runtime. - GDVIRTUAL1R(bool, _use_tile_data_runtime_update, Vector2i); - GDVIRTUAL2(_tile_data_runtime_update, Vector2i, TileData *); - // --- + void set_navigation_visibility_mode(DebugVisibilityMode p_show_navigation); + DebugVisibilityMode get_navigation_visibility_mode() const; TileMapLayer(); ~TileMapLayer(); }; +VARIANT_ENUM_CAST(TileMapLayer::DebugVisibilityMode); + #endif // TILE_MAP_LAYER_H diff --git a/scene/2d/tile_map_layer_group.cpp b/scene/2d/tile_map_layer_group.cpp deleted file mode 100644 index 132b4bbba54d..000000000000 --- a/scene/2d/tile_map_layer_group.cpp +++ /dev/null @@ -1,148 +0,0 @@ -/**************************************************************************/ -/* tile_map_layer_group.cpp */ -/**************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/**************************************************************************/ -/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ -/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/**************************************************************************/ - -#include "tile_map_layer_group.h" - -#include "core/core_string_names.h" -#include "scene/2d/tile_map_layer.h" -#include "scene/resources/2d/tile_set.h" - -#ifdef TOOLS_ENABLED - -void TileMapLayerGroup::_cleanup_selected_layers() { - for (int i = 0; i < selected_layers.size(); i++) { - const String name = selected_layers[i]; - TileMapLayer *layer = Object::cast_to(get_node_or_null(name)); - if (!layer) { - selected_layers.remove_at(i); - i--; - } - } -} - -#endif // TOOLS_ENABLED - -void TileMapLayerGroup::_tile_set_changed() { - for (int i = 0; i < get_child_count(); i++) { - TileMapLayer *layer = Object::cast_to(get_child(i)); - if (layer) { - layer->notify_tile_map_layer_group_change(TileMapLayer::DIRTY_FLAGS_LAYER_GROUP_TILE_SET); - } - } - - update_configuration_warnings(); -} - -#ifdef TOOLS_ENABLED - -void TileMapLayerGroup::set_selected_layers(Vector p_layer_names) { - selected_layers = p_layer_names; - _cleanup_selected_layers(); - - // Update the layers modulation. - for (int i = 0; i < get_child_count(); i++) { - TileMapLayer *layer = Object::cast_to(get_child(i)); - if (layer) { - layer->notify_tile_map_layer_group_change(TileMapLayer::DIRTY_FLAGS_LAYER_GROUP_SELECTED_LAYERS); - } - } -} - -Vector TileMapLayerGroup::get_selected_layers() const { - return selected_layers; -} - -void TileMapLayerGroup::set_highlight_selected_layer(bool p_highlight_selected_layer) { - if (highlight_selected_layer == p_highlight_selected_layer) { - return; - } - - highlight_selected_layer = p_highlight_selected_layer; - - for (int i = 0; i < get_child_count(); i++) { - TileMapLayer *layer = Object::cast_to(get_child(i)); - if (layer) { - layer->notify_tile_map_layer_group_change(TileMapLayer::DIRTY_FLAGS_LAYER_GROUP_HIGHLIGHT_SELECTED); - } - } -} - -bool TileMapLayerGroup::is_highlighting_selected_layer() const { - return highlight_selected_layer; -} - -#endif // TOOLS_ENABLED - -void TileMapLayerGroup::remove_child_notify(Node *p_child) { -#ifdef TOOLS_ENABLED - _cleanup_selected_layers(); -#endif // TOOLS_ENABLED -} - -void TileMapLayerGroup::_bind_methods() { - ClassDB::bind_method(D_METHOD("set_tileset", "tileset"), &TileMapLayerGroup::set_tileset); - ClassDB::bind_method(D_METHOD("get_tileset"), &TileMapLayerGroup::get_tileset); - - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "TileSet"), "set_tileset", "get_tileset"); -} - -void TileMapLayerGroup::set_tileset(const Ref &p_tileset) { - if (p_tileset == tile_set) { - return; - } - - // Set the tileset, registering to its changes. - if (tile_set.is_valid()) { - tile_set->disconnect_changed(callable_mp(this, &TileMapLayerGroup::_tile_set_changed)); - } - - tile_set = p_tileset; - - if (tile_set.is_valid()) { - tile_set->connect_changed(callable_mp(this, &TileMapLayerGroup::_tile_set_changed)); - } - - for (int i = 0; i < get_child_count(); i++) { - TileMapLayer *layer = Object::cast_to(get_child(i)); - if (layer) { - layer->notify_tile_map_layer_group_change(TileMapLayer::DIRTY_FLAGS_LAYER_GROUP_TILE_SET); - } - } -} - -Ref TileMapLayerGroup::get_tileset() const { - return tile_set; -} - -TileMapLayerGroup::~TileMapLayerGroup() { - if (tile_set.is_valid()) { - tile_set->disconnect_changed(callable_mp(this, &TileMapLayerGroup::_tile_set_changed)); - } -} diff --git a/scene/2d/tile_map_layer_group.h b/scene/2d/tile_map_layer_group.h deleted file mode 100644 index d80c244f80d3..000000000000 --- a/scene/2d/tile_map_layer_group.h +++ /dev/null @@ -1,73 +0,0 @@ -/**************************************************************************/ -/* tile_map_layer_group.h */ -/**************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/**************************************************************************/ -/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ -/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/**************************************************************************/ - -#ifndef TILE_MAP_LAYER_GROUP_H -#define TILE_MAP_LAYER_GROUP_H - -#include "scene/2d/node_2d.h" - -class TileSet; - -class TileMapLayerGroup : public Node2D { - GDCLASS(TileMapLayerGroup, Node2D); - -private: - mutable Vector selected_layers; - bool highlight_selected_layer = true; - -#ifdef TOOLS_ENABLED - void _cleanup_selected_layers(); -#endif - void _tile_set_changed(); - -protected: - Ref tile_set; - - virtual void remove_child_notify(Node *p_child) override; - - static void _bind_methods(); - -public: -#ifdef TOOLS_ENABLED - // For editor use. - void set_selected_layers(Vector p_layer_names); - Vector get_selected_layers() const; - void set_highlight_selected_layer(bool p_highlight_selected_layer); - bool is_highlighting_selected_layer() const; -#endif - - // Accessors. - void set_tileset(const Ref &p_tileset); - Ref get_tileset() const; - - ~TileMapLayerGroup(); -}; - -#endif // TILE_MAP_LAYER_GROUP_H diff --git a/scene/main/canvas_item.cpp b/scene/main/canvas_item.cpp index 768c83954bc6..56aa453407d1 100644 --- a/scene/main/canvas_item.cpp +++ b/scene/main/canvas_item.cpp @@ -1401,14 +1401,17 @@ void CanvasItem::_refresh_texture_filter_cache() const { } } +void CanvasItem::_update_self_texture_filter(RS::CanvasItemTextureFilter p_texture_filter) { + RS::get_singleton()->canvas_item_set_default_texture_filter(get_canvas_item(), p_texture_filter); + queue_redraw(); +} + void CanvasItem::_update_texture_filter_changed(bool p_propagate) { if (!is_inside_tree()) { return; } _refresh_texture_filter_cache(); - - RS::get_singleton()->canvas_item_set_default_texture_filter(get_canvas_item(), texture_filter_cache); - queue_redraw(); + _update_self_texture_filter(texture_filter_cache); if (p_propagate) { for (CanvasItem *E : children_items) { @@ -1452,14 +1455,18 @@ void CanvasItem::_refresh_texture_repeat_cache() const { } } +void CanvasItem::_update_self_texture_repeat(RS::CanvasItemTextureRepeat p_texture_repeat) { + RS::get_singleton()->canvas_item_set_default_texture_repeat(get_canvas_item(), p_texture_repeat); + queue_redraw(); +} + void CanvasItem::_update_texture_repeat_changed(bool p_propagate) { if (!is_inside_tree()) { return; } _refresh_texture_repeat_cache(); + _update_self_texture_repeat(texture_repeat_cache); - RS::get_singleton()->canvas_item_set_default_texture_repeat(get_canvas_item(), texture_repeat_cache); - queue_redraw(); if (p_propagate) { for (CanvasItem *E : children_items) { if (!E->top_level && E->texture_repeat == TEXTURE_REPEAT_PARENT_NODE) { diff --git a/scene/main/canvas_item.h b/scene/main/canvas_item.h index 383edeec93a6..8cec086ca6d9 100644 --- a/scene/main/canvas_item.h +++ b/scene/main/canvas_item.h @@ -152,6 +152,9 @@ private: void _notify_transform_deferred(); protected: + virtual void _update_self_texture_repeat(RS::CanvasItemTextureRepeat p_texture_repeat); + virtual void _update_self_texture_filter(RS::CanvasItemTextureFilter p_texture_filter); + _FORCE_INLINE_ void _notify_transform() { _notify_transform(this); if (is_inside_tree() && !block_transform_notify && notify_local_transform) { diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp index 3583dace2a55..b6efd30f63f7 100644 --- a/scene/register_scene_types.cpp +++ b/scene/register_scene_types.cpp @@ -77,6 +77,7 @@ #include "scene/2d/skeleton_2d.h" #include "scene/2d/sprite_2d.h" #include "scene/2d/tile_map.h" +#include "scene/2d/tile_map_layer.h" #include "scene/2d/touch_screen_button.h" #include "scene/2d/visible_on_screen_notifier_2d.h" #include "scene/animation/animation_blend_space_1d.h" @@ -813,7 +814,7 @@ void register_scene_types() { GDREGISTER_CLASS(TileMapPattern); GDREGISTER_CLASS(TileData); GDREGISTER_CLASS(TileMap); - GDREGISTER_ABSTRACT_CLASS(TileMapLayerGroup); + GDREGISTER_CLASS(TileMapLayer); GDREGISTER_CLASS(Parallax2D); GDREGISTER_CLASS(ParallaxBackground); GDREGISTER_CLASS(ParallaxLayer);