#1611 Regression in anti-flipping mechanism for mouselook camera

10 files changed, 252 insertions, 438 deletions

diff --git a/indra/llmath/llcoordframe.cpp b/indra/llmath/llcoordframe.cpp
index 4d6276b2cd..7e1f350ab5 100644
--- a/indra/llmath/llcoordframe.cpp
+++ b/indra/llmath/llcoordframe.cpp
@@ -329,28 +329,30 @@ void LLCoordFrame::rotate(const LLMatrix3 &rotation_matrix)
 }
 
 
+// Rotate 2 normalized orthogonal vectors in direction from `source` to `target`
+static void rotate2(LLVector3& source, LLVector3& target, F32 angle)
+{
+    double sx = source[VX], sy = source[VY], sz = source[VZ];
+    double tx = target[VX], ty = target[VY], tz = target[VZ];
+    double c = cos(angle), s = sin(angle);
+
+    source.set(sx * c + tx * s, sy * c + ty * s, sz * c + tz * s);
+    target.set(tx * c - sx * s, ty * c - sy * s, tz * c - sz * s);
+}
+
 void LLCoordFrame::roll(F32 angle)
 {
-    LLQuaternion q(angle, mXAxis);
-    LLMatrix3 rotation_matrix(q);
-    rotate(rotation_matrix);
-    CHECK_FINITE_OBJ();
+    rotate2(mYAxis, mZAxis, angle);
 }
 
 void LLCoordFrame::pitch(F32 angle)
 {
-    LLQuaternion q(angle, mYAxis);
-    LLMatrix3 rotation_matrix(q);
-    rotate(rotation_matrix);
-    CHECK_FINITE_OBJ();
+    rotate2(mZAxis, mXAxis, angle);
 }
 
 void LLCoordFrame::yaw(F32 angle)
 {
-    LLQuaternion q(angle, mZAxis);
-    LLMatrix3 rotation_matrix(q);
-    rotate(rotation_matrix);
-    CHECK_FINITE_OBJ();
+    rotate2(mXAxis, mYAxis, angle);
 }
 
 // get*() routines
diff --git a/indra/llmath/llquaternion.cpp b/indra/llmath/llquaternion.cpp
index ce0a88c26f..07e54daf87 100644
--- a/indra/llmath/llquaternion.cpp
+++ b/indra/llmath/llquaternion.cpp
@@ -58,7 +58,7 @@ LLQuaternion::LLQuaternion(const LLMatrix3 &mat)
 
 LLQuaternion::LLQuaternion(F32 angle, const LLVector4 &vec)
 {
-    F32 mag = sqrtf(vec.mV[VX] * vec.mV[VX] + vec.mV[VY] * vec.mV[VY] + vec.mV[VZ] * vec.mV[VZ]);
+    F32 mag = vec.length();
     if (mag > FP_MAG_THRESHOLD)
     {
         angle *= 0.5;
@@ -77,7 +77,7 @@ LLQuaternion::LLQuaternion(F32 angle, const LLVector4 &vec)
 
 LLQuaternion::LLQuaternion(F32 angle, const LLVector3 &vec)
 {
-    F32 mag = sqrtf(vec.mV[VX] * vec.mV[VX] + vec.mV[VY] * vec.mV[VY] + vec.mV[VZ] * vec.mV[VZ]);
+    F32 mag = vec.length();
     if (mag > FP_MAG_THRESHOLD)
     {
         angle *= 0.5;
diff --git a/indra/llmath/v2math.cpp b/indra/llmath/v2math.cpp
index ecbfe7378c..78d349f2f0 100644
--- a/indra/llmath/v2math.cpp
+++ b/indra/llmath/v2math.cpp
@@ -67,7 +67,14 @@ F32 angle_between(const LLVector2& a, const LLVector2& b)
     return angle;
 }
 
-BOOL are_parallel(const LLVector2 &a, const LLVector2 &b, float epsilon)
+F32 signed_angle_between(const LLVector2& a, const LLVector2& b)
+{
+    F32 angle = angle_between(a, b);
+    F32 rhombus_square = a[VX] * b[VY] - b[VX] * a[VY];
+    return rhombus_square < 0 ? -angle : angle;
+}
+
+BOOL are_parallel(const LLVector2 &a, const LLVector2 &b, F32 epsilon)
 {
     LLVector2 an = a;
     LLVector2 bn = b;
diff --git a/indra/llmath/v2math.h b/indra/llmath/v2math.h
index 5c756a7f84..978d14ece8 100644
--- a/indra/llmath/v2math.h
+++ b/indra/llmath/v2math.h
@@ -107,13 +107,14 @@ class LLVector2
 
         friend LLVector2 operator-(const LLVector2 &a);                 // Return vector -a
 
-        friend std::ostream&     operator<<(std::ostream& s, const LLVector2 &a);       // Stream a
+        friend std::ostream& operator<<(std::ostream& s, const LLVector2 &a);       // Stream a
 };
 
 
 // Non-member functions
 
 F32 angle_between(const LLVector2 &a, const LLVector2 &b);  // Returns angle (radians) between a and b
+F32 signed_angle_between(const LLVector2& a, const LLVector2& b); // Returns signed angle (radians) between a and b
 BOOL are_parallel(const LLVector2 &a, const LLVector2 &b, F32 epsilon=F_APPROXIMATELY_ZERO);    // Returns TRUE if a and b are very close to parallel
 F32 dist_vec(const LLVector2 &a, const LLVector2 &b);       // Returns distance between a and b
 F32 dist_vec_squared(const LLVector2 &a, const LLVector2 &b);// Returns distance squared between a and b
@@ -124,26 +125,22 @@ LLVector2 lerp(const LLVector2 &a, const LLVector2 &b, F32 u); // Returns a vect
 
 inline LLVector2::LLVector2(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    clear();
 }
 
 inline LLVector2::LLVector2(F32 x, F32 y)
 {
-    mV[VX] = x;
-    mV[VY] = y;
+    set(x, y);
 }
 
 inline LLVector2::LLVector2(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
+    set(vec);
 }
 
 inline LLVector2::LLVector2(const LLVector3 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
+    set(vec.mV);
 }
 
 inline LLVector2::LLVector2(const LLSD &sd)
@@ -155,28 +152,24 @@ inline LLVector2::LLVector2(const LLSD &sd)
 
 inline void LLVector2::clear(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    mV[VX] = mV[VY] = 0.f;
 }
 
 inline void LLVector2::setZero(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    clear();
 }
 
 // deprecated
 inline void LLVector2::clearVec(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    clear();
 }
 
 // deprecated
 inline void LLVector2::zeroVec(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    clear();
 }
 
 inline void LLVector2::set(F32 x, F32 y)
@@ -187,36 +180,31 @@ inline void LLVector2::set(F32 x, F32 y)
 
 inline void LLVector2::set(const LLVector2 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
+    set(vec.mV);
 }
 
 inline void LLVector2::set(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
+    set(vec[VX], vec[VY]);
 }
 
 
 // deprecated
 inline void LLVector2::setVec(F32 x, F32 y)
 {
-    mV[VX] = x;
-    mV[VY] = y;
+    set(x, y);
 }
 
 // deprecated
 inline void LLVector2::setVec(const LLVector2 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
+    set(vec);
 }
 
 // deprecated
 inline void LLVector2::setVec(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
+    set(vec);
 }
 
 
@@ -224,7 +212,7 @@ inline void LLVector2::setVec(const F32 *vec)
 
 inline F32 LLVector2::length(void) const
 {
-    return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
+    return (F32) sqrt(lengthSquared());
 }
 
 inline F32 LLVector2::lengthSquared(void) const
@@ -232,63 +220,44 @@ inline F32 LLVector2::lengthSquared(void) const
     return mV[0]*mV[0] + mV[1]*mV[1];
 }
 
-inline F32      LLVector2::normalize(void)
+inline F32 LLVector2::normalize(void)
 {
-    F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
-    F32 oomag;
+    F32 mag = length();
 
     if (mag > FP_MAG_THRESHOLD)
     {
-        oomag = 1.f/mag;
-        mV[0] *= oomag;
-        mV[1] *= oomag;
+        *this /= mag;
     }
     else
     {
-        mV[0] = 0.f;
-        mV[1] = 0.f;
+        clear();
         mag = 0;
     }
-    return (mag);
+    return mag;
 }
 
 // checker
 inline bool LLVector2::isFinite() const
 {
-    return (llfinite(mV[VX]) && llfinite(mV[VY]));
+    return llfinite(mV[VX]) && llfinite(mV[VY]);
 }
 
 // deprecated
-inline F32      LLVector2::magVec(void) const
+inline F32 LLVector2::magVec(void) const
 {
-    return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
+    return length();
 }
 
 // deprecated
-inline F32      LLVector2::magVecSquared(void) const
+inline F32 LLVector2::magVecSquared(void) const
 {
-    return mV[0]*mV[0] + mV[1]*mV[1];
+    return lengthSquared();
 }
 
 // deprecated
-inline F32      LLVector2::normVec(void)
+inline F32 LLVector2::normVec(void)
 {
-    F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
-    F32 oomag;
-
-    if (mag > FP_MAG_THRESHOLD)
-    {
-        oomag = 1.f/mag;
-        mV[0] *= oomag;
-        mV[1] *= oomag;
-    }
-    else
-    {
-        mV[0] = 0.f;
-        mV[1] = 0.f;
-        mag = 0;
-    }
-    return (mag);
+    return normalize();
 }
 
 inline const LLVector2& LLVector2::scaleVec(const LLVector2& vec)
@@ -301,11 +270,7 @@ inline const LLVector2& LLVector2::scaleVec(const LLVector2& vec)
 
 inline BOOL LLVector2::isNull()
 {
-    if ( F_APPROXIMATELY_ZERO > mV[VX]*mV[VX] + mV[VY]*mV[VY] )
-    {
-        return TRUE;
-    }
-    return FALSE;
+    return F_APPROXIMATELY_ZERO > mV[VX]*mV[VX] + mV[VY]*mV[VY];
 }
 
 
@@ -337,9 +302,9 @@ inline LLVector2 operator-(const LLVector2 &a, const LLVector2 &b)
     return c -= b;
 }
 
-inline F32  operator*(const LLVector2 &a, const LLVector2 &b)
+inline F32 operator*(const LLVector2 &a, const LLVector2 &b)
 {
-    return (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1]);
+    return a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1];
 }
 
 inline LLVector2 operator%(const LLVector2 &a, const LLVector2 &b)
