Revert "Renamed plane's d to distance"
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:
parent
6ab92464bc
commit
94721f5ab8
36 changed files with 126 additions and 126 deletions
|
@ -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;
|
||||
|
|
|
@ -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: {
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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: {
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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: {
|
||||
|
|
|
@ -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.
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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());
|
||||
|
|
|
@ -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();
|
||||
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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 */
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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"],
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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) {
|
||||
|
||||
|
|
|
@ -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());
|
||||
|
|
|
@ -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)
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
};
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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++;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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];
|
||||
|
|
Loading…
Reference in a new issue