Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-15 16:43:10 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #78328 from groud/tilemap_layers_as_another_class

Browse Source 
Move TileMap layers to their own class
This commit is contained in:
Yuri Sizov 2023-07-21 17:15:18 +02:00
commit ac0204b201
4 changed files with 3036 additions and 2709 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
doc/classes/TileMap.xml
View File

@ -55,6 +55,7 @@
<param index="0" name="layer" type="int" />
<description>
Clears all cells on the given layer.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="erase_cell">
@ -63,6 +64,7 @@
<param index="1" name="coords" type="Vector2i" />
<description>
Erases the cell on layer [param layer] at coordinates [param coords].
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="fix_invalid_tiles">
@ -75,7 +77,7 @@
<return type="void" />
<param index="0" name="layer" type="int" default="-1" />
<description>
Triggers an update of the TileMap. If [param layer] is provided, only updates the given layer.
Triggers an update of the TileMap. If [param layer] is provided and is positive, only updates the given layer.
[b]Note:[/b] The TileMap node updates automatically when one of its properties is modified. A manual update is only needed if runtime modifications (implemented in [method _tile_data_runtime_update]) need to be applied.
[b]Warning:[/b] Updating the TileMap is computationally expensive and may impact performance. Try to limit the number of updates and the tiles they impact (by placing frequently updated tiles in a dedicated layer for example).
</description>
@ -87,6 +89,7 @@
<param 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 [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>
<method name="get_cell_atlas_coords" qualifiers="const">
@ -96,6 +99,7 @@
<param 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 [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>
<method name="get_cell_source_id" qualifiers="const">
@ -106,6 +110,7 @@
<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 [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>
<method name="get_cell_tile_data" qualifiers="const">
@ -115,6 +120,7 @@
<param index="2" name="use_proxies" type="bool" default="false" />
<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].
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():
@ -146,6 +152,7 @@
<param index="0" name="layer" type="int" />
<description>
Returns a TileMap layer's modulate.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_layer_name" qualifiers="const">
@ -153,6 +160,17 @@
<param index="0" name="layer" type="int" />
<description>
Returns a TileMap layer's name.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_layer_navigation_map" qualifiers="const">
<return type="RID" />
<param index="0" name="layer" type="int" />
<description>
Returns the [NavigationServer2D] navigation map [RID] currently assigned to the specified TileMap [param layer].
By default the TileMap uses the default [World2D] navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
In order to make [NavigationAgent2D] switch between TileMap layer navigation maps use [method NavigationAgent2D.set_navigation_map] with the navigation map received from [method get_layer_navigation_map].
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_layer_y_sort_origin" qualifiers="const">
@ -160,6 +178,7 @@
<param index="0" name="layer" type="int" />
<description>
Returns a TileMap layer's Y sort origin.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_layer_z_index" qualifiers="const">
@ -167,6 +186,7 @@
<param index="0" name="layer" type="int" />
<description>
Returns a TileMap layer's Z-index value.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_layers_count" qualifiers="const">
@ -175,13 +195,11 @@
Returns the number of layers in the TileMap.
</description>
</method>
<method name="get_navigation_map" qualifiers="const">
<method name="get_navigation_map" qualifiers="const" is_deprecated="true">
<return type="RID" />
<param index="0" name="layer" type="int" />
<description>
Returns the [NavigationServer2D] navigation map [RID] currently assigned to the specified TileMap [param layer].
By default the TileMap uses the default [World2D] navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
In order to make [NavigationAgent2D] switch between TileMap layer navigation maps use [method NavigationAgent2D.set_navigation_map] with the navigation map received from [method get_navigation_map].
See [method get_layer_navigation_map].
</description>
</method>
<method name="get_neighbor_cell" qualifiers="const">
@ -198,6 +216,7 @@
<param index="1" name="coords_array" type="Vector2i[]" />
<description>
Creates a new [TileMapPattern] from the given layer and set of cells.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_surrounding_cells">
@ -212,6 +231,7 @@
<param index="0" name="layer" type="int" />
<description>
Returns a [Vector2i] array with the positions of all cells containing a tile in the given layer. A cell is considered empty if its source identifier equals -1, its atlas coordinates identifiers is [code]Vector2(-1, -1)[/code] and its alternative identifier is -1.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_used_cells_by_id" qualifiers="const">
@ -224,9 +244,10 @@
Returns a [Vector2i] array with the positions of all cells containing a tile in the given layer. 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 it's value set to the default one, this parameter is not used to filter a cell. Thus, if all parameters have their respective default value, this method returns the same result as [method get_used_cells].
A cell is considered empty if its source identifier equals -1, its atlas coordinates identifiers is [code]Vector2(-1, -1)[/code] and its alternative identifier is -1.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="get_used_rect">
<method name="get_used_rect" qualifiers="const">
<return type="Rect2i" />
<description>
Returns a rectangle enclosing the used (non-empty) tiles of the map, including all layers.
@ -237,6 +258,7 @@
<param index="0" name="layer" type="int" />
<description>
Returns if a layer is enabled.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="is_layer_y_sort_enabled" qualifiers="const">
@ -244,6 +266,7 @@
<param index="0" name="layer" type="int" />
<description>
Returns if a layer Y-sorts its tiles.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="local_to_map" qualifiers="const">
@ -298,6 +321,7 @@
- The atlas coordinates 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].
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="set_cells_terrain_connect">
@ -310,6 +334,7 @@
<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.
If [param layer] is negative, the layers are accessed from the last one.
[b]Note:[/b] To work correctly, this method requires the TileMap's TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results.
</description>
</method>
@ -323,6 +348,7 @@
<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.
If [param layer] is negative, the layers are accessed from the last one.
[b]Note:[/b] To work correctly, this method requires the TileMap's TileSet to have terrains set up with all required terrain combinations. Otherwise, it may produce unexpected results.
</description>
</method>
@ -353,6 +379,17 @@
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="set_layer_navigation_map">
<return type="void" />
<param index="0" name="layer" type="int" />
<param index="1" name="map" type="RID" />
<description>
Assigns a [NavigationServer2D] navigation map [RID] to the specified TileMap [param layer].
By default the TileMap uses the default [World2D] navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
In order to make [NavigationAgent2D] switch between TileMap layer navigation maps use [method NavigationAgent2D.set_navigation_map] with the navigation map received from [method get_layer_navigation_map].
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="set_layer_y_sort_enabled">
<return type="void" />
<param index="0" name="layer" type="int" />
@ -382,14 +419,12 @@
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
<method name="set_navigation_map">
<method name="set_navigation_map" is_deprecated="true">
<return type="void" />
<param index="0" name="layer" type="int" />
<param index="1" name="map" type="RID" />
<description>
Assigns a [NavigationServer2D] navigation map [RID] to the specified TileMap [param layer].
By default the TileMap uses the default [World2D] navigation map for the first TileMap layer. For each additional TileMap layer a new navigation map is created for the additional layer.
In order to make [NavigationAgent2D] switch between TileMap layer navigation maps use [method NavigationAgent2D.set_navigation_map] with the navigation map received from [method get_navigation_map].
See [method set_layer_navigation_map].
</description>
</method>
<method name="set_pattern">
@ -399,6 +434,7 @@
<param index="2" name="pattern" type="TileMapPattern" />
<description>
Paste the given [TileMapPattern] at the given [param position] and [param layer] in the tile map.
If [param layer] is negative, the layers are accessed from the last one.
</description>
</method>
</methods>

45
scene/2d/tile_map.compat.inc Normal file
View File

@ -0,0 +1,45 @@
/**************************************************************************/
/* object.compat.inc */
/**************************************************************************/
/* 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 DISABLE_DEPRECATED
#include "core/object/object.h"
#include "core/object/class_db.h"
Rect2i TileMap::_get_used_rect_bind_compat_78328() {
return get_used_rect();
}
void TileMap::_bind_compatibility_methods() {
ClassDB::bind_compatibility_method(D_METHOD("get_used_rect"), &TileMap::_get_used_rect_bind_compat_78328);
}
#endif

5225
scene/2d/tile_map.cpp
View File

File diff suppressed because it is too large Load Diff

419
scene/2d/tile_map.h
View File

@ -37,6 +37,58 @@
class TileSetAtlasSource;
class TerrainConstraint {
private:
const TileMap *tile_map = nullptr;
Vector2i base_cell_coords;
int bit = -1;
int terrain = -1;
int priority = 1;
public:
bool operator<(const TerrainConstraint &p_other) const {
if (base_cell_coords == p_other.base_cell_coords) {
return bit < p_other.bit;
}
return base_cell_coords < p_other.base_cell_coords;
}
String to_string() const {
return vformat("Constraint {pos:%s, bit:%d, terrain:%d, priority:%d}", base_cell_coords, bit, terrain, priority);
}
Vector2i get_base_cell_coords() const {
return base_cell_coords;
}
bool is_center_bit() const {
return bit == 0;
}
HashMap<Vector2i, TileSet::CellNeighbor> get_overlapping_coords_and_peering_bits() const;
void set_terrain(int p_terrain) {
terrain = p_terrain;
}
int get_terrain() const {
return terrain;
}
void set_priority(int p_priority) {
priority = p_priority;
}
int get_priority() const {
return priority;
}
TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, int p_terrain); // For the center terrain bit
TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, const TileSet::CellNeighbor &p_bit, int p_terrain); // For peering bits
TerrainConstraint(){};
};
struct TileMapQuadrant {
struct CoordsWorldComparator {
_ALWAYS_INLINE_ bool operator()(const Vector2 &p_a, const Vector2 &p_b) const {
@ -52,13 +104,12 @@ struct TileMapQuadrant {
// Dirty list element.
SelfList<TileMapQuadrant> dirty_list_element;
// Quadrant layer and coords.
int layer = -1;
// Quadrant coords.
Vector2i coords;
// TileMapCells
// TileMapCells.
RBSet<Vector2i> cells;
// We need those two maps to sort by local position for rendering
// We need those two maps to sort by local position for rendering.
// This is kind of workaround, it would be better to sort the cells directly in the "cells" set instead.
RBMap<Vector2i, Vector2> map_to_local;
RBMap<Vector2, Vector2i, CoordsWorldComparator> local_to_map;
@ -83,7 +134,6 @@ struct TileMapQuadrant {
HashMap<Vector2i, TileData *> runtime_tile_data_cache;
void operator=(const TileMapQuadrant &q) {
layer = q.layer;
coords = q.coords;
debug_canvas_item = q.debug_canvas_item;
canvas_items = q.canvas_items;
@ -94,7 +144,6 @@ struct TileMapQuadrant {
TileMapQuadrant(const TileMapQuadrant &q) :
dirty_list_element(this) {
layer = q.layer;
coords = q.coords;
debug_canvas_item = q.debug_canvas_item;
canvas_items = q.canvas_items;
@ -108,62 +157,174 @@ struct TileMapQuadrant {
}
};
class TileMapLayer : public RefCounted {
public:
enum DataFormat {
FORMAT_1 = 0,
FORMAT_2,
FORMAT_3,
FORMAT_MAX,
};
private:
// Exposed properties.
String name;
bool enabled = true;
Color modulate = Color(1, 1, 1, 1);
bool y_sort_enabled = false;
int y_sort_origin = 0;
int z_index = 0;
RID navigation_map;
bool uses_world_navigation_map = false;
// Internal.
TileMap *tile_map_node = nullptr;
int layer_index_in_tile_map_node = -1;
RID canvas_item;
bool _rendering_quadrant_order_dirty = false;
HashMap<Vector2i, TileMapCell> tile_map;
HashMap<Vector2i, TileMapQuadrant> quadrant_map;
SelfList<TileMapQuadrant>::List dirty_quadrant_list;
// Rect cache.
mutable Rect2 rect_cache;
mutable bool rect_cache_dirty = true;
mutable Rect2i used_rect_cache;
mutable bool used_rect_cache_dirty = true;
// Quadrants management.
Vector2i _coords_to_quadrant_coords(const Vector2i &p_coords) const;
HashMap<Vector2i, TileMapQuadrant>::Iterator _create_quadrant(const Vector2i &p_qk);
void _make_quadrant_dirty(HashMap<Vector2i, TileMapQuadrant>::Iterator Q);
void _erase_quadrant(HashMap<Vector2i, TileMapQuadrant>::Iterator Q);
// Per-system methods.
void _rendering_notification(int p_what);
void _rendering_update();
void _rendering_cleanup();
void _rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _rendering_reorder_quadrants(int &r_index);
void _rendering_create_quadrant(TileMapQuadrant *p_quadrant);
void _rendering_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _rendering_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
HashMap<RID, Vector2i> bodies_coords; // Mapping for RID to coords.
void _physics_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _physics_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _physics_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
void _navigation_update();
void _navigation_cleanup();
void _navigation_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _navigation_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _navigation_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
HashSet<Vector2i> instantiated_scenes;
void _scenes_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _scenes_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _scenes_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
// Runtime tile data.
void _build_runtime_update_tile_data(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
// Terrains.
TileSet::TerrainsPattern _get_best_terrain_pattern_for_constraints(int p_terrain_set, const Vector2i &p_position, const RBSet<TerrainConstraint> &p_constraints, TileSet::TerrainsPattern p_current_pattern);
RBSet<TerrainConstraint> _get_terrain_constraints_from_added_pattern(const Vector2i &p_position, int p_terrain_set, TileSet::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;
public:
// TileMap node.
void set_tile_map(TileMap *p_tile_map);
void set_layer_index_in_tile_map_node(int p_index);
// Rect caching.
Rect2 get_rect(bool &r_changed) const;
// Terrains.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_constraints(const Vector<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> &p_constraints); // Not exposed.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_connect(const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); // Not exposed.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_path(const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); // Not exposed.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_pattern(const Vector<Vector2i> &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains = true); // Not exposed.
// Not exposed to users.
TileMapCell get_cell(const Vector2i &p_coords, bool p_use_proxies = false) const;
int get_effective_quadrant_size() const;
// For TileMap node's use.
void notify_canvas_entered();
void notify_visibility_changed();
void notify_xform_changed();
void notify_local_xform_changed();
void notify_canvas_exited();
void notify_selected_layer_changed();
void notify_light_mask_changed();
void notify_material_changed();
void notify_use_parent_material_changed();
void notify_texture_filter_changed();
void notify_texture_repeat_changed();
void update_dirty_quadrants();
void set_tile_data(DataFormat p_format, const Vector<int> &p_data);
Vector<int> get_tile_data() const;
void clear_instantiated_scenes();
void clear_internals(); // Exposed for now to tilemap, but ideally, we should avoid it.
void recreate_internals(); // Exposed for now to tilemap, but ideally, we should avoid it.
// --- 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);
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 clear();
// Patterns.
Ref<TileMapPattern> get_pattern(TypedArray<Vector2i> p_coords_array);
void set_pattern(const Vector2i &p_position, const Ref<TileMapPattern> p_pattern);
// Terrains.
void set_cells_terrain_connect(TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
void set_cells_terrain_path(TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
// Cells usage.
TypedArray<Vector2i> get_used_cells() const;
TypedArray<Vector2i> 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;
// Layer properties.
void set_name(String p_name);
String get_name() const;
void set_enabled(bool p_enabled);
bool is_enabled() const;
void set_modulate(Color p_modulate);
Color get_modulate() const;
void set_y_sort_enabled(bool p_y_sort_enabled);
bool is_y_sort_enabled() const;
void set_y_sort_origin(int p_y_sort_origin);
int get_y_sort_origin() const;
void set_z_index(int p_z_index);
int get_z_index() const;
void set_navigation_map(RID p_map);
RID get_navigation_map() const;
// In case something goes wrong.
void force_update();
// 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.
};
class TileMap : public Node2D {
GDCLASS(TileMap, Node2D);
public:
class TerrainConstraint {
private:
const TileMap *tile_map;
Vector2i base_cell_coords;
int bit = -1;
int terrain = -1;
int priority = 1;
public:
bool operator<(const TerrainConstraint &p_other) const {
if (base_cell_coords == p_other.base_cell_coords) {
return bit < p_other.bit;
}
return base_cell_coords < p_other.base_cell_coords;
}
String to_string() const {
return vformat("Constraint {pos:%s, bit:%d, terrain:%d, priority:%d}", base_cell_coords, bit, terrain, priority);
}
Vector2i get_base_cell_coords() const {
return base_cell_coords;
}
bool is_center_bit() const {
return bit == 0;
}
HashMap<Vector2i, TileSet::CellNeighbor> get_overlapping_coords_and_peering_bits() const;
void set_terrain(int p_terrain) {
terrain = p_terrain;
}
int get_terrain() const {
return terrain;
}
void set_priority(int p_priority) {
priority = p_priority;
}
int get_priority() const {
return priority;
}
TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, int p_terrain); // For the center terrain bit
TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, const TileSet::CellNeighbor &p_bit, int p_terrain); // For peering bits
TerrainConstraint(){};
};
enum VisibilityMode {
VISIBILITY_MODE_DEFAULT,
VISIBILITY_MODE_FORCE_SHOW,
@ -174,12 +335,7 @@ private:
friend class TileSetPlugin;
// A compatibility enum to specify how is the data if formatted.
enum DataFormat {
FORMAT_1 = 0,
FORMAT_2,
FORMAT_3
};
mutable DataFormat format = FORMAT_3;
mutable TileMapLayer::DataFormat format = TileMapLayer::FORMAT_3;
static constexpr float FP_ADJUST = 0.00001;
@ -190,99 +346,17 @@ private:
VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT;
VisibilityMode navigation_visibility_mode = VISIBILITY_MODE_DEFAULT;
// Updates.
bool pending_update = false;
// Rect.
Rect2 rect_cache;
bool rect_cache_dirty = true;
Rect2i used_rect_cache;
bool used_rect_cache_dirty = true;
// TileMap layers.
struct TileMapLayer {
String name;
bool enabled = true;
Color modulate = Color(1, 1, 1, 1);
bool y_sort_enabled = false;
int y_sort_origin = 0;
int z_index = 0;
RID canvas_item;
HashMap<Vector2i, TileMapCell> tile_map;
HashMap<Vector2i, TileMapQuadrant> quadrant_map;
SelfList<TileMapQuadrant>::List dirty_quadrant_list;
RID navigation_map;
bool uses_world_navigation_map = false;
};
LocalVector<TileMapLayer> layers;
// Layers.
LocalVector<Ref<TileMapLayer>> layers;
int selected_layer = -1;
// Mapping for RID to coords.
HashMap<RID, Vector2i> bodies_coords;
// Mapping for RID to tile layer.
HashMap<RID, int> bodies_layers;
// Quadrants and internals management.
Vector2i _coords_to_quadrant_coords(int p_layer, const Vector2i &p_coords) const;
HashMap<Vector2i, TileMapQuadrant>::Iterator _create_quadrant(int p_layer, const Vector2i &p_qk);
void _make_quadrant_dirty(HashMap<Vector2i, TileMapQuadrant>::Iterator Q);
void _make_all_quadrants_dirty();
void _queue_update_dirty_quadrants();
void _update_dirty_quadrants();
void _recreate_layer_internals(int p_layer);
void _clear_internals();
void _recreate_internals();
void _erase_quadrant(HashMap<Vector2i, TileMapQuadrant>::Iterator Q);
void _clear_layer_internals(int p_layer);
void _clear_internals();
HashSet<Vector3i> instantiated_scenes;
// Rect caching.
void _recompute_rect_cache();
// Per-system methods.
bool _rendering_quadrant_order_dirty = false;
void _rendering_notification(int p_what);
void _rendering_update_layer(int p_layer);
void _rendering_cleanup_layer(int p_layer);
void _rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _rendering_create_quadrant(TileMapQuadrant *p_quadrant);
void _rendering_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _rendering_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
bool pending_update = false;
Transform2D last_valid_transform;
Transform2D new_transform;
void _physics_notification(int p_what);
void _physics_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _physics_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _physics_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
void _navigation_notification(int p_what);
void _navigation_update_layer(int p_layer);
void _navigation_cleanup_layer(int p_layer);
void _navigation_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _navigation_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _navigation_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
void _scenes_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _scenes_cleanup_quadrant(TileMapQuadrant *p_quadrant);
void _scenes_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
// Terrains.
TileSet::TerrainsPattern _get_best_terrain_pattern_for_constraints(int p_terrain_set, const Vector2i &p_position, const RBSet<TerrainConstraint> &p_constraints, TileSet::TerrainsPattern p_current_pattern);
RBSet<TerrainConstraint> _get_terrain_constraints_from_added_pattern(const Vector2i &p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const;
RBSet<TerrainConstraint> _get_terrain_constraints_from_painted_cells_list(int p_layer, const RBSet<Vector2i> &p_painted, int p_terrain_set, bool p_ignore_empty_terrains) const;
// Set and get tiles from data arrays.
void _set_tile_data(int p_layer, const Vector<int> &p_data);
Vector<int> _get_tile_data(int p_layer) const;
void _build_runtime_update_tile_data(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
void _tile_set_changed();
bool _tile_set_changed_deferred_update_needed = false;
@ -296,17 +370,22 @@ protected:
void _notification(int p_what);
static void _bind_methods();
#ifndef DISABLE_DEPRECATED
Rect2i _get_used_rect_bind_compat_78328();
static void _bind_compatibility_methods();
#endif
public:
static Vector2i transform_coords_layout(const Vector2i &p_coords, TileSet::TileOffsetAxis p_offset_axis, TileSet::TileLayout p_from_layout, TileSet::TileLayout p_to_layout);
enum {
INVALID_CELL = -1
};
#ifdef TOOLS_ENABLED
virtual Rect2 _edit_get_rect() const override;
#endif
// Called by TileMapLayers.
void queue_update_dirty_quadrants();
void _update_dirty_quadrants();
void set_tileset(const Ref<TileSet> &p_tileset);
Ref<TileSet> get_tileset() const;
@ -320,6 +399,7 @@ public:
void add_layer(int p_to_pos);
void move_layer(int p_layer, int p_to_pos);
void remove_layer(int p_layer);
void set_layer_name(int p_layer, String p_name);
String get_layer_name(int p_layer) const;
void set_layer_enabled(int p_layer, bool p_visible);
@ -332,6 +412,9 @@ public:
int get_layer_y_sort_origin(int p_layer) const;
void set_layer_z_index(int p_layer, int p_z_index);
int get_layer_z_index(int p_layer) const;
void set_layer_navigation_map(int p_layer, RID p_map);
RID get_layer_navigation_map(int p_layer) const;
void set_selected_layer(int p_layer_id); // For editor use.
int get_selected_layer() const;
@ -345,9 +428,6 @@ public:
void set_navigation_visibility_mode(VisibilityMode p_show_navigation);
VisibilityMode get_navigation_visibility_mode();
void set_navigation_map(int p_layer, RID p_map);
RID get_navigation_map(int p_layer) const;
// Cells accessors.
void set_cell(int p_layer, 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(int p_layer, const Vector2i &p_coords);
@ -362,20 +442,19 @@ public:
Vector2i map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref<TileMapPattern> p_pattern);
void set_pattern(int p_layer, const Vector2i &p_position, const Ref<TileMapPattern> p_pattern);
// Terrains.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_constraints(int p_layer, const Vector<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> &p_constraints); // Not exposed.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_connect(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); // Not exposed.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_path(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); // Not exposed.
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_pattern(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains = true); // Not exposed.
// Terrains (Not exposed).
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_constraints(int p_layer, const Vector<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> &p_constraints);
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_connect(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_path(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_pattern(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains = true);
// Terrains (exposed).
void set_cells_terrain_connect(int p_layer, TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
void set_cells_terrain_path(int p_layer, TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
// Not exposed to users
// Not exposed to users.
TileMapCell get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
HashMap<Vector2i, TileMapQuadrant> *get_quadrant_map(int p_layer);
int get_effective_quadrant_size(int p_layer) const;
//---
virtual void set_y_sort_enabled(bool p_enable) override;
@ -387,9 +466,9 @@ public:
TypedArray<Vector2i> get_used_cells(int p_layer) const;
TypedArray<Vector2i> get_used_cells_by_id(int p_layer, 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(); // Not const because of cache
Rect2i get_used_rect() const;
// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems
// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems.
virtual void set_light_mask(int p_light_mask) override;
virtual void set_material(const Ref<Material> &p_material) override;
virtual void set_use_parent_material(bool p_use_parent_material) override;
@ -404,18 +483,18 @@ public:
// Fixing and clearing methods.
void fix_invalid_tiles();
// Clears tiles from a given layer
// Clears tiles from a given layer.
void clear_layer(int p_layer);
void clear();
// Force a TileMap update
// Force a TileMap update.
void force_update(int p_layer = -1);
// Helpers?
TypedArray<Vector2i> get_surrounding_cells(const Vector2i &coords);
void draw_cells_outline(Control *p_control, const RBSet<Vector2i> &p_cells, Color p_color, Transform2D p_transform = Transform2D());
// Virtual function to modify the TileData at runtime
// Virtual function to modify the TileData at runtime.
GDVIRTUAL2R(bool, _use_tile_data_runtime_update, int, Vector2i);
GDVIRTUAL3(_tile_data_runtime_update, int, Vector2i, TileData *);