@@ -405,10 +370,7 @@ inline const LLVector2& operator*=(LLVector2 &a, F32 k)
 
 inline const LLVector2& operator/=(LLVector2 &a, F32 k)
 {
-    F32 t = 1.f / k;
-    a.mV[0] *= t;
-    a.mV[1] *= t;
-    return a;
+    return a *= 1.f / k;
 }
 
 inline LLVector2 operator-(const LLVector2 &a)
diff --git a/indra/llmath/v3math.h b/indra/llmath/v3math.h
index 0f4a4a07ae..513e01d3e1 100644
--- a/indra/llmath/v3math.h
+++ b/indra/llmath/v3math.h
@@ -100,24 +100,24 @@ class LLVector3
         const LLVector3& setVec(const LLVector4 &vec);  // deprecated
         const LLVector3& setVec(const LLVector3d &vec); // deprecated
 
-        F32     length() const;         // Returns magnitude of LLVector3
-        F32     lengthSquared() const;  // Returns magnitude squared of LLVector3
-        F32     magVec() const;         // deprecated
-        F32     magVecSquared() const;  // deprecated
+        F32 length() const;         // Returns magnitude of LLVector3
+        F32 lengthSquared() const;  // Returns magnitude squared of LLVector3
+        F32 magVec() const;         // deprecated
+        F32 magVecSquared() const;  // deprecated
 
-        inline F32      normalize();    // Normalizes and returns the magnitude of LLVector3
-        inline F32      normVec();      // deprecated
+        inline F32 normalize();    // Normalizes and returns the magnitude of LLVector3
+        inline F32 normVec();      // deprecated
 
-        inline BOOL inRange( F32 min, F32 max ) const; // Returns true if all values of the vector are between min and max
+        inline BOOL inRange(F32 min, F32 max) const; // Returns true if all values of the vector are between min and max
 
-        const LLVector3&    rotVec(F32 angle, const LLVector3 &vec);    // Rotates about vec by angle radians
-        const LLVector3&    rotVec(F32 angle, F32 x, F32 y, F32 z);     // Rotates about x,y,z by angle radians
-        const LLVector3&    rotVec(const LLMatrix3 &mat);               // Rotates by LLMatrix4 mat
-        const LLVector3&    rotVec(const LLQuaternion &q);              // Rotates by LLQuaternion q
-        const LLVector3&    transVec(const LLMatrix4& mat);             // Transforms by LLMatrix4 mat (mat * v)
+        const LLVector3& rotVec(F32 angle, const LLVector3 &vec);    // Rotates about vec by angle radians
+        const LLVector3& rotVec(F32 angle, F32 x, F32 y, F32 z);     // Rotates about x,y,z by angle radians
+        const LLVector3& rotVec(const LLMatrix3 &mat);               // Rotates by LLMatrix4 mat
+        const LLVector3& rotVec(const LLQuaternion &q);              // Rotates by LLQuaternion q
+        const LLVector3& transVec(const LLMatrix4& mat);             // Transforms by LLMatrix4 mat (mat * v)
 
-        const LLVector3&    scaleVec(const LLVector3& vec);             // scales per component by vec
-        LLVector3           scaledVec(const LLVector3& vec) const;          // get a copy of this vector scaled by vec
+        const LLVector3& scaleVec(const LLVector3& vec);             // scales per component by vec
+        LLVector3 scaledVec(const LLVector3& vec) const;             // get a copy of this vector scaled by vec
 
         BOOL isNull() const;            // Returns TRUE if vector has a _very_small_ length
         BOOL isExactlyZero() const      { return !mV[VX] && !mV[VY] && !mV[VZ]; }
