Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2024-12-22 11:56:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Backported from Godot4: Expose TileMapLayer

Browse Source 
- groud
3cd4b2859c
This commit is contained in:
Relintai 2024-04-06 18:35:58 +02:00
parent 9ab9c3a9a4
commit 8648a32667
19 changed files with 1629 additions and 973 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
doc/classes/EditorSettings.xml
View File

@ -836,6 +836,9 @@
If [code]true[/code], sorts the members outline (located at the left of the script editor) using alphabetical order. If [code]false[/code], sorts the members outline depending on the order in which members are found in the script.
[b]Note:[/b] Only effective if [member text_editor/script_list/show_members_overview] is [code]true[/code].
</member>
<member name="editors/layered_tiles_editor/highlight_selected_layer" type="bool" setter="" getter="">
Highlight the currently selected TileMapLayer by dimming the other ones in the scene.
</member>
</members>
<signals>
<signal name="settings_changed">

2
modules/layered_tile_map/config.py
View File

@ -9,7 +9,7 @@ def get_doc_classes():
return [
"LayeredTileData",
"LayeredTileMap",
"LayeredTileMapLayerGroup",
"LayeredTileMapLayer",
"LayeredTileMapPattern",
"LayeredTileSet",
"LayeredTileSetAtlasSource",

15
modules/layered_tile_map/doc_classes/LayeredTileMap.xml
View File

@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="LayeredTileMap" inherits="LayeredTileMapLayerGroup" version="4.3">
<class name="LayeredTileMap" inherits="Node2D" version="4.3">
<brief_description>
Node for 2D tile-based maps.
</brief_description>
@ -89,7 +89,8 @@
<argument index="1" name="coords" type="Vector2i" />
<argument index="2" name="use_proxies" type="bool" default="false" />
<description>
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 [LayeredTileSet]'s tile proxies, returning the raw alternative identifier. See [method LayeredTileSet.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.
</description>
</method>
@ -99,7 +100,8 @@
<argument index="1" name="coords" type="Vector2i" />
<argument index="2" name="use_proxies" type="bool" default="false" />
<description>
Returns the tile atlas coordinates ID of the cell on layer [param layer] at coordinates [param coords]. If [param use_proxies] is [code]false[/code], ignores the [LayeredTileSet]'s tile proxies, returning the raw alternative identifier. See [method LayeredTileSet.map_tile_proxy].
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 atlas coordinate identifier. See [method TileSet.map_tile_proxy].
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
@ -110,7 +112,7 @@
<argument index="2" name="use_proxies" type="bool" default="false" />
<description>
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 [LayeredTileSet]'s tile proxies, returning the raw alternative identifier. See [method LayeredTileSet.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.
</description>
</method>
@ -122,7 +124,6 @@
<description>
Returns the [LayeredTileData] object associated with the given cell, or [code]null[/code] if the cell does not exist or is not a [LayeredTileSetAtlasSource].
If [param layer] is negative, the layers are accessed from the last one.
If [param use_proxies] is [code]false[/code], ignores the [LayeredTileSet]'s tile proxies, returning the raw alternative identifier. See [method LayeredTileSet.map_tile_proxy].
[codeblock]
func get_clicked_tile_power():
var clicked_cell = tile_map.local_to_map(tile_map.get_local_mouse_position())
@ -132,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].
</description>
</method>
<method name="get_coords_for_body_rid">
@ -483,6 +485,9 @@
<member name="navigation_visibility_mode" type="int" setter="set_navigation_visibility_mode" getter="get_navigation_visibility_mode" enum="LayeredTileMap.VisibilityMode" default="0">
Show or hide the LayeredTileMap's navigation meshes. If set to [constant VISIBILITY_MODE_DEFAULT], this depends on the show navigation debug settings.
</member>
<member name="tile_set" type="TileSet" setter="set_tileset" getter="get_tileset">
The [TileSet] used by this [TileMap]. The textures, collisions, and additional behavior of all available tiles are stored here.
</member>
<member name="rao_noise_params" type="FastnoiseNoiseParams" setter="rao_set_noise_params" getter="rao_get_noise_params">
</member>
<member name="rao_strength" type="float" setter="rao_set_strength" getter="rao_get_strength" default="0.3">

303
modules/layered_tile_map/doc_classes/LayeredTileMapLayer.xml Normal file
View File

