Merge commit 'f32a6d40aa' into marchcat/c-develop

# Conflicts:
#	indra/llmath/v2math.cpp
#	indra/llmath/v2math.h
#	indra/llmath/v3math.h
#	indra/llmath/v4math.h
#	indra/newview/llagent.cpp
#	indra/newview/llagentcamera.h
#	indra/newview/llfloaternamedesc.cpp
#	indra/newview/llfloaternamedesc.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llmaterialeditor.cpp
#	indra/newview/llreflectionmap.cpp
#	indra/newview/llviewerassetupload.cpp
#	indra/newview/llviewercamera.cpp
#	indra/newview/llviewercamera.h
#	indra/newview/llviewermenufile.cpp
#	indra/newview/llviewerobject.h
#	indra/newview/llvovolume.h

49 files changed, 744 insertions, 570 deletions

diff --git a/indra/llcommon/llprocessor.cpp b/indra/llcommon/llprocessor.cpp
index 51b1b967f1..0264cf792b 100644
--- a/indra/llcommon/llprocessor.cpp
+++ b/indra/llcommon/llprocessor.cpp
@@ -638,6 +638,14 @@ public:
     {
         getCPUIDInfo();
         uint64_t frequency = getSysctlInt64("hw.cpufrequency");
+        if (!frequency)
+        {
+            auto tbfrequency = getSysctlInt64("hw.tbfrequency");
+            struct clockinfo clockrate;
+            auto clockrate_len = sizeof(clockrate);
+            if (!sysctlbyname("kern.clockrate", &clockrate, &clockrate_len, NULL, 0))
+                frequency = tbfrequency * clockrate.hz;
+        }
         setInfo(eFrequency, (F64)frequency  / (F64)1000000);
     }
 
diff --git a/indra/llmath/llcoordframe.cpp b/indra/llmath/llcoordframe.cpp
index 15c9f6ff3f..f9ecea1a4a 100644
--- a/indra/llmath/llcoordframe.cpp
+++ b/indra/llmath/llcoordframe.cpp
@@ -328,28 +328,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)
+{
+    F32 sx = source[VX], sy = source[VY], sz = source[VZ];
+    F32 tx = target[VX], ty = target[VY], tz = target[VZ];
+    F32 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 1ab3a73d79..3a6748bdb3 100644
--- a/indra/llmath/llquaternion.cpp
+++ b/indra/llmath/llquaternion.cpp
@@ -57,7 +57,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;
@@ -76,7 +76,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 198fedcb03..9d16f1e654 100644
--- a/indra/llmath/v2math.cpp
+++ b/indra/llmath/v2math.cpp
@@ -66,7 +66,14 @@ F32 angle_between(const LLVector2& a, const LLVector2& b)
     return angle;
 }
 
-bool are_parallel(const LLVector2& a, const LLVector2& b, F32 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 a0ba3ec505..b06739f122 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()
 {
-    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()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    mV[VX] = mV[VY] = 0.f;
 }
 
 inline void LLVector2::setZero()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    clear();
 }
 
 // deprecated
 inline void LLVector2::clearVec()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
+    clear();
 }
 
 // deprecated
 inline void LLVector2::zeroVec()
 {
-    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() const
 {
-    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
+    return (F32) sqrt(lengthSquared());
 }
 
 inline F32 LLVector2::lengthSquared() const
@@ -234,61 +222,42 @@ inline F32 LLVector2::lengthSquared() const
 
 inline F32 LLVector2::normalize()
 {
-    F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
-    F32 oomag;
+    F32 mag = length();
 
     if (mag > FP_MAG_THRESHOLD)
     {
-        oomag = 1.f/mag;
-        mV[VX] *= oomag;
-        mV[VY] *= oomag;
+        *this /= mag;
     }
     else
     {
-        mV[VX] = 0.f;
-        mV[VY] = 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() const
 {
-    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
+    return length();
 }
 
 // deprecated
 inline F32 LLVector2::magVecSquared() const
 {
-    return mV[VX]*mV[VX] + mV[VY]*mV[VY];
+    return lengthSquared();
 }
 
 // deprecated
 inline F32 LLVector2::normVec()
 {
-    F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY]);
-    F32 oomag;
-
-    if (mag > FP_MAG_THRESHOLD)
-    {
-        oomag = 1.f/mag;
-        mV[VX] *= oomag;
-        mV[VY] *= oomag;
-    }
-    else
-    {
-        mV[VX] = 0.f;
-        mV[VY] = 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() const
 {
-    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];
 }
 
 
@@ -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[VX] *= t;
-    a.mV[VY] *= 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 53491533c2..bcd8f311a8 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()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 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()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
+    set(0.f, 0.f, 0.f);
 }
 
 inline void LLVector3::setZero()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
+    clear();
 }
 
 inline void LLVector3::clearVec()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
+    clear();
 }
 
 inline void LLVector3::zeroVec()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 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[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
+    set(vec.mV[0], vec.mV[1], vec.mV[2]);
 }
 
 inline void LLVector3::set(const F32* vec)
 {
-    mV[VX] = vec[0];
-    mV[VY] = vec[1];
-    mV[VZ] = 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[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
+    set(vec);
 }
 
 // deprecated
 inline void LLVector3::setVec(const F32* vec)
 {
-    mV[VX] = vec[0];
-    mV[VY] = vec[1];
-    mV[VZ] = vec[2];
+    set(vec);
 }
 
 inline F32 LLVector3::normalize()
 {
     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
     {
-        mV[VX] = 0.f;
-        mV[VY] = 0.f;
-        mV[VZ] = 0.f;
+        clear();
         mag = 0;
     }
-    return (mag);
+    return mag;
 }
 
 // deprecated
 inline F32 LLVector3::normVec()
 {
-    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[VX] *= oomag;
-        mV[VY] *= oomag;
-        mV[VZ] *= oomag;
-    }
-    else
-    {
-        mV[VX] = 0.f;
-        mV[VY] = 0.f;
-        mV[VZ] = 0.f;
-        mag = 0;
-    }
-    return (mag);
+    return normalize();
 }
 
 // LLVector3 Magnitude and Normalization Functions
 
-inline F32  LLVector3::length() const
+inline F32 LLVector3::length() const
 {
-    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return (F32) sqrt(lengthSquared());
 }
 
-inline F32  LLVector3::lengthSquared() const
+inline F32  LLVector3::lengthSquared(void) const
 {
     return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
 }
 
-inline F32  LLVector3::magVec() const
+inline F32 LLVector3::magVec() const
 {
-    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return length();
 }
 
-inline F32  LLVector3::magVecSquared() const
+inline F32 LLVector3::magVecSquared() const
 {
-    return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
+    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[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 LLVector3 operator%(const LLVector3& a, const LLVector3& b)
@@ -478,7 +431,7 @@ inline LLVector3 operator-(const LLVector3& a)
     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[VX] - b.mV[VX];
     F32 y = a.mV[VY] - b.mV[VY];
@@ -486,7 +439,7 @@ inline F32  dist_vec(const LLVector3& a, const LLVector3& b)
     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[VX] - b.mV[VX];
     F32 y = a.mV[VY] - b.mV[VY];
@@ -494,7 +447,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[VX] - b.mV[VX];
     F32 y = a.mV[VY] - b.mV[VY];
@@ -508,10 +461,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)
@@ -548,11 +498,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)
@@ -593,7 +539,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)
@@ -603,7 +549,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 e2092d1277..b906ae24fd 100644
--- a/indra/llmath/v4math.h
+++ b/indra/llmath/v4math.h
@@ -148,34 +148,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)
@@ -204,18 +192,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)
@@ -226,43 +208,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()
 {
-    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()
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
-    mV[VW] = 1.f;
+    clear();
 }
 
 // deprecated
 inline void LLVector4::zeroVec()
 {
-    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)
@@ -275,10 +245,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)
@@ -297,57 +264,41 @@ 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() const
 {
-    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return (F32) sqrt(lengthSquared());
 }
 
 inline F32      LLVector4::lengthSquared() const
@@ -357,12 +308,12 @@ inline F32      LLVector4::lengthSquared() const
 
 inline F32      LLVector4::magVec() const
 {
-    return sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return length();
 }
 
 inline F32      LLVector4::magVecSquared() const
 {
-    return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
+    return lengthSquared();
 }
 
 // LLVector4 Operators
@@ -381,7 +332,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)
@@ -454,11 +405,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)
@@ -469,13 +416,13 @@ inline LLVector4 operator-(const LLVector4& a)
 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)
 {
     LLVector4 vec = a - b;
-    return (vec.lengthSquared());
+    return vec.lengthSquared();
 }
 
 inline LLVector4 lerp(const LLVector4& a, const LLVector4& b, F32 u)
@@ -489,15 +436,11 @@ inline LLVector4 lerp(const LLVector4& a, const LLVector4& b, F32 u)
 
 inline F32      LLVector4::normalize()
 {
-    F32 mag = sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
-    F32 oomag;
+    F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 
     if (mag > FP_MAG_THRESHOLD)
     {
-        oomag = 1.f/mag;
-        mV[VX] *= oomag;
-        mV[VY] *= oomag;
-        mV[VZ] *= oomag;
+        *this /= mag;
     }
     else
     {
@@ -506,30 +449,13 @@ inline F32      LLVector4::normalize()
         mV[VZ] = 0.f;
         mag = 0.f;
     }
-    return (mag);
+    return mag;
 }
 
 // deprecated
 inline F32      LLVector4::normVec()
 {
-    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[VX] *= oomag;
-        mV[VY] *= oomag;
-        mV[VZ] *= oomag;
-    }
-    else
-    {
-        mV[VX] = 0.f;
-        mV[VY] = 0.f;
-        mV[VZ] = 0.f;
-        mag = 0.f;
-    }
-    return (mag);
+    return normalize();
 }
 
 // Because apparently some parts of the viewer use this for color info.
diff --git a/indra/llprimitive/llmodel.cpp b/indra/llprimitive/llmodel.cpp
index 4e3e49ec9f..2fb1956301 100644
--- a/indra/llprimitive/llmodel.cpp
+++ b/indra/llprimitive/llmodel.cpp
@@ -66,7 +66,12 @@ LLModel::~LLModel()
 {
     if (mDecompID >= 0)
     {
-        LLConvexDecomposition::getInstance()->deleteDecomposition(mDecompID);
+        // can be null on shutdown
+        LLConvexDecomposition* decomp = LLConvexDecomposition::getInstance();
+        if (decomp)
+        {
+            decomp->deleteDecomposition(mDecompID);
+        }
     }
     mPhysics.mMesh.clear();
 }
diff --git a/indra/newview/gltfscenemanager.cpp b/indra/newview/gltfscenemanager.cpp
index ed66753267..29a82416ab 100644
--- a/indra/newview/gltfscenemanager.cpp
+++ b/indra/newview/gltfscenemanager.cpp
@@ -213,6 +213,7 @@ void GLTFSceneManager::uploadSelection()
                         LLFloaterPerms::getGroupPerms("Uploads"),
                         LLFloaterPerms::getEveryonePerms("Uploads"),
                         expected_upload_cost,
+                        LLUUID::null,
                         false,
                         finish,
                         failure));
@@ -276,6 +277,7 @@ void GLTFSceneManager::uploadSelection()
                 LLFloaterPerms::getGroupPerms("Uploads"),
                 LLFloaterPerms::getEveryonePerms("Uploads"),
                 expected_upload_cost,
+                LLUUID::null,
                 false,
                 finish,
                 failure));
@@ -545,6 +547,7 @@ void GLTFSceneManager::update()
                 LLFloaterPerms::getGroupPerms("Uploads"),
                 LLFloaterPerms::getEveryonePerms("Uploads"),
                 expected_upload_cost,
+                LLUUID::null,
                 false,
                 finish,
                 failure));
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 5f1d19c827..b92a07f020 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -222,7 +222,6 @@ private:
     LLVector3d mPosGlobal;
 };
 
-
 class LLTeleportRequestViaLocationLookAt : public LLTeleportRequestViaLocation
 {
 public:
@@ -842,7 +841,6 @@ void LLAgent::movePitch(F32 mag)
     }
 }
 
-
 // Does this parcel allow you to fly?
 bool LLAgent::canFly()
 {
@@ -922,7 +920,6 @@ void LLAgent::setFlying(bool fly, bool fail_sound)
     LLFloaterMove::setFlyingMode(fly);
 }
 
-
 // UI based mechanism of setting fly state
 //-----------------------------------------------------------------------------
 // toggleFlying()
@@ -1001,7 +998,6 @@ void LLAgent::capabilityReceivedCallback(const LLUUID &region_id, LLViewerRegion
     }
 }
 
-
 //-----------------------------------------------------------------------------
 // setRegion()
 //-----------------------------------------------------------------------------
@@ -1107,7 +1103,6 @@ void LLAgent::setRegion(LLViewerRegion *regionp)
     mRegionChangedSignal();
 }
 
-
 //-----------------------------------------------------------------------------
 // getRegion()
 //-----------------------------------------------------------------------------
@@ -1116,7 +1111,6 @@ LLViewerRegion *LLAgent::getRegion() const
     return mRegionp;
 }
 
-
 LLHost LLAgent::getRegionHost() const
 {
     if (mRegionp)
@@ -1147,7 +1141,6 @@ bool LLAgent::inPrelude()
     return mRegionp && mRegionp->isPrelude();
 }
 
-
 std::string LLAgent::getRegionCapability(const std::string &name)
 {
     if (!mRegionp)
@@ -1156,7 +1149,6 @@ std::string LLAgent::getRegionCapability(const std::string &name)
     return mRegionp->getCapability(name);
 }
 
