Revert "Renamed plane's d to distance"

This reverts commit ec7b481170dcd6a7b4cf0e6c1221e204ff7945f3.

This was wrong, `d` is not a distance but the `d` constant in the
parametric equation `ax + by + cz = d` describing the plane.

6 files changed, 35 insertions, 35 deletions

diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp
index a091b5d00d..76321b0679 100644
--- a/core/math/camera_matrix.cpp
+++ b/core/math/camera_matrix.cpp
@@ -59,10 +59,10 @@ Plane CameraMatrix::xform4(const Plane &p_vec4) const {
 
 	Plane ret;
 
-	ret.normal.x = matrix[0][0] * p_vec4.normal.x + matrix[1][0] * p_vec4.normal.y + matrix[2][0] * p_vec4.normal.z + matrix[3][0] * p_vec4.distance;
-	ret.normal.y = matrix[0][1] * p_vec4.normal.x + matrix[1][1] * p_vec4.normal.y + matrix[2][1] * p_vec4.normal.z + matrix[3][1] * p_vec4.distance;
-	ret.normal.z = matrix[0][2] * p_vec4.normal.x + matrix[1][2] * p_vec4.normal.y + matrix[2][2] * p_vec4.normal.z + matrix[3][2] * p_vec4.distance;
-	ret.distance = matrix[0][3] * p_vec4.normal.x + matrix[1][3] * p_vec4.normal.y + matrix[2][3] * p_vec4.normal.z + matrix[3][3] * p_vec4.distance;
+	ret.normal.x = matrix[0][0] * p_vec4.normal.x + matrix[1][0] * p_vec4.normal.y + matrix[2][0] * p_vec4.normal.z + matrix[3][0] * p_vec4.d;
+	ret.normal.y = matrix[0][1] * p_vec4.normal.x + matrix[1][1] * p_vec4.normal.y + matrix[2][1] * p_vec4.normal.z + matrix[3][1] * p_vec4.d;
+	ret.normal.z = matrix[0][2] * p_vec4.normal.x + matrix[1][2] * p_vec4.normal.y + matrix[2][2] * p_vec4.normal.z + matrix[3][2] * p_vec4.d;
+	ret.d = matrix[0][3] * p_vec4.normal.x + matrix[1][3] * p_vec4.normal.y + matrix[2][3] * p_vec4.normal.z + matrix[3][3] * p_vec4.d;
 	return ret;
 }
 
@@ -233,7 +233,7 @@ real_t CameraMatrix::get_z_far() const {
 	new_plane.normal = -new_plane.normal;
 	new_plane.normalize();
 
-	return new_plane.distance;
+	return new_plane.d;
 }
 real_t CameraMatrix::get_z_near() const {
 
@@ -244,7 +244,7 @@ real_t CameraMatrix::get_z_near() const {
 			-matrix[15] - matrix[14]);
 
 	new_plane.normalize();
-	return new_plane.distance;
+	return new_plane.d;
 }
 
 Vector2 CameraMatrix::get_viewport_half_extents() const {
diff --git a/core/math/geometry.cpp b/core/math/geometry.cpp
index 95789f97ea..e556eb3b9c 100644
--- a/core/math/geometry.cpp
+++ b/core/math/geometry.cpp
@@ -781,7 +781,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
 					if (Math::is_zero_approx(den))
 						continue; // Point too short.
 
-					real_t dist = -(clip.normal.dot(edge0_A) - clip.distance) / den;
+					real_t dist = -(clip.normal.dot(edge0_A) - clip.d) / den;
 					Vector3 inters = edge0_A + rel * dist;
 					new_vertices.push_back(inters);
 				}
