maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Revert "Renamed plane's d to distance"

Browse source 
This reverts commit ec7b481170.

This was wrong, `d` is not a distance but the `d` constant in the
parametric equation `ax + by + cz = d` describing the plane.
This commit is contained in:
Rémi Verschelde 2020-05-10 16:47:11 +02:00
parent 6ab92464bc
commit 94721f5ab8
36 changed files with 126 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
core/io/marshalls.cpp
View file

@ -277,7 +277,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
val.normal.x = decode_float(&buf[0]);
val.normal.y = decode_float(&buf[4]);
val.normal.z = decode_float(&buf[8]);
val.distance = decode_float(&buf[12]);
val.d = decode_float(&buf[12]);
r_variant = val;
if (r_len)
@ -1140,7 +1140,7 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bo
encode_float(p.normal.x, &buf[0]);
encode_float(p.normal.y, &buf[4]);
encode_float(p.normal.z, &buf[8]);
encode_float(p.distance, &buf[12]);
encode_float(p.d, &buf[12]);
}
r_len += 4 * 4;

4
core/io/resource_format_binary.cpp
View file

@ -214,7 +214,7 @@ Error ResourceLoaderBinary::parse_variant(Variant &r_v) {
v.normal.x = f->get_real();
v.normal.y = f->get_real();
v.normal.z = f->get_real();
v.distance = f->get_real();
v.d = f->get_real();
r_v = v;
} break;
case VARIANT_QUAT: {
@ -1458,7 +1458,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(FileAccess *f, const Varia
f->store_real(val.normal.x);
f->store_real(val.normal.y);
f->store_real(val.normal.z);
f->store_real(val.distance);
f->store_real(val.d);
} break;
case Variant::QUAT: {

12
core/math/camera_matrix.cpp
View file

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

4
core/math/geometry.cpp
View file

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

2
core/math/math_fieldwise.cpp
View file

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

18
core/math/plane.cpp
View file

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

30
core/math/plane.h
View file

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

4
core/math/transform.h
View file

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

4
core/variant.cpp
View file

@ -3277,7 +3277,7 @@ uint32_t Variant::hash() const {
uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Plane *>(_data._mem)->normal.x);
hash = hash_djb2_one_float(reinterpret_cast<const Plane *>(_data._mem)->normal.y, hash);
hash = hash_djb2_one_float(reinterpret_cast<const Plane *>(_data._mem)->normal.z, hash);
return hash_djb2_one_float(reinterpret_cast<const Plane *>(_data._mem)->distance, hash);
return hash_djb2_one_float(reinterpret_cast<const Plane *>(_data._mem)->d, hash);
} break;
/*
@ -3625,7 +3625,7 @@ bool Variant::hash_compare(const Variant &p_variant) const {
const Plane *r = reinterpret_cast<const Plane *>(p_variant._data._mem);
return (hash_compare_vector3(l->normal, r->normal)) &&
(hash_compare_scalar(l->distance, r->distance));
(hash_compare_scalar(l->d, r->d));
} break;
case AABB: {

10
core/variant_op.cpp
View file

@ -1588,7 +1588,7 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool
v->normal.z = p_value._data._int;
valid = true;
} else if (p_index == CoreStringNames::singleton->d) {
v->distance = p_value._data._int;
v->d = p_value._data._int;
valid = true;
}
} else if (p_value.type == Variant::FLOAT) {
@ -1603,7 +1603,7 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool
v->normal.z = p_value._data._float;
valid = true;
} else if (p_index == CoreStringNames::singleton->d) {
v->distance = p_value._data._float;
v->d = p_value._data._float;
valid = true;
}
@ -1889,7 +1889,7 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const {
} else if (p_index == CoreStringNames::singleton->z) {
return v->normal.z;
} else if (p_index == CoreStringNames::singleton->d) {
return v->distance;
return v->d;
} else if (p_index == CoreStringNames::singleton->normal) {
return v->normal;
}
@ -2373,7 +2373,7 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
return;
} else if (*str == "d") {
valid = true;
v->distance = p_value;
v->d = p_value;
return;
}
}
@ -2880,7 +2880,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
return v->normal;
} else if (*str == "d") {
valid = true;
return v->distance;
return v->d;
}
}

2
core/variant_parser.cpp
View file

@ -1561,7 +1561,7 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
case Variant::PLANE: {
Plane p = p_variant;
p_store_string_func(p_store_string_ud, "Plane( " + rtosfix(p.normal.x) + ", " + rtosfix(p.normal.y) + ", " + rtosfix(p.normal.z) + ", " + rtosfix(p.distance) + " )");
p_store_string_func(p_store_string_ud, "Plane( " + rtosfix(p.normal.x) + ", " + rtosfix(p.normal.y) + ", " + rtosfix(p.normal.z) + ", " + rtosfix(p.d) + " )");
} break;
case Variant::AABB: {

6
doc/classes/Plane.xml
View file

@ -19,10 +19,10 @@
</argument>
<argument index="2" name="c" type="float">
</argument>
<argument index="3" name="distance" type="float">
<argument index="3" name="d" type="float">
</argument>
<description>
Creates a plane from the four parameters. The three components of the resulting plane's [member normal] are [code]a[/code], [code]b[/code] and [code]c[/code], and the plane has a distance of [code]distance[/code] from the origin.
Creates a plane from the four parameters. The three components of the resulting plane's [member normal] are [code]a[/code], [code]b[/code] and [code]c[/code], and the plane has a distance of [code]d[/code] from the origin.
</description>
</method>
<method name="Plane">
@ -43,7 +43,7 @@
</return>
<argument index="0" name="normal" type="Vector3">
</argument>
<argument index="1" name="distance" type="float">
<argument index="1" name="d" type="float">
</argument>
<description>
Creates a plane from the normal and the plane's distance to the origin.

4
editor/editor_properties.cpp
View file

@ -1611,7 +1611,7 @@ void EditorPropertyPlane::_value_changed(double val, const String &p_name) {
p.normal.x = spin[0]->get_value();
p.normal.y = spin[1]->get_value();
p.normal.z = spin[2]->get_value();
p.distance = spin[3]->get_value();
p.d = spin[3]->get_value();
emit_changed(get_edited_property(), p, p_name);
}
@ -1621,7 +1621,7 @@ void EditorPropertyPlane::update_property() {
spin[0]->set_value(val.normal.x);
spin[1]->set_value(val.normal.y);
spin[2]->set_value(val.normal.z);
spin[3]->set_value(val.distance);
spin[3]->set_value(val.d);
setting = false;
}
void EditorPropertyPlane::_notification(int p_what) {

6
editor/import/editor_import_collada.cpp
View file

@ -766,7 +766,7 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize, Ref<ArrayMesh> &p_me
Vector3 tangent = Vector3(tangent_src->array[tangent_pos + 0], tangent_src->array[tangent_pos + 1], tangent_src->array[tangent_pos + 2]);
vertex.tangent.normal = tangent;
vertex.tangent.distance = vertex.normal.cross(tangent).dot(binormal) > 0 ? 1 : -1;
vertex.tangent.d = vertex.normal.cross(tangent).dot(binormal) > 0 ? 1 : -1;
}
}
@ -794,7 +794,7 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize, Ref<ArrayMesh> &p_me
#ifndef NO_UP_AXIS_SWAP
if (collada.state.up_axis == Vector3::AXIS_Z) {
Vector3 bn = vertex.normal.cross(vertex.tangent.normal) * vertex.tangent.distance;
Vector3 bn = vertex.normal.cross(vertex.tangent.normal) * vertex.tangent.d;
SWAP(vertex.vertex.z, vertex.vertex.y);
vertex.vertex.z = -vertex.vertex.z;
@ -805,7 +805,7 @@ Error ColladaImport::_create_mesh_surfaces(bool p_optimize, Ref<ArrayMesh> &p_me
SWAP(bn.z, bn.y);
bn.z = -bn.z;
vertex.tangent.distance = vertex.normal.cross(vertex.tangent.normal).dot(bn) > 0 ? 1 : -1;
vertex.tangent.d = vertex.normal.cross(vertex.tangent.normal).dot(bn) > 0 ? 1 : -1;
}
#endif

12
editor/node_3d_editor_gizmos.cpp
View file

@ -3753,10 +3753,10 @@ void CollisionShape3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
Vector3 n2 = p.normal.cross(n1).normalized();
Vector3 pface[4] = {
p.normal * p.distance + n1 * 10.0 + n2 * 10.0,
p.normal * p.distance + n1 * 10.0 + n2 * -10.0,
p.normal * p.distance + n1 * -10.0 + n2 * -10.0,
p.normal * p.distance + n1 * -10.0 + n2 * 10.0,
p.normal * p.d + n1 * 10.0 + n2 * 10.0,
p.normal * p.d + n1 * 10.0 + n2 * -10.0,
p.normal * p.d + n1 * -10.0 + n2 * -10.0,
p.normal * p.d + n1 * -10.0 + n2 * 10.0,
};
points.push_back(pface[0]);
@ -3767,8 +3767,8 @@ void CollisionShape3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
points.push_back(pface[3]);
points.push_back(pface[3]);
points.push_back(pface[0]);
points.push_back(p.normal * p.distance);
points.push_back(p.normal * p.distance + p.normal * 3);
points.push_back(p.normal * p.d);
points.push_back(p.normal * p.d + p.normal * 3);
p_gizmo->add_lines(points, material);
p_gizmo->add_collision_segments(points);

4
editor/plugins/node_3d_editor_plugin.cpp
View file

@ -682,11 +682,11 @@ void Node3DEditorViewport::_select_region() {
}
Plane near(cam_pos, -_get_camera_normal());
near.distance -= get_znear();
near.d -= get_znear();
frustum.push_back(near);
Plane far = -near;
far.distance += get_zfar();
far.d += get_zfar();
frustum.push_back(far);
Vector<ObjectID> instances = RenderingServer::get_singleton()->instances_cull_convex(frustum, get_tree()->get_root()->get_world_3d()->get_scenario());

4
editor/property_editor.cpp
View file

@ -752,7 +752,7 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
value_editor[0]->set_text(String::num(plane.normal.x));
value_editor[1]->set_text(String::num(plane.normal.y));
value_editor[2]->set_text(String::num(plane.normal.z));
value_editor[3]->set_text(String::num(plane.distance));
value_editor[3]->set_text(String::num(plane.d));
} break;
case Variant::QUAT: {
@ -1598,7 +1598,7 @@ void CustomPropertyEditor::_modified(String p_string) {
pl.normal.x = _parse_real_expression(value_editor[0]->get_text());
pl.normal.y = _parse_real_expression(value_editor[1]->get_text());
pl.normal.z = _parse_real_expression(value_editor[2]->get_text());
pl.distance = _parse_real_expression(value_editor[3]->get_text());
pl.d = _parse_real_expression(value_editor[3]->get_text());
v = pl;
_emit_changed_whole_or_field();

2
main/tests/test_math.cpp
View file

@ -380,7 +380,7 @@ void test_vec(Plane p_vec) {
Plane v0 = cm.xform4(p_vec);
print_line("out: " + v0);
v0.normal.z = (v0.distance / 100.0 * 2.0 - 1.0) * v0.distance;
v0.normal.z = (v0.d / 100.0 * 2.0 - 1.0) * v0.d;
print_line("out_F: " + v0);
}

2
modules/bullet/shape_bullet.cpp
View file

@ -189,7 +189,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.distance));
return prepare(PlaneShapeBullet::create_shape_plane(btPlaneNormal, plane.d));
}
/* Sphere */

12
modules/gdnative/gdnative/plane.cpp
View file

@ -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_distance) {
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) {
Plane *dest = (Plane *)r_dest;
*dest = Plane(p_a, p_b, p_c, p_distance);
*dest = Plane(p_a, p_b, p_c, p_d);
}
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_distance(const godot_plane *p_self) {
godot_real GDAPI godot_plane_get_d(const godot_plane *p_self) {
const Plane *self = (const Plane *)p_self;
return self->distance;
return self->d;
}
void GDAPI godot_plane_set_distance(godot_plane *p_self, const godot_real p_distance) {
void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d) {
Plane *self = (Plane *)p_self;
self->distance = p_distance;
self->d = p_d;
}
#ifdef __cplusplus

4
modules/gdnative/gdnative_api.json
View file

@ -3120,14 +3120,14 @@
]
},
{
"name": "godot_plane_get_distance",
"name": "godot_plane_get_d",
"return_type": "godot_real",
"arguments": [
["const godot_plane *", "p_self"]
]
},
{
"name": "godot_plane_set_distance",
"name": "godot_plane_set_d",
"return_type": "void",
"arguments": [
["godot_plane *", "p_self"],

4
modules/gdnative/include/gdnative/plane.h
View file

@ -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_distance(const godot_plane *p_self);
godot_real GDAPI godot_plane_get_d(const godot_plane *p_self);
void GDAPI godot_plane_set_distance(godot_plane *p_self, const godot_real p_distance);
void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d);
#ifdef __cplusplus
}