-
 //-----------------------------------------------------------------------------
 // canManageEstate()
 //-----------------------------------------------------------------------------
@@ -1184,7 +1176,6 @@ void LLAgent::sendMessage()
     gMessageSystem->sendMessage(mRegionp->getHost());
 }
 
-
 //-----------------------------------------------------------------------------
 // sendReliableMessage()
 //-----------------------------------------------------------------------------
@@ -1218,7 +1209,6 @@ LLVector3 LLAgent::getVelocity() const
     }
 }
 
-
 //-----------------------------------------------------------------------------
 // setPositionAgent()
 //-----------------------------------------------------------------------------
@@ -1287,12 +1277,11 @@ const LLVector3 &LLAgent::getPositionAgent()
             mFrameAgent.setOrigin(gAgentAvatarp->getPositionAgent());
         }
         else
-    {
-        mFrameAgent.setOrigin(gAgentAvatarp->getRenderPosition());
-    }
+        {
+            mFrameAgent.setOrigin(gAgentAvatarp->getRenderPosition());
+        }
     }
 
-
     return mFrameAgent.getOrigin();
 }
 
@@ -1301,7 +1290,6 @@ boost::signals2::connection LLAgent::whenPositionChanged(position_signal_t::slot
     return mOnPositionChanged.connect(fn);
 }
 
-
 //-----------------------------------------------------------------------------
 // getRegionsVisited()
 //-----------------------------------------------------------------------------
@@ -1318,7 +1306,6 @@ F64 LLAgent::getDistanceTraveled() const
     return mDistanceTraveled;
 }
 
-
 //-----------------------------------------------------------------------------
 // getPosAgentFromGlobal()
 //-----------------------------------------------------------------------------
@@ -1329,7 +1316,6 @@ LLVector3 LLAgent::getPosAgentFromGlobal(const LLVector3d &pos_global) const
     return pos_agent;
 }
 
-
 //-----------------------------------------------------------------------------
 // getPosGlobalFromAgent()
 //-----------------------------------------------------------------------------
@@ -1345,7 +1331,6 @@ void LLAgent::sitDown()
     setControlFlags(AGENT_CONTROL_SIT_ON_GROUND);
 }
 
-
 //-----------------------------------------------------------------------------
 // resetAxes()
 //-----------------------------------------------------------------------------
@@ -1354,7 +1339,6 @@ void LLAgent::resetAxes()
     mFrameAgent.resetAxes();
 }
 
-
 // Copied from LLCamera::setOriginAndLookAt
 // Look_at must be unit vector
 //-----------------------------------------------------------------------------
@@ -1383,7 +1367,6 @@ void LLAgent::resetAxes(const LLVector3 &look_at)
     mFrameAgent.setAxes(look_at, left, up);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1392,7 +1375,6 @@ void LLAgent::rotate(F32 angle, const LLVector3 &axis)
     mFrameAgent.rotate(angle, axis);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1401,7 +1383,6 @@ void LLAgent::rotate(F32 angle, F32 x, F32 y, F32 z)
     mFrameAgent.rotate(angle, x, y, z);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1410,7 +1391,6 @@ void LLAgent::rotate(const LLMatrix3 &matrix)
     mFrameAgent.rotate(matrix);
 }
 
-
 //-----------------------------------------------------------------------------
 // rotate()
 //-----------------------------------------------------------------------------
@@ -1419,7 +1399,6 @@ void LLAgent::rotate(const LLQuaternion &quaternion)
     mFrameAgent.rotate(quaternion);
 }
 
-
 //-----------------------------------------------------------------------------
 // getReferenceUpVector()
 //-----------------------------------------------------------------------------
@@ -1454,49 +1433,65 @@ LLVector3 LLAgent::getReferenceUpVector()
 //-----------------------------------------------------------------------------
 void LLAgent::pitch(F32 angle)
 {
-    if (fabs(angle) <= 1e-4)
-        return;
-
-    LLCoordFrame newCoordFrame(mFrameAgent);
-    newCoordFrame.pitch(angle);
-
-    // don't let user pitch if rotated 180 degree around the vertical axis
-    if ((newCoordFrame.getXAxis()[VX] * mFrameAgent.getXAxis()[VX] < 0) &&
-        (newCoordFrame.getXAxis()[VY] * mFrameAgent.getXAxis()[VY] < 0))
-        return;
-
-    // A dot B = mag(A) * mag(B) * cos(angle between A and B)
-    // so... cos(angle between A and B) = A dot B / mag(A) / mag(B)
-    //                                  = A dot B for unit vectors
+    if (gAgentCamera.getCameraMode() == CAMERA_MODE_THIRD_PERSON ||
+        gAgentCamera.getCameraMode() == CAMERA_MODE_MOUSELOOK)
+    {
+        // Backup the current orientation
+        LLCoordFrame saved_frame_agent(mFrameAgent);
 
-    LLVector3 skyward = getReferenceUpVector();
+        // Optimistic rotation up/down (vertical angle can reach and exceed 0 or 180)
+        mFrameAgent.pitch(angle);
 
-    // SL-19286 Avatar is upside down when viewed from below
-    // after left-clicking the mouse on the avatar and dragging down
-    //
-    // The issue is observed on angle below 10 degrees
-    const F32 look_down_limit = 179.f * DEG_TO_RAD;
-    const F32 look_up_limit = 10.f * DEG_TO_RAD;
+        // Cosine of the angle between current agent At and Up directions
+        F32 agent_at_to_up_now_cos = saved_frame_agent.mXAxis * gAgentCamera.getCameraUpVector();
+        bool pitch_away_from_horizont = (angle < 0) ^ (agent_at_to_up_now_cos < 0);
+        // We always allow to pitch in direction to horizont (from zenith or from nadir)
+        if (!pitch_away_from_horizont)
+            return;
 
-    F32 angle_from_skyward = acos(mFrameAgent.getAtAxis() * skyward);
+        // Current angle between agent At and Up directions
+        F32 agent_at_to_up_now = acos(agent_at_to_up_now_cos);
+        // Requested angle between agent At and Up directions
+        F32 agent_at_to_up_new = agent_at_to_up_now + angle;
+        F32 agent_at_to_up_new_sin = sin(agent_at_to_up_new);
+        // Overpitched? Then rollback
+        if (agent_at_to_up_new_sin < 1e-4)
+        {
+            mFrameAgent = saved_frame_agent;
+            return;
+        }
 
-    // clamp pitch to limits
-    if ((angle >= 0.f) && (angle_from_skyward + angle > look_down_limit))
-    {
-        angle = look_down_limit - angle_from_skyward;
-    }
-    else if ((angle < 0.f) && (angle_from_skyward + angle < look_up_limit))
-    {
-        angle = look_up_limit - angle_from_skyward;
+        if (gAgentCamera.getCameraMode() == CAMERA_MODE_THIRD_PERSON ||
+            (isAgentAvatarValid() && gAgentAvatarp->getParent()))
+        {
+            // Camera sight relative to agent frame (focus - offset)
+            LLVector3 camera_offset(gAgentCamera.getCameraOffsetInitial());
+            LLVector3 camera_focus(gAgentCamera.getFocusOffsetInitial());
+            LLVector3 camera_sight(camera_focus - camera_offset);
+            // 2D projection of the camera sight to the XZ plane
+            LLVector2 camera_sight_2d_vert(1, camera_sight[VZ]);
+            camera_sight_2d_vert.normalize();
+            // Cosine of the 2D angle between initial camera At and X axis (in the XZ plane)
+            F32 camera_sight_to_at_2d_vert_cos = camera_sight_2d_vert * LLVector2(LLVector3::x_axis);
+            F32 camera_sight_to_at_2d_vert = acos(camera_sight_to_at_2d_vert_cos);
+            // Requested angle between camera At and Up directions
+            F32 camera_at_to_up_new = agent_at_to_up_new - camera_sight_to_at_2d_vert;
+            F32 camera_at_to_up_new_sin = sin(camera_at_to_up_new);
+            // Overpitched? Then rollback
+            if (camera_at_to_up_new_sin < 1e-4)
+            {
+                mFrameAgent = saved_frame_agent;
+                return;
+            }
+        }
     }
-
-    if (fabs(angle) > 1e-4)
+    else
     {
+        // No limitations in other modes
         mFrameAgent.pitch(angle);
     }
 }
 
-
 //-----------------------------------------------------------------------------
 // roll()
 //-----------------------------------------------------------------------------
@@ -1505,7 +1500,6 @@ void LLAgent::roll(F32 angle)
     mFrameAgent.roll(angle);
 }
 
-
 //-----------------------------------------------------------------------------
 // yaw()
 //-----------------------------------------------------------------------------
@@ -1517,7 +1511,6 @@ void LLAgent::yaw(F32 angle)
     }
 }
 
-
 // Returns a quat that represents the rotation of the agent in the absolute frame
 //-----------------------------------------------------------------------------
 // getQuat()
@@ -1543,7 +1536,6 @@ void LLAgent::setControlFlags(U32 mask)
     mControlFlags |= mask;
 }
 
-
 //-----------------------------------------------------------------------------
 // clearControlFlags()
 //-----------------------------------------------------------------------------
@@ -1631,7 +1623,6 @@ bool LLAgent::isDoNotDisturb() const
     return mIsDoNotDisturb;
 }
 
-
 //-----------------------------------------------------------------------------
 // startAutoPilotGlobal()
 //-----------------------------------------------------------------------------
@@ -1737,7 +1728,6 @@ void LLAgent::startAutoPilotGlobal(
     mAutoPilotNoProgressFrameCount = 0;
 }
 
-
 //-----------------------------------------------------------------------------
 // setAutoPilotTargetGlobal
 //-----------------------------------------------------------------------------
@@ -1791,7 +1781,6 @@ void LLAgent::startFollowPilot(const LLUUID &leader_id, bool allow_flying, F32 s
                          allow_flying);
 }
 
-
 //-----------------------------------------------------------------------------
 // stopAutoPilot()
 //-----------------------------------------------------------------------------
@@ -1833,7 +1822,6 @@ void LLAgent::stopAutoPilot(bool user_cancel)
     }
 }
 
-
 // Returns necessary agent pitch and yaw changes, radians.
 //-----------------------------------------------------------------------------
 // autoPilot()
@@ -2022,7 +2010,6 @@ void LLAgent::autoPilot(F32 *delta_yaw)
     }
 }
 
-
 //-----------------------------------------------------------------------------
 // propagate()
 //-----------------------------------------------------------------------------
@@ -2043,18 +2030,19 @@ void LLAgent::propagate(const F32 dt)
     }
 
     // handle rotation based on keyboard levels
-    constexpr F32 YAW_RATE = 90.f * DEG_TO_RAD;                // radians per second
-    F32 angle = YAW_RATE * gAgentCamera.getYawKey() * dt;
-    if (fabs(angle) > 0.0f)
+    if (fabs(dt) > 1e-6)
     {
-        yaw(angle);
-    }
+        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);
+        }
 
-    constexpr F32 PITCH_RATE = 90.f * DEG_TO_RAD;            // radians per second
-    angle = PITCH_RATE * gAgentCamera.getPitchKey() * dt;
-    if (fabs(angle) > 0.0f)
-    {
-        pitch(angle);
+        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
@@ -2216,7 +2204,6 @@ void LLAgent::clearRenderState(U8 clearstate)
     mRenderState &= ~clearstate;
 }
 
-
 //-----------------------------------------------------------------------------
 // getRenderState()
 //-----------------------------------------------------------------------------
@@ -2258,6 +2245,7 @@ void LLAgent::endAnimationUpdateUI()
     {
         return;
     }
+
     if (gAgentCamera.getCameraMode() == gAgentCamera.getLastCameraMode())
     {
         // We're already done endAnimationUpdateUI for this transition.
@@ -2323,9 +2311,8 @@ void LLAgent::endAnimationUpdateUI()
             mViewsPushed = false;
         }
 
-
         gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
-        if( gMorphView )
+        if (gMorphView)
         {
             gMorphView->setVisible( false );
         }
@@ -2333,7 +2320,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())
                 {
@@ -2952,7 +2939,6 @@ void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)
     }
 }
 
-
 void LLAgent::processMaturityPreferenceFromServer(const LLSD &result, U8 perferredMaturity)
 {
     U8 maturity = SIM_ACCESS_MIN;
@@ -3022,7 +3008,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())
@@ -3349,7 +3334,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
@@ -4279,7 +4263,6 @@ void LLAgent::onCapabilitiesReceivedAfterTeleport()
     check_merchant_status();
 }
 
-
 void LLAgent::teleportRequest(
     const U64& region_handle,
     const LLVector3& pos_local,
@@ -4379,7 +4362,6 @@ void LLAgent::doTeleportViaLure(const LLUUID& lure_id, bool godlike)
     }
 }
 
-
 // James Cook, July 28, 2005
 void LLAgent::teleportCancel()
 {
@@ -4504,7 +4486,6 @@ LLAgent::ETeleportState LLAgent::getTeleportState() const
         TELEPORT_NONE : mTeleportState;
 }
 
-
 void LLAgent::setTeleportState(ETeleportState state)
 {
     if (mTeleportRequest && (state != TELEPORT_NONE) && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed))
@@ -4549,7 +4530,6 @@ void LLAgent::setTeleportState(ETeleportState state)
     }
 }
 
