Merge branch 'mccabe-plugins' into plugins_merge

Conflicts:
	linden/doc/contributions.txt
	linden/indra/cmake/GStreamer.cmake
	linden/indra/cmake/LLMedia.cmake
	linden/indra/cmake/OPENAL.cmake
	linden/indra/llmedia/CMakeLists.txt
	linden/indra/llprimitive/material_codes.h
	linden/indra/newview/chatbar_as_cmdline.cpp
	linden/indra/newview/llappviewer.cpp
	linden/indra/newview/llfloatertos.cpp
	linden/indra/newview/llstartup.cpp
	linden/indra/newview/llviewerwindow.cpp
	linden/indra/newview/llvoavatar.cpp
	linden/indra/newview/pipeline.cpp
	linden/indra/newview/pipeline.h
	linden/indra/newview/viewer_manifest.py
	linden/install.xml

10 files changed, 434 insertions, 23 deletions

diff --git a/linden/indra/llmath/llbbox.cpp b/linden/indra/llmath/llbbox.cpp
new file mode 100644
index 0000000..f0ec010
--- /dev/null
+++ b/linden/indra/llmath/llbbox.cpp
@@ -0,0 +1,162 @@
+/** 
+ * @file llbbox.cpp
+ * @brief General purpose bounding box class (Not axis aligned)
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2010, /linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by /linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and /linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL /linden LAB SOURCE CODE IS PROVIDED "AS IS." /linden LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+// self include
+#include "llbbox.h"
+
+// library includes
+#include "m4math.h"
+
+void LLBBox::addPointLocal(const LLVector3& p)
+{
+        if (mEmpty)
+        {
+                mMinLocal = p;
+                mMaxLocal = p;
+                mEmpty = FALSE;
+        }
+        else
+        {
+                mMinLocal.mV[VX] = llmin( p.mV[VX], mMinLocal.mV[VX] );
+                mMinLocal.mV[VY] = llmin( p.mV[VY], mMinLocal.mV[VY] );
+                mMinLocal.mV[VZ] = llmin( p.mV[VZ], mMinLocal.mV[VZ] );
+                mMaxLocal.mV[VX] = llmax( p.mV[VX], mMaxLocal.mV[VX] );
+                mMaxLocal.mV[VY] = llmax( p.mV[VY], mMaxLocal.mV[VY] );
+                mMaxLocal.mV[VZ] = llmax( p.mV[VZ], mMaxLocal.mV[VZ] );
+        }
+}
+
+void LLBBox::addPointAgent( LLVector3 p)
+{
+        p -= mPosAgent;
+        p.rotVec( ~mRotation );
+        addPointLocal( p );
+}
+
+
+void LLBBox::addBBoxAgent(const LLBBox& b)
+{
+        if (mEmpty)
+        {
+                mPosAgent = b.mPosAgent;
+                mRotation = b.mRotation;
+                mMinLocal.clearVec();
+                mMaxLocal.clearVec();
+        }
+        LLVector3 vertex[8];
+        vertex[0].setVec( b.mMinLocal.mV[VX], b.mMinLocal.mV[VY], b.mMinLocal.mV[VZ] );
+        vertex[1].setVec( b.mMinLocal.mV[VX], b.mMinLocal.mV[VY], b.mMaxLocal.mV[VZ] );
+        vertex[2].setVec( b.mMinLocal.mV[VX], b.mMaxLocal.mV[VY], b.mMinLocal.mV[VZ] );
+        vertex[3].setVec( b.mMinLocal.mV[VX], b.mMaxLocal.mV[VY], b.mMaxLocal.mV[VZ] );
+        vertex[4].setVec( b.mMaxLocal.mV[VX], b.mMinLocal.mV[VY], b.mMinLocal.mV[VZ] );
+        vertex[5].setVec( b.mMaxLocal.mV[VX], b.mMinLocal.mV[VY], b.mMaxLocal.mV[VZ] );
+        vertex[6].setVec( b.mMaxLocal.mV[VX], b.mMaxLocal.mV[VY], b.mMinLocal.mV[VZ] );
+        vertex[7].setVec( b.mMaxLocal.mV[VX], b.mMaxLocal.mV[VY], b.mMaxLocal.mV[VZ] );
+
+        LLMatrix4 m( b.mRotation );
+        m.translate( b.mPosAgent );
+        m.translate( -mPosAgent );
+        m.rotate( ~mRotation );
+
+        for( S32 i=0; i<8; i++ )
+        {
+                addPointLocal( vertex[i] * m );
+        }
+}
+
+
+void LLBBox::expand( F32 delta )
+{
+        mMinLocal.mV[VX] -= delta;
+        mMinLocal.mV[VY] -= delta;
+        mMinLocal.mV[VZ] -= delta;
+        mMaxLocal.mV[VX] += delta;
+        mMaxLocal.mV[VY] += delta;
+        mMaxLocal.mV[VZ] += delta;
+}
+
+LLVector3 LLBBox::localToAgent(const LLVector3& v) const
+{
+        LLMatrix4 m( mRotation );
+        m.translate( mPosAgent );
+        return v * m;
+}
+
+LLVector3 LLBBox::agentToLocal(const LLVector3& v) const
+{
+        LLMatrix4 m;
+        m.translate( -mPosAgent );
+        m.rotate( ~mRotation );  // inverse rotation
+        return v * m;
+}
+
+LLVector3 LLBBox::localToAgentBasis(const LLVector3& v) const
+{
+        LLMatrix4 m( mRotation );
+        return v * m;
+}
+
+LLVector3 LLBBox::agentToLocalBasis(const LLVector3& v) const
+{
+        LLMatrix4 m( ~mRotation );  // inverse rotation
+        return v * m;
+}
+
+BOOL LLBBox::containsPointLocal(const LLVector3& p) const
+{
+        if (  (p.mV[VX] < mMinLocal.mV[VX])
+                ||(p.mV[VX] > mMaxLocal.mV[VX])
+                ||(p.mV[VY] < mMinLocal.mV[VY])
+                ||(p.mV[VY] > mMaxLocal.mV[VY])
+                ||(p.mV[VZ] < mMinLocal.mV[VZ])
+                ||(p.mV[VZ] > mMaxLocal.mV[VZ]))
+        {
+                return FALSE;
+        }
+        return TRUE;
+}
+
+BOOL LLBBox::containsPointAgent(const LLVector3& p) const
+{
+        LLVector3 point_local = agentToLocal(p);
+        return containsPointLocal(point_local);
+}
+
+
+/*
+LLBBox operator*(const LLBBox &a, const LLMatrix4 &b)
+{
+        return LLBBox( a.mMin * b, a.mMax * b );
+}
+*/
diff --git a/linden/indra/llmath/llbbox.h b/linden/indra/llmath/llbbox.h
new file mode 100644
index 0000000..3559284
--- /dev/null
+++ b/linden/indra/llmath/llbbox.h
@@ -0,0 +1,103 @@
+/** 
+ * @file llbbox.h
+ * @brief General purpose bounding box class
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2010, /linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by /linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and /linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL /linden LAB SOURCE CODE IS PROVIDED "AS IS." /linden LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_BBOX_H
+#define LL_BBOX_H
+
+#include "v3math.h"
+#include "llquaternion.h"
+
+// Note: "local space" for an LLBBox is defined relative to agent space in terms of
+// a translation followed by a rotation.  There is no scale term since the LLBBox's min and 
+// max are not necessarily symetrical and define their own extents.
+
+class LLBBox
+{
+public:
+        LLBBox() {mEmpty = TRUE;}
+        LLBBox( const LLVector3& pos_agent,
+                const LLQuaternion& rot,
+                const LLVector3& min_local,
+                const LLVector3& max_local )
+                :
+                mMinLocal( min_local ), mMaxLocal( max_local ), mPosAgent(pos_agent), mRotation( rot), mEmpty( TRUE )
+                {}
+
+        // Default copy constructor is OK.
+
+        const LLVector3&        getPositionAgent() const                        { return mPosAgent; }
+        const LLQuaternion&     getRotation() const                                     { return mRotation; }
+
+        const LLVector3&        getMinLocal() const                                     { return mMinLocal; }
+        void                            setMinLocal( const LLVector3& min )     { mMinLocal = min; }
+
+        const LLVector3&        getMaxLocal() const                                     { return mMaxLocal; }
+        void                            setMaxLocal( const LLVector3& max )     { mMaxLocal = max; }
+
+        LLVector3                       getCenterLocal() const                          { return (mMaxLocal - mMinLocal) * 0.5f + mMinLocal; }
+        LLVector3                       getCenterAgent() const                          { return localToAgent( getCenterLocal() ); }
+
+        LLVector3                       getExtentLocal() const                          { return mMaxLocal - mMinLocal; }
+
+        BOOL                            containsPointLocal(const LLVector3& p) const;
+        BOOL                            containsPointAgent(const LLVector3& p) const;
+
+        void                            addPointAgent(LLVector3 p);
+        void                            addBBoxAgent(const LLBBox& b);
+        
+        void                            addPointLocal(const LLVector3& p);
+        void                            addBBoxLocal(const LLBBox& b) { addPointLocal( b.mMinLocal ); addPointLocal( b.mMaxLocal ); }
+
+        void                            expand( F32 delta );
+
+        LLVector3                       localToAgent( const LLVector3& v ) const;
+        LLVector3                       agentToLocal( const LLVector3& v ) const;
+
+        // Changes rotation but not position
+        LLVector3                       localToAgentBasis(const LLVector3& v) const;
+        LLVector3                       agentToLocalBasis(const LLVector3& v) const;
+
+
+//      friend LLBBox operator*(const LLBBox& a, const LLMatrix4& b);
+
+private:
+        LLVector3                       mMinLocal;
+        LLVector3                       mMaxLocal;
+        LLVector3                       mPosAgent;  // Position relative to Agent's Region
+        LLQuaternion            mRotation;
+        BOOL                            mEmpty;         // Nothing has been added to this bbox yet
+};
+
+//LLBBox operator*(const LLBBox &a, const LLMatrix4 &b);
+
+
+#endif  // LL_BBOX_H
diff --git a/linden/indra/llmath/llcamera.cpp b/linden/indra/llmath/llcamera.cpp
index e6b6797..9c37fcf 100644
--- a/linden/indra/llmath/llcamera.cpp
+++ b/linden/indra/llmath/llcamera.cpp
@@ -246,6 +246,10 @@ S32 LLCamera::AABBInFrustum(const LLVector3 &center, const LLVector3& radius)
                 for (U32 i = 0; i < mPlaneCount; i++)
                 {
                         mask = mAgentPlanes[i].mask;
+                        if (mask == 0xff)
+                        {
+                                continue;
+                        } 
                         LLPlane p = mAgentPlanes[i].p;
                         LLVector3 n = LLVector3(p);
                         float d = p.mV[3];
@@ -294,6 +298,10 @@ S32 LLCamera::AABBInFrustumNoFarClip(const LLVector3 &center, const LLVector3& r
                 }
 
                 mask = mAgentPlanes[i].mask;
+                if (mask == 0xff)
+                {
+                        continue;
+                } 
                 LLPlane p = mAgentPlanes[i].p;
                 LLVector3 n = LLVector3(p);
                 float d = p.mV[3];
@@ -437,6 +445,11 @@ int LLCamera::sphereInFrustum(const LLVector3 &sphere_center, const F32 radius)
         int res = 2;
         for (int i = 0; i < 6; i++)
         {
+                if (mAgentPlanes[i].mask == 0xff)
+                {
+                        continue;
+                } 
+
                 float d = mAgentPlanes[i].p.dist(sphere_center);
 
                 if (d > radius) 
@@ -622,6 +635,17 @@ U8 LLCamera::calcPlaneMask(const LLPlane& plane)
         return mask;
 }
 
+void LLCamera::ignoreAgentFrustumPlane(S32 idx)
+{
+        if (idx < 0 || idx > (S32) mPlaneCount)
+        {
+                return;
+        }
+
+        mAgentPlanes[idx].mask = 0xff;
+        mAgentPlanes[idx].p.clearVec();
+}
+
 void LLCamera::calcAgentFrustumPlanes(LLVector3* frust)
 {
 
diff --git a/linden/indra/llmath/llcamera.h b/linden/indra/llmath/llcamera.h
index 85b93df..8d3ad08 100644
--- a/linden/indra/llmath/llcamera.h
+++ b/linden/indra/llmath/llcamera.h
@@ -84,6 +84,17 @@ public:
                 PLANE_TOP_MASK = (1<<PLANE_TOP),
                 PLANE_ALL_MASK = 0xf
         };
+
+        enum
+        {
+                AGENT_PLANE_LEFT = 0,
+                AGENT_PLANE_RIGHT,
+                AGENT_PLANE_NEAR,
+                AGENT_PLANE_BOTTOM,
+                AGENT_PLANE_TOP,
+                AGENT_PLANE_FAR,
+        };
+
         enum {
                 HORIZ_PLANE_LEFT = 0,
                 HORIZ_PLANE_RIGHT = 1,
@@ -123,7 +134,8 @@ private:
 public:
         LLVector3 mAgentFrustum[8];  //8 corners of 6-plane frustum
         F32     mFrustumCornerDist;             //distance to corner of frustum against far clip plane
-        
+        LLPlane getAgentPlane(U32 idx) { return mAgentPlanes[idx].p; }
+
 public:
         LLCamera();
         LLCamera(F32 vertical_fov_rads, F32 aspect_ratio, S32 view_height_in_pixels, F32 near_plane, F32 far_plane);
@@ -170,6 +182,8 @@ public:
         // Return number of bytes copied.
         size_t readFrustumFromBuffer(const char *buffer);
         void calcAgentFrustumPlanes(LLVector3* frust);
+        void ignoreAgentFrustumPlane(S32 idx);
+
         // Returns 1 if partly in, 2 if fully in.
         // NOTE: 'center' is in absolute frame.
         S32 sphereInFrustumOld(const LLVector3 &center, const F32 radius) const;
diff --git a/linden/indra/llmath/llmath.h b/linden/indra/llmath/llmath.h
index 9f8e539..ec1076d 100644
--- a/linden/indra/llmath/llmath.h
+++ b/linden/indra/llmath/llmath.h
@@ -35,6 +35,7 @@
 
 #include <cmath>
 #include <cstdlib>
+#include <complex>
 #include "lldefs.h"
 #include "llstl.h" // *TODO: Remove when LLString is gone
 #include "llstring.h" // *TODO: Remove when LLString is gone
@@ -60,7 +61,9 @@
 #endif
 
 // Single Precision Floating Point Routines
-#if _MSC_VER < 1400
+#ifndef fsqrtf
+#define fsqrtf(x)               ((F32)sqrt((F64)(x)))
+#endif
 #ifndef sqrtf
 #define sqrtf(x)                ((F32)sqrt((F64)(x)))
 #endif
@@ -81,11 +84,6 @@
 #ifndef powf
 #define powf(x,y) ((F32)pow((F64)(x),(F64)(y)))
 #endif
-#endif
-
-#ifndef fsqrtf
-#define fsqrtf(x)               sqrtf(x)
-#endif
 
 const F32       GRAVITY                 = -9.8f;
 
@@ -205,7 +203,7 @@ inline S32 llfloor( F32 f )
                 }
                 return result;
 #else
-                return (S32)floor(f);
+                return (S32)floorf(f);
 #endif
 }
 
diff --git a/linden/indra/llmath/llmodularmath.cpp b/linden/indra/llmath/llmodularmath.cpp
new file mode 100644
index 0000000..f0afeb7
--- /dev/null
+++ b/linden/indra/llmath/llmodularmath.cpp
@@ -0,0 +1,36 @@
+/** 
+ * @file llmodularmath.cpp
+ * @brief LLModularMath class implementation
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2010, /linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by /linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and /linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL /linden LAB SOURCE CODE IS PROVIDED "AS IS." /linden LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+// implementation is all in the header, this include dep ensures the unit test is rerun if the implementation changes.
+#include "llmodularmath.h"
diff --git a/linden/indra/llmath/llsdutil_math.h b/linden/indra/llmath/llsdutil_math.h
new file mode 100755
index 0000000..5b64942
--- /dev/null
+++ b/linden/indra/llmath/llsdutil_math.h
@@ -0,0 +1,70 @@
+/** 
+ * @file llsdutil_math.h
+ * @author Brad
+ * @date 2009-05-19
+ * @brief Utility classes, functions, etc, for using structured data with math classes.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009-2010, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLSDUTIL_MATH_H
+#define LL_LLSDUTIL_MATH_H
+
+class LL_COMMON_API LLSD;
+
+// vector3
+class LLVector3;
+LLSD ll_sd_from_vector3(const LLVector3& vec);
+LLVector3 ll_vector3_from_sd(const LLSD& sd, S32 start_index = 0);
+
+// vector4
+class LLVector4;
+LLSD ll_sd_from_vector4(const LLVector4& vec);
+LLVector4 ll_vector4_from_sd(const LLSD& sd, S32 start_index = 0);
+
+// vector3d (double)
+class LLVector3d;
+LLSD ll_sd_from_vector3d(const LLVector3d& vec);
+LLVector3d ll_vector3d_from_sd(const LLSD& sd, S32 start_index = 0);
+
+// vector2
+class LLVector2;
+LLSD ll_sd_from_vector2(const LLVector2& vec);
+LLVector2 ll_vector2_from_sd(const LLSD& sd);
+
+// Quaternion
+class LLQuaternion;
+LLSD ll_sd_from_quaternion(const LLQuaternion& quat);
+LLQuaternion ll_quaternion_from_sd(const LLSD& sd);
+
+// color4
+class LLColor4;
+LLSD ll_sd_from_color4(const LLColor4& c);
+LLColor4 ll_color4_from_sd(const LLSD& sd);
+
+#endif // LL_LLSDUTIL_MATH_H
diff --git a/linden/indra/llmath/llvolume.cpp b/linden/indra/llmath/llvolume.cpp
index b9b9e0b..a1d891a 100644
--- a/linden/indra/llmath/llvolume.cpp
+++ b/linden/indra/llmath/llvolume.cpp
@@ -2208,16 +2208,10 @@ void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components,
         S32 requested_sizeS = 0;
         S32 requested_sizeT = 0;
 
-        // create oblong sculpties with high LOD always
-        F32 sculpt_detail = mDetail;
-        if (sculpt_width != sculpt_height && sculpt_detail < 4.0)
-        {
-                sculpt_detail = 4.0;
-        }
-        sculpt_calc_mesh_resolution(sculpt_width, sculpt_height, sculpt_type, sculpt_detail, requested_sizeS, requested_sizeT);
+        sculpt_calc_mesh_resolution(sculpt_width, sculpt_height, sculpt_type, mDetail, requested_sizeS, requested_sizeT);
 
-        mPathp->generate(mParams.getPathParams(), sculpt_detail, 0, TRUE, requested_sizeS);
-        mProfilep->generate(mParams.getProfileParams(), mPathp->isOpen(), sculpt_detail, 0, TRUE, requested_sizeT);
+        mPathp->generate(mParams.getPathParams(), mDetail, 0, TRUE, requested_sizeS);
+        mProfilep->generate(mParams.getProfileParams(), mPathp->isOpen(), mDetail, 0, TRUE, requested_sizeT);
 
         S32 sizeS = mPathp->mPath.size();         // we requested a specific size, now see what we really got
         S32 sizeT = mProfilep->mProfile.size();   // we requested a specific size, now see what we really got
@@ -3376,7 +3370,8 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
                                                                                   std::vector<S32> &segments,
                                                                                   const LLVector3& obj_cam_vec,
                                                                                   const LLMatrix4& mat,
-                                                                                  const LLMatrix3& norm_mat)
+                                                                                  const LLMatrix3& norm_mat,
+                                                                                  S32 face_mask)
 {
         LLMemType m1(LLMemType::MTYPE_VOLUME);
         
@@ -3384,12 +3379,17 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
         normals.clear();
         segments.clear();
 
+        S32 cur_index = 0;
         //for each face
         for (face_list_t::iterator iter = mVolumeFaces.begin();
                  iter != mVolumeFaces.end(); ++iter)
         {
                 const LLVolumeFace& face = *iter;
         
+                if (!(face_mask & (0x1 << cur_index++)))
+                {
+                        continue;
+                }
                 if (face.mTypeMask & (LLVolumeFace::CAP_MASK)) {
         
                 }
diff --git a/linden/indra/llmath/llvolume.h b/linden/indra/llmath/llvolume.h
index 2b1c60d..0b9002f 100644
--- a/linden/indra/llmath/llvolume.h
+++ b/linden/indra/llmath/llvolume.h
@@ -905,9 +905,13 @@ public:
         // returns number of triangle indeces required for path/profile mesh
         S32 getNumTriangleIndices() const;
 
-        void generateSilhouetteVertices(std::vector<LLVector3> &vertices, std::vector<LLVector3> &normals, std::vector<S32> &segments, const LLVector3& view_vec,
-                                                                                          const LLMatrix4& mat,
-                                                                                  const LLMatrix3& norm_mat);
+        void generateSilhouetteVertices(std::vector<LLVector3> &vertices, 
+                                                                        std::vector<LLVector3> &normals, 
+                                                                        std::vector<S32> &segments, 
+                                                                        const LLVector3& view_vec,
+                                                                        const LLMatrix4& mat,
+                                                                        const LLMatrix3& norm_mat,
+                                                                        S32 face_index);
 
         //get the face index of the face that intersects with the given line segment at the point 
         //closest to start.  Moves end to the point of intersection.  Returns -1 if no intersection.
diff --git a/linden/indra/llmath/v3math.h b/linden/indra/llmath/v3math.h
index 7f96800..8c65d93 100644
--- a/linden/indra/llmath/v3math.h
+++ b/linden/indra/llmath/v3math.h
@@ -411,8 +411,8 @@ inline bool operator<(const LLVector3 &a, const LLVector3 &b)
         return (a.mV[0] < b.mV[0]
                         || (a.mV[0] == b.mV[0]
                                 && (a.mV[1] < b.mV[1]
-                                        || (a.mV[1] == b.mV[1])
-                                                && a.mV[2] < b.mV[2])));
+                                        || ((a.mV[1] == b.mV[1])
+                                                && a.mV[2] < b.mV[2]))));
 }
 
 inline const LLVector3& operator+=(LLVector3 &a, const LLVector3 &b)