Add a lot of more constexpr; use constants for accessing vector indices in vector math classes (#2766)

1 files changed, 134 insertions, 134 deletions

diff --git a/indra/llmath/v3math.h b/indra/llmath/v3math.h
index 4fc7585a46..53491533c2 100644
--- a/indra/llmath/v3math.h
+++ b/indra/llmath/v3math.h
@@ -41,7 +41,7 @@ class LLQuaternion;
 
 //  LLvector3 = |x y z w|
 
-static const U32 LENGTHOFVECTOR3 = 3;
+static constexpr U32 LENGTHOFVECTOR3 = 3;
 
 class LLVector3
 {
@@ -169,11 +169,11 @@ LLVector3 lerp(const LLVector3 &a, const LLVector3 &b, F32 u); // Returns a vect
 LLVector3 point_to_box_offset(LLVector3& pos, const LLVector3* box); // Displacement from query point to nearest point on bounding box.
 bool box_valid_and_non_zero(const LLVector3* box);
 
-inline LLVector3::LLVector3(void)
+inline LLVector3::LLVector3()
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    mV[VX] = 0.f;
+    mV[VY] = 0.f;
+    mV[VZ] = 0.f;
 }
 
 inline LLVector3::LLVector3(const F32 x, const F32 y, const F32 z)
@@ -210,32 +210,32 @@ inline bool LLVector3::isFinite() const
 
 // Clear and Assignment Functions
 
-inline void LLVector3::clear(void)
+inline void LLVector3::clear()
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    mV[VX] = 0.f;
+    mV[VY] = 0.f;
+    mV[VZ] = 0.f;
 }
 
-inline void LLVector3::setZero(void)
+inline void LLVector3::setZero()
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    mV[VX] = 0.f;
+    mV[VY] = 0.f;
+    mV[VZ] = 0.f;
 }
 
-inline void LLVector3::clearVec(void)
+inline void LLVector3::clearVec()
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    mV[VX] = 0.f;
+    mV[VY] = 0.f;
+    mV[VZ] = 0.f;
 }
 
-inline void LLVector3::zeroVec(void)
+inline void LLVector3::zeroVec()
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    mV[VX] = 0.f;
+    mV[VY] = 0.f;
+    mV[VZ] = 0.f;
 }
 
 inline void LLVector3::set(F32 x, F32 y, F32 z)
@@ -245,18 +245,18 @@ inline void LLVector3::set(F32 x, F32 y, F32 z)
     mV[VZ] = z;
 }
 
-inline void LLVector3::set(const LLVector3 &vec)
+inline void LLVector3::set(const LLVector3& vec)
 {
-    mV[0] = vec.mV[0];
-    mV[1] = vec.mV[1];
-    mV[2] = vec.mV[2];
+    mV[VX] = vec.mV[VX];
+    mV[VY] = vec.mV[VY];
+    mV[VZ] = vec.mV[VZ];
 }
 
-inline void LLVector3::set(const F32 *vec)
+inline void LLVector3::set(const F32* vec)
 {
-    mV[0] = vec[0];
-    mV[1] = vec[1];
-    mV[2] = vec[2];
+    mV[VX] = vec[0];
+    mV[VY] = vec[1];
+    mV[VZ] = vec[2];
 }
 
 // deprecated
@@ -268,61 +268,61 @@ inline void LLVector3::setVec(F32 x, F32 y, F32 z)
 }
 
 // deprecated
-inline void LLVector3::setVec(const LLVector3 &vec)
+inline void LLVector3::setVec(const LLVector3& vec)
 {
-    mV[0] = vec.mV[0];
-    mV[1] = vec.mV[1];
-    mV[2] = vec.mV[2];
+    mV[VX] = vec.mV[VX];
+    mV[VY] = vec.mV[VY];
+    mV[VZ] = vec.mV[VZ];
 }
 
 // deprecated
-inline void LLVector3::setVec(const F32 *vec)
+inline void LLVector3::setVec(const F32* vec)
 {
-    mV[0] = vec[0];
-    mV[1] = vec[1];
-    mV[2] = vec[2];
+    mV[VX] = vec[0];
+    mV[VY] = vec[1];
+    mV[VZ] = vec[2];
 }
 
-inline F32 LLVector3::normalize(void)
+inline F32 LLVector3::normalize()
 {
-    F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+    F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
     F32 oomag;
 
     if (mag > FP_MAG_THRESHOLD)
     {
         oomag = 1.f/mag;
-        mV[0] *= oomag;
-        mV[1] *= oomag;
-        mV[2] *= oomag;
+        mV[VX] *= oomag;
+        mV[VY] *= oomag;
+        mV[VZ] *= oomag;
     }
     else
     {
-        mV[0] = 0.f;
-        mV[1] = 0.f;
-        mV[2] = 0.f;
+        mV[VX] = 0.f;
+        mV[VY] = 0.f;
+        mV[VZ] = 0.f;
         mag = 0;
     }
     return (mag);
 }
 
 // deprecated