-
 void LLAgent::stopCurrentAnimations()
 {
     LL_DEBUGS("Avatar") << "Stopping current animations" << LL_ENDL;
@@ -4664,7 +4644,6 @@ void LLAgent::stopFidget()
     gAgent.sendAnimationRequests(anims, ANIM_REQUEST_STOP);
 }
 
-
 void LLAgent::requestEnterGodMode()
 {
     LLMessageSystem* msg = gMessageSystem;
@@ -4785,7 +4764,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 d4767e18af..339656089c 100644
--- a/indra/newview/llagentcamera.cpp
+++ b/indra/newview/llagentcamera.cpp
@@ -1462,13 +1462,12 @@ void LLAgentCamera::updateCamera()
 //  LL_INFOS() << "Current FOV Zoom: " << mCameraCurrentFOVZoomFactor << " Target FOV Zoom: " << mCameraFOVZoomFactor << " Object penetration: " << mFocusObjectDist << LL_ENDL;
 
     LLVector3 focus_agent = gAgent.getPosAgentFromGlobal(mFocusGlobal);
+    LLVector3 position_agent = gAgent.getPosAgentFromGlobal(camera_pos_global);
 
-    mCameraPositionAgent = gAgent.getPosAgentFromGlobal(camera_pos_global);
+    // Try to move the camera
 
-    // Move the camera
-
-    LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, mCameraUpVector, focus_agent);
-    //LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, camera_skyward, focus_agent);
+    if (!LLViewerCamera::getInstance()->updateCameraLocation(position_agent, mCameraUpVector, focus_agent))
+        return;
 
     // Change FOV
     LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / (1.f + mCameraCurrentFOVZoomFactor));
@@ -1476,7 +1475,7 @@ void LLAgentCamera::updateCamera()
     // follow camera when in customize mode
     if (cameraCustomizeAvatar())
     {
-        setLookAt(LOOKAT_TARGET_FOCUS, NULL, mCameraPositionAgent);
+        setLookAt(LOOKAT_TARGET_FOCUS, NULL, position_agent);
     }
 
     // update the travel distance stat
@@ -1495,8 +1494,8 @@ void LLAgentCamera::updateCamera()
         LLVector3 head_pos = gAgentAvatarp->mHeadp->getWorldPosition() +
             LLVector3(0.08f, 0.f, 0.05f) * gAgentAvatarp->mHeadp->getWorldRotation() +
             LLVector3(0.1f, 0.f, 0.f) * gAgentAvatarp->mPelvisp->getWorldRotation();
-        LLVector3 diff = mCameraPositionAgent - head_pos;
-        diff = diff * ~gAgentAvatarp->mRoot->getWorldRotation();
+        LLVector3 diff = position_agent - head_pos;
+        diff *= ~gAgentAvatarp->mRoot->getWorldRotation();
 
         LLJoint* torso_joint = gAgentAvatarp->mTorsop;
         LLJoint* chest_joint = gAgentAvatarp->mChestp;
@@ -2256,7 +2255,8 @@ void LLAgentCamera::changeCameraToFollow(bool animate)
         mCameraMode = CAMERA_MODE_FOLLOW;
 
         // bang-in the current focus, position, and up vector of the follow cam
-        mFollowCam.reset(mCameraPositionAgent, LLViewerCamera::getInstance()->getPointOfInterest(), LLVector3::z_axis);
+        const LLViewerCamera& camera = LLViewerCamera::instance();
+        mFollowCam.reset(camera.getOrigin(), camera.getPointOfInterest(), LLVector3::z_axis);
 
         if (gBasicToolset)
         {
diff --git a/indra/newview/llagentcamera.h b/indra/newview/llagentcamera.h
index a407a65be0..feb396d840 100644
--- a/indra/newview/llagentcamera.h
+++ b/indra/newview/llagentcamera.h
@@ -146,6 +146,7 @@ public:
     bool            calcCameraMinDistance(F32 &obj_min_distance);
     F32             getCurrentCameraBuildOffset()   { return (F32)mCameraFocusOffset.length(); }
     void            clearCameraLag() { mCameraLag.clearVec(); }
+    const LLVector3& getCameraUpVector() const { return mCameraUpVector; }
 private:
     LLVector3       getAvatarRootPosition();
 
@@ -155,7 +156,6 @@ private:
     F32             mCameraCurrentFOVZoomFactor;    // Interpolated fov zoom
     LLVector4       mCameraCollidePlane;            // Colliding plane for camera
     F32             mCameraZoomFraction;            // Mousewheel driven fraction of zoom
-    LLVector3       mCameraPositionAgent;           // Camera position in agent coordinates
     LLVector3       mCameraVirtualPositionAgent;    // Camera virtual position (target) before performing FOV zoom
     LLVector3d      mCameraSmoothingLastPositionGlobal;
     LLVector3d      mCameraSmoothingLastPositionAgent;
@@ -279,7 +279,7 @@ public:
     F32             getAgentHUDTargetZoom();
 
     void            resetCameraZoomFraction();
-    F32             getCurrentCameraZoomFraction() { return mCameraZoomFraction; }
+    F32             getCurrentCameraZoomFraction() const { return mCameraZoomFraction; }
 
     //--------------------------------------------------------------------
     // Pan
diff --git a/indra/newview/llagentpilot.cpp b/indra/newview/llagentpilot.cpp
index 0b5198bbd3..8b18b7d5a2 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/llfloaterbvhpreview.cpp b/indra/newview/llfloaterbvhpreview.cpp
index b94c31ec04..7450be45f1 100644
--- a/indra/newview/llfloaterbvhpreview.cpp
+++ b/indra/newview/llfloaterbvhpreview.cpp
@@ -118,8 +118,8 @@ std::string STATUS[] =
 //-----------------------------------------------------------------------------
 // LLFloaterBvhPreview()
 //-----------------------------------------------------------------------------
-LLFloaterBvhPreview::LLFloaterBvhPreview(const std::string& filename) :
-    LLFloaterNameDesc(filename)
+LLFloaterBvhPreview::LLFloaterBvhPreview(const LLSD& args) :
+    LLFloaterNameDesc(args)
 {
     mLastMouseX = 0;
     mLastMouseY = 0;
@@ -1028,7 +1028,8 @@ void LLFloaterBvhPreview::onBtnOK(void* userdata)
                     LLFloaterPerms::getNextOwnerPerms("Uploads"),
                     LLFloaterPerms::getGroupPerms("Uploads"),
                     LLFloaterPerms::getEveryonePerms("Uploads"),
-                    expected_upload_cost));
+                    expected_upload_cost,
+                    floaterp->mDestinationFolderId));
 
                 upload_new_resource(assetUploadInfo);
             }
diff --git a/indra/newview/llfloaterbvhpreview.h b/indra/newview/llfloaterbvhpreview.h
index ae64521492..c6b75c00b2 100644
--- a/indra/newview/llfloaterbvhpreview.h
+++ b/indra/newview/llfloaterbvhpreview.h
@@ -70,7 +70,7 @@ protected:
 class LLFloaterBvhPreview : public LLFloaterNameDesc
 {
 public:
-    LLFloaterBvhPreview(const std::string& filename);
+    LLFloaterBvhPreview(const LLSD& args);
     virtual ~LLFloaterBvhPreview();
 
     bool postBuild();
diff --git a/indra/newview/llfloaterimagepreview.cpp b/indra/newview/llfloaterimagepreview.cpp
index 989e1d8d04..f254fdafaf 100644
--- a/indra/newview/llfloaterimagepreview.cpp
+++ b/indra/newview/llfloaterimagepreview.cpp
@@ -72,8 +72,8 @@ const S32 PREVIEW_TEXTURE_HEIGHT = 320;
 //-----------------------------------------------------------------------------
 // LLFloaterImagePreview()
 //-----------------------------------------------------------------------------
-LLFloaterImagePreview::LLFloaterImagePreview(const std::string& filename) :
-    LLFloaterNameDesc(filename),
+LLFloaterImagePreview::LLFloaterImagePreview(const LLSD& args) :
+    LLFloaterNameDesc(args),
 
     mAvatarPreview(NULL),
     mSculptedPreview(NULL),
diff --git a/indra/newview/llfloaterimagepreview.h b/indra/newview/llfloaterimagepreview.h
index ed395722de..9bc57246cf 100644
--- a/indra/newview/llfloaterimagepreview.h
+++ b/indra/newview/llfloaterimagepreview.h
@@ -110,7 +110,7 @@ protected:
 class LLFloaterImagePreview : public LLFloaterNameDesc
 {
 public:
-    LLFloaterImagePreview(const std::string& filename);
+    LLFloaterImagePreview(const LLSD& args);
     virtual ~LLFloaterImagePreview();
 
     bool postBuild() override;
diff --git a/indra/newview/llfloatermodelpreview.cpp b/indra/newview/llfloatermodelpreview.cpp
index f7021128d8..b5489d2dd8 100644
--- a/indra/newview/llfloatermodelpreview.cpp
+++ b/indra/newview/llfloatermodelpreview.cpp
@@ -349,14 +349,14 @@ void LLFloaterModelPreview::initModelPreview()
 }
 
 //static
-bool LLFloaterModelPreview::showModelPreview()
+void LLFloaterModelPreview::showModelPreview(const LLUUID& dest_folder)
 {
     LLFloaterModelPreview* fmp = (LLFloaterModelPreview*)LLFloaterReg::getInstance("upload_model");
     if (fmp && !fmp->isModelLoading())
     {
+        fmp->setUploadDestination(dest_folder);
         fmp->loadHighLodModel();
     }
-    return true;
 }
 
 void LLFloaterModelPreview::onUploadOptionChecked(LLUICtrl* ctrl)
@@ -505,7 +505,7 @@ void LLFloaterModelPreview::onClickCalculateBtn()
     gMeshRepo.uploadModel(mModelPreview->mUploadData, mModelPreview->mPreviewScale,
                           childGetValue("upload_textures").asBoolean(),
                           upload_skinweights, upload_joint_positions, lock_scale_if_joint_position,
-                          mUploadModelUrl, false,
+                          mUploadModelUrl, mDestinationFolderId, false,
                           getWholeModelFeeObserverHandle());
 
     toggleCalculateButton(false);
@@ -1660,7 +1660,7 @@ void LLFloaterModelPreview::onUpload(void* user_data)
     gMeshRepo.uploadModel(mp->mModelPreview->mUploadData, mp->mModelPreview->mPreviewScale,
                           mp->childGetValue("upload_textures").asBoolean(),
                           upload_skinweights, upload_joint_positions, lock_scale_if_joint_position,
-                          mp->mUploadModelUrl,
+                          mp->mUploadModelUrl, mp->mDestinationFolderId,
                           true, LLHandle<LLWholeModelFeeObserver>(), mp->getWholeModelUploadObserverHandle());
 }
 
diff --git a/indra/newview/llfloatermodelpreview.h b/indra/newview/llfloatermodelpreview.h
index 6adc084fe8..7b652a3613 100644
--- a/indra/newview/llfloatermodelpreview.h
+++ b/indra/newview/llfloatermodelpreview.h
@@ -73,7 +73,8 @@ public:
     /*virtual*/ void reshape(S32 width, S32 height, bool called_from_parent = true);
 
     void initModelPreview();
-    static bool showModelPreview();
+    void setUploadDestination(const LLUUID& dest_folder) { mDestinationFolderId = dest_folder; }
+    static void showModelPreview(const LLUUID& dest_folder = LLUUID::null);
 
     bool handleMouseDown(S32 x, S32 y, MASK mask);
     bool handleMouseUp(S32 x, S32 y, MASK mask);
@@ -164,9 +165,6 @@ protected:
 
     static void onPhysicsBrowse(LLUICtrl* ctrl, void* userdata);
     static void onPhysicsUseLOD(LLUICtrl* ctrl, void* userdata);
-    static void onPhysicsOptimize(LLUICtrl* ctrl, void* userdata);
-    static void onPhysicsDecomposeBack(LLUICtrl* ctrl, void* userdata);
-    static void onPhysicsSimplifyBack(LLUICtrl* ctrl, void* userdata);
 
     void            draw();
 
@@ -225,6 +223,7 @@ private:
 
     void createSmoothComboBox(LLComboBox* combo_box, float min, float max);
 
+    LLUUID mDestinationFolderId;
     LLButton* mUploadBtn;
     LLButton* mCalculateBtn;
     LLViewerTextEditor* mUploadLogText;
diff --git a/indra/newview/llfloaternamedesc.cpp b/indra/newview/llfloaternamedesc.cpp
index 01c50d89c5..569b41cfa9 100644
--- a/indra/newview/llfloaternamedesc.cpp
+++ b/indra/newview/llfloaternamedesc.cpp
@@ -62,11 +62,20 @@ const S32 PREVIEW_HPAD = PREVIEW_RESIZE_HANDLE_SIZE;
 //-----------------------------------------------------------------------------
 // LLFloaterNameDesc()
 //-----------------------------------------------------------------------------
-LLFloaterNameDesc::LLFloaterNameDesc(const LLSD& filename )
-    : LLFloater(filename),
-      mIsAudio(false)
+LLFloaterNameDesc::LLFloaterNameDesc(const LLSD& args)
+    : LLFloater(args)
+    , mIsAudio(false)
+    , mIsText(false)
 {
-    mFilenameAndPath = filename.asString();
+    if (args.isString())
+    {
+        mFilenameAndPath = args.asString();
+    }
+    else
+    {
+        mFilenameAndPath = args["filename"].asString();
+        mDestinationFolderId = args["dest"].asUUID();
+    }
     mFilename = gDirUtilp->getBaseFileName(mFilenameAndPath, false);
 }
 
