Renamed plane's d to distance

8 files changed, 41 insertions, 41 deletions

diff --git a/modules/bullet/shape_bullet.cpp b/modules/bullet/shape_bullet.cpp
index 8ac26a0fdb..e28683ba78 100644
--- a/modules/bullet/shape_bullet.cpp
+++ b/modules/bullet/shape_bullet.cpp
@@ -188,7 +188,7 @@ void PlaneShapeBullet::setup(const Plane &p_plane) {
 btCollisionShape *PlaneShapeBullet::create_bt_shape(const btVector3 &p_implicit_scale, real_t p_extra_edge) {
 	btVector3 btPlaneNormal;
 	G_TO_B(plane.normal, btPlaneNormal);
-	return prepare(PlaneShapeBullet::create_shape_plane(btPlaneNormal, plane.d));
+	return prepare(PlaneShapeBullet::create_shape_plane(btPlaneNormal, plane.distance));
 }
 
 /* Sphere */
diff --git a/modules/gdnative/gdnative/plane.cpp b/modules/gdnative/gdnative/plane.cpp
index 17221fe081..054673d9cc 100644
--- a/modules/gdnative/gdnative/plane.cpp
+++ b/modules/gdnative/gdnative/plane.cpp
@@ -37,10 +37,10 @@
 extern "C" {
 #endif
 
-void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d) {
+void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_distance) {
 
 	Plane *dest = (Plane *)r_dest;
-	*dest = Plane(p_a, p_b, p_c, p_d);
+	*dest = Plane(p_a, p_b, p_c, p_distance);
 }
 
 void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3) {
@@ -162,14 +162,14 @@ godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self) {
 	return *v3;
 }
 
-godot_real GDAPI godot_plane_get_d(const godot_plane *p_self) {
+godot_real GDAPI godot_plane_get_distance(const godot_plane *p_self) {
 	const Plane *self = (const Plane *)p_self;
-	return self->d;
+	return self->distance;
 }
 
-void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d) {
+void GDAPI godot_plane_set_distance(godot_plane *p_self, const godot_real p_distance) {
 	Plane *self = (Plane *)p_self;
-	self->d = p_d;
+	self->distance = p_distance;
 }
 
 #ifdef __cplusplus
diff --git a/modules/gdnative/gdnative_api.json b/modules/gdnative/gdnative_api.json
index d5ab62dc61..c4b8098fc6 100644
--- a/modules/gdnative/gdnative_api.json
+++ b/modules/gdnative/gdnative_api.json
@@ -3120,14 +3120,14 @@
         ]
       },
       {
-        "name": "godot_plane_get_d",
+        "name": "godot_plane_get_distance",
         "return_type": "godot_real",
         "arguments": [
           ["const godot_plane *", "p_self"]
         ]
       },
       {
-        "name": "godot_plane_set_d",
+        "name": "godot_plane_set_distance",
         "return_type": "void",
         "arguments": [
           ["godot_plane *", "p_self"],
diff --git a/modules/gdnative/include/gdnative/plane.h b/modules/gdnative/include/gdnative/plane.h
index b759a8cc1a..6bd28d7363 100644
--- a/modules/gdnative/include/gdnative/plane.h
+++ b/modules/gdnative/include/gdnative/plane.h
@@ -92,9 +92,9 @@ void GDAPI godot_plane_set_normal(godot_plane *p_self, const godot_vector3 *p_no
 
 godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self);
 
-godot_real GDAPI godot_plane_get_d(const godot_plane *p_self);
+godot_real GDAPI godot_plane_get_distance(const godot_plane *p_self);
 
-void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d);
+void GDAPI godot_plane_set_distance(godot_plane *p_self, const godot_real p_distance);
 
 #ifdef __cplusplus
 }
