mirrors/monado
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/monado/monado.git synced 2025-01-22 14:41:47 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

d/ns: const correctness cleanup for math.

Browse source
This commit is contained in:
Ryan Pavlik 2020-10-21 17:04:25 -05:00
parent d4011ed78a
commit 4c0d71aa30
1 changed files with 62 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

146
src/xrt/drivers/north_star/distortion/utility_northstar.h
View file

@ -85,7 +85,7 @@ public:
}; };
inline Vector3 inline Vector3
operator-(Vector3 &rhs) operator-(Vector3 &rhs) const
{ {
Vector3 ret; Vector3 ret;
ret.x = (x - rhs.x); ret.x = (x - rhs.x);
@ -95,13 +95,13 @@ public:
} }
inline Vector3 inline Vector3
operator-() operator-() const
{ {
return Vector3(-x, -y, -z); return Vector3(-x, -y, -z);
} }
inline Vector3 inline Vector3
operator+(const Vector3 &rhs) operator+(const Vector3 &rhs) const
{ {
Vector3 ret; Vector3 ret;
ret.x = (x + rhs.x); ret.x = (x + rhs.x);
@ -129,7 +129,7 @@ public:
return ret; return ret;
} }
inline Vector3 operator*(const float &d) inline Vector3 operator*(const float &d) const
{ {
Vector3 ret; Vector3 ret;
ret.x = (x * d); ret.x = (x * d);
@ -139,16 +139,12 @@ public:
} }
inline Vector3 inline Vector3
Inverse() Inverse() const
{ {
Vector3 ret; return {-x, -y, -z};
ret.x = -x;
ret.y = -y;
ret.z = -z;
return ret;
} }
inline float static Dot(Vector3 lhs, Vector3 rhs) inline float static Dot(Vector3 const &lhs, Vector3 const &rhs)
{ {
float result = float result =
(lhs.x * rhs.x) + (lhs.y * rhs.y) + (lhs.z * rhs.z); (lhs.x * rhs.x) + (lhs.y * rhs.y) + (lhs.z * rhs.z);
@ -156,7 +152,7 @@ public:
} }
inline float inline float
Dot(Vector3 rhs) Dot(Vector3 const &rhs) const
{ {
float result = (x * rhs.x) + (y * rhs.y) + (z * rhs.z); float result = (x * rhs.x) + (y * rhs.y) + (z * rhs.z);
return result; return result;
@ -177,13 +173,13 @@ public:
} }
inline float inline float
sqrMagnitude() sqrMagnitude() const
{ {
return x * x + y * y + z * z; return x * x + y * y + z * z;
} }
inline float inline float
Magnitude() Magnitude() const
{ {
return sqrt(x * x + y * y + z * z); return sqrt(x * x + y * y + z * z);
} }
@ -191,21 +187,13 @@ public:
inline static Vector3 inline static Vector3
Zero() Zero()
{ {
Vector3 ret; return {0.f, 0.f, 0.f};
ret.x = 0.f;
ret.y = 0.f;
ret.z = 0.f;
return ret;
} }
inline static Vector3 inline static Vector3
One() One()
{ {
Vector3 ret; return {1.f, 1.f, 1.f};
ret.x = 1.f;
ret.y = 1.f;
ret.z = 1.f;
return ret;
} }
inline static Vector3 inline static Vector3
@ -231,7 +219,7 @@ public:
} }
inline Vector3 inline Vector3
Normalized() Normalized() const
{ {
Vector3 ret; Vector3 ret;
float mag = Magnitude(); float mag = Magnitude();
@ -265,7 +253,7 @@ public:
} }
inline Vector3 inline Vector3
Cross(const Vector3 in) Cross(const Vector3 in) const
{ {
Vector3 ret; Vector3 ret;
ret.x = y * in.z - z * in.y; ret.x = y * in.z - z * in.y;
@ -328,7 +316,7 @@ public:
} }
inline Vector2 inline Vector2
operator/(const float &d) operator/(float d) const
{ {
Vector2 ret; Vector2 ret;
ret.x = (x / d); ret.x = (x / d);
@ -336,7 +324,7 @@ public:
return ret; return ret;
} }
inline Vector2 operator*(const float &d) inline Vector2 operator*(float d) const
{ {
Vector2 ret; Vector2 ret;
ret.x = (x * d); ret.x = (x * d);
@ -344,7 +332,7 @@ public:
return ret; return ret;
} }
inline Vector2 inline Vector2
operator-(const Vector2 &rhs) operator-(const Vector2 &rhs) const
{ {
Vector2 ret; Vector2 ret;
ret.x = (x - rhs.x); ret.x = (x - rhs.x);
@ -353,7 +341,7 @@ public:
} }
inline Vector2 inline Vector2
operator+(const Vector2 &rhs) operator+(const Vector2 &rhs) const
{ {
Vector2 ret; Vector2 ret;
ret.x = (x + rhs.x); ret.x = (x + rhs.x);
@ -490,7 +478,7 @@ public:
// Returns a 3x3 rotation matrix (padded to a Matrix4x4). // Returns a 3x3 rotation matrix (padded to a Matrix4x4).
inline static Matrix4x4 inline static Matrix4x4
RotationAlign(Vector3 fromDir, Vector3 toDir) RotationAlign(Vector3 const &fromDir, Vector3 const &toDir)
{ {
const Vector3 v = fromDir.Cross(toDir); const Vector3 v = fromDir.Cross(toDir);
const float c = fromDir.Dot(toDir); const float c = fromDir.Dot(toDir);
@ -548,7 +536,7 @@ public:
} }
inline Vector3 inline Vector3
MultiplyPoint(Vector3 point) MultiplyPoint(Vector3 const &point) const
{ {
Vector3 res; Vector3 res;
float w; float w;
@ -589,7 +577,7 @@ public:
} }
inline Vector3 inline Vector3
MultiplyVector(Vector3 vector) MultiplyVector(Vector3 vector) const
{ {
Vector3 res; Vector3 res;
res.x = m00 * vector.x + m01 * vector.y + m02 * vector.z; res.x = m00 * vector.x + m01 * vector.y + m02 * vector.z;
@ -599,7 +587,7 @@ public:
} }
inline Vector3 inline Vector3
MultiplyPoint3x4(Vector3 point) MultiplyPoint3x4(Vector3 point) const
{ {
Vector3 res; Vector3 res;
res.x = m00 * point.x + m01 * point.y + m02 * point.z + m03; res.x = m00 * point.x + m01 * point.y + m02 * point.z + m03;
@ -609,7 +597,7 @@ public:
} }
inline Matrix4x4 inline Matrix4x4
Transpose() Transpose() const
{ {
Matrix4x4 r; Matrix4x4 r;
r.m00 = m00; r.m00 = m00;
@ -632,7 +620,7 @@ public:
} }
inline Matrix4x4 inline Matrix4x4
Inverse() Inverse() const
{ {
float A2323 = m22 * m33 - m23 * m32; float A2323 = m22 * m33 - m23 * m32;
float A1323 = m21 * m33 - m23 * m31; float A1323 = m21 * m33 - m23 * m31;
@ -722,6 +710,10 @@ public:
constexpr Vector4 & constexpr Vector4 &
operator=(const Vector4 &lhr) operator=(const Vector4 &lhr)
{ {
if (this == &lhr) {
// avoid self-assign
return *this;
}
this->x = lhr.x; this->x = lhr.x;
this->y = lhr.y; this->y = lhr.y;
this->z = lhr.z; this->z = lhr.z;
@ -730,7 +722,7 @@ public:
} }
inline Matrix4x4 inline Matrix4x4
ComposeProjection() ComposeProjection() const
{ {
const float zNear = 0.07f; const float zNear = 0.07f;
const float zFar = 1000.f; const float zFar = 1000.f;
@ -798,6 +790,18 @@ public:
Vector3 m_Direction; Vector3 m_Direction;
}; };
static inline float
SIGN(float x)
{
return (x >= 0.0f) ? +1.0f : -1.0f;
}
static inline float
NORM(float a, float b, float c, float d)
{
return sqrt(a * a + b * b + c * c + d * d);
}
class Quaternion class Quaternion
{ {
public: public:
@ -817,23 +821,10 @@ public:
w = _w; w = _w;
}; };
inline Quaternion(const Quaternion &_in) inline Quaternion(const Quaternion &_in) = default;
{
x = _in.x;
y = _in.y;
z = _in.z;
w = _in.w;
};
constexpr Quaternion & Quaternion &
operator=(const Quaternion &lhr) operator=(const Quaternion &lhr) = default;
{
this->x = lhr.x;
this->y = lhr.y;
this->z = lhr.z;
this->w = lhr.w;
return *this;
}
inline static Quaternion inline static Quaternion
Identity() Identity()
@ -842,43 +833,43 @@ public:
} }
inline Quaternion inline Quaternion
conjugate() conjugate() const
{ {
return Quaternion(-x, -y, -z, w); return Quaternion(-x, -y, -z, w);
} }
inline float inline float
norm() norm() const
{ {
return sqrt((x * x) + (y * y) + (z * z) + (w * w)); return sqrt((x * x) + (y * y) + (z * z) + (w * w));
} }
inline Quaternion inline Quaternion
scale(float s) scale(float s) const
{ {
return Quaternion(w * s, x * s, y * s, z * s); return Quaternion(w * s, x * s, y * s, z * s);
} }
inline Quaternion inline Quaternion
Inverse() Inverse() const
{ {
return conjugate() / norm(); return conjugate() / norm();
} }
inline Vector3 inline Vector3
Right() Right() const
{ {
return *this * Vector3::Right(); return *this * Vector3::Right();
} }
inline Vector3 inline Vector3
Up() Up() const
{ {
return *this * Vector3::Up(); return *this * Vector3::Up();
} }
inline Vector3 inline Vector3
Forward() Forward() const
{ {
return *this * Vector3::Forward(); return *this * Vector3::Forward();
} }
@ -936,7 +927,7 @@ public:
return euler; return euler;
} }
inline Vector3 operator*(Vector3 vec) inline Vector3 operator*(Vector3 const &vec) const
{ {
float num = x * 2.f; float num = x * 2.f;
float num2 = y * 2.f; float num2 = y * 2.f;
@ -982,7 +973,7 @@ public:
Matrix4x4 Matrix4x4
ToMatrix4x4() ToMatrix4x4() const
{ {
float qw = w; float qw = w;
float qx = x; float qx = x;
@ -1008,7 +999,7 @@ public:
0.0f, 0.0f, 0.0f, 1.0f); 0.0f, 0.0f, 0.0f, 1.0f);
} }
inline Quaternion operator*(const Quaternion &q) inline Quaternion operator*(const Quaternion &q) const
{ {
return Quaternion(y * q.z - z * q.y + x * q.w + w * q.x, return Quaternion(y * q.z - z * q.y + x * q.w + w * q.x,
z * q.x - x * q.z + y * q.w + w * q.y, z * q.x - x * q.z + y * q.w + w * q.y,
@ -1017,7 +1008,7 @@ public:
} }
Quaternion Quaternion
operator/(const float div) operator/(const float div) const
{ {
return Quaternion(x / div, y / div, z / div, w / div); return Quaternion(x / div, y / div, z / div, w / div);
} }
@ -1115,19 +1106,6 @@ public:
return quaternion; return quaternion;
} }
inline float
SIGN(float x)
{
return (x >= 0.0f) ? +1.0f : -1.0f;
}
inline float
NORM(float a, float b, float c, float d)
{
return sqrt(a * a + b * b + c * c + d * d);
}
inline static Quaternion inline static Quaternion
FromMatrix(const Matrix4x4 m) FromMatrix(const Matrix4x4 m)
{ {
@ -1250,17 +1228,17 @@ public:
Vector3 position; Vector3 position;
Quaternion rotation; Quaternion rotation;
Pose(Vector3 pos) explicit Pose(Vector3 const &pos)
{ {
position = pos; position = pos;
rotation = Quaternion::Identity(); rotation = Quaternion::Identity();
} }
Pose(Quaternion rot) explicit Pose(Quaternion const &rot)
{ {
position = Vector3::Zero(); position = Vector3::Zero();
rotation = rot; rotation = rot;
} }
Pose(Vector3 pos, Quaternion rot) Pose(Vector3 const &pos, Quaternion const &rot)
{ {
position = pos; position = pos;
rotation = rot; rotation = rot;
@ -1273,25 +1251,25 @@ public:
} }
inline Pose inline Pose
Inverse() Inverse() const
{ {
Quaternion invQ = rotation.Inverse(); Quaternion invQ = rotation.Inverse();
return Pose(invQ * -position, invQ); return Pose(invQ * -position, invQ);
} }
inline Matrix4x4 inline Matrix4x4
Matrix() Matrix() const
{ {
return Matrix4x4::Translate(position) * rotation.ToMatrix4x4(); return Matrix4x4::Translate(position) * rotation.ToMatrix4x4();
} }
inline Pose operator*(Pose rhs) inline Pose operator*(Pose const &rhs) const
{ {
return Pose(position + (rotation * rhs.position), return Pose(position + (rotation * rhs.position),
rotation * rhs.rotation); rotation * rhs.rotation);
} }
inline Pose operator*(Vector3 rhs) inline Pose operator*(Vector3 const &rhs) const
{ {
return Pose(position + rotation * rhs, rotation); return Pose(position + rotation * rhs, rotation);
} }