@@ -203,7 +212,8 @@ void LLFloaterNameDesc::onBtnOK( )
             LLFloaterPerms::getNextOwnerPerms("Uploads"),
             LLFloaterPerms::getGroupPerms("Uploads"),
             LLFloaterPerms::getEveryonePerms("Uploads"),
-            expected_upload_cost));
+            expected_upload_cost,
+            mDestinationFolderId));
 
         upload_new_resource(uploadInfo, callback, nruserdata);
     }
@@ -230,8 +240,8 @@ void LLFloaterNameDesc::onBtnCancel()
 // LLFloaterSoundPreview()
 //-----------------------------------------------------------------------------
 
-LLFloaterSoundPreview::LLFloaterSoundPreview(const LLSD& filename )
-    : LLFloaterNameDesc(filename)
+LLFloaterSoundPreview::LLFloaterSoundPreview(const LLSD& args )
+    : LLFloaterNameDesc(args)
 {
     mIsAudio = true;
 }
@@ -251,8 +261,8 @@ bool LLFloaterSoundPreview::postBuild()
 // LLFloaterAnimPreview()
 //-----------------------------------------------------------------------------
 
-LLFloaterAnimPreview::LLFloaterAnimPreview(const LLSD& filename )
-    : LLFloaterNameDesc(filename)
+LLFloaterAnimPreview::LLFloaterAnimPreview(const LLSD& args )
+    : LLFloaterNameDesc(args)
 {
 }
 
@@ -270,8 +280,8 @@ bool LLFloaterAnimPreview::postBuild()
 // LLFloaterScriptPreview()
 //-----------------------------------------------------------------------------
 
-LLFloaterScriptPreview::LLFloaterScriptPreview(const LLSD& filename )
-    : LLFloaterNameDesc(filename)
+LLFloaterScriptPreview::LLFloaterScriptPreview(const LLSD& args )
+    : LLFloaterNameDesc(args)
 {
     mIsText = true;
 }
diff --git a/indra/newview/llfloaternamedesc.h b/indra/newview/llfloaternamedesc.h
index aa5571ccc0..a1b9bd3b95 100644
--- a/indra/newview/llfloaternamedesc.h
+++ b/indra/newview/llfloaternamedesc.h
@@ -39,7 +39,7 @@ class LLRadioGroup;
 class LLFloaterNameDesc : public LLFloater
 {
 public:
-    LLFloaterNameDesc(const LLSD& filename);
+    LLFloaterNameDesc(const LLSD& args);
     virtual ~LLFloaterNameDesc();
     bool postBuild() override;
 
@@ -58,26 +58,27 @@ protected:
 
     std::string     mFilenameAndPath;
     std::string     mFilename;
+    LLUUID          mDestinationFolderId;
 };
 
 class LLFloaterSoundPreview : public LLFloaterNameDesc
 {
 public:
-    LLFloaterSoundPreview(const LLSD& filename );
+    LLFloaterSoundPreview(const LLSD& args );
     bool postBuild() override;
 };
 
 class LLFloaterAnimPreview : public LLFloaterNameDesc
 {
 public:
-    LLFloaterAnimPreview(const LLSD& filename );
+    LLFloaterAnimPreview(const LLSD& args );
     bool postBuild() override;
 };
 
 class LLFloaterScriptPreview : public LLFloaterNameDesc
 {
 public:
-    LLFloaterScriptPreview(const LLSD& filename );
+    LLFloaterScriptPreview(const LLSD& args );
     bool postBuild() override;
 };
 
diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index b98329fd20..7b975a2154 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -4348,6 +4348,7 @@ void LLFolderBridge::buildContextMenuOptions(U32 flags, menuentry_vec_t&   items
         }
 
         disabled_items.push_back(std::string("New Folder"));
+        disabled_items.push_back(std::string("upload_options"));
         disabled_items.push_back(std::string("upload_def"));
         disabled_items.push_back(std::string("create_new"));
     }
@@ -4373,6 +4374,7 @@ void LLFolderBridge::buildContextMenuOptions(U32 flags, menuentry_vec_t&   items
     {
         disabled_items.push_back(std::string("New Folder"));
         disabled_items.push_back(std::string("New Listing Folder"));
+        disabled_items.push_back(std::string("upload_options"));
         disabled_items.push_back(std::string("upload_def"));
         disabled_items.push_back(std::string("create_new"));
     }
@@ -4439,6 +4441,7 @@ void LLFolderBridge::buildContextMenuOptions(U32 flags, menuentry_vec_t&   items
                 }
                 if (!isMarketplaceListingsFolder())
                 {
+                    items.push_back(std::string("upload_options"));
                     items.push_back(std::string("upload_def"));
                     items.push_back(std::string("create_new"));
                     items.push_back(std::string("New Script"));
@@ -6988,7 +6991,7 @@ void LLObjectBridge::performAction(LLInventoryModel* model, std::string action)
         else if(item && item->isFinished())
         {
             // must be in library. copy it to our inventory and put it on.
-            LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(rez_attachment_cb, _1, (LLViewerJointAttachment*)0));
+            LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(rez_attachment_cb, _1, (LLViewerJointAttachment*)0, true));
             copy_inventory_item(
                 gAgent.getID(),
                 item->getPermissions().getOwner(),
diff --git a/indra/newview/llinventorybridge.h b/indra/newview/llinventorybridge.h
index a19b5f8e59..1b80ac163c 100644
--- a/indra/newview/llinventorybridge.h
+++ b/indra/newview/llinventorybridge.h
@@ -823,7 +823,7 @@ private:
 
 void rez_attachment(LLViewerInventoryItem* item,
                     LLViewerJointAttachment* attachment,
-                    bool replace = false);
+                    bool replace);
 
 // Move items from an in-world object's "Contents" folder to a specified
 // folder in agent inventory.
diff --git a/indra/newview/llinventoryfunctions.cpp b/indra/newview/llinventoryfunctions.cpp
index 04ec0ae186..74e8961ee0 100644
--- a/indra/newview/llinventoryfunctions.cpp
+++ b/indra/newview/llinventoryfunctions.cpp
@@ -51,6 +51,7 @@
 #include "lldirpicker.h"
 #include "lldonotdisturbnotificationstorage.h"
 #include "llfloatermarketplacelistings.h"
+#include "llfloatermodelpreview.h"
 #include "llfloatersidepanelcontainer.h"
 #include "llfocusmgr.h"
 #include "llfolderview.h"
@@ -62,6 +63,7 @@
 #include "llinventorymodel.h"
 #include "llinventorypanel.h"
 #include "lllineeditor.h"
+#include "llmaterialeditor.h"
 #include "llmarketplacenotifications.h"
 #include "llmarketplacefunctions.h"
 #include "llmenugl.h"
@@ -86,6 +88,7 @@
 #include "llviewermessage.h"
 #include "llviewerfoldertype.h"
 #include "llviewerobjectlist.h"
+#include "llviewermenufile.h"
 #include "llviewerregion.h"
 #include "llviewerwindow.h"
 #include "llvoavatarself.h"
@@ -3719,6 +3722,55 @@ void LLInventoryAction::removeItemFromDND(LLFolderView* root)
     }
 }
 
+void LLInventoryAction::fileUploadLocation(const LLUUID& dest_id, const std::string& action)
+{
+    if (action == "def_model")
+    {
+        gSavedPerAccountSettings.setString("ModelUploadFolder", dest_id.asString());
+    }
+    else if (action == "def_texture")
+    {
+        gSavedPerAccountSettings.setString("TextureUploadFolder", dest_id.asString());
+    }
+    else if (action == "def_sound")
+    {
+        gSavedPerAccountSettings.setString("SoundUploadFolder", dest_id.asString());
+    }
+    else if (action == "def_animation")
+    {
+        gSavedPerAccountSettings.setString("AnimationUploadFolder", dest_id.asString());
+    }
+    else if (action == "def_pbr_material")
+    {
+        gSavedPerAccountSettings.setString("PBRUploadFolder", dest_id.asString());
+    }
+    else if (action == "upload_texture")
+    {
+        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2, dest_id), LLFilePicker::FFLOAD_IMAGE, false);
+    }
+    else if (action == "upload_sound")
+    {
+        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2, dest_id), LLFilePicker::FFLOAD_WAV, false);
+    }
+    else if (action == "upload_animation")
+    {
+        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2, dest_id), LLFilePicker::FFLOAD_ANIM, false);
+    }
+    else if (action == "upload_model")
+    {
+        LLFloaterModelPreview::showModelPreview(dest_id);
+    }
+    else if (action == "upload_pbr_material")
+    {
+        LLMaterialEditor::importMaterial(dest_id);
+    }
+    else if (action == "upload_bulk")
+    {
+        //LLFilePickerReplyThread::startPicker(boost::bind(&upload_bulk, _1, _2, dest_id), LLFilePicker::FFLOAD_ALL, true);
+        LLFilePickerReplyThread::startPicker(boost::bind(&upload_bulk, _1, _2, true), LLFilePicker::FFLOAD_ALL, true); // TODO: merge conflict; fix this
+    }
+}
+
 void LLInventoryAction::onItemsRemovalConfirmation(const LLSD& notification, const LLSD& response, LLHandle<LLFolderView> root)
 {
     S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
diff --git a/indra/newview/llinventoryfunctions.h b/indra/newview/llinventoryfunctions.h
index 7affd2daf2..9c1f72cb6b 100644
--- a/indra/newview/llinventoryfunctions.h
+++ b/indra/newview/llinventoryfunctions.h
@@ -620,6 +620,7 @@ struct LLInventoryAction
     static void callback_copySelected(const LLSD& notification, const LLSD& response, class LLInventoryModel* model, class LLFolderView* root, const std::string& action);
     static void onItemsRemovalConfirmation(const LLSD& notification, const LLSD& response, LLHandle<LLFolderView> root);
     static void removeItemFromDND(LLFolderView* root);
+    static void fileUploadLocation(const LLUUID& dest_id, const std::string& action);
 
     static void saveMultipleTextures(const std::vector<std::string>& filenames, std::set<LLFolderViewItem*> selected_items, LLInventoryModel* model);
 
diff --git a/indra/newview/llinventorygallerymenu.cpp b/indra/newview/llinventorygallerymenu.cpp
index 9941115e19..43ab9502d4 100644
--- a/indra/newview/llinventorygallerymenu.cpp
+++ b/indra/newview/llinventorygallerymenu.cpp
@@ -489,22 +489,7 @@ void LLInventoryGalleryContextMenu::onRename(const LLSD& notification, const LLS
 void LLInventoryGalleryContextMenu::fileUploadLocation(const LLSD& userdata)
 {
     const std::string param = userdata.asString();
-    if (param == "model")
-    {
-        gSavedPerAccountSettings.setString("ModelUploadFolder", mUUIDs.front().asString());
-    }
-    else if (param == "texture")
-    {
-        gSavedPerAccountSettings.setString("TextureUploadFolder", mUUIDs.front().asString());
-    }
-    else if (param == "sound")
-    {
-        gSavedPerAccountSettings.setString("SoundUploadFolder", mUUIDs.front().asString());
-    }
-    else if (param == "animation")
-    {
-        gSavedPerAccountSettings.setString("AnimationUploadFolder", mUUIDs.front().asString());
-    }
+    LLInventoryAction::fileUploadLocation(mUUIDs.front(), param);
 }
 
 bool LLInventoryGalleryContextMenu::canSetUploadLocation(const LLSD& userdata)
@@ -801,6 +786,7 @@ void LLInventoryGalleryContextMenu::updateMenuItemsVisibility(LLContextMenu* men
                 {
                     items.push_back(std::string("New Folder"));
                 }
+                items.push_back(std::string("upload_options"));
                 items.push_back(std::string("upload_def"));
             }
 
@@ -1013,6 +999,7 @@ void LLInventoryGalleryContextMenu::updateMenuItemsVisibility(LLContextMenu* men
             }
 
             disabled_items.push_back(std::string("New Folder"));
+            disabled_items.push_back(std::string("upload_options"));
             disabled_items.push_back(std::string("upload_def"));
             disabled_items.push_back(std::string("create_new"));
         }
diff --git a/indra/newview/llinventorypanel.cpp b/indra/newview/llinventorypanel.cpp
index 52c0afbe68..f374ed11e2 100644
--- a/indra/newview/llinventorypanel.cpp
+++ b/indra/newview/llinventorypanel.cpp
@@ -1788,26 +1788,8 @@ bool LLInventoryPanel::beginIMSession()
 void LLInventoryPanel::fileUploadLocation(const LLSD& userdata)
 {
     const std::string param = userdata.asString();
-    if (param == "model")
-    {
-        gSavedPerAccountSettings.setString("ModelUploadFolder", LLFolderBridge::sSelf.get()->getUUID().asString());
-    }
-    else if (param == "texture")
-    {
-        gSavedPerAccountSettings.setString("TextureUploadFolder", LLFolderBridge::sSelf.get()->getUUID().asString());
-    }
-    else if (param == "sound")
-    {
-        gSavedPerAccountSettings.setString("SoundUploadFolder", LLFolderBridge::sSelf.get()->getUUID().asString());
-    }
-    else if (param == "animation")
-    {
-        gSavedPerAccountSettings.setString("AnimationUploadFolder", LLFolderBridge::sSelf.get()->getUUID().asString());
-    }
-    else if (param == "pbr_material")
-    {
-        gSavedPerAccountSettings.setString("PBRUploadFolder", LLFolderBridge::sSelf.get()->getUUID().asString());
-    }
+    const LLUUID dest = LLFolderBridge::sSelf.get()->getUUID();
+    LLInventoryAction::fileUploadLocation(dest, param);
 }
 
 void LLInventoryPanel::openSingleViewInventory(LLUUID folder_id)
diff --git a/indra/newview/llmaterialeditor.cpp b/indra/newview/llmaterialeditor.cpp
index b5e494379d..6b337150a1 100644
--- a/indra/newview/llmaterialeditor.cpp
+++ b/indra/newview/llmaterialeditor.cpp
@@ -1415,7 +1415,7 @@ bool LLMaterialEditor::saveIfNeeded()
         }
 
         std::string res_desc = buildMaterialDescription();