2
modules/gdnavigation/nav_map.cpp
View file

@ -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.distance = cut_plane.normal.dot(from);
cut_plane.d = cut_plane.normal.dot(from);
while (from_poly != p_to_poly) {

4
modules/gridmap/grid_map_editor_plugin.cpp
View file

@ -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.distance = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
p.d = 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.distance = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
p.d = 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());

46
modules/mono/glue/GodotSharp/GodotSharp/Core/Plane.cs
View file

@ -56,29 +56,29 @@ namespace Godot
}
}
public real_t Distance { get; set; }
public real_t D { get; set; }
public Vector3 Center
{
get
{
return _normal * Distance;
return _normal * D;
}
}
public real_t DistanceTo(Vector3 point)
{
return _normal.Dot(point) - Distance;
return _normal.Dot(point) - D;
}
public Vector3 GetAnyPoint()
{
return _normal * Distance;
return _normal * D;
}
public bool HasPoint(Vector3 point, real_t epsilon = Mathf.Epsilon)
{
real_t dist = _normal.Dot(point) - Distance;
real_t dist = _normal.Dot(point) - D;
return Mathf.Abs(dist) <= epsilon;
}
@ -89,9 +89,9 @@ namespace Godot
if (Mathf.IsZeroApprox(denom))
return null;
Vector3 result = b._normal.Cross(c._normal) * Distance +
c._normal.Cross(_normal) * b.Distance +
_normal.Cross(b._normal) * c.Distance;
Vector3 result = b._normal.Cross(c._normal) * D +
c._normal.Cross(_normal) * b.D +
_normal.Cross(b._normal) * c.D;
return result / denom;
}
@ -103,7 +103,7 @@ namespace Godot
if (Mathf.IsZeroApprox(den))
return null;
real_t dist = (_normal.Dot(from) - Distance) / den;
real_t dist = (_normal.Dot(from) - D) / 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) - Distance) / den;
real_t dist = (_normal.Dot(begin) - D) / 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) > Distance;
return _normal.Dot(point) > D;
}
public Plane Normalized()
@ -141,7 +141,7 @@ namespace Godot
if (len == 0)
return new Plane(0, 0, 0, 0);
return new Plane(_normal / len, Distance / len);
return new Plane(_normal / len, D / 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 distance)
public Plane(real_t a, real_t b, real_t c, real_t d)
{
_normal = new Vector3(a, b, c);
this.Distance = distance;
this.D = d;
}
public Plane(Vector3 normal, real_t distance)
public Plane(Vector3 normal, real_t d)
{
this._normal = normal;
this.Distance = distance;
this.D = d;
}
public Plane(Vector3 v1, Vector3 v2, Vector3 v3)
{
_normal = (v1 - v3).Cross(v1 - v2);
_normal.Normalize();
Distance = _normal.Dot(v1);
D = _normal.Dot(v1);
}
public static Plane operator -(Plane plane)
{
return new Plane(-plane._normal, -plane.Distance);
return new Plane(-plane._normal, -plane.D);
}
public static bool operator ==(Plane left, Plane right)
@ -204,17 +204,17 @@ namespace Godot
public bool Equals(Plane other)
{
return _normal == other._normal && Distance == other.Distance;
return _normal == other._normal && D == other.D;
}
public bool IsEqualApprox(Plane other)
{
return _normal.IsEqualApprox(other._normal) && Mathf.IsEqualApprox(Distance, other.Distance);
return _normal.IsEqualApprox(other._normal) && Mathf.IsEqualApprox(D, other.D);
}
public override int GetHashCode()
{
return _normal.GetHashCode() ^ Distance.GetHashCode();
return _normal.GetHashCode() ^ D.GetHashCode();
}
public override string ToString()
@ -222,7 +222,7 @@ namespace Godot
return String.Format("({0}, {1})", new object[]
{
_normal.ToString(),
Distance.ToString()
D.ToString()
});
}
@ -231,7 +231,7 @@ namespace Godot
return String.Format("({0}, {1})", new object[]
{
_normal.ToString(format),
Distance.ToString(format)
D.ToString(format)
});
}
}