-inline F32 LLVector3::normVec(void)
+inline F32 LLVector3::normVec()
 {
-    F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+    F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
     F32 oomag;
 
     if (mag > FP_MAG_THRESHOLD)
     {
         oomag = 1.f/mag;
-        mV[0] *= oomag;
-        mV[1] *= oomag;
-        mV[2] *= oomag;
+        mV[VX] *= oomag;
+        mV[VY] *= oomag;
+        mV[VZ] *= oomag;
     }
     else
     {
-        mV[0] = 0.f;
-        mV[1] = 0.f;
-        mV[2] = 0.f;
+        mV[VX] = 0.f;
+        mV[VY] = 0.f;
+        mV[VZ] = 0.f;
         mag = 0;
     }
     return (mag);
@@ -330,178 +330,178 @@ inline F32 LLVector3::normVec(void)
 
 // LLVector3 Magnitude and Normalization Functions
 
-inline F32  LLVector3::length(void) const
+inline F32  LLVector3::length() const
 {
-    return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 }
 
-inline F32  LLVector3::lengthSquared(void) const
+inline F32  LLVector3::lengthSquared() const
 {
-    return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
+    return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
 }
 
-inline F32  LLVector3::magVec(void) const
+inline F32  LLVector3::magVec() const
 {
-    return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 }
 
-inline F32  LLVector3::magVecSquared(void) const
+inline F32  LLVector3::magVecSquared() const
 {
-    return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
+    return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
 }
 
 inline bool LLVector3::inRange( F32 min, F32 max ) const
 {
-    return mV[0] >= min && mV[0] <= max &&
-           mV[1] >= min && mV[1] <= max &&
-           mV[2] >= min && mV[2] <= max;
+    return mV[VX] >= min && mV[VX] <= max &&
+           mV[VY] >= min && mV[VY] <= max &&
+           mV[VZ] >= min && mV[VZ] <= max;
 }
 
-inline LLVector3 operator+(const LLVector3 &a, const LLVector3 &b)
+inline LLVector3 operator+(const LLVector3& a, const LLVector3& b)
 {
     LLVector3 c(a);
     return c += b;
 }
 
-inline LLVector3 operator-(const LLVector3 &a, const LLVector3 &b)
+inline LLVector3 operator-(const LLVector3& a, const LLVector3& b)
 {
     LLVector3 c(a);
     return c -= b;
 }
 
-inline F32  operator*(const LLVector3 &a, const LLVector3 &b)
+inline F32  operator*(const LLVector3& a, const LLVector3& b)
 {
-    return (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2]);
+    return (a.mV[VX]*b.mV[VX] + a.mV[VY]*b.mV[VY] + a.mV[VZ]*b.mV[VZ]);
 }
 
-inline LLVector3 operator%(const LLVector3 &a, const LLVector3 &b)
+inline LLVector3 operator%(const LLVector3& a, const LLVector3& b)
 {
-    return LLVector3( a.mV[1]*b.mV[2] - b.mV[1]*a.mV[2], a.mV[2]*b.mV[0] - b.mV[2]*a.mV[0], a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1] );
+    return LLVector3( a.mV[VY]*b.mV[VZ] - b.mV[VY]*a.mV[VZ], a.mV[VZ]*b.mV[VX] - b.mV[VZ]*a.mV[VX], a.mV[VX]*b.mV[VY] - b.mV[VX]*a.mV[VY] );
 }
 
-inline LLVector3 operator/(const LLVector3 &a, F32 k)
+inline LLVector3 operator/(const LLVector3& a, F32 k)
 {
     F32 t = 1.f / k;
-    return LLVector3( a.mV[0] * t, a.mV[1] * t, a.mV[2] * t );
+    return LLVector3( a.mV[VX] * t, a.mV[VY] * t, a.mV[VZ] * t );
 }
 
-inline LLVector3 operator*(const LLVector3 &a, F32 k)
+inline LLVector3 operator*(const LLVector3& a, F32 k)
 {
-    return LLVector3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
+    return LLVector3( a.mV[VX] * k, a.mV[VY] * k, a.mV[VZ] * k );
 }
 