-        createInventoryItem(buffer, mMaterialName, res_desc, local_permissions);
+        createInventoryItem(buffer, mMaterialName, res_desc, local_permissions, mUploadFolder);
 
         // We do not update floater with uploaded asset yet, so just close it.
         closeFloater();
@@ -1585,12 +1585,12 @@ private:
     std::string mNewName;
 };
 
-void LLMaterialEditor::createInventoryItem(const std::string &buffer, const std::string &name, const std::string &desc, const LLPermissions& permissions)
+void LLMaterialEditor::createInventoryItem(const std::string &buffer, const std::string &name, const std::string &desc, const LLPermissions& permissions, const LLUUID& upload_folder)
 {
     // gen a new uuid for this asset
     LLTransactionID tid;
     tid.generate();     // timestamp-based randomization + uniquification
-    LLUUID parent = gInventory.findUserDefinedCategoryUUIDForType(LLFolderType::FT_MATERIAL);
+    LLUUID parent = upload_folder.isNull() ? gInventory.findUserDefinedCategoryUUIDForType(LLFolderType::FT_MATERIAL) : upload_folder;
     const U8 subtype = NO_INV_SUBTYPE;  // TODO maybe use AT_SETTINGS and LLSettingsType::ST_MATERIAL ?
 
     LLPointer<LLObjectsMaterialItemCallback> cb = new LLObjectsMaterialItemCallback(permissions, buffer, name);
@@ -1904,7 +1904,11 @@ static void pack_textures(
     }
 }
 
-void LLMaterialEditor::uploadMaterialFromModel(const std::string& filename, tinygltf::Model& model_in, S32 index)
+void LLMaterialEditor::uploadMaterialFromModel(
+    const std::string& filename,
+    tinygltf::Model& model_in,
+    S32 index,
+    const LLUUID& dest)
 {
     if (index < 0 || !LLMaterialEditor::capabilitiesAvailable())
     {
@@ -1927,12 +1931,13 @@ void LLMaterialEditor::uploadMaterialFromModel(const std::string& filename, tiny
     // This uses 'filename' to make sure multiple bulk uploads work
     // instead of fighting for a single instance.
     LLMaterialEditor* me = (LLMaterialEditor*)LLFloaterReg::getInstance("material_editor", LLSD().with("filename", filename).with("index", LLSD::Integer(index)));
+    me->mUploadFolder = dest;
     me->loadMaterial(model_in, filename, index, false);
     me->saveIfNeeded();
 }
 
 
-void LLMaterialEditor::loadMaterialFromFile(const std::string& filename, S32 index)
+void LLMaterialEditor::loadMaterialFromFile(const std::string& filename, S32 index, const LLUUID& dest_folder)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_UI;
 
@@ -1978,6 +1983,7 @@ void LLMaterialEditor::loadMaterialFromFile(const std::string& filename, S32 ind
     }
 
     LLMaterialEditor* me = (LLMaterialEditor*)LLFloaterReg::getInstance("material_editor");
+    me->mUploadFolder = dest_folder;
 
     if (index >= 0)
     {
@@ -2428,10 +2434,11 @@ void LLMaterialEditor::onSaveObjectsMaterialAsMsgCallback(const LLSD& notificati
         return;
     }
 
-    createInventoryItem(str.str(), new_name, std::string(), permissions);
+    createInventoryItem(str.str(), new_name, std::string(), permissions, LLUUID::null);
 }
 
-const void upload_bulk(const std::vector<std::string>& filenames, LLFilePicker::ELoadFilter type, bool allow_2k);
+
+void upload_bulk(const std::vector<std::string>& filenames, LLFilePicker::ELoadFilter type, bool allow_2k);
 
 void LLMaterialEditor::loadMaterial(const tinygltf::Model &model_in, const std::string &filename, S32 index, bool open_floater)
 {
@@ -2845,10 +2852,10 @@ void LLMaterialEditor::setFromGltfMetaData(const std::string& filename, const ti
     }
 }
 
-void LLMaterialEditor::importMaterial()
+void LLMaterialEditor::importMaterial(const LLUUID dest_folder)
 {
     LLFilePickerReplyThread::startPicker(
-        [](const std::vector<std::string>& filenames, LLFilePicker::ELoadFilter load_filter, LLFilePicker::ESaveFilter save_filter)
+        [dest_folder](const std::vector<std::string>& filenames, LLFilePicker::ELoadFilter load_filter, LLFilePicker::ESaveFilter save_filter)
             {
                 if (LLAppViewer::instance()->quitRequested())
                 {
@@ -2856,7 +2863,7 @@ void LLMaterialEditor::importMaterial()
                 }
                 if (filenames.size() > 0)
                 {
-                    LLMaterialEditor::loadMaterialFromFile(filenames[0], -1);
+                    LLMaterialEditor::loadMaterialFromFile(filenames[0], -1, dest_folder);
                 }
             },
         LLFilePicker::FFLOAD_MATERIAL,
@@ -3539,6 +3546,7 @@ void LLMaterialEditor::saveTexture(LLImageJ2C* img, const std::string& name, con
         LLFloaterPerms::getGroupPerms("Uploads"),
         LLFloaterPerms::getEveryonePerms("Uploads"),
         expected_upload_cost,
+        mUploadFolder,
         false,
         cb,
         failed_upload));
diff --git a/indra/newview/llmaterialeditor.h b/indra/newview/llmaterialeditor.h
index 232467460e..1abdd7f84c 100644
--- a/indra/newview/llmaterialeditor.h
+++ b/indra/newview/llmaterialeditor.h
@@ -94,7 +94,7 @@ class LLMaterialEditor : public LLPreview, public LLVOInventoryListener
     void setFromGltfMetaData(const std::string& filename, const  tinygltf::Model& model, S32 index);
 
     // open a file dialog and select a gltf/glb file for import
-    static void importMaterial();
+    static void importMaterial(const LLUUID dest_folder = LLUUID::null);
 
     // for live preview, apply current material to currently selected object
     void applyToSelection();
@@ -105,8 +105,11 @@ class LLMaterialEditor : public LLPreview, public LLVOInventoryListener
     void loadAsset() override;
     // @index if -1 and file contains more than one material,
     // will promt to select specific one
-    static void uploadMaterialFromModel(const std::string& filename, tinygltf::Model& model, S32 index);
-    static void loadMaterialFromFile(const std::string& filename, S32 index = -1);
+    static void uploadMaterialFromModel(const std::string& filename,
+                                        tinygltf::Model& model,
+                                        S32 index,
+                                        const LLUUID& dest_folder_id = LLUUID::null);
+    static void loadMaterialFromFile(const std::string& filename, S32 index = -1, const LLUUID& dest_folder = LLUUID::null);
 
     void onSelectionChanged(); // live overrides selection changes
 
@@ -134,8 +137,6 @@ class LLMaterialEditor : public LLPreview, public LLVOInventoryListener
 
     void onClickSave();
 
-    void getGLTFModel(tinygltf::Model& model);
-
     std::string getEncodedAsset();
 
     bool decodeAsset(const std::vector<char>& buffer);
@@ -239,7 +240,7 @@ private:
     static void saveObjectsMaterialAs(const LLGLTFMaterial *render_material, const LLLocalGLTFMaterial *local_material, const LLPermissions& permissions, const LLUUID& object_id /* = LLUUID::null */, const LLUUID& item /* = LLUUID::null */);
 
     static bool updateInventoryItem(const std::string &buffer, const LLUUID &item_id, const LLUUID &task_id);
-    static void createInventoryItem(const std::string &buffer, const std::string &name, const std::string &desc, const LLPermissions& permissions);
+    static void createInventoryItem(const std::string &buffer, const std::string &name, const std::string &desc, const LLPermissions& permissions, const LLUUID& upload_folder);
 
     void setFromGLTFMaterial(LLGLTFMaterial* mat);
     bool setFromSelection();
@@ -249,6 +250,7 @@ private:
     friend class LLMaterialFilePicker;
 
     LLUUID mAssetID;
+    LLUUID mUploadFolder;
 
     LLTextureCtrl* mBaseColorTextureCtrl;
     LLTextureCtrl* mMetallicTextureCtrl;
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 5fc49b32ea..06a327c56a 100644
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -742,8 +742,12 @@ public:
 };
 
 
-void log_upload_error(LLCore::HttpStatus status, const LLSD& content,
-                      const char * const stage, const std::string & model_name)
+void log_upload_error(
+    LLCore::HttpStatus status,
+    const LLSD& content,
+    const char * const stage,
+    const std::string & model_name,
+    const std::vector<std::string> & texture_filenames)
 {
     // Add notification popup.
     LLSD args;
@@ -801,6 +805,20 @@ void log_upload_error(LLCore::HttpStatus status, const LLSD& content,
                 error_num++;
             }
         }
+
+        if (err.has("TextureIndex"))
+        {
+            S32 texture_index = err["TextureIndex"].asInteger();
+            if (texture_index < texture_filenames.size())
+            {
+                args["MESSAGE"] = message + "\n" + texture_filenames[texture_index];
+            }
+            else
+            {
+                llassert(false); // figure out why or how texture wasn't in the list
+                args["MESSAGE"] = message + llformat("\nTexture index: %d", texture_index);
+            }
+        }
     }
     else
     {
@@ -2158,7 +2176,7 @@ EMeshProcessingResult LLMeshRepoThread::physicsShapeReceived(const LLUUID& mesh_
 
 LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data, LLVector3& scale, bool upload_textures,
                                        bool upload_skin, bool upload_joints, bool lock_scale_if_joint_position,
-                                       const std::string & upload_url, bool do_upload,
+                                       const std::string & upload_url, LLUUID destination_folder_id, bool do_upload,
                                        LLHandle<LLWholeModelFeeObserver> fee_observer,
                                        LLHandle<LLWholeModelUploadObserver> upload_observer)
   : LLThread("mesh upload"),
@@ -2166,6 +2184,7 @@ LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data,
     mDiscarded(false),
     mDoUpload(do_upload),
     mWholeModelUploadURL(upload_url),
+    mDestinationFolderId(destination_folder_id),
     mFeeObserverHandle(fee_observer),
     mUploadObserverHandle(upload_observer)
 {
@@ -2283,13 +2302,21 @@ LLSD llsd_from_file(std::string filename)
     return result;
 }
 
-void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, bool include_textures)
+void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, std::vector<std::string>& texture_list_dest, bool include_textures)
 {
     LLSD result;
 
     LLSD res;
+    if (mDestinationFolderId.isNull())
+    {
     result["folder_id"] = gInventory.findUserDefinedCategoryUUIDForType(LLFolderType::FT_OBJECT);
     result["texture_folder_id"] = gInventory.findUserDefinedCategoryUUIDForType(LLFolderType::FT_TEXTURE);
+    }
+    else
+    {
+        result["folder_id"] = mDestinationFolderId;
+        result["texture_folder_id"] = mDestinationFolderId;
+    }
     result["asset_type"] = "mesh";
     result["inventory_type"] = "object";
     result["description"] = "(No Description)";
@@ -2432,7 +2459,7 @@ void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, bool include_textures)
                         LLPointer<LLImageJ2C> upload_file =
                             LLViewerTextureList::convertToUploadFile(texture->getSavedRawImage());
 
-                        if (!upload_file.isNull() && upload_file->getDataSize())
+                        if (!upload_file.isNull() && upload_file->getDataSize() && !upload_file->isBufferInvalid())
                         {
                             texture_str.write((const char*) upload_file->getData(), upload_file->getDataSize());
                         }
@@ -2446,6 +2473,8 @@ void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, bool include_textures)
                     texture_index[texture] = texture_num;
                     std::string str = texture_str.str();
                     res["texture_list"][texture_num] = LLSD::Binary(str.begin(),str.end());
+                    // store indexes for error handling;
+                    texture_list_dest.push_back(material.mDiffuseMapFilename);
                     texture_num++;
                 }
 
@@ -2710,7 +2739,8 @@ void LLMeshUploadThread::doWholeModelUpload()
         LL_DEBUGS(LOG_MESH) << "Hull generation completed." << LL_ENDL;
 
         mModelData = LLSD::emptyMap();
-        wholeModelToLLSD(mModelData, true);
+        mTextureFiles.clear();
+        wholeModelToLLSD(mModelData, mTextureFiles, true);
         LLSD body = mModelData["asset_resources"];
 
         dump_llsd_to_file(body, make_dump_name("whole_model_body_", dump_num));
@@ -2763,7 +2793,8 @@ void LLMeshUploadThread::requestWholeModelFee()
     generateHulls();
 
     mModelData = LLSD::emptyMap();