diff --git a/modules/gdnavigation/nav_map.cpp b/modules/gdnavigation/nav_map.cpp
index 7e6a3f7a26..9652938251 100644
--- a/modules/gdnavigation/nav_map.cpp
+++ b/modules/gdnavigation/nav_map.cpp
@@ -783,7 +783,7 @@ void NavMap::clip_path(const std::vector<gd::NavigationPoly> &p_navigation_polys
 	if (cut_plane.normal == Vector3())
 		return;
 	cut_plane.normal.normalize();
-	cut_plane.d = cut_plane.normal.dot(from);
+	cut_plane.distance = cut_plane.normal.dot(from);
 
 	while (from_poly != p_to_poly) {
 
diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp
index 9abbac6a0b..b0c2c75c19 100644
--- a/modules/gridmap/grid_map_editor_plugin.cpp
+++ b/modules/gridmap/grid_map_editor_plugin.cpp
@@ -385,7 +385,7 @@ bool GridMapEditor::do_input_action(Camera3D *p_camera, const Point2 &p_point, b
 
 	Plane p;
 	p.normal[edit_axis] = 1.0;
-	p.d = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
+	p.distance = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
 
 	Vector3 inters;
 	if (!p.intersects_segment(from, from + normal * settings_pick_distance->get_value(), &inters))
@@ -1137,7 +1137,7 @@ void GridMapEditor::_notification(int p_what) {
 
 				Plane p;
 				p.normal[edit_axis] = 1.0;
-				p.d = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
+				p.distance = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
 				p = node->get_transform().xform(p); // plane to snap
 
 				Node3DEditorPlugin *sep = Object::cast_to<Node3DEditorPlugin>(editor->get_editor_plugin_screen());
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
index 885845e3a4..55a83642fd 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
@@ -56,29 +56,29 @@ namespace Godot
             }
         }
 
-        public real_t D { get; set; }
+        public real_t Distance { get; set; }
 
         public Vector3 Center
         {
             get
             {
-                return _normal * D;
+                return _normal * Distance;
             }
         }
 
         public real_t DistanceTo(Vector3 point)
         {
-            return _normal.Dot(point) - D;
+            return _normal.Dot(point) - Distance;
         }
 
         public Vector3 GetAnyPoint()
         {
-            return _normal * D;
+            return _normal * Distance;
         }
 
         public bool HasPoint(Vector3 point, real_t epsilon = Mathf.Epsilon)
         {
-            real_t dist = _normal.Dot(point) - D;
+            real_t dist = _normal.Dot(point) - Distance;
             return Mathf.Abs(dist) <= epsilon;
         }
 
@@ -89,9 +89,9 @@ namespace Godot
             if (Mathf.IsZeroApprox(denom))
                 return null;
 
-            Vector3 result = b._normal.Cross(c._normal) * D +
-                                c._normal.Cross(_normal) * b.D +
-                                _normal.Cross(b._normal) * c.D;
+            Vector3 result = b._normal.Cross(c._normal) * Distance +
+                                c._normal.Cross(_normal) * b.Distance +
+                                _normal.Cross(b._normal) * c.Distance;
 
             return result / denom;
         }
@@ -103,7 +103,7 @@ namespace Godot
             if (Mathf.IsZeroApprox(den))
                 return null;
 
-            real_t dist = (_normal.Dot(from) - D) / den;
+            real_t dist = (_normal.Dot(from) - Distance) / den;
 
             // This is a ray, before the emitting pos (from) does not exist
             if (dist > Mathf.Epsilon)
@@ -120,7 +120,7 @@ namespace Godot
             if (Mathf.IsZeroApprox(den))
                 return null;
 
-            real_t dist = (_normal.Dot(begin) - D) / den;
+            real_t dist = (_normal.Dot(begin) - Distance) / den;
 
             // Only allow dist to be in the range of 0 to 1, with tolerance.
             if (dist < -Mathf.Epsilon || dist > 1.0f + Mathf.Epsilon)
@@ -131,7 +131,7 @@ namespace Godot
 
         public bool IsPointOver(Vector3 point)
         {
-            return _normal.Dot(point) > D;
+            return _normal.Dot(point) > Distance;
         }
 
         public Plane Normalized()
@@ -141,7 +141,7 @@ namespace Godot
             if (len == 0)
                 return new Plane(0, 0, 0, 0);
 
-            return new Plane(_normal / len, D / len);
+            return new Plane(_normal / len, Distance / len);
         }
 
         public Vector3 Project(Vector3 point)
