mirror of
https://github.com/godotengine/godot.git
synced 2024-10-23 13:41:43 +00:00
Float literals - fix math classes to allow 32 bit calculations
Converts float literals from double format (e.g. 0.0) to float format (e.g. 0.0f) where appropriate for 32 bit calculations, and cast to (real_t) or (float) as appropriate. This ensures that appropriate calculations will be done at 32 bits when real_t is compiled as float, rather than promoted to 64 bits.
This commit is contained in:
lawnjelly
parent
ae9fa90091
commit
d24c715678
|
|
@ -58,7 +58,7 @@ public:
|
|||
void set_position(const Vector3 &p_pos) { position = p_pos; }
|
||||
const Vector3 &get_size() const { return size; }
|
||||
void set_size(const Vector3 &p_size) { size = p_size; }
|
||||
Vector3 get_center() const { return position + (size * 0.5); }
|
||||
Vector3 get_center() const { return position + (size * 0.5f); }
|
||||
|
||||
bool operator==(const AABB &p_rval) const;
|
||||
bool operator!=(const AABB &p_rval) const;
|
||||
|
|
@ -176,7 +176,7 @@ inline bool AABB::encloses(const AABB &p_aabb) const {
|
|||
}
|
||||
|
||||
Vector3 AABB::get_support(const Vector3 &p_normal) const {
|
||||
Vector3 half_extents = size * 0.5;
|
||||
Vector3 half_extents = size * 0.5f;
|
||||
Vector3 ofs = position + half_extents;
|
||||
|
||||
return Vector3(
|
||||
|
|
@ -210,7 +210,7 @@ Vector3 AABB::get_endpoint(int p_point) const {
|
|||
}
|
||||
|
||||
bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count, const Vector3 *p_points, int p_point_count) const {
|
||||
Vector3 half_extents = size * 0.5;
|
||||
Vector3 half_extents = size * 0.5f;
|
||||
Vector3 ofs = position + half_extents;
|
||||
|
||||
for (int i = 0; i < p_plane_count; i++) {
|
||||
|
|
@ -252,7 +252,7 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count, con
|
|||
}
|
||||
|
||||
bool AABB::inside_convex_shape(const Plane *p_planes, int p_plane_count) const {
|
||||
Vector3 half_extents = size * 0.5;
|
||||
Vector3 half_extents = size * 0.5f;
|
||||
Vector3 ofs = position + half_extents;
|
||||
|
||||
for (int i = 0; i < p_plane_count; i++) {
|
||||
|
|
@ -322,7 +322,7 @@ inline void AABB::expand_to(const Vector3 &p_vector) {
|
|||
}
|
||||
|
||||
void AABB::project_range_in_plane(const Plane &p_plane, real_t &r_min, real_t &r_max) const {
|
||||
Vector3 half_extents(size.x * 0.5, size.y * 0.5, size.z * 0.5);
|
||||
Vector3 half_extents = size * 0.5f;
|
||||
Vector3 center(position.x + half_extents.x, position.y + half_extents.y, position.z + half_extents.z);
|
||||
|
||||
real_t length = p_plane.normal.abs().dot(half_extents);
|
||||
|
|
@ -360,9 +360,9 @@ inline real_t AABB::get_shortest_axis_size() const {
|
|||
}
|
||||
|
||||
bool AABB::smits_intersect_ray(const Vector3 &p_from, const Vector3 &p_dir, real_t t0, real_t t1) const {
|
||||
real_t divx = 1.0 / p_dir.x;
|
||||
real_t divy = 1.0 / p_dir.y;
|
||||
real_t divz = 1.0 / p_dir.z;
|
||||
real_t divx = 1 / p_dir.x;
|
||||
real_t divy = 1 / p_dir.y;
|
||||
real_t divz = 1 / p_dir.z;
|
||||
|
||||
Vector3 upbound = position + size;
|
||||
real_t tmin, tmax, tymin, tymax, tzmin, tzmax;
|
||||
|
|
@ -412,9 +412,9 @@ void AABB::grow_by(real_t p_amount) {
|
|||
position.x -= p_amount;
|
||||
position.y -= p_amount;
|
||||
position.z -= p_amount;
|
||||
size.x += 2.0 * p_amount;
|
||||
size.y += 2.0 * p_amount;
|
||||
size.z += 2.0 * p_amount;
|
||||
size.x += 2 * p_amount;
|
||||
size.y += 2 * p_amount;
|
||||
size.z += 2 * p_amount;
|
||||
}
|
||||
|
||||
#endif // AABB_H
|
||||
|
|
|
|||
|
|
@ -37,16 +37,16 @@
|
|||
(elements[row1][col1] * elements[row2][col2] - elements[row1][col2] * elements[row2][col1])
|
||||
|
||||
void Basis::from_z(const Vector3 &p_z) {
|
||||
if (Math::abs(p_z.z) > Math_SQRT12) {
|
||||
if (Math::abs(p_z.z) > (real_t)Math_SQRT12) {
|
||||
// choose p in y-z plane
|
||||
real_t a = p_z[1] * p_z[1] + p_z[2] * p_z[2];
|
||||
real_t k = 1.0 / Math::sqrt(a);
|
||||
real_t k = 1 / Math::sqrt(a);
|
||||
elements[0] = Vector3(0, -p_z[2] * k, p_z[1] * k);
|
||||
elements[1] = Vector3(a * k, -p_z[0] * elements[0][2], p_z[0] * elements[0][1]);
|
||||
} else {
|
||||
// choose p in x-y plane
|
||||
real_t a = p_z.x * p_z.x + p_z.y * p_z.y;
|
||||
real_t k = 1.0 / Math::sqrt(a);
|
||||
real_t k = 1 / Math::sqrt(a);
|
||||
elements[0] = Vector3(-p_z.y * k, p_z.x * k, 0);
|
||||
elements[1] = Vector3(-p_z.z * elements[0].y, p_z.z * elements[0].x, a * k);
|
||||
}
|
||||
|
|
@ -63,7 +63,7 @@ void Basis::invert() {
|
|||
#ifdef MATH_CHECKS
|
||||
ERR_FAIL_COND(det == 0);
|
||||
#endif
|
||||
real_t s = 1.0 / det;
|
||||
real_t s = 1 / det;
|
||||
|
||||
set(co[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
|
||||
co[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
|
||||
|
|
@ -113,13 +113,13 @@ bool Basis::is_rotation() const {
|
|||
}
|
||||
|
||||
bool Basis::is_symmetric() const {
|
||||
if (!Math::is_equal_approx_ratio(elements[0][1], elements[1][0], UNIT_EPSILON)) {
|
||||
if (!Math::is_equal_approx_ratio(elements[0][1], elements[1][0], (real_t)UNIT_EPSILON)) {
|
||||
return false;
|
||||
}
|
||||
if (!Math::is_equal_approx_ratio(elements[0][2], elements[2][0], UNIT_EPSILON)) {
|
||||
if (!Math::is_equal_approx_ratio(elements[0][2], elements[2][0], (real_t)UNIT_EPSILON)) {
|
||||
return false;
|
||||
}
|
||||
if (!Math::is_equal_approx_ratio(elements[1][2], elements[2][1], UNIT_EPSILON)) {
|
||||
if (!Math::is_equal_approx_ratio(elements[1][2], elements[2][1], (real_t)UNIT_EPSILON)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -138,7 +138,7 @@ Basis Basis::diagonalize() {
|
|||
|
||||
int ite = 0;
|
||||
Basis acc_rot;
|
||||
while (off_matrix_norm_2 > CMP_EPSILON2 && ite++ < ite_max) {
|
||||
while (off_matrix_norm_2 > (real_t)CMP_EPSILON2 && ite++ < ite_max) {
|
||||
real_t el01_2 = elements[0][1] * elements[0][1];
|
||||
real_t el02_2 = elements[0][2] * elements[0][2];
|
||||
real_t el12_2 = elements[1][2] * elements[1][2];
|
||||
|
|
@ -167,7 +167,7 @@ Basis Basis::diagonalize() {
|
|||
if (Math::is_equal_approx(elements[j][j], elements[i][i])) {
|
||||
angle = Math_PI / 4;
|
||||
} else {
|
||||
angle = 0.5 * Math::atan(2 * elements[i][j] / (elements[j][j] - elements[i][i]));
|
||||
angle = 0.5f * Math::atan(2 * elements[i][j] / (elements[j][j] - elements[i][i]));
|
||||
}
|
||||
|
||||
// Compute the rotation matrix
|
||||
|
|
@ -412,10 +412,10 @@ Vector3 Basis::get_euler_xyz() const {
|
|||
|
||||
Vector3 euler;
|
||||
real_t sy = elements[0][2];
|
||||
if (sy < (1.0 - CMP_EPSILON)) {
|
||||
if (sy > -(1.0 - CMP_EPSILON)) {
|
||||
if (sy < (1 - (real_t)CMP_EPSILON)) {
|
||||
if (sy > -(1 - (real_t)CMP_EPSILON)) {
|
||||
// is this a pure Y rotation?
|
||||
if (elements[1][0] == 0.0 && elements[0][1] == 0.0 && elements[1][2] == 0 && elements[2][1] == 0 && elements[1][1] == 1) {
|
||||
if (elements[1][0] == 0 && elements[0][1] == 0 && elements[1][2] == 0 && elements[2][1] == 0 && elements[1][1] == 1) {
|
||||
// return the simplest form (human friendlier in editor and scripts)
|
||||
euler.x = 0;
|
||||
euler.y = atan2(elements[0][2], elements[0][0]);
|
||||
|
|
@ -447,15 +447,15 @@ void Basis::set_euler_xyz(const Vector3 &p_euler) {
|
|||
|
||||
c = Math::cos(p_euler.x);
|
||||
s = Math::sin(p_euler.x);
|
||||
Basis xmat(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c);
|
||||
Basis xmat(1, 0, 0, 0, c, -s, 0, s, c);
|
||||
|
||||
c = Math::cos(p_euler.y);
|
||||
s = Math::sin(p_euler.y);
|
||||
Basis ymat(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c);
|
||||
Basis ymat(c, 0, s, 0, 1, 0, -s, 0, c);
|
||||
|
||||
c = Math::cos(p_euler.z);
|
||||
s = Math::sin(p_euler.z);
|
||||
Basis zmat(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0);
|
||||
Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1);
|
||||
|
||||
//optimizer will optimize away all this anyway
|
||||
*this = xmat * (ymat * zmat);
|
||||
|
|
@ -471,8 +471,8 @@ Vector3 Basis::get_euler_xzy() const {
|
|||
|
||||
Vector3 euler;
|
||||
real_t sz = elements[0][1];
|
||||
if (sz < (1.0 - CMP_EPSILON)) {
|
||||
if (sz > -(1.0 - CMP_EPSILON)) {
|
||||
if (sz < (1 - (real_t)CMP_EPSILON)) {
|
||||
if (sz > -(1 - (real_t)CMP_EPSILON)) {
|
||||
euler.x = Math::atan2(elements[2][1], elements[1][1]);
|
||||
euler.y = Math::atan2(elements[0][2], elements[0][0]);
|
||||
euler.z = Math::asin(-sz);
|
||||
|
|
@ -496,15 +496,15 @@ void Basis::set_euler_xzy(const Vector3 &p_euler) {
|
|||
|
||||
c = Math::cos(p_euler.x);
|
||||
s = Math::sin(p_euler.x);
|
||||
Basis xmat(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c);
|
||||
Basis xmat(1, 0, 0, 0, c, -s, 0, s, c);
|
||||
|
||||
c = Math::cos(p_euler.y);
|
||||
s = Math::sin(p_euler.y);
|
||||
Basis ymat(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c);
|
||||
Basis ymat(c, 0, s, 0, 1, 0, -s, 0, c);
|
||||
|
||||
c = Math::cos(p_euler.z);
|
||||
s = Math::sin(p_euler.z);
|
||||
Basis zmat(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0);
|
||||
Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1);
|
||||
|
||||
*this = xmat * zmat * ymat;
|
||||
}
|
||||
|
|
@ -519,8 +519,8 @@ Vector3 Basis::get_euler_yzx() const {
|
|||
|
||||
Vector3 euler;
|
||||
real_t sz = elements[1][0];
|
||||
if (sz < (1.0 - CMP_EPSILON)) {
|
||||
if (sz > -(1.0 - CMP_EPSILON)) {
|
||||
if (sz < (1 - (real_t)CMP_EPSILON)) {
|
||||
if (sz > -(1 - (real_t)CMP_EPSILON)) {
|
||||
euler.x = Math::atan2(-elements[1][2], elements[1][1]);
|
||||
euler.y = Math::atan2(-elements[2][0], elements[0][0]);
|
||||
euler.z = Math::asin(sz);
|
||||
|
|
@ -544,15 +544,15 @@ void Basis::set_euler_yzx(const Vector3 &p_euler) {
|
|||
|
||||
c = Math::cos(p_euler.x);
|
||||
s = Math::sin(p_euler.x);
|
||||
Basis xmat(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c);
|
||||
Basis xmat(1, 0, 0, 0, c, -s, 0, s, c);
|
||||
|
||||
c = Math::cos(p_euler.y);
|
||||
s = Math::sin(p_euler.y);
|
||||
Basis ymat(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c);
|
||||
Basis ymat(c, 0, s, 0, 1, 0, -s, 0, c);
|
||||
|
||||
c = Math::cos(p_euler.z);
|
||||
s = Math::sin(p_euler.z);
|
||||
Basis zmat(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0);
|
||||
Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1);
|
||||
|
||||
*this = ymat * zmat * xmat;
|
||||
}
|
||||
|
|
@ -572,8 +572,8 @@ Vector3 Basis::get_euler_yxz() const {
|
|||
|
||||
real_t m12 = elements[1][2];
|
||||
|
||||
if (m12 < (1 - CMP_EPSILON)) {
|
||||
if (m12 > -(1 - CMP_EPSILON)) {
|
||||
if (m12 < (1 - (real_t)CMP_EPSILON)) {
|
||||
if (m12 > -(1 - (real_t)CMP_EPSILON)) {
|
||||
// is this a pure X rotation?
|
||||
if (elements[1][0] == 0 && elements[0][1] == 0 && elements[0][2] == 0 && elements[2][0] == 0 && elements[0][0] == 1) {
|
||||
// return the simplest form (human friendlier in editor and scripts)
|
||||
|
|
@ -608,15 +608,15 @@ void Basis::set_euler_yxz(const Vector3 &p_euler) {
|
|||
|
||||
c = Math::cos(p_euler.x);
|
||||
s = Math::sin(p_euler.x);
|
||||
Basis xmat(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c);
|
||||
Basis xmat(1, 0, 0, 0, c, -s, 0, s, c);
|
||||
|
||||
c = Math::cos(p_euler.y);
|
||||
s = Math::sin(p_euler.y);
|
||||
Basis ymat(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c);
|
||||
Basis ymat(c, 0, s, 0, 1, 0, -s, 0, c);
|
||||
|
||||
c = Math::cos(p_euler.z);
|
||||
s = Math::sin(p_euler.z);
|
||||
Basis zmat(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0);
|
||||
Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1);
|
||||
|
||||
//optimizer will optimize away all this anyway
|
||||
*this = ymat * xmat * zmat;
|
||||
|
|
@ -631,8 +631,8 @@ Vector3 Basis::get_euler_zxy() const {
|
|||
// -cx*sy sx cx*cy
|
||||
Vector3 euler;
|
||||
real_t sx = elements[2][1];
|
||||
if (sx < (1.0 - CMP_EPSILON)) {
|
||||
if (sx > -(1.0 - CMP_EPSILON)) {
|
||||
if (sx < (1 - (real_t)CMP_EPSILON)) {
|
||||
if (sx > -(1 - (real_t)CMP_EPSILON)) {
|
||||
euler.x = Math::asin(sx);
|
||||
euler.y = Math::atan2(-elements[2][0], elements[2][2]);
|
||||
euler.z = Math::atan2(-elements[0][1], elements[1][1]);
|
||||
|
|
@ -656,15 +656,15 @@ void Basis::set_euler_zxy(const Vector3 &p_euler) {
|
|||
|
||||
c = Math::cos(p_euler.x);
|
||||
s = Math::sin(p_euler.x);
|
||||
Basis xmat(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c);
|
||||
Basis xmat(1, 0, 0, 0, c, -s, 0, s, c);
|
||||
|
||||
c = Math::cos(p_euler.y);
|
||||
s = Math::sin(p_euler.y);
|
||||
Basis ymat(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c);
|
||||
Basis ymat(c, 0, s, 0, 1, 0, -s, 0, c);
|
||||
|
||||
c = Math::cos(p_euler.z);
|
||||
s = Math::sin(p_euler.z);
|
||||
Basis zmat(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0);
|
||||
Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1);
|
||||
|
||||
*this = zmat * xmat * ymat;
|
||||
}
|
||||
|
|
@ -678,8 +678,8 @@ Vector3 Basis::get_euler_zyx() const {
|
|||
// -sy cy*sx cy*cx
|
||||
Vector3 euler;
|
||||
real_t sy = elements[2][0];
|
||||
if (sy < (1.0 - CMP_EPSILON)) {
|
||||
if (sy > -(1.0 - CMP_EPSILON)) {
|
||||
if (sy < (1 - (real_t)CMP_EPSILON)) {
|
||||
if (sy > -(1 - (real_t)CMP_EPSILON)) {
|
||||
euler.x = Math::atan2(elements[2][1], elements[2][2]);
|
||||
euler.y = Math::asin(-sy);
|
||||
euler.z = Math::atan2(elements[1][0], elements[0][0]);
|
||||
|
|
@ -703,15 +703,15 @@ void Basis::set_euler_zyx(const Vector3 &p_euler) {
|
|||
|
||||
c = Math::cos(p_euler.x);
|
||||
s = Math::sin(p_euler.x);
|
||||
Basis xmat(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c);
|
||||
Basis xmat(1, 0, 0, 0, c, -s, 0, s, c);
|
||||
|
||||
c = Math::cos(p_euler.y);
|
||||
s = Math::sin(p_euler.y);
|
||||
Basis ymat(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c);
|
||||
Basis ymat(c, 0, s, 0, 1, 0, -s, 0, c);
|
||||
|
||||
c = Math::cos(p_euler.z);
|
||||
s = Math::sin(p_euler.z);
|
||||
Basis zmat(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0);
|
||||
Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1);
|
||||
|
||||
*this = zmat * ymat * xmat;
|
||||
}
|
||||
|
|
@ -772,10 +772,10 @@ Quat Basis::get_quat() const {
|
|||
real_t trace = m.elements[0][0] + m.elements[1][1] + m.elements[2][2];
|
||||
real_t temp[4];
|
||||
|
||||
if (trace > 0.0) {
|
||||
real_t s = Math::sqrt(trace + 1.0);
|
||||
temp[3] = (s * 0.5);
|
||||
s = 0.5 / s;
|
||||
if (trace > 0) {
|
||||
real_t s = Math::sqrt(trace + 1);
|
||||
temp[3] = (s * 0.5f);
|
||||
s = 0.5f / s;
|
||||
|
||||
temp[0] = ((m.elements[2][1] - m.elements[1][2]) * s);
|
||||
temp[1] = ((m.elements[0][2] - m.elements[2][0]) * s);
|
||||
|
|
@ -787,9 +787,9 @@ Quat Basis::get_quat() const {
|
|||
int j = (i + 1) % 3;
|
||||
int k = (i + 2) % 3;
|
||||
|
||||
real_t s = Math::sqrt(m.elements[i][i] - m.elements[j][j] - m.elements[k][k] + 1.0);
|
||||
temp[i] = s * 0.5;
|
||||
s = 0.5 / s;
|
||||
real_t s = Math::sqrt(m.elements[i][i] - m.elements[j][j] - m.elements[k][k] + 1);
|
||||
temp[i] = s * 0.5f;
|
||||
s = 0.5f / s;
|
||||
|
||||
temp[3] = (m.elements[k][j] - m.elements[j][k]) * s;
|
||||
temp[j] = (m.elements[j][i] + m.elements[i][j]) * s;
|
||||
|
|
@ -832,10 +832,10 @@ int Basis::get_orthogonal_index() const {
|
|||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
real_t v = orth[i][j];
|
||||
if (v > 0.5) {
|
||||
v = 1.0;
|
||||
} else if (v < -0.5) {
|
||||
v = -1.0;
|
||||
if (v > 0.5f) {
|
||||
v = 1;
|
||||
} else if (v < -0.5f) {
|
||||
v = -1;
|
||||
} else {
|
||||
v = 0;
|
||||
}
|
||||
|
|
@ -940,14 +940,14 @@ void Basis::get_axis_angle(Vector3 &r_axis, real_t &r_angle) const {
|
|||
|
||||
void Basis::set_quat(const Quat &p_quat) {
|
||||
real_t d = p_quat.length_squared();
|
||||
real_t s = 2.0 / d;
|
||||
real_t s = 2 / d;
|
||||
real_t xs = p_quat.x * s, ys = p_quat.y * s, zs = p_quat.z * s;
|
||||
real_t wx = p_quat.w * xs, wy = p_quat.w * ys, wz = p_quat.w * zs;
|
||||
real_t xx = p_quat.x * xs, xy = p_quat.x * ys, xz = p_quat.x * zs;
|
||||
real_t yy = p_quat.y * ys, yz = p_quat.y * zs, zz = p_quat.z * zs;
|
||||
set(1.0 - (yy + zz), xy - wz, xz + wy,
|
||||
xy + wz, 1.0 - (xx + zz), yz - wx,
|
||||
xz - wy, yz + wx, 1.0 - (xx + yy));
|
||||
set(1 - (yy + zz), xy - wz, xz + wy,
|
||||
xy + wz, 1 - (xx + zz), yz - wx,
|
||||
xz - wy, yz + wx, 1 - (xx + yy));
|
||||
}
|
||||
|
||||
void Basis::set_axis_angle(const Vector3 &p_axis, real_t p_phi) {
|
||||
|
|
@ -957,9 +957,9 @@ void Basis::set_axis_angle(const Vector3 &p_axis, real_t p_phi) {
|
|||
#endif
|
||||
Vector3 axis_sq(p_axis.x * p_axis.x, p_axis.y * p_axis.y, p_axis.z * p_axis.z);
|
||||
real_t cosine = Math::cos(p_phi);
|
||||
elements[0][0] = axis_sq.x + cosine * (1.0 - axis_sq.x);
|
||||
elements[1][1] = axis_sq.y + cosine * (1.0 - axis_sq.y);
|
||||
elements[2][2] = axis_sq.z + cosine * (1.0 - axis_sq.z);
|
||||
elements[0][0] = axis_sq.x + cosine * (1 - axis_sq.x);
|
||||
elements[1][1] = axis_sq.y + cosine * (1 - axis_sq.y);
|
||||
elements[2][2] = axis_sq.z + cosine * (1 - axis_sq.z);
|
||||
|
||||
real_t sine = Math::sin(p_phi);
|
||||
real_t t = 1 - cosine;
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ int BSP_Tree::_get_points_inside(int p_node, const Vector3 *p_points, int *p_ind
|
|||
real_t dist_min = p.distance_to(min);
|
||||
real_t dist_max = p.distance_to(max);
|
||||
|
||||
if ((dist_min * dist_max) < CMP_EPSILON) { //intersection, test point by point
|
||||
if ((dist_min * dist_max) < (real_t)CMP_EPSILON) { //intersection, test point by point
|
||||
|
||||
int under_count = 0;
|
||||
|
||||
|
|
@ -213,7 +213,7 @@ int BSP_Tree::get_points_inside(const Vector3 *p_points, int p_point_count) cons
|
|||
bounds.expand_to(p_points[i]);
|
||||
}
|
||||
|
||||
Vector3 half_extents = bounds.size / 2.0;
|
||||
Vector3 half_extents = bounds.size / 2;
|
||||
return _get_points_inside(nodes.size() + 1, p_points, indices, bounds.pos + half_extents, half_extents, p_point_count);
|
||||
#endif
|
||||
}
|
||||
|
|
@ -530,7 +530,7 @@ BSP_Tree::BSP_Tree(const PoolVector<Face3> &p_faces, real_t p_error_radius) {
|
|||
|
||||
ERR_FAIL_COND(aabb.has_no_area());
|
||||
|
||||
int top = _bsp_create_node(faces_r.ptr(), indices, planes, nodes, aabb.get_longest_axis_size() * 0.0001);
|
||||
int top = _bsp_create_node(faces_r.ptr(), indices, planes, nodes, aabb.get_longest_axis_size() * 0.0001f);
|
||||
|
||||
if (top < 0) {
|
||||
nodes.clear();
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ public:
|
|||
// see the variable declarations for more info.
|
||||
void params_set_node_expansion(real_t p_value) {
|
||||
BVH_LOCKED_FUNCTION
|
||||
if (p_value >= 0.0) {
|
||||
if (p_value >= 0) {
|
||||
tree._node_expansion = p_value;
|
||||
tree._auto_node_expansion = false;
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -88,12 +88,12 @@ struct BVH_ABB {
|
|||
}
|
||||
|
||||
POINT calculate_centre() const {
|
||||
return POINT((calculate_size() * 0.5) + min);
|
||||
return POINT((calculate_size() * 0.5f) + min);
|
||||
}
|
||||
|
||||
real_t get_proximity_to(const BVH_ABB &p_b) const {
|
||||
const POINT d = (min - neg_max) - (p_b.min - p_b.neg_max);
|
||||
real_t proximity = 0.0;
|
||||
real_t proximity = 0;
|
||||
for (int axis = 0; axis < POINT::AXIS_COUNT; ++axis) {
|
||||
proximity += Math::abs(d[axis]);
|
||||
}
|
||||
|
|
@ -119,7 +119,7 @@ struct BVH_ABB {
|
|||
|
||||
bool intersects_plane(const Plane &p_p) const {
|
||||
Vector3 size = calculate_size();
|
||||
Vector3 half_extents = size * 0.5;
|
||||
Vector3 half_extents = size * 0.5f;
|
||||
Vector3 ofs = min + half_extents;
|
||||
|
||||
// forward side of plane?
|
||||
|
|
@ -143,7 +143,7 @@ struct BVH_ABB {
|
|||
|
||||
bool intersects_convex_optimized(const ConvexHull &p_hull, const uint32_t *p_plane_ids, uint32_t p_num_planes) const {
|
||||
Vector3 size = calculate_size();
|
||||
Vector3 half_extents = size * 0.5;
|
||||
Vector3 half_extents = size * 0.5f;
|
||||
Vector3 ofs = min + half_extents;
|
||||
|
||||
for (unsigned int i = 0; i < p_num_planes; i++) {
|
||||
|
|
@ -189,7 +189,7 @@ struct BVH_ABB {
|
|||
|
||||
bool is_point_within_hull(const ConvexHull &p_hull, const Vector3 &p_pt) const {
|
||||
for (int n = 0; n < p_hull.num_planes; n++) {
|
||||
if (p_hull.planes[n].distance_to(p_pt) > 0.0f) {
|
||||
if (p_hull.planes[n].distance_to(p_pt) > 0) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
@ -258,7 +258,7 @@ struct BVH_ABB {
|
|||
// Actually surface area metric.
|
||||
float get_area() const {
|
||||
POINT d = calculate_size();
|
||||
return 2.0f * (d.x * d.y + d.y * d.z + d.z * d.x);
|
||||
return 2 * (d.x * d.y + d.y * d.z + d.z * d.x);
|
||||
}
|
||||
|
||||
void set_to_max_opposite_extents() {
|
||||
|
|
|
|||
|
|
@ -64,9 +64,9 @@ struct ItemPairs {
|
|||
// when the number of pairs is high, the density is high and a lower collision margin is better.
|
||||
// when there are few local pairs, a larger margin is more optimal.
|
||||
real_t scale_expansion_margin(real_t p_margin) const {
|
||||
real_t x = real_t(num_pairs) * (1.0 / 9.0);
|
||||
real_t x = (real_t)num_pairs * (real_t)(1.0 / 9.0);
|
||||
x = MIN(x, 1.0);
|
||||
x = 1.0 - x;
|
||||
x = 1 - x;
|
||||
return p_margin * x;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -452,7 +452,7 @@ void update() {
|
|||
}
|
||||
|
||||
void params_set_pairing_expansion(real_t p_value) {
|
||||
if (p_value < 0.0) {
|
||||
if (p_value < 0) {
|
||||
#ifdef BVH_ALLOW_AUTO_EXPANSION
|
||||
_auto_pairing_expansion = true;
|
||||
#endif
|
||||
|
|
@ -465,8 +465,8 @@ void params_set_pairing_expansion(real_t p_value) {
|
|||
_pairing_expansion = p_value;
|
||||
|
||||
// calculate shrinking threshold
|
||||
const real_t fudge_factor = 1.1;
|
||||
_aabb_shrinkage_threshold = _pairing_expansion * POINT::AXIS_COUNT * 2.0 * fudge_factor;
|
||||
const real_t fudge_factor = 1.1f;
|
||||
_aabb_shrinkage_threshold = _pairing_expansion * POINT::AXIS_COUNT * 2 * fudge_factor;
|
||||
}
|
||||
|
||||
// This routine is not just an enclose check, it also checks for special case of shrinkage
|
||||
|
|
@ -481,8 +481,8 @@ bool expanded_aabb_encloses_not_shrink(const BOUNDS &p_expanded_aabb, const BOUN
|
|||
const POINT &exp_size = p_expanded_aabb.size;
|
||||
const POINT &new_size = p_aabb.size;
|
||||
|
||||
real_t exp_l = 0.0;
|
||||
real_t new_l = 0.0;
|
||||
real_t exp_l = 0;
|
||||
real_t new_l = 0;
|
||||
|
||||
for (int i = 0; i < POINT::AXIS_COUNT; ++i) {
|
||||
exp_l += exp_size[i];
|
||||
|
|
|
|||
|
|
@ -154,11 +154,11 @@ void CameraMatrix::set_for_hmd(int p_eye, real_t p_aspect, real_t p_intraocular_
|
|||
void CameraMatrix::set_orthogonal(real_t p_left, real_t p_right, real_t p_bottom, real_t p_top, real_t p_znear, real_t p_zfar) {
|
||||
set_identity();
|
||||
|
||||
matrix[0][0] = 2.0 / (p_right - p_left);
|
||||
matrix[0][0] = 2 / (p_right - p_left);
|
||||
matrix[3][0] = -((p_right + p_left) / (p_right - p_left));
|
||||
matrix[1][1] = 2.0 / (p_top - p_bottom);
|
||||
matrix[1][1] = 2 / (p_top - p_bottom);
|
||||
matrix[3][1] = -((p_top + p_bottom) / (p_top - p_bottom));
|
||||
matrix[2][2] = -2.0 / (p_zfar - p_znear);
|
||||
matrix[2][2] = -2 / (p_zfar - p_znear);
|
||||
matrix[3][2] = -((p_zfar + p_znear) / (p_zfar - p_znear));
|
||||
matrix[3][3] = 1.0;
|
||||
}
|
||||
|
|
@ -388,7 +388,7 @@ void CameraMatrix::invert() {
|
|||
pvt_j[k] = k;
|
||||
for (i = k; i < 4; i++) {
|
||||
for (j = k; j < 4; j++) {
|
||||
if (Math::absd(matrix[i][j]) > Math::absd(pvt_val)) {
|
||||
if (Math::abs(matrix[i][j]) > Math::abs(pvt_val)) {
|
||||
pvt_i[k] = i;
|
||||
pvt_j[k] = j;
|
||||
pvt_val = matrix[i][j];
|
||||
|
|
@ -398,7 +398,7 @@ void CameraMatrix::invert() {
|
|||
|
||||
/** Product of pivots, gives determinant when finished **/
|
||||
determinat *= pvt_val;
|
||||
if (Math::absd(determinat) < 1e-7) {
|
||||
if (Math::abs(determinat) < (real_t)1e-7) {
|
||||
return; //(false); /** Matrix is singular (zero determinant). **/
|
||||
}
|
||||
|
||||
|
|
@ -554,7 +554,7 @@ real_t CameraMatrix::get_aspect() const {
|
|||
int CameraMatrix::get_pixels_per_meter(int p_for_pixel_width) const {
|
||||
Vector3 result = xform(Vector3(1, 0, -1));
|
||||
|
||||
return int((result.x * 0.5 + 0.5) * p_for_pixel_width);
|
||||
return int((result.x * 0.5f + 0.5f) * p_for_pixel_width);
|
||||
}
|
||||
|
||||
bool CameraMatrix::is_orthogonal() const {
|
||||
|
|
@ -571,7 +571,7 @@ real_t CameraMatrix::get_fov() const {
|
|||
right_plane.normalize();
|
||||
|
||||
if ((matrix[8] == 0) && (matrix[9] == 0)) {
|
||||
return Math::rad2deg(Math::acos(Math::abs(right_plane.normal.x))) * 2.0;
|
||||
return Math::rad2deg(Math::acos(Math::abs(right_plane.normal.x))) * 2;
|
||||
} else {
|
||||
// our frustum is asymmetrical need to calculate the left planes angle separately..
|
||||
Plane left_plane = Plane(matrix[3] + matrix[0],
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ int Face3::split_by_plane(const Plane &p_plane, Face3 p_res[3], bool p_is_point_
|
|||
int below_count = 0;
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
if (p_plane.has_point(vertex[i], CMP_EPSILON)) { // point is in plane
|
||||
if (p_plane.has_point(vertex[i], (real_t)CMP_EPSILON)) { // point is in plane
|
||||
|
||||
ERR_FAIL_COND_V(above_count >= 4, 0);
|
||||
above[above_count++] = vertex[i];
|
||||
|
|
@ -117,7 +117,7 @@ bool Face3::intersects_segment(const Vector3 &p_from, const Vector3 &p_dir, Vect
|
|||
|
||||
bool Face3::is_degenerate() const {
|
||||
Vector3 normal = vec3_cross(vertex[0] - vertex[1], vertex[0] - vertex[2]);
|
||||
return (normal.length_squared() < CMP_EPSILON2);
|
||||
return (normal.length_squared() < (real_t)CMP_EPSILON2);
|
||||
}
|
||||
|
||||
Face3::Side Face3::get_side_of(const Face3 &p_face, ClockDirection p_clock_dir) const {
|
||||
|
|
@ -223,7 +223,7 @@ bool Face3::intersects_aabb(const AABB &p_aabb) const {
|
|||
|
||||
Vector3 axis = vec3_cross(e1, e2);
|
||||
|
||||
if (axis.length_squared() < 0.0001) {
|
||||
if (axis.length_squared() < 0.0001f) {
|
||||
continue; // coplanar
|
||||
}
|
||||
axis.normalize();
|
||||
|
|
@ -270,7 +270,7 @@ void Face3::get_support(const Vector3 &p_normal, const Transform &p_transform, V
|
|||
Vector3 n = p_transform.basis.xform_inv(p_normal);
|
||||
|
||||
/** TEST FACE AS SUPPORT **/
|
||||
if (get_plane().normal.dot(n) > _FACE_IS_VALID_SUPPORT_THRESHOLD) {
|
||||
if (get_plane().normal.dot(n) > (real_t)_FACE_IS_VALID_SUPPORT_THRESHOLD) {
|
||||
*p_count = MIN(3, p_max);
|
||||
|
||||
for (int i = 0; i < *p_count; i++) {
|
||||
|
|
@ -304,7 +304,7 @@ void Face3::get_support(const Vector3 &p_normal, const Transform &p_transform, V
|
|||
// check if edge is valid as a support
|
||||
real_t dot = (vertex[i] - vertex[(i + 1) % 3]).normalized().dot(n);
|
||||
dot = ABS(dot);
|
||||
if (dot < _EDGE_IS_VALID_SUPPORT_THRESHOLD) {
|
||||
if (dot < (real_t)_EDGE_IS_VALID_SUPPORT_THRESHOLD) {
|
||||
*p_count = MIN(2, p_max);
|
||||
|
||||
for (int j = 0; j < *p_count; j++) {
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ inline real_t Face3::get_twice_area_squared() const {
|
|||
bool Face3::intersects_aabb2(const AABB &p_aabb) const {
|
||||
Vector3 perp = (vertex[0] - vertex[2]).cross(vertex[0] - vertex[1]);
|
||||
|
||||
Vector3 half_extents = p_aabb.size * 0.5;
|
||||
Vector3 half_extents = p_aabb.size * 0.5f;
|
||||
Vector3 ofs = p_aabb.position + half_extents;
|
||||
|
||||
Vector3 sup = Vector3(
|
||||
|
|
@ -217,7 +217,7 @@ bool Face3::intersects_aabb2(const AABB &p_aabb) const {
|
|||
|
||||
Vector3 axis = vec3_cross(e1, e2);
|
||||
|
||||
if (axis.length_squared() < 0.0001) {
|
||||
if (axis.length_squared() < 0.0001f) {
|
||||
continue; // coplanar
|
||||
}
|
||||
//axis.normalize();
|
||||
|
|
|
|||
|
|
@ -160,8 +160,8 @@ static bool _connect_faces(_FaceClassify *p_faces, int len, int p_group) {
|
|||
Vector3 vj2 = p_faces[j].face.vertex[l];
|
||||
Vector3 vj1 = p_faces[j].face.vertex[(l + 1) % 3];
|
||||
|
||||
if (vi1.distance_to(vj1) < 0.00001 &&
|
||||
vi2.distance_to(vj2) < 0.00001) {
|
||||
if (vi1.distance_to(vj1) < 0.00001f &&
|
||||
vi2.distance_to(vj2) < 0.00001f) {
|
||||
if (p_faces[i].links[k].face != -1) {
|
||||
ERR_PRINT("already linked\n");
|
||||
error = true;
|
||||
|
|
@ -534,7 +534,7 @@ static inline void _build_faces(uint8_t ***p_cell_status, int x, int y, int z, i
|
|||
}
|
||||
|
||||
PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_error) {
|
||||
#define _MIN_SIZE 1.0
|
||||
#define _MIN_SIZE 1.0f
|
||||
#define _MAX_LENGTH 20
|
||||
|
||||
int face_count = p_array.size();
|
||||
|
|
@ -551,7 +551,7 @@ PoolVector<Face3> Geometry::wrap_geometry(PoolVector<Face3> p_array, real_t *p_e
|
|||
}
|
||||
}
|
||||
|
||||
global_aabb.grow_by(0.01); // Avoid numerical error.
|
||||
global_aabb.grow_by(0.01f); // Avoid numerical error.
|
||||
|
||||
// Determine amount of cells in grid axis.
|
||||
int div_x, div_y, div_z;
|
||||
|
|
@ -716,7 +716,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
|
||||
Vector3 ref = Vector3(0.0, 1.0, 0.0);
|
||||
|
||||
if (ABS(p.normal.dot(ref)) > 0.95) {
|
||||
if (ABS(p.normal.dot(ref)) > 0.95f) {
|
||||
ref = Vector3(0.0, 0.0, 1.0); // Change axis.
|
||||
}
|
||||
|
||||
|
|
@ -740,7 +740,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
Vector<Vector3> new_vertices;
|
||||
Plane clip = p_planes[j];
|
||||
|
||||
if (clip.normal.dot(p.normal) > 0.95) {
|
||||
if (clip.normal.dot(p.normal) > 0.95f) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -793,7 +793,7 @@ Geometry::MeshData Geometry::build_convex_mesh(const PoolVector<Plane> &p_planes
|
|||
for (int j = 0; j < vertices.size(); j++) {
|
||||
int idx = -1;
|
||||
for (int k = 0; k < mesh.vertices.size(); k++) {
|
||||
if (mesh.vertices[k].distance_to(vertices[j]) < 0.001) {
|
||||
if (mesh.vertices[k].distance_to(vertices[j]) < 0.001f) {
|
||||
idx = k;
|
||||
break;
|
||||
}
|
||||
|
|
@ -860,8 +860,8 @@ PoolVector<Plane> Geometry::build_cylinder_planes(real_t p_radius, real_t p_heig
|
|||
|
||||
for (int i = 0; i < p_sides; i++) {
|
||||
Vector3 normal;
|
||||
normal[(p_axis + 1) % 3] = Math::cos(i * (2.0 * Math_PI) / p_sides);
|
||||
normal[(p_axis + 2) % 3] = Math::sin(i * (2.0 * Math_PI) / p_sides);
|
||||
normal[(p_axis + 1) % 3] = Math::cos(i * (real_t)(2.0 * Math_PI) / p_sides);
|
||||
normal[(p_axis + 2) % 3] = Math::sin(i * (real_t)(2.0 * Math_PI) / p_sides);
|
||||
|
||||
planes.push_back(Plane(normal, p_radius));
|
||||
}
|
||||
|
|
@ -869,8 +869,8 @@ PoolVector<Plane> Geometry::build_cylinder_planes(real_t p_radius, real_t p_heig
|
|||
Vector3 axis;
|
||||
axis[p_axis] = 1.0;
|
||||
|
||||
planes.push_back(Plane(axis, p_height * 0.5));
|
||||
planes.push_back(Plane(-axis, p_height * 0.5));
|
||||
planes.push_back(Plane(axis, p_height * 0.5f));
|
||||
planes.push_back(Plane(-axis, p_height * 0.5f));
|
||||
|
||||
return planes;
|
||||
}
|
||||
|
|
@ -881,17 +881,17 @@ PoolVector<Plane> Geometry::build_sphere_planes(real_t p_radius, int p_lats, int
|
|||
PoolVector<Plane> planes;
|
||||
|
||||
Vector3 axis;
|
||||
axis[p_axis] = 1.0;
|
||||
axis[p_axis] = 1;
|
||||
|
||||
Vector3 axis_neg;
|
||||
axis_neg[(p_axis + 1) % 3] = 1.0;
|
||||
axis_neg[(p_axis + 2) % 3] = 1.0;
|
||||
axis_neg[p_axis] = -1.0;
|
||||
axis_neg[(p_axis + 1) % 3] = 1;
|
||||
axis_neg[(p_axis + 2) % 3] = 1;
|
||||
axis_neg[p_axis] = -1;
|
||||
|
||||
for (int i = 0; i < p_lons; i++) {
|
||||
Vector3 normal;
|
||||
normal[(p_axis + 1) % 3] = Math::cos(i * (2.0 * Math_PI) / p_lons);
|
||||
normal[(p_axis + 2) % 3] = Math::sin(i * (2.0 * Math_PI) / p_lons);
|
||||
normal[(p_axis + 1) % 3] = Math::cos(i * (real_t)(2.0 * Math_PI) / p_lons);
|
||||
normal[(p_axis + 2) % 3] = Math::sin(i * (real_t)(2.0 * Math_PI) / p_lons);
|
||||
|
||||
planes.push_back(Plane(normal, p_radius));
|
||||
|
||||
|
|
@ -913,23 +913,23 @@ PoolVector<Plane> Geometry::build_capsule_planes(real_t p_radius, real_t p_heigh
|
|||
PoolVector<Plane> planes;
|
||||
|
||||
Vector3 axis;
|
||||
axis[p_axis] = 1.0;
|
||||
axis[p_axis] = 1;
|
||||
|
||||
Vector3 axis_neg;
|
||||
axis_neg[(p_axis + 1) % 3] = 1.0;
|
||||
axis_neg[(p_axis + 2) % 3] = 1.0;
|
||||
axis_neg[p_axis] = -1.0;
|
||||
axis_neg[(p_axis + 1) % 3] = 1;
|
||||
axis_neg[(p_axis + 2) % 3] = 1;
|
||||
axis_neg[p_axis] = -1;
|
||||
|
||||
for (int i = 0; i < p_sides; i++) {
|
||||
Vector3 normal;
|
||||
normal[(p_axis + 1) % 3] = Math::cos(i * (2.0 * Math_PI) / p_sides);
|
||||
normal[(p_axis + 2) % 3] = Math::sin(i * (2.0 * Math_PI) / p_sides);
|
||||
normal[(p_axis + 1) % 3] = Math::cos(i * (real_t)(2.0 * Math_PI) / p_sides);
|
||||
normal[(p_axis + 2) % 3] = Math::sin(i * (real_t)(2.0 * Math_PI) / p_sides);
|
||||
|
||||
planes.push_back(Plane(normal, p_radius));
|
||||
|
||||
for (int j = 1; j <= p_lats; j++) {
|
||||
Vector3 angle = normal.linear_interpolate(axis, j / (real_t)p_lats).normalized();
|
||||
Vector3 pos = axis * p_height * 0.5 + angle * p_radius;
|
||||
Vector3 pos = axis * p_height * 0.5f + angle * p_radius;
|
||||
planes.push_back(Plane(pos, angle));
|
||||
planes.push_back(Plane(pos * axis_neg, angle * axis_neg));
|
||||
}
|
||||
|
|
@ -942,7 +942,7 @@ struct _AtlasWorkRect {
|
|||
Size2i s;
|
||||
Point2i p;
|
||||
int idx;
|
||||
_FORCE_INLINE_ bool operator<(const _AtlasWorkRect &p_r) const { return s.width > p_r.s.width; };
|
||||
_FORCE_INLINE_ bool operator<(const _AtlasWorkRect &p_r) const { return s.width > p_r.s.width; }
|
||||
};
|
||||
|
||||
struct _AtlasWorkRectResult {
|
||||
|
|
@ -1085,10 +1085,10 @@ Vector<Vector<Point2>> Geometry::_polypaths_do_operation(PolyBooleanOperation p_
|
|||
|
||||
// Need to scale points (Clipper's requirement for robust computation).
|
||||
for (int i = 0; i != p_polypath_a.size(); ++i) {
|
||||
path_a << IntPoint(p_polypath_a[i].x * SCALE_FACTOR, p_polypath_a[i].y * SCALE_FACTOR);
|
||||
path_a << IntPoint(p_polypath_a[i].x * (real_t)SCALE_FACTOR, p_polypath_a[i].y * (real_t)SCALE_FACTOR);
|
||||
}
|
||||
for (int i = 0; i != p_polypath_b.size(); ++i) {
|
||||
path_b << IntPoint(p_polypath_b[i].x * SCALE_FACTOR, p_polypath_b[i].y * SCALE_FACTOR);
|
||||
path_b << IntPoint(p_polypath_b[i].x * (real_t)SCALE_FACTOR, p_polypath_b[i].y * (real_t)SCALE_FACTOR);
|
||||
}
|
||||
Clipper clp;
|
||||
clp.AddPath(path_a, ptSubject, !is_a_open); // Forward compatible with Clipper 10.0.0.
|
||||
|
|
@ -1113,8 +1113,8 @@ Vector<Vector<Point2>> Geometry::_polypaths_do_operation(PolyBooleanOperation p_
|
|||
|
||||
for (Paths::size_type j = 0; j < scaled_path.size(); ++j) {
|
||||
polypath.push_back(Point2(
|
||||
static_cast<real_t>(scaled_path[j].X) / SCALE_FACTOR,
|
||||
static_cast<real_t>(scaled_path[j].Y) / SCALE_FACTOR));
|
||||
static_cast<real_t>(scaled_path[j].X) / (real_t)SCALE_FACTOR,
|
||||
static_cast<real_t>(scaled_path[j].Y) / (real_t)SCALE_FACTOR));
|
||||
}
|
||||
polypaths.push_back(polypath);
|
||||
}
|
||||
|
|
@ -1157,17 +1157,17 @@ Vector<Vector<Point2>> Geometry::_polypath_offset(const Vector<Point2> &p_polypa
|
|||
et = etOpenRound;
|
||||
break;
|
||||
}
|
||||
ClipperOffset co(2.0, 0.25 * SCALE_FACTOR); // Defaults from ClipperOffset.
|
||||
ClipperOffset co(2.0f, 0.25f * (real_t)SCALE_FACTOR); // Defaults from ClipperOffset.
|
||||
Path path;
|
||||
|
||||
// Need to scale points (Clipper's requirement for robust computation).
|
||||
for (int i = 0; i != p_polypath.size(); ++i) {
|
||||
path << IntPoint(p_polypath[i].x * SCALE_FACTOR, p_polypath[i].y * SCALE_FACTOR);
|
||||
path << IntPoint(p_polypath[i].x * (real_t)SCALE_FACTOR, p_polypath[i].y * (real_t)SCALE_FACTOR);
|
||||
}
|
||||
co.AddPath(path, jt, et);
|
||||
|
||||
Paths paths;
|
||||
co.Execute(paths, p_delta * SCALE_FACTOR); // Inflate/deflate.
|
||||
co.Execute(paths, p_delta * (real_t)SCALE_FACTOR); // Inflate/deflate.
|
||||
|
||||
// Have to scale points down now.
|
||||
Vector<Vector<Point2>> polypaths;
|
||||
|
|
@ -1179,8 +1179,8 @@ Vector<Vector<Point2>> Geometry::_polypath_offset(const Vector<Point2> &p_polypa
|
|||
|
||||
for (Paths::size_type j = 0; j < scaled_path.size(); ++j) {
|
||||
polypath.push_back(Point2(
|
||||
static_cast<real_t>(scaled_path[j].X) / SCALE_FACTOR,
|
||||
static_cast<real_t>(scaled_path[j].Y) / SCALE_FACTOR));
|
||||
static_cast<real_t>(scaled_path[j].X) / (real_t)SCALE_FACTOR,
|
||||
static_cast<real_t>(scaled_path[j].Y) / (real_t)SCALE_FACTOR));
|
||||
}
|
||||
polypaths.push_back(polypath);
|
||||
}
|
||||
|
|
@ -1189,7 +1189,7 @@ Vector<Vector<Point2>> Geometry::_polypath_offset(const Vector<Point2> &p_polypa
|
|||
|
||||
real_t Geometry::calculate_convex_hull_volume(const Geometry::MeshData &p_md) {
|
||||
if (!p_md.vertices.size()) {
|
||||
return 0.0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// find center
|
||||
|
|
@ -1226,7 +1226,7 @@ real_t Geometry::calculate_convex_hull_volume(const Geometry::MeshData &p_md) {
|
|||
volume += face_area * height;
|
||||
}
|
||||
|
||||
volume *= (1.0 / 3.0) * 0.5;
|
||||
volume *= (real_t)((1.0 / 3.0) * 0.5);
|
||||
return volume;
|
||||
}
|
||||
|
||||
|
|
@ -1394,7 +1394,7 @@ real_t Geometry::find_polygon_area(const Vector3 *p_verts, int p_num_verts) {
|
|||
area += Math::sqrt(f.get_twice_area_squared());
|
||||
}
|
||||
|
||||
return area * 0.5;
|
||||
return area * 0.5f;
|
||||
}
|
||||
|
||||
// adapted from:
|
||||
|
|
@ -1422,10 +1422,10 @@ void Geometry::sort_polygon_winding(Vector<Vector2> &r_verts, bool p_clockwise)
|
|||
|
||||
// compute the cross product of vectors (center -> a) x (center -> b)
|
||||
real_t det = (a.x - center.x) * (b.y - center.y) - (b.x - center.x) * (a.y - center.y);
|
||||
if (det < 0.0) {
|
||||
if (det < 0) {
|
||||
return true;
|
||||
}
|
||||
if (det > 0.0) {
|
||||
if (det > 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -52,33 +52,33 @@ public:
|
|||
real_t f = d2.dot(r);
|
||||
real_t s, t;
|
||||
// Check if either or both segments degenerate into points.
|
||||
if (a <= CMP_EPSILON && e <= CMP_EPSILON) {
|
||||
if (a <= (real_t)CMP_EPSILON && e <= (real_t)CMP_EPSILON) {
|
||||
// Both segments degenerate into points.
|
||||
c1 = p1;
|
||||
c2 = p2;
|
||||
return Math::sqrt((c1 - c2).dot(c1 - c2));
|
||||
}
|
||||
if (a <= CMP_EPSILON) {
|
||||
if (a <= (real_t)CMP_EPSILON) {
|
||||
// First segment degenerates into a point.
|
||||
s = 0.0;
|
||||
s = 0;
|
||||
t = f / e; // s = 0 => t = (b*s + f) / e = f / e
|
||||
t = CLAMP(t, 0.0, 1.0);
|
||||
t = CLAMP(t, 0, 1);
|
||||
} else {
|
||||
real_t c = d1.dot(r);
|
||||
if (e <= CMP_EPSILON) {
|
||||
if (e <= (real_t)CMP_EPSILON) {
|
||||
// Second segment degenerates into a point.
|
||||
t = 0.0;
|
||||
s = CLAMP(-c / a, 0.0, 1.0); // t = 0 => s = (b*t - c) / a = -c / a
|
||||
t = 0;
|
||||
s = CLAMP(-c / a, 0, 1); // t = 0 => s = (b*t - c) / a = -c / a
|
||||
} else {
|
||||
// The general nondegenerate case starts here.
|
||||
real_t b = d1.dot(d2);
|
||||
real_t denom = a * e - b * b; // Always nonnegative.
|
||||
// If segments not parallel, compute closest point on L1 to L2 and
|
||||
// clamp to segment S1. Else pick arbitrary s (here 0).
|
||||
if (denom != 0.0) {
|
||||
s = CLAMP((b * f - c * e) / denom, 0.0, 1.0);
|
||||
if (denom != 0) {
|
||||
s = CLAMP((b * f - c * e) / denom, 0, 1);
|
||||
} else {
|
||||
s = 0.0;
|
||||
s = 0;
|
||||
}
|
||||
// Compute point on L2 closest to S1(s) using
|
||||
// t = Dot((P1 + D1*s) - P2,D2) / Dot(D2,D2) = (b*s + f) / e
|
||||
|
|
@ -87,12 +87,12 @@ public:
|
|||
//If t in [0,1] done. Else clamp t, recompute s for the new value
|
||||
// of t using s = Dot((P2 + D2*t) - P1,D1) / Dot(D1,D1)= (t*b - c) / a
|
||||
// and clamp s to [0, 1].
|
||||
if (t < 0.0) {
|
||||
t = 0.0;
|
||||
s = CLAMP(-c / a, 0.0, 1.0);
|
||||
} else if (t > 1.0) {
|
||||
t = 1.0;
|
||||
s = CLAMP((b - c) / a, 0.0, 1.0);
|
||||
if (t < 0) {
|
||||
t = 0;
|
||||
s = CLAMP(-c / a, 0, 1);
|
||||
} else if (t > 1) {
|
||||
t = 1;
|
||||
s = CLAMP((b - c) / a, 0, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -140,16 +140,16 @@ public:
|
|||
real_t tc, tN, tD = D; // tc = tN / tD, default tD = D >= 0
|
||||
|
||||
// Compute the line parameters of the two closest points.
|
||||
if (D < CMP_EPSILON) { // The lines are almost parallel.
|
||||
sN = 0.0; // Force using point P0 on segment S1
|
||||
sD = 1.0; // to prevent possible division by 0.0 later.
|
||||
if (D < (real_t)CMP_EPSILON) { // The lines are almost parallel.
|
||||
sN = 0; // Force using point P0 on segment S1
|
||||
sD = 1; // to prevent possible division by 0.0 later.
|
||||
tN = e;
|
||||
tD = c;
|
||||
} else { // Get the closest points on the infinite lines
|
||||
sN = (b * e - c * d);
|
||||
tN = (a * e - b * d);
|
||||
if (sN < 0.0) { // sc < 0 => the s=0 edge is visible.
|
||||
sN = 0.0;
|
||||
if (sN < 0) { // sc < 0 => the s=0 edge is visible.
|
||||
sN = 0;
|
||||
tN = e;
|
||||
tD = c;
|
||||
} else if (sN > sD) { // sc > 1 => the s=1 edge is visible.
|
||||
|
|
@ -159,11 +159,11 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
if (tN < 0.0) { // tc < 0 => the t=0 edge is visible.
|
||||
tN = 0.0;
|
||||
if (tN < 0) { // tc < 0 => the t=0 edge is visible.
|
||||
tN = 0;
|
||||
// Recompute sc for this edge.
|
||||
if (-d < 0.0) {
|
||||
sN = 0.0;
|
||||
if (-d < 0) {
|
||||
sN = 0;
|
||||
} else if (-d > a) {
|
||||
sN = sD;
|
||||
} else {
|
||||
|
|
@ -173,7 +173,7 @@ public:
|
|||
} else if (tN > tD) { // tc > 1 => the t=1 edge is visible.
|
||||
tN = tD;
|
||||
// Recompute sc for this edge.
|
||||
if ((-d + b) < 0.0) {
|
||||
if ((-d + b) < 0) {
|
||||
sN = 0;
|
||||
} else if ((-d + b) > a) {
|
||||
sN = sD;
|
||||
|
|
@ -183,8 +183,8 @@ public:
|
|||
}
|
||||
}
|
||||
// Finally do the division to get sc and tc.
|
||||
sc = (Math::is_zero_approx(sN) ? 0.0 : sN / sD);
|
||||
tc = (Math::is_zero_approx(tN) ? 0.0 : tN / tD);
|
||||
sc = (Math::is_zero_approx(sN) ? 0 : sN / sD);
|
||||
tc = (Math::is_zero_approx(tN) ? 0 : tN / tD);
|
||||
|
||||
// Get the difference of the two closest points.
|
||||
Vector3 dP = w + (sc * u) - (tc * v); // = S1(sc) - S2(tc)
|
||||
|
|
@ -201,12 +201,12 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
real_t f = 1.0 / a;
|
||||
real_t f = 1 / a;
|
||||
|
||||
Vector3 s = p_from - p_v0;
|
||||
real_t u = f * s.dot(h);
|
||||
|
||||
if (u < 0.0 || u > 1.0) {
|
||||
if ((u < 0) || (u > 1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -214,7 +214,7 @@ public:
|
|||
|
||||
real_t v = f * p_dir.dot(q);
|
||||
|
||||
if (v < 0.0 || u + v > 1.0) {
|
||||
if ((v < 0) || (u + v > 1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -222,7 +222,7 @@ public:
|
|||
// the intersection point is on the line.
|
||||
real_t t = f * e2.dot(q);
|
||||
|
||||
if (t > 0.00001) { // ray intersection
|
||||
if (t > 0.00001f) { // ray intersection
|
||||
if (r_res) {
|
||||
*r_res = p_from + p_dir * t;
|
||||
}
|
||||
|
|
@ -242,12 +242,12 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
real_t f = 1.0 / a;
|
||||
real_t f = 1 / a;
|
||||
|
||||
Vector3 s = p_from - p_v0;
|
||||
real_t u = f * s.dot(h);
|
||||
|
||||
if (u < 0.0 || u > 1.0) {
|
||||
if ((u < 0) || (u > 1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -255,7 +255,7 @@ public:
|
|||
|
||||
real_t v = f * rel.dot(q);
|
||||
|
||||
if (v < 0.0 || u + v > 1.0) {
|
||||
if ((v < 0) || (u + v > 1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -263,7 +263,7 @@ public:
|
|||
// the intersection point is on the line.
|
||||
real_t t = f * e2.dot(q);
|
||||
|
||||
if (t > CMP_EPSILON && t <= 1.0) { // Ray intersection.
|
||||
if (t > (real_t)CMP_EPSILON && t <= 1) { // Ray intersection.
|
||||
if (r_res) {
|
||||
*r_res = p_from + rel * t;
|
||||
}
|
||||
|
|
@ -277,7 +277,7 @@ public:
|
|||
Vector3 sphere_pos = p_sphere_pos - p_from;
|
||||
Vector3 rel = (p_to - p_from);
|
||||
real_t rel_l = rel.length();
|
||||
if (rel_l < CMP_EPSILON) {
|
||||
if (rel_l < (real_t)CMP_EPSILON) {
|
||||
return false; // Both points are the same.
|
||||
}
|
||||
Vector3 normal = rel / rel_l;
|
||||
|
|
@ -293,7 +293,7 @@ public:
|
|||
real_t inters_d2 = p_sphere_radius * p_sphere_radius - ray_distance * ray_distance;
|
||||
real_t inters_d = sphere_d;
|
||||
|
||||
if (inters_d2 >= CMP_EPSILON) {
|
||||
if (inters_d2 >= (real_t)CMP_EPSILON) {
|
||||
inters_d -= Math::sqrt(inters_d2);
|
||||
}
|
||||
|
||||
|
|
@ -317,14 +317,14 @@ public:
|
|||
static inline bool segment_intersects_cylinder(const Vector3 &p_from, const Vector3 &p_to, real_t p_height, real_t p_radius, Vector3 *r_res = nullptr, Vector3 *r_norm = nullptr, int p_cylinder_axis = 2) {
|
||||
Vector3 rel = (p_to - p_from);
|
||||
real_t rel_l = rel.length();
|
||||
if (rel_l < CMP_EPSILON) {
|
||||
if (rel_l < (real_t)CMP_EPSILON) {
|
||||
return false; // Both points are the same.
|
||||
}
|
||||
|
||||
ERR_FAIL_COND_V(p_cylinder_axis < 0, false);
|
||||
ERR_FAIL_COND_V(p_cylinder_axis > 2, false);
|
||||
Vector3 cylinder_axis;
|
||||
cylinder_axis[p_cylinder_axis] = 1.0;
|
||||
cylinder_axis[p_cylinder_axis] = 1;
|
||||
|
||||
// First check if they are parallel.
|
||||
Vector3 normal = (rel / rel_l);
|
||||
|
|
@ -333,9 +333,9 @@ public:
|
|||
|
||||
Vector3 axis_dir;
|
||||
|
||||
if (crs_l < CMP_EPSILON) {
|
||||
if (crs_l < (real_t)CMP_EPSILON) {
|
||||
Vector3 side_axis;
|
||||
side_axis[(p_cylinder_axis + 1) % 3] = 1.0; // Any side axis OK.
|
||||
side_axis[(p_cylinder_axis + 1) % 3] = 1; // Any side axis OK.
|
||||
axis_dir = side_axis;
|
||||
} else {
|
||||
axis_dir = crs / crs_l;
|
||||
|
|
@ -349,10 +349,10 @@ public:
|
|||
|
||||
// Convert to 2D.
|
||||
real_t w2 = p_radius * p_radius - dist * dist;
|
||||
if (w2 < CMP_EPSILON) {
|
||||
if (w2 < (real_t)CMP_EPSILON) {
|
||||
return false; // Avoid numerical error.
|
||||
}
|
||||
Size2 size(Math::sqrt(w2), p_height * 0.5);
|
||||
Size2 size(Math::sqrt(w2), p_height * 0.5f);
|
||||
|
||||
Vector3 side_dir = axis_dir.cross(cylinder_axis).normalized();
|
||||
|
||||
|
|
@ -430,7 +430,7 @@ public:
|
|||
Vector3 rel = p_to - p_from;
|
||||
real_t rel_l = rel.length();
|
||||
|
||||
if (rel_l < CMP_EPSILON) {
|
||||
if (rel_l < (real_t)CMP_EPSILON) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -443,7 +443,7 @@ public:
|
|||
|
||||
real_t den = p.normal.dot(dir);
|
||||
|
||||
if (Math::abs(den) <= CMP_EPSILON) {
|
||||
if (Math::abs(den) <= (real_t)CMP_EPSILON) {
|
||||
continue; // Ignore parallel plane.
|
||||
}
|
||||
|
||||
|
|
@ -481,13 +481,13 @@ public:
|
|||
Vector3 p = p_point - p_segment[0];
|
||||
Vector3 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20) {
|
||||
if (l2 < 1e-20f) {
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
}
|
||||
|
||||
real_t d = n.dot(p) / l2;
|
||||
|
||||
if (d <= 0.0) {
|
||||
if (d <= 0) {
|
||||
return p_segment[0]; // Before first point.
|
||||
} else if (d >= 1.0) {
|
||||
return p_segment[1]; // After first point.
|
||||
|
|
@ -500,7 +500,7 @@ public:
|
|||
Vector3 p = p_point - p_segment[0];
|
||||
Vector3 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20) {
|
||||
if (l2 < 1e-20f) {
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
}
|
||||
|
||||
|
|
@ -513,15 +513,15 @@ public:
|
|||
Vector2 p = p_point - p_segment[0];
|
||||
Vector2 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20) {
|
||||
if (l2 < 1e-20f) {
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
}
|
||||
|
||||
real_t d = n.dot(p) / l2;
|
||||
|
||||
if (d <= 0.0) {
|
||||
if (d <= 0) {
|
||||
return p_segment[0]; // Before first point.
|
||||
} else if (d >= 1.0) {
|
||||
} else if (d >= 1) {
|
||||
return p_segment[1]; // After first point.
|
||||
} else {
|
||||
return p_segment[0] + n * d; // Inside.
|
||||
|
|
@ -573,7 +573,7 @@ public:
|
|||
Vector2 p = p_point - p_segment[0];
|
||||
Vector2 n = p_segment[1] - p_segment[0];
|
||||
real_t l2 = n.length_squared();
|
||||
if (l2 < 1e-20) {
|
||||
if (l2 < 1e-20f) {
|
||||
return p_segment[0]; // Both points are the same, just give any.
|
||||
}
|
||||
|
||||
|
|
@ -616,7 +616,7 @@ public:
|
|||
real_t ABpos = D.x + (C.x - D.x) * D.y / (D.y - C.y);
|
||||
|
||||
// Fail if segment C-D crosses line A-B outside of segment A-B.
|
||||
if (ABpos < 0 || ABpos > 1.0) {
|
||||
if ((ABpos < 0) || (ABpos > 1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -785,11 +785,11 @@ public:
|
|||
|
||||
for (int a = 0; a < polygon.size(); a++) {
|
||||
real_t dist = p_plane.distance_to(polygon[a]);
|
||||
if (dist < -CMP_POINT_IN_PLANE_EPSILON) {
|
||||
if (dist < (real_t)-CMP_POINT_IN_PLANE_EPSILON) {
|
||||
location_cache[a] = LOC_INSIDE;
|
||||
inside_count++;
|
||||
} else {
|
||||
if (dist > CMP_POINT_IN_PLANE_EPSILON) {
|
||||
if (dist > (real_t)CMP_POINT_IN_PLANE_EPSILON) {
|
||||
location_cache[a] = LOC_OUTSIDE;
|
||||
outside_count++;
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ public:
|
|||
static _ALWAYS_INLINE_ float sinc(float p_x) { return p_x == 0 ? 1 : ::sin(p_x) / p_x; }
|
||||
static _ALWAYS_INLINE_ double sinc(double p_x) { return p_x == 0 ? 1 : ::sin(p_x) / p_x; }
|
||||
|
||||
static _ALWAYS_INLINE_ float sincn(float p_x) { return sinc(Math_PI * p_x); }
|
||||
static _ALWAYS_INLINE_ float sincn(float p_x) { return sinc((float)Math_PI * p_x); }
|
||||
static _ALWAYS_INLINE_ double sincn(double p_x) { return sinc(Math_PI * p_x); }
|
||||
|
||||
static _ALWAYS_INLINE_ double cosh(double p_x) { return ::cosh(p_x); }
|
||||
|
|
@ -185,7 +185,7 @@ public:
|
|||
|
||||
static _ALWAYS_INLINE_ double fposmod(double p_x, double p_y) {
|
||||
double value = Math::fmod(p_x, p_y);
|
||||
if ((value < 0 && p_y > 0) || (value > 0 && p_y < 0)) {
|
||||
if (((value < 0) && (p_y > 0)) || ((value > 0) && (p_y < 0))) {
|
||||
value += p_y;
|
||||
}
|
||||
value += 0.0;
|
||||
|
|
@ -193,25 +193,25 @@ public:
|
|||
}
|
||||
static _ALWAYS_INLINE_ float fposmod(float p_x, float p_y) {
|
||||
float value = Math::fmod(p_x, p_y);
|
||||
if ((value < 0 && p_y > 0) || (value > 0 && p_y < 0)) {
|
||||
if (((value < 0) && (p_y > 0)) || ((value > 0) && (p_y < 0))) {
|
||||
value += p_y;
|
||||
}
|
||||
value += 0.0;
|
||||
value += 0.0f;
|
||||
return value;
|
||||
}
|
||||
static _ALWAYS_INLINE_ int64_t posmod(int64_t p_x, int64_t p_y) {
|
||||
int64_t value = p_x % p_y;
|
||||
if ((value < 0 && p_y > 0) || (value > 0 && p_y < 0)) {
|
||||
if (((value < 0) && (p_y > 0)) || ((value > 0) && (p_y < 0))) {
|
||||
value += p_y;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
static _ALWAYS_INLINE_ double deg2rad(double p_y) { return p_y * Math_PI / 180.0; }
|
||||
static _ALWAYS_INLINE_ float deg2rad(float p_y) { return p_y * Math_PI / 180.0; }
|
||||
static _ALWAYS_INLINE_ float deg2rad(float p_y) { return p_y * (float)(Math_PI / 180.0); }
|
||||
|
||||
static _ALWAYS_INLINE_ double rad2deg(double p_y) { return p_y * 180.0 / Math_PI; }
|
||||
static _ALWAYS_INLINE_ float rad2deg(float p_y) { return p_y * 180.0 / Math_PI; }
|
||||
static _ALWAYS_INLINE_ float rad2deg(float p_y) { return p_y * (float)(180.0 / Math_PI); }
|
||||
|
||||
static _ALWAYS_INLINE_ double lerp(double p_from, double p_to, double p_weight) { return p_from + (p_to - p_from) * p_weight; }
|
||||
static _ALWAYS_INLINE_ float lerp(float p_from, float p_to, float p_weight) { return p_from + (p_to - p_from) * p_weight; }
|
||||
|
|
@ -251,10 +251,10 @@ public:
|
|||
static _ALWAYS_INLINE_ float move_toward(float p_from, float p_to, float p_delta) { return abs(p_to - p_from) <= p_delta ? p_to : p_from + SGN(p_to - p_from) * p_delta; }
|
||||
|
||||
static _ALWAYS_INLINE_ double linear2db(double p_linear) { return Math::log(p_linear) * 8.6858896380650365530225783783321; }
|
||||
static _ALWAYS_INLINE_ float linear2db(float p_linear) { return Math::log(p_linear) * 8.6858896380650365530225783783321; }
|
||||
static _ALWAYS_INLINE_ float linear2db(float p_linear) { return Math::log(p_linear) * (float)8.6858896380650365530225783783321; }
|
||||
|
||||
static _ALWAYS_INLINE_ double db2linear(double p_db) { return Math::exp(p_db * 0.11512925464970228420089957273422); }
|
||||
static _ALWAYS_INLINE_ float db2linear(float p_db) { return Math::exp(p_db * 0.11512925464970228420089957273422); }
|
||||
static _ALWAYS_INLINE_ float db2linear(float p_db) { return Math::exp(p_db * (float)0.11512925464970228420089957273422); }
|
||||
|
||||
static _ALWAYS_INLINE_ double round(double p_val) { return ::round(p_val); }
|
||||
static _ALWAYS_INLINE_ float round(float p_val) { return ::roundf(p_val); }
|
||||
|
|
@ -296,10 +296,10 @@ public:
|
|||
// this is an approximate way to check that numbers are close, as a ratio of their average size
|
||||
// helps compare approximate numbers that may be very big or very small
|
||||
real_t diff = abs(a - b);
|
||||
if (diff == 0.0 || diff < min_epsilon) {
|
||||
if (diff == 0 || diff < min_epsilon) {
|
||||
return true;
|
||||
}
|
||||
real_t avg_size = (abs(a) + abs(b)) / 2.0;
|
||||
real_t avg_size = (abs(a) + abs(b)) / 2;
|
||||
diff /= avg_size;
|
||||
return diff < epsilon;
|
||||
}
|
||||
|
|
@ -310,9 +310,9 @@ public:
|
|||
return true;
|
||||
}
|
||||
// Then check for approximate equality.
|
||||
float tolerance = CMP_EPSILON * abs(a);
|
||||
if (tolerance < CMP_EPSILON) {
|
||||
tolerance = CMP_EPSILON;
|
||||
float tolerance = (float)CMP_EPSILON * abs(a);
|
||||
if (tolerance < (float)CMP_EPSILON) {
|
||||
tolerance = (float)CMP_EPSILON;
|
||||
}
|
||||
return abs(a - b) < tolerance;
|
||||
}
|
||||
|
|
@ -327,7 +327,7 @@ public:
|
|||
}
|
||||
|
||||
static _ALWAYS_INLINE_ bool is_zero_approx(float s) {
|
||||
return abs(s) < CMP_EPSILON;
|
||||
return abs(s) < (float)CMP_EPSILON;
|
||||
}
|
||||
|
||||
static _ALWAYS_INLINE_ bool is_equal_approx(double a, double b) {
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ Vector3 Plane::get_any_perpendicular_normal() const {
|
|||
static const Vector3 p2 = Vector3(0, 1, 0);
|
||||
Vector3 p;
|
||||
|
||||
if (ABS(normal.dot(p1)) > 0.99) { // if too similar to p1
|
||||
if (ABS(normal.dot(p1)) > 0.99f) { // if too similar to p1
|
||||
p = p2; // use p2
|
||||
} else {
|
||||
p = p1; // use p1
|
||||
|
|
@ -109,7 +109,7 @@ bool Plane::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3
|
|||
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
|
||||
if (dist > (real_t)CMP_EPSILON) { //this is a ray, before the emitting pos (p_from) doesn't exist
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
@ -132,7 +132,7 @@ bool Plane::intersects_segment(const Vector3 &p_begin, const Vector3 &p_end, Vec
|
|||
real_t dist = (normal.dot(p_begin) - d) / den;
|
||||
//printf("dist is %i\n",dist);
|
||||
|
||||
if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) {
|
||||
if (dist < (real_t)-CMP_EPSILON || dist > (1 + (real_t)CMP_EPSILON)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -43,9 +43,9 @@ real_t Quat::angle_to(const Quat &p_to) const {
|
|||
// and similar for other axes.
|
||||
// This implementation uses XYZ convention (Z is the first rotation).
|
||||
void Quat::set_euler_xyz(const Vector3 &p_euler) {
|
||||
real_t half_a1 = p_euler.x * 0.5;
|
||||
real_t half_a2 = p_euler.y * 0.5;
|
||||
real_t half_a3 = p_euler.z * 0.5;
|
||||
real_t half_a1 = p_euler.x * 0.5f;
|
||||
real_t half_a2 = p_euler.y * 0.5f;
|
||||
real_t half_a3 = p_euler.z * 0.5f;
|
||||
|
||||
// R = X(a1).Y(a2).Z(a3) convention for Euler angles.
|
||||
// Conversion to quaternion as listed in https://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19770024290.pdf (page A-2)
|
||||
|
|
@ -78,9 +78,9 @@ Vector3 Quat::get_euler_xyz() const {
|
|||
// and similar for other axes.
|
||||
// This implementation uses YXZ convention (Z is the first rotation).
|
||||
void Quat::set_euler_yxz(const Vector3 &p_euler) {
|
||||
real_t half_a1 = p_euler.y * 0.5;
|
||||
real_t half_a2 = p_euler.x * 0.5;
|
||||
real_t half_a3 = p_euler.z * 0.5;
|
||||
real_t half_a1 = p_euler.y * 0.5f;
|
||||
real_t half_a2 = p_euler.x * 0.5f;
|
||||
real_t half_a3 = p_euler.z * 0.5f;
|
||||
|
||||
// R = Y(a1).X(a2).Z(a3) convention for Euler angles.
|
||||
// Conversion to quaternion as listed in https://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19770024290.pdf (page A-6)
|
||||
|
|
@ -163,7 +163,7 @@ Quat Quat::slerp(const Quat &p_to, const real_t &p_weight) const {
|
|||
cosom = dot(p_to);
|
||||
|
||||
// adjust signs (if necessary)
|
||||
if (cosom < 0.0) {
|
||||
if (cosom < 0) {
|
||||
cosom = -cosom;
|
||||
to1.x = -p_to.x;
|
||||
to1.y = -p_to.y;
|
||||
|
|
@ -178,16 +178,16 @@ Quat Quat::slerp(const Quat &p_to, const real_t &p_weight) const {
|
|||
|
||||
// calculate coefficients
|
||||
|
||||
if ((1.0 - cosom) > CMP_EPSILON) {
|
||||
if ((1 - cosom) > (real_t)CMP_EPSILON) {
|
||||
// standard case (slerp)
|
||||
omega = Math::acos(cosom);
|
||||
sinom = Math::sin(omega);
|
||||
scale0 = Math::sin((1.0 - p_weight) * omega) / sinom;
|
||||
scale0 = Math::sin((1 - p_weight) * omega) / sinom;
|
||||
scale1 = Math::sin(p_weight * omega) / sinom;
|
||||
} else {
|
||||
// "from" and "to" quaternions are very close
|
||||
// ... so we can do a linear interpolation
|
||||
scale0 = 1.0 - p_weight;
|
||||
scale0 = 1 - p_weight;
|
||||
scale1 = p_weight;
|
||||
}
|
||||
// calculate final values
|
||||
|
|
@ -207,14 +207,14 @@ Quat Quat::slerpni(const Quat &p_to, const real_t &p_weight) const {
|
|||
|
||||
real_t dot = from.dot(p_to);
|
||||
|
||||
if (Math::absf(dot) > 0.9999) {
|
||||
if (Math::absf(dot) > 0.9999f) {
|
||||
return from;
|
||||
}
|
||||
|
||||
real_t theta = Math::acos(dot),
|
||||
sinT = 1.0 / Math::sin(theta),
|
||||
sinT = 1 / Math::sin(theta),
|
||||
newFactor = Math::sin(p_weight * theta) * sinT,
|
||||
invFactor = Math::sin((1.0 - p_weight) * theta) * sinT;
|
||||
invFactor = Math::sin((1 - p_weight) * theta) * sinT;
|
||||
|
||||
return Quat(invFactor * from.x + newFactor * p_to.x,
|
||||
invFactor * from.y + newFactor * p_to.y,
|
||||
|
|
@ -228,7 +228,7 @@ Quat Quat::cubic_slerp(const Quat &p_b, const Quat &p_pre_a, const Quat &p_post_
|
|||
ERR_FAIL_COND_V_MSG(!p_b.is_normalized(), Quat(), "The end quaternion must be normalized.");
|
||||
#endif
|
||||
//the only way to do slerp :|
|
||||
real_t t2 = (1.0 - p_weight) * p_weight * 2;
|
||||
real_t t2 = (1 - p_weight) * p_weight * 2;
|
||||
Quat sp = this->slerp(p_b, p_weight);
|
||||
Quat sq = p_pre_a.slerpni(p_post_b, p_weight);
|
||||
return sp.slerpni(sq, t2);
|
||||
|
|
@ -246,8 +246,8 @@ void Quat::set_axis_angle(const Vector3 &axis, const real_t &angle) {
|
|||
if (d == 0) {
|
||||
set(0, 0, 0, 0);
|
||||
} else {
|
||||
real_t sin_angle = Math::sin(angle * 0.5);
|
||||
real_t cos_angle = Math::cos(angle * 0.5);
|
||||
real_t sin_angle = Math::sin(angle * 0.5f);
|
||||
real_t cos_angle = Math::cos(angle * 0.5f);
|
||||
real_t s = sin_angle / d;
|
||||
set(axis.x * s, axis.y * s, axis.z * s,
|
||||
cos_angle);
|
||||
|
|
|
|||
|
|
@ -140,19 +140,19 @@ public:
|
|||
Vector3 c = v0.cross(v1);
|
||||
real_t d = v0.dot(v1);
|
||||
|
||||
if (d < -1.0 + CMP_EPSILON) {
|
||||
if (d < -1 + (real_t)CMP_EPSILON) {
|
||||
x = 0;
|
||||
y = 1;
|
||||
z = 0;
|
||||
w = 0;
|
||||
} else {
|
||||
real_t s = Math::sqrt((1.0 + d) * 2.0);
|
||||
real_t rs = 1.0 / s;
|
||||
real_t s = Math::sqrt((1 + d) * 2);
|
||||
real_t rs = 1 / s;
|
||||
|
||||
x = c.x * rs;
|
||||
y = c.y * rs;
|
||||
z = c.z * rs;
|
||||
w = s * 0.5;
|
||||
w = s * 0.5f;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -194,7 +194,7 @@ void Quat::operator*=(const real_t &s) {
|
|||
}
|
||||
|
||||
void Quat::operator/=(const real_t &s) {
|
||||
*this *= 1.0 / s;
|
||||
*this *= 1 / s;
|
||||
}
|
||||
|
||||
Quat Quat::operator+(const Quat &q2) const {
|
||||
|
|
@ -217,7 +217,7 @@ Quat Quat::operator*(const real_t &s) const {
|
|||
}
|
||||
|
||||
Quat Quat::operator/(const real_t &s) const {
|
||||
return *this * (1.0 / s);
|
||||
return *this * (1 / s);
|
||||
}
|
||||
|
||||
bool Quat::operator==(const Quat &p_quat) const {
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ struct _NO_DISCARD_CLASS_ Rect2 {
|
|||
|
||||
real_t get_area() const { return size.width * size.height; }
|
||||
|
||||
_FORCE_INLINE_ Vector2 get_center() const { return position + (size * 0.5); }
|
||||
_FORCE_INLINE_ Vector2 get_center() const { return position + (size * 0.5f); }
|
||||
|
||||
inline bool intersects(const Rect2 &p_rect, const bool p_include_borders = false) const {
|
||||
if (p_include_borders) {
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ void Transform2D::affine_invert() {
|
|||
#ifdef MATH_CHECKS
|
||||
ERR_FAIL_COND(det == 0);
|
||||
#endif
|
||||
real_t idet = 1.0 / det;
|
||||
real_t idet = 1 / det;
|
||||
|
||||
SWAP(elements[0][0], elements[1][1]);
|
||||
elements[0] *= Vector2(idet, -idet);
|
||||
|
|
@ -238,11 +238,11 @@ Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t
|
|||
|
||||
real_t dot = v1.dot(v2);
|
||||
|
||||
dot = CLAMP(dot, -1.0, 1.0);
|
||||
dot = CLAMP(dot, -1, 1);
|
||||
|
||||
Vector2 v;
|
||||
|
||||
if (dot > 0.9995) {
|
||||
if (dot > 0.9995f) {
|
||||
v = Vector2::linear_interpolate(v1, v2, p_c).normalized(); //linearly interpolate to avoid numerical precision issues
|
||||
} else {
|
||||
real_t angle = p_c * Math::acos(dot);
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ Quat TransformInterpolator::_basis_to_quat_unchecked(const Basis &p_basis) {
|
|||
real_t trace = m.elements[0][0] + m.elements[1][1] + m.elements[2][2];
|
||||
real_t temp[4];
|
||||
|
||||
if (trace > 0.0) {
|
||||
if (trace > 0) {
|
||||
real_t s = Math::sqrt(trace + 1.0f);
|
||||
temp[3] = (s * 0.5f);
|
||||
s = 0.5f / s;
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ int TriangleMesh::_create_bvh(BVH *p_bvh, BVH **p_bb, int p_from, int p_size, in
|
|||
int index = max_alloc++;
|
||||
BVH *_new = &p_bvh[index];
|
||||
_new->aabb = aabb;
|
||||
_new->center = aabb.position + aabb.size * 0.5;
|
||||
_new->center = aabb.position + aabb.size * 0.5f;
|
||||
_new->face_index = -1;
|
||||
_new->left = left;
|
||||
_new->right = right;
|
||||
|
|
@ -152,7 +152,7 @@ void TriangleMesh::create(const PoolVector<Vector3> &p_faces) {
|
|||
bw[i].left = -1;
|
||||
bw[i].right = -1;
|
||||
bw[i].face_index = i;
|
||||
bw[i].center = bw[i].aabb.position + bw[i].aabb.size * 0.5;
|
||||
bw[i].center = bw[i].aabb.position + bw[i].aabb.size * 0.5f;
|
||||
}
|
||||
|
||||
vertices.resize(db.size());
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ real_t Triangulate::get_area(const Vector<Vector2> &contour) {
|
|||
for (int p = n - 1, q = 0; q < n; p = q++) {
|
||||
A += c[p].cross(c[q]);
|
||||
}
|
||||
return A * 0.5;
|
||||
return A * 0.5f;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -72,9 +72,9 @@ bool Triangulate::is_inside_triangle(real_t Ax, real_t Ay,
|
|||
bCROSScp = bx * cpy - by * cpx;
|
||||
|
||||
if (include_edges) {
|
||||
return ((aCROSSbp > 0.0) && (bCROSScp > 0.0) && (cCROSSap > 0.0));
|
||||
return ((aCROSSbp > 0) && (bCROSScp > 0) && (cCROSSap > 0));
|
||||
} else {
|
||||
return ((aCROSSbp >= 0.0) && (bCROSScp >= 0.0) && (cCROSSap >= 0.0));
|
||||
return ((aCROSSbp >= 0) && (bCROSScp >= 0) && (cCROSSap >= 0));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -130,7 +130,7 @@ bool Triangulate::triangulate(const Vector<Vector2> &contour, Vector<int> &resul
|
|||
|
||||
/* we want a counter-clockwise polygon in V */
|
||||
|
||||
if (0.0 < get_area(contour)) {
|
||||
if (0 < get_area(contour)) {
|
||||
for (int v = 0; v < n; v++) {
|
||||
V.write[v] = v;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -161,11 +161,11 @@ Vector2 Vector2::cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, c
|
|||
real_t t3 = t2 * t;
|
||||
|
||||
Vector2 out;
|
||||
out = 0.5 *
|
||||
((p1 * 2.0) +
|
||||
out = 0.5f *
|
||||
((p1 * 2) +
|
||||
(-p0 + p2) * t +
|
||||
(2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 +
|
||||
(-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3);
|
||||
(2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 +
|
||||
(-p0 + 3 * p1 - 3 * p2 + p3) * t3);
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -173,7 +173,7 @@ Vector2 Vector2::move_toward(const Vector2 &p_to, const real_t p_delta) const {
|
|||
Vector2 v = *this;
|
||||
Vector2 vd = p_to - v;
|
||||
real_t len = vd.length();
|
||||
return len <= p_delta || len < CMP_EPSILON ? p_to : v + vd / len * p_delta;
|
||||
return len <= p_delta || len < (real_t)CMP_EPSILON ? p_to : v + vd / len * p_delta;
|
||||
}
|
||||
|
||||
// slide returns the component of the vector along the given plane, specified by its normal vector.
|
||||
|
|
@ -192,7 +192,7 @@ Vector2 Vector2::reflect(const Vector2 &p_normal) const {
|
|||
#ifdef MATH_CHECKS
|
||||
ERR_FAIL_COND_V_MSG(!p_normal.is_normalized(), Vector2(), "The normal Vector2 must be normalized.");
|
||||
#endif
|
||||
return 2.0 * p_normal * this->dot(p_normal) - *this;
|
||||
return 2 * p_normal * this->dot(p_normal) - *this;
|
||||
}
|
||||
|
||||
bool Vector2::is_equal_approx(const Vector2 &p_v) const {
|
||||
|
|
|
|||
|
|
@ -99,11 +99,11 @@ Vector3 Vector3::cubic_interpolaten(const Vector3 &p_b, const Vector3 &p_pre_a,
|
|||
real_t t3 = t2 * t;
|
||||
|
||||
Vector3 out;
|
||||
out = 0.5 *
|
||||
((p1 * 2.0) +
|
||||
out = 0.5f *
|
||||
((p1 * 2) +
|
||||
(-p0 + p2) * t +
|
||||
(2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 +
|
||||
(-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3);
|
||||
(2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 +
|
||||
(-p0 + 3 * p1 - 3 * p2 + p3) * t3);
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -118,11 +118,11 @@ Vector3 Vector3::cubic_interpolate(const Vector3 &p_b, const Vector3 &p_pre_a, c
|
|||
real_t t3 = t2 * t;
|
||||
|
||||
Vector3 out;
|
||||
out = 0.5 *
|
||||
((p1 * 2.0) +
|
||||
out = 0.5f *
|
||||
((p1 * 2) +
|
||||
(-p0 + p2) * t +
|
||||
(2.0 * p0 - 5.0 * p1 + 4 * p2 - p3) * t2 +
|
||||
(-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3);
|
||||
(2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 +
|
||||
(-p0 + 3 * p1 - 3 * p2 + p3) * t3);
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -130,7 +130,7 @@ Vector3 Vector3::move_toward(const Vector3 &p_to, const real_t p_delta) const {
|
|||
Vector3 v = *this;
|
||||
Vector3 vd = p_to - v;
|
||||
real_t len = vd.length();
|
||||
return len <= p_delta || len < CMP_EPSILON ? p_to : v + vd / len * p_delta;
|
||||
return len <= p_delta || len < (real_t)CMP_EPSILON ? p_to : v + vd / len * p_delta;
|
||||
}
|
||||
|
||||
Basis Vector3::outer(const Vector3 &p_b) const {
|
||||
|
|
|
|||
|
|
@ -427,7 +427,7 @@ bool Vector3::is_normalized() const {
|
|||
}
|
||||
|
||||
Vector3 Vector3::inverse() const {
|
||||
return Vector3(1.0 / x, 1.0 / y, 1.0 / z);
|
||||
return Vector3(1 / x, 1 / y, 1 / z);
|
||||
}
|
||||
|
||||
void Vector3::zero() {
|
||||
|
|
@ -450,7 +450,7 @@ Vector3 Vector3::reflect(const Vector3 &p_normal) const {
|
|||
#ifdef MATH_CHECKS
|
||||
ERR_FAIL_COND_V_MSG(!p_normal.is_normalized(), Vector3(), "The normal Vector3 must be normalized.");
|
||||
#endif
|
||||
return 2.0 * p_normal * this->dot(p_normal) - *this;
|
||||
return 2 * p_normal * this->dot(p_normal) - *this;
|
||||
}
|
||||
|
||||
bool Vector3::is_equal_approx(const Vector3 &p_v, real_t p_tolerance) const {
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ T *_nullptr() {
|
|||
#define ABSDIFF(x, y) (((x) < (y)) ? ((y) - (x)) : ((x) - (y)))
|
||||
|
||||
#ifndef SGN
|
||||
#define SGN(m_v) (((m_v) < 0) ? (-1.0) : (+1.0))
|
||||
#define SGN(m_v) (((m_v) < 0) ? (-1.0f) : (+1.0f))
|
||||
#endif
|
||||
|
||||
#ifndef MIN
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user