-inline LLVector3 operator*(F32 k, const LLVector3 &a)
+inline LLVector3 operator*(F32 k, const LLVector3& a)
 {
-    return LLVector3( a.mV[0] * k, a.mV[1] * k, a.mV[2] * k );
+    return LLVector3( a.mV[VX] * k, a.mV[VY] * k, a.mV[VZ] * k );
 }
 
-inline bool operator==(const LLVector3 &a, const LLVector3 &b)
+inline bool operator==(const LLVector3& a, const LLVector3& b)
 {
-    return (  (a.mV[0] == b.mV[0])
-            &&(a.mV[1] == b.mV[1])
-            &&(a.mV[2] == b.mV[2]));
+    return (  (a.mV[VX] == b.mV[VX])
+            &&(a.mV[VY] == b.mV[VY])
+            &&(a.mV[VZ] == b.mV[VZ]));
 }
 
-inline bool operator!=(const LLVector3 &a, const LLVector3 &b)
+inline bool operator!=(const LLVector3& a, const LLVector3& b)
 {
-    return (  (a.mV[0] != b.mV[0])
-            ||(a.mV[1] != b.mV[1])
-            ||(a.mV[2] != b.mV[2]));
+    return (  (a.mV[VX] != b.mV[VX])
+            ||(a.mV[VY] != b.mV[VY])
+            ||(a.mV[VZ] != b.mV[VZ]));
 }
 
-inline bool operator<(const LLVector3 &a, const LLVector3 &b)
+inline bool operator<(const LLVector3& a, const LLVector3& b)
 {
-    return (a.mV[0] < b.mV[0]
-            || (a.mV[0] == b.mV[0]
-                && (a.mV[1] < b.mV[1]
-                    || ((a.mV[1] == b.mV[1])
-                        && a.mV[2] < b.mV[2]))));
+    return (a.mV[VX] < b.mV[VX]
+            || (a.mV[VX] == b.mV[VX]
+                && (a.mV[VY] < b.mV[VY]
+                    || ((a.mV[VY] == b.mV[VY])
+                        && a.mV[VZ] < b.mV[VZ]))));
 }
 
-inline const LLVector3& operator+=(LLVector3 &a, const LLVector3 &b)
+inline const LLVector3& operator+=(LLVector3& a, const LLVector3& b)
 {
-    a.mV[0] += b.mV[0];
-    a.mV[1] += b.mV[1];
-    a.mV[2] += b.mV[2];
+    a.mV[VX] += b.mV[VX];
+    a.mV[VY] += b.mV[VY];
+    a.mV[VZ] += b.mV[VZ];
     return a;
 }
 
-inline const LLVector3& operator-=(LLVector3 &a, const LLVector3 &b)
+inline const LLVector3& operator-=(LLVector3& a, const LLVector3& b)
 {
-    a.mV[0] -= b.mV[0];
-    a.mV[1] -= b.mV[1];
-    a.mV[2] -= b.mV[2];
+    a.mV[VX] -= b.mV[VX];
+    a.mV[VY] -= b.mV[VY];
+    a.mV[VZ] -= b.mV[VZ];
     return a;
 }
 
-inline const LLVector3& operator%=(LLVector3 &a, const LLVector3 &b)
+inline const LLVector3& operator%=(LLVector3& a, const LLVector3& b)
 {
-    LLVector3 ret( a.mV[1]*b.mV[2] - b.mV[1]*a.mV[2], a.mV[2]*b.mV[0] - b.mV[2]*a.mV[0], a.mV[0]*b.mV[1] - b.mV[0]*a.mV[1]);
+    LLVector3 ret( a.mV[VY]*b.mV[VZ] - b.mV[VY]*a.mV[VZ], a.mV[VZ]*b.mV[VX] - b.mV[VZ]*a.mV[VX], a.mV[VX]*b.mV[VY] - b.mV[VX]*a.mV[VY]);
     a = ret;
     return a;
 }
 
-inline const LLVector3& operator*=(LLVector3 &a, F32 k)
+inline const LLVector3& operator*=(LLVector3& a, F32 k)
 {
-    a.mV[0] *= k;
-    a.mV[1] *= k;
-    a.mV[2] *= k;
+    a.mV[VX] *= k;
+    a.mV[VY] *= k;
+    a.mV[VZ] *= k;
     return a;
 }
 
-inline const LLVector3& operator*=(LLVector3 &a, const LLVector3 &b)
+inline const LLVector3& operator*=(LLVector3& a, const LLVector3& b)
 {
-    a.mV[0] *= b.mV[0];
-    a.mV[1] *= b.mV[1];
-    a.mV[2] *= b.mV[2];
+    a.mV[VX] *= b.mV[VX];
+    a.mV[VY] *= b.mV[VY];
+    a.mV[VZ] *= b.mV[VZ];
     return a;
 }
 