@ -0,0 +1,303 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="LayeredTileMapLayer" inherits="Node2D" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
Node for 2D tile-based maps.
</brief_description>
<description>
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].
</description>
<tutorials>
</tutorials>
<methods>
<method name="_tile_data_runtime_update" qualifiers="virtual">
<return type="void" />
<param index="0" name="coords" type="Vector2i" />
<param index="1" name="tile_data" type="TileData" />
<description>
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.
</description>
</method>
<method name="_use_tile_data_runtime_update" qualifiers="virtual">
<return type="bool" />
<param index="0" name="coords" type="Vector2i" />
<description>
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.
</description>
</method>
<method name="clear">
<return type="void" />
<description>
Clears all cells.
</description>
</method>
<method name="erase_cell">
<return type="void" />
<param index="0" name="coords" type="Vector2i" />
<description>
Erases the cell at coordinates [param coords].
</description>
</method>
<method name="fix_invalid_tiles">
<return type="void" />
<description>
Clears cells containing tiles that do not exist in the [member tile_set].
</description>
</method>
<method name="get_cell_alternative_tile" qualifiers="const">
<return type="int" />
<param index="0" name="coords" type="Vector2i" />
<description>
Returns the tile alternative ID of the cell at coordinates [param coords].
</description>
</method>
<method name="get_cell_atlas_coords" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="coords" type="Vector2i" />
<description>
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.
</description>
</method>
<method name="get_cell_source_id" qualifiers="const">
<return type="int" />
<param index="0" name="coords" type="Vector2i" />
<description>
Returns the tile source ID of the cell at coordinates [param coords]. Returns [code]-1[/code] if the cell does not exist.
</description>
</method>
<method name="get_cell_tile_data" qualifiers="const">
<return type="TileData" />
<param index="0" name="coords" type="Vector2i" />
<description>
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]
</description>
</method>
<method name="get_coords_for_body_rid" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="body" type="RID" />
<description>
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.
</description>
</method>
<method name="get_navigation_map" qualifiers="const">
<return type="RID" />
<description>
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].
</description>
</method>
<method name="get_neighbor_cell" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="coords" type="Vector2i" />
<param index="1" name="neighbor" type="int" enum="TileSet.CellNeighbor" />
<description>
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.
</description>
</method>
<method name="get_pattern">
<return type="TileMapPattern" />
<param index="0" name="coords_array" type="PoolVector2iArray" />
<description>
Creates and returns a new [TileMapPattern] from the given array of cells. See also [method set_pattern].
</description>
</method>
<method name="get_surrounding_cells">
<return type="PoolVector2iArray" />
<param index="0" name="coords" type="Vector2i" />
<description>
Returns the list of all neighboring cells to the one at [param coords].
</description>
</method>
<method name="get_used_cells" qualifiers="const">
<return type="PoolVector2iArray" />
<description>
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].
</description>
</method>
<method name="get_used_cells_by_id" qualifiers="const">
<return type="PoolVector2iArray" />
<param index="0" name="source_id" type="int" default="-1" />
<param index="1" name="atlas_coords" type="Vector2i" default="Vector2i(-1, -1)" />
<param index="2" name="alternative_tile" type="int" default="-1" />
<description>
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].
</description>
</method>
<method name="get_used_rect" qualifiers="const">
<return type="Rect2i" />
<description>
Returns a rectangle enclosing the used (non-empty) tiles of the map.
</description>
</method>
<method name="has_body_rid" qualifiers="const">
<return type="bool" />
<param index="0" name="body" type="RID" />
<description>
Returns whether the provided [param body] [RID] belongs to one of this [TileMapLayer]'s cells.
</description>
</method>
<method name="local_to_map" qualifiers="const">
<return type="Vector2i" />
<param index="0" name="local_position" type="Vector2" />
<description>
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].
</description>
</method>
<method name="map_pattern">
<return type="Vector2i" />
<param index="0" name="position_in_tilemap" type="Vector2i" />
<param index="1" name="coords_in_pattern" type="Vector2i" />
<param index="2" name="pattern" type="TileMapPattern" />
<description>
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].
</description>
</method>
<method name="map_to_local" qualifiers="const">
<return type="Vector2" />
<param index="0" name="map_position" type="Vector2i" />
<description>
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.
</description>
</method>
<method name="notify_runtime_tile_data_update">
<return type="void" />
<description>
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]).
</description>
</method>
<method name="set_cell">
<return type="void" />
<param index="0" name="coords" type="Vector2i" />
<param index="1" name="source_id" type="int" default="-1" />
<param index="2" name="atlas_coords" type="Vector2i" default="Vector2i(-1, -1)" />
<param index="3" name="alternative_tile" type="int" default="0" />
<description>
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].
</description>
</method>
<method name="set_cells_terrain_connect">
<return type="void" />
<param index="0" name="cells" type="PoolVector2iArray" />
<param index="1" name="terrain_set" type="int" />
<param index="2" name="terrain" type="int" />
<param index="3" name="ignore_empty_terrains" type="bool" default="true" />
<description>
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.
</description>
</method>
<method name="set_cells_terrain_path">
<return type="void" />
<param index="0" name="path" type="PoolVector2iArray" />
<param index="1" name="terrain_set" type="int" />
<param index="2" name="terrain" type="int" />
<param index="3" name="ignore_empty_terrains" type="bool" default="true" />
<description>
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.
</description>
</method>
<method name="set_navigation_map">
<return type="void" />
<param index="0" name="map" type="RID" />
<description>
Sets a custom [param map] as a [NavigationServer2D] navigation map. If not set, uses the default [World2D] navigation map instead.
</description>
</method>
<method name="set_pattern">
<return type="void" />
<param index="0" name="position" type="Vector2i" />
<param index="1" name="pattern" type="TileMapPattern" />
<description>
Pastes the [TileMapPattern] at the given [param position] in the tile map. See also [method get_pattern].
</description>
</method>
<method name="update_internals">
<return type="void" />
<description>
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.
</description>
</method>
</methods>
<members>
<member name="collision_enabled" type="bool" setter="set_collision_enabled" getter="is_collision_enabled" default="true">
Enable or disable collisions.
</member>
<member name="collision_visibility_mode" type="int" setter="set_collision_visibility_mode" getter="get_collision_visibility_mode" enum="TileMapLayer.DebugVisibilityMode" default="0">
Show or hide the [TileMapLayer]'s collision shapes. If set to [constant DEBUG_VISIBILITY_MODE_DEFAULT], this depends on the show collision debug settings.
</member>
<member name="enabled" type="bool" setter="set_enabled" getter="is_enabled" default="true">
If [code]false[/code], disables this [TileMapLayer] completely (rendering, collision, navigation, scene tiles, etc.)
</member>
<member name="navigation_enabled" type="bool" setter="set_navigation_enabled" getter="is_navigation_enabled" default="true">
If [code]true[/code], navigation regions are enabled.
</member>
<member name="navigation_visibility_mode" type="int" setter="set_navigation_visibility_mode" getter="get_navigation_visibility_mode" enum="TileMapLayer.DebugVisibilityMode" default="0">
Show or hide the [TileMapLayer]'s navigation meshes. If set to [constant DEBUG_VISIBILITY_MODE_DEFAULT], this depends on the show navigation debug settings.
</member>
<member name="rendering_quadrant_size" type="int" setter="set_rendering_quadrant_size" getter="get_rendering_quadrant_size" default="16">
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.
</member>
<member name="tile_map_data" type="PackedByteArray" setter="set_tile_map_data_from_array" getter="get_tile_map_data_as_array" default="PackedByteArray(0, 0)">
The raw tile map data as a byte array.
</member>
<member name="tile_set" type="TileSet" setter="set_tile_set" getter="get_tile_set">
The [TileSet] used by this layer. The textures, collisions, and additional behavior of all available tiles are stored here.
</member>
<member name="use_kinematic_bodies" type="bool" setter="set_use_kinematic_bodies" getter="is_using_kinematic_bodies" default="false">
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).
</member>
<member name="y_sort_origin" type="int" setter="set_y_sort_origin" getter="get_y_sort_origin" default="0">
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.
</member>
</members>
<signals>
<signal name="changed">
<description>
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]).
</description>
</signal>
</signals>
<constants>
<constant name="DEBUG_VISIBILITY_MODE_DEFAULT" value="0" enum="DebugVisibilityMode">
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]).
</constant>
<constant name="DEBUG_VISIBILITY_MODE_FORCE_HIDE" value="2" enum="DebugVisibilityMode">
Always hide the collisions or navigation debug shapes.
</constant>
<constant name="DEBUG_VISIBILITY_MODE_FORCE_SHOW" value="1" enum="DebugVisibilityMode">
Always show the collisions or navigation debug shapes.
</constant>
</constants>
</class>

21
modules/layered_tile_map/doc_classes/LayeredTileMapLayerGroup.xml
View File

