gaming/godot
gaming/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot synced 2024-09-15 22:48:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix NavigationServer internals still using float instead of real_t

Browse source 
Fixes that some NavigationServer internals still used float instead of real_t in some parts.
This commit is contained in:
smix8 2023-03-07 15:16:07 +01:00
parent 013a457068
commit 217a27014b
9 changed files with 43 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
modules/navigation/nav_base.h
View file

@ -40,8 +40,8 @@ class NavMap;
class NavBase : public NavRid { class NavBase : public NavRid {
protected: protected:
uint32_t navigation_layers = 1; uint32_t navigation_layers = 1;
float enter_cost = 0.0; real_t enter_cost = 0.0;
float travel_cost = 1.0; real_t travel_cost = 1.0;
ObjectID owner_id; ObjectID owner_id;
NavigationUtilities::PathSegmentType type; NavigationUtilities::PathSegmentType type;
@ -51,11 +51,11 @@ public:
void set_navigation_layers(uint32_t p_navigation_layers) { navigation_layers = p_navigation_layers; } void set_navigation_layers(uint32_t p_navigation_layers) { navigation_layers = p_navigation_layers; }
uint32_t get_navigation_layers() const { return navigation_layers; } uint32_t get_navigation_layers() const { return navigation_layers; }
void set_enter_cost(float p_enter_cost) { enter_cost = MAX(p_enter_cost, 0.0); } void set_enter_cost(real_t p_enter_cost) { enter_cost = MAX(p_enter_cost, 0.0); }
float get_enter_cost() const { return enter_cost; } real_t get_enter_cost() const { return enter_cost; }
void set_travel_cost(float p_travel_cost) { travel_cost = MAX(p_travel_cost, 0.0); } void set_travel_cost(real_t p_travel_cost) { travel_cost = MAX(p_travel_cost, 0.0); }
float get_travel_cost() const { return travel_cost; } real_t get_travel_cost() const { return travel_cost; }
void set_owner_id(ObjectID p_owner_id) { owner_id = p_owner_id; } void set_owner_id(ObjectID p_owner_id) { owner_id = p_owner_id; }
ObjectID get_owner_id() const { return owner_id; } ObjectID get_owner_id() const { return owner_id; }

38
modules/navigation/nav_map.cpp
View file

@ -55,17 +55,17 @@ void NavMap::set_up(Vector3 p_up) {
regenerate_polygons = true; regenerate_polygons = true;
} }
void NavMap::set_cell_size(float p_cell_size) { void NavMap::set_cell_size(real_t p_cell_size) {
cell_size = p_cell_size; cell_size = p_cell_size;
regenerate_polygons = true; regenerate_polygons = true;
} }
void NavMap::set_edge_connection_margin(float p_edge_connection_margin) { void NavMap::set_edge_connection_margin(real_t p_edge_connection_margin) {
edge_connection_margin = p_edge_connection_margin; edge_connection_margin = p_edge_connection_margin;
regenerate_links = true; regenerate_links = true;
} }
void NavMap::set_link_connection_radius(float p_link_connection_radius) { void NavMap::set_link_connection_radius(real_t p_link_connection_radius) {
link_connection_radius = p_link_connection_radius; link_connection_radius = p_link_connection_radius;
regenerate_links = true; regenerate_links = true;
} }
@ -100,8 +100,8 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
const gd::Polygon *end_poly = nullptr; const gd::Polygon *end_poly = nullptr;
Vector3 begin_point; Vector3 begin_point;
Vector3 end_point; Vector3 end_point;
float begin_d = 1e20; real_t begin_d = FLT_MAX;
float end_d = 1e20; real_t end_d = FLT_MAX;
// Find the initial poly and the end poly on this map. // Find the initial poly and the end poly on this map.
for (const gd::Polygon &p : polygons) { for (const gd::Polygon &p : polygons) {
// Only consider the polygon if it in a region with compatible layers. // Only consider the polygon if it in a region with compatible layers.
@ -114,7 +114,7 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
const Face3 face(p.points[0].pos, p.points[point_id - 1].pos, p.points[point_id].pos); const Face3 face(p.points[0].pos, p.points[point_id - 1].pos, p.points[point_id].pos);
Vector3 point = face.get_closest_point_to(p_origin); Vector3 point = face.get_closest_point_to(p_origin);
float distance_to_point = point.distance_to(p_origin); real_t distance_to_point = point.distance_to(p_origin);
if (distance_to_point < begin_d) { if (distance_to_point < begin_d) {
begin_d = distance_to_point; begin_d = distance_to_point;
begin_poly = &p; begin_poly = &p;
@ -183,7 +183,7 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
bool found_route = false; bool found_route = false;
const gd::Polygon *reachable_end = nullptr; const gd::Polygon *reachable_end = nullptr;
float reachable_d = 1e30; real_t reachable_d = FLT_MAX;
bool is_reachable = true; bool is_reachable = true;
while (true) { while (true) {
@ -199,8 +199,8 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
} }
const gd::NavigationPoly &least_cost_poly = navigation_polys[least_cost_id]; const gd::NavigationPoly &least_cost_poly = navigation_polys[least_cost_id];
float poly_enter_cost = 0.0; real_t poly_enter_cost = 0.0;
float poly_travel_cost = least_cost_poly.poly->owner->get_travel_cost(); real_t poly_travel_cost = least_cost_poly.poly->owner->get_travel_cost();
if (prev_least_cost_id != -1 && (navigation_polys[prev_least_cost_id].poly->owner->get_self() != least_cost_poly.poly->owner->get_self())) { if (prev_least_cost_id != -1 && (navigation_polys[prev_least_cost_id].poly->owner->get_self() != least_cost_poly.poly->owner->get_self())) {
poly_enter_cost = least_cost_poly.poly->owner->get_enter_cost(); poly_enter_cost = least_cost_poly.poly->owner->get_enter_cost();
@ -209,7 +209,7 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
Vector3 pathway[2] = { connection.pathway_start, connection.pathway_end }; Vector3 pathway[2] = { connection.pathway_start, connection.pathway_end };
const Vector3 new_entry = Geometry3D::get_closest_point_to_segment(least_cost_poly.entry, pathway); const Vector3 new_entry = Geometry3D::get_closest_point_to_segment(least_cost_poly.entry, pathway);
const float new_distance = (least_cost_poly.entry.distance_to(new_entry) * poly_travel_cost) + poly_enter_cost + least_cost_poly.traveled_distance; const real_t new_distance = (least_cost_poly.entry.distance_to(new_entry) * poly_travel_cost) + poly_enter_cost + least_cost_poly.traveled_distance;
int64_t already_visited_polygon_index = navigation_polys.find(gd::NavigationPoly(connection.polygon)); int64_t already_visited_polygon_index = navigation_polys.find(gd::NavigationPoly(connection.polygon));
@ -257,11 +257,11 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
// Set as end point the furthest reachable point. // Set as end point the furthest reachable point.
end_poly = reachable_end; end_poly = reachable_end;
end_d = 1e20; end_d = FLT_MAX;
for (size_t point_id = 2; point_id < end_poly->points.size(); point_id++) { for (size_t point_id = 2; point_id < end_poly->points.size(); point_id++) {
Face3 f(end_poly->points[0].pos, end_poly->points[point_id - 1].pos, end_poly->points[point_id].pos); Face3 f(end_poly->points[0].pos, end_poly->points[point_id - 1].pos, end_poly->points[point_id].pos);
Vector3 spoint = f.get_closest_point_to(p_destination); Vector3 spoint = f.get_closest_point_to(p_destination);
float dpoint = spoint.distance_to(p_destination); real_t dpoint = spoint.distance_to(p_destination);
if (dpoint < end_d) { if (dpoint < end_d) {
end_point = spoint; end_point = spoint;
end_d = dpoint; end_d = dpoint;
@ -284,10 +284,10 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
// Find the polygon with the minimum cost from the list of polygons to visit. // Find the polygon with the minimum cost from the list of polygons to visit.
least_cost_id = -1; least_cost_id = -1;
float least_cost = 1e30; real_t least_cost = FLT_MAX;
for (List<uint32_t>::Element *element = to_visit.front(); element != nullptr; element = element->next()) { for (List<uint32_t>::Element *element = to_visit.front(); element != nullptr; element = element->next()) {
gd::NavigationPoly *np = &navigation_polys[element->get()]; gd::NavigationPoly *np = &navigation_polys[element->get()];
float cost = np->traveled_distance; real_t cost = np->traveled_distance;
cost += (np->entry.distance_to(end_point) * np->poly->owner->get_travel_cost()); cost += (np->entry.distance_to(end_point) * np->poly->owner->get_travel_cost());
if (cost < least_cost) { if (cost < least_cost) {
least_cost_id = np->self_id; least_cost_id = np->self_id;
@ -299,7 +299,7 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
// Stores the further reachable end polygon, in case our goal is not reachable. // Stores the further reachable end polygon, in case our goal is not reachable.
if (is_reachable) { if (is_reachable) {
float d = navigation_polys[least_cost_id].entry.distance_to(p_destination) * navigation_polys[least_cost_id].poly->owner->get_travel_cost(); real_t d = navigation_polys[least_cost_id].entry.distance_to(p_destination) * navigation_polys[least_cost_id].poly->owner->get_travel_cost();
if (reachable_d > d) { if (reachable_d > d) {
reachable_d = d; reachable_d = d;
reachable_end = navigation_polys[least_cost_id].poly; reachable_end = navigation_polys[least_cost_id].poly;
@ -459,7 +459,7 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
Vector3 NavMap::get_closest_point_to_segment(const Vector3 &p_from, const Vector3 &p_to, const bool p_use_collision) const { Vector3 NavMap::get_closest_point_to_segment(const Vector3 &p_from, const Vector3 &p_to, const bool p_use_collision) const {
bool use_collision = p_use_collision; bool use_collision = p_use_collision;
Vector3 closest_point; Vector3 closest_point;
real_t closest_point_d = 1e20; real_t closest_point_d = FLT_MAX;
for (const gd::Polygon &p : polygons) { for (const gd::Polygon &p : polygons) {
// For each face check the distance to the segment // For each face check the distance to the segment
@ -520,7 +520,7 @@ RID NavMap::get_closest_point_owner(const Vector3 &p_point) const {
gd::ClosestPointQueryResult NavMap::get_closest_point_info(const Vector3 &p_point) const { gd::ClosestPointQueryResult NavMap::get_closest_point_info(const Vector3 &p_point) const {
gd::ClosestPointQueryResult result; gd::ClosestPointQueryResult result;
real_t closest_point_ds = 1e20; real_t closest_point_ds = FLT_MAX;
for (size_t i(0); i < polygons.size(); i++) { for (size_t i(0); i < polygons.size(); i++) {
const gd::Polygon &p = polygons[i]; const gd::Polygon &p = polygons[i];
@ -734,8 +734,8 @@ void NavMap::sync() {
// Compute the projection of the opposite edge on the current one // Compute the projection of the opposite edge on the current one
Vector3 edge_vector = edge_p2 - edge_p1; Vector3 edge_vector = edge_p2 - edge_p1;
float projected_p1_ratio = edge_vector.dot(other_edge_p1 - edge_p1) / (edge_vector.length_squared()); real_t projected_p1_ratio = edge_vector.dot(other_edge_p1 - edge_p1) / (edge_vector.length_squared());
float projected_p2_ratio = edge_vector.dot(other_edge_p2 - edge_p1) / (edge_vector.length_squared()); real_t projected_p2_ratio = edge_vector.dot(other_edge_p2 - edge_p1) / (edge_vector.length_squared());
if ((projected_p1_ratio < 0.0 && projected_p2_ratio < 0.0) || (projected_p1_ratio > 1.0 && projected_p2_ratio > 1.0)) { if ((projected_p1_ratio < 0.0 && projected_p2_ratio < 0.0) || (projected_p1_ratio > 1.0 && projected_p2_ratio > 1.0)) {
continue; continue;
} }

12
modules/navigation/nav_map.h
View file

@ -108,18 +108,18 @@ public:
return up; return up;
} }
void set_cell_size(float p_cell_size); void set_cell_size(real_t p_cell_size);
float get_cell_size() const { real_t get_cell_size() const {
return cell_size; return cell_size;
} }
void set_edge_connection_margin(float p_edge_connection_margin); void set_edge_connection_margin(real_t p_edge_connection_margin);
float get_edge_connection_margin() const { real_t get_edge_connection_margin() const {
return edge_connection_margin; return edge_connection_margin;
} }
void set_link_connection_radius(float p_link_connection_radius); void set_link_connection_radius(real_t p_link_connection_radius);
float get_link_connection_radius() const { real_t get_link_connection_radius() const {
return link_connection_radius; return link_connection_radius;
} }

4
modules/navigation/nav_region.cpp
View file

@ -114,7 +114,7 @@ void NavRegion::update_polygons() {
p.edges.resize(mesh_poly.size()); p.edges.resize(mesh_poly.size());
Vector3 center; Vector3 center;
float sum(0); real_t sum(0);
for (int j(0); j < mesh_poly.size(); j++) { for (int j(0); j < mesh_poly.size(); j++) {
int idx = indices[j]; int idx = indices[j];
@ -143,7 +143,7 @@ void NavRegion::update_polygons() {
p.clockwise = sum > 0; p.clockwise = sum > 0;
if (mesh_poly.size() != 0) { if (mesh_poly.size() != 0) {
p.center = center / float(mesh_poly.size()); p.center = center / real_t(mesh_poly.size());
} }
} }
} }

2
modules/navigation/nav_utils.h
View file

@ -128,7 +128,7 @@ struct NavigationPoly {
/// The entry position of this poly. /// The entry position of this poly.
Vector3 entry; Vector3 entry;
/// The distance to the destination. /// The distance to the destination.
float traveled_distance = 0.0; real_t traveled_distance = 0.0;
NavigationPoly() { poly = nullptr; } NavigationPoly() { poly = nullptr; }

4
servers/navigation_server_2d.cpp
View file

@ -257,11 +257,11 @@ bool NavigationServer2D::get_debug_navigation_enable_agent_paths() const {
return NavigationServer3D::get_singleton()->get_debug_navigation_enable_agent_paths(); return NavigationServer3D::get_singleton()->get_debug_navigation_enable_agent_paths();
} }
void NavigationServer2D::set_debug_navigation_agent_path_point_size(float p_point_size) { void NavigationServer2D::set_debug_navigation_agent_path_point_size(real_t p_point_size) {
NavigationServer3D::get_singleton()->set_debug_navigation_agent_path_point_size(p_point_size); NavigationServer3D::get_singleton()->set_debug_navigation_agent_path_point_size(p_point_size);
} }
float NavigationServer2D::get_debug_navigation_agent_path_point_size() const { real_t NavigationServer2D::get_debug_navigation_agent_path_point_size() const {
return NavigationServer3D::get_singleton()->get_debug_navigation_agent_path_point_size(); return NavigationServer3D::get_singleton()->get_debug_navigation_agent_path_point_size();
} }
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED

4
servers/navigation_server_2d.h
View file

@ -274,8 +274,8 @@ public:
void set_debug_navigation_enable_agent_paths(const bool p_value); void set_debug_navigation_enable_agent_paths(const bool p_value);
bool get_debug_navigation_enable_agent_paths() const; bool get_debug_navigation_enable_agent_paths() const;
void set_debug_navigation_agent_path_point_size(float p_point_size); void set_debug_navigation_agent_path_point_size(real_t p_point_size);
float get_debug_navigation_agent_path_point_size() const; real_t get_debug_navigation_agent_path_point_size() const;
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED

4
servers/navigation_server_3d.cpp
View file

@ -456,14 +456,14 @@ Color NavigationServer3D::get_debug_navigation_link_connection_disabled_color()
return debug_navigation_link_connection_disabled_color; return debug_navigation_link_connection_disabled_color;
} }
void NavigationServer3D::set_debug_navigation_agent_path_point_size(float p_point_size) { void NavigationServer3D::set_debug_navigation_agent_path_point_size(real_t p_point_size) {
debug_navigation_agent_path_point_size = MAX(0.1, p_point_size); debug_navigation_agent_path_point_size = MAX(0.1, p_point_size);
if (debug_navigation_agent_path_point_material.is_valid()) { if (debug_navigation_agent_path_point_material.is_valid()) {
debug_navigation_agent_path_point_material->set_point_size(debug_navigation_agent_path_point_size); debug_navigation_agent_path_point_material->set_point_size(debug_navigation_agent_path_point_size);
} }
} }
float NavigationServer3D::get_debug_navigation_agent_path_point_size() const { real_t NavigationServer3D::get_debug_navigation_agent_path_point_size() const {
return debug_navigation_agent_path_point_size; return debug_navigation_agent_path_point_size;
} }

6
servers/navigation_server_3d.h
View file

@ -293,7 +293,7 @@ private:
Color debug_navigation_link_connection_disabled_color = Color(0.5, 0.5, 0.5, 1.0); Color debug_navigation_link_connection_disabled_color = Color(0.5, 0.5, 0.5, 1.0);
Color debug_navigation_agent_path_color = Color(1.0, 0.0, 0.0, 1.0); Color debug_navigation_agent_path_color = Color(1.0, 0.0, 0.0, 1.0);
float debug_navigation_agent_path_point_size = 4.0; real_t debug_navigation_agent_path_point_size = 4.0;
bool debug_navigation_enable_edge_connections = true; bool debug_navigation_enable_edge_connections = true;
bool debug_navigation_enable_edge_connections_xray = true; bool debug_navigation_enable_edge_connections_xray = true;
@ -368,8 +368,8 @@ public:
void set_debug_navigation_enable_agent_paths_xray(const bool p_value); void set_debug_navigation_enable_agent_paths_xray(const bool p_value);
bool get_debug_navigation_enable_agent_paths_xray() const; bool get_debug_navigation_enable_agent_paths_xray() const;
void set_debug_navigation_agent_path_point_size(float p_point_size); void set_debug_navigation_agent_path_point_size(real_t p_point_size);
float get_debug_navigation_agent_path_point_size() const; real_t get_debug_navigation_agent_path_point_size() const;
Ref<StandardMaterial3D> get_debug_navigation_geometry_face_material(); Ref<StandardMaterial3D> get_debug_navigation_geometry_face_material();
Ref<StandardMaterial3D> get_debug_navigation_geometry_edge_material(); Ref<StandardMaterial3D> get_debug_navigation_geometry_edge_material();