Rework the TileSet resource and TileMap nodes:

- Move most properties from TileMap to TileSet,
- Make TileSet more flexible, supporting more feature (several
  collision layers, etc...),
- Fusion both the TileMap and TileSet editor,
- Implement TileSetSources, and thus a new way to index tiles in the TileSet,
- Rework the TileSet and TileMap editors completely,
- Implement an editor zoom widget (and use it in several places)

6 files changed, 5931 insertions, 2627 deletions

diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp
index 532a795b7c..4400198497 100644
--- a/scene/2d/tile_map.cpp
+++ b/scene/2d/tile_map.cpp
@@ -30,260 +30,323 @@
 
 #include "tile_map.h"
 
-#include "collision_object_2d.h"
 #include "core/io/marshalls.h"
+#include "core/math/geometry_2d.h"
 #include "core/os/os.h"
-#include "scene/2d/area_2d.h"
-#include "servers/navigation_server_2d.h"
-#include "servers/physics_server_2d.h"
 
-int TileMap::_get_quadrant_size() const {
-	if (use_y_sort) {
-		return 1;
-	} else {
-		return quadrant_size;
-	}
+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));
+
+	size = size.max(p_coords + Vector2i(1, 1));
+	pattern[p_coords] = TileMapCell(p_source_id, p_atlas_coords, p_alternative_tile);
 }
 
-void TileMap::_notification(int p_what) {
-	switch (p_what) {
-		case NOTIFICATION_ENTER_TREE: {
-			if (use_parent) {
-				_clear_quadrants();
-				collision_parent = Object::cast_to<CollisionObject2D>(get_parent());
-			}
+bool TileMapPattern::has_cell(const Vector2i &p_coords) const {
+	return pattern.has(p_coords);
+}
 
-			pending_update = true;
-			_recreate_quadrants();
-			update_dirty_quadrants();
-			RID space = get_world_2d()->get_space();
-			_update_quadrant_transform();
-			_update_quadrant_space(space);
-			update_configuration_warnings();
+void TileMapPattern::remove_cell(const Vector2i &p_coords, bool p_update_size) {
+	ERR_FAIL_COND(!pattern.has(p_coords));
 
-		} break;
+	pattern.erase(p_coords);
+	if (p_update_size) {
+		size = Vector2i();
+		for (Map<Vector2i, TileMapCell>::Element *E = pattern.front(); E; E = E->next()) {
+			size = size.max(E->key() + Vector2i(1, 1));
+		}
+	}
+}
 
-		case NOTIFICATION_EXIT_TREE: {
-			_update_quadrant_space(RID());
-			for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-				Quadrant &q = E->get();
-				for (Map<PosKey, Quadrant::NavPoly>::Element *F = q.navpoly_ids.front(); F; F = F->next()) {
-					NavigationServer2D::get_singleton()->region_set_map(F->get().region, RID());
-				}
-				q.navpoly_ids.clear();
+int TileMapPattern::get_cell_source_id(const Vector2i &p_coords) const {
+	ERR_FAIL_COND_V(!pattern.has(p_coords), -1);
 
-				if (collision_parent) {
-					collision_parent->remove_shape_owner(q.shape_owner_id);
-					q.shape_owner_id = -1;
-				}
+	return pattern[p_coords].source_id;
+}
 
-				for (Map<PosKey, Quadrant::Occluder>::Element *F = q.occluder_instances.front(); F; F = F->next()) {
-					RS::get_singleton()->free(F->get().id);
-				}
-				q.occluder_instances.clear();
-			}
+Vector2i TileMapPattern::get_cell_atlas_coords(const Vector2i &p_coords) const {
+	ERR_FAIL_COND_V(!pattern.has(p_coords), TileSetAtlasSource::INVALID_ATLAS_COORDS);
 
-			collision_parent = nullptr;
-		} break;
+	return pattern[p_coords].get_atlas_coords();
+}
 
-		case NOTIFICATION_TRANSFORM_CHANGED: {
-			//move stuff
-			_update_quadrant_transform();
+int TileMapPattern::get_cell_alternative_tile(const Vector2i &p_coords) const {
+	ERR_FAIL_COND_V(!pattern.has(p_coords), TileSetAtlasSource::INVALID_TILE_ALTERNATIVE);
 
-		} break;
-		case NOTIFICATION_LOCAL_TRANSFORM_CHANGED: {
-			if (use_parent) {
-				_recreate_quadrants();
-			}
+	return pattern[p_coords].alternative_tile;
+}
 
-		} break;
+TypedArray<Vector2i> TileMapPattern::get_used_cells() const {
+	// Returns the cells used in the tilemap.
+	TypedArray<Vector2i> a;
+	a.resize(pattern.size());
+	int i = 0;
+	for (Map<Vector2i, TileMapCell>::Element *E = pattern.front(); E; E = E->next()) {
+		Vector2i p(E->key().x, E->key().y);
+		a[i++] = p;
 	}
+
+	return a;
 }
 
-void TileMap::_update_quadrant_space(const RID &p_space) {
-	if (!use_parent) {
-		for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-			Quadrant &q = E->get();
-			PhysicsServer2D::get_singleton()->body_set_space(q.body, p_space);
-		}
-	}
+Vector2i TileMapPattern::get_size() const {
+	return size;
 }
 
-void TileMap::_update_quadrant_transform() {
-	if (!is_inside_tree()) {
-		return;
+void TileMapPattern::set_size(const Vector2i &p_size) {
+	for (Map<Vector2i, TileMapCell>::Element *E = pattern.front(); E; E = E->next()) {
+		Vector2i coords = E->key();
+		if (p_size.x <= coords.x || p_size.y <= coords.y) {
+			ERR_FAIL_MSG(vformat("Cannot set pattern size to %s, it contains a tile at %s. Size can only be increased.", p_size, coords));
+		};
 	}
 
-	Transform2D global_transform = get_global_transform();
+	size = p_size;
+}
 
-	Transform2D local_transform;
-	if (collision_parent) {
-		local_transform = get_transform();
-	}
+bool TileMapPattern::is_empty() const {
+	return pattern.is_empty();
+};
 
-	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		Quadrant &q = E->get();
-		Transform2D xform;
-		xform.set_origin(q.pos);
+void TileMapPattern::clear() {
+	size = Vector2i();
+	pattern.clear();
+};
 
-		if (!use_parent) {
-			xform = global_transform * xform;
-			PhysicsServer2D::get_singleton()->body_set_state(q.body, PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
-		}
+void TileMapPattern::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_cell", "coords", "source_id", "atlas_coords", "alternative_tile"), &TileMapPattern::set_cell, DEFVAL(-1), DEFVAL(TileSetAtlasSource::INVALID_ATLAS_COORDS), DEFVAL(TileSetAtlasSource::INVALID_TILE_ALTERNATIVE));
+	ClassDB::bind_method(D_METHOD("has_cell", "coords"), &TileMapPattern::has_cell);
+	ClassDB::bind_method(D_METHOD("remove_cell", "coords"), &TileMapPattern::remove_cell);
+	ClassDB::bind_method(D_METHOD("get_cell_source_id", "coords"), &TileMapPattern::get_cell_source_id);
+	ClassDB::bind_method(D_METHOD("get_cell_atlas_coords", "coords"), &TileMapPattern::get_cell_atlas_coords);
+	ClassDB::bind_method(D_METHOD("get_cell_alternative_tile", "coords"), &TileMapPattern::get_cell_alternative_tile);
 
-		if (bake_navigation) {
-			for (Map<PosKey, Quadrant::NavPoly>::Element *F = q.navpoly_ids.front(); F; F = F->next()) {
-				NavigationServer2D::get_singleton()->region_set_transform(F->get().region, F->get().xform);
+	ClassDB::bind_method(D_METHOD("get_used_cells"), &TileMapPattern::get_used_cells);
+	ClassDB::bind_method(D_METHOD("get_size"), &TileMapPattern::get_size);
+	ClassDB::bind_method(D_METHOD("set_size", "size"), &TileMapPattern::set_size);
+	ClassDB::bind_method(D_METHOD("is_empty"), &TileMapPattern::is_empty);
+}
+
+Vector2i TileMap::transform_coords_layout(Vector2i p_coords, TileSet::TileOffsetAxis p_offset_axis, TileSet::TileLayout p_from_layout, TileSet::TileLayout p_to_layout) {
+	// Transform to stacked layout.
+	Vector2i output = p_coords;
+	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
+		SWAP(output.x, output.y);
+	}
+	switch (p_from_layout) {
+		case TileSet::TILE_LAYOUT_STACKED:
+			break;
+		case TileSet::TILE_LAYOUT_STACKED_OFFSET:
+			if (output.y % 2) {
+				output.x -= 1;
 			}
-		}
+			break;
+		case TileSet::TILE_LAYOUT_STAIRS_RIGHT:
+		case TileSet::TILE_LAYOUT_STAIRS_DOWN:
+			if ((p_from_layout == TileSet::TILE_LAYOUT_STAIRS_RIGHT) ^ (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL)) {
+				if (output.y < 0 && bool(output.y % 2)) {
+					output = Vector2i(output.x + output.y / 2 - 1, output.y);
+				} else {
+					output = Vector2i(output.x + output.y / 2, output.y);
+				}
+			} else {
+				if (output.x < 0 && bool(output.x % 2)) {
+					output = Vector2i(output.x / 2 - 1, output.x + output.y * 2);
+				} else {
+					output = Vector2i(output.x / 2, output.x + output.y * 2);
+				}
+			}
+			break;
+		case TileSet::TILE_LAYOUT_DIAMOND_RIGHT:
+		case TileSet::TILE_LAYOUT_DIAMOND_DOWN:
+			if ((p_from_layout == TileSet::TILE_LAYOUT_DIAMOND_RIGHT) ^ (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL)) {
+				if ((output.x + output.y) < 0 && (output.x - output.y) % 2) {
+					output = Vector2i((output.x + output.y) / 2 - 1, output.y - output.x);
+				} else {
+					output = Vector2i((output.x + output.y) / 2, -output.x + output.y);
+				}
+			} else {
+				if ((output.x - output.y) < 0 && (output.x + output.y) % 2) {
+					output = Vector2i((output.x - output.y) / 2 - 1, output.x + output.y);
+				} else {
+					output = Vector2i((output.x - output.y) / 2, output.x + output.y);
+				}
+			}
+			break;
+	}
 
-		for (Map<PosKey, Quadrant::Occluder>::Element *F = q.occluder_instances.front(); F; F = F->next()) {
-			RS::get_singleton()->canvas_light_occluder_set_transform(F->get().id, global_transform * F->get().xform);
-		}
+	switch (p_to_layout) {
+		case TileSet::TILE_LAYOUT_STACKED:
+			break;
+		case TileSet::TILE_LAYOUT_STACKED_OFFSET:
+			if (output.y % 2) {
+				output.x += 1;
+			}
+			break;
+		case TileSet::TILE_LAYOUT_STAIRS_RIGHT:
+		case TileSet::TILE_LAYOUT_STAIRS_DOWN:
+			if ((p_to_layout == TileSet::TILE_LAYOUT_STAIRS_RIGHT) ^ (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL)) {
+				if (output.y < 0 && (output.y % 2)) {
+					output = Vector2i(output.x - output.y / 2 + 1, output.y);
+				} else {
+					output = Vector2i(output.x - output.y / 2, output.y);
+				}
+			} else {
+				if (output.y % 2) {
+					if (output.y < 0) {
+						output = Vector2i(2 * output.x + 1, -output.x + output.y / 2 - 1);
+					} else {
+						output = Vector2i(2 * output.x + 1, -output.x + output.y / 2);
+					}
+				} else {
+					output = Vector2i(2 * output.x, -output.x + output.y / 2);
+				}
+			}
+			break;
+		case TileSet::TILE_LAYOUT_DIAMOND_RIGHT:
+		case TileSet::TILE_LAYOUT_DIAMOND_DOWN:
+			if ((p_to_layout == TileSet::TILE_LAYOUT_DIAMOND_RIGHT) ^ (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL)) {
+				if (output.y % 2) {
+					if (output.y > 0) {
+						output = Vector2i(output.x - output.y / 2, output.x + output.y / 2 + 1);
+					} else {
+						output = Vector2i(output.x - output.y / 2 + 1, output.x + output.y / 2);
+					}
+				} else {
+					output = Vector2i(output.x - output.y / 2, output.x + output.y / 2);
+				}
+			} else {
+				if (output.y % 2) {
+					if (output.y < 0) {
+						output = Vector2i(output.x + output.y / 2, -output.x + output.y / 2 - 1);
+					} else {
+						output = Vector2i(output.x + output.y / 2 + 1, -output.x + output.y / 2);
+					}
+				} else {
+					output = Vector2i(output.x + output.y / 2, -output.x + output.y / 2);
+				}
+			}
+			break;
 	}
-}
 
-void TileMap::set_tileset(const Ref<TileSet> &p_tileset) {
-	if (tile_set.is_valid()) {
-		tile_set->disconnect("changed", callable_mp(this, &TileMap::_recreate_quadrants));
+	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
+		SWAP(output.x, output.y);
 	}
 
-	_clear_quadrants();
-	tile_set = p_tileset;
+	return output;
+}
 
-	if (tile_set.is_valid()) {
-		tile_set->connect("changed", callable_mp(this, &TileMap::_recreate_quadrants));
+int TileMap::get_effective_quadrant_size() 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()) {
+		return 1;
 	} else {
-		clear();
+		return quadrant_size;
 	}
+}
 
-	_recreate_quadrants();
-	emit_signal("settings_changed");
+Vector2i TileMap::_coords_to_quadrant_coords(const Vector2i &p_coords) const {
+	int quadrant_size = get_effective_quadrant_size();
+
+	// 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);
+}
+
+void TileMap::_notification(int p_what) {
+	switch (p_what) {
+		case NOTIFICATION_ENTER_TREE: {
+			pending_update = true;
+			_recreate_quadrants();
+		} break;
+		case NOTIFICATION_EXIT_TREE: {
+			_clear_quadrants();
+		} 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);
+		}
+	}
 }
 
 Ref<TileSet> TileMap::get_tileset() const {
 	return tile_set;
 }
 
-void TileMap::set_cell_size(Size2 p_size) {
-	ERR_FAIL_COND(p_size.x < 1 || p_size.y < 1);
+void TileMap::set_tileset(const Ref<TileSet> &p_tileset) {
+	if (p_tileset == tile_set) {
+		return;
+	}
 
-	_clear_quadrants();
-	cell_size = p_size;
-	_recreate_quadrants();
-	emit_signal("settings_changed");
+	// 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();
+	}
+
+	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();
+	}
+
+	emit_signal("changed");
 }
 
-Size2 TileMap::get_cell_size() const {
-	return cell_size;
+int TileMap::get_quadrant_size() const {
+	return quadrant_size;
 }
 
 void TileMap::set_quadrant_size(int p_size) {
-	ERR_FAIL_COND_MSG(p_size < 1, "Quadrant size cannot be smaller than 1.");
+	ERR_FAIL_COND_MSG(p_size < 1, "TileMapQuadrant size cannot be smaller than 1.");
 
-	_clear_quadrants();
 	quadrant_size = p_size;
 	_recreate_quadrants();
-	emit_signal("settings_changed");
-}
-
-int TileMap::get_quadrant_size() const {
-	return quadrant_size;
+	emit_signal("changed");
 }
 
-void TileMap::_fix_cell_transform(Transform2D &xform, const Cell &p_cell, const Vector2 &p_offset, const Size2 &p_sc) {
+void TileMap::_fix_cell_transform(Transform2D &xform, const TileMapCell &p_cell, const Vector2 &p_offset, const Size2 &p_sc) {
 	Size2 s = p_sc;
 	Vector2 offset = p_offset;
 
-	if (compatibility_mode && !centered_textures) {
-		if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
-			offset.y += cell_size.y;
-		} else if (tile_origin == TILE_ORIGIN_CENTER) {
-			offset += cell_size / 2;
-		}
-
-		if (s.y > s.x) {
-			if ((p_cell.flip_h && (p_cell.flip_v || p_cell.transpose)) || (p_cell.flip_v && !p_cell.transpose)) {
-				offset.y += s.y - s.x;
-			}
-		} else if (s.y < s.x) {
-			if ((p_cell.flip_v && (p_cell.flip_h || p_cell.transpose)) || (p_cell.flip_h && !p_cell.transpose)) {
-				offset.x += s.x - s.y;
-			}
-		}
+	// Flip/transpose: update the tile transform.
+	TileSetSource *source = *tile_set->get_source(p_cell.source_id);
+	TileSetAtlasSource *atlas_source = Object::cast_to<TileSetAtlasSource>(source);
+	if (!atlas_source) {
+		return;
 	}
-
-	if (p_cell.transpose) {
+	TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(p_cell.get_atlas_coords(), p_cell.alternative_tile));
+	if (tile_data->get_transpose()) {
 		SWAP(xform.elements[0].x, xform.elements[0].y);
 		SWAP(xform.elements[1].x, xform.elements[1].y);
 		SWAP(offset.x, offset.y);
 		SWAP(s.x, s.y);
 	}
 
-	if (p_cell.flip_h) {
+	if (tile_data->get_flip_h()) {
 		xform.elements[0].x = -xform.elements[0].x;
 		xform.elements[1].x = -xform.elements[1].x;
-		if (compatibility_mode && !centered_textures) {
-			if (tile_origin == TILE_ORIGIN_TOP_LEFT || tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
-				offset.x = s.x - offset.x;
-			} else if (tile_origin == TILE_ORIGIN_CENTER) {
-				offset.x = s.x - offset.x / 2;
-			}
-		} else {
-			offset.x = s.x - offset.x;
-		}
+		offset.x = s.x - offset.x;
 	}
 
-	if (p_cell.flip_v) {
+	if (tile_data->get_flip_v()) {
 		xform.elements[0].y = -xform.elements[0].y;
 		xform.elements[1].y = -xform.elements[1].y;
-		if (compatibility_mode && !centered_textures) {
-			if (tile_origin == TILE_ORIGIN_TOP_LEFT) {
-				offset.y = s.y - offset.y;
-			} else if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
-				offset.y += s.y;
-			} else if (tile_origin == TILE_ORIGIN_CENTER) {
-				offset.y += s.y;
-			}
-		} else {
-			offset.y = s.y - offset.y;
-		}
+		offset.y = s.y - offset.y;
 	}
 
-	if (centered_textures) {
-		offset += cell_size / 2 - s / 2;
-	}
 	xform.elements[2] += offset;
 }
 
-void TileMap::_add_shape(int &shape_idx, const Quadrant &p_q, const Ref<Shape2D> &p_shape, const TileSet::ShapeData &p_shape_data, const Transform2D &p_xform, const Vector2 &p_metadata) {
-	PhysicsServer2D *ps = PhysicsServer2D::get_singleton();
-
-	if (!use_parent) {
-		ps->body_add_shape(p_q.body, p_shape->get_rid(), p_xform);
-		ps->body_set_shape_metadata(p_q.body, shape_idx, p_metadata);
-		ps->body_set_shape_as_one_way_collision(p_q.body, shape_idx, p_shape_data.one_way_collision, p_shape_data.one_way_collision_margin);
-
-	} else if (collision_parent) {
-		Transform2D xform = p_xform;
-		xform.set_origin(xform.get_origin() + p_q.pos);
-
-		collision_parent->shape_owner_add_shape(p_q.shape_owner_id, p_shape);
-
-		int real_index = collision_parent->shape_owner_get_shape_index(p_q.shape_owner_id, shape_idx);
-		RID rid = collision_parent->get_rid();
-
-		if (Object::cast_to<Area2D>(collision_parent) != nullptr) {
-			ps->area_set_shape_transform(rid, real_index, get_transform() * xform);
-		} else {
-			ps->body_set_shape_transform(rid, real_index, get_transform() * xform);
-			ps->body_set_shape_metadata(rid, real_index, p_metadata);
-			ps->body_set_shape_as_one_way_collision(rid, real_index, p_shape_data.one_way_collision, p_shape_data.one_way_collision_margin);
-		}
-	}
-	shape_idx++;
-}
-
 void TileMap::update_dirty_quadrants() {
 	if (!pending_update) {
 		return;
@@ -293,387 +356,47 @@ void TileMap::update_dirty_quadrants() {
 		return;
 	}
 
-	RenderingServer *vs = RenderingServer::get_singleton();
-	PhysicsServer2D *ps = PhysicsServer2D::get_singleton();
-	Vector2 tofs = get_cell_draw_offset();
-	Vector2 qofs;
-
-	SceneTree *st = SceneTree::get_singleton();
-	Color debug_collision_color;
-	Color debug_navigation_color;
-
-	bool debug_shapes = st && st->is_debugging_collisions_hint();
-	if (debug_shapes) {
-		debug_collision_color = st->get_debug_collisions_color();
+	// 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;
+		}
 	}
 
-	bool debug_navigation = st && st->is_debugging_navigation_hint();
-	if (debug_navigation) {
-		debug_navigation_color = st->get_debug_navigation_color();
+	// 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);
 	}
 
-	while (dirty_quadrant_list.first()) {
-		Quadrant &q = *dirty_quadrant_list.first()->self();
-
-		for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {
-			vs->free(E->get());
-		}
-
-		q.canvas_items.clear();
-
-		if (!use_parent) {
-			ps->body_clear_shapes(q.body);
-		} else if (collision_parent) {
-			collision_parent->shape_owner_clear_shapes(q.shape_owner_id);
-		}
-		int shape_idx = 0;
-
-		for (Map<PosKey, Quadrant::NavPoly>::Element *E = q.navpoly_ids.front(); E; E = E->next()) {
-			NavigationServer2D::get_singleton()->region_set_map(E->get().region, RID());
-		}
-		q.navpoly_ids.clear();
-
-		for (Map<PosKey, Quadrant::Occluder>::Element *E = q.occluder_instances.front(); E; E = E->next()) {
-			RS::get_singleton()->free(E->get().id);
-		}
-		q.occluder_instances.clear();
-		Ref<ShaderMaterial> prev_material;
-		int prev_z_index = 0;
-		RID prev_canvas_item;
-		RID prev_debug_canvas_item;
-
-		for (int i = 0; i < q.cells.size(); i++) {
-			Map<PosKey, Cell>::Element *E = tile_map.find(q.cells[i]);
-			Cell &c = E->get();
-			//moment of truth
-			if (!tile_set->has_tile(c.id)) {
-				continue;
-			}
-			Ref<Texture2D> tex = tile_set->tile_get_texture(c.id);
-			Vector2 tile_ofs = tile_set->tile_get_texture_offset(c.id);
-
-			Vector2 wofs = _map_to_world(E->key().x, E->key().y);
-			Vector2 offset = wofs - q.pos + tofs;
-
-			if (!tex.is_valid()) {
-				continue;
-			}
-
-			Ref<ShaderMaterial> mat = tile_set->tile_get_material(c.id);
-			int z_index = tile_set->tile_get_z_index(c.id);
-
-			if (tile_set->tile_get_tile_mode(c.id) == TileSet::AUTO_TILE ||
-					tile_set->tile_get_tile_mode(c.id) == TileSet::ATLAS_TILE) {
-				z_index += tile_set->autotile_get_z_index(c.id, Vector2(c.autotile_coord_x, c.autotile_coord_y));
-			}
-
-			RID canvas_item;
-			RID debug_canvas_item;
-
-			if (prev_canvas_item == RID() || prev_material != mat || prev_z_index != z_index) {
-				canvas_item = vs->canvas_item_create();
-				if (mat.is_valid()) {
-					vs->canvas_item_set_material(canvas_item, mat->get_rid());
-				}
-				vs->canvas_item_set_parent(canvas_item, get_canvas_item());
-				_update_item_material_state(canvas_item);
-				Transform2D xform;
-				xform.set_origin(q.pos);
-				vs->canvas_item_set_transform(canvas_item, xform);
-				vs->canvas_item_set_light_mask(canvas_item, get_light_mask());
-				vs->canvas_item_set_z_index(canvas_item, z_index);
-
-				vs->canvas_item_set_default_texture_filter(canvas_item, RS::CanvasItemTextureFilter(CanvasItem::get_texture_filter()));
-				vs->canvas_item_set_default_texture_repeat(canvas_item, RS::CanvasItemTextureRepeat(CanvasItem::get_texture_repeat()));
-
-				q.canvas_items.push_back(canvas_item);
-
-				if (debug_shapes) {
-					debug_canvas_item = vs->canvas_item_create();
-					vs->canvas_item_set_parent(debug_canvas_item, canvas_item);
-					vs->canvas_item_set_z_as_relative_to_parent(debug_canvas_item, false);
-					vs->canvas_item_set_z_index(debug_canvas_item, RS::CANVAS_ITEM_Z_MAX - 1);
-					q.canvas_items.push_back(debug_canvas_item);
-					prev_debug_canvas_item = debug_canvas_item;
-				}
-
-				prev_canvas_item = canvas_item;
-				prev_material = mat;
-				prev_z_index = z_index;
-
-			} else {
-				canvas_item = prev_canvas_item;
-				if (debug_shapes) {
-					debug_canvas_item = prev_debug_canvas_item;
-				}
-			}
-
-			Rect2 r = tile_set->tile_get_region(c.id);
-			if (tile_set->tile_get_tile_mode(c.id) == TileSet::AUTO_TILE || tile_set->tile_get_tile_mode(c.id) == TileSet::ATLAS_TILE) {
-				int spacing = tile_set->autotile_get_spacing(c.id);
-				r.size = tile_set->autotile_get_size(c.id);
-				r.position += (r.size + Vector2(spacing, spacing)) * Vector2(c.autotile_coord_x, c.autotile_coord_y);
-			}
-
-			Size2 s;
-			if (r == Rect2()) {
-				s = tex->get_size();
-			} else {
-				s = r.size;
-			}
-
-			Rect2 rect;
-			rect.position = offset.floor();
-			rect.size = s;
-			rect.size.x += fp_adjust;
-			rect.size.y += fp_adjust;
-
-			if (compatibility_mode && !centered_textures) {
-				if (rect.size.y > rect.size.x) {
-					if ((c.flip_h && (c.flip_v || c.transpose)) || (c.flip_v && !c.transpose)) {
-						tile_ofs.y += rect.size.y - rect.size.x;
-					}
-				} else if (rect.size.y < rect.size.x) {
-					if ((c.flip_v && (c.flip_h || c.transpose)) || (c.flip_h && !c.transpose)) {
-						tile_ofs.x += rect.size.x - rect.size.y;
-					}
-				}
-			}
-
-			if (c.transpose) {
-				SWAP(tile_ofs.x, tile_ofs.y);
-				if (centered_textures) {
-					rect.position.x += cell_size.x / 2 - rect.size.y / 2;
-					rect.position.y += cell_size.y / 2 - rect.size.x / 2;
-				}
-			} else if (centered_textures) {
-				rect.position += cell_size / 2 - rect.size / 2;
-			}
-
-			if (c.flip_h) {
-				rect.size.x = -rect.size.x;
-				tile_ofs.x = -tile_ofs.x;
-			}
-
-			if (c.flip_v) {
-				rect.size.y = -rect.size.y;
-				tile_ofs.y = -tile_ofs.y;
-			}
-
-			if (compatibility_mode && !centered_textures) {
-				if (tile_origin == TILE_ORIGIN_TOP_LEFT) {
-					rect.position += tile_ofs;
-
-				} else if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
-					rect.position += tile_ofs;
-
-					if (c.transpose) {
-						if (c.flip_h) {
-							rect.position.x -= cell_size.x;
-						} else {
-							rect.position.x += cell_size.x;
-						}
-					} else {
-						if (c.flip_v) {
-							rect.position.y -= cell_size.y;
-						} else {
-							rect.position.y += cell_size.y;
-						}
-					}
-
-				} else if (tile_origin == TILE_ORIGIN_CENTER) {
-					rect.position += tile_ofs;
-
-					if (c.flip_h) {
-						rect.position.x -= cell_size.x / 2;
-					} else {
-						rect.position.x += cell_size.x / 2;
-					}
-
-					if (c.flip_v) {
-						rect.position.y -= cell_size.y / 2;
-					} else {
-						rect.position.y += cell_size.y / 2;
-					}
-				}
-			} else {
-				rect.position += tile_ofs;
-			}
-
-			Color modulate = tile_set->tile_get_modulate(c.id);
-			Color self_modulate = get_self_modulate();
-			modulate = Color(modulate.r * self_modulate.r, modulate.g * self_modulate.g,
-					modulate.b * self_modulate.b, modulate.a * self_modulate.a);
-			if (r == Rect2()) {
-				tex->draw_rect(canvas_item, rect, false, modulate, c.transpose);
-			} else {
-				tex->draw_rect_region(canvas_item, rect, r, modulate, c.transpose, clip_uv);
-			}
-
-			Vector<TileSet::ShapeData> shapes = tile_set->tile_get_shapes(c.id);
-
-			for (int j = 0; j < shapes.size(); j++) {
-				Ref<Shape2D> shape = shapes[j].shape;
-				if (shape.is_valid()) {
-					if (tile_set->tile_get_tile_mode(c.id) == TileSet::SINGLE_TILE || (shapes[j].autotile_coord.x == c.autotile_coord_x && shapes[j].autotile_coord.y == c.autotile_coord_y)) {
-						Transform2D xform;
-						xform.set_origin(offset.floor());
-
-						Vector2 shape_ofs = shapes[j].shape_transform.get_origin();
-
-						_fix_cell_transform(xform, c, shape_ofs, s);
-
-						xform *= shapes[j].shape_transform.untranslated();
-
-						if (debug_canvas_item.is_valid()) {
-							vs->canvas_item_add_set_transform(debug_canvas_item, xform);
-							shape->draw(debug_canvas_item, debug_collision_color);
-						}
-
-						if (shape->has_meta("decomposed")) {
-							Array _shapes = shape->get_meta("decomposed");
-							for (int k = 0; k < _shapes.size(); k++) {
-								Ref<ConvexPolygonShape2D> convex = _shapes[k];
-								if (convex.is_valid()) {
-									_add_shape(shape_idx, q, convex, shapes[j], xform, Vector2(E->key().x, E->key().y));
-#ifdef DEBUG_ENABLED
-								} else {
-									print_error("The TileSet assigned to the TileMap " + get_name() + " has an invalid convex shape.");
-#endif
-								}
-							}
-						} else {
-							_add_shape(shape_idx, q, shape, shapes[j], xform, Vector2(E->key().x, E->key().y));
-						}
-					}
-				}
-			}
-
-			if (debug_canvas_item.is_valid()) {
-				vs->canvas_item_add_set_transform(debug_canvas_item, Transform2D());
-			}
-
-			if (bake_navigation) {
-				Ref<NavigationPolygon> navpoly;
-				Vector2 npoly_ofs;
-				if (tile_set->tile_get_tile_mode(c.id) == TileSet::AUTO_TILE || tile_set->tile_get_tile_mode(c.id) == TileSet::ATLAS_TILE) {
-					navpoly = tile_set->autotile_get_navigation_polygon(c.id, Vector2(c.autotile_coord_x, c.autotile_coord_y));
-					npoly_ofs = Vector2();
-				} else {
-					navpoly = tile_set->tile_get_navigation_polygon(c.id);
-					npoly_ofs = tile_set->tile_get_navigation_polygon_offset(c.id);
-				}
-
-				if (navpoly.is_valid()) {
-					Transform2D xform;
-					xform.set_origin(offset.floor() + q.pos);
-					_fix_cell_transform(xform, c, npoly_ofs, s);
-
-					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, xform);
-					NavigationServer2D::get_singleton()->region_set_navpoly(region, navpoly);
-
-					Quadrant::NavPoly np;
-					np.region = region;
-					np.xform = xform;
-					q.navpoly_ids[E->key()] = np;
-
-					if (debug_navigation) {
-						RID debug_navigation_item = vs->canvas_item_create();
-						vs->canvas_item_set_parent(debug_navigation_item, canvas_item);
-						vs->canvas_item_set_z_as_relative_to_parent(debug_navigation_item, false);
-						vs->canvas_item_set_z_index(debug_navigation_item, RS::CANVAS_ITEM_Z_MAX - 2); // Display one below collision debug
-
-						if (debug_navigation_item.is_valid()) {
-							Vector<Vector2> navigation_polygon_vertices = navpoly->get_vertices();
-							int vsize = navigation_polygon_vertices.size();
-
-							if (vsize > 2) {
-								Vector<Color> colors;
-								Vector<Vector2> vertices;
-								vertices.resize(vsize);
-								colors.resize(vsize);
-								{
-									const Vector2 *vr = navigation_polygon_vertices.ptr();
-									for (int j = 0; j < vsize; j++) {
-										vertices.write[j] = vr[j];
-										colors.write[j] = debug_navigation_color;
-									}
-								}
-
-								Vector<int> indices;
-
-								for (int j = 0; j < navpoly->get_polygon_count(); j++) {
-									Vector<int> polygon = navpoly->get_polygon(j);
-
-									for (int k = 2; k < polygon.size(); k++) {
-										int kofs[3] = { 0, k - 1, k };
-										for (int l = 0; l < 3; l++) {
-											int idx = polygon[kofs[l]];
-											ERR_FAIL_INDEX(idx, vsize);
-											indices.push_back(idx);
-										}
-									}
-								}
-								Transform2D navxform;
-								navxform.set_origin(offset.floor());
-								_fix_cell_transform(navxform, c, npoly_ofs, s);
-
-								vs->canvas_item_set_transform(debug_navigation_item, navxform);
-								vs->canvas_item_add_triangle_array(debug_navigation_item, indices, vertices, colors);
-							}
-						}
-					}
-				}
-			}
-
-			Ref<OccluderPolygon2D> occluder;
-			if (tile_set->tile_get_tile_mode(c.id) == TileSet::AUTO_TILE || tile_set->tile_get_tile_mode(c.id) == TileSet::ATLAS_TILE) {
-				occluder = tile_set->autotile_get_light_occluder(c.id, Vector2(c.autotile_coord_x, c.autotile_coord_y));
-			} else {
-				occluder = tile_set->tile_get_light_occluder(c.id);
-			}
-			if (occluder.is_valid()) {
-				Vector2 occluder_ofs = tile_set->tile_get_occluder_offset(c.id);
-				Transform2D xform;
-				xform.set_origin(offset.floor() + q.pos);
-				_fix_cell_transform(xform, c, occluder_ofs, s);
-
-				RID orid = RS::get_singleton()->canvas_light_occluder_create();
-				RS::get_singleton()->canvas_light_occluder_set_transform(orid, get_global_transform() * xform);
-				RS::get_singleton()->canvas_light_occluder_set_polygon(orid, occluder->get_rid());
-				RS::get_singleton()->canvas_light_occluder_attach_to_canvas(orid, get_canvas());
-				RS::get_singleton()->canvas_light_occluder_set_light_mask(orid, occluder_light_mask);
-				Quadrant::Occluder oc;
-				oc.xform = xform;
-				oc.id = orid;
-				q.occluder_instances[E->key()] = oc;
-			}
+	// 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());
 		}
+	}
 
+	// Clear the list
+	while (dirty_quadrant_list.first()) {
 		dirty_quadrant_list.remove(dirty_quadrant_list.first());
-		quadrant_order_dirty = true;
 	}
 
 	pending_update = false;
 
-	if (quadrant_order_dirty) {
-		int index = -(int64_t)0x80000000; //always must be drawn below children
-		for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-			Quadrant &q = E->get();
-			for (List<RID>::Element *F = q.canvas_items.front(); F; F = F->next()) {
-				RS::get_singleton()->canvas_item_set_draw_index(F->get(), index++);
-			}
-		}
-
-		quadrant_order_dirty = false;
-	}
-
 	_recompute_rect_cache();
 }
 
 void TileMap::_recompute_rect_cache() {
+	// Compute the displayed area of the tilemap.
 #ifdef DEBUG_ENABLED
 
 	if (!rect_cache_dirty) {
@@ -681,12 +404,12 @@ void TileMap::_recompute_rect_cache() {
 	}
 
 	Rect2 r_total;
-	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
+	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
 		Rect2 r;
-		r.position = _map_to_world(E->key().x * _get_quadrant_size(), E->key().y * _get_quadrant_size());
-		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size() + _get_quadrant_size(), E->key().y * _get_quadrant_size()));
-		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size() + _get_quadrant_size(), E->key().y * _get_quadrant_size() + _get_quadrant_size()));
-		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size(), E->key().y * _get_quadrant_size() + _get_quadrant_size()));
+		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 {
@@ -702,83 +425,58 @@ void TileMap::_recompute_rect_cache() {
 #endif
 }
 
-Map<TileMap::PosKey, TileMap::Quadrant>::Element *TileMap::_create_quadrant(const PosKey &p_qk) {
-	Transform2D xform;
-	//xform.set_origin(Point2(p_qk.x,p_qk.y)*cell_size*quadrant_size);
-	Quadrant q;
-	q.pos = _map_to_world(p_qk.x * _get_quadrant_size(), p_qk.y * _get_quadrant_size());
-	q.pos += get_cell_draw_offset();
-	if (tile_origin == TILE_ORIGIN_CENTER) {
-		q.pos += cell_size / 2;
-	} else if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
-		q.pos.y += cell_size.y;
-	}
-
-	xform.set_origin(q.pos);
-	//q.canvas_item = RenderingServer::get_singleton()->canvas_item_create();
-	if (!use_parent) {
-		q.body = PhysicsServer2D::get_singleton()->body_create();
-		PhysicsServer2D::get_singleton()->body_set_mode(q.body, use_kinematic ? PhysicsServer2D::BODY_MODE_KINEMATIC : PhysicsServer2D::BODY_MODE_STATIC);
-
-		PhysicsServer2D::get_singleton()->body_attach_object_instance_id(q.body, get_instance_id());
-		PhysicsServer2D::get_singleton()->body_set_collision_layer(q.body, collision_layer);
-		PhysicsServer2D::get_singleton()->body_set_collision_mask(q.body, collision_mask);
-		PhysicsServer2D::get_singleton()->body_set_param(q.body, PhysicsServer2D::BODY_PARAM_FRICTION, friction);
-		PhysicsServer2D::get_singleton()->body_set_param(q.body, PhysicsServer2D::BODY_PARAM_BOUNCE, bounce);
-
-		if (is_inside_tree()) {
-			xform = get_global_transform() * xform;
-			RID space = get_world_2d()->get_space();
-			PhysicsServer2D::get_singleton()->body_set_space(q.body, space);
-		}
+Map<Vector2i, TileMapQuadrant>::Element *TileMap::_create_quadrant(const Vector2i &p_qk) {
+	TileMapQuadrant q;
+	q.coords = p_qk;
 
-		PhysicsServer2D::get_singleton()->body_set_state(q.body, PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
-	} else if (collision_parent) {
-		xform = get_transform() * xform;
-		q.shape_owner_id = collision_parent->create_shape_owner(this);
-	} else {
-		q.shape_owner_id = -1;
+	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()) {
+		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);
+		}
 	}
 
-	rect_cache_dirty = true;
-	quadrant_order_dirty = true;
 	return quadrant_map.insert(p_qk, q);
 }
 
-void TileMap::_erase_quadrant(Map<PosKey, Quadrant>::Element *Q) {
-	Quadrant &q = Q->get();
-	if (!use_parent) {
-		PhysicsServer2D::get_singleton()->free(q.body);
-	} else if (collision_parent) {
-		collision_parent->remove_shape_owner(q.shape_owner_id);
-	}
+void TileMap::_erase_quadrant(Map<Vector2i, TileMapQuadrant>::Element *Q) {
+	// Remove a quadrant.
+	TileMapQuadrant *q = &(Q->get());
 
-	for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {
-		RenderingServer::get_singleton()->free(E->get());
-	}
-	q.canvas_items.clear();
-	if (q.dirty_list.in_list()) {
-		dirty_quadrant_list.remove(&q.dirty_list);
+	// 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);
+		}
 	}
 
-	for (Map<PosKey, Quadrant::NavPoly>::Element *E = q.navpoly_ids.front(); E; E = E->next()) {
-		NavigationServer2D::get_singleton()->region_set_map(E->get().region, RID());
+	// 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));
 	}
-	q.navpoly_ids.clear();
 
-	for (Map<PosKey, Quadrant::Occluder>::Element *E = q.occluder_instances.front(); E; E = E->next()) {
-		RS::get_singleton()->free(E->get().id);
-	}
-	q.occluder_instances.clear();
+	// Free the debug canvas item.
+	RenderingServer *rs = RenderingServer::get_singleton();
+	rs->free(q->debug_canvas_item);
 
 	quadrant_map.erase(Q);
 	rect_cache_dirty = true;
 }
 
-void TileMap::_make_quadrant_dirty(Map<PosKey, Quadrant>::Element *Q, bool update) {
-	Quadrant &q = Q->get();
-	if (!q.dirty_list.in_list()) {
-		dirty_quadrant_list.add(&q.dirty_list);
+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);
+		}
 	}
 
 	if (pending_update) {
@@ -788,39 +486,68 @@ void TileMap::_make_quadrant_dirty(Map<PosKey, Quadrant>::Element *Q, bool updat
 	if (!is_inside_tree()) {
 		return;
 	}
-
-	if (update) {
+	if (p_update) {
 		call_deferred("update_dirty_quadrants");
 	}
 }
 
-void TileMap::set_cellv(const Vector2 &p_pos, int p_tile, bool p_flip_x, bool p_flip_y, bool p_transpose) {
-	set_cell(p_pos.x, p_pos.y, p_tile, p_flip_x, p_flip_y, p_transpose);
-}
+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);
+	}
+
+	if (pending_update) {
+		return;
+	}
+	pending_update = true;
+	if (!is_inside_tree()) {
+		return;
+	}
 
-void TileMap::_set_celld(const Vector2 &p_pos, const Dictionary &p_data) {
-	Variant v_pos_x = p_pos.x, v_pos_y = p_pos.y, v_tile = p_data["id"], v_flip_h = p_data["flip_h"], v_flip_v = p_data["flip_y"], v_transpose = p_data["transpose"], v_autotile_coord = p_data["auto_coord"];
-	const Variant *args[7] = { &v_pos_x, &v_pos_y, &v_tile, &v_flip_h, &v_flip_v, &v_transpose, &v_autotile_coord };
-	Callable::CallError ce;
-	call("set_cell", args, 7, ce);
+	if (p_update) {
+		call_deferred("update_dirty_quadrants");
+	}
 }
 
-void TileMap::set_cell(int p_x, int p_y, int p_tile, bool p_flip_x, bool p_flip_y, bool p_transpose, Vector2 p_autotile_coord) {
-	PosKey pk(p_x, p_y);
+void TileMap::set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile) {
+	// Set the current cell tile (using integer position).
+	Vector2i pk(p_coords);
+	Map<Vector2i, TileMapCell>::Element *E = tile_map.find(pk);
+
+	int source_id = p_source_id;
+	Vector2i atlas_coords = p_atlas_coords;
+	int alternative_tile = p_alternative_tile;
+
+	if ((source_id == -1 || atlas_coords == TileSetAtlasSource::INVALID_ATLAS_COORDS || alternative_tile == TileSetAtlasSource::INVALID_TILE_ALTERNATIVE) &&
+			(source_id != -1 || atlas_coords != TileSetAtlasSource::INVALID_ATLAS_COORDS || alternative_tile != TileSetAtlasSource::INVALID_TILE_ALTERNATIVE)) {
+		WARN_PRINT("Setting a cell a cell as empty requires both source_id, atlas_coord and alternative_tile to be set to their respective \"invalid\" values. Values were thus changes accordingly.");
+		source_id = -1;
+		atlas_coords = TileSetAtlasSource::INVALID_ATLAS_COORDS;
+		alternative_tile = TileSetAtlasSource::INVALID_TILE_ALTERNATIVE;
+	}
 
-	Map<PosKey, Cell>::Element *E = tile_map.find(pk);
-	if (!E && p_tile == INVALID_CELL) {
-		return; //nothing to do
+	if (!E && source_id == -1) {
+		return; // Nothing to do, the tile is already empty.
 	}
 
-	PosKey qk = pk.to_quadrant(_get_quadrant_size());
-	if (p_tile == INVALID_CELL) {
-		//erase existing
+	// Get the quadrant
+	Vector2i qk = _coords_to_quadrant_coords(pk);
+
+	Map<Vector2i, TileMapQuadrant>::Element *Q = quadrant_map.find(qk);
+
+	if (source_id == -1) {
+		// Erase existing cell in the tile map.
 		tile_map.erase(pk);
-		Map<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);
+
+		// Erase existing cell in the quadrant.
 		ERR_FAIL_COND(!Q);
-		Quadrant &q = Q->get();
+		TileMapQuadrant &q = Q->get();
+
 		q.cells.erase(pk);
+
+		// Remove or make the quadrant dirty.
 		if (q.cells.size() == 0) {
 			_erase_quadrant(Q);
 		} else {
@@ -828,331 +555,232 @@ void TileMap::set_cell(int p_x, int p_y, int p_tile, bool p_flip_x, bool p_flip_
 		}
 
 		used_size_cache_dirty = true;
-		return;
-	}
-
-	Map<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);
-
-	if (!E) {
-		E = tile_map.insert(pk, Cell());
-		if (!Q) {
-			Q = _create_quadrant(qk);
-		}
-		Quadrant &q = Q->get();
-		q.cells.insert(pk);
 	} else {
-		ERR_FAIL_COND(!Q); // quadrant should exist...
-
-		if (E->get().id == p_tile && E->get().flip_h == p_flip_x && E->get().flip_v == p_flip_y && E->get().transpose == p_transpose && E->get().autotile_coord_x == (uint16_t)p_autotile_coord.x && E->get().autotile_coord_y == (uint16_t)p_autotile_coord.y) {
-			return; //nothing changed
-		}
-	}
-
-	Cell &c = E->get();
-
-	c.id = p_tile;
-	c.flip_h = p_flip_x;
-	c.flip_v = p_flip_y;
-	c.transpose = p_transpose;
-	c.autotile_coord_x = (uint16_t)p_autotile_coord.x;
-	c.autotile_coord_y = (uint16_t)p_autotile_coord.y;
-
-	_make_quadrant_dirty(Q);
-	used_size_cache_dirty = true;
-}
+		if (!E) {
+			// Insert a new cell in the tile map.
+			E = tile_map.insert(pk, TileMapCell());
 
-int TileMap::get_cellv(const Vector2 &p_pos) const {
-	return get_cell(p_pos.x, p_pos.y);
-}
-
-void TileMap::make_bitmask_area_dirty(const Vector2 &p_pos) {
-	for (int x = p_pos.x - 1; x <= p_pos.x + 1; x++) {
-		for (int y = p_pos.y - 1; y <= p_pos.y + 1; y++) {
-			PosKey p(x, y);
-			if (dirty_bitmask.find(p) == nullptr) {
-				dirty_bitmask.push_back(p);
-			}
-		}
-	}
-}
-
-void TileMap::update_bitmask_area(const Vector2 &p_pos) {
-	for (int x = p_pos.x - 1; x <= p_pos.x + 1; x++) {
-		for (int y = p_pos.y - 1; y <= p_pos.y + 1; y++) {
-			update_cell_bitmask(x, y);
-		}
-	}
-}
-
-void TileMap::update_bitmask_region(const Vector2 &p_start, const Vector2 &p_end) {
-	if ((p_end.x < p_start.x || p_end.y < p_start.y) || (p_end.x == p_start.x && p_end.y == p_start.y)) {
-		Array a = get_used_cells();
-		for (int i = 0; i < a.size(); i++) {
-			Vector2 vector = (Vector2)a[i];
-			update_cell_bitmask(vector.x, vector.y);
-		}
-		return;
-	}
-	for (int x = p_start.x - 1; x <= p_end.x + 1; x++) {
-		for (int y = p_start.y - 1; y <= p_end.y + 1; y++) {
-			update_cell_bitmask(x, y);
-		}
-	}
-}
-
-void TileMap::update_cell_bitmask(int p_x, int p_y) {
-	ERR_FAIL_COND_MSG(tile_set.is_null(), "Cannot update cell bitmask if Tileset is not open.");
-	PosKey p(p_x, p_y);
-	Map<PosKey, Cell>::Element *E = tile_map.find(p);
-	if (E != nullptr) {
-		int id = get_cell(p_x, p_y);
-		if (tile_set->tile_get_tile_mode(id) == TileSet::AUTO_TILE) {
-			uint16_t mask = 0;
-			if (tile_set->autotile_get_bitmask_mode(id) == TileSet::BITMASK_2X2) {
-				if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) {
-					mask |= TileSet::BIND_TOPLEFT;
-				}
-				if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) {
-					mask |= TileSet::BIND_TOPRIGHT;
-				}
-				if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) {
-					mask |= TileSet::BIND_BOTTOMLEFT;
-				}
-				if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) {
-					mask |= TileSet::BIND_BOTTOMRIGHT;
-				}
-			} else {
-				if (tile_set->autotile_get_bitmask_mode(id) == TileSet::BITMASK_3X3_MINIMAL) {
-					if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) {
-						mask |= TileSet::BIND_TOPLEFT;
-					}
-					if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) {
-						mask |= TileSet::BIND_TOPRIGHT;
-					}
-					if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) {
-						mask |= TileSet::BIND_BOTTOMLEFT;
-					}
-					if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1)) && tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) {
-						mask |= TileSet::BIND_BOTTOMRIGHT;
-					}
-				} else {
-					if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y - 1))) {
-						mask |= TileSet::BIND_TOPLEFT;
-					}
-					if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y - 1))) {
-						mask |= TileSet::BIND_TOPRIGHT;
-					}
-					if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y + 1))) {
-						mask |= TileSet::BIND_BOTTOMLEFT;
-					}
-					if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y + 1))) {
-						mask |= TileSet::BIND_BOTTOMRIGHT;
-					}
-				}
-				if (tile_set->is_tile_bound(id, get_cell(p_x, p_y - 1))) {
-					mask |= TileSet::BIND_TOP;
-				}
-				if (tile_set->is_tile_bound(id, get_cell(p_x - 1, p_y))) {
-					mask |= TileSet::BIND_LEFT;
-				}
-				mask |= TileSet::BIND_CENTER;
-				if (tile_set->is_tile_bound(id, get_cell(p_x + 1, p_y))) {
-					mask |= TileSet::BIND_RIGHT;
-				}
-				if (tile_set->is_tile_bound(id, get_cell(p_x, p_y + 1))) {
-					mask |= TileSet::BIND_BOTTOM;
-				}
+			// Create a new quadrant if needed, then insert the cell if needed.
+			if (!Q) {
+				Q = _create_quadrant(qk);
 			}
-			Vector2 coord = tile_set->autotile_get_subtile_for_bitmask(id, mask, this, Vector2(p_x, p_y));
-			E->get().autotile_coord_x = (int)coord.x;
-			E->get().autotile_coord_y = (int)coord.y;
-
-			PosKey qk = p.to_quadrant(_get_quadrant_size());
-			Map<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);
-			_make_quadrant_dirty(Q);
+			TileMapQuadrant &q = Q->get();
+			q.cells.insert(pk);
 
-		} else if (tile_set->tile_get_tile_mode(id) == TileSet::SINGLE_TILE) {
-			E->get().autotile_coord_x = 0;
-			E->get().autotile_coord_y = 0;
-		} else if (tile_set->tile_get_tile_mode(id) == TileSet::ATLAS_TILE) {
-			if (tile_set->autotile_get_bitmask(id, Vector2(p_x, p_y)) == TileSet::BIND_CENTER) {
-				Vector2 coord = tile_set->atlastile_get_subtile_by_priority(id, this, Vector2(p_x, p_y));
+		} else {
+			ERR_FAIL_COND(!Q); // TileMapQuadrant should exist...
 
-				E->get().autotile_coord_x = (int)coord.x;
-				E->get().autotile_coord_y = (int)coord.y;
+			if (E->get().source_id == source_id && E->get().get_atlas_coords() == atlas_coords && E->get().alternative_tile == alternative_tile) {
+				return; // Nothing changed.
 			}
 		}
-	}
-}
 
-void TileMap::update_dirty_bitmask() {
-	while (dirty_bitmask.size() > 0) {
-		update_cell_bitmask(dirty_bitmask[0].x, dirty_bitmask[0].y);
-		dirty_bitmask.pop_front();
-	}
-}
+		TileMapCell &c = E->get();
 
-void TileMap::fix_invalid_tiles() {
-	ERR_FAIL_COND_MSG(tile_set.is_null(), "Cannot fix invalid tiles if Tileset is not open.");
+		c.source_id = source_id;
+		c.set_atlas_coords(atlas_coords);
+		c.alternative_tile = alternative_tile;
 
-	Map<PosKey, Cell> temp_tile_map = tile_map;
-	for (Map<PosKey, Cell>::Element *E = temp_tile_map.front(); E; E = E->next()) {
-		if (!tile_set->has_tile(get_cell(E->key().x, E->key().y))) {
-			set_cell(E->key().x, E->key().y, INVALID_CELL);
-		}
+		_make_quadrant_dirty(Q);
+		used_size_cache_dirty = true;
 	}
 }
 
-int TileMap::get_cell(int p_x, int p_y) const {
-	PosKey pk(p_x, p_y);
-
-	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);
+int TileMap::get_cell_source_id(const Vector2i &p_coords) const {
+	// Get a cell source id from position
+	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
 
 	if (!E) {
-		return INVALID_CELL;
+		return -1;
 	}
 
-	return E->get().id;
+	return E->get().source_id;
 }
 
-bool TileMap::is_cell_x_flipped(int p_x, int p_y) const {
-	PosKey pk(p_x, p_y);
-
-	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);
+Vector2i TileMap::get_cell_atlas_coords(const Vector2i &p_coords) const {
+	// Get a cell source id from position
+	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
 
 	if (!E) {
-		return false;
+		return TileSetAtlasSource::INVALID_ATLAS_COORDS;
 	}
 
-	return E->get().flip_h;
+	return E->get().get_atlas_coords();
 }
 
-bool TileMap::is_cell_y_flipped(int p_x, int p_y) const {
-	PosKey pk(p_x, p_y);
-
-	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);
+int TileMap::get_cell_alternative_tile(const Vector2i &p_coords) const {
+	// Get a cell source id from position
+	const Map<Vector2i, TileMapCell>::Element *E = tile_map.find(p_coords);
 
 	if (!E) {
-		return false;
+		return TileSetAtlasSource::INVALID_TILE_ALTERNATIVE;
 	}
 
-	return E->get().flip_v;
+	return E->get().alternative_tile;
 }
 
-bool TileMap::is_cell_transposed(int p_x, int p_y) const {
-	PosKey pk(p_x, p_y);
+TileMapPattern *TileMap::get_pattern(TypedArray<Vector2i> p_coords_array) {
+	ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr);
 
-	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);
-
-	if (!E) {
-		return false;
+	TileMapPattern *output = memnew(TileMapPattern);
+	if (p_coords_array.is_empty()) {
+		return output;
 	}
 
-	return E->get().transpose;
-}
-
-void TileMap::set_cell_autotile_coord(int p_x, int p_y, const Vector2 &p_coord) {
-	PosKey pk(p_x, p_y);
+	Vector2i min = Vector2i(p_coords_array[0]);
+	for (int i = 1; i < p_coords_array.size(); i++) {
+		min = min.min(p_coords_array[i]);
+	}
 
-	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);
+	Vector<Vector2i> coords_in_pattern_array;
+	coords_in_pattern_array.resize(p_coords_array.size());
+	Vector2i ensure_positive_offset;
+	for (int i = 0; i < p_coords_array.size(); i++) {
+		Vector2i coords = p_coords_array[i];
+		Vector2i coords_in_pattern = coords - min;
+		if (tile_set->get_tile_shape() != TileSet::TILE_SHAPE_SQUARE) {
+			if (tile_set->get_tile_layout() == TileSet::TILE_LAYOUT_STACKED) {
+				if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL && bool(min.y % 2) && bool(coords_in_pattern.y % 2)) {
+					coords_in_pattern.x -= 1;
+					if (coords_in_pattern.x < 0) {
+						ensure_positive_offset.x = 1;
+					}
+				} else if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL && bool(min.x % 2) && bool(coords_in_pattern.x % 2)) {
+					coords_in_pattern.y -= 1;
+					if (coords_in_pattern.y < 0) {
+						ensure_positive_offset.y = 1;
+					}
+				}
+			} else if (tile_set->get_tile_layout() == TileSet::TILE_LAYOUT_STACKED_OFFSET) {
+				if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL && bool(min.y % 2) && bool(coords_in_pattern.y % 2)) {
+					coords_in_pattern.x += 1;
+				} else if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL && bool(min.x % 2) && bool(coords_in_pattern.x % 2)) {
+					coords_in_pattern.y += 1;
+				}
+			}
+		}
+		coords_in_pattern_array.write[i] = coords_in_pattern;
+	}
 
-	if (!E) {
-		return;
+	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));
 	}
 
-	Cell c = E->get();
-	c.autotile_coord_x = p_coord.x;
-	c.autotile_coord_y = p_coord.y;
-	tile_map[pk] = c;
+	return output;
+}
 
-	PosKey qk = pk.to_quadrant(_get_quadrant_size());
-	Map<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);
+Vector2i TileMap::map_pattern(Vector2i p_position_in_tilemap, Vector2i p_coords_in_pattern, const TileMapPattern *p_pattern) {
+	ERR_FAIL_COND_V(!p_pattern->has_cell(p_coords_in_pattern), Vector2i());
 
-	if (!Q) {
-		return;
+	Vector2i output = p_position_in_tilemap + p_coords_in_pattern;
+	if (tile_set->get_tile_shape() != TileSet::TILE_SHAPE_SQUARE) {
+		if (tile_set->get_tile_layout() == TileSet::TILE_LAYOUT_STACKED) {
+			if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL && bool(p_position_in_tilemap.y % 2) && bool(p_coords_in_pattern.y % 2)) {
+				output.x += 1;
+			} else if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL && bool(p_position_in_tilemap.x % 2) && bool(p_coords_in_pattern.x % 2)) {
+				output.y += 1;
+			}
+		} else if (tile_set->get_tile_layout() == TileSet::TILE_LAYOUT_STACKED_OFFSET) {
+			if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL && bool(p_position_in_tilemap.y % 2) && bool(p_coords_in_pattern.y % 2)) {
+				output.x -= 1;
+			} else if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL && bool(p_position_in_tilemap.x % 2) && bool(p_coords_in_pattern.x % 2)) {
+				output.y -= 1;
+			}
+		}
 	}
 
-	_make_quadrant_dirty(Q);
+	return output;
 }
 
-Vector2 TileMap::get_cell_autotile_coord(int p_x, int p_y) const {
-	PosKey pk(p_x, p_y);
+void TileMap::set_pattern(Vector2i p_position, const TileMapPattern *p_pattern) {
+	ERR_FAIL_COND(!tile_set.is_valid());
 
-	const Map<PosKey, Cell>::Element *E = tile_map.find(pk);
+	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));
+	}
+}
 
-	if (!E) {
-		return Vector2();
+TileMapCell TileMap::get_cell(const Vector2i &p_coords) const {
+	if (!tile_map.has(p_coords)) {
+		return TileMapCell();
+	} else {
+		return tile_map.find(p_coords)->get();
 	}
+}
 
-	return Vector2(E->get().autotile_coord_x, E->get().autotile_coord_y);
+Map<Vector2i, TileMapQuadrant> &TileMap::get_quadrant_map() {
+	return quadrant_map;
+}
+
+void TileMap::fix_invalid_tiles() {
+	ERR_FAIL_COND_MSG(tile_set.is_null(), "Cannot fix invalid tiles if Tileset is not open.");
+	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)) {
+			set_cell(E->key(), -1, TileSetAtlasSource::INVALID_ATLAS_COORDS, TileSetAtlasSource::INVALID_TILE_ALTERNATIVE);
+		}
+	}
 }
 
 void TileMap::_recreate_quadrants() {
+	// Clear then recreate all quadrants.
 	_clear_quadrants();
 
-	for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {
-		PosKey qk = PosKey(E->key().x, E->key().y).to_quadrant(_get_quadrant_size());
+	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<PosKey, Quadrant>::Element *Q = quadrant_map.find(qk);
+		Map<Vector2i, TileMapQuadrant>::Element *Q = quadrant_map.find(qk);
 		if (!Q) {
 			Q = _create_quadrant(qk);
-			dirty_quadrant_list.add(&Q->get().dirty_list);
+			dirty_quadrant_list.add(&Q->get().dirty_list_element);
 		}
 
-		Q->get().cells.insert(E->key());
+		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::set_material(const Ref<Material> &p_material) {
-	CanvasItem::set_material(p_material);
-	_update_all_items_material_state();
-}
-
-void TileMap::set_use_parent_material(bool p_use_parent_material) {
-	CanvasItem::set_use_parent_material(p_use_parent_material);
-	_update_all_items_material_state();
-}
-
-void TileMap::_update_all_items_material_state() {
-	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		Quadrant &q = E->get();
-		for (List<RID>::Element *F = q.canvas_items.front(); F; F = F->next()) {
-			_update_item_material_state(F->get());
-		}
+	// Clear the dirty quadrants list.
+	while (dirty_quadrant_list.first()) {
+		dirty_quadrant_list.remove(dirty_quadrant_list.first());
 	}
 }
 
-void TileMap::_update_item_material_state(const RID &p_canvas_item) {
-	RS::get_singleton()->canvas_item_set_use_parent_material(p_canvas_item, get_use_parent_material() || get_material().is_valid());
-}
-
 void TileMap::clear() {
+	// Remove all tiles.
 	_clear_quadrants();
 	tile_map.clear();
 	used_size_cache_dirty = true;
 }
 
 void TileMap::_set_tile_data(const Vector<int> &p_data) {
-	ERR_FAIL_COND(format > FORMAT_2);
+	// Set data for a given tile from raw data.
+	ERR_FAIL_COND(format > FORMAT_3);
 
 	int c = p_data.size();
 	const int *r = p_data.ptr();
 
-	int offset = (format == FORMAT_2) ? 3 : 2;
+	int offset = (format >= FORMAT_2) ? 3 : 2;
 
 	clear();
 	for (int i = 0; i < c; i += offset) {
 		const uint8_t *ptr = (const uint8_t *)&r[i];
 		uint8_t local[12];
-		for (int j = 0; j < ((format == FORMAT_2) ? 12 : 8); j++) {
+		for (int j = 0; j < ((format >= FORMAT_2) ? 12 : 8); j++) {
 			local[j] = ptr[j];
 		}
 
@@ -1163,31 +791,49 @@ void TileMap::_set_tile_data(const Vector<int> &p_data) {
 		SWAP(local[4], local[7]);
 		SWAP(local[5], local[6]);
 		//TODO: ask someone to check this...
-		if (FORMAT == FORMAT_2) {
+		if (FORMAT >= FORMAT_2) {
 			SWAP(local[8], local[11]);
 			SWAP(local[9], local[10]);
 		}
 #endif
+		int16_t x = decode_uint16(&local[0]);
+		int16_t y = decode_uint16(&local[2]);
+
+		if (format == FORMAT_3) {
+			uint16_t source_id = decode_uint16(&local[4]);
+			uint16_t atlas_coords_x = decode_uint16(&local[6]);
+			uint16_t atlas_coords_y = decode_uint32(&local[8]);
+			uint16_t alternative_tile = decode_uint16(&local[10]);
+			set_cell(Vector2i(x, y), source_id, Vector2i(atlas_coords_x, atlas_coords_y), alternative_tile);
+		} else {
+			uint32_t v = decode_uint32(&local[4]);
+			v &= (1 << 29) - 1;
+
+			// We generate an alternative tile number out of the the flags
+			// An option should create the alternative in the tileset for compatibility
+			bool flip_h = v & (1 << 29);
+			bool flip_v = v & (1 << 30);
+			bool transpose = v & (1 << 31);
+			int16_t coord_x = 0;
+			int16_t coord_y = 0;
+			if (format == FORMAT_2) {
+				coord_x = decode_uint16(&local[8]);
+				coord_y = decode_uint16(&local[10]);
+			}
 
-		uint16_t x = decode_uint16(&local[0]);
-		uint16_t y = decode_uint16(&local[2]);
-		uint32_t v = decode_uint32(&local[4]);
-		bool flip_h = v & (1 << 29);
-		bool flip_v = v & (1 << 30);
-		bool transpose = v & (1 << 31);
-		v &= (1 << 29) - 1;
-		int16_t coord_x = 0;
-		int16_t coord_y = 0;
-		if (format == FORMAT_2) {
-			coord_x = decode_uint16(&local[8]);
-			coord_y = decode_uint16(&local[10]);
-		}
+			int compatibility_alternative_tile = ((int)flip_h) + ((int)flip_v << 1) + ((int)transpose << 2);
+
+			if (tile_set.is_valid()) {
+				v = tile_set->compatibility_get_source_for_tile_id(v);
+			}
 
-		set_cell(x, y, v, flip_h, flip_v, transpose, Vector2(coord_x, coord_y));
+			set_cell(Vector2i(x, y), v, Vector2i(coord_x, coord_y), compatibility_alternative_tile);
+		}
 	}
 }
 
 Vector<int> TileMap::_get_tile_data() const {
+	// Export tile data to raw format
 	Vector<int> data;
 	data.resize(tile_map.size() * 3);
 	int *w = data.ptrw();
@@ -1195,23 +841,14 @@ Vector<int> TileMap::_get_tile_data() const {
 	// Save in highest format
 
 	int idx = 0;
-	for (const Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {
+	for (const Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
 		uint8_t *ptr = (uint8_t *)&w[idx];
-		encode_uint16(E->key().x, &ptr[0]);
-		encode_uint16(E->key().y, &ptr[2]);
-		uint32_t val = E->get().id;
-		if (E->get().flip_h) {
-			val |= (1 << 29);
-		}
-		if (E->get().flip_v) {
-			val |= (1 << 30);
-		}
-		if (E->get().transpose) {
-			val |= (1 << 31);
-		}
-		encode_uint32(val, &ptr[4]);
-		encode_uint16(E->get().autotile_coord_x, &ptr[8]);
-		encode_uint16(E->get().autotile_coord_y, &ptr[10]);
+		encode_uint16((int16_t)(E->key().x), &ptr[0]);
+		encode_uint16((int16_t)(E->key().y), &ptr[2]);
+		encode_uint16(E->get().source_id, &ptr[4]);
+		encode_uint16(E->get().coord_x, &ptr[6]);
+		encode_uint16(E->get().coord_y, &ptr[8]);
+		encode_uint16(E->get().alternative_tile, &ptr[10]);
 		idx += 3;
 	}
 
@@ -1220,6 +857,7 @@ Vector<int> TileMap::_get_tile_data() const {
 
 #ifdef TOOLS_ENABLED
 Rect2 TileMap::_edit_get_rect() const {
+	// Return the visible rect of the tilemap
 	if (pending_update) {
 		const_cast<TileMap *>(this)->update_dirty_quadrants();
 	} else {
@@ -1229,255 +867,6 @@ Rect2 TileMap::_edit_get_rect() const {
 }
 #endif
 
-void TileMap::set_collision_layer(uint32_t p_layer) {
-	collision_layer = p_layer;
-	if (!use_parent) {
-		for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-			Quadrant &q = E->get();
-			PhysicsServer2D::get_singleton()->body_set_collision_layer(q.body, collision_layer);
-		}
-	}
-}
-
-void TileMap::set_collision_mask(uint32_t p_mask) {
-	collision_mask = p_mask;
-	if (!use_parent) {
-		for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-			Quadrant &q = E->get();
-			PhysicsServer2D::get_singleton()->body_set_collision_mask(q.body, collision_mask);
-		}
-	}
-}
-
-void TileMap::set_collision_layer_bit(int p_bit, bool p_value) {
-	ERR_FAIL_INDEX_MSG(p_bit, 32, "Collision layer bit must be between 0 and 31 inclusive.");
-	uint32_t layer = get_collision_layer();
-	if (p_value) {
-		layer |= 1 << p_bit;
-	} else {
-		layer &= ~(1 << p_bit);
-	}
-	set_collision_layer(layer);
-}
-
-void TileMap::set_collision_mask_bit(int p_bit, bool p_value) {
-	ERR_FAIL_INDEX_MSG(p_bit, 32, "Collision mask bit must be between 0 and 31 inclusive.");
-	uint32_t mask = get_collision_mask();
-	if (p_value) {
-		mask |= 1 << p_bit;
-	} else {
-		mask &= ~(1 << p_bit);
-	}
-	set_collision_mask(mask);
-}
-
-bool TileMap::get_collision_use_kinematic() const {
-	return use_kinematic;
-}
-
-void TileMap::set_collision_use_kinematic(bool p_use_kinematic) {
-	_clear_quadrants();
-	use_kinematic = p_use_kinematic;
-	_recreate_quadrants();
-}
-
-bool TileMap::get_collision_use_parent() const {
-	return use_parent;
-}
-
-void TileMap::set_collision_use_parent(bool p_use_parent) {
-	if (use_parent == p_use_parent) {
-		return;
-	}
-
-	_clear_quadrants();
-
-	use_parent = p_use_parent;
-	set_notify_local_transform(use_parent);
-
-	if (use_parent && is_inside_tree()) {
-		collision_parent = Object::cast_to<CollisionObject2D>(get_parent());
-	} else {
-		collision_parent = nullptr;
-	}
-
-	_recreate_quadrants();
-	notify_property_list_changed();
-	update_configuration_warnings();
-}
-
-void TileMap::set_collision_friction(float p_friction) {
-	friction = p_friction;
-	if (!use_parent) {
-		for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-			Quadrant &q = E->get();
-			PhysicsServer2D::get_singleton()->body_set_param(q.body, PhysicsServer2D::BODY_PARAM_FRICTION, p_friction);
-		}
-	}
-}
-
-float TileMap::get_collision_friction() const {
-	return friction;
-}
-
-void TileMap::set_collision_bounce(float p_bounce) {
-	bounce = p_bounce;
-	if (!use_parent) {
-		for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-			Quadrant &q = E->get();
-			PhysicsServer2D::get_singleton()->body_set_param(q.body, PhysicsServer2D::BODY_PARAM_BOUNCE, p_bounce);
-		}
-	}
-}
-
-float TileMap::get_collision_bounce() const {
-	return bounce;
-}
-
-void TileMap::set_bake_navigation(bool p_bake_navigation) {
-	bake_navigation = p_bake_navigation;
-	for (Map<PosKey, Quadrant>::Element *F = quadrant_map.front(); F; F = F->next()) {
-		_make_quadrant_dirty(F);
-	}
-}
-
-bool TileMap::is_baking_navigation() {
-	return bake_navigation;
-}
-
-uint32_t TileMap::get_collision_layer() const {
-	return collision_layer;
-}
-
-uint32_t TileMap::get_collision_mask() const {
-	return collision_mask;
-}
-
-bool TileMap::get_collision_layer_bit(int p_bit) const {
-	ERR_FAIL_INDEX_V_MSG(p_bit, 32, false, "Collision layer bit must be between 0 and 31 inclusive.");
-	return get_collision_layer() & (1 << p_bit);
-}
-
-bool TileMap::get_collision_mask_bit(int p_bit) const {
-	ERR_FAIL_INDEX_V_MSG(p_bit, 32, false, "Collision mask bit must be between 0 and 31 inclusive.");
-	return get_collision_mask() & (1 << p_bit);
-}
-
-void TileMap::set_mode(Mode p_mode) {
-	_clear_quadrants();
-	mode = p_mode;
-	_recreate_quadrants();
-	emit_signal("settings_changed");
-}
-
-TileMap::Mode TileMap::get_mode() const {
-	return mode;
-}
-
-void TileMap::set_half_offset(HalfOffset p_half_offset) {
-	_clear_quadrants();
-	half_offset = p_half_offset;
-	_recreate_quadrants();
-	emit_signal("settings_changed");
-}
-
-void TileMap::set_tile_origin(TileOrigin p_tile_origin) {
-	_clear_quadrants();
-	tile_origin = p_tile_origin;
-	_recreate_quadrants();
-	emit_signal("settings_changed");
-}
-
-TileMap::TileOrigin TileMap::get_tile_origin() const {
-	return tile_origin;
-}
-
-Vector2 TileMap::get_cell_draw_offset() const {
-	switch (mode) {
-		case MODE_SQUARE: {
-			return Vector2();
-		} break;
-		case MODE_ISOMETRIC: {
-			return Vector2(-cell_size.x * 0.5, 0);
-
-		} break;
-		case MODE_CUSTOM: {
-			Vector2 min;
-			min.x = MIN(custom_transform[0].x, min.x);
-			min.y = MIN(custom_transform[0].y, min.y);
-			min.x = MIN(custom_transform[1].x, min.x);
-			min.y = MIN(custom_transform[1].y, min.y);
-			return min;
-		} break;
-	}
-
-	return Vector2();
-}
-
-TileMap::HalfOffset TileMap::get_half_offset() const {
-	return half_offset;
-}
-
-Transform2D TileMap::get_cell_transform() const {
-	switch (mode) {
-		case MODE_SQUARE: {
-			Transform2D m;
-			m[0] *= cell_size.x;
-			m[1] *= cell_size.y;
-			return m;
-		} break;
-		case MODE_ISOMETRIC: {
-			//isometric only makes sense when y is positive in both x and y vectors, otherwise
-			//the drawing of tiles will overlap
-			Transform2D m;
-			m[0] = Vector2(cell_size.x * 0.5, cell_size.y * 0.5);
-			m[1] = Vector2(-cell_size.x * 0.5, cell_size.y * 0.5);
-			return m;
-
-		} break;
-		case MODE_CUSTOM: {
-			return custom_transform;
-		} break;
-	}
-
-	return Transform2D();
-}
-
-void TileMap::set_custom_transform(const Transform2D &p_xform) {
-	_clear_quadrants();
-	custom_transform = p_xform;
-	_recreate_quadrants();
-	emit_signal("settings_changed");
-}
-
-Transform2D TileMap::get_custom_transform() const {
-	return custom_transform;
-}
-
-Vector2 TileMap::_map_to_world(int p_x, int p_y, bool p_ignore_ofs) const {
-	Vector2 ret = get_cell_transform().xform(Vector2(p_x, p_y));
-	if (!p_ignore_ofs) {
-		switch (half_offset) {
-			case HALF_OFFSET_X:
-			case HALF_OFFSET_NEGATIVE_X: {
-				if (ABS(p_y) & 1) {
-					ret += get_cell_transform()[0] * (half_offset == HALF_OFFSET_X ? 0.5 : -0.5);
-				}
-			} break;
-			case HALF_OFFSET_Y:
-			case HALF_OFFSET_NEGATIVE_Y: {
-				if (ABS(p_x) & 1) {
-					ret += get_cell_transform()[1] * (half_offset == HALF_OFFSET_Y ? 0.5 : -0.5);
-				}
-			} break;
-			case HALF_OFFSET_DISABLED: {
-				// Nothing to do.
-			}
-		}
-	}
-	return ret;
-}
-
 bool TileMap::_set(const StringName &p_name, const Variant &p_value) {
 	if (p_name == "format") {
 		if (p_value.get_type() == Variant::INT) {
@@ -1496,7 +885,7 @@ bool TileMap::_set(const StringName &p_name, const Variant &p_value) {
 
 bool TileMap::_get(const StringName &p_name, Variant &r_ret) const {
 	if (p_name == "format") {
-		r_ret = FORMAT_2; // When saving, always save highest format
+		r_ret = FORMAT_3; // When saving, always save highest format
 		return true;
 	} else if (p_name == "tile_data") {
 		r_ret = _get_tile_data();
@@ -1513,93 +902,632 @@ void TileMap::_get_property_list(List<PropertyInfo> *p_list) const {
 	p_list->push_back(p);
 }
 
-void TileMap::_validate_property(PropertyInfo &property) const {
-	if (use_parent && property.name != "collision_use_parent" && property.name.begins_with("collision_")) {
-		property.usage = PROPERTY_USAGE_NOEDITOR;
+Vector2 TileMap::map_to_world(const Vector2 &p_pos) const {
+	// SHOULD RETURN THE CENTER OF THE TILE
+	ERR_FAIL_COND_V(!tile_set.is_valid(), Vector2());
+
+	Vector2 ret = p_pos;
+	TileSet::TileShape tile_shape = tile_set->get_tile_shape();
+	TileSet::TileOffsetAxis tile_offset_axis = tile_set->get_tile_offset_axis();
+
+	if (tile_shape == TileSet::TILE_SHAPE_HALF_OFFSET_SQUARE || tile_shape == TileSet::TILE_SHAPE_HEXAGON || tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+		// Technically, those 3 shapes are equivalent, as they are basically half-offset, but with different levels or overlap.
+		// square = no overlap, hexagon = 0.25 overlap, isometric = 0.5 overlap
+		if (tile_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+			switch (tile_set->get_tile_layout()) {
+				case TileSet::TILE_LAYOUT_STACKED:
+					ret = Vector2(ret.x + (Math::posmod(ret.y, 2) == 0 ? 0.0 : 0.5), ret.y);
+					break;
+				case TileSet::TILE_LAYOUT_STACKED_OFFSET:
+					ret = Vector2(ret.x + (Math::posmod(ret.y, 2) == 1 ? 0.0 : 0.5), ret.y);
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_RIGHT:
+					ret = Vector2(ret.x + ret.y / 2, ret.y);
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_DOWN:
+					ret = Vector2(ret.x / 2, ret.y * 2 + ret.x);
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_RIGHT:
+					ret = Vector2((ret.x + ret.y) / 2, ret.y - ret.x);
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_DOWN:
+					ret = Vector2((ret.x - ret.y) / 2, ret.y + ret.x);
+					break;
+			}
+		} else { // TILE_OFFSET_AXIS_VERTICAL
+			switch (tile_set->get_tile_layout()) {
+				case TileSet::TILE_LAYOUT_STACKED:
+					ret = Vector2(ret.x, ret.y + (Math::posmod(ret.x, 2) == 0 ? 0.0 : 0.5));
+					break;
+				case TileSet::TILE_LAYOUT_STACKED_OFFSET:
+					ret = Vector2(ret.x, ret.y + (Math::posmod(ret.x, 2) == 1 ? 0.0 : 0.5));
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_RIGHT:
+					ret = Vector2(ret.x * 2 + ret.y, ret.y / 2);
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_DOWN:
+					ret = Vector2(ret.x, ret.y + ret.x / 2);
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_RIGHT:
+					ret = Vector2(ret.x + ret.y, (ret.y - ret.x) / 2);
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_DOWN:
+					ret = Vector2(ret.x - ret.y, (ret.y + ret.x) / 2);
+					break;
+			}
+		}
 	}
-}
 
-Vector2 TileMap::map_to_world(const Vector2 &p_pos, bool p_ignore_ofs) const {
-	return _map_to_world(p_pos.x, p_pos.y, p_ignore_ofs);
+	// Multiply by the overlapping ratio
+	double overlapping_ratio = 1.0;
+	if (tile_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+			overlapping_ratio = 0.5;
+		} else if (tile_shape == TileSet::TILE_SHAPE_HEXAGON) {
+			overlapping_ratio = 0.75;
+		}
+		ret.y *= overlapping_ratio;
+	} else { // TILE_OFFSET_AXIS_VERTICAL
+		if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+			overlapping_ratio = 0.5;
+		} else if (tile_shape == TileSet::TILE_SHAPE_HEXAGON) {
+			overlapping_ratio = 0.75;
+		}
+		ret.x *= overlapping_ratio;
+	}
+
+	return (ret + Vector2(0.5, 0.5)) * tile_set->get_tile_size();
 }
 
-Vector2 TileMap::world_to_map(const Vector2 &p_pos) const {
-	Vector2 ret = get_cell_transform().affine_inverse().xform(p_pos);
+Vector2i TileMap::world_to_map(const Vector2 &p_pos) const {
+	ERR_FAIL_COND_V(!tile_set.is_valid(), Vector2());
+
+	Vector2 ret = p_pos;
+	ret /= tile_set->get_tile_size();
 
-	// Account for precision errors on the border (GH-23250).
-	// 0.00005 is 5*CMP_EPSILON, results would start being unpredictable if
-	// cell size is > 15,000, but we can hardly have more precision anyway with
-	// floating point.
-	ret += Vector2(0.00005, 0.00005);
+	TileSet::TileShape tile_shape = tile_set->get_tile_shape();
+	TileSet::TileOffsetAxis tile_offset_axis = tile_set->get_tile_offset_axis();
+	TileSet::TileLayout tile_layout = tile_set->get_tile_layout();
 
-	switch (half_offset) {
-		case HALF_OFFSET_X: {
-			if (int(floor(ret.y)) & 1) {
-				ret.x -= 0.5;
+	// Divide by the overlapping ratio
+	double overlapping_ratio = 1.0;
+	if (tile_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+			overlapping_ratio = 0.5;
+		} else if (tile_shape == TileSet::TILE_SHAPE_HEXAGON) {
+			overlapping_ratio = 0.75;
+		}
+		ret.y /= overlapping_ratio;
+	} else { // TILE_OFFSET_AXIS_VERTICAL
+		if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+			overlapping_ratio = 0.5;
+		} else if (tile_shape == TileSet::TILE_SHAPE_HEXAGON) {
+			overlapping_ratio = 0.75;
+		}
+		ret.x /= overlapping_ratio;
+	}
+
+	// For each half-offset shape, we check if we are in the corner of the tile, and thus should correct the world position accordingly.
+	if (tile_shape == TileSet::TILE_SHAPE_HALF_OFFSET_SQUARE || tile_shape == TileSet::TILE_SHAPE_HEXAGON || tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+		// Technically, those 3 shapes are equivalent, as they are basically half-offset, but with different levels or overlap.
+		// square = no overlap, hexagon = 0.25 overlap, isometric = 0.5 overlap
+		if (tile_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+			// Smart floor of the position
+			Vector2 raw_pos = ret;
+			if (Math::posmod(Math::floor(ret.y), 2) ^ (tile_layout == TileSet::TILE_LAYOUT_STACKED_OFFSET)) {
+				ret = Vector2(Math::floor(ret.x + 0.5) - 0.5, Math::floor(ret.y));
+			} else {
+				ret = ret.floor();
 			}
-		} break;
-		case HALF_OFFSET_NEGATIVE_X: {
-			if (int(floor(ret.y)) & 1) {
-				ret.x += 0.5;
+
+			// Compute the tile offset, and if we might the output for a neighbour top tile
+			Vector2 in_tile_pos = raw_pos - ret;
+			bool in_top_left_triangle = (in_tile_pos - Vector2(0.5, 0.0)).cross(Vector2(-0.5, 1.0 / overlapping_ratio - 1)) <= 0;
+			bool in_top_right_triangle = (in_tile_pos - Vector2(0.5, 0.0)).cross(Vector2(0.5, 1.0 / overlapping_ratio - 1)) > 0;
+
+			switch (tile_layout) {
+				case TileSet::TILE_LAYOUT_STACKED:
+					ret = ret.floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(Math::posmod(Math::floor(ret.y), 2) ? 0 : -1, -1);
+					} else if (in_top_right_triangle) {
+						ret += Vector2i(Math::posmod(Math::floor(ret.y), 2) ? 1 : 0, -1);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_STACKED_OFFSET:
+					ret = ret.floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(Math::posmod(Math::floor(ret.y), 2) ? -1 : 0, -1);
+					} else if (in_top_right_triangle) {
+						ret += Vector2i(Math::posmod(Math::floor(ret.y), 2) ? 0 : 1, -1);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_RIGHT:
+					ret = Vector2(ret.x - ret.y / 2, ret.y).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(0, -1);
+					} else if (in_top_right_triangle) {
+						ret += Vector2i(1, -1);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_DOWN:
+					ret = Vector2(ret.x * 2, ret.y / 2 - ret.x).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(-1, 0);
+					} else if (in_top_right_triangle) {
+						ret += Vector2i(1, -1);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_RIGHT:
+					ret = Vector2(ret.x - ret.y / 2, ret.y / 2 + ret.x).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(0, -1);
+					} else if (in_top_right_triangle) {
+						ret += Vector2i(1, 0);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_DOWN:
+					ret = Vector2(ret.x + ret.y / 2, ret.y / 2 - ret.x).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(-1, 0);
+					} else if (in_top_right_triangle) {
+						ret += Vector2i(0, -1);
+					}
+					break;
 			}
-		} break;
-		case HALF_OFFSET_Y: {
-			if (int(floor(ret.x)) & 1) {
-				ret.y -= 0.5;
+		} else { // TILE_OFFSET_AXIS_VERTICAL
+			// Smart floor of the position
+			Vector2 raw_pos = ret;
+			if (Math::posmod(Math::floor(ret.x), 2) ^ (tile_layout == TileSet::TILE_LAYOUT_STACKED_OFFSET)) {
+				ret = Vector2(Math::floor(ret.x), Math::floor(ret.y + 0.5) - 0.5);
+			} else {
+				ret = ret.floor();
 			}
-		} break;
-		case HALF_OFFSET_NEGATIVE_Y: {
-			if (int(floor(ret.x)) & 1) {
-				ret.y += 0.5;
+
+			// Compute the tile offset, and if we might the output for a neighbour top tile
+			Vector2 in_tile_pos = raw_pos - ret;
+			bool in_top_left_triangle = (in_tile_pos - Vector2(0.0, 0.5)).cross(Vector2(1.0 / overlapping_ratio - 1, -0.5)) > 0;
+			bool in_bottom_left_triangle = (in_tile_pos - Vector2(0.0, 0.5)).cross(Vector2(1.0 / overlapping_ratio - 1, 0.5)) <= 0;
+
+			switch (tile_layout) {
+				case TileSet::TILE_LAYOUT_STACKED:
+					ret = ret.floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(-1, Math::posmod(Math::floor(ret.x), 2) ? 0 : -1);
+					} else if (in_bottom_left_triangle) {
+						ret += Vector2i(-1, Math::posmod(Math::floor(ret.x), 2) ? 1 : 0);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_STACKED_OFFSET:
+					ret = ret.floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(-1, Math::posmod(Math::floor(ret.x), 2) ? -1 : 0);
+					} else if (in_bottom_left_triangle) {
+						ret += Vector2i(-1, Math::posmod(Math::floor(ret.x), 2) ? 0 : 1);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_RIGHT:
+					ret = Vector2(ret.x / 2 - ret.y, ret.y * 2).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(0, -1);
+					} else if (in_bottom_left_triangle) {
+						ret += Vector2i(-1, 1);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_STAIRS_DOWN:
+					ret = Vector2(ret.x, ret.y - ret.x / 2).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(-1, 0);
+					} else if (in_bottom_left_triangle) {
+						ret += Vector2i(-1, 1);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_RIGHT:
+					ret = Vector2(ret.x / 2 - ret.y, ret.y + ret.x / 2).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(0, -1);
+					} else if (in_bottom_left_triangle) {
+						ret += Vector2i(-1, 0);
+					}
+					break;
+				case TileSet::TILE_LAYOUT_DIAMOND_DOWN:
+					ret = Vector2(ret.x / 2 + ret.y, ret.y - ret.x / 2).floor();
+					if (in_top_left_triangle) {
+						ret += Vector2i(-1, 0);
+					} else if (in_bottom_left_triangle) {
+						ret += Vector2i(0, 1);
+					}
+					break;
 			}
-		} break;
-		case HALF_OFFSET_DISABLED: {
-			// Nothing to do.
 		}
+	} else {
+		ret = (ret + Vector2(0.00005, 0.00005)).floor();
 	}
-
-	return ret.floor();
+	return ret;
 }
 
-void TileMap::set_y_sort_enabled(bool p_enable) {
-	_clear_quadrants();
-	use_y_sort = p_enable;
-	RS::get_singleton()->canvas_item_set_sort_children_by_y(get_canvas_item(), use_y_sort);
-	_recreate_quadrants();
-	emit_signal("settings_changed");
+bool TileMap::is_existing_neighbor(TileSet::CellNeighbor p_cell_neighbor) const {
+	ERR_FAIL_COND_V(!tile_set.is_valid(), false);
+
+	TileSet::TileShape shape = tile_set->get_tile_shape();
+	if (shape == TileSet::TILE_SHAPE_SQUARE) {
+		return p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER;
+
+	} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+		return p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER ||
+			   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE;
+	} else {
+		if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+			return p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE;
+		} else {
+			return p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE ||
+				   p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE;
+		}
+	}
 }
 
-bool TileMap::is_y_sort_enabled() const {
-	return use_y_sort;
-}
+Vector2i TileMap::get_neighbor_cell(const Vector2i &p_coords, TileSet::CellNeighbor p_cell_neighbor) const {
+	ERR_FAIL_COND_V(!tile_set.is_valid(), p_coords);
+
+	TileSet::TileShape shape = tile_set->get_tile_shape();
+	if (shape == TileSet::TILE_SHAPE_SQUARE) {
+		switch (p_cell_neighbor) {
+			case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
+				return p_coords + Vector2i(1, 0);
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
+				return p_coords + Vector2i(1, 1);
+			case TileSet::CELL_NEIGHBOR_BOTTOM_SIDE:
+				return p_coords + Vector2i(0, 1);
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
+				return p_coords + Vector2i(-1, 1);
+			case TileSet::CELL_NEIGHBOR_LEFT_SIDE:
+				return p_coords + Vector2i(-1, 0);
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
+				return p_coords + Vector2i(-1, -1);
+			case TileSet::CELL_NEIGHBOR_TOP_SIDE:
+				return p_coords + Vector2i(0, -1);
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
+				return p_coords + Vector2i(1, -1);
+			default:
+				ERR_FAIL_V(p_coords);
+		}
+	} else { // Half-offset shapes (square and hexagon)
+		switch (tile_set->get_tile_layout()) {
+			case TileSet::TILE_LAYOUT_STACKED: {
+				if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+					bool is_offset = p_coords.y % 2;
+					if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) ||
+							(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE)) {
+						return p_coords + Vector2i(1, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+						return p_coords + Vector2i(is_offset ? 1 : 0, 1);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) {
+						return p_coords + Vector2i(0, 2);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+						return p_coords + Vector2i(is_offset ? 0 : -1, 1);
+					} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) ||
+							   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE)) {
+						return p_coords + Vector2i(-1, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+						return p_coords + Vector2i(is_offset ? 0 : -1, -1);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) {
+						return p_coords + Vector2i(0, -2);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+						return p_coords + Vector2i(is_offset ? 1 : 0, -1);
+					} else {
+						ERR_FAIL_V(p_coords);
+					}
+				} else {
+					bool is_offset = p_coords.x % 2;
+
+					if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) ||
+							(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)) {
+						return p_coords + Vector2i(0, 1);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+						return p_coords + Vector2i(1, is_offset ? 1 : 0);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) {
+						return p_coords + Vector2i(2, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+						return p_coords + Vector2i(1, is_offset ? 0 : -1);
+					} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) ||
+							   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE)) {
+						return p_coords + Vector2i(0, -1);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+						return p_coords + Vector2i(-1, is_offset ? 0 : -1);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) {
+						return p_coords + Vector2i(-2, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+						return p_coords + Vector2i(-1, is_offset ? 1 : 0);
+					} else {
+						ERR_FAIL_V(p_coords);
+					}
+				}
+			} break;
+			case TileSet::TILE_LAYOUT_STACKED_OFFSET: {
+				if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+					bool is_offset = p_coords.y % 2;
+
+					if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) ||
+							(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE)) {
+						return p_coords + Vector2i(1, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+						return p_coords + Vector2i(is_offset ? 0 : 1, 1);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) {
+						return p_coords + Vector2i(0, 2);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+						return p_coords + Vector2i(is_offset ? -1 : 0, 1);
+					} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) ||
+							   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE)) {
+						return p_coords + Vector2i(-1, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+						return p_coords + Vector2i(is_offset ? -1 : 0, -1);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) {
+						return p_coords + Vector2i(0, -2);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+						return p_coords + Vector2i(is_offset ? 0 : 1, -1);
+					} else {
+						ERR_FAIL_V(p_coords);
+					}
+				} else {
+					bool is_offset = p_coords.x % 2;
+
+					if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) ||
+							(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)) {
+						return p_coords + Vector2i(0, 1);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+						return p_coords + Vector2i(1, is_offset ? 0 : 1);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) {
+						return p_coords + Vector2i(2, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+						return p_coords + Vector2i(1, is_offset ? -1 : 0);
+					} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) ||
+							   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE)) {
+						return p_coords + Vector2i(0, -1);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+						return p_coords + Vector2i(-1, is_offset ? -1 : 0);
+					} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) {
+						return p_coords + Vector2i(-2, 0);
+					} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+						return p_coords + Vector2i(-1, is_offset ? 0 : 1);
+					} else {
+						ERR_FAIL_V(p_coords);
+					}
+				}
+			} break;
+			case TileSet::TILE_LAYOUT_STAIRS_RIGHT:
+			case TileSet::TILE_LAYOUT_STAIRS_DOWN: {
+				if ((tile_set->get_tile_layout() == TileSet::TILE_LAYOUT_STAIRS_RIGHT) ^ (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL)) {
+					if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE)) {
+							return p_coords + Vector2i(1, 0);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(0, 1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) {
+							return p_coords + Vector2i(-1, 2);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 1);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE)) {
+							return p_coords + Vector2i(-1, 0);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(0, -1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) {
+							return p_coords + Vector2i(1, -2);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, -1);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
 
-void TileMap::set_compatibility_mode(bool p_enable) {
-	_clear_quadrants();
-	compatibility_mode = p_enable;
-	_recreate_quadrants();
-	emit_signal("settings_changed");
-}
+					} else {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)) {
+							return p_coords + Vector2i(0, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) {
+							return p_coords + Vector2i(2, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, -1);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE)) {
+							return p_coords + Vector2i(0, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) {
+							return p_coords + Vector2i(-2, 1);
+
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 1);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
+					}
+				} else {
+					if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE)) {
+							return p_coords + Vector2i(2, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) {
+							return p_coords + Vector2i(0, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 1);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE)) {
+							return p_coords + Vector2i(-2, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) {
+							return p_coords + Vector2i(0, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, -1);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
 
-bool TileMap::is_compatibility_mode_enabled() const {
-	return compatibility_mode;
-}
+					} else {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)) {
+							return p_coords + Vector2i(-1, 2);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(0, 1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) {
+							return p_coords + Vector2i(1, 0);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, -1);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE)) {
+							return p_coords + Vector2i(1, -2);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(0, -1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) {
+							return p_coords + Vector2i(-1, 0);
+
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 1);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
+					}
+				}
+			} break;
+			case TileSet::TILE_LAYOUT_DIAMOND_RIGHT:
+			case TileSet::TILE_LAYOUT_DIAMOND_DOWN: {
+				if ((tile_set->get_tile_layout() == TileSet::TILE_LAYOUT_DIAMOND_RIGHT) ^ (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL)) {
+					if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE)) {
+							return p_coords + Vector2i(1, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(0, 1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) {
+							return p_coords + Vector2i(-1, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 0);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE)) {
+							return p_coords + Vector2i(-1, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(0, -1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) {
+							return p_coords + Vector2i(1, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, 0);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
 
-void TileMap::set_centered_textures(bool p_enable) {
-	_clear_quadrants();
-	centered_textures = p_enable;
-	_recreate_quadrants();
-	emit_signal("settings_changed");
-}
+					} else {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)) {
+							return p_coords + Vector2i(1, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) {
+							return p_coords + Vector2i(1, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(0, -1);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE)) {
+							return p_coords + Vector2i(-1, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) {
+							return p_coords + Vector2i(-1, 1);
+
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(0, 1);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
+					}
+				} else {
+					if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_SIDE)) {
+							return p_coords + Vector2i(1, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) {
+							return p_coords + Vector2i(1, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(0, 1);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_SIDE)) {
+							return p_coords + Vector2i(-1, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 0);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) {
+							return p_coords + Vector2i(-1, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(0, -1);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
 
-bool TileMap::is_centered_textures_enabled() const {
-	return centered_textures;
+					} else {
+						if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) ||
+								(shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)) {
+							return p_coords + Vector2i(-1, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) {
+							return p_coords + Vector2i(0, 1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_RIGHT_CORNER) {
+							return p_coords + Vector2i(1, 1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+							return p_coords + Vector2i(1, 0);
+						} else if ((shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_CORNER) ||
+								   (shape != TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_SIDE)) {
+							return p_coords + Vector2i(1, -1);
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) {
+							return p_coords + Vector2i(0, -1);
+						} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC && p_cell_neighbor == TileSet::CELL_NEIGHBOR_LEFT_CORNER) {
+							return p_coords + Vector2i(-1, -1);
+
+						} else if (p_cell_neighbor == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) {
+							return p_coords + Vector2i(-1, 0);
+						} else {
+							ERR_FAIL_V(p_coords);
+						}
+					}
+				}
+			} break;
+			default:
+				ERR_FAIL_V(p_coords);
+		}
+	}
 }
 
 TypedArray<Vector2i> TileMap::get_used_cells() const {
+	// Returns the cells used in the tilemap.
 	TypedArray<Vector2i> a;
 	a.resize(tile_map.size());
 	int i = 0;
-	for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {
+	for (Map<Vector2i, TileMapCell>::Element *E = tile_map.front(); E; E = E->next()) {
 		Vector2i p(E->key().x, E->key().y);
 		a[i++] = p;
 	}
@@ -1607,25 +1535,13 @@ TypedArray<Vector2i> TileMap::get_used_cells() const {
 	return a;
 }
 
-TypedArray<Vector2i> TileMap::get_used_cells_by_index(int p_id) const {
-	TypedArray<Vector2i> a;
-	for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {
-		if (E->value().id == p_id) {
-			Vector2i p(E->key().x, E->key().y);
-			a.push_back(p);
-		}
-	}
-
-	return a;
-}
-
 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);
 
-			for (Map<PosKey, Cell>::Element *E = tile_map.front(); E; E = E->next()) {
+			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));
 			}
 
@@ -1640,46 +1556,49 @@ Rect2 TileMap::get_used_rect() { // Not const because of cache
 	return used_size_cache;
 }
 
-void TileMap::set_occluder_light_mask(int p_mask) {
-	occluder_light_mask = p_mask;
-	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
-		for (Map<PosKey, Quadrant::Occluder>::Element *F = E->get().occluder_instances.front(); F; F = F->next()) {
-			RenderingServer::get_singleton()->canvas_light_occluder_set_light_mask(F->get().id, occluder_light_mask);
-		}
-	}
-}
-
-int TileMap::get_occluder_light_mask() const {
-	return occluder_light_mask;
-}
+// --- Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems ---
 
 void TileMap::set_light_mask(int p_light_mask) {
+	// Occlusion: set light mask.
 	CanvasItem::set_light_mask(p_light_mask);
-	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
+	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
 		for (List<RID>::Element *F = E->get().canvas_items.front(); F; F = F->next()) {
 			RenderingServer::get_singleton()->canvas_item_set_light_mask(F->get(), get_light_mask());
 		}
 	}
 }
 
-void TileMap::set_clip_uv(bool p_enable) {
-	if (clip_uv == p_enable) {
-		return;
-	}
+void TileMap::set_material(const Ref<Material> &p_material) {
+	// Set material for the whole tilemap.
+	CanvasItem::set_material(p_material);
 
-	_clear_quadrants();
-	clip_uv = p_enable;
-	_recreate_quadrants();
+	// Update material for the whole tilemap.
+	for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
+		TileMapQuadrant &q = E->get();
+		for (List<RID>::Element *F = q.canvas_items.front(); F; F = F->next()) {
+			RS::get_singleton()->canvas_item_set_use_parent_material(F->get(), get_use_parent_material() || get_material().is_valid());
+		}
+	}
 }
 
-bool TileMap::get_clip_uv() const {
-	return clip_uv;
+void TileMap::set_use_parent_material(bool p_use_parent_material) {
+	// Set use_parent_material for the whole tilemap.
+	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 (List<RID>::Element *F = q.canvas_items.front(); F; F = F->next()) {
+			RS::get_singleton()->canvas_item_set_use_parent_material(F->get(), get_use_parent_material() || get_material().is_valid());
+		}
+	}
 }
 
 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<PosKey, Quadrant>::Element *F = quadrant_map.front(); F; F = F->next()) {
-		Quadrant &q = F->get();
+	for (Map<Vector2i, TileMapQuadrant>::Element *F = quadrant_map.front(); F; F = F->next()) {
+		TileMapQuadrant &q = F->get();
 		for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {
 			RenderingServer::get_singleton()->canvas_item_set_default_texture_filter(E->get(), RS::CanvasItemTextureFilter(p_texture_filter));
 			_make_quadrant_dirty(F);
@@ -1688,9 +1607,10 @@ void TileMap::set_texture_filter(TextureFilter p_texture_filter) {
 }
 
 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<PosKey, Quadrant>::Element *F = quadrant_map.front(); F; F = F->next()) {
-		Quadrant &q = F->get();
+	for (Map<Vector2i, TileMapQuadrant>::Element *F = quadrant_map.front(); F; F = F->next()) {
+		TileMapQuadrant &q = F->get();
 		for (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {
 			RenderingServer::get_singleton()->canvas_item_set_default_texture_repeat(E->get(), RS::CanvasItemTextureRepeat(p_texture_repeat));
 			_make_quadrant_dirty(F);
@@ -1698,167 +1618,153 @@ void TileMap::set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) {
 	}
 }
 
-TypedArray<String> TileMap::get_configuration_warnings() const {
-	TypedArray<String> warnings = Node::get_configuration_warnings();
+TypedArray<Vector2i> TileMap::get_surrounding_tiles(Vector2i coords) {
+	if (!tile_set.is_valid()) {
+		return TypedArray<Vector2i>();
+	}
 
-	if (use_parent && !collision_parent) {
-		warnings.push_back(TTR("TileMap with Use Parent on needs a parent CollisionObject2D to give shapes to. Please use it as a child of Area2D, StaticBody2D, RigidBody2D, KinematicBody2D, etc. to give them a shape."));
+	TypedArray<Vector2i> around;
+	TileSet::TileShape shape = tile_set->get_tile_shape();
+	if (shape == TileSet::TILE_SHAPE_SQUARE) {
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_RIGHT_SIDE));
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE));
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_LEFT_SIDE));
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_SIDE));
+	} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE));
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE));
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE));
+		around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE));
+	} else {
+		if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_RIGHT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_LEFT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE));
+		} else {
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_SIDE));
+			around.push_back(get_neighbor_cell(coords, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE));
+		}
 	}
 
-	return warnings;
+	return around;
 }
 
-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);
-
-	ClassDB::bind_method(D_METHOD("set_mode", "mode"), &TileMap::set_mode);
-	ClassDB::bind_method(D_METHOD("get_mode"), &TileMap::get_mode);
+void TileMap::draw_cells_outline(Control *p_control, Set<Vector2i> p_cells, Color p_color, Transform2D p_transform) {
+	if (!tile_set.is_valid()) {
+		return;
+	}
 
-	ClassDB::bind_method(D_METHOD("set_half_offset", "half_offset"), &TileMap::set_half_offset);
-	ClassDB::bind_method(D_METHOD("get_half_offset"), &TileMap::get_half_offset);
+	// Create a set.
+	Vector2i tile_size = tile_set->get_tile_size();
+	Vector<Vector2> uvs;
 
-	ClassDB::bind_method(D_METHOD("set_custom_transform", "custom_transform"), &TileMap::set_custom_transform);
-	ClassDB::bind_method(D_METHOD("get_custom_transform"), &TileMap::get_custom_transform);
+	if (tile_set->get_tile_shape() == TileSet::TILE_SHAPE_SQUARE) {
+		uvs.append(Vector2(1.0, 0.0));
+		uvs.append(Vector2(1.0, 1.0));
+		uvs.append(Vector2(0.0, 1.0));
+		uvs.append(Vector2(0.0, 0.0));
+	} else {
+		float overlap = 0.0;
+		switch (tile_set->get_tile_shape()) {
+			case TileSet::TILE_SHAPE_ISOMETRIC:
+				overlap = 0.5;
+				break;
+			case TileSet::TILE_SHAPE_HEXAGON:
+				overlap = 0.25;
+				break;
+			case TileSet::TILE_SHAPE_HALF_OFFSET_SQUARE:
+				overlap = 0.0;
+				break;
+			default:
+				break;
+		}
+		uvs.append(Vector2(1.0, overlap));
+		uvs.append(Vector2(1.0, 1.0 - overlap));
+		uvs.append(Vector2(0.5, 1.0));
+		uvs.append(Vector2(0.0, 1.0 - overlap));
+		uvs.append(Vector2(0.0, overlap));
+		uvs.append(Vector2(0.5, 0.0));
+		if (tile_set->get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
+			for (int i = 0; i < uvs.size(); i++) {
+				uvs.write[i] = Vector2(uvs[i].y, uvs[i].x);
+			}
+		}
+	}
 
-	ClassDB::bind_method(D_METHOD("set_cell_size", "size"), &TileMap::set_cell_size);
-	ClassDB::bind_method(D_METHOD("get_cell_size"), &TileMap::get_cell_size);
+	for (Set<Vector2i>::Element *E = p_cells.front(); E; E = E->next()) {
+		Vector2 top_left = map_to_world(E->get()) - tile_size / 2;
+		TypedArray<Vector2i> surrounding_tiles = get_surrounding_tiles(E->get());
+		for (int i = 0; i < surrounding_tiles.size(); i++) {
+			if (!p_cells.has(surrounding_tiles[i])) {
+				p_control->draw_line(p_transform.xform(top_left + uvs[i] * tile_size), p_transform.xform(top_left + uvs[(i + 1) % uvs.size()] * tile_size), p_color);
+			}
+		}
+	}
+}
 
-	ClassDB::bind_method(D_METHOD("_set_old_cell_size", "size"), &TileMap::_set_old_cell_size);
-	ClassDB::bind_method(D_METHOD("_get_old_cell_size"), &TileMap::_get_old_cell_size);
+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);
 
 	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_tile_origin", "origin"), &TileMap::set_tile_origin);
-	ClassDB::bind_method(D_METHOD("get_tile_origin"), &TileMap::get_tile_origin);
-
-	ClassDB::bind_method(D_METHOD("set_clip_uv", "enable"), &TileMap::set_clip_uv);
-	ClassDB::bind_method(D_METHOD("get_clip_uv"), &TileMap::get_clip_uv);
-
-	ClassDB::bind_method(D_METHOD("set_y_sort_enabled", "enable"), &TileMap::set_y_sort_enabled);
-	ClassDB::bind_method(D_METHOD("is_y_sort_enabled"), &TileMap::is_y_sort_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_compatibility_mode", "enable"), &TileMap::set_compatibility_mode);
-	ClassDB::bind_method(D_METHOD("is_compatibility_mode_enabled"), &TileMap::is_compatibility_mode_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_centered_textures", "enable"), &TileMap::set_centered_textures);
-	ClassDB::bind_method(D_METHOD("is_centered_textures_enabled"), &TileMap::is_centered_textures_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_collision_use_kinematic", "use_kinematic"), &TileMap::set_collision_use_kinematic);
-	ClassDB::bind_method(D_METHOD("get_collision_use_kinematic"), &TileMap::get_collision_use_kinematic);
-
-	ClassDB::bind_method(D_METHOD("set_collision_use_parent", "use_parent"), &TileMap::set_collision_use_parent);
-	ClassDB::bind_method(D_METHOD("get_collision_use_parent"), &TileMap::get_collision_use_parent);
-
-	ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &TileMap::set_collision_layer);
-	ClassDB::bind_method(D_METHOD("get_collision_layer"), &TileMap::get_collision_layer);
-
-	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &TileMap::set_collision_mask);
-	ClassDB::bind_method(D_METHOD("get_collision_mask"), &TileMap::get_collision_mask);
-
-	ClassDB::bind_method(D_METHOD("set_collision_layer_bit", "bit", "value"), &TileMap::set_collision_layer_bit);
-	ClassDB::bind_method(D_METHOD("get_collision_layer_bit", "bit"), &TileMap::get_collision_layer_bit);
-
-	ClassDB::bind_method(D_METHOD("set_collision_mask_bit", "bit", "value"), &TileMap::set_collision_mask_bit);
-	ClassDB::bind_method(D_METHOD("get_collision_mask_bit", "bit"), &TileMap::get_collision_mask_bit);
-
-	ClassDB::bind_method(D_METHOD("set_collision_friction", "value"), &TileMap::set_collision_friction);
-	ClassDB::bind_method(D_METHOD("get_collision_friction"), &TileMap::get_collision_friction);
-
-	ClassDB::bind_method(D_METHOD("set_collision_bounce", "value"), &TileMap::set_collision_bounce);
-	ClassDB::bind_method(D_METHOD("get_collision_bounce"), &TileMap::get_collision_bounce);
-
-	ClassDB::bind_method(D_METHOD("set_bake_navigation", "bake_navigation"), &TileMap::set_bake_navigation);
-	ClassDB::bind_method(D_METHOD("is_baking_navigation"), &TileMap::is_baking_navigation);
-
-	ClassDB::bind_method(D_METHOD("set_occluder_light_mask", "mask"), &TileMap::set_occluder_light_mask);
-	ClassDB::bind_method(D_METHOD("get_occluder_light_mask"), &TileMap::get_occluder_light_mask);
-
-	ClassDB::bind_method(D_METHOD("set_cell", "x", "y", "tile", "flip_x", "flip_y", "transpose", "autotile_coord"), &TileMap::set_cell, DEFVAL(false), DEFVAL(false), DEFVAL(false), DEFVAL(Vector2()));
-	ClassDB::bind_method(D_METHOD("set_cellv", "position", "tile", "flip_x", "flip_y", "transpose"), &TileMap::set_cellv, DEFVAL(false), DEFVAL(false), DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("_set_celld", "position", "data"), &TileMap::_set_celld);
-	ClassDB::bind_method(D_METHOD("get_cell", "x", "y"), &TileMap::get_cell);
-	ClassDB::bind_method(D_METHOD("get_cellv", "position"), &TileMap::get_cellv);
-	ClassDB::bind_method(D_METHOD("is_cell_x_flipped", "x", "y"), &TileMap::is_cell_x_flipped);
-	ClassDB::bind_method(D_METHOD("is_cell_y_flipped", "x", "y"), &TileMap::is_cell_y_flipped);
-	ClassDB::bind_method(D_METHOD("is_cell_transposed", "x", "y"), &TileMap::is_cell_transposed);
-
-	ClassDB::bind_method(D_METHOD("get_cell_autotile_coord", "x", "y"), &TileMap::get_cell_autotile_coord);
+	ClassDB::bind_method(D_METHOD("set_cell", "coords", "source_id", "atlas_coords", "alternative_tile"), &TileMap::set_cell, DEFVAL(-1), DEFVAL(TileSetAtlasSource::INVALID_ATLAS_COORDS), DEFVAL(TileSetAtlasSource::INVALID_TILE_ALTERNATIVE));
+	ClassDB::bind_method(D_METHOD("get_cell_source_id", "coords"), &TileMap::get_cell_source_id);
+	ClassDB::bind_method(D_METHOD("get_cell_atlas_coords", "coords"), &TileMap::get_cell_atlas_coords);
+	ClassDB::bind_method(D_METHOD("get_cell_alternative_tile", "coords"), &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_by_index", "index"), &TileMap::get_used_cells_by_index);
 	ClassDB::bind_method(D_METHOD("get_used_rect"), &TileMap::get_used_rect);
 
-	ClassDB::bind_method(D_METHOD("map_to_world", "map_position", "ignore_half_ofs"), &TileMap::map_to_world, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("map_to_world", "map_position"), &TileMap::map_to_world);
 	ClassDB::bind_method(D_METHOD("world_to_map", "world_position"), &TileMap::world_to_map);
 
-	ClassDB::bind_method(D_METHOD("_clear_quadrants"), &TileMap::_clear_quadrants);
-	ClassDB::bind_method(D_METHOD("update_dirty_quadrants"), &TileMap::update_dirty_quadrants);
+	ClassDB::bind_method(D_METHOD("get_neighbor_cell", "coords", "neighbor"), &TileMap::get_neighbor_cell);
 
-	ClassDB::bind_method(D_METHOD("update_bitmask_area", "position"), &TileMap::update_bitmask_area);
-	ClassDB::bind_method(D_METHOD("update_bitmask_region", "start", "end"), &TileMap::update_bitmask_region, DEFVAL(Vector2()), DEFVAL(Vector2()));
+	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);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Square,Isometric,Custom"), "set_mode", "get_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "tile_set", PROPERTY_HINT_RESOURCE_TYPE, "TileSet"), "set_tileset", "get_tileset");
-
-	ADD_GROUP("Cell", "cell_");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "cell_size", PROPERTY_HINT_RANGE, "1,8192,1"), "set_cell_size", "get_cell_size");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_quadrant_size", PROPERTY_HINT_RANGE, "1,128,1"), "set_quadrant_size", "get_quadrant_size");
-	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM2D, "cell_custom_transform"), "set_custom_transform", "get_custom_transform");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_half_offset", PROPERTY_HINT_ENUM, "Offset X,Offset Y,Disabled,Offset Negative X,Offset Negative Y"), "set_half_offset", "get_half_offset");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_tile_origin", PROPERTY_HINT_ENUM, "Top Left,Center,Bottom Left"), "set_tile_origin", "get_tile_origin");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cell_y_sort"), "set_y_sort_enabled", "is_y_sort_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "compatibility_mode"), "set_compatibility_mode", "is_compatibility_mode_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "centered_textures"), "set_centered_textures", "is_centered_textures_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cell_clip_uv"), "set_clip_uv", "get_clip_uv");
-
-	ADD_GROUP("Collision", "collision_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision_use_parent", PROPERTY_HINT_NONE, ""), "set_collision_use_parent", "get_collision_use_parent");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "collision_use_kinematic", PROPERTY_HINT_NONE, ""), "set_collision_use_kinematic", "get_collision_use_kinematic");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "collision_friction", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_collision_friction", "get_collision_friction");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "collision_bounce", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_collision_bounce", "get_collision_bounce");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_collision_layer", "get_collision_layer");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_collision_mask", "get_collision_mask");
-
-	ADD_GROUP("Occluder", "occluder_");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "occluder_light_mask", PROPERTY_HINT_LAYERS_2D_RENDER), "set_occluder_light_mask", "get_occluder_light_mask");
-
-	ADD_GROUP("Navigation", "");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bake_navigation"), "set_bake_navigation", "is_baking_navigation");
 
 	ADD_PROPERTY_DEFAULT("format", FORMAT_1);
 
-	ADD_SIGNAL(MethodInfo("settings_changed"));
-
-	BIND_CONSTANT(INVALID_CELL);
-
-	BIND_ENUM_CONSTANT(MODE_SQUARE);
-	BIND_ENUM_CONSTANT(MODE_ISOMETRIC);
-	BIND_ENUM_CONSTANT(MODE_CUSTOM);
-
-	BIND_ENUM_CONSTANT(HALF_OFFSET_X);
-	BIND_ENUM_CONSTANT(HALF_OFFSET_Y);
-	BIND_ENUM_CONSTANT(HALF_OFFSET_DISABLED);
-	BIND_ENUM_CONSTANT(HALF_OFFSET_NEGATIVE_X);
-	BIND_ENUM_CONSTANT(HALF_OFFSET_NEGATIVE_Y);
+	ADD_SIGNAL(MethodInfo("changed"));
+}
 
-	BIND_ENUM_CONSTANT(TILE_ORIGIN_TOP_LEFT);
-	BIND_ENUM_CONSTANT(TILE_ORIGIN_CENTER);
-	BIND_ENUM_CONSTANT(TILE_ORIGIN_BOTTOM_LEFT);
+void TileMap::_tile_set_changed() {
+	emit_signal("changed");
+	_make_all_quadrants_dirty(true);
 }
 
 TileMap::TileMap() {
+	rect_cache_dirty = true;
+	used_size_cache_dirty = true;
+	pending_update = false;
+	quadrant_size = 16;
+	format = FORMAT_1; // Assume lowest possible format if none is present
+
 	set_notify_transform(true);
 	set_notify_local_transform(false);
 }
 
 TileMap::~TileMap() {
-	clear();
+	if (tile_set.is_valid()) {
+		tile_set->disconnect("changed", callable_mp(this, &TileMap::_tile_set_changed));
+	}
+	_clear_quadrants();
 }
diff --git a/scene/2d/tile_map.h b/scene/2d/tile_map.h
index 9d27053fee..704897da15 100644
--- a/scene/2d/tile_map.h
+++ b/scene/2d/tile_map.h
@@ -34,193 +34,194 @@
 #include "core/templates/self_list.h"
 #include "core/templates/vset.h"
 #include "scene/2d/node_2d.h"
+#include "scene/gui/control.h"
 #include "scene/resources/tile_set.h"
 
-class CollisionObject2D;
+class TileSetAtlasSource;
 
-class TileMap : public Node2D {
-	GDCLASS(TileMap, Node2D);
-
-public:
-	enum Mode {
-		MODE_SQUARE,
-		MODE_ISOMETRIC,
-		MODE_CUSTOM
+union TileMapCell {
+	struct {
+		int32_t source_id : 16;
+		int16_t coord_x : 16;
+		int16_t coord_y : 16;
+		int32_t alternative_tile : 16;
 	};
 
-	enum HalfOffset {
-		HALF_OFFSET_X,
-		HALF_OFFSET_Y,
-		HALF_OFFSET_DISABLED,
-		HALF_OFFSET_NEGATIVE_X,
-		HALF_OFFSET_NEGATIVE_Y,
-	};
+	uint64_t _u64t;
+	TileMapCell(int p_source_id = -1, Vector2i p_atlas_coords = TileSetAtlasSource::INVALID_ATLAS_COORDS, int p_alternative_tile = TileSetAtlasSource::INVALID_TILE_ALTERNATIVE) {
+		source_id = p_source_id;
+		set_atlas_coords(p_atlas_coords);
+		alternative_tile = p_alternative_tile;
+	}
+
+	Vector2i get_atlas_coords() const {
+		return Vector2i(coord_x, coord_y);
+	}
+
+	void set_atlas_coords(const Vector2i &r_coords) {
+		coord_x = r_coords.x;
+		coord_y = r_coords.y;
+	}
+
+	bool operator<(const TileMapCell &p_other) const {
+		if (source_id == p_other.source_id) {
+			if (coord_x == p_other.coord_x) {
+				if (coord_y == p_other.coord_y) {
+					return alternative_tile < p_other.alternative_tile;
+				} else {
+					return coord_y < p_other.coord_y;
+				}
+			} else {
+				return coord_x < p_other.coord_x;
+			}
+		} else {
+			return source_id < p_other.source_id;
+		}
+	}
 
-	enum TileOrigin {
-		TILE_ORIGIN_TOP_LEFT,
-		TILE_ORIGIN_CENTER,
-		TILE_ORIGIN_BOTTOM_LEFT
-	};
+	bool operator!=(const TileMapCell &p_other) const {
+		return !(source_id == p_other.source_id && coord_x == p_other.coord_x && coord_y == p_other.coord_y && alternative_tile == p_other.alternative_tile);
+	}
+};
 
-private:
-	enum DataFormat {
-		FORMAT_1 = 0,
-		FORMAT_2
+struct TileMapQuadrant {
+	struct CoordsWorldComparator {
+		_ALWAYS_INLINE_ bool operator()(const Vector2i &p_a, const Vector2i &p_b) const {
+			// We sort the cells by their world coords, as it is needed by rendering.
+			if (p_a.y == p_b.y) {
+				return p_a.x > p_b.x;
+			} else {
+				return p_a.y < p_b.y;
+			}
+		}
 	};
 
-	Ref<TileSet> tile_set;
-	Size2i cell_size = Size2(64, 64);
-	int quadrant_size = 16;
-	Mode mode = MODE_SQUARE;
-	Transform2D custom_transform = Transform2D(64, 0, 0, 64, 0, 0);
-	HalfOffset half_offset = HALF_OFFSET_DISABLED;
-	bool use_parent = false;
-	CollisionObject2D *collision_parent = nullptr;
-	bool use_kinematic = false;
-	bool bake_navigation = false;
-
-	union PosKey {
-		struct {
-			int16_t x;
-			int16_t y;
-		};
-		uint32_t key = 0;
-
-		//using a more precise comparison so the regions can be sorted later
-		bool operator<(const PosKey &p_k) const { return (y == p_k.y) ? x < p_k.x : y < p_k.y; }
-
-		bool operator==(const PosKey &p_k) const { return (y == p_k.y && x == p_k.x); }
-
-		PosKey to_quadrant(const int &p_quadrant_size) const {
-			// rounding down, instead of simply rounding towards zero (truncating)
-			return PosKey(
-					x > 0 ? x / p_quadrant_size : (x - (p_quadrant_size - 1)) / p_quadrant_size,
-					y > 0 ? y / p_quadrant_size : (y - (p_quadrant_size - 1)) / p_quadrant_size);
-		}
+	// Dirty list element
+	SelfList<TileMapQuadrant> dirty_list_element;
+
+	// Quadrant coords.
+	Vector2i coords;
+
+	// TileMapCells
+	Set<Vector2i> cells;
+	// We need those two maps to sort by world position for rendering
+	// This is kind of workaround, it would be better to sort the cells directly in the "cells" set instead.
+	Map<Vector2i, Vector2i> map_to_world;
+	Map<Vector2i, Vector2i, CoordsWorldComparator> world_to_map;
+
+	// Debug.
+	RID debug_canvas_item;
+
+	// Rendering
+	List<RID> canvas_items;
+	List<RID> occluders;
+
+	// Physics.
+	List<RID> bodies;
+
+	// Navigation
+	Map<Vector2i, Vector<RID>> navigation_regions;
+
+	void operator=(const TileMapQuadrant &q) {
+		coords = q.coords;
+		debug_canvas_item = q.debug_canvas_item;
+		canvas_items = q.canvas_items;
+		occluders = q.occluders;
+		bodies = q.bodies;
+		navigation_regions = q.navigation_regions;
+	}
+
+	TileMapQuadrant(const TileMapQuadrant &q) :
+			dirty_list_element(this) {
+		coords = q.coords;
+		debug_canvas_item = q.debug_canvas_item;
+		canvas_items = q.canvas_items;
+		occluders = q.occluders;
+		bodies = q.bodies;
+		navigation_regions = q.navigation_regions;
+	}
+
+	TileMapQuadrant() :
+			dirty_list_element(this) {
+	}
+};
 
-		PosKey(int16_t p_x, int16_t p_y) {
-			x = p_x;
-			y = p_y;
-		}
-		PosKey() {
-			x = 0;
-			y = 0;
-		}
-	};
+class TileMapPattern : public Object {
+	GDCLASS(TileMapPattern, Object);
 
-	union Cell {
-		struct {
-			int32_t id : 24;
-			bool flip_h : 1;
-			bool flip_v : 1;
-			bool transpose : 1;
-			int16_t autotile_coord_x : 16;
-			int16_t autotile_coord_y : 16;
-		};
-
-		uint64_t _u64t = 0;
-	};
+	Vector2i size;
+	Map<Vector2i, TileMapCell> pattern;
 
-	Map<PosKey, Cell> tile_map;
-	List<PosKey> dirty_bitmask;
+protected:
+	static void _bind_methods();
 
-	struct Quadrant {
-		Vector2 pos;
-		List<RID> canvas_items;
-		RID body;
-		uint32_t shape_owner_id = 0;
+public:
+	void set_cell(const Vector2i &p_coords, int p_source_id, const Vector2i p_atlas_coords, int p_alternative_tile = 0);
+	bool has_cell(const Vector2i &p_coords) const;
+	void remove_cell(const Vector2i &p_coords, bool p_update_size = true);
+	int get_cell_source_id(const Vector2i &p_coords) const;
+	Vector2i get_cell_atlas_coords(const Vector2i &p_coords) const;
+	int get_cell_alternative_tile(const Vector2i &p_coords) const;
 
-		SelfList<Quadrant> dirty_list;
+	TypedArray<Vector2i> get_used_cells() const;
 
-		struct NavPoly {
-			RID region;
-			Transform2D xform;
-		};
+	Vector2i get_size() const;
+	void set_size(const Vector2i &p_size);
+	bool is_empty() const;
 
-		struct Occluder {
-			RID id;
-			Transform2D xform;
-		};
+	void clear();
+};
 
-		Map<PosKey, NavPoly> navpoly_ids;
-		Map<PosKey, Occluder> occluder_instances;
+class TileMap : public Node2D {
+	GDCLASS(TileMap, Node2D);
 
-		VSet<PosKey> cells;
+public:
+private:
+	friend class TileSetPlugin;
 
-		void operator=(const Quadrant &q) {
-			pos = q.pos;
-			canvas_items = q.canvas_items;
-			body = q.body;
-			shape_owner_id = q.shape_owner_id;
-			cells = q.cells;
-			navpoly_ids = q.navpoly_ids;
-			occluder_instances = q.occluder_instances;
-		}
-		Quadrant(const Quadrant &q) :
-				dirty_list(this) {
-			pos = q.pos;
-			canvas_items = q.canvas_items;
-			body = q.body;
-			shape_owner_id = q.shape_owner_id;
-			cells = q.cells;
-			occluder_instances = q.occluder_instances;
-			navpoly_ids = q.navpoly_ids;
-		}
-		Quadrant() :
-				dirty_list(this) {}
+	enum DataFormat {
+		FORMAT_1 = 0,
+		FORMAT_2,
+		FORMAT_3
 	};
 
-	Map<PosKey, Quadrant> quadrant_map;
+	Ref<TileSet> tile_set;
+	int quadrant_size;
+	Transform2D custom_transform;
+
+	// Map of cells
+	Map<Vector2i, TileMapCell> tile_map;
 
-	SelfList<Quadrant>::List dirty_quadrant_list;
+	Vector2i _coords_to_quadrant_coords(const Vector2i &p_coords) const;
+
+	Map<Vector2i, TileMapQuadrant> quadrant_map;
+
+	SelfList<TileMapQuadrant>::List dirty_quadrant_list;
 
 	bool pending_update = false;
 
 	Rect2 rect_cache;
 	bool rect_cache_dirty = true;
 	Rect2 used_size_cache;
-	bool used_size_cache_dirty = true;
-	bool quadrant_order_dirty = false;
-	bool use_y_sort = false;
-	bool compatibility_mode = false;
-	bool centered_textures = false;
-	bool clip_uv = false;
-	float fp_adjust = 0.00001;
-	float friction = 1.0;
-	float bounce = 0.0;
-	uint32_t collision_layer = 1;
-	uint32_t collision_mask = 1;
-	mutable DataFormat format = FORMAT_1; // Assume lowest possible format if none is present
-
-	TileOrigin tile_origin = TILE_ORIGIN_TOP_LEFT;
-
-	int occluder_light_mask = 1;
-
-	void _fix_cell_transform(Transform2D &xform, const Cell &p_cell, const Vector2 &p_offset, const Size2 &p_sc);
-
-	void _add_shape(int &shape_idx, const Quadrant &p_q, const Ref<Shape2D> &p_shape, const TileSet::ShapeData &p_shape_data, const Transform2D &p_xform, const Vector2 &p_metadata);
-
-	Map<PosKey, Quadrant>::Element *_create_quadrant(const PosKey &p_qk);
-	void _erase_quadrant(Map<PosKey, Quadrant>::Element *Q);
-	void _make_quadrant_dirty(Map<PosKey, Quadrant>::Element *Q, bool update = true);
+	bool used_size_cache_dirty;
+	mutable DataFormat format;
+
+	void _fix_cell_transform(Transform2D &xform, const TileMapCell &p_cell, const Vector2 &p_offset, const Size2 &p_sc);
+
+	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 _update_quadrant_space(const RID &p_space);
-	void _update_quadrant_transform();
 	void _recompute_rect_cache();
 
 	void _update_all_items_material_state();
-	_FORCE_INLINE_ void _update_item_material_state(const RID &p_canvas_item);
-
-	_FORCE_INLINE_ int _get_quadrant_size() const;
 
 	void _set_tile_data(const Vector<int> &p_data);
 	Vector<int> _get_tile_data() const;
 
-	void _set_old_cell_size(int p_size) { set_cell_size(Size2(p_size, p_size)); }
-	int _get_old_cell_size() const { return cell_size.x; }
-
-	_FORCE_INLINE_ Vector2 _map_to_world(int p_x, int p_y, bool p_ignore_ofs = false) const;
+	void _tile_set_changed();
 
 protected:
 	bool _set(const StringName &p_name, const Variant &p_value);
@@ -230,9 +231,9 @@ protected:
 	void _notification(int p_what);
 	static void _bind_methods();
 
-	virtual void _validate_property(PropertyInfo &property) const override;
-
 public:
+	static Vector2i transform_coords_layout(Vector2i p_coords, TileSet::TileOffsetAxis p_offset_axis, TileSet::TileLayout p_from_layout, TileSet::TileLayout p_to_layout);
+
 	enum {
 		INVALID_CELL = -1
 	};
@@ -244,117 +245,49 @@ public:
 	void set_tileset(const Ref<TileSet> &p_tileset);
 	Ref<TileSet> get_tileset() const;
 
-	void set_cell_size(Size2 p_size);
-	Size2 get_cell_size() const;
-
 	void set_quadrant_size(int p_size);
 	int get_quadrant_size() const;
 
-	void set_cell(int p_x, int p_y, int p_tile, bool p_flip_x = false, bool p_flip_y = false, bool p_transpose = false, Vector2 p_autotile_coord = Vector2());
-	int get_cell(int p_x, int p_y) const;
-	bool is_cell_x_flipped(int p_x, int p_y) const;
-	bool is_cell_y_flipped(int p_x, int p_y) const;
-	bool is_cell_transposed(int p_x, int p_y) const;
-	void set_cell_autotile_coord(int p_x, int p_y, const Vector2 &p_coord);
-	Vector2 get_cell_autotile_coord(int p_x, int p_y) const;
+	void set_cell(const Vector2i &p_coords, int p_source_id = -1, const Vector2i p_atlas_coords = TileSetAtlasSource::INVALID_ATLAS_COORDS, int p_alternative_tile = TileSetAtlasSource::INVALID_TILE_ALTERNATIVE);
+	int get_cell_source_id(const Vector2i &p_coords) const;
+	Vector2i get_cell_atlas_coords(const Vector2i &p_coords) const;
+	int get_cell_alternative_tile(const Vector2i &p_coords) const;
 
-	void _set_celld(const Vector2 &p_pos, const Dictionary &p_data);
-	void set_cellv(const Vector2 &p_pos, int p_tile, bool p_flip_x = false, bool p_flip_y = false, bool p_transpose = false);
-	int get_cellv(const Vector2 &p_pos) const;
+	TileMapPattern *get_pattern(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 make_bitmask_area_dirty(const Vector2 &p_pos);
-	void update_bitmask_area(const Vector2 &p_pos);
-	void update_bitmask_region(const Vector2 &p_start = Vector2(), const Vector2 &p_end = Vector2());
-	void update_cell_bitmask(int p_x, int p_y);
-	void update_dirty_bitmask();
+	// Not exposed to users
+	TileMapCell get_cell(const Vector2i &p_coords) const;
+	Map<Vector2i, TileMapQuadrant> &get_quadrant_map();
+	int get_effective_quadrant_size() const;
 
 	void update_dirty_quadrants();
 
-	void set_collision_layer(uint32_t p_layer);
-	uint32_t get_collision_layer() const;
-
-	void set_collision_mask(uint32_t p_mask);
-	uint32_t get_collision_mask() const;
-
-	void set_collision_layer_bit(int p_bit, bool p_value);
-	bool get_collision_layer_bit(int p_bit) const;
-
-	void set_collision_mask_bit(int p_bit, bool p_value);
-	bool get_collision_mask_bit(int p_bit) const;
-
-	void set_collision_use_kinematic(bool p_use_kinematic);
-	bool get_collision_use_kinematic() const;
-
-	void set_collision_use_parent(bool p_use_parent);
-	bool get_collision_use_parent() const;
-
-	void set_collision_friction(float p_friction);
-	float get_collision_friction() const;
-
-	void set_collision_bounce(float p_bounce);
-	float get_collision_bounce() const;
-
-	void set_bake_navigation(bool p_bake_navigation);
-	bool is_baking_navigation();
-
-	void set_mode(Mode p_mode);
-	Mode get_mode() const;
+	Vector2 map_to_world(const Vector2 &p_pos) const;
+	Vector2i world_to_map(const Vector2 &p_pos) const;
 
-	void set_half_offset(HalfOffset p_half_offset);
-	HalfOffset get_half_offset() const;
-
-	void set_tile_origin(TileOrigin p_tile_origin);
-	TileOrigin get_tile_origin() const;
-
-	void set_custom_transform(const Transform2D &p_xform);
-	Transform2D get_custom_transform() const;
-
-	Transform2D get_cell_transform() const;
-	Vector2 get_cell_draw_offset() const;
-
-	Vector2 map_to_world(const Vector2 &p_pos, bool p_ignore_ofs = false) const;
-	Vector2 world_to_map(const Vector2 &p_pos) const;
-
-	void set_y_sort_enabled(bool p_enable);
-	bool is_y_sort_enabled() const;
-
-	void set_compatibility_mode(bool p_enable);
-	bool is_compatibility_mode_enabled() const;
-
-	void set_centered_textures(bool p_enable);
-	bool is_centered_textures_enabled() const;
+	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_by_index(int p_index) const;
 	Rect2 get_used_rect(); // Not const because of cache
 
-	void set_occluder_light_mask(int p_mask);
-	int get_occluder_light_mask() const;
-
+	// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems
 	virtual void set_light_mask(int p_light_mask) override;
-
 	virtual void set_material(const Ref<Material> &p_material) override;
-
 	virtual void set_use_parent_material(bool p_use_parent_material) override;
-
-	void set_clip_uv(bool p_enable);
-	bool get_clip_uv() const;
-
-	TypedArray<String> get_configuration_warnings() const override;
-
 	virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter) override;
-
 	virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) override;
 
 	void fix_invalid_tiles();
 	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());
+
 	TileMap();
 	~TileMap();
 };
-
-VARIANT_ENUM_CAST(TileMap::Mode);
-VARIANT_ENUM_CAST(TileMap::HalfOffset);
-VARIANT_ENUM_CAST(TileMap::TileOrigin);
-
 #endif // TILE_MAP_H
diff --git a/scene/gui/item_list.cpp b/scene/gui/item_list.cpp
index 4fddb4b661..0bdae2b118 100644
--- a/scene/gui/item_list.cpp
+++ b/scene/gui/item_list.cpp
@@ -406,6 +406,9 @@ void ItemList::remove_item(int p_idx) {
 	ERR_FAIL_INDEX(p_idx, items.size());
 
 	items.remove(p_idx);
+	if (current == p_idx) {
+		current = -1;
+	}
 	update();
 	shape_changed = true;
 	defer_select_single = -1;
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index b16532676f..5b5eb946f0 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -655,6 +655,9 @@ void register_scene_types() {
 	ClassDB::register_class<GrooveJoint2D>();
 	ClassDB::register_class<DampedSpringJoint2D>();
 	ClassDB::register_class<TileSet>();
+	ClassDB::register_virtual_class<TileSetSource>();
+	ClassDB::register_class<TileSetAtlasSource>();
+	ClassDB::register_class<TileData>();
 	ClassDB::register_class<TileMap>();
 	ClassDB::register_class<ParallaxBackground>();
 	ClassDB::register_class<ParallaxLayer>();
diff --git a/scene/resources/tile_set.cpp b/scene/resources/tile_set.cpp
index 84be69d0d6..c4b8a56f54 100644
--- a/scene/resources/tile_set.cpp
+++ b/scene/resources/tile_set.cpp
@@ -30,1150 +30,4221 @@
 
 #include "tile_set.h"
 
-#include "core/config/engine.h"
 #include "core/math/geometry_2d.h"
-#include "core/variant/array.h"
+#include "scene/2d/navigation_region_2d.h"
+#include "scene/gui/control.h"
+#include "scene/resources/convex_polygon_shape_2d.h"
+#include "servers/navigation_server_2d.h"
 
-bool TileSet::_set(const StringName &p_name, const Variant &p_value) {
-	String n = p_name;
-	int slash = n.find("/");
-	if (slash == -1) {
-		return false;
-	}
-	int id = String::to_int(n.get_data(), slash);
-
-	if (!tile_map.has(id)) {
-		create_tile(id);
-	}
-	String what = n.substr(slash + 1, n.length());
-
-	if (what == "name") {
-		tile_set_name(id, p_value);
-	} else if (what == "texture") {
-		tile_set_texture(id, p_value);
-	} else if (what == "tex_offset") {
-		tile_set_texture_offset(id, p_value);
-	} else if (what == "material") {
-		tile_set_material(id, p_value);
-	} else if (what == "modulate") {
-		tile_set_modulate(id, p_value);
-	} else if (what == "region") {
-		tile_set_region(id, p_value);
-	} else if (what == "tile_mode") {
-		tile_set_tile_mode(id, (TileMode)((int)p_value));
-	} else if (what == "is_autotile") {
-		// backward compatibility for Godot 3.0.x
-		// autotile used to be a bool, it's now an enum
-		bool is_autotile = p_value;
-		if (is_autotile) {
-			tile_set_tile_mode(id, AUTO_TILE);
-		}
-	} else if (what.left(9) == "autotile/") {
-		what = what.right(9);
-		if (what == "bitmask_mode") {
-			autotile_set_bitmask_mode(id, (BitmaskMode)((int)p_value));
-		} else if (what == "icon_coordinate") {
-			autotile_set_icon_coordinate(id, p_value);
-		} else if (what == "tile_size") {
-			autotile_set_size(id, p_value);
-		} else if (what == "spacing") {
-			autotile_set_spacing(id, p_value);
-		} else if (what == "bitmask_flags") {
-			tile_map[id].autotile_data.flags.clear();
-			if (p_value.is_array()) {
-				Array p = p_value;
-				Vector2 last_coord;
-				while (p.size() > 0) {
-					if (p[0].get_type() == Variant::VECTOR2) {
-						last_coord = p[0];
-					} else if (p[0].get_type() == Variant::INT) {
-						autotile_set_bitmask(id, last_coord, p[0]);
-					}
-					p.pop_front();
-				}
-			}
-		} else if (what == "occluder_map") {
-			tile_map[id].autotile_data.occluder_map.clear();
-			Array p = p_value;
-			Vector2 last_coord;
-			while (p.size() > 0) {
-				if (p[0].get_type() == Variant::VECTOR2) {
-					last_coord = p[0];
-				} else if (p[0].get_type() == Variant::OBJECT) {
-					autotile_set_light_occluder(id, p[0], last_coord);
-				}
-				p.pop_front();
-			}
-		} else if (what == "navpoly_map") {
-			tile_map[id].autotile_data.navpoly_map.clear();
-			Array p = p_value;
-			Vector2 last_coord;
-			while (p.size() > 0) {
-				if (p[0].get_type() == Variant::VECTOR2) {
-					last_coord = p[0];
-				} else if (p[0].get_type() == Variant::OBJECT) {
-					autotile_set_navigation_polygon(id, p[0], last_coord);
-				}
-				p.pop_front();
-			}
-		} else if (what == "priority_map") {
-			tile_map[id].autotile_data.priority_map.clear();
-			Array p = p_value;
-			Vector3 val;
-			Vector2 v;
-			int priority;
-			while (p.size() > 0) {
-				val = p[0];
-				if (val.z > 1) {
-					v.x = val.x;
-					v.y = val.y;
-					priority = (int)val.z;
-					tile_map[id].autotile_data.priority_map[v] = priority;
-				}
-				p.pop_front();
-			}
-		} else if (what == "z_index_map") {
-			tile_map[id].autotile_data.z_index_map.clear();
-			Array p = p_value;
-			Vector3 val;
-			Vector2 v;
-			int z_index;
-			while (p.size() > 0) {
-				val = p[0];
-				if (val.z != 0) {
-					v.x = val.x;
-					v.y = val.y;
-					z_index = (int)val.z;
-					tile_map[id].autotile_data.z_index_map[v] = z_index;
-				}
-				p.pop_front();
-			}
-		}
-	} else if (what == "shape") {
-		if (tile_get_shape_count(id) > 0) {
-			for (int i = 0; i < tile_get_shape_count(id); i++) {
-				tile_set_shape(id, i, p_value);
-			}
-		} else {
-			tile_set_shape(id, 0, p_value);
-		}
-	} else if (what == "shape_offset") {
-		if (tile_get_shape_count(id) > 0) {
-			for (int i = 0; i < tile_get_shape_count(id); i++) {
-				tile_set_shape_offset(id, i, p_value);
-			}
-		} else {
-			tile_set_shape_offset(id, 0, p_value);
-		}
-	} else if (what == "shape_transform") {
-		if (tile_get_shape_count(id) > 0) {
-			for (int i = 0; i < tile_get_shape_count(id); i++) {
-				tile_set_shape_transform(id, i, p_value);
-			}
-		} else {
-			tile_set_shape_transform(id, 0, p_value);
-		}
-	} else if (what == "shape_one_way") {
-		if (tile_get_shape_count(id) > 0) {
-			for (int i = 0; i < tile_get_shape_count(id); i++) {
-				tile_set_shape_one_way(id, i, p_value);
-			}
-		} else {
-			tile_set_shape_one_way(id, 0, p_value);
-		}
-	} else if (what == "shape_one_way_margin") {
-		if (tile_get_shape_count(id) > 0) {
-			for (int i = 0; i < tile_get_shape_count(id); i++) {
-				tile_set_shape_one_way_margin(id, i, p_value);
-			}
-		} else {
-			tile_set_shape_one_way_margin(id, 0, p_value);
-		}
-	} else if (what == "shapes") {
-		_tile_set_shapes(id, p_value);
-	} else if (what == "occluder") {
-		tile_set_light_occluder(id, p_value);
-	} else if (what == "occluder_offset") {
-		tile_set_occluder_offset(id, p_value);
-	} else if (what == "navigation") {
-		tile_set_navigation_polygon(id, p_value);
-	} else if (what == "navigation_offset") {
-		tile_set_navigation_polygon_offset(id, p_value);
-	} else if (what == "z_index") {
-		tile_set_z_index(id, p_value);
-	} else {
-		return false;
-	}
+/////////////////////////////// TileSet //////////////////////////////////////
 
-	return true;
+// --- Plugins ---
+Vector<TileSetPlugin *> TileSet::get_tile_set_atlas_plugins() const {
+	return tile_set_plugins_vector;
 }
 
-bool TileSet::_get(const StringName &p_name, Variant &r_ret) const {
-	String n = p_name;
-	int slash = n.find("/");
-	if (slash == -1) {
-		return false;
+// -- Shape and layout --
+void TileSet::set_tile_shape(TileSet::TileShape p_shape) {
+	tile_shape = p_shape;
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
 	}
-	int id = String::to_int(n.get_data(), slash);
-
-	ERR_FAIL_COND_V(!tile_map.has(id), false);
-
-	String what = n.substr(slash + 1, n.length());
-
-	if (what == "name") {
-		r_ret = tile_get_name(id);
-	} else if (what == "texture") {
-		r_ret = tile_get_texture(id);
-	} else if (what == "tex_offset") {
-		r_ret = tile_get_texture_offset(id);
-	} else if (what == "material") {
-		r_ret = tile_get_material(id);
-	} else if (what == "modulate") {
-		r_ret = tile_get_modulate(id);
-	} else if (what == "region") {
-		r_ret = tile_get_region(id);
-	} else if (what == "tile_mode") {
-		r_ret = tile_get_tile_mode(id);
-	} else if (what.left(9) == "autotile/") {
-		what = what.right(9);
-		if (what == "bitmask_mode") {
-			r_ret = autotile_get_bitmask_mode(id);
-		} else if (what == "icon_coordinate") {
-			r_ret = autotile_get_icon_coordinate(id);
-		} else if (what == "tile_size") {
-			r_ret = autotile_get_size(id);
-		} else if (what == "spacing") {
-			r_ret = autotile_get_spacing(id);
-		} else if (what == "bitmask_flags") {
-			Array p;
-			for (Map<Vector2, uint32_t>::Element *E = tile_map[id].autotile_data.flags.front(); E; E = E->next()) {
-				p.push_back(E->key());
-				p.push_back(E->value());
-			}
-			r_ret = p;
-		} else if (what == "occluder_map") {
-			Array p;
-			for (Map<Vector2, Ref<OccluderPolygon2D>>::Element *E = tile_map[id].autotile_data.occluder_map.front(); E; E = E->next()) {
-				p.push_back(E->key());
-				p.push_back(E->value());
-			}
-			r_ret = p;
-		} else if (what == "navpoly_map") {
-			Array p;
-			for (Map<Vector2, Ref<NavigationPolygon>>::Element *E = tile_map[id].autotile_data.navpoly_map.front(); E; E = E->next()) {
-				p.push_back(E->key());
-				p.push_back(E->value());
-			}
-			r_ret = p;
-		} else if (what == "priority_map") {
-			Array p;
-			Vector3 v;
-			for (Map<Vector2, int>::Element *E = tile_map[id].autotile_data.priority_map.front(); E; E = E->next()) {
-				if (E->value() > 1) {
-					//Don't save default value
-					v.x = E->key().x;
-					v.y = E->key().y;
-					v.z = E->value();
-					p.push_back(v);
-				}
-			}
-			r_ret = p;
-		} else if (what == "z_index_map") {
-			Array p;
-			Vector3 v;
-			for (Map<Vector2, int>::Element *E = tile_map[id].autotile_data.z_index_map.front(); E; E = E->next()) {
-				if (E->value() != 0) {
-					//Don't save default value
-					v.x = E->key().x;
-					v.y = E->key().y;
-					v.z = E->value();
-					p.push_back(v);
-				}
-			}
-			r_ret = p;
-		}
-	} else if (what == "shape") {
-		r_ret = tile_get_shape(id, 0);
-	} else if (what == "shape_offset") {
-		r_ret = tile_get_shape_offset(id, 0);
-	} else if (what == "shape_transform") {
-		r_ret = tile_get_shape_transform(id, 0);
-	} else if (what == "shape_one_way") {
-		r_ret = tile_get_shape_one_way(id, 0);
-	} else if (what == "shape_one_way_margin") {
-		r_ret = tile_get_shape_one_way_margin(id, 0);
-	} else if (what == "shapes") {
-		r_ret = _tile_get_shapes(id);
-	} else if (what == "occluder") {
-		r_ret = tile_get_light_occluder(id);
-	} else if (what == "occluder_offset") {
-		r_ret = tile_get_occluder_offset(id);
-	} else if (what == "navigation") {
-		r_ret = tile_get_navigation_polygon(id);
-	} else if (what == "navigation_offset") {
-		r_ret = tile_get_navigation_polygon_offset(id);
-	} else if (what == "z_index") {
-		r_ret = tile_get_z_index(id);
-	} else {
-		return false;
+
+	emit_changed();
+}
+TileSet::TileShape TileSet::get_tile_shape() const {
+	return tile_shape;
+}
+
+void TileSet::set_tile_layout(TileSet::TileLayout p_layout) {
+	tile_layout = p_layout;
+	emit_changed();
+}
+TileSet::TileLayout TileSet::get_tile_layout() const {
+	return tile_layout;
+}
+
+void TileSet::set_tile_offset_axis(TileSet::TileOffsetAxis p_alignment) {
+	tile_offset_axis = p_alignment;
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
 	}
 
-	return true;
+	emit_changed();
+}
+TileSet::TileOffsetAxis TileSet::get_tile_offset_axis() const {
+	return tile_offset_axis;
 }
 
-void TileSet::_get_property_list(List<PropertyInfo> *p_list) const {
-	for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
-		int id = E->key();
-		String pre = itos(id) + "/";
-		p_list->push_back(PropertyInfo(Variant::STRING, pre + "name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "tex_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::COLOR, pre + "modulate", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::RECT2, pre + "region", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::INT, pre + "tile_mode", PROPERTY_HINT_ENUM, "SINGLE_TILE,AUTO_TILE,ATLAS_TILE", PROPERTY_USAGE_NOEDITOR));
-		if (tile_get_tile_mode(id) == AUTO_TILE) {
-			p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/bitmask_mode", PROPERTY_HINT_ENUM, "2X2,3X3 (minimal),3X3", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/bitmask_flags", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/icon_coordinate", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/tile_size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/spacing", PROPERTY_HINT_RANGE, "0,256,1", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/occluder_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/navpoly_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/priority_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/z_index_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-		} else if (tile_get_tile_mode(id) == ATLAS_TILE) {
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/icon_coordinate", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "autotile/tile_size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::INT, pre + "autotile/spacing", PROPERTY_HINT_RANGE, "0,256,1", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/occluder_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/navpoly_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/priority_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-			p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "autotile/z_index_map", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
-		}
-		p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "occluder_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "occluder", PROPERTY_HINT_RESOURCE_TYPE, "OccluderPolygon2D", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "navigation_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "navigation", PROPERTY_HINT_RESOURCE_TYPE, "NavigationPolygon", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "shape_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::VECTOR2, pre + "shape_transform", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::OBJECT, pre + "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape2D", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::BOOL, pre + "shape_one_way", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::FLOAT, pre + "shape_one_way_margin", PROPERTY_HINT_RANGE, "0,128,0.01", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::ARRAY, pre + "shapes", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
-		p_list->push_back(PropertyInfo(Variant::INT, pre + "z_index", PROPERTY_HINT_RANGE, itos(RS::CANVAS_ITEM_Z_MIN) + "," + itos(RS::CANVAS_ITEM_Z_MAX) + ",1", PROPERTY_USAGE_NOEDITOR));
-	}
-}
-
-void TileSet::create_tile(int p_id) {
-	ERR_FAIL_COND(tile_map.has(p_id));
-	tile_map[p_id] = TileData();
-	tile_map[p_id].autotile_data = AutotileData();
-	notify_property_list_changed();
+void TileSet::set_tile_size(Size2i p_size) {
+	ERR_FAIL_COND(p_size.x < 1 || p_size.y < 1);
+	tile_size = p_size;
 	emit_changed();
 }
+Size2i TileSet::get_tile_size() const {
+	return tile_size;
+}
 
-void TileSet::autotile_set_bitmask_mode(int p_id, BitmaskMode p_mode) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].autotile_data.bitmask_mode = p_mode;
-	notify_property_list_changed();
+void TileSet::set_tile_skew(Vector2 p_skew) {
 	emit_changed();
+	tile_skew = p_skew;
+}
+Vector2 TileSet::get_tile_skew() const {
+	return tile_skew;
+}
+
+int TileSet::get_next_source_id() const {
+	return next_source_id;
 }
 
-TileSet::BitmaskMode TileSet::autotile_get_bitmask_mode(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), BITMASK_2X2);
-	return tile_map[p_id].autotile_data.bitmask_mode;
+void TileSet::_compute_next_source_id() {
+	while (sources.has(next_source_id)) {
+		next_source_id = (next_source_id + 1) % 1073741824; // 2 ** 30
+	};
 }
 
-void TileSet::tile_set_texture(int p_id, const Ref<Texture2D> &p_texture) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].texture = p_texture;
+// Sources management
+int TileSet::add_source(Ref<TileSetAtlasSource> p_tile_atlas_source, int p_atlas_source_id_override) {
+	ERR_FAIL_COND_V(!p_tile_atlas_source.is_valid(), -1);
+	ERR_FAIL_COND_V_MSG(p_atlas_source_id_override >= 0 && (sources.has(p_atlas_source_id_override)), -1, vformat("Cannot create TileSet atlas source. Another atlas source exists with id %d.", p_atlas_source_id_override));
+
+	int new_source_id = p_atlas_source_id_override >= 0 ? p_atlas_source_id_override : next_source_id;
+	sources[new_source_id] = p_tile_atlas_source;
+	source_ids.append(new_source_id);
+	source_ids.sort();
+	p_tile_atlas_source->set_tile_set(this);
+	_compute_next_source_id();
+
+	sources[new_source_id]->connect("changed", callable_mp(this, &TileSet::_source_changed));
+
 	emit_changed();
+
+	return new_source_id;
 }
 
-Ref<Texture2D> TileSet::tile_get_texture(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<Texture2D>());
-	return tile_map[p_id].texture;
+void TileSet::remove_source(int p_source_id) {
+	ERR_FAIL_COND_MSG(!sources.has(p_source_id), vformat("Cannot remove TileSet atlas source. No tileset atlas source with id %d.", p_source_id));
+
+	sources[p_source_id]->disconnect("changed", callable_mp(this, &TileSet::_source_changed));
+
+	sources[p_source_id]->set_tile_set(nullptr);
+	sources.erase(p_source_id);
+	source_ids.erase(p_source_id);
+	source_ids.sort();
+
+	emit_changed();
 }
 
-void TileSet::tile_set_material(int p_id, const Ref<ShaderMaterial> &p_material) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].material = p_material;
+void TileSet::set_source_id(int p_source_id, int p_new_source_id) {
+	ERR_FAIL_COND(p_new_source_id < 0);
+	ERR_FAIL_COND_MSG(!sources.has(p_source_id), vformat("Cannot change TileSet atlas source ID. No tileset atlas source with id %d.", p_source_id));
+	if (p_source_id == p_new_source_id) {
+		return;
+	}
+
+	ERR_FAIL_COND_MSG(sources.has(p_new_source_id), vformat("Cannot change TileSet atlas source ID. Another atlas source exists with id %d.", p_new_source_id));
+
+	sources[p_new_source_id] = sources[p_source_id];
+	sources.erase(p_source_id);
+
+	source_ids.erase(p_source_id);
+	source_ids.append(p_new_source_id);
+	source_ids.sort();
+
 	emit_changed();
 }
 
-Ref<ShaderMaterial> TileSet::tile_get_material(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<ShaderMaterial>());
-	return tile_map[p_id].material;
+bool TileSet::has_source(int p_source_id) const {
+	return sources.has(p_source_id);
+}
+
+Ref<TileSetSource> TileSet::get_source(int p_source_id) const {
+	ERR_FAIL_COND_V_MSG(!sources.has(p_source_id), nullptr, vformat("No TileSet atlas source with id %d.", p_source_id));
+
+	return sources[p_source_id];
+}
+
+int TileSet::get_source_count() const {
+	return source_ids.size();
 }
 
-void TileSet::tile_set_modulate(int p_id, const Color &p_modulate) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].modulate = p_modulate;
+int TileSet::get_source_id(int p_index) const {
+	ERR_FAIL_INDEX_V(p_index, source_ids.size(), -1);
+	return source_ids[p_index];
+}
+
+// Rendering
+void TileSet::set_uv_clipping(bool p_uv_clipping) {
+	if (uv_clipping == p_uv_clipping) {
+		return;
+	}
+	uv_clipping = p_uv_clipping;
 	emit_changed();
 }
+bool TileSet::is_uv_clipping() const {
+	return uv_clipping;
+};
 
-Color TileSet::tile_get_modulate(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Color(1, 1, 1));
-	return tile_map[p_id].modulate;
+void TileSet::set_y_sorting(bool p_y_sort) {
+	if (y_sorting == p_y_sort) {
+		return;
+	}
+	y_sorting = p_y_sort;
+	emit_changed();
 }
+bool TileSet::is_y_sorting() const {
+	return y_sorting;
+};
 
-void TileSet::tile_set_texture_offset(int p_id, const Vector2 &p_offset) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].offset = p_offset;
+void TileSet::set_occlusion_layers_count(int p_occlusion_layers_count) {
+	ERR_FAIL_COND(p_occlusion_layers_count < 0);
+	if (occlusion_layers.size() == p_occlusion_layers_count) {
+		return;
+	}
+
+	occlusion_layers.resize(p_occlusion_layers_count);
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
+	}
+
+	notify_property_list_changed();
 	emit_changed();
 }
 
-Vector2 TileSet::tile_get_texture_offset(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
-	return tile_map[p_id].offset;
+int TileSet::get_occlusion_layers_count() const {
+	return occlusion_layers.size();
+};
+
+void TileSet::set_occlusion_layer_light_mask(int p_layer_index, int p_light_mask) {
+	ERR_FAIL_INDEX(p_layer_index, occlusion_layers.size());
+	occlusion_layers.write[p_layer_index].light_mask = p_light_mask;
+	emit_changed();
+}
+
+int TileSet::get_occlusion_layer_light_mask(int p_layer_index) const {
+	ERR_FAIL_INDEX_V(p_layer_index, occlusion_layers.size(), 0);
+	return occlusion_layers[p_layer_index].light_mask;
 }
 
-void TileSet::tile_set_region(int p_id, const Rect2 &p_region) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].region = p_region;
+void TileSet::set_occlusion_layer_sdf_collision(int p_layer_index, int p_sdf_collision) {
+	ERR_FAIL_INDEX(p_layer_index, occlusion_layers.size());
+	occlusion_layers.write[p_layer_index].sdf_collision = p_sdf_collision;
 	emit_changed();
 }
 
-Rect2 TileSet::tile_get_region(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Rect2());
-	return tile_map[p_id].region;
+bool TileSet::get_occlusion_layer_sdf_collision(int p_layer_index) const {
+	ERR_FAIL_INDEX_V(p_layer_index, occlusion_layers.size(), false);
+	return occlusion_layers[p_layer_index].sdf_collision;
+}
+
+void TileSet::draw_tile_shape(CanvasItem *p_canvas_item, Rect2 p_region, Color p_color, bool p_filled, Ref<Texture2D> p_texture) {
+	// TODO: optimize this with 2D meshes when they work again.
+	if (get_tile_shape() == TileSet::TILE_SHAPE_SQUARE) {
+		if (p_filled && p_texture.is_valid()) {
+			p_canvas_item->draw_texture_rect(p_texture, p_region, false, p_color);
+		} else {
+			p_canvas_item->draw_rect(p_region, p_color, p_filled);
+		}
+	} else {
+		float overlap = 0.0;
+		switch (get_tile_shape()) {
+			case TileSet::TILE_SHAPE_ISOMETRIC:
+				overlap = 0.5;
+				break;
+			case TileSet::TILE_SHAPE_HEXAGON:
+				overlap = 0.25;
+				break;
+			case TileSet::TILE_SHAPE_HALF_OFFSET_SQUARE:
+				overlap = 0.0;
+				break;
+			default:
+				break;
+		}
+
+		Vector<Vector2> uvs;
+		uvs.append(Vector2(0.5, 0.0));
+		uvs.append(Vector2(0.0, overlap));
+		uvs.append(Vector2(0.0, 1.0 - overlap));
+		uvs.append(Vector2(0.5, 1.0));
+		uvs.append(Vector2(1.0, 1.0 - overlap));
+		uvs.append(Vector2(1.0, overlap));
+		uvs.append(Vector2(0.5, 0.0));
+		if (get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
+			for (int i = 0; i < uvs.size(); i++) {
+				uvs.write[i] = Vector2(uvs[i].y, uvs[i].x);
+			}
+		}
+
+		Vector<Vector2> points;
+		for (int i = 0; i < uvs.size(); i++) {
+			points.append(p_region.position + uvs[i] * p_region.size);
+		}
+
+		if (p_filled) {
+			// This does hurt performances a lot. We should use a mesh if possible instead.
+			p_canvas_item->draw_colored_polygon(points, p_color, uvs, p_texture);
+
+			// Should improve performances, but does not work as draw_primitive does not work with textures :/ :
+			/*for (int i = 0; i < 6; i += 3) {
+				Vector<Vector2> quad;
+				quad.append(points[i]);
+				quad.append(points[(i + 1) % points.size()]);
+				quad.append(points[(i + 2) % points.size()]);
+				quad.append(points[(i + 3) % points.size()]);
+
+				Vector<Vector2> uv_quad;
+				uv_quad.append(uvs[i]);
+				uv_quad.append(uvs[(i + 1) % uvs.size()]);
+				uv_quad.append(uvs[(i + 2) % uvs.size()]);
+				uv_quad.append(uvs[(i + 3) % uvs.size()]);
+
+				p_control->draw_primitive(quad, Vector<Color>(), uv_quad, p_texture);
+			}*/
+
+		} else {
+			// This does hurt performances a lot. We should use a mesh if possible instead.
+			// tile_shape_grid->draw_polyline(points, p_color);
+			for (int i = 0; i < points.size() - 1; i++) {
+				p_canvas_item->draw_line(points[i], points[i + 1], p_color);
+			}
+		}
+	}
 }
 
-void TileSet::tile_set_tile_mode(int p_id, TileMode p_tile_mode) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].tile_mode = p_tile_mode;
+// Physics
+void TileSet::set_physics_layers_count(int p_physics_layers_count) {
+	ERR_FAIL_COND(p_physics_layers_count < 0);
+	if (physics_layers.size() == p_physics_layers_count) {
+		return;
+	}
+
+	physics_layers.resize(p_physics_layers_count);
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
+	}
+
+	notify_property_list_changed();
 	emit_changed();
 }
 
-TileSet::TileMode TileSet::tile_get_tile_mode(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), SINGLE_TILE);
-	return tile_map[p_id].tile_mode;
+int TileSet::get_physics_layers_count() const {
+	return physics_layers.size();
 }
 
-void TileSet::autotile_set_icon_coordinate(int p_id, Vector2 coord) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].autotile_data.icon_coord = coord;
+void TileSet::set_physics_layer_collision_layer(int p_layer_index, uint32_t p_layer) {
+	ERR_FAIL_INDEX(p_layer_index, physics_layers.size());
+	physics_layers.write[p_layer_index].collision_layer = p_layer;
 	emit_changed();
 }
 
-Vector2 TileSet::autotile_get_icon_coordinate(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
-	return tile_map[p_id].autotile_data.icon_coord;
+uint32_t TileSet::get_physics_layer_collision_layer(int p_layer_index) const {
+	ERR_FAIL_INDEX_V(p_layer_index, physics_layers.size(), 0);
+	return physics_layers[p_layer_index].collision_layer;
 }
 
-void TileSet::autotile_set_spacing(int p_id, int p_spacing) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	ERR_FAIL_COND(p_spacing < 0);
-	tile_map[p_id].autotile_data.spacing = p_spacing;
+void TileSet::set_physics_layer_collision_mask(int p_layer_index, uint32_t p_mask) {
+	ERR_FAIL_INDEX(p_layer_index, physics_layers.size());
+	physics_layers.write[p_layer_index].collision_mask = p_mask;
 	emit_changed();
 }
 
-int TileSet::autotile_get_spacing(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
-	return tile_map[p_id].autotile_data.spacing;
+uint32_t TileSet::get_physics_layer_collision_mask(int p_layer_index) const {
+	ERR_FAIL_INDEX_V(p_layer_index, physics_layers.size(), 0);
+	return physics_layers[p_layer_index].collision_mask;
 }
 
-void TileSet::autotile_set_size(int p_id, Size2 p_size) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	ERR_FAIL_COND(p_size.x <= 0 || p_size.y <= 0);
-	tile_map[p_id].autotile_data.size = p_size;
+void TileSet::set_physics_layer_physics_material(int p_layer_index, Ref<PhysicsMaterial> p_physics_material) {
+	ERR_FAIL_INDEX(p_layer_index, physics_layers.size());
+	physics_layers.write[p_layer_index].physics_material = p_physics_material;
 }
 
-Size2 TileSet::autotile_get_size(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Size2());
-	return tile_map[p_id].autotile_data.size;
+Ref<PhysicsMaterial> TileSet::get_physics_layer_physics_material(int p_layer_index) const {
+	ERR_FAIL_INDEX_V(p_layer_index, physics_layers.size(), Ref<PhysicsMaterial>());
+	return physics_layers[p_layer_index].physics_material;
 }
 
-void TileSet::autotile_clear_bitmask_map(int p_id) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].autotile_data.flags.clear();
+// Terrains
+void TileSet::set_terrain_sets_count(int p_terrains_sets_count) {
+	ERR_FAIL_COND(p_terrains_sets_count < 0);
+
+	terrain_sets.resize(p_terrains_sets_count);
+
+	notify_property_list_changed();
+	emit_changed();
 }
 
-void TileSet::autotile_set_subtile_priority(int p_id, const Vector2 &p_coord, int p_priority) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	ERR_FAIL_COND(p_priority <= 0);
-	tile_map[p_id].autotile_data.priority_map[p_coord] = p_priority;
+int TileSet::get_terrain_sets_count() const {
+	return terrain_sets.size();
 }
 
-int TileSet::autotile_get_subtile_priority(int p_id, const Vector2 &p_coord) {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), 1);
-	if (tile_map[p_id].autotile_data.priority_map.has(p_coord)) {
-		return tile_map[p_id].autotile_data.priority_map[p_coord];
+void TileSet::set_terrain_set_mode(int p_terrain_set, TerrainMode p_terrain_mode) {
+	ERR_FAIL_INDEX(p_terrain_set, terrain_sets.size());
+	terrain_sets.write[p_terrain_set].mode = p_terrain_mode;
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
 	}
-	//When not custom priority set return the default value
-	return 1;
+
+	notify_property_list_changed();
+	emit_changed();
 }
 
-const Map<Vector2, int> &TileSet::autotile_get_priority_map(int p_id) const {
-	static Map<Vector2, int> dummy;
-	ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
-	return tile_map[p_id].autotile_data.priority_map;
+TileSet::TerrainMode TileSet::get_terrain_set_mode(int p_terrain_set) const {
+	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES);
+	return terrain_sets[p_terrain_set].mode;
 }
 
-void TileSet::autotile_set_z_index(int p_id, const Vector2 &p_coord, int p_z_index) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].autotile_data.z_index_map[p_coord] = p_z_index;
+void TileSet::set_terrains_count(int p_terrain_set, int p_terrains_layers_count) {
+	ERR_FAIL_INDEX(p_terrain_set, terrain_sets.size());
+	ERR_FAIL_COND(p_terrains_layers_count < 0);
+	if (terrain_sets[p_terrain_set].terrains.size() == p_terrains_layers_count) {
+		return;
+	}
+
+	int old_size = terrain_sets[p_terrain_set].terrains.size();
+	terrain_sets.write[p_terrain_set].terrains.resize(p_terrains_layers_count);
+
+	// Default name and color
+	for (int i = old_size; i < terrain_sets.write[p_terrain_set].terrains.size(); i++) {
+		float hue_rotate = (i * 2 % 16) / 16.0;
+		Color c;
+		c.set_hsv(Math::fmod(float(hue_rotate), float(1.0)), 0.5, 0.5);
+		terrain_sets.write[p_terrain_set].terrains.write[i].color = c;
+		terrain_sets.write[p_terrain_set].terrains.write[i].name = String(vformat("Terrain %d", i));
+	}
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
+	}
+
+	notify_property_list_changed();
 	emit_changed();
 }
 
-int TileSet::autotile_get_z_index(int p_id, const Vector2 &p_coord) {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), 1);
-	if (tile_map[p_id].autotile_data.z_index_map.has(p_coord)) {
-		return tile_map[p_id].autotile_data.z_index_map[p_coord];
+int TileSet::get_terrains_count(int p_terrain_set) const {
+	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), -1);
+	return terrain_sets[p_terrain_set].terrains.size();
+}
+
+void TileSet::set_terrain_name(int p_terrain_set, int p_terrain_index, String p_name) {
+	ERR_FAIL_INDEX(p_terrain_set, terrain_sets.size());
+	ERR_FAIL_INDEX(p_terrain_index, terrain_sets[p_terrain_set].terrains.size());
+	terrain_sets.write[p_terrain_set].terrains.write[p_terrain_index].name = p_name;
+	emit_changed();
+}
+
+String TileSet::get_terrain_name(int p_terrain_set, int p_terrain_index) const {
+	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), String());
+	ERR_FAIL_INDEX_V(p_terrain_index, terrain_sets[p_terrain_set].terrains.size(), String());
+	return terrain_sets[p_terrain_set].terrains[p_terrain_index].name;
+}
+
+void TileSet::set_terrain_color(int p_terrain_set, int p_terrain_index, Color p_color) {
+	ERR_FAIL_INDEX(p_terrain_set, terrain_sets.size());
+	ERR_FAIL_INDEX(p_terrain_index, terrain_sets[p_terrain_set].terrains.size());
+	if (p_color.a != 1.0) {
+		WARN_PRINT("Terrain color should have alpha == 1.0");
+		p_color.a = 1.0;
 	}
-	//When not custom z index set return the default value
-	return 0;
+	terrain_sets.write[p_terrain_set].terrains.write[p_terrain_index].color = p_color;
+	emit_changed();
 }
 
-const Map<Vector2, int> &TileSet::autotile_get_z_index_map(int p_id) const {
-	static Map<Vector2, int> dummy;
-	ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
-	return tile_map[p_id].autotile_data.z_index_map;
+Color TileSet::get_terrain_color(int p_terrain_set, int p_terrain_index) const {
+	ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), Color());
+	ERR_FAIL_INDEX_V(p_terrain_index, terrain_sets[p_terrain_set].terrains.size(), Color());
+	return terrain_sets[p_terrain_set].terrains[p_terrain_index].color;
 }
 
-void TileSet::autotile_set_bitmask(int p_id, Vector2 p_coord, uint32_t p_flag) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	if (p_flag == 0) {
-		if (tile_map[p_id].autotile_data.flags.has(p_coord)) {
-			tile_map[p_id].autotile_data.flags.erase(p_coord);
+bool TileSet::is_valid_peering_bit_terrain(int p_terrain_set, TileSet::CellNeighbor p_peering_bit) const {
+	if (p_terrain_set < 0 || p_terrain_set >= get_terrain_sets_count()) {
+		return false;
+	}
+
+	TileSet::TerrainMode terrain_mode = get_terrain_set_mode(p_terrain_set);
+	if (tile_shape == TileSet::TILE_SHAPE_SQUARE) {
+		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_SIDES) {
+			if (p_peering_bit == TileSet::CELL_NEIGHBOR_RIGHT_SIDE ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_LEFT_SIDE ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_SIDE) {
+				return true;
+			}
+		}
+		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
+			if (p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER) {
+				return true;
+			}
+		}
+	} else if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_SIDES) {
+			if (p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+				return true;
+			}
+		}
+		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
+			if (p_peering_bit == TileSet::CELL_NEIGHBOR_RIGHT_CORNER ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_LEFT_CORNER ||
+					p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_CORNER) {
+				return true;
+			}
 		}
 	} else {
-		tile_map[p_id].autotile_data.flags[p_coord] = p_flag;
+		if (get_tile_offset_axis() == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+			if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_SIDES) {
+				if (p_peering_bit == TileSet::CELL_NEIGHBOR_RIGHT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_LEFT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+					return true;
+				}
+			}
+			if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
+				if (p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER) {
+					return true;
+				}
+			}
+		} else {
+			if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_SIDES) {
+				if (p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_SIDE ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) {
+					return true;
+				}
+			}
+			if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
+				if (p_peering_bit == TileSet::CELL_NEIGHBOR_RIGHT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_LEFT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER ||
+						p_peering_bit == TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER) {
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+
+// Navigation
+void TileSet::set_navigation_layers_count(int p_navigation_layers_count) {
+	ERR_FAIL_COND(p_navigation_layers_count < 0);
+	if (navigation_layers.size() == p_navigation_layers_count) {
+		return;
+	}
+
+	navigation_layers.resize(p_navigation_layers_count);
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
 	}
+
+	notify_property_list_changed();
+	emit_changed();
+}
+
+int TileSet::get_navigation_layers_count() const {
+	return navigation_layers.size();
+}
+
+void TileSet::set_navigation_layer_layers(int p_layer_index, uint32_t p_layers) {
+	ERR_FAIL_INDEX(p_layer_index, navigation_layers.size());
+	navigation_layers.write[p_layer_index].layers = p_layers;
+	emit_changed();
 }
 
-uint32_t TileSet::autotile_get_bitmask(int p_id, Vector2 p_coord) {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
-	if (!tile_map[p_id].autotile_data.flags.has(p_coord)) {
-		return 0;
+uint32_t TileSet::get_navigation_layer_layers(int p_layer_index) const {
+	ERR_FAIL_INDEX_V(p_layer_index, navigation_layers.size(), 0);
+	return navigation_layers[p_layer_index].layers;
+}
+
+// Custom data.
+void TileSet::set_custom_data_layers_count(int p_custom_data_layers_count) {
+	ERR_FAIL_COND(p_custom_data_layers_count < 0);
+	if (custom_data_layers.size() == p_custom_data_layers_count) {
+		return;
 	}
-	return tile_map[p_id].autotile_data.flags[p_coord];
+
+	custom_data_layers.resize(p_custom_data_layers_count);
+
+	for (Map<String, int>::Element *E = custom_data_layers_by_name.front(); E; E = E->next()) {
+		if (E->get() >= custom_data_layers.size()) {
+			custom_data_layers_by_name.erase(E);
+		}
+	}
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
+	}
+
+	notify_property_list_changed();
+	emit_changed();
 }
 
-const Map<Vector2, uint32_t> &TileSet::autotile_get_bitmask_map(int p_id) {
-	static Map<Vector2, uint32_t> dummy;
-	static Map<Vector2, uint32_t> dummy_atlas;
-	ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
-	if (tile_get_tile_mode(p_id) == ATLAS_TILE) {
-		dummy_atlas = Map<Vector2, uint32_t>();
-		Rect2 region = tile_get_region(p_id);
-		Size2 size = autotile_get_size(p_id);
-		float spacing = autotile_get_spacing(p_id);
-		for (int x = 0; x < (region.size.x / (size.x + spacing)); x++) {
-			for (int y = 0; y < (region.size.y / (size.y + spacing)); y++) {
-				dummy_atlas.insert(Vector2(x, y), 0);
+int TileSet::get_custom_data_layers_count() const {
+	return custom_data_layers.size();
+}
+
+int TileSet::get_custom_data_layer_by_name(String p_value) const {
+	if (custom_data_layers_by_name.has(p_value)) {
+		return custom_data_layers_by_name[p_value];
+	} else {
+		return -1;
+	}
+}
+
+void TileSet::set_custom_data_name(int p_layer_id, String p_value) {
+	ERR_FAIL_INDEX(p_layer_id, custom_data_layers.size());
+
+	// Exit if another property has the same name.
+	if (!p_value.is_empty()) {
+		for (int other_layer_id = 0; other_layer_id < get_custom_data_layers_count(); other_layer_id++) {
+			if (other_layer_id != p_layer_id && get_custom_data_name(other_layer_id) == p_value) {
+				ERR_FAIL_MSG(vformat("There is already a custom property named %s", p_value));
 			}
 		}
-		return dummy_atlas;
+	}
+
+	if (p_value.is_empty() && custom_data_layers_by_name.has(p_value)) {
+		custom_data_layers_by_name.erase(p_value);
 	} else {
-		return tile_map[p_id].autotile_data.flags;
+		custom_data_layers_by_name[p_value] = p_layer_id;
 	}
+
+	custom_data_layers.write[p_layer_id].name = p_value;
+	emit_changed();
+}
+
+String TileSet::get_custom_data_name(int p_layer_id) const {
+	ERR_FAIL_INDEX_V(p_layer_id, custom_data_layers.size(), "");
+	return custom_data_layers[p_layer_id].name;
+}
+
+void TileSet::set_custom_data_type(int p_layer_id, Variant::Type p_value) {
+	ERR_FAIL_INDEX(p_layer_id, custom_data_layers.size());
+	custom_data_layers.write[p_layer_id].type = p_value;
+
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		E_source->get()->notify_tile_data_properties_should_change();
+	}
+
+	emit_changed();
+}
+
+Variant::Type TileSet::get_custom_data_type(int p_layer_id) const {
+	ERR_FAIL_INDEX_V(p_layer_id, custom_data_layers.size(), Variant::NIL);
+	return custom_data_layers[p_layer_id].type;
+}
+
+void TileSet::_source_changed() {
+	emit_changed();
+	notify_property_list_changed();
+}
+
+void TileSet::reset_state() {
+	occlusion_layers.clear();
+	physics_layers.clear();
+	custom_data_layers.clear();
 }
 
-Vector2 TileSet::autotile_get_subtile_for_bitmask(int p_id, uint16_t p_bitmask, const Node *p_tilemap_node, const Vector2 &p_tile_location) {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
-	//First try to forward selection to script
-	if (p_tilemap_node->get_class_name() == "TileMap") {
-		if (get_script_instance() != nullptr) {
-			if (get_script_instance()->has_method("_forward_subtile_selection")) {
-				Variant ret = get_script_instance()->call("_forward_subtile_selection", p_id, p_bitmask, p_tilemap_node, p_tile_location);
-				if (ret.get_type() == Variant::VECTOR2) {
-					return ret;
+const Vector2i TileSetAtlasSource::INVALID_ATLAS_COORDS = Vector2i(-1, -1);
+const int TileSetAtlasSource::INVALID_TILE_ALTERNATIVE = -1;
+
+#ifndef DISABLE_DEPRECATED
+void TileSet::compatibility_conversion() {
+	for (Map<int, CompatibilityTileData *>::Element *E = compatibility_data.front(); E; E = E->next()) {
+		CompatibilityTileData *ctd = E->value();
+
+		// Add the texture
+		TileSetAtlasSource *atlas_source = memnew(TileSetAtlasSource);
+		int source_id = add_source(Ref<TileSetSource>(atlas_source));
+
+		atlas_source->set_texture(ctd->texture);
+
+		// Handle each tile as a new source. Not optimal but at least it should stay compatible.
+		switch (ctd->tile_mode) {
+			case 0: // SINGLE_TILE
+				// TODO
+				break;
+			case 1: // AUTO_TILE
+				// TODO
+				break;
+			case 2: // ATLAS_TILE
+				atlas_source->set_margins(ctd->region.get_position());
+				atlas_source->set_separation(Vector2i(ctd->autotile_spacing, ctd->autotile_spacing));
+				atlas_source->set_texture_region_size(ctd->autotile_tile_size);
+
+				Size2i atlas_size = ctd->region.get_size() / (ctd->autotile_tile_size + atlas_source->get_separation());
+				for (int i = 0; i < atlas_size.x; i++) {
+					for (int j = 0; j < atlas_size.y; j++) {
+						Vector2i coords = Vector2i(i, j);
+
+						for (int flags = 0; flags < 8; flags++) {
+							bool flip_h = flags & 1;
+							bool flip_v = flags & 2;
+							bool transpose = flags & 4;
+
+							int alternative_tile = 0;
+							if (!atlas_source->has_tile(coords)) {
+								atlas_source->create_tile(coords);
+							} else {
+								alternative_tile = atlas_source->create_alternative_tile(coords);
+							}
+							TileData *tile_data = Object::cast_to<TileData>(atlas_source->get_tile_data(coords, alternative_tile));
+
+							tile_data->set_flip_h(flip_h);
+							tile_data->set_flip_v(flip_v);
+							tile_data->set_transpose(transpose);
+							tile_data->tile_set_material(ctd->material);
+							tile_data->set_modulate(ctd->modulate);
+							tile_data->set_z_index(ctd->z_index);
+							if (ctd->autotile_occluder_map.has(coords)) {
+								if (get_occlusion_layers_count() < 1) {
+									set_occlusion_layers_count(1);
+								}
+								tile_data->set_occluder(0, ctd->autotile_occluder_map[coords]);
+							}
+							if (ctd->autotile_navpoly_map.has(coords)) {
+								if (get_navigation_layers_count() < 1) {
+									set_navigation_layers_count(1);
+								}
+								tile_data->set_navigation_polygon(0, ctd->autotile_navpoly_map[coords]);
+							}
+							if (ctd->autotile_priority_map.has(coords)) {
+								tile_data->set_probability(ctd->autotile_priority_map[coords]);
+							}
+							if (ctd->autotile_z_index_map.has(coords)) {
+								tile_data->set_z_index(ctd->autotile_z_index_map[coords]);
+							}
+
+							// Add the shapes.
+							if (ctd->shapes.size() > 0) {
+								if (get_physics_layers_count() < 1) {
+									set_physics_layers_count(1);
+								}
+							}
+							for (int k = 0; k < ctd->shapes.size(); k++) {
+								CompatibilityShapeData csd = ctd->shapes[k];
+								if (csd.autotile_coords == coords) {
+									tile_data->set_collision_shapes_count(0, tile_data->get_collision_shapes_count(0) + 1);
+									int index = tile_data->get_collision_shapes_count(0) - 1;
+									tile_data->set_collision_shape_one_way(0, index, csd.one_way);
+									tile_data->set_collision_shape_one_way_margin(0, index, csd.one_way_margin);
+									tile_data->set_collision_shape_shape(0, index, csd.shape);
+									// Ignores transform for now.
+								}
+							}
+
+							// -- TODO: handle --
+							// Those are offset for the whole atlas, they are likely useless for the atlases, but might make sense for single tiles.
+							// texture offset
+							// occluder_offset
+							// navigation_offset
+
+							// For terrains, ignored for now?
+							// bitmask_mode
+							// bitmask_flags
+						}
+					}
+				}
+				break;
+		}
+
+		// Offset all shapes
+		for (int k = 0; k < ctd->shapes.size(); k++) {
+			Ref<ConvexPolygonShape2D> convex = ctd->shapes[k].shape;
+			if (convex.is_valid()) {
+				Vector<Vector2> points = convex->get_points();
+				for (int i_point = 0; i_point < points.size(); i_point++) {
+					points.write[i_point] = points[i_point] - get_tile_size() / 2;
 				}
+				convex->set_points(points);
 			}
 		}
+
+		// Add the mapping to the map
+		compatibility_source_mapping.insert(E->key(), source_id);
+	}
+
+	// Reset compatibility data
+	for (Map<int, CompatibilityTileData *>::Element *E = compatibility_data.front(); E; E = E->next()) {
+		memdelete(E->get());
 	}
+	compatibility_data = Map<int, CompatibilityTileData *>();
+}
+#endif // DISABLE_DEPRECATED
 
-	List<Vector2> coords;
-	List<uint32_t> priorities;
-	uint32_t priority_sum = 0;
-	uint32_t mask;
-	uint16_t mask_;
-	uint16_t mask_ignore;
-	for (Map<Vector2, uint32_t>::Element *E = tile_map[p_id].autotile_data.flags.front(); E; E = E->next()) {
-		mask = E->get();
-		if (tile_map[p_id].autotile_data.bitmask_mode == BITMASK_2X2) {
-			mask |= (BIND_IGNORE_TOP | BIND_IGNORE_LEFT | BIND_IGNORE_CENTER | BIND_IGNORE_RIGHT | BIND_IGNORE_BOTTOM);
+bool TileSet::_set(const StringName &p_name, const Variant &p_value) {
+	Vector<String> components = String(p_name).split("/", true, 2);
+
+#ifndef DISABLE_DEPRECATED
+	// TODO: THIS IS HOW WE CHECK IF WE HAVE A DEPRECATED RESOURCE
+	// This should be moved to a dedicated conversion system
+	if (components.size() >= 1 && components[0].is_valid_integer()) {
+		int id = components[0].to_int();
+
+		// Get or create the compatibility object
+		CompatibilityTileData *ctd;
+		Map<int, CompatibilityTileData *>::Element *E = compatibility_data.find(id);
+		if (!E) {
+			ctd = memnew(CompatibilityTileData);
+			compatibility_data.insert(id, ctd);
+		} else {
+			ctd = E->get();
 		}
 
-		mask_ = mask & 0xFFFF;
-		mask_ignore = mask >> 16;
+		if (components.size() < 2) {
+			return false;
+		}
 
-		if (((mask_ & (~mask_ignore)) == (p_bitmask & (~mask_ignore))) && (((~mask_) | mask_ignore) == ((~p_bitmask) | mask_ignore))) {
-			uint32_t priority = autotile_get_subtile_priority(p_id, E->key());
-			priority_sum += priority;
-			priorities.push_back(priority);
-			coords.push_back(E->key());
+		String what = components[1];
+
+		if (what == "name") {
+			ctd->name = p_value;
+		} else if (what == "texture") {
+			ctd->texture = p_value;
+		} else if (what == "tex_offset") {
+			ctd->tex_offset = p_value;
+		} else if (what == "material") {
+			ctd->material = p_value;
+		} else if (what == "modulate") {
+			ctd->modulate = p_value;
+		} else if (what == "region") {
+			ctd->region = p_value;
+		} else if (what == "tile_mode") {
+			ctd->tile_mode = p_value;
+		} else if (what.left(9) == "autotile") {
+			what = what.right(9);
+			if (what == "bitmask_mode") {
+				ctd->autotile_bitmask_mode = p_value;
+			} else if (what == "icon_coordinate") {
+				ctd->autotile_icon_coordinate = p_value;
+			} else if (what == "tile_size") {
+				ctd->autotile_tile_size = p_value;
+			} else if (what == "spacing") {
+				ctd->autotile_spacing = p_value;
+			} else if (what == "bitmask_flags") {
+				if (p_value.is_array()) {
+					Array p = p_value;
+					Vector2i last_coord;
+					while (p.size() > 0) {
+						if (p[0].get_type() == Variant::VECTOR2) {
+							last_coord = p[0];
+						} else if (p[0].get_type() == Variant::INT) {
+							ctd->autotile_bitmask_flags.insert(last_coord, p[0]);
+						}
+						p.pop_front();
+					}
+				}
+			} else if (what == "occluder_map") {
+				Array p = p_value;
+				Vector2 last_coord;
+				while (p.size() > 0) {
+					if (p[0].get_type() == Variant::VECTOR2) {
+						last_coord = p[0];
+					} else if (p[0].get_type() == Variant::OBJECT) {
+						ctd->autotile_occluder_map.insert(last_coord, p[0]);
+					}
+					p.pop_front();
+				}
+			} else if (what == "navpoly_map") {
+				Array p = p_value;
+				Vector2 last_coord;
+				while (p.size() > 0) {
+					if (p[0].get_type() == Variant::VECTOR2) {
+						last_coord = p[0];
+					} else if (p[0].get_type() == Variant::OBJECT) {
+						ctd->autotile_navpoly_map.insert(last_coord, p[0]);
+					}
+					p.pop_front();
+				}
+			} else if (what == "priority_map") {
+				Array p = p_value;
+				Vector3 val;
+				Vector2 v;
+				int priority;
+				while (p.size() > 0) {
+					val = p[0];
+					if (val.z > 1) {
+						v.x = val.x;
+						v.y = val.y;
+						priority = (int)val.z;
+						ctd->autotile_priority_map.insert(v, priority);
+					}
+					p.pop_front();
+				}
+			} else if (what == "z_index_map") {
+				Array p = p_value;
+				Vector3 val;
+				Vector2 v;
+				int z_index;
+				while (p.size() > 0) {
+					val = p[0];
+					if (val.z != 0) {
+						v.x = val.x;
+						v.y = val.y;
+						z_index = (int)val.z;
+						ctd->autotile_z_index_map.insert(v, z_index);
+					}
+					p.pop_front();
+				}
+			}
+
+		} else if (what == "shapes") {
+			Array p = p_value;
+			for (int i = 0; i < p.size(); i++) {
+				CompatibilityShapeData csd;
+				Dictionary d = p[i];
+				for (int j = 0; j < d.size(); j++) {
+					String key = d.get_key_at_index(j);
+					if (key == "autotile_coord") {
+						csd.autotile_coords = d[key];
+					} else if (key == "one_way") {
+						csd.one_way = d[key];
+					} else if (key == "one_way_margin") {
+						csd.one_way_margin = d[key];
+					} else if (key == "shape") {
+						csd.shape = d[key];
+					} else if (key == "shape_transform") {
+						csd.transform = d[key];
+					}
+				}
+				ctd->shapes.push_back(csd);
+			}
+
+			/*
+		// IGNORED FOR NOW, they seem duplicated data compared to the shapes array
+		} else if (what == "shape") {
+			// TODO
+		} else if (what == "shape_offset") {
+			// TODO
+		} else if (what == "shape_transform") {
+			// TODO
+		} else if (what == "shape_one_way") {
+			// TODO
+		} else if (what == "shape_one_way_margin") {
+			// TODO
 		}
-	}
+		// IGNORED FOR NOW, maybe useless ?
+		else if (what == "occluder_offset") {
+			// Not
+		} else if (what == "navigation_offset") {
+			// TODO
+		}
+		*/
 
-	if (coords.size() == 0) {
-		return autotile_get_icon_coordinate(p_id);
+		} else if (what == "z_index") {
+			ctd->z_index = p_value;
+
+			// TODO: remove the conversion from here, it's not where it should be done
+			compatibility_conversion();
+		} else {
+			return false;
+		}
 	} else {
-		uint32_t picked_value = Math::rand() % priority_sum;
-		uint32_t upper_bound;
-		uint32_t lower_bound = 0;
-		Vector2 result = coords.front()->get();
-		List<Vector2>::Element *coords_E = coords.front();
-		List<uint32_t>::Element *priorities_E = priorities.front();
-		while (priorities_E) {
-			upper_bound = lower_bound + priorities_E->get();
-			if (lower_bound <= picked_value && picked_value < upper_bound) {
-				result = coords_E->get();
-				break;
+#endif // DISABLE_DEPRECATED
+
+		// This is now a new property.
+		if (components.size() == 2 && components[0].begins_with("occlusion_layer_") && components[0].trim_prefix("occlusion_layer_").is_valid_integer()) {
+			// Occlusion layers.
+			int index = components[0].trim_prefix("occlusion_layer_").to_int();
+			ERR_FAIL_COND_V(index < 0, false);
+			if (components[1] == "light_mask") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::INT, false);
+				if (index >= occlusion_layers.size()) {
+					set_occlusion_layers_count(index + 1);
+				}
+				set_occlusion_layer_light_mask(index, p_value);
+				return true;
+			} else if (components[1] == "sdf_collision") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::BOOL, false);
+				if (index >= occlusion_layers.size()) {
+					set_occlusion_layers_count(index + 1);
+				}
+				set_occlusion_layer_sdf_collision(index, p_value);
+				return true;
+			}
+		} else if (components.size() == 2 && components[0].begins_with("physics_layer_") && components[0].trim_prefix("physics_layer_").is_valid_integer()) {
+			// Physics layers.
+			int index = components[0].trim_prefix("physics_layer_").to_int();
+			ERR_FAIL_COND_V(index < 0, false);
+			if (components[1] == "collision_layer") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::INT, false);
+				if (index >= physics_layers.size()) {
+					set_physics_layers_count(index + 1);
+				}
+				set_physics_layer_collision_layer(index, p_value);
+				return true;
+			} else if (components[1] == "collision_mask") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::INT, false);
+				if (index >= physics_layers.size()) {
+					set_physics_layers_count(index + 1);
+				}
+				set_physics_layer_collision_mask(index, p_value);
+				return true;
+			} else if (components[1] == "physics_material") {
+				Ref<PhysicsMaterial> physics_material = p_value;
+				ERR_FAIL_COND_V(!physics_material.is_valid(), false);
+				if (index >= physics_layers.size()) {
+					set_physics_layers_count(index + 1);
+				}
+				set_physics_layer_physics_material(index, physics_material);
+				return true;
+			}
+		} else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_integer()) {
+			// Terrains.
+			int terrain_set_index = components[0].trim_prefix("terrain_set_").to_int();
+			ERR_FAIL_COND_V(terrain_set_index < 0, false);
+			if (components[1] == "mode") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::INT, false);
+				if (terrain_set_index >= terrain_sets.size()) {
+					set_terrain_sets_count(terrain_set_index + 1);
+				}
+				set_terrain_set_mode(terrain_set_index, TerrainMode(int(p_value)));
+			} else if (components[1] == "terrains_count") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::INT, false);
+				if (terrain_set_index >= terrain_sets.size()) {
+					set_terrain_sets_count(terrain_set_index + 1);
+				}
+				set_terrains_count(terrain_set_index, p_value);
+				return true;
+			} else if (components.size() >= 3 && components[1].begins_with("terrain_") && components[1].trim_prefix("terrain_").is_valid_integer()) {
+				int terrain_index = components[1].trim_prefix("terrain_").to_int();
+				ERR_FAIL_COND_V(terrain_index < 0, false);
+				if (components[2] == "name") {
+					ERR_FAIL_COND_V(p_value.get_type() != Variant::STRING, false);
+					if (terrain_set_index >= terrain_sets.size()) {
+						set_terrain_sets_count(terrain_set_index + 1);
+					}
+					if (terrain_index >= terrain_sets[terrain_set_index].terrains.size()) {
+						set_terrains_count(terrain_set_index, terrain_index + 1);
+					}
+					set_terrain_name(terrain_set_index, terrain_index, p_value);
+					return true;
+				} else if (components[2] == "color") {
+					ERR_FAIL_COND_V(p_value.get_type() != Variant::COLOR, false);
+					if (terrain_set_index >= terrain_sets.size()) {
+						set_terrain_sets_count(terrain_set_index + 1);
+					}
+					if (terrain_index >= terrain_sets[terrain_set_index].terrains.size()) {
+						set_terrains_count(terrain_set_index, terrain_index + 1);
+					}
+					set_terrain_color(terrain_set_index, terrain_index, p_value);
+					return true;
+				}
+			}
+		} else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_integer()) {
+			// Navigation layers.
+			int index = components[0].trim_prefix("navigation_layer_").to_int();
+			ERR_FAIL_COND_V(index < 0, false);
+			if (components[1] == "layers") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::INT, false);
+				if (index >= navigation_layers.size()) {
+					set_navigation_layers_count(index + 1);
+				}
+				set_navigation_layer_layers(index, p_value);
+				return true;
+			}
+		} else if (components.size() == 2 && components[0].begins_with("custom_data_layer_") && components[0].trim_prefix("custom_data_layer_").is_valid_integer()) {
+			// Custom data layers.
+			int index = components[0].trim_prefix("custom_data_layer_").to_int();
+			ERR_FAIL_COND_V(index < 0, false);
+			if (components[1] == "name") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::STRING, false);
+				if (index >= custom_data_layers.size()) {
+					set_custom_data_layers_count(index + 1);
+				}
+				set_custom_data_name(index, p_value);
+				return true;
+			} else if (components[1] == "type") {
+				ERR_FAIL_COND_V(p_value.get_type() != Variant::INT, false);
+				if (index >= custom_data_layers.size()) {
+					set_custom_data_layers_count(index + 1);
+				}
+				set_custom_data_type(index, Variant::Type(int(p_value)));
+				return true;
 			}
-			lower_bound = upper_bound;
-			priorities_E = priorities_E->next();
-			coords_E = coords_E->next();
+		} else if (components.size() == 2 && components[0] == "sources" && components[1].is_valid_integer()) {
+			// Create atlas if it does not exists.
+			int source_id = components[1].to_int();
+
+			if (!has_source(source_id)) {
+				add_source(p_value, source_id);
+			}
+			return true;
 		}
 
-		return result;
+#ifndef DISABLE_DEPRECATED
 	}
+#endif // DISABLE_DEPRECATED
+
+	return false;
 }
 
-Vector2 TileSet::atlastile_get_subtile_by_priority(int p_id, const Node *p_tilemap_node, const Vector2 &p_tile_location) {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
-	//First try to forward selection to script
-	if (get_script_instance() != nullptr) {
-		if (get_script_instance()->has_method("_forward_atlas_subtile_selection")) {
-			Variant ret = get_script_instance()->call("_forward_atlas_subtile_selection", p_id, p_tilemap_node, p_tile_location);
-			if (ret.get_type() == Variant::VECTOR2) {
-				return ret;
+bool TileSet::_get(const StringName &p_name, Variant &r_ret) const {
+	Vector<String> components = String(p_name).split("/", true, 2);
+
+	if (components.size() == 2 && components[0].begins_with("occlusion_layer_") && components[0].trim_prefix("occlusion_layer_").is_valid_integer()) {
+		// Occlusion layers.
+		int index = components[0].trim_prefix("occlusion_layer_").to_int();
+		if (index < 0 || index >= occlusion_layers.size()) {
+			return false;
+		}
+		if (components[1] == "light_mask") {
+			r_ret = get_occlusion_layer_light_mask(index);
+			return true;
+		} else if (components[1] == "sdf_collision") {
+			r_ret = get_occlusion_layer_sdf_collision(index);
+			return true;
+		}
+	} else if (components.size() == 2 && components[0].begins_with("physics_layer_") && components[0].trim_prefix("physics_layer_").is_valid_integer()) {
+		// Physics layers.
+		int index = components[0].trim_prefix("physics_layer_").to_int();
+		if (index < 0 || index >= physics_layers.size()) {
+			return false;
+		}
+		if (components[1] == "collision_layer") {
+			r_ret = get_physics_layer_collision_layer(index);
+			return true;
+		} else if (components[1] == "collision_mask") {
+			r_ret = get_physics_layer_collision_mask(index);
+			return true;
+		} else if (components[1] == "physics_material") {
+			r_ret = get_physics_layer_physics_material(index);
+			return true;
+		}
+	} else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_integer()) {
+		// Terrains.
+		int terrain_set_index = components[0].trim_prefix("terrain_set_").to_int();
+		if (terrain_set_index < 0 || terrain_set_index >= terrain_sets.size()) {
+			return false;
+		}
+		if (components[1] == "mode") {
+			r_ret = get_terrain_set_mode(terrain_set_index);
+			return true;
+		} else if (components[1] == "terrains_count") {
+			r_ret = get_terrains_count(terrain_set_index);
+			return true;
+		} else if (components.size() >= 3 && components[1].begins_with("terrain_") && components[1].trim_prefix("terrain_").is_valid_integer()) {
+			int terrain_index = components[1].trim_prefix("terrain_").to_int();
+			if (terrain_index < 0 || terrain_index >= terrain_sets[terrain_set_index].terrains.size()) {
+				return false;
+			}
+			if (components[2] == "name") {
+				r_ret = get_terrain_name(terrain_set_index, terrain_index);
+				return true;
+			} else if (components[2] == "color") {
+				r_ret = get_terrain_color(terrain_set_index, terrain_index);
+				return true;
 			}
 		}
+	} else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_integer()) {
+		// navigation layers.
+		int index = components[0].trim_prefix("navigation_layer_").to_int();
+		if (index < 0 || index >= navigation_layers.size()) {
+			return false;
+		}
+		if (components[1] == "layers") {
+			r_ret = get_navigation_layer_layers(index);
+			return true;
+		}
+	} else if (components.size() == 2 && components[0].begins_with("custom_data_layer_") && components[0].trim_prefix("custom_data_layer_").is_valid_integer()) {
+		// Custom data layers.
+		int index = components[0].trim_prefix("custom_data_layer_").to_int();
+		if (index < 0 || index >= custom_data_layers.size()) {
+			return false;
+		}
+		if (components[1] == "name") {
+			r_ret = get_custom_data_name(index);
+			return true;
+		} else if (components[1] == "type") {
+			r_ret = get_custom_data_type(index);
+			return true;
+		}
+	} else if (components.size() == 2 && components[0] == "sources" && components[1].is_valid_integer()) {
+		// Atlases data.
+		int source_id = components[1].to_int();
+
+		if (has_source(source_id)) {
+			r_ret = get_source(source_id);
+			return true;
+		} else {
+			return false;
+		}
 	}
 
-	Vector2 coord = tile_get_region(p_id).size / autotile_get_size(p_id);
+	return false;
+}
 
-	List<Vector2> coords;
-	for (int x = 0; x < coord.x; x++) {
-		for (int y = 0; y < coord.y; y++) {
-			for (int i = 0; i < autotile_get_subtile_priority(p_id, Vector2(x, y)); i++) {
-				coords.push_back(Vector2(x, y));
-			}
+void TileSet::_get_property_list(List<PropertyInfo> *p_list) const {
+	PropertyInfo property_info;
+	// Rendering.
+	p_list->push_back(PropertyInfo(Variant::NIL, "Rendering", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+	for (int i = 0; i < occlusion_layers.size(); i++) {
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("occlusion_layer_%d/light_mask", i), PROPERTY_HINT_LAYERS_2D_RENDER));
+
+		// occlusion_layer_%d/sdf_collision
+		property_info = PropertyInfo(Variant::BOOL, vformat("occlusion_layer_%d/sdf_collision", i));
+		if (occlusion_layers[i].sdf_collision == false) {
+			property_info.usage ^= PROPERTY_USAGE_STORAGE;
 		}
+		p_list->push_back(property_info);
 	}
-	if (coords.size() == 0) {
-		return autotile_get_icon_coordinate(p_id);
-	} else {
-		return coords[Math::random(0, (int)coords.size())];
+
+	// Physics.
+	p_list->push_back(PropertyInfo(Variant::NIL, "Physics", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+	for (int i = 0; i < physics_layers.size(); i++) {
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("physics_layer_%d/collision_layer", i), PROPERTY_HINT_LAYERS_2D_PHYSICS));
+
+		// physics_layer_%d/collision_mask
+		property_info = PropertyInfo(Variant::INT, vformat("physics_layer_%d/collision_mask", i), PROPERTY_HINT_LAYERS_2D_PHYSICS);
+		if (physics_layers[i].collision_mask == 1) {
+			property_info.usage ^= PROPERTY_USAGE_STORAGE;
+		}
+		p_list->push_back(property_info);
+
+		// physics_layer_%d/physics_material
+		property_info = PropertyInfo(Variant::OBJECT, vformat("physics_layer_%d/physics_material", i), PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial");
+		if (!physics_layers[i].physics_material.is_valid()) {
+			property_info.usage ^= PROPERTY_USAGE_STORAGE;
+		}
+		p_list->push_back(property_info);
 	}
-}
 
-void TileSet::tile_set_name(int p_id, const String &p_name) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].name = p_name;
-	emit_changed();
+	// Terrains.
+	p_list->push_back(PropertyInfo(Variant::NIL, "Terrains", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+	for (int terrain_set_index = 0; terrain_set_index < terrain_sets.size(); terrain_set_index++) {
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("terrain_set_%d/mode", terrain_set_index), PROPERTY_HINT_ENUM, "Match corners and sides,Match corners,Match sides"));
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("terrain_set_%d/terrains_count", terrain_set_index), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
+		for (int terrain_index = 0; terrain_index < terrain_sets[terrain_set_index].terrains.size(); terrain_index++) {
+			p_list->push_back(PropertyInfo(Variant::STRING, vformat("terrain_set_%d/terrain_%d/name", terrain_set_index, terrain_index)));
+			p_list->push_back(PropertyInfo(Variant::COLOR, vformat("terrain_set_%d/terrain_%d/color", terrain_set_index, terrain_index)));
+		}
+	}
+
+	// Navigation.
+	p_list->push_back(PropertyInfo(Variant::NIL, "Navigation", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+	for (int i = 0; i < navigation_layers.size(); i++) {
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("navigation_layer_%d/layers", i), PROPERTY_HINT_LAYERS_2D_NAVIGATION));
+	}
+
+	// Custom data.
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
+	}
+	p_list->push_back(PropertyInfo(Variant::NIL, "Custom data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+	for (int i = 0; i < custom_data_layers.size(); i++) {
+		p_list->push_back(PropertyInfo(Variant::STRING, vformat("custom_data_layer_%d/name", i)));
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("custom_data_layer_%d/type", i), PROPERTY_HINT_ENUM, argt));
+	}
+
+	// Sources.
+	// Note: sources have to be listed in at the end as some TileData rely on the TileSet properties being initialized first.
+	for (Map<int, Ref<TileSetSource>>::Element *E_source = sources.front(); E_source; E_source = E_source->next()) {
+		p_list->push_back(PropertyInfo(Variant::INT, vformat("sources/%d", E_source->key()), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+	}
 }
 
-String TileSet::tile_get_name(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), String());
-	return tile_map[p_id].name;
+void TileSet::_bind_methods() {
+	// Sources management.
+	ClassDB::bind_method(D_METHOD("get_next_source_id"), &TileSet::get_next_source_id);
+	ClassDB::bind_method(D_METHOD("add_source", "atlas_source_id_override"), &TileSet::add_source, DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("remove_source", "source_id"), &TileSet::remove_source);
+	ClassDB::bind_method(D_METHOD("set_source_id", "source_id"), &TileSet::set_source_id);
+	ClassDB::bind_method(D_METHOD("get_source_count"), &TileSet::get_source_count);
+	ClassDB::bind_method(D_METHOD("get_source_id", "index"), &TileSet::get_source_id);
+	ClassDB::bind_method(D_METHOD("has_source", "index"), &TileSet::has_source);
+	ClassDB::bind_method(D_METHOD("get_source", "index"), &TileSet::get_source);
+
+	// Shape and layout.
+	ClassDB::bind_method(D_METHOD("set_tile_shape", "shape"), &TileSet::set_tile_shape);
+	ClassDB::bind_method(D_METHOD("get_tile_shape"), &TileSet::get_tile_shape);
+	ClassDB::bind_method(D_METHOD("set_tile_layout", "layout"), &TileSet::set_tile_layout);
+	ClassDB::bind_method(D_METHOD("get_tile_layout"), &TileSet::get_tile_layout);
+	ClassDB::bind_method(D_METHOD("set_tile_offset_axis", "alignment"), &TileSet::set_tile_offset_axis);
+	ClassDB::bind_method(D_METHOD("get_tile_offset_axis"), &TileSet::get_tile_offset_axis);
+	ClassDB::bind_method(D_METHOD("set_tile_size", "size"), &TileSet::set_tile_size);
+	ClassDB::bind_method(D_METHOD("get_tile_size"), &TileSet::get_tile_size);
+	ClassDB::bind_method(D_METHOD("set_tile_skew", "skew"), &TileSet::set_tile_skew);
+	ClassDB::bind_method(D_METHOD("get_tile_skew"), &TileSet::get_tile_skew);
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "tile_shape", PROPERTY_HINT_ENUM, "Square,Isometric,Half-offset square,Hexagon"), "set_tile_shape", "get_tile_shape");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "tile_layout", PROPERTY_HINT_ENUM, "Stacked,Stacked Offset,Stairs Right,Stairs Down,Diamond Right,Diamond Down"), "set_tile_layout", "get_tile_layout");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "tile_offset_axis", PROPERTY_HINT_ENUM, "Horizontal Offset,Vertical Offset"), "set_tile_offset_axis", "get_tile_offset_axis");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "tile_size"), "set_tile_size", "get_tile_size");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "tile_skew"), "set_tile_skew", "get_tile_skew");
+
+	// Rendering.
+	ClassDB::bind_method(D_METHOD("set_uv_clipping", "uv_clipping"), &TileSet::set_uv_clipping);
+	ClassDB::bind_method(D_METHOD("is_uv_clipping"), &TileSet::is_uv_clipping);
+	ClassDB::bind_method(D_METHOD("set_y_sorting", "y_sorting"), &TileSet::set_y_sorting);
+	ClassDB::bind_method(D_METHOD("is_y_sorting"), &TileSet::is_y_sorting);
+
+	ClassDB::bind_method(D_METHOD("set_occlusion_layers_count", "occlusion_layers_count"), &TileSet::set_occlusion_layers_count);
+	ClassDB::bind_method(D_METHOD("get_occlusion_layers_count"), &TileSet::get_occlusion_layers_count);
+	ClassDB::bind_method(D_METHOD("set_occlusion_layer_light_mask", "layer_index", "light_mask"), &TileSet::set_occlusion_layer_light_mask);
+	ClassDB::bind_method(D_METHOD("get_occlusion_layer_light_mask"), &TileSet::get_occlusion_layer_light_mask);
+	ClassDB::bind_method(D_METHOD("set_occlusion_layer_sdf_collision", "layer_index", "sdf_collision"), &TileSet::set_occlusion_layer_sdf_collision);
+	ClassDB::bind_method(D_METHOD("get_occlusion_layer_sdf_collision"), &TileSet::get_occlusion_layer_sdf_collision);
+
+	// Physics
+	ClassDB::bind_method(D_METHOD("set_physics_layers_count", "physics_layers_count"), &TileSet::set_physics_layers_count);
+	ClassDB::bind_method(D_METHOD("get_physics_layers_count"), &TileSet::get_physics_layers_count);
+	ClassDB::bind_method(D_METHOD("set_physics_layer_collision_layer", "layer_index", "layer"), &TileSet::set_physics_layer_collision_layer);
+	ClassDB::bind_method(D_METHOD("get_physics_layer_collision_layer", "layer_index"), &TileSet::get_physics_layer_collision_layer);
+	ClassDB::bind_method(D_METHOD("set_physics_layer_collision_mask", "layer_index", "mask"), &TileSet::set_physics_layer_collision_mask);
+	ClassDB::bind_method(D_METHOD("get_physics_layer_collision_mask", "layer_index"), &TileSet::get_physics_layer_collision_mask);
+	ClassDB::bind_method(D_METHOD("set_physics_layer_physics_material", "layer_index", "physics_material"), &TileSet::set_physics_layer_physics_material);
+	ClassDB::bind_method(D_METHOD("get_physics_layer_physics_material", "layer_index"), &TileSet::get_physics_layer_physics_material);
+
+	// Terrains
+	ClassDB::bind_method(D_METHOD("set_terrain_sets_count", "terrain_sets_count"), &TileSet::set_terrain_sets_count);
+	ClassDB::bind_method(D_METHOD("get_terrain_sets_count"), &TileSet::get_terrain_sets_count);
+	ClassDB::bind_method(D_METHOD("set_terrain_set_mode", "terrain_set", "mode"), &TileSet::set_terrain_set_mode);
+	ClassDB::bind_method(D_METHOD("get_terrain_set_mode", "terrain_set"), &TileSet::get_terrain_set_mode);
+
+	ClassDB::bind_method(D_METHOD("set_terrains_count", "terrain_set", "terrains_count"), &TileSet::set_terrains_count);
+	ClassDB::bind_method(D_METHOD("get_terrains_count", "terrain_set"), &TileSet::get_terrains_count);
+	ClassDB::bind_method(D_METHOD("set_terrain_name", "terrain_set", "terrain_index", "name"), &TileSet::set_terrain_name);
+	ClassDB::bind_method(D_METHOD("get_terrain_name", "terrain_set", "terrain_index"), &TileSet::get_terrain_name);
+	ClassDB::bind_method(D_METHOD("set_terrain_color", "terrain_set", "terrain_index", "color"), &TileSet::set_terrain_color);
+	ClassDB::bind_method(D_METHOD("get_terrain_color", "terrain_set", "terrain_index"), &TileSet::get_terrain_color);
+
+	// Navigation
+	ClassDB::bind_method(D_METHOD("set_navigation_layers_count", "navigation_layers_count"), &TileSet::set_navigation_layers_count);
+	ClassDB::bind_method(D_METHOD("get_navigation_layers_count"), &TileSet::get_navigation_layers_count);
+	ClassDB::bind_method(D_METHOD("set_navigation_layer_layers", "layer_index", "layers"), &TileSet::set_navigation_layer_layers);
+	ClassDB::bind_method(D_METHOD("get_navigation_layer_layers", "layer_index"), &TileSet::get_navigation_layer_layers);
+
+	// Custom data
+	ClassDB::bind_method(D_METHOD("set_custom_data_layers_count", "custom_data_layers_count"), &TileSet::set_custom_data_layers_count);
+	ClassDB::bind_method(D_METHOD("get_custom_data_layers_count"), &TileSet::get_custom_data_layers_count);
+
+	ADD_GROUP("Rendering", "");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "uv_clipping"), "set_uv_clipping", "is_uv_clipping");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "y_sorting"), "set_y_sorting", "is_y_sorting");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "occlusion_layers_count", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_occlusion_layers_count", "get_occlusion_layers_count");
+
+	ADD_GROUP("Physics", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "physics_layers_count", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_physics_layers_count", "get_physics_layers_count");
+
+	ADD_GROUP("Terrains", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "terrains_sets_count", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_terrain_sets_count", "get_terrain_sets_count");
+
+	ADD_GROUP("Navigation", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "navigation_layers_count", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_navigation_layers_count", "get_navigation_layers_count");
+
+	ADD_GROUP("Custom data", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "custom_data_layers_count", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR), "set_custom_data_layers_count", "get_custom_data_layers_count");
+
+	// -- Enum binding --
+	BIND_ENUM_CONSTANT(TILE_SHAPE_SQUARE);
+	BIND_ENUM_CONSTANT(TILE_SHAPE_ISOMETRIC);
+	BIND_ENUM_CONSTANT(TILE_SHAPE_HALF_OFFSET_SQUARE);
+	BIND_ENUM_CONSTANT(TILE_SHAPE_HEXAGON);
+
+	BIND_ENUM_CONSTANT(TILE_LAYOUT_STACKED);
+	BIND_ENUM_CONSTANT(TILE_LAYOUT_STACKED_OFFSET);
+	BIND_ENUM_CONSTANT(TILE_LAYOUT_STAIRS_RIGHT);
+	BIND_ENUM_CONSTANT(TILE_LAYOUT_STAIRS_DOWN);
+	BIND_ENUM_CONSTANT(TILE_LAYOUT_DIAMOND_RIGHT);
+	BIND_ENUM_CONSTANT(TILE_LAYOUT_DIAMOND_DOWN);
+
+	BIND_ENUM_CONSTANT(TILE_OFFSET_AXIS_HORIZONTAL);
+	BIND_ENUM_CONSTANT(TILE_OFFSET_AXIS_VERTICAL);
+
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_RIGHT_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_RIGHT_CORNER);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_CORNER);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_LEFT_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_LEFT_CORNER);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_CORNER);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
+	BIND_ENUM_CONSTANT(TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER);
+
+	BIND_ENUM_CONSTANT(TERRAIN_MODE_MATCH_CORNERS_AND_SIDES);
+	BIND_ENUM_CONSTANT(TERRAIN_MODE_MATCH_CORNERS);
+	BIND_ENUM_CONSTANT(TERRAIN_MODE_MATCH_SIDES);
 }
 
-void TileSet::tile_clear_shapes(int p_id) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].shapes_data.clear();
+TileSet::TileSet() {
+	// Instanciatie and list all plugins.
+	tile_set_plugins_vector.append(memnew(TileSetAtlasPluginRendering));
+	tile_set_plugins_vector.append(memnew(TileSetAtlasPluginPhysics));
+	tile_set_plugins_vector.append(memnew(TileSetAtlasPluginTerrain));
+	tile_set_plugins_vector.append(memnew(TileSetAtlasPluginNavigation));
 }
 
-void TileSet::tile_add_shape(int p_id, const Ref<Shape2D> &p_shape, const Transform2D &p_transform, bool p_one_way, const Vector2 &p_autotile_coord) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
+TileSet::~TileSet() {
+	for (Map<int, CompatibilityTileData *>::Element *E = compatibility_data.front(); E; E = E->next()) {
+		memdelete(E->get());
+	}
+	while (!source_ids.is_empty()) {
+		remove_source(source_ids[0]);
+	}
+	for (int i = 0; i < tile_set_plugins_vector.size(); i++) {
+		memdelete(tile_set_plugins_vector[i]);
+	}
+}
 
-	ShapeData new_data = ShapeData();
-	new_data.shape = p_shape;
-	new_data.shape_transform = p_transform;
-	new_data.one_way_collision = p_one_way;
-	new_data.autotile_coord = p_autotile_coord;
+/////////////////////////////// TileSetSource //////////////////////////////////////
 
-	tile_map[p_id].shapes_data.push_back(new_data);
+void TileSetSource::set_tile_set(const TileSet *p_tile_set) {
+	tile_set = p_tile_set;
 }
 
-int TileSet::tile_get_shape_count(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
-	return tile_map[p_id].shapes_data.size();
+/////////////////////////////// TileSetAtlasSource //////////////////////////////////////
+
+void TileSetAtlasSource::set_tile_set(const TileSet *p_tile_set) {
+	tile_set = p_tile_set;
+
+	// Set the TileSet on all TileData.
+	for (Map<Vector2i, TileAlternativesData>::Element *E_tile = tiles.front(); E_tile; E_tile = E_tile->next()) {
+		for (Map<int, TileData *>::Element *E_alternative = E_tile->get().alternatives.front(); E_alternative; E_alternative = E_alternative->next()) {
+			E_alternative->get()->set_tile_set(tile_set);
+		}
+	}
 }
 
-void TileSet::tile_set_shape(int p_id, int p_shape_id, const Ref<Shape2D> &p_shape) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	ERR_FAIL_COND(p_shape_id < 0);
+void TileSetAtlasSource::notify_tile_data_properties_should_change() {
+	// Set the TileSet on all TileData.
+	for (Map<Vector2i, TileAlternativesData>::Element *E_tile = tiles.front(); E_tile; E_tile = E_tile->next()) {
+		for (Map<int, TileData *>::Element *E_alternative = E_tile->get().alternatives.front(); E_alternative; E_alternative = E_alternative->next()) {
+			E_alternative->get()->notify_tile_data_properties_should_change();
+		}
+	}
+}
 
-	if (p_shape_id >= tile_map[p_id].shapes_data.size()) {
-		tile_map[p_id].shapes_data.resize(p_shape_id + 1);
+void TileSetAtlasSource::reset_state() {
+	// Reset all TileData.
+	for (Map<Vector2i, TileAlternativesData>::Element *E_tile = tiles.front(); E_tile; E_tile = E_tile->next()) {
+		for (Map<int, TileData *>::Element *E_alternative = E_tile->get().alternatives.front(); E_alternative; E_alternative = E_alternative->next()) {
+			E_alternative->get()->reset_state();
+		}
 	}
-	tile_map[p_id].shapes_data.write[p_shape_id].shape = p_shape;
-	_decompose_convex_shape(p_shape);
+}
+
+void TileSetAtlasSource::set_texture(Ref<Texture2D> p_texture) {
+	texture = p_texture;
+
 	emit_changed();
 }
 
-Ref<Shape2D> TileSet::tile_get_shape(int p_id, int p_shape_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<Shape2D>());
-	ERR_FAIL_COND_V(p_shape_id < 0, Ref<Shape2D>());
+Ref<Texture2D> TileSetAtlasSource::get_texture() const {
+	return texture;
+}
 
-	if (p_shape_id < tile_map[p_id].shapes_data.size()) {
-		return tile_map[p_id].shapes_data[p_shape_id].shape;
+void TileSetAtlasSource::set_margins(Vector2i p_margins) {
+	if (p_margins.x < 0 || p_margins.y < 0) {
+		WARN_PRINT("Atlas source margins should be positive.");
+		margins = Vector2i(MAX(0, p_margins.x), MAX(0, p_margins.y));
+	} else {
+		margins = p_margins;
 	}
 
-	return Ref<Shape2D>();
+	emit_changed();
+}
+Vector2i TileSetAtlasSource::get_margins() const {
+	return margins;
 }
 
-void TileSet::tile_set_shape_transform(int p_id, int p_shape_id, const Transform2D &p_offset) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	ERR_FAIL_COND(p_shape_id < 0);
+void TileSetAtlasSource::set_separation(Vector2i p_separation) {
+	if (p_separation.x < 0 || p_separation.y < 0) {
+		WARN_PRINT("Atlas source separation should be positive.");
+		separation = Vector2i(MAX(0, p_separation.x), MAX(0, p_separation.y));
+	} else {
+		separation = p_separation;
+	}
+
+	emit_changed();
+}
+Vector2i TileSetAtlasSource::get_separation() const {
+	return separation;
+}
 
-	if (p_shape_id >= tile_map[p_id].shapes_data.size()) {
-		tile_map[p_id].shapes_data.resize(p_shape_id + 1);
+void TileSetAtlasSource::set_texture_region_size(Vector2i p_tile_size) {
+	if (p_tile_size.x <= 0 || p_tile_size.y <= 0) {
+		WARN_PRINT("Atlas source tile_size should be strictly positive.");
+		texture_region_size = Vector2i(MAX(1, p_tile_size.x), MAX(1, p_tile_size.y));
+	} else {
+		texture_region_size = p_tile_size;
 	}
-	tile_map[p_id].shapes_data.write[p_shape_id].shape_transform = p_offset;
+
 	emit_changed();
 }
+Vector2i TileSetAtlasSource::get_texture_region_size() const {
+	return texture_region_size;
+}
+
+Vector2i TileSetAtlasSource::get_atlas_grid_size() const {
+	Ref<Texture2D> texture = get_texture();
+	if (!texture.is_valid()) {
+		return Vector2i();
+	}
+
+	ERR_FAIL_COND_V(texture_region_size.x <= 0 || texture_region_size.y <= 0, Vector2i());
+
+	Size2i valid_area = texture->get_size() - margins;
+
+	// Compute the number of valid tiles in the tiles atlas
+	Size2i grid_size = Size2i();
+	if (valid_area.x >= texture_region_size.x && valid_area.y >= texture_region_size.y) {
+		valid_area -= texture_region_size;
+		grid_size = Size2i(1, 1) + valid_area / (texture_region_size + separation);
+	}
+	return grid_size;
+}
 
-Transform2D TileSet::tile_get_shape_transform(int p_id, int p_shape_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Transform2D());
-	ERR_FAIL_COND_V(p_shape_id < 0, Transform2D());
+bool TileSetAtlasSource::_set(const StringName &p_name, const Variant &p_value) {
+	Vector<String> components = String(p_name).split("/", true, 2);
 
-	if (p_shape_id < tile_map[p_id].shapes_data.size()) {
-		return tile_map[p_id].shapes_data[p_shape_id].shape_transform;
+	// Compute the vector2i if we have coordinates.
+	Vector<String> coords_split = components[0].split(":");
+	Vector2i coords = TileSetAtlasSource::INVALID_ATLAS_COORDS;
+	if (coords_split.size() == 2 && coords_split[0].is_valid_integer() && coords_split[1].is_valid_integer()) {
+		coords = Vector2i(coords_split[0].to_int(), coords_split[1].to_int());
 	}
 
-	return Transform2D();
+	// Properties.
+	if (coords != TileSetAtlasSource::INVALID_ATLAS_COORDS) {
+		// Create the tile if needed.
+		if (!has_tile(coords)) {
+			create_tile(coords);
+		}
+		if (components.size() >= 2) {
+			// Properties.
+			if (components[1] == "size_in_atlas") {
+				move_tile_in_atlas(coords, coords, p_value);
+			} else if (components[1] == "next_alternative_id") {
+				tiles[coords].next_alternative_id = p_value;
+			} else if (components[1].is_valid_integer()) {
+				int alternative_id = components[1].to_int();
+				if (alternative_id != TileSetAtlasSource::INVALID_TILE_ALTERNATIVE) {
+					// Create the alternative if needed ?
+					if (!has_alternative_tile(coords, alternative_id)) {
+						create_alternative_tile(coords, alternative_id);
+					}
+					if (!tiles[coords].alternatives.has(alternative_id)) {
+						tiles[coords].alternatives[alternative_id] = memnew(TileData);
+						tiles[coords].alternatives[alternative_id]->set_tile_set(tile_set);
+						tiles[coords].alternatives[alternative_id]->set_allow_transform(alternative_id > 0);
+						tiles[coords].alternatives_ids.append(alternative_id);
+					}
+					if (components.size() >= 3) {
+						bool valid;
+						tiles[coords].alternatives[alternative_id]->set(components[2], p_value, &valid);
+						return valid;
+					} else {
+						// Only create the alternative if it did not exist yet.
+						return true;
+					}
+				}
+			}
+		}
+	}
+
+	return false;
 }
 
-void TileSet::tile_set_shape_offset(int p_id, int p_shape_id, const Vector2 &p_offset) {
-	Transform2D transform = tile_get_shape_transform(p_id, p_shape_id);
-	transform.set_origin(p_offset);
-	tile_set_shape_transform(p_id, p_shape_id, transform);
+bool TileSetAtlasSource::_get(const StringName &p_name, Variant &r_ret) const {
+	Vector<String> components = String(p_name).split("/", true, 2);
+
+	// Properties.
+	Vector<String> coords_split = components[0].split(":");
+	if (coords_split.size() == 2 && coords_split[0].is_valid_integer() && coords_split[1].is_valid_integer()) {
+		Vector2i coords = Vector2i(coords_split[0].to_int(), coords_split[1].to_int());
+		if (tiles.has(coords)) {
+			if (components.size() >= 2) {
+				// Properties.
+				if (components[1] == "size_in_atlas") {
+					r_ret = tiles[coords].size_in_atlas;
+					return true;
+				} else if (components[1] == "next_alternative_id") {
+					r_ret = tiles[coords].next_alternative_id;
+					return true;
+				} else if (components[1].is_valid_integer()) {
+					int alternative_id = components[1].to_int();
+					if (alternative_id != TileSetAtlasSource::INVALID_TILE_ALTERNATIVE && tiles[coords].alternatives.has(alternative_id)) {
+						if (components.size() >= 3) {
+							bool valid;
+							r_ret = tiles[coords].alternatives[alternative_id]->get(components[2], &valid);
+							return valid;
+						} else {
+							// Only to notify the tile alternative exists.
+							r_ret = alternative_id;
+							return true;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return false;
 }
 
-Vector2 TileSet::tile_get_shape_offset(int p_id, int p_shape_id) const {
-	return tile_get_shape_transform(p_id, p_shape_id).get_origin();
+void TileSetAtlasSource::_get_property_list(List<PropertyInfo> *p_list) const {
+	// Atlases data.
+	PropertyInfo property_info;
+	for (Map<Vector2i, TileAlternativesData>::Element *E_tile = tiles.front(); E_tile; E_tile = E_tile->next()) {
+		List<PropertyInfo> tile_property_list;
+
+		// size_in_atlas
+		property_info = PropertyInfo(Variant::VECTOR2I, "size_in_atlas", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR);
+		if (E_tile->get().size_in_atlas == Vector2i(1, 1)) {
+			property_info.usage ^= PROPERTY_USAGE_STORAGE;
+		}
+		tile_property_list.push_back(property_info);
+
+		// next_alternative_id
+		property_info = PropertyInfo(Variant::INT, "next_alternative_id", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR);
+		if (E_tile->get().next_alternative_id == 1) {
+			property_info.usage ^= PROPERTY_USAGE_STORAGE;
+		}
+		tile_property_list.push_back(property_info);
+
+		for (Map<int, TileData *>::Element *E_alternative = E_tile->get().alternatives.front(); E_alternative; E_alternative = E_alternative->next()) {
+			// Add a dummy property to show the alternative exists.
+			tile_property_list.push_back(PropertyInfo(Variant::INT, vformat("%d", E_alternative->key()), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+
+			// Get the alternative tile's properties and append them to the list of properties.
+			List<PropertyInfo> alternative_property_list;
+			E_alternative->get()->get_property_list(&alternative_property_list);
+			for (List<PropertyInfo>::Element *E_property = alternative_property_list.front(); E_property; E_property = E_property->next()) {
+				property_info = E_property->get();
+				bool valid;
+				Variant default_value = ClassDB::class_get_default_property_value("TileData", property_info.name, &valid);
+				Variant value = E_alternative->get()->get(property_info.name);
+				if (valid && value == default_value) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				property_info.name = vformat("%s/%s", vformat("%d", E_alternative->key()), property_info.name);
+				tile_property_list.push_back(property_info);
+			}
+		}
+
+		// Add all alternative.
+		for (List<PropertyInfo>::Element *E_property = tile_property_list.front(); E_property; E_property = E_property->next()) {
+			E_property->get().name = vformat("%s/%s", vformat("%d:%d", E_tile->key().x, E_tile->key().y), E_property->get().name);
+			p_list->push_back(E_property->get());
+		}
+	}
 }
 
-void TileSet::tile_set_shape_one_way(int p_id, int p_shape_id, const bool p_one_way) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	ERR_FAIL_COND(p_shape_id < 0);
+void TileSetAtlasSource::create_tile(const Vector2i p_atlas_coords, const Vector2i p_size) {
+	// Create a tile if it does not exists.
+	ERR_FAIL_COND(p_atlas_coords.x < 0 || p_atlas_coords.y < 0);
+	ERR_FAIL_COND(p_size.x <= 0 || p_size.y <= 0);
+	for (int x = 0; x < p_size.x; x++) {
+		for (int y = 0; y < p_size.y; y++) {
+			Vector2i coords = p_atlas_coords + Vector2i(x, y);
+			ERR_FAIL_COND_MSG(tiles.has(coords), vformat("Cannot create tile at position %s with size %s. Already a tile present at %s.", p_atlas_coords, p_size, coords));
+		}
+	}
 
-	if (p_shape_id >= tile_map[p_id].shapes_data.size()) {
-		tile_map[p_id].shapes_data.resize(p_shape_id + 1);
+	// Create and resize the tile.
+	tiles.insert(p_atlas_coords, TileSetAtlasSource::TileAlternativesData());
+	tiles_ids.append(p_atlas_coords);
+	tiles_ids.sort();
+
+	tiles[p_atlas_coords].size_in_atlas = p_size;
+	tiles[p_atlas_coords].alternatives[0] = memnew(TileData);
+	tiles[p_atlas_coords].alternatives[0]->set_tile_set(tile_set);
+	tiles[p_atlas_coords].alternatives[0]->set_allow_transform(false);
+	tiles[p_atlas_coords].alternatives[0]->connect("changed", callable_mp((Resource *)this, &TileSetAtlasSource::emit_changed));
+	tiles[p_atlas_coords].alternatives[0]->notify_property_list_changed();
+	tiles[p_atlas_coords].alternatives_ids.append(0);
+
+	// Add all covered positions to the mapping cache
+	for (int x = 0; x < p_size.x; x++) {
+		for (int y = 0; y < p_size.y; y++) {
+			Vector2i coords = p_atlas_coords + Vector2i(x, y);
+			_coords_mapping_cache[coords] = p_atlas_coords;
+		}
 	}
-	tile_map[p_id].shapes_data.write[p_shape_id].one_way_collision = p_one_way;
-	emit_changed();
+
+	emit_signal("changed");
 }
 
-bool TileSet::tile_get_shape_one_way(int p_id, int p_shape_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), false);
-	ERR_FAIL_COND_V(p_shape_id < 0, false);
+void TileSetAtlasSource::remove_tile(Vector2i p_atlas_coords) {
+	ERR_FAIL_COND_MSG(!tiles.has(p_atlas_coords), vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+
+	// Remove all covered positions from the mapping cache
+	Size2i size = tiles[p_atlas_coords].size_in_atlas;
 
-	if (p_shape_id < tile_map[p_id].shapes_data.size()) {
-		return tile_map[p_id].shapes_data[p_shape_id].one_way_collision;
+	for (int x = 0; x < size.x; x++) {
+		for (int y = 0; y < size.y; y++) {
+			Vector2i coords = p_atlas_coords + Vector2i(x, y);
+			_coords_mapping_cache.erase(coords);
+		}
 	}
 
-	return false;
+	// Free tile data.
+	for (Map<int, TileData *>::Element *E_tile_data = tiles[p_atlas_coords].alternatives.front(); E_tile_data; E_tile_data = E_tile_data->next()) {
+		memdelete(E_tile_data->get());
+	}
+
+	// Delete the tile
+	tiles.erase(p_atlas_coords);
+	tiles_ids.erase(p_atlas_coords);
+	tiles_ids.sort();
+
+	emit_signal("changed");
 }
 
-void TileSet::tile_set_shape_one_way_margin(int p_id, int p_shape_id, float p_margin) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	ERR_FAIL_COND(p_shape_id < 0);
+bool TileSetAtlasSource::has_tile(Vector2i p_atlas_coords) const {
+	return tiles.has(p_atlas_coords);
+}
 
-	if (p_shape_id >= tile_map[p_id].shapes_data.size()) {
-		tile_map[p_id].shapes_data.resize(p_shape_id + 1);
+Vector2i TileSetAtlasSource::get_tile_at_coords(Vector2i p_atlas_coords) const {
+	if (!_coords_mapping_cache.has(p_atlas_coords)) {
+		return INVALID_ATLAS_COORDS;
 	}
-	tile_map[p_id].shapes_data.write[p_shape_id].one_way_collision_margin = p_margin;
-	emit_changed();
+
+	return _coords_mapping_cache[p_atlas_coords];
+}
+
+Vector2i TileSetAtlasSource::get_tile_size_in_atlas(Vector2i p_atlas_coords) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), Vector2i(-1, -1), vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+
+	return tiles[p_atlas_coords].size_in_atlas;
 }
 
-float TileSet::tile_get_shape_one_way_margin(int p_id, int p_shape_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
-	ERR_FAIL_COND_V(p_shape_id < 0, 0);
+int TileSetAtlasSource::get_tiles_count() const {
+	return tiles_ids.size();
+}
+
+Vector2i TileSetAtlasSource::get_tile_id(int p_index) const {
+	ERR_FAIL_INDEX_V(p_index, tiles_ids.size(), TileSetAtlasSource::INVALID_ATLAS_COORDS);
+	return tiles_ids[p_index];
+}
+
+Rect2i TileSetAtlasSource::get_tile_texture_region(Vector2i p_atlas_coords) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), Rect2i(), vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+
+	Vector2i size_in_atlas = tiles[p_atlas_coords].size_in_atlas;
+	Vector2 region_size = texture_region_size * size_in_atlas + separation * (size_in_atlas - Vector2i(1, 1));
+
+	Vector2 origin = margins + (p_atlas_coords * (texture_region_size + separation));
+
+	return Rect2(origin, region_size);
+	;
+}
 
-	if (p_shape_id < tile_map[p_id].shapes_data.size()) {
-		return tile_map[p_id].shapes_data[p_shape_id].one_way_collision_margin;
+Vector2i TileSetAtlasSource::get_tile_effective_texture_offset(Vector2i p_atlas_coords, int p_alternative_tile) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), Vector2i(), vformat("TileSetAtlasSource has no tile at %s.", Vector2i(p_atlas_coords)));
+	ERR_FAIL_COND_V_MSG(!has_alternative_tile(p_atlas_coords, p_alternative_tile), Vector2i(), vformat("TileSetAtlasSource has no alternative tile with id %d at %s.", p_alternative_tile, String(p_atlas_coords)));
+	ERR_FAIL_COND_V(!tile_set, Vector2i());
+
+	Vector2 margin = (get_tile_texture_region(p_atlas_coords).size - tile_set->get_tile_size()) / 2;
+	margin = Vector2i(MAX(0, margin.x), MAX(0, margin.y));
+	Vector2i effective_texture_offset = Object::cast_to<TileData>(get_tile_data(p_atlas_coords, p_alternative_tile))->get_texture_offset();
+	if (ABS(effective_texture_offset.x) > margin.x || ABS(effective_texture_offset.y) > margin.y) {
+		effective_texture_offset.x = CLAMP(effective_texture_offset.x, -margin.x, margin.x);
+		effective_texture_offset.y = CLAMP(effective_texture_offset.y, -margin.y, margin.y);
 	}
 
-	return 0;
+	return effective_texture_offset;
 }
 
-void TileSet::tile_set_light_occluder(int p_id, const Ref<OccluderPolygon2D> &p_light_occluder) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].occluder = p_light_occluder;
+bool TileSetAtlasSource::can_move_tile_in_atlas(Vector2i p_atlas_coords, Vector2i p_new_atlas_coords, Vector2i p_new_size) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), false, vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+
+	Vector2i new_atlas_coords = (p_new_atlas_coords != INVALID_ATLAS_COORDS) ? p_new_atlas_coords : p_atlas_coords;
+	if (new_atlas_coords.x < 0 || new_atlas_coords.y < 0) {
+		return false;
+	}
+
+	Vector2i size = (p_new_size != Vector2i(-1, -1)) ? p_new_size : tiles[p_atlas_coords].size_in_atlas;
+	ERR_FAIL_COND_V(size.x <= 0 || size.y <= 0, false);
+
+	Size2i grid_size = get_atlas_grid_size();
+	if (new_atlas_coords.x + size.x > grid_size.x || new_atlas_coords.y + size.y > grid_size.y) {
+		return false;
+	}
+
+	Rect2i new_rect = Rect2i(new_atlas_coords, size);
+	// Check if the new tile can fit in the new rect.
+	for (int x = new_rect.position.x; x < new_rect.get_end().x; x++) {
+		for (int y = new_rect.position.y; y < new_rect.get_end().y; y++) {
+			Vector2i coords = get_tile_at_coords(Vector2i(x, y));
+			if (coords != p_atlas_coords && coords != TileSetAtlasSource::INVALID_ATLAS_COORDS) {
+				return false;
+			}
+		}
+	}
+
+	return true;
 }
 
-Ref<OccluderPolygon2D> TileSet::tile_get_light_occluder(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<OccluderPolygon2D>());
-	return tile_map[p_id].occluder;
+void TileSetAtlasSource::move_tile_in_atlas(Vector2i p_atlas_coords, Vector2i p_new_atlas_coords, Vector2i p_new_size) {
+	bool can_move = can_move_tile_in_atlas(p_atlas_coords, p_new_atlas_coords, p_new_size);
+	ERR_FAIL_COND_MSG(!can_move, vformat("Cannot move tile at position %s with size %s. Tile already present.", p_new_atlas_coords, p_new_size));
+
+	// Compute the actual new rect from arguments.
+	Vector2i new_atlas_coords = (p_new_atlas_coords != INVALID_ATLAS_COORDS) ? p_new_atlas_coords : p_atlas_coords;
+	Vector2i size = (p_new_size != Vector2i(-1, -1)) ? p_new_size : tiles[p_atlas_coords].size_in_atlas;
+
+	if (new_atlas_coords == p_atlas_coords && size == tiles[p_atlas_coords].size_in_atlas) {
+		return;
+	}
+
+	// Remove all covered positions from the mapping cache.
+	Size2i old_size = tiles[p_atlas_coords].size_in_atlas;
+	for (int x = 0; x < old_size.x; x++) {
+		for (int y = 0; y < old_size.y; y++) {
+			Vector2i coords = p_atlas_coords + Vector2i(x, y);
+			_coords_mapping_cache.erase(coords);
+		}
+	}
+
+	// Move the tile and update its size.
+	if (new_atlas_coords != p_atlas_coords) {
+		tiles[new_atlas_coords] = tiles[p_atlas_coords];
+		tiles.erase(p_atlas_coords);
+
+		tiles_ids.erase(p_atlas_coords);
+		tiles_ids.append(new_atlas_coords);
+		tiles_ids.sort();
+	}
+	tiles[new_atlas_coords].size_in_atlas = size;
+
+	// Add all covered positions to the mapping cache again.
+	for (int x = 0; x < size.x; x++) {
+		for (int y = 0; y < size.y; y++) {
+			Vector2i coords = new_atlas_coords + Vector2i(x, y);
+			_coords_mapping_cache[coords] = new_atlas_coords;
+		}
+	}
+
+	emit_signal("changed");
 }
 
-void TileSet::autotile_set_light_occluder(int p_id, const Ref<OccluderPolygon2D> &p_light_occluder, const Vector2 &p_coord) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	if (p_light_occluder.is_null()) {
-		if (tile_map[p_id].autotile_data.occluder_map.has(p_coord)) {
-			tile_map[p_id].autotile_data.occluder_map.erase(p_coord);
+bool TileSetAtlasSource::has_tiles_outside_texture() {
+	Vector2i grid_size = get_atlas_grid_size();
+	Vector<Vector2i> to_remove;
+
+	for (Map<Vector2i, TileSetAtlasSource::TileAlternativesData>::Element *E = tiles.front(); E; E = E->next()) {
+		if (E->key().x >= grid_size.x || E->key().y >= grid_size.y) {
+			return true;
 		}
-	} else {
-		tile_map[p_id].autotile_data.occluder_map[p_coord] = p_light_occluder;
 	}
+
+	return false;
 }
 
-Ref<OccluderPolygon2D> TileSet::autotile_get_light_occluder(int p_id, const Vector2 &p_coord) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<OccluderPolygon2D>());
+void TileSetAtlasSource::clear_tiles_outside_texture() {
+	Vector2i grid_size = get_atlas_grid_size();
+	Vector<Vector2i> to_remove;
 
-	if (!tile_map[p_id].autotile_data.occluder_map.has(p_coord)) {
-		return Ref<OccluderPolygon2D>();
-	} else {
-		return tile_map[p_id].autotile_data.occluder_map[p_coord];
+	for (Map<Vector2i, TileSetAtlasSource::TileAlternativesData>::Element *E = tiles.front(); E; E = E->next()) {
+		if (E->key().x >= grid_size.x || E->key().y >= grid_size.y) {
+			to_remove.append(E->key());
+		}
+	}
+
+	for (int i = 0; i < to_remove.size(); i++) {
+		remove_tile(to_remove[i]);
 	}
 }
 
-void TileSet::tile_set_navigation_polygon_offset(int p_id, const Vector2 &p_offset) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].navigation_polygon_offset = p_offset;
+int TileSetAtlasSource::create_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_id_override) {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), -1, vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+	ERR_FAIL_COND_V_MSG(p_alternative_id_override >= 0 && (tiles[p_atlas_coords].alternatives.has(p_alternative_id_override) || tiles[p_atlas_coords].alternatives.has(p_alternative_id_override)), -1, vformat("Cannot create alternative tile. Another alternative exists with id %d.", p_alternative_id_override));
+
+	int new_alternative_id = p_alternative_id_override >= 0 ? p_alternative_id_override : tiles[p_atlas_coords].next_alternative_id;
+
+	tiles[p_atlas_coords].alternatives[new_alternative_id] = memnew(TileData);
+	tiles[p_atlas_coords].alternatives[new_alternative_id]->set_tile_set(tile_set);
+	tiles[p_atlas_coords].alternatives[new_alternative_id]->set_allow_transform(true);
+	tiles[p_atlas_coords].alternatives[new_alternative_id]->notify_property_list_changed();
+	tiles[p_atlas_coords].alternatives_ids.append(new_alternative_id);
+	tiles[p_atlas_coords].alternatives_ids.sort();
+	_compute_next_alternative_id(p_atlas_coords);
+
+	emit_signal("changed");
+
+	return new_alternative_id;
+}
+
+void TileSetAtlasSource::remove_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) {
+	ERR_FAIL_COND_MSG(!tiles.has(p_atlas_coords), vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+	ERR_FAIL_COND_MSG(!tiles[p_atlas_coords].alternatives.has(p_alternative_tile), vformat("TileSetAtlasSource has no alternative with id %d for tile coords %s.", p_alternative_tile, String(p_atlas_coords)));
+	ERR_FAIL_COND_MSG(p_alternative_tile == 0, "Cannot remove the alternative with id 0, the base tile alternative cannot be removed.");
+
+	memdelete(tiles[p_atlas_coords].alternatives[p_alternative_tile]);
+	tiles[p_atlas_coords].alternatives.erase(p_alternative_tile);
+	tiles[p_atlas_coords].alternatives_ids.erase(p_alternative_tile);
+	tiles[p_atlas_coords].alternatives_ids.sort();
+
+	emit_signal("changed");
+}
+
+void TileSetAtlasSource::set_alternative_tile_id(const Vector2i p_atlas_coords, int p_alternative_tile, int p_new_id) {
+	ERR_FAIL_COND_MSG(!tiles.has(p_atlas_coords), vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+	ERR_FAIL_COND_MSG(!tiles[p_atlas_coords].alternatives.has(p_alternative_tile), vformat("TileSetAtlasSource has no alternative with id %d for tile coords %s.", p_alternative_tile, String(p_atlas_coords)));
+	ERR_FAIL_COND_MSG(p_alternative_tile == 0, "Cannot change the alternative with id 0, the base tile alternative cannot be modified.");
+
+	ERR_FAIL_COND_MSG(tiles[p_atlas_coords].alternatives.has(p_new_id), vformat("TileSetAtlasSource has already an alternative with id %d at %s.", p_new_id, String(p_atlas_coords)));
+
+	tiles[p_atlas_coords].alternatives[p_new_id] = tiles[p_atlas_coords].alternatives[p_alternative_tile];
+	tiles[p_atlas_coords].alternatives_ids.append(p_new_id);
+
+	tiles[p_atlas_coords].alternatives.erase(p_alternative_tile);
+	tiles[p_atlas_coords].alternatives_ids.erase(p_alternative_tile);
+	tiles[p_atlas_coords].alternatives_ids.sort();
+
+	emit_signal("changed");
+}
+
+bool TileSetAtlasSource::has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), false, vformat("The TileSetAtlasSource atlas has no tile at %s.", String(p_atlas_coords)));
+	return tiles[p_atlas_coords].alternatives.has(p_alternative_tile);
+}
+
+int TileSetAtlasSource::get_next_alternative_tile_id(const Vector2i p_atlas_coords) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), -1, vformat("The TileSetAtlasSource atlas has no tile at %s.", String(p_atlas_coords)));
+	return tiles[p_atlas_coords].next_alternative_id;
 }
 
-Vector2 TileSet::tile_get_navigation_polygon_offset(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
-	return tile_map[p_id].navigation_polygon_offset;
+int TileSetAtlasSource::get_alternative_tiles_count(const Vector2i p_atlas_coords) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), -1, vformat("The TileSetAtlasSource atlas has no tile at %s.", String(p_atlas_coords)));
+	return tiles[p_atlas_coords].alternatives_ids.size();
 }
 
-void TileSet::tile_set_navigation_polygon(int p_id, const Ref<NavigationPolygon> &p_navigation_polygon) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].navigation_polygon = p_navigation_polygon;
+int TileSetAtlasSource::get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), -1, vformat("The TileSetAtlasSource atlas has no tile at %s.", String(p_atlas_coords)));
+	ERR_FAIL_INDEX_V(p_index, tiles[p_atlas_coords].alternatives_ids.size(), -1);
+
+	return tiles[p_atlas_coords].alternatives_ids[p_index];
 }
 
-Ref<NavigationPolygon> TileSet::tile_get_navigation_polygon(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<NavigationPolygon>());
-	return tile_map[p_id].navigation_polygon;
+Object *TileSetAtlasSource::get_tile_data(const Vector2i p_atlas_coords, int p_alternative_tile) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), nullptr, vformat("The TileSetAtlasSource atlas has no tile at %s.", String(p_atlas_coords)));
+	ERR_FAIL_COND_V_MSG(!tiles[p_atlas_coords].alternatives.has(p_alternative_tile), nullptr, vformat("TileSetAtlasSource has no alternative with id %d for tile coords %s.", p_alternative_tile, String(p_atlas_coords)));
+
+	return tiles[p_atlas_coords].alternatives[p_alternative_tile];
 }
 
-const Map<Vector2, Ref<OccluderPolygon2D>> &TileSet::autotile_get_light_oclusion_map(int p_id) const {
-	static Map<Vector2, Ref<OccluderPolygon2D>> dummy;
-	ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
-	return tile_map[p_id].autotile_data.occluder_map;
+void TileSetAtlasSource::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_texture", "texture"), &TileSetAtlasSource::set_texture);
+	ClassDB::bind_method(D_METHOD("get_texture"), &TileSetAtlasSource::get_texture);
+	ClassDB::bind_method(D_METHOD("set_margins", "margins"), &TileSetAtlasSource::set_margins);
+	ClassDB::bind_method(D_METHOD("get_margins"), &TileSetAtlasSource::get_margins);
+	ClassDB::bind_method(D_METHOD("set_separation", "separation"), &TileSetAtlasSource::set_separation);
+	ClassDB::bind_method(D_METHOD("get_separation"), &TileSetAtlasSource::get_separation);
+	ClassDB::bind_method(D_METHOD("set_texture_region_size", "texture_region_size"), &TileSetAtlasSource::set_texture_region_size);
+	ClassDB::bind_method(D_METHOD("get_texture_region_size"), &TileSetAtlasSource::get_texture_region_size);
+
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D", PROPERTY_USAGE_NOEDITOR), "set_texture", "get_texture");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "margins", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_margins", "get_margins");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "separation", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_separation", "get_separation");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "tile_size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_texture_region_size", "get_texture_region_size");
+
+	// Base tiles
+	ClassDB::bind_method(D_METHOD("create_tile", "atlas_coords", "size"), &TileSetAtlasSource::create_tile, DEFVAL(Vector2i(1, 1)));
+	ClassDB::bind_method(D_METHOD("remove_tile", "atlas_coords"), &TileSetAtlasSource::remove_tile); // Remove a tile. If p_tile_key.alternative_tile if different from 0, remove the alternative
+	ClassDB::bind_method(D_METHOD("has_tile", "atlas_coords"), &TileSetAtlasSource::has_tile);
+	ClassDB::bind_method(D_METHOD("can_move_tile_in_atlas", "atlas_coords", "new_atlas_coords", "new_size"), &TileSetAtlasSource::can_move_tile_in_atlas, DEFVAL(INVALID_ATLAS_COORDS), DEFVAL(Vector2i(-1, -1)));
+	ClassDB::bind_method(D_METHOD("move_tile_in_atlas", "atlas_coords", "new_atlas_coords", "new_size"), &TileSetAtlasSource::move_tile_in_atlas, DEFVAL(INVALID_ATLAS_COORDS), DEFVAL(Vector2i(-1, -1)));
+	ClassDB::bind_method(D_METHOD("get_tile_size_in_atlas", "atlas_coords"), &TileSetAtlasSource::get_tile_size_in_atlas);
+
+	ClassDB::bind_method(D_METHOD("get_tiles_count"), &TileSetAtlasSource::get_tiles_count);
+	ClassDB::bind_method(D_METHOD("get_tile_id", "index"), &TileSetAtlasSource::get_tile_id);
+
+	ClassDB::bind_method(D_METHOD("get_tile_at_coords", "atlas_coords"), &TileSetAtlasSource::get_tile_at_coords);
+
+	// Alternative tiles
+	ClassDB::bind_method(D_METHOD("create_alternative_tile", "atlas_coords", "alternative_id_override"), &TileSetAtlasSource::create_alternative_tile, DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("remove_alternative_tile", "atlas_coords", "alternative_tile"), &TileSetAtlasSource::remove_alternative_tile);
+	ClassDB::bind_method(D_METHOD("set_alternative_tile_id", "atlas_coords", "alternative_tile", "new_id"), &TileSetAtlasSource::set_alternative_tile_id);
+	ClassDB::bind_method(D_METHOD("has_alternative_tile", "atlas_coords", "alternative_tile"), &TileSetAtlasSource::has_alternative_tile);
+	ClassDB::bind_method(D_METHOD("get_next_alternative_tile_id", "atlas_coords"), &TileSetAtlasSource::get_next_alternative_tile_id);
+
+	ClassDB::bind_method(D_METHOD("get_alternative_tiles_count", "atlas_coords"), &TileSetAtlasSource::get_alternative_tiles_count);
+	ClassDB::bind_method(D_METHOD("get_alternative_tile_id", "atlas_coords", "index"), &TileSetAtlasSource::get_alternative_tile_id);
+
+	ClassDB::bind_method(D_METHOD("get_tile_data", "atlas_coords", "index"), &TileSetAtlasSource::get_tile_data);
+
+	// Helpers.
+	ClassDB::bind_method(D_METHOD("get_atlas_grid_size"), &TileSetAtlasSource::get_atlas_grid_size);
+	ClassDB::bind_method(D_METHOD("has_tiles_outside_texture"), &TileSetAtlasSource::has_tiles_outside_texture);
+	ClassDB::bind_method(D_METHOD("clear_tiles_outside_texture"), &TileSetAtlasSource::clear_tiles_outside_texture);
+	ClassDB::bind_method(D_METHOD("get_tile_texture_region", "atlas_coords"), &TileSetAtlasSource::get_tile_texture_region);
 }
 
-void TileSet::autotile_set_navigation_polygon(int p_id, const Ref<NavigationPolygon> &p_navigation_polygon, const Vector2 &p_coord) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	if (p_navigation_polygon.is_null()) {
-		if (tile_map[p_id].autotile_data.navpoly_map.has(p_coord)) {
-			tile_map[p_id].autotile_data.navpoly_map.erase(p_coord);
+TileSetAtlasSource::~TileSetAtlasSource() {
+	// Free everything needed.
+	for (Map<Vector2i, TileAlternativesData>::Element *E_alternatives = tiles.front(); E_alternatives; E_alternatives = E_alternatives->next()) {
+		for (Map<int, TileData *>::Element *E_tile_data = E_alternatives->get().alternatives.front(); E_tile_data; E_tile_data = E_tile_data->next()) {
+			memdelete(E_tile_data->get());
 		}
-	} else {
-		tile_map[p_id].autotile_data.navpoly_map[p_coord] = p_navigation_polygon;
 	}
 }
 
-Ref<NavigationPolygon> TileSet::autotile_get_navigation_polygon(int p_id, const Vector2 &p_coord) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Ref<NavigationPolygon>());
-	if (!tile_map[p_id].autotile_data.navpoly_map.has(p_coord)) {
-		return Ref<NavigationPolygon>();
-	} else {
-		return tile_map[p_id].autotile_data.navpoly_map[p_coord];
+TileData *TileSetAtlasSource::_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile) {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), nullptr, vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+	ERR_FAIL_COND_V_MSG(!tiles[p_atlas_coords].alternatives.has(p_alternative_tile), nullptr, vformat("TileSetAtlasSource has no alternative with id %d for tile coords %s.", p_alternative_tile, String(p_atlas_coords)));
+
+	return tiles[p_atlas_coords].alternatives[p_alternative_tile];
+}
+
+const TileData *TileSetAtlasSource::_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile) const {
+	ERR_FAIL_COND_V_MSG(!tiles.has(p_atlas_coords), nullptr, vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+	ERR_FAIL_COND_V_MSG(!tiles[p_atlas_coords].alternatives.has(p_alternative_tile), nullptr, vformat("TileSetAtlasSource has no alternative with id %d for tile coords %s.", p_alternative_tile, String(p_atlas_coords)));
+
+	return tiles[p_atlas_coords].alternatives[p_alternative_tile];
+}
+
+void TileSetAtlasSource::_compute_next_alternative_id(const Vector2i p_atlas_coords) {
+	ERR_FAIL_COND_MSG(!tiles.has(p_atlas_coords), vformat("TileSetAtlasSource has no tile at %s.", String(p_atlas_coords)));
+
+	while (tiles[p_atlas_coords].alternatives.has(tiles[p_atlas_coords].next_alternative_id)) {
+		tiles[p_atlas_coords].next_alternative_id = (tiles[p_atlas_coords].next_alternative_id % 1073741823) + 1; // 2 ** 30
+	};
+}
+
+/////////////////////////////// TileData //////////////////////////////////////
+
+void TileData::set_tile_set(const TileSet *p_tile_set) {
+	tile_set = p_tile_set;
+	if (tile_set) {
+		occluders.resize(tile_set->get_occlusion_layers_count());
+		physics.resize(tile_set->get_physics_layers_count());
+		navigation.resize(tile_set->get_navigation_layers_count());
+		custom_data.resize(tile_set->get_custom_data_layers_count());
+	}
+	notify_property_list_changed();
+}
+
+void TileData::notify_tile_data_properties_should_change() {
+	occluders.resize(tile_set->get_occlusion_layers_count());
+	physics.resize(tile_set->get_physics_layers_count());
+	for (int bit_index = 0; bit_index < 16; bit_index++) {
+		if (terrain_set < 0 || terrain_peering_bits[bit_index] >= tile_set->get_terrains_count(terrain_set)) {
+			terrain_peering_bits[bit_index] = -1;
+		}
+	}
+	navigation.resize(tile_set->get_navigation_layers_count());
+
+	// Convert custom data to the new type.
+	custom_data.resize(tile_set->get_custom_data_layers_count());
+	for (int i = 0; i < custom_data.size(); i++) {
+		if (custom_data[i].get_type() != tile_set->get_custom_data_type(i)) {
+			Variant new_val;
+			Callable::CallError error;
+			if (Variant::can_convert(custom_data[i].get_type(), tile_set->get_custom_data_type(i))) {
+				const Variant *args[] = { &custom_data[i] };
+				Variant::construct(tile_set->get_custom_data_type(i), new_val, args, 1, error);
+			} else {
+				Variant::construct(tile_set->get_custom_data_type(i), new_val, nullptr, 0, error);
+			}
+			custom_data.write[i] = new_val;
+		}
 	}
+
+	notify_property_list_changed();
+	emit_signal("changed");
+}
+
+void TileData::reset_state() {
+	occluders.clear();
+	physics.clear();
+	navigation.clear();
+	custom_data.clear();
+}
+
+void TileData::set_allow_transform(bool p_allow_transform) {
+	allow_transform = p_allow_transform;
+}
+
+bool TileData::is_allowing_transform() const {
+	return allow_transform;
+}
+
+// Rendering
+void TileData::set_flip_h(bool p_flip_h) {
+	ERR_FAIL_COND_MSG(!allow_transform && p_flip_h, "Transform is only allowed for alternative tiles (with its alternative_id != 0)");
+	flip_h = p_flip_h;
+	emit_signal("changed");
+}
+bool TileData::get_flip_h() const {
+	return flip_h;
+}
+
+void TileData::set_flip_v(bool p_flip_v) {
+	ERR_FAIL_COND_MSG(!allow_transform && p_flip_v, "Transform is only allowed for alternative tiles (with its alternative_id != 0)");
+	flip_v = p_flip_v;
+	emit_signal("changed");
+}
+
+bool TileData::get_flip_v() const {
+	return flip_v;
+}
+
+void TileData::set_transpose(bool p_transpose) {
+	ERR_FAIL_COND_MSG(!allow_transform && p_transpose, "Transform is only allowed for alternative tiles (with its alternative_id != 0)");
+	transpose = p_transpose;
+	emit_signal("changed");
+}
+bool TileData::get_transpose() const {
+	return transpose;
+}
+
+void TileData::set_texture_offset(Vector2i p_texture_offset) {
+	tex_offset = p_texture_offset;
+	emit_signal("changed");
+}
+
+Vector2i TileData::get_texture_offset() const {
+	return tex_offset;
+}
+
+void TileData::tile_set_material(Ref<ShaderMaterial> p_material) {
+	material = p_material;
+	emit_signal("changed");
+}
+Ref<ShaderMaterial> TileData::tile_get_material() const {
+	return material;
+}
+
+void TileData::set_modulate(Color p_modulate) {
+	modulate = p_modulate;
+	emit_signal("changed");
+}
+Color TileData::get_modulate() const {
+	return modulate;
+}
+
+void TileData::set_z_index(int p_z_index) {
+	z_index = p_z_index;
+	emit_signal("changed");
+}
+int TileData::get_z_index() const {
+	return z_index;
+}
+
+void TileData::set_y_sort_origin(Vector2i p_y_sort_origin) {
+	y_sort_origin = p_y_sort_origin;
+	emit_signal("changed");
+}
+Vector2i TileData::get_y_sort_origin() const {
+	return y_sort_origin;
+}
+
+void TileData::set_occluder(int p_layer_id, Ref<OccluderPolygon2D> p_occluder_polygon) {
+	ERR_FAIL_INDEX(p_layer_id, occluders.size());
+	occluders.write[p_layer_id] = p_occluder_polygon;
+	emit_signal("changed");
+}
+
+Ref<OccluderPolygon2D> TileData::get_occluder(int p_layer_id) const {
+	ERR_FAIL_INDEX_V(p_layer_id, occluders.size(), Ref<OccluderPolygon2D>());
+	return occluders[p_layer_id];
 }
 
-const Map<Vector2, Ref<NavigationPolygon>> &TileSet::autotile_get_navigation_map(int p_id) const {
-	static Map<Vector2, Ref<NavigationPolygon>> dummy;
-	ERR_FAIL_COND_V(!tile_map.has(p_id), dummy);
-	return tile_map[p_id].autotile_data.navpoly_map;
+// Physics
+int TileData::get_collision_shapes_count(int p_layer_id) const {
+	ERR_FAIL_INDEX_V(p_layer_id, physics.size(), 0);
+	return physics[p_layer_id].shapes.size();
 }
 
-void TileSet::tile_set_occluder_offset(int p_id, const Vector2 &p_offset) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].occluder_offset = p_offset;
+void TileData::set_collision_shapes_count(int p_layer_id, int p_shapes_count) {
+	ERR_FAIL_INDEX(p_layer_id, physics.size());
+	ERR_FAIL_COND(p_shapes_count < 0);
+	physics.write[p_layer_id].shapes.resize(p_shapes_count);
+	notify_property_list_changed();
+	emit_signal("changed");
+}
+
+void TileData::add_collision_shape(int p_layer_id) {
+	ERR_FAIL_INDEX(p_layer_id, physics.size());
+	physics.write[p_layer_id].shapes.push_back(PhysicsLayerTileData::ShapeTileData());
+	emit_signal("changed");
+}
+
+void TileData::remove_collision_shape(int p_layer_id, int p_shape_index) {
+	ERR_FAIL_INDEX(p_layer_id, physics.size());
+	ERR_FAIL_INDEX(p_shape_index, physics[p_layer_id].shapes.size());
+	physics.write[p_layer_id].shapes.remove(p_shape_index);
+	emit_signal("changed");
+}
+
+void TileData::set_collision_shape_shape(int p_layer_id, int p_shape_index, Ref<Shape2D> p_shape) {
+	ERR_FAIL_INDEX(p_layer_id, physics.size());
+	ERR_FAIL_INDEX(p_shape_index, physics[p_layer_id].shapes.size());
+	physics.write[p_layer_id].shapes.write[p_shape_index].shape = p_shape;
+	emit_signal("changed");
 }
 
-Vector2 TileSet::tile_get_occluder_offset(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Vector2());
-	return tile_map[p_id].occluder_offset;
+Ref<Shape2D> TileData::get_collision_shape_shape(int p_layer_id, int p_shape_index) const {
+	ERR_FAIL_INDEX_V(p_layer_id, physics.size(), Ref<Shape2D>());
+	ERR_FAIL_INDEX_V(p_shape_index, physics[p_layer_id].shapes.size(), Ref<Shape2D>());
+	return physics[p_layer_id].shapes[p_shape_index].shape;
 }
 
-void TileSet::tile_set_shapes(int p_id, const Vector<ShapeData> &p_shapes) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].shapes_data = p_shapes;
-	for (int i = 0; i < p_shapes.size(); i++) {
-		_decompose_convex_shape(p_shapes[i].shape);
+void TileData::set_collision_shape_one_way(int p_layer_id, int p_shape_index, bool p_one_way) {
+	ERR_FAIL_INDEX(p_layer_id, physics.size());
+	ERR_FAIL_INDEX(p_shape_index, physics[p_layer_id].shapes.size());
+	physics.write[p_layer_id].shapes.write[p_shape_index].one_way = p_one_way;
+	emit_signal("changed");
+}
+
+bool TileData::is_collision_shape_one_way(int p_layer_id, int p_shape_index) const {
+	ERR_FAIL_INDEX_V(p_layer_id, physics.size(), false);
+	ERR_FAIL_INDEX_V(p_shape_index, physics[p_layer_id].shapes.size(), false);
+	return physics[p_layer_id].shapes[p_shape_index].one_way;
+}
+
+void TileData::set_collision_shape_one_way_margin(int p_layer_id, int p_shape_index, float p_one_way_margin) {
+	ERR_FAIL_INDEX(p_layer_id, physics.size());
+	ERR_FAIL_INDEX(p_shape_index, physics[p_layer_id].shapes.size());
+	physics.write[p_layer_id].shapes.write[p_shape_index].one_way_margin = p_one_way_margin;
+	emit_signal("changed");
+}
+
+float TileData::get_collision_shape_one_way_margin(int p_layer_id, int p_shape_index) const {
+	ERR_FAIL_INDEX_V(p_layer_id, physics.size(), 0.0);
+	ERR_FAIL_INDEX_V(p_shape_index, physics[p_layer_id].shapes.size(), 0.0);
+	return physics[p_layer_id].shapes[p_shape_index].one_way_margin;
+}
+
+// Terrain
+void TileData::set_terrain_set(int p_terrain_set) {
+	ERR_FAIL_COND(p_terrain_set < -1);
+	if (tile_set) {
+		ERR_FAIL_COND(p_terrain_set >= tile_set->get_terrain_sets_count());
 	}
-	emit_changed();
+	terrain_set = p_terrain_set;
+	notify_property_list_changed();
+	emit_signal("changed");
 }
 
-Vector<TileSet::ShapeData> TileSet::tile_get_shapes(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Vector<ShapeData>());
+int TileData::get_terrain_set() const {
+	return terrain_set;
+}
 
-	return tile_map[p_id].shapes_data;
+void TileData::set_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit, int p_terrain_index) {
+	ERR_FAIL_COND(p_terrain_index < -1);
+	if (tile_set) {
+		ERR_FAIL_COND(p_terrain_index >= tile_set->get_terrains_count(terrain_set));
+		ERR_FAIL_COND(!is_valid_peering_bit_terrain(p_peering_bit));
+	}
+	terrain_peering_bits[p_peering_bit] = p_terrain_index;
+	emit_signal("changed");
 }
 
-int TileSet::tile_get_z_index(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), 0);
-	return tile_map[p_id].z_index;
+int TileData::get_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const {
+	return terrain_peering_bits[p_peering_bit];
 }
 
-void TileSet::tile_set_z_index(int p_id, int p_z_index) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map[p_id].z_index = p_z_index;
-	emit_changed();
+bool TileData::is_valid_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const {
+	ERR_FAIL_COND_V(!tile_set, false);
+
+	return tile_set->is_valid_peering_bit_terrain(terrain_set, p_peering_bit);
 }
 
-void TileSet::_tile_set_shapes(int p_id, const Array &p_shapes) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	Vector<ShapeData> shapes_data;
-	Transform2D default_transform = tile_get_shape_transform(p_id, 0);
-	bool default_one_way = tile_get_shape_one_way(p_id, 0);
-	Vector2 default_autotile_coord = Vector2();
-	for (int i = 0; i < p_shapes.size(); i++) {
-		ShapeData s = ShapeData();
+// Navigation
+void TileData::set_navigation_polygon(int p_layer_id, Ref<NavigationPolygon> p_navigation_polygon) {
+	ERR_FAIL_INDEX(p_layer_id, navigation.size());
+	navigation.write[p_layer_id] = p_navigation_polygon;
+	emit_signal("changed");
+}
 
-		if (p_shapes[i].get_type() == Variant::OBJECT) {
-			Ref<Shape2D> shape = p_shapes[i];
-			if (shape.is_null()) {
-				continue;
+Ref<NavigationPolygon> TileData::get_navigation_polygon(int p_layer_id) const {
+	ERR_FAIL_INDEX_V(p_layer_id, navigation.size(), Ref<NavigationPolygon>());
+	return navigation[p_layer_id];
+}
+
+// Misc
+void TileData::set_probability(float p_probability) {
+	ERR_FAIL_COND(p_probability <= 0.0);
+	probability = p_probability;
+	emit_signal("changed");
+}
+float TileData::get_probability() const {
+	return probability;
+}
+
+// Custom data
+void TileData::set_custom_data(String p_layer_name, Variant p_value) {
+	ERR_FAIL_COND(!tile_set);
+	int p_layer_id = tile_set->get_custom_data_layer_by_name(p_layer_name);
+	ERR_FAIL_COND_MSG(p_layer_id < 0, vformat("TileSet has no layer with name: %s", p_layer_name));
+	set_custom_data_by_layer_id(p_layer_id, p_value);
+}
+
+Variant TileData::get_custom_data(String p_layer_name) const {
+	ERR_FAIL_COND_V(!tile_set, Variant());
+	int p_layer_id = tile_set->get_custom_data_layer_by_name(p_layer_name);
+	ERR_FAIL_COND_V_MSG(p_layer_id < 0, Variant(), vformat("TileSet has no layer with name: %s", p_layer_name));
+	return get_custom_data_by_layer_id(p_layer_id);
+}
+
+void TileData::set_custom_data_by_layer_id(int p_layer_id, Variant p_value) {
+	ERR_FAIL_INDEX(p_layer_id, custom_data.size());
+	custom_data.write[p_layer_id] = p_value;
+	emit_signal("changed");
+}
+
+Variant TileData::get_custom_data_by_layer_id(int p_layer_id) const {
+	ERR_FAIL_INDEX_V(p_layer_id, custom_data.size(), Variant());
+	return custom_data[p_layer_id];
+}
+
+bool TileData::_set(const StringName &p_name, const Variant &p_value) {
+	Vector<String> components = String(p_name).split("/", true, 2);
+
+	if (components.size() == 2 && components[0].begins_with("occlusion_layer_") && components[0].trim_prefix("occlusion_layer_").is_valid_integer()) {
+		// Occlusion layers.
+		int layer_index = components[0].trim_prefix("occlusion_layer_").to_int();
+		ERR_FAIL_COND_V(layer_index < 0, false);
+		if (components[1] == "polygon") {
+			Ref<OccluderPolygon2D> polygon = p_value;
+			if (!polygon.is_valid()) {
+				return false;
 			}
 
-			s.shape = shape;
-			s.shape_transform = default_transform;
-			s.one_way_collision = default_one_way;
-			s.autotile_coord = default_autotile_coord;
-		} else if (p_shapes[i].get_type() == Variant::DICTIONARY) {
-			Dictionary d = p_shapes[i];
+			if (layer_index >= occluders.size()) {
+				if (tile_set) {
+					return false;
+				} else {
+					occluders.resize(layer_index + 1);
+				}
+			}
+			set_occluder(layer_index, polygon);
+			return true;
+		}
+	} else if (components.size() >= 2 && components[0].begins_with("physics_layer_") && components[0].trim_prefix("physics_layer_").is_valid_integer()) {
+		// Physics layers.
+		int layer_index = components[0].trim_prefix("physics_layer_").to_int();
+		ERR_FAIL_COND_V(layer_index < 0, false);
+		if (components.size() == 2 && components[1] == "shapes_count") {
+			if (p_value.get_type() != Variant::INT) {
+				return false;
+			}
 
-			if (d.has("shape") && d["shape"].get_type() == Variant::OBJECT) {
-				s.shape = d["shape"];
-				_decompose_convex_shape(s.shape);
-			} else {
-				continue;
+			if (layer_index >= physics.size()) {
+				if (tile_set) {
+					return false;
+				} else {
+					physics.resize(layer_index + 1);
+				}
 			}
+			set_collision_shapes_count(layer_index, p_value);
+			return true;
+		} else if (components.size() == 3 && components[1].begins_with("shape_") && components[1].trim_prefix("shape_").is_valid_integer()) {
+			int shape_index = components[1].trim_prefix("shape_").to_int();
+			ERR_FAIL_COND_V(shape_index < 0, false);
+
+			if (components[2] == "shape" || components[2] == "one_way" || components[2] == "one_way_margin") {
+				if (layer_index >= physics.size()) {
+					if (tile_set) {
+						return false;
+					} else {
+						physics.resize(layer_index + 1);
+					}
+				}
 
-			if (d.has("shape_transform") && d["shape_transform"].get_type() == Variant::TRANSFORM2D) {
-				s.shape_transform = d["shape_transform"];
-			} else if (d.has("shape_offset") && d["shape_offset"].get_type() == Variant::VECTOR2) {
-				s.shape_transform = Transform2D(0, (Vector2)d["shape_offset"]);
-			} else {
-				s.shape_transform = default_transform;
+				if (shape_index >= physics[layer_index].shapes.size()) {
+					physics.write[layer_index].shapes.resize(shape_index + 1);
+				}
+			}
+			if (components[2] == "shape") {
+				Ref<Shape2D> shape = p_value;
+				set_collision_shape_shape(layer_index, shape_index, shape);
+				return true;
+			} else if (components[2] == "one_way") {
+				set_collision_shape_one_way(layer_index, shape_index, p_value);
+				return true;
+			} else if (components[2] == "one_way_margin") {
+				set_collision_shape_one_way_margin(layer_index, shape_index, p_value);
+				return true;
+			}
+		}
+	} else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_integer()) {
+		// Navigation layers.
+		int layer_index = components[0].trim_prefix("navigation_layer_").to_int();
+		ERR_FAIL_COND_V(layer_index < 0, false);
+		if (components[1] == "polygon") {
+			Ref<NavigationPolygon> polygon = p_value;
+			if (!polygon.is_valid()) {
+				return false;
 			}
 
-			if (d.has("one_way") && d["one_way"].get_type() == Variant::BOOL) {
-				s.one_way_collision = d["one_way"];
+			if (layer_index >= navigation.size()) {
+				if (tile_set) {
+					return false;
+				} else {
+					navigation.resize(layer_index + 1);
+				}
+			}
+			set_navigation_polygon(layer_index, polygon);
+			return true;
+		}
+	} else if (components.size() == 2 && components[0] == "terrains_peering_bit") {
+		// Terrains.
+		if (components[1] == "right_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_RIGHT_SIDE, p_value);
+		} else if (components[1] == "right_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_RIGHT_CORNER, p_value);
+		} else if (components[1] == "bottom_right_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE, p_value);
+		} else if (components[1] == "bottom_right_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER, p_value);
+		} else if (components[1] == "bottom_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_SIDE, p_value);
+		} else if (components[1] == "bottom_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_CORNER, p_value);
+		} else if (components[1] == "bottom_left_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE, p_value);
+		} else if (components[1] == "bottom_left_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER, p_value);
+		} else if (components[1] == "left_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_LEFT_SIDE, p_value);
+		} else if (components[1] == "left_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_LEFT_CORNER, p_value);
+		} else if (components[1] == "top_left_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE, p_value);
+		} else if (components[1] == "top_left_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER, p_value);
+		} else if (components[1] == "top_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_SIDE, p_value);
+		} else if (components[1] == "top_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_CORNER, p_value);
+		} else if (components[1] == "top_right_side") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE, p_value);
+		} else if (components[1] == "top_right_corner") {
+			set_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER, p_value);
+		} else {
+			return false;
+		}
+		return true;
+	} else if (components.size() == 1 && components[0].begins_with("custom_data_") && components[0].trim_prefix("custom_data_").is_valid_integer()) {
+		// Custom data layers.
+		int layer_index = components[0].trim_prefix("custom_data_").to_int();
+		ERR_FAIL_COND_V(layer_index < 0, false);
+
+		if (layer_index >= custom_data.size()) {
+			if (tile_set) {
+				return false;
 			} else {
-				s.one_way_collision = default_one_way;
+				custom_data.resize(layer_index + 1);
 			}
+		}
+		set_custom_data_by_layer_id(layer_index, p_value);
+
+		return true;
+	}
+
+	return false;
+}
 
-			if (d.has("one_way_margin") && d["one_way_margin"].is_num()) {
-				s.one_way_collision_margin = d["one_way_margin"];
+bool TileData::_get(const StringName &p_name, Variant &r_ret) const {
+	Vector<String> components = String(p_name).split("/", true, 2);
+
+	if (tile_set) {
+		if (components.size() == 2 && components[0].begins_with("occlusion_layer") && components[0].trim_prefix("occlusion_layer_").is_valid_integer()) {
+			// Occlusion layers.
+			int layer_index = components[0].trim_prefix("occlusion_layer_").to_int();
+			ERR_FAIL_COND_V(layer_index < 0, false);
+			if (layer_index >= occluders.size()) {
+				return false;
+			}
+			if (components[1] == "polygon") {
+				r_ret = get_occluder(layer_index);
+				return true;
+			}
+		} else if (components.size() >= 2 && components[0].begins_with("physics_layer_") && components[0].trim_prefix("physics_layer_").is_valid_integer()) {
+			// Physics layers.
+			int layer_index = components[0].trim_prefix("physics_layer_").to_int();
+			ERR_FAIL_COND_V(layer_index < 0, false);
+			if (layer_index >= physics.size()) {
+				return false;
+			}
+			if (components.size() == 2 && components[1] == "shapes_count") {
+				r_ret = get_collision_shapes_count(layer_index);
+				return true;
+			} else if (components.size() == 3 && components[1].begins_with("shape_") && components[1].trim_prefix("shape_").is_valid_integer()) {
+				int shape_index = components[1].trim_prefix("shape_").to_int();
+				ERR_FAIL_COND_V(shape_index < 0, false);
+				if (shape_index >= physics[layer_index].shapes.size()) {
+					return false;
+				}
+				if (components[2] == "shape") {
+					r_ret = get_collision_shape_shape(layer_index, shape_index);
+					return true;
+				} else if (components[2] == "one_way") {
+					r_ret = is_collision_shape_one_way(layer_index, shape_index);
+					return true;
+				} else if (components[2] == "one_way_margin") {
+					r_ret = get_collision_shape_one_way_margin(layer_index, shape_index);
+					return true;
+				}
+			}
+		} else if (components.size() == 2 && components[0] == "terrains_peering_bit") {
+			// Terrains.
+			if (components[1] == "right_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_RIGHT_SIDE];
+			} else if (components[1] == "right_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_RIGHT_CORNER];
+			} else if (components[1] == "bottom_right_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE];
+			} else if (components[1] == "bottom_right_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER];
+			} else if (components[1] == "bottom_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_BOTTOM_SIDE];
+			} else if (components[1] == "bottom_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_BOTTOM_CORNER];
+			} else if (components[1] == "bottom_left_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE];
+			} else if (components[1] == "bottom_left_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER];
+			} else if (components[1] == "left_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_LEFT_SIDE];
+			} else if (components[1] == "left_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_LEFT_CORNER];
+			} else if (components[1] == "top_left_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE];
+			} else if (components[1] == "top_left_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER];
+			} else if (components[1] == "top_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_TOP_SIDE];
+			} else if (components[1] == "top_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_TOP_CORNER];
+			} else if (components[1] == "top_right_side") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE];
+			} else if (components[1] == "top_right_corner") {
+				r_ret = terrain_peering_bits[TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER];
 			} else {
-				s.one_way_collision_margin = 1.0;
+				return false;
+			}
+			return true;
+		} else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_integer()) {
+			// Occlusion layers.
+			int layer_index = components[0].trim_prefix("navigation_layer_").to_int();
+			ERR_FAIL_COND_V(layer_index < 0, false);
+			if (layer_index >= navigation.size()) {
+				return false;
+			}
+			if (components[1] == "polygon") {
+				r_ret = get_navigation_polygon(layer_index);
+				return true;
+			}
+		} else if (components.size() == 1 && components[0].begins_with("custom_data_") && components[0].trim_prefix("custom_data_").is_valid_integer()) {
+			// Custom data layers.
+			int layer_index = components[0].trim_prefix("custom_data_").to_int();
+			ERR_FAIL_COND_V(layer_index < 0, false);
+			if (layer_index >= custom_data.size()) {
+				return false;
 			}
+			r_ret = get_custom_data_by_layer_id(layer_index);
+			return true;
+		}
+	}
 
-			if (d.has("autotile_coord") && d["autotile_coord"].get_type() == Variant::VECTOR2) {
-				s.autotile_coord = d["autotile_coord"];
-			} else {
-				s.autotile_coord = default_autotile_coord;
+	return false;
+}
+
+void TileData::_get_property_list(List<PropertyInfo> *p_list) const {
+	PropertyInfo property_info;
+	// Add the groups manually.
+	if (tile_set) {
+		// Occlusion layers.
+		p_list->push_back(PropertyInfo(Variant::NIL, "Rendering", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+		for (int i = 0; i < occluders.size(); i++) {
+			// occlusion_layer_%d/polygon
+			property_info = PropertyInfo(Variant::OBJECT, vformat("occlusion_layer_%d/polygon", i), PROPERTY_HINT_RESOURCE_TYPE, "OccluderPolygon2D", PROPERTY_USAGE_DEFAULT);
+			if (!occluders[i].is_valid()) {
+				property_info.usage ^= PROPERTY_USAGE_STORAGE;
 			}
+			p_list->push_back(property_info);
+		}
 
-		} else {
-			ERR_CONTINUE_MSG(true, "Expected an array of objects or dictionaries for tile_set_shapes.");
+		// Physics layers.
+		p_list->push_back(PropertyInfo(Variant::NIL, "Physics", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+		for (int i = 0; i < physics.size(); i++) {
+			p_list->push_back(PropertyInfo(Variant::INT, vformat("physics_layer_%d/shapes_count", i), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
+
+			for (int j = 0; j < physics[i].shapes.size(); j++) {
+				// physics_layer_%d/shapes_count
+				property_info = PropertyInfo(Variant::OBJECT, vformat("physics_layer_%d/shape_%d/shape", i, j), PROPERTY_HINT_RESOURCE_TYPE, "Shape2D", PROPERTY_USAGE_DEFAULT);
+				if (!physics[i].shapes[j].shape.is_valid()) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+
+				// physics_layer_%d/shape_%d/one_way
+				property_info = PropertyInfo(Variant::BOOL, vformat("physics_layer_%d/shape_%d/one_way", i, j));
+				if (physics[i].shapes[j].one_way == false) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+
+				// physics_layer_%d/shape_%d/one_way_margin
+				property_info = PropertyInfo(Variant::FLOAT, vformat("physics_layer_%d/shape_%d/one_way_margin", i, j));
+				if (physics[i].shapes[j].one_way_margin == 1.0) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+		}
+
+		// Terrain data
+		if (terrain_set >= 0) {
+			p_list->push_back(PropertyInfo(Variant::NIL, "Terrains", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_RIGHT_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/right_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_RIGHT_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_RIGHT_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/right_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_RIGHT_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/bottom_right_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/bottom_right_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/bottom_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/bottom_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/bottom_left_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/bottom_left_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_LEFT_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/left_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_LEFT_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_LEFT_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/left_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_LEFT_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/top_left_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/top_left_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/top_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/top_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/top_right_side");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
+			if (is_valid_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER)) {
+				property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/top_right_corner");
+				if (get_peering_bit_terrain(TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER) == -1) {
+					property_info.usage ^= PROPERTY_USAGE_STORAGE;
+				}
+				p_list->push_back(property_info);
+			}
 		}
 
-		shapes_data.push_back(s);
+		// Navigation layers.
+		p_list->push_back(PropertyInfo(Variant::NIL, "Navigation", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+		for (int i = 0; i < navigation.size(); i++) {
+			property_info = PropertyInfo(Variant::OBJECT, vformat("navigation_layer_%d/polygon", i), PROPERTY_HINT_RESOURCE_TYPE, "NavigationPolygon", PROPERTY_USAGE_DEFAULT);
+			if (!navigation[i].is_valid()) {
+				property_info.usage ^= PROPERTY_USAGE_STORAGE;
+			}
+			p_list->push_back(property_info);
+		}
+
+		// Custom data layers.
+		p_list->push_back(PropertyInfo(Variant::NIL, "Custom data", PROPERTY_HINT_NONE, "custom_data_", PROPERTY_USAGE_GROUP));
+		for (int i = 0; i < custom_data.size(); i++) {
+			Variant default_val;
+			Callable::CallError error;
+			Variant::construct(custom_data[i].get_type(), default_val, nullptr, 0, error);
+			property_info = PropertyInfo(tile_set->get_custom_data_type(i), vformat("custom_data_%d", i), PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT);
+			if (custom_data[i] == default_val) {
+				property_info.usage ^= PROPERTY_USAGE_STORAGE;
+			}
+			p_list->push_back(property_info);
+		}
 	}
+}
 
-	tile_map[p_id].shapes_data = shapes_data;
-	emit_changed();
+void TileData::_bind_methods() {
+	// Rendering.
+	ClassDB::bind_method(D_METHOD("set_flip_h", "flip_h"), &TileData::set_flip_h);
+	ClassDB::bind_method(D_METHOD("get_flip_h"), &TileData::get_flip_h);
+	ClassDB::bind_method(D_METHOD("set_flip_v", "flip_v"), &TileData::set_flip_v);
+	ClassDB::bind_method(D_METHOD("get_flip_v"), &TileData::get_flip_v);
+	ClassDB::bind_method(D_METHOD("set_transpose", "transpose"), &TileData::set_transpose);
+	ClassDB::bind_method(D_METHOD("get_transpose"), &TileData::get_transpose);
+	ClassDB::bind_method(D_METHOD("tile_set_material", "material"), &TileData::tile_set_material);
+	ClassDB::bind_method(D_METHOD("tile_get_material"), &TileData::tile_get_material);
+	ClassDB::bind_method(D_METHOD("set_texture_offset", "texture_offset"), &TileData::set_texture_offset);
+	ClassDB::bind_method(D_METHOD("get_texture_offset"), &TileData::get_texture_offset);
+	ClassDB::bind_method(D_METHOD("set_modulate", "modulate"), &TileData::set_modulate);
+	ClassDB::bind_method(D_METHOD("get_modulate"), &TileData::get_modulate);
+	ClassDB::bind_method(D_METHOD("set_z_index", "z_index"), &TileData::set_z_index);
+	ClassDB::bind_method(D_METHOD("get_z_index"), &TileData::get_z_index);
+	ClassDB::bind_method(D_METHOD("set_y_sort_origin", "y_sort_origin"), &TileData::set_y_sort_origin);
+	ClassDB::bind_method(D_METHOD("get_y_sort_origin"), &TileData::get_y_sort_origin);
+
+	ClassDB::bind_method(D_METHOD("set_occluder", "layer_id", "occluder_polygon"), &TileData::set_occluder);
+	ClassDB::bind_method(D_METHOD("get_occluder", "layer_id"), &TileData::get_occluder);
+
+	// Physics.
+	ClassDB::bind_method(D_METHOD("get_collision_shapes_count", "layer_id"), &TileData::get_collision_shapes_count);
+	ClassDB::bind_method(D_METHOD("set_collision_shapes_count", "layer_id", "shapes_count"), &TileData::set_collision_shapes_count);
+	ClassDB::bind_method(D_METHOD("add_collision_shape", "layer_id"), &TileData::add_collision_shape);
+	ClassDB::bind_method(D_METHOD("remove_collision_shape", "layer_id", "shape_index"), &TileData::remove_collision_shape);
+	ClassDB::bind_method(D_METHOD("set_collision_shape_shape", "layer_id", "shape_index", "shape"), &TileData::set_collision_shape_shape);
+	ClassDB::bind_method(D_METHOD("get_collision_shape_shape", "layer_id", "shape_index"), &TileData::get_collision_shape_shape);
+	ClassDB::bind_method(D_METHOD("set_collision_shape_one_way", "layer_id", "shape_index", "one_way"), &TileData::set_collision_shape_one_way);
+	ClassDB::bind_method(D_METHOD("is_collision_shape_one_way", "layer_id", "shape_index"), &TileData::is_collision_shape_one_way);
+	ClassDB::bind_method(D_METHOD("set_collision_shape_one_way_margin", "layer_id", "shape_index", "one_way_margin"), &TileData::set_collision_shape_one_way_margin);
+	ClassDB::bind_method(D_METHOD("get_collision_shape_one_way_margin", "layer_id", "shape_index"), &TileData::get_collision_shape_one_way_margin);
+
+	// Terrain
+	ClassDB::bind_method(D_METHOD("set_terrain_set", "terrain_set"), &TileData::set_terrain_set);
+	ClassDB::bind_method(D_METHOD("get_terrain_set"), &TileData::get_terrain_set);
+	ClassDB::bind_method(D_METHOD("set_peering_bit_terrain", "peering_bit", "terrain"), &TileData::set_peering_bit_terrain);
+	ClassDB::bind_method(D_METHOD("get_peering_bit_terrain", "peering_bit"), &TileData::get_peering_bit_terrain);
+
+	// Navigation
+	ClassDB::bind_method(D_METHOD("set_navigation_polygon", "layer_id", "navigation_polygon"), &TileData::set_navigation_polygon);
+	ClassDB::bind_method(D_METHOD("get_navigation_polygon", "layer_id"), &TileData::get_navigation_polygon);
+
+	// Misc.
+	ClassDB::bind_method(D_METHOD("set_probability", "probability"), &TileData::set_probability);
+	ClassDB::bind_method(D_METHOD("get_probability"), &TileData::get_probability);
+
+	// Custom data.
+	ClassDB::bind_method(D_METHOD("set_custom_data", "layer_name", "value"), &TileData::set_custom_data);
+	ClassDB::bind_method(D_METHOD("get_custom_data", "layer_name"), &TileData::get_custom_data);
+	ClassDB::bind_method(D_METHOD("set_custom_data_by_layer_id", "layer_id", "value"), &TileData::set_custom_data_by_layer_id);
+	ClassDB::bind_method(D_METHOD("get_custom_data_by_layer_id", "layer_id"), &TileData::get_custom_data_by_layer_id);
+
+	ADD_GROUP("Rendering", "");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "flip_h"), "set_flip_h", "get_flip_h");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "flip_v"), "set_flip_v", "get_flip_v");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "transpose"), "set_transpose", "get_transpose");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "texture_offset"), "set_texture_offset", "get_texture_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "modulate"), "set_modulate", "get_modulate");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "z_index"), "set_z_index", "get_z_index");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2I, "y_sort_origin"), "set_y_sort_origin", "get_y_sort_origin");
+
+	ADD_GROUP("Terrains", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "terrain_set"), "set_terrain_set", "get_terrain_set");
+
+	ADD_GROUP("Miscellaneous", "");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "probability"), "set_probability", "get_probability");
+
+	ADD_SIGNAL(MethodInfo("changed"));
 }
 
-Array TileSet::_tile_get_shapes(int p_id) const {
-	ERR_FAIL_COND_V(!tile_map.has(p_id), Array());
-	Array arr;
+/////////////////////////////// TileSetAtlasPluginTerrain //////////////////////////////////////
+
+// --- PLUGINS ---
+void TileSetAtlasPluginTerrain::_draw_square_corner_or_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit) {
+	Rect2 bit_rect;
+	bit_rect.size = Vector2(p_size) / 3;
+	switch (p_bit) {
+		case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
+			bit_rect.position = Vector2(1, -1);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
+			bit_rect.position = Vector2(1, 1);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_SIDE:
+			bit_rect.position = Vector2(-1, 1);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
+			bit_rect.position = Vector2(-3, 1);
+			break;
+		case TileSet::CELL_NEIGHBOR_LEFT_SIDE:
+			bit_rect.position = Vector2(-3, -1);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
+			bit_rect.position = Vector2(-3, -3);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_SIDE:
+			bit_rect.position = Vector2(-1, -3);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
+			bit_rect.position = Vector2(1, -3);
+			break;
+		default:
+			break;
+	}
+	bit_rect.position *= Vector2(p_size) / 6.0;
+	p_canvas_item->draw_rect(bit_rect, p_color);
+}
 
-	Vector<ShapeData> data = tile_map[p_id].shapes_data;
-	for (int i = 0; i < data.size(); i++) {
-		Dictionary shape_data;
-		shape_data["shape"] = data[i].shape;
-		shape_data["shape_transform"] = data[i].shape_transform;
-		shape_data["one_way"] = data[i].one_way_collision;
-		shape_data["one_way_margin"] = data[i].one_way_collision_margin;
-		shape_data["autotile_coord"] = data[i].autotile_coord;
-		arr.push_back(shape_data);
+void TileSetAtlasPluginTerrain::_draw_square_corner_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	PackedVector2Array polygon;
+	switch (p_bit) {
+		case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
+			polygon.push_back(Vector2(0, 3) * unit);
+			polygon.push_back(Vector2(3, 3) * unit);
+			polygon.push_back(Vector2(3, 0) * unit);
+			polygon.push_back(Vector2(1, 0) * unit);
+			polygon.push_back(Vector2(1, 1) * unit);
+			polygon.push_back(Vector2(0, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
+			polygon.push_back(Vector2(0, 3) * unit);
+			polygon.push_back(Vector2(-3, 3) * unit);
+			polygon.push_back(Vector2(-3, 0) * unit);
+			polygon.push_back(Vector2(-1, 0) * unit);
+			polygon.push_back(Vector2(-1, 1) * unit);
+			polygon.push_back(Vector2(0, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
+			polygon.push_back(Vector2(0, -3) * unit);
+			polygon.push_back(Vector2(-3, -3) * unit);
+			polygon.push_back(Vector2(-3, 0) * unit);
+			polygon.push_back(Vector2(-1, 0) * unit);
+			polygon.push_back(Vector2(-1, -1) * unit);
+			polygon.push_back(Vector2(0, -1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
+			polygon.push_back(Vector2(0, -3) * unit);
+			polygon.push_back(Vector2(3, -3) * unit);
+			polygon.push_back(Vector2(3, 0) * unit);
+			polygon.push_back(Vector2(1, 0) * unit);
+			polygon.push_back(Vector2(1, -1) * unit);
+			polygon.push_back(Vector2(0, -1) * unit);
+			break;
+		default:
+			break;
+	}
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
 	}
+}
 
-	return arr;
+void TileSetAtlasPluginTerrain::_draw_square_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	PackedVector2Array polygon;
+	switch (p_bit) {
+		case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
+			polygon.push_back(Vector2(1, -1) * unit);
+			polygon.push_back(Vector2(3, -3) * unit);
+			polygon.push_back(Vector2(3, 3) * unit);
+			polygon.push_back(Vector2(1, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_SIDE:
+			polygon.push_back(Vector2(-1, 1) * unit);
+			polygon.push_back(Vector2(-3, 3) * unit);
+			polygon.push_back(Vector2(3, 3) * unit);
+			polygon.push_back(Vector2(1, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_LEFT_SIDE:
+			polygon.push_back(Vector2(-1, -1) * unit);
+			polygon.push_back(Vector2(-3, -3) * unit);
+			polygon.push_back(Vector2(-3, 3) * unit);
+			polygon.push_back(Vector2(-1, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_SIDE:
+			polygon.push_back(Vector2(-1, -1) * unit);
+			polygon.push_back(Vector2(-3, -3) * unit);
+			polygon.push_back(Vector2(3, -3) * unit);
+			polygon.push_back(Vector2(1, -1) * unit);
+			break;
+		default:
+			break;
+	}
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
+	}
 }
 
-Array TileSet::_get_tiles_ids() const {
-	Array arr;
+void TileSetAtlasPluginTerrain::_draw_isometric_corner_or_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	PackedVector2Array polygon;
+	switch (p_bit) {
+		case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
+			polygon.push_back(Vector2(1, 0) * unit);
+			polygon.push_back(Vector2(2, -1) * unit);
+			polygon.push_back(Vector2(3, 0) * unit);
+			polygon.push_back(Vector2(2, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
+			polygon.push_back(Vector2(0, 1) * unit);
+			polygon.push_back(Vector2(1, 2) * unit);
+			polygon.push_back(Vector2(2, 1) * unit);
+			polygon.push_back(Vector2(1, 0) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_CORNER:
+			polygon.push_back(Vector2(0, 1) * unit);
+			polygon.push_back(Vector2(-1, 2) * unit);
+			polygon.push_back(Vector2(0, 3) * unit);
+			polygon.push_back(Vector2(1, 2) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
+			polygon.push_back(Vector2(0, 1) * unit);
+			polygon.push_back(Vector2(-1, 2) * unit);
+			polygon.push_back(Vector2(-2, 1) * unit);
+			polygon.push_back(Vector2(-1, 0) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_LEFT_CORNER:
+			polygon.push_back(Vector2(-1, 0) * unit);
+			polygon.push_back(Vector2(-2, -1) * unit);
+			polygon.push_back(Vector2(-3, 0) * unit);
+			polygon.push_back(Vector2(-2, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
+			polygon.push_back(Vector2(0, -1) * unit);
+			polygon.push_back(Vector2(-1, -2) * unit);
+			polygon.push_back(Vector2(-2, -1) * unit);
+			polygon.push_back(Vector2(-1, 0) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_CORNER:
+			polygon.push_back(Vector2(0, -1) * unit);
+			polygon.push_back(Vector2(-1, -2) * unit);
+			polygon.push_back(Vector2(0, -3) * unit);
+			polygon.push_back(Vector2(1, -2) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
+			polygon.push_back(Vector2(0, -1) * unit);
+			polygon.push_back(Vector2(1, -2) * unit);
+			polygon.push_back(Vector2(2, -1) * unit);
+			polygon.push_back(Vector2(1, 0) * unit);
+			break;
+		default:
+			break;
+	}
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
+	}
+}
 
-	for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
-		arr.push_back(E->key());
+void TileSetAtlasPluginTerrain::_draw_isometric_corner_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	PackedVector2Array polygon;
+	switch (p_bit) {
+		case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
+			polygon.push_back(Vector2(0.5, -0.5) * unit);
+			polygon.push_back(Vector2(1.5, -1.5) * unit);
+			polygon.push_back(Vector2(3, 0) * unit);
+			polygon.push_back(Vector2(1.5, 1.5) * unit);
+			polygon.push_back(Vector2(0.5, 0.5) * unit);
+			polygon.push_back(Vector2(1, 0) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_CORNER:
+			polygon.push_back(Vector2(-0.5, 0.5) * unit);
+			polygon.push_back(Vector2(-1.5, 1.5) * unit);
+			polygon.push_back(Vector2(0, 3) * unit);
+			polygon.push_back(Vector2(1.5, 1.5) * unit);
+			polygon.push_back(Vector2(0.5, 0.5) * unit);
+			polygon.push_back(Vector2(0, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_LEFT_CORNER:
+			polygon.push_back(Vector2(-0.5, -0.5) * unit);
+			polygon.push_back(Vector2(-1.5, -1.5) * unit);
+			polygon.push_back(Vector2(-3, 0) * unit);
+			polygon.push_back(Vector2(-1.5, 1.5) * unit);
+			polygon.push_back(Vector2(-0.5, 0.5) * unit);
+			polygon.push_back(Vector2(-1, 0) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_CORNER:
+			polygon.push_back(Vector2(-0.5, -0.5) * unit);
+			polygon.push_back(Vector2(-1.5, -1.5) * unit);
+			polygon.push_back(Vector2(0, -3) * unit);
+			polygon.push_back(Vector2(1.5, -1.5) * unit);
+			polygon.push_back(Vector2(0.5, -0.5) * unit);
+			polygon.push_back(Vector2(0, -1) * unit);
+			break;
+		default:
+			break;
 	}
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
+	}
+}
 
-	return arr;
+void TileSetAtlasPluginTerrain::_draw_isometric_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	PackedVector2Array polygon;
+	switch (p_bit) {
+		case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
+			polygon.push_back(Vector2(1, 0) * unit);
+			polygon.push_back(Vector2(3, 0) * unit);
+			polygon.push_back(Vector2(0, 3) * unit);
+			polygon.push_back(Vector2(0, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
+			polygon.push_back(Vector2(-1, 0) * unit);
+			polygon.push_back(Vector2(-3, 0) * unit);
+			polygon.push_back(Vector2(0, 3) * unit);
+			polygon.push_back(Vector2(0, 1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
+			polygon.push_back(Vector2(-1, 0) * unit);
+			polygon.push_back(Vector2(-3, 0) * unit);
+			polygon.push_back(Vector2(0, -3) * unit);
+			polygon.push_back(Vector2(0, -1) * unit);
+			break;
+		case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
+			polygon.push_back(Vector2(1, 0) * unit);
+			polygon.push_back(Vector2(3, 0) * unit);
+			polygon.push_back(Vector2(0, -3) * unit);
+			polygon.push_back(Vector2(0, -1) * unit);
+			break;
+		default:
+			break;
+	}
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
+	}
 }
 
-void TileSet::_decompose_convex_shape(Ref<Shape2D> p_shape) {
-	if (Engine::get_singleton()->is_editor_hint()) {
-		return;
+void TileSetAtlasPluginTerrain::_draw_half_offset_corner_or_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	PackedVector2Array point_list;
+	point_list.push_back(Vector2(3, (3.0 * (1.0 - p_overlap * 2.0)) / 2.0));
+	point_list.push_back(Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(2, 3.0 * (1.0 - (p_overlap * 2.0) * 2.0 / 3.0)));
+	point_list.push_back(Vector2(1, 3.0 - p_overlap * 2.0));
+	point_list.push_back(Vector2(0, 3));
+	point_list.push_back(Vector2(-1, 3.0 - p_overlap * 2.0));
+	point_list.push_back(Vector2(-2, 3.0 * (1.0 - (p_overlap * 2.0) * 2.0 / 3.0)));
+	point_list.push_back(Vector2(-3, 3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(-3, (3.0 * (1.0 - p_overlap * 2.0)) / 2.0));
+	point_list.push_back(Vector2(-3, -(3.0 * (1.0 - p_overlap * 2.0)) / 2.0));
+	point_list.push_back(Vector2(-3, -3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(-2, -3.0 * (1.0 - (p_overlap * 2.0) * 2.0 / 3.0)));
+	point_list.push_back(Vector2(-1, -(3.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(0, -3));
+	point_list.push_back(Vector2(1, -(3.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(2, -3.0 * (1.0 - (p_overlap * 2.0) * 2.0 / 3.0)));
+	point_list.push_back(Vector2(3, -3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(3, -(3.0 * (1.0 - p_overlap * 2.0)) / 2.0));
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	for (int i = 0; i < point_list.size(); i++) {
+		point_list.write[i] = point_list[i] * unit;
+	}
+
+	PackedVector2Array polygon;
+	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		switch (p_bit) {
+			case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
+				polygon.push_back(point_list[17]);
+				polygon.push_back(point_list[0]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
+				polygon.push_back(point_list[0]);
+				polygon.push_back(point_list[1]);
+				polygon.push_back(point_list[2]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
+				polygon.push_back(point_list[2]);
+				polygon.push_back(point_list[3]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_CORNER:
+				polygon.push_back(point_list[3]);
+				polygon.push_back(point_list[4]);
+				polygon.push_back(point_list[5]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
+				polygon.push_back(point_list[5]);
+				polygon.push_back(point_list[6]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
+				polygon.push_back(point_list[6]);
+				polygon.push_back(point_list[7]);
+				polygon.push_back(point_list[8]);
+				break;
+			case TileSet::CELL_NEIGHBOR_LEFT_SIDE:
+				polygon.push_back(point_list[8]);
+				polygon.push_back(point_list[9]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
+				polygon.push_back(point_list[9]);
+				polygon.push_back(point_list[10]);
+				polygon.push_back(point_list[11]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
+				polygon.push_back(point_list[11]);
+				polygon.push_back(point_list[12]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_CORNER:
+				polygon.push_back(point_list[12]);
+				polygon.push_back(point_list[13]);
+				polygon.push_back(point_list[14]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
+				polygon.push_back(point_list[14]);
+				polygon.push_back(point_list[15]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
+				polygon.push_back(point_list[15]);
+				polygon.push_back(point_list[16]);
+				polygon.push_back(point_list[17]);
+				break;
+			default:
+				break;
+		}
+	} else {
+		if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
+			for (int i = 0; i < point_list.size(); i++) {
+				point_list.write[i] = Vector2(point_list[i].y, point_list[i].x);
+			}
+		}
+		switch (p_bit) {
+			case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
+				polygon.push_back(point_list[3]);
+				polygon.push_back(point_list[4]);
+				polygon.push_back(point_list[5]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
+				polygon.push_back(point_list[2]);
+				polygon.push_back(point_list[3]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
+				polygon.push_back(point_list[0]);
+				polygon.push_back(point_list[1]);
+				polygon.push_back(point_list[2]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_SIDE:
+				polygon.push_back(point_list[17]);
+				polygon.push_back(point_list[0]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
+				polygon.push_back(point_list[15]);
+				polygon.push_back(point_list[16]);
+				polygon.push_back(point_list[17]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
+				polygon.push_back(point_list[14]);
+				polygon.push_back(point_list[15]);
+				break;
+			case TileSet::CELL_NEIGHBOR_LEFT_CORNER:
+				polygon.push_back(point_list[12]);
+				polygon.push_back(point_list[13]);
+				polygon.push_back(point_list[14]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
+				polygon.push_back(point_list[11]);
+				polygon.push_back(point_list[12]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
+				polygon.push_back(point_list[9]);
+				polygon.push_back(point_list[10]);
+				polygon.push_back(point_list[11]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_SIDE:
+				polygon.push_back(point_list[8]);
+				polygon.push_back(point_list[9]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
+				polygon.push_back(point_list[6]);
+				polygon.push_back(point_list[7]);
+				polygon.push_back(point_list[8]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
+				polygon.push_back(point_list[5]);
+				polygon.push_back(point_list[6]);
+				break;
+			default:
+				break;
+		}
+	}
+
+	int half_polygon_size = polygon.size();
+	for (int i = 0; i < half_polygon_size; i++) {
+		polygon.push_back(polygon[half_polygon_size - 1 - i] / 3.0);
+	}
+
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
+	}
+}
+
+void TileSetAtlasPluginTerrain::_draw_half_offset_corner_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	PackedVector2Array point_list;
+	point_list.push_back(Vector2(3, 0));
+	point_list.push_back(Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(1.5, (3.0 * (1.0 - p_overlap * 2.0) + 3.0) / 2.0));
+	point_list.push_back(Vector2(0, 3));
+	point_list.push_back(Vector2(-1.5, (3.0 * (1.0 - p_overlap * 2.0) + 3.0) / 2.0));
+	point_list.push_back(Vector2(-3, 3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(-3, 0));
+	point_list.push_back(Vector2(-3, -3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(-1.5, -(3.0 * (1.0 - p_overlap * 2.0) + 3.0) / 2.0));
+	point_list.push_back(Vector2(0, -3));
+	point_list.push_back(Vector2(1.5, -(3.0 * (1.0 - p_overlap * 2.0) + 3.0) / 2.0));
+	point_list.push_back(Vector2(3, -3.0 * (1.0 - p_overlap * 2.0)));
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	for (int i = 0; i < point_list.size(); i++) {
+		point_list.write[i] = point_list[i] * unit;
+	}
+
+	PackedVector2Array polygon;
+	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		switch (p_bit) {
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
+				polygon.push_back(point_list[0]);
+				polygon.push_back(point_list[1]);
+				polygon.push_back(point_list[2]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_CORNER:
+				polygon.push_back(point_list[2]);
+				polygon.push_back(point_list[3]);
+				polygon.push_back(point_list[4]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
+				polygon.push_back(point_list[4]);
+				polygon.push_back(point_list[5]);
+				polygon.push_back(point_list[6]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
+				polygon.push_back(point_list[6]);
+				polygon.push_back(point_list[7]);
+				polygon.push_back(point_list[8]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_CORNER:
+				polygon.push_back(point_list[8]);
+				polygon.push_back(point_list[9]);
+				polygon.push_back(point_list[10]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
+				polygon.push_back(point_list[10]);
+				polygon.push_back(point_list[11]);
+				polygon.push_back(point_list[0]);
+				break;
+			default:
+				break;
+		}
+	} else {
+		if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
+			for (int i = 0; i < point_list.size(); i++) {
+				point_list.write[i] = Vector2(point_list[i].y, point_list[i].x);
+			}
+		}
+		switch (p_bit) {
+			case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
+				polygon.push_back(point_list[2]);
+				polygon.push_back(point_list[3]);
+				polygon.push_back(point_list[4]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
+				polygon.push_back(point_list[0]);
+				polygon.push_back(point_list[1]);
+				polygon.push_back(point_list[2]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
+				polygon.push_back(point_list[10]);
+				polygon.push_back(point_list[11]);
+				polygon.push_back(point_list[0]);
+				break;
+			case TileSet::CELL_NEIGHBOR_LEFT_CORNER:
+				polygon.push_back(point_list[8]);
+				polygon.push_back(point_list[9]);
+				polygon.push_back(point_list[10]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
+				polygon.push_back(point_list[6]);
+				polygon.push_back(point_list[7]);
+				polygon.push_back(point_list[8]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
+				polygon.push_back(point_list[4]);
+				polygon.push_back(point_list[5]);
+				polygon.push_back(point_list[6]);
+				break;
+			default:
+				break;
+		}
+	}
+
+	int half_polygon_size = polygon.size();
+	for (int i = 0; i < half_polygon_size; i++) {
+		polygon.push_back(polygon[half_polygon_size - 1 - i] / 3.0);
+	}
+
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
+	}
+}
+
+void TileSetAtlasPluginTerrain::_draw_half_offset_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) {
+	PackedColorArray color_array;
+	color_array.push_back(p_color);
+
+	PackedVector2Array point_list;
+	point_list.push_back(Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(0, 3));
+	point_list.push_back(Vector2(-3, 3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(-3, -3.0 * (1.0 - p_overlap * 2.0)));
+	point_list.push_back(Vector2(0, -3));
+	point_list.push_back(Vector2(3, -3.0 * (1.0 - p_overlap * 2.0)));
+
+	Vector2 unit = Vector2(p_size) / 6.0;
+	for (int i = 0; i < point_list.size(); i++) {
+		point_list.write[i] = point_list[i] * unit;
+	}
+
+	PackedVector2Array polygon;
+	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		switch (p_bit) {
+			case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
+				polygon.push_back(point_list[5]);
+				polygon.push_back(point_list[0]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
+				polygon.push_back(point_list[0]);
+				polygon.push_back(point_list[1]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
+				polygon.push_back(point_list[1]);
+				polygon.push_back(point_list[2]);
+				break;
+			case TileSet::CELL_NEIGHBOR_LEFT_SIDE:
+				polygon.push_back(point_list[2]);
+				polygon.push_back(point_list[3]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
+				polygon.push_back(point_list[3]);
+				polygon.push_back(point_list[4]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
+				polygon.push_back(point_list[4]);
+				polygon.push_back(point_list[5]);
+				break;
+			default:
+				break;
+		}
+	} else {
+		if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
+			for (int i = 0; i < point_list.size(); i++) {
+				point_list.write[i] = Vector2(point_list[i].y, point_list[i].x);
+			}
+		}
+		switch (p_bit) {
+			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
+				polygon.push_back(point_list[0]);
+				polygon.push_back(point_list[1]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_SIDE:
+				polygon.push_back(point_list[5]);
+				polygon.push_back(point_list[0]);
+				break;
+			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
+				polygon.push_back(point_list[4]);
+				polygon.push_back(point_list[5]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
+				polygon.push_back(point_list[3]);
+				polygon.push_back(point_list[4]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_SIDE:
+				polygon.push_back(point_list[2]);
+				polygon.push_back(point_list[3]);
+				break;
+			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
+				polygon.push_back(point_list[1]);
+				polygon.push_back(point_list[2]);
+				break;
+			default:
+				break;
+		}
+	}
+
+	int half_polygon_size = polygon.size();
+	for (int i = 0; i < half_polygon_size; i++) {
+		polygon.push_back(polygon[half_polygon_size - 1 - i] / 3.0);
+	}
+
+	if (!polygon.is_empty()) {
+		p_canvas_item->draw_polygon(polygon, color_array);
 	}
-	Ref<ConvexPolygonShape2D> convex = p_shape;
-	if (!convex.is_valid()) {
+}
+
+#define TERRAIN_ALPHA 0.8
+
+#define DRAW_TERRAIN_BIT(f, bit)                                                  \
+	{                                                                             \
+		int terrain_id = p_tile_data->get_peering_bit_terrain((bit));             \
+		if (terrain_id >= 0) {                                                    \
+			Color color = p_tile_set->get_terrain_color(terrain_set, terrain_id); \
+			color.a = TERRAIN_ALPHA;                                              \
+			f(p_canvas_item, color, size, (bit));                                 \
+		}                                                                         \
+	}
+
+#define DRAW_HALF_OFFSET_TERRAIN_BIT(f, bit, overlap, half_offset_axis)           \
+	{                                                                             \
+		int terrain_id = p_tile_data->get_peering_bit_terrain((bit));             \
+		if (terrain_id >= 0) {                                                    \
+			Color color = p_tile_set->get_terrain_color(terrain_set, terrain_id); \
+			color.a = TERRAIN_ALPHA;                                              \
+			f(p_canvas_item, color, size, (bit), overlap, half_offset_axis);      \
+		}                                                                         \
+	}
+
+void TileSetAtlasPluginTerrain::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform, TileSet *p_tile_set, const TileData *p_tile_data) {
+	ERR_FAIL_COND(!p_tile_set);
+	ERR_FAIL_COND(!p_tile_data);
+
+	int terrain_set = p_tile_data->get_terrain_set();
+	if (terrain_set < 0) {
 		return;
 	}
-	Vector<Vector<Vector2>> decomp = Geometry2D::decompose_polygon_in_convex(convex->get_points());
-	if (decomp.size() > 1) {
-		Array sub_shapes;
-		for (int i = 0; i < decomp.size(); i++) {
-			Ref<ConvexPolygonShape2D> _convex = memnew(ConvexPolygonShape2D);
-			_convex->set_points(decomp[i]);
-			sub_shapes.append(_convex);
+	TileSet::TerrainMode terrain_mode = p_tile_set->get_terrain_set_mode(terrain_set);
+
+	TileSet::TileShape shape = p_tile_set->get_tile_shape();
+	Vector2i size = p_tile_set->get_tile_size();
+
+	RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), p_transform);
+	if (shape == TileSet::TILE_SHAPE_SQUARE) {
+		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE);
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_SIDE);
+			DRAW_TERRAIN_BIT(_draw_square_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER);
+		} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
+			DRAW_TERRAIN_BIT(_draw_square_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_square_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_square_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_square_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER);
+		} else { // TileData::TERRAIN_MODE_MATCH_SIDES
+			DRAW_TERRAIN_BIT(_draw_square_side_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_square_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE);
+			DRAW_TERRAIN_BIT(_draw_square_side_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_square_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_SIDE);
+		}
+	} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_CORNER);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_CORNER);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
+		} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_CORNER);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_CORNER);
+			DRAW_TERRAIN_BIT(_draw_isometric_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_CORNER);
+		} else { // TileData::TERRAIN_MODE_MATCH_SIDES
+			DRAW_TERRAIN_BIT(_draw_isometric_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_isometric_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_isometric_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
+			DRAW_TERRAIN_BIT(_draw_isometric_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
 		}
-		convex->set_meta("decomposed", sub_shapes);
 	} else {
-		convex->set_meta("decomposed", Variant());
+		TileSet::TileOffsetAxis offset_axis = p_tile_set->get_tile_offset_axis();
+		float overlap = 0.0;
+		switch (p_tile_set->get_tile_shape()) {
+			case TileSet::TILE_SHAPE_HEXAGON:
+				overlap = 0.25;
+				break;
+			case TileSet::TILE_SHAPE_HALF_OFFSET_SQUARE:
+				overlap = 0.0;
+				break;
+			default:
+				break;
+		}
+		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
+			if (offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER, overlap, offset_axis);
+			} else {
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_or_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE, overlap, offset_axis);
+			}
+		} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
+			if (offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER, overlap, offset_axis);
+			} else {
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_corner_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER, overlap, offset_axis);
+			}
+		} else { // TileData::TERRAIN_MODE_MATCH_SIDES
+			if (offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_RIGHT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE, overlap, offset_axis);
+			} else {
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_SIDE, overlap, offset_axis);
+				DRAW_HALF_OFFSET_TERRAIN_BIT(_draw_half_offset_side_terrain_bit, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE, overlap, offset_axis);
+			}
+		}
 	}
+	RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), Transform2D());
 }
 
-void TileSet::get_tile_list(List<int> *p_tiles) const {
-	for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
-		p_tiles->push_back(E->key());
+/////////////////////////////// TileSetAtlasPluginRendering //////////////////////////////////////
+
+void TileSetAtlasPluginRendering::tilemap_notification(TileMap *p_tile_map, int p_what) {
+	switch (p_what) {
+		case CanvasItem::NOTIFICATION_VISIBILITY_CHANGED: {
+			bool visible = p_tile_map->is_visible_in_tree();
+			for (Map<Vector2i, TileMapQuadrant>::Element *E_quadrant = p_tile_map->get_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 (List<RID>::Element *E_occluder_id = q.occluders.front(); E_occluder_id; E_occluder_id = E_occluder_id->next()) {
+						RS::get_singleton()->canvas_light_occluder_set_enabled(E_occluder_id->get(), visible);
+					}
+				}
+			}
+		} break;
+		case CanvasItem::NOTIFICATION_TRANSFORM_CHANGED: {
+			if (!p_tile_map->is_inside_tree()) {
+				return;
+			}
+
+			for (Map<Vector2i, TileMapQuadrant>::Element *E_quadrant = p_tile_map->get_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 (List<RID>::Element *E_occluder_id = q.occluders.front(); E_occluder_id; E_occluder_id = E_occluder_id->next()) {
+						RS::get_singleton()->canvas_light_occluder_set_transform(E_occluder_id->get(), p_tile_map->get_global_transform() * xform);
+					}
+				}
+			}
+		} break;
 	}
 }
 
-bool TileSet::has_tile(int p_id) const {
-	return tile_map.has(p_id);
+void TileSetAtlasPluginRendering::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;
+		}
+
+		// 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());
+	}
 }
 
-bool TileSet::is_tile_bound(int p_drawn_id, int p_neighbor_id) {
-	if (p_drawn_id == p_neighbor_id) {
-		return true;
-	} else if (get_script_instance() != nullptr) {
-		if (get_script_instance()->has_method("_is_tile_bound")) {
-			Variant ret = get_script_instance()->call("_is_tile_bound", p_drawn_id, p_neighbor_id);
-			if (ret.get_type() == Variant::BOOL) {
-				return ret;
+void TileSetAtlasPluginRendering::update_dirty_quadrants(TileMap *p_tile_map, SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {
+	ERR_FAIL_COND(!p_tile_map);
+	ERR_FAIL_COND(!p_tile_map->is_inside_tree());
+	Ref<TileSet> tile_set = p_tile_map->get_tileset();
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	bool visible = p_tile_map->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 (List<RID>::Element *E = q.canvas_items.front(); E; E = E->next()) {
+			rs->free(E->get());
+		}
+		q.canvas_items.clear();
+
+		// Free the occluders.
+		for (List<RID>::Element *E = q.occluders.front(); E; E = E->next()) {
+			rs->free(E->get());
+		}
+		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 = p_tile_map->get_cell(E_cell->value());
+
+			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 = tile_data->get_z_index();
+
+					// Quandrant pos.
+					Vector2 position = p_tile_map->map_to_world(q.coords * p_tile_map->get_effective_quadrant_size()) - tile_set->get_tile_size() / 2;
+
+					// --- 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) {
+						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, p_tile_map->get_canvas_item());
+						rs->canvas_item_set_use_parent_material(canvas_item, p_tile_map->get_use_parent_material() || p_tile_map->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, p_tile_map->get_light_mask());
+						rs->canvas_item_set_z_index(canvas_item, z_index);
+
+						rs->canvas_item_set_default_texture_filter(canvas_item, RS::CanvasItemTextureFilter(p_tile_map->CanvasItem::get_texture_filter()));
+						rs->canvas_item_set_default_texture_repeat(canvas_item, RS::CanvasItemTextureRepeat(p_tile_map->CanvasItem::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.
+					draw_tile(canvas_item, E_cell->key() - position, tile_set, c.source_id, c.get_atlas_coords(), c.alternative_tile, p_tile_map->get_self_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, p_tile_map->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, p_tile_map->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);
+						}
+					}
+				}
 			}
 		}
+
+		quadrant_order_dirty = true;
+		q_list_element = q_list_element->next();
+	}
+
+	// Reset the drawing indices
+	if (quadrant_order_dirty) {
+		int index = -(int64_t)0x80000000; //always must be drawn below children.
+
+		// Sort the quadrants coords per world coordinates
+		Map<Vector2i, Vector2i, TileMapQuadrant::CoordsWorldComparator> world_to_map;
+		Map<Vector2i, TileMapQuadrant> quadrant_map = p_tile_map->get_quadrant_map();
+		for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
+			world_to_map[p_tile_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 = quadrant_map[E->value()];
+			for (List<RID>::Element *F = q.canvas_items.front(); F; F = F->next()) {
+				RS::get_singleton()->canvas_item_set_draw_index(F->get(), index++);
+			}
+		}
+
+		quadrant_order_dirty = false;
 	}
-	return false;
 }
 
-void TileSet::remove_tile(int p_id) {
-	ERR_FAIL_COND(!tile_map.has(p_id));
-	tile_map.erase(p_id);
-	notify_property_list_changed();
-	emit_changed();
+void TileSetAtlasPluginRendering::create_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) {
+	Ref<TileSet> tile_set = p_tile_map->get_tileset();
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	quadrant_order_dirty = true;
 }
 
-int TileSet::get_last_unused_tile_id() const {
-	if (tile_map.size()) {
-		return tile_map.back()->key() + 1;
-	} else {
-		return 0;
+void TileSetAtlasPluginRendering::cleanup_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) {
+	// Free the canvas items.
+	for (List<RID>::Element *E = p_quadrant->canvas_items.front(); E; E = E->next()) {
+		RenderingServer::get_singleton()->free(E->get());
+	}
+	p_quadrant->canvas_items.clear();
+
+	// Free the occluders.
+	for (List<RID>::Element *E = p_quadrant->occluders.front(); E; E = E->next()) {
+		RenderingServer::get_singleton()->free(E->get());
 	}
+	p_quadrant->occluders.clear();
 }
 
-int TileSet::find_tile_by_name(const String &p_name) const {
-	for (Map<int, TileData>::Element *E = tile_map.front(); E; E = E->next()) {
-		if (p_name == E->get().name) {
-			return E->key();
+/////////////////////////////// TileSetAtlasPluginPhysics //////////////////////////////////////
+
+void TileSetAtlasPluginPhysics::tilemap_notification(TileMap *p_tile_map, int p_what) {
+	switch (p_what) {
+		case CanvasItem::NOTIFICATION_TRANSFORM_CHANGED: {
+			// Update the bodies transforms.
+			if (p_tile_map->is_inside_tree()) {
+				Map<Vector2i, TileMapQuadrant> quadrant_map = p_tile_map->get_quadrant_map();
+				Transform2D global_transform = p_tile_map->get_global_transform();
+
+				for (Map<Vector2i, TileMapQuadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
+					TileMapQuadrant &q = E->get();
+
+					Transform2D xform;
+					xform.set_origin(p_tile_map->map_to_world(E->key() * p_tile_map->get_effective_quadrant_size()));
+					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 TileSetAtlasPluginPhysics::update_dirty_quadrants(TileMap *p_tile_map, SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {
+	ERR_FAIL_COND(!p_tile_map);
+	ERR_FAIL_COND(!p_tile_map->is_inside_tree());
+	Ref<TileSet> tile_set = p_tile_map->get_tileset();
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	Transform2D global_transform = p_tile_map->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 = p_tile_map->map_to_world(q.coords * p_tile_map->get_effective_quadrant_size());
+
+		// 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 = p_tile_map->get_cell(E_cell->get());
+
+			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 shape_index = 0; shape_index < tile_data->get_collision_shapes_count(body_index); shape_index++) {
+							bool one_way_collision = tile_data->is_collision_shape_one_way(body_index, shape_index);
+							float one_way_collision_margin = tile_data->get_collision_shape_one_way_margin(body_index, shape_index);
+							Ref<Shape2D> shape = tile_data->get_collision_shape_shape(body_index, shape_index);
+							if (shape.is_valid()) {
+								Transform2D xform = Transform2D();
+								xform.set_origin(p_tile_map->map_to_world(E_cell->get()) - quadrant_pos);
+
+								// Add decomposed convex shapes.
+								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();
 	}
-	return -1;
 }
 
-void TileSet::reset_state() {
-	clear();
+void TileSetAtlasPluginPhysics::create_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) {
+	Ref<TileSet> tile_set = p_tile_map->get_tileset();
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	//Get the TileMap's gobla transform.
+	Transform2D global_transform;
+	if (p_tile_map->is_inside_tree()) {
+		global_transform = p_tile_map->get_global_transform();
+	}
+
+	// Clear all bodies.
+	p_quadrant->bodies.clear();
+
+	// Create the body and set its parameters.
+	for (int layer_index = 0; layer_index < tile_set->get_physics_layers_count(); layer_index++) {
+		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, p_tile_map->get_instance_id());
+		PhysicsServer2D::get_singleton()->body_set_collision_layer(body, tile_set->get_physics_layer_collision_layer(layer_index));
+		PhysicsServer2D::get_singleton()->body_set_collision_mask(body, tile_set->get_physics_layer_collision_mask(layer_index));
+
+		Ref<PhysicsMaterial> physics_material = tile_set->get_physics_layer_physics_material(layer_index);
+		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 (p_tile_map->is_inside_tree()) {
+			RID space = p_tile_map->get_world_2d()->get_space();
+			PhysicsServer2D::get_singleton()->body_set_space(body, space);
+
+			Transform2D xform;
+			xform.set_origin(p_tile_map->map_to_world(p_quadrant->coords * p_tile_map->get_effective_quadrant_size()));
+			xform = global_transform * xform;
+			PhysicsServer2D::get_singleton()->body_set_state(body, PhysicsServer2D::BODY_STATE_TRANSFORM, xform);
+		}
+
+		p_quadrant->bodies.push_back(body);
+	}
 }
 
-void TileSet::clear() {
-	tile_map.clear();
-	notify_property_list_changed();
-	emit_changed();
+void TileSetAtlasPluginPhysics::cleanup_quadrant(TileMap *p_tile_map, 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 TileSet::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("create_tile", "id"), &TileSet::create_tile);
-	ClassDB::bind_method(D_METHOD("autotile_clear_bitmask_map", "id"), &TileSet::autotile_clear_bitmask_map);
-	ClassDB::bind_method(D_METHOD("autotile_set_icon_coordinate", "id", "coord"), &TileSet::autotile_set_icon_coordinate);
-	ClassDB::bind_method(D_METHOD("autotile_get_icon_coordinate", "id"), &TileSet::autotile_get_icon_coordinate);
-	ClassDB::bind_method(D_METHOD("autotile_set_subtile_priority", "id", "coord", "priority"), &TileSet::autotile_set_subtile_priority);
-	ClassDB::bind_method(D_METHOD("autotile_get_subtile_priority", "id", "coord"), &TileSet::autotile_get_subtile_priority);
-	ClassDB::bind_method(D_METHOD("autotile_set_z_index", "id", "coord", "z_index"), &TileSet::autotile_set_z_index);
-	ClassDB::bind_method(D_METHOD("autotile_get_z_index", "id", "coord"), &TileSet::autotile_get_z_index);
-	ClassDB::bind_method(D_METHOD("autotile_set_light_occluder", "id", "light_occluder", "coord"), &TileSet::autotile_set_light_occluder);
-	ClassDB::bind_method(D_METHOD("autotile_get_light_occluder", "id", "coord"), &TileSet::autotile_get_light_occluder);
-	ClassDB::bind_method(D_METHOD("autotile_set_navigation_polygon", "id", "navigation_polygon", "coord"), &TileSet::autotile_set_navigation_polygon);
-	ClassDB::bind_method(D_METHOD("autotile_get_navigation_polygon", "id", "coord"), &TileSet::autotile_get_navigation_polygon);
-	ClassDB::bind_method(D_METHOD("autotile_set_bitmask", "id", "bitmask", "flag"), &TileSet::autotile_set_bitmask);
-	ClassDB::bind_method(D_METHOD("autotile_get_bitmask", "id", "coord"), &TileSet::autotile_get_bitmask);
-	ClassDB::bind_method(D_METHOD("autotile_set_bitmask_mode", "id", "mode"), &TileSet::autotile_set_bitmask_mode);
-	ClassDB::bind_method(D_METHOD("autotile_get_bitmask_mode", "id"), &TileSet::autotile_get_bitmask_mode);
-	ClassDB::bind_method(D_METHOD("autotile_set_spacing", "id", "spacing"), &TileSet::autotile_set_spacing);
-	ClassDB::bind_method(D_METHOD("autotile_get_spacing", "id"), &TileSet::autotile_get_spacing);
-	ClassDB::bind_method(D_METHOD("autotile_set_size", "id", "size"), &TileSet::autotile_set_size);
-	ClassDB::bind_method(D_METHOD("autotile_get_size", "id"), &TileSet::autotile_get_size);
-	ClassDB::bind_method(D_METHOD("tile_set_name", "id", "name"), &TileSet::tile_set_name);
-	ClassDB::bind_method(D_METHOD("tile_get_name", "id"), &TileSet::tile_get_name);
-	ClassDB::bind_method(D_METHOD("tile_set_texture", "id", "texture"), &TileSet::tile_set_texture);
-	ClassDB::bind_method(D_METHOD("tile_get_texture", "id"), &TileSet::tile_get_texture);
-	ClassDB::bind_method(D_METHOD("tile_set_material", "id", "material"), &TileSet::tile_set_material);
-	ClassDB::bind_method(D_METHOD("tile_get_material", "id"), &TileSet::tile_get_material);
-	ClassDB::bind_method(D_METHOD("tile_set_modulate", "id", "color"), &TileSet::tile_set_modulate);
-	ClassDB::bind_method(D_METHOD("tile_get_modulate", "id"), &TileSet::tile_get_modulate);
-	ClassDB::bind_method(D_METHOD("tile_set_texture_offset", "id", "texture_offset"), &TileSet::tile_set_texture_offset);
-	ClassDB::bind_method(D_METHOD("tile_get_texture_offset", "id"), &TileSet::tile_get_texture_offset);
-	ClassDB::bind_method(D_METHOD("tile_set_region", "id", "region"), &TileSet::tile_set_region);
-	ClassDB::bind_method(D_METHOD("tile_get_region", "id"), &TileSet::tile_get_region);
-	ClassDB::bind_method(D_METHOD("tile_set_shape", "id", "shape_id", "shape"), &TileSet::tile_set_shape);
-	ClassDB::bind_method(D_METHOD("tile_get_shape", "id", "shape_id"), &TileSet::tile_get_shape);
-	ClassDB::bind_method(D_METHOD("tile_set_shape_offset", "id", "shape_id", "shape_offset"), &TileSet::tile_set_shape_offset);
-	ClassDB::bind_method(D_METHOD("tile_get_shape_offset", "id", "shape_id"), &TileSet::tile_get_shape_offset);
-	ClassDB::bind_method(D_METHOD("tile_set_shape_transform", "id", "shape_id", "shape_transform"), &TileSet::tile_set_shape_transform);
-	ClassDB::bind_method(D_METHOD("tile_get_shape_transform", "id", "shape_id"), &TileSet::tile_get_shape_transform);
-	ClassDB::bind_method(D_METHOD("tile_set_shape_one_way", "id", "shape_id", "one_way"), &TileSet::tile_set_shape_one_way);
-	ClassDB::bind_method(D_METHOD("tile_get_shape_one_way", "id", "shape_id"), &TileSet::tile_get_shape_one_way);
-	ClassDB::bind_method(D_METHOD("tile_set_shape_one_way_margin", "id", "shape_id", "one_way"), &TileSet::tile_set_shape_one_way_margin);
-	ClassDB::bind_method(D_METHOD("tile_get_shape_one_way_margin", "id", "shape_id"), &TileSet::tile_get_shape_one_way_margin);
-	ClassDB::bind_method(D_METHOD("tile_add_shape", "id", "shape", "shape_transform", "one_way", "autotile_coord"), &TileSet::tile_add_shape, DEFVAL(false), DEFVAL(Vector2()));
-	ClassDB::bind_method(D_METHOD("tile_get_shape_count", "id"), &TileSet::tile_get_shape_count);
-	ClassDB::bind_method(D_METHOD("tile_set_shapes", "id", "shapes"), &TileSet::_tile_set_shapes);
-	ClassDB::bind_method(D_METHOD("tile_get_shapes", "id"), &TileSet::_tile_get_shapes);
-	ClassDB::bind_method(D_METHOD("tile_set_tile_mode", "id", "tilemode"), &TileSet::tile_set_tile_mode);
-	ClassDB::bind_method(D_METHOD("tile_get_tile_mode", "id"), &TileSet::tile_get_tile_mode);
-	ClassDB::bind_method(D_METHOD("tile_set_navigation_polygon", "id", "navigation_polygon"), &TileSet::tile_set_navigation_polygon);
-	ClassDB::bind_method(D_METHOD("tile_get_navigation_polygon", "id"), &TileSet::tile_get_navigation_polygon);
-	ClassDB::bind_method(D_METHOD("tile_set_navigation_polygon_offset", "id", "navigation_polygon_offset"), &TileSet::tile_set_navigation_polygon_offset);
-	ClassDB::bind_method(D_METHOD("tile_get_navigation_polygon_offset", "id"), &TileSet::tile_get_navigation_polygon_offset);
-	ClassDB::bind_method(D_METHOD("tile_set_light_occluder", "id", "light_occluder"), &TileSet::tile_set_light_occluder);
-	ClassDB::bind_method(D_METHOD("tile_get_light_occluder", "id"), &TileSet::tile_get_light_occluder);
-	ClassDB::bind_method(D_METHOD("tile_set_occluder_offset", "id", "occluder_offset"), &TileSet::tile_set_occluder_offset);
-	ClassDB::bind_method(D_METHOD("tile_get_occluder_offset", "id"), &TileSet::tile_get_occluder_offset);
-	ClassDB::bind_method(D_METHOD("tile_set_z_index", "id", "z_index"), &TileSet::tile_set_z_index);
-	ClassDB::bind_method(D_METHOD("tile_get_z_index", "id"), &TileSet::tile_get_z_index);
-
-	ClassDB::bind_method(D_METHOD("remove_tile", "id"), &TileSet::remove_tile);
-	ClassDB::bind_method(D_METHOD("clear"), &TileSet::clear);
-	ClassDB::bind_method(D_METHOD("get_last_unused_tile_id"), &TileSet::get_last_unused_tile_id);
-	ClassDB::bind_method(D_METHOD("find_tile_by_name", "name"), &TileSet::find_tile_by_name);
-	ClassDB::bind_method(D_METHOD("get_tiles_ids"), &TileSet::_get_tiles_ids);
-
-	BIND_VMETHOD(MethodInfo(Variant::BOOL, "_is_tile_bound", PropertyInfo(Variant::INT, "drawn_id"), PropertyInfo(Variant::INT, "neighbor_id")));
-	BIND_VMETHOD(MethodInfo(Variant::VECTOR2, "_forward_subtile_selection", PropertyInfo(Variant::INT, "autotile_id"), PropertyInfo(Variant::INT, "bitmask"), PropertyInfo(Variant::OBJECT, "tilemap", PROPERTY_HINT_NONE, "TileMap"), PropertyInfo(Variant::VECTOR2, "tile_location")));
-	BIND_VMETHOD(MethodInfo(Variant::VECTOR2, "_forward_atlas_subtile_selection", PropertyInfo(Variant::INT, "atlastile_id"), PropertyInfo(Variant::OBJECT, "tilemap", PROPERTY_HINT_NONE, "TileMap"), PropertyInfo(Variant::VECTOR2, "tile_location")));
-
-	BIND_ENUM_CONSTANT(BITMASK_2X2);
-	BIND_ENUM_CONSTANT(BITMASK_3X3_MINIMAL);
-	BIND_ENUM_CONSTANT(BITMASK_3X3);
-
-	BIND_ENUM_CONSTANT(BIND_TOPLEFT);
-	BIND_ENUM_CONSTANT(BIND_TOP);
-	BIND_ENUM_CONSTANT(BIND_TOPRIGHT);
-	BIND_ENUM_CONSTANT(BIND_LEFT);
-	BIND_ENUM_CONSTANT(BIND_CENTER);
-	BIND_ENUM_CONSTANT(BIND_RIGHT);
-	BIND_ENUM_CONSTANT(BIND_BOTTOMLEFT);
-	BIND_ENUM_CONSTANT(BIND_BOTTOM);
-	BIND_ENUM_CONSTANT(BIND_BOTTOMRIGHT);
-
-	BIND_ENUM_CONSTANT(SINGLE_TILE);
-	BIND_ENUM_CONSTANT(AUTO_TILE);
-	BIND_ENUM_CONSTANT(ATLAS_TILE);
+void TileSetAtlasPluginPhysics::draw_quadrant_debug(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) {
+	// Draw the debug collision shapes.
+	Ref<TileSet> tile_set = p_tile_map->get_tileset();
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	if (!p_tile_map->get_tree() || !(Engine::get_singleton()->is_editor_hint() || p_tile_map->get_tree()->is_debugging_collisions_hint())) {
+		return;
+	}
+
+	RenderingServer *rs = RenderingServer::get_singleton();
+
+	Vector2 quadrant_pos = p_tile_map->map_to_world(p_quadrant->coords * p_tile_map->get_effective_quadrant_size());
+
+	Color debug_collision_color = p_tile_map->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 = p_tile_map->get_cell(E_cell->get());
+
+		Transform2D xform;
+		xform.set_origin(p_tile_map->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 shape_index = 0; shape_index < tile_data->get_collision_shapes_count(body_index); shape_index++) {
+						// Draw the debug shape.
+						Ref<Shape2D> shape = tile_data->get_collision_shape_shape(body_index, shape_index);
+						if (shape.is_valid()) {
+							shape->draw(p_quadrant->debug_canvas_item, debug_collision_color);
+						}
+					}
+				}
+			}
+		}
+		rs->canvas_item_add_set_transform(p_quadrant->debug_canvas_item, Transform2D());
+	}
+};
+
+/////////////////////////////// TileSetAtlasPluginNavigation //////////////////////////////////////
+
+void TileSetAtlasPluginNavigation::tilemap_notification(TileMap *p_tile_map, int p_what) {
+	switch (p_what) {
+		case CanvasItem::NOTIFICATION_TRANSFORM_CHANGED: {
+			if (p_tile_map->is_inside_tree()) {
+				Map<Vector2i, TileMapQuadrant> quadrant_map = p_tile_map->get_quadrant_map();
+				Transform2D tilemap_xform = p_tile_map->get_global_transform();
+				for (Map<Vector2i, TileMapQuadrant>::Element *E_quadrant = 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(p_tile_map->map_to_world(E_region->key()));
+							NavigationServer2D::get_singleton()->region_set_transform(region, tilemap_xform * tile_transform);
+						}
+					}
+				}
+			}
+		} break;
+	}
 }
 
-TileSet::TileSet() {
+void TileSetAtlasPluginNavigation::update_dirty_quadrants(TileMap *p_tile_map, SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) {
+	ERR_FAIL_COND(!p_tile_map);
+	ERR_FAIL_COND(!p_tile_map->is_inside_tree());
+	Ref<TileSet> tile_set = p_tile_map->get_tileset();
+	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 = p_tile_map->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 = p_tile_map->get_cell(E_cell->get());
+
+			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(p_tile_map->map_to_world(E_cell->get()));
+
+							RID region = NavigationServer2D::get_singleton()->region_create();
+							NavigationServer2D::get_singleton()->region_set_map(region, p_tile_map->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();
+	}
+}
+
+void TileSetAtlasPluginNavigation::cleanup_quadrant(TileMap *p_tile_map, 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 TileSetAtlasPluginNavigation::draw_quadrant_debug(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) {
+	// Draw the debug collision shapes.
+	Ref<TileSet> tile_set = p_tile_map->get_tileset();
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	if (!p_tile_map->get_tree() || !(Engine::get_singleton()->is_editor_hint() || p_tile_map->get_tree()->is_debugging_navigation_hint())) {
+		return;
+	}
+
+	RenderingServer *rs = RenderingServer::get_singleton();
+
+	Color color = p_tile_map->get_tree()->get_debug_navigation_color();
+	RandomPCG rand;
+
+	Vector2 quadrant_pos = p_tile_map->map_to_world(p_quadrant->coords * p_tile_map->get_effective_quadrant_size());
+
+	for (Set<Vector2i>::Element *E_cell = p_quadrant->cells.front(); E_cell; E_cell = E_cell->next()) {
+		TileMapCell c = p_tile_map->get_cell(E_cell->get());
+
+		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(p_tile_map->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::get_singleton()->canvas_item_add_polygon(p_quadrant->debug_canvas_item, vertices, colors);
+						}
+					}
+				}
+			}
+		}
+	}
 }
diff --git a/scene/resources/tile_set.h b/scene/resources/tile_set.h
index 0a8721f35b..20cf183a20 100644
--- a/scene/resources/tile_set.h
+++ b/scene/resources/tile_set.h
@@ -32,226 +32,614 @@
 #define TILE_SET_H
 
 #include "core/io/resource.h"
-#include "core/variant/array.h"
+#include "core/object/object.h"
 #include "scene/2d/light_occluder_2d.h"
 #include "scene/2d/navigation_region_2d.h"
+#include "scene/main/canvas_item.h"
 #include "scene/resources/convex_polygon_shape_2d.h"
+#include "scene/resources/packed_scene.h"
+#include "scene/resources/physics_material.h"
+#include "scene/resources/shape_2d.h"
+
+#ifndef DISABLE_DEPRECATED
+#include "scene/2d/light_occluder_2d.h"
+#include "scene/2d/navigation_region_2d.h"
+#include "scene/resources/shader.h"
 #include "scene/resources/shape_2d.h"
 #include "scene/resources/texture.h"
+#endif
+
+class TileMap;
+struct TileMapQuadrant;
+class TileSetSource;
+class TileSetAtlasSource;
+class TileData;
+
+// Forward-declare the plugins.
+class TileSetPlugin;
+class TileSetAtlasPluginRendering;
+class TileSetAtlasPluginPhysics;
+class TileSetAtlasPluginNavigation;
+class TileSetAtlasPluginTerrain;
 
 class TileSet : public Resource {
 	GDCLASS(TileSet, Resource);
 
-public:
-	struct ShapeData {
+#ifndef DISABLE_DEPRECATED
+private:
+	struct CompatibilityShapeData {
+		Vector2i autotile_coords;
+		bool one_way;
+		float one_way_margin;
 		Ref<Shape2D> shape;
-		Transform2D shape_transform;
-		Vector2 autotile_coord;
-		bool one_way_collision = false;
-		float one_way_collision_margin = 1.0;
+		Transform2D transform;
+	};
 
-		ShapeData() {}
+	struct CompatibilityTileData {
+		String name;
+		Ref<Texture2D> texture;
+		Vector2 tex_offset;
+		Ref<ShaderMaterial> material;
+		Rect2 region;
+		int tile_mode;
+		Color modulate;
+
+		// Atlas or autotiles data
+		int autotile_bitmask_mode;
+		Vector2 autotile_icon_coordinate;
+		Size2i autotile_tile_size = Size2i(16, 16);
+
+		int autotile_spacing;
+		Map<Vector2i, int> autotile_bitmask_flags;
+		Map<Vector2i, Ref<OccluderPolygon2D>> autotile_occluder_map;
+		Map<Vector2i, Ref<NavigationPolygon>> autotile_navpoly_map;
+		Map<Vector2i, int> autotile_priority_map;
+		Map<Vector2i, int> autotile_z_index_map;
+
+		Vector<CompatibilityShapeData> shapes;
+		Ref<OccluderPolygon2D> occluder;
+		Vector2 occluder_offset;
+		Ref<NavigationPolygon> navigation;
+		Vector2 navigation_offset;
+		int z_index;
 	};
 
-	enum BitmaskMode {
-		BITMASK_2X2,
-		BITMASK_3X3_MINIMAL,
-		BITMASK_3X3
+	Map<int, CompatibilityTileData *> compatibility_data = Map<int, CompatibilityTileData *>();
+	Map<int, int> compatibility_source_mapping = Map<int, int>();
+
+private:
+	void compatibility_conversion();
+
+public:
+	int compatibility_get_source_for_tile_id(int p_old_source) {
+		return compatibility_source_mapping[p_old_source];
 	};
 
-	enum AutotileBindings {
-		BIND_TOPLEFT = 1,
-		BIND_TOP = 2,
-		BIND_TOPRIGHT = 4,
-		BIND_LEFT = 8,
-		BIND_CENTER = 16,
-		BIND_RIGHT = 32,
-		BIND_BOTTOMLEFT = 64,
-		BIND_BOTTOM = 128,
-		BIND_BOTTOMRIGHT = 256,
-
-		BIND_IGNORE_TOPLEFT = 1 << 16,
-		BIND_IGNORE_TOP = 1 << 17,
-		BIND_IGNORE_TOPRIGHT = 1 << 18,
-		BIND_IGNORE_LEFT = 1 << 19,
-		BIND_IGNORE_CENTER = 1 << 20,
-		BIND_IGNORE_RIGHT = 1 << 21,
-		BIND_IGNORE_BOTTOMLEFT = 1 << 22,
-		BIND_IGNORE_BOTTOM = 1 << 23,
-		BIND_IGNORE_BOTTOMRIGHT = 1 << 24
+#endif // DISABLE_DEPRECATED
+
+public:
+	enum CellNeighbor {
+		CELL_NEIGHBOR_RIGHT_SIDE = 0,
+		CELL_NEIGHBOR_RIGHT_CORNER,
+		CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE,
+		CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER,
+		CELL_NEIGHBOR_BOTTOM_SIDE,
+		CELL_NEIGHBOR_BOTTOM_CORNER,
+		CELL_NEIGHBOR_BOTTOM_LEFT_SIDE,
+		CELL_NEIGHBOR_BOTTOM_LEFT_CORNER,
+		CELL_NEIGHBOR_LEFT_SIDE,
+		CELL_NEIGHBOR_LEFT_CORNER,
+		CELL_NEIGHBOR_TOP_LEFT_SIDE,
+		CELL_NEIGHBOR_TOP_LEFT_CORNER,
+		CELL_NEIGHBOR_TOP_SIDE,
+		CELL_NEIGHBOR_TOP_CORNER,
+		CELL_NEIGHBOR_TOP_RIGHT_SIDE,
+		CELL_NEIGHBOR_TOP_RIGHT_CORNER,
+		CELL_NEIGHBOR_MAX,
 	};
 
-	enum TileMode {
-		SINGLE_TILE,
-		AUTO_TILE,
-		ATLAS_TILE
+	enum TerrainMode {
+		TERRAIN_MODE_MATCH_CORNERS_AND_SIDES = 0,
+		TERRAIN_MODE_MATCH_CORNERS,
+		TERRAIN_MODE_MATCH_SIDES,
 	};
 
-	struct AutotileData {
-		BitmaskMode bitmask_mode = BITMASK_2X2;
-		// Default size to prevent invalid value
-		Size2 size = Size2(64, 64);
-		Vector2 icon_coord = Vector2(0, 0);
-		int spacing = 0;
-		Map<Vector2, uint32_t> flags;
-		Map<Vector2, Ref<OccluderPolygon2D>> occluder_map;
-		Map<Vector2, Ref<NavigationPolygon>> navpoly_map;
-		Map<Vector2, int> priority_map;
-		Map<Vector2, int> z_index_map;
-
-		explicit AutotileData() {}
+	enum TileShape {
+		TILE_SHAPE_SQUARE,
+		TILE_SHAPE_ISOMETRIC,
+		TILE_SHAPE_HALF_OFFSET_SQUARE,
+		TILE_SHAPE_HEXAGON,
 	};
 
-private:
-	struct TileData {
-		String name;
-		Ref<Texture2D> texture;
-		Vector2 offset;
-		Rect2i region;
-		Vector<ShapeData> shapes_data;
-		Vector2 occluder_offset;
-		Ref<OccluderPolygon2D> occluder;
-		Vector2 navigation_polygon_offset;
-		Ref<NavigationPolygon> navigation_polygon;
-		Ref<ShaderMaterial> material;
-		TileMode tile_mode = SINGLE_TILE;
-		// Default modulate for back-compat
-		Color modulate = Color(1, 1, 1);
-		AutotileData autotile_data;
-		int z_index = 0;
+	enum TileLayout {
+		TILE_LAYOUT_STACKED,
+		TILE_LAYOUT_STACKED_OFFSET,
+		TILE_LAYOUT_STAIRS_RIGHT,
+		TILE_LAYOUT_STAIRS_DOWN,
+		TILE_LAYOUT_DIAMOND_RIGHT,
+		TILE_LAYOUT_DIAMOND_DOWN,
+	};
 
-		explicit TileData() {}
+	enum TileOffsetAxis {
+		TILE_OFFSET_AXIS_HORIZONTAL,
+		TILE_OFFSET_AXIS_VERTICAL,
 	};
 
-	Map<int, TileData> tile_map;
+public:
+	struct PackedSceneSource {
+		Ref<PackedScene> scene;
+		Vector2 offset;
+	};
 
 protected:
 	bool _set(const StringName &p_name, const Variant &p_value);
 	bool _get(const StringName &p_name, Variant &r_ret) const;
 	void _get_property_list(List<PropertyInfo> *p_list) const;
-	void _tile_set_shapes(int p_id, const Array &p_shapes);
-	Array _tile_get_shapes(int p_id) const;
-	Array _get_tiles_ids() const;
-	void _decompose_convex_shape(Ref<Shape2D> p_shape);
 
+private:
+	// --- TileSet data ---
+	// Basic shape and layout.
+	TileShape tile_shape = TILE_SHAPE_SQUARE;
+	TileLayout tile_layout = TILE_LAYOUT_STACKED;
+	TileOffsetAxis tile_offset_axis = TILE_OFFSET_AXIS_HORIZONTAL;
+	Size2i tile_size = Size2i(16, 16); //Size2(64, 64);
+	Vector2 tile_skew = Vector2(0, 0);
+
+	// Rendering.
+	bool y_sorting = false;
+	bool uv_clipping = false;
+	struct OcclusionLayer {
+		uint32_t light_mask = 1;
+		bool sdf_collision = false;
+	};
+	Vector<OcclusionLayer> occlusion_layers;
+
+	// Physics
+	struct PhysicsLayer {
+		uint32_t collision_layer = 1;
+		uint32_t collision_mask = 1;
+		Ref<PhysicsMaterial> physics_material;
+	};
+	Vector<PhysicsLayer> physics_layers;
+
+	// Terrains
+	struct Terrain {
+		String name;
+		Color color;
+	};
+	struct TerrainSet {
+		TerrainMode mode = TERRAIN_MODE_MATCH_CORNERS_AND_SIDES;
+		Vector<Terrain> terrains;
+	};
+	Vector<TerrainSet> terrain_sets;
+
+	// Navigation
+	struct Navigationlayer {
+		uint32_t layers = 1;
+	};
+	Vector<Navigationlayer> navigation_layers;
+
+	// CustomData
+	struct CustomDataLayer {
+		String name;
+		Variant::Type type = Variant::NIL;
+	};
+	Vector<CustomDataLayer> custom_data_layers;
+	Map<String, int> custom_data_layers_by_name;
+
+	// Per Atlas source data.
+	Map<int, Ref<TileSetSource>> sources;
+	Vector<int> source_ids;
+	int next_source_id = 0;
+	// ---------------------
+
+	// Plugins themselves.
+	Vector<TileSetPlugin *> tile_set_plugins_vector;
+
+	void _compute_next_source_id();
+	void _source_changed();
+
+protected:
 	static void _bind_methods();
 
+public:
+	// --- Plugins ---
+	Vector<TileSetPlugin *> get_tile_set_atlas_plugins() const;
+
+	// --- Accessors for TileSet data ---
+
+	// -- Shape and layout --
+	void set_tile_shape(TileShape p_shape);
+	TileShape get_tile_shape() const;
+	void set_tile_layout(TileLayout p_layout);
+	TileLayout get_tile_layout() const;
+	void set_tile_offset_axis(TileOffsetAxis p_alignment);
+	TileOffsetAxis get_tile_offset_axis() const;
+	void set_tile_size(Size2i p_size);
+	Size2i get_tile_size() const;
+	void set_tile_skew(Vector2 p_skew);
+	Vector2 get_tile_skew() const;
+
+	// -- Sources management --
+	int get_next_source_id() const;
+	int get_source_count() const;
+	int get_source_id(int p_index) const;
+	int add_source(Ref<TileSetAtlasSource> p_tile_atlas_source, int p_source_id_override = -1);
+	void set_source_id(int p_source_id, int p_new_id);
+	void remove_source(int p_source_id);
+	bool has_source(int p_source_id) const;
+	Ref<TileSetSource> get_source(int p_source_id) const;
+
+	// Rendering
+	void set_y_sorting(bool p_y_sort);
+	bool is_y_sorting() const;
+
+	void set_uv_clipping(bool p_uv_clipping);
+	bool is_uv_clipping() const;
+
+	void set_occlusion_layers_count(int p_occlusion_layers_count);
+	int get_occlusion_layers_count() const;
+	void set_occlusion_layer_light_mask(int p_layer_index, int p_light_mask);
+	int get_occlusion_layer_light_mask(int p_layer_index) const;
+	void set_occlusion_layer_sdf_collision(int p_layer_index, int p_sdf_collision);
+	bool get_occlusion_layer_sdf_collision(int p_layer_index) const;
+
+	// Physics
+	void set_physics_layers_count(int p_physics_layers_count);
+	int get_physics_layers_count() const;
+	void set_physics_layer_collision_layer(int p_layer_index, uint32_t p_layer);
+	uint32_t get_physics_layer_collision_layer(int p_layer_index) const;
+	void set_physics_layer_collision_mask(int p_layer_index, uint32_t p_mask);
+	uint32_t get_physics_layer_collision_mask(int p_layer_index) const;
+	void set_physics_layer_physics_material(int p_layer_index, Ref<PhysicsMaterial> p_physics_material);
+	Ref<PhysicsMaterial> get_physics_layer_physics_material(int p_layer_index) const;
+
+	// Terrains
+	void set_terrain_sets_count(int p_terrains_sets_count);
+	int get_terrain_sets_count() const;
+	void set_terrain_set_mode(int p_terrain_set, TerrainMode p_terrain_mode);
+	TerrainMode get_terrain_set_mode(int p_terrain_set) const;
+	void set_terrains_count(int p_terrain_set, int p_terrains_count);
+	int get_terrains_count(int p_terrain_set) const;
+	void set_terrain_name(int p_terrain_set, int p_terrain_index, String p_name);
+	String get_terrain_name(int p_terrain_set, int p_terrain_index) const;
+	void set_terrain_color(int p_terrain_set, int p_terrain_index, Color p_color);
+	Color get_terrain_color(int p_terrain_set, int p_terrain_index) const;
+	bool is_valid_peering_bit_terrain(int p_terrain_set, TileSet::CellNeighbor p_peering_bit) const;
+
+	// Navigation
+	void set_navigation_layers_count(int p_navigation_layers_count);
+	int get_navigation_layers_count() const;
+	void set_navigation_layer_layers(int p_layer_index, uint32_t p_layers);
+	uint32_t get_navigation_layer_layers(int p_layer_index) const;
+
+	// Custom data
+	void set_custom_data_layers_count(int p_custom_data_layers_count);
+	int get_custom_data_layers_count() const;
+	int get_custom_data_layer_by_name(String p_value) const;
+	void set_custom_data_name(int p_layer_id, String p_value);
+	String get_custom_data_name(int p_layer_id) const;
+	void set_custom_data_type(int p_layer_id, Variant::Type p_value);
+	Variant::Type get_custom_data_type(int p_layer_id) const;
+
+	// Helpers
+	void draw_tile_shape(CanvasItem *p_canvas_item, Rect2 p_region, Color p_color, bool p_filled = false, Ref<Texture2D> p_texture = Ref<Texture2D>());
+
 	virtual void reset_state() override;
 
+	TileSet();
+	~TileSet();
+};
+
+class TileSetSource : public Resource {
+	GDCLASS(TileSetSource, Resource);
+
+protected:
+	const TileSet *tile_set = nullptr;
+
 public:
-	void create_tile(int p_id);
+	// Not exposed.
+	virtual void set_tile_set(const TileSet *p_tile_set);
+	virtual void notify_tile_data_properties_should_change(){};
+	virtual void reset_state() override{};
+
+	// Tiles.
+	virtual int get_tiles_count() const = 0;
+	virtual Vector2i get_tile_id(int tile_index) const = 0;
+	virtual bool has_tile(Vector2i p_atlas_coords) const = 0;
+
+	// Alternative tiles.
+	virtual int get_alternative_tiles_count(const Vector2i p_atlas_coords) const = 0;
+	virtual int get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const = 0;
+	virtual bool has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const = 0;
+};
 
-	void autotile_set_bitmask_mode(int p_id, BitmaskMode p_mode);
-	BitmaskMode autotile_get_bitmask_mode(int p_id) const;
+class TileSetAtlasSource : public TileSetSource {
+	GDCLASS(TileSetAtlasSource, TileSetSource);
 
-	void tile_set_name(int p_id, const String &p_name);
-	String tile_get_name(int p_id) const;
+public:
+	static const Vector2i INVALID_ATLAS_COORDS; // Vector2i(-1, -1);
+	static const int INVALID_TILE_ALTERNATIVE; // -1;
+
+	struct TileAlternativesData {
+		Vector2i size_in_atlas = Vector2i(1, 1);
+		Vector2i texture_offset;
+		Map<int, TileData *> alternatives;
+		Vector<int> alternatives_ids;
+		int next_alternative_id = 1;
+	};
 
-	void tile_set_texture(int p_id, const Ref<Texture2D> &p_texture);
-	Ref<Texture2D> tile_get_texture(int p_id) const;
+private:
+	Ref<Texture2D> texture;
+	Vector2i margins;
+	Vector2i separation;
+	Size2i texture_region_size = Size2i(16, 16);
 
-	void tile_set_texture_offset(int p_id, const Vector2 &p_offset);
-	Vector2 tile_get_texture_offset(int p_id) const;
+	Map<Vector2i, TileAlternativesData> tiles;
+	Vector<Vector2i> tiles_ids;
+	Map<Vector2i, Vector2i> _coords_mapping_cache; // Maps any coordinate to the including tile
 
-	void tile_set_region(int p_id, const Rect2 &p_region);
-	Rect2 tile_get_region(int p_id) const;
+	TileData *_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile);
+	const TileData *_get_atlas_tile_data(Vector2i p_atlas_coords, int p_alternative_tile) const;
 
-	void tile_set_tile_mode(int p_id, TileMode p_tile_mode);
-	TileMode tile_get_tile_mode(int p_id) const;
+	void _compute_next_alternative_id(const Vector2i p_atlas_coords);
 
-	void autotile_set_icon_coordinate(int p_id, Vector2 coord);
-	Vector2 autotile_get_icon_coordinate(int p_id) const;
+protected:
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
-	void autotile_set_spacing(int p_id, int p_spacing);
-	int autotile_get_spacing(int p_id) const;
+	static void _bind_methods();
 
-	void autotile_set_size(int p_id, Size2 p_size);
-	Size2 autotile_get_size(int p_id) const;
+public:
+	// Not exposed.
+	virtual void set_tile_set(const TileSet *p_tile_set) override;
+	virtual void notify_tile_data_properties_should_change() override;
+	virtual void reset_state() override;
 
-	void autotile_clear_bitmask_map(int p_id);
-	void autotile_set_subtile_priority(int p_id, const Vector2 &p_coord, int p_priority);
-	int autotile_get_subtile_priority(int p_id, const Vector2 &p_coord);
-	const Map<Vector2, int> &autotile_get_priority_map(int p_id) const;
+	// Base properties.
+	void set_texture(Ref<Texture2D> p_texture);
+	Ref<Texture2D> get_texture() const;
+	void set_margins(Vector2i p_margins);
+	Vector2i get_margins() const;
+	void set_separation(Vector2i p_separation);
+	Vector2i get_separation() const;
+	void set_texture_region_size(Vector2i p_tile_size);
+	Vector2i get_texture_region_size() const;
+
+	// Base tiles.
+	void create_tile(const Vector2i p_atlas_coords, const Vector2i p_size = Vector2i(1, 1)); // Create a tile if it does not exists, or add alternative tile if it does.
+	void remove_tile(Vector2i p_atlas_coords); // Remove a tile. If p_tile_key.alternative_tile if different from 0, remove the alternative
+	virtual bool has_tile(Vector2i p_atlas_coords) const override;
+	bool can_move_tile_in_atlas(Vector2i p_atlas_coords, Vector2i p_new_atlas_coords = INVALID_ATLAS_COORDS, Vector2i p_new_size = Vector2i(-1, -1)) const;
+	void move_tile_in_atlas(Vector2i p_atlas_coords, Vector2i p_new_atlas_coords = INVALID_ATLAS_COORDS, Vector2i p_new_size = Vector2i(-1, -1));
+	Vector2i get_tile_size_in_atlas(Vector2i p_atlas_coords) const;
+
+	virtual int get_tiles_count() const override;
+	virtual Vector2i get_tile_id(int p_index) const override;
+
+	Vector2i get_tile_at_coords(Vector2i p_atlas_coords) const;
+
+	// Alternative tiles.
+	int create_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_id_override = -1);
+	void remove_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile);
+	void set_alternative_tile_id(const Vector2i p_atlas_coords, int p_alternative_tile, int p_new_id);
+	virtual bool has_alternative_tile(const Vector2i p_atlas_coords, int p_alternative_tile) const override;
+	int get_next_alternative_tile_id(const Vector2i p_atlas_coords) const;
+
+	virtual int get_alternative_tiles_count(const Vector2i p_atlas_coords) const override;
+	virtual int get_alternative_tile_id(const Vector2i p_atlas_coords, int p_index) const override;
+
+	// Get data associated to a tile.
+	Object *get_tile_data(const Vector2i p_atlas_coords, int p_alternative_tile) const;
+
+	// Helpers.
+	Vector2i get_atlas_grid_size() const;
+	bool has_tiles_outside_texture();
+	void clear_tiles_outside_texture();
+	Rect2i get_tile_texture_region(Vector2i p_atlas_coords) const;
+	Vector2i get_tile_effective_texture_offset(Vector2i p_atlas_coords, int p_alternative_tile) const;
+
+	~TileSetAtlasSource();
+};
 
-	void autotile_set_z_index(int p_id, const Vector2 &p_coord, int p_z_index);
-	int autotile_get_z_index(int p_id, const Vector2 &p_coord);
-	const Map<Vector2, int> &autotile_get_z_index_map(int p_id) const;
+class TileData : public Object {
+	GDCLASS(TileData, Object);
 
-	void autotile_set_bitmask(int p_id, Vector2 p_coord, uint32_t p_flag);
-	uint32_t autotile_get_bitmask(int p_id, Vector2 p_coord);
-	const Map<Vector2, uint32_t> &autotile_get_bitmask_map(int p_id);
-	Vector2 autotile_get_subtile_for_bitmask(int p_id, uint16_t p_bitmask, const Node *p_tilemap_node = nullptr, const Vector2 &p_tile_location = Vector2());
-	Vector2 atlastile_get_subtile_by_priority(int p_id, const Node *p_tilemap_node = nullptr, const Vector2 &p_tile_location = Vector2());
+private:
+	const TileSet *tile_set = nullptr;
+	bool allow_transform = true;
+
+	// Rendering
+	bool flip_h = false;
+	bool flip_v = false;
+	bool transpose = false;
+	Vector2i tex_offset = Vector2i();
+	Ref<ShaderMaterial> material = Ref<ShaderMaterial>();
+	Color modulate = Color(1.0, 1.0, 1.0, 1.0);
+	int z_index = 0;
+	Vector2i y_sort_origin = Vector2i();
+	Vector<Ref<OccluderPolygon2D>> occluders;
+
+	// Physics
+	struct PhysicsLayerTileData {
+		struct ShapeTileData {
+			Ref<Shape2D> shape = Ref<Shape2D>();
+			bool one_way = false;
+			float one_way_margin = 1.0;
+		};
+
+		Vector<ShapeTileData> shapes;
+	};
+	Vector<PhysicsLayerTileData> physics;
+	// TODO add support for areas.
 
-	void tile_set_shape(int p_id, int p_shape_id, const Ref<Shape2D> &p_shape);
-	Ref<Shape2D> tile_get_shape(int p_id, int p_shape_id) const;
+	// Terrain
+	int terrain_set = -1;
+	int terrain_peering_bits[16] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 
-	void tile_set_shape_transform(int p_id, int p_shape_id, const Transform2D &p_offset);
-	Transform2D tile_get_shape_transform(int p_id, int p_shape_id) const;
+	// Navigation
+	Vector<Ref<NavigationPolygon>> navigation;
 
-	void tile_set_shape_offset(int p_id, int p_shape_id, const Vector2 &p_offset);
-	Vector2 tile_get_shape_offset(int p_id, int p_shape_id) const;
+	// Misc
+	double probability = 1.0;
 
-	void tile_set_shape_one_way(int p_id, int p_shape_id, bool p_one_way);
-	bool tile_get_shape_one_way(int p_id, int p_shape_id) const;
+	// Custom data
+	Vector<Variant> custom_data;
 
-	void tile_set_shape_one_way_margin(int p_id, int p_shape_id, float p_margin);
-	float tile_get_shape_one_way_margin(int p_id, int p_shape_id) const;
+protected:
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
+	static void _bind_methods();
 
-	void tile_clear_shapes(int p_id);
-	void tile_add_shape(int p_id, const Ref<Shape2D> &p_shape, const Transform2D &p_transform, bool p_one_way = false, const Vector2 &p_autotile_coord = Vector2());
-	int tile_get_shape_count(int p_id) const;
+public:
+	// Not exposed.
+	void set_tile_set(const TileSet *p_tile_set);
+	void notify_tile_data_properties_should_change();
+	void reset_state();
+	void set_allow_transform(bool p_allow_transform);
+	bool is_allowing_transform() const;
+
+	// Rendering
+	void set_flip_h(bool p_flip_h);
+	bool get_flip_h() const;
+	void set_flip_v(bool p_flip_v);
+	bool get_flip_v() const;
+	void set_transpose(bool p_transpose);
+	bool get_transpose() const;
+
+	void set_texture_offset(Vector2i p_texture_offset);
+	Vector2i get_texture_offset() const;
+	void tile_set_material(Ref<ShaderMaterial> p_material);
+	Ref<ShaderMaterial> tile_get_material() const;
+	void set_modulate(Color p_modulate);
+	Color get_modulate() const;
+	void set_z_index(int p_z_index);
+	int get_z_index() const;
+	void set_y_sort_origin(Vector2i p_y_sort_origin);
+	Vector2i get_y_sort_origin() const;
+
+	void set_occluder(int p_layer_id, Ref<OccluderPolygon2D> p_occluder_polygon);
+	Ref<OccluderPolygon2D> get_occluder(int p_layer_id) const;
+
+	// Physics
+	int get_collision_shapes_count(int p_layer_id) const;
+	void set_collision_shapes_count(int p_layer_id, int p_shapes_count);
+	void add_collision_shape(int p_layer_id);
+	void remove_collision_shape(int p_layer_id, int p_shape_index);
+	void set_collision_shape_shape(int p_layer_id, int p_shape_index, Ref<Shape2D> p_shape);
+	Ref<Shape2D> get_collision_shape_shape(int p_layer_id, int p_shape_index) const;
+	void set_collision_shape_one_way(int p_layer_id, int p_shape_index, bool p_one_way);
+	bool is_collision_shape_one_way(int p_layer_id, int p_shape_index) const;
+	void set_collision_shape_one_way_margin(int p_layer_id, int p_shape_index, float p_one_way_margin);
+	float get_collision_shape_one_way_margin(int p_layer_id, int p_shape_index) const;
+
+	// Terrain
+	void set_terrain_set(int p_terrain_id);
+	int get_terrain_set() const;
+	void set_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit, int p_terrain_id);
+	int get_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const;
+	bool is_valid_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const;
+
+	// Navigation
+	void set_navigation_polygon(int p_layer_id, Ref<NavigationPolygon> p_navigation_polygon);
+	Ref<NavigationPolygon> get_navigation_polygon(int p_layer_id) const;
+
+	// Misc
+	void set_probability(float p_probability);
+	float get_probability() const;
+
+	// Custom data.
+	void set_custom_data(String p_layer_name, Variant p_value);
+	Variant get_custom_data(String p_layer_name) const;
+	void set_custom_data_by_layer_id(int p_layer_id, Variant p_value);
+	Variant get_custom_data_by_layer_id(int p_layer_id) const;
+};
 
-	void tile_set_shapes(int p_id, const Vector<ShapeData> &p_shapes);
-	Vector<ShapeData> tile_get_shapes(int p_id) const;
+#include "scene/2d/tile_map.h"
 
-	void tile_set_material(int p_id, const Ref<ShaderMaterial> &p_material);
-	Ref<ShaderMaterial> tile_get_material(int p_id) const;
+class TileSetPlugin : public Object {
+	GDCLASS(TileSetPlugin, Object);
 
-	void tile_set_modulate(int p_id, const Color &p_modulate);
-	Color tile_get_modulate(int p_id) const;
+public:
+	// Tilemap updates.
+	virtual void tilemap_notification(TileMap *p_tile_map, int p_what){};
+	virtual void update_dirty_quadrants(TileMap *p_tile_map, SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list){};
+	virtual void create_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant){};
+	virtual void cleanup_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant){};
 
-	void tile_set_occluder_offset(int p_id, const Vector2 &p_offset);
-	Vector2 tile_get_occluder_offset(int p_id) const;
+	virtual void draw_quadrant_debug(TileMap *p_tile_map, TileMapQuadrant *p_quadrant){};
+};
 
-	void tile_set_light_occluder(int p_id, const Ref<OccluderPolygon2D> &p_light_occluder);
-	Ref<OccluderPolygon2D> tile_get_light_occluder(int p_id) const;
+class TileSetAtlasPluginRendering : public TileSetPlugin {
+	GDCLASS(TileSetAtlasPluginRendering, TileSetPlugin);
 
-	void autotile_set_light_occluder(int p_id, const Ref<OccluderPolygon2D> &p_light_occluder, const Vector2 &p_coord);
-	Ref<OccluderPolygon2D> autotile_get_light_occluder(int p_id, const Vector2 &p_coord) const;
-	const Map<Vector2, Ref<OccluderPolygon2D>> &autotile_get_light_oclusion_map(int p_id) const;
+private:
+	static constexpr float fp_adjust = 0.00001;
+	bool quadrant_order_dirty = false;
 
-	void tile_set_navigation_polygon_offset(int p_id, const Vector2 &p_offset);
-	Vector2 tile_get_navigation_polygon_offset(int p_id) const;
+public:
+	// Tilemap updates
+	virtual void tilemap_notification(TileMap *p_tile_map, int p_what) override;
+	virtual void update_dirty_quadrants(TileMap *p_tile_map, SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) override;
+	virtual void create_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
+	virtual void cleanup_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
+
+	// Other.
+	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));
+};
 
-	void tile_set_navigation_polygon(int p_id, const Ref<NavigationPolygon> &p_navigation_polygon);
-	Ref<NavigationPolygon> tile_get_navigation_polygon(int p_id) const;
+class TileSetAtlasPluginTerrain : public TileSetPlugin {
+	GDCLASS(TileSetAtlasPluginTerrain, TileSetPlugin);
 
-	void autotile_set_navigation_polygon(int p_id, const Ref<NavigationPolygon> &p_navigation_polygon, const Vector2 &p_coord);
-	Ref<NavigationPolygon> autotile_get_navigation_polygon(int p_id, const Vector2 &p_coord) const;
-	const Map<Vector2, Ref<NavigationPolygon>> &autotile_get_navigation_map(int p_id) const;
+private:
+	static void _draw_square_corner_or_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit);
+	static void _draw_square_corner_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit);
+	static void _draw_square_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit);
 
-	void tile_set_z_index(int p_id, int p_z_index);
-	int tile_get_z_index(int p_id) const;
+	static void _draw_isometric_corner_or_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit);
+	static void _draw_isometric_corner_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit);
+	static void _draw_isometric_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit);
 
-	void remove_tile(int p_id);
+	static void _draw_half_offset_corner_or_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis);
+	static void _draw_half_offset_corner_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis);
+	static void _draw_half_offset_side_terrain_bit(CanvasItem *p_canvas_item, Color p_color, Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis);
 
-	bool has_tile(int p_id) const;
+public:
+	//virtual void tilemap_notification(const TileMap * p_tile_map, int p_what);
 
-	bool is_tile_bound(int p_drawn_id, int p_neighbor_id);
+	static void draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform, TileSet *p_tile_set, const TileData *p_tile_data);
+};
 
-	int find_tile_by_name(const String &p_name) const;
-	void get_tile_list(List<int> *p_tiles) const;
+class TileSetAtlasPluginPhysics : public TileSetPlugin {
+	GDCLASS(TileSetAtlasPluginPhysics, TileSetPlugin);
 
-	void clear();
+public:
+	// Tilemap updates
+	virtual void tilemap_notification(TileMap *p_tile_map, int p_what) override;
+	virtual void update_dirty_quadrants(TileMap *p_tile_map, SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) override;
+	virtual void create_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
+	virtual void cleanup_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
+	virtual void draw_quadrant_debug(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
+};
 
-	int get_last_unused_tile_id() const;
+class TileSetAtlasPluginNavigation : public TileSetPlugin {
+	GDCLASS(TileSetAtlasPluginNavigation, TileSetPlugin);
 
-	TileSet();
+public:
+	// Tilemap updates
+	virtual void tilemap_notification(TileMap *p_tile_map, int p_what) override;
+	virtual void update_dirty_quadrants(TileMap *p_tile_map, SelfList<TileMapQuadrant>::List &r_dirty_quadrant_list) override;
+	//virtual void create_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
+	virtual void cleanup_quadrant(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
+	virtual void draw_quadrant_debug(TileMap *p_tile_map, TileMapQuadrant *p_quadrant) override;
 };
 
-VARIANT_ENUM_CAST(TileSet::AutotileBindings);
-VARIANT_ENUM_CAST(TileSet::BitmaskMode);
-VARIANT_ENUM_CAST(TileSet::TileMode);
+VARIANT_ENUM_CAST(TileSet::CellNeighbor);
+VARIANT_ENUM_CAST(TileSet::TerrainMode);
+VARIANT_ENUM_CAST(TileSet::TileShape);
+VARIANT_ENUM_CAST(TileSet::TileLayout);
+VARIANT_ENUM_CAST(TileSet::TileOffsetAxis);
 
 #endif // TILE_SET_H