-    wholeModelToLLSD(mModelData, false);
+    mTextureFiles.clear();
+    wholeModelToLLSD(mModelData, mTextureFiles, false);
     dump_llsd_to_file(mModelData, make_dump_name("whole_model_fee_request_", dump_num));
     LLCore::HttpHandle handle = LLCoreHttpUtil::requestPostWithLLSD(mHttpRequest,
                                                                     mHttpPolicyClass,
@@ -2829,7 +2860,7 @@ void LLMeshUploadThread::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResp
             body["error"] = LLSD::emptyMap();
             body["error"]["message"] = reason;
             body["error"]["identifier"] = "NetworkError";       // from asset-upload/upload_util.py
-            log_upload_error(status, body, "upload", mModelData["name"].asString());
+            log_upload_error(status, body, "upload", mModelData["name"].asString(), mTextureFiles);
 
             if (observer)
             {
@@ -2864,7 +2895,7 @@ void LLMeshUploadThread::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResp
             else
             {
                 LL_WARNS(LOG_MESH) << "Upload failed.  Not in expected 'complete' state." << LL_ENDL;
-                log_upload_error(status, body, "upload", mModelData["name"].asString());
+                log_upload_error(status, body, "upload", mModelData["name"].asString(), mTextureFiles);
 
                 if (observer)
                 {
@@ -2889,7 +2920,7 @@ void LLMeshUploadThread::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResp
             body["error"] = LLSD::emptyMap();
             body["error"]["message"] = reason;
             body["error"]["identifier"] = "NetworkError";       // from asset-upload/upload_util.py
-            log_upload_error(status, body, "fee", mModelData["name"].asString());
+            log_upload_error(status, body, "fee", mModelData["name"].asString(), mTextureFiles);
 
             if (observer)
             {
@@ -2922,7 +2953,7 @@ void LLMeshUploadThread::onCompleted(LLCore::HttpHandle handle, LLCore::HttpResp
             else
             {
                 LL_WARNS(LOG_MESH) << "Fee request failed.  Not in expected 'upload' state." << LL_ENDL;
-                log_upload_error(status, body, "fee", mModelData["name"].asString());
+                log_upload_error(status, body, "fee", mModelData["name"].asString(), mTextureFiles);
 
                 if (observer)
                 {
@@ -4453,12 +4484,12 @@ bool LLMeshRepoThread::hasHeader(const LLUUID& mesh_id)
 
 void LLMeshRepository::uploadModel(std::vector<LLModelInstance>& data, LLVector3& scale, bool upload_textures,
                                    bool upload_skin, bool upload_joints, bool lock_scale_if_joint_position,
-                                   std::string upload_url, bool do_upload,
+                                   std::string upload_url, const LLUUID& destination_folder_id, bool do_upload,
                                    LLHandle<LLWholeModelFeeObserver> fee_observer, LLHandle<LLWholeModelUploadObserver> upload_observer)
 {
     LLMeshUploadThread* thread = new LLMeshUploadThread(data, scale, upload_textures,
                                                         upload_skin, upload_joints, lock_scale_if_joint_position,
-                                                        upload_url, do_upload, fee_observer, upload_observer);
+                                                        upload_url, destination_folder_id, do_upload, fee_observer, upload_observer);
     mUploadWaitList.push_back(thread);
 }
 
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index d864a07615..e13ad10b37 100644
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -510,10 +510,13 @@ public:
     LLHost          mHost;
     std::string     mWholeModelFeeCapability;
     std::string     mWholeModelUploadURL;
+    LLUUID          mDestinationFolderId;
 
     LLMeshUploadThread(instance_list& data, LLVector3& scale, bool upload_textures,
                        bool upload_skin, bool upload_joints, bool lock_scale_if_joint_position,
-                       const std::string & upload_url, bool do_upload = true,
+                       const std::string & upload_url,
+                       const LLUUID destination_folder_id = LLUUID::null,
+                       bool do_upload = true,
                        LLHandle<LLWholeModelFeeObserver> fee_observer = (LLHandle<LLWholeModelFeeObserver>()),
                        LLHandle<LLWholeModelUploadObserver> upload_observer = (LLHandle<LLWholeModelUploadObserver>()));
     ~LLMeshUploadThread();
@@ -529,7 +532,7 @@ public:
     void doWholeModelUpload();
     void requestWholeModelFee();
 
-    void wholeModelToLLSD(LLSD& dest, bool include_textures);
+    void wholeModelToLLSD(LLSD& dest, std::vector<std::string>& texture_list_dest, bool include_textures);
 
     void decomposeMeshMatrix(LLMatrix4& transformation,
                              LLVector3& result_pos,
@@ -550,6 +553,7 @@ private:
 
     bool mDoUpload; // if false only model data will be requested, otherwise the model will be uploaded
     LLSD mModelData;
+    std::vector<std::string> mTextureFiles;
 
     // llcorehttp library interface objects.
     LLCore::HttpStatus                  mHttpStatus;
@@ -674,7 +678,9 @@ public:
 
     void uploadModel(std::vector<LLModelInstance>& data, LLVector3& scale, bool upload_textures,
                      bool upload_skin, bool upload_joints, bool lock_scale_if_joint_position,
-                     std::string upload_url, bool do_upload = true,
+                     std::string upload_url,
+                     const LLUUID& destination_folder_id = LLUUID::null,
+                     bool do_upload = true,
                      LLHandle<LLWholeModelFeeObserver> fee_observer= (LLHandle<LLWholeModelFeeObserver>()),
                      LLHandle<LLWholeModelUploadObserver> upload_observer = (LLHandle<LLWholeModelUploadObserver>()));
 
diff --git a/indra/newview/llsnapshotlivepreview.cpp b/indra/newview/llsnapshotlivepreview.cpp
index ea95d71b27..7d5f380886 100644
--- a/indra/newview/llsnapshotlivepreview.cpp
+++ b/indra/newview/llsnapshotlivepreview.cpp
@@ -1066,7 +1066,7 @@ void LLSnapshotLivePreview::saveTexture(bool outfit_snapshot, std::string name)
             tid, LLAssetType::AT_TEXTURE, res_name, res_desc, 0,
             folder_type, inv_type,
             PERM_ALL, LLFloaterPerms::getGroupPerms("Uploads"), LLFloaterPerms::getEveryonePerms("Uploads"),
-            expected_upload_cost, !outfit_snapshot));
+            expected_upload_cost, LLUUID::null, !outfit_snapshot));
 
         upload_new_resource(assetUploadInfo);
 
diff --git a/indra/newview/lltooldraganddrop.cpp b/indra/newview/lltooldraganddrop.cpp
index 6d0704a469..58c01269f7 100644
--- a/indra/newview/lltooldraganddrop.cpp
+++ b/indra/newview/lltooldraganddrop.cpp
@@ -2145,7 +2145,7 @@ EAcceptance LLToolDragAndDrop::dad3dRezAttachmentFromInv(
     {
         if(mSource == SOURCE_LIBRARY)
         {
-            LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(rez_attachment_cb, _1, (LLViewerJointAttachment*)0));
+            LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(rez_attachment_cb, _1, (LLViewerJointAttachment*)0, false));
             copy_inventory_item(
                 gAgent.getID(),
                 item->getPermissions().getOwner(),
@@ -2156,7 +2156,7 @@ EAcceptance LLToolDragAndDrop::dad3dRezAttachmentFromInv(
         }
         else
         {
-            rez_attachment(item, 0);
+            rez_attachment(item, 0, false);
         }
     }
     return ACCEPT_YES_SINGLE;
diff --git a/indra/newview/llviewerassetupload.cpp b/indra/newview/llviewerassetupload.cpp
index 7ef2c8d697..7d5386110d 100644
--- a/indra/newview/llviewerassetupload.cpp
+++ b/indra/newview/llviewerassetupload.cpp
@@ -62,7 +62,8 @@ LLResourceUploadInfo::LLResourceUploadInfo(LLTransactionID transactId,
         LLAssetType::EType assetType, std::string name, std::string description,
         S32 compressionInfo, LLFolderType::EType destinationType,
         LLInventoryType::EType inventoryType, U32 nextOWnerPerms,
-        U32 groupPerms, U32 everyonePerms, S32 expectedCost, bool showInventory) :
+        U32 groupPerms, U32 everyonePerms, S32 expectedCost,
+        const LLUUID& destFolderId, bool showInventory) :
     mTransactionId(transactId),
     mAssetType(assetType),
     mName(name),
@@ -75,7 +76,7 @@ LLResourceUploadInfo::LLResourceUploadInfo(LLTransactionID transactId,
     mEveryonePerms(everyonePerms),
     mExpectedUploadCost(expectedCost),
     mShowInventory(showInventory),
-    mFolderId(LLUUID::null),
+    mFolderId(destFolderId),
     mItemId(LLUUID::null),
     mAssetId(LLAssetID::null)
 { }
@@ -84,7 +85,8 @@ LLResourceUploadInfo::LLResourceUploadInfo(LLTransactionID transactId,
 LLResourceUploadInfo::LLResourceUploadInfo(std::string name,
         std::string description, S32 compressionInfo,
         LLFolderType::EType destinationType, LLInventoryType::EType inventoryType,
-        U32 nextOWnerPerms, U32 groupPerms, U32 everyonePerms, S32 expectedCost, bool showInventory) :
+        U32 nextOWnerPerms, U32 groupPerms, U32 everyonePerms, S32 expectedCost,
+        const LLUUID& destFolderId, bool showInventory) :
     mName(name),
     mDescription(description),
     mCompressionInfo(compressionInfo),
@@ -97,7 +99,7 @@ LLResourceUploadInfo::LLResourceUploadInfo(std::string name,
     mShowInventory(showInventory),
     mTransactionId(),
     mAssetType(LLAssetType::AT_NONE),
-    mFolderId(LLUUID::null),
+    mFolderId(destFolderId),
     mItemId(LLUUID::null),
     mAssetId(LLAssetID::null)
 {
@@ -306,10 +308,10 @@ void LLResourceUploadInfo::assignDefaults()
     }
     else
     {
-    mFolderId = gInventory.findUserDefinedCategoryUUIDForType(
-        (mDestinationFolderType == LLFolderType::FT_NONE) ?
-        (LLFolderType::EType)mAssetType : mDestinationFolderType);
-}
+        mFolderId = gInventory.findUserDefinedCategoryUUIDForType(
+            (mDestinationFolderType == LLFolderType::FT_NONE) ?
+            (LLFolderType::EType)mAssetType : mDestinationFolderType);
+    }
 }
 
 std::string LLResourceUploadInfo::getDisplayName() const
@@ -366,10 +368,12 @@ LLNewFileResourceUploadInfo::LLNewFileResourceUploadInfo(
     U32 groupPerms,
     U32 everyonePerms,
     S32 expectedCost,
+    const LLUUID& destFolderId,
     bool show_inventory) :
     LLResourceUploadInfo(name, description, compressionInfo,
     destinationType, inventoryType,
-    nextOWnerPerms, groupPerms, everyonePerms, expectedCost, show_inventory),
+    nextOWnerPerms, groupPerms, everyonePerms, expectedCost,
+    destFolderId, show_inventory),
     mFileName(fileName),
     mMaxImageSize(LLViewerFetchedTexture::MAX_IMAGE_SIZE_DEFAULT)
 {
@@ -580,12 +584,13 @@ LLNewBufferedResourceUploadInfo::LLNewBufferedResourceUploadInfo(
     U32 groupPerms,
     U32 everyonePerms,
     S32 expectedCost,
+    const LLUUID& destFolderId,
     bool show_inventory,
     uploadFinish_f finish,
     uploadFailure_f failure)
     : LLResourceUploadInfo(name, description, compressionInfo,
         destinationType, inventoryType,
-        nextOWnerPerms, groupPerms, everyonePerms, expectedCost, show_inventory)
+        nextOWnerPerms, groupPerms, everyonePerms, expectedCost, destFolderId, show_inventory)
     , mBuffer(buffer)
     , mFinishFn(finish)
     , mFailureFn(failure)
diff --git a/indra/newview/llviewerassetupload.h b/indra/newview/llviewerassetupload.h
index 365436ede0..c627e9dbb8 100644
--- a/indra/newview/llviewerassetupload.h
+++ b/indra/newview/llviewerassetupload.h
@@ -54,6 +54,7 @@ public:
         U32 groupPerms,
         U32 everyonePerms,
         S32 expectedCost,
+        const LLUUID &destFolderId = LLUUID::null,
         bool showInventory = true);
 
     virtual ~LLResourceUploadInfo()
@@ -104,6 +105,7 @@ protected:
         U32 groupPerms,
         U32 everyonePerms,
         S32 expectedCost,
+        const LLUUID& destFolderId = LLUUID::null,
         bool showInventory = true);
 
     LLResourceUploadInfo(
@@ -155,6 +157,7 @@ public:
         U32 groupPerms,
         U32 everyonePerms,
         S32 expectedCost,
+        const LLUUID &destFolderId = LLUUID::null,
         bool show_inventory = true);
 
     virtual LLSD        prepareUpload();
@@ -193,6 +196,7 @@ public:
         U32 groupPerms,
         U32 everyonePerms,
         S32 expectedCost,
+        const LLUUID& destFolderId, // use null for default
         bool show_inventory,
         uploadFinish_f finish,
         uploadFailure_f failure);
@@ -219,6 +223,7 @@ public:
     typedef std::function<void(LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response)> taskUploadFinish_f;
     typedef std::function<bool(LLUUID itemId, LLUUID taskId, LLSD response, std::string reason)> uploadFailed_f;
 
+    // destFolderId is the folder to put the new item in, leave null for default
     LLBufferedAssetUploadInfo(LLUUID itemId, LLAssetType::EType assetType, std::string buffer, invnUploadFinish_f finish, uploadFailed_f failed);
     LLBufferedAssetUploadInfo(LLUUID itemId, LLPointer<LLImageFormatted> image, invnUploadFinish_f finish);
     LLBufferedAssetUploadInfo(LLUUID taskId, LLUUID itemId, LLAssetType::EType assetType, std::string buffer, taskUploadFinish_f finish, uploadFailed_f failed);