8
modules/mono/mono_gd/gd_mono_marshal.h
View file

@ -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, distance) == sizeof(Vector3))
offsetof(Plane, d) == 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 distance;
real_t d;
static _FORCE_INLINE_ Plane convert_to(const M_Plane &p_from) {
return Plane(M_Vector3::convert_to(p_from.normal), p_from.distance);
return Plane(M_Vector3::convert_to(p_from.normal), p_from.d);
}
static _FORCE_INLINE_ M_Plane convert_from(const Plane &p_from) {
M_Plane ret = { M_Vector3::convert_from(p_from.normal), p_from.distance };
M_Plane ret = { M_Vector3::convert_from(p_from.normal), p_from.d };
return ret;
}
};

2
scene/3d/camera_3d.cpp
View file

@ -376,7 +376,7 @@ Point2 Camera3D::unproject_position(const Vector3 &p_pos) const {
Plane p(get_camera_transform().xform_inv(p_pos), 1.0);
p = cm.xform4(p);
p.normal /= p.distance;
p.normal /= p.d;
Point2 res;
res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x;

2
scene/3d/xr_nodes.cpp
View file

@ -111,7 +111,7 @@ Point2 XRCamera3D::unproject_position(const Vector3 &p_pos) const {
Plane p(get_camera_transform().xform_inv(p_pos), 1.0);
p = cm.xform4(p);
p.normal /= p.distance;
p.normal /= p.d;
Point2 res;
res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x;

4
scene/resources/curve.cpp
View file

@ -1237,7 +1237,7 @@ void Curve3D::_bake() const {
p = mid;
Plane post;
post.normal = pos;
post.distance = Math::lerp(points[i].tilt, points[i + 1].tilt, mid);
post.d = Math::lerp(points[i].tilt, points[i + 1].tilt, mid);
pointlist.push_back(post);
} else {
@ -1274,7 +1274,7 @@ void Curve3D::_bake() const {
for (List<Plane>::Element *E = pointlist.front(); E; E = E->next()) {
w[idx] = E->get().normal;
wt[idx] = E->get().distance;
wt[idx] = E->get().d;
if (!up_vector_enabled) {
idx++;

2
scene/resources/mesh.cpp
View file

@ -1522,7 +1522,7 @@ Error ArrayMesh::lightmap_unwrap_cached(int *&r_cache_data, unsigned int &r_cach
if (lightmap_surfaces[surface].format & ARRAY_FORMAT_TANGENT) {
Plane t;
t.normal = v.tangent;
t.distance = v.binormal.dot(v.normal.cross(v.tangent)) < 0 ? -1 : 1;
t.d = v.binormal.dot(v.normal.cross(v.tangent)) < 0 ? -1 : 1;
surfaces_tools.write[surface]->add_tangent(t);
}
if (lightmap_surfaces[surface].format & ARRAY_FORMAT_BONES) {

2
scene/resources/mesh_data_tool.cpp
View file

@ -255,7 +255,7 @@ Error MeshDataTool::commit_to_surface(const Ref<ArrayMesh> &p_mesh) {
ta[i * 4 + 0] = vtx.tangent.normal.x;
ta[i * 4 + 1] = vtx.tangent.normal.y;
ta[i * 4 + 2] = vtx.tangent.normal.z;
ta[i * 4 + 3] = vtx.tangent.distance;
ta[i * 4 + 3] = vtx.tangent.d;
}
if (uv)
uv[i] = vtx.uv;

6
scene/resources/surface_tool.cpp
View file

@ -107,7 +107,7 @@ void SurfaceTool::add_vertex(const Vector3 &p_vertex) {
vtx.weights = last_weights;
vtx.bones = last_bones;
vtx.tangent = last_tangent.normal;
vtx.binormal = last_normal.cross(last_tangent.normal).normalized() * last_tangent.distance;
vtx.binormal = last_normal.cross(last_tangent.normal).normalized() * last_tangent.d;
const int expected_vertices = 4;
@ -575,7 +575,7 @@ Vector<SurfaceTool::Vertex> SurfaceTool::create_vertex_array_from_triangle_array
if (lformat & RS::ARRAY_FORMAT_TANGENT) {
Plane p(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]);
v.tangent = p.normal;
v.binormal = p.normal.cross(v.tangent).normalized() * p.distance;
v.binormal = p.normal.cross(v.tangent).normalized() * p.d;
}
if (lformat & RS::ARRAY_FORMAT_COLOR)
v.color = carr[i];
@ -658,7 +658,7 @@ void SurfaceTool::_create_list_from_arrays(Array arr, List<Vertex> *r_vertex, Li
if (lformat & RS::ARRAY_FORMAT_TANGENT) {
Plane p(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]);
v.tangent = p.normal;
v.binormal = p.normal.cross(v.tangent).normalized() * p.distance;
v.binormal = p.normal.cross(v.tangent).normalized() * p.d;
}
if (lformat & RS::ARRAY_FORMAT_COLOR)
v.color = carr[i];

12
scene/resources/world_margin_shape_3d.cpp
View file

@ -41,10 +41,10 @@ Vector<Vector3> WorldMarginShape3D::get_debug_mesh_lines() {
Vector3 n2 = p.normal.cross(n1).normalized();
Vector3 pface[4] = {
p.normal * p.distance + n1 * 10.0 + n2 * 10.0,
p.normal * p.distance + n1 * 10.0 + n2 * -10.0,
p.normal * p.distance + n1 * -10.0 + n2 * -10.0,
p.normal * p.distance + n1 * -10.0 + n2 * 10.0,
p.normal * p.d + n1 * 10.0 + n2 * 10.0,
p.normal * p.d + n1 * 10.0 + n2 * -10.0,
p.normal * p.d + n1 * -10.0 + n2 * -10.0,
p.normal * p.d + n1 * -10.0 + n2 * 10.0,
};
points.push_back(pface[0]);
@ -55,8 +55,8 @@ Vector<Vector3> WorldMarginShape3D::get_debug_mesh_lines() {
points.push_back(pface[3]);
points.push_back(pface[3]);
points.push_back(pface[0]);
points.push_back(p.normal * p.distance);
points.push_back(p.normal * p.distance + p.normal * 3);
points.push_back(p.normal * p.d);
points.push_back(p.normal * p.d + p.normal * 3);
return points;
}

2
servers/physics_3d/collision_solver_3d_sat.cpp
View file

@ -194,7 +194,7 @@ static void _generate_contacts_face_face(const Vector3 *p_points_A, int p_point_
// calculate intersection
Vector3 rel = edge1_A - edge0_A;
real_t den = clip.normal.dot(rel);
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;
ERR_FAIL_COND(dst_idx >= max_clip);

2
servers/rendering/rasterizer_rd/rasterizer_effects_rd.cpp
View file

@ -558,7 +558,7 @@ void RasterizerEffectsRD::sub_surface_scattering(RID p_diffuse, RID p_diffuse2,
int32_t y_groups = (p_screen_size.height - 1) / 8 + 1;
Plane p = p_camera.xform4(Plane(1, 0, -1, 1));
p.normal /= p.distance;
p.normal /= p.d;
float unit_size = p.normal.x;
{ //scale color and depth to half

4
servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
View file

@ -1368,7 +1368,7 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
gui[0] = v.normal.x;
gui[1] = v.normal.y;
gui[2] = v.normal.z;
gui[3] = v.distance;
gui[3] = v.d;
}
} break;
case ShaderLanguage::TYPE_MAT2: {
@ -4929,7 +4929,7 @@ void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::
bv.x = v.normal.x;
bv.y = v.normal.y;
bv.z = v.normal.z;
bv.w = v.distance;
bv.w = v.d;
} break;
case RS::GLOBAL_VAR_TYPE_COLOR: {
GlobalVariables::Value &bv = global_variables.buffer_values[p_index];