Implements TileMap layers and move TileSetPlugins's functions to the TileMap node instead

2 files changed, 1485 insertions, 260 deletions

diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp
index e9efa1cf84..6afa0c0779 100644
--- a/scene/2d/tile_map.cpp
+++ b/scene/2d/tile_map.cpp
@@ -34,6 +34,8 @@
 #include "core/math/geometry_2d.h"
 #include "core/os/os.h"
 
+#include "servers/navigation_server_2d.h"
+
 void TileMapPattern::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) {
 	ERR_FAIL_COND_MSG(p_coords.x < 0 || p_coords.y < 0, vformat("Cannot set cell with negative coords in a TileMapPattern. Wrong coords: %s", p_coords));
 
@@ -235,40 +237,42 @@ Vector2i TileMap::transform_coords_layout(Vector2i p_coords, TileSet::TileOffset
 	return output;
 }
 
-int TileMap::get_effective_quadrant_size() const {
+int TileMap::get_effective_quadrant_size(int p_layer) const {
 	// When using YSort, the quadrant size is reduced to 1 to have one CanvasItem per quadrant
-	if (tile_set.is_valid() && tile_set->is_y_sorting()) {
+	if (is_y_sort_enabled() && layers[p_layer].y_sort_enabled) {
 		return 1;
 	} else {
 		return quadrant_size;
 	}
 }
 
-Vector2i TileMap::_coords_to_quadrant_coords(const Vector2i &p_coords) const {
-	int quadrant_size = get_effective_quadrant_size();
+void TileMap::set_selected_layer(int p_layer_id) {
+	ERR_FAIL_COND(p_layer_id < -1 || p_layer_id >= (int)layers.size());
+	selected_layer = p_layer_id;
+	emit_signal(SNAME("changed"));
+	_make_all_quadrants_dirty();
+}
 
-	// Rounding down, instead of simply rounding towards zero (truncating)
-	return Vector2i(
-			p_coords.x > 0 ? p_coords.x / quadrant_size : (p_coords.x - (quadrant_size - 1)) / quadrant_size,
-			p_coords.y > 0 ? p_coords.y / quadrant_size : (p_coords.y - (quadrant_size - 1)) / quadrant_size);
+int TileMap::get_selected_layer() const {
+	return selected_layer;
 }
 
 void TileMap::_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_ENTER_TREE: {
 			pending_update = true;
-			_recreate_quadrants();
+			_recreate_internals();
 		} break;
 		case NOTIFICATION_EXIT_TREE: {
-			_clear_quadrants();
+			_clear_internals();
 		} break;
 	}
 
 	// Transfers the notification to tileset plugins.
 	if (tile_set.is_valid()) {
-		for (int i = 0; i < tile_set->get_tile_set_atlas_plugins().size(); i++) {
-			tile_set->get_tile_set_atlas_plugins()[i]->tilemap_notification(this, p_what);
-		}
+		_rendering_notification(p_what);
+		_physics_notification(p_what);
+		_navigation_notification(p_what);
 	}
 }
 
@@ -283,64 +287,210 @@ void TileMap::set_tileset(const Ref<TileSet> &p_tileset) {
 
 	// Set the tileset, registering to its changes.
 	if (tile_set.is_valid()) {
-		tile_set->disconnect("changed", callable_mp(this, &TileMap::_make_all_quadrants_dirty));
 		tile_set->disconnect("changed", callable_mp(this, &TileMap::_tile_set_changed));
 	}
 
 	if (!p_tileset.is_valid()) {
-		_clear_quadrants();
+		_clear_internals();
 	}
 
 	tile_set = p_tileset;
 
 	if (tile_set.is_valid()) {
-		tile_set->connect("changed", callable_mp(this, &TileMap::_make_all_quadrants_dirty), varray(true));
 		tile_set->connect("changed", callable_mp(this, &TileMap::_tile_set_changed));
-		_recreate_quadrants();
+		_recreate_internals();
 	}
 
 	emit_signal(SNAME("changed"));
 }
 
+void TileMap::set_quadrant_size(int p_size) {
+	ERR_FAIL_COND_MSG(p_size < 1, "TileMapQuadrant size cannot be smaller than 1.");
+
+	quadrant_size = p_size;
+	_recreate_internals();
+	emit_signal(SNAME("changed"));
+}
+
 int TileMap::get_quadrant_size() const {
 	return quadrant_size;
 }
 
-void TileMap::set_quadrant_size(int p_size) {
-	ERR_FAIL_COND_MSG(p_size < 1, "TileMapQuadrant size cannot be smaller than 1.");
+void TileMap::set_layers_count(int p_layers_count) {
+	ERR_FAIL_COND(p_layers_count < 0);
+	_clear_internals();
 
-	quadrant_size = p_size;
-	_recreate_quadrants();
+	layers.resize(p_layers_count);
+	_recreate_internals();
+	notify_property_list_changed();
+
+	if (selected_layer >= p_layers_count) {
+		selected_layer = -1;
+	}
+
+	emit_signal(SNAME("changed"));
+
+	update_configuration_warnings();
+}
+
+int TileMap::get_layers_count() const {
+	return layers.size();
+}
+
+void TileMap::set_layer_name(int p_layer, String p_name) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+	layers[p_layer].name = p_name;
+	emit_signal(SNAME("changed"));
+}
+
+String TileMap::get_layer_name(int p_layer) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), String());
+	return layers[p_layer].name;
+}
+
+void TileMap::set_layer_enabled(int p_layer, bool p_enabled) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+	layers[p_layer].enabled = p_enabled;
+	_recreate_internals();
+	emit_signal(SNAME("changed"));
+
+	update_configuration_warnings();
+}
+
+bool TileMap::is_layer_enabled(int p_layer) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), false);
+	return layers[p_layer].enabled;
+}
+
+void TileMap::set_layer_y_sort_enabled(int p_layer, bool p_y_sort_enabled) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+	layers[p_layer].y_sort_enabled = p_y_sort_enabled;
+	_recreate_internals();
 	emit_signal(SNAME("changed"));
+
+	update_configuration_warnings();
+}
+
+bool TileMap::is_layer_y_sort_enabled(int p_layer) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), false);
+	return layers[p_layer].y_sort_enabled;
+}
+
+void TileMap::set_layer_y_sort_origin(int p_layer, int p_y_sort_origin) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+	layers[p_layer].y_sort_origin = p_y_sort_origin;
+	_recreate_internals();
+	emit_signal(SNAME("changed"));
+}
+
+int TileMap::get_layer_y_sort_origin(int p_layer) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), false);
+	return layers[p_layer].y_sort_origin;
+}
+
+void TileMap::set_layer_z_index(int p_layer, int p_z_index) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+	layers[p_layer].z_index = p_z_index;
+	_recreate_internals();
+	emit_signal(SNAME("changed"));
+
+	update_configuration_warnings();
+}
+
+int TileMap::get_layer_z_index(int p_layer) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), false);
+	return layers[p_layer].z_index;
 }
 
 void TileMap::set_collision_visibility_mode(TileMap::VisibilityMode p_show_collision) {
-	show_collision = p_show_collision;
-	_recreate_quadrants();
+	collision_visibility_mode = p_show_collision;
+	_recreate_internals();
 	emit_signal(SNAME("changed"));
 }
 
 TileMap::VisibilityMode TileMap::get_collision_visibility_mode() {
-	return show_collision;
+	return collision_visibility_mode;
 }
 
 void TileMap::set_navigation_visibility_mode(TileMap::VisibilityMode p_show_navigation) {
-	show_navigation = p_show_navigation;
-	_recreate_quadrants();
+	navigation_visibility_mode = p_show_navigation;
+	_recreate_internals();
 	emit_signal(SNAME("changed"));
 }
 
 TileMap::VisibilityMode TileMap::get_navigation_visibility_mode() {
-	return show_navigation;
+	return navigation_visibility_mode;
 }
 
 void TileMap::set_y_sort_enabled(bool p_enable) {
 	Node2D::set_y_sort_enabled(p_enable);
-	_recreate_quadrants();
+	_recreate_internals();
 	emit_signal(SNAME("changed"));
 }
 