@@ -1224,7 +1224,7 @@ Vector<Vector3> Geometry::compute_convex_mesh_points(const Plane *p_planes, int
 					for (int n = 0; n < p_plane_count; n++) {
 						if (n != i && n != j && n != k) {
 							real_t dp = p_planes[n].normal.dot(convex_shape_point);
-							if (dp - p_planes[n].distance > CMP_EPSILON) {
+							if (dp - p_planes[n].d > CMP_EPSILON) {
 								excluded = true;
 								break;
 							}
diff --git a/core/math/math_fieldwise.cpp b/core/math/math_fieldwise.cpp
index e42c399ba4..a47d4ef7ad 100644
--- a/core/math/math_fieldwise.cpp
+++ b/core/math/math_fieldwise.cpp
@@ -89,7 +89,7 @@ Variant fieldwise_assign(const Variant &p_target, const Variant &p_source, const
 			/**/ TRY_TRANSFER_FIELD("x", normal.x)
 			else TRY_TRANSFER_FIELD("y", normal.y)
 			else TRY_TRANSFER_FIELD("z", normal.z)
-			else TRY_TRANSFER_FIELD("d", distance)
+			else TRY_TRANSFER_FIELD("d", d)
 
 			return target;
 		}
diff --git a/core/math/plane.cpp b/core/math/plane.cpp
index c375913756..a3818698bc 100644
--- a/core/math/plane.cpp
+++ b/core/math/plane.cpp
@@ -45,7 +45,7 @@ void Plane::normalize() {
 		return;
 	}
 	normal /= l;
-	distance /= l;
+	d /= l;
 }
 
 Plane Plane::normalized() const {
@@ -57,7 +57,7 @@ Plane Plane::normalized() const {
 
 Vector3 Plane::get_any_point() const {
 
-	return get_normal() * distance;
+	return get_normal() * d;
 }
 
 Vector3 Plane::get_any_perpendicular_normal() const {
@@ -92,9 +92,9 @@ bool Plane::intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r
 		return false;
 
 	if (r_result) {
-		*r_result = ((vec3_cross(normal1, normal2) * p_plane0.distance) +
-							(vec3_cross(normal2, normal0) * p_plane1.distance) +
-							(vec3_cross(normal0, normal1) * p_plane2.distance)) /
+		*r_result = ((vec3_cross(normal1, normal2) * p_plane0.d) +
+							(vec3_cross(normal2, normal0) * p_plane1.d) +
+							(vec3_cross(normal0, normal1) * p_plane2.d)) /
 					denom;
 	}
 
@@ -112,7 +112,7 @@ bool Plane::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3
 		return false;
 	}
 
-	real_t dist = (normal.dot(p_from) - distance) / den;
+	real_t dist = (normal.dot(p_from) - d) / den;
 	//printf("dist is %i\n",dist);
 
 	if (dist > CMP_EPSILON) { //this is a ray, before the emitting pos (p_from) doesn't exist
@@ -137,7 +137,7 @@ bool Plane::intersects_segment(const Vector3 &p_begin, const Vector3 &p_end, Vec
 		return false;
 	}
 
-	real_t dist = (normal.dot(p_begin) - distance) / den;
+	real_t dist = (normal.dot(p_begin) - d) / den;
 	//printf("dist is %i\n",dist);
 
 	if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) {
@@ -155,10 +155,10 @@ bool Plane::intersects_segment(const Vector3 &p_begin, const Vector3 &p_end, Vec
 
 bool Plane::is_equal_approx(const Plane &p_plane) const {
 
-	return normal.is_equal_approx(p_plane.normal) && Math::is_equal_approx(distance, p_plane.distance);
+	return normal.is_equal_approx(p_plane.normal) && Math::is_equal_approx(d, p_plane.d);
 }
 
 Plane::operator String() const {
 
-	return normal.operator String() + ", " + rtos(distance);
+	return normal.operator String() + ", " + rtos(d);
 }
diff --git a/core/math/plane.h b/core/math/plane.h
index 1409a4140f..771c8fc705 100644
--- a/core/math/plane.h
+++ b/core/math/plane.h
@@ -36,7 +36,7 @@
 class Plane {
 public:
 	Vector3 normal;
-	real_t distance;
+	real_t d;
 
 	void set_normal(const Vector3 &p_normal);
 	_FORCE_INLINE_ Vector3 get_normal() const { return normal; }; ///Point is coplanar, CMP_EPSILON for precision
@@ -46,7 +46,7 @@ public:
 
 	/* Plane-Point operations */
 
-	_FORCE_INLINE_ Vector3 center() const { return normal * distance; }
+	_FORCE_INLINE_ Vector3 center() const { return normal * d; }
 	Vector3 get_any_point() const;
 	Vector3 get_any_perpendicular_normal() const;
 
@@ -67,7 +67,7 @@ public:
 
 	/* misc */
 
-	Plane operator-() const { return Plane(-normal, -distance); }
+	Plane operator-() const { return Plane(-normal, -d); }
 	bool is_equal_approx(const Plane &p_plane) const;
 
 	_FORCE_INLINE_ bool operator==(const Plane &p_plane) const;
@@ -75,41 +75,41 @@ public:
 	operator String() const;
 
 	_FORCE_INLINE_ Plane() :
-			distance(0) {}
+			d(0) {}
 	_FORCE_INLINE_ Plane(real_t p_a, real_t p_b, real_t p_c, real_t p_d) :
 			normal(p_a, p_b, p_c),
-			distance(p_d) {}
+			d(p_d) {}
 
-	_FORCE_INLINE_ Plane(const Vector3 &p_normal, real_t p_distance);
+	_FORCE_INLINE_ Plane(const Vector3 &p_normal, real_t p_d);
 	_FORCE_INLINE_ Plane(const Vector3 &p_point, const Vector3 &p_normal);
 	_FORCE_INLINE_ Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3, ClockDirection p_dir = CLOCKWISE);
 };
 
 bool Plane::is_point_over(const Vector3 &p_point) const {
 
-	return (normal.dot(p_point) > distance);
+	return (normal.dot(p_point) > d);
 }
 
 real_t Plane::distance_to(const Vector3 &p_point) const {
 
-	return (normal.dot(p_point) - distance);
+	return (normal.dot(p_point) - d);
 }
 
 bool Plane::has_point(const Vector3 &p_point, real_t _epsilon) const {
 
-	real_t dist = normal.dot(p_point) - distance;
+	real_t dist = normal.dot(p_point) - d;
 	dist = ABS(dist);
 	return (dist <= _epsilon);
 }
 
-Plane::Plane(const Vector3 &p_normal, real_t p_distance) :
+Plane::Plane(const Vector3 &p_normal, real_t p_d) :
 		normal(p_normal),
-		distance(p_distance) {
+		d(p_d) {
 }
 
 Plane::Plane(const Vector3 &p_point, const Vector3 &p_normal) :
 		normal(p_normal),
-		distance(p_normal.dot(p_point)) {
+		d(p_normal.dot(p_point)) {
 }
 
 Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3, ClockDirection p_dir) {
@@ -120,17 +120,17 @@ Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_
 		normal = (p_point1 - p_point2).cross(p_point1 - p_point3);
 
 	normal.normalize();
-	distance = normal.dot(p_point1);
+	d = normal.dot(p_point1);
 }
 
 bool Plane::operator==(const Plane &p_plane) const {
 
-	return normal == p_plane.normal && distance == p_plane.distance;
+	return normal == p_plane.normal && d == p_plane.d;
 }
 
 bool Plane::operator!=(const Plane &p_plane) const {
 
-	return normal != p_plane.normal || distance != p_plane.distance;
+	return normal != p_plane.normal || d != p_plane.d;
 }
 
 #endif // PLANE_H
diff --git a/core/math/transform.h b/core/math/transform.h
index edbabc9c8b..c6e3be4c70 100644
--- a/core/math/transform.h
+++ b/core/math/transform.h
@@ -132,7 +132,7 @@ _FORCE_INLINE_ Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
 
 _FORCE_INLINE_ Plane Transform::xform(const Plane &p_plane) const {
 
-	Vector3 point = p_plane.normal * p_plane.distance;
+	Vector3 point = p_plane.normal * p_plane.d;
 	Vector3 point_dir = point + p_plane.normal;
 	point = xform(point);
 	point_dir = xform(point_dir);
@@ -145,7 +145,7 @@ _FORCE_INLINE_ Plane Transform::xform(const Plane &p_plane) const {
 }
 _FORCE_INLINE_ Plane Transform::xform_inv(const Plane &p_plane) const {
 
-	Vector3 point = p_plane.normal * p_plane.distance;
+	Vector3 point = p_plane.normal * p_plane.d;
 	Vector3 point_dir = point + p_plane.normal;
 	xform_inv(point);
 	xform_inv(point_dir);