@ -1,21 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="LayeredTileMapLayerGroup" inherits="YSort" version="4.3">
<brief_description>
Groups a set of tile map layers together, allowing them to share a provided [LayeredTileSet].
</brief_description>
<description>
Groups together tile map layers as part or the same map, replacing the [LayeredTileMap] node. Child layers will use this node's [member tile_set].
The editor also uses [LayeredTileMapLayerGroup] as a way to store which layers are selected in a given group. This allows highlighting the currently selected layers.
</description>
<tutorials>
</tutorials>
<methods>
</methods>
<members>
<member name="tile_set" type="LayeredTileSet" setter="set_tileset" getter="get_tileset">
The assigned [LayeredTileSet]. This LayeredTileSet will be applied to all child layers.
</member>
</members>
<constants>
</constants>
</class>

600
modules/layered_tile_map/editor/layered_tile_map_layer_editor.cpp
View File

File diff suppressed because it is too large Load Diff

32
modules/layered_tile_map/editor/layered_tile_map_layer_editor.h
View File

@ -353,31 +353,54 @@ class LayeredTileMapLayerEditor : public VBoxContainer {
GDCLASS(LayeredTileMapLayerEditor, 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<LayeredTileMapLayer *> tile_map_layers_in_scene_cache;
bool layers_in_scene_list_cache_needs_update = false;
LayeredTileMapLayer *_get_edited_layer() const;
void _find_tile_map_layers_in_scene(Node *p_current, const Node *p_owner, Vector<LayeredTileMapLayer *> &r_list) const;
void _update_tile_map_layers_in_scene_list_cache();
void _node_change(Node *p_node);
// Vector to keep plugins.
Vector<LayeredTileMapLayerSubEditorPlugin *> tile_map_editor_plugins;
// 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;
Tabs *tabs_bar = nullptr;
LocalVector<LayeredTileMapLayerSubEditorPlugin::TabData> tabs_data;
LocalVector<LayeredTileMapLayerSubEditorPlugin *> tabs_plugins;
@ -393,7 +416,6 @@ 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);
@ -407,8 +429,8 @@ public:
bool forward_canvas_gui_input(const Ref<InputEvent> &p_event);
void forward_canvas_draw_over_viewport(Control *p_overlay);
void edit(LayeredTileMapLayer *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);
LayeredTileMapLayerEditor();
~LayeredTileMapLayerEditor();

108
modules/layered_tile_map/editor/layered_tiles_editor_plugin.cpp
View File

@ -49,6 +49,7 @@
#include "scene/main/control.h"
#include "scene/main/viewport.h"
#include "scene/resources/texture.h"
#include "editor/multi_node_edit.h"
LayeredTilesEditorUtils *LayeredTilesEditorUtils::singleton = nullptr;
LayeredTileMapEditorPlugin *tile_map_plugin_singleton = nullptr;
@ -356,7 +357,7 @@ void LayeredTileMapEditorPlugin::_tile_map_layer_removed() {
void LayeredTileMapEditorPlugin::_update_tile_map() {
LayeredTileMapLayer *edited_layer = Object::cast_to<LayeredTileMapLayer>(ObjectDB::get_instance(tile_map_layer_id));
if (edited_layer) {
Ref<LayeredTileSet> tile_set = edited_layer->get_effective_tile_set();
Ref<LayeredTileSet> 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);
@ -375,39 +376,27 @@ void LayeredTileMapEditorPlugin::_select_layer(const StringName &p_name) {
ERR_FAIL_NULL(edited_layer);
Node *parent = edited_layer->get_parent();
ERR_FAIL_NULL(parent);
LayeredTileMapLayer *new_layer = Object::cast_to<LayeredTileMapLayer>(parent->get_node_or_null(String(p_name)));
edit(new_layer);
if (parent) {
LayeredTileMapLayer *new_layer = Object::cast_to<LayeredTileMapLayer>(parent->get_node_or_null(String(p_name)));
edit(new_layer);
}
}
void LayeredTileMapEditorPlugin::_edit_tile_map_layer(LayeredTileMapLayer *p_tile_map_layer) {
void LayeredTileMapEditorPlugin::_edit_tile_map_layer(LayeredTileMapLayer *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 LayeredTileMapLayerGroup parent node.
LayeredTileMapLayerGroup *tile_map_layer_group = Object::cast_to<LayeredTileMapLayerGroup>(p_tile_map_layer->get_parent());
if (tile_map_layer_group) {
Vector<StringName> 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", this, "_tile_map_layer_changed");
p_tile_map_layer->connect("tree_exited", this, "_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", this, "_tile_map_group_child_tree_changed");
tile_map_layer_group->connect("child_exiting_tree", this, "_tile_map_group_child_tree_changed");
tile_map_layer_group->connect("child_order_changed", editor, "update_layers_selector");
}
// Update the edited tileset.
Ref<LayeredTileSet> tile_set = p_tile_map_layer->get_effective_tile_set();
Ref<LayeredTileSet> 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);
@ -418,30 +407,15 @@ void LayeredTileMapEditorPlugin::_edit_tile_map_layer(LayeredTileMapLayer *p_til
}
}
void LayeredTileMapEditorPlugin::_edit_tile_map_layer_group(LayeredTileMapLayerGroup *p_tile_map_layer_group) {
ERR_FAIL_NULL(p_tile_map_layer_group);
void LayeredTileMapEditorPlugin::_edit_tile_map(LayeredTileMap *p_tile_map) {
ERR_FAIL_NULL(p_tile_map);
Vector<StringName> selected_layers = p_tile_map_layer_group->get_selected_layers();
LayeredTileMapLayer *selected_layer = nullptr;
if (selected_layers.size() > 0) {
// Edit the selected layer.
selected_layer = Object::cast_to<LayeredTileMapLayer>(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<LayeredTileMapLayer>(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) {
LayeredTileMapLayer *selected_layer = Object::cast_to<LayeredTileMapLayer>(p_tile_map->get_child(0));
_edit_tile_map_layer(selected_layer, true);
} else {
editor->edit(nullptr);
editor->set_show_layer_selector(false);
}
}
@ -451,14 +425,9 @@ void LayeredTileMapEditorPlugin::_notification(int p_notification) {
}
}
void LayeredTileMapEditorPlugin::_tile_map_group_child_tree_changed(Node *p_node) {
editor->update_layers_selector();
}
void LayeredTileMapEditorPlugin::_bind_methods() {
ClassDB::bind_method(D_METHOD("_tile_map_layer_changed"), &LayeredTileMapEditorPlugin::_tile_map_layer_changed);
ClassDB::bind_method(D_METHOD("_tile_map_layer_removed"), &LayeredTileMapEditorPlugin::_tile_map_layer_removed);
ClassDB::bind_method(D_METHOD("_tile_map_group_child_tree_changed"), &LayeredTileMapEditorPlugin::_tile_map_group_child_tree_changed);
ClassDB::bind_method(D_METHOD("_update_tile_map"), &LayeredTileMapEditorPlugin::_update_tile_map);
ClassDB::bind_method(D_METHOD("_select_layer"), &LayeredTileMapEditorPlugin::_select_layer);
}
@ -470,36 +439,39 @@ void LayeredTileMapEditorPlugin::edit(Object *p_object) {
edited_layer->disconnect("tree_exited", this, "_tile_map_layer_removed");
}
LayeredTileMapLayerGroup *tile_map_group = Object::cast_to<LayeredTileMapLayerGroup>(ObjectDB::get_instance(tile_map_group_id));
if (tile_map_group) {
tile_map_group->disconnect("child_entered_tree", this, "_tile_map_group_child_tree_changed");
tile_map_group->disconnect("child_exiting_tree", this, "_tile_map_group_child_tree_changed");
tile_map_group->disconnect("child_order_changed", editor, "update_layers_selector");
}
tile_map_group_id = ObjectID();
tile_map_layer_id = ObjectID();
tile_set_id = ObjectID();
LayeredTileMapLayerGroup *tile_map_layer_group = Object::cast_to<LayeredTileMap>(p_object);
LayeredTileMap *tile_map = Object::cast_to<LayeredTileMap>(p_object);
LayeredTileMapLayer *tile_map_layer = Object::cast_to<LayeredTileMapLayer>(p_object);
if (tile_map_layer_group) {
_edit_tile_map_layer_group(tile_map_layer_group);
MultiNodeEdit *multi_node_edit = Object::cast_to<MultiNodeEdit>(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<LayeredTileMapLayerGroup>(edited_layer->get_parent());
if (tile_map_layer_group) {
tile_map_layer_group->set_selected_layers(Vector<StringName>());
}
}
editor->edit(nullptr);
}
}
bool LayeredTileMapEditorPlugin::handles(Object *p_object) const {
return Object::cast_to<LayeredTileMapLayer>(p_object) != nullptr || Object::cast_to<LayeredTileMapLayerGroup>(p_object) != nullptr;
MultiNodeEdit *multi_node_edit = Object::cast_to<MultiNodeEdit>(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<LayeredTileMapLayer>(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<LayeredTileMapLayer>(p_object) != nullptr || Object::cast_to<LayeredTileMap>(p_object) != nullptr;
}
void LayeredTileMapEditorPlugin::make_visible(bool p_visible) {
@ -542,7 +514,6 @@ LayeredTileMapEditorPlugin::LayeredTileMapEditorPlugin(EditorNode *p_node) {
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", this, "_select_layer");
editor->hide();
button = EditorNode::get_singleton()->add_bottom_panel_item(TTR("LayeredTileMap"), editor);
@ -586,6 +557,7 @@ ObjectID LayeredTileSetEditorPlugin::get_edited_tileset() const {
LayeredTileSetEditorPlugin::LayeredTileSetEditorPlugin(EditorNode *p_node) {
EDITOR_DEF("editors/layered_tiles_editor/display_grid", true);
EDITOR_DEF("editors/layered_tiles_editor/highlight_selected_layer", true);
EDITOR_DEF("editors/layered_tiles_editor/grid_color", Color(1.0, 0.5, 0.2, 0.5));
if (!LayeredTilesEditorUtils::get_singleton()) {

6
modules/layered_tile_map/editor/layered_tiles_editor_plugin.h
View File

@ -134,10 +134,8 @@ class LayeredTileMapEditorPlugin : public EditorPlugin {
void _update_tile_map();
void _select_layer(const StringName &p_name);
void _edit_tile_map_layer(LayeredTileMapLayer *p_tile_map_layer);
void _edit_tile_map_layer_group(LayeredTileMapLayerGroup *p_tile_map_layer_group);
void _tile_map_group_child_tree_changed(Node *p_node);
void _edit_tile_map_layer(LayeredTileMapLayer *p_tile_map_layer, bool p_show_layer_selector);
void _edit_tile_map(LayeredTileMap *p_tile_map);
protected:
void _notification(int p_notification);

2
modules/layered_tile_map/icons/icon_layered_tile_map_layer.svg
View File

@ -1 +1 @@
<svg height="16" viewBox="0 0 16 16" width="16" xmlns="http://www.w3.org/2000/svg"><path d="m1 7v2h2v-2zm3 0v2h2v-2zm3 0v2h2v-2zm3 0v2h2v-2zm3 0v2h2v-2z" fill="#8da5f3"/></svg>
<svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M8 2 6.25 3.375 8 4.75l1.75-1.375zm2.624 2.062-1.75 1.375 1.75 1.375 1.75-1.375Zm2.626 2.063L11.5 7.5l1.75 1.375L15 7.5ZM5.376 4.062l-1.75 1.375 1.75 1.375 1.75-1.375zM8 6.124 6.25 7.499 8 8.874l1.75-1.375zm2.626 2.063-1.75 1.375 1.75 1.375 1.75-1.375ZM2.75 6.125 1 7.5l1.75 1.375L4.5 7.5Zm2.624 2.062-1.75 1.375 1.75 1.375 1.75-1.375ZM8 10.25l-1.75 1.375L8 13l1.75-1.375z" fill="#8da5f3"/></svg>
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 176 B

After

Width:  |  Height:  |  Size: 488 B

253
modules/layered_tile_map/layered_tile_map.cpp
View File

@ -35,6 +35,7 @@
#include "core/core_string_names.h"
#include "layered_tile_map_layer.h"
#include "scene/main/control.h"
#include "core/io/marshalls.h"
#define TILEMAP_CALL_FOR_LAYER(layer, function, ...) \
if (layer < 0) { \
@ -50,10 +51,118 @@
ERR_FAIL_INDEX_V(layer, (int)layers.size(), err_value); \
return layers[layer]->function(__VA_ARGS__);
void LayeredTileMap::_tile_set_changed() {
update_configuration_warning();
}
void LayeredTileMap::_emit_changed() {
emit_signal(CoreStringNames::get_singleton()->changed);
}
void LayeredTileMap::_set_tile_map_data_using_compatibility_format(int p_layer, LayeredTileMapDataFormat p_format, const Vector<int> &p_data) {
ERR_FAIL_INDEX(p_layer, (int)layers.size());
ERR_FAIL_COND(p_format >= LayeredTileMapDataFormat::TILE_MAP_DATA_FORMAT_MAX);
#ifndef DISABLE_DEPRECATED
ERR_FAIL_COND_MSG(p_format != (LayeredTileMapDataFormat)(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 >= LayeredTileMapDataFormat::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 >= LayeredTileMapDataFormat::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 == LayeredTileMapDataFormat::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 == LayeredTileMapDataFormat::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<int> LayeredTileMap::_get_tile_map_data_using_compatibility_format(int p_layer) const {
ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), Vector<int>());
// Export tile data to raw format.
const HashMap<Vector2i, CellData> tile_map_layer_data = layers[p_layer]->get_tile_map_layer_data();
Vector<int> 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 HashMap<Vector2i, CellData>::Element *E = tile_map_layer_data.front(); E; E = E->next) {
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 LayeredTileMap::_notification(int p_what) {
switch (p_what) {
case LayeredTileMap::NOTIFICATION_INTERNAL_PHYSICS_PROCESS: {
@ -228,6 +337,34 @@ void LayeredTileMap::draw_tile(RID p_canvas_item, const Vector2 &p_position, con
}
}
void LayeredTileMap::set_tileset(const Ref<LayeredTileSet> &p_tileset) {
if (p_tileset == tile_set) {
return;
}
// Set the tileset, registering to its changes.
if (tile_set.is_valid()) {
tile_set->disconnect("changed", this, "_tile_set_changed");
}
tile_set = p_tileset;
if (tile_set.is_valid()) {
tile_set->connect("changed", this, "_tile_set_changed");
}
for (int i = 0; i < get_child_count(); i++) {
LayeredTileMapLayer *layer = Object::cast_to<LayeredTileMapLayer>(get_child(i));
if (layer) {
layer->set_tile_set(tile_set);
}
}
}
Ref<LayeredTileSet> LayeredTileMap::get_tileset() const {
return tile_set;
}
int LayeredTileMap::get_layers_count() const {
return layers.size();
}
@ -245,6 +382,7 @@ void LayeredTileMap::add_layer(int p_to_pos) {
add_child(new_layer, false);
move_child(new_layer, 0);
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);
@ -282,9 +420,12 @@ void LayeredTileMap::remove_layer(int p_layer) {
ERR_FAIL_INDEX(p_layer, (int)layers.size());
// Clear before removing the layer.
layers[p_layer]->queue_delete();
LayeredTileMapLayer *removed = layers[p_layer];
layers.remove(p_layer);
remove_child(removed);
removed->queue_delete();
for (uint32_t i = 0; i < layers.size(); i++) {
layers[i]->set_as_tile_map_internal_node(i);
}
@ -387,7 +528,7 @@ void LayeredTileMap::set_collision_visibility_mode(LayeredTileMap::VisibilityMod
for (uint32_t i = 0; i < layers.size(); ++i) {
LayeredTileMapLayer *layer = layers[i];
layer->set_collision_visibility_mode(LayeredTileMapLayer::VisibilityMode(p_show_collision));
layer->set_collision_visibility_mode(LayeredTileMapLayer::DebugVisibilityMode(p_show_collision));
}
_emit_changed();
@ -405,7 +546,7 @@ void LayeredTileMap::set_navigation_visibility_mode(LayeredTileMap::VisibilityMo
for (uint32_t i = 0; i < layers.size(); ++i) {
LayeredTileMapLayer *layer = layers[i];
layer->set_navigation_visibility_mode(LayeredTileMapLayer::VisibilityMode(p_show_navigation));
layer->set_navigation_visibility_mode(LayeredTileMapLayer::DebugVisibilityMode(p_show_navigation));
}
_emit_changed();
@ -441,19 +582,85 @@ void LayeredTileMap::erase_cell(int p_layer, const Vector2i &p_coords) {
}
int LayeredTileMap::get_cell_source_id(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
TILEMAP_CALL_FOR_LAYER_V(p_layer, LayeredTileSet::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(), LayeredTileSet::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, LayeredTileSet::INVALID_SOURCE);
return arr[0];
} else {
TILEMAP_CALL_FOR_LAYER_V(p_layer, LayeredTileSet::INVALID_SOURCE, get_cell_source_id, p_coords);
}
}
Vector2i LayeredTileMap::get_cell_atlas_coords(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
TILEMAP_CALL_FOR_LAYER_V(p_layer, LayeredTileSetSource::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(), LayeredTileSetAtlasSource::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, LayeredTileSetSource::INVALID_ATLAS_COORDS);
return arr[1];
} else {
TILEMAP_CALL_FOR_LAYER_V(p_layer, LayeredTileSetSource::INVALID_ATLAS_COORDS, get_cell_atlas_coords, p_coords);
}
}
int LayeredTileMap::get_cell_alternative_tile(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
TILEMAP_CALL_FOR_LAYER_V(p_layer, LayeredTileSetSource::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(), LayeredTileSetSource::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, LayeredTileSetSource::INVALID_TILE_ALTERNATIVE);
return arr[2];
} else {
TILEMAP_CALL_FOR_LAYER_V(p_layer, LayeredTileSetSource::INVALID_TILE_ALTERNATIVE, get_cell_alternative_tile, p_coords);
}
}
LayeredTileData *LayeredTileMap::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<LayeredTileSetAtlasSource> 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<LayeredTileMapPattern> LayeredTileMap::get_pattern(int p_layer, PoolVector2iArray p_coords_array) {
@ -616,7 +823,10 @@ void LayeredTileMap::rao_setup_noise(Ref<FastNoise> noise) {
#endif
LayeredTileMapCell LayeredTileMap::get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
TILEMAP_CALL_FOR_LAYER_V(p_layer, LayeredTileMapCell(), 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, LayeredTileMapCell(), get_cell, p_coords);
}
Vector2i LayeredTileMap::get_coords_for_body_rid(RID p_physics_body) {
@ -647,6 +857,13 @@ void LayeredTileMap::fix_invalid_tiles() {
}
}
#ifdef TOOLS_ENABLED
LayeredTileMapLayer *LayeredTileMap::duplicate_layer_from_internal(int p_layer) {
ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr);
return Object::cast_to<LayeredTileMapLayer>(layers[p_layer]->duplicate(DUPLICATE_USE_INSTANCING | DUPLICATE_FROM_EDITOR));
}
#endif // TOOLS_ENABLED
void LayeredTileMap::clear_layer(int p_layer) {
TILEMAP_CALL_FOR_LAYER(p_layer, clear)
}
@ -713,10 +930,11 @@ bool LayeredTileMap::_set(const StringName &p_name, const Variant &p_value) {
move_child(new_layer, 0);
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, this, "_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;
}
@ -739,6 +957,7 @@ bool LayeredTileMap::_set(const StringName &p_name, const Variant &p_value) {
move_child(new_layer, 0);
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, this, "_emit_changed");
layers.push_back(new_layer);
}
@ -770,7 +989,7 @@ bool LayeredTileMap::_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 {
@ -783,7 +1002,7 @@ bool LayeredTileMap::_set(const StringName &p_name, const Variant &p_value) {
bool LayeredTileMap::_get(const StringName &p_name, Variant &r_ret) const {
Vector<String> components = String(p_name).split("/", true, 2);
if (p_name == "format") {
r_ret = LayeredTileMapDataFormat::FORMAT_MAX - 1; // When saving, always save highest format.
r_ret = LayeredTileMapDataFormat::TILE_MAP_DATA_FORMAT_MAX - 1; // When saving, always save highest format.
return true;
}
#ifndef DISABLE_DEPRECATED
@ -820,7 +1039,7 @@ bool LayeredTileMap::_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;
@ -1079,6 +1298,9 @@ void LayeredTileMap::_bind_methods() {
ClassDB::bind_method(D_METHOD("force_update", "layer"), &LayeredTileMap::force_update, DEFVAL(-1));
#endif // DISABLE_DEPRECATED
ClassDB::bind_method(D_METHOD("set_tileset", "tileset"), &LayeredTileMap::set_tileset);
ClassDB::bind_method(D_METHOD("get_tileset"), &LayeredTileMap::get_tileset);
ClassDB::bind_method(D_METHOD("set_rendering_quadrant_size", "size"), &LayeredTileMap::set_rendering_quadrant_size);
ClassDB::bind_method(D_METHOD("get_rendering_quadrant_size"), &LayeredTileMap::get_rendering_quadrant_size);
@ -1159,7 +1381,9 @@ void LayeredTileMap::_bind_methods() {
//ClassDB::bind_method(D_METHOD("tile_data_runtime_update", "layer", "coords", "tile_data"), &LayeredTileMap::tile_data_runtime_update);
ClassDB::bind_method(D_METHOD("_emit_changed"), &LayeredTileMap::_emit_changed);
ClassDB::bind_method(D_METHOD("_tile_set_changed"), &LayeredTileMap::_tile_set_changed);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "LayeredTileSet"), "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");
@ -1191,7 +1415,7 @@ void LayeredTileMap::_bind_methods() {
ADD_ARRAY("layers", "layer_");
ADD_PROPERTY_DEFAULT("format", LayeredTileMapDataFormat::FORMAT_1);
ADD_PROPERTY_DEFAULT("format", LayeredTileMapDataFormat::TILE_MAP_DATA_FORMAT_1);
ADD_SIGNAL(MethodInfo(CoreStringNames::get_singleton()->changed));
@ -1206,6 +1430,7 @@ LayeredTileMap::LayeredTileMap() {
move_child(new_layer, 0);
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, this, "_emit_changed");
layers.push_back(new_layer);
default_layer = memnew(LayeredTileMapLayer);

32
modules/layered_tile_map/layered_tile_map.h
View File

@ -32,7 +32,7 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "layered_tile_map_layer_group.h"
#include "layered_tile_map_layer.h"
#include "layered_tile_set.h"
#include "modules/modules_enabled.gen.h"
@ -47,14 +47,14 @@ class LayeredTileMapLayer;
class TerrainConstraint;
enum LayeredTileMapDataFormat {
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 LayeredTileMap : public LayeredTileMapLayerGroup {
GDCLASS(LayeredTileMap, LayeredTileMapLayerGroup)
class LayeredTileMap : public YSort {
GDCLASS(LayeredTileMap, YSort)
public:
// Kept for compatibility, but should use LayeredTileMapLayer::VisibilityMode instead.
@ -68,11 +68,12 @@ private:
friend class LayeredTileSetPlugin;
// A compatibility enum to specify how is the data if formatted.
mutable LayeredTileMapDataFormat format = LayeredTileMapDataFormat::FORMAT_3;
mutable LayeredTileMapDataFormat format = LayeredTileMapDataFormat::TILE_MAP_DATA_FORMAT_3;
static constexpr float FP_ADJUST = 0.00001;
// Properties.
Ref<LayeredTileSet> tile_set;
int rendering_quadrant_size = 16;
bool collision_animatable = false;
VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT;
@ -100,7 +101,13 @@ private:
Ref<FastNoise> _rao_noise;
#endif
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, LayeredTileMapDataFormat p_format, const Vector<int> &p_data);
Vector<int> _get_tile_map_data_using_compatibility_format(int p_layer) const;
protected:
bool _set(const StringName &p_name, const Variant &p_value);
@ -126,6 +133,10 @@ public:
static void draw_tile(RID p_canvas_item, const Vector2 &p_position, const Ref<LayeredTileSet> 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 LayeredTileData *p_tile_data_override = nullptr, real_t p_normalized_animation_offset = 0.0);
// Accessors.
void set_tileset(const Ref<LayeredTileSet> &p_tileset);
Ref<LayeredTileSet> get_tileset() const;
// Layers management.
int get_layers_count() const;
void add_layer(int p_to_pos);
@ -230,6 +241,11 @@ public:
// Fixing and clearing methods.
void fix_invalid_tiles();
#ifdef TOOLS_ENABLED
// Moving layers outside of TileMap.
LayeredTileMapLayer *duplicate_layer_from_internal(int p_layer);
#endif // TOOLS_ENABLED
// Clears tiles from a given layer.
void clear_layer(int p_layer);
void clear();

832
modules/layered_tile_map/layered_tile_map_layer.cpp
View File

File diff suppressed because it is too large Load Diff

146
modules/layered_tile_map/layered_tile_map_layer.h
View File

@ -32,7 +32,6 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "layered_tile_map.h"
#include "layered_tile_set.h"
#include "scene/2d/y_sort.h"
@ -43,6 +42,12 @@
#endif
class LayeredTileSetAtlasSource;
class LayeredTileMap;
enum LayeredTileMapLayerDataFormat {
LAYERED_TILE_MAP_LAYER_DATA_FORMAT_0 = 0,
LAYERED_TILE_MAP_LAYER_DATA_FORMAT_MAX,
};
class TerrainConstraint {
private:
@ -235,14 +240,21 @@ class LayeredTileMapLayer : public YSort {
GDCLASS(LayeredTileMapLayer, YSort);
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,
@ -255,6 +267,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,
@ -275,23 +288,32 @@ 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<Vector2i, CellData> tile_map_layer_data;
bool enabled = true;
Ref<LayeredTileSet> 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<Vector2i, CellData> tile_map;
@ -385,6 +407,8 @@ private:
RBSet<TerrainConstraint> _get_terrain_constraints_from_added_pattern(const Vector2i &p_position, int p_terrain_set, LayeredTileSet::TerrainsPattern p_terrains_pattern) const;
RBSet<TerrainConstraint> _get_terrain_constraints_from_painted_cells_list(const RBSet<Vector2i> &p_painted, int p_terrain_set, bool p_ignore_empty_terrains) const;
void _tile_set_changed();
void _renamed();
void _update_notify_local_transform();
@ -400,11 +424,19 @@ private:
protected:
void _notification(int p_what);
static void _bind_methods();
public:
// LayeredTileMap 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<Vector2i, CellData> &get_tile_map_layer_data() const {
return tile_map_layer_data;
}
// Rect caching.
Rect2 get_rect(bool &r_changed) const;
@ -416,26 +448,26 @@ public:
HashMap<Vector2i, LayeredTileSet::TerrainsPattern> terrain_fill_pattern(const Vector<Vector2i> &p_coords_array, int p_terrain_set, LayeredTileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains = true) const; // Not exposed.
// Not exposed to users.
LayeredTileMapCell get_cell(const Vector2i &p_coords, bool p_use_proxies = false) const;
LayeredTileMapCell get_cell(const Vector2i &p_coords) const;
// For LayeredTileMap node's use.
void set_tile_data(LayeredTileMapDataFormat p_format, const Vector<int> &p_data);
Vector<int> 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 LayeredTileMap ---
// Cells manipulation.
void set_cell(const Vector2i &p_coords, int p_source_id = LayeredTileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = LayeredTileSetSource::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 = LayeredTileSet::INVALID_SOURCE, const Vector2i &p_atlas_coords = LayeredTileSetSource::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;
LayeredTileData *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;
LayeredTileData *get_cell_tile_data(const Vector2i &p_coords) const; // Helper method to make accessing the data easier.
PoolVector2iArray get_used_cells() const;
PoolVector2iArray get_used_cells_by_id(int p_source_id = LayeredTileSet::INVALID_SOURCE, const Vector2i &p_atlas_coords = LayeredTileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = LayeredTileSetSource::INVALID_TILE_ALTERNATIVE) const;
Rect2i get_used_rect() const;
// Patterns.
Ref<LayeredTileMapPattern> get_pattern(PoolVector2iArray p_coords_array);
@ -445,14 +477,33 @@ public:
void set_cells_terrain_connect(PoolVector2iArray p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
void set_cells_terrain_path(PoolVector2iArray p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
// Cells usage.
PoolVector2iArray get_used_cells() const;
PoolVector2iArray get_used_cells_by_id(int p_source_id = LayeredTileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = LayeredTileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = LayeredTileSetSource::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();
// --- Shortcuts to methods defined in TileSet ---
Vector2i map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref<LayeredTileMapPattern> p_pattern);
PoolVector2iArray get_surrounding_cells(const Vector2i &p_coords);
Vector2i get_neighbor_cell(const Vector2i &p_coords, LayeredTileSet::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<uint8_t> &p_data);
Vector<uint8_t> 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<LayeredTileSet> &p_tile_set);
Ref<LayeredTileSet> 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);
virtual void set_y_sort_enabled(bool p_y_sort_enabled);
void set_y_sort_origin(int p_y_sort_origin);
@ -462,17 +513,24 @@ public:
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;
void set_navigation_visibility_mode(DebugVisibilityMode p_show_navigation);
DebugVisibilityMode get_navigation_visibility_mode() const;
// Virtual function to modify the LayeredTileData at runtime.
bool use_tile_data_runtime_update(const Vector2i &p_coords);
void tile_data_runtime_update(const Vector2i &p_coords, LayeredTileData *p_tile_data);
//VertexLights2D
#ifdef MODULE_VERTEX_LIGHTS_2D_ENABLED
@ -488,25 +546,11 @@ public:
void set_rao_strength(const real_t p_strength);
real_t get_rao_strength() const;
#endif
// 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<LayeredTileSet> get_effective_tile_set() const;
// Virtual function to modify the LayeredTileData at runtime.
bool use_tile_data_runtime_update(const Vector2i &p_coords);
void tile_data_runtime_update(const Vector2i &p_coords, LayeredTileData *p_tile_data);
// ---
LayeredTileMapLayer();
~LayeredTileMapLayer();
};
VARIANT_ENUM_CAST(LayeredTileMapLayer::DebugVisibilityMode);
#endif // TILE_MAP_LAYER_H

151
modules/layered_tile_map/layered_tile_map_layer_group.cpp
View File

@ -1,151 +0,0 @@
/*************************************************************************/
/* layered_tile_map_layer_group.cpp */
/*************************************************************************/
/* This file is part of: */
/* PANDEMONIUM ENGINE */
/* https://github.com/Relintai/pandemonium_engine */
/*************************************************************************/
/* Copyright (c) 2022-present Péter Magyar. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
/* Copyright (c) 2007-2022 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 "layered_tile_map_layer_group.h"
#include "core/core_string_names.h"
#include "layered_tile_map_layer.h"
#include "layered_tile_set.h"
#ifdef TOOLS_ENABLED
void LayeredTileMapLayerGroup::_cleanup_selected_layers() {
for (int i = 0; i < selected_layers.size(); i++) {
const String name = selected_layers[i];
LayeredTileMapLayer *layer = Object::cast_to<LayeredTileMapLayer>(get_node_or_null(name));
if (!layer) {
selected_layers.remove(i);
i--;
}
}
}
#endif // TOOLS_ENABLED
void LayeredTileMapLayerGroup::_tile_set_changed() {
for (int i = 0; i < get_child_count(); i++) {
LayeredTileMapLayer *layer = Object::cast_to<LayeredTileMapLayer>(get_child(i));
if (layer) {
layer->notify_tile_map_layer_group_change(LayeredTileMapLayer::DIRTY_FLAGS_LAYER_GROUP_TILE_SET);
}
}
update_configuration_warning();
}
#ifdef TOOLS_ENABLED
void LayeredTileMapLayerGroup::set_selected_layers(Vector<StringName> p_layer_names) {
selected_layers = p_layer_names;
_cleanup_selected_layers();
// Update the layers modulation.
for (int i = 0; i < get_child_count(); i++) {
LayeredTileMapLayer *layer = Object::cast_to<LayeredTileMapLayer>(get_child(i));
if (layer) {
layer->notify_tile_map_layer_group_change(LayeredTileMapLayer::DIRTY_FLAGS_LAYER_GROUP_SELECTED_LAYERS);
}
}
}
Vector<StringName> LayeredTileMapLayerGroup::get_selected_layers() const {
return selected_layers;
}
void LayeredTileMapLayerGroup::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++) {
LayeredTileMapLayer *layer = Object::cast_to<LayeredTileMapLayer>(get_child(i));
if (layer) {
layer->notify_tile_map_layer_group_change(LayeredTileMapLayer::DIRTY_FLAGS_LAYER_GROUP_HIGHLIGHT_SELECTED);
}
}
}
bool LayeredTileMapLayerGroup::is_highlighting_selected_layer() const {
return highlight_selected_layer;
}
#endif // TOOLS_ENABLED
void LayeredTileMapLayerGroup::remove_child_notify(Node *p_child) {
#ifdef TOOLS_ENABLED
_cleanup_selected_layers();
#endif // TOOLS_ENABLED
}
void LayeredTileMapLayerGroup::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_tileset", "tileset"), &LayeredTileMapLayerGroup::set_tileset);
ClassDB::bind_method(D_METHOD("get_tileset"), &LayeredTileMapLayerGroup::get_tileset);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "LayeredTileSet"), "set_tileset", "get_tileset");
ClassDB::bind_method(D_METHOD("_tile_set_changed"), &LayeredTileMapLayerGroup::_tile_set_changed);
}
void LayeredTileMapLayerGroup::set_tileset(const Ref<LayeredTileSet> &p_tileset) {
if (p_tileset == tile_set) {
return;
}
// Set the tileset, registering to its changes.
if (tile_set.is_valid()) {
tile_set->disconnect(CoreStringNames::get_singleton()->changed, this, "_tile_set_changed");
}
tile_set = p_tileset;
if (tile_set.is_valid()) {
tile_set->connect(CoreStringNames::get_singleton()->changed, this, "_tile_set_changed");
}
for (int i = 0; i < get_child_count(); i++) {
LayeredTileMapLayer *layer = Object::cast_to<LayeredTileMapLayer>(get_child(i));
if (layer) {
layer->notify_tile_map_layer_group_change(LayeredTileMapLayer::DIRTY_FLAGS_LAYER_GROUP_TILE_SET);
}
}
}
Ref<LayeredTileSet> LayeredTileMapLayerGroup::get_tileset() const {
return tile_set;
}
LayeredTileMapLayerGroup::~LayeredTileMapLayerGroup() {
if (tile_set.is_valid()) {
tile_set->disconnect(CoreStringNames::get_singleton()->changed, this, "_tile_set_changed");
}
}

74
modules/layered_tile_map/layered_tile_map_layer_group.h
View File

@ -1,74 +0,0 @@
#ifndef LAYERED_TILE_MAP_LAYER_GROUP_H
#define LAYERED_TILE_MAP_LAYER_GROUP_H
/*************************************************************************/
/* layered_tile_map_layer_group.h */
/*************************************************************************/
/* This file is part of: */
/* PANDEMONIUM ENGINE */
/* https://github.com/Relintai/pandemonium_engine */
/*************************************************************************/
/* Copyright (c) 2022-present Péter Magyar. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
/* Copyright (c) 2007-2022 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 "scene/2d/y_sort.h"
class LayeredTileSet;
class LayeredTileMapLayerGroup : public YSort {
GDCLASS(LayeredTileMapLayerGroup, YSort);
private:
mutable Vector<StringName> selected_layers;
bool highlight_selected_layer = true;
#ifdef TOOLS_ENABLED
void _cleanup_selected_layers();
#endif
void _tile_set_changed();
protected:
Ref<LayeredTileSet> tile_set;
virtual void remove_child_notify(Node *p_child);
static void _bind_methods();
public:
#ifdef TOOLS_ENABLED
// For editor use.
void set_selected_layers(Vector<StringName> p_layer_names);
Vector<StringName> 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<LayeredTileSet> &p_tileset);
Ref<LayeredTileSet> get_tileset() const;
~LayeredTileMapLayerGroup();
};
#endif // TILE_MAP_LAYER_GROUP_H

13
modules/layered_tile_map/layered_tile_set.cpp
View File

@ -1433,10 +1433,10 @@ int LayeredTileSet::get_patterns_count() {
return patterns.size();
}
RBSet<LayeredTileSet::TerrainsPattern> LayeredTileSet::get_terrains_pattern_set(int p_terrain_set) {
RBSet<LayeredTileSet::TerrainsPattern> LayeredTileSet::get_terrains_pattern_set(int p_terrain_set) const {
ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), RBSet<LayeredTileSet::TerrainsPattern>());
_update_terrains_cache();
const_cast<LayeredTileSet*>(this)->_update_terrains_cache();
RBSet<LayeredTileSet::TerrainsPattern> output;
@ -1449,17 +1449,18 @@ RBSet<LayeredTileSet::TerrainsPattern> LayeredTileSet::get_terrains_pattern_set(
return output;
}
RBSet<LayeredTileMapCell> LayeredTileSet::get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) {
RBSet<LayeredTileMapCell> LayeredTileSet::get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) const {
ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), RBSet<LayeredTileMapCell>());
_update_terrains_cache();
const_cast<LayeredTileSet*>(this)->_update_terrains_cache();
return per_terrain_pattern_tiles[p_terrain_set][p_terrain_tile_pattern];
}
LayeredTileMapCell LayeredTileSet::get_random_tile_from_terrains_pattern(int p_terrain_set, LayeredTileSet::TerrainsPattern p_terrain_tile_pattern) {
LayeredTileMapCell LayeredTileSet::get_random_tile_from_terrains_pattern(int p_terrain_set, LayeredTileSet::TerrainsPattern p_terrain_tile_pattern) const {
ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), LayeredTileMapCell());
_update_terrains_cache();
const_cast<LayeredTileSet*>(this)->_update_terrains_cache();
// Count the sum of probabilities.
double sum = 0.0;

6
modules/layered_tile_map/layered_tile_set.h
View File

@ -524,9 +524,9 @@ public:
int get_patterns_count();
// Terrains.
RBSet<TerrainsPattern> get_terrains_pattern_set(int p_terrain_set);
RBSet<LayeredTileMapCell> get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern);
LayeredTileMapCell get_random_tile_from_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern);
RBSet<TerrainsPattern> get_terrains_pattern_set(int p_terrain_set) const;
RBSet<LayeredTileMapCell> get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) const;
LayeredTileMapCell get_random_tile_from_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) const;
// Helpers
Vector<Vector2> get_tile_shape_polygon() const;

3
modules/layered_tile_map/register_types.cpp
View File

@ -34,7 +34,6 @@
#include "geometry_parser/layered_tilemap_navigation_geometry_parser_2d.h"
#include "servers/navigation/navigation_mesh_generator.h"
#include "layered_tile_map_layer_group.h"
#include "layered_tile_map_layer.h"
#include "layered_tile_map.h"
#include "layered_tile_set.h"
@ -47,7 +46,7 @@ void register_layered_tile_map_types(ModuleRegistrationLevel p_level) {
if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<LayeredTileData>();
ClassDB::register_class<LayeredTileMap>();
ClassDB::register_class<LayeredTileMapLayerGroup>();
ClassDB::register_class<LayeredTileMapLayer>();
ClassDB::register_class<LayeredTileMapPattern>();
ClassDB::register_class<LayeredTileSet>();
ClassDB::register_class<LayeredTileSetAtlasSource>();