7 files changed, 345 insertions, 12 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 0f343bc..0609e2f 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 23ee115..0c81067 100644
--- a/linden/indra/llmath/llcamera.h
+++ b/linden/indra/llmath/llcamera.h
@@ -93,6 +93,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,
@@ -132,7 +143,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);
@@ -179,6 +191,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 0de568c..ec1076d 100644
--- a/linden/indra/llmath/llmath.h
+++ b/linden/indra/llmath/llmath.h
@@ -203,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/llvolume.cpp b/linden/indra/llmath/llvolume.cpp
index b0b8a94..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
@@ -4274,7 +4268,7 @@ LLFaceID LLVolume::generateFaceMask()
                 }
                 break;
         default:
-                llerrs << "Unknown profile!" << llendl
+                llerrs << "Unknown profile!" << llendl;
                 break;
         }