diff --git a/modules/layered_tile_map/doc_classes/LayeredTileSetScenesCollectionSource.xml b/modules/layered_tile_map/doc_classes/LayeredTileSetScenesCollectionSource.xml
index f6c56c10f..786db2288 100644
--- a/modules/layered_tile_map/doc_classes/LayeredTileSetScenesCollectionSource.xml
+++ b/modules/layered_tile_map/doc_classes/LayeredTileSetScenesCollectionSource.xml
@@ -4,8 +4,8 @@
Exposes a set of scenes as tiles for a [LayeredTileSet] resource.
- When placed on a [LayeredTileMap], tiles from [LayeredTileSetScenesCollectionSource] will automatically instantiate an associated scene at the cell's position in the LayeredTileMap.
- Scenes are instantiated as children of the [LayeredTileMap] when it enters the tree. If you add/remove a scene tile in the [LayeredTileMap] that is already inside the tree, the [LayeredTileMap] will automatically instantiate/free the scene accordingly.
+ When placed on a [LayeredTileMap], tiles from [LayeredTileSetScenesCollectionSource] will automatically instance an associated scene at the cell's position in the LayeredTileMap.
+ Scenes are instanced as children of the [LayeredTileMap] when it enters the tree. If you add/remove a scene tile in the [LayeredTileMap] that is already inside the tree, the [LayeredTileMap] will automatically instance/free the scene accordingly.
diff --git a/modules/layered_tile_map/editor/atlas_merging_dialog.cpp b/modules/layered_tile_map/editor/atlas_merging_dialog.cpp
index 82866a9fd..35e73a4b5 100644
--- a/modules/layered_tile_map/editor/atlas_merging_dialog.cpp
+++ b/modules/layered_tile_map/editor/atlas_merging_dialog.cpp
@@ -44,7 +44,7 @@ void AtlasMergingDialog::_property_changed(const StringName &p_property, const V
}
void AtlasMergingDialog::_generate_merged(const Vector> &p_atlas_sources, int p_max_columns) {
- merged.instantiate();
+ merged.instance();
merged_mapping.clear();
if (p_atlas_sources.size() >= 2) {
diff --git a/modules/layered_tile_map/editor/layered_tile_atlas_view.cpp b/modules/layered_tile_map/editor/layered_tile_atlas_view.cpp
index 066e1a9d4..87103ec3b 100644
--- a/modules/layered_tile_map/editor/layered_tile_atlas_view.cpp
+++ b/modules/layered_tile_map/editor/layered_tile_atlas_view.cpp
@@ -593,7 +593,7 @@ void LayeredTileAtlasView::_notification(int p_what) {
}
void LayeredTileAtlasView::_bind_methods() {
- ADD_SIGNAL(MethodInfo("transform_changed", PropertyInfo(Variant::FLOAT, "zoom"), PropertyInfo(Variant::VECTOR2, "scroll")));
+ ADD_SIGNAL(MethodInfo("transform_changed", PropertyInfo(Variant::REAL, "zoom"), PropertyInfo(Variant::VECTOR2, "scroll")));
}
LayeredTileAtlasView::LayeredTileAtlasView() {
@@ -622,7 +622,7 @@ LayeredTileAtlasView::LayeredTileAtlasView() {
button_center_view->set_tooltip_text(TTR("Center View"));
add_child(button_center_view);
- panner.instantiate();
+ panner.instance();
panner->set_callbacks(callable_mp(this, &LayeredTileAtlasView::_pan_callback), callable_mp(this, &LayeredTileAtlasView::_zoom_callback));
panner->set_enable_rmb(true);
diff --git a/modules/layered_tile_map/editor/layered_tile_data_editors.cpp b/modules/layered_tile_map/editor/layered_tile_data_editors.cpp
index ff8879d4c..8cf41bfba 100644
--- a/modules/layered_tile_map/editor/layered_tile_data_editors.cpp
+++ b/modules/layered_tile_map/editor/layered_tile_data_editors.cpp
@@ -86,11 +86,11 @@ void LayeredTileDataEditor::_bind_methods() {
void LayeredTileDataEditor::set_tile_set(Ref p_tile_set) {
if (tile_set.is_valid()) {
- tile_set->disconnect_changed(callable_mp(this, &LayeredTileDataEditor::_tile_set_changed_plan_update));
+ tile_set->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileDataEditor::_tile_set_changed_plan_update));
}
tile_set = p_tile_set;
if (tile_set.is_valid()) {
- tile_set->connect_changed(callable_mp(this, &LayeredTileDataEditor::_tile_set_changed_plan_update));
+ tile_set->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileDataEditor::_tile_set_changed_plan_update));
}
_tile_set_changed_plan_update();
}
@@ -405,7 +405,7 @@ void GenericTilePolygonEditor::_grab_polygon_segment_point(Vector2 p_pos, const
const Vector &polygon = polygons[i];
for (int j = 0; j < polygon.size(); j++) {
Vector2 segment[2] = { polygon[j], polygon[(j + 1) % polygon.size()] };
- Vector2 closest_point = Geometry2D::get_closest_point_to_segment(point, segment);
+ Vector2 closest_point = Geometry::get_closest_point_to_segment(point, segment);
float distance = closest_point.distance_to(point);
if (distance < grab_threshold / editor_zoom_widget->get_zoom() && distance < closest_distance) {
r_polygon_index = i;
@@ -441,7 +441,7 @@ void GenericTilePolygonEditor::_snap_to_tile_shape(Point2 &r_point, float &r_cur
if (!snapped) {
for (int i = 0; i < polygon.size(); i++) {
Point2 segment[2] = { polygon[i], polygon[(i + 1) % polygon.size()] };
- Point2 point = Geometry2D::get_closest_point_to_segment(r_point, segment);
+ Point2 point = Geometry::get_closest_point_to_segment(r_point, segment);
float distance = r_point.distance_to(point);
if (distance < p_snap_dist && distance < r_current_snapped_dist) {
snapped_point = point;
@@ -849,7 +849,7 @@ GenericTilePolygonEditor::GenericTilePolygonEditor() {
toolbar = memnew(HBoxContainer);
add_child(toolbar);
- tools_button_group.instantiate();
+ tools_button_group.instance();
button_expand = memnew(Button);
button_expand->set_theme_type_variation("FlatButton");
@@ -1041,7 +1041,7 @@ void TileDataDefaultEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVie
Ref mm = p_event;
if (mm.is_valid()) {
if (drag_type == DRAG_TYPE_PAINT) {
- Vector line = Geometry2D::bresenham_line(p_tile_atlas_view->get_atlas_tile_coords_at_pos(drag_last_pos, true), p_tile_atlas_view->get_atlas_tile_coords_at_pos(mm->get_position(), true));
+ Vector line = Geometry::bresenham_line(p_tile_atlas_view->get_atlas_tile_coords_at_pos(drag_last_pos, true), p_tile_atlas_view->get_atlas_tile_coords_at_pos(mm->get_position(), true));
for (int i = 0; i < line.size(); i++) {
Vector2i coords = p_tile_set_atlas_source->get_tile_at_coords(line[i]);
if (coords != LayeredTileSetSource::INVALID_ATLAS_COORDS) {
@@ -1219,7 +1219,7 @@ void TileDataDefaultEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform2
String text;
// Round floating point precision to 2 digits, as tiles don't have that much space.
switch (value.get_type()) {
- case Variant::FLOAT:
+ case Variant::REAL:
text = vformat("%.2f", value);
break;
case Variant::VECTOR2:
@@ -1240,7 +1240,7 @@ void TileDataDefaultEditor::draw_over_tile(CanvasItem *p_canvas_item, Transform2
color = selection_color;
} else if (is_visible_in_tree()) {
Variant painted_value = _get_painted_value();
- bool equal = (painted_value.get_type() == Variant::FLOAT && value.get_type() == Variant::FLOAT) ? Math::is_equal_approx(float(painted_value), float(value)) : painted_value == value;
+ bool equal = (painted_value.get_type() == Variant::REAL && value.get_type() == Variant::REAL) ? Math::is_equal_approx(float(painted_value), float(value)) : painted_value == value;
if (equal) {
color = Color(0.7, 0.7, 0.7);
}
@@ -1430,7 +1430,7 @@ void TileDataOcclusionShapeEditor::draw_over_tile(CanvasItem *p_canvas_item, Tra
Variant TileDataOcclusionShapeEditor::_get_painted_value() {
Ref occluder_polygon;
if (polygon_editor->get_polygon_count() >= 1) {
- occluder_polygon.instantiate();
+ occluder_polygon.instance();
occluder_polygon->set_polygon(polygon_editor->get_polygon(0));
}
return occluder_polygon;
@@ -1531,7 +1531,7 @@ void TileDataCollisionEditor::_polygons_changed() {
}
if (!property_editors.has(one_way_margin_property)) {
- EditorProperty *one_way_margin_property_editor = EditorInspectorDefaultPlugin::get_editor_for_property(dummy_object, Variant::FLOAT, one_way_margin_property, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT);
+ EditorProperty *one_way_margin_property_editor = EditorInspectorDefaultPlugin::get_editor_for_property(dummy_object, Variant::REAL, one_way_margin_property, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT);
one_way_margin_property_editor->set_object_and_property(dummy_object, one_way_margin_property);
one_way_margin_property_editor->set_label(one_way_margin_property);
one_way_margin_property_editor->connect("property_changed", callable_mp(this, &TileDataCollisionEditor::_property_value_changed).unbind(1));
@@ -1707,7 +1707,7 @@ TileDataCollisionEditor::TileDataCollisionEditor() {
add_child(linear_velocity_editor);
property_editors["linear_velocity"] = linear_velocity_editor;
- EditorProperty *angular_velocity_editor = EditorInspectorDefaultPlugin::get_editor_for_property(dummy_object, Variant::FLOAT, "angular_velocity", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT);
+ EditorProperty *angular_velocity_editor = EditorInspectorDefaultPlugin::get_editor_for_property(dummy_object, Variant::REAL, "angular_velocity", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT);
angular_velocity_editor->set_object_and_property(dummy_object, "angular_velocity");
angular_velocity_editor->set_label("angular_velocity");
angular_velocity_editor->connect("property_changed", callable_mp(this, &TileDataCollisionEditor::_property_value_changed).unbind(1));
@@ -1864,7 +1864,7 @@ void TileDataTerrainsEditor::forward_draw_over_atlas(LayeredTileAtlasView *p_til
color.push_back(Color(1.0, 1.0, 1.0, 0.5));
Vector polygon = tile_set->get_terrain_polygon(terrain_set);
- if (Geometry2D::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
+ if (Geometry::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
p_canvas_item->draw_set_transform_matrix(p_transform * xform);
p_canvas_item->draw_polygon(polygon, color);
}
@@ -1872,7 +1872,7 @@ void TileDataTerrainsEditor::forward_draw_over_atlas(LayeredTileAtlasView *p_til
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(i);
if (tile_set->is_valid_terrain_peering_bit(terrain_set, bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(terrain_set, bit);
- if (Geometry2D::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
+ if (Geometry::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
p_canvas_item->draw_set_transform_matrix(p_transform * xform);
p_canvas_item->draw_polygon(polygon, color);
}
@@ -2003,7 +2003,7 @@ void TileDataTerrainsEditor::forward_draw_over_atlas(LayeredTileAtlasView *p_til
for (int j = 0; j < polygon.size(); j++) {
polygon.write[j] += position;
}
- if (!Geometry2D::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
+ if (!Geometry::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
// Draw terrain.
p_canvas_item->draw_polygon(polygon, color);
}
@@ -2015,7 +2015,7 @@ void TileDataTerrainsEditor::forward_draw_over_atlas(LayeredTileAtlasView *p_til
for (int j = 0; j < polygon.size(); j++) {
polygon.write[j] += position;
}
- if (!Geometry2D::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
+ if (!Geometry::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
// Draw bit.
p_canvas_item->draw_polygon(polygon, color);
}
@@ -2053,7 +2053,7 @@ void TileDataTerrainsEditor::forward_draw_over_alternatives(LayeredTileAtlasView
color.push_back(Color(1.0, 1.0, 1.0, 0.5));
Vector polygon = tile_set->get_terrain_polygon(terrain_set);
- if (Geometry2D::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
+ if (Geometry::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
p_canvas_item->draw_set_transform_matrix(p_transform * xform);
p_canvas_item->draw_polygon(polygon, color);
}
@@ -2062,7 +2062,7 @@ void TileDataTerrainsEditor::forward_draw_over_alternatives(LayeredTileAtlasView
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(i);
if (tile_set->is_valid_terrain_peering_bit(terrain_set, bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(terrain_set, bit);
- if (Geometry2D::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
+ if (Geometry::is_point_in_polygon(xform.affine_inverse().xform(mouse_pos), polygon)) {
p_canvas_item->draw_set_transform_matrix(p_transform * xform);
p_canvas_item->draw_polygon(polygon, color);
}
@@ -2120,7 +2120,7 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVi
Ref mm = p_event;
if (mm.is_valid()) {
if (drag_type == DRAG_TYPE_PAINT_TERRAIN_SET) {
- Vector line = Geometry2D::bresenham_line(p_tile_atlas_view->get_atlas_tile_coords_at_pos(drag_last_pos, true), p_tile_atlas_view->get_atlas_tile_coords_at_pos(mm->get_position(), true));
+ Vector line = Geometry::bresenham_line(p_tile_atlas_view->get_atlas_tile_coords_at_pos(drag_last_pos, true), p_tile_atlas_view->get_atlas_tile_coords_at_pos(mm->get_position(), true));
for (int i = 0; i < line.size(); i++) {
Vector2i coords = p_tile_set_atlas_source->get_tile_at_coords(line[i]);
if (coords != LayeredTileSetSource::INVALID_ATLAS_COORDS) {
@@ -2154,7 +2154,7 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVi
} else if (drag_type == DRAG_TYPE_PAINT_TERRAIN_BITS) {
int terrain_set = Dictionary(drag_painted_value)["terrain_set"];
int terrain = Dictionary(drag_painted_value)["terrain"];
- Vector line = Geometry2D::bresenham_line(p_tile_atlas_view->get_atlas_tile_coords_at_pos(drag_last_pos, true), p_tile_atlas_view->get_atlas_tile_coords_at_pos(mm->get_position(), true));
+ Vector line = Geometry::bresenham_line(p_tile_atlas_view->get_atlas_tile_coords_at_pos(drag_last_pos, true), p_tile_atlas_view->get_atlas_tile_coords_at_pos(mm->get_position(), true));
for (int i = 0; i < line.size(); i++) {
Vector2i coords = p_tile_set_atlas_source->get_tile_at_coords(line[i]);
if (coords != LayeredTileSetSource::INVALID_ATLAS_COORDS) {
@@ -2184,14 +2184,14 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVi
Vector2i position = texture_region.get_center() + tile_data->get_texture_origin();
Vector polygon = tile_set->get_terrain_polygon(tile_data->get_terrain_set());
- if (Geometry2D::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
+ if (Geometry::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
tile_data->set_terrain(terrain);
}
for (int j = 0; j < LayeredTileSet::CELL_NEIGHBOR_MAX; j++) {
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(j);
if (tile_data->is_valid_terrain_peering_bit(bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(tile_data->get_terrain_set(), bit);
- if (Geometry2D::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
+ if (Geometry::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
tile_data->set_terrain_peering_bit(bit, terrain);
}
}
@@ -2220,14 +2220,14 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVi
dummy_object->set("terrain", -1);
Vector polygon = tile_set->get_terrain_polygon(terrain_set);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
dummy_object->set("terrain", tile_data->get_terrain());
}
for (int i = 0; i < LayeredTileSet::CELL_NEIGHBOR_MAX; i++) {
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(i);
if (tile_set->is_valid_terrain_peering_bit(terrain_set, bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(terrain_set, bit);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
dummy_object->set("terrain", tile_data->get_terrain_peering_bit(bit));
}
}
@@ -2333,14 +2333,14 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVi
Vector2i position = texture_region.get_center() + tile_data->get_texture_origin();
Vector polygon = tile_set->get_terrain_polygon(terrain_set);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
tile_data->set_terrain(terrain);
}
for (int i = 0; i < LayeredTileSet::CELL_NEIGHBOR_MAX; i++) {
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(i);
if (tile_set->is_valid_terrain_peering_bit(terrain_set, bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(terrain_set, bit);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
tile_data->set_terrain_peering_bit(bit, terrain);
}
}
@@ -2483,7 +2483,7 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVi
for (int j = 0; j < polygon.size(); j++) {
polygon.write[j] += position;
}
- if (!Geometry2D::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
+ if (!Geometry::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
// Draw terrain.
undo_redo->add_do_property(p_tile_set_atlas_source, vformat("%d:%d/%d/terrain", coords.x, coords.y, E.alternative_tile), terrain);
undo_redo->add_undo_property(p_tile_set_atlas_source, vformat("%d:%d/%d/terrain", coords.x, coords.y, E.alternative_tile), tile_data->get_terrain());
@@ -2496,7 +2496,7 @@ void TileDataTerrainsEditor::forward_painting_atlas_gui_input(LayeredTileAtlasVi
for (int j = 0; j < polygon.size(); j++) {
polygon.write[j] += position;
}
- if (!Geometry2D::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
+ if (!Geometry::intersect_polygons(polygon, mouse_pos_rect_polygon).empty()) {
// Draw bit.
undo_redo->add_do_property(p_tile_set_atlas_source, vformat("%d:%d/%d/terrains_peering_bit/" + String(LayeredTileSet::CELL_NEIGHBOR_ENUM_TO_TEXT[i]), coords.x, coords.y, E.alternative_tile), terrain);
undo_redo->add_undo_property(p_tile_set_atlas_source, vformat("%d:%d/%d/terrains_peering_bit/" + String(LayeredTileSet::CELL_NEIGHBOR_ENUM_TO_TEXT[i]), coords.x, coords.y, E.alternative_tile), tile_data->get_terrain_peering_bit(bit));
@@ -2580,7 +2580,7 @@ void TileDataTerrainsEditor::forward_painting_alternatives_gui_input(LayeredTile
Vector2i position = texture_region.get_center() + tile_data->get_texture_origin();
Vector polygon = tile_set->get_terrain_polygon(tile_data->get_terrain_set());
- if (Geometry2D::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
+ if (Geometry::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
tile_data->set_terrain(terrain);
}
@@ -2588,7 +2588,7 @@ void TileDataTerrainsEditor::forward_painting_alternatives_gui_input(LayeredTile
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(j);
if (tile_data->is_valid_terrain_peering_bit(bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(tile_data->get_terrain_set(), bit);
- if (Geometry2D::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
+ if (Geometry::is_segment_intersecting_polygon(mm->get_position() - position, drag_last_pos - position, polygon)) {
tile_data->set_terrain_peering_bit(bit, terrain);
}
}
@@ -2618,7 +2618,7 @@ void TileDataTerrainsEditor::forward_painting_alternatives_gui_input(LayeredTile
dummy_object->set("terrain", -1);
Vector polygon = tile_set->get_terrain_polygon(terrain_set);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
dummy_object->set("terrain", tile_data->get_terrain());
}
@@ -2626,7 +2626,7 @@ void TileDataTerrainsEditor::forward_painting_alternatives_gui_input(LayeredTile
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(i);
if (tile_set->is_valid_terrain_peering_bit(terrain_set, bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(terrain_set, bit);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
dummy_object->set("terrain", tile_data->get_terrain_peering_bit(bit));
}
}
@@ -2706,14 +2706,14 @@ void TileDataTerrainsEditor::forward_painting_alternatives_gui_input(LayeredTile
Vector2i position = texture_region.get_center() + tile_data->get_texture_origin();
Vector polygon = tile_set->get_terrain_polygon(terrain_set);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
tile_data->set_terrain(terrain);
}
for (int i = 0; i < LayeredTileSet::CELL_NEIGHBOR_MAX; i++) {
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(i);
if (tile_set->is_valid_terrain_peering_bit(terrain_set, bit)) {
polygon = tile_set->get_terrain_peering_bit_polygon(terrain_set, bit);
- if (Geometry2D::is_point_in_polygon(mb->get_position() - position, polygon)) {
+ if (Geometry::is_point_in_polygon(mb->get_position() - position, polygon)) {
tile_data->set_terrain_peering_bit(bit, terrain);
}
}
@@ -2831,11 +2831,11 @@ TileDataTerrainsEditor::~TileDataTerrainsEditor() {
Variant TileDataNavigationEditor::_get_painted_value() {
Ref nav_polygon;
- nav_polygon.instantiate();
+ nav_polygon.instance();
if (polygon_editor->get_polygon_count() > 0) {
Ref source_geometry_data;
- source_geometry_data.instantiate();
+ source_geometry_data.instance();
for (int i = 0; i < polygon_editor->get_polygon_count(); i++) {
Vector polygon = polygon_editor->get_polygon(i);
nav_polygon->add_outline(polygon);
diff --git a/modules/layered_tile_map/editor/layered_tile_map_layer_editor.cpp b/modules/layered_tile_map/editor/layered_tile_map_layer_editor.cpp
index a68635e6e..393e9f361 100644
--- a/modules/layered_tile_map/editor/layered_tile_map_layer_editor.cpp
+++ b/modules/layered_tile_map/editor/layered_tile_map_layer_editor.cpp
@@ -498,7 +498,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_scenes_list_lmb_empty_clicked(const
scene_tiles_list->deselect_all();
tile_set_selection.clear();
tile_map_selection.clear();
- selection_pattern.instantiate();
+ selection_pattern.instance();
_update_selection_pattern_from_tileset_tiles_selection();
}
@@ -548,7 +548,7 @@ bool LayeredTileMapLayerEditorTilesPlugin::forward_canvas_gui_input(const Ref LayeredTileMapLayerEditorTilesPlugin::_dra
// Get or create the pattern.
Ref erase_pattern;
- erase_pattern.instantiate();
+ erase_pattern.instance();
erase_pattern->set_cell(Vector2i(0, 0), LayeredTileSet::INVALID_SOURCE, LayeredTileSetSource::INVALID_ATLAS_COORDS, LayeredTileSetSource::INVALID_TILE_ALTERNATIVE);
Ref pattern = p_erase ? erase_pattern : selection_pattern;
@@ -1134,7 +1134,7 @@ HashMap LayeredTileMapLayerEditorTilesPlugin::_dra
// Get or create the pattern.
Ref erase_pattern;
- erase_pattern.instantiate();
+ erase_pattern.instance();
erase_pattern->set_cell(Vector2i(0, 0), LayeredTileSet::INVALID_SOURCE, LayeredTileSetSource::INVALID_ATLAS_COORDS, LayeredTileSetSource::INVALID_TILE_ALTERNATIVE);
Ref pattern = p_erase ? erase_pattern : selection_pattern;
@@ -1191,7 +1191,7 @@ HashMap LayeredTileMapLayerEditorTilesPlugin::_dra
// Get or create the pattern.
Ref erase_pattern;
- erase_pattern.instantiate();
+ erase_pattern.instance();
erase_pattern->set_cell(Vector2i(0, 0), LayeredTileSet::INVALID_SOURCE, LayeredTileSetSource::INVALID_ATLAS_COORDS, LayeredTileSetSource::INVALID_TILE_ALTERNATIVE);
Ref pattern = p_erase ? erase_pattern : selection_pattern;
@@ -1508,7 +1508,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_apply_transform(int p_type) {
}
Ref transformed_pattern;
- transformed_pattern.instantiate();
+ transformed_pattern.instance();
bool keep_shape = selection_pattern->get_size() == Vector2i(1, 1);
Vector2i size = selection_pattern->get_size();
@@ -1599,7 +1599,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_fix_selected_and_hovered() {
tile_set_selection.clear();
patterns_item_list->deselect_all();
tile_map_selection.clear();
- selection_pattern.instantiate();
+ selection_pattern.instance();
return;
}
Ref tile_set = edited_layer->get_effective_tile_set();
@@ -1610,7 +1610,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_fix_selected_and_hovered() {
tile_set_selection.clear();
patterns_item_list->deselect_all();
tile_map_selection.clear();
- selection_pattern.instantiate();
+ selection_pattern.instance();
return;
}
@@ -1622,7 +1622,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_fix_selected_and_hovered() {
tile_set_selection.clear();
patterns_item_list->deselect_all();
tile_map_selection.clear();
- selection_pattern.instantiate();
+ selection_pattern.instance();
return;
}
@@ -1694,7 +1694,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tilema
return;
}
- selection_pattern.instantiate();
+ selection_pattern.instance();
PoolVector2iArray coords_array;
for (const Vector2i &E : tile_map_selection) {
@@ -1719,7 +1719,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tilese
tile_map_selection.clear();
// Clear the selected pattern.
- selection_pattern.instantiate();
+ selection_pattern.instance();
// Group per source.
HashMap> per_source;
@@ -1793,7 +1793,7 @@ void LayeredTileMapLayerEditorTilesPlugin::_update_selection_pattern_from_tilese
tile_map_selection.clear();
// Clear the selected pattern.
- selection_pattern.instantiate();
+ selection_pattern.instance();
if (patterns_item_list->get_selected_items().size() >= 1) {
selection_pattern = patterns_item_list->get_item_metadata(patterns_item_list->get_selected_items()[0]);
@@ -2172,7 +2172,7 @@ void LayeredTileMapLayerEditorTilesPlugin::edit(ObjectID p_tile_map_layer_id) {
tile_set_selection.clear();
patterns_item_list->deselect_all();
tile_map_selection.clear();
- selection_pattern.instantiate();
+ selection_pattern.instance();
}
edited_tile_map_layer_id = p_tile_map_layer_id;
@@ -2191,15 +2191,15 @@ LayeredTileMapLayerEditorTilesPlugin::LayeredTileMapLayerEditorTilesPlugin() {
ED_SHORTCUT("tiles_editor/delete", TTR("Delete"), Key::KEY_DELETE);
// --- Initialize references ---
- tile_map_clipboard.instantiate();
- selection_pattern.instantiate();
+ tile_map_clipboard.instance();
+ selection_pattern.instance();
// --- Toolbar ---
toolbar = memnew(HBoxContainer);
HBoxContainer *tilemap_tiles_tools_buttons = memnew(HBoxContainer);
- tool_buttons_group.instantiate();
+ tool_buttons_group.instance();
select_tool_button = memnew(Button);
select_tool_button->set_theme_type_variation("FlatButton");
@@ -3543,7 +3543,7 @@ LayeredTileMapLayerEditorTerrainsPlugin::LayeredTileMapLayerEditorTerrainsPlugin
HBoxContainer *tilemap_tiles_tools_buttons = memnew(HBoxContainer);
- tool_buttons_group.instantiate();
+ tool_buttons_group.instance();
paint_tool_button = memnew(Button);
paint_tool_button->set_theme_type_variation("FlatButton");
@@ -3739,7 +3739,7 @@ Vector LayeredTileMapLayerEditor::get_line(const LayeredTileMapLayer *
ERR_FAIL_COND_V(tile_set.is_null(), Vector());
if (tile_set->get_tile_shape() == LayeredTileSet::TILE_SHAPE_SQUARE) {
- return Geometry2D::bresenham_line(p_from_cell, p_to_cell);
+ return Geometry::bresenham_line(p_from_cell, p_to_cell);
} else {
// Adapt the bresenham line algorithm to half-offset shapes.
// See this blog post: http://zvold.blogspot.com/2010/01/bresenhams-line-drawing-algorithm-on_26.html
diff --git a/modules/layered_tile_map/editor/layered_tile_set_atlas_source_editor.cpp b/modules/layered_tile_map/editor/layered_tile_set_atlas_source_editor.cpp
index 0f7d06c96..5444f8917 100644
--- a/modules/layered_tile_map/editor/layered_tile_set_atlas_source_editor.cpp
+++ b/modules/layered_tile_map/editor/layered_tile_set_atlas_source_editor.cpp
@@ -275,7 +275,7 @@ bool LayeredTileSetAtlasSourceEditor::LayeredAtlasTileProxyObject::_set(const St
property_list_changed_notify();
emit_signal(SNAME("changed"), "animation_separation");
return true;
- } else if (components.size() == 2 && components[0].begins_with("animation_frame_") && components[0].trim_prefix("animation_frame_").is_valid_int()) {
+ } else if (components.size() == 2 && components[0].begins_with("animation_frame_") && components[0].trim_prefix("animation_frame_").is_valid_integer()) {
for (TileSelection tile : tiles) {
int frame = components[0].trim_prefix("animation_frame_").to_int();
if (frame < 0 || frame >= tile_set_atlas_source->get_tile_animation_frames_count(tile.tile)) {
@@ -367,7 +367,7 @@ bool LayeredTileSetAtlasSourceEditor::LayeredAtlasTileProxyObject::_get(const St
} else if (p_name == "animation_frames_count") {
r_ret = tile_set_atlas_source->get_tile_animation_frames_count(coords);
return true;
- } else if (components.size() == 2 && components[0].begins_with("animation_frame_") && components[0].trim_prefix("animation_frame_").is_valid_int()) {
+ } else if (components.size() == 2 && components[0].begins_with("animation_frame_") && components[0].trim_prefix("animation_frame_").is_valid_integer()) {
int frame = components[0].trim_prefix("animation_frame_").to_int();
if (components[1] == "duration") {
if (frame < 0 || frame >= tile_set_atlas_source->get_tile_animation_frames_count(coords)) {
@@ -431,15 +431,15 @@ void LayeredTileSetAtlasSourceEditor::LayeredAtlasTileProxyObject::_get_property
p_list->push_back(PropertyInfo(Variant::NIL, GNAME("Animation", "animation_"), PROPERTY_HINT_NONE, "animation_", PROPERTY_USAGE_GROUP));
p_list->push_back(PropertyInfo(Variant::INT, PNAME("animation_columns")));
p_list->push_back(PropertyInfo(Variant::VECTOR2I, PNAME("animation_separation")));
- p_list->push_back(PropertyInfo(Variant::FLOAT, PNAME("animation_speed")));
+ p_list->push_back(PropertyInfo(Variant::REAL, PNAME("animation_speed")));
p_list->push_back(PropertyInfo(Variant::INT, PNAME("animation_mode"), PROPERTY_HINT_ENUM, "Default,Random Start Times"));
p_list->push_back(PropertyInfo(Variant::INT, PNAME("animation_frames_count"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_ARRAY, "Frames,animation_frame_"));
// Not optimal, but returns value for the first tile. This is similar to what MultiNodeEdit does.
if (tile_set_atlas_source->get_tile_animation_frames_count(tiles.front()->get().tile) == 1) {
- p_list->push_back(PropertyInfo(Variant::FLOAT, "animation_frame_0/duration", PROPERTY_HINT_NONE, "suffix:s", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_READ_ONLY));
+ p_list->push_back(PropertyInfo(Variant::REAL, "animation_frame_0/duration", PROPERTY_HINT_NONE, "suffix:s", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_READ_ONLY));
} else {
for (int i = 0; i < tile_set_atlas_source->get_tile_animation_frames_count(tiles.front()->get().tile); i++) {
- p_list->push_back(PropertyInfo(Variant::FLOAT, vformat("animation_frame_%d/%s", i, PNAME("duration")), PROPERTY_HINT_NONE, "suffix:s"));
+ p_list->push_back(PropertyInfo(Variant::REAL, vformat("animation_frame_%d/%s", i, PNAME("duration")), PROPERTY_HINT_NONE, "suffix:s"));
}
}
}
@@ -730,7 +730,7 @@ void LayeredTileSetAtlasSourceEditor::_update_tile_data_editors() {
if (!tile_data_editors.has("probability")) {
TileDataDefaultEditor *tile_data_probability_editor = memnew(TileDataDefaultEditor());
tile_data_probability_editor->hide();
- tile_data_probability_editor->setup_property_editor(Variant::FLOAT, "probability", "", 1.0);
+ tile_data_probability_editor->setup_property_editor(Variant::REAL, "probability", "", 1.0);
tile_data_probability_editor->connect("needs_redraw", callable_mp((CanvasItem *)tile_atlas_control_unscaled, &Control::queue_redraw));
tile_data_probability_editor->connect("needs_redraw", callable_mp((CanvasItem *)alternative_tiles_control_unscaled, &Control::queue_redraw));
tile_data_editors["probability"] = tile_data_probability_editor;
@@ -1104,7 +1104,7 @@ void LayeredTileSetAtlasSourceEditor::_tile_atlas_control_gui_input(const Ref line = Geometry2D::bresenham_line(last_base_tiles_coords, new_base_tiles_coords);
+ Vector line = Geometry::bresenham_line(last_base_tiles_coords, new_base_tiles_coords);
for (int i = 0; i < line.size(); i++) {
if (tile_set_atlas_source->get_tile_at_coords(line[i]) == LayeredTileSetSource::INVALID_ATLAS_COORDS) {
tile_set_atlas_source->create_tile(line[i]);
@@ -1119,7 +1119,7 @@ void LayeredTileSetAtlasSourceEditor::_tile_atlas_control_gui_input(const Ref line = Geometry2D::bresenham_line(last_base_tiles_coords, new_base_tiles_coords);
+ Vector line = Geometry::bresenham_line(last_base_tiles_coords, new_base_tiles_coords);
for (int i = 0; i < line.size(); i++) {
Vector2i base_tile_coords = tile_set_atlas_source->get_tile_at_coords(line[i]);
if (base_tile_coords != LayeredTileSetSource::INVALID_ATLAS_COORDS) {
@@ -1584,7 +1584,7 @@ HashMap> LayeredTileSetAtlasSourceEditor::_
Vector components = String(E_property->get().name).split("/", true, 1);
if (components.size() >= 1) {
Vector coord_arr = components[0].split(":");
- if (coord_arr.size() == 2 && coord_arr[0].is_valid_int() && coord_arr[1].is_valid_int()) {
+ if (coord_arr.size() == 2 && coord_arr[0].is_valid_integer() && coord_arr[1].is_valid_integer()) {
Vector2i coords = Vector2i(coord_arr[0].to_int(), coord_arr[1].to_int());
per_tile[coords].push_back(&(E_property->get()));
}
@@ -1634,7 +1634,7 @@ void LayeredTileSetAtlasSourceEditor::_menu_option(int p_option) {
if (per_tile.has(selected.tile)) {
for (List::Element *E_property = per_tile[selected.tile].front(); E_property; E_property = E_property->next()) {
Vector components = E_property->get()->name.split("/", true, 2);
- if (components.size() >= 2 && components[1].is_valid_int() && components[1].to_int() == selected.alternative) {
+ if (components.size() >= 2 && components[1].is_valid_integer() && components[1].to_int() == selected.alternative) {
String property = E_property->get()->name;
Variant value = tile_set_atlas_source->get(property);
if (value.get_type() != Variant::NIL) {
@@ -2093,7 +2093,7 @@ void LayeredTileSetAtlasSourceEditor::_tile_alternatives_control_unscaled_draw()
void LayeredTileSetAtlasSourceEditor::_tile_set_changed() {
if (tile_set->get_source_count() == 0) {
// No sources, so nothing to do here anymore.
- tile_set->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
+ tile_set->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
tile_set = Ref();
return;
}
@@ -2177,13 +2177,13 @@ void LayeredTileSetAtlasSourceEditor::edit(Ref p_tile_set, Layer
// Remove listener for old objects.
if (tile_set.is_valid()) {
- tile_set->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
+ tile_set->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
}
if (tile_set_atlas_source) {
- tile_set_atlas_source->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_source_texture));
+ tile_set_atlas_source->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_source_texture));
if (atlas_source_texture.is_valid()) {
- atlas_source_texture->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles));
+ atlas_source_texture->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles));
atlas_source_texture = Ref();
}
}
@@ -2200,11 +2200,11 @@ void LayeredTileSetAtlasSourceEditor::edit(Ref p_tile_set, Layer
read_only = new_read_only_state;
if (tile_set.is_valid()) {
- tile_set->connect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
+ tile_set->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
}
if (tile_set_atlas_source) {
- tile_set_atlas_source->connect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_source_texture));
+ tile_set_atlas_source->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_source_texture));
_update_source_texture();
}
@@ -2243,7 +2243,7 @@ void LayeredTileSetAtlasSourceEditor::_update_source_texture() {
}
if (atlas_source_texture.is_valid()) {
- atlas_source_texture->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles));
+ atlas_source_texture->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles));
atlas_source_texture = Ref();
}
@@ -2251,7 +2251,7 @@ void LayeredTileSetAtlasSourceEditor::_update_source_texture() {
return;
}
atlas_source_texture = tile_set_atlas_source->get_texture();
- atlas_source_texture->connect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles), CONNECT_DEFERRED);
+ atlas_source_texture->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_check_outside_tiles), CONNECT_DEFERRED);
_check_outside_tiles();
}
@@ -2510,7 +2510,7 @@ LayeredTileSetAtlasSourceEditor::LayeredTileSetAtlasSourceEditor() {
add_child(middle_vbox_container);
// -- Toolbox --
- tools_button_group.instantiate();
+ tools_button_group.instance();
tools_button_group->connect("pressed", callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_fix_selected_and_hovered_tiles).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_tile_id_label).unbind(1));
tools_button_group->connect("pressed", callable_mp(this, &LayeredTileSetAtlasSourceEditor::_update_atlas_source_inspector).unbind(1));
@@ -2741,7 +2741,7 @@ LayeredTileSetAtlasSourceEditor::LayeredTileSetAtlasSourceEditor() {
// Inspector plugin.
Ref tile_data_inspector_plugin;
- tile_data_inspector_plugin.instantiate();
+ tile_data_inspector_plugin.instance();
EditorInspector::add_inspector_plugin(tile_data_inspector_plugin);
}
@@ -2752,7 +2752,7 @@ LayeredTileSetAtlasSourceEditor::~LayeredTileSetAtlasSourceEditor() {
// Remove listener for old objects, so the LayeredTileSet doesn't
// try to call the destroyed LayeredTileSetAtlasSourceEditor.
if (tile_set.is_valid()) {
- tile_set->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
+ tile_set->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSourceEditor::_tile_set_changed));
}
}
@@ -2774,18 +2774,18 @@ void EditorPropertyTilePolygon::_polygons_changed() {
// Single OccluderPolygon2D.
Ref occluder;
if (generic_tile_polygon_editor->get_polygon_count() >= 1) {
- occluder.instantiate();
+ occluder.instance();
occluder->set_polygon(generic_tile_polygon_editor->get_polygon(0));
}
emit_changed(get_edited_property(), occluder);
} else if (base_type == "NavigationPolygon") {
Ref navigation_polygon;
if (generic_tile_polygon_editor->get_polygon_count() >= 1) {
- navigation_polygon.instantiate();
+ navigation_polygon.instance();
if (generic_tile_polygon_editor->get_polygon_count() > 0) {
Ref source_geometry_data;
- source_geometry_data.instantiate();
+ source_geometry_data.instance();
for (int i = 0; i < generic_tile_polygon_editor->get_polygon_count(); i++) {
Vector polygon = generic_tile_polygon_editor->get_polygon(i);
navigation_polygon->add_outline(polygon);
@@ -2899,7 +2899,7 @@ bool EditorInspectorPluginTileData::can_handle(Object *p_object) {
bool EditorInspectorPluginTileData::parse_property(Object *p_object, const Variant::Type p_type, const String &p_path, const PropertyHint p_hint, const String &p_hint_text, const BitField p_usage, const bool p_wide) {
Vector components = String(p_path).split("/", true, 2);
- if (components.size() == 2 && components[0].begins_with("occlusion_layer_") && components[0].trim_prefix("occlusion_layer_").is_valid_int()) {
+ 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);
@@ -2909,7 +2909,7 @@ bool EditorInspectorPluginTileData::parse_property(Object *p_object, const Varia
add_property_editor(p_path, ep);
return true;
}
- } else if (components.size() >= 2 && components[0].begins_with("physics_layer_") && components[0].trim_prefix("physics_layer_").is_valid_int()) {
+ } 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);
@@ -2924,14 +2924,14 @@ bool EditorInspectorPluginTileData::parse_property(Object *p_object, const Varia
}
add_property_editor_for_multiple_properties("Polygons", properties, ep);
return true;
- } else if (components.size() == 3 && components[1].begins_with("polygon_") && components[1].trim_prefix("polygon_").is_valid_int()) {
+ } else if (components.size() == 3 && components[1].begins_with("polygon_") && components[1].trim_prefix("polygon_").is_valid_integer()) {
int polygon_index = components[1].trim_prefix("polygon_").to_int();
ERR_FAIL_COND_V(polygon_index < 0, false);
if (components[2] == "points") {
return true;
}
}
- } else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_int()) {
+ } 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);
diff --git a/modules/layered_tile_map/editor/layered_tile_set_editor.cpp b/modules/layered_tile_map/editor/layered_tile_set_editor.cpp
index 935757ea9..7b10da46d 100644
--- a/modules/layered_tile_map/editor/layered_tile_set_editor.cpp
+++ b/modules/layered_tile_map/editor/layered_tile_set_editor.cpp
@@ -479,7 +479,7 @@ void LayeredTileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Obj
end = ed_tile_set->get_physics_layers_count();
} else if (p_array_prefix == "terrain_set_") {
end = ed_tile_set->get_terrain_sets_count();
- } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_int() && components[1] == "terrain_") {
+ } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_integer() && components[1] == "terrain_") {
int terrain_set = components[0].trim_prefix("terrain_set_").to_int();
end = ed_tile_set->get_terrains_count(terrain_set);
} else if (p_array_prefix == "navigation_layer_") {
@@ -520,7 +520,7 @@ void LayeredTileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Obj
if (p_from_index < 0) {
undo_redo_man->add_undo_method(ed_tile_set, "remove_terrain_set", p_to_pos < 0 ? ed_tile_set->get_terrain_sets_count() : p_to_pos);
}
- } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_int() && components[1] == "terrain_") {
+ } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_integer() && components[1] == "terrain_") {
int terrain_set = components[0].trim_prefix("terrain_set_").to_int();
if (p_from_index < 0) {
undo_redo_man->add_undo_method(ed_tile_set, "remove_terrain", terrain_set, p_to_pos < 0 ? ed_tile_set->get_terrains_count(terrain_set) : p_to_pos);
@@ -594,7 +594,7 @@ void LayeredTileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Obj
}
}
}
- } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_int() && components[1] == "terrain_") {
+ } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_integer() && components[1] == "terrain_") {
for (int terrain_index = 0; terrain_index < LayeredTileSet::CELL_NEIGHBOR_MAX; terrain_index++) {
LayeredTileSet::CellNeighbor bit = LayeredTileSet::CellNeighbor(terrain_index);
if (tile_data->is_valid_terrain_peering_bit(bit)) {
@@ -641,7 +641,7 @@ void LayeredTileSetEditor::_move_tile_set_array_element(Object *p_undo_redo, Obj
} else {
undo_redo_man->add_do_method(ed_tile_set, "move_terrain_set", p_from_index, p_to_pos);
}
- } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_int() && components[1] == "terrain_") {
+ } else if (components.size() >= 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_integer() && components[1] == "terrain_") {
int terrain_set = components[0].trim_prefix("terrain_set_").to_int();
if (p_from_index < 0) {
undo_redo_man->add_do_method(ed_tile_set, "add_terrain", terrain_set, p_to_pos);
@@ -689,7 +689,7 @@ void LayeredTileSetEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Ob
TileData *tile_data = tas->get_tile_data(tile_id, alternative_id);
ERR_FAIL_NULL(tile_data);
- if (components.size() == 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_int() && components[1] == "mode") {
+ if (components.size() == 2 && components[0].begins_with("terrain_set_") && components[0].trim_prefix("terrain_set_").is_valid_integer() && components[1] == "mode") {
ADD_UNDO(tile_data, "terrain_set");
ADD_UNDO(tile_data, "terrain");
for (int l = 0; l < LayeredTileSet::CELL_NEIGHBOR_MAX; l++) {
@@ -698,8 +698,8 @@ void LayeredTileSetEditor::_undo_redo_inspector_callback(Object *p_undo_redo, Ob
ADD_UNDO(tile_data, "terrains_peering_bit/" + String(LayeredTileSet::CELL_NEIGHBOR_ENUM_TO_TEXT[l]));
}
}
- } else if (components.size() == 2 && components[0].begins_with("custom_data_layer_") && components[0].trim_prefix("custom_data_layer_").is_valid_int() && components[1] == "type") {
- int custom_data_layer = components[0].trim_prefix("custom_data_layer_").is_valid_int();
+ } else if (components.size() == 2 && components[0].begins_with("custom_data_layer_") && components[0].trim_prefix("custom_data_layer_").is_valid_integer() && components[1] == "type") {
+ int custom_data_layer = components[0].trim_prefix("custom_data_layer_").is_valid_integer();
ADD_UNDO(tile_data, vformat("custom_data_%d", custom_data_layer));
}
}
@@ -722,7 +722,7 @@ void LayeredTileSetEditor::edit(Ref p_tile_set) {
// Remove listener.
if (tile_set.is_valid()) {
- tile_set->disconnect_changed(callable_mp(this, &LayeredTileSetEditor::_tile_set_changed));
+ tile_set->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetEditor::_tile_set_changed));
}
// Change the edited object.
@@ -737,7 +737,7 @@ void LayeredTileSetEditor::edit(Ref p_tile_set) {
sources_advanced_menu_button->set_disabled(read_only);
source_sort_button->set_disabled(read_only);
- tile_set->connect_changed(callable_mp(this, &LayeredTileSetEditor::_tile_set_changed));
+ tile_set->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetEditor::_tile_set_changed));
if (first_edit) {
first_edit = false;
_set_source_sort(EditorSettings::get_singleton()->get_project_metadata("editor_metadata", "tile_source_sort", 0));
diff --git a/modules/layered_tile_map/editor/layered_tile_set_scenes_collection_source_editor.cpp b/modules/layered_tile_map/editor/layered_tile_set_scenes_collection_source_editor.cpp
index d965d74b6..f46ddfdd7 100644
--- a/modules/layered_tile_map/editor/layered_tile_set_scenes_collection_source_editor.cpp
+++ b/modules/layered_tile_map/editor/layered_tile_set_scenes_collection_source_editor.cpp
@@ -417,7 +417,7 @@ void LayeredTileSetScenesCollectionSourceEditor::edit(Ref p_tile
// Remove listener for old objects.
if (tile_set_scenes_collection_source) {
- tile_set_scenes_collection_source->disconnect_changed(callable_mp(this, &LayeredTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed));
+ tile_set_scenes_collection_source->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed));
}
// Change the edited object.
@@ -437,7 +437,7 @@ void LayeredTileSetScenesCollectionSourceEditor::edit(Ref p_tile
// Add the listener again.
if (tile_set_scenes_collection_source) {
- tile_set_scenes_collection_source->connect_changed(callable_mp(this, &LayeredTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed));
+ tile_set_scenes_collection_source->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetScenesCollectionSourceEditor::_tile_set_scenes_collection_source_changed));
}
// Update everything.
diff --git a/modules/layered_tile_map/layered_tile_map.cpp b/modules/layered_tile_map/layered_tile_map.cpp
index 524bd30e4..9563242ad 100644
--- a/modules/layered_tile_map/layered_tile_map.cpp
+++ b/modules/layered_tile_map/layered_tile_map.cpp
@@ -554,7 +554,7 @@ bool LayeredTileMap::_set(const StringName &p_name, const Variant &p_value) {
return true;
}
#endif // DISABLE_DEPRECATED
- else if (components.size() == 2 && components[0].begins_with("layer_") && components[0].trim_prefix("layer_").is_valid_int()) {
+ else if (components.size() == 2 && components[0].begins_with("layer_") && components[0].trim_prefix("layer_").is_valid_integer()) {
int index = components[0].trim_prefix("layer_").to_int();
if (index < 0) {
return false;
@@ -619,7 +619,7 @@ bool LayeredTileMap::_get(const StringName &p_name, Variant &r_ret) const {
return true;
}
#endif
- else if (components.size() == 2 && components[0].begins_with("layer_") && components[0].trim_prefix("layer_").is_valid_int()) {
+ else if (components.size() == 2 && components[0].begins_with("layer_") && components[0].trim_prefix("layer_").is_valid_integer()) {
int index = components[0].trim_prefix("layer_").to_int();
if (index < 0 || index >= (int)layers.size()) {
return false;
diff --git a/modules/layered_tile_map/layered_tile_map_layer.cpp b/modules/layered_tile_map/layered_tile_map_layer.cpp
index 278fb0b4e..af4031099 100644
--- a/modules/layered_tile_map/layered_tile_map_layer.cpp
+++ b/modules/layered_tile_map/layered_tile_map_layer.cpp
@@ -160,7 +160,7 @@ void LayeredTileMapLayer::_debug_quadrants_update_cell(CellData &r_cell_data, Se
if (!debug_quadrant_map.has(quadrant_coords)) {
// Create a new quadrant and add it to the quadrant map.
Ref new_quadrant;
- new_quadrant.instantiate();
+ new_quadrant.instance();
new_quadrant->quadrant_coords = quadrant_coords;
debug_quadrant_map[quadrant_coords] = new_quadrant;
}
@@ -502,7 +502,7 @@ void LayeredTileMapLayer::_rendering_quadrants_update_cell(CellData &r_cell_data
rendering_quadrant = rendering_quadrant_map[quadrant_coords];
} else {
// Create a new rendering quadrant.
- rendering_quadrant.instantiate();
+ rendering_quadrant.instance();
rendering_quadrant->quadrant_coords = quadrant_coords;
rendering_quadrant->canvas_items_position = canvas_items_position;
rendering_quadrant_map[quadrant_coords] = rendering_quadrant;
@@ -1271,7 +1271,7 @@ void LayeredTileMapLayer::_scenes_update_cell(CellData &r_cell_data) {
if (scenes_collection_source) {
Ref packed_scene = scenes_collection_source->get_scene_tile_scene(c.alternative_tile);
if (packed_scene.is_valid()) {
- Node *scene = packed_scene->instantiate();
+ Node *scene = packed_scene->instance();
Control *scene_as_control = Object::cast_to(scene);
Node2D *scene_as_node2d = Object::cast_to(scene);
if (scene_as_control) {
@@ -2346,7 +2346,7 @@ Ref LayeredTileMapLayer::get_pattern(PoolVector2iArray p_
ERR_FAIL_COND_V(!tile_set.is_valid(), nullptr);
Ref output;
- output.instantiate();
+ output.instance();
if (p_coords_array.empty()) {
return output;
}
diff --git a/modules/layered_tile_map/layered_tile_map_layer_group.cpp b/modules/layered_tile_map/layered_tile_map_layer_group.cpp
index c2782a8f5..531e2dc0e 100644
--- a/modules/layered_tile_map/layered_tile_map_layer_group.cpp
+++ b/modules/layered_tile_map/layered_tile_map_layer_group.cpp
@@ -121,13 +121,13 @@ void LayeredTileMapLayerGroup::set_tileset(const Ref &p_tileset)
// Set the tileset, registering to its changes.
if (tile_set.is_valid()) {
- tile_set->disconnect_changed(callable_mp(this, &LayeredTileMapLayerGroup::_tile_set_changed));
+ tile_set->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileMapLayerGroup::_tile_set_changed));
}
tile_set = p_tileset;
if (tile_set.is_valid()) {
- tile_set->connect_changed(callable_mp(this, &LayeredTileMapLayerGroup::_tile_set_changed));
+ tile_set->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileMapLayerGroup::_tile_set_changed));
}
for (int i = 0; i < get_child_count(); i++) {
@@ -144,6 +144,6 @@ Ref LayeredTileMapLayerGroup::get_tileset() const {
LayeredTileMapLayerGroup::~LayeredTileMapLayerGroup() {
if (tile_set.is_valid()) {
- tile_set->disconnect_changed(callable_mp(this, &LayeredTileMapLayerGroup::_tile_set_changed));
+ tile_set->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileMapLayerGroup::_tile_set_changed));
}
}
diff --git a/modules/layered_tile_map/layered_tile_set.cpp b/modules/layered_tile_map/layered_tile_set.cpp
index 3a1bb24e7..3fcdc1c01 100644
--- a/modules/layered_tile_map/layered_tile_set.cpp
+++ b/modules/layered_tile_map/layered_tile_set.cpp
@@ -38,6 +38,7 @@
#include "core/io/marshalls.h"
#include "core/math/geometry.h"
#include "scene/main/control.h"
+#include "scene/resources/mesh/mesh.h"
#include "scene/resources/texture.h"
#include "servers/navigation_2d_server.h"
@@ -422,7 +423,7 @@ void LayeredTileSet::_update_terrains_cache() {
int alternative_id = source->get_alternative_tile_id(tile_id, alternative_index);
// Executed for each tile_data.
- TileData *tile_data = atlas_source->get_tile_data(tile_id, alternative_id);
+ LayeredTileData *tile_data = atlas_source->get_tile_data(tile_id, alternative_id);
int terrain_set = tile_data->get_terrain_set();
if (terrain_set >= 0) {
LayeredTileMapCell cell;
@@ -1085,7 +1086,7 @@ void LayeredTileSet::remove_custom_data_layer(int p_index) {
for (HashMap>::Element *source = sources.front(); source; source = source->next) {
source->value()->remove_custom_data_layer(p_index);
}
-
+
property_list_changed_notify();
emit_changed();
}
@@ -1268,34 +1269,40 @@ void LayeredTileSet::remove_alternative_level_tile_proxy(int p_source_from, Vect
Array LayeredTileSet::get_source_level_tile_proxies() const {
Array output;
- for (const KeyValue &E : source_level_proxies) {
+
+ for (const RBMap::Element *E = source_level_proxies.front(); E; E = E->next()) {
Array proxy;
- proxy.push_back(E.key);
- proxy.push_back(E.value);
+ proxy.push_back(E->key());
+ proxy.push_back(E->value());
output.push_back(proxy);
}
+
return output;
}
Array LayeredTileSet::get_coords_level_tile_proxies() const {
Array output;
- for (const KeyValue &E : coords_level_proxies) {
+
+ for (const RBMap::Element *E = coords_level_proxies.front(); E; E = E->next()) {
Array proxy;
- proxy.append_array(E.key);
- proxy.append_array(E.value);
+ proxy.append_array(E->key());
+ proxy.append_array(E->value());
output.push_back(proxy);
}
+
return output;
}
Array LayeredTileSet::get_alternative_level_tile_proxies() const {
Array output;
- for (const KeyValue &E : alternative_level_proxies) {
+
+ for (const RBMap::Element *E = alternative_level_proxies.front(); E; E = E->next()) {
Array proxy;
- proxy.append_array(E.key);
- proxy.append_array(E.value);
+ proxy.append_array(E->key());
+ proxy.append_array(E->value());
output.push_back(proxy);
}
+
return output;
}
@@ -1345,9 +1352,9 @@ Array LayeredTileSet::map_tile_proxy(int p_source_from, Vector2i p_coords_from,
void LayeredTileSet::cleanup_invalid_tile_proxies() {
// Source level.
Vector source_to_remove;
- for (const KeyValue &E : source_level_proxies) {
- if (has_source(E.key)) {
- source_to_remove.push_back(E.key);
+ for (const RBMap::Element *E = source_level_proxies.front(); E; E = E->next()) {
+ if (has_source(E->key())) {
+ source_to_remove.push_back(E->key());
}
}
for (int i = 0; i < source_to_remove.size(); i++) {
@@ -1356,8 +1363,8 @@ void LayeredTileSet::cleanup_invalid_tile_proxies() {
// Coords level.
Vector coords_to_remove;
- for (const KeyValue &E : coords_level_proxies) {
- Array a = E.key;
+ for (const RBMap::Element *E = coords_level_proxies.front(); E; E = E->next()) {
+ Array a = E->key();
if (has_source(a[0]) && get_source(a[0])->has_tile(a[1])) {
coords_to_remove.push_back(a);
}
@@ -1369,8 +1376,8 @@ void LayeredTileSet::cleanup_invalid_tile_proxies() {
// Alternative level.
Vector alternative_to_remove;
- for (const KeyValue &E : alternative_level_proxies) {
- Array a = E.key;
+ for (const RBMap::Element *E = alternative_level_proxies.front(); E; E = E->next()) {
+ Array a = E->key();
if (has_source(a[0]) && get_source(a[0])->has_tile(a[1]) && get_source(a[0])->has_alternative_tile(a[1], a[2])) {
alternative_to_remove.push_back(a);
}
@@ -1392,9 +1399,12 @@ void LayeredTileSet::clear_tile_proxies() {
int LayeredTileSet::add_pattern(Ref p_pattern, int p_index) {
ERR_FAIL_COND_V(!p_pattern.is_valid(), -1);
ERR_FAIL_COND_V_MSG(p_pattern->empty(), -1, "Cannot add an empty pattern to the LayeredTileSet.");
- for (const Ref &pattern : patterns) {
+
+ for (uint32_t i = 0; i < patterns.size(); ++i) {
+ const Ref &pattern = patterns[i];
ERR_FAIL_COND_V_MSG(pattern == p_pattern, -1, "LayeredTileSet has already this pattern.");
}
+
ERR_FAIL_COND_V(p_index > (int)patterns.size(), -1);
if (p_index < 0) {
p_index = patterns.size();
@@ -1421,18 +1431,25 @@ int LayeredTileSet::get_patterns_count() {
RBSet LayeredTileSet::get_terrains_pattern_set(int p_terrain_set) {
ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), RBSet());
+
_update_terrains_cache();
RBSet output;
- for (KeyValue> kv : per_terrain_pattern_tiles[p_terrain_set]) {
- output.insert(kv.key);
+
+ const RBMap> &m = per_terrain_pattern_tiles[p_terrain_set];
+
+ for (const RBMap>::Element *kv = m.front(); kv; kv = kv->next()) {
+ output.insert(kv->key());
}
+
return output;
}
RBSet LayeredTileSet::get_tiles_for_terrains_pattern(int p_terrain_set, TerrainsPattern p_terrain_tile_pattern) {
ERR_FAIL_INDEX_V(p_terrain_set, terrain_sets.size(), RBSet());
+
_update_terrains_cache();
+
return per_terrain_pattern_tiles[p_terrain_set][p_terrain_tile_pattern];
}
@@ -1443,12 +1460,13 @@ LayeredTileMapCell LayeredTileSet::get_random_tile_from_terrains_pattern(int p_t
// Count the sum of probabilities.
double sum = 0.0;
RBSet set = per_terrain_pattern_tiles[p_terrain_set][p_terrain_tile_pattern];
- for (const LayeredTileMapCell &E : set) {
- if (E.source_id >= 0) {
- Ref source = sources[E.source_id];
+
+ for (const RBSet::Element *E = set.front(); E; E = E->next()) {
+ if (E->get().source_id >= 0) {
+ Ref source = sources[E->get().source_id];
Ref atlas_source = source;
if (atlas_source.is_valid()) {
- TileData *tile_data = atlas_source->get_tile_data(E.get_atlas_coords(), E.alternative_tile);
+ LayeredTileData *tile_data = atlas_source->get_tile_data(E->get().get_atlas_coords(), E->get().alternative_tile);
sum += tile_data->get_probability();
} else {
sum += 1.0;
@@ -1463,13 +1481,13 @@ LayeredTileMapCell LayeredTileSet::get_random_tile_from_terrains_pattern(int p_t
double picked = Math::random(0.0, sum);
// Pick the tile.
- for (const LayeredTileMapCell &E : set) {
- if (E.source_id >= 0) {
- Ref source = sources[E.source_id];
+ for (const RBSet::Element *E = set.front(); E; E = E->next()) {
+ if (E->get().source_id >= 0) {
+ Ref source = sources[E->get().source_id];
Ref atlas_source = source;
if (atlas_source.is_valid()) {
- TileData *tile_data = atlas_source->get_tile_data(E.get_atlas_coords(), E.alternative_tile);
+ LayeredTileData *tile_data = atlas_source->get_tile_data(E->get().get_atlas_coords(), E->get().alternative_tile);
count += tile_data->get_probability();
} else {
count += 1.0;
@@ -1479,7 +1497,7 @@ LayeredTileMapCell LayeredTileSet::get_random_tile_from_terrains_pattern(int p_t
}
if (count >= picked) {
- return E;
+ return E->get();
}
}
@@ -1527,7 +1545,7 @@ Vector LayeredTileSet::get_tile_shape_polygon() const {
return points;
}
-void LayeredTileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled, Ref p_texture) const {
+void LayeredTileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled, Ref p_texture) {
if (tile_meshes_dirty) {
Vector shape = get_tile_shape_polygon();
Vector uvs;
@@ -1542,13 +1560,14 @@ void LayeredTileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_tr
// Filled mesh.
tile_filled_mesh->clear_surfaces();
+
Array a;
a.resize(Mesh::ARRAY_MAX);
a[Mesh::ARRAY_VERTEX] = shape;
a[Mesh::ARRAY_TEX_UV] = uvs;
a[Mesh::ARRAY_COLOR] = colors;
- a[Mesh::ARRAY_INDEX] = Geometry2D::triangulate_polygon(shape);
- tile_filled_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Dictionary(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
+ a[Mesh::ARRAY_INDEX] = Geometry::triangulate_polygon(shape);
+ tile_filled_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
// Lines mesh.
tile_lines_mesh->clear_surfaces();
@@ -1559,15 +1578,15 @@ void LayeredTileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_tr
colors.push_back(colors[0]);
a[Mesh::ARRAY_VERTEX] = shape;
a[Mesh::ARRAY_COLOR] = colors;
- tile_lines_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINE_STRIP, a, Array(), Dictionary(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
+ tile_lines_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_LINE_STRIP, a, Array(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
tile_meshes_dirty = false;
}
if (p_filled) {
- p_canvas_item->draw_mesh(tile_filled_mesh, p_texture, p_transform, p_color);
+ p_canvas_item->draw_mesh(tile_filled_mesh, p_texture, Ref(), p_transform, p_color);
} else {
- p_canvas_item->draw_mesh(tile_lines_mesh, Ref(), p_transform, p_color);
+ p_canvas_item->draw_mesh(tile_lines_mesh, Ref(), Ref(), p_transform, p_color);
}
}
@@ -2232,7 +2251,10 @@ Vector2i LayeredTileSet::map_pattern(const Vector2i &p_position_in_tilemap, cons
void LayeredTileSet::draw_cells_outline(CanvasItem *p_canvas_item, const RBSet &p_cells, Color p_color, Transform2D p_transform) const {
Vector polygon = get_tile_shape_polygon();
- for (const Vector2i &E : p_cells) {
+
+ for (const RBSet::Element *SE = p_cells.front(); SE; SE = SE->next()) {
+ const Vector2i &E = SE->get();
+
Vector2 center = map_to_local(E);
#define DRAW_SIDE_IF_NEEDED(side, polygon_index_from, polygon_index_to) \
@@ -2304,7 +2326,7 @@ Vector LayeredTileSet::get_terrain_peering_bit_polygon(int p_terrain_set
return _get_square_corner_or_side_terrain_peering_bit_polygon(tile_size, p_bit);
} else if (terrain_mode == LayeredTileSet::TERRAIN_MODE_MATCH_CORNERS) {
return _get_square_corner_terrain_peering_bit_polygon(tile_size, p_bit);
- } else { // TileData::TERRAIN_MODE_MATCH_SIDES
+ } else { // LayeredTileData::TERRAIN_MODE_MATCH_SIDES
return _get_square_side_terrain_peering_bit_polygon(tile_size, p_bit);
}
} else if (tile_shape == LayeredTileSet::TILE_SHAPE_ISOMETRIC) {
@@ -2312,7 +2334,7 @@ Vector LayeredTileSet::get_terrain_peering_bit_polygon(int p_terrain_set
return _get_isometric_corner_or_side_terrain_peering_bit_polygon(tile_size, p_bit);
} else if (terrain_mode == LayeredTileSet::TERRAIN_MODE_MATCH_CORNERS) {
return _get_isometric_corner_terrain_peering_bit_polygon(tile_size, p_bit);
- } else { // TileData::TERRAIN_MODE_MATCH_SIDES
+ } else { // LayeredTileData::TERRAIN_MODE_MATCH_SIDES
return _get_isometric_side_terrain_peering_bit_polygon(tile_size, p_bit);
}
} else {
@@ -2331,7 +2353,7 @@ Vector LayeredTileSet::get_terrain_peering_bit_polygon(int p_terrain_set
return _get_half_offset_corner_or_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, p_bit);
} else if (terrain_mode == LayeredTileSet::TERRAIN_MODE_MATCH_CORNERS) {
return _get_half_offset_corner_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, p_bit);
- } else { // TileData::TERRAIN_MODE_MATCH_SIDES
+ } else { // LayeredTileData::TERRAIN_MODE_MATCH_SIDES
return _get_half_offset_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, p_bit);
}
}
@@ -2339,7 +2361,7 @@ Vector LayeredTileSet::get_terrain_peering_bit_polygon(int p_terrain_set
#define TERRAIN_ALPHA 0.6
-void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform, const TileData *p_tile_data) {
+void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform, const LayeredTileData *p_tile_data) {
ERR_FAIL_NULL(p_tile_data);
if (terrain_bits_meshes_dirty) {
@@ -2371,7 +2393,7 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
}
{
Ref mesh;
- mesh.instantiate();
+ mesh.instance();
Vector uvs;
uvs.resize(polygon.size());
Vector colors;
@@ -2382,8 +2404,8 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
a[Mesh::ARRAY_VERTEX] = polygon;
a[Mesh::ARRAY_TEX_UV] = uvs;
a[Mesh::ARRAY_COLOR] = colors;
- a[Mesh::ARRAY_INDEX] = Geometry2D::triangulate_polygon(polygon);
- mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Dictionary(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
+ a[Mesh::ARRAY_INDEX] = Geometry::triangulate_polygon(polygon);
+ mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
terrain_meshes[terrain_mode] = mesh;
}
// Peering bits
@@ -2396,7 +2418,7 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
polygon = _get_square_corner_or_side_terrain_peering_bit_polygon(tile_size, bit);
} else if (terrain_mode == LayeredTileSet::TERRAIN_MODE_MATCH_CORNERS) {
polygon = _get_square_corner_terrain_peering_bit_polygon(tile_size, bit);
- } else { // TileData::TERRAIN_MODE_MATCH_SIDES
+ } else { // LayeredTileData::TERRAIN_MODE_MATCH_SIDES
polygon = _get_square_side_terrain_peering_bit_polygon(tile_size, bit);
}
} else if (tile_shape == LayeredTileSet::TILE_SHAPE_ISOMETRIC) {
@@ -2404,7 +2426,7 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
polygon = _get_isometric_corner_or_side_terrain_peering_bit_polygon(tile_size, bit);
} else if (terrain_mode == LayeredTileSet::TERRAIN_MODE_MATCH_CORNERS) {
polygon = _get_isometric_corner_terrain_peering_bit_polygon(tile_size, bit);
- } else { // TileData::TERRAIN_MODE_MATCH_SIDES
+ } else { // LayeredTileData::TERRAIN_MODE_MATCH_SIDES
polygon = _get_isometric_side_terrain_peering_bit_polygon(tile_size, bit);
}
} else {
@@ -2423,13 +2445,13 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
polygon = _get_half_offset_corner_or_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, bit);
} else if (terrain_mode == LayeredTileSet::TERRAIN_MODE_MATCH_CORNERS) {
polygon = _get_half_offset_corner_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, bit);
- } else { // TileData::TERRAIN_MODE_MATCH_SIDES
+ } else { // LayeredTileData::TERRAIN_MODE_MATCH_SIDES
polygon = _get_half_offset_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, bit);
}
}
{
Ref mesh;
- mesh.instantiate();
+ mesh.instance();
Vector uvs;
uvs.resize(polygon.size());
Vector colors;
@@ -2440,8 +2462,8 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
a[Mesh::ARRAY_VERTEX] = polygon;
a[Mesh::ARRAY_TEX_UV] = uvs;
a[Mesh::ARRAY_COLOR] = colors;
- a[Mesh::ARRAY_INDEX] = Geometry2D::triangulate_polygon(polygon);
- mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Dictionary(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
+ a[Mesh::ARRAY_INDEX] = Geometry::triangulate_polygon(polygon);
+ mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
terrain_peering_bits_meshes[terrain_mode][bit] = mesh;
}
}
@@ -2461,7 +2483,7 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
if (terrain_id >= 0) {
Color color = get_terrain_color(terrain_set, terrain_id);
color.a = TERRAIN_ALPHA;
- p_canvas_item->draw_mesh(terrain_meshes[terrain_mode], Ref(), Transform2D(), color);
+ p_canvas_item->draw_mesh(terrain_meshes[terrain_mode], Ref(), Ref(), Transform2D(), color);
}
for (int i = 0; i < LayeredTileSet::CELL_NEIGHBOR_MAX; i++) {
@@ -2471,7 +2493,7 @@ void LayeredTileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_tran
if (terrain_id >= 0) {
Color color = get_terrain_color(terrain_set, terrain_id);
color.a = TERRAIN_ALPHA;
- p_canvas_item->draw_mesh(terrain_peering_bits_meshes[terrain_mode][bit], Ref(), Transform2D(), color);
+ p_canvas_item->draw_mesh(terrain_peering_bits_meshes[terrain_mode][bit], Ref(), Ref(), Transform2D(), color);
}
}
}
@@ -2506,7 +2528,7 @@ Vector>> LayeredTileSet::generate_terrains_icons(Size2i p_si
for (int alternative_index = 0; alternative_index < source->get_alternative_tiles_count(tile_id); alternative_index++) {
int alternative_id = source->get_alternative_tile_id(tile_id, alternative_index);
- TileData *tile_data = atlas_source->get_tile_data(tile_id, alternative_id);
+ LayeredTileData *tile_data = atlas_source->get_tile_data(tile_id, alternative_id);
int terrain_set = tile_data->get_terrain_set();
if (terrain_set >= 0) {
ERR_FAIL_INDEX_V(terrain_set, get_terrain_sets_count(), Vector>>());
@@ -2551,24 +2573,26 @@ Vector>> LayeredTileSet::generate_terrains_icons(Size2i p_si
for (int terrain_set = 0; terrain_set < get_terrain_sets_count(); terrain_set++) {
for (int terrain = 0; terrain < get_terrains_count(terrain_set); terrain++) {
Ref dst_image;
- dst_image.instantiate();
+ dst_image.instance();
if (counts[terrain_set][terrain].count > 0) {
// Get the best tile.
Ref src_texture = counts[terrain_set][terrain].texture;
ERR_FAIL_COND_V(src_texture.is_null(), output);
- Ref src_image = src_texture->get_image();
+ Ref src_image = src_texture->get_data();
ERR_FAIL_COND_V(src_image.is_null(), output);
Rect2i region = counts[terrain_set][terrain].region;
- dst_image->initialize_data(region.size.x, region.size.y, false, src_image->get_format());
+ dst_image->create(region.size.x, region.size.y, false, src_image->get_format());
dst_image->blit_rect(src_image, region, Point2i());
dst_image->convert(Image::FORMAT_RGBA8);
dst_image->resize(p_size.x, p_size.y, Image::INTERPOLATE_NEAREST);
} else {
- dst_image->initialize_data(1, 1, false, Image::FORMAT_RGBA8);
+ dst_image->create(1, 1, false, Image::FORMAT_RGBA8);
dst_image->set_pixel(0, 0, get_terrain_color(terrain_set, terrain));
}
- Ref icon = ImageTexture::create_from_image(dst_image);
+ Ref icon;
+ icon.instance();
+ icon->create_from_image(dst_image);
icon->set_size_override(p_size);
output.write[terrain_set].write[terrain] = icon;
}
@@ -2583,12 +2607,16 @@ void LayeredTileSet::_source_changed() {
Vector LayeredTileSet::_get_square_terrain_polygon(Vector2i p_size) {
Rect2 rect(-Vector2(p_size) / 6.0, Vector2(p_size) / 3.0);
- return {
- rect.position,
- Vector2(rect.get_end().x, rect.position.y),
- rect.get_end(),
- Vector2(rect.position.x, rect.get_end().y)
- };
+
+ Vector ret;
+ ret.resize(4);
+
+ ret.write[0] = rect.position;
+ ret.write[1] = Vector2(rect.get_end().x, rect.position.y);
+ ret.write[2] = rect.get_end();
+ ret.write[3] = Vector2(rect.position.x, rect.get_end().y);
+
+ return ret;
}
Vector LayeredTileSet::_get_square_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, LayeredTileSet::CellNeighbor p_bit) {
@@ -2624,12 +2652,13 @@ Vector LayeredTileSet::_get_square_corner_or_side_terrain_peering_bit_po
}
bit_rect.position *= Vector2(p_size) / 6.0;
- Vector polygon = {
- bit_rect.position,
- Vector2(bit_rect.get_end().x, bit_rect.position.y),
- bit_rect.get_end(),
- Vector2(bit_rect.position.x, bit_rect.get_end().y)
- };
+ Vector polygon;
+ polygon.resize(4);
+
+ polygon.write[0] = bit_rect.position;
+ polygon.write[1] = Vector2(bit_rect.get_end().x, bit_rect.position.y);
+ polygon.write[2] = bit_rect.get_end();
+ polygon.write[3] = Vector2(bit_rect.position.x, bit_rect.get_end().y);
return polygon;
}
@@ -2712,12 +2741,16 @@ Vector LayeredTileSet::_get_square_side_terrain_peering_bit_polygon(Vect
Vector LayeredTileSet::_get_isometric_terrain_polygon(Vector2i p_size) {
Vector2 unit = Vector2(p_size) / 6.0;
- return {
- Vector2(1, 0) * unit,
- Vector2(0, 1) * unit,
- Vector2(-1, 0) * unit,
- Vector2(0, -1) * unit,
- };
+
+ Vector ret;
+ ret.resize(4);
+
+ ret.write[0] = Vector2(1, 0) * unit;
+ ret.write[1] = Vector2(0, 1) * unit;
+ ret.write[2] = Vector2(-1, 0) * unit;
+ ret.write[3] = Vector2(0, -1) * unit;
+
+ return ret;
}
Vector LayeredTileSet::_get_isometric_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, LayeredTileSet::CellNeighbor p_bit) {
@@ -2856,29 +2889,32 @@ Vector LayeredTileSet::_get_isometric_side_terrain_peering_bit_polygon(V
Vector LayeredTileSet::_get_half_offset_terrain_polygon(Vector2i p_size, float p_overlap, LayeredTileSet::TileOffsetAxis p_offset_axis) {
Vector2 unit = Vector2(p_size) / 6.0;
+
+ Vector ret;
+ ret.resize(6);
+
if (p_offset_axis == LayeredTileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
- return {
- Vector2(1, 1.0 - p_overlap * 2.0) * unit,
- Vector2(0, 1) * unit,
- Vector2(-1, 1.0 - p_overlap * 2.0) * unit,
- Vector2(-1, -1.0 + p_overlap * 2.0) * unit,
- Vector2(0, -1) * unit,
- Vector2(1, -1.0 + p_overlap * 2.0) * unit,
- };
+ ret.write[0] = Vector2(1, 1.0 - p_overlap * 2.0) * unit;
+ ret.write[1] = Vector2(0, 1) * unit;
+ ret.write[2] = Vector2(-1, 1.0 - p_overlap * 2.0) * unit;
+ ret.write[3] = Vector2(-1, -1.0 + p_overlap * 2.0) * unit;
+ ret.write[4] = Vector2(0, -1) * unit;
+ ret.write[5] = Vector2(1, -1.0 + p_overlap * 2.0) * unit;
+
} else {
- return {
- Vector2(1, 0) * unit,
- Vector2(1.0 - p_overlap * 2.0, -1) * unit,
- Vector2(-1.0 + p_overlap * 2.0, -1) * unit,
- Vector2(-1, 0) * unit,
- Vector2(-1.0 + p_overlap * 2.0, 1) * unit,
- Vector2(1.0 - p_overlap * 2.0, 1) * unit,
- };
+ ret.write[0] = Vector2(1, 0) * unit;
+ ret.write[1] = Vector2(1.0 - p_overlap * 2.0, -1) * unit;
+ ret.write[2] = Vector2(-1.0 + p_overlap * 2.0, -1) * unit;
+ ret.write[3] = Vector2(-1, 0) * unit;
+ ret.write[4] = Vector2(-1.0 + p_overlap * 2.0, 1) * unit;
+ ret.write[5] = Vector2(1.0 - p_overlap * 2.0, 1) * unit;
}
+
+ return ret;
}
Vector LayeredTileSet::_get_half_offset_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, LayeredTileSet::TileOffsetAxis p_offset_axis, LayeredTileSet::CellNeighbor p_bit) {
- Vector point_list = {
+ Vector2 point_list[18] = {
Vector2(3, (3.0 * (1.0 - p_overlap * 2.0)) / 2.0),
Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)),
Vector2(2, 3.0 * (1.0 - (p_overlap * 2.0) * 2.0 / 3.0)),
@@ -2902,9 +2938,10 @@ Vector LayeredTileSet::_get_half_offset_corner_or_side_terrain_peering_b
Vector2 unit = Vector2(p_size) / 6.0;
Vector polygon;
if (p_offset_axis == LayeredTileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
- for (int i = 0; i < point_list.size(); i++) {
- point_list.write[i] = point_list[i] * unit;
+ for (int i = 0; i < 18; i++) {
+ point_list[i] = point_list[i] * unit;
}
+
switch (p_bit) {
case LayeredTileSet::CELL_NEIGHBOR_RIGHT_SIDE:
polygon.push_back(point_list[17]);
@@ -2964,9 +3001,10 @@ Vector LayeredTileSet::_get_half_offset_corner_or_side_terrain_peering_b
break;
}
} else {
- for (int i = 0; i < point_list.size(); i++) {
- point_list.write[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
+ for (int i = 0; i < 18; i++) {
+ point_list[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
}
+
switch (p_bit) {
case LayeredTileSet::CELL_NEIGHBOR_RIGHT_CORNER:
polygon.push_back(point_list[3]);
@@ -3036,7 +3074,7 @@ Vector LayeredTileSet::_get_half_offset_corner_or_side_terrain_peering_b
}
Vector LayeredTileSet::_get_half_offset_corner_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, LayeredTileSet::TileOffsetAxis p_offset_axis, LayeredTileSet::CellNeighbor p_bit) {
- Vector point_list = {
+ Vector2 point_list[12] = {
Vector2(3, 0),
Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)),
Vector2(1.5, (3.0 * (1.0 - p_overlap * 2.0) + 3.0) / 2.0),
@@ -3054,8 +3092,8 @@ Vector LayeredTileSet::_get_half_offset_corner_terrain_peering_bit_polyg
Vector2 unit = Vector2(p_size) / 6.0;
Vector polygon;
if (p_offset_axis == LayeredTileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
- for (int i = 0; i < point_list.size(); i++) {
- point_list.write[i] = point_list[i] * unit;
+ for (int i = 0; i < 12; i++) {
+ point_list[i] = point_list[i] * unit;
}
switch (p_bit) {
case LayeredTileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
@@ -3092,9 +3130,10 @@ Vector LayeredTileSet::_get_half_offset_corner_terrain_peering_bit_polyg
break;
}
} else {
- for (int i = 0; i < point_list.size(); i++) {
- point_list.write[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
+ for (int i = 0; i < 12; i++) {
+ point_list[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
}
+
switch (p_bit) {
case LayeredTileSet::CELL_NEIGHBOR_RIGHT_CORNER:
polygon.push_back(point_list[2]);
@@ -3140,7 +3179,7 @@ Vector LayeredTileSet::_get_half_offset_corner_terrain_peering_bit_polyg
}
Vector LayeredTileSet::_get_half_offset_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, LayeredTileSet::TileOffsetAxis p_offset_axis, LayeredTileSet::CellNeighbor p_bit) {
- Vector point_list = {
+ Vector2 point_list[6] = {
Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)),
Vector2(0, 3),
Vector2(-3, 3.0 * (1.0 - p_overlap * 2.0)),
@@ -3152,9 +3191,10 @@ Vector LayeredTileSet::_get_half_offset_side_terrain_peering_bit_polygon
Vector2 unit = Vector2(p_size) / 6.0;
Vector polygon;
if (p_offset_axis == LayeredTileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
- for (int i = 0; i < point_list.size(); i++) {
- point_list.write[i] = point_list[i] * unit;
+ for (int i = 0; i < 6; i++) {
+ point_list[i] = point_list[i] * unit;
}
+
switch (p_bit) {
case LayeredTileSet::CELL_NEIGHBOR_RIGHT_SIDE:
polygon.push_back(point_list[5]);
@@ -3184,9 +3224,10 @@ Vector LayeredTileSet::_get_half_offset_side_terrain_peering_bit_polygon
break;
}
} else {
- for (int i = 0; i < point_list.size(); i++) {
- point_list.write[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
+ for (int i = 0; i < 6; i++) {
+ point_list[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
}
+
switch (p_bit) {
case LayeredTileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
polygon.push_back(point_list[0]);
@@ -3228,8 +3269,8 @@ Vector LayeredTileSet::_get_half_offset_side_terrain_peering_bit_polygon
void LayeredTileSet::reset_state() {
// Rendering
occlusion_layers.clear();
- tile_lines_mesh.instantiate();
- tile_filled_mesh.instantiate();
+ tile_lines_mesh.instance();
+ tile_filled_mesh.instance();
tile_meshes_dirty = true;
// Physics
@@ -3254,11 +3295,13 @@ void LayeredTileSet::reset_state() {
alternative_level_proxies.clear();
#ifndef DISABLE_DEPRECATED
- for (const KeyValue &E : compatibility_data) {
- memdelete(E.value);
+ for (const HashMap::Element *E = compatibility_data.front(); E; E = E->next) {
+ memdelete(E->value());
}
+
compatibility_data.clear();
#endif // DISABLE_DEPRECATED
+
while (!source_ids.empty()) {
remove_source(source_ids[0]);
}
@@ -3383,8 +3426,8 @@ const int LayeredTileSetSource::INVALID_TILE_ALTERNATIVE = -1;
#ifndef DISABLE_DEPRECATED
void LayeredTileSet::_compatibility_conversion() {
- for (KeyValue &E : compatibility_data) {
- CompatibilityTileData *ctd = E.value;
+ for (HashMap::Element *E = compatibility_data.front(); E; E = E->next) {
+ CompatibilityTileData *ctd = E->value();
// Add the texture
LayeredTileSetAtlasSource *atlas_source = memnew(LayeredTileSetAtlasSource);
@@ -3427,13 +3470,13 @@ void LayeredTileSet::_compatibility_conversion() {
value_array.push_back(coords);
value_array.push_back(alternative_tile);
- if (!compatibility_tilemap_mapping.has(E.key)) {
- compatibility_tilemap_mapping[E.key] = RBMap();
+ if (!compatibility_tilemap_mapping.has(E->key())) {
+ compatibility_tilemap_mapping[E->key()] = RBMap();
}
- compatibility_tilemap_mapping[E.key][key_array] = value_array;
- compatibility_tilemap_mapping_tile_modes[E.key] = COMPATIBILITY_TILE_MODE_SINGLE_TILE;
+ compatibility_tilemap_mapping[E->key()][key_array] = value_array;
+ compatibility_tilemap_mapping_tile_modes[E->key()] = COMPATIBILITY_TILE_MODE_SINGLE_TILE;
- TileData *tile_data = atlas_source->get_tile_data(coords, alternative_tile);
+ LayeredTileData *tile_data = atlas_source->get_tile_data(coords, alternative_tile);
ERR_CONTINUE(!tile_data);
tile_data->set_flip_h(flip_h);
@@ -3448,9 +3491,9 @@ void LayeredTileSet::_compatibility_conversion() {
add_occlusion_layer();
};
Ref occluder = ctd->occluder->duplicate();
- Vector polygon = ctd->occluder->get_polygon();
+ PoolVector polygon = ctd->occluder->get_polygon();
for (int index = 0; index < polygon.size(); index++) {
- polygon.write[index] = xform.xform(polygon[index] - ctd->region.get_size() / 2.0);
+ polygon.set(index, xform.xform(polygon[index] - ctd->region.get_size() / 2.0));
}
occluder->set_polygon(polygon);
tile_data->set_occluder(0, occluder);
@@ -3460,9 +3503,9 @@ void LayeredTileSet::_compatibility_conversion() {
add_navigation_layer();
}
Ref navigation = ctd->navigation->duplicate();
- Vector vertices = navigation->get_vertices();
+ PoolVector vertices = navigation->get_vertices();
for (int index = 0; index < vertices.size(); index++) {
- vertices.write[index] = xform.xform(vertices[index] - ctd->region.get_size() / 2.0);
+ vertices.set(index, xform.xform(vertices[index] - ctd->region.get_size() / 2.0));
}
navigation->set_vertices(vertices);
tile_data->set_navigation_polygon(0, navigation);
@@ -3543,11 +3586,11 @@ void LayeredTileSet::_compatibility_conversion() {
value_array.push_back(coords);
value_array.push_back(alternative_tile);
- if (!compatibility_tilemap_mapping.has(E.key)) {
- compatibility_tilemap_mapping[E.key] = RBMap();
+ if (!compatibility_tilemap_mapping.has(E->key())) {
+ compatibility_tilemap_mapping[E->key()] = RBMap();
}
- compatibility_tilemap_mapping[E.key][key_array] = value_array;
- compatibility_tilemap_mapping_tile_modes[E.key] = COMPATIBILITY_TILE_MODE_ATLAS_TILE;
+ compatibility_tilemap_mapping[E->key()][key_array] = value_array;
+ compatibility_tilemap_mapping_tile_modes[E->key()] = COMPATIBILITY_TILE_MODE_ATLAS_TILE;
TileData *tile_data = atlas_source->get_tile_data(coords, alternative_tile);
@@ -3658,7 +3701,7 @@ void LayeredTileSet::_compatibility_conversion() {
set_tile_size(max_size);
// Reset compatibility data (besides the histogram counts)
- for (const KeyValue &E : compatibility_data) {
+ for (const HashMap::Element *E = compatibility_data.front(); E; E = E->next) {
memdelete(E.value);
}
compatibility_data = HashMap();
@@ -3707,7 +3750,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
#ifndef DISABLE_DEPRECATED
// TODO: This should be moved to a dedicated conversion system (see #50691)
- if (components.size() >= 1 && components[0].is_valid_int()) {
+ if (components.size() >= 1 && components[0].is_valid_integer()) {
int id = components[0].to_int();
// Get or create the compatibility object
@@ -3870,7 +3913,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
#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_int()) {
+ 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);
@@ -3889,7 +3932,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
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_int()) {
+ } 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);
@@ -3915,7 +3958,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
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_int()) {
+ } 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);
@@ -3925,7 +3968,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
add_terrain_set();
}
set_terrain_set_mode(terrain_set_index, TerrainMode(int(p_value)));
- } else if (components.size() >= 3 && components[1].begins_with("terrain_") && components[1].trim_prefix("terrain_").is_valid_int()) {
+ } 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") {
@@ -3950,7 +3993,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
return true;
}
}
- } else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_int()) {
+ } 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);
@@ -3962,7 +4005,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
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_int()) {
+ } 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);
@@ -3981,7 +4024,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
set_custom_data_layer_type(index, Variant::Type(int(p_value)));
return true;
}
- } else if (components.size() == 2 && components[0] == "sources" && components[1].is_valid_int()) {
+ } else if (components.size() == 2 && components[0] == "sources" && components[1].is_valid_integer()) {
// Create source only if it does not exists.
int source_id = components[1].to_int();
@@ -4015,7 +4058,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
return true;
}
return false;
- } else if (components.size() == 1 && components[0].begins_with("pattern_") && components[0].trim_prefix("pattern_").is_valid_int()) {
+ } else if (components.size() == 1 && components[0].begins_with("pattern_") && components[0].trim_prefix("pattern_").is_valid_integer()) {
int pattern_index = components[0].trim_prefix("pattern_").to_int();
for (int i = patterns.size(); i <= pattern_index; i++) {
add_pattern(p_value);
@@ -4033,7 +4076,7 @@ bool LayeredTileSet::_set(const StringName &p_name, const Variant &p_value) {
bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
Vector 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_int()) {
+ 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()) {
@@ -4046,7 +4089,7 @@ bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
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_int()) {
+ } 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()) {
@@ -4062,7 +4105,7 @@ bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
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_int()) {
+ } 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()) {
@@ -4071,7 +4114,7 @@ bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
if (components[1] == "mode") {
r_ret = get_terrain_set_mode(terrain_set_index);
return true;
- } else if (components.size() >= 3 && components[1].begins_with("terrain_") && components[1].trim_prefix("terrain_").is_valid_int()) {
+ } 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;
@@ -4084,7 +4127,7 @@ bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
return true;
}
}
- } else if (components.size() == 2 && components[0].begins_with("navigation_layer_") && components[0].trim_prefix("navigation_layer_").is_valid_int()) {
+ } 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()) {
@@ -4094,7 +4137,7 @@ bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
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_int()) {
+ } 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()) {
@@ -4107,7 +4150,7 @@ bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
r_ret = get_custom_data_layer_type(index);
return true;
}
- } else if (components.size() == 2 && components[0] == "sources" && components[1].is_valid_int()) {
+ } else if (components.size() == 2 && components[0] == "sources" && components[1].is_valid_integer()) {
// Atlases data.
int source_id = components[1].to_int();
@@ -4120,31 +4163,31 @@ bool LayeredTileSet::_get(const StringName &p_name, Variant &r_ret) const {
} else if (components.size() == 2 && components[0] == "tile_proxies") {
if (components[1] == "source_level") {
Array a;
- for (const KeyValue &E : source_level_proxies) {
- a.push_back(E.key);
- a.push_back(E.value);
+ for (const RBMap::Element *E = source_level_proxies.front(); E; E = E->next()) {
+ a.push_back(E->key());
+ a.push_back(E->value());
}
r_ret = a;
return true;
} else if (components[1] == "coords_level") {
Array a;
- for (const KeyValue &E : coords_level_proxies) {
- a.push_back(E.key);
- a.push_back(E.value);
+ for (const RBMap::Element *E = coords_level_proxies.front(); E; E = E->next()) {
+ a.push_back(E->key());
+ a.push_back(E->value());
}
r_ret = a;
return true;
} else if (components[1] == "alternative_level") {
Array a;
- for (const KeyValue &E : alternative_level_proxies) {
- a.push_back(E.key);
- a.push_back(E.value);
+ for (const RBMap::Element *E = alternative_level_proxies.front(); E; E = E->next()) {
+ a.push_back(E->key());
+ a.push_back(E->value());
}
r_ret = a;
return true;
}
return false;
- } else if (components.size() == 1 && components[0].begins_with("pattern_") && components[0].trim_prefix("pattern_").is_valid_int()) {
+ } else if (components.size() == 1 && components[0].begins_with("pattern_") && components[0].trim_prefix("pattern_").is_valid_integer()) {
int pattern_index = components[0].trim_prefix("pattern_").to_int();
if (pattern_index < 0 || pattern_index >= (int)patterns.size()) {
return false;
@@ -4414,13 +4457,13 @@ void LayeredTileSet::_bind_methods() {
LayeredTileSet::LayeredTileSet() {
// Instantiate the tile meshes.
- tile_lines_mesh.instantiate();
- tile_filled_mesh.instantiate();
+ tile_lines_mesh.instance();
+ tile_filled_mesh.instance();
}
LayeredTileSet::~LayeredTileSet() {
#ifndef DISABLE_DEPRECATED
- for (const KeyValue &E : compatibility_data) {
+ for (const HashMap::Element *E = compatibility_data.front(); E; E = E->next) {
memdelete(E.value);
}
#endif // DISABLE_DEPRECATED
@@ -4641,13 +4684,13 @@ void LayeredTileSetAtlasSource::reset_state() {
void LayeredTileSetAtlasSource::set_texture(Ref p_texture) {
if (texture.is_valid()) {
- texture->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
+ texture->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
}
texture = p_texture;
if (texture.is_valid()) {
- texture->connect_changed(callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
+ texture->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
}
_queue_update_padded_texture();
@@ -4744,7 +4787,7 @@ bool LayeredTileSetAtlasSource::_set(const StringName &p_name, const Variant &p_
// Compute the vector2i if we have coordinates.
Vector coords_split = components[0].split(":");
Vector2i coords = LayeredTileSetSource::INVALID_ATLAS_COORDS;
- if (coords_split.size() == 2 && coords_split[0].is_valid_int() && coords_split[1].is_valid_int()) {
+ 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());
}
@@ -4777,7 +4820,7 @@ bool LayeredTileSetAtlasSource::_set(const StringName &p_name, const Variant &p_
} else if (components[1] == "animation_frames_count") {
set_tile_animation_frames_count(coords, p_value);
return true;
- } else if (components.size() >= 3 && components[1].begins_with("animation_frame_") && components[1].trim_prefix("animation_frame_").is_valid_int()) {
+ } else if (components.size() >= 3 && components[1].begins_with("animation_frame_") && components[1].trim_prefix("animation_frame_").is_valid_integer()) {
int frame = components[1].trim_prefix("animation_frame_").to_int();
if (components[2] == "duration") {
if (frame >= get_tile_animation_frames_count(coords)) {
@@ -4787,7 +4830,7 @@ bool LayeredTileSetAtlasSource::_set(const StringName &p_name, const Variant &p_
return true;
}
return false;
- } else if (components[1].is_valid_int()) {
+ } else if (components[1].is_valid_integer()) {
int alternative_id = components[1].to_int();
if (alternative_id != LayeredTileSetSource::INVALID_TILE_ALTERNATIVE) {
// Create the alternative if needed ?
@@ -4821,7 +4864,7 @@ bool LayeredTileSetAtlasSource::_get(const StringName &p_name, Variant &r_ret) c
// Properties.
Vector coords_split = components[0].split(":");
- if (coords_split.size() == 2 && coords_split[0].is_valid_int() && coords_split[1].is_valid_int()) {
+ 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) {
@@ -4847,7 +4890,7 @@ bool LayeredTileSetAtlasSource::_get(const StringName &p_name, Variant &r_ret) c
} else if (components[1] == "animation_frames_count") {
r_ret = get_tile_animation_frames_count(coords);
return true;
- } else if (components.size() >= 3 && components[1].begins_with("animation_frame_") && components[1].trim_prefix("animation_frame_").is_valid_int()) {
+ } else if (components.size() >= 3 && components[1].begins_with("animation_frame_") && components[1].trim_prefix("animation_frame_").is_valid_integer()) {
int frame = components[1].trim_prefix("animation_frame_").to_int();
if (frame < 0 || frame >= get_tile_animation_frames_count(coords)) {
return false;
@@ -4857,7 +4900,7 @@ bool LayeredTileSetAtlasSource::_get(const StringName &p_name, Variant &r_ret) c
return true;
}
return false;
- } else if (components[1].is_valid_int()) {
+ } else if (components[1].is_valid_integer()) {
int alternative_id = components[1].to_int();
if (alternative_id != LayeredTileSetSource::INVALID_TILE_ALTERNATIVE && tiles[coords].alternatives.has(alternative_id)) {
if (components.size() >= 3) {
@@ -4913,7 +4956,7 @@ void LayeredTileSetAtlasSource::_get_property_list(List *p_list) c
tile_property_list.push_back(property_info);
// animation_speed.
- property_info = PropertyInfo(Variant::FLOAT, "animation_speed", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR);
+ property_info = PropertyInfo(Variant::REAL, "animation_speed", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR);
if (E_tile.value.animation_speed == 1.0) {
property_info.usage ^= PROPERTY_USAGE_STORAGE;
}
@@ -4932,7 +4975,7 @@ void LayeredTileSetAtlasSource::_get_property_list(List *p_list) c
// animation_frame_*.
bool store_durations = tiles[E_tile.key].animation_frames_durations.size() >= 2;
for (int i = 0; i < (int)tiles[E_tile.key].animation_frames_durations.size(); i++) {
- property_info = PropertyInfo(Variant::FLOAT, vformat("animation_frame_%d/duration", i), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR);
+ property_info = PropertyInfo(Variant::REAL, vformat("animation_frame_%d/duration", i), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR);
if (!store_durations) {
property_info.usage ^= PROPERTY_USAGE_STORAGE;
}
@@ -5587,10 +5630,10 @@ void LayeredTileSetAtlasSource::_queue_update_padded_texture() {
Ref LayeredTileSetAtlasSource::_create_padded_image_texture(const Ref &p_source) {
ERR_FAIL_COND_V(p_source.is_null(), Ref());
- Ref src_image = p_source->get_image();
+ Ref src_image = p_source->get_data();
if (src_image.is_null()) {
Ref ret;
- ret.instantiate();
+ ret.instance();
return ret;
}
@@ -5637,7 +5680,7 @@ void LayeredTileSetAtlasSource::_update_padded_texture() {
padded_texture_needs_update = false;
if (padded_texture.is_valid()) {
- padded_texture->disconnect_changed(callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
+ padded_texture->disconnect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
}
padded_texture = Ref();
@@ -5650,7 +5693,7 @@ void LayeredTileSetAtlasSource::_update_padded_texture() {
return;
}
- padded_texture.instantiate();
+ padded_texture.instance();
Ref src_canvas_texture = texture;
if (src_canvas_texture.is_valid()) {
@@ -5684,7 +5727,7 @@ void LayeredTileSetAtlasSource::_update_padded_texture() {
Ref image_texture = _create_padded_image_texture(texture);
padded_texture->set_diffuse_texture(image_texture);
}
- padded_texture->connect_changed(callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
+ padded_texture->connect(CoreStringNames::get_singleton()->changed, callable_mp(this, &LayeredTileSetAtlasSource::_queue_update_padded_texture));
emit_changed();
}
@@ -5816,7 +5859,7 @@ int LayeredTileSetScenesCollectionSource::get_next_scene_tile_id() const {
bool LayeredTileSetScenesCollectionSource::_set(const StringName &p_name, const Variant &p_value) {
Vector components = String(p_name).split("/", true, 2);
- if (components.size() >= 2 && components[0] == "scenes" && components[1].is_valid_int()) {
+ if (components.size() >= 2 && components[0] == "scenes" && components[1].is_valid_integer()) {
int scene_id = components[1].to_int();
if (components.size() >= 3 && components[2] == "scene") {
if (has_scene_tile_id(scene_id)) {
@@ -5840,7 +5883,7 @@ bool LayeredTileSetScenesCollectionSource::_set(const StringName &p_name, const
bool LayeredTileSetScenesCollectionSource::_get(const StringName &p_name, Variant &r_ret) const {
Vector components = String(p_name).split("/", true, 2);
- if (components.size() >= 2 && components[0] == "scenes" && components[1].is_valid_int() && scenes.has(components[1].to_int())) {
+ if (components.size() >= 2 && components[0] == "scenes" && components[1].is_valid_integer() && scenes.has(components[1].to_int())) {
if (components.size() >= 3 && components[2] == "scene") {
r_ret = scenes[components[1].to_int()].scene;
return true;
@@ -5881,12 +5924,12 @@ void LayeredTileSetScenesCollectionSource::_bind_methods() {
/////////////////////////////// TileData //////////////////////////////////////
-void TileData::set_tile_set(const LayeredTileSet *p_tile_set) {
+void LayeredTileData::set_tile_set(const LayeredTileSet *p_tile_set) {
tile_set = p_tile_set;
notify_tile_data_properties_should_change();
}
-void TileData::notify_tile_data_properties_should_change() {
+void LayeredTileData::notify_tile_data_properties_should_change() {
if (!tile_set) {
return;
}
@@ -5920,7 +5963,7 @@ void TileData::notify_tile_data_properties_should_change() {
emit_signal(SNAME("changed"));
}
-void TileData::add_occlusion_layer(int p_to_pos) {
+void LayeredTileData::add_occlusion_layer(int p_to_pos) {
if (p_to_pos < 0) {
p_to_pos = occluders.size();
}
@@ -5928,19 +5971,19 @@ void TileData::add_occlusion_layer(int p_to_pos) {
occluders.insert(p_to_pos, OcclusionLayerTileData());
}
-void TileData::move_occlusion_layer(int p_from_index, int p_to_pos) {
+void LayeredTileData::move_occlusion_layer(int p_from_index, int p_to_pos) {
ERR_FAIL_INDEX(p_from_index, occluders.size());
ERR_FAIL_INDEX(p_to_pos, occluders.size() + 1);
occluders.insert(p_to_pos, occluders[p_from_index]);
occluders.remove(p_to_pos < p_from_index ? p_from_index + 1 : p_from_index);
}
-void TileData::remove_occlusion_layer(int p_index) {
+void LayeredTileData::remove_occlusion_layer(int p_index) {
ERR_FAIL_INDEX(p_index, occluders.size());
occluders.remove(p_index);
}
-void TileData::add_physics_layer(int p_to_pos) {
+void LayeredTileData::add_physics_layer(int p_to_pos) {
if (p_to_pos < 0) {
p_to_pos = physics.size();
}
@@ -5948,25 +5991,25 @@ void TileData::add_physics_layer(int p_to_pos) {
physics.insert(p_to_pos, PhysicsLayerTileData());
}
-void TileData::move_physics_layer(int p_from_index, int p_to_pos) {
+void LayeredTileData::move_physics_layer(int p_from_index, int p_to_pos) {
ERR_FAIL_INDEX(p_from_index, physics.size());
ERR_FAIL_INDEX(p_to_pos, physics.size() + 1);
physics.insert(p_to_pos, physics[p_from_index]);
physics.remove(p_to_pos < p_from_index ? p_from_index + 1 : p_from_index);
}
-void TileData::remove_physics_layer(int p_index) {
+void LayeredTileData::remove_physics_layer(int p_index) {
ERR_FAIL_INDEX(p_index, physics.size());
physics.remove(p_index);
}
-void TileData::add_terrain_set(int p_to_pos) {
+void LayeredTileData::add_terrain_set(int p_to_pos) {
if (p_to_pos >= 0 && p_to_pos <= terrain_set) {
terrain_set += 1;
}
}
-void TileData::move_terrain_set(int p_from_index, int p_to_pos) {
+void LayeredTileData::move_terrain_set(int p_from_index, int p_to_pos) {
if (p_from_index == terrain_set) {
terrain_set = (p_from_index < p_to_pos) ? p_to_pos - 1 : p_to_pos;
} else {
@@ -5979,7 +6022,7 @@ void TileData::move_terrain_set(int p_from_index, int p_to_pos) {
}
}
-void TileData::remove_terrain_set(int p_index) {
+void LayeredTileData::remove_terrain_set(int p_index) {
if (p_index == terrain_set) {
terrain_set = -1;
for (int i = 0; i < 16; i++) {
@@ -5990,7 +6033,7 @@ void TileData::remove_terrain_set(int p_index) {
}
}
-void TileData::add_terrain(int p_terrain_set, int p_to_pos) {
+void LayeredTileData::add_terrain(int p_terrain_set, int p_to_pos) {
if (terrain_set == p_terrain_set) {
for (int i = 0; i < 16; i++) {
if (p_to_pos >= 0 && p_to_pos <= terrain_peering_bits[i]) {
@@ -6000,7 +6043,7 @@ void TileData::add_terrain(int p_terrain_set, int p_to_pos) {
}
}
-void TileData::move_terrain(int p_terrain_set, int p_from_index, int p_to_pos) {
+void LayeredTileData::move_terrain(int p_terrain_set, int p_from_index, int p_to_pos) {
if (terrain_set == p_terrain_set) {
for (int i = 0; i < 16; i++) {
if (p_from_index == terrain_peering_bits[i]) {
@@ -6017,7 +6060,7 @@ void TileData::move_terrain(int p_terrain_set, int p_from_index, int p_to_pos) {
}
}
-void TileData::remove_terrain(int p_terrain_set, int p_index) {
+void LayeredTileData::remove_terrain(int p_terrain_set, int p_index) {
if (terrain_set == p_terrain_set) {
if (terrain == p_index) {
terrain = -1;
@@ -6035,7 +6078,7 @@ void TileData::remove_terrain(int p_terrain_set, int p_index) {
}
}
-void TileData::add_navigation_layer(int p_to_pos) {
+void LayeredTileData::add_navigation_layer(int p_to_pos) {
if (p_to_pos < 0) {
p_to_pos = navigation.size();
}
@@ -6043,19 +6086,19 @@ void TileData::add_navigation_layer(int p_to_pos) {
navigation.insert(p_to_pos, NavigationLayerTileData());
}
-void TileData::move_navigation_layer(int p_from_index, int p_to_pos) {
+void LayeredTileData::move_navigation_layer(int p_from_index, int p_to_pos) {
ERR_FAIL_INDEX(p_from_index, navigation.size());
ERR_FAIL_INDEX(p_to_pos, navigation.size() + 1);
navigation.insert(p_to_pos, navigation[p_from_index]);
navigation.remove(p_to_pos < p_from_index ? p_from_index + 1 : p_from_index);
}
-void TileData::remove_navigation_layer(int p_index) {
+void LayeredTileData::remove_navigation_layer(int p_index) {
ERR_FAIL_INDEX(p_index, navigation.size());
navigation.remove(p_index);
}
-void TileData::add_custom_data_layer(int p_to_pos) {
+void LayeredTileData::add_custom_data_layer(int p_to_pos) {
if (p_to_pos < 0) {
p_to_pos = custom_data.size();
}
@@ -6063,27 +6106,27 @@ void TileData::add_custom_data_layer(int p_to_pos) {
custom_data.insert(p_to_pos, Variant());
}
-void TileData::move_custom_data_layer(int p_from_index, int p_to_pos) {
+void LayeredTileData::move_custom_data_layer(int p_from_index, int p_to_pos) {
ERR_FAIL_INDEX(p_from_index, custom_data.size());
ERR_FAIL_INDEX(p_to_pos, custom_data.size() + 1);
custom_data.insert(p_to_pos, custom_data[p_from_index]);
custom_data.remove(p_to_pos < p_from_index ? p_from_index + 1 : p_from_index);
}
-void TileData::remove_custom_data_layer(int p_index) {
+void LayeredTileData::remove_custom_data_layer(int p_index) {
ERR_FAIL_INDEX(p_index, custom_data.size());
custom_data.remove(p_index);
}
-void TileData::set_allow_transform(bool p_allow_transform) {
+void LayeredTileData::set_allow_transform(bool p_allow_transform) {
allow_transform = p_allow_transform;
}
-bool TileData::is_allowing_transform() const {
+bool LayeredTileData::is_allowing_transform() const {
return allow_transform;
}
-TileData *TileData::duplicate() {
+LayeredTileData *LayeredTileData::duplicate() {
TileData *output = memnew(TileData);
output->tile_set = tile_set;
@@ -6115,83 +6158,83 @@ TileData *TileData::duplicate() {
}
// Rendering
-void TileData::set_flip_h(bool p_flip_h) {
+void LayeredTileData::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(SNAME("changed"));
}
-bool TileData::get_flip_h() const {
+bool LayeredTileData::get_flip_h() const {
return flip_h;
}
-void TileData::set_flip_v(bool p_flip_v) {
+void LayeredTileData::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(SNAME("changed"));
}
-bool TileData::get_flip_v() const {
+bool LayeredTileData::get_flip_v() const {
return flip_v;
}
-void TileData::set_transpose(bool p_transpose) {
+void LayeredTileData::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(SNAME("changed"));
}
-bool TileData::get_transpose() const {
+bool LayeredTileData::get_transpose() const {
return transpose;
}
-void TileData::set_texture_origin(Vector2i p_texture_origin) {
+void LayeredTileData::set_texture_origin(Vector2i p_texture_origin) {
texture_origin = p_texture_origin;
emit_signal(SNAME("changed"));
}
-Vector2i TileData::get_texture_origin() const {
+Vector2i LayeredTileData::get_texture_origin() const {
return texture_origin;
}
-void TileData::set_material(Ref p_material) {
+void LayeredTileData::set_material(Ref p_material) {
material = p_material;
emit_signal(SNAME("changed"));
}
-Ref TileData::get_material() const {
+Ref LayeredTileData::get_material() const {
return material;
}
-void TileData::set_modulate(Color p_modulate) {
+void LayeredTileData::set_modulate(Color p_modulate) {
modulate = p_modulate;
emit_signal(SNAME("changed"));
}
-Color TileData::get_modulate() const {
+Color LayeredTileData::get_modulate() const {
return modulate;
}
-void TileData::set_z_index(int p_z_index) {
+void LayeredTileData::set_z_index(int p_z_index) {
z_index = p_z_index;
emit_signal(SNAME("changed"));
}
-int TileData::get_z_index() const {
+int LayeredTileData::get_z_index() const {
return z_index;
}
-void TileData::set_y_sort_origin(int p_y_sort_origin) {
+void LayeredTileData::set_y_sort_origin(int p_y_sort_origin) {
y_sort_origin = p_y_sort_origin;
emit_signal(SNAME("changed"));
}
-int TileData::get_y_sort_origin() const {
+int LayeredTileData::get_y_sort_origin() const {
return y_sort_origin;
}
-void TileData::set_occluder(int p_layer_id, Ref p_occluder_polygon) {
+void LayeredTileData::set_occluder(int p_layer_id, Ref p_occluder_polygon) {
ERR_FAIL_INDEX(p_layer_id, occluders.size());
occluders.write[p_layer_id].occluder = p_occluder_polygon;
occluders.write[p_layer_id].transformed_occluders.clear();
emit_signal(SNAME("changed"));
}
-Ref TileData::get_occluder(int p_layer_id, bool p_flip_h, bool p_flip_v, bool p_transpose) const {
+Ref LayeredTileData::get_occluder(int p_layer_id, bool p_flip_h, bool p_flip_v, bool p_transpose) const {
ERR_FAIL_INDEX_V(p_layer_id, occluders.size(), Ref());
const OcclusionLayerTileData &layer_tile_data = occluders[p_layer_id];
@@ -6208,7 +6251,7 @@ Ref TileData::get_occluder(int p_layer_id, bool p_flip_h, boo
HashMap>::Iterator I = layer_tile_data.transformed_occluders.find(key);
if (!I) {
Ref transformed_polygon;
- transformed_polygon.instantiate();
+ transformed_polygon.instance();
transformed_polygon->set_polygon(get_transformed_vertices(layer_tile_data.occluder->get_polygon(), p_flip_h, p_flip_v, p_transpose));
layer_tile_data.transformed_occluders[key] = transformed_polygon;
return transformed_polygon;
@@ -6218,29 +6261,29 @@ Ref TileData::get_occluder(int p_layer_id, bool p_flip_h, boo
}
// Physics
-void TileData::set_constant_linear_velocity(int p_layer_id, const Vector2 &p_velocity) {
+void LayeredTileData::set_constant_linear_velocity(int p_layer_id, const Vector2 &p_velocity) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
physics.write[p_layer_id].linear_velocity = p_velocity;
emit_signal(SNAME("changed"));
}
-Vector2 TileData::get_constant_linear_velocity(int p_layer_id) const {
+Vector2 LayeredTileData::get_constant_linear_velocity(int p_layer_id) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), Vector2());
return physics[p_layer_id].linear_velocity;
}
-void TileData::set_constant_angular_velocity(int p_layer_id, real_t p_velocity) {
+void LayeredTileData::set_constant_angular_velocity(int p_layer_id, real_t p_velocity) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
physics.write[p_layer_id].angular_velocity = p_velocity;
emit_signal(SNAME("changed"));
}
-real_t TileData::get_constant_angular_velocity(int p_layer_id) const {
+real_t LayeredTileData::get_constant_angular_velocity(int p_layer_id) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), 0.0);
return physics[p_layer_id].angular_velocity;
}
-void TileData::set_collision_polygons_count(int p_layer_id, int p_polygons_count) {
+void LayeredTileData::set_collision_polygons_count(int p_layer_id, int p_polygons_count) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
ERR_FAIL_COND(p_polygons_count < 0);
if (p_polygons_count == physics.write[p_layer_id].polygons.size()) {
@@ -6251,25 +6294,25 @@ void TileData::set_collision_polygons_count(int p_layer_id, int p_polygons_count
emit_signal(SNAME("changed"));
}
-int TileData::get_collision_polygons_count(int p_layer_id) const {
+int LayeredTileData::get_collision_polygons_count(int p_layer_id) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), 0);
return physics[p_layer_id].polygons.size();
}
-void TileData::add_collision_polygon(int p_layer_id) {
+void LayeredTileData::add_collision_polygon(int p_layer_id) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
physics.write[p_layer_id].polygons.push_back(PhysicsLayerTileData::PolygonShapeTileData());
emit_signal(SNAME("changed"));
}
-void TileData::remove_collision_polygon(int p_layer_id, int p_polygon_index) {
+void LayeredTileData::remove_collision_polygon(int p_layer_id, int p_polygon_index) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
ERR_FAIL_INDEX(p_polygon_index, physics[p_layer_id].polygons.size());
physics.write[p_layer_id].polygons.remove(p_polygon_index);
emit_signal(SNAME("changed"));
}
-void TileData::set_collision_polygon_points(int p_layer_id, int p_polygon_index, Vector p_polygon) {
+void LayeredTileData::set_collision_polygon_points(int p_layer_id, int p_polygon_index, Vector p_polygon) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
ERR_FAIL_INDEX(p_polygon_index, physics[p_layer_id].polygons.size());
ERR_FAIL_COND_MSG(p_polygon.size() != 0 && p_polygon.size() < 3, "Invalid polygon. Needs either 0 or more than 3 points.");
@@ -6280,13 +6323,13 @@ void TileData::set_collision_polygon_points(int p_layer_id, int p_polygon_index,
polygon_shape_tile_data.shapes.clear();
} else {
// Decompose into convex shapes.
- Vector> decomp = Geometry2D::decompose_polygon_in_convex(p_polygon);
+ Vector> decomp = Geometry::decompose_polygon_in_convex(p_polygon);
ERR_FAIL_COND_MSG(decomp.empty(), "Could not decompose the polygon into convex shapes.");
polygon_shape_tile_data.shapes.resize(decomp.size());
for (int i = 0; i < decomp.size(); i++) {
Ref shape;
- shape.instantiate();
+ shape.instance();
shape->set_points(decomp[i]);
polygon_shape_tile_data.shapes[i] = shape;
}
@@ -6296,45 +6339,45 @@ void TileData::set_collision_polygon_points(int p_layer_id, int p_polygon_index,
emit_signal(SNAME("changed"));
}
-Vector TileData::get_collision_polygon_points(int p_layer_id, int p_polygon_index) const {
+Vector LayeredTileData::get_collision_polygon_points(int p_layer_id, int p_polygon_index) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), Vector());
ERR_FAIL_INDEX_V(p_polygon_index, physics[p_layer_id].polygons.size(), Vector());
return physics[p_layer_id].polygons[p_polygon_index].polygon;
}
-void TileData::set_collision_polygon_one_way(int p_layer_id, int p_polygon_index, bool p_one_way) {
+void LayeredTileData::set_collision_polygon_one_way(int p_layer_id, int p_polygon_index, bool p_one_way) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
ERR_FAIL_INDEX(p_polygon_index, physics[p_layer_id].polygons.size());
physics.write[p_layer_id].polygons.write[p_polygon_index].one_way = p_one_way;
emit_signal(SNAME("changed"));
}
-bool TileData::is_collision_polygon_one_way(int p_layer_id, int p_polygon_index) const {
+bool LayeredTileData::is_collision_polygon_one_way(int p_layer_id, int p_polygon_index) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), false);
ERR_FAIL_INDEX_V(p_polygon_index, physics[p_layer_id].polygons.size(), false);
return physics[p_layer_id].polygons[p_polygon_index].one_way;
}
-void TileData::set_collision_polygon_one_way_margin(int p_layer_id, int p_polygon_index, float p_one_way_margin) {
+void LayeredTileData::set_collision_polygon_one_way_margin(int p_layer_id, int p_polygon_index, float p_one_way_margin) {
ERR_FAIL_INDEX(p_layer_id, physics.size());
ERR_FAIL_INDEX(p_polygon_index, physics[p_layer_id].polygons.size());
physics.write[p_layer_id].polygons.write[p_polygon_index].one_way_margin = p_one_way_margin;
emit_signal(SNAME("changed"));
}
-float TileData::get_collision_polygon_one_way_margin(int p_layer_id, int p_polygon_index) const {
+float LayeredTileData::get_collision_polygon_one_way_margin(int p_layer_id, int p_polygon_index) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), 0.0);
ERR_FAIL_INDEX_V(p_polygon_index, physics[p_layer_id].polygons.size(), 0.0);
return physics[p_layer_id].polygons[p_polygon_index].one_way_margin;
}
-int TileData::get_collision_polygon_shapes_count(int p_layer_id, int p_polygon_index) const {
+int LayeredTileData::get_collision_polygon_shapes_count(int p_layer_id, int p_polygon_index) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), 0);
ERR_FAIL_INDEX_V(p_polygon_index, physics[p_layer_id].polygons.size(), 0);
return physics[p_layer_id].polygons[p_polygon_index].shapes.size();
}
-Ref TileData::get_collision_polygon_shape(int p_layer_id, int p_polygon_index, int shape_index, bool p_flip_h, bool p_flip_v, bool p_transpose) const {
+Ref LayeredTileData::get_collision_polygon_shape(int p_layer_id, int p_polygon_index, int shape_index, bool p_flip_h, bool p_flip_v, bool p_transpose) const {
ERR_FAIL_INDEX_V(p_layer_id, physics.size(), Ref());
ERR_FAIL_INDEX_V(p_polygon_index, physics[p_layer_id].polygons.size(), Ref());
ERR_FAIL_INDEX_V(shape_index, (int)physics[p_layer_id].polygons[p_polygon_index].shapes.size(), Ref());
@@ -6356,7 +6399,7 @@ Ref TileData::get_collision_polygon_shape(int p_layer_id,
shapes_data.transformed_shapes[key].resize(size);
for (int i = 0; i < size; i++) {
Ref transformed_polygon;
- transformed_polygon.instantiate();
+ transformed_polygon.instance();
transformed_polygon->set_points(get_transformed_vertices(shapes_data.shapes[shape_index]->get_points(), p_flip_h, p_flip_v, p_transpose));
shapes_data.transformed_shapes[key][i] = transformed_polygon;
}
@@ -6367,7 +6410,7 @@ Ref TileData::get_collision_polygon_shape(int p_layer_id,
}
// Terrain
-void TileData::set_terrain_set(int p_terrain_set) {
+void LayeredTileData::set_terrain_set(int p_terrain_set) {
ERR_FAIL_COND(p_terrain_set < -1);
if (p_terrain_set == terrain_set) {
return;
@@ -6384,11 +6427,11 @@ void TileData::set_terrain_set(int p_terrain_set) {
emit_signal(SNAME("changed"));
}
-int TileData::get_terrain_set() const {
+int LayeredTileData::get_terrain_set() const {
return terrain_set;
}
-void TileData::set_terrain(int p_terrain) {
+void LayeredTileData::set_terrain(int p_terrain) {
ERR_FAIL_COND(terrain_set < 0);
ERR_FAIL_COND(p_terrain < -1);
if (tile_set) {
@@ -6398,11 +6441,11 @@ void TileData::set_terrain(int p_terrain) {
emit_signal(SNAME("changed"));
}
-int TileData::get_terrain() const {
+int LayeredTileData::get_terrain() const {
return terrain;
}
-void TileData::set_terrain_peering_bit(LayeredTileSet::CellNeighbor p_peering_bit, int p_terrain_index) {
+void LayeredTileData::set_terrain_peering_bit(LayeredTileSet::CellNeighbor p_peering_bit, int p_terrain_index) {
ERR_FAIL_INDEX(p_peering_bit, LayeredTileSet::CellNeighbor::CELL_NEIGHBOR_MAX);
ERR_FAIL_COND(terrain_set < 0);
ERR_FAIL_COND(p_terrain_index < -1);
@@ -6414,18 +6457,18 @@ void TileData::set_terrain_peering_bit(LayeredTileSet::CellNeighbor p_peering_bi
emit_signal(SNAME("changed"));
}
-int TileData::get_terrain_peering_bit(LayeredTileSet::CellNeighbor p_peering_bit) const {
+int LayeredTileData::get_terrain_peering_bit(LayeredTileSet::CellNeighbor p_peering_bit) const {
ERR_FAIL_COND_V(!is_valid_terrain_peering_bit(p_peering_bit), -1);
return terrain_peering_bits[p_peering_bit];
}
-bool TileData::is_valid_terrain_peering_bit(LayeredTileSet::CellNeighbor p_peering_bit) const {
+bool LayeredTileData::is_valid_terrain_peering_bit(LayeredTileSet::CellNeighbor p_peering_bit) const {
ERR_FAIL_NULL_V(tile_set, false);
return tile_set->is_valid_terrain_peering_bit(terrain_set, p_peering_bit);
}
-LayeredTileSet::TerrainsPattern TileData::get_terrains_pattern() const {
+LayeredTileSet::TerrainsPattern LayeredTileData::get_terrains_pattern() const {
ERR_FAIL_NULL_V(tile_set, LayeredTileSet::TerrainsPattern());
LayeredTileSet::TerrainsPattern output(tile_set, terrain_set);
@@ -6439,14 +6482,14 @@ LayeredTileSet::TerrainsPattern TileData::get_terrains_pattern() const {
}
// Navigation
-void TileData::set_navigation_polygon(int p_layer_id, Ref p_navigation_polygon) {
+void LayeredTileData::set_navigation_polygon(int p_layer_id, Ref p_navigation_polygon) {
ERR_FAIL_INDEX(p_layer_id, navigation.size());
navigation.write[p_layer_id].navigation_polygon = p_navigation_polygon;
navigation.write[p_layer_id].transformed_navigation_polygon.clear();
emit_signal(SNAME("changed"));
}
-Ref TileData::get_navigation_polygon(int p_layer_id, bool p_flip_h, bool p_flip_v, bool p_transpose) const {
+Ref LayeredTileData::get_navigation_polygon(int p_layer_id, bool p_flip_h, bool p_flip_v, bool p_transpose) const {
ERR_FAIL_INDEX_V(p_layer_id, navigation.size(), Ref());
const NavigationLayerTileData &layer_tile_data = navigation[p_layer_id];
@@ -6463,7 +6506,7 @@ Ref TileData::get_navigation_polygon(int p_layer_id, bool p_f
HashMap>::Iterator I = layer_tile_data.transformed_navigation_polygon.find(key);
if (!I) {
Ref