-void TileMap::update_dirty_quadrants() {
+Vector2i TileMap::_coords_to_quadrant_coords(int p_layer, const Vector2i &p_coords) const {
+	int quadrant_size = get_effective_quadrant_size(p_layer);
+
+	// Rounding down, instead of simply rounding towards zero (truncating)
+	return Vector2i(
+			p_coords.x > 0 ? p_coords.x / quadrant_size : (p_coords.x - (quadrant_size - 1)) / quadrant_size,
+			p_coords.y > 0 ? p_coords.y / quadrant_size : (p_coords.y - (quadrant_size - 1)) / quadrant_size);
+}
+
+Map<Vector2i, TileMapQuadrant>::Element *TileMap::_create_quadrant(int p_layer, const Vector2i &p_qk) {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr);
+
+	TileMapQuadrant q;
+	q.layer = p_layer;
+	q.coords = p_qk;
+
+	rect_cache_dirty = true;
+
+	// Create the debug canvas item.
+	RenderingServer *rs = RenderingServer::get_singleton();
+	q.debug_canvas_item = rs->canvas_item_create();
+	rs->canvas_item_set_z_index(q.debug_canvas_item, RS::CANVAS_ITEM_Z_MAX - 1);
+	rs->canvas_item_set_parent(q.debug_canvas_item, get_canvas_item());
+
+	// Call the create_quadrant method on plugins
+	if (tile_set.is_valid()) {
+		_rendering_create_quadrant(&q);
+		_physics_create_quadrant(&q);
+	}
+
+	return layers[p_layer].quadrant_map.insert(p_qk, q);
+}
+
+void TileMap::_make_quadrant_dirty(Map<Vector2i, TileMapQuadrant>::Element *Q) {
+	// Make the given quadrant dirty, then trigger an update later.
+	TileMapQuadrant &q = Q->get();
+	if (!q.dirty_list_element.in_list()) {
+		layers[q.layer].dirty_quadrant_list.add(&q.dirty_list_element);
+	}
+	_queue_update_dirty_quadrants();
+}
+
+void TileMap::_make_all_quadrants_dirty() {
+	// Make all quandrants dirty, then trigger an update later.
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		for (Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+			if (!E->value().dirty_list_element.in_list()) {
+				layers[layer].dirty_quadrant_list.add(&E->value().dirty_list_element);
+			}
+		}
+	}
+	_queue_update_dirty_quadrants();
+}
+
+void TileMap::_queue_update_dirty_quadrants() {
+	if (pending_update || !is_inside_tree()) {
+		return;
+	}
+	pending_update = true;
+	call_deferred(SNAME("_update_dirty_quadrants"));
+}
+
+void TileMap::_update_dirty_quadrants() {
 	if (!pending_update) {
 		return;
 	}
@@ -349,43 +499,130 @@ void TileMap::update_dirty_quadrants() {
 		return;
 	}
 
-	// Update the coords cache.
-	for (SelfList<TileMapQuadrant> *q = dirty_quadrant_list.first(); q; q = q->next()) {
-		q->self()->map_to_world.clear();
-		q->self()->world_to_map.clear();
-		for (Set<Vector2i>::Element *E = q->self()->cells.front(); E; E = E->next()) {
-			Vector2i pk = E->get();
-			Vector2i pk_world_coords = map_to_world(pk);
-			q->self()->map_to_world[pk] = pk_world_coords;
-			q->self()->world_to_map[pk_world_coords] = pk;
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		// Update the coords cache.
+		for (SelfList<TileMapQuadrant> *q = layers[layer].dirty_quadrant_list.first(); q; q = q->next()) {
+			q->self()->map_to_world.clear();
+			q->self()->world_to_map.clear();
+			for (Set<Vector2i>::Element *E = q->self()->cells.front(); E; E = E->next()) {
+				Vector2i pk = E->get();
+				Vector2i pk_world_coords = map_to_world(pk);
+				q->self()->map_to_world[pk] = pk_world_coords;
+				q->self()->world_to_map[pk_world_coords] = pk;
+			}
+		}
+
+		// Call the update_dirty_quadrant method on plugins.
+		_rendering_update_dirty_quadrants(layers[layer].dirty_quadrant_list);
+		_physics_update_dirty_quadrants(layers[layer].dirty_quadrant_list);
+		_navigation_update_dirty_quadrants(layers[layer].dirty_quadrant_list);
+		_scenes_update_dirty_quadrants(layers[layer].dirty_quadrant_list);
+
+		// Redraw the debug canvas_items.
+		RenderingServer *rs = RenderingServer::get_singleton();
+		for (SelfList<TileMapQuadrant> *q = layers[layer].dirty_quadrant_list.first(); q; q = q->next()) {
+			rs->canvas_item_clear(q->self()->debug_canvas_item);
+			Transform2D xform;
+			xform.set_origin(map_to_world(q->self()->coords * get_effective_quadrant_size(layer)));
+			rs->canvas_item_set_transform(q->self()->debug_canvas_item, xform);
+
+			_rendering_draw_quadrant_debug(q->self());
+			_physics_draw_quadrant_debug(q->self());
+			_navigation_draw_quadrant_debug(q->self());
+			_scenes_draw_quadrant_debug(q->self());
 		}
-	}
 
-	// Call the update_dirty_quadrant method on plugins.
-	for (int i = 0; i < tile_set->get_tile_set_atlas_plugins().size(); i++) {
-		tile_set->get_tile_set_atlas_plugins()[i]->update_dirty_quadrants(this, dirty_quadrant_list);
+		// Clear the list
+		while (layers[layer].dirty_quadrant_list.first()) {
+			layers[layer].dirty_quadrant_list.remove(layers[layer].dirty_quadrant_list.first());
+		}
 	}
 
-	// Redraw the debug canvas_items.
-	RenderingServer *rs = RenderingServer::get_singleton();
-	for (SelfList<TileMapQuadrant> *q = dirty_quadrant_list.first(); q; q = q->next()) {
-		rs->canvas_item_clear(q->self()->debug_canvas_item);
-		Transform2D xform;
-		xform.set_origin(map_to_world(q->self()->coords * get_effective_quadrant_size()));
-		rs->canvas_item_set_transform(q->self()->debug_canvas_item, xform);
-		for (int i = 0; i < tile_set->get_tile_set_atlas_plugins().size(); i++) {
-			tile_set->get_tile_set_atlas_plugins()[i]->draw_quadrant_debug(this, q->self());
+	pending_update = false;
+
+	_recompute_rect_cache();
+}
+
+void TileMap::_recreate_internals() {
+	// Clear all internals.
+	_clear_internals();
+
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		if (!layers[layer].enabled) {
+			continue;
+		}
+
+		// Upadate the layer internals.
+		_rendering_update_layer(layer);
+
+		// Recreate the quadrants.
+		const Map<Vector2i, TileMapCell> &tile_map = layers[layer].tile_map;
+		for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
+			Vector2i qk = _coords_to_quadrant_coords(layer, Vector2i(E->key().x, E->key().y));
+
+			Map<Vector2i, TileMapQuadrant>::Element *Q = layers[layer].quadrant_map.find(qk);
+			if (!Q) {
+				Q = _create_quadrant(layer, qk);
+				layers[layer].dirty_quadrant_list.add(&Q->get().dirty_list_element);
+			}
+
+			Vector2i pk = E->key();
+			Q->get().cells.insert(pk);
+
+			_make_quadrant_dirty(Q);
 		}
 	}
 
-	// Clear the list
-	while (dirty_quadrant_list.first()) {
-		dirty_quadrant_list.remove(dirty_quadrant_list.first());
+	_update_dirty_quadrants();
+}
+
+void TileMap::_erase_quadrant(Map<Vector2i, TileMapQuadrant>::Element *Q) {
+	// Remove a quadrant.
+	TileMapQuadrant *q = &(Q->get());
+
+	// Call the cleanup_quadrant method on plugins.
+	if (tile_set.is_valid()) {
+		_rendering_cleanup_quadrant(q);
+		_physics_cleanup_quadrant(q);
+		_navigation_cleanup_quadrant(q);
+		_scenes_cleanup_quadrant(q);
 	}
 
-	pending_update = false;
+	// Remove the quadrant from the dirty_list if it is there.
+	if (q->dirty_list_element.in_list()) {
+		layers[q->layer].dirty_quadrant_list.remove(&(q->dirty_list_element));
+	}
 
-	_recompute_rect_cache();
+	// Free the debug canvas item.
+	RenderingServer *rs = RenderingServer::get_singleton();
+	rs->free(q->debug_canvas_item);
+
+	layers[q->layer].quadrant_map.erase(Q);
+	rect_cache_dirty = true;
+}
+
+void TileMap::_clear_layer_internals(int p_layer) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+
+	// Clear quadrants.
+	while (layers[p_layer].quadrant_map.size()) {
+		_erase_quadrant(layers[p_layer].quadrant_map.front());
+	}
+
+	// Clear the layers internals.
+	_rendering_cleanup_layer(p_layer);
+
+	// Clear the dirty quadrants list.
+	while (layers[p_layer].dirty_quadrant_list.first()) {
+		layers[p_layer].dirty_quadrant_list.remove(layers[p_layer].dirty_quadrant_list.first());
+	}
+}
+
+void TileMap::_clear_internals() {
+	// Clear quadrants.
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		_clear_layer_internals(layer);
+	}
 }
 
 void TileMap::_recompute_rect_cache() {
@@ -397,16 +634,18 @@ void TileMap::_recompute_rect_cache() {
 	}
 
 	Rect2 r_total;
-	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		Rect2 r;
-		r.position = map_to_world(E->key() * get_effective_quadrant_size());
-		r.expand_to(map_to_world((E->key() + Vector2i(1, 0)) * get_effective_quadrant_size()));
-		r.expand_to(map_to_world((E->key() + Vector2i(1, 1)) * get_effective_quadrant_size()));
-		r.expand_to(map_to_world((E->key() + Vector2i(0, 1)) * get_effective_quadrant_size()));
-		if (E == quadrant_map.front()) {
-			r_total = r;
-		} else {
-			r_total = r_total.merge(r);
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		for (Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+			Rect2 r;
+			r.position = map_to_world(E->key() * get_effective_quadrant_size(layer));
+			r.expand_to(map_to_world((E->key() + Vector2i(1, 0)) * get_effective_quadrant_size(layer)));
+			r.expand_to(map_to_world((E->key() + Vector2i(1, 1)) * get_effective_quadrant_size(layer)));
+			r.expand_to(map_to_world((E->key() + Vector2i(0, 1)) * get_effective_quadrant_size(layer)));
+			if (E == layers[layer].quadrant_map.front()) {
+				r_total = r;
+			} else {
+				r_total = r_total.merge(r);
+			}
 		}
 	}
 
@@ -418,94 +657,884 @@ void TileMap::_recompute_rect_cache() {
 #endif
 }
 
-Map<Vector2i, TileMapQuadrant>::Element *TileMap::_create_quadrant(const Vector2i &p_qk) {
-	TileMapQuadrant q;
-	q.coords = p_qk;
+/////////////////////////////// Rendering //////////////////////////////////////
 
-	rect_cache_dirty = true;
+void TileMap::_rendering_notification(int p_what) {
+	switch (p_what) {
+		case CanvasItem::NOTIFICATION_VISIBILITY_CHANGED: {
+			bool visible = is_visible_in_tree();
+			for (int layer = 0; layer < (int)layers.size(); layer++) {
+				for (Map<Vector2i, TileMapQuadrant>::Element *E_quadrant = layers[layer].quadrant_map.front(); E_quadrant; E_quadrant = E_quadrant->next()) {
+					TileMapQuadrant &q = E_quadrant->get();
+
+					// Update occluders transform.
+					for (Map<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator>::Element *E_cell = q.world_to_map.front(); E_cell; E_cell = E_cell->next()) {
+						Transform2D xform;
+						xform.set_origin(E_cell->key());
+						for (const RID &occluder : q.occluders) {
+							RS::get_singleton()->canvas_light_occluder_set_enabled(occluder, visible);
+						}
+					}
+				}
+			}
+		} break;
+		case CanvasItem::NOTIFICATION_TRANSFORM_CHANGED: {
+			if (!is_inside_tree()) {
+				return;
+			}
+			for (int layer = 0; layer < (int)layers.size(); layer++) {
+				for (Map<Vector2i, TileMapQuadrant>::Element *E_quadrant = layers[layer].quadrant_map.front(); E_quadrant; E_quadrant = E_quadrant->next()) {
+					TileMapQuadrant &q = E_quadrant->get();
+
+					// Update occluders transform.
+					for (Map<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator>::Element *E_cell = q.world_to_map.front(); E_cell; E_cell = E_cell->next()) {
+						Transform2D xform;
+						xform.set_origin(E_cell->key());
+						for (const RID &occluder : q.occluders) {
+							RS::get_singleton()->canvas_light_occluder_set_transform(occluder, get_global_transform() * xform);
+						}
+					}
+				}
+			}
+		} break;
+		case CanvasItem::NOTIFICATION_DRAW: {
+			if (tile_set.is_valid()) {
+				RenderingServer::get_singleton()->canvas_item_set_sort_children_by_y(get_canvas_item(), is_y_sort_enabled());
+			}
+		} break;
+	}
+}
+
+void TileMap::_rendering_update_layer(int p_layer) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
 
-	// Create the debug canvas item.
 	RenderingServer *rs = RenderingServer::get_singleton();
-	q.debug_canvas_item = rs->canvas_item_create();
-	rs->canvas_item_set_z_index(q.debug_canvas_item, RS::CANVAS_ITEM_Z_MAX - 1);
-	rs->canvas_item_set_parent(q.debug_canvas_item, get_canvas_item());
+	if (!layers[p_layer].canvas_item.is_valid()) {
+		RID ci = rs->canvas_item_create();
+		rs->canvas_item_set_parent(ci, get_canvas_item());
 
-	// Call the create_quadrant method on plugins
-	if (tile_set.is_valid()) {
-		for (int i = 0; i < tile_set->get_tile_set_atlas_plugins().size(); i++) {
-			tile_set->get_tile_set_atlas_plugins()[i]->create_quadrant(this, &q);
-		}
+		/*Transform2D xform;
+		xform.set_origin(Vector2(0, p_layer));
+		rs->canvas_item_set_transform(ci, xform);*/
+		rs->canvas_item_set_draw_index(ci, p_layer);
+
+		layers[p_layer].canvas_item = ci;
 	}
+	RID &ci = layers[p_layer].canvas_item;
+	rs->canvas_item_set_sort_children_by_y(ci, layers[p_layer].y_sort_enabled);
+	rs->canvas_item_set_use_parent_material(ci, get_use_parent_material() || get_material().is_valid());
+	rs->canvas_item_set_z_index(ci, layers[p_layer].z_index);
+	rs->canvas_item_set_default_texture_filter(ci, RS::CanvasItemTextureFilter(get_texture_filter()));
+	rs->canvas_item_set_default_texture_repeat(ci, RS::CanvasItemTextureRepeat(get_texture_repeat()));
+	rs->canvas_item_set_light_mask(ci, get_light_mask());
+}
 
-	return quadrant_map.insert(p_qk, q);
+void TileMap::_rendering_cleanup_layer(int p_layer) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+
+	RenderingServer *rs = RenderingServer::get_singleton();
+	if (!layers[p_layer].canvas_item.is_valid()) {
+		rs->free(layers[p_layer].canvas_item);
+	}
 }
 
-void TileMap::_erase_quadrant(Map<Vector2i, TileMapQuadrant>::Element *Q) {
-	// Remove a quadrant.
-	TileMapQuadrant *q = &(Q->get());
+void TileMap::_rendering_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {
+	ERR_FAIL_COND(!is_inside_tree());
+	ERR_FAIL_COND(!tile_set.is_valid());
 
-	// Call the cleanup_quadrant method on plugins.
-	if (tile_set.is_valid()) {
-		for (int i = 0; i < tile_set->get_tile_set_atlas_plugins().size(); i++) {
-			tile_set->get_tile_set_atlas_plugins()[i]->cleanup_quadrant(this, q);
+	bool visible = is_visible_in_tree();
+
+	SelfList<TileMapQuadrant> *q_list_element = r_dirty_quadrant_list.first();
+	while (q_list_element) {
+		TileMapQuadrant &q = *q_list_element->self();
+
+		RenderingServer *rs = RenderingServer::get_singleton();
+
+		// Free the canvas items.
+		for (const RID &ci : q.canvas_items) {
+			rs->free(ci);
+		}
+		q.canvas_items.clear();
+
+		// Free the occluders.
+		for (const RID &occluder : q.occluders) {
+			rs->free(occluder);
 		}
+		q.occluders.clear();
+
+		// Those allow to group cell per material or z-index.
+		Ref<ShaderMaterial> prev_material;
+		int prev_z_index = 0;
+		RID prev_canvas_item;
+
+		// Iterate over the cells of the quadrant.
+		for (Map<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator>::Element *E_cell = q.world_to_map.front(); E_cell; E_cell = E_cell->next()) {
+			TileMapCell c = get_cell(q.layer, E_cell->value(), true);
+
+			TileSetSource *source;
+			if (tile_set->has_source(c.source_id)) {
+				source = *tile_set->get_source(c.source_id);
+
+				if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+					continue;
+				}
+
+				TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+				if (atlas_source) {
+					// Get the tile data.
+					TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(c.get_atlas_coords(), c.alternative_tile));
+					Ref<ShaderMaterial> mat = tile_data->tile_get_material();
+					int z_index = layers[q.layer].z_index + tile_data->get_z_index();
+
+					// Quandrant pos.
+					Vector2 position = map_to_world(q.coords * get_effective_quadrant_size(q.layer));
+					if (is_y_sort_enabled() && layers[q.layer].y_sort_enabled) {
+						// When Y-sorting, the quandrant size is sure to be 1, we can thus offset the CanvasItem.
+						position.y += layers[q.layer].y_sort_origin + tile_data->get_y_sort_origin();
+					}
+
+					// --- CanvasItems ---
+					// Create two canvas items, for rendering and debug.
+					RID canvas_item;
+
+					// Check if the material or the z_index changed.
+					if (prev_canvas_item == RID() || prev_material != mat || prev_z_index != z_index) {
+						// If so, create a new CanvasItem.
+						canvas_item = rs->canvas_item_create();
+						if (mat.is_valid()) {
+							rs->canvas_item_set_material(canvas_item, mat->get_rid());
+						}
+						rs->canvas_item_set_parent(canvas_item, layers[q.layer].canvas_item);
+						rs->canvas_item_set_use_parent_material(canvas_item, get_use_parent_material() || get_material().is_valid());
+
+						Transform2D xform;
+						xform.set_origin(position);
+						rs->canvas_item_set_transform(canvas_item, xform);
+
+						rs->canvas_item_set_light_mask(canvas_item, get_light_mask());
+						rs->canvas_item_set_z_index(canvas_item, z_index);
+
+						rs->canvas_item_set_default_texture_filter(canvas_item, RS::CanvasItemTextureFilter(get_texture_filter()));
+						rs->canvas_item_set_default_texture_repeat(canvas_item, RS::CanvasItemTextureRepeat(get_texture_repeat()));
+
+						q.canvas_items.push_back(canvas_item);
+
+						prev_canvas_item = canvas_item;
+						prev_material = mat;
+						prev_z_index = z_index;
+
+					} else {
+						// Keep the same canvas_item to draw on.
+						canvas_item = prev_canvas_item;
+					}
+
+					// Drawing the tile in the canvas item.
+					Color modulate = get_self_modulate();
+					if (selected_layer >= 0) {
+						if (q.layer < selected_layer) {
+							modulate = modulate.darkened(0.5);
+						} else if (q.layer > selected_layer) {
+							modulate = modulate.darkened(0.5);
+							modulate.a *= 0.3;
+						}
+					}
+					draw_tile(canvas_item, E_cell->key() - position, tile_set, c.source_id, c.get_atlas_coords(), c.alternative_tile, modulate);
+
+					// --- Occluders ---
+					for (int i = 0; i < tile_set->get_occlusion_layers_count(); i++) {
+						Transform2D xform;
+						xform.set_origin(E_cell->key());
+						if (tile_data->get_occluder(i).is_valid()) {
+							RID occluder_id = rs->canvas_light_occluder_create();
+							rs->canvas_light_occluder_set_enabled(occluder_id, visible);
+							rs->canvas_light_occluder_set_transform(occluder_id, get_global_transform() * xform);
+							rs->canvas_light_occluder_set_polygon(occluder_id, tile_data->get_occluder(i)->get_rid());
+							rs->canvas_light_occluder_attach_to_canvas(occluder_id, get_canvas());
+							rs->canvas_light_occluder_set_light_mask(occluder_id, tile_set->get_occlusion_layer_light_mask(i));
+							q.occluders.push_back(occluder_id);
+						}
+					}
+				}
+			}
+		}
+
+		_rendering_quadrant_order_dirty = true;
+		q_list_element = q_list_element->next();
 	}
 
-	// Remove the quadrant from the dirty_list if it is there.
-	if (q->dirty_list_element.in_list()) {
-		dirty_quadrant_list.remove(&(q->dirty_list_element));
+	// Reset the drawing indices
+	if (_rendering_quadrant_order_dirty) {
+		int index = -(int64_t)0x80000000; //always must be drawn below children.
+
+		for (int layer = 0; layer < (int)layers.size(); layer++) {
+			// Sort the quadrants coords per world coordinates
+			Map<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator> world_to_map;
+			for (Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+				world_to_map[map_to_world(E->key())] = E->key();
+			}
+
+			// Sort the quadrants
+			for (Map<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator>::Element *E = world_to_map.front(); E; E = E->next()) {
+				TileMapQuadrant &q = layers[layer].quadrant_map[E->value()];
+				for (const RID &ci : q.canvas_items) {
+					RS::get_singleton()->canvas_item_set_draw_index(ci, index++);
+				}
+			}
+		}
+		_rendering_quadrant_order_dirty = false;
 	}
+}
 
-	// Free the debug canvas item.
+void TileMap::_rendering_create_quadrant(TileMapQuadrant *p_quadrant) {
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	_rendering_quadrant_order_dirty = true;
+}
+
+void TileMap::_rendering_cleanup_quadrant(TileMapQuadrant *p_quadrant) {
+	// Free the canvas items.
+	for (const RID &ci : p_quadrant->canvas_items) {
+		RenderingServer::get_singleton()->free(ci);
+	}
+	p_quadrant->canvas_items.clear();
+
+	// Free the occluders.
+	for (const RID &occluder : p_quadrant->occluders) {
+		RenderingServer::get_singleton()->free(occluder);
+	}
+	p_quadrant->occluders.clear();
+}
+
+void TileMap::_rendering_draw_quadrant_debug(TileMapQuadrant *p_quadrant) {
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	if (!Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+
+	// Draw a placeholder for scenes needing one.
 	RenderingServer *rs = RenderingServer::get_singleton();
-	rs->free(q->debug_canvas_item);
+	Vector2 quadrant_pos = map_to_world(p_quadrant->coords * get_effective_quadrant_size(p_quadrant->layer));
+	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+		const TileMapCell &c = get_cell(p_quadrant->layer, E_cell->get(), true);
 
-	quadrant_map.erase(Q);
-	rect_cache_dirty = true;
+		TileSetSource *source;
+		if (tile_set->has_source(c.source_id)) {
+			source = *tile_set->get_source(c.source_id);
+
+			if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+				continue;
+			}
+
+			TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+			if (atlas_source) {
+				Vector2i grid_size = atlas_source->get_atlas_grid_size();
+				if (!atlas_source->get_texture().is_valid() || c.get_atlas_coords().x >= grid_size.x || c.get_atlas_coords().y >= grid_size.y) {
+					// Generate a random color from the hashed values of the tiles.
+					Array to_hash;
+					to_hash.push_back(c.source_id);
+					to_hash.push_back(c.get_atlas_coords());
+					to_hash.push_back(c.alternative_tile);
+					uint32_t hash = RandomPCG(to_hash.hash()).rand();
+
+					Color color;
+					color = color.from_hsv(
+							(float)((hash >> 24) & 0xFF) / 256.0,
+							Math::lerp(0.5, 1.0, (float)((hash >> 16) & 0xFF) / 256.0),
+							Math::lerp(0.5, 1.0, (float)((hash >> 8) & 0xFF) / 256.0),
+							0.8);
+
+					// Draw a placeholder tile.
+					Transform2D xform;
+					xform.set_origin(map_to_world(E_cell->get()) - quadrant_pos);
+					rs->canvas_item_add_set_transform(p_quadrant->debug_canvas_item, xform);
+					rs->canvas_item_add_circle(p_quadrant->debug_canvas_item, Vector2(), MIN(tile_set->get_tile_size().x, tile_set->get_tile_size().y) / 4.0, color);
+				}
+			}
+		}
+	}
 }
 
-void TileMap::_make_all_quadrants_dirty(bool p_update) {
-	// Make all quandrants dirty, then trigger an update later.
-	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		if (!E->value().dirty_list_element.in_list()) {
-			dirty_quadrant_list.add(&E->value().dirty_list_element);
+void TileMap::draw_tile(RID p_canvas_item, Vector2i p_position, const Ref<TileSet> p_tile_set, int p_atlas_source_id, Vector2i p_atlas_coords, int p_alternative_tile, Color p_modulation) {
+	ERR_FAIL_COND(!p_tile_set.is_valid());
+	ERR_FAIL_COND(!p_tile_set->has_source(p_atlas_source_id));
+	ERR_FAIL_COND(!p_tile_set->get_source(p_atlas_source_id)->has_tile(p_atlas_coords));
+	ERR_FAIL_COND(!p_tile_set->get_source(p_atlas_source_id)->has_alternative_tile(p_atlas_coords, p_alternative_tile));
+
+	TileSetSource *source = *p_tile_set->get_source(p_atlas_source_id);
+	TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+	if (atlas_source) {
+		// Get the texture.
+		Ref<Texture2D> tex = atlas_source->get_texture();
+		if (!tex.is_valid()) {
+			return;
+		}
+
+		// Check if we are in the texture, return otherwise.
+		Vector2i grid_size = atlas_source->get_atlas_grid_size();
+		if (p_atlas_coords.x >= grid_size.x || p_atlas_coords.y >= grid_size.y) {
+			return;
+		}
+
+		// Get tile data.
+		TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(p_atlas_coords, p_alternative_tile));
+
+		// Compute the offset
+		Rect2i source_rect = atlas_source->get_tile_texture_region(p_atlas_coords);
+		Vector2i tile_offset = atlas_source->get_tile_effective_texture_offset(p_atlas_coords, p_alternative_tile);
+
+		// Compute the destination rectangle in the CanvasItem.
+		Rect2 dest_rect;
+		dest_rect.size = source_rect.size;
+		dest_rect.size.x += FP_ADJUST;
+		dest_rect.size.y += FP_ADJUST;
+
+		bool transpose = tile_data->get_transpose();
+		if (transpose) {
+			dest_rect.position = (p_position - Vector2(dest_rect.size.y, dest_rect.size.x) / 2 - tile_offset);
+		} else {
+			dest_rect.position = (p_position - dest_rect.size / 2 - tile_offset);
+		}
+
+		if (tile_data->get_flip_h()) {
+			dest_rect.size.x = -dest_rect.size.x;
+		}
+
+		if (tile_data->get_flip_v()) {
+			dest_rect.size.y = -dest_rect.size.y;
 		}
+
+		// Get the tile modulation.
+		Color modulate = tile_data->get_modulate();
+		modulate = Color(modulate.r * p_modulation.r, modulate.g * p_modulation.g, modulate.b * p_modulation.b, modulate.a * p_modulation.a);
+
+		// Draw the tile.
+		tex->draw_rect_region(p_canvas_item, dest_rect, source_rect, modulate, transpose, p_tile_set->is_uv_clipping());
 	}
+}
 
-	if (pending_update) {
+/////////////////////////////// Physics //////////////////////////////////////
+
+void TileMap::_physics_notification(int p_what) {
+	switch (p_what) {
+		case CanvasItem::NOTIFICATION_TRANSFORM_CHANGED: {
+			// Update the bodies transforms.
+			if (is_inside_tree()) {
+				for (int layer = 0; layer < (int)layers.size(); layer++) {
+					Transform2D global_transform = get_global_transform();
+
+					for (Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+						TileMapQuadrant &q = E->get();
+
+						Transform2D xform;
+						xform.set_origin(map_to_world(E->key() * get_effective_quadrant_size(layer)));
+						xform = global_transform * xform;
+
+						for (int body_index = 0; body_index < q.bodies.size(); body_index++) {
+							PhysicsServer2D::get_singleton()->body_set_state(q.bodies[body_index], PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
+						}
+					}
+				}
+			}
+		} break;
+	}
+}
+
+void TileMap::_physics_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {
+	ERR_FAIL_COND(!is_inside_tree());
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	Transform2D global_transform = get_global_transform();
+	PhysicsServer2D *ps = PhysicsServer2D::get_singleton();
+
+	SelfList<TileMapQuadrant> *q_list_element = r_dirty_quadrant_list.first();
+	while (q_list_element) {
+		TileMapQuadrant &q = *q_list_element->self();
+
+		Vector2 quadrant_pos = map_to_world(q.coords * get_effective_quadrant_size(q.layer));
+
+		// Clear shapes.
+		for (int body_index = 0; body_index < q.bodies.size(); body_index++) {
+			ps->body_clear_shapes(q.bodies[body_index]);
+
+			// Position the bodies.
+			Transform2D xform;
+			xform.set_origin(quadrant_pos);
+			xform = global_transform * xform;
+			ps->body_set_state(q.bodies[body_index], PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
+		}
+
+		for (Set<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
+			TileMapCell c = get_cell(q.layer, E_cell->get(), true);
+
+			TileSetSource *source;
+			if (tile_set->has_source(c.source_id)) {
+				source = *tile_set->get_source(c.source_id);
+
+				if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+					continue;
+				}
+
+				TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+				if (atlas_source) {
+					TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(c.get_atlas_coords(), c.alternative_tile));
+
+					for (int body_index = 0; body_index < q.bodies.size(); body_index++) {
+						// Add the shapes again.
+						for (int polygon_index = 0; polygon_index < tile_data->get_collision_polygons_count(body_index); polygon_index++) {
+							bool one_way_collision = tile_data->is_collision_polygon_one_way(body_index, polygon_index);
+							float one_way_collision_margin = tile_data->get_collision_polygon_one_way_margin(body_index, polygon_index);
+
+							int shapes_count = tile_data->get_collision_polygon_shapes_count(body_index, polygon_index);
+							for (int shape_index = 0; shape_index < shapes_count; shape_index++) {
+								Transform2D xform = Transform2D();
+								xform.set_origin(map_to_world(E_cell->get()) - quadrant_pos);
+
+								// Add decomposed convex shapes.
+								Ref<ConvexPolygonShape2D> shape = tile_data->get_collision_polygon_shape(body_index, polygon_index, shape_index);
+								ps->body_add_shape(q.bodies[body_index], shape->get_rid(), xform);
+								ps->body_set_shape_metadata(q.bodies[body_index], shape_index, E_cell->get());
+								ps->body_set_shape_as_one_way_collision(q.bodies[body_index], shape_index, one_way_collision, one_way_collision_margin);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		q_list_element = q_list_element->next();
+	}
+}
+
+void TileMap::_physics_create_quadrant(TileMapQuadrant *p_quadrant) {
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	//Get the TileMap's gobla transform.
+	Transform2D global_transform;
+	if (is_inside_tree()) {
+		global_transform = get_global_transform();
+	}
+
+	// Clear all bodies.
+	p_quadrant->bodies.clear();
+
+	// Create the body and set its parameters.
+	for (int layer = 0; layer < tile_set->get_physics_layers_count(); layer++) {
+		RID body = PhysicsServer2D::get_singleton()->body_create();
+		PhysicsServer2D::get_singleton()->body_set_mode(body, PhysicsServer2D::BODY_MODE_STATIC);
+
+		PhysicsServer2D::get_singleton()->body_attach_object_instance_id(body, get_instance_id());
+		PhysicsServer2D::get_singleton()->body_set_collision_layer(body, tile_set->get_physics_layer_collision_layer(layer));
+		PhysicsServer2D::get_singleton()->body_set_collision_mask(body, tile_set->get_physics_layer_collision_mask(layer));
+
+		Ref<PhysicsMaterial> physics_material = tile_set->get_physics_layer_physics_material(layer);
+		if (!physics_material.is_valid()) {
+			PhysicsServer2D::get_singleton()->body_set_param(body, PhysicsServer2D::BODY_PARAM_BOUNCE, 0);
+			PhysicsServer2D::get_singleton()->body_set_param(body, PhysicsServer2D::BODY_PARAM_FRICTION, 1);
+		} else {
+			PhysicsServer2D::get_singleton()->body_set_param(body, PhysicsServer2D::BODY_PARAM_BOUNCE, physics_material->computed_bounce());
+			PhysicsServer2D::get_singleton()->body_set_param(body, PhysicsServer2D::BODY_PARAM_FRICTION, physics_material->computed_friction());
+		}
+
+		if (is_inside_tree()) {
+			RID space = get_world_2d()->get_space();
+			PhysicsServer2D::get_singleton()->body_set_space(body, space);
+
+			Transform2D xform;
+			xform.set_origin(map_to_world(p_quadrant->coords * get_effective_quadrant_size(layer)));
+			xform = global_transform * xform;
+			PhysicsServer2D::get_singleton()->body_set_state(body, PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
+		}
+
+		p_quadrant->bodies.push_back(body);
+	}
+}
+
+void TileMap::_physics_cleanup_quadrant(TileMapQuadrant *p_quadrant) {
+	// Remove a quadrant.
+	for (int body_index = 0; body_index < p_quadrant->bodies.size(); body_index++) {
+		PhysicsServer2D::get_singleton()->free(p_quadrant->bodies[body_index]);
+	}
+	p_quadrant->bodies.clear();
+}
+
+void TileMap::_physics_draw_quadrant_debug(TileMapQuadrant *p_quadrant) {
+	// Draw the debug collision shapes.
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	if (!get_tree()) {
 		return;
 	}
-	pending_update = true;
-	if (!is_inside_tree()) {
+
+	bool show_collision = false;
+	switch (collision_visibility_mode) {
+		case TileMap::VISIBILITY_MODE_DEFAULT:
+			show_collision = !Engine::get_singleton()->is_editor_hint() && (get_tree() && get_tree()->is_debugging_navigation_hint());
+			break;
+		case TileMap::VISIBILITY_MODE_FORCE_HIDE:
+			show_collision = false;
+			break;
+		case TileMap::VISIBILITY_MODE_FORCE_SHOW:
+			show_collision = true;
+			break;
+	}
+	if (!show_collision) {
 		return;
 	}
-	if (p_update) {
-		call_deferred(SNAME("update_dirty_quadrants"));
+
+	RenderingServer *rs = RenderingServer::get_singleton();
+
+	Vector2 quadrant_pos = map_to_world(p_quadrant->coords * get_effective_quadrant_size(p_quadrant->layer));
+
+	Color debug_collision_color = get_tree()->get_debug_collisions_color();
+	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+		TileMapCell c = get_cell(p_quadrant->layer, E_cell->get(), true);
+
+		Transform2D xform;
+		xform.set_origin(map_to_world(E_cell->get()) - quadrant_pos);
+		rs->canvas_item_add_set_transform(p_quadrant->debug_canvas_item, xform);
+
+		if (tile_set->has_source(c.source_id)) {
+			TileSetSource *source = *tile_set->get_source(c.source_id);
+
+			if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+				continue;
+			}
+
+			TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+			if (atlas_source) {
+				TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(c.get_atlas_coords(), c.alternative_tile));
+
+				for (int body_index = 0; body_index < p_quadrant->bodies.size(); body_index++) {
+					for (int polygon_index = 0; polygon_index < tile_data->get_collision_polygons_count(body_index); polygon_index++) {
+						// Draw the debug polygon.
+						Vector<Vector2> polygon = tile_data->get_collision_polygon_points(body_index, polygon_index);
+						if (polygon.size() >= 3) {
+							Vector<Color> color;
+							color.push_back(debug_collision_color);
+							rs->canvas_item_add_polygon(p_quadrant->debug_canvas_item, polygon, color);
+						}
+					}
+				}
+			}
+		}
+		rs->canvas_item_add_set_transform(p_quadrant->debug_canvas_item, Transform2D());
+	}
+};
+
+/////////////////////////////// Navigation //////////////////////////////////////
+
+void TileMap::_navigation_notification(int p_what) {
+	switch (p_what) {
+		case CanvasItem::NOTIFICATION_TRANSFORM_CHANGED: {
+			if (is_inside_tree()) {
+				for (int layer = 0; layer < (int)layers.size(); layer++) {
+					Transform2D tilemap_xform = get_global_transform();
+					for (Map<Vector2i, TileMapQuadrant>::Element *E_quadrant = layers[layer].quadrant_map.front(); E_quadrant; E_quadrant = E_quadrant->next()) {
+						TileMapQuadrant &q = E_quadrant->get();
+						for (Map<Vector2i, Vector<RID>>::Element *E_region = q.navigation_regions.front(); E_region; E_region = E_region->next()) {
+							for (int layer_index = 0; layer_index < E_region->get().size(); layer_index++) {
+								RID region = E_region->get()[layer_index];
+								if (!region.is_valid()) {
+									continue;
+								}
+								Transform2D tile_transform;
+								tile_transform.set_origin(map_to_world(E_region->key()));
+								NavigationServer2D::get_singleton()->region_set_transform(region, tilemap_xform * tile_transform);
+							}
+						}
+					}
+				}
+			}
+		} break;
 	}
 }
 
-void TileMap::_make_quadrant_dirty(Map<Vector2i, TileMapQuadrant>::Element *Q, bool p_update) {
-	// Make the given quadrant dirty, then trigger an update later.
-	TileMapQuadrant &q = Q->get();
-	if (!q.dirty_list_element.in_list()) {
-		dirty_quadrant_list.add(&q.dirty_list_element);
+void TileMap::_navigation_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {
+	ERR_FAIL_COND(!is_inside_tree());
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	// Get colors for debug.
+	SceneTree *st = SceneTree::get_singleton();
+	Color debug_navigation_color;
+	bool debug_navigation = st && st->is_debugging_navigation_hint();
+	if (debug_navigation) {
+		debug_navigation_color = st->get_debug_navigation_color();
+	}
+
+	Transform2D tilemap_xform = get_global_transform();
+	SelfList<TileMapQuadrant> *q_list_element = r_dirty_quadrant_list.first();
+	while (q_list_element) {
+		TileMapQuadrant &q = *q_list_element->self();
+
+		// Clear navigation shapes in the quadrant.
+		for (Map<Vector2i, Vector<RID>>::Element *E = q.navigation_regions.front(); E; E = E->next()) {
+			for (int i = 0; i < E->get().size(); i++) {
+				RID region = E->get()[i];
+				if (!region.is_valid()) {
+					continue;
+				}
+				NavigationServer2D::get_singleton()->region_set_map(region, RID());
+			}
+		}
+		q.navigation_regions.clear();
+
+		// Get the navigation polygons and create regions.
+		for (Set<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
+			TileMapCell c = get_cell(q.layer, E_cell->get(), true);
+
+			TileSetSource *source;
+			if (tile_set->has_source(c.source_id)) {
+				source = *tile_set->get_source(c.source_id);
+
+				if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+					continue;
+				}
+
+				TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+				if (atlas_source) {
+					TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(c.get_atlas_coords(), c.alternative_tile));
+					q.navigation_regions[E_cell->get()].resize(tile_set->get_navigation_layers_count());
+
+					for (int layer_index = 0; layer_index < tile_set->get_navigation_layers_count(); layer_index++) {
+						Ref<NavigationPolygon> navpoly;
+						navpoly = tile_data->get_navigation_polygon(layer_index);
+
+						if (navpoly.is_valid()) {
+							Transform2D tile_transform;
+							tile_transform.set_origin(map_to_world(E_cell->get()));
+
+							RID region = NavigationServer2D::get_singleton()->region_create();
+							NavigationServer2D::get_singleton()->region_set_map(region, get_world_2d()->get_navigation_map());
+							NavigationServer2D::get_singleton()->region_set_transform(region, tilemap_xform * tile_transform);
+							NavigationServer2D::get_singleton()->region_set_navpoly(region, navpoly);
+							q.navigation_regions[E_cell->get()].write[layer_index] = region;
+						}
+					}
+				}
+			}
+		}
+
+		q_list_element = q_list_element->next();
 	}
+}
 
-	if (pending_update) {
+void TileMap::_navigation_cleanup_quadrant(TileMapQuadrant *p_quadrant) {
+	// Clear navigation shapes in the quadrant.
+	for (Map<Vector2i, Vector<RID>>::Element *E = p_quadrant->navigation_regions.front(); E; E = E->next()) {
+		for (int i = 0; i < E->get().size(); i++) {
+			RID region = E->get()[i];
+			if (!region.is_valid()) {
+				continue;
+			}
+			NavigationServer2D::get_singleton()->free(region);
+		}
+	}
+	p_quadrant->navigation_regions.clear();
+}
+
+void TileMap::_navigation_draw_quadrant_debug(TileMapQuadrant *p_quadrant) {
+	// Draw the debug collision shapes.
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	if (!get_tree()) {
 		return;
 	}
-	pending_update = true;
-	if (!is_inside_tree()) {
+
+	bool show_navigation = false;
+	switch (navigation_visibility_mode) {
+		case TileMap::VISIBILITY_MODE_DEFAULT:
+			show_navigation = !Engine::get_singleton()->is_editor_hint() && (get_tree() && get_tree()->is_debugging_navigation_hint());
+			break;
+		case TileMap::VISIBILITY_MODE_FORCE_HIDE:
+			show_navigation = false;
+			break;
+		case TileMap::VISIBILITY_MODE_FORCE_SHOW:
+			show_navigation = true;
+			break;
+	}
+	if (!show_navigation) {
+		return;
+	}
+
+	RenderingServer *rs = RenderingServer::get_singleton();
+
+	Color color = get_tree()->get_debug_navigation_color();
+	RandomPCG rand;
+
+	Vector2 quadrant_pos = map_to_world(p_quadrant->coords * get_effective_quadrant_size(p_quadrant->layer));
+
+	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+		TileMapCell c = get_cell(p_quadrant->layer, E_cell->get(), true);
+
+		TileSetSource *source;
+		if (tile_set->has_source(c.source_id)) {
+			source = *tile_set->get_source(c.source_id);
+
+			if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+				continue;
+			}
+
+			TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+			if (atlas_source) {
+				TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(c.get_atlas_coords(), c.alternative_tile));
+
+				Transform2D xform;
+				xform.set_origin(map_to_world(E_cell->get()) - quadrant_pos);
+				rs->canvas_item_add_set_transform(p_quadrant->debug_canvas_item, xform);
+
+				for (int layer_index = 0; layer_index < tile_set->get_navigation_layers_count(); layer_index++) {
+					Ref<NavigationPolygon> navpoly = tile_data->get_navigation_polygon(layer_index);
+					if (navpoly.is_valid()) {
+						PackedVector2Array navigation_polygon_vertices = navpoly->get_vertices();
+
+						for (int i = 0; i < navpoly->get_polygon_count(); i++) {
+							// An array of vertices for this polygon.
+							Vector<int> polygon = navpoly->get_polygon(i);
+							Vector<Vector2> vertices;
+							vertices.resize(polygon.size());
+							for (int j = 0; j < polygon.size(); j++) {
+								ERR_FAIL_INDEX(polygon[j], navigation_polygon_vertices.size());
+								vertices.write[j] = navigation_polygon_vertices[polygon[j]];
+							}
+
+							// Generate the polygon color, slightly randomly modified from the settings one.
+							Color random_variation_color;
+							random_variation_color.set_hsv(color.get_h() + rand.random(-1.0, 1.0) * 0.05, color.get_s(), color.get_v() + rand.random(-1.0, 1.0) * 0.1);
+							random_variation_color.a = color.a;
+							Vector<Color> colors;
+							colors.push_back(random_variation_color);
+
+							rs->canvas_item_add_polygon(p_quadrant->debug_canvas_item, vertices, colors);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+/////////////////////////////// Scenes //////////////////////////////////////
+
+void TileMap::_scenes_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	SelfList<TileMapQuadrant> *q_list_element = r_dirty_quadrant_list.first();
+	while (q_list_element) {
+		TileMapQuadrant &q = *q_list_element->self();
+
+		// Clear the scenes.
+		for (Map<Vector2i, String>::Element *E = q.scenes.front(); E; E = E->next()) {
+			Node *node = get_node(E->get());
+			if (node) {
+				node->queue_delete();
+			}
+		}
+
+		q.scenes.clear();
+
+		// Recreate the scenes.
+		for (Set<Vector2i>::Element *E_cell = q.cells.front(); E_cell; E_cell = E_cell->next()) {
+			const TileMapCell &c = get_cell(q.layer, E_cell->get(), true);
+
+			TileSetSource *source;
+			if (tile_set->has_source(c.source_id)) {
+				source = *tile_set->get_source(c.source_id);
+
+				if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+					continue;
+				}
+
+				TileSetScenesCollectionSource *scenes_collection_source = Object::cast_to<TileSetScenesCollectionSource>(source);
+				if (scenes_collection_source) {
+					Ref<PackedScene> packed_scene = scenes_collection_source->get_scene_tile_scene(c.alternative_tile);
+					if (packed_scene.is_valid()) {
+						Node *scene = packed_scene->instantiate();
+						add_child(scene);
+						Control *scene_as_control = Object::cast_to<Control>(scene);
+						Node2D *scene_as_node2d = Object::cast_to<Node2D>(scene);
+						if (scene_as_control) {
+							scene_as_control->set_position(map_to_world(E_cell->get()) + scene_as_control->get_position());
+						} else if (scene_as_node2d) {
+							Transform2D xform;
+							xform.set_origin(map_to_world(E_cell->get()));
+							scene_as_node2d->set_transform(xform * scene_as_node2d->get_transform());
+						}
+						q.scenes[E_cell->get()] = scene->get_name();
+					}
+				}
+			}
+		}
+
+		q_list_element = q_list_element->next();
+	}
+}
+
+void TileMap::_scenes_cleanup_quadrant(TileMapQuadrant *p_quadrant) {
+	// Clear the scenes.
+	for (Map<Vector2i, String>::Element *E = p_quadrant->scenes.front(); E; E = E->next()) {
+		Node *node = get_node(E->get());
+		if (node) {
+			node->queue_delete();
+		}
+	}
+
+	p_quadrant->scenes.clear();
+}
+
+void TileMap::_scenes_draw_quadrant_debug(TileMapQuadrant *p_quadrant) {
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	if (!Engine::get_singleton()->is_editor_hint()) {
 		return;
 	}
 
-	if (p_update) {
-		call_deferred(SNAME("update_dirty_quadrants"));
+	// Draw a placeholder for scenes needing one.
+	RenderingServer *rs = RenderingServer::get_singleton();
+	Vector2 quadrant_pos = map_to_world(p_quadrant->coords * get_effective_quadrant_size(p_quadrant->layer));
+	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+		const TileMapCell &c = get_cell(p_quadrant->layer, E_cell->get(), true);
+
+		TileSetSource *source;
+		if (tile_set->has_source(c.source_id)) {
+			source = *tile_set->get_source(c.source_id);
+
+			if (!source->has_tile(c.get_atlas_coords()) || !source->has_alternative_tile(c.get_atlas_coords(), c.alternative_tile)) {
+				continue;
+			}
+
+			TileSetScenesCollectionSource *scenes_collection_source = Object::cast_to<TileSetScenesCollectionSource>(source);
+			if (scenes_collection_source) {
+				if (!scenes_collection_source->get_scene_tile_scene(c.alternative_tile).is_valid() || scenes_collection_source->get_scene_tile_display_placeholder(c.alternative_tile)) {
+					// Generate a random color from the hashed values of the tiles.
+					Array to_hash;
+					to_hash.push_back(c.source_id);
+					to_hash.push_back(c.alternative_tile);
+					uint32_t hash = RandomPCG(to_hash.hash()).rand();
+
+					Color color;
+					color = color.from_hsv(
+							(float)((hash >> 24) & 0xFF) / 256.0,
+							Math::lerp(0.5, 1.0, (float)((hash >> 16) & 0xFF) / 256.0),
+							Math::lerp(0.5, 1.0, (float)((hash >> 8) & 0xFF) / 256.0),
+							0.8);
+
+					// Draw a placeholder tile.
+					Transform2D xform;
+					xform.set_origin(map_to_world(E_cell->get()) - quadrant_pos);
+					rs->canvas_item_add_set_transform(p_quadrant->debug_canvas_item, xform);
+					rs->canvas_item_add_circle(p_quadrant->debug_canvas_item, Vector2(), MIN(tile_set->get_tile_size().x, tile_set->get_tile_size().y) / 4.0, color);
+				}
+			}
+		}
 	}
 }
 
-void TileMap::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) {
+void TileMap::set_cell(int p_layer, const Vector2i &p_coords, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+
 	// Set the current cell tile (using integer position).
+	Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	Vector2i pk(p_coords);
 	Map<Vector2i, TileMapCell>::Element *E = tile_map.find(pk);
 
@@ -526,9 +1555,9 @@ void TileMap::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i
 	}
 
 	// Get the quadrant
-	Vector2i qk = _coords_to_quadrant_coords(pk);
+	Vector2i qk = _coords_to_quadrant_coords(p_layer, pk);
 
-	Map<Vector2i, TileMapQuadrant>::Element *Q = quadrant_map.find(qk);
+	Map<Vector2i, TileMapQuadrant>::Element *Q = layers[p_layer].quadrant_map.find(qk);
 
 	if (source_id == TileSet::INVALID_SOURCE) {
 		// Erase existing cell in the tile map.
@@ -555,7 +1584,7 @@ void TileMap::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i
 
 			// Create a new quadrant if needed, then insert the cell if needed.
 			if (!Q) {
-				Q = _create_quadrant(qk);
+				Q = _create_quadrant(p_layer, qk);
 			}
 			TileMapQuadrant &q = Q->get();
 			q.cells.insert(pk);
@@ -579,8 +1608,11 @@ void TileMap::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i
 	}
 }
 
-int TileMap::get_cell_source_id(const Vector2i &p_coords, bool p_use_proxies) const {
+int TileMap::get_cell_source_id(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSet::INVALID_SOURCE);
+
 	// Get a cell source id from position
+	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
 
 	if (!E) {
@@ -595,8 +1627,11 @@ int TileMap::get_cell_source_id(const Vector2i &p_coords, bool p_use_proxies) co
 	return E->get().source_id;
 }
 
-Vector2i TileMap::get_cell_atlas_coords(const Vector2i &p_coords, bool p_use_proxies) const {
+Vector2i TileMap::get_cell_atlas_coords(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSetSource::INVALID_ATLAS_COORDS);
+
 	// Get a cell source id from position
+	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
 
 	if (!E) {
@@ -611,8 +1646,11 @@ Vector2i TileMap::get_cell_atlas_coords(const Vector2i &p_coords, bool p_use_pro
 	return E->get().get_atlas_coords();
 }
 
-int TileMap::get_cell_alternative_tile(const Vector2i &p_coords, bool p_use_proxies) const {
+int TileMap::get_cell_alternative_tile(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileSetSource::INVALID_TILE_ALTERNATIVE);
+
 	// Get a cell source id from position
+	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
 
 	if (!E) {
@@ -627,7 +1665,8 @@ int TileMap::get_cell_alternative_tile(const Vector2i &p_coords, bool p_use_prox
 	return E->get().alternative_tile;
 }
 
-TileMapPattern *TileMap::get_pattern(TypedArray<Vector2i> p_coords_array) {
+TileMapPattern *TileMap::get_pattern(int p_layer, TypedArray<Vector2i> p_coords_array) {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr);
 	ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr);
 
 	TileMapPattern *output = memnew(TileMapPattern);
@@ -673,7 +1712,7 @@ TileMapPattern *TileMap::get_pattern(TypedArray<Vector2i> p_coords_array) {
 	for (int i = 0; i < coords_in_pattern_array.size(); i++) {
 		Vector2i coords = p_coords_array[i];
 		Vector2i coords_in_pattern = coords_in_pattern_array[i];
-		output->set_cell(coords_in_pattern + ensure_positive_offset, get_cell_source_id(coords), get_cell_atlas_coords(coords), get_cell_alternative_tile(coords));
+		output->set_cell(coords_in_pattern + ensure_positive_offset, get_cell_source_id(p_layer, coords), get_cell_atlas_coords(p_layer, coords), get_cell_alternative_tile(p_layer, coords));
 	}
 
 	return output;
@@ -702,17 +1741,20 @@ Vector2i TileMap::map_pattern(Vector2i p_position_in_tilemap, Vector2i p_coords_
 	return output;
 }
 
-void TileMap::set_pattern(Vector2i p_position, const TileMapPattern *p_pattern) {
+void TileMap::set_pattern(int p_layer, Vector2i p_position, const TileMapPattern *p_pattern) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
 	ERR_FAIL_COND(!tile_set.is_valid());
 
 	TypedArray<Vector2i> used_cells = p_pattern->get_used_cells();
 	for (int i = 0; i < used_cells.size(); i++) {
 		Vector2i coords = map_pattern(p_position, used_cells[i], p_pattern);
-		set_cell(coords, p_pattern->get_cell_source_id(coords), p_pattern->get_cell_atlas_coords(coords), p_pattern->get_cell_alternative_tile(coords));
+		set_cell(p_layer, coords, p_pattern->get_cell_source_id(coords), p_pattern->get_cell_atlas_coords(coords), p_pattern->get_cell_alternative_tile(coords));
 	}
 }
 
-TileMapCell TileMap::get_cell(const Vector2i &p_coords, bool p_use_proxies) const {
+TileMapCell TileMap::get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TileMapCell());
+	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	if (!tile_map.has(p_coords)) {
 		return TileMapCell();
 	} else {
@@ -727,77 +1769,62 @@ TileMapCell TileMap::get_cell(const Vector2i &p_coords, bool p_use_proxies) cons
 	}
 }
 
-Map<Vector2i, TileMapQuadrant> &TileMap::get_quadrant_map() {
-	return quadrant_map;
+Map<Vector2i, TileMapQuadrant> *TileMap::get_quadrant_map(int p_layer) {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), nullptr);
+
+	return &layers[p_layer].quadrant_map;
 }
 
 void TileMap::fix_invalid_tiles() {
 	ERR_FAIL_COND_MSG(tile_set.is_null(), "Cannot fix invalid tiles if Tileset is not open.");
 
-	Set<Vector2i> coords;
-	for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
-		TileSetSource *source = *tile_set->get_source(E->get().source_id);
-		if (!source || !source->has_tile(E->get().get_atlas_coords()) || !source->has_alternative_tile(E->get().get_atlas_coords(), E->get().alternative_tile)) {
-			coords.insert(E->key());
+	for (unsigned int i = 0; i < layers.size(); i++) {
+		const Map<Vector2i, TileMapCell> &tile_map = layers[i].tile_map;
+		Set<Vector2i> coords;
+		for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
+			TileSetSource *source = *tile_set->get_source(E->get().source_id);
+			if (!source || !source->has_tile(E->get().get_atlas_coords()) || !source->has_alternative_tile(E->get().get_atlas_coords(), E->get().alternative_tile)) {
+				coords.insert(E->key());
+			}
 		}
-	}
-	for (Set<Vector2i>::Element *E = coords.front(); E; E = E->next()) {
-		set_cell(E->get(), TileSet::INVALID_SOURCE, TileSetSource::INVALID_ATLAS_COORDS, TileSetSource::INVALID_TILE_ALTERNATIVE);
-	}
-}
-
-void TileMap::_recreate_quadrants() {
-	// Clear then recreate all quadrants.
-	_clear_quadrants();
-
-	for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
-		Vector2i qk = _coords_to_quadrant_coords(Vector2i(E->key().x, E->key().y));
-
-		Map<Vector2i, TileMapQuadrant>::Element *Q = quadrant_map.find(qk);
-		if (!Q) {
-			Q = _create_quadrant(qk);
-			dirty_quadrant_list.add(&Q->get().dirty_list_element);
+		for (Set<Vector2i>::Element *E = coords.front(); E; E = E->next()) {
+			set_cell(i, E->get(), TileSet::INVALID_SOURCE, TileSetSource::INVALID_ATLAS_COORDS, TileSetSource::INVALID_TILE_ALTERNATIVE);
 		}
-
-		Vector2i pk = E->key();
-		Q->get().cells.insert(pk);
-
-		_make_quadrant_dirty(Q, false);
 	}
-
-	update_dirty_quadrants();
 }
 
-void TileMap::_clear_quadrants() {
-	// Clear quadrants.
-	while (quadrant_map.size()) {
-		_erase_quadrant(quadrant_map.front());
-	}
+void TileMap::clear_layer(int p_layer) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
 
-	// Clear the dirty quadrants list.
-	while (dirty_quadrant_list.first()) {
-		dirty_quadrant_list.remove(dirty_quadrant_list.first());
-	}
+	// Remove all tiles.
+	_clear_layer_internals(p_layer);
+	layers[p_layer].tile_map.clear();
+
+	used_size_cache_dirty = true;
 }
 
 void TileMap::clear() {
 	// Remove all tiles.
-	_clear_quadrants();
-	tile_map.clear();
+	_clear_internals();
+	for (unsigned int i = 0; i < layers.size(); i++) {
+		layers[i].tile_map.clear();
+	}
 	used_size_cache_dirty = true;
 }
 
-void TileMap::_set_tile_data(const Vector<int> &p_data) {
-	// Set data for a given tile from raw data.
+void TileMap::_set_tile_data(int p_layer, const Vector<int> &p_data) {
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
 	ERR_FAIL_COND(format > FORMAT_3);
 
+	// Set data for a given tile from raw data.
+
 	int c = p_data.size();
 	const int *r = p_data.ptr();
 
 	int offset = (format >= FORMAT_2) ? 3 : 2;
 	ERR_FAIL_COND_MSG(c % offset != 0, "Corrupted tile data.");
 
-	clear();
+	clear_layer(p_layer);
 
 #ifdef DISABLE_DEPRECATED
 	ERR_FAIL_COND_MSG(format != FORMAT_3, vformat("Cannot handle deprecated TileMap data format version %d. This Godot version was compiled with no support for deprecated data.", format));
@@ -831,7 +1858,7 @@ void TileMap::_set_tile_data(const Vector<int> &p_data) {
 			uint16_t atlas_coords_x = decode_uint16(&local[6]);
 			uint16_t atlas_coords_y = decode_uint16(&local[8]);
 			uint16_t alternative_tile = decode_uint16(&local[10]);
-			set_cell(Vector2i(x, y), source_id, Vector2i(atlas_coords_x, atlas_coords_y), alternative_tile);
+			set_cell(p_layer, Vector2i(x, y), source_id, Vector2i(atlas_coords_x, atlas_coords_y), alternative_tile);
 		} else {
 #ifndef DISABLE_DEPRECATED
 			// Previous decated format.
@@ -854,21 +1881,25 @@ void TileMap::_set_tile_data(const Vector<int> &p_data) {
 			if (tile_set.is_valid()) {
 				Array a = tile_set->compatibility_tilemap_map(v, Vector2i(coord_x, coord_y), flip_h, flip_v, transpose);
 				if (a.size() == 3) {
-					set_cell(Vector2i(x, y), a[0], a[1], a[2]);
+					set_cell(p_layer, Vector2i(x, y), a[0], a[1], a[2]);
 				} else {
 					ERR_PRINT(vformat("No valid tile in Tileset for: tile:%s coords:%s flip_h:%s flip_v:%s transpose:%s", v, Vector2i(coord_x, coord_y), flip_h, flip_v, transpose));
 				}
 			} else {
 				int compatibility_alternative_tile = ((int)flip_h) + ((int)flip_v << 1) + ((int)transpose << 2);
-				set_cell(Vector2i(x, y), v, Vector2i(coord_x, coord_y), compatibility_alternative_tile);
+				set_cell(p_layer, Vector2i(x, y), v, Vector2i(coord_x, coord_y), compatibility_alternative_tile);
 			}
 #endif
 		}
 	}
+	emit_signal(SNAME("changed"));
 }
 
-Vector<int> TileMap::_get_tile_data() const {
+Vector<int> TileMap::_get_tile_data(int p_layer) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), Vector<int>());
+
 	// Export tile data to raw format
+	const Map<Vector2i, TileMapCell> &tile_map = layers[p_layer].tile_map;
 	Vector<int> data;
 	data.resize(tile_map.size() * 3);
 	int *w = data.ptrw();
@@ -894,7 +1925,7 @@ Vector<int> TileMap::_get_tile_data() const {
 Rect2 TileMap::_edit_get_rect() const {
 	// Return the visible rect of the tilemap
 	if (pending_update) {
-		const_cast<TileMap *>(this)->update_dirty_quadrants();
+		const_cast<TileMap *>(this)->_update_dirty_quadrants();
 	} else {
 		const_cast<TileMap *>(this)->_recompute_rect_cache();
 	}
@@ -903,38 +1934,99 @@ Rect2 TileMap::_edit_get_rect() const {
 #endif
 
 bool TileMap::_set(const StringName &p_name, const Variant &p_value) {
+	Vector<String> components = String(p_name).split("/", true, 2);
 	if (p_name == "format") {
 		if (p_value.get_type() == Variant::INT) {
 			format = (DataFormat)(p_value.operator int64_t()); // Set format used for loading
 			return true;
 		}
-	} else if (p_name == "tile_data") {
+	} else if (p_name == "tile_data") { // Kept for compatibility reasons.
 		if (p_value.is_array()) {
-			_set_tile_data(p_value);
+			if (layers.size() < 1) {
+				layers.resize(1);
+			}
+			_set_tile_data(0, p_value);
 			return true;
 		}
 		return false;
+	} else if (components.size() == 2 && components[0].begins_with("layer_") && components[0].trim_prefix("layer_").is_valid_int()) {
+		int index = components[0].trim_prefix("layer_").to_int();
+		if (index < 0 || index >= (int)layers.size()) {
+			return false;
+		}
+
+		if (components[1] == "name") {
+			set_layer_name(index, p_value);
+			return true;
+		} else if (components[1] == "enabled") {
+			set_layer_enabled(index, p_value);
+			return true;
+		} else if (components[1] == "y_sort_enabled") {
+			set_layer_y_sort_enabled(index, p_value);
+			return true;
+		} else if (components[1] == "y_sort_origin") {
+			set_layer_y_sort_origin(index, p_value);
+			return true;
+		} else if (components[1] == "z_index") {
+			set_layer_z_index(index, p_value);
+			return true;
+		} else if (components[1] == "tile_data") {
+			_set_tile_data(index, p_value);
+			return true;
+		} else {
+			return false;
+		}
 	}
 	return false;
 }
 
 bool TileMap::_get(const StringName &p_name, Variant &r_ret) const {
+	Vector<String> components = String(p_name).split("/", true, 2);
 	if (p_name == "format") {
 		r_ret = FORMAT_3; // When saving, always save highest format
 		return true;
-	} else if (p_name == "tile_data") {
-		r_ret = _get_tile_data();
-		return true;
+	} else if (components.size() == 2 && components[0].begins_with("layer_") && components[0].trim_prefix("layer_").is_valid_int()) {
+		int index = components[0].trim_prefix("layer_").to_int();
+		if (index < 0 || index >= (int)layers.size()) {
+			return false;
+		}
+
+		if (components[1] == "name") {
+			r_ret = get_layer_name(index);
+			return true;
+		} else if (components[1] == "enabled") {
+			r_ret = is_layer_enabled(index);
+			return true;
+		} else if (components[1] == "y_sort_enabled") {
+			r_ret = is_layer_y_sort_enabled(index);
+			return true;
+		} else if (components[1] == "y_sort_origin") {
+			r_ret = get_layer_y_sort_origin(index);
+			return true;
+		} else if (components[1] == "z_index") {
+			r_ret = get_layer_z_index(index);
+			return true;
+		} else if (components[1] == "tile_data") {
+			r_ret = _get_tile_data(index);
+			return true;
+		} else {
+			return false;
+		}
 	}
 	return false;
 }
 
 void TileMap::_get_property_list(List<PropertyInfo> *p_list) const {
-	PropertyInfo p(Variant::INT, "format", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL);
-	p_list->push_back(p);
-
-	p = PropertyInfo(Variant::OBJECT, "tile_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL);
-	p_list->push_back(p);
+	p_list->push_back(PropertyInfo(Variant::INT, "format", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
+	p_list->push_back(PropertyInfo(Variant::NIL, "Layers", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+	for (unsigned int i = 0; i < layers.size(); i++) {
+		p_list->push_back(PropertyInfo(Variant::STRING, vformat("layer_%d/name", i), PROPERTY_HINT_NONE));
+		p_list->push_back(PropertyInfo(Variant::BOOL, vformat("layer_%d/enabled", i), PROPERTY_HINT_NONE));
+		p_list->push_back(PropertyInfo(Variant::BOOL, vformat("layer_%d/y_sort_enabled", i), PROPERTY_HINT_NONE));
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("layer_%d/y_sort_origin", i), PROPERTY_HINT_NONE));
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("layer_%d/z_index", i), PROPERTY_HINT_NONE));
+		p_list->push_back(PropertyInfo(Variant::OBJECT, vformat("layer_%d/tile_data", i), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+	}
 }
 
 Vector2 TileMap::map_to_world(const Vector2i &p_pos) const {
@@ -1557,12 +2649,14 @@ Vector2i TileMap::get_neighbor_cell(const Vector2i &p_coords, TileSet::CellNeigh
 	}
 }
 
-TypedArray<Vector2i> TileMap::get_used_cells() const {
+TypedArray<Vector2i> TileMap::get_used_cells(int p_layer) const {
+	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), TypedArray<Vector2i>());
+
 	// Returns the cells used in the tilemap.
 	TypedArray<Vector2i> a;
-	a.resize(tile_map.size());
+	a.resize(layers[p_layer].tile_map.size());
 	int i = 0;
-	for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
+	for (Map<Vector2i, TileMapCell>::Element *E = layers[p_layer].tile_map.front(); E; E = E->next()) {
 		Vector2i p(E->key().x, E->key().y);
 		a[i++] = p;
 	}
@@ -1573,18 +2667,20 @@ TypedArray<Vector2i> TileMap::get_used_cells() const {
 Rect2 TileMap::get_used_rect() { // Not const because of cache
 	// Return the rect of the currently used area
 	if (used_size_cache_dirty) {
-		if (tile_map.size() > 0) {
-			used_size_cache = Rect2(tile_map.front()->key().x, tile_map.front()->key().y, 0, 0);
+		bool first = true;
+		for (unsigned int i = 0; i < layers.size(); i++) {
+			const Map<Vector2i, TileMapCell> &tile_map = layers[i].tile_map;
+			if (tile_map.size() > 0) {
+				if (first) {
+					used_size_cache = Rect2(tile_map.front()->key().x, tile_map.front()->key().y, 1, 1);
+					first = false;
+				}
 
-			for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
-				used_size_cache.expand_to(Vector2(E->key().x, E->key().y));
+				for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
+					used_size_cache.expand_to(Vector2(E->key().x + 1, E->key().y + 1));
+				}
 			}
-
-			used_size_cache.size += Vector2(1, 1);
-		} else {
-			used_size_cache = Rect2();
 		}
-
 		used_size_cache_dirty = false;
 	}
 
@@ -1596,10 +2692,13 @@ Rect2 TileMap::get_used_rect() { // Not const because of cache
 void TileMap::set_light_mask(int p_light_mask) {
 	// Occlusion: set light mask.
 	CanvasItem::set_light_mask(p_light_mask);
-	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		for (const RID &F : E->get().canvas_items) {
-			RenderingServer::get_singleton()->canvas_item_set_light_mask(F, get_light_mask());
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		for (Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+			for (const RID &ci : E->get().canvas_items) {
+				RenderingServer::get_singleton()->canvas_item_set_light_mask(ci, get_light_mask());
+			}
 		}
+		_rendering_update_layer(layer);
 	}
 }
 
@@ -1608,11 +2707,14 @@ void TileMap::set_material(const Ref<Material> &p_material) {
 	CanvasItem::set_material(p_material);
 
 	// Update material for the whole tilemap.
-	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		TileMapQuadrant &q = E->get();
-		for (const RID &F : q.canvas_items) {
-			RS::get_singleton()->canvas_item_set_use_parent_material(F, get_use_parent_material() || get_material().is_valid());
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		for (Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+			TileMapQuadrant &q = E->get();
+			for (const RID &ci : q.canvas_items) {
+				RS::get_singleton()->canvas_item_set_use_parent_material(ci, get_use_parent_material() || get_material().is_valid());
+			}
 		}
+		_rendering_update_layer(layer);
 	}
 }
 
@@ -1621,35 +2723,44 @@ void TileMap::set_use_parent_material(bool p_use_parent_material) {
 	CanvasItem::set_use_parent_material(p_use_parent_material);
 
 	// Update use_parent_material for the whole tilemap.
-	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		TileMapQuadrant &q = E->get();
-		for (const RID &F : q.canvas_items) {
-			RS::get_singleton()->canvas_item_set_use_parent_material(F, get_use_parent_material() || get_material().is_valid());
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		for (Map<Vector2i, TileMapQuadrant>::Element *E = layers[layer].quadrant_map.front(); E; E = E->next()) {
+			TileMapQuadrant &q = E->get();
+			for (const RID &ci : q.canvas_items) {
+				RS::get_singleton()->canvas_item_set_use_parent_material(ci, get_use_parent_material() || get_material().is_valid());
+			}
 		}
+		_rendering_update_layer(layer);
 	}
 }
 
 void TileMap::set_texture_filter(TextureFilter p_texture_filter) {
 	// Set a default texture filter for the whole tilemap
 	CanvasItem::set_texture_filter(p_texture_filter);
-	for (Map<Vector2i, TileMapQuadrant>::Element *F = quadrant_map.front(); F; F = F->next()) {
-		TileMapQuadrant &q = F->get();
-		for (const RID &E : q.canvas_items) {
-			RenderingServer::get_singleton()->canvas_item_set_default_texture_filter(E, RS::CanvasItemTextureFilter(p_texture_filter));
-			_make_quadrant_dirty(F);
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		for (Map<Vector2i, TileMapQuadrant>::Element *F = layers[layer].quadrant_map.front(); F; F = F->next()) {
+			TileMapQuadrant &q = F->get();
+			for (const RID &ci : q.canvas_items) {
+				RenderingServer::get_singleton()->canvas_item_set_default_texture_filter(ci, RS::CanvasItemTextureFilter(p_texture_filter));
+				_make_quadrant_dirty(F);
+			}
 		}
+		_rendering_update_layer(layer);
 	}
 }
 
 void TileMap::set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) {
 	// Set a default texture repeat for the whole tilemap
 	CanvasItem::set_texture_repeat(p_texture_repeat);
-	for (Map<Vector2i, TileMapQuadrant>::Element *F = quadrant_map.front(); F; F = F->next()) {
-		TileMapQuadrant &q = F->get();
-		for (const RID &E : q.canvas_items) {
-			RenderingServer::get_singleton()->canvas_item_set_default_texture_repeat(E, RS::CanvasItemTextureRepeat(p_texture_repeat));
-			_make_quadrant_dirty(F);
+	for (unsigned int layer = 0; layer < layers.size(); layer++) {
+		for (Map<Vector2i, TileMapQuadrant>::Element *F = layers[layer].quadrant_map.front(); F; F = F->next()) {
+			TileMapQuadrant &q = F->get();
+			for (const RID &ci : q.canvas_items) {
+				RenderingServer::get_singleton()->canvas_item_set_default_texture_repeat(ci, RS::CanvasItemTextureRepeat(p_texture_repeat));
+				_make_quadrant_dirty(F);
+			}
 		}
+		_rendering_update_layer(layer);
 	}
 }
 
@@ -1744,6 +2855,28 @@ void TileMap::draw_cells_outline(Control *p_control, Set<Vector2i> p_cells, Colo
 	}
 }
 
+TypedArray<String> TileMap::get_configuration_warnings() const {
+	TypedArray<String> warnings = Node::get_configuration_warnings();
+
+	// Retrieve the set of Z index values with a Y-sorted layer.
+	Set<int> y_sorted_z_index;
+	for (int layer = 0; layer < (int)layers.size(); layer++) {
+		if (layers[layer].y_sort_enabled) {
+			y_sorted_z_index.insert(layers[layer].z_index);
+		}
+	}
+
+	// Check if we have a non-sorted layer in a Z-index with a Y-sorted layer.
+	for (int layer = 0; layer < (int)layers.size(); layer++) {
+		if (!layers[layer].y_sort_enabled && y_sorted_z_index.has(layers[layer].z_index)) {
+			warnings.push_back(TTR("A Y-sorted layer has the same Z-index value as a not Y-sorted layer.\nThis may lead to unwanted behaviors, as a layer that is not Y-sorted will be Y-sorted as a whole with tiles from Y-sorted layers."));
+			break;
+		}
+	}
+
+	return warnings;
+}
+
 void TileMap::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_tileset", "tileset"), &TileMap::set_tileset);
 	ClassDB::bind_method(D_METHOD("get_tileset"), &TileMap::get_tileset);
@@ -1751,22 +2884,35 @@ void TileMap::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_quadrant_size", "size"), &TileMap::set_quadrant_size);
 	ClassDB::bind_method(D_METHOD("get_quadrant_size"), &TileMap::get_quadrant_size);
 
-	ClassDB::bind_method(D_METHOD("set_collision_visibility_mode", "show_collision"), &TileMap::set_collision_visibility_mode);
+	ClassDB::bind_method(D_METHOD("set_layers_count", "layers_count"), &TileMap::set_layers_count);
+	ClassDB::bind_method(D_METHOD("get_layers_count"), &TileMap::get_layers_count);
+	ClassDB::bind_method(D_METHOD("set_layer_name", "layer", "name"), &TileMap::set_layer_name);
+	ClassDB::bind_method(D_METHOD("get_layer_name", "layer"), &TileMap::get_layer_name);
+	ClassDB::bind_method(D_METHOD("set_layer_enabled", "layer", "enabled"), &TileMap::set_layer_enabled);
+	ClassDB::bind_method(D_METHOD("is_layer_enabled", "layer"), &TileMap::is_layer_enabled);
+	ClassDB::bind_method(D_METHOD("set_layer_y_sort_enabled", "layer", "y_sort_enabled"), &TileMap::set_layer_y_sort_enabled);
+	ClassDB::bind_method(D_METHOD("is_layer_y_sort_enabled", "layer"), &TileMap::is_layer_y_sort_enabled);
+	ClassDB::bind_method(D_METHOD("set_layer_y_sort_origin", "layer", "y_sort_origin"), &TileMap::set_layer_y_sort_origin);
+	ClassDB::bind_method(D_METHOD("get_layer_y_sort_origin", "layer"), &TileMap::get_layer_y_sort_origin);
+	ClassDB::bind_method(D_METHOD("set_layer_z_index", "layer", "z_index"), &TileMap::set_layer_z_index);
+	ClassDB::bind_method(D_METHOD("get_layer_z_indexd", "layer"), &TileMap::get_layer_z_index);
+
+	ClassDB::bind_method(D_METHOD("set_collision_visibility_mode", "collision_visibility_mode"), &TileMap::set_collision_visibility_mode);
 	ClassDB::bind_method(D_METHOD("get_collision_visibility_mode"), &TileMap::get_collision_visibility_mode);
 
-	ClassDB::bind_method(D_METHOD("set_navigation_visibility_mode", "show_navigation"), &TileMap::set_navigation_visibility_mode);
+	ClassDB::bind_method(D_METHOD("set_navigation_visibility_mode", "navigation_visibility_mode"), &TileMap::set_navigation_visibility_mode);
 	ClassDB::bind_method(D_METHOD("get_navigation_visibility_mode"), &TileMap::get_navigation_visibility_mode);
 
-	ClassDB::bind_method(D_METHOD("set_cell", "coords", "source_id", "atlas_coords", "alternative_tile"), &TileMap::set_cell, DEFVAL(TileSet::INVALID_SOURCE), DEFVAL(TileSetSource::INVALID_ATLAS_COORDS), DEFVAL(TileSetSource::INVALID_TILE_ALTERNATIVE));
-	ClassDB::bind_method(D_METHOD("get_cell_source_id", "coords", "use_proxies"), &TileMap::get_cell_source_id);
-	ClassDB::bind_method(D_METHOD("get_cell_atlas_coords", "coords", "use_proxies"), &TileMap::get_cell_atlas_coords);
-	ClassDB::bind_method(D_METHOD("get_cell_alternative_tile", "coords", "use_proxies"), &TileMap::get_cell_alternative_tile);
+	ClassDB::bind_method(D_METHOD("set_cell", "layer", "coords", "source_id", "atlas_coords", "alternative_tile"), &TileMap::set_cell, DEFVAL(TileSet::INVALID_SOURCE), DEFVAL(TileSetSource::INVALID_ATLAS_COORDS), DEFVAL(TileSetSource::INVALID_TILE_ALTERNATIVE));
+	ClassDB::bind_method(D_METHOD("get_cell_source_id", "layer", "coords", "use_proxies"), &TileMap::get_cell_source_id);
+	ClassDB::bind_method(D_METHOD("get_cell_atlas_coords", "layer", "coords", "use_proxies"), &TileMap::get_cell_atlas_coords);
+	ClassDB::bind_method(D_METHOD("get_cell_alternative_tile", "layer", "coords", "use_proxies"), &TileMap::get_cell_alternative_tile);
 
 	ClassDB::bind_method(D_METHOD("fix_invalid_tiles"), &TileMap::fix_invalid_tiles);
 	ClassDB::bind_method(D_METHOD("get_surrounding_tiles", "coords"), &TileMap::get_surrounding_tiles);
 	ClassDB::bind_method(D_METHOD("clear"), &TileMap::clear);
 
-	ClassDB::bind_method(D_METHOD("get_used_cells"), &TileMap::get_used_cells);
+	ClassDB::bind_method(D_METHOD("get_used_cells", "layer"), &TileMap::get_used_cells);
 	ClassDB::bind_method(D_METHOD("get_used_rect"), &TileMap::get_used_rect);
 
 	ClassDB::bind_method(D_METHOD("map_to_world", "map_position"), &TileMap::map_to_world);
@@ -1774,15 +2920,19 @@ void TileMap::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("get_neighbor_cell", "coords", "neighbor"), &TileMap::get_neighbor_cell);
 
-	ClassDB::bind_method(D_METHOD("update_dirty_quadrants"), &TileMap::update_dirty_quadrants);
+	ClassDB::bind_method(D_METHOD("_update_dirty_quadrants"), &TileMap::_update_dirty_quadrants);
 
-	ClassDB::bind_method(D_METHOD("_set_tile_data"), &TileMap::_set_tile_data);
-	ClassDB::bind_method(D_METHOD("_get_tile_data"), &TileMap::_get_tile_data);
+	ClassDB::bind_method(D_METHOD("_set_tile_data", "layer"), &TileMap::_set_tile_data);
+	ClassDB::bind_method(D_METHOD("_get_tile_data", "layer"), &TileMap::_get_tile_data);
 
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "TileSet"), "set_tileset", "get_tileset");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_quadrant_size", PROPERTY_HINT_RANGE, "1,128,1"), "set_quadrant_size", "get_quadrant_size");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "show_collision", PROPERTY_HINT_ENUM, "Default,Force Show,Force Hide"), "set_collision_visibility_mode", "get_collision_visibility_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "show_navigation", PROPERTY_HINT_ENUM, "Default,Force Show,Force Hide"), "set_navigation_visibility_mode", "get_navigation_visibility_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_visibility_mode", PROPERTY_HINT_ENUM, "Default,Force Show,Force Hide"), "set_collision_visibility_mode", "get_collision_visibility_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "navigation_visibility_mode", PROPERTY_HINT_ENUM, "Default,Force Show,Force Hide"), "set_navigation_visibility_mode", "get_navigation_visibility_mode");
+
+	ADD_GROUP("Layers", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "layers_count"), "set_layers_count", "get_layers_count");
+	ADD_PROPERTY_DEFAULT("layers_count", 1);
 
 	ADD_PROPERTY_DEFAULT("format", FORMAT_1);
 
@@ -1795,17 +2945,19 @@ void TileMap::_bind_methods() {
 
 void TileMap::_tile_set_changed() {
 	emit_signal(SNAME("changed"));
-	_make_all_quadrants_dirty(true);
+	_recreate_internals();
 }
 
 TileMap::TileMap() {
 	set_notify_transform(true);
 	set_notify_local_transform(false);
+
+	layers.resize(1);
 }
 
 TileMap::~TileMap() {
 	if (tile_set.is_valid()) {
 		tile_set->disconnect("changed", callable_mp(this, &TileMap::_tile_set_changed));
 	}
-	_clear_quadrants();
+	_clear_internals();
 }
diff --git a/scene/2d/tile_map.h b/scene/2d/tile_map.h
index 9e35e73ad8..4800780f94 100644
--- a/scene/2d/tile_map.h
+++ b/scene/2d/tile_map.h
@@ -99,7 +99,8 @@ struct TileMapQuadrant {
 	// Dirty list element
 	SelfList<TileMapQuadrant> dirty_list_element;
 
-	// Quadrant coords.
+	// Quadrant layer and coords.
+	int layer = -1;
 	Vector2i coords;
 
 	// TileMapCells
@@ -126,6 +127,7 @@ struct TileMapQuadrant {
 	Map<Vector2i, String> scenes;
 
 	void operator=(const TileMapQuadrant &q) {
+		layer = q.layer;
 		coords = q.coords;
 		debug_canvas_item = q.debug_canvas_item;
 		canvas_items = q.canvas_items;
@@ -136,6 +138,7 @@ 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;
@@ -196,11 +199,13 @@ private:
 	};
 	mutable DataFormat format = FORMAT_1; // Assume lowest possible format if none is present;
 
+	static constexpr float FP_ADJUST = 0.00001;
+
 	// Properties.
 	Ref<TileSet> tile_set;
 	int quadrant_size = 16;
-	VisibilityMode show_collision = VISIBILITY_MODE_DEFAULT;
-	VisibilityMode show_navigation = VISIBILITY_MODE_DEFAULT;
+	VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT;
+	VisibilityMode navigation_visibility_mode = VISIBILITY_MODE_DEFAULT;
 
 	// Updates.
 	bool pending_update = false;
@@ -211,25 +216,69 @@ private:
 	Rect2 used_size_cache;
 	bool used_size_cache_dirty = true;
 
-	// Map of cells.
-	Map<Vector2i, TileMapCell> tile_map;
+	// TileMap layers.
+	struct TileMapLayer {
+		String name;
+		bool enabled = true;
+		bool y_sort_enabled = false;
+		int y_sort_origin = 0;
+		int z_index = 0;
+		RID canvas_item;
+		Map<Vector2i, TileMapCell> tile_map;
+		Map<Vector2i, TileMapQuadrant> quadrant_map;
+		SelfList<TileMapQuadrant>::List dirty_quadrant_list;
+	};
+	LocalVector<TileMapLayer> layers;
+	int selected_layer = -1;
+
+	// Quadrants and internals management.
+	Vector2i _coords_to_quadrant_coords(int p_layer, const Vector2i &p_coords) const;
+
+	Map<Vector2i, TileMapQuadrant>::Element *_create_quadrant(int p_layer, const Vector2i &p_qk);
+
+	void _make_quadrant_dirty(Map<Vector2i, TileMapQuadrant>::Element *Q);
+	void _make_all_quadrants_dirty();
+	void _queue_update_dirty_quadrants();
+
+	void _update_dirty_quadrants();
 
-	// Quadrants management.
-	Map<Vector2i, TileMapQuadrant> quadrant_map;
-	Vector2i _coords_to_quadrant_coords(const Vector2i &p_coords) const;
-	SelfList<TileMapQuadrant>::List dirty_quadrant_list;
+	void _recreate_internals();
 
-	Map<Vector2i, TileMapQuadrant>::Element *_create_quadrant(const Vector2i &p_qk);
 	void _erase_quadrant(Map<Vector2i, TileMapQuadrant>::Element *Q);
-	void _make_all_quadrants_dirty(bool p_update = true);
-	void _make_quadrant_dirty(Map<Vector2i, TileMapQuadrant>::Element *Q, bool p_update = true);
-	void _recreate_quadrants();
-	void _clear_quadrants();
+	void _clear_layer_internals(int p_layer);
+	void _clear_internals();
+
+	// 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);
+
+	void _physics_notification(int p_what);
+	void _physics_update_dirty_quadrants(SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list);
+	void _physics_create_quadrant(TileMapQuadrant *p_quadrant);
+	void _physics_cleanup_quadrant(TileMapQuadrant *p_quadrant);
+	void _physics_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
+
+	void _navigation_notification(int p_what);
+	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);
+
 	// Set and get tiles from data arrays.
-	void _set_tile_data(const Vector<int> &p_data);
-	Vector<int> _get_tile_data() const;
+	void _set_tile_data(int p_layer, const Vector<int> &p_data);
+	Vector<int> _get_tile_data(int p_layer) const;
 
 	void _tile_set_changed();
 
@@ -258,27 +307,45 @@ public:
 	void set_quadrant_size(int p_size);
 	int get_quadrant_size() const;
 
+	static void draw_tile(RID p_canvas_item, Vector2i p_position, const Ref<TileSet> p_tile_set, int p_atlas_source_id, Vector2i p_atlas_coords, int p_alternative_tile, Color p_modulation = Color(1.0, 1.0, 1.0, 1.0));
+
+	// Layers management.
+	void set_layers_count(int p_layers_count);
+	int get_layers_count() const;
+	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);
+	bool is_layer_enabled(int p_layer) const;
+	void set_layer_y_sort_enabled(int p_layer, bool p_enabled);
+	bool is_layer_y_sort_enabled(int p_layer) const;
+	void set_layer_y_sort_origin(int p_layer, int p_y_sort_origin);
+	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_selected_layer(int p_layer_id); // For editor use.
+	int get_selected_layer() const;
+
 	void set_collision_visibility_mode(VisibilityMode p_show_collision);
 	VisibilityMode get_collision_visibility_mode();
 
 	void set_navigation_visibility_mode(VisibilityMode p_show_navigation);
 	VisibilityMode get_navigation_visibility_mode();
 
-	void set_cell(const Vector2i &p_coords, int p_source_id = -1, const Vector2i p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE);
-	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;
+	void set_cell(int p_layer, const Vector2i &p_coords, int p_source_id = -1, const Vector2i p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE);
+	int get_cell_source_id(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
+	Vector2i get_cell_atlas_coords(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
+	int get_cell_alternative_tile(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
 
-	TileMapPattern *get_pattern(TypedArray<Vector2i> p_coords_array);
+	TileMapPattern *get_pattern(int p_layer, TypedArray<Vector2i> p_coords_array);
 	Vector2i map_pattern(Vector2i p_position_in_tilemap, Vector2i p_coords_in_pattern, const TileMapPattern *p_pattern);
-	void set_pattern(Vector2i p_position, const TileMapPattern *p_pattern);
+	void set_pattern(int p_layer, Vector2i p_position, const TileMapPattern *p_pattern);
 
 	// Not exposed to users
-	TileMapCell get_cell(const Vector2i &p_coords, bool p_use_proxies = false) const;
-	Map<Vector2i, TileMapQuadrant> &get_quadrant_map();
-	int get_effective_quadrant_size() const;
+	TileMapCell get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
+	Map<Vector2i, TileMapQuadrant> *get_quadrant_map(int p_layer);
+	int get_effective_quadrant_size(int p_layer) const;
+	//---
 
-	void update_dirty_quadrants();
 	virtual void set_y_sort_enabled(bool p_enable) override;
 
 	Vector2 map_to_world(const Vector2i &p_pos) const;
@@ -287,7 +354,7 @@ public:
 	bool is_existing_neighbor(TileSet::CellNeighbor p_cell_neighbor) const;
 	Vector2i get_neighbor_cell(const Vector2i &p_coords, TileSet::CellNeighbor p_cell_neighbor) const;
 
-	TypedArray<Vector2i> get_used_cells() const;
+	TypedArray<Vector2i> get_used_cells(int p_layer) const;
 	Rect2 get_used_rect(); // Not const because of cache
 
 	// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems
@@ -297,13 +364,19 @@ public:
 	virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter) override;
 	virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) override;
 
+	// Fixing a nclearing methods.
 	void fix_invalid_tiles();
+
+	void clear_layer(int p_layer);
 	void clear();
 
 	// Helpers
 	TypedArray<Vector2i> get_surrounding_tiles(Vector2i coords);
 	void draw_cells_outline(Control *p_control, Set<Vector2i> p_cells, Color p_color, Transform2D p_transform = Transform2D());
 
+	// Configuration warnings.
+	TypedArray<String> get_configuration_warnings() const override;
+
 	TileMap();
 	~TileMap();
 };