@@ -171,23 +171,17 @@ bool box_valid_and_non_zero(const LLVector3* box);
 
 inline LLVector3::LLVector3(void)
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    clear();
 }
 
 inline LLVector3::LLVector3(const F32 x, const F32 y, const F32 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
+    set(x, y, z);
 }
 
 inline LLVector3::LLVector3(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
+    set(vec);
 }
 
 /*
@@ -204,7 +198,7 @@ inline LLVector3::LLVector3(const LLVector3 &copy)
 // checker
 inline BOOL LLVector3::isFinite() const
 {
-    return (llfinite(mV[VX]) && llfinite(mV[VY]) && llfinite(mV[VZ]));
+    return llfinite(mV[VX]) && llfinite(mV[VY]) && llfinite(mV[VZ]);
 }
 
 
@@ -212,30 +206,22 @@ inline BOOL LLVector3::isFinite() const
 
 inline void LLVector3::clear(void)
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    set(0.f, 0.f, 0.f);
 }
 
 inline void LLVector3::setZero(void)
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    clear();
 }
 
 inline void LLVector3::clearVec(void)
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    clear();
 }
 
 inline void LLVector3::zeroVec(void)
 {
-    mV[0] = 0.f;
-    mV[1] = 0.f;
-    mV[2] = 0.f;
+    clear();
 }
 
 inline void LLVector3::set(F32 x, F32 y, F32 z)
@@ -247,107 +233,74 @@ inline void LLVector3::set(F32 x, F32 y, F32 z)
 
 inline void LLVector3::set(const LLVector3 &vec)
 {
-    mV[0] = vec.mV[0];
-    mV[1] = vec.mV[1];
-    mV[2] = vec.mV[2];
+    set(vec.mV[0], vec.mV[1], vec.mV[2]);
 }
 
 inline void LLVector3::set(const F32 *vec)
 {
-    mV[0] = vec[0];
-    mV[1] = vec[1];
-    mV[2] = vec[2];
+    set(vec[0], vec[1], vec[2]);
 }
 
 // deprecated
 inline void LLVector3::setVec(F32 x, F32 y, F32 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
+    set(x, y, z);
 }
 
 // deprecated
 inline void LLVector3::setVec(const LLVector3 &vec)
 {
-    mV[0] = vec.mV[0];
-    mV[1] = vec.mV[1];
-    mV[2] = vec.mV[2];
+    set(vec);
 }
 
 // deprecated
 inline void LLVector3::setVec(const F32 *vec)
 {
-    mV[0] = vec[0];
-    mV[1] = vec[1];
-    mV[2] = vec[2];
+    set(vec);
 }
 
 inline F32 LLVector3::normalize(void)
 {
     F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
-    F32 oomag;
 
     if (mag > FP_MAG_THRESHOLD)
     {
-        oomag = 1.f/mag;
-        mV[0] *= oomag;
-        mV[1] *= oomag;
-        mV[2] *= oomag;
+        *this /= mag;
     }
     else
     {
-        mV[0] = 0.f;
-        mV[1] = 0.f;
-        mV[2] = 0.f;
+        clear();
         mag = 0;
     }
-    return (mag);
+    return mag;
 }
 
 // deprecated
 inline F32 LLVector3::normVec(void)
 {
-    F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
-    F32 oomag;
-
-    if (mag > FP_MAG_THRESHOLD)
-    {
-        oomag = 1.f/mag;
-        mV[0] *= oomag;
-        mV[1] *= oomag;
-        mV[2] *= oomag;
-    }
-    else
-    {
-        mV[0] = 0.f;
-        mV[1] = 0.f;
-        mV[2] = 0.f;
-        mag = 0;
-    }
-    return (mag);
+    return normalize();
 }
 
 // LLVector3 Magnitude and Normalization Functions
 
-inline F32  LLVector3::length(void) const
+inline F32 LLVector3::length(void) const
 {
-    return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+    return (F32) sqrt(lengthSquared());
 }
 
-inline F32  LLVector3::lengthSquared(void) const
+inline F32 LLVector3::lengthSquared(void) const
 {
     return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
 }
 
-inline F32  LLVector3::magVec(void) const
+inline F32 LLVector3::magVec(void) const
 {
-    return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+    return length();
 }
 
-inline F32  LLVector3::magVecSquared(void) const
+inline F32 LLVector3::magVecSquared(void) const
 {
-    return mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2];
+    return lengthSquared();
 }
 
 inline BOOL LLVector3::inRange( F32 min, F32 max ) const
@@ -371,7 +324,7 @@ inline LLVector3 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[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2];
 }
 
 inline LLVector3 operator%(const LLVector3 &a, const LLVector3 &b)
@@ -459,10 +412,7 @@ inline const LLVector3& operator*=(LLVector3 &a, const LLVector3 &b)
 
 inline const LLVector3& operator/=(LLVector3 &a, F32 k)
 {
-    F32 t = 1.f / k;
-    a.mV[0] *= t;
-    a.mV[1] *= t;
-    a.mV[2] *= t;
+    a *= 1.f / k;
     return a;
 }
 
@@ -471,7 +421,7 @@ inline LLVector3 operator-(const LLVector3 &a)
     return LLVector3( -a.mV[0], -a.mV[1], -a.mV[2] );
 }
 
-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];
@@ -479,7 +429,7 @@ inline F32  dist_vec(const LLVector3 &a, const LLVector3 &b)
     return (F32) 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];
@@ -487,7 +437,7 @@ inline F32  dist_vec_squared(const LLVector3 &a, const LLVector3 &b)
     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];
@@ -501,10 +451,7 @@ inline LLVector3 projected_vec(const LLVector3 &a, const LLVector3 &b)
     {
         return ((a * b) / bb) * b;
     }
-    else
-    {
-        return b.zero;
-    }
+    return b.zero;
 }
 
 inline LLVector3 inverse_projected_vec(const LLVector3& a, const LLVector3& b)
@@ -541,11 +488,7 @@ inline LLVector3 lerp(const LLVector3 &a, const LLVector3 &b, F32 u)
 
 inline BOOL LLVector3::isNull() const
 {
-    if ( F_APPROXIMATELY_ZERO > mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ] )
-    {
-        return TRUE;
-    }
-    return FALSE;
+    return F_APPROXIMATELY_ZERO > mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
 }
 
 inline void update_min_max(LLVector3& min, LLVector3& max, const LLVector3& pos)
@@ -586,7 +529,7 @@ inline F32 angle_between(const LLVector3& a, const LLVector3& b)
         ab = 0.0f; // get rid of negative zero
     }
     LLVector3 c = a % b; // crossproduct
-    return atan2f(sqrtf(c * c), ab); // return the angle
+    return atan2f(c.length(), ab); // return the angle
 }
 
 inline BOOL are_parallel(const LLVector3 &a, const LLVector3 &b, F32 epsilon)
@@ -596,7 +539,7 @@ inline BOOL are_parallel(const LLVector3 &a, const LLVector3 &b, F32 epsilon)
     an.normalize();
     bn.normalize();
     F32 dot = an * bn;
-    if ( (1.0f - fabs(dot)) < epsilon)
+    if (1.0f - fabs(dot) < epsilon)
     {
         return TRUE;
     }
diff --git a/indra/llmath/v4math.h b/indra/llmath/v4math.h
index 7f0020af6b..b9460820a1 100644
--- a/indra/llmath/v4math.h
+++ b/indra/llmath/v4math.h
@@ -96,9 +96,9 @@ class LLVector4
         F32 lengthSquared() const;      // Returns magnitude squared of LLVector4
         F32 normalize();                // Normalizes and returns the magnitude of LLVector4
 
-        F32         magVec() const;             // deprecated
-        F32         magVecSquared() const;      // deprecated
-        F32         normVec();                  // deprecated
+        F32 magVec() const;             // deprecated
+        F32 magVecSquared() const;      // deprecated
+        F32 normVec();                  // deprecated
 
         // Sets all values to absolute value of their original values
         // Returns TRUE if data changed
@@ -107,10 +107,10 @@ class LLVector4
         BOOL isExactlyClear() const     { return (mV[VW] == 1.0f) && !mV[VX] && !mV[VY] && !mV[VZ]; }
         BOOL isExactlyZero() const      { return !mV[VW] && !mV[VX] && !mV[VY] && !mV[VZ]; }
 
-        const LLVector4&    rotVec(F32 angle, const LLVector4 &vec);    // Rotates about vec by angle radians
-        const LLVector4&    rotVec(F32 angle, F32 x, F32 y, F32 z);     // Rotates about x,y,z by angle radians
-        const LLVector4&    rotVec(const LLMatrix4 &mat);               // Rotates by MAT4 mat
-        const LLVector4&    rotVec(const LLQuaternion &q);              // Rotates by QUAT q
+        const LLVector4& rotVec(F32 angle, const LLVector4 &vec);    // Rotates about vec by angle radians
+        const LLVector4& rotVec(F32 angle, F32 x, F32 y, F32 z);     // Rotates about x,y,z by angle radians
+        const LLVector4& rotVec(const LLMatrix4 &mat);               // Rotates by MAT4 mat
+        const LLVector4& rotVec(const LLQuaternion &q);              // Rotates by QUAT q
 
         const LLVector4&    scaleVec(const LLVector4& vec); // Scales component-wise by vec
 
@@ -150,34 +150,22 @@ LLVector4 lerp(const LLVector4 &a, const LLVector4 &b, F32 u); // Returns a vect
 
 inline LLVector4::LLVector4(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
-    mV[VW] = 1.f;
+    clear();
 }
 
 inline LLVector4::LLVector4(F32 x, F32 y, F32 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
-    mV[VW] = 1.f;
+    set(x, y, z, 1.f);
 }
 
 inline LLVector4::LLVector4(F32 x, F32 y, F32 z, F32 w)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
-    mV[VW] = w;
+    set(x, y, z, w);
 }
 
 inline LLVector4::LLVector4(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    set(vec);
 }
 
 inline LLVector4::LLVector4(const F64 *vec)
@@ -206,18 +194,12 @@ inline LLVector4::LLVector4(const LLVector2 &vec, F32 z, F32 w)
 
 inline LLVector4::LLVector4(const LLVector3 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = 1.f;
+    set(vec, 1.f);
 }
 
 inline LLVector4::LLVector4(const LLVector3 &vec, F32 w)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = w;
+    set(vec, w);
 }
 
 inline LLVector4::LLVector4(const LLSD &sd)
@@ -228,43 +210,31 @@ inline LLVector4::LLVector4(const LLSD &sd)
 
 inline BOOL LLVector4::isFinite() const
 {
-    return (llfinite(mV[VX]) && llfinite(mV[VY]) && llfinite(mV[VZ]) && llfinite(mV[VW]));
+    return llfinite(mV[VX]) && llfinite(mV[VY]) && llfinite(mV[VZ]) && llfinite(mV[VW]);
 }
 
 // Clear and Assignment Functions
 
 inline void LLVector4::clear(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
-    mV[VW] = 1.f;
+    set(0.f, 0.f, 0.f, 1.f);
 }
 
 // deprecated
 inline void LLVector4::clearVec(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
-    mV[VW] = 1.f;
+    clear();
 }
 
 // deprecated
 inline void LLVector4::zeroVec(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
-    mV[VW] = 0.f;
+    set(0.f, 0.f, 0.f, 0.f);
 }
 
 inline void LLVector4::set(F32 x, F32 y, F32 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
-    mV[VW] = 1.f;
+    set(x, y, z, 1.f);
 }
 
 inline void LLVector4::set(F32 x, F32 y, F32 z, F32 w)
@@ -277,10 +247,7 @@ inline void LLVector4::set(F32 x, F32 y, F32 z, F32 w)
 
 inline void LLVector4::set(const LLVector4 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = vec.mV[VW];
+    set(vec.mV);
 }
 
 inline void LLVector4::set(const LLVector3 &vec, F32 w)
@@ -299,72 +266,56 @@ inline void LLVector4::set(const F32 *vec)
     mV[VW] = vec[VW];
 }
 
-
 // deprecated
 inline void LLVector4::setVec(F32 x, F32 y, F32 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
-    mV[VW] = 1.f;
+    set(x, y, z);
 }
 
 // deprecated
 inline void LLVector4::setVec(F32 x, F32 y, F32 z, F32 w)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
-    mV[VW] = w;
+    set(x, y, z, w);
 }
 
 // deprecated
 inline void LLVector4::setVec(const LLVector4 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = vec.mV[VW];
+    set(vec);
 }
 
 // deprecated
 inline void LLVector4::setVec(const LLVector3 &vec, F32 w)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = w;
+    set(vec, w);
 }
 
 // deprecated
 inline void LLVector4::setVec(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    set(vec);
 }
 
 // LLVector4 Magnitude and Normalization Functions
 
-inline F32      LLVector4::length(void) const
+inline F32 LLVector4::length(void) const
 {
-    return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return (F32) sqrt(lengthSquared());
 }
 
-inline F32      LLVector4::lengthSquared(void) const
+inline F32 LLVector4::lengthSquared(void) const
 {
     return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
 }
 
-inline F32      LLVector4::magVec(void) const
+inline F32 LLVector4::magVec(void) const
 {
-    return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return length();
 }
 
-inline F32      LLVector4::magVecSquared(void) const
+inline F32 LLVector4::magVecSquared(void) const
 {
-    return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
+    return lengthSquared();
 }
 
 // LLVector4 Operators
@@ -383,7 +334,7 @@ inline LLVector4 operator-(const LLVector4 &a, const LLVector4 &b)
 
 inline F32  operator*(const LLVector4 &a, const LLVector4 &b)
 {
-    return (a.mV[VX]*b.mV[VX] + a.mV[VY]*b.mV[VY] + a.mV[VZ]*b.mV[VZ]);
+    return a.mV[VX]*b.mV[VX] + a.mV[VY]*b.mV[VY] + a.mV[VZ]*b.mV[VZ];
 }
 
 inline LLVector4 operator%(const LLVector4 &a, const LLVector4 &b)
@@ -456,11 +407,7 @@ inline const LLVector4& operator*=(LLVector4 &a, F32 k)
 
 inline const LLVector4& operator/=(LLVector4 &a, F32 k)
 {
-    F32 t = 1.f / k;
-    a.mV[VX] *= t;
-    a.mV[VY] *= t;
-    a.mV[VZ] *= t;
-    return a;
+    return a *= 1.f / k;
 }
 
 inline LLVector4 operator-(const LLVector4 &a)
@@ -468,16 +415,16 @@ inline LLVector4 operator-(const LLVector4 &a)
     return LLVector4( -a.mV[VX], -a.mV[VY], -a.mV[VZ] );
 }
 
-inline F32  dist_vec(const LLVector4 &a, const LLVector4 &b)
+inline F32 dist_vec(const LLVector4 &a, const LLVector4 &b)
 {
     LLVector4 vec = a - b;
-    return (vec.length());
+    return vec.length();
 }
 
-inline F32  dist_vec_squared(const LLVector4 &a, const LLVector4 &b)
+inline F32 dist_vec_squared(const LLVector4 &a, const LLVector4 &b)
 {
     LLVector4 vec = a - b;
-    return (vec.lengthSquared());
+    return vec.lengthSquared();
 }
 
 inline LLVector4 lerp(const LLVector4 &a, const LLVector4 &b, F32 u)
@@ -489,17 +436,13 @@ inline LLVector4 lerp(const LLVector4 &a, const LLVector4 &b, F32 u)
         a.mV[VW] + (b.mV[VW] - a.mV[VW]) * u);
 }
 
-inline F32      LLVector4::normalize(void)
+inline F32 LLVector4::normalize(void)
 {
     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[VX] *= oomag;
-        mV[VY] *= oomag;
-        mV[VZ] *= oomag;
+        *this /= mag;
     }
     else
     {
@@ -508,34 +451,18 @@ inline F32      LLVector4::normalize(void)
         mV[2] = 0.f;
         mag = 0;
     }
-    return (mag);
+    return mag;
 }
 
 // deprecated
-inline F32      LLVector4::normVec(void)
+inline F32 LLVector4::normVec(void)
 {
-    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[VX] *= oomag;
-        mV[VY] *= oomag;
-        mV[VZ] *= oomag;
-    }
-    else
-    {
-        mV[0] = 0.f;
-        mV[1] = 0.f;
-        mV[2] = 0.f;
-        mag = 0;
-    }
-    return (mag);
+    return normalize();
 }
 
 // Because apparently some parts of the viewer use this for color info.
-inline const LLVector4 srgbVector4(const LLVector4 &a) {
+inline const LLVector4 srgbVector4(const LLVector4 &a)
+{
     LLVector4 srgbColor;
 
     srgbColor.mV[0] = linearTosRGB(a.mV[0]);
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 25a3690162..8e15a08373 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -222,7 +222,6 @@ private:
     LLVector3d mPosGlobal;
 };
 
-
 class LLTeleportRequestViaLocationLookAt : public LLTeleportRequestViaLocation
 {
 public:
@@ -844,7 +843,6 @@ void LLAgent::movePitch(F32 mag)
     }
 }
 
-
 // Does this parcel allow you to fly?
 BOOL LLAgent::canFly()
 {
@@ -926,7 +924,6 @@ void LLAgent::setFlying(BOOL fly, BOOL fail_sound)
     mbFlagsDirty = TRUE;
 }
 
-
 // UI based mechanism of setting fly state
 //-----------------------------------------------------------------------------
 // toggleFlying()
@@ -1005,7 +1002,6 @@ void LLAgent::capabilityReceivedCallback(const LLUUID &region_id, LLViewerRegion
     }
 }
 
-
 //-----------------------------------------------------------------------------
 // setRegion()
 //-----------------------------------------------------------------------------
@@ -1112,7 +1108,6 @@ void LLAgent::setRegion(LLViewerRegion *regionp)
     mRegionChangedSignal();
 }
 
-
 //-----------------------------------------------------------------------------
 // getRegion()
 //-----------------------------------------------------------------------------
@@ -1121,7 +1116,6 @@ LLViewerRegion *LLAgent::getRegion() const
     return mRegionp;
 }
 
-
 LLHost LLAgent::getRegionHost() const
 {
     if (mRegionp)
@@ -1152,7 +1146,6 @@ BOOL LLAgent::inPrelude()
     return mRegionp && mRegionp->isPrelude();
 }
 
-
 std::string LLAgent::getRegionCapability(const std::string &name)
 {
     if (!mRegionp)
@@ -1161,7 +1154,6 @@ std::string LLAgent::getRegionCapability(const std::string &name)
     return mRegionp->getCapability(name);
 }
 
-
 //-----------------------------------------------------------------------------
 // canManageEstate()
 //-----------------------------------------------------------------------------
@@ -1189,7 +1181,6 @@ void LLAgent::sendMessage()
     gMessageSystem->sendMessage(mRegionp->getHost());
 }
 
-
 //-----------------------------------------------------------------------------
 // sendReliableMessage()
 //-----------------------------------------------------------------------------
@@ -1223,7 +1214,6 @@ LLVector3 LLAgent::getVelocity() const
     }
 }
 
-
 //-----------------------------------------------------------------------------
 // setPositionAgent()
 //-----------------------------------------------------------------------------
@@ -1292,12 +1282,11 @@ const LLVector3 &LLAgent::getPositionAgent()
             mFrameAgent.setOrigin(gAgentAvatarp->getPositionAgent());
         }
         else
-    {
-        mFrameAgent.setOrigin(gAgentAvatarp->getRenderPosition());
-    }
+        {
+            mFrameAgent.setOrigin(gAgentAvatarp->getRenderPosition());
+        }
     }
 
-
     return mFrameAgent.getOrigin();
 }
 
@@ -1306,7 +1295,6 @@ boost::signals2::connection LLAgent::whenPositionChanged(position_signal_t::slot
     return mOnPositionChanged.connect(fn);
 }
 
-
 //-----------------------------------------------------------------------------
 // getRegionsVisited()
 //-----------------------------------------------------------------------------
@@ -1323,7 +1311,6 @@ F64 LLAgent::getDistanceTraveled() const
     return mDistanceTraveled;
 }
 
-
 //-----------------------------------------------------------------------------
 // getPosAgentFromGlobal()
 //-----------------------------------------------------------------------------
@@ -1334,7 +1321,6 @@ LLVector3 LLAgent::getPosAgentFromGlobal(const LLVector3d &pos_global) const
     return pos_agent;
 }
 
-
 //-----------------------------------------------------------------------------
 // getPosGlobalFromAgent()
 //-----------------------------------------------------------------------------
@@ -1350,7 +1336,6 @@ void LLAgent::sitDown()
     setControlFlags(AGENT_CONTROL_SIT_ON_GROUND);
 }
 
-
 //-----------------------------------------------------------------------------
 // resetAxes()
 //-----------------------------------------------------------------------------
@@ -1359,7 +1344,6 @@ void LLAgent::resetAxes()
     mFrameAgent.resetAxes();
 }
 
-
 // Copied from LLCamera::setOriginAndLookAt
 // Look_at must be unit vector
 //-----------------------------------------------------------------------------
@@ -1388,7 +1372,6 @@ void LLAgent::resetAxes(const LLVector3 &look_at)
     mFrameAgent.setAxes(look_at, left, up);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1397,7 +1380,6 @@ void LLAgent::rotate(F32 angle, const LLVector3 &axis)
     mFrameAgent.rotate(angle, axis);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1406,7 +1388,6 @@ void LLAgent::rotate(F32 angle, F32 x, F32 y, F32 z)
     mFrameAgent.rotate(angle, x, y, z);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1415,7 +1396,6 @@ void LLAgent::rotate(const LLMatrix3 &matrix)
     mFrameAgent.rotate(matrix);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1424,7 +1404,6 @@ void LLAgent::rotate(const LLQuaternion &quaternion)
     mFrameAgent.rotate(quaternion);
 }
 
-
 //-----------------------------------------------------------------------------
 // getReferenceUpVector()
 //-----------------------------------------------------------------------------
@@ -1526,7 +1505,6 @@ void LLAgent::roll(F32 angle)
     mFrameAgent.roll(angle);
 }
 
-
 //-----------------------------------------------------------------------------
 // yaw()
 //-----------------------------------------------------------------------------
@@ -1538,7 +1516,6 @@ void LLAgent::yaw(F32 angle)
     }
 }
 
-
 // Returns a quat that represents the rotation of the agent in the absolute frame
 //-----------------------------------------------------------------------------
 // getQuat()
@@ -1565,7 +1542,6 @@ void LLAgent::setControlFlags(U32 mask)
     mbFlagsDirty = TRUE;
 }
 
-
 //-----------------------------------------------------------------------------
 // clearControlFlags()
 //-----------------------------------------------------------------------------
@@ -1679,7 +1655,6 @@ bool LLAgent::isDoNotDisturb() const
     return mIsDoNotDisturb;
 }
 
-
 //-----------------------------------------------------------------------------
 // startAutoPilotGlobal()
 //-----------------------------------------------------------------------------
@@ -1785,7 +1760,6 @@ void LLAgent::startAutoPilotGlobal(
     mAutoPilotNoProgressFrameCount = 0;
 }
 
-
 //-----------------------------------------------------------------------------
 // setAutoPilotTargetGlobal
 //-----------------------------------------------------------------------------
@@ -1839,7 +1813,6 @@ void LLAgent::startFollowPilot(const LLUUID &leader_id, BOOL allow_flying, F32 s
                          allow_flying);
 }
 
-
 //-----------------------------------------------------------------------------
 // stopAutoPilot()
 //-----------------------------------------------------------------------------
@@ -1881,7 +1854,6 @@ void LLAgent::stopAutoPilot(BOOL user_cancel)
     }
 }
 
-
 // Returns necessary agent pitch and yaw changes, radians.
 //-----------------------------------------------------------------------------
 // autoPilot()
@@ -2070,7 +2042,6 @@ void LLAgent::autoPilot(F32 *delta_yaw)
     }
 }
 
-
 //-----------------------------------------------------------------------------
 // propagate()
 //-----------------------------------------------------------------------------
@@ -2091,11 +2062,20 @@ void LLAgent::propagate(const F32 dt)
     }
 
     // handle rotation based on keyboard levels
-    const F32 YAW_RATE = 90.f * DEG_TO_RAD;             // radians per second
-    yaw(YAW_RATE * gAgentCamera.getYawKey() * dt);
+    if (fabs(dt) > 1e-6)
+    {
+        if (fabs(gAgentCamera.getYawKey()) > 1e-6)
+        {
+            static const F32 YAW_RATE = 90.f * DEG_TO_RAD;   // radians per second
+            yaw(YAW_RATE * gAgentCamera.getYawKey() * dt);
+        }
 
-    const F32 PITCH_RATE = 90.f * DEG_TO_RAD;           // radians per second
-    pitch(PITCH_RATE * gAgentCamera.getPitchKey() * dt);
+        if (fabs(gAgentCamera.getPitchKey()) > 1e-6)
+        {
+            static const F32 PITCH_RATE = 90.f * DEG_TO_RAD; // radians per second
+            pitch(PITCH_RATE * gAgentCamera.getPitchKey() * dt);
+        }
+    }
 
     // handle auto-land behavior
     if (isAgentAvatarValid())
@@ -2256,7 +2236,6 @@ void LLAgent::clearRenderState(U8 clearstate)
     mRenderState &= ~clearstate;
 }
 
-
 //-----------------------------------------------------------------------------
 // getRenderState()
 //-----------------------------------------------------------------------------
@@ -2298,6 +2277,7 @@ void LLAgent::endAnimationUpdateUI()
     {
         return;
     }
+
     if (gAgentCamera.getCameraMode() == gAgentCamera.getLastCameraMode())
     {
         // We're already done endAnimationUpdateUI for this transition.
@@ -2363,9 +2343,8 @@ void LLAgent::endAnimationUpdateUI()
             mViewsPushed = FALSE;
         }
 
-
         gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
-        if( gMorphView )
+        if (gMorphView)
         {
             gMorphView->setVisible( FALSE );
         }
@@ -2373,7 +2352,7 @@ void LLAgent::endAnimationUpdateUI()
         // Disable mouselook-specific animations
         if (isAgentAvatarValid())
         {
-            if( gAgentAvatarp->isAnyAnimationSignaled(AGENT_GUN_AIM_ANIMS, NUM_AGENT_GUN_AIM_ANIMS) )
+            if (gAgentAvatarp->isAnyAnimationSignaled(AGENT_GUN_AIM_ANIMS, NUM_AGENT_GUN_AIM_ANIMS))
             {
                 if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_RIFLE_R) != gAgentAvatarp->mSignaledAnimations.end())
                 {
@@ -2992,7 +2971,6 @@ void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)
     }
 }
 
-
 void LLAgent::processMaturityPreferenceFromServer(const LLSD &result, U8 perferredMaturity)
 {
     U8 maturity = SIM_ACCESS_MIN;
@@ -3062,7 +3040,6 @@ void LLAgent::changeInterestListMode(const std::string &new_mode)
     }
 }
 
-
 bool LLAgent::requestPostCapability(const std::string &capName, LLSD &postData, httpCallback_t cbSuccess, httpCallback_t cbFailure)
 {
     if (getRegion())
@@ -3390,7 +3367,6 @@ void LLAgent::sendAnimationStateReset()
     sendReliableMessage();
 }
 
-
 // Send a message to the region to revoke sepecified permissions on ALL scripts in the region
 // If the target is an object in the region, permissions in scripts on that object are cleared.
 // If it is the region ID, all scripts clear the permissions for this agent
@@ -4324,7 +4300,6 @@ void LLAgent::onCapabilitiesReceivedAfterTeleport()
     check_merchant_status();
 }
 
-
 void LLAgent::teleportRequest(
     const U64& region_handle,
     const LLVector3& pos_local,
@@ -4424,7 +4399,6 @@ void LLAgent::doTeleportViaLure(const LLUUID& lure_id, BOOL godlike)
     }
 }
 
-
 // James Cook, July 28, 2005
 void LLAgent::teleportCancel()
 {
@@ -4549,7 +4523,6 @@ LLAgent::ETeleportState LLAgent::getTeleportState() const
         TELEPORT_NONE : mTeleportState;
 }
 
-
 void LLAgent::setTeleportState(ETeleportState state)
 {
     if (mTeleportRequest && (state != TELEPORT_NONE) && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed))
@@ -4594,7 +4567,6 @@ void LLAgent::setTeleportState(ETeleportState state)
     }
 }
 
-
 void LLAgent::stopCurrentAnimations()
 {
     LL_DEBUGS("Avatar") << "Stopping current animations" << LL_ENDL;
@@ -4709,7 +4681,6 @@ void LLAgent::stopFidget()
     gAgent.sendAnimationRequests(anims, ANIM_REQUEST_STOP);
 }
 
-
 void LLAgent::requestEnterGodMode()
 {
     LLMessageSystem* msg = gMessageSystem;
@@ -4830,7 +4801,6 @@ void LLAgent::sendAgentUpdateUserInfo(const std::string& directory_visibility)
     }
 }
 
-
 void LLAgent::updateAgentUserInfoCoro(std::string capurl, std::string directory_visibility)
 {
     LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
diff --git a/indra/newview/llagentcamera.cpp b/indra/newview/llagentcamera.cpp
index 2045f8d7a0..3fbba7ac54 100644
--- a/indra/newview/llagentcamera.cpp
+++ b/indra/newview/llagentcamera.cpp
@@ -1232,7 +1232,7 @@ void LLAgentCamera::updateCamera()
     }
 
     //NOTE - this needs to be integrated into a general upVector system here within llAgent.
-    if ( camera_mode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
+    if (camera_mode == CAMERA_MODE_FOLLOW && mFocusOnAvatar)
     {
         mCameraUpVector = mFollowCam.getUpVector();
     }
@@ -1496,7 +1496,7 @@ void LLAgentCamera::updateCamera()
             LLVector3(0.08f, 0.f, 0.05f) * gAgentAvatarp->mHeadp->getWorldRotation() +
             LLVector3(0.1f, 0.f, 0.f) * gAgentAvatarp->mPelvisp->getWorldRotation();
         LLVector3 diff = position_agent - head_pos;
-        diff = diff * ~gAgentAvatarp->mRoot->getWorldRotation();
+        diff *= ~gAgentAvatarp->mRoot->getWorldRotation();
 
         LLJoint* torso_joint = gAgentAvatarp->mTorsop;
         LLJoint* chest_joint = gAgentAvatarp->mChestp;
diff --git a/indra/newview/llagentpilot.cpp b/indra/newview/llagentpilot.cpp
index ecb705ec2d..4bd00bf427 100644
--- a/indra/newview/llagentpilot.cpp
+++ b/indra/newview/llagentpilot.cpp
@@ -322,9 +322,7 @@ void LLAgentPilot::moveCamera()
 
         LLViewerCamera::getInstance()->setView(view);
         LLViewerCamera::getInstance()->setOrigin(origin);
-        LLViewerCamera::getInstance()->mXAxis = LLVector3(mat.mMatrix[0]);
-        LLViewerCamera::getInstance()->mYAxis = LLVector3(mat.mMatrix[1]);
-        LLViewerCamera::getInstance()->mZAxis = LLVector3(mat.mMatrix[2]);
+        LLViewerCamera::getInstance()->setAxes(mat);
     }
 }
 
diff --git a/indra/newview/llviewercamera.cpp b/indra/newview/llviewercamera.cpp
index 836bcad784..3300d6f633 100644
--- a/indra/newview/llviewercamera.cpp
+++ b/indra/newview/llviewercamera.cpp
@@ -122,18 +122,22 @@ bool LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVecto
         regp = gAgent.getRegion();
     }
 
-    F32 water_height = (NULL != regp) ? regp->getWaterHeight() : 0.f;
+    F32 water_height = regp ? regp->getWaterHeight() : 0.f;
 
     LLVector3 origin = center;
 
+    // Move origin[VZ] far enough (up or down) from the water surface
+    static const F32 MIN_DIST_TO_WATER = 0.2f;
+    F32& zpos = origin.mV[VZ];
+    if (zpos < water_height + MIN_DIST_TO_WATER)
     {
-        if (origin.mV[2] > water_height)
+        if (zpos >= water_height)
         {
-            origin.mV[2] = llmax(origin.mV[2], water_height + 0.20f);
+            zpos = water_height + MIN_DIST_TO_WATER;
         }
-        else
+        else if (zpos > water_height - MIN_DIST_TO_WATER)
         {
-            origin.mV[2] = llmin(origin.mV[2], water_height - 0.20f);
+            zpos = water_height - MIN_DIST_TO_WATER;
         }
     }
 
@@ -160,8 +164,7 @@ bool LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVecto
     LLQuaternion rotation;
     rotation.shortestArc(last_axis, getAtAxis());
 
-    F32 x, y, z;
-    F32 drot;
+    F32 drot, x, y, z;
     rotation.getAngleAxis(&drot, &x, &y, &z);
 
     add(sVelocityStat, dpos);
@@ -172,9 +175,9 @@ bool LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVecto
     mCosHalfCameraFOV = cosf(0.5f * getView() * llmax(1.0f, getAspect()));
 
     // update pixel meter ratio using default fov, not modified one
-    mPixelMeterRatio = getViewHeightInPixels()/ (2.f*tanf(mCameraFOVDefault*0.5));
+    mPixelMeterRatio = getViewHeightInPixels() / (2.f * tanf(mCameraFOVDefault * 0.5));
     // update screen pixel area
-    mScreenPixelArea =(S32)((F32)getViewHeightInPixels() * ((F32)getViewHeightInPixels() * getAspect()));
+    mScreenPixelArea = (S32)((F32)getViewHeightInPixels() * ((F32)getViewHeightInPixels() * getAspect()));
 
     return true;
 }
@@ -183,7 +186,6 @@ const LLMatrix4 &LLViewerCamera::getProjection() const
 {
     calcProjection(getFar());
     return mProjectionMatrix;
-
 }
 
 const LLMatrix4 &LLViewerCamera::getModelview() const
@@ -196,19 +198,18 @@ const LLMatrix4 &LLViewerCamera::getModelview() const
 
 void LLViewerCamera::calcProjection(const F32 far_distance) const
 {
-    F32 fov_y, z_far, z_near, aspect, f;
-    fov_y = getView();
-    z_far = far_distance;
-    z_near = getNear();
-    aspect = getAspect();
+    F32 fov_y = getView();
+    F32 z_far = far_distance;
+    F32 z_near = getNear();
+    F32 aspect = getAspect();
 
-    f = 1/tan(fov_y*0.5f);
+    F32 f = 1 / tan(fov_y * 0.5f);
 
     mProjectionMatrix.setZero();
-    mProjectionMatrix.mMatrix[0][0] = f/aspect;
+    mProjectionMatrix.mMatrix[0][0] = f / aspect;
     mProjectionMatrix.mMatrix[1][1] = f;
-    mProjectionMatrix.mMatrix[2][2] = (z_far + z_near)/(z_near - z_far);
-    mProjectionMatrix.mMatrix[3][2] = (2*z_far*z_near)/(z_near - z_far);
+    mProjectionMatrix.mMatrix[2][2] = (z_far + z_near) / (z_near - z_far);
+    mProjectionMatrix.mMatrix[3][2] = (2 * z_far * z_near) / (z_near - z_far);
     mProjectionMatrix.mMatrix[2][3] = -1;
 }
 
@@ -230,71 +231,71 @@ void LLViewerCamera::updateFrustumPlanes(LLCamera& camera, BOOL ortho, BOOL zfli
         proj[i] = (F64) gGLProjection[i];
     }
 
-    GLdouble objX,objY,objZ;
+    GLdouble objX, objY, objZ;
 
     LLVector3 frust[8];
 
     if (no_hacks)
     {
-        gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
-
-        gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);
+        gluUnProject(viewport[0], viewport[1], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[0].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[1].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1] + viewport[3], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[2].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0], viewport[1] + viewport[3], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[3].setVec((F32)objX, (F32)objY, (F32)objZ);
+
+        gluUnProject(viewport[0], viewport[1], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[4].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[5].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1] + viewport[3], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[6].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0], viewport[1] + viewport[3], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[7].setVec((F32)objX, (F32)objY, (F32)objZ);
     }
     else if (zflip)
     {
-        gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
-
-        gluUnProject(viewport[0],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[4].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[5].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[6].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0],viewport[1],1,model,proj,viewport,&objX,&objY,&objZ);
-        frust[7].setVec((F32)objX,(F32)objY,(F32)objZ);
+        gluUnProject(viewport[0], viewport[1] + viewport[3], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[0].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1] + viewport[3], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[1].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[2].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0], viewport[1], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[3].setVec((F32)objX, (F32)objY, (F32)objZ);
+
+        gluUnProject(viewport[0], viewport[1] + viewport[3], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[4].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1] + viewport[3], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[5].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[6].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0], viewport[1], 1, model, proj, viewport, &objX, &objY, &objZ);
+        frust[7].setVec((F32)objX, (F32)objY, (F32)objZ);
 
         for (U32 i = 0; i < 4; i++)
         {
-            frust[i+4] = frust[i+4]-frust[i];
-            frust[i+4].normVec();
-            frust[i+4] = frust[i] + frust[i+4]*camera.getFar();
+            frust[i + 4] = frust[i + 4] - frust[i];
+            frust[i + 4].normVec();
+            frust[i + 4] = frust[i] + frust[i + 4] * camera.getFar();
         }
     }
     else
     {
-        gluUnProject(viewport[0],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[0].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[1].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0]+viewport[2],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[2].setVec((F32)objX,(F32)objY,(F32)objZ);
-        gluUnProject(viewport[0],viewport[1]+viewport[3],0,model,proj,viewport,&objX,&objY,&objZ);
-        frust[3].setVec((F32)objX,(F32)objY,(F32)objZ);
+        gluUnProject(viewport[0], viewport[1], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[0].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[1].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0] + viewport[2], viewport[1] + viewport[3], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[2].setVec((F32)objX, (F32)objY, (F32)objZ);
+        gluUnProject(viewport[0], viewport[1] + viewport[3], 0, model, proj, viewport, &objX, &objY, &objZ);
+        frust[3].setVec((F32)objX, (F32)objY, (F32)objZ);
 
         if (ortho)
         {
-            LLVector3 far_shift = camera.getAtAxis()*camera.getFar()*2.f;
+            LLVector3 far_shift = camera.getAtAxis() * camera.getFar() * 2.f;
             for (U32 i = 0; i < 4; i++)
             {
                 frust[i+4] = frust[i] + far_shift;
@@ -306,7 +307,7 @@ void LLViewerCamera::updateFrustumPlanes(LLCamera& camera, BOOL ortho, BOOL zfli
             {
                 LLVector3 vec = frust[i] - camera.getOrigin();
                 vec.normVec();
-                frust[i+4] = camera.getOrigin() + vec*camera.getFar();
+                frust[i + 4] = camera.getOrigin() + vec * camera.getFar();
             }
         }
     }
@@ -344,11 +345,13 @@ void LLViewerCamera::setPerspective(BOOL for_selection,
         // make a tiny little viewport
         // anything drawn into this viewport will be "selected"
 
-        GLint viewport[4];
-        viewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft;
-        viewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom;
-        viewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth();
-        viewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight();
+        GLint viewport[] =
+        {
+            gViewerWindow->getWorldViewRectRaw().mLeft,
+            gViewerWindow->getWorldViewRectRaw().mBottom,
+            gViewerWindow->getWorldViewRectRaw().getWidth(),
+            gViewerWindow->getWorldViewRectRaw().getHeight()
+        };
 
         proj_mat = gl_pick_matrix(x+width/2.f, y_from_bot+height/2.f, (GLfloat) width, (GLfloat) height, viewport);
 
@@ -405,7 +408,7 @@ void LLViewerCamera::setPerspective(BOOL for_selection,
 
     glh::matrix4f modelview((GLfloat*) OGL_TO_CFR_ROTATION);
 
-    GLfloat         ogl_matrix[16];
+    GLfloat ogl_matrix[16];
 
     getOpenGLTransform(ogl_matrix);
 
@@ -418,11 +421,13 @@ void LLViewerCamera::setPerspective(BOOL for_selection,
         // NB: as of this writing, i believe the code below is broken (doesn't take into account the world view, assumes entire window)
         // however, it is also unused (the GL matricies are used for selection, (see LLCamera::sphereInFrustum())) and so i'm not
         // comfortable hacking on it.
-        calculateFrustumPlanesFromWindow((F32)(x - width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
-                                (F32)(y_from_bot - height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f,
-                                (F32)(x + width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
-                                (F32)(y_from_bot + height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f);
-
+        calculateFrustumPlanesFromWindow
+        (
+            (F32)(x - width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
+            (F32)(y_from_bot - height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f,
+            (F32)(x + width / 2) / (F32)gViewerWindow->getWindowWidthScaled() - 0.5f,
+            (F32)(y_from_bot + height / 2) / (F32)gViewerWindow->getWindowHeightScaled() - 0.5f
+        );
     }
 
     // if not picking and not doing a snapshot, cache various GL matrices