godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #38613 from MCrafterzz/plane 

Renamed plane's d to distance
This commit is contained in:
Rémi Verschelde 2020-05-10 13:06:55 +02:00 committed by GitHub
parent 2d8d311b12 ec7b481170
commit 9cc67b19b8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
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.x = decode_float(&buf[0]);
val.normal.y = decode_float(&buf[4]); val.normal.y = decode_float(&buf[4]);
val.normal.z = decode_float(&buf[8]); val.normal.z = decode_float(&buf[8]);
val.d = decode_float(&buf[12]); val.distance = decode_float(&buf[12]);
r_variant = val; r_variant = val;
if (r_len) 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.x, &buf[0]);
encode_float(p.normal.y, &buf[4]); encode_float(p.normal.y, &buf[4]);
encode_float(p.normal.z, &buf[8]); encode_float(p.normal.z, &buf[8]);
encode_float(p.d, &buf[12]); encode_float(p.distance, &buf[12]);
} }
r_len += 4 * 4; 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.x = f->get_real();
v.normal.y = f->get_real(); v.normal.y = f->get_real();
v.normal.z = f->get_real(); v.normal.z = f->get_real();
v.d = f->get_real(); v.distance = f->get_real();
r_v = v; r_v = v;
} break; } break;
case VARIANT_QUAT: { 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.x);
f->store_real(val.normal.y); f->store_real(val.normal.y);
f->store_real(val.normal.z); f->store_real(val.normal.z);
f->store_real(val.d); f->store_real(val.distance);
} break; } break;
case Variant::QUAT: { 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; 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.d; 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.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.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.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.distance;
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; 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;
return ret; return ret;
} }
@ -233,7 +233,7 @@ real_t CameraMatrix::get_z_far() const {
new_plane.normal = -new_plane.normal; new_plane.normal = -new_plane.normal;
new_plane.normalize(); new_plane.normalize();
return new_plane.d; return new_plane.distance;
} }
real_t CameraMatrix::get_z_near() const { real_t CameraMatrix::get_z_near() const {
@ -244,7 +244,7 @@ real_t CameraMatrix::get_z_near() const {
-matrix[15] - matrix[14]); -matrix[15] - matrix[14]);
new_plane.normalize(); new_plane.normalize();
return new_plane.d; return new_plane.distance;
} }
Vector2 CameraMatrix::get_viewport_half_extents() const { Vector2 CameraMatrix::get_viewport_half_extents() const {

4
core/math/geometry.cpp
View File

@ -780,7 +780,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const Vector<Plane> &p_planes) {
if (Math::is_zero_approx(den)) if (Math::is_zero_approx(den))
continue; // Point too short. continue; // Point too short.
real_t dist = -(clip.normal.dot(edge0_A) - clip.d) / den; real_t dist = -(clip.normal.dot(edge0_A) - clip.distance) / den;
Vector3 inters = edge0_A + rel * dist; Vector3 inters = edge0_A + rel * dist;
new_vertices.push_back(inters); new_vertices.push_back(inters);
} }
@ -1199,7 +1199,7 @@ Vector<Vector3> Geometry::compute_convex_mesh_points(const Plane *p_planes, int
for (int n = 0; n < p_plane_count; n++) { for (int n = 0; n < p_plane_count; n++) {
if (n != i && n != j && n != k) { if (n != i && n != j && n != k) {
real_t dp = p_planes[n].normal.dot(convex_shape_point); real_t dp = p_planes[n].normal.dot(convex_shape_point);
if (dp - p_planes[n].d > CMP_EPSILON) { if (dp - p_planes[n].distance > CMP_EPSILON) {
excluded = true; excluded = true;
break; 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) /**/ TRY_TRANSFER_FIELD("x", normal.x)
else TRY_TRANSFER_FIELD("y", normal.y) else TRY_TRANSFER_FIELD("y", normal.y)
else TRY_TRANSFER_FIELD("z", normal.z) else TRY_TRANSFER_FIELD("z", normal.z)
else TRY_TRANSFER_FIELD("d", d) else TRY_TRANSFER_FIELD("d", distance)
return target; return target;
} }

18
core/math/plane.cpp
View File

@ -45,7 +45,7 @@ void Plane::normalize() {
return; return;
} }
normal /= l; normal /= l;
d /= l; distance /= l;
} }
Plane Plane::normalized() const { Plane Plane::normalized() const {
@ -57,7 +57,7 @@ Plane Plane::normalized() const {
Vector3 Plane::get_any_point() const { Vector3 Plane::get_any_point() const {
return get_normal() * d; return get_normal() * distance;
} }
Vector3 Plane::get_any_perpendicular_normal() const { 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; return false;
if (r_result) { if (r_result) {
*r_result = ((vec3_cross(normal1, normal2) * p_plane0.d) + *r_result = ((vec3_cross(normal1, normal2) * p_plane0.distance) +
(vec3_cross(normal2, normal0) * p_plane1.d) + (vec3_cross(normal2, normal0) * p_plane1.distance) +
(vec3_cross(normal0, normal1) * p_plane2.d)) / (vec3_cross(normal0, normal1) * p_plane2.distance)) /
denom; denom;
} }
@ -112,7 +112,7 @@ bool Plane::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3
return false; return false;
} }
real_t dist = (normal.dot(p_from) - d) / den; real_t dist = (normal.dot(p_from) - distance) / den;
//printf("dist is %i\n",dist); //printf("dist is %i\n",dist);
if (dist > CMP_EPSILON) { //this is a ray, before the emitting pos (p_from) doesn't exist 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; return false;
} }
real_t dist = (normal.dot(p_begin) - d) / den; real_t dist = (normal.dot(p_begin) - distance) / den;
//printf("dist is %i\n",dist); //printf("dist is %i\n",dist);
if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) { 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 { bool Plane::is_equal_approx(const Plane &p_plane) const {
return normal.is_equal_approx(p_plane.normal) && Math::is_equal_approx(d, p_plane.d); return normal.is_equal_approx(p_plane.normal) && Math::is_equal_approx(distance, p_plane.distance);
} }
Plane::operator String() const { Plane::operator String() const {
return normal.operator String() + ", " + rtos(d); return normal.operator String() + ", " + rtos(distance);
} }

30
core/math/plane.h
View File

@ -36,7 +36,7 @@
class Plane { class Plane {
public: public:
Vector3 normal; Vector3 normal;
real_t d; real_t distance;
void set_normal(const Vector3 &p_normal); void set_normal(const Vector3 &p_normal);
_FORCE_INLINE_ Vector3 get_normal() const { return normal; }; ///Point is coplanar, CMP_EPSILON for precision _FORCE_INLINE_ Vector3 get_normal() const { return normal; }; ///Point is coplanar, CMP_EPSILON for precision
@ -46,7 +46,7 @@ public:
/* Plane-Point operations */ /* Plane-Point operations */
_FORCE_INLINE_ Vector3 center() const { return normal * d; } _FORCE_INLINE_ Vector3 center() const { return normal * distance; }
Vector3 get_any_point() const; Vector3 get_any_point() const;
Vector3 get_any_perpendicular_normal() const; Vector3 get_any_perpendicular_normal() const;
@ -67,7 +67,7 @@ public:
/* misc */ /* misc */
Plane operator-() const { return Plane(-normal, -d); } Plane operator-() const { return Plane(-normal, -distance); }
bool is_equal_approx(const Plane &p_plane) const; bool is_equal_approx(const Plane &p_plane) const;
_FORCE_INLINE_ bool operator==(const Plane &p_plane) const; _FORCE_INLINE_ bool operator==(const Plane &p_plane) const;
@ -75,41 +75,41 @@ public:
operator String() const; operator String() const;
_FORCE_INLINE_ Plane() : _FORCE_INLINE_ Plane() :
d(0) {} distance(0) {}
_FORCE_INLINE_ Plane(real_t p_a, real_t p_b, real_t p_c, real_t p_d) : _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), normal(p_a, p_b, p_c),
d(p_d) {} distance(p_d) {}
_FORCE_INLINE_ Plane(const Vector3 &p_normal, real_t p_d); _FORCE_INLINE_ Plane(const Vector3 &p_normal, real_t p_distance);
_FORCE_INLINE_ Plane(const Vector3 &p_point, const Vector3 &p_normal); _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); _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 { bool Plane::is_point_over(const Vector3 &p_point) const {
return (normal.dot(p_point) > d); return (normal.dot(p_point) > distance);
} }
real_t Plane::distance_to(const Vector3 &p_point) const { real_t Plane::distance_to(const Vector3 &p_point) const {
return (normal.dot(p_point) - d); return (normal.dot(p_point) - distance);
} }
bool Plane::has_point(const Vector3 &p_point, real_t _epsilon) const { bool Plane::has_point(const Vector3 &p_point, real_t _epsilon) const {
real_t dist = normal.dot(p_point) - d; real_t dist = normal.dot(p_point) - distance;
dist = ABS(dist); dist = ABS(dist);
return (dist <= _epsilon); return (dist <= _epsilon);
} }
Plane::Plane(const Vector3 &p_normal, real_t p_d) : Plane::Plane(const Vector3 &p_normal, real_t p_distance) :
normal(p_normal), normal(p_normal),
d(p_d) { distance(p_distance) {
} }
Plane::Plane(const Vector3 &p_point, const Vector3 &p_normal) : Plane::Plane(const Vector3 &p_point, const Vector3 &p_normal) :
normal(p_normal), normal(p_normal),
d(p_normal.dot(p_point)) { distance(p_normal.dot(p_point)) {
} }
Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3, ClockDirection p_dir) { 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 = (p_point1 - p_point2).cross(p_point1 - p_point3);
normal.normalize(); normal.normalize();
d = normal.dot(p_point1); distance = normal.dot(p_point1);
} }
bool Plane::operator==(const Plane &p_plane) const { bool Plane::operator==(const Plane &p_plane) const {
return normal == p_plane.normal && d == p_plane.d; return normal == p_plane.normal && distance == p_plane.distance;
} }
bool Plane::operator!=(const Plane &p_plane) const { bool Plane::operator!=(const Plane &p_plane) const {
return normal != p_plane.normal || d != p_plane.d; return normal != p_plane.normal || distance != p_plane.distance;
} }
#endif // PLANE_H #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 { _FORCE_INLINE_ Plane Transform::xform(const Plane &p_plane) const {
Vector3 point = p_plane.normal * p_plane.d; Vector3 point = p_plane.normal * p_plane.distance;
Vector3 point_dir = point + p_plane.normal; Vector3 point_dir = point + p_plane.normal;
point = xform(point); point = xform(point);
point_dir = xform(point_dir); 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 { _FORCE_INLINE_ Plane Transform::xform_inv(const Plane &p_plane) const {
Vector3 point = p_plane.normal * p_plane.d; Vector3 point = p_plane.normal * p_plane.distance;
Vector3 point_dir = point + p_plane.normal; Vector3 point_dir = point + p_plane.normal;
xform_inv(point); xform_inv(point);
xform_inv(point_dir); xform_inv(point_dir);

4
core/variant.cpp
View File

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

10
core/variant_op.cpp
View File

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

2
core/variant_parser.cpp
View File

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

6
doc/classes/Plane.xml
View File

@ -19,10 +19,10 @@
</argument> </argument>
<argument index="2" name="c" type="float"> <argument index="2" name="c" type="float">
</argument> </argument>
<argument index="3" name="d" type="float"> <argument index="3" name="distance" type="float">
</argument> </argument>
<description> <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]d[/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]distance[/code] from the origin.
</description> </description>
</method> </method>
<method name="Plane"> <method name="Plane">
@ -43,7 +43,7 @@
</return> </return>
<argument index="0" name="normal" type="Vector3"> <argument index="0" name="normal" type="Vector3">
</argument> </argument>
<argument index="1" name="d" type="float"> <argument index="1" name="distance" type="float">
</argument> </argument>
<description> <description>
Creates a plane from the normal and the plane's distance to the origin. 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.x = spin[0]->get_value();
p.normal.y = spin[1]->get_value(); p.normal.y = spin[1]->get_value();
p.normal.z = spin[2]->get_value(); p.normal.z = spin[2]->get_value();
p.d = spin[3]->get_value(); p.distance = spin[3]->get_value();
emit_changed(get_edited_property(), p, p_name); emit_changed(get_edited_property(), p, p_name);
} }
@ -1621,7 +1621,7 @@ void EditorPropertyPlane::update_property() {
spin[0]->set_value(val.normal.x); spin[0]->set_value(val.normal.x);
spin[1]->set_value(val.normal.y); spin[1]->set_value(val.normal.y);
spin[2]->set_value(val.normal.z); spin[2]->set_value(val.normal.z);
spin[3]->set_value(val.d); spin[3]->set_value(val.distance);
setting = false; setting = false;
} }
void EditorPropertyPlane::_notification(int p_what) { 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]); 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.normal = tangent;
vertex.tangent.d = vertex.normal.cross(tangent).dot(binormal) > 0 ? 1 : -1; vertex.tangent.distance = 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 #ifndef NO_UP_AXIS_SWAP
if (collada.state.up_axis == Vector3::AXIS_Z) { if (collada.state.up_axis == Vector3::AXIS_Z) {
Vector3 bn = vertex.normal.cross(vertex.tangent.normal) * vertex.tangent.d; Vector3 bn = vertex.normal.cross(vertex.tangent.normal) * vertex.tangent.distance;
SWAP(vertex.vertex.z, vertex.vertex.y); SWAP(vertex.vertex.z, vertex.vertex.y);
vertex.vertex.z = -vertex.vertex.z; 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); SWAP(bn.z, bn.y);
bn.z = -bn.z; bn.z = -bn.z;
vertex.tangent.d = vertex.normal.cross(vertex.tangent.normal).dot(bn) > 0 ? 1 : -1; vertex.tangent.distance = vertex.normal.cross(vertex.tangent.normal).dot(bn) > 0 ? 1 : -1;
} }
#endif #endif

