Merge pull request #105252 from smix8/nav2d_point

Replace NavigationServer2D `Point` struct with `Vector2`

modules/navigation_2d/2d/nav_map_builder_2d.cpp

@@ -106,7 +106,7 @@ void NavMapBuilder2D::_build_step_find_edge_connection_pairs(NavMapIterationBuil
 	PerformanceData &performance_data = r_build.performance_data;
 	NavMapIteration2D *map_iteration = r_build.map_iteration;
 	int polygon_count = r_build.polygon_count;
-
+	const Vector2 merge_rasterizer_cell_size = r_build.merge_rasterizer_cell_size;
 	HashMap<EdgeKey, EdgeConnectionPair, EdgeKey> &connection_pairs_map = r_build.iter_connection_pairs_map;
 
 	// Group all edges per key.
@@ -120,9 +120,9 @@ void NavMapBuilder2D::_build_step_find_edge_connection_pairs(NavMapIterationBuil
 		}
 
 		for (Polygon &poly : region.navmesh_polygons) {
-			for (uint32_t p = 0; p < poly.points.size(); p++) {
-				const int next_point = (p + 1) % poly.points.size();
-				const EdgeKey ek(poly.points[p].key, poly.points[next_point].key);
+			for (uint32_t p = 0; p < poly.vertices.size(); p++) {
+				const int next_point = (p + 1) % poly.vertices.size();
+				const EdgeKey ek(get_point_key(poly.vertices[p], merge_rasterizer_cell_size), get_point_key(poly.vertices[next_point], merge_rasterizer_cell_size));
 
 				HashMap<EdgeKey, EdgeConnectionPair, EdgeKey>::Iterator pair_it = connection_pairs_map.find(ek);
 				if (!pair_it) {
@@ -136,8 +136,8 @@ void NavMapBuilder2D::_build_step_find_edge_connection_pairs(NavMapIterationBuil
 					Edge::Connection new_connection;
 					new_connection.polygon = &poly;
 					new_connection.edge = p;
-					new_connection.pathway_start = poly.points[p].pos;
-					new_connection.pathway_end = poly.points[next_point].pos;
+					new_connection.pathway_start = poly.vertices[p];
+					new_connection.pathway_end = poly.vertices[next_point];
 
 					pair.connections[pair.size] = new_connection;
 					++pair.size;
@@ -207,8 +207,8 @@ void NavMapBuilder2D::_build_step_edge_connection_margin_connections(NavMapItera
 
 	for (uint32_t i = 0; i < free_edges.size(); i++) {
 		const Edge::Connection &free_edge = free_edges[i];
-		Vector2 edge_p1 = free_edge.polygon->points[free_edge.edge].pos;
-		Vector2 edge_p2 = free_edge.polygon->points[(free_edge.edge + 1) % free_edge.polygon->points.size()].pos;
+		Vector2 edge_p1 = free_edge.polygon->vertices[free_edge.edge];
+		Vector2 edge_p2 = free_edge.polygon->vertices[(free_edge.edge + 1) % free_edge.polygon->vertices.size()];
 
 		for (uint32_t j = 0; j < free_edges.size(); j++) {
 			const Edge::Connection &other_edge = free_edges[j];
@@ -216,8 +216,8 @@ void NavMapBuilder2D::_build_step_edge_connection_margin_connections(NavMapItera
 				continue;
 			}
 
-			Vector2 other_edge_p1 = other_edge.polygon->points[other_edge.edge].pos;
-			Vector2 other_edge_p2 = other_edge.polygon->points[(other_edge.edge + 1) % other_edge.polygon->points.size()].pos;
+			Vector2 other_edge_p1 = other_edge.polygon->vertices[other_edge.edge];
+			Vector2 other_edge_p2 = other_edge.polygon->vertices[(other_edge.edge + 1) % other_edge.polygon->vertices.size()];
 
 			// Compute the projection of the opposite edge on the current one.
 			Vector2 edge_vector = edge_p2 - edge_p1;
@@ -267,7 +267,6 @@ void NavMapBuilder2D::_build_step_navlink_connections(NavMapIterationBuild2D &r_
 	NavMapIteration2D *map_iteration = r_build.map_iteration;
 
 	real_t link_connection_radius = r_build.link_connection_radius;
-	Vector2 merge_rasterizer_cell_size = r_build.merge_rasterizer_cell_size;
 
 	LocalVector<Polygon> &link_polygons = map_iteration->link_polygons;
 	LocalVector<NavLinkIteration2D> &links = map_iteration->link_iterations;
@@ -303,8 +302,8 @@ void NavMapBuilder2D::_build_step_navlink_connections(NavMapIterationBuild2D &r_
 			}
 
 			for (Polygon &polyon : region.navmesh_polygons) {
-				for (uint32_t point_id = 2; point_id < polyon.points.size(); point_id += 1) {
-					const Triangle2 triangle(polyon.points[0].pos, polyon.points[point_id - 1].pos, polyon.points[point_id].pos);
+				for (uint32_t point_id = 2; point_id < polyon.vertices.size(); point_id += 1) {
+					const Triangle2 triangle(polyon.vertices[0], polyon.vertices[point_id - 1], polyon.vertices[point_id]);
 
 					{
 						const Vector2 start_point = triangle.get_closest_point_to(link_start_pos);
@@ -341,28 +340,28 @@ void NavMapBuilder2D::_build_step_navlink_connections(NavMapIterationBuild2D &r_
 
 			new_polygon.edges.clear();
 			new_polygon.edges.resize(4);
-			new_polygon.points.resize(4);
+			new_polygon.vertices.resize(4);
 
 			// Build a set of vertices that create a thin polygon going from the start to the end point.
-			new_polygon.points[0] = { closest_start_point, get_point_key(closest_start_point, merge_rasterizer_cell_size) };
-			new_polygon.points[1] = { closest_start_point, get_point_key(closest_start_point, merge_rasterizer_cell_size) };
-			new_polygon.points[2] = { closest_end_point, get_point_key(closest_end_point, merge_rasterizer_cell_size) };
-			new_polygon.points[3] = { closest_end_point, get_point_key(closest_end_point, merge_rasterizer_cell_size) };
+			new_polygon.vertices[0] = closest_start_point;
+			new_polygon.vertices[1] = closest_start_point;
+			new_polygon.vertices[2] = closest_end_point;
+			new_polygon.vertices[3] = closest_end_point;
 
 			// Setup connections to go forward in the link.
 			{
 				Edge::Connection entry_connection;
 				entry_connection.polygon = &new_polygon;
 				entry_connection.edge = -1;
-				entry_connection.pathway_start = new_polygon.points[0].pos;
-				entry_connection.pathway_end = new_polygon.points[1].pos;
+				entry_connection.pathway_start = new_polygon.vertices[0];
+				entry_connection.pathway_end = new_polygon.vertices[1];
 				closest_start_polygon->edges[0].connections.push_back(entry_connection);
 
 				Edge::Connection exit_connection;
 				exit_connection.polygon = closest_end_polygon;
 				exit_connection.edge = -1;
-				exit_connection.pathway_start = new_polygon.points[2].pos;
-				exit_connection.pathway_end = new_polygon.points[3].pos;
+				exit_connection.pathway_start = new_polygon.vertices[2];
+				exit_connection.pathway_end = new_polygon.vertices[3];
 				new_polygon.edges[2].connections.push_back(exit_connection);
 			}
 
@@ -371,15 +370,15 @@ void NavMapBuilder2D::_build_step_navlink_connections(NavMapIterationBuild2D &r_
 				Edge::Connection entry_connection;
 				entry_connection.polygon = &new_polygon;
 				entry_connection.edge = -1;
-				entry_connection.pathway_start = new_polygon.points[2].pos;
-				entry_connection.pathway_end = new_polygon.points[3].pos;
+				entry_connection.pathway_start = new_polygon.vertices[2];
+				entry_connection.pathway_end = new_polygon.vertices[3];
 				closest_end_polygon->edges[0].connections.push_back(entry_connection);
 
 				Edge::Connection exit_connection;
 				exit_connection.polygon = closest_start_polygon;
 				exit_connection.edge = -1;
-				exit_connection.pathway_start = new_polygon.points[0].pos;
-				exit_connection.pathway_end = new_polygon.points[1].pos;
+				exit_connection.pathway_start = new_polygon.vertices[0];
+				exit_connection.pathway_end = new_polygon.vertices[1];
 				new_polygon.edges[0].connections.push_back(exit_connection);
 			}
 		}

modules/navigation_2d/2d/nav_mesh_queries_2d.cpp

@@ -90,8 +90,8 @@ Vector2 NavMeshQueries2D::polygons_get_random_point(const LocalVector<Polygon> &
 		real_t accumulated_polygon_area = 0;
 		RBMap<real_t, uint32_t> polygon_area_map;
 
-		for (uint32_t rpp_index = 2; rpp_index < rr_polygon.points.size(); rpp_index++) {
-			real_t triangle_area = Triangle2(rr_polygon.points[0].pos, rr_polygon.points[rpp_index - 1].pos, rr_polygon.points[rpp_index].pos).get_area();
+		for (uint32_t rpp_index = 2; rpp_index < rr_polygon.vertices.size(); rpp_index++) {
+			real_t triangle_area = Triangle2(rr_polygon.vertices[0], rr_polygon.vertices[rpp_index - 1], rr_polygon.vertices[rpp_index]).get_area();
 
 			if (triangle_area == 0.0) {
 				continue;
@@ -109,9 +109,9 @@ Vector2 NavMeshQueries2D::polygons_get_random_point(const LocalVector<Polygon> &
 		RBMap<real_t, uint32_t>::Iterator polygon_E = polygon_area_map.find_closest(polygon_area_map_pos);
 		ERR_FAIL_COND_V(!polygon_E, Vector2());
 		uint32_t rrp_face_index = polygon_E->value;
-		ERR_FAIL_UNSIGNED_INDEX_V(rrp_face_index, rr_polygon.points.size(), Vector2());
+		ERR_FAIL_UNSIGNED_INDEX_V(rrp_face_index, rr_polygon.vertices.size(), Vector2());
 
-		const Triangle2 triangle(rr_polygon.points[0].pos, rr_polygon.points[rrp_face_index - 1].pos, rr_polygon.points[rrp_face_index].pos);
+		const Triangle2 triangle(rr_polygon.vertices[0], rr_polygon.vertices[rrp_face_index - 1], rr_polygon.vertices[rrp_face_index]);
 
 		Vector2 triangle_random_position = triangle.get_random_point_inside();
 		return triangle_random_position;
@@ -121,9 +121,9 @@ Vector2 NavMeshQueries2D::polygons_get_random_point(const LocalVector<Polygon> &
 
 		const Polygon &rr_polygon = region_polygons[rrp_polygon_index];
 
-		uint32_t rrp_face_index = Math::random(int(2), rr_polygon.points.size() - 1);
+		uint32_t rrp_face_index = Math::random(int(2), rr_polygon.vertices.size() - 1);
 
-		const Triangle2 triangle(rr_polygon.points[0].pos, rr_polygon.points[rrp_face_index - 1].pos, rr_polygon.points[rrp_face_index].pos);
+		const Triangle2 triangle(rr_polygon.vertices[0], rr_polygon.vertices[rrp_face_index - 1], rr_polygon.vertices[rrp_face_index]);
 
 		Vector2 triangle_random_position = triangle.get_random_point_inside();
 		return triangle_random_position;
@@ -256,8 +256,8 @@ void NavMeshQueries2D::_query_task_find_start_end_positions(NavMeshPathQueryTask
 			}
 
 			// For each triangle check the distance between the origin/destination.
-			for (uint32_t point_id = 2; point_id < p.points.size(); point_id++) {
-				const Triangle2 triangle(p.points[0].pos, p.points[point_id - 1].pos, p.points[point_id].pos);
+			for (uint32_t point_id = 2; point_id < p.vertices.size(); point_id++) {
+				const Triangle2 triangle(p.vertices[0], p.vertices[point_id - 1], p.vertices[point_id]);
 
 				Vector2 point = triangle.get_closest_point_to(p_query_task.start_position);
 				real_t distance_to_point = point.distance_to(p_query_task.start_position);
@@ -371,8 +371,8 @@ void NavMeshQueries2D::_query_task_build_path_corridor(NavMeshPathQueryTask2D &p
 			// Set as end point the furthest reachable point.
 			end_poly = reachable_end;
 			real_t end_d = FLT_MAX;
-			for (uint32_t point_id = 2; point_id < end_poly->points.size(); point_id++) {
-				Triangle2 t(end_poly->points[0].pos, end_poly->points[point_id - 1].pos, end_poly->points[point_id].pos);
+			for (uint32_t point_id = 2; point_id < end_poly->vertices.size(); point_id++) {
+				Triangle2 t(end_poly->vertices[0], end_poly->vertices[point_id - 1], end_poly->vertices[point_id]);
 				Vector2 spoint = t.get_closest_point_to(p_target_position);
 				real_t dpoint = spoint.distance_squared_to(p_target_position);
 				if (dpoint < end_d) {
@@ -383,8 +383,8 @@ void NavMeshQueries2D::_query_task_build_path_corridor(NavMeshPathQueryTask2D &p
 
 			// Search all faces of start polygon as well.
 			bool closest_point_on_start_poly = false;
-			for (uint32_t point_id = 2; point_id < begin_poly->points.size(); point_id++) {
-				Triangle2 t(begin_poly->points[0].pos, begin_poly->points[point_id - 1].pos, begin_poly->points[point_id].pos);
+			for (uint32_t point_id = 2; point_id < begin_poly->vertices.size(); point_id++) {
+				Triangle2 t(begin_poly->vertices[0], begin_poly->vertices[point_id - 1], begin_poly->vertices[point_id]);
 				Vector2 spoint = t.get_closest_point_to(p_target_position);
 				real_t dpoint = spoint.distance_squared_to(p_target_position);
 				if (dpoint < end_d) {
@@ -442,8 +442,8 @@ void NavMeshQueries2D::_query_task_build_path_corridor(NavMeshPathQueryTask2D &p
 	if (!found_route) {
 		real_t end_d = FLT_MAX;
 		// Search all faces of the start polygon for the closest point to our target position.
-		for (uint32_t point_id = 2; point_id < begin_poly->points.size(); point_id++) {
-			Triangle2 t(begin_poly->points[0].pos, begin_poly->points[point_id - 1].pos, begin_poly->points[point_id].pos);
+		for (uint32_t point_id = 2; point_id < begin_poly->vertices.size(); point_id++) {
+			Triangle2 t(begin_poly->vertices[0], begin_poly->vertices[point_id - 1], begin_poly->vertices[point_id]);
 			Vector2 spoint = t.get_closest_point_to(p_target_position);
 			real_t dpoint = spoint.distance_squared_to(p_target_position);
 			if (dpoint < end_d) {
@@ -682,8 +682,8 @@ void NavMeshQueries2D::_query_task_post_process_edgecentered(NavMeshPathQueryTas
 	while (np_id != -1 && navigation_polys[np_id].back_navigation_poly_id != -1) {
 		if (navigation_polys[np_id].back_navigation_edge != -1) {
 			int prev = navigation_polys[np_id].back_navigation_edge;
-			int prev_n = (navigation_polys[np_id].back_navigation_edge + 1) % navigation_polys[np_id].poly->points.size();
-			Vector2 point = (navigation_polys[np_id].poly->points[prev].pos + navigation_polys[np_id].poly->points[prev_n].pos) * 0.5;
+			int prev_n = (navigation_polys[np_id].back_navigation_edge + 1) % navigation_polys[np_id].poly->vertices.size();
+			Vector2 point = (navigation_polys[np_id].poly->vertices[prev] + navigation_polys[np_id].poly->vertices[prev_n]) * 0.5;
 
 			_query_task_push_back_point_with_metadata(p_query_task, point, navigation_polys[np_id].poly);
 		} else {
@@ -736,13 +736,13 @@ ClosestPointQueryResult NavMeshQueries2D::map_iteration_get_closest_point_info(c
 	const LocalVector<NavRegionIteration2D> &regions = p_map_iteration.region_iterations;
 	for (const NavRegionIteration2D &region : regions) {
 		for (const Polygon &polygon : region.get_navmesh_polygons()) {
-			real_t cross = (polygon.points[1].pos - polygon.points[0].pos).cross(polygon.points[2].pos - polygon.points[0].pos);
+			real_t cross = (polygon.vertices[1] - polygon.vertices[0]).cross(polygon.vertices[2] - polygon.vertices[0]);
 			Vector2 closest_on_polygon;
 			real_t closest = FLT_MAX;
 			bool inside = true;
-			Vector2 previous = polygon.points[polygon.points.size() - 1].pos;
-			for (uint32_t point_id = 0; point_id < polygon.points.size(); ++point_id) {
-				Vector2 edge = polygon.points[point_id].pos - previous;
+			Vector2 previous = polygon.vertices[polygon.vertices.size() - 1];
+			for (uint32_t point_id = 0; point_id < polygon.vertices.size(); ++point_id) {
+				Vector2 edge = polygon.vertices[point_id] - previous;
 				Vector2 to_point = p_point - previous;
 				real_t edge_to_point_cross = edge.cross(to_point);
 				bool clockwise = (edge_to_point_cross * cross) > 0;
@@ -753,9 +753,9 @@ ClosestPointQueryResult NavMeshQueries2D::map_iteration_get_closest_point_info(c
 					real_t edge_square = edge.length_squared();
 
 					if (point_projected_on_edge > edge_square) {
-						real_t distance = polygon.points[point_id].pos.distance_squared_to(p_point);
+						real_t distance = polygon.vertices[point_id].distance_squared_to(p_point);
 						if (distance < closest) {
-							closest_on_polygon = polygon.points[point_id].pos;
+							closest_on_polygon = polygon.vertices[point_id];
 							closest = distance;
 						}
 					} else if (point_projected_on_edge < 0.0) {
@@ -771,7 +771,7 @@ ClosestPointQueryResult NavMeshQueries2D::map_iteration_get_closest_point_info(c
 						break;
 					}
 				}
-				previous = polygon.points[point_id].pos;
+				previous = polygon.vertices[point_id];
 			}
 
 			if (inside) {
@@ -868,13 +868,13 @@ ClosestPointQueryResult NavMeshQueries2D::polygons_get_closest_point_info(const
 	// TODO: Check for further 2D improvements.
 
 	for (const Polygon &polygon : p_polygons) {
-		real_t cross = (polygon.points[1].pos - polygon.points[0].pos).cross(polygon.points[2].pos - polygon.points[0].pos);
+		real_t cross = (polygon.vertices[1] - polygon.vertices[0]).cross(polygon.vertices[2] - polygon.vertices[0]);
 		Vector2 closest_on_polygon;
 		real_t closest = FLT_MAX;
 		bool inside = true;
-		Vector2 previous = polygon.points[polygon.points.size() - 1].pos;
-		for (uint32_t point_id = 0; point_id < polygon.points.size(); ++point_id) {
-			Vector2 edge = polygon.points[point_id].pos - previous;
+		Vector2 previous = polygon.vertices[polygon.vertices.size() - 1];
+		for (uint32_t point_id = 0; point_id < polygon.vertices.size(); ++point_id) {
+			Vector2 edge = polygon.vertices[point_id] - previous;
 			Vector2 to_point = p_point - previous;
 			real_t edge_to_point_cross = edge.cross(to_point);
 			bool clockwise = (edge_to_point_cross * cross) > 0;
@@ -885,9 +885,9 @@ ClosestPointQueryResult NavMeshQueries2D::polygons_get_closest_point_info(const
 				real_t edge_square = edge.length_squared();
 
 				if (point_projected_on_edge > edge_square) {
-					real_t distance = polygon.points[point_id].pos.distance_squared_to(p_point);
+					real_t distance = polygon.vertices[point_id].distance_squared_to(p_point);
 					if (distance < closest) {
-						closest_on_polygon = polygon.points[point_id].pos;
+						closest_on_polygon = polygon.vertices[point_id];
 						closest = distance;
 					}
 				} else if (point_projected_on_edge < 0.0) {
@@ -903,7 +903,7 @@ ClosestPointQueryResult NavMeshQueries2D::polygons_get_closest_point_info(const
 					break;
 				}
 			}
-			previous = polygon.points[point_id].pos;
+			previous = polygon.vertices[point_id];
 		}
 
 		if (inside) {

modules/navigation_2d/nav_region_2d.cpp

@@ -229,7 +229,7 @@ void NavRegion2D::update_polygons() {
 		const int *indices = navigation_mesh_polygon.ptr();
 		bool valid(true);
 
-		polygon.points.resize(navigation_mesh_polygon_size);
+		polygon.vertices.resize(navigation_mesh_polygon_size);
 		polygon.edges.resize(navigation_mesh_polygon_size);
 
 		real_t _new_polygon_surface_area = 0.0;
@@ -254,8 +254,7 @@ void NavRegion2D::update_polygons() {
 			}
 
 			Vector2 point_position = transform.xform(vertices_r[idx]);
-			polygon.points[j].pos = point_position;
-			polygon.points[j].key = NavMapBuilder2D::get_point_key(point_position, map->get_merge_rasterizer_cell_size());
+			polygon.vertices[j] = point_position;
 
 			if (first_vertex) {
 				first_vertex = false;

modules/navigation_2d/nav_utils_2d.h

@@ -71,11 +71,6 @@ struct EdgeKey {
 	}
 };
 
-struct Point {
-	Vector2 pos;
-	PointKey key;
-};
-
 struct Edge {
 	/// The gateway in the edge, as, in some case, the whole edge might not be navigable.
 	struct Connection {
@@ -103,8 +98,7 @@ struct Polygon {
 	/// Navigation region or link that contains this polygon.
 	const NavBaseIteration2D *owner = nullptr;
 
-	/// The points of this `Polygon`
-	LocalVector<Point> points;
+	LocalVector<Vector2> vertices;
 
 	/// The edges of this `Polygon`
 	LocalVector<Edge> edges;