diff --git a/indra/newview/llviewerattachmenu.cpp b/indra/newview/llviewerattachmenu.cpp
index f2557e299c..9828ab1fdf 100644
--- a/indra/newview/llviewerattachmenu.cpp
+++ b/indra/newview/llviewerattachmenu.cpp
@@ -116,12 +116,12 @@ void LLViewerAttachMenu::attachObjects(const uuid_vec_t& items, const std::strin
         LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getLinkedItem(id);
         if(item && gInventory.isObjectDescendentOf(id, gInventory.getRootFolderID()))
         {
-            rez_attachment(item, attachmentp); // don't replace if called from an "Attach To..." menu
+            rez_attachment(item, attachmentp, false); // don't replace if called from an "Attach To..." menu
         }
         else if(item && item->isFinished())
         {
             // must be in library. copy it to our inventory and put it on.
-            LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(rez_attachment_cb, _1, attachmentp));
+            LLPointer<LLInventoryCallback> cb = new LLBoostFuncInventoryCallback(boost::bind(rez_attachment_cb, _1, attachmentp, false));
             copy_inventory_item(gAgent.getID(),
                                 item->getPermissions().getOwner(),
                                 item->getUUID(),
diff --git a/indra/newview/llviewercamera.cpp b/indra/newview/llviewercamera.cpp
index aa43b2dbad..80c8d5045a 100644
--- a/indra/newview/llviewercamera.cpp
+++ b/indra/newview/llviewercamera.cpp
@@ -81,18 +81,16 @@ LLViewerCamera::~LLViewerCamera()
     mCameraAngleChangedSignal.disconnect();
 }
 
-void LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVector3 &up_direction, const LLVector3 &point_of_interest)
+bool LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVector3 &up_direction, const LLVector3 &point_of_interest)
 {
     // do not update if avatar didn't move
     if (!LLViewerJoystick::getInstance()->getCameraNeedsUpdate())
     {
-        return;
+        return true;
     }
 
-    LLVector3 last_position;
-    LLVector3 last_axis;
-    last_position = getOrigin();
-    last_axis     = getAtAxis();
+    LLVector3 last_position = getOrigin();
+    LLVector3 last_axis = getAtAxis();
 
     mLastPointOfInterest = point_of_interest;
 
@@ -102,30 +100,49 @@ void 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;
         }
     }
 
-    setOriginAndLookAt(origin, up_direction, point_of_interest);
+    LLVector3 at(point_of_interest - origin);
+    at.normalize();
+    if (at.isNull() || !at.isFinite())
+        return false;
+
+    LLVector3 left(up_direction % at);
+    left.normalize();
+    if (left.isNull() || !left.isFinite())
+        return false;
+
+    LLVector3 up = at % left;
+    up.normalize();
+    if (up.isNull() || !up.isFinite())
+        return false;
+
+    setOrigin(origin);
+    setAxes(at, left, up);
 
-    mVelocityDir = origin - last_position ;
-    F32 dpos = mVelocityDir.normVec() ;
+    mVelocityDir = origin - last_position;
+    F32 dpos = mVelocityDir.normVec();
     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);
@@ -138,14 +155,15 @@ void LLViewerCamera::updateCameraLocation(const LLVector3 &center, const LLVecto
     // update pixel meter ratio using default fov, not modified one
     mPixelMeterRatio = (F32)(getViewHeightInPixels()/ (2.f*tanf(mCameraFOVDefault*0.5f)));
     // update screen pixel area
-    mScreenPixelArea =(S32)((F32)getViewHeightInPixels() * ((F32)getViewHeightInPixels() * getAspect()));
+    mScreenPixelArea = (S32)((F32)getViewHeightInPixels() * ((F32)getViewHeightInPixels() * getAspect()));
+
+    return true;
 }
 
 const LLMatrix4 &LLViewerCamera::getProjection() const
 {
     calcProjection(getFar());
     return mProjectionMatrix;
-
 }
 
 const LLMatrix4 &LLViewerCamera::getModelview() const
@@ -158,19 +176,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;
 }
 
@@ -231,9 +248,9 @@ void LLViewerCamera::updateFrustumPlanes(LLCamera& camera, bool ortho, bool zfli
 
         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
@@ -249,7 +266,7 @@ void LLViewerCamera::updateFrustumPlanes(LLCamera& camera, bool ortho, bool zfli
 
         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;
@@ -261,7 +278,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();
             }
         }
     }
@@ -357,7 +374,7 @@ void LLViewerCamera::setPerspective(bool for_selection,
 
     glm::mat4 modelview(glm::make_mat4((GLfloat*) OGL_TO_CFR_ROTATION));
 
-    GLfloat         ogl_matrix[16];
+    GLfloat ogl_matrix[16];
 
     getOpenGLTransform(ogl_matrix);
 
diff --git a/indra/newview/llviewercamera.h b/indra/newview/llviewercamera.h
index a204b85d88..c1c73dc0c6 100644
--- a/indra/newview/llviewercamera.h
+++ b/indra/newview/llviewercamera.h
@@ -61,7 +61,7 @@ public:
 
     static eCameraID sCurCameraID;
 
-    void updateCameraLocation(const LLVector3 &center,
+    bool updateCameraLocation(const LLVector3 &center,
                                 const LLVector3 &up_direction,
                                 const LLVector3 &point_of_interest);
 
@@ -77,12 +77,12 @@ public:
     bool projectPosAgentToScreen(const LLVector3 &pos_agent, LLCoordGL &out_point, const bool clamp = true) const;
     bool projectPosAgentToScreenEdge(const LLVector3 &pos_agent, LLCoordGL &out_point) const;
 
-    LLVector3 getVelocityDir() const {return mVelocityDir;}
-    static LLTrace::CountStatHandle<>* getVelocityStat()           {return &sVelocityStat; }
-    static LLTrace::CountStatHandle<>* getAngularVelocityStat()  {return &sAngularVelocityStat; }
-    F32     getCosHalfFov() {return mCosHalfCameraFOV;}
-    F32     getAverageSpeed() {return mAverageSpeed ;}
-    F32     getAverageAngularSpeed() {return mAverageAngularSpeed;}
+    LLVector3 getVelocityDir() const { return mVelocityDir; }
+    static LLTrace::CountStatHandle<>* getVelocityStat() { return &sVelocityStat; }
+    static LLTrace::CountStatHandle<>* getAngularVelocityStat() { return &sAngularVelocityStat; }
+    F32     getCosHalfFov() const { return mCosHalfCameraFOV; }
+    F32     getAverageSpeed() const { return mAverageSpeed; }
+    F32     getAverageAngularSpeed() const { return mAverageAngularSpeed; }
 
     void getPixelVectors(const LLVector3 &pos_agent, LLVector3 &up, LLVector3 &right);
     LLVector3 roundToPixel(const LLVector3 &pos_agent);
@@ -90,21 +90,21 @@ public:
     // Sets the current matrix
     /* virtual */ void setView(F32 vertical_fov_rads); // NOTE: broadcasts to simulator
     void setViewNoBroadcast(F32 vertical_fov_rads);  // set FOV without broadcasting to simulator (for temporary local cameras)
-    void setDefaultFOV(F32 fov) ;
-    F32 getDefaultFOV() { return mCameraFOVDefault; }
+    void setDefaultFOV(F32 fov);
+    F32 getDefaultFOV() const { return mCameraFOVDefault; }
 
     bool isDefaultFOVChanged();
 
     bool cameraUnderWater() const;
     bool areVertsVisible(LLViewerObject* volumep, bool all_verts);
 
-    const LLVector3 &getPointOfInterest() { return mLastPointOfInterest; }
+    const LLVector3& getPointOfInterest() const { return mLastPointOfInterest; }
     F32 getPixelMeterRatio() const              { return mPixelMeterRatio; }
     S32 getScreenPixelArea() const              { return mScreenPixelArea; }
 
     void setZoomParameters(F32 factor, S16 subregion) { mZoomFactor = factor; mZoomSubregion = subregion; }
-    F32 getZoomFactor() { return mZoomFactor; }
-    S16 getZoomSubRegion() { return mZoomSubregion; }
+    F32 getZoomFactor() const { return mZoomFactor; }
+    S16 getZoomSubRegion() const { return mZoomSubregion; }
 
 protected:
     void calcProjection(const F32 far_distance) const;
diff --git a/indra/newview/llviewerinventory.cpp b/indra/newview/llviewerinventory.cpp
index 418071f6aa..01b97a6154 100644
--- a/indra/newview/llviewerinventory.cpp
+++ b/indra/newview/llviewerinventory.cpp
@@ -969,7 +969,7 @@ void LLInventoryCallbackManager::fire(U32 callback_id, const LLUUID& item_id)
     }
 }
 
-void rez_attachment_cb(const LLUUID& inv_item, LLViewerJointAttachment *attachmentp)
+void rez_attachment_cb(const LLUUID& inv_item, LLViewerJointAttachment *attachmentp, bool replace)
 {
     if (inv_item.isNull())
         return;
@@ -977,7 +977,7 @@ void rez_attachment_cb(const LLUUID& inv_item, LLViewerJointAttachment *attachme
     LLViewerInventoryItem *item = gInventory.getItem(inv_item);
     if (item)
     {
-        rez_attachment(item, attachmentp);
+        rez_attachment(item, attachmentp, replace);
     }
 }
 
diff --git a/indra/newview/llviewerinventory.h b/indra/newview/llviewerinventory.h
index 21a6606253..18daa368d9 100644
--- a/indra/newview/llviewerinventory.h
+++ b/indra/newview/llviewerinventory.h
@@ -264,7 +264,7 @@ public:
 
 class LLViewerJointAttachment;
 
-void rez_attachment_cb(const LLUUID& inv_item, LLViewerJointAttachment *attachmentp);
+void rez_attachment_cb(const LLUUID& inv_item, LLViewerJointAttachment *attachmentp, bool replace);
 
 void activate_gesture_cb(const LLUUID& inv_item);
 
diff --git a/indra/newview/llviewermenufile.cpp b/indra/newview/llviewermenufile.cpp
index 2a871a24af..6c8de6590b 100644
--- a/indra/newview/llviewermenufile.cpp
+++ b/indra/newview/llviewermenufile.cpp
@@ -478,13 +478,19 @@ const bool check_file_extension(const std::string& filename, LLFilePicker::ELoad
     return true;
 }
 
-const void upload_single_file(const std::vector<std::string>& filenames, LLFilePicker::ELoadFilter type)
+void upload_single_file(
+    const std::vector<std::string>& filenames,
+    LLFilePicker::ELoadFilter type,
+    const LLUUID& dest)
 {
     std::string filename = filenames[0];
     if (!check_file_extension(filename, type)) return;
 
     if (!filename.empty())
     {
+        LLSD args;
+        args["filename"] = filename;
+        args["dest"] = dest;
         if (type == LLFilePicker::FFLOAD_WAV)
         {
             // pre-qualify wavs to make sure the format is acceptable
@@ -499,12 +505,12 @@ const void upload_single_file(const std::vector<std::string>& filenames, LLFileP
             }
             else
             {
-                LLFloaterReg::showInstance("upload_sound", LLSD(filename));
+                LLFloaterReg::showInstance("upload_sound", args);
             }
         }
         if (type == LLFilePicker::FFLOAD_IMAGE)
         {
-            LLFloaterReg::showInstance("upload_image", LLSD(filename));
+            LLFloaterReg::showInstance("upload_image", args);
         }
         if (type == LLFilePicker::FFLOAD_ANIM)
         {
@@ -512,11 +518,11 @@ const void upload_single_file(const std::vector<std::string>& filenames, LLFileP
             LLStringUtil::toLower(filename_lc);
             if (filename_lc.rfind(".anim") != std::string::npos)
             {
-                LLFloaterReg::showInstance("upload_anim_anim", LLSD(filename));
+                LLFloaterReg::showInstance("upload_anim_anim", args);
             }
             else
             {
-                LLFloaterReg::showInstance("upload_anim_bvh", LLSD(filename));
+                LLFloaterReg::showInstance("upload_anim_bvh", args);
             }
         }
     }
@@ -754,7 +760,7 @@ const void upload_bulk(const std::vector<std::string>& filtered_filenames, bool
 
 }
 
-const void upload_bulk(const std::vector<std::string>& filenames, LLFilePicker::ELoadFilter type, bool allow_2k)
+void upload_bulk(const std::vector<std::string>& filenames, LLFilePicker::ELoadFilter type, bool allow_2k)
 {
     // TODO:
     // Check user balance for entire cost
@@ -787,7 +793,7 @@ class LLFileUploadImage : public view_listener_t
         {
             gAgentCamera.changeCameraToDefault();
         }
-        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2), LLFilePicker::FFLOAD_IMAGE, false);
+        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2, LLUUID::null), LLFilePicker::FFLOAD_IMAGE, false);
         return true;
     }
 };
@@ -818,7 +824,7 @@ class LLFileUploadSound : public view_listener_t
         {
             gAgentCamera.changeCameraToDefault();
         }
-        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2), LLFilePicker::FFLOAD_WAV, false);
+        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2, LLUUID::null), LLFilePicker::FFLOAD_WAV, false);
         return true;
     }
 };
@@ -831,7 +837,7 @@ class LLFileUploadAnim : public view_listener_t
         {
             gAgentCamera.changeCameraToDefault();
         }