12
editor/node_3d_editor_gizmos.cpp
View File

@ -3724,10 +3724,10 @@ void CollisionShape3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
Vector3 n2 = p.normal.cross(n1).normalized(); Vector3 n2 = p.normal.cross(n1).normalized();
Vector3 pface[4] = { Vector3 pface[4] = {
p.normal * p.d + 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.distance + n1 * 10.0 + n2 * -10.0,
p.normal * p.d + 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.distance + n1 * -10.0 + n2 * 10.0,
}; };
points.push_back(pface[0]); points.push_back(pface[0]);
@ -3738,8 +3738,8 @@ void CollisionShape3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
points.push_back(pface[3]); points.push_back(pface[3]);
points.push_back(pface[3]); points.push_back(pface[3]);
points.push_back(pface[0]); points.push_back(pface[0]);
points.push_back(p.normal * p.d); points.push_back(p.normal * p.distance);
points.push_back(p.normal * p.d + p.normal * 3); points.push_back(p.normal * p.distance + p.normal * 3);
p_gizmo->add_lines(points, material); p_gizmo->add_lines(points, material);
p_gizmo->add_collision_segments(points); 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()); Plane near(cam_pos, -_get_camera_normal());
near.d -= get_znear(); near.distance -= get_znear();
frustum.push_back(near); frustum.push_back(near);
Plane far = -near; Plane far = -near;
far.d += get_zfar(); far.distance += get_zfar();
frustum.push_back(far); frustum.push_back(far);
Vector<ObjectID> instances = RenderingServer::get_singleton()->instances_cull_convex(frustum, get_tree()->get_root()->get_world_3d()->get_scenario()); 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[0]->set_text(String::num(plane.normal.x));
value_editor[1]->set_text(String::num(plane.normal.y)); value_editor[1]->set_text(String::num(plane.normal.y));
value_editor[2]->set_text(String::num(plane.normal.z)); value_editor[2]->set_text(String::num(plane.normal.z));
value_editor[3]->set_text(String::num(plane.d)); value_editor[3]->set_text(String::num(plane.distance));
} break; } break;
case Variant::QUAT: { 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.x = _parse_real_expression(value_editor[0]->get_text());
pl.normal.y = _parse_real_expression(value_editor[1]->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.normal.z = _parse_real_expression(value_editor[2]->get_text());
pl.d = _parse_real_expression(value_editor[3]->get_text()); pl.distance = _parse_real_expression(value_editor[3]->get_text());
v = pl; v = pl;
_emit_changed_whole_or_field(); _emit_changed_whole_or_field();

2
main/tests/test_math.cpp
View File

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

2
modules/bullet/shape_bullet.cpp
View File

@ -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) { btCollisionShape *PlaneShapeBullet::create_bt_shape(const btVector3 &p_implicit_scale, real_t p_extra_edge) {
btVector3 btPlaneNormal; btVector3 btPlaneNormal;
G_TO_B(plane.normal, 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 */ /* Sphere */

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

@ -37,10 +37,10 @@
extern "C" { extern "C" {
#endif #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; 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) { 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; 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; 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; Plane *self = (Plane *)p_self;
self->d = p_d; self->distance = p_distance;
} }
#ifdef __cplusplus #ifdef __cplusplus

4
modules/gdnative/gdnative_api.json
View File

@ -3120,14 +3120,14 @@
] ]
}, },
{ {
"name": "godot_plane_get_d", "name": "godot_plane_get_distance",
"return_type": "godot_real", "return_type": "godot_real",
"arguments": [ "arguments": [
["const godot_plane *", "p_self"] ["const godot_plane *", "p_self"]
] ]
}, },
{ {
"name": "godot_plane_set_d", "name": "godot_plane_set_distance",
"return_type": "void", "return_type": "void",
"arguments": [ "arguments": [
["godot_plane *", "p_self"], ["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_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 #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()) if (cut_plane.normal == Vector3())
return; return;
cut_plane.normal.normalize(); 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) { 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; Plane p;
p.normal[edit_axis] = 1.0; 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; Vector3 inters;
if (!p.intersects_segment(from, from + normal * settings_pick_distance->get_value(), &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; Plane p;
p.normal[edit_axis] = 1.0; 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 p = node->get_transform().xform(p); // plane to snap
Node3DEditorPlugin *sep = Object::cast_to<Node3DEditorPlugin>(editor->get_editor_plugin_screen()); 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 D { get; set; } public real_t Distance { get; set; }
public Vector3 Center public Vector3 Center
{ {
get get
{ {
return _normal * D; return _normal * Distance;
} }
} }
public real_t DistanceTo(Vector3 point) public real_t DistanceTo(Vector3 point)
{ {
return _normal.Dot(point) - D; return _normal.Dot(point) - Distance;
} }
public Vector3 GetAnyPoint() public Vector3 GetAnyPoint()
{ {
return _normal * D; return _normal * Distance;
} }
public bool HasPoint(Vector3 point, real_t epsilon = Mathf.Epsilon) 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; return Mathf.Abs(dist) <= epsilon;
} }
@ -89,9 +89,9 @@ namespace Godot
if (Mathf.IsZeroApprox(denom)) if (Mathf.IsZeroApprox(denom))
return null; return null;
Vector3 result = b._normal.Cross(c._normal) * D + Vector3 result = b._normal.Cross(c._normal) * Distance +
c._normal.Cross(_normal) * b.D + c._normal.Cross(_normal) * b.Distance +
_normal.Cross(b._normal) * c.D; _normal.Cross(b._normal) * c.Distance;
return result / denom; return result / denom;
} }
@ -103,7 +103,7 @@ namespace Godot
if (Mathf.IsZeroApprox(den)) if (Mathf.IsZeroApprox(den))
return null; 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 // This is a ray, before the emitting pos (from) does not exist
if (dist > Mathf.Epsilon) if (dist > Mathf.Epsilon)
@ -120,7 +120,7 @@ namespace Godot
if (Mathf.IsZeroApprox(den)) if (Mathf.IsZeroApprox(den))
return null; 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. // Only allow dist to be in the range of 0 to 1, with tolerance.
if (dist < -Mathf.Epsilon || dist > 1.0f + Mathf.Epsilon) if (dist < -Mathf.Epsilon || dist > 1.0f + Mathf.Epsilon)
@ -131,7 +131,7 @@ namespace Godot
public bool IsPointOver(Vector3 point) public bool IsPointOver(Vector3 point)
{ {
return _normal.Dot(point) > D; return _normal.Dot(point) > Distance;
} }
public Plane Normalized() public Plane Normalized()
@ -141,7 +141,7 @@ namespace Godot
if (len == 0) if (len == 0)
return new Plane(0, 0, 0, 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) public Vector3 Project(Vector3 point)
@ -159,27 +159,27 @@ namespace Godot
public static Plane PlaneXY { get { return _planeXY; } } public static Plane PlaneXY { get { return _planeXY; } }
// Constructors // 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); _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._normal = normal;
this.D = d; this.Distance = distance;
} }
public Plane(Vector3 v1, Vector3 v2, Vector3 v3) public Plane(Vector3 v1, Vector3 v2, Vector3 v3)
{ {
_normal = (v1 - v3).Cross(v1 - v2); _normal = (v1 - v3).Cross(v1 - v2);
_normal.Normalize(); _normal.Normalize();
D = _normal.Dot(v1); Distance = _normal.Dot(v1);
} }
public static Plane operator -(Plane plane) 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) public static bool operator ==(Plane left, Plane right)
@ -204,17 +204,17 @@ namespace Godot
public bool Equals(Plane other) public bool Equals(Plane other)
{ {
return _normal == other._normal && D == other.D; return _normal == other._normal && Distance == other.Distance;
} }
public bool IsEqualApprox(Plane other) 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() public override int GetHashCode()
{ {
return _normal.GetHashCode() ^ D.GetHashCode(); return _normal.GetHashCode() ^ Distance.GetHashCode();
} }
public override string ToString() public override string ToString()
@ -222,7 +222,7 @@ namespace Godot
return String.Format("({0}, {1})", new object[] return String.Format("({0}, {1})", new object[]
{ {
_normal.ToString(), _normal.ToString(),
D.ToString() Distance.ToString()
}); });
} }
@ -231,7 +231,7 @@ namespace Godot
return String.Format("({0}, {1})", new object[] return String.Format("({0}, {1})", new object[]
{ {
_normal.ToString(format), _normal.ToString(format),
D.ToString(format) Distance.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))) && MATCHES_Plane = (MATCHES_Vector3 && MATCHES_real_t && (sizeof(Plane) == (sizeof(Vector3) + sizeof(real_t))) &&
offsetof(Plane, normal) == 0 && 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 // 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 { struct M_Plane {
M_Vector3 normal; M_Vector3 normal;
real_t d; real_t distance;
static _FORCE_INLINE_ Plane convert_to(const M_Plane &p_from) { 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) { 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; 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); Plane p(get_camera_transform().xform_inv(p_pos), 1.0);
p = cm.xform4(p); p = cm.xform4(p);
p.normal /= p.d; p.normal /= p.distance;
Point2 res; Point2 res;
res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x; 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); Plane p(get_camera_transform().xform_inv(p_pos), 1.0);
p = cm.xform4(p); p = cm.xform4(p);
p.normal /= p.d; p.normal /= p.distance;
Point2 res; Point2 res;
res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x; 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; p = mid;
Plane post; Plane post;
post.normal = pos; post.normal = pos;
post.d = Math::lerp(points[i].tilt, points[i + 1].tilt, mid); post.distance = Math::lerp(points[i].tilt, points[i + 1].tilt, mid);
pointlist.push_back(post); pointlist.push_back(post);
} else { } else {
@ -1274,7 +1274,7 @@ void Curve3D::_bake() const {
for (List<Plane>::Element *E = pointlist.front(); E; E = E->next()) { for (List<Plane>::Element *E = pointlist.front(); E; E = E->next()) {
w[idx] = E->get().normal; w[idx] = E->get().normal;
wt[idx] = E->get().d; wt[idx] = E->get().distance;
if (!up_vector_enabled) { if (!up_vector_enabled) {
idx++; 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) { if (lightmap_surfaces[surface].format & ARRAY_FORMAT_TANGENT) {
Plane t; Plane t;
t.normal = v.tangent; t.normal = v.tangent;
t.d = v.binormal.dot(v.normal.cross(v.tangent)) < 0 ? -1 : 1; t.distance = v.binormal.dot(v.normal.cross(v.tangent)) < 0 ? -1 : 1;
surfaces_tools.write[surface]->add_tangent(t); surfaces_tools.write[surface]->add_tangent(t);
} }
if (lightmap_surfaces[surface].format & ARRAY_FORMAT_BONES) { 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 + 0] = vtx.tangent.normal.x;
ta[i * 4 + 1] = vtx.tangent.normal.y; ta[i * 4 + 1] = vtx.tangent.normal.y;
ta[i * 4 + 2] = vtx.tangent.normal.z; ta[i * 4 + 2] = vtx.tangent.normal.z;
ta[i * 4 + 3] = vtx.tangent.d; ta[i * 4 + 3] = vtx.tangent.distance;
} }
if (uv) if (uv)
uv[i] = vtx.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.weights = last_weights;
vtx.bones = last_bones; vtx.bones = last_bones;
vtx.tangent = last_tangent.normal; vtx.tangent = last_tangent.normal;
vtx.binormal = last_normal.cross(last_tangent.normal).normalized() * last_tangent.d; vtx.binormal = last_normal.cross(last_tangent.normal).normalized() * last_tangent.distance;
const int expected_vertices = 4; 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) { if (lformat & RS::ARRAY_FORMAT_TANGENT) {
Plane p(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]); Plane p(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]);
v.tangent = p.normal; v.tangent = p.normal;
v.binormal = p.normal.cross(v.tangent).normalized() * p.d; v.binormal = p.normal.cross(v.tangent).normalized() * p.distance;
} }
if (lformat & RS::ARRAY_FORMAT_COLOR) if (lformat & RS::ARRAY_FORMAT_COLOR)
v.color = carr[i]; 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) { if (lformat & RS::ARRAY_FORMAT_TANGENT) {
Plane p(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]); Plane p(tarr[i * 4 + 0], tarr[i * 4 + 1], tarr[i * 4 + 2], tarr[i * 4 + 3]);
v.tangent = p.normal; v.tangent = p.normal;
v.binormal = p.normal.cross(v.tangent).normalized() * p.d; v.binormal = p.normal.cross(v.tangent).normalized() * p.distance;
} }
if (lformat & RS::ARRAY_FORMAT_COLOR) if (lformat & RS::ARRAY_FORMAT_COLOR)
v.color = carr[i]; 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 n2 = p.normal.cross(n1).normalized();
Vector3 pface[4] = { Vector3 pface[4] = {
p.normal * p.d + 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.distance + n1 * 10.0 + n2 * -10.0,
p.normal * p.d + 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.distance + n1 * -10.0 + n2 * 10.0,
}; };
points.push_back(pface[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[3]); points.push_back(pface[3]);
points.push_back(pface[0]); points.push_back(pface[0]);
points.push_back(p.normal * p.d); points.push_back(p.normal * p.distance);
points.push_back(p.normal * p.d + p.normal * 3); points.push_back(p.normal * p.distance + p.normal * 3);
return points; 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 // calculate intersection
Vector3 rel = edge1_A - edge0_A; Vector3 rel = edge1_A - edge0_A;
real_t den = clip.normal.dot(rel); real_t den = clip.normal.dot(rel);
real_t dist = -(clip.normal.dot(edge0_A) - clip.d) / den; real_t dist = -(clip.normal.dot(edge0_A) - clip.distance) / den;
Vector3 inters = edge0_A + rel * dist; Vector3 inters = edge0_A + rel * dist;
ERR_FAIL_COND(dst_idx >= max_clip); 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; int32_t y_groups = (p_screen_size.height - 1) / 8 + 1;
Plane p = p_camera.xform4(Plane(1, 0, -1, 1)); Plane p = p_camera.xform4(Plane(1, 0, -1, 1));
p.normal /= p.d; p.normal /= p.distance;
float unit_size = p.normal.x; float unit_size = p.normal.x;
{ //scale color and depth to half { //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[0] = v.normal.x;
gui[1] = v.normal.y; gui[1] = v.normal.y;
gui[2] = v.normal.z; gui[2] = v.normal.z;
gui[3] = v.d; gui[3] = v.distance;
} }
} break; } break;
case ShaderLanguage::TYPE_MAT2: { 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.x = v.normal.x;
bv.y = v.normal.y; bv.y = v.normal.y;
bv.z = v.normal.z; bv.z = v.normal.z;
bv.w = v.d; bv.w = v.distance;
} break; } break;
case RS::GLOBAL_VAR_TYPE_COLOR: { case RS::GLOBAL_VAR_TYPE_COLOR: {
GlobalVariables::Value &bv = global_variables.buffer_values[p_index]; GlobalVariables::Value &bv = global_variables.buffer_values[p_index];