-inline const LLVector3& operator/=(LLVector3 &a, F32 k)
+inline const LLVector3& operator/=(LLVector3& a, F32 k)
 {
-    a.mV[0] /= k;
-    a.mV[1] /= k;
-    a.mV[2] /= k;
+    a.mV[VX] /= k;
+    a.mV[VY] /= k;
+    a.mV[VZ] /= k;
     return a;
 }
 
 inline const LLVector3& operator/=(LLVector3& a, const LLVector3& b)
 {
-    a.mV[0] /= b.mV[0];
-    a.mV[1] /= b.mV[1];
-    a.mV[2] /= b.mV[2];
+    a.mV[VX] /= b.mV[VX];
+    a.mV[VY] /= b.mV[VY];
+    a.mV[VZ] /= b.mV[VZ];
     return a;
 }
 
-inline LLVector3 operator-(const LLVector3 &a)
+inline LLVector3 operator-(const LLVector3& a)
 {
-    return LLVector3( -a.mV[0], -a.mV[1], -a.mV[2] );
+    return LLVector3( -a.mV[VX], -a.mV[VY], -a.mV[VZ] );
 }
 
-inline F32  dist_vec(const LLVector3 &a, const LLVector3 &b)
+inline F32  dist_vec(const LLVector3& a, const LLVector3& b)
 {
-    F32 x = a.mV[0] - b.mV[0];
-    F32 y = a.mV[1] - b.mV[1];
-    F32 z = a.mV[2] - b.mV[2];
-    return (F32) sqrt( x*x + y*y + z*z );
+    F32 x = a.mV[VX] - b.mV[VX];
+    F32 y = a.mV[VY] - b.mV[VY];
+    F32 z = a.mV[VZ] - b.mV[VZ];
+    return sqrt( x*x + y*y + z*z );
 }
 
-inline F32  dist_vec_squared(const LLVector3 &a, const LLVector3 &b)
+inline F32  dist_vec_squared(const LLVector3& a, const LLVector3& b)
 {
-    F32 x = a.mV[0] - b.mV[0];
-    F32 y = a.mV[1] - b.mV[1];
-    F32 z = a.mV[2] - b.mV[2];
+    F32 x = a.mV[VX] - b.mV[VX];
+    F32 y = a.mV[VY] - b.mV[VY];
+    F32 z = a.mV[VZ] - b.mV[VZ];
     return x*x + y*y + z*z;
 }
 
-inline F32  dist_vec_squared2D(const LLVector3 &a, const LLVector3 &b)
+inline F32  dist_vec_squared2D(const LLVector3& a, const LLVector3& b)
 {
-    F32 x = a.mV[0] - b.mV[0];
-    F32 y = a.mV[1] - b.mV[1];
+    F32 x = a.mV[VX] - b.mV[VX];
+    F32 y = a.mV[VY] - b.mV[VY];
     return x*x + y*y;
 }
 
-inline LLVector3 projected_vec(const LLVector3 &a, const LLVector3 &b)
+inline LLVector3 projected_vec(const LLVector3& a, const LLVector3& b)
 {
     F32 bb = b * b;
     if (bb > FP_MAG_THRESHOLD * FP_MAG_THRESHOLD)
@@ -526,18 +526,18 @@ inline LLVector3 inverse_projected_vec(const LLVector3& a, const LLVector3& b)
     return normalized_a * (b_length / dot_product);
 }
 
-inline LLVector3 parallel_component(const LLVector3 &a, const LLVector3 &b)
+inline LLVector3 parallel_component(const LLVector3& a, const LLVector3& b)
 {
     return projected_vec(a, b);
 }
 
-inline LLVector3 orthogonal_component(const LLVector3 &a, const LLVector3 &b)
+inline LLVector3 orthogonal_component(const LLVector3& a, const LLVector3& b)
 {
     return a - projected_vec(a, b);
 }
 
 
-inline LLVector3 lerp(const LLVector3 &a, const LLVector3 &b, F32 u)
+inline LLVector3 lerp(const LLVector3& a, const LLVector3& b, F32 u)
 {
     return LLVector3(
         a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
@@ -596,7 +596,7 @@ inline F32 angle_between(const LLVector3& a, const LLVector3& b)
     return atan2f(sqrtf(c * c), ab); // return the angle
 }
 
-inline bool are_parallel(const LLVector3 &a, const LLVector3 &b, F32 epsilon)
+inline bool are_parallel(const LLVector3& a, const LLVector3& b, F32 epsilon)
 {
     LLVector3 an = a;
     LLVector3 bn = b;