aboutsummaryrefslogtreecommitdiffstats
path: root/LibOVR/Src/Kernel
diff options
context:
space:
mode:
Diffstat (limited to 'LibOVR/Src/Kernel')
-rw-r--r--LibOVR/Src/Kernel/OVR_Math.h208
1 files changed, 104 insertions, 104 deletions
diff --git a/LibOVR/Src/Kernel/OVR_Math.h b/LibOVR/Src/Kernel/OVR_Math.h
index 108b9d3..ce21e62 100644
--- a/LibOVR/Src/Kernel/OVR_Math.h
+++ b/LibOVR/Src/Kernel/OVR_Math.h
@@ -46,7 +46,7 @@ enum Axis
enum RotateDirection
{
Rotate_CCW = 1,
- Rotate_CW = -1
+ Rotate_CW = -1
};
// Constants for right handed and left handed coordinate systems
@@ -71,7 +71,7 @@ struct WorldAxes
AxisDirection XAxis, YAxis, ZAxis;
WorldAxes(AxisDirection x, AxisDirection y, AxisDirection z)
- : XAxis(x), YAxis(y), ZAxis(z)
+ : XAxis(x), YAxis(y), ZAxis(z)
{ OVR_ASSERT(abs(x) != abs(y) && abs(y) != abs(z) && abs(z) != abs(x));}
};
@@ -83,7 +83,7 @@ struct WorldAxes
// per type, with Math<float> and Math<double> being distinct.
template<class Type>
class Math
-{
+{
};
// Single-precision Math constants class.
@@ -140,18 +140,18 @@ T DegreeToRad(T rads) { return rads * Math<T>::DegreeToRadFactor; }
// Numerically stable acos function
template<class T>
-T Acos(T val) {
+T Acos(T val) {
if (val > T(1)) return T(0);
else if (val < T(-1)) return Math<T>::Pi;
- else return acos(val);
+ else return acos(val);
};
// Numerically stable asin function
template<class T>
-T Asin(T val) {
+T Asin(T val) {
if (val > T(1)) return Math<T>::PiOver2;
else if (val < T(-1)) return Math<T>::PiOver2 * T(3);
- else return asin(val);
+ else return asin(val);
};
#ifdef OVR_CC_MSVC
@@ -179,7 +179,7 @@ public:
bool operator== (const Vector2& b) const { return x == b.x && y == b.y; }
bool operator!= (const Vector2& b) const { return x != b.x || y != b.y; }
-
+
Vector2 operator+ (const Vector2& b) const { return Vector2(x + b.x, y + b.y); }
Vector2& operator+= (const Vector2& b) { x += b.x; y += b.y; return *this; }
Vector2 operator- (const Vector2& b) const { return Vector2(x - b.x, y - b.y); }
@@ -201,7 +201,7 @@ public:
{
return (fabs(b.x-x) < tolerance) && (fabs(b.y-y) < tolerance);
}
-
+
// Entrywise product of two vectors
Vector2 EntrywiseMultiply(const Vector2& b) const { return Vector2(x * b.x, y * b.y);}
@@ -211,8 +211,8 @@ public:
T Dot(const Vector2& b) const { return x*b.x + y*b.y; }
// Returns the angle from this vector to b, in radians.
- T Angle(const Vector2& b) const
- {
+ T Angle(const Vector2& b) const
+ {
T div = LengthSq()*b.LengthSq();
OVR_ASSERT(div != T(0));
T result = Acos((this->Dot(b))/sqrt(div));
@@ -230,19 +230,19 @@ public:
// Determine if this a unit vector.
bool IsNormalized() const { return fabs(LengthSq() - T(1)) < Math<T>::Tolerance; }
- // Normalize, convention vector length to 1.
- void Normalize()
+ // Normalize, convention vector length to 1.
+ void Normalize()
{
T l = Length();
OVR_ASSERT(l != T(0));
- *this /= l;
+ *this /= l;
}
// Returns normalized (unit) version of the vector without modifying itself.
- Vector2 Normalized() const
- {
+ Vector2 Normalized() const
+ {
T l = Length();
OVR_ASSERT(l != T(0));
- return *this / l;
+ return *this / l;
}
// Linearly interpolates from this vector to another.
@@ -251,11 +251,11 @@ public:
// Projects this vector onto the argument; in other words,
// A.Project(B) returns projection of vector A onto B.
- Vector2 ProjectTo(const Vector2& b) const
- {
+ Vector2 ProjectTo(const Vector2& b) const
+ {
T l2 = b.LengthSq();
OVR_ASSERT(l2 != T(0));
- return b * ( Dot(b) / l2 );
+ return b * ( Dot(b) / l2 );
}
};
@@ -283,7 +283,7 @@ public:
bool operator== (const Vector3& b) const { return x == b.x && y == b.y && z == b.z; }
bool operator!= (const Vector3& b) const { return x != b.x || y != b.y || z != b.z; }
-
+
Vector3 operator+ (const Vector3& b) const { return Vector3(x + b.x, y + b.y, z + b.z); }
Vector3& operator+= (const Vector3& b) { x += b.x; y += b.y; z += b.z; return *this; }
Vector3 operator- (const Vector3& b) const { return Vector3(x - b.x, y - b.y, z - b.z); }
@@ -303,14 +303,14 @@ public:
// Compare two vectors for equality with tolerance. Returns true if vectors match withing tolerance.
bool Compare(const Vector3&b, T tolerance = Mathf::Tolerance)
{
- return (fabs(b.x-x) < tolerance) &&
- (fabs(b.y-y) < tolerance) &&
+ return (fabs(b.x-x) < tolerance) &&
+ (fabs(b.y-y) < tolerance) &&
(fabs(b.z-z) < tolerance);
}
-
+
// Entrywise product of two vectors
- Vector3 EntrywiseMultiply(const Vector3& b) const { return Vector3(x * b.x,
- y * b.y,
+ Vector3 EntrywiseMultiply(const Vector3& b) const { return Vector3(x * b.x,
+ y * b.y,
z * b.z);}
// Dot product
@@ -326,7 +326,7 @@ public:
x*b.y - y*b.x); }
// Returns the angle from this vector to b, in radians.
- T Angle(const Vector3& b) const
+ T Angle(const Vector3& b) const
{
T div = LengthSq()*b.LengthSq();
OVR_ASSERT(div != T(0));
@@ -341,24 +341,24 @@ public:
// Returns distance between two points represented by vectors.
T Distance(Vector3& b) const { return (*this - b).Length(); }
-
+
// Determine if this a unit vector.
bool IsNormalized() const { return fabs(LengthSq() - T(1)) < Math<T>::Tolerance; }
- // Normalize, convention vector length to 1.
- void Normalize()
+ // Normalize, convention vector length to 1.
+ void Normalize()
{
T l = Length();
OVR_ASSERT(l != T(0));
- *this /= l;
+ *this /= l;
}
// Returns normalized (unit) version of the vector without modifying itself.
- Vector3 Normalized() const
- {
+ Vector3 Normalized() const
+ {
T l = Length();
OVR_ASSERT(l != T(0));
- return *this / l;
+ return *this / l;
}
// Linearly interpolates from this vector to another.
@@ -367,11 +367,11 @@ public:
// Projects this vector onto the argument; in other words,
// A.Project(B) returns projection of vector A onto B.
- Vector3 ProjectTo(const Vector3& b) const
- {
+ Vector3 ProjectTo(const Vector3& b) const
+ {
T l2 = b.LengthSq();
OVR_ASSERT(l2 != T(0));
- return b * ( Dot(b) / l2 );
+ return b * ( Dot(b) / l2 );
}
// Projects this vector onto a plane defined by a normal vector
@@ -401,7 +401,7 @@ public:
bool operator== (const Size& b) const { return Width == b.Width && Height == b.Height; }
bool operator!= (const Size& b) const { return Width != b.Width || Height != b.Height; }
-
+
Size operator+ (const Size& b) const { return Size(Width + b.Width, Height + b.Height); }
Size& operator+= (const Size& b) { Width += b.Width; Height += b.Height; return *this; }
Size operator- (const Size& b) const { return Size(Width - b.Width, Height - b.Height); }
@@ -414,7 +414,7 @@ public:
// Scalar multiplication/division scales both components.
Size operator* (T s) const { return Size(Width*s, Height*s); }
- Size& operator*= (T s) { Width *= s; Height *= s; return *this; }
+ Size& operator*= (T s) { Width *= s; Height *= s; return *this; }
Size operator/ (T s) const { return Size(Width/s, Height/s); }
Size& operator/= (T s) { Width /= s; Height /= s; return *this; }
@@ -438,19 +438,19 @@ typedef Size<double> Sized;
// The matrix is stored in row-major order in memory, meaning that values
// of the first row are stored before the next one.
//
-// The arrangement of the matrix is chosen to be in Right-Handed
+// The arrangement of the matrix is chosen to be in Right-Handed
// coordinate system and counterclockwise rotations when looking down
// the axis
//
// Transformation Order:
// - Transformations are applied from right to left, so the expression
// M1 * M2 * M3 * V means that the vector V is transformed by M3 first,
-// followed by M2 and M1.
+// followed by M2 and M1.
//
// Coordinate system: Right Handed
//
// Rotations: Counterclockwise when looking down the axis. All angles are in radians.
-//
+//
// | sx 01 02 tx | // First column (sx, 10, 20): Axis X basis vector.
// | 10 sy 12 ty | // Second column (01, sy, 21): Axis Y basis vector.
// | 20 21 sz tz | // Third columnt (02, 12, sz): Axis Z basis vector.
@@ -463,7 +463,7 @@ class Matrix4f
static Matrix4f IdentityValue;
public:
- float M[4][4];
+ float M[4][4];
enum NoInitType { NoInit };
@@ -473,7 +473,7 @@ public:
// By default, we construct identity matrix.
Matrix4f()
{
- SetIdentity();
+ SetIdentity();
}
Matrix4f(float m11, float m12, float m13, float m14,
@@ -659,8 +659,8 @@ public:
Matrix4f Adjugated() const
{
- return Matrix4f(Cofactor(0,0), Cofactor(1,0), Cofactor(2,0), Cofactor(3,0),
- Cofactor(0,1), Cofactor(1,1), Cofactor(2,1), Cofactor(3,1),
+ return Matrix4f(Cofactor(0,0), Cofactor(1,0), Cofactor(2,0), Cofactor(3,0),
+ Cofactor(0,1), Cofactor(1,1), Cofactor(2,1), Cofactor(3,1),
Cofactor(0,2), Cofactor(1,2), Cofactor(2,2), Cofactor(3,2),
Cofactor(0,3), Cofactor(1,3), Cofactor(2,3), Cofactor(3,3));
}
@@ -711,7 +711,7 @@ public:
float psign = -1.0f;
if (((A1 + 1) % 3 == A2) && ((A2 + 1) % 3 == A3)) // Determine whether even permutation
psign = 1.0f;
-
+
float pm = psign*M[A1][A3];
if (pm < -1.0f + Math<float>::SingularityRadius)
{ // South pole singularity
@@ -743,9 +743,9 @@ public:
// rotations are CCW or CW (D) in LH or RH coordinate system (S)
template <Axis A1, Axis A2, RotateDirection D, HandedSystem S>
void ToEulerAnglesABA(float *a, float *b, float *c)
- {
+ {
OVR_COMPILER_ASSERT(A1 != A2);
-
+
// Determine the axis that was not supplied
int m = 3 - A1 - A2;
@@ -774,21 +774,21 @@ public:
}
return;
}
-
+
// Creates a matrix that converts the vertices from one coordinate system
// to another.
static Matrix4f AxisConversion(const WorldAxes& to, const WorldAxes& from)
- {
+ {
// Holds axis values from the 'to' structure
int toArray[3] = { to.XAxis, to.YAxis, to.ZAxis };
// The inverse of the toArray
- int inv[4];
+ int inv[4];
inv[0] = inv[abs(to.XAxis)] = 0;
inv[abs(to.YAxis)] = 1;
inv[abs(to.ZAxis)] = 2;
- Matrix4f m(0, 0, 0,
+ Matrix4f m(0, 0, 0,
0, 0, 0,
0, 0, 0);
@@ -797,7 +797,7 @@ public:
m.M[inv[abs(from.YAxis)]][1] = float(from.YAxis/toArray[inv[abs(from.YAxis)]]);
m.M[inv[abs(from.ZAxis)]][2] = float(from.ZAxis/toArray[inv[abs(from.ZAxis)]]);
return m;
- }
+ }
// Creates a matrix for translation by vector
@@ -850,7 +850,7 @@ public:
return t;
}
-
+
// Creates a rotation matrix rotating around the X axis by 'angle' radians.
// Just for quick testing. Not for final API. Need to remove case.
@@ -858,19 +858,19 @@ public:
{
float sina = s * d *sin(angle);
float cosa = cos(angle);
-
+
switch(A)
{
case Axis_X:
- return Matrix4f(1, 0, 0,
+ return Matrix4f(1, 0, 0,
0, cosa, -sina,
0, sina, cosa);
case Axis_Y:
- return Matrix4f(cosa, 0, sina,
+ return Matrix4f(cosa, 0, sina,
0, 1, 0,
-sina, 0, cosa);
case Axis_Z:
- return Matrix4f(cosa, -sina, 0,
+ return Matrix4f(cosa, -sina, 0,
sina, cosa, 0,
0, 0, 1);
}
@@ -888,7 +888,7 @@ public:
{
float sina = sin(angle);
float cosa = cos(angle);
- return Matrix4f(1, 0, 0,
+ return Matrix4f(1, 0, 0,
0, cosa, -sina,
0, sina, cosa);
}
@@ -904,7 +904,7 @@ public:
{
float sina = sin(angle);
float cosa = cos(angle);
- return Matrix4f(cosa, 0, sina,
+ return Matrix4f(cosa, 0, sina,
0, 1, 0,
-sina, 0, cosa);
}
@@ -920,7 +920,7 @@ public:
{
float sina = sin(angle);
float cosa = cos(angle);
- return Matrix4f(cosa, -sina, 0,
+ return Matrix4f(cosa, -sina, 0,
sina, cosa, 0,
0, 0, 1);
}
@@ -934,12 +934,12 @@ public:
// LookAtLH creates a View transformation matrix for left-handed coordinate system.
// The resulting matrix points camera from 'eye' towards 'at' direction, with 'up'
- // specifying the up vector.
+ // specifying the up vector.
static Matrix4f LookAtLH(const Vector3f& eye, const Vector3f& at, const Vector3f& up);
-
-
+
+
// PerspectiveRH creates a right-handed perspective projection matrix that can be
- // used with the Oculus sample renderer.
+ // used with the Oculus sample renderer.
// yfov - Specifies vertical field of view in radians.
// aspect - Screen aspect ration, which is usually width/height for square pixels.
// Note that xfov = yfov * aspect.
@@ -948,10 +948,10 @@ public:
// Even though RHS usually looks in the direction of negative Z, positive values
// are expected for znear and zfar.
static Matrix4f PerspectiveRH(float yfov, float aspect, float znear, float zfar);
-
-
+
+
// PerspectiveRH creates a left-handed perspective projection matrix that can be
- // used with the Oculus sample renderer.
+ // used with the Oculus sample renderer.
// yfov - Specifies vertical field of view in radians.
// aspect - Screen aspect ration, which is usually width/height for square pixels.
// Note that xfov = yfov * aspect.
@@ -968,7 +968,7 @@ public:
// **************************************** Quat **************************************//
//
// Quatf represents a quaternion class used for rotations.
-//
+//
// Quaternion multiplications are done in right-to-left order, to match the
// behavior of matrices.
@@ -978,7 +978,7 @@ class Quat
{
public:
// w + Xi + Yj + Zk
- T x, y, z, w;
+ T x, y, z, w;
Quat() : x(0), y(0), z(0), w(1) {}
Quat(T x_, T y_, T z_, T w_) : x(x_), y(y_), z(z_), w(w_) {}
@@ -1018,7 +1018,7 @@ public:
*axis = Vector3<T>(x, y, z).Normalized();
*angle = T(2) * Acos(w);
}
- else
+ else
{
*axis = Vector3<T>(1, 0, 0);
*angle= 0;
@@ -1048,8 +1048,8 @@ public:
T LengthSq() const { return (x * x + y * y + z * z + w * w); }
// Simple Eulidean distance in R^4 (not SLERP distance, but at least respects Haar measure)
- T Distance(const Quat& q) const
- {
+ T Distance(const Quat& q) const
+ {
T d1 = (*this - q).Length();
T d2 = (*this + q).Length(); // Antipodal point check
return (d1 < d2) ? d1 : d2;
@@ -1065,31 +1065,31 @@ public:
// Normalize
bool IsNormalized() const { return fabs(LengthSq() - T(1)) < Math<T>::Tolerance; }
- void Normalize()
+ void Normalize()
{
T l = Length();
OVR_ASSERT(l != T(0));
- *this /= l;
+ *this /= l;
}
- Quat Normalized() const
- {
+ Quat Normalized() const
+ {
T l = Length();
OVR_ASSERT(l != T(0));
- return *this / l;
+ return *this / l;
}
// Returns conjugate of the quaternion. Produces inverse rotation if quaternion is normalized.
Quat Conj() const { return Quat(-x, -y, -z, w); }
- // Quaternion multiplication. Combines quaternion rotations, performing the one on the
+ // Quaternion multiplication. Combines quaternion rotations, performing the one on the
// right hand side first.
Quat operator* (const Quat& b) const { return Quat(w * b.x + x * b.w + y * b.z - z * b.y,
w * b.y - x * b.z + y * b.w + z * b.x,
w * b.z + x * b.y - y * b.x + z * b.w,
w * b.w - x * b.x - y * b.y - z * b.z); }
- //
+ //
// this^p normalized; same as rotating by this p times.
Quat PowNormalized(T p) const
{
@@ -1098,15 +1098,15 @@ public:
GetAxisAngle(&v, &a);
return Quat(v, a * p);
}
-
+
// Rotate transforms vector in a manner that matches Matrix rotations (counter-clockwise,
- // assuming negative direction of the axis). Standard formula: q(t) * V * q(t)^-1.
+ // assuming negative direction of the axis). Standard formula: q(t) * V * q(t)^-1.
Vector3<T> Rotate(const Vector3<T>& v) const
{
return ((*this * Quat<T>(v.x, v.y, v.z, T(0))) * Inverted()).Imag();
}
-
+
// Inversed quaternion rotates in the opposite direction.
Quat Inverted() const
{
@@ -1118,7 +1118,7 @@ public:
{
*this = Quat(-x, -y, -z, w);
}
-
+
// Converting quaternion to matrix.
operator Matrix4f() const
{
@@ -1142,31 +1142,31 @@ public:
// In almost all cases, the first part is executed.
// However, if the trace is not positive, the other
// cases arise.
- if (trace > T(0))
+ if (trace > T(0))
{
T s = sqrt(trace + T(1)) * T(2); // s=4*qw
q.w = T(0.25) * s;
q.x = (m.M[2][1] - m.M[1][2]) / s;
q.y = (m.M[0][2] - m.M[2][0]) / s;
- q.z = (m.M[1][0] - m.M[0][1]) / s;
- }
- else if ((m.M[0][0] > m.M[1][1])&&(m.M[0][0] > m.M[2][2]))
+ q.z = (m.M[1][0] - m.M[0][1]) / s;
+ }
+ else if ((m.M[0][0] > m.M[1][1])&&(m.M[0][0] > m.M[2][2]))
{
T s = sqrt(T(1) + m.M[0][0] - m.M[1][1] - m.M[2][2]) * T(2);
q.w = (m.M[2][1] - m.M[1][2]) / s;
q.x = T(0.25) * s;
q.y = (m.M[0][1] + m.M[1][0]) / s;
q.z = (m.M[2][0] + m.M[0][2]) / s;
- }
- else if (m.M[1][1] > m.M[2][2])
+ }
+ else if (m.M[1][1] > m.M[2][2])
{
T s = sqrt(T(1) + m.M[1][1] - m.M[0][0] - m.M[2][2]) * T(2); // S=4*qy
q.w = (m.M[0][2] - m.M[2][0]) / s;
q.x = (m.M[0][1] + m.M[1][0]) / s;
q.y = T(0.25) * s;
q.z = (m.M[1][2] + m.M[2][1]) / s;
- }
- else
+ }
+ else
{
T s = sqrt(T(1) + m.M[2][2] - m.M[0][0] - m.M[1][1]) * T(2); // S=4*qz
q.w = (m.M[1][0] - m.M[0][1]) / s;
@@ -1178,7 +1178,7 @@ public:
}
-
+
// GetEulerAngles extracts Euler angles from the quaternion, in the specified order of
// axis rotations and the specified coordinate system. Right-handed coordinate system
// is the default, with CCW rotations while looking in the negative axis direction.
@@ -1188,7 +1188,7 @@ public:
// is followed by rotation c around axis A3
// rotations are CCW or CW (D) in LH or RH coordinate system (S)
template <Axis A1, Axis A2, Axis A3, RotateDirection D, HandedSystem S>
- void GetEulerAngles(T *a, T *b, T *c)
+ void GetEulerAngles(T *a, T *b, T *c) const
{
OVR_COMPILER_ASSERT((A1 != A2) && (A2 != A3) && (A1 != A3));
@@ -1203,7 +1203,7 @@ public:
// Determine whether even permutation
if (((A1 + 1) % 3 == A2) && ((A2 + 1) % 3 == A3))
psign = T(1);
-
+
T s2 = psign * T(2) * (psign*w*Q[A2] + Q[A1]*Q[A3]);
if (s2 < T(-1) + Math<T>::SingularityRadius)
@@ -1227,7 +1227,7 @@ public:
*b = S*D*asin(s2);
*c = S*D*atan2(T(2)*(w*Q[A3] - psign*Q[A1]*Q[A2]),
ww + Q11 - Q22 - Q33);
- }
+ }
return;
}
@@ -1319,7 +1319,7 @@ public:
};
Angle() : a(0) {}
-
+
// Fix the range to be between -Pi and Pi
Angle(T a_, AngularUnits u = Radians) : a((u == Radians) ? a_ : a_*Math<T>::DegreeToRadFactor) { FixRange(); }
@@ -1330,10 +1330,10 @@ public:
bool operator== (const Angle& b) const { return a == b.a; }
bool operator!= (const Angle& b) const { return a != b.a; }
-// bool operator< (const Angle& b) const { return a < a.b; }
-// bool operator> (const Angle& b) const { return a > a.b; }
-// bool operator<= (const Angle& b) const { return a <= a.b; }
-// bool operator>= (const Angle& b) const { return a >= a.b; }
+// bool operator< (const Angle& b) const { return a < a.b; }
+// bool operator> (const Angle& b) const { return a > a.b; }
+// bool operator<= (const Angle& b) const { return a <= a.b; }
+// bool operator>= (const Angle& b) const { return a >= a.b; }
// bool operator= (const T& x) { a = x; FixRange(); }
// These operations assume a is already between -Pi and Pi.
@@ -1345,7 +1345,7 @@ public:
Angle& operator-= (const T& x) { a = a - x; FixRange(); return *this; }
Angle operator- (const Angle& b) const { Angle res = *this; res -= b; return res; }
Angle operator- (const T& x) const { Angle res = *this; res -= x; return res; }
-
+
T Distance(const Angle& b) { T c = fabs(a - b.a); return (c <= Math<T>::Pi) ? c : Math<T>::TwoPi - c; }
private:
@@ -1353,7 +1353,7 @@ private:
// The stored angle, which should be maintained between -Pi and Pi
T a;
- // Fixes the angle range to [-Pi,Pi], but assumes no more than 2Pi away on either side
+ // Fixes the angle range to [-Pi,Pi], but assumes no more than 2Pi away on either side
inline void FastFixRange()
{
if (a < -Math<T>::Pi)
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-21 01:49:42 +0000