@@ -159,27 +159,27 @@ namespace Godot
         public static Plane PlaneXY { get { return _planeXY; } }
 
         // Constructors
-        public Plane(real_t a, real_t b, real_t c, real_t d)
+        public Plane(real_t a, real_t b, real_t c, real_t distance)
         {
             _normal = new Vector3(a, b, c);
-            this.D = d;
+            this.Distance = distance;
         }
-        public Plane(Vector3 normal, real_t d)
+        public Plane(Vector3 normal, real_t distance)
         {
             this._normal = normal;
-            this.D = d;
+            this.Distance = distance;
         }
 
         public Plane(Vector3 v1, Vector3 v2, Vector3 v3)
         {
             _normal = (v1 - v3).Cross(v1 - v2);
             _normal.Normalize();
-            D = _normal.Dot(v1);
+            Distance = _normal.Dot(v1);
         }
 
         public static Plane operator -(Plane plane)
         {
-            return new Plane(-plane._normal, -plane.D);
+            return new Plane(-plane._normal, -plane.Distance);
         }
 
         public static bool operator ==(Plane left, Plane right)
@@ -204,17 +204,17 @@ namespace Godot
 
         public bool Equals(Plane other)
         {
-            return _normal == other._normal && D == other.D;
+            return _normal == other._normal && Distance == other.Distance;
         }
 
         public bool IsEqualApprox(Plane other)
         {
-            return _normal.IsEqualApprox(other._normal) && Mathf.IsEqualApprox(D, other.D);
+            return _normal.IsEqualApprox(other._normal) && Mathf.IsEqualApprox(Distance, other.Distance);
         }
 
         public override int GetHashCode()
         {
-            return _normal.GetHashCode() ^ D.GetHashCode();
+            return _normal.GetHashCode() ^ Distance.GetHashCode();
         }
 
         public override string ToString()
@@ -222,7 +222,7 @@ namespace Godot
             return String.Format("({0}, {1})", new object[]
             {
                 _normal.ToString(),
-                D.ToString()
+                Distance.ToString()
             });
         }
 
@@ -231,7 +231,7 @@ namespace Godot
             return String.Format("({0}, {1})", new object[]
             {
                 _normal.ToString(format),
-                D.ToString(format)
+                Distance.ToString(format)
             });
         }
     }
diff --git a/modules/mono/mono_gd/gd_mono_marshal.h b/modules/mono/mono_gd/gd_mono_marshal.h
index f2d887e6d6..fd645f1608 100644
--- a/modules/mono/mono_gd/gd_mono_marshal.h
+++ b/modules/mono/mono_gd/gd_mono_marshal.h
@@ -274,7 +274,7 @@ enum {
 
 	MATCHES_Plane = (MATCHES_Vector3 && MATCHES_real_t && (sizeof(Plane) == (sizeof(Vector3) + sizeof(real_t))) &&
 					 offsetof(Plane, normal) == 0 &&
-					 offsetof(Plane, d) == sizeof(Vector3))
+					 offsetof(Plane, distance) == sizeof(Vector3))
 };
 
 // In the future we may force this if we want to ref return these structs
@@ -466,14 +466,14 @@ struct M_Color {
 
 struct M_Plane {
 	M_Vector3 normal;
-	real_t d;
+	real_t distance;
 
 	static _FORCE_INLINE_ Plane convert_to(const M_Plane &p_from) {
-		return Plane(M_Vector3::convert_to(p_from.normal), p_from.d);
+		return Plane(M_Vector3::convert_to(p_from.normal), p_from.distance);
 	}
 
 	static _FORCE_INLINE_ M_Plane convert_from(const Plane &p_from) {
-		M_Plane ret = { M_Vector3::convert_from(p_from.normal), p_from.d };
+		M_Plane ret = { M_Vector3::convert_from(p_from.normal), p_from.distance };
 		return ret;
 	}
 };