7 files changed, 146 insertions, 65 deletions

diff --git a/linden/indra/llmath/camera.h b/linden/indra/llmath/camera.h
index 3aa86d5..be8c711 100644
--- a/linden/indra/llmath/camera.h
+++ b/linden/indra/llmath/camera.h
@@ -2,7 +2,7 @@
  * @file camera.h
  * @brief Legacy wrapper header.
  *
- * Copyright (c) 2000-2007 Linden Research, Inc.
+ * Copyright (c) 2000-2007, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
diff --git a/linden/indra/llmath/coordframe.h b/linden/indra/llmath/coordframe.h
index 611387d..01d3031 100644
--- a/linden/indra/llmath/coordframe.h
+++ b/linden/indra/llmath/coordframe.h
@@ -2,7 +2,7 @@
  * @file coordframe.h
  * @brief Legacy wrapper header.
  *
- * Copyright (c) 2000-2007 Linden Research, Inc.
+ * Copyright (c) 2000-2007, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
diff --git a/linden/indra/llmath/llquaternion.cpp b/linden/indra/llmath/llquaternion.cpp
index abc9e42..06e34af 100644
--- a/linden/indra/llmath/llquaternion.cpp
+++ b/linden/indra/llmath/llquaternion.cpp
@@ -1,5 +1,5 @@
 /** 
- * @file qmath.cpp
+ * @file llquaternion.cpp
  * @brief LLQuaternion class implementation.
  *
  * Copyright (c) 2000-2007, Linden Research, Inc.
diff --git a/linden/indra/llmath/llrand.h b/linden/indra/llmath/llrand.h
index 4a3dca6..c5ab7e3 100644
--- a/linden/indra/llmath/llrand.h
+++ b/linden/indra/llmath/llrand.h
@@ -29,8 +29,8 @@
 #ifndef LL_LLRAND_H
 #define LL_LLRAND_H
 
-#include "boost/random/lagged_fibonacci.hpp"
-#include "boost/random/mersenne_twister.hpp"
+#include <boost/random/lagged_fibonacci.hpp>
+#include <boost/random/mersenne_twister.hpp>
 
 /**
  * Use the boost random number generators if you want a stateful
diff --git a/linden/indra/llmath/llvolume.cpp b/linden/indra/llmath/llvolume.cpp
index 327f1bf..5764c38 100644
--- a/linden/indra/llmath/llvolume.cpp
+++ b/linden/indra/llmath/llvolume.cpp
@@ -1799,6 +1799,8 @@ void LLVolume::createVolumeFaces()
 // sculpt replaces generate() for sculpted surfaces
 void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, S32 sculpt_level)
 {
+    U8 sculpt_type = mParams.getSculptType();
+
         BOOL data_is_empty = FALSE;
 
         if (sculpt_width == 0 || sculpt_height == 0 || sculpt_data == NULL)
@@ -1880,6 +1882,7 @@ void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components,
                         line += sizeT;
                 }
         }
+        
         else
         {
                 S32 line = 0;
@@ -1894,18 +1897,52 @@ void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components,
                                 U32 x = (U32) ((F32)t/(sizeT-1) * (F32) sculpt_width);
                                 U32 y = (U32) ((F32)s/(sizeS-1) * (F32) sculpt_height);
 
-                                if (y == sculpt_height)  // stitch bottom row
+                                if (y == 0)  // top row stitching
                                 {
-                                        y = sculpt_height - 1;
-                                        x = sculpt_width / 2;
+                                        // pinch?
+                                        if (sculpt_type == LL_SCULPT_TYPE_SPHERE)
+                                        {
+                                                x = sculpt_width / 2;
+                                        }
                                 }
 
-                                if (x == sculpt_width)   // stitch sides
-                                        x = 0;
+                                if (y == sculpt_height)  // bottom row stitching
+                                {
+                                        // wrap?
+                                        if (sculpt_type == LL_SCULPT_TYPE_TORUS)
+                                        {
+                                                y = 0;
+                                        }
+                                        else
+                                        {
+                                                y = sculpt_height - 1;
+                                        }
 
-                                if (y == 0)  // stitch top row
-                                        x = sculpt_width / 2;
-                        
+                                        // pinch?
+                                        if (sculpt_type == LL_SCULPT_TYPE_SPHERE)
+                                        {
+                                                x = sculpt_width / 2;
+                                        }
+                                }
+
+                                if (x == sculpt_width)   // side stitching
+                                {
+                                        // wrap?
+                                        if ((sculpt_type == LL_SCULPT_TYPE_SPHERE) ||
+                                                (sculpt_type == LL_SCULPT_TYPE_TORUS) ||
+                                                (sculpt_type == LL_SCULPT_TYPE_CYLINDER))
+                                        {
+                                                x = 0;
+                                        }
+                                        
+                                        else
+                                        {
+                                                x = sculpt_width - 1;
+                                        }
+                                }
+
+
+                                
                                 U32 index = (x + y * sculpt_width) * sculpt_components;
                                 pt.mPos.mV[0] = sculpt_data[index  ] / 256.f - 0.5f;
                                 pt.mPos.mV[1] = sculpt_data[index+1] / 256.f - 0.5f;
@@ -4615,82 +4652,130 @@ BOOL LLVolumeFace::createSide()
                 }
         }
 
+        // adjust normals based on wrapping and stitching
+        
         BOOL s_bottom_converges = ((mVertices[0].mPosition - mVertices[mNumS*(mNumT-2)].mPosition).magVecSquared() < 0.000001f);
         BOOL s_top_converges = ((mVertices[mNumS-1].mPosition - mVertices[mNumS*(mNumT-2)+mNumS-1].mPosition).magVecSquared() < 0.000001f);
-        
-        if (mVolumep->getPath().isOpen() == FALSE) { //wrap normals on T
-                for (S32 i = 0; i < mNumS; i++) {
-                        LLVector3 norm = mVertices[i].mNormal + mVertices[mNumS*(mNumT-1)+i].mNormal;
-                        mVertices[i].mNormal = norm;
-                        mVertices[mNumS*(mNumT-1)+i].mNormal = norm;
+        U8 sculpt_type = mVolumep->getParams().getSculptType();
+
+        if (sculpt_type == LL_SCULPT_TYPE_NONE)  // logic for non-sculpt volumes
+        {
+                if (mVolumep->getPath().isOpen() == FALSE)
+                { //wrap normals on T
+                        for (S32 i = 0; i < mNumS; i++)
+                        {
+                                LLVector3 norm = mVertices[i].mNormal + mVertices[mNumS*(mNumT-1)+i].mNormal;
+                                mVertices[i].mNormal = norm;
+                                mVertices[mNumS*(mNumT-1)+i].mNormal = norm;
+                        }
                 }
-        }
 
-        if ((mVolumep->getProfile().isOpen() == FALSE) &&
-                !(s_bottom_converges))
+                if ((mVolumep->getProfile().isOpen() == FALSE) && !(s_bottom_converges))
                 { //wrap normals on S
-                        for (S32 i = 0; i < mNumT; i++) {
+                        for (S32 i = 0; i < mNumT; i++)
+                        {
                                 LLVector3 norm = mVertices[mNumS*i].mNormal + mVertices[mNumS*i+mNumS-1].mNormal;
                                 mVertices[mNumS * i].mNormal = norm;
                                 mVertices[mNumS * i+mNumS-1].mNormal = norm;
                         }
                 }
         
-        if (mVolumep->getPathType() == LL_PCODE_PATH_CIRCLE &&
-                ((mVolumep->getProfileType() & LL_PCODE_PROFILE_MASK) == LL_PCODE_PROFILE_CIRCLE_HALF))
-        {
-                if (s_bottom_converges)
-                { //all lower S have same normal
-                        for (S32 i = 0; i < mNumT; i++) {
-                                mVertices[mNumS*i].mNormal = LLVector3(1,0,0);
+                if (mVolumep->getPathType() == LL_PCODE_PATH_CIRCLE &&
+                        ((mVolumep->getProfileType() & LL_PCODE_PROFILE_MASK) == LL_PCODE_PROFILE_CIRCLE_HALF))
+                {
+                        if (s_bottom_converges)
+                        { //all lower S have same normal
+                                for (S32 i = 0; i < mNumT; i++)
+                                {
+                                        mVertices[mNumS*i].mNormal = LLVector3(1,0,0);
+                                }
                         }
-                }
 
-                if (s_top_converges)
-                { //all upper S have same normal
-                        for (S32 i = 0; i < mNumT; i++) {
-                                mVertices[mNumS*i+mNumS-1].mNormal = LLVector3(-1,0,0);
+                        if (s_top_converges)
+                        { //all upper S have same normal
+                                for (S32 i = 0; i < mNumT; i++)
+                                {
+                                        mVertices[mNumS*i+mNumS-1].mNormal = LLVector3(-1,0,0);
+                                }
                         }
                 }
         }
-
-        U8 sculpt_type = mVolumep->getParams().getSculptType();
         
-        if (sculpt_type == LL_SCULPT_TYPE_SPHERE)
+        else  // logic for sculpt volumes
         {
-                // average normals for north pole
+                BOOL average_poles = FALSE;
+                BOOL wrap_s = FALSE;
+                BOOL wrap_t = FALSE;
+
+                if (sculpt_type == LL_SCULPT_TYPE_SPHERE)
+                        average_poles = TRUE;
+
+                if ((sculpt_type == LL_SCULPT_TYPE_SPHERE) ||
+                        (sculpt_type == LL_SCULPT_TYPE_TORUS) ||
+                        (sculpt_type == LL_SCULPT_TYPE_CYLINDER))
+                        wrap_s = TRUE;
+
+                if (sculpt_type == LL_SCULPT_TYPE_TORUS)
+                        wrap_t = TRUE;
+                        
                 
-                LLVector3 average(0.0, 0.0, 0.0);
-                for (S32 i = 0; i < mNumS; i++)
+                if (average_poles)
                 {
-                        average += mVertices[i].mNormal;
-                }
+                        // average normals for north pole
+                
+                        LLVector3 average(0.0, 0.0, 0.0);
+                        for (S32 i = 0; i < mNumS; i++)
+                        {
+                                average += mVertices[i].mNormal;
+                        }
+
+                        // set average
+                        for (S32 i = 0; i < mNumS; i++)
+                        {
+                                mVertices[i].mNormal = average;
+                        }
+
+                        // average normals for south pole
+                
+                        average = LLVector3(0.0, 0.0, 0.0);
+                        for (S32 i = 0; i < mNumS; i++)
+                        {
+                                average += mVertices[i + mNumS * (mNumT - 1)].mNormal;
+                        }
+
+                        // set average
+                        for (S32 i = 0; i < mNumS; i++)
+                        {
+                                mVertices[i + mNumS * (mNumT - 1)].mNormal = average;
+                        }
 
-                // set average
-                for (S32 i = 0; i < mNumS; i++)
-                {
-                        mVertices[i].mNormal = average;
                 }
-        }
 
-        
-        if (sculpt_type == LL_SCULPT_TYPE_SPHERE)
-        {
-                // average normals for south pole
                 
-                LLVector3 average(0.0, 0.0, 0.0);
-                for (S32 i = 0; i < mNumS; i++)
+                if (wrap_s)
                 {
-                        average += mVertices[i + mNumS * (mNumT - 1)].mNormal;
+                        for (S32 i = 0; i < mNumT; i++)
+                        {
+                                LLVector3 norm = mVertices[mNumS*i].mNormal + mVertices[mNumS*i+mNumS-1].mNormal;
+                                mVertices[mNumS * i].mNormal = norm;
+                                mVertices[mNumS * i+mNumS-1].mNormal = norm;
+                        }
                 }
 
-                // set average
-                for (S32 i = 0; i < mNumS; i++)
+
+                
+                if (wrap_t)
                 {
-                        mVertices[i + mNumS * (mNumT - 1)].mNormal = average;
+                        for (S32 i = 0; i < mNumS; i++)
+                        {
+                                LLVector3 norm = mVertices[i].mNormal + mVertices[mNumS*(mNumT-1)+i].mNormal;
+                                mVertices[i].mNormal = norm;
+                                mVertices[mNumS*(mNumT-1)+i].mNormal = norm;
+                        }
+                        
                 }
-        }
 
+        }
 
 
         //normalize normals and binormals here so the meshes that reference
diff --git a/linden/indra/llmath/llvolume.h b/linden/indra/llmath/llvolume.h
index 6ac07f5..3973f70 100644
--- a/linden/indra/llmath/llvolume.h
+++ b/linden/indra/llmath/llvolume.h
@@ -174,7 +174,7 @@ const LLFaceID	LL_FACE_OUTER_SIDE_3	= 0x1 << 8;
 const U8 LL_SCULPT_TYPE_NONE      = 0;
 const U8 LL_SCULPT_TYPE_SPHERE    = 1;
 const U8 LL_SCULPT_TYPE_TORUS     = 2;
-const U8 LL_SCULPT_TYPE_PLAIN     = 3;
+const U8 LL_SCULPT_TYPE_PLANE     = 3;
 const U8 LL_SCULPT_TYPE_CYLINDER  = 4;
 
 
@@ -860,9 +860,6 @@ public:
         BOOL isUnique() const                                                                   { return mUnique; }
 
         S32 getSculptLevel() const                              { return mSculptLevel; }
-        void setSculptLevel(S32 level)                          { mSculptLevel = level; }
-
-        U8 getSculptType() const                                { return mSculptType; }
         
         S32 *getTriangleIndices(U32 &num_indices) const;
         void generateSilhouetteVertices(std::vector<LLVector3> &vertices, std::vector<LLVector3> &normals, std::vector<S32> &segments, const LLVector3& view_vec,
@@ -908,7 +905,6 @@ protected:
         BOOL mUnique;
         F32 mDetail;
         S32 mSculptLevel;
-        U8  mSculptType;
         
         LLVolumeParams mParams;
         LLPath *mPathp;
diff --git a/linden/indra/llmath/v3color.cpp b/linden/indra/llmath/v3color.cpp
index 5464a0b..5378bc5 100644
--- a/linden/indra/llmath/v3color.cpp
+++ b/linden/indra/llmath/v3color.cpp
@@ -110,4 +110,4 @@ void LLColor3::calcHSL(F32* hue, F32* saturation, F32* luminance) const
         if (hue) *hue = H;
         if (saturation) *saturation = S;
         if (luminance) *luminance = L;
-}
\ No newline at end of file
+}