-        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2), LLFilePicker::FFLOAD_ANIM, false);
+        LLFilePickerReplyThread::startPicker(boost::bind(&upload_single_file, _1, _2, LLUUID::null), LLFilePicker::FFLOAD_ANIM, false);
         return true;
     }
 };
@@ -844,7 +850,9 @@ class LLFileUploadBulk : public view_listener_t
         {
             gAgentCamera.changeCameraToDefault();
         }
+
         LLFilePickerReplyThread::startPicker(boost::bind(&upload_bulk, _1, _2, true), LLFilePicker::FFLOAD_ALL, true);
+
         return true;
     }
 };
@@ -1138,7 +1146,7 @@ LLUUID upload_new_resource(
         name, desc, compression_info,
         destination_folder_type, inv_type,
         next_owner_perms, group_perms, everyone_perms,
-        expected_upload_cost, show_inventory));
+        expected_upload_cost, LLUUID::null, show_inventory));
     upload_new_resource(uploadInfo, callback, userdata);
 
     return LLUUID::null;
diff --git a/indra/newview/llviewermenufile.h b/indra/newview/llviewermenufile.h
index 6b628f07de..e222c6cfb0 100644
--- a/indra/newview/llviewermenufile.h
+++ b/indra/newview/llviewermenufile.h
@@ -76,6 +76,16 @@ void do_bulk_upload(std::vector<std::string> filenames, bool allow_2k);
 
 void close_all_windows();
 
+void upload_single_file(
+    const std::vector<std::string>& filenames,
+    LLFilePicker::ELoadFilter type,
+    const LLUUID& dest);
+
+void upload_bulk(
+    const std::vector<std::string>& filenames,
+    LLFilePicker::ELoadFilter type,
+    bool allow_2k);
+
 //consider moving all file pickers below to more suitable place
 class LLFilePickerThread : public LLThread
 { //multi-threaded file picker (runs system specific file picker in background and calls "notify" from main thread)
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index b0a0314e85..cd01f870bf 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -3008,7 +3008,8 @@ bool LLViewerWindow::handleKey(KEY key, MASK mask)
     {
         if ((focusedFloaterName == "nearby_chat") || (focusedFloaterName == "im_container") || (focusedFloaterName == "impanel"))
         {
-            if (gSavedSettings.getBOOL("ArrowKeysAlwaysMove"))
+            LLCachedControl<bool> key_move(gSavedSettings, "ArrowKeysAlwaysMove");
+            if (key_move())
             {
                 // let Control-Up and Control-Down through for chat line history,
                 if (!(key == KEY_UP && mask == MASK_CONTROL)
@@ -3022,10 +3023,9 @@ bool LLViewerWindow::handleKey(KEY key, MASK mask)
                     case KEY_RIGHT:
                     case KEY_UP:
                     case KEY_DOWN:
-                    case KEY_PAGE_UP:
-                    case KEY_PAGE_DOWN:
-                    case KEY_HOME:
-                    case KEY_END:
+                    case KEY_PAGE_UP: //jump
+                    case KEY_PAGE_DOWN: // down
+                    case KEY_HOME: // toggle fly
                         // when chatbar is empty or ArrowKeysAlwaysMove set,
                         // pass arrow keys on to avatar...
                         return false;
diff --git a/indra/newview/llvoicechannel.cpp b/indra/newview/llvoicechannel.cpp
index 55769f567b..b60337ee14 100644
--- a/indra/newview/llvoicechannel.cpp
+++ b/indra/newview/llvoicechannel.cpp
@@ -370,6 +370,12 @@ void LLVoiceChannel::resume()
         {
             if (sSuspendedVoiceChannel)
             {
+                if (sSuspendedVoiceChannel->callStarted())
+                {
+                    // should have channel data already, restart
+                    sSuspendedVoiceChannel->setState(STATE_READY);
+                }
+                // won't do anything if call is already started
                 sSuspendedVoiceChannel->activate();
             }
             else
diff --git a/indra/newview/skins/default/xui/en/floater_voice_chat_volume.xml b/indra/newview/skins/default/xui/en/floater_voice_chat_volume.xml
index 51809793d3..c0d260ef59 100644
--- a/indra/newview/skins/default/xui/en/floater_voice_chat_volume.xml
+++ b/indra/newview/skins/default/xui/en/floater_voice_chat_volume.xml
@@ -22,7 +22,7 @@
 		increment="0.025"
 		initial_value="0.5"
 		label="Voice Chat"
-		label_width="50"
+		label_width="60"
 		layout="topleft"
 		left="15"
 		top="50"
diff --git a/indra/newview/skins/default/xui/en/menu_gallery_inventory.xml b/indra/newview/skins/default/xui/en/menu_gallery_inventory.xml
index d9919661f3..0d4d4158a3 100644
--- a/indra/newview/skins/default/xui/en/menu_gallery_inventory.xml
+++ b/indra/newview/skins/default/xui/en/menu_gallery_inventory.xml
@@ -747,6 +747,136 @@
        function="Inventory.CanSetUploadLocation" />
     </menu_item_call>
   </menu>
+  <menu
+   label="Upload to folder"
+   layout="topleft"
+   name="upload_options">
+    <menu_item_call
+     label="Image..."
+     layout="topleft"
+     name="Upload Image">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_texture" />
+       <menu_item_call.on_enable
+        function="File.EnableUpload" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Upload Image,texture" />
+    </menu_item_call>
+    <menu_item_call
+     label="Sound (L$[COST])..."
+     layout="topleft"
+     name="Upload Sound">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_sound" />
+       <menu_item_call.on_enable
+        function="File.EnableUpload" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Upload Sound,sound" />
+    </menu_item_call>
+    <menu_item_call
+     label="Animation (L$[COST])..."
+     layout="topleft"
+     name="Upload Animation">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_animation" />
+       <menu_item_call.on_enable
+        function="File.EnableUpload" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Upload Animation,animation" />
+    </menu_item_call>
+    <menu_item_call
+     label="Model..."
+     layout="topleft"
+     name="Upload Model">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_model" />
+       <menu_item_call.on_enable
+        function="File.EnableUploadModel" />
+       <menu_item_call.on_visible
+        function="File.VisibleUploadModel"/>
+    </menu_item_call>
+    <menu_item_call
+     label="Material..."
+     layout="topleft"
+     name="Upload Material">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_pbr_material" />
+       <menu_item_call.on_enable
+        function="File.EnableUploadMaterial" />
+    </menu_item_call>
+    <menu_item_call
+     label="Bulk..."
+     layout="topleft"
+     name="Bulk Upload">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_bulk" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Bulk Upload,texture" />
+    </menu_item_call>
+  </menu>
+  <menu
+   label="Use as default for"
+   layout="topleft"
+   name="upload_def">
+    <menu_item_call
+     label="Image uploads"
+     layout="topleft"
+     name="Image uploads">
+      <menu_item_call.on_click
+       function="Inventory.FileUploadLocation"
+        parameter="def_texture" />
+      <menu_item_call.on_visible
+       function="Inventory.CanSetUploadLocation" />
+    </menu_item_call>
+    <menu_item_call
+     label="Sound uploads"
+     layout="topleft"
+     name="Sound uploads">
+      <menu_item_call.on_click
+       function="Inventory.FileUploadLocation"
+       parameter="def_sound" />
+      <menu_item_call.on_visible
+       function="Inventory.CanSetUploadLocation" />
+    </menu_item_call>
+    <menu_item_call
+     label="Animation uploads"
+     layout="topleft"
+     name="Animation uploads">
+      <menu_item_call.on_click
+       function="Inventory.FileUploadLocation"
+       parameter="def_animation" />
+      <menu_item_call.on_visible
+       function="Inventory.CanSetUploadLocation" />
+    </menu_item_call>
+    <menu_item_call
+     label="Model uploads"
+     layout="topleft"
+     name="Model uploads">
+      <menu_item_call.on_click
+       function="Inventory.FileUploadLocation"
+       parameter="def_model" />
+      <menu_item_call.on_visible
+       function="Inventory.CanSetUploadLocation" />
+    </menu_item_call>
+    <menu_item_call
+     label="PBR material uploads"
+     layout="topleft"
+     name="PBR uploads">
+      <menu_item_call.on_click
+       function="Inventory.FileUploadLocation"
+       parameter="def_pbr_material" />
+    </menu_item_call>
+  </menu>
 	<menu_item_separator
 	 layout="topleft"
 	 name="Marketplace Separator" />
diff --git a/indra/newview/skins/default/xui/en/menu_inventory.xml b/indra/newview/skins/default/xui/en/menu_inventory.xml
index ed2b8ea7bd..1558343216 100644
--- a/indra/newview/skins/default/xui/en/menu_inventory.xml
+++ b/indra/newview/skins/default/xui/en/menu_inventory.xml
@@ -968,6 +968,83 @@
      parameter="remove_from_favorites" />
   </menu_item_call>
   <menu
+   label="Upload to folder"
+   layout="topleft"
+   name="upload_options">
+    <menu_item_call
+     label="Image..."
+     layout="topleft"
+     name="Upload Image">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_texture" />
+       <menu_item_call.on_enable
+        function="File.EnableUpload" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Upload Image,texture" />
+    </menu_item_call>
+    <menu_item_call
+     label="Sound (L$[COST])..."
+     layout="topleft"
+     name="Upload Sound">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_sound" />
+       <menu_item_call.on_enable
+        function="File.EnableUpload" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Upload Sound,sound" />
+    </menu_item_call>
+    <menu_item_call
+     label="Animation (L$[COST])..."
+     layout="topleft"
+     name="Upload Animation">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_animation" />
+       <menu_item_call.on_enable
+        function="File.EnableUpload" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Upload Animation,animation" />
+    </menu_item_call>
+    <menu_item_call
+     label="Model..."
+     layout="topleft"
+     name="Upload Model">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_model" />
+       <menu_item_call.on_enable
+        function="File.EnableUploadModel" />
+       <menu_item_call.on_visible
+        function="File.VisibleUploadModel"/>
+    </menu_item_call>
+    <menu_item_call
+     label="Material..."
+     layout="topleft"
+     name="Upload Material">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_pbr_material" />
+       <menu_item_call.on_enable
+        function="File.EnableUploadMaterial" />
+    </menu_item_call>
+    <menu_item_call
+     label="Bulk..."
+     layout="topleft"
+     name="Bulk Upload">
+       <menu_item_call.on_click
+        function="Inventory.FileUploadLocation"
+        parameter="upload_bulk" />
+       <menu_item_call.on_visible
+        function="Upload.CalculateCosts"
+        parameter="Bulk Upload,texture" />
+    </menu_item_call>
+  </menu>
+  <menu
    label="Use as default for"
    layout="topleft"
    name="upload_def">
@@ -977,7 +1054,7 @@
      name="Image uploads">
       <menu_item_call.on_click
        function="Inventory.FileUploadLocation"
-        parameter="texture" />
+       parameter="def_texture" />
     </menu_item_call>
     <menu_item_call
      label="Sound uploads"
@@ -985,7 +1062,7 @@
      name="Sound uploads">
     <menu_item_call.on_click
      function="Inventory.FileUploadLocation"
-     parameter="sound" />
+       parameter="def_sound" />
     </menu_item_call>
     <menu_item_call
      label="Animation uploads"
@@ -993,7 +1070,7 @@
      name="Animation uploads">
     <menu_item_call.on_click
      function="Inventory.FileUploadLocation"
-     parameter="animation" />
+       parameter="def_animation" />
     </menu_item_call>
     <menu_item_call
      label="Model uploads"
@@ -1001,7 +1078,7 @@
      name="Model uploads">
     <menu_item_call.on_click
      function="Inventory.FileUploadLocation"
-     parameter="model" />
+       parameter="def_model" />
     </menu_item_call>
     <menu_item_call
      label="PBR material uploads"
@@ -1009,7 +1086,7 @@
      name="PBR uploads">
         <menu_item_call.on_click
          function="Inventory.FileUploadLocation"
-         parameter="pbr_material" />
+       parameter="def_pbr_material" />
     </menu_item_call>
   </menu>
 	<menu_item_separator
diff --git a/indra/newview/skins/default/xui/ja/strings.xml b/indra/newview/skins/default/xui/ja/strings.xml
index fa6c329fe7..71f7c1a034 100644
--- a/indra/newview/skins/default/xui/ja/strings.xml
+++ b/indra/newview/skins/default/xui/ja/strings.xml
@@ -66,7 +66,6 @@ SLURL：&lt;nolink&gt;[SLURL]&lt;/nolink&gt;
 帯域幅：[NET_BANDWITH]kbit／秒
 ＬＯＤ係数：[LOD_FACTOR]
 描画の質：[RENDER_QUALITY]
-高度な光源モデル：[GPU_SHADERS]
 テクスチャメモリ：[TEXTURE_MEMORY]㎆
 	</string>
 	<string name="AboutOSXHiDPI">
diff --git a/indra/newview/skins/default/xui/zh/strings.xml b/indra/newview/skins/default/xui/zh/strings.xml
index bdb16c9bf1..d053d2b30d 100644
--- a/indra/newview/skins/default/xui/zh/strings.xml
+++ b/indra/newview/skins/default/xui/zh/strings.xml
@@ -69,7 +69,6 @@
 頻寬：[NET_BANDWITH]千位元/秒
 細節層次率：[LOD_FACTOR]
 呈像品質：[RENDER_QUALITY]
-進階照明模型：[GPU_SHADERS]
 材質記憶體：[TEXTURE_MEMORY]MB
 	</string>
 	<string name="AboutOSXHiDPI">