godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-04 12:00:25 +00:00
Code Releases Wiki Activity

Merge pull request #105252 from smix8/nav2d_point

Browse Source 
Replace NavigationServer2D `Point` struct with `Vector2`
This commit is contained in:
Thaddeus Crews
2025-04-11 09:51:05 -05:00
parent 717df3ee88 1c03b15b4f
commit 3bcc45617b
4 changed files with 58 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
modules/navigation_2d/2d/nav_map_builder_2d.cpp
View File

@@ -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);
}
}

60
modules/navigation_2d/2d/nav_mesh_queries_2d.cpp
View File

@@ -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) {

5
modules/navigation_2d/nav_region_2d.cpp
View File

@@ -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;

8
modules/navigation_2d/nav_utils_2d.h
View File

@@ -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;