merge

49 files changed, 10848 insertions, 6040 deletions

diff --git a/indra/llmath/CMakeLists.txt b/indra/llmath/CMakeLists.txt
index e93fe90650..9dadad7dd3 100644
--- a/indra/llmath/CMakeLists.txt
+++ b/indra/llmath/CMakeLists.txt
@@ -15,13 +15,16 @@ set(llmath_SOURCE_FILES
     llcamera.cpp
     llcoordframe.cpp
     llline.cpp
+    llmatrix3a.cpp
     llmodularmath.cpp
     llperlin.cpp
     llquaternion.cpp
     llrect.cpp
     llsphere.cpp
+    llvector4a.cpp
     llvolume.cpp
     llvolumemgr.cpp
+    llvolumeoctree.cpp
     llsdutil_math.cpp
     m3math.cpp
     m4math.cpp
@@ -49,21 +52,32 @@ set(llmath_HEADER_FILES
     llinterp.h
     llline.h
     llmath.h
+    llmatrix3a.h
+    llmatrix3a.inl
     llmodularmath.h
     lloctree.h
     llperlin.h
     llplane.h
     llquantize.h
     llquaternion.h
+    llquaternion2.h
+    llquaternion2.inl
     llrect.h
+    llsimdmath.h
+    llsimdtypes.h
+    llsimdtypes.inl
     llsphere.h
     lltreenode.h
+    llvector4a.h
+    llvector4a.inl
+    llvector4logical.h
     llv4math.h
     llv4matrix3.h
     llv4matrix4.h
     llv4vector3.h
     llvolume.h
     llvolumemgr.h
+    llvolumeoctree.h
     llsdutil_math.h
     m3math.h
     m4math.h
diff --git a/indra/llmath/llcamera.cpp b/indra/llmath/llcamera.cpp
index 687c1a7d45..22ba26f99b 100644
--- a/indra/llmath/llcamera.cpp
+++ b/indra/llmath/llcamera.cpp
@@ -45,7 +45,6 @@ LLCamera::LLCamera() :
 	calculateFrustumPlanes();
 } 
 
-
 LLCamera::LLCamera(F32 vertical_fov_rads, F32 aspect_ratio, S32 view_height_in_pixels, F32 near_plane, F32 far_plane) :
 	LLCoordFrame(),
 	mViewHeightInPixels(view_height_in_pixels),
@@ -61,6 +60,10 @@ LLCamera::LLCamera(F32 vertical_fov_rads, F32 aspect_ratio, S32 view_height_in_p
 	setView(vertical_fov_rads);
 } 
 
+LLCamera::~LLCamera()
+{
+
+}
 
 // ---------------- LLCamera::getFoo() member functions ----------------
 
@@ -82,11 +85,11 @@ F32 LLCamera::getMaxView() const
 
 // ---------------- LLCamera::setFoo() member functions ----------------
 
-void LLCamera::setUserClipPlane(LLPlane plane)
+void LLCamera::setUserClipPlane(LLPlane& plane)
 {
 	mPlaneCount = 7;
-	mAgentPlanes[6].p = plane;
-	mAgentPlanes[6].mask = calcPlaneMask(plane);
+	mAgentPlanes[6] = plane;
+	mPlaneMask[6] = plane.calcPlaneMask();
 }
 
 void LLCamera::disableUserClipPlane()
@@ -158,166 +161,91 @@ size_t LLCamera::readFrustumFromBuffer(const char *buffer)
 
 // ---------------- test methods  ---------------- 
 
-S32 LLCamera::AABBInFrustum(const LLVector3 &center, const LLVector3& radius) 
+S32 LLCamera::AABBInFrustum(const LLVector4a &center, const LLVector4a& radius) 
 {
-	static const LLVector3 scaler[] = {
-		LLVector3(-1,-1,-1),
-		LLVector3( 1,-1,-1),
-		LLVector3(-1, 1,-1),
-		LLVector3( 1, 1,-1),
-		LLVector3(-1,-1, 1),
-		LLVector3( 1,-1, 1),
-		LLVector3(-1, 1, 1),
-		LLVector3( 1, 1, 1)
+	static const LLVector4a scaler[] = {
+		LLVector4a(-1,-1,-1),
+		LLVector4a( 1,-1,-1),
+		LLVector4a(-1, 1,-1),
+		LLVector4a( 1, 1,-1),
+		LLVector4a(-1,-1, 1),
+		LLVector4a( 1,-1, 1),
+		LLVector4a(-1, 1, 1),
+		LLVector4a( 1, 1, 1)
 	};
 
 	U8 mask = 0;
-	S32 result = 2;
-
-	/*if (mFrustumCornerDist > 0.f && radius.magVecSquared() > mFrustumCornerDist * mFrustumCornerDist)
-	{ //box is larger than frustum, check frustum quads against box planes
-
-		static const LLVector3 dir[] = 
-		{
-			LLVector3(1, 0, 0),
-			LLVector3(-1, 0, 0),
-			LLVector3(0, 1, 0),
-			LLVector3(0, -1, 0),
-			LLVector3(0, 0, 1),
-			LLVector3(0, 0, -1)
-		};
-
-		U32 quads[] = 
-		{
-			0, 1, 2, 3,
-			0, 1, 5, 4,
-			2, 3, 7, 6,
-			3, 0, 7, 4,
-			1, 2, 6, 4,
-			4, 5, 6, 7
-		};
-
-		result = 0;
-
-		BOOL total_inside = TRUE;
-		for (U32 i = 0; i < 6; i++)
-		{ 
-			LLVector3 p = center + radius.scaledVec(dir[i]);
-			F32 d = -p*dir[i];
-
-			for (U32 j = 0; j <	6; j++)
-			{ //for each quad
-				F32 dist = mAgentFrustum[quads[j*4+0]]*dir[i] + d;
-				if (dist > 0)
-				{ //at least one frustum point is outside the AABB
-					total_inside = FALSE;
-					for (U32 k = 1; k < 4; k++)
-					{ //for each other point on quad
-						if ( mAgentFrustum[quads[j*4+k]]*dir[i]+d  <= 0.f)
-						{ //quad is straddling some plane of AABB
-							return 1;
-						}
-					}
-				}
-				else
-				{
-					for (U32 k = 1; k < 4; k++)
-					{
-						if (mAgentFrustum[quads[j*4+k]]*dir[i]+d > 0.f)
-						{
-							return 1;
-						}
-					}
-				}
-			}
-		}
-
-		if (total_inside)
-		{
-			result = 1;
-		}
-	}
-	else*/
+	bool result = false;
+	LLVector4a rscale, maxp, minp;
+	LLSimdScalar d;
+	for (U32 i = 0; i < mPlaneCount; i++)
 	{
-		for (U32 i = 0; i < mPlaneCount; i++)
+		mask = mPlaneMask[i];
+		if (mask != 0xff)
 		{
-			mask = mAgentPlanes[i].mask;
-			if (mask == 0xff)
-			{
-				continue;
-			}
-			LLPlane p = mAgentPlanes[i].p;
-			LLVector3 n = LLVector3(p);
-			float d = p.mV[3];
-			LLVector3 rscale = radius.scaledVec(scaler[mask]);
-
-			LLVector3 minp = center - rscale;
-			LLVector3 maxp = center + rscale;
-
-			if (n * minp > -d) 
+			const LLPlane& p(mAgentPlanes[i]);
+			p.getAt<3>(d);
+			rscale.setMul(radius, scaler[mask]);
+			minp.setSub(center, rscale);
+			d = -d;
+			if (p.dot3(minp).getF32() > d) 
 			{
 				return 0;
 			}
-		
-			if (n * maxp > -d)
+			
+			if(!result)
 			{
-				result = 1;
+				maxp.setAdd(center, rscale);
+				result = (p.dot3(maxp).getF32() > d);
 			}
 		}
 	}
 
-	
-	return result;
+	return result?1:2;
 }
 
-S32 LLCamera::AABBInFrustumNoFarClip(const LLVector3 &center, const LLVector3& radius) 
+
+S32 LLCamera::AABBInFrustumNoFarClip(const LLVector4a& center, const LLVector4a& radius) 
 {
-	static const LLVector3 scaler[] = {
-		LLVector3(-1,-1,-1),
-		LLVector3( 1,-1,-1),
-		LLVector3(-1, 1,-1),
-		LLVector3( 1, 1,-1),
-		LLVector3(-1,-1, 1),
-		LLVector3( 1,-1, 1),
-		LLVector3(-1, 1, 1),
-		LLVector3( 1, 1, 1)
+	static const LLVector4a scaler[] = {
+		LLVector4a(-1,-1,-1),
+		LLVector4a( 1,-1,-1),
+		LLVector4a(-1, 1,-1),
+		LLVector4a( 1, 1,-1),
+		LLVector4a(-1,-1, 1),
+		LLVector4a( 1,-1, 1),
+		LLVector4a(-1, 1, 1),
+		LLVector4a( 1, 1, 1)
 	};
 
 	U8 mask = 0;
-	S32 result = 2;
-
+	bool result = false;
+	LLVector4a rscale, maxp, minp;
+	LLSimdScalar d;
 	for (U32 i = 0; i < mPlaneCount; i++)
 	{
-		if (i == 5)
-		{
-			continue;
-		}
-
-		mask = mAgentPlanes[i].mask;
-		if (mask == 0xff)
-		{
-			continue;
-		}
-		LLPlane p = mAgentPlanes[i].p;
-		LLVector3 n = LLVector3(p);
-		float d = p.mV[3];
-		LLVector3 rscale = radius.scaledVec(scaler[mask]);
-
-		LLVector3 minp = center - rscale;
-		LLVector3 maxp = center + rscale;
-
-		if (n * minp > -d) 
+		mask = mPlaneMask[i];
+		if ((i != 5) && (mask != 0xff))
 		{
-			return 0;
-		}
-	
-		if (n * maxp > -d)
-		{
-			result = 1;
+			const LLPlane& p(mAgentPlanes[i]);
+			p.getAt<3>(d);
+			rscale.setMul(radius, scaler[mask]);
+			minp.setSub(center, rscale);
+			d = -d;
+			if (p.dot3(minp).getF32() > d) 
+			{
+				return 0;
+			}
+			
+			if(!result)
+			{
+				maxp.setAdd(center, rscale);
+				result = (p.dot3(maxp).getF32() > d);
+			}
 		}
 	}
 
-	return result;
+	return result?1:2;
 }
 
 int LLCamera::sphereInFrustumQuick(const LLVector3 &sphere_center, const F32 radius) 
@@ -438,28 +366,22 @@ int LLCamera::sphereInFrustumOld(const LLVector3 &sphere_center, const F32 radiu
 int LLCamera::sphereInFrustum(const LLVector3 &sphere_center, const F32 radius) const 
 {
 	// Returns 1 if sphere is in frustum, 0 if not.
-	int res = 2;
+	bool res = false;
 	for (int i = 0; i < 6; i++)
 	{
-		if (mAgentPlanes[i].mask == 0xff)
+		if (mPlaneMask[i] != 0xff)
 		{
-			continue;
-		}
-
-		float d = mAgentPlanes[i].p.dist(sphere_center);
+			float d = mAgentPlanes[i].dist(sphere_center);
 
-		if (d > radius) 
-		{
-			return 0;
-		}
-
-		if (d > -radius)
-		{
-			res = 1;
+			if (d > radius) 
+			{
+				return 0;
+			}
+			res = res || (d > -radius);
 		}
 	}
 
-	return res;
+	return res?1:2;
 }
 
 
@@ -611,25 +533,6 @@ LLPlane planeFromPoints(LLVector3 p1, LLVector3 p2, LLVector3 p3)
 	return LLPlane(p1, n);
 }
 
-U8 LLCamera::calcPlaneMask(const LLPlane& plane)
-{
-	U8 mask = 0;
-	
-	if (plane.mV[0] >= 0)
-	{
-		mask |= 1;
-	}
-	if (plane.mV[1] >= 0)
-	{
-		mask |= 2;
-	}
-	if (plane.mV[2] >= 0)
-	{
-		mask |= 4;
-	}
-
-	return mask;
-}
 
 void LLCamera::ignoreAgentFrustumPlane(S32 idx)
 {
@@ -638,12 +541,13 @@ void LLCamera::ignoreAgentFrustumPlane(S32 idx)
 		return;
 	}
 
-	mAgentPlanes[idx].mask = 0xff;
-	mAgentPlanes[idx].p.clearVec();
+	mPlaneMask[idx] = 0xff;
+	mAgentPlanes[idx].clear();
 }
 
 void LLCamera::calcAgentFrustumPlanes(LLVector3* frust)
 {
+	
 	for (int i = 0; i < 8; i++)
 	{
 		mAgentFrustum[i] = frust[i];
@@ -656,27 +560,27 @@ void LLCamera::calcAgentFrustumPlanes(LLVector3* frust)
 	//order of planes is important, keep most likely to fail in the front of the list
 
 	//near - frust[0], frust[1], frust[2]
-	mAgentPlanes[2].p = planeFromPoints(frust[0], frust[1], frust[2]);
+	mAgentPlanes[2] = planeFromPoints(frust[0], frust[1], frust[2]);
 
 	//far  
-	mAgentPlanes[5].p = planeFromPoints(frust[5], frust[4], frust[6]);
+	mAgentPlanes[5] = planeFromPoints(frust[5], frust[4], frust[6]);
 
 	//left  
-	mAgentPlanes[0].p = planeFromPoints(frust[4], frust[0], frust[7]);
+	mAgentPlanes[0] = planeFromPoints(frust[4], frust[0], frust[7]);
 
 	//right  
-	mAgentPlanes[1].p = planeFromPoints(frust[1], frust[5], frust[6]);
+	mAgentPlanes[1] = planeFromPoints(frust[1], frust[5], frust[6]);
 
 	//top  
-	mAgentPlanes[4].p = planeFromPoints(frust[3], frust[2], frust[6]);
+	mAgentPlanes[4] = planeFromPoints(frust[3], frust[2], frust[6]);
 
 	//bottom  
-	mAgentPlanes[3].p = planeFromPoints(frust[1], frust[0], frust[4]);
+	mAgentPlanes[3] = planeFromPoints(frust[1], frust[0], frust[4]);
 
 	//cache plane octant facing mask for use in AABBInFrustum
 	for (U32 i = 0; i < mPlaneCount; i++)
 	{
-		mAgentPlanes[i].mask = calcPlaneMask(mAgentPlanes[i].p);
+		mPlaneMask[i] = mAgentPlanes[i].calcPlaneMask();
 	}
 }
 
@@ -730,9 +634,10 @@ void LLCamera::calculateWorldFrustumPlanes()
 	F32 d;
 	LLVector3 center = mOrigin - mXAxis*mNearPlane;
 	mWorldPlanePos = center;
+	LLVector3 pnorm;	
 	for (int p=0; p<4; p++)
 	{
-		LLVector3 pnorm = LLVector3(mLocalPlanes[p]);
+		mLocalPlanes[p].getVector3(pnorm);
 		LLVector3 norm = rotateToAbsolute(pnorm);
 		norm.normVec();
 		d = -(center * norm);
@@ -742,13 +647,15 @@ void LLCamera::calculateWorldFrustumPlanes()
 	LLVector3 zaxis(0, 0, 1.0f);
 	F32 yaw = getYaw();
 	{
-		LLVector3 tnorm = LLVector3(mLocalPlanes[PLANE_LEFT]);
+		LLVector3 tnorm;
+		mLocalPlanes[PLANE_LEFT].getVector3(tnorm);
 		tnorm.rotVec(yaw, zaxis);
 		d = -(mOrigin * tnorm);
 		mHorizPlanes[HORIZ_PLANE_LEFT] = LLPlane(tnorm, d);
 	}
 	{
-		LLVector3 tnorm = LLVector3(mLocalPlanes[PLANE_RIGHT]);
+		LLVector3 tnorm;
+		mLocalPlanes[PLANE_RIGHT].getVector3(tnorm);
 		tnorm.rotVec(yaw, zaxis);
 		d = -(mOrigin * tnorm);
 		mHorizPlanes[HORIZ_PLANE_RIGHT] = LLPlane(tnorm, d);
diff --git a/indra/llmath/llcamera.h b/indra/llmath/llcamera.h
index 531144db39..ec67b91d05 100644
--- a/indra/llmath/llcamera.h
+++ b/indra/llmath/llcamera.h
@@ -31,6 +31,7 @@
 #include "llmath.h"
 #include "llcoordframe.h"
 #include "llplane.h"
+#include "llvector4a.h"
 
 const F32 DEFAULT_FIELD_OF_VIEW 	= 60.f * DEG_TO_RAD;
 const F32 DEFAULT_ASPECT_RATIO 		= 640.f / 480.f;
@@ -64,6 +65,12 @@ class LLCamera
 : 	public LLCoordFrame
 {
 public:
+	
+	LLCamera(const LLCamera& rhs)
+	{
+		*this = rhs;
+	}
+	
 	enum {
 		PLANE_LEFT = 0,
 		PLANE_RIGHT = 1,
@@ -101,6 +108,9 @@ public:
 	};
 
 private:
+	LLPlane mAgentPlanes[7];  //frustum planes in agent space a la gluUnproject (I'm a bastard, I know) - DaveP
+	U8 mPlaneMask[8];         // 8 for alignment	
+	
 	F32 mView;					// angle between top and bottom frustum planes in radians.
 	F32 mAspect;				// width/height
 	S32 mViewHeightInPixels;	// for ViewHeightInPixels() only
@@ -114,30 +124,22 @@ private:
 	LLPlane mWorldPlanes[PLANE_NUM];
 	LLPlane mHorizPlanes[HORIZ_PLANE_NUM];
 
-	struct frustum_plane
-	{
-		frustum_plane() : mask(0) {}
-		LLPlane p;
-		U8 mask;
-	};
-	frustum_plane mAgentPlanes[7];  //frustum planes in agent space a la gluUnproject (I'm a bastard, I know) - DaveP
-
 	U32 mPlaneCount;  //defaults to 6, if setUserClipPlane is called, uses user supplied clip plane in
 
 	LLVector3 mWorldPlanePos;		// Position of World Planes (may be offset from camera)
 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; }
+	LLPlane& getAgentPlane(U32 idx) { return mAgentPlanes[idx]; }
 
 public:
 	LLCamera();
 	LLCamera(F32 vertical_fov_rads, F32 aspect_ratio, S32 view_height_in_pixels, F32 near_plane, F32 far_plane);
-	virtual ~LLCamera(){} // no-op virtual destructor
+	virtual ~LLCamera();
+	
 
-	void setUserClipPlane(LLPlane plane);
+	void setUserClipPlane(LLPlane& plane);
 	void disableUserClipPlane();
-	U8 calcPlaneMask(const LLPlane& plane);
 	virtual void setView(F32 vertical_fov_rads);
 	void setViewHeightInPixels(S32 height);
 	void setAspect(F32 new_aspect);
@@ -184,8 +186,8 @@ public:
 	S32 sphereInFrustum(const LLVector3 &center, const F32 radius) const;
 	S32 pointInFrustum(const LLVector3 &point) const { return sphereInFrustum(point, 0.0f); }
 	S32 sphereInFrustumFull(const LLVector3 &center, const F32 radius) const { return sphereInFrustum(center, radius); }
-	S32 AABBInFrustum(const LLVector3 &center, const LLVector3& radius);
-	S32 AABBInFrustumNoFarClip(const LLVector3 &center, const LLVector3& radius);
+	S32 AABBInFrustum(const LLVector4a& center, const LLVector4a& radius);
+	S32 AABBInFrustumNoFarClip(const LLVector4a& center, const LLVector4a& radius);
 
 	//does a quick 'n dirty sphere-sphere check
 	S32 sphereInFrustumQuick(const LLVector3 &sphere_center, const F32 radius); 
diff --git a/indra/llmath/llmath.h b/indra/llmath/llmath.h
index 798f1154d0..eea7c977fb 100644
--- a/indra/llmath/llmath.h
+++ b/indra/llmath/llmath.h
@@ -29,7 +29,7 @@
 
 #include <cmath>
 #include <cstdlib>
-#include <complex>
+#include <vector>
 #include "lldefs.h"
 //#include "llstl.h" // *TODO: Remove when LLString is gone
 //#include "llstring.h" // *TODO: Remove when LLString is gone
@@ -55,32 +55,11 @@
 #endif
 
 // Single Precision Floating Point Routines
-#ifndef sqrtf
-#define sqrtf(x)	((F32)sqrt((F64)(x)))
-#endif
-#ifndef fsqrtf
-#define fsqrtf(x)	sqrtf(x)
-#endif
-
-#ifndef cosf
-#define cosf(x)		((F32)cos((F64)(x)))
-#endif
-#ifndef sinf
-#define sinf(x)		((F32)sin((F64)(x)))
-#endif
-#ifndef tanf
+// (There used to be more defined here, but they appeared to be redundant and 
+// were breaking some other includes. Removed by Falcon, reviewed by Andrew, 11/25/09)
+/*#ifndef tanf
 #define tanf(x)		((F32)tan((F64)(x)))
-#endif
-#ifndef acosf
-#define acosf(x)	((F32)acos((F64)(x)))
-#endif
-
-#ifndef powf
-#define powf(x,y)	((F32)pow((F64)(x),(F64)(y)))
-#endif
-#ifndef expf
-#define expf(x)		((F32)exp((F64)(x)))
-#endif
+#endif*/
 
 const F32	GRAVITY			= -9.8f;
 
@@ -200,7 +179,7 @@ inline S32 llfloor( F32 f )
 		}
 		return result;
 #else
-		return (S32)floorf(f);
+		return (S32)floor(f);
 #endif
 }
 
@@ -378,11 +357,14 @@ inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
 		bar *= 10.f;
 	}
 
-	foo = (F32)llround(foo * bar);
+	//F32 new_foo = (F32)llround(foo * bar);
+	// the llround() implementation sucks.  Don't us it.
 
-	// shift back
-	foo /= bar;
-	return foo;
+	F32 sign = (foo > 0.f) ? 1.f : -1.f;
+	F32 new_foo = F32( S64(foo * bar + sign * 0.5f));
+	new_foo /= bar;
+
+	return new_foo;
 }
 
 inline F32 lerp(F32 a, F32 b, F32 u) 
@@ -516,4 +498,45 @@ inline F32 llgaussian(F32 x, F32 o)
 	return 1.f/(F_SQRT_TWO_PI*o)*powf(F_E, -(x*x)/(2*o*o));
 }
 
+//helper function for removing outliers
+template <class VEC_TYPE>
+inline void ll_remove_outliers(std::vector<VEC_TYPE>& data, F32 k)
+{
+	if (data.size() < 100)
+	{ //not enough samples
+		return;
+	}
+
+	VEC_TYPE Q1 = data[data.size()/4];
+	VEC_TYPE Q3 = data[data.size()-data.size()/4-1];
+
+	VEC_TYPE min = (VEC_TYPE) ((F32) Q1-k * (F32) (Q3-Q1));
+	VEC_TYPE max = (VEC_TYPE) ((F32) Q3+k * (F32) (Q3-Q1));
+
+	U32 i = 0;
+	while (i < data.size() && data[i] < min)
+	{
+		i++;
+	}
+
+	S32 j = data.size()-1;
+	while (j > 0 && data[j] > max)
+	{
+		j--;
+	}
+
+	if (j < data.size()-1)
+	{
+		data.erase(data.begin()+j, data.end());
+	}
+
+	if (i > 0)
+	{
+		data.erase(data.begin(), data.begin()+i);
+	}
+}
+
+// Include simd math header
+#include "llsimdmath.h"
+
 #endif
diff --git a/indra/llmath/llmatrix3a.cpp b/indra/llmath/llmatrix3a.cpp
new file mode 100644
index 0000000000..ab077abcb0
--- /dev/null
+++ b/indra/llmath/llmatrix3a.cpp
@@ -0,0 +1,134 @@
+/** 
+ * @file llvector4a.cpp
+ * @brief SIMD vector implementation
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llmath.h"
+
+static LL_ALIGN_16(const F32 M_IDENT_3A[12]) = 
+												{	1.f, 0.f, 0.f, 0.f, // Column 1
+													0.f, 1.f, 0.f, 0.f, // Column 2
+													0.f, 0.f, 1.f, 0.f }; // Column 3
+
+extern const LLMatrix3a LL_M3A_IDENTITY = *reinterpret_cast<const LLMatrix3a*> (M_IDENT_3A);
+
+void LLMatrix3a::setMul( const LLMatrix3a& lhs, const LLMatrix3a& rhs )
+{
+	const LLVector4a col0 = lhs.getColumn(0);
+	const LLVector4a col1 = lhs.getColumn(1);
+	const LLVector4a col2 = lhs.getColumn(2);
+
+	for ( int i = 0; i < 3; i++ )
+	{
+		LLVector4a xxxx = _mm_load_ss( rhs.mColumns[i].getF32ptr() );
+		xxxx.splat<0>( xxxx );
+		xxxx.mul( col0 );
+
+		{
+			LLVector4a yyyy = _mm_load_ss( rhs.mColumns[i].getF32ptr() +  1 );
+			yyyy.splat<0>( yyyy );
+			yyyy.mul( col1 ); 
+			xxxx.add( yyyy );
+		}
+
+		{
+			LLVector4a zzzz = _mm_load_ss( rhs.mColumns[i].getF32ptr() +  2 );
+			zzzz.splat<0>( zzzz );
+			zzzz.mul( col2 );
+			xxxx.add( zzzz );
+		}
+
+		xxxx.store4a( mColumns[i].getF32ptr() );
+	}
+	
+}
+
+/*static */void LLMatrix3a::batchTransform( const LLMatrix3a& xform, const LLVector4a* src, int numVectors, LLVector4a* dst )
+{
+	const LLVector4a col0 = xform.getColumn(0);
+	const LLVector4a col1 = xform.getColumn(1);
+	const LLVector4a col2 = xform.getColumn(2);
+	const LLVector4a* maxAddr = src + numVectors;
+
+	if ( numVectors & 0x1 )
+	{
+		LLVector4a xxxx = _mm_load_ss( (const F32*)src );
+		LLVector4a yyyy = _mm_load_ss( (const F32*)src + 1 );
+		LLVector4a zzzz = _mm_load_ss( (const F32*)src + 2 );
+		xxxx.splat<0>( xxxx );
+		yyyy.splat<0>( yyyy );
+		zzzz.splat<0>( zzzz );
+		xxxx.mul( col0 );
+		yyyy.mul( col1 ); 
+		zzzz.mul( col2 );
+		xxxx.add( yyyy );
+		xxxx.add( zzzz );
+		xxxx.store4a( (F32*)dst );
+		src++;
+		dst++;
+	}
+
+
+	numVectors >>= 1;
+	while ( src < maxAddr )
+	{
+		_mm_prefetch( (const char*)(src + 32 ), _MM_HINT_NTA );
+		_mm_prefetch( (const char*)(dst + 32), _MM_HINT_NTA );
+		LLVector4a xxxx = _mm_load_ss( (const F32*)src );
+		LLVector4a xxxx1= _mm_load_ss( (const F32*)(src + 1) );
+
+		xxxx.splat<0>( xxxx );
+		xxxx1.splat<0>( xxxx1 );
+		xxxx.mul( col0 );
+		xxxx1.mul( col0 );
+
+		{
+			LLVector4a yyyy = _mm_load_ss( (const F32*)src + 1 );
+			LLVector4a yyyy1 = _mm_load_ss( (const F32*)(src + 1) + 1);
+			yyyy.splat<0>( yyyy );
+			yyyy1.splat<0>( yyyy1 );
+			yyyy.mul( col1 );
+			yyyy1.mul( col1 );
+			xxxx.add( yyyy );
+			xxxx1.add( yyyy1 );
+		}
+
+		{
+			LLVector4a zzzz = _mm_load_ss( (const F32*)(src) + 2 );
+			LLVector4a zzzz1 = _mm_load_ss( (const F32*)(++src) + 2 );
+			zzzz.splat<0>( zzzz );
+			zzzz1.splat<0>( zzzz1 );
+			zzzz.mul( col2 );
+			zzzz1.mul( col2 );
+			xxxx.add( zzzz );
+			xxxx1.add( zzzz1 );
+		}
+
+		xxxx.store4a(dst->getF32ptr());
+		src++;
+		dst++;
+
+		xxxx1.store4a((F32*)dst++);
+	}
+}
diff --git a/indra/llmath/llmatrix3a.h b/indra/llmath/llmatrix3a.h
new file mode 100644
index 0000000000..adb7e3389d
--- /dev/null
+++ b/indra/llmath/llmatrix3a.h
@@ -0,0 +1,128 @@
+/** 
+ * @file llmatrix3a.h
+ * @brief LLMatrix3a class header file - memory aligned and vectorized 3x3 matrix
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	LL_LLMATRIX3A_H
+#define	LL_LLMATRIX3A_H
+
+/////////////////////////////
+// LLMatrix3a, LLRotation
+/////////////////////////////
+// This class stores a 3x3 (technically 4x3) matrix in column-major order
+/////////////////////////////
+/////////////////////////////
+// These classes are intentionally minimal right now. If you need additional
+// functionality, please contact someone with SSE experience (e.g., Falcon or
+// Huseby).
+/////////////////////////////
+
+// LLMatrix3a is the base class for LLRotation, which should be used instead any time you're dealing with a 
+// rotation matrix.
+class LLMatrix3a
+{
+public:
+
+	// Utility function for quickly transforming an array of LLVector4a's
+	// For transforming a single LLVector4a, see LLVector4a::setRotated
+	static void batchTransform( const LLMatrix3a& xform, const LLVector4a* src, int numVectors, LLVector4a* dst );
+
+	// Utility function to obtain the identity matrix
+	static inline const LLMatrix3a& getIdentity();
+
+	//////////////////////////
+	// Ctors
+	//////////////////////////
+	
+	// Ctor
+	LLMatrix3a() {}
+
+	// Ctor for setting by columns
+	inline LLMatrix3a( const LLVector4a& c0, const LLVector4a& c1, const LLVector4a& c2 );
+
+	//////////////////////////
+	// Get/Set
+	//////////////////////////
+
+	// Loads from an LLMatrix3
+	inline void loadu(const LLMatrix3& src);
+	
+	// Set rows
+	inline void setRows(const LLVector4a& r0, const LLVector4a& r1, const LLVector4a& r2);
+	
+	// Set columns
+	inline void setColumns(const LLVector4a& c0, const LLVector4a& c1, const LLVector4a& c2);
+
+	// Get the read-only access to a specified column. Valid columns are 0-2, but the 
+	// function is unchecked. You've been warned.
+	inline const LLVector4a& getColumn(const U32 column) const;
+
+	/////////////////////////
+	// Matrix modification
+	/////////////////////////
+	
+	// Set this matrix to the product of lhs and rhs ( this = lhs * rhs )
+	void setMul( const LLMatrix3a& lhs, const LLMatrix3a& rhs );
+
+	// Set this matrix to the transpose of src
+	inline void setTranspose(const LLMatrix3a& src);
+
+	// Set this matrix to a*w + b*(1-w)
+	inline void setLerp(const LLMatrix3a& a, const LLMatrix3a& b, F32 w);
+
+	/////////////////////////
+	// Matrix inspection
+	/////////////////////////
+
+	// Sets all 4 elements in 'dest' to the determinant of this matrix.
+	// If you will be using the determinant in subsequent ops with LLVector4a, use this version
+	inline void getDeterminant( LLVector4a& dest ) const;
+
+	// Returns the determinant as an LLSimdScalar. Use this if you will be using the determinant
+	// primary for scalar operations.
+	inline LLSimdScalar getDeterminant() const;
+
+	// Returns nonzero if rows 0-2 and colums 0-2 contain no NaN or INF values. Row 3 is ignored
+	inline LLBool32 isFinite() const;
+
+	// Returns true if this matrix is equal to 'rhs' up to 'tolerance'
+	inline bool isApproximatelyEqual( const LLMatrix3a& rhs, F32 tolerance = F_APPROXIMATELY_ZERO ) const;
+
+protected:
+
+	LLVector4a mColumns[3];
+
+};
+
+class LLRotation : public LLMatrix3a
+{
+public:
+	
+	LLRotation() {}
+	
+	// Returns true if this rotation is orthonormal with det ~= 1
+	inline bool isOkRotation() const;		
+};
+
+#endif
diff --git a/indra/llmath/llmatrix3a.inl b/indra/llmath/llmatrix3a.inl
new file mode 100644
index 0000000000..37819fea3c
--- /dev/null
+++ b/indra/llmath/llmatrix3a.inl
@@ -0,0 +1,119 @@
+/** 
+ * @file llmatrix3a.inl
+ * @brief LLMatrix3a inline definitions
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llmatrix3a.h"
+#include "m3math.h"
+
+inline LLMatrix3a::LLMatrix3a( const LLVector4a& c0, const LLVector4a& c1, const LLVector4a& c2 )
+{
+	setColumns( c0, c1, c2 );
+}
+
+inline void LLMatrix3a::loadu(const LLMatrix3& src)
+{
+	mColumns[0].load3(src.mMatrix[0]);
+	mColumns[1].load3(src.mMatrix[1]);
+	mColumns[2].load3(src.mMatrix[2]);
+}
+
+inline void LLMatrix3a::setRows(const LLVector4a& r0, const LLVector4a& r1, const LLVector4a& r2)
+{
+	mColumns[0] = r0;
+	mColumns[1] = r1;
+	mColumns[2] = r2;
+	setTranspose( *this );
+}
+
+inline void LLMatrix3a::setColumns(const LLVector4a& c0, const LLVector4a& c1, const LLVector4a& c2)
+{
+	mColumns[0] = c0;
+	mColumns[1] = c1;
+	mColumns[2] = c2;
+}
+
+inline void LLMatrix3a::setTranspose(const LLMatrix3a& src)
+{
+	const LLQuad srcCol0 = src.mColumns[0];
+	const LLQuad srcCol1 = src.mColumns[1];
+	const LLQuad unpacklo = _mm_unpacklo_ps( srcCol0, srcCol1 );
+	mColumns[0] = _mm_movelh_ps( unpacklo, src.mColumns[2] );
+	mColumns[1] = _mm_shuffle_ps( _mm_movehl_ps( srcCol0, unpacklo ), src.mColumns[2], _MM_SHUFFLE(0, 1, 1, 0) );
+	mColumns[2] = _mm_shuffle_ps( _mm_unpackhi_ps( srcCol0, srcCol1 ), src.mColumns[2], _MM_SHUFFLE(0, 2, 1, 0) );
+}
+
+inline const LLVector4a& LLMatrix3a::getColumn(const U32 column) const
+{
+	llassert( column < 3 );
+	return mColumns[column];
+}
+
+inline void LLMatrix3a::setLerp(const LLMatrix3a& a, const LLMatrix3a& b, F32 w)
+{
+	mColumns[0].setLerp( a.mColumns[0], b.mColumns[0], w );
+	mColumns[1].setLerp( a.mColumns[1], b.mColumns[1], w );
+	mColumns[2].setLerp( a.mColumns[2], b.mColumns[2], w );
+}
+
+inline LLBool32 LLMatrix3a::isFinite() const
+{
+	return mColumns[0].isFinite3() && mColumns[1].isFinite3() && mColumns[2].isFinite3();
+}
+
+inline void LLMatrix3a::getDeterminant( LLVector4a& dest ) const
+{
+	LLVector4a col1xcol2; col1xcol2.setCross3( mColumns[1], mColumns[2] );
+	dest.setAllDot3( col1xcol2, mColumns[0] );
+}
+
+inline LLSimdScalar LLMatrix3a::getDeterminant() const
+{
+	LLVector4a col1xcol2; col1xcol2.setCross3( mColumns[1], mColumns[2] );
+	return col1xcol2.dot3( mColumns[0] );
+}
+
+inline bool LLMatrix3a::isApproximatelyEqual( const LLMatrix3a& rhs, F32 tolerance /*= F_APPROXIMATELY_ZERO*/ ) const
+{
+	return rhs.getColumn(0).equals3(mColumns[0], tolerance) 
+		&& rhs.getColumn(1).equals3(mColumns[1], tolerance) 
+		&& rhs.getColumn(2).equals3(mColumns[2], tolerance); 
+}
+
+inline const LLMatrix3a& LLMatrix3a::getIdentity()
+{
+	extern const LLMatrix3a LL_M3A_IDENTITY;
+	return LL_M3A_IDENTITY;
+}
+
+inline bool LLRotation::isOkRotation() const
+{
+	LLMatrix3a transpose; transpose.setTranspose( *this );
+	LLMatrix3a product; product.setMul( *this, transpose );
+
+	LLSimdScalar detMinusOne = getDeterminant() - 1.f;
+
+	return product.isApproximatelyEqual( LLMatrix3a::getIdentity() ) && (detMinusOne.getAbs() < F_APPROXIMATELY_ZERO);
+}
+
diff --git a/indra/llmath/llmatrix4a.h b/indra/llmath/llmatrix4a.h
new file mode 100644
index 0000000000..27cf5b79f6
--- /dev/null
+++ b/indra/llmath/llmatrix4a.h
@@ -0,0 +1,143 @@
+/** 
+ * @file llmatrix4a.h
+ * @brief LLMatrix4a class header file - memory aligned and vectorized 4x4 matrix
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	LL_LLMATRIX4A_H
+#define	LL_LLMATRIX4A_H
+
+#include "llvector4a.h"
+#include "m4math.h"
+#include "m3math.h"
+
+class LLMatrix4a
+{
+public:
+	LLVector4a mMatrix[4];
+
+	inline void clear()
+	{
+		mMatrix[0].clear();
+		mMatrix[1].clear();
+		mMatrix[2].clear();
+		mMatrix[3].clear();
+	}
+
+	inline void loadu(const LLMatrix4& src)
+	{
+		mMatrix[0] = _mm_loadu_ps(src.mMatrix[0]);
+		mMatrix[1] = _mm_loadu_ps(src.mMatrix[1]);
+		mMatrix[2] = _mm_loadu_ps(src.mMatrix[2]);
+		mMatrix[3] = _mm_loadu_ps(src.mMatrix[3]);
+		
+	}
+
+	inline void loadu(const LLMatrix3& src)
+	{
+		mMatrix[0].load3(src.mMatrix[0]);
+		mMatrix[1].load3(src.mMatrix[1]);
+		mMatrix[2].load3(src.mMatrix[2]);
+		mMatrix[3].set(0,0,0,1.f);
+	}
+
+	inline void add(const LLMatrix4a& rhs)
+	{
+		mMatrix[0].add(rhs.mMatrix[0]);
+		mMatrix[1].add(rhs.mMatrix[1]);
+		mMatrix[2].add(rhs.mMatrix[2]);
+		mMatrix[3].add(rhs.mMatrix[3]);
+	}
+
+	inline void setRows(const LLVector4a& r0, const LLVector4a& r1, const LLVector4a& r2)
+	{
+		mMatrix[0] = r0;
+		mMatrix[1] = r1;
+		mMatrix[2] = r2;
+	}
+
+	inline void setMul(const LLMatrix4a& m, const F32 s)
+	{
+		mMatrix[0].setMul(m.mMatrix[0], s);
+		mMatrix[1].setMul(m.mMatrix[1], s);
+		mMatrix[2].setMul(m.mMatrix[2], s);
+		mMatrix[3].setMul(m.mMatrix[3], s);
+	}
+
+	inline void setLerp(const LLMatrix4a& a, const LLMatrix4a& b, F32 w)
+	{
+		LLVector4a d0,d1,d2,d3;
+		d0.setSub(b.mMatrix[0], a.mMatrix[0]);
+		d1.setSub(b.mMatrix[1], a.mMatrix[1]);
+		d2.setSub(b.mMatrix[2], a.mMatrix[2]);
+		d3.setSub(b.mMatrix[3], a.mMatrix[3]);
+
+		// this = a + d*w
+		
+		d0.mul(w);
+		d1.mul(w);
+		d2.mul(w);
+		d3.mul(w);
+
+		mMatrix[0].setAdd(a.mMatrix[0],d0);
+		mMatrix[1].setAdd(a.mMatrix[1],d1);
+		mMatrix[2].setAdd(a.mMatrix[2],d2);
+		mMatrix[3].setAdd(a.mMatrix[3],d3);
+	}
+
+	inline void rotate(const LLVector4a& v, LLVector4a& res)
+	{
+		res = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
+		res.mul(mMatrix[0]);
+		
+		LLVector4a y;
+		y = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
+		y.mul(mMatrix[1]);
+
+		LLVector4a z;
+		z = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
+		z.mul(mMatrix[2]);
+
+		res.add(y);
+		res.add(z);
+	}
+
+	inline void affineTransform(const LLVector4a& v, LLVector4a& res)
+	{
+		LLVector4a x,y,z;
+
+		x = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
+		y = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
+		z = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
+		
+		x.mul(mMatrix[0]);
+		y.mul(mMatrix[1]);
+		z.mul(mMatrix[2]);
+
+		x.add(y);
+		z.add(mMatrix[3]);
+		res.setAdd(x,z);
+	}
+};
+
+#endif
diff --git a/indra/llmath/lloctree.h b/indra/llmath/lloctree.h
index 90d4d742c9..fdfc24f8b7 100644
--- a/indra/llmath/lloctree.h
+++ b/indra/llmath/lloctree.h
@@ -29,14 +29,11 @@
 
 #include "lltreenode.h"
 #include "v3math.h"
+#include "llvector4a.h"
 #include <vector>
 #include <set>
 
-#if LL_RELEASE_WITH_DEBUG_INFO || LL_DEBUG
-#define OCT_ERRS LL_ERRS("OctreeErrors")
-#else
 #define OCT_ERRS LL_WARNS("OctreeErrors")
-#endif
 
 #define LL_OCTREE_PARANOIA_CHECK 0
 #if LL_DARWIN
@@ -67,6 +64,13 @@ public:
 };
 
 template <class T>
+class LLOctreeTravelerDepthFirst : public LLOctreeTraveler<T>
+{
+public:
+	virtual void traverse(const LLOctreeNode<T>* node);
+};
+
+template <class T>
 class LLOctreeNode : public LLTreeNode<T>
 {
 public:
@@ -81,23 +85,30 @@ public:
 	typedef LLOctreeNode<T>		oct_node;
 	typedef LLOctreeListener<T>	oct_listener;
 
-	static const U8 OCTANT_POSITIVE_X = 0x01;
-	static const U8 OCTANT_POSITIVE_Y = 0x02;
-	static const U8 OCTANT_POSITIVE_Z = 0x04;
-		
-	LLOctreeNode(	LLVector3d center, 
-					LLVector3d size, 
+	/*void* operator new(size_t size)
+	{
+		return ll_aligned_malloc_16(size);
+	}
+
+	void operator delete(void* ptr)
+	{
+		ll_aligned_free_16(ptr);
+	}*/
+
+	LLOctreeNode(	const LLVector4a& center, 
+					const LLVector4a& size, 
 					BaseType* parent, 
 					U8 octant = 255)
 	:	mParent((oct_node*)parent), 
-		mCenter(center), 
-		mSize(size), 
 		mOctant(octant) 
 	{ 
+		mCenter = center;
+		mSize = size;
+
 		updateMinMax();
 		if ((mOctant == 255) && mParent)
 		{
-			mOctant = ((oct_node*) mParent)->getOctant(mCenter.mdV);
+			mOctant = ((oct_node*) mParent)->getOctant(mCenter);
 		}
 
 		clearChildren();
@@ -114,40 +125,24 @@ public:
 	}
 
 	inline const BaseType* getParent()	const			{ return mParent; }
-	inline void setParent(BaseType* parent)			{ mParent = (oct_node*) parent; }
-	inline const LLVector3d& getCenter() const			{ return mCenter; }
-	inline const LLVector3d& getSize() const			{ return mSize; }
-	inline void setCenter(LLVector3d center)			{ mCenter = center; }
-	inline void setSize(LLVector3d size)				{ mSize = size; }
-    inline oct_node* getNodeAt(T* data)				{ return getNodeAt(data->getPositionGroup(), data->getBinRadius()); }
-	inline U8 getOctant() const						{ return mOctant; }
-	inline void setOctant(U8 octant)					{ mOctant = octant; }
+	inline void setParent(BaseType* parent)				{ mParent = (oct_node*) parent; }
+	inline const LLVector4a& getCenter() const			{ return mCenter; }
+	inline const LLVector4a& getSize() const			{ return mSize; }
+	inline void setCenter(const LLVector4a& center)		{ mCenter = center; }
+	inline void setSize(const LLVector4a& size)			{ mSize = size; }
+    inline oct_node* getNodeAt(T* data)					{ return getNodeAt(data->getPositionGroup(), data->getBinRadius()); }
+	inline U8 getOctant() const							{ return mOctant; }
 	inline const oct_node*	getOctParent() const		{ return (const oct_node*) getParent(); }
 	inline oct_node* getOctParent() 					{ return (oct_node*) getParent(); }
 	
-	U8 getOctant(const F64 pos[]) const	//get the octant pos is in
+	U8 getOctant(const LLVector4a& pos) const			//get the octant pos is in
 	{
-		U8 ret = 0;
-
-		if (pos[0] > mCenter.mdV[0])
-		{
-			ret |= OCTANT_POSITIVE_X;
-		}
-		if (pos[1] > mCenter.mdV[1])
-		{
-			ret |= OCTANT_POSITIVE_Y;
-		}
-		if (pos[2] > mCenter.mdV[2])
-		{
-			ret |= OCTANT_POSITIVE_Z;
-		}
-
-		return ret;
+		return (U8) (pos.greaterThan(mCenter).getGatheredBits() & 0x7);
 	}
 	
-	inline bool isInside(const LLVector3d& pos, const F64& rad) const
+	inline bool isInside(const LLVector4a& pos, const F32& rad) const
 	{
-		return rad <= mSize.mdV[0]*2.0 && isInside(pos); 
+		return rad <= mSize[0]*2.f && isInside(pos); 
 	}
 
 	inline bool isInside(T* data) const			
@@ -155,29 +150,27 @@ public:
 		return isInside(data->getPositionGroup(), data->getBinRadius());
 	}
 
-	bool isInside(const LLVector3d& pos) const
+	bool isInside(const LLVector4a& pos) const
 	{
-		const F64& x = pos.mdV[0];
-		const F64& y = pos.mdV[1];
-		const F64& z = pos.mdV[2];
-			
-		if (x > mMax.mdV[0] || x <= mMin.mdV[0] ||
-			y > mMax.mdV[1] || y <= mMin.mdV[1] ||
-			z > mMax.mdV[2] || z <= mMin.mdV[2])
+		S32 gt = pos.greaterThan(mMax).getGatheredBits() & 0x7;
+		if (gt)
 		{
 			return false;
 		}
-		
+
+		S32 lt = pos.lessEqual(mMin).getGatheredBits() & 0x7;
+		if (lt)
+		{
+			return false;
+		}
+				
 		return true;
 	}
 	
 	void updateMinMax()
 	{
-		for (U32 i = 0; i < 3; i++)
-		{
-			mMax.mdV[i] = mCenter.mdV[i] + mSize.mdV[i];
-			mMin.mdV[i] = mCenter.mdV[i] - mSize.mdV[i];
-		}
+		mMax.setAdd(mCenter, mSize);
+		mMin.setSub(mCenter, mSize);
 	}
 
 	inline oct_listener* getOctListener(U32 index) 
@@ -190,34 +183,34 @@ public:
 		return contains(xform->getBinRadius());
 	}
 
-	bool contains(F64 radius)
+	bool contains(F32 radius)
 	{
 		if (mParent == NULL)
 		{	//root node contains nothing
 			return false;
 		}
 
-		F64 size = mSize.mdV[0];
-		F64 p_size = size * 2.0;
+		F32 size = mSize[0];
+		F32 p_size = size * 2.f;
 
-		return (radius <= 0.001 && size <= 0.001) ||
+		return (radius <= 0.001f && size <= 0.001f) ||
 				(radius <= p_size && radius > size);
 	}
 
-	static void pushCenter(LLVector3d &center, const LLVector3d &size, const T* data)
+	static void pushCenter(LLVector4a &center, const LLVector4a &size, const T* data)
 	{
-		const LLVector3d& pos = data->getPositionGroup();
-		for (U32 i = 0; i < 3; i++)
-		{
-			if (pos.mdV[i] > center.mdV[i])
-			{
-				center.mdV[i] += size.mdV[i];
-			}
-			else 
-			{
-				center.mdV[i] -= size.mdV[i];
-			}
-		}
+		const LLVector4a& pos = data->getPositionGroup();
+
+		LLVector4Logical gt = pos.greaterThan(center);
+
+		LLVector4a up;
+		up = _mm_and_ps(size, gt);
+
+		LLVector4a down;
+		down = _mm_andnot_ps(gt, size);
+
+		center.add(up);
+		center.sub(down);
 	}
 
 	void accept(oct_traveler* visitor)				{ visitor->visit(this); }
@@ -236,32 +229,49 @@ public:
 	void accept(tree_traveler* visitor) const		{ visitor->visit(this); }
 	void accept(oct_traveler* visitor) const		{ visitor->visit(this); }
 	
-	oct_node* getNodeAt(const LLVector3d& pos, const F64& rad)
+	void validateChildMap()
+	{
+		for (U32 i = 0; i < 8; i++)
+		{
+			U8 idx = mChildMap[i];
+			if (idx != 255)
+			{
+				LLOctreeNode<T>* child = mChild[idx];
+
+				if (child->getOctant() != i)
+				{
+					llerrs << "Invalid child map, bad octant data." << llendl;
+				}
+
+				if (getOctant(child->getCenter()) != child->getOctant())
+				{
+					llerrs << "Invalid child octant compared to position data." << llendl;
+				}
+			}
+		}
+	}
+
+
+	oct_node* getNodeAt(const LLVector4a& pos, const F32& rad)
 	{ 
 		LLOctreeNode<T>* node = this;
 
 		if (node->isInside(pos, rad))
 		{		
 			//do a quick search by octant
-			U8 octant = node->getOctant(pos.mdV);
-			BOOL keep_going = TRUE;
-
+			U8 octant = node->getOctant(pos);
+			
 			//traverse the tree until we find a node that has no node
 			//at the appropriate octant or is smaller than the object.  
 			//by definition, that node is the smallest node that contains 
 			// the data
-			while (keep_going && node->getSize().mdV[0] >= rad)
+			U8 next_node = node->mChildMap[octant];
+			
+			while (next_node != 255 && node->getSize()[0] >= rad)
 			{	
-				keep_going = FALSE;
-				for (U32 i = 0; i < node->getChildCount() && !keep_going; i++)
-				{
-					if (node->getChild(i)->getOctant() == octant)
-					{
-						node = node->getChild(i);
-						octant = node->getOctant(pos.mdV);
-						keep_going = TRUE;
-					}
-				}
+				node = node->getChild(next_node);
+				octant = node->getOctant(pos);
+				next_node = node->mChildMap[octant];
 			}
 		}
 		else if (!node->contains(rad) && node->getParent())
@@ -276,7 +286,7 @@ public:
 	{
 		if (data == NULL)
 		{
-			//OCT_ERRS << "!!! INVALID ELEMENT ADDED TO OCTREE BRANCH !!!" << llendl;
+			OCT_ERRS << "!!! INVALID ELEMENT ADDED TO OCTREE BRANCH !!!" << llendl;
 			return false;
 		}
 		LLOctreeNode<T>* parent = getOctParent();
@@ -284,10 +294,8 @@ public:
 		//is it here?
 		if (isInside(data->getPositionGroup()))
 		{
-			if (getElementCount() < LL_OCTREE_MAX_CAPACITY &&
-				(contains(data->getBinRadius()) ||
-				(data->getBinRadius() > getSize().mdV[0] &&
-				parent && parent->getElementCount() >= LL_OCTREE_MAX_CAPACITY))) 
+			if ((getElementCount() < LL_OCTREE_MAX_CAPACITY && contains(data->getBinRadius()) ||
+				(data->getBinRadius() > getSize()[0] &&	parent && parent->getElementCount() >= LL_OCTREE_MAX_CAPACITY))) 
 			{ //it belongs here
 #if LL_OCTREE_PARANOIA_CHECK
 				//if this is a redundant insertion, error out (should never happen)
@@ -317,16 +325,21 @@ public:
 				}
 				
 				//it's here, but no kids are in the right place, make a new kid
-				LLVector3d center(getCenter());
-				LLVector3d size(getSize()*0.5);
+				LLVector4a center = getCenter();
+				LLVector4a size = getSize();
+				size.mul(0.5f);
 		        		
 				//push center in direction of data
 				LLOctreeNode<T>::pushCenter(center, size, data);
 
 				// handle case where floating point number gets too small
-				if( llabs(center.mdV[0] - getCenter().mdV[0]) < F_APPROXIMATELY_ZERO &&
-					llabs(center.mdV[1] - getCenter().mdV[1]) < F_APPROXIMATELY_ZERO &&
-					llabs(center.mdV[2] - getCenter().mdV[2]) < F_APPROXIMATELY_ZERO)
+				LLVector4a val;
+				val.setSub(center, getCenter());
+				val.setAbs(val);
+								
+				S32 lt = val.lessThan(LLVector4a::getEpsilon()).getGatheredBits() & 0x7;
+
+				if( lt == 0x7 )
 				{
 					mData.insert(data);
 					BaseType::insert(data);
@@ -344,7 +357,7 @@ public:
 				//make sure no existing node matches this position
 				for (U32 i = 0; i < getChildCount(); i++)
 				{
-					if (mChild[i]->getCenter() == center)
+					if (mChild[i]->getCenter().equals3(center))
 					{
 						OCT_ERRS << "Octree detected duplicate child center and gave up." << llendl;
 						return false;
@@ -362,7 +375,7 @@ public:
 		else 
 		{
 			//it's not in here, give it to the root
-			//OCT_ERRS << "Octree insertion failed, starting over from root!" << llendl;
+			OCT_ERRS << "Octree insertion failed, starting over from root!" << llendl;
 
 			oct_node* node = this;
 
@@ -436,6 +449,9 @@ public:
 	void clearChildren()
 	{
 		mChild.clear();
+
+		U32* foo = (U32*) mChildMap;
+		foo[0] = foo[1] = 0xFFFFFFFF;
 	}
 
 	void validate()
@@ -469,13 +485,19 @@ public:
 	void addChild(oct_node* child, BOOL silent = FALSE) 
 	{
 #if LL_OCTREE_PARANOIA_CHECK
+
+		if (child->getSize().equals3(getSize()))
+		{
+			OCT_ERRS << "Child size is same as parent size!" << llendl;
+		}
+
 		for (U32 i = 0; i < getChildCount(); i++)
 		{
-			if(mChild[i]->getSize() != child->getSize()) 
+			if(!mChild[i]->getSize().equals3(child->getSize())) 
 			{
 				OCT_ERRS <<"Invalid octree child size." << llendl;
 			}
-			if (mChild[i]->getCenter() == child->getCenter())
+			if (mChild[i]->getCenter().equals3(child->getCenter()))
 			{
 				OCT_ERRS <<"Duplicate octree child position." << llendl;
 			}
@@ -487,6 +509,8 @@ public:
 		}
 #endif
 
+		mChildMap[child->getOctant()] = (U8) mChild.size();
+
 		mChild.push_back(child);
 		child->setParent(this);
 
@@ -500,7 +524,7 @@ public:
 		}
 	}
 
-	void removeChild(U8 index, BOOL destroy = FALSE)
+	void removeChild(S32 index, BOOL destroy = FALSE)
 	{
 		for (U32 i = 0; i < this->getListenerCount(); i++)
 		{
@@ -508,6 +532,8 @@ public:
 			listener->handleChildRemoval(this, getChild(index));
 		}
 
+		
+
 		if (destroy)
 		{
 			mChild[index]->destroy();
@@ -515,6 +541,15 @@ public:
 		}
 		mChild.erase(mChild.begin() + index);
 
+		//rebuild child map
+		U32* foo = (U32*) mChildMap;
+		foo[0] = foo[1] = 0xFFFFFFFF;
+
+		for (U32 i = 0; i < mChild.size(); ++i)
+		{
+			mChildMap[mChild[i]->getOctant()] = i;
+		}
+
 		checkAlive();
 	}
 
@@ -541,19 +576,32 @@ public:
 			}
 		}
 
-		//OCT_ERRS << "Octree failed to delete requested child." << llendl;
+		OCT_ERRS << "Octree failed to delete requested child." << llendl;
 	}
 
 protected:	
-	child_list mChild;
-	element_list mData;
+	typedef enum
+	{
+		CENTER = 0,
+		SIZE = 1,
+		MAX = 2,
+		MIN = 3
+	} eDName;
+
+	LLVector4a mCenter;
+	LLVector4a mSize;
+	LLVector4a mMax;
+	LLVector4a mMin;
+	
 	oct_node* mParent;
-	LLVector3d mCenter;
-	LLVector3d mSize;
-	LLVector3d mMax;
-	LLVector3d mMin;
 	U8 mOctant;
-};
+
+	child_list mChild;
+	U8 mChildMap[8];
+
+	element_list mData;
+		
+}; 
 
 //just like a regular node, except it might expand on insert and compress on balance
 template <class T>
@@ -563,9 +611,9 @@ public:
 	typedef LLOctreeNode<T>	BaseType;
 	typedef LLOctreeNode<T>		oct_node;
 
-	LLOctreeRoot(	LLVector3d center, 
-					LLVector3d size, 
-					BaseType* parent)
+	LLOctreeRoot(const LLVector4a& center, 
+				 const LLVector4a& size, 
+				 BaseType* parent)
 	:	BaseType(center, size, parent)
 	{
 	}
@@ -596,6 +644,8 @@ public:
 			//destroy child
 			child->clearChildren();
 			delete child;
+
+			return false;
 		}
 		
 		return true;
@@ -606,28 +656,33 @@ public:
 	{
 		if (data == NULL) 
 		{
-			//OCT_ERRS << "!!! INVALID ELEMENT ADDED TO OCTREE ROOT !!!" << llendl;
+			OCT_ERRS << "!!! INVALID ELEMENT ADDED TO OCTREE ROOT !!!" << llendl;
 			return false;
 		}
 		
 		if (data->getBinRadius() > 4096.0)
 		{
-			//OCT_ERRS << "!!! ELEMENT EXCEEDS MAXIMUM SIZE IN OCTREE ROOT !!!" << llendl;
+			OCT_ERRS << "!!! ELEMENT EXCEEDS MAXIMUM SIZE IN OCTREE ROOT !!!" << llendl;
 			return false;
 		}
 		
-		const F64 MAX_MAG = 1024.0*1024.0;
+		LLVector4a MAX_MAG;
+		MAX_MAG.splat(1024.f*1024.f);
 
-		const LLVector3d& v = data->getPositionGroup();
-		if (!(fabs(v.mdV[0]-this->mCenter.mdV[0]) < MAX_MAG &&
-		      fabs(v.mdV[1]-this->mCenter.mdV[1]) < MAX_MAG &&
-		      fabs(v.mdV[2]-this->mCenter.mdV[2]) < MAX_MAG))
+		const LLVector4a& v = data->getPositionGroup();
+
+		LLVector4a val;
+		val.setSub(v, BaseType::mCenter);
+		val.setAbs(val);
+		S32 lt = val.lessThan(MAX_MAG).getGatheredBits() & 0x7;
+
+		if (lt != 0x7)
 		{
-			//OCT_ERRS << "!!! ELEMENT EXCEEDS RANGE OF SPATIAL PARTITION !!!" << llendl;
+			OCT_ERRS << "!!! ELEMENT EXCEEDS RANGE OF SPATIAL PARTITION !!!" << llendl;
 			return false;
 		}
 
-		if (this->getSize().mdV[0] > data->getBinRadius() && isInside(data->getPositionGroup()))
+		if (this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup()))
 		{
 			//we got it, just act like a branch
 			oct_node* node = getNodeAt(data);
@@ -643,31 +698,34 @@ public:
 		else if (this->getChildCount() == 0)
 		{
 			//first object being added, just wrap it up
-			while (!(this->getSize().mdV[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
+			while (!(this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
 			{
-				LLVector3d center, size;
+				LLVector4a center, size;
 				center = this->getCenter();
 				size = this->getSize();
 				LLOctreeNode<T>::pushCenter(center, size, data);
 				this->setCenter(center);
-				this->setSize(size*2);
+				size.mul(2.f);
+				this->setSize(size);
 				this->updateMinMax();
 			}
 			LLOctreeNode<T>::insert(data);
 		}
 		else
 		{
-			while (!(this->getSize().mdV[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
+			while (!(this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
 			{
 				//the data is outside the root node, we need to grow
-				LLVector3d center(this->getCenter());
-				LLVector3d size(this->getSize());
+				LLVector4a center(this->getCenter());
+				LLVector4a size(this->getSize());
 
 				//expand this node
-				LLVector3d newcenter(center);
+				LLVector4a newcenter(center);
 				LLOctreeNode<T>::pushCenter(newcenter, size, data);
 				this->setCenter(newcenter);
-				this->setSize(size*2);
+				LLVector4a size2 = size;
+				size2.mul(2.f);
+				this->setSize(size2);
 				this->updateMinMax();
 
 				//copy our children to a new branch
@@ -704,4 +762,15 @@ void LLOctreeTraveler<T>::traverse(const LLOctreeNode<T>* node)
 		traverse(node->getChild(i));
 	}
 }
+
+template <class T>
+void LLOctreeTravelerDepthFirst<T>::traverse(const LLOctreeNode<T>* node)
+{
+	for (U32 i = 0; i < node->getChildCount(); i++)
+	{
+		traverse(node->getChild(i));
+	}
+	node->accept(this);
+}
+
 #endif
diff --git a/indra/llmath/llplane.h b/indra/llmath/llplane.h
index 443f3f46b9..a611894721 100644
--- a/indra/llmath/llplane.h
+++ b/indra/llmath/llplane.h
@@ -36,19 +36,23 @@
 // The plane normal = [A, B, C]
 // The closest approach = D / sqrt(A*A + B*B + C*C)
 
-class LLPlane : public LLVector4
+class LLPlane
 {
 public:
+	
+	// Constructors
 	LLPlane() {}; // no default constructor
 	LLPlane(const LLVector3 &p0, F32 d) { setVec(p0, d); }
 	LLPlane(const LLVector3 &p0, const LLVector3 &n) { setVec(p0, n); }
-	void setVec(const LLVector3 &p0, F32 d) { LLVector4::setVec(p0[0], p0[1], p0[2], d); }
-	void setVec(const LLVector3 &p0, const LLVector3 &n)
+	inline void setVec(const LLVector3 &p0, F32 d) { mV.set(p0[0], p0[1], p0[2], d); }
+	
+	// Set
+	inline void setVec(const LLVector3 &p0, const LLVector3 &n)
 	{
 		F32 d = -(p0 * n);
 		setVec(n, d);
 	}
-	void setVec(const LLVector3 &p0, const LLVector3 &p1, const LLVector3 &p2)
+	inline void setVec(const LLVector3 &p0, const LLVector3 &p1, const LLVector3 &p2)
 	{
 		LLVector3 u, v, w;
 		u = p1 - p0;
@@ -58,8 +62,38 @@ public:
 		F32 d = -(w * p0);
 		setVec(w, d);
 	}
-	LLPlane& operator=(const LLVector4& v2) {  LLVector4::setVec(v2[0],v2[1],v2[2],v2[3]); return *this;}
+	
+	inline LLPlane& operator=(const LLVector4& v2) {  mV.set(v2[0],v2[1],v2[2],v2[3]); return *this;}
+	
+	inline LLPlane& operator=(const LLVector4a& v2) {  mV.set(v2[0],v2[1],v2[2],v2[3]); return *this;}	
+	
+	inline void set(const LLPlane& p2) { mV = p2.mV; }
+	
+	// 
 	F32 dist(const LLVector3 &v2) const { return mV[0]*v2[0] + mV[1]*v2[1] + mV[2]*v2[2] + mV[3]; }
+	
+	inline LLSimdScalar dot3(const LLVector4a& b) const { return mV.dot3(b); }
+	
+	// Read-only access a single float in this vector. Do not use in proximity to any function call that manipulates
+	// the data at the whole vector level or you will incur a substantial penalty. Consider using the splat functions instead	
+	inline F32 operator[](const S32 idx) const { return mV[idx]; }
+	
+	// preferable when index is known at compile time
+	template <int N> LL_FORCE_INLINE void getAt(LLSimdScalar& v) const { v = mV.getScalarAt<N>(); } 
+	
+	// reset the vector to 0, 0, 0, 1
+	inline void clear() { mV.set(0, 0, 0, 1); }
+	
+	inline void getVector3(LLVector3& vec) const { vec.set(mV[0], mV[1], mV[2]); }
+	
+	// Retrieve the mask indicating which of the x, y, or z axis are greater or equal to zero.
+	inline U8 calcPlaneMask() 
+	{ 
+		return mV.greaterEqual(LLVector4a::getZero()).getGatheredBits() & LLVector4Logical::MASK_XYZ;
+	}
+		
+private:
+	LLVector4a mV;
 };
 
 
diff --git a/indra/llmath/llquantize.h b/indra/llmath/llquantize.h
index 7f56ff3448..1595dbecf8 100644
--- a/indra/llmath/llquantize.h
+++ b/indra/llmath/llquantize.h
@@ -29,10 +29,16 @@
 #define LL_LLQUANTIZE_H
 
 const U16 U16MAX = 65535;
+LL_ALIGN_16( const F32 F_U16MAX_4A[4] ) = { 65535.f, 65535.f, 65535.f, 65535.f };
+
 const F32 OOU16MAX = 1.f/(F32)(U16MAX);
+LL_ALIGN_16( const F32 F_OOU16MAX_4A[4] ) = { OOU16MAX, OOU16MAX, OOU16MAX, OOU16MAX };
 
 const U8 U8MAX = 255;
+LL_ALIGN_16( const F32 F_U8MAX_4A[4] ) = { 255.f, 255.f, 255.f, 255.f };
+
 const F32 OOU8MAX = 1.f/(F32)(U8MAX);
+LL_ALIGN_16( const F32 F_OOU8MAX_4A[4] ) = { OOU8MAX, OOU8MAX, OOU8MAX, OOU8MAX };
 
 const U8 FIRSTVALIDCHAR = 54;
 const U8 MAXSTRINGVAL = U8MAX - FIRSTVALIDCHAR; //we don't allow newline or null 
diff --git a/indra/llmath/llquaternion.cpp b/indra/llmath/llquaternion.cpp
index a51f11072c..7381d5eb99 100644
--- a/indra/llmath/llquaternion.cpp
+++ b/indra/llmath/llquaternion.cpp
@@ -26,9 +26,10 @@
 
 #include "linden_common.h"
 
+#include "llmath.h"	// for F_PI
+
 #include "llquaternion.h"
 
-#include "llmath.h"	// for F_PI
 //#include "vmath.h"
 #include "v3math.h"
 #include "v3dmath.h"
diff --git a/indra/llmath/llquaternion.h b/indra/llmath/llquaternion.h
index 26da14ae20..ca0dfe206b 100644
--- a/indra/llmath/llquaternion.h
+++ b/indra/llmath/llquaternion.h
@@ -27,7 +27,11 @@
 #ifndef LLQUATERNION_H
 #define LLQUATERNION_H
 
-#include "llmath.h"
+#include <iostream>
+
+#ifndef LLMATH_H //enforce specific include order to avoid tangling inline dependencies
+#error "Please include llmath.h first."
+#endif
 
 class LLVector4;
 class LLVector3;
diff --git a/indra/llmath/llquaternion2.h b/indra/llmath/llquaternion2.h
new file mode 100644
index 0000000000..fd9c0cf3ab
--- /dev/null
+++ b/indra/llmath/llquaternion2.h
@@ -0,0 +1,105 @@
+/** 
+ * @file llquaternion2.h
+ * @brief LLQuaternion2 class header file - SIMD-enabled quaternion class
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	LL_QUATERNION2_H
+#define	LL_QUATERNION2_H
+
+/////////////////////////////
+// LLQuaternion2
+/////////////////////////////
+// This class stores a quaternion x*i + y*j + z*k + w in <x, y, z, w> order
+// (i.e., w in high order element of vector)
+/////////////////////////////
+/////////////////////////////
+// These classes are intentionally minimal right now. If you need additional
+// functionality, please contact someone with SSE experience (e.g., Falcon or
+// Huseby).
+/////////////////////////////
+#include "llquaternion.h"
+
+class LLQuaternion2
+{
+public:
+
+	//////////////////////////
+	// Ctors
+	//////////////////////////
+	
+	// Ctor
+	LLQuaternion2() {}
+
+	// Ctor from LLQuaternion
+	explicit LLQuaternion2( const class LLQuaternion& quat );
+
+	//////////////////////////
+	// Get/Set
+	//////////////////////////
+
+	// Load from an LLQuaternion
+	inline void operator=( const LLQuaternion& quat )
+	{
+		mQ.loadua( quat.mQ );
+	}
+
+	// Return the internal LLVector4a representation of the quaternion
+	inline const LLVector4a& getVector4a() const;
+	inline LLVector4a& getVector4aRw();
+
+	/////////////////////////
+	// Quaternion modification
+	/////////////////////////
+	
+	// Set this quaternion to the conjugate of src
+	inline void setConjugate(const LLQuaternion2& src);
+
+	// Renormalizes the quaternion. Assumes it has nonzero length.
+	inline void normalize();
+
+	// Quantize this quaternion to 8 bit precision
+	inline void quantize8();
+
+	// Quantize this quaternion to 16 bit precision
+	inline void quantize16();
+
+	/////////////////////////
+	// Quaternion inspection
+	/////////////////////////
+
+	// Return true if this quaternion is equal to 'rhs'. 
+	// Note! Quaternions exhibit "double-cover", so any rotation has two equally valid
+	// quaternion representations and they will NOT compare equal.
+	inline bool equals(const LLQuaternion2& rhs, F32 tolerance = F_APPROXIMATELY_ZERO ) const;
+
+	// Return true if all components are finite and the quaternion is normalized
+	inline bool isOkRotation() const;
+
+protected:
+
+	LLVector4a mQ;
+
+};
+
+#endif
diff --git a/indra/llmath/llquaternion2.inl b/indra/llmath/llquaternion2.inl
new file mode 100644
index 0000000000..2a6987552d
--- /dev/null
+++ b/indra/llmath/llquaternion2.inl
@@ -0,0 +1,102 @@
+/** 
+ * @file llquaternion2.inl
+ * @brief LLQuaternion2 inline definitions
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llquaternion2.h"
+
+static const LLQuad LL_V4A_PLUS_ONE = {1.f, 1.f, 1.f, 1.f};
+static const LLQuad LL_V4A_MINUS_ONE = {-1.f, -1.f, -1.f, -1.f};
+
+// Ctor from LLQuaternion
+inline LLQuaternion2::LLQuaternion2( const LLQuaternion& quat )
+{
+	mQ.set(quat.mQ[VX], quat.mQ[VY], quat.mQ[VZ], quat.mQ[VW]);
+}
+
+//////////////////////////
+// Get/Set
+//////////////////////////
+
+// Return the internal LLVector4a representation of the quaternion
+inline const LLVector4a& LLQuaternion2::getVector4a() const
+{
+	return mQ;
+}
+
+inline LLVector4a& LLQuaternion2::getVector4aRw()
+{
+	return mQ;
+}
+
+/////////////////////////
+// Quaternion modification
+/////////////////////////
+
+// Set this quaternion to the conjugate of src
+inline void LLQuaternion2::setConjugate(const LLQuaternion2& src)
+{
+	static LL_ALIGN_16( const U32 F_QUAT_INV_MASK_4A[4] ) = { 0x80000000, 0x80000000, 0x80000000, 0x00000000 };
+	mQ = _mm_xor_ps(src.mQ, *reinterpret_cast<const LLQuad*>(&F_QUAT_INV_MASK_4A));	
+}
+
+// Renormalizes the quaternion. Assumes it has nonzero length.
+inline void LLQuaternion2::normalize()
+{
+	mQ.normalize4();
+}
+
+// Quantize this quaternion to 8 bit precision
+inline void LLQuaternion2::quantize8()
+{
+	mQ.quantize8( LL_V4A_MINUS_ONE, LL_V4A_PLUS_ONE );
+	normalize();
+}
+
+// Quantize this quaternion to 16 bit precision
+inline void LLQuaternion2::quantize16()
+{
+	mQ.quantize16( LL_V4A_MINUS_ONE, LL_V4A_PLUS_ONE );
+	normalize();
+}
+
+
+/////////////////////////
+// Quaternion inspection
+/////////////////////////
+
+// Return true if this quaternion is equal to 'rhs'. 
+// Note! Quaternions exhibit "double-cover", so any rotation has two equally valid
+// quaternion representations and they will NOT compare equal.
+inline bool LLQuaternion2::equals(const LLQuaternion2 &rhs, F32 tolerance/* = F_APPROXIMATELY_ZERO*/) const
+{
+	return mQ.equals4(rhs.mQ, tolerance);
+}
+
+// Return true if all components are finite and the quaternion is normalized
+inline bool LLQuaternion2::isOkRotation() const
+{
+	return mQ.isFinite4() && mQ.isNormalized4();
+}
+
diff --git a/indra/llmath/llsimdmath.h b/indra/llmath/llsimdmath.h
new file mode 100644
index 0000000000..c7cdf7b32c
--- /dev/null
+++ b/indra/llmath/llsimdmath.h
@@ -0,0 +1,93 @@
+/** 
+ * @file llsimdmath.h
+ * @brief Common header for SIMD-based math library (llvector4a, llmatrix3a, etc.)
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	LL_SIMD_MATH_H
+#define	LL_SIMD_MATH_H
+
+#ifndef LLMATH_H
+#error "Please include llmath.h before this file."
+#endif
+
+#if ( ( LL_DARWIN || LL_LINUX ) && !(__SSE2__) ) || ( LL_WINDOWS && ( _M_IX86_FP < 2 ) )
+#error SSE2 not enabled. LLVector4a and related class will not compile.
+#endif
+
+#if !LL_WINDOWS
+#include <stdint.h>
+#endif
+
+template <typename T> T* LL_NEXT_ALIGNED_ADDRESS(T* address) 
+{ 
+	return reinterpret_cast<T*>(
+		(reinterpret_cast<uintptr_t>(address) + 0xF) & ~0xF);
+}
+
+template <typename T> T* LL_NEXT_ALIGNED_ADDRESS_64(T* address) 
+{ 
+	return reinterpret_cast<T*>(
+		(reinterpret_cast<uintptr_t>(address) + 0x3F) & ~0x3F);
+}
+
+#if LL_LINUX || LL_DARWIN
+
+#define			LL_ALIGN_PREFIX(x)
+#define			LL_ALIGN_POSTFIX(x)		__attribute__((aligned(x)))
+
+#elif LL_WINDOWS
+
+#define			LL_ALIGN_PREFIX(x)		__declspec(align(x))
+#define			LL_ALIGN_POSTFIX(x)
+
+#else
+#error "LL_ALIGN_PREFIX and LL_ALIGN_POSTFIX undefined"
+#endif
+
+#define LL_ALIGN_16(var) LL_ALIGN_PREFIX(16) var LL_ALIGN_POSTFIX(16)
+
+
+
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+#include "llsimdtypes.h"
+#include "llsimdtypes.inl"
+
+class LLMatrix3a;
+class LLRotation;
+class LLMatrix3;
+
+#include "llquaternion.h"
+
+#include "llvector4logical.h"
+#include "llvector4a.h"
+#include "llmatrix3a.h"
+#include "llquaternion2.h"
+#include "llvector4a.inl"
+#include "llmatrix3a.inl"
+#include "llquaternion2.inl"
+
+
+#endif //LL_SIMD_MATH_H
diff --git a/indra/llmath/llsimdtypes.h b/indra/llmath/llsimdtypes.h
new file mode 100644
index 0000000000..bd991d0e71
--- /dev/null
+++ b/indra/llmath/llsimdtypes.h
@@ -0,0 +1,124 @@
+/** 
+ * @file llsimdtypes.h
+ * @brief Declaration of basic SIMD math related types
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_SIMD_TYPES_H
+#define LL_SIMD_TYPES_H
+
+#ifndef LL_SIMD_MATH_H
+#error "Please include llmath.h before this file."
+#endif
+
+typedef __m128	LLQuad;
+
+
+#if LL_WINDOWS
+#pragma warning(push)
+#pragma warning( disable : 4800 3 ) // Disable warning about casting int to bool for this class.
+#if defined(_MSC_VER) && (_MSC_VER < 1500)
+// VC++ 2005 is missing these intrinsics
+// __forceinline is MSVC specific and attempts to override compiler inlining judgment. This is so
+// even in debug builds this call is a NOP.
+__forceinline const __m128 _mm_castsi128_ps( const __m128i a ) { return reinterpret_cast<const __m128&>(a); }
+__forceinline const __m128i _mm_castps_si128( const __m128 a ) { return reinterpret_cast<const __m128i&>(a); }
+#endif // _MSC_VER
+
+#endif // LL_WINDOWS
+
+class LLBool32
+{
+public:
+	inline LLBool32() {}
+	inline LLBool32(int rhs) : m_bool(rhs) {}
+	inline LLBool32(unsigned int rhs) : m_bool(rhs) {}
+	inline LLBool32(bool rhs) { m_bool = static_cast<const int>(rhs); }
+	inline LLBool32& operator= (bool rhs) { m_bool = (int)rhs; return *this; }
+	inline bool operator== (bool rhs) const { return static_cast<const bool&>(m_bool) == rhs; }
+	inline bool operator!= (bool rhs) const { return !operator==(rhs); }
+	inline operator bool() const { return static_cast<const bool&>(m_bool); }
+
+private:
+	int m_bool;
+};
+
+#if LL_WINDOWS
+#pragma warning(pop)
+#endif
+
+class LLSimdScalar
+{
+public:
+	inline LLSimdScalar() {}
+	inline LLSimdScalar(LLQuad q) 
+	{ 
+		mQ = q; 
+	}
+
+	inline LLSimdScalar(F32 f) 
+	{ 
+		mQ = _mm_set_ss(f); 
+	}
+
+	static inline const LLSimdScalar& getZero()
+	{
+		extern const LLQuad F_ZERO_4A;
+		return reinterpret_cast<const LLSimdScalar&>(F_ZERO_4A);
+	}
+
+	inline F32 getF32() const;
+
+	inline LLBool32 isApproximatelyEqual(const LLSimdScalar& rhs, F32 tolerance = F_APPROXIMATELY_ZERO) const;
+
+	inline LLSimdScalar getAbs() const;
+
+	inline void setMax( const LLSimdScalar& a, const LLSimdScalar& b );
+	
+	inline void setMin( const LLSimdScalar& a, const LLSimdScalar& b );
+
+	inline LLSimdScalar& operator=(F32 rhs);
+
+	inline LLSimdScalar& operator+=(const LLSimdScalar& rhs);
+
+	inline LLSimdScalar& operator-=(const LLSimdScalar& rhs);
+
+	inline LLSimdScalar& operator*=(const LLSimdScalar& rhs);
+
+	inline LLSimdScalar& operator/=(const LLSimdScalar& rhs);
+
+	inline operator LLQuad() const
+	{ 
+		return mQ; 
+	}
+	
+	inline const LLQuad& getQuad() const 
+	{ 
+		return mQ; 
+	}
+
+private:
+	LLQuad mQ;
+};
+
+#endif //LL_SIMD_TYPES_H
diff --git a/indra/llmath/llsimdtypes.inl b/indra/llmath/llsimdtypes.inl
new file mode 100644
index 0000000000..712239e425
--- /dev/null
+++ b/indra/llmath/llsimdtypes.inl
@@ -0,0 +1,157 @@
+/** 
+ * @file llsimdtypes.inl
+ * @brief Inlined definitions of basic SIMD math related types
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+
+
+
+//////////////////
+// LLSimdScalar
+//////////////////
+
+inline LLSimdScalar operator+(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	LLSimdScalar t(a);
+	t += b;
+	return t;
+}
+
+inline LLSimdScalar operator-(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	LLSimdScalar t(a);
+	t -= b;
+	return t;
+}
+
+inline LLSimdScalar operator*(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	LLSimdScalar t(a);
+	t *= b;
+	return t;
+}
+
+inline LLSimdScalar operator/(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	LLSimdScalar t(a);
+	t /= b;
+	return t;
+}
+
+inline LLSimdScalar operator-(const LLSimdScalar& a)
+{
+	static LL_ALIGN_16(const U32 signMask[4]) = {0x80000000, 0x80000000, 0x80000000, 0x80000000 };
+	return _mm_xor_ps(*reinterpret_cast<const LLQuad*>(signMask), a);
+}
+
+inline LLBool32 operator==(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	return _mm_comieq_ss(a, b);
+}
+
+inline LLBool32 operator!=(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	return _mm_comineq_ss(a, b);
+}
+
+inline LLBool32 operator<(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	return _mm_comilt_ss(a, b);
+}
+
+inline LLBool32 operator<=(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	return _mm_comile_ss(a, b);
+}
+
+inline LLBool32 operator>(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	return _mm_comigt_ss(a, b);
+}
+
+inline LLBool32 operator>=(const LLSimdScalar& a, const LLSimdScalar& b)
+{
+	return _mm_comige_ss(a, b);
+}
+
+inline LLBool32 LLSimdScalar::isApproximatelyEqual(const LLSimdScalar& rhs, F32 tolerance /* = F_APPROXIMATELY_ZERO */) const
+{
+	const LLSimdScalar tol( tolerance );
+	const LLSimdScalar diff = _mm_sub_ss( mQ, rhs.mQ );
+	const LLSimdScalar absDiff = diff.getAbs();
+	return absDiff <= tol;
+}
+
+inline void LLSimdScalar::setMax( const LLSimdScalar& a, const LLSimdScalar& b )
+{
+	mQ = _mm_max_ss( a, b );
+}
+
+inline void LLSimdScalar::setMin( const LLSimdScalar& a, const LLSimdScalar& b )
+{
+	mQ = _mm_min_ss( a, b );
+}
+
+inline LLSimdScalar& LLSimdScalar::operator=(F32 rhs) 
+{ 
+	mQ = _mm_set_ss(rhs); 
+	return *this; 
+}
+
+inline LLSimdScalar& LLSimdScalar::operator+=(const LLSimdScalar& rhs) 
+{
+	mQ = _mm_add_ss( mQ, rhs );
+	return *this;
+}
+
+inline LLSimdScalar& LLSimdScalar::operator-=(const LLSimdScalar& rhs)
+{
+	mQ = _mm_sub_ss( mQ, rhs );
+	return *this;
+}
+
+inline LLSimdScalar& LLSimdScalar::operator*=(const LLSimdScalar& rhs)
+{
+	mQ = _mm_mul_ss( mQ, rhs );
+	return *this;
+}
+
+inline LLSimdScalar& LLSimdScalar::operator/=(const LLSimdScalar& rhs)
+{
+	mQ = _mm_div_ss( mQ, rhs );
+	return *this;
+}
+
+inline LLSimdScalar LLSimdScalar::getAbs() const
+{
+	static const LL_ALIGN_16(U32 F_ABS_MASK_4A[4]) = { 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF };
+	return _mm_and_ps( mQ, *reinterpret_cast<const LLQuad*>(F_ABS_MASK_4A));
+}
+
+inline F32 LLSimdScalar::getF32() const
+{ 
+	F32 ret; 
+	_mm_store_ss(&ret, mQ); 
+	return ret; 
+}
diff --git a/indra/llmath/lltreenode.h b/indra/llmath/lltreenode.h
index a462d1659e..c66bc26176 100644
--- a/indra/llmath/lltreenode.h
+++ b/indra/llmath/lltreenode.h
@@ -28,6 +28,9 @@
 
 #include "stdtypes.h"
 #include "xform.h"
+#include "llpointer.h"
+#include "llrefcount.h"
+
 #include <vector>
 
 template <class T> class LLTreeNode;
diff --git a/indra/llmath/llvector4a.cpp b/indra/llmath/llvector4a.cpp
new file mode 100644
index 0000000000..b66b7a7076
--- /dev/null
+++ b/indra/llmath/llvector4a.cpp
@@ -0,0 +1,222 @@
+/** 
+ * @file llvector4a.cpp
+ * @brief SIMD vector implementation
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llmath.h"
+#include "llquantize.h"
+
+extern const LLQuad F_ZERO_4A		= { 0, 0, 0, 0 };
+extern const LLQuad F_APPROXIMATELY_ZERO_4A = { 
+	F_APPROXIMATELY_ZERO,
+	F_APPROXIMATELY_ZERO,
+	F_APPROXIMATELY_ZERO,
+	F_APPROXIMATELY_ZERO
+};
+
+extern const LLVector4a LL_V4A_ZERO = reinterpret_cast<const LLVector4a&> ( F_ZERO_4A );
+extern const LLVector4a LL_V4A_EPSILON = reinterpret_cast<const LLVector4a&> ( F_APPROXIMATELY_ZERO_4A );
+
+/*static */void LLVector4a::memcpyNonAliased16(F32* __restrict dst, const F32* __restrict src, size_t bytes)
+{
+	assert(src != NULL);
+	assert(dst != NULL);
+	assert(bytes > 0);
+	assert((bytes % sizeof(F32))== 0); 
+	
+	F32* end = dst + (bytes / sizeof(F32) );
+
+	if (bytes > 64)
+	{
+		F32* begin_64 = LL_NEXT_ALIGNED_ADDRESS_64(dst);
+		
+		//at least 64 (16*4) bytes before the end of the destination, switch to 16 byte copies
+		F32* end_64 = end-16;
+		
+		_mm_prefetch((char*)begin_64, _MM_HINT_NTA);
+		_mm_prefetch((char*)begin_64 + 64, _MM_HINT_NTA);
+		_mm_prefetch((char*)begin_64 + 128, _MM_HINT_NTA);
+		_mm_prefetch((char*)begin_64 + 192, _MM_HINT_NTA);
+		
+		while (dst < begin_64)
+		{
+			copy4a(dst, src);
+			dst += 4;
+			src += 4;
+		}
+		
+		while (dst < end_64)
+		{
+			_mm_prefetch((char*)src + 512, _MM_HINT_NTA);
+			_mm_prefetch((char*)dst + 512, _MM_HINT_NTA);
+			copy4a(dst, src);
+			copy4a(dst+4, src+4);
+			copy4a(dst+8, src+8);
+			copy4a(dst+12, src+12);
+			
+			dst += 16;
+			src += 16;
+		}
+	}
+
+	while (dst < end)
+	{
+		copy4a(dst, src);
+		dst += 4;
+		src += 4;
+	}
+}
+
+void LLVector4a::setRotated( const LLRotation& rot, const LLVector4a& vec )
+{
+	const LLVector4a col0 = rot.getColumn(0);
+	const LLVector4a col1 = rot.getColumn(1);
+	const LLVector4a col2 = rot.getColumn(2);
+
+	LLVector4a result = _mm_load_ss( vec.getF32ptr() );
+	result.splat<0>( result );
+	result.mul( col0 );
+
+	{
+		LLVector4a yyyy = _mm_load_ss( vec.getF32ptr() +  1 );
+		yyyy.splat<0>( yyyy );
+		yyyy.mul( col1 ); 
+		result.add( yyyy );
+	}
+
+	{
+		LLVector4a zzzz = _mm_load_ss( vec.getF32ptr() +  2 );
+		zzzz.splat<0>( zzzz );
+		zzzz.mul( col2 );
+		result.add( zzzz );
+	}
+
+	*this = result;
+}
+
+void LLVector4a::setRotated( const LLQuaternion2& quat, const LLVector4a& vec )
+{
+	const LLVector4a& quatVec = quat.getVector4a();
+	LLVector4a temp; temp.setCross3(quatVec, vec);
+	temp.add( temp );
+	
+	const LLVector4a realPart( quatVec.getScalarAt<3>() );
+	LLVector4a tempTimesReal; tempTimesReal.setMul( temp, realPart );
+
+	mQ = vec;
+	add( tempTimesReal );
+	
+	LLVector4a imagCrossTemp; imagCrossTemp.setCross3( quatVec, temp );
+	add(imagCrossTemp);
+}
+
+void LLVector4a::quantize8( const LLVector4a& low, const LLVector4a& high )
+{
+	LLVector4a val(mQ);
+	LLVector4a delta; delta.setSub( high, low );
+
+	{
+		val.clamp(low, high);
+		val.sub(low);
+
+		// 8-bit quantization means we can do with just 12 bits of reciprocal accuracy
+		const LLVector4a oneOverDelta = _mm_rcp_ps(delta.mQ);
+// 		{
+// 			static LL_ALIGN_16( const F32 F_TWO_4A[4] ) = { 2.f, 2.f, 2.f, 2.f };
+// 			LLVector4a two; two.load4a( F_TWO_4A );
+// 
+// 			// Here we use _mm_rcp_ps plus one round of newton-raphson
+// 			// We wish to find 'x' such that x = 1/delta
+// 			// As a first approximation, we take x0 = _mm_rcp_ps(delta)
+// 			// Then x1 = 2 * x0 - a * x0^2 or x1 = x0 * ( 2 - a * x0 )
+// 			// See Intel AP-803 http://ompf.org/!/Intel_application_note_AP-803.pdf
+// 			const LLVector4a recipApprox = _mm_rcp_ps(delta.mQ);
+// 			oneOverDelta.setMul( delta, recipApprox );
+// 			oneOverDelta.setSub( two, oneOverDelta );
+// 			oneOverDelta.mul( recipApprox );
+// 		}
+
+		val.mul(oneOverDelta);
+		val.mul(*reinterpret_cast<const LLVector4a*>(F_U8MAX_4A));
+	}
+
+	val = _mm_cvtepi32_ps(_mm_cvtps_epi32( val.mQ ));
+
+	{
+		val.mul(*reinterpret_cast<const LLVector4a*>(F_OOU8MAX_4A));
+		val.mul(delta);
+		val.add(low);
+	}
+
+	{
+		LLVector4a maxError; maxError.setMul(delta, *reinterpret_cast<const LLVector4a*>(F_OOU8MAX_4A));
+		LLVector4a absVal; absVal.setAbs( val );
+		setSelectWithMask( absVal.lessThan( maxError ), F_ZERO_4A, val );
+	}	
+}
+
+void LLVector4a::quantize16( const LLVector4a& low, const LLVector4a& high )
+{
+	LLVector4a val(mQ);
+	LLVector4a delta; delta.setSub( high, low );
+
+	{
+		val.clamp(low, high);
+		val.sub(low);
+
+		// 16-bit quantization means we need a round of Newton-Raphson
+		LLVector4a oneOverDelta;
+		{
+			static LL_ALIGN_16( const F32 F_TWO_4A[4] ) = { 2.f, 2.f, 2.f, 2.f };
+			LLVector4a two; two.load4a( F_TWO_4A );
+
+			// Here we use _mm_rcp_ps plus one round of newton-raphson
+			// We wish to find 'x' such that x = 1/delta
+			// As a first approximation, we take x0 = _mm_rcp_ps(delta)
+			// Then x1 = 2 * x0 - a * x0^2 or x1 = x0 * ( 2 - a * x0 )
+			// See Intel AP-803 http://ompf.org/!/Intel_application_note_AP-803.pdf
+			const LLVector4a recipApprox = _mm_rcp_ps(delta.mQ);
+			oneOverDelta.setMul( delta, recipApprox );
+			oneOverDelta.setSub( two, oneOverDelta );
+			oneOverDelta.mul( recipApprox );
+		}
+
+		val.mul(oneOverDelta);
+		val.mul(*reinterpret_cast<const LLVector4a*>(F_U16MAX_4A));
+	}
+
+	val = _mm_cvtepi32_ps(_mm_cvtps_epi32( val.mQ ));
+
+	{
+		val.mul(*reinterpret_cast<const LLVector4a*>(F_OOU16MAX_4A));
+		val.mul(delta);
+		val.add(low);
+	}
+
+	{
+		LLVector4a maxError; maxError.setMul(delta, *reinterpret_cast<const LLVector4a*>(F_OOU16MAX_4A));
+		LLVector4a absVal; absVal.setAbs( val );
+		setSelectWithMask( absVal.lessThan( maxError ), F_ZERO_4A, val );
+	}	
+}
diff --git a/indra/llmath/llvector4a.h b/indra/llmath/llvector4a.h
new file mode 100644
index 0000000000..596082509d
--- /dev/null
+++ b/indra/llmath/llvector4a.h
@@ -0,0 +1,324 @@
+/** 
+ * @file llvector4a.h
+ * @brief LLVector4a class header file - memory aligned and vectorized 4 component vector
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	LL_LLVECTOR4A_H
+#define	LL_LLVECTOR4A_H
+
+
+class LLRotation;
+
+#include <assert.h>
+#include "llpreprocessor.h"
+
+///////////////////////////////////
+// FIRST TIME USERS PLEASE READ
+//////////////////////////////////
+// This is just the beginning of LLVector4a. There are many more useful functions
+// yet to be implemented. For example, setNeg to negate a vector, rotate() to apply
+// a matrix rotation, various functions to manipulate only the X, Y, and Z elements
+// and many others (including a whole variety of accessors). So if you don't see a 
+// function here that you need, please contact Falcon or someone else with SSE 
+// experience (Richard, I think, has some and davep has a little as of the time 
+// of this writing, July 08, 2010) about getting it implemented before you resort to
+// LLVector3/LLVector4. 
+/////////////////////////////////
+
+class LLVector4a
+{
+public:
+
+	///////////////////////////////////
+	// STATIC METHODS
+	///////////////////////////////////
+	
+	// Call initClass() at startup to avoid 15,000+ cycle penalties from denormalized numbers
+	static void initClass()
+	{
+		_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
+		_MM_SET_ROUNDING_MODE(_MM_ROUND_NEAREST);
+	}
+
+	// Return a vector of all zeros
+	static inline const LLVector4a& getZero()
+	{
+		extern const LLVector4a LL_V4A_ZERO;
+		return LL_V4A_ZERO;
+	}
+	
+	// Return a vector of all epsilon, where epsilon is a small float suitable for approximate equality checks
+	static inline const LLVector4a& getEpsilon()
+	{
+		extern const LLVector4a LL_V4A_EPSILON;
+		return LL_V4A_EPSILON;
+	}
+
+	// Copy 16 bytes from src to dst. Source and destination must be 16-byte aligned
+	static inline void copy4a(F32* dst, const F32* src)
+	{
+		_mm_store_ps(dst, _mm_load_ps(src));
+	}
+
+	// Copy words 16-byte blocks from src to dst. Source and destination must not overlap. 
+	static void memcpyNonAliased16(F32* __restrict dst, const F32* __restrict src, size_t bytes);
+
+	////////////////////////////////////
+	// CONSTRUCTORS 
+	////////////////////////////////////
+	
+	LLVector4a()
+	{ //DO NOT INITIALIZE -- The overhead is completely unnecessary
+	}
+	
+	LLVector4a(F32 x, F32 y, F32 z, F32 w = 0.f)
+	{
+		set(x,y,z,w);
+	}
+	
+	LLVector4a(F32 x)
+	{
+		splat(x);
+	}
+	
+	LLVector4a(const LLSimdScalar& x)
+	{
+		splat(x);
+	}
+
+	LLVector4a(LLQuad q)
+	{
+		mQ = q;
+	}
+
+	////////////////////////////////////
+	// LOAD/STORE
+	////////////////////////////////////
+	
+	// Load from 16-byte aligned src array (preferred method of loading)
+	inline void load4a(const F32* src);
+	
+	// Load from unaligned src array (NB: Significantly slower than load4a)
+	inline void loadua(const F32* src);
+	
+	// Load only three floats beginning at address 'src'. Slowest method.
+	inline void load3(const F32* src);
+	
+	// Store to a 16-byte aligned memory address
+	inline void store4a(F32* dst) const;
+	
+	////////////////////////////////////
+	// BASIC GET/SET 
+	////////////////////////////////////
+	
+	// Return a "this" as an F32 pointer. Do not use unless you have a very good reason.  (Not sure? Ask Falcon)
+	inline F32* getF32ptr();
+	
+	// Return a "this" as a const F32 pointer. Do not use unless you have a very good reason.  (Not sure? Ask Falcon)
+	inline const F32* const getF32ptr() const;
+	
+	// Read-only access a single float in this vector. Do not use in proximity to any function call that manipulates
+	// the data at the whole vector level or you will incur a substantial penalty. Consider using the splat functions instead
+	inline F32 operator[](const S32 idx) const;
+
+	// Prefer this method for read-only access to a single element. Prefer the templated version if the elem is known at compile time.
+	inline LLSimdScalar getScalarAt(const S32 idx) const;
+
+	// Prefer this method for read-only access to a single element. Prefer the templated version if the elem is known at compile time.
+	template <int N> LL_FORCE_INLINE LLSimdScalar getScalarAt() const;
+
+	// Set to an x, y, z and optional w provided
+	inline void set(F32 x, F32 y, F32 z, F32 w = 0.f);
+	
+	// Set to all zeros. This is preferred to using ::getZero()
+	inline void clear();
+	
+	// Set all elements to 'x'
+	inline void splat(const F32 x);
+
+	// Set all elements to 'x'
+	inline void splat(const LLSimdScalar& x);
+	
+	// Set all 4 elements to element N of src, with N known at compile time
+	template <int N> void splat(const LLVector4a& src);
+	
+	// Set all 4 elements to element i of v, with i NOT known at compile time
+	inline void splat(const LLVector4a& v, U32 i);
+	
+	// Select bits from sourceIfTrue and sourceIfFalse according to bits in mask
+	inline void setSelectWithMask( const LLVector4Logical& mask, const LLVector4a& sourceIfTrue, const LLVector4a& sourceIfFalse );
+	
+	////////////////////////////////////
+	// ALGEBRAIC
+	////////////////////////////////////
+	
+	// Set this to the element-wise (a + b)
+	inline void setAdd(const LLVector4a& a, const LLVector4a& b);
+	
+	// Set this to element-wise (a - b)
+	inline void setSub(const LLVector4a& a, const LLVector4a& b);
+	
+	// Set this to element-wise multiply (a * b)
+	inline void setMul(const LLVector4a& a, const LLVector4a& b);
+	
+	// Set this to element-wise quotient (a / b)
+	inline void setDiv(const LLVector4a& a, const LLVector4a& b);
+	
+	// Set this to the element-wise absolute value of src
+	inline void setAbs(const LLVector4a& src);
+	
+	// Add to each component in this vector the corresponding component in rhs
+	inline void add(const LLVector4a& rhs);
+	
+	// Subtract from each component in this vector the corresponding component in rhs
+	inline void sub(const LLVector4a& rhs);
+	
+	// Multiply each component in this vector by the corresponding component in rhs
+	inline void mul(const LLVector4a& rhs);
+	
+	// Divide each component in this vector by the corresponding component in rhs
+	inline void div(const LLVector4a& rhs);
+	
+	// Multiply this vector by x in a scalar fashion
+	inline void mul(const F32 x);
+
+	// Set this to (a x b) (geometric cross-product)
+	inline void setCross3(const LLVector4a& a, const LLVector4a& b);
+	
+	// Set all elements to the dot product of the x, y, and z elements in a and b
+	inline void setAllDot3(const LLVector4a& a, const LLVector4a& b);
+
+	// Set all elements to the dot product of the x, y, z, and w elements in a and b
+	inline void setAllDot4(const LLVector4a& a, const LLVector4a& b);
+
+	// Return the 3D dot product of this vector and b
+	inline LLSimdScalar dot3(const LLVector4a& b) const;
+
+	// Return the 4D dot product of this vector and b
+	inline LLSimdScalar dot4(const LLVector4a& b) const;
+
+	// Normalize this vector with respect to the x, y, and z components only. Accurate to 22 bites of precision. W component is destroyed
+	// Note that this does not consider zero length vectors!
+	inline void normalize3();
+
+	// Same as normalize3() but with respect to all 4 components
+	inline void normalize4();
+
+	// Same as normalize3(), but returns length as a SIMD scalar
+	inline LLSimdScalar normalize3withLength();
+
+	// Normalize this vector with respect to the x, y, and z components only. Accurate only to 10-12 bits of precision. W component is destroyed
+	// Note that this does not consider zero length vectors!
+	inline void normalize3fast();
+
+	// Return true if this vector is normalized with respect to x,y,z up to tolerance
+	inline LLBool32 isNormalized3( F32 tolerance = 1e-3 ) const;
+
+	// Return true if this vector is normalized with respect to all components up to tolerance
+	inline LLBool32 isNormalized4( F32 tolerance = 1e-3 ) const;
+
+	// Set all elements to the length of vector 'v' 
+	inline void setAllLength3( const LLVector4a& v );
+
+	// Get this vector's length
+	inline LLSimdScalar getLength3() const;
+	
+	// Set the components of this vector to the minimum of the corresponding components of lhs and rhs
+	inline void setMin(const LLVector4a& lhs, const LLVector4a& rhs);
+	
+	// Set the components of this vector to the maximum of the corresponding components of lhs and rhs
+	inline void setMax(const LLVector4a& lhs, const LLVector4a& rhs);
+	
+	// Clamps this vector to be within the component-wise range low to high (inclusive)
+	inline void clamp( const LLVector4a& low, const LLVector4a& high );
+
+	// Set this to  (c * lhs) + rhs * ( 1 - c)
+	inline void setLerp(const LLVector4a& lhs, const LLVector4a& rhs, F32 c);
+	
+	// Return true (nonzero) if x, y, z (and w for Finite4) are all finite floats
+	inline LLBool32 isFinite3() const;	
+	inline LLBool32 isFinite4() const;
+
+	// Set this vector to 'vec' rotated by the LLRotation or LLQuaternion2 provided
+	void setRotated( const LLRotation& rot, const LLVector4a& vec );
+	void setRotated( const class LLQuaternion2& quat, const LLVector4a& vec );
+
+	// Set this vector to 'vec' rotated by the INVERSE of the LLRotation or LLQuaternion2 provided
+	inline void setRotatedInv( const LLRotation& rot, const LLVector4a& vec );
+	inline void setRotatedInv( const class LLQuaternion2& quat, const LLVector4a& vec );
+
+	// Quantize this vector to 8 or 16 bit precision
+	void quantize8( const LLVector4a& low, const LLVector4a& high );
+	void quantize16( const LLVector4a& low, const LLVector4a& high );
+
+	////////////////////////////////////
+	// LOGICAL
+	////////////////////////////////////	
+	// The functions in this section will compare the elements in this vector
+	// to those in rhs and return an LLVector4Logical with all bits set in elements
+	// where the comparison was true and all bits unset in elements where the comparison
+	// was false. See llvector4logica.h
+	////////////////////////////////////
+	// WARNING: Other than equals3 and equals4, these functions do NOT account
+	// for floating point tolerance. You should include the appropriate tolerance
+	// in the inputs.
+	////////////////////////////////////
+	
+	inline LLVector4Logical greaterThan(const LLVector4a& rhs) const;
+
+	inline LLVector4Logical lessThan(const LLVector4a& rhs) const;
+	
+	inline LLVector4Logical greaterEqual(const LLVector4a& rhs) const;
+
+	inline LLVector4Logical lessEqual(const LLVector4a& rhs) const;
+	
+	inline LLVector4Logical equal(const LLVector4a& rhs) const;
+
+	// Returns true if this and rhs are componentwise equal up to the specified absolute tolerance
+	inline bool equals4(const LLVector4a& rhs, F32 tolerance = F_APPROXIMATELY_ZERO ) const;
+
+	inline bool equals3(const LLVector4a& rhs, F32 tolerance = F_APPROXIMATELY_ZERO ) const;
+
+	////////////////////////////////////
+	// OPERATORS
+	////////////////////////////////////	
+	
+	// Do NOT add aditional operators without consulting someone with SSE experience
+	inline const LLVector4a& operator= ( const LLVector4a& rhs );
+	
+	inline const LLVector4a& operator= ( const LLQuad& rhs );
+
+	inline operator LLQuad() const;	
+
+private:
+	LLQuad mQ;
+};
+
+inline void update_min_max(LLVector4a& min, LLVector4a& max, const LLVector4a& p)
+{
+	min.setMin(min, p);
+	max.setMax(max, p);
+}
+
+#endif
diff --git a/indra/llmath/llvector4a.inl b/indra/llmath/llvector4a.inl
new file mode 100644
index 0000000000..7ad22a5631
--- /dev/null
+++ b/indra/llmath/llvector4a.inl
@@ -0,0 +1,593 @@
+/** 
+ * @file llvector4a.inl
+ * @brief LLVector4a inline function implementations
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+////////////////////////////////////
+// LOAD/STORE
+////////////////////////////////////
+
+// Load from 16-byte aligned src array (preferred method of loading)
+inline void LLVector4a::load4a(const F32* src)
+{
+	mQ = _mm_load_ps(src);
+}
+
+// Load from unaligned src array (NB: Significantly slower than load4a)
+inline void LLVector4a::loadua(const F32* src)
+{
+	mQ = _mm_loadu_ps(src);
+}
+
+// Load only three floats beginning at address 'src'. Slowest method.
+inline void LLVector4a::load3(const F32* src)
+{
+	// mQ = { 0.f, src[2], src[1], src[0] } = { W, Z, Y, X }
+	// NB: This differs from the convention of { Z, Y, X, W }
+	mQ = _mm_set_ps(0.f, src[2], src[1], src[0]);
+}	
+
+// Store to a 16-byte aligned memory address
+inline void LLVector4a::store4a(F32* dst) const
+{
+	_mm_store_ps(dst, mQ);
+}
+
+////////////////////////////////////
+// BASIC GET/SET 
+////////////////////////////////////
+
+// Return a "this" as an F32 pointer. Do not use unless you have a very good reason.  (Not sure? Ask Falcon)
+F32* LLVector4a::getF32ptr()
+{
+	return (F32*) &mQ;
+}
+
+// Return a "this" as a const F32 pointer. Do not use unless you have a very good reason.  (Not sure? Ask Falcon)
+const F32* const LLVector4a::getF32ptr() const
+{
+	return (const F32* const) &mQ;
+}
+
+// Read-only access a single float in this vector. Do not use in proximity to any function call that manipulates
+// the data at the whole vector level or you will incur a substantial penalty. Consider using the splat functions instead
+inline F32 LLVector4a::operator[](const S32 idx) const
+{
+	return ((F32*)&mQ)[idx];
+}	
+
+// Prefer this method for read-only access to a single element. Prefer the templated version if the elem is known at compile time.
+inline LLSimdScalar LLVector4a::getScalarAt(const S32 idx) const
+{
+	// Return appropriate LLQuad. It will be cast to LLSimdScalar automatically (should be effectively a nop)
+	switch (idx)
+	{
+		case 0:
+			return mQ;
+		case 1:
+			return _mm_shuffle_ps(mQ, mQ, _MM_SHUFFLE(1, 1, 1, 1));
+		case 2:
+			return _mm_shuffle_ps(mQ, mQ, _MM_SHUFFLE(2, 2, 2, 2));
+		case 3:
+		default:
+			return _mm_shuffle_ps(mQ, mQ, _MM_SHUFFLE(3, 3, 3, 3));
+	}
+}
+
+// Prefer this method for read-only access to a single element. Prefer the templated version if the elem is known at compile time.
+template <int N> LL_FORCE_INLINE LLSimdScalar LLVector4a::getScalarAt() const
+{
+	return _mm_shuffle_ps(mQ, mQ, _MM_SHUFFLE(N, N, N, N));
+}
+
+template<> LL_FORCE_INLINE LLSimdScalar LLVector4a::getScalarAt<0>() const
+{
+	return mQ;
+}
+
+// Set to an x, y, z and optional w provided
+inline void LLVector4a::set(F32 x, F32 y, F32 z, F32 w)
+{
+	mQ = _mm_set_ps(w, z, y, x);
+}
+
+// Set to all zeros
+inline void LLVector4a::clear()
+{
+	mQ = LLVector4a::getZero().mQ;
+}
+
+inline void LLVector4a::splat(const F32 x)
+{
+	mQ = _mm_set1_ps(x);	
+}
+
+inline void LLVector4a::splat(const LLSimdScalar& x)
+{
+	mQ = _mm_shuffle_ps( x.getQuad(), x.getQuad(), _MM_SHUFFLE(0,0,0,0) );
+}
+
+// Set all 4 elements to element N of src, with N known at compile time
+template <int N> void LLVector4a::splat(const LLVector4a& src)
+{
+	mQ = _mm_shuffle_ps(src.mQ, src.mQ, _MM_SHUFFLE(N, N, N, N) );
+}
+
+// Set all 4 elements to element i of v, with i NOT known at compile time
+inline void LLVector4a::splat(const LLVector4a& v, U32 i)
+{
+	switch (i)
+	{
+		case 0:
+			mQ = _mm_shuffle_ps(v.mQ, v.mQ, _MM_SHUFFLE(0, 0, 0, 0));
+			break;
+		case 1:
+			mQ = _mm_shuffle_ps(v.mQ, v.mQ, _MM_SHUFFLE(1, 1, 1, 1));
+			break;
+		case 2:
+			mQ = _mm_shuffle_ps(v.mQ, v.mQ, _MM_SHUFFLE(2, 2, 2, 2));
+			break;
+		case 3:
+			mQ = _mm_shuffle_ps(v.mQ, v.mQ, _MM_SHUFFLE(3, 3, 3, 3));
+			break;
+	}
+}
+
+// Select bits from sourceIfTrue and sourceIfFalse according to bits in mask
+inline void LLVector4a::setSelectWithMask( const LLVector4Logical& mask, const LLVector4a& sourceIfTrue, const LLVector4a& sourceIfFalse )
+{
+	// ((( sourceIfTrue ^ sourceIfFalse ) & mask) ^ sourceIfFalse )
+	// E.g., sourceIfFalse = 1010b, sourceIfTrue = 0101b, mask = 1100b
+	// (sourceIfTrue ^ sourceIfFalse) = 1111b --> & mask = 1100b --> ^ sourceIfFalse = 0110b, 
+	// as expected (01 from sourceIfTrue, 10 from sourceIfFalse)
+	// Courtesy of Mark++, http://markplusplus.wordpress.com/2007/03/14/fast-sse-select-operation/
+	mQ = _mm_xor_ps( sourceIfFalse, _mm_and_ps( mask, _mm_xor_ps( sourceIfTrue, sourceIfFalse ) ) );
+}
+
+////////////////////////////////////
+// ALGEBRAIC
+////////////////////////////////////
+
+// Set this to the element-wise (a + b)
+inline void LLVector4a::setAdd(const LLVector4a& a, const LLVector4a& b)
+{
+	mQ = _mm_add_ps(a.mQ, b.mQ);
+}
+
+// Set this to element-wise (a - b)
+inline void LLVector4a::setSub(const LLVector4a& a, const LLVector4a& b)
+{
+	mQ = _mm_sub_ps(a.mQ, b.mQ);
+}
+
+// Set this to element-wise multiply (a * b)
+inline void LLVector4a::setMul(const LLVector4a& a, const LLVector4a& b)
+{
+	mQ = _mm_mul_ps(a.mQ, b.mQ);
+}
+
+// Set this to element-wise quotient (a / b)
+inline void LLVector4a::setDiv(const LLVector4a& a, const LLVector4a& b)
+{
+	mQ = _mm_div_ps( a.mQ, b.mQ );
+}
+
+// Set this to the element-wise absolute value of src
+inline void LLVector4a::setAbs(const LLVector4a& src)
+{
+	static const LL_ALIGN_16(U32 F_ABS_MASK_4A[4]) = { 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF };
+	mQ = _mm_and_ps(src.mQ, *reinterpret_cast<const LLQuad*>(F_ABS_MASK_4A));
+}
+
+// Add to each component in this vector the corresponding component in rhs
+inline void LLVector4a::add(const LLVector4a& rhs)
+{
+	mQ = _mm_add_ps(mQ, rhs.mQ);	
+}
+
+// Subtract from each component in this vector the corresponding component in rhs
+inline void LLVector4a::sub(const LLVector4a& rhs)
+{
+	mQ = _mm_sub_ps(mQ, rhs.mQ);
+}
+
+// Multiply each component in this vector by the corresponding component in rhs
+inline void LLVector4a::mul(const LLVector4a& rhs)
+{
+	mQ = _mm_mul_ps(mQ, rhs.mQ);	
+}
+
+// Divide each component in this vector by the corresponding component in rhs
+inline void LLVector4a::div(const LLVector4a& rhs)
+{
+	// TODO: Check accuracy, maybe add divFast
+	mQ = _mm_div_ps(mQ, rhs.mQ);
+}
+
+// Multiply this vector by x in a scalar fashion
+inline void LLVector4a::mul(const F32 x) 
+{
+	LLVector4a t;
+	t.splat(x);
+	
+	mQ = _mm_mul_ps(mQ, t.mQ);
+}
+
+// Set this to (a x b) (geometric cross-product)
+inline void LLVector4a::setCross3(const LLVector4a& a, const LLVector4a& b)
+{
+	// Vectors are stored in memory in w, z, y, x order from high to low
+	// Set vector1 = { a[W], a[X], a[Z], a[Y] }
+	const LLQuad vector1 = _mm_shuffle_ps( a.mQ, a.mQ, _MM_SHUFFLE( 3, 0, 2, 1 ));
+	// Set vector2 = { b[W], b[Y], b[X], b[Z] }
+	const LLQuad vector2 = _mm_shuffle_ps( b.mQ, b.mQ, _MM_SHUFFLE( 3, 1, 0, 2 ));
+	// mQ = { a[W]*b[W], a[X]*b[Y], a[Z]*b[X], a[Y]*b[Z] }
+	mQ = _mm_mul_ps( vector1, vector2 );
+	// vector3 = { a[W], a[Y], a[X], a[Z] }
+	const LLQuad vector3 = _mm_shuffle_ps( a.mQ, a.mQ, _MM_SHUFFLE( 3, 1, 0, 2 ));
+	// vector4 = { b[W], b[X], b[Z], b[Y] }
+	const LLQuad vector4 = _mm_shuffle_ps( b.mQ, b.mQ, _MM_SHUFFLE( 3, 0, 2, 1 ));
+	// mQ = { 0, a[X]*b[Y] - a[Y]*b[X], a[Z]*b[X] - a[X]*b[Z], a[Y]*b[Z] - a[Z]*b[Y] }
+	mQ = _mm_sub_ps( mQ, _mm_mul_ps( vector3, vector4 ));
+}
+
+/* This function works, but may be slightly slower than the one below on older machines
+ inline void LLVector4a::setAllDot3(const LLVector4a& a, const LLVector4a& b)
+ {
+ // ab = { a[W]*b[W], a[Z]*b[Z], a[Y]*b[Y], a[X]*b[X] }
+ const LLQuad ab = _mm_mul_ps( a.mQ, b.mQ );
+ // yzxw = { a[W]*b[W], a[Z]*b[Z], a[X]*b[X], a[Y]*b[Y] }
+ const LLQuad wzxy = _mm_shuffle_ps( ab, ab, _MM_SHUFFLE(3, 2, 0, 1 ));
+ // xPlusY = { 2*a[W]*b[W], 2 * a[Z] * b[Z], a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y] }
+ const LLQuad xPlusY = _mm_add_ps(ab, wzxy);
+ // xPlusYSplat = { a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y], a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y] } 
+ const LLQuad xPlusYSplat = _mm_movelh_ps(xPlusY, xPlusY);
+ // zSplat = { a[Z]*b[Z], a[Z]*b[Z], a[Z]*b[Z], a[Z]*b[Z] }
+ const LLQuad zSplat = _mm_shuffle_ps( ab, ab, _MM_SHUFFLE( 2, 2, 2, 2 ));
+ // mQ = { a[Z] * b[Z] + a[Y] * b[Y] + a[X] * b[X], same, same, same }
+ mQ = _mm_add_ps(zSplat, xPlusYSplat);
+ }*/
+
+// Set all elements to the dot product of the x, y, and z elements in a and b
+inline void LLVector4a::setAllDot3(const LLVector4a& a, const LLVector4a& b)
+{
+	// ab = { a[W]*b[W], a[Z]*b[Z], a[Y]*b[Y], a[X]*b[X] }
+	const LLQuad ab = _mm_mul_ps( a.mQ, b.mQ );
+	// yzxw = { a[W]*b[W], a[Z]*b[Z], a[X]*b[X], a[Y]*b[Y] }
+	const __m128i wzxy = _mm_shuffle_epi32(_mm_castps_si128(ab), _MM_SHUFFLE(3, 2, 0, 1 ));
+	// xPlusY = { 2*a[W]*b[W], 2 * a[Z] * b[Z], a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y] }
+	const LLQuad xPlusY = _mm_add_ps(ab, _mm_castsi128_ps(wzxy));
+	// xPlusYSplat = { a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y], a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y] } 
+	const LLQuad xPlusYSplat = _mm_movelh_ps(xPlusY, xPlusY);
+	// zSplat = { a[Z]*b[Z], a[Z]*b[Z], a[Z]*b[Z], a[Z]*b[Z] }
+	const __m128i zSplat = _mm_shuffle_epi32(_mm_castps_si128(ab), _MM_SHUFFLE( 2, 2, 2, 2 ));
+	// mQ = { a[Z] * b[Z] + a[Y] * b[Y] + a[X] * b[X], same, same, same }
+	mQ = _mm_add_ps(_mm_castsi128_ps(zSplat), xPlusYSplat);
+}
+
+// Set all elements to the dot product of the x, y, z, and w elements in a and b
+inline void LLVector4a::setAllDot4(const LLVector4a& a, const LLVector4a& b)
+{
+	// ab = { a[W]*b[W], a[Z]*b[Z], a[Y]*b[Y], a[X]*b[X] }
+	const LLQuad ab = _mm_mul_ps( a.mQ, b.mQ );
+	// yzxw = { a[W]*b[W], a[Z]*b[Z], a[X]*b[X], a[Y]*b[Y] }
+	const __m128i zwxy = _mm_shuffle_epi32(_mm_castps_si128(ab), _MM_SHUFFLE(2, 3, 0, 1 ));
+	// zPlusWandXplusY = { a[W]*b[W] + a[Z]*b[Z], a[Z] * b[Z] + a[W]*b[W], a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y] }
+	const LLQuad zPlusWandXplusY = _mm_add_ps(ab, _mm_castsi128_ps(zwxy));
+	// xPlusYSplat = { a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y], a[Y]*b[Y] + a[X] * b[X], a[X] * b[X] + a[Y] * b[Y] } 
+	const LLQuad xPlusYSplat = _mm_movelh_ps(zPlusWandXplusY, zPlusWandXplusY);
+	const LLQuad zPlusWSplat = _mm_movehl_ps(zPlusWandXplusY, zPlusWandXplusY);
+
+	// mQ = { a[W]*b[W] + a[Z] * b[Z] + a[Y] * b[Y] + a[X] * b[X], same, same, same }
+	mQ = _mm_add_ps(xPlusYSplat, zPlusWSplat);
+}
+
+// Return the 3D dot product of this vector and b
+inline LLSimdScalar LLVector4a::dot3(const LLVector4a& b) const
+{
+	const LLQuad ab = _mm_mul_ps( mQ, b.mQ );
+	const LLQuad splatY = _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128(ab), _MM_SHUFFLE(1, 1, 1, 1) ) );
+	const LLQuad splatZ = _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128(ab), _MM_SHUFFLE(2, 2, 2, 2) ) );
+	const LLQuad xPlusY = _mm_add_ps( ab, splatY );
+	return _mm_add_ps( xPlusY, splatZ );	
+}
+
+// Return the 4D dot product of this vector and b
+inline LLSimdScalar LLVector4a::dot4(const LLVector4a& b) const
+{
+	// ab = { w, z, y, x }
+ 	const LLQuad ab = _mm_mul_ps( mQ, b.mQ );
+ 	// upperProdsInLowerElems = { y, x, y, x }
+	const LLQuad upperProdsInLowerElems = _mm_movehl_ps( ab, ab );
+	// sumOfPairs = { w+y, z+x, 2y, 2x }
+ 	const LLQuad sumOfPairs = _mm_add_ps( upperProdsInLowerElems, ab );
+	// shuffled = { z+x, z+x, z+x, z+x }
+	const LLQuad shuffled = _mm_castsi128_ps( _mm_shuffle_epi32( _mm_castps_si128( sumOfPairs ), _MM_SHUFFLE(1, 1, 1, 1) ) );
+	return _mm_add_ss( sumOfPairs, shuffled );
+}
+
+// Normalize this vector with respect to the x, y, and z components only. Accurate to 22 bites of precision. W component is destroyed
+// Note that this does not consider zero length vectors!
+inline void LLVector4a::normalize3()
+{
+	// lenSqrd = a dot a
+	LLVector4a lenSqrd; lenSqrd.setAllDot3( *this, *this );
+	// rsqrt = approximate reciprocal square (i.e., { ~1/len(a)^2, ~1/len(a)^2, ~1/len(a)^2, ~1/len(a)^2 }
+	const LLQuad rsqrt = _mm_rsqrt_ps(lenSqrd.mQ);
+	static const LLQuad half = { 0.5f, 0.5f, 0.5f, 0.5f };
+	static const LLQuad three = {3.f, 3.f, 3.f, 3.f };
+	// Now we do one round of Newton-Raphson approximation to get full accuracy
+	// According to the Newton-Raphson method, given a first 'w' for the root of f(x) = 1/x^2 - a (i.e., x = 1/sqrt(a))
+	// the next better approximation w[i+1] = w - f(w)/f'(w) = w - (1/w^2 - a)/(-2*w^(-3))
+	// w[i+1] = w + 0.5 * (1/w^2 - a) * w^3 = w + 0.5 * (w - a*w^3) = 1.5 * w - 0.5 * a * w^3
+	// = 0.5 * w * (3 - a*w^2)
+	// Our first approx is w = rsqrt. We need out = a * w[i+1] (this is the input vector 'a', not the 'a' from the above formula
+	// which is actually lenSqrd). So out = a * [0.5*rsqrt * (3 - lenSqrd*rsqrt*rsqrt)]
+	const LLQuad AtimesRsqrt = _mm_mul_ps( lenSqrd.mQ, rsqrt );
+	const LLQuad AtimesRsqrtTimesRsqrt = _mm_mul_ps( AtimesRsqrt, rsqrt );
+	const LLQuad threeMinusAtimesRsqrtTimesRsqrt = _mm_sub_ps(three, AtimesRsqrtTimesRsqrt );
+	const LLQuad nrApprox = _mm_mul_ps(half, _mm_mul_ps(rsqrt, threeMinusAtimesRsqrtTimesRsqrt));
+	mQ = _mm_mul_ps( mQ, nrApprox );
+}
+
+// Normalize this vector with respect to all components. Accurate to 22 bites of precision.
+// Note that this does not consider zero length vectors!
+inline void LLVector4a::normalize4()
+{
+	// lenSqrd = a dot a
+	LLVector4a lenSqrd; lenSqrd.setAllDot4( *this, *this );
+	// rsqrt = approximate reciprocal square (i.e., { ~1/len(a)^2, ~1/len(a)^2, ~1/len(a)^2, ~1/len(a)^2 }
+	const LLQuad rsqrt = _mm_rsqrt_ps(lenSqrd.mQ);
+	static const LLQuad half = { 0.5f, 0.5f, 0.5f, 0.5f };
+	static const LLQuad three = {3.f, 3.f, 3.f, 3.f };
+	// Now we do one round of Newton-Raphson approximation to get full accuracy
+	// According to the Newton-Raphson method, given a first 'w' for the root of f(x) = 1/x^2 - a (i.e., x = 1/sqrt(a))
+	// the next better approximation w[i+1] = w - f(w)/f'(w) = w - (1/w^2 - a)/(-2*w^(-3))
+	// w[i+1] = w + 0.5 * (1/w^2 - a) * w^3 = w + 0.5 * (w - a*w^3) = 1.5 * w - 0.5 * a * w^3
+	// = 0.5 * w * (3 - a*w^2)
+	// Our first approx is w = rsqrt. We need out = a * w[i+1] (this is the input vector 'a', not the 'a' from the above formula
+	// which is actually lenSqrd). So out = a * [0.5*rsqrt * (3 - lenSqrd*rsqrt*rsqrt)]
+	const LLQuad AtimesRsqrt = _mm_mul_ps( lenSqrd.mQ, rsqrt );
+	const LLQuad AtimesRsqrtTimesRsqrt = _mm_mul_ps( AtimesRsqrt, rsqrt );
+	const LLQuad threeMinusAtimesRsqrtTimesRsqrt = _mm_sub_ps(three, AtimesRsqrtTimesRsqrt );
+	const LLQuad nrApprox = _mm_mul_ps(half, _mm_mul_ps(rsqrt, threeMinusAtimesRsqrtTimesRsqrt));
+	mQ = _mm_mul_ps( mQ, nrApprox );
+}
+
+// Normalize this vector with respect to the x, y, and z components only. Accurate to 22 bites of precision. W component is destroyed
+// Note that this does not consider zero length vectors!
+inline LLSimdScalar LLVector4a::normalize3withLength()
+{
+	// lenSqrd = a dot a
+	LLVector4a lenSqrd; lenSqrd.setAllDot3( *this, *this );
+	// rsqrt = approximate reciprocal square (i.e., { ~1/len(a)^2, ~1/len(a)^2, ~1/len(a)^2, ~1/len(a)^2 }
+	const LLQuad rsqrt = _mm_rsqrt_ps(lenSqrd.mQ);
+	static const LLQuad half = { 0.5f, 0.5f, 0.5f, 0.5f };
+	static const LLQuad three = {3.f, 3.f, 3.f, 3.f };
+	// Now we do one round of Newton-Raphson approximation to get full accuracy
+	// According to the Newton-Raphson method, given a first 'w' for the root of f(x) = 1/x^2 - a (i.e., x = 1/sqrt(a))
+	// the next better approximation w[i+1] = w - f(w)/f'(w) = w - (1/w^2 - a)/(-2*w^(-3))
+	// w[i+1] = w + 0.5 * (1/w^2 - a) * w^3 = w + 0.5 * (w - a*w^3) = 1.5 * w - 0.5 * a * w^3
+	// = 0.5 * w * (3 - a*w^2)
+	// Our first approx is w = rsqrt. We need out = a * w[i+1] (this is the input vector 'a', not the 'a' from the above formula
+	// which is actually lenSqrd). So out = a * [0.5*rsqrt * (3 - lenSqrd*rsqrt*rsqrt)]
+	const LLQuad AtimesRsqrt = _mm_mul_ps( lenSqrd.mQ, rsqrt );
+	const LLQuad AtimesRsqrtTimesRsqrt = _mm_mul_ps( AtimesRsqrt, rsqrt );
+	const LLQuad threeMinusAtimesRsqrtTimesRsqrt = _mm_sub_ps(three, AtimesRsqrtTimesRsqrt );
+	const LLQuad nrApprox = _mm_mul_ps(half, _mm_mul_ps(rsqrt, threeMinusAtimesRsqrtTimesRsqrt));
+	mQ = _mm_mul_ps( mQ, nrApprox );
+	return _mm_sqrt_ss(lenSqrd);
+}
+
+// Normalize this vector with respect to the x, y, and z components only. Accurate only to 10-12 bits of precision. W component is destroyed
+// Note that this does not consider zero length vectors!
+inline void LLVector4a::normalize3fast()
+{
+	LLVector4a lenSqrd; lenSqrd.setAllDot3( *this, *this );
+	const LLQuad approxRsqrt = _mm_rsqrt_ps(lenSqrd.mQ);
+	mQ = _mm_mul_ps( mQ, approxRsqrt );
+}
+
+// Return true if this vector is normalized with respect to x,y,z up to tolerance
+inline LLBool32 LLVector4a::isNormalized3( F32 tolerance ) const
+{
+	static LL_ALIGN_16(const U32 ones[4]) = { 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000 };
+	LLSimdScalar tol = _mm_load_ss( &tolerance );
+	tol = _mm_mul_ss( tol, tol );
+	LLVector4a lenSquared; lenSquared.setAllDot3( *this, *this );
+	lenSquared.sub( *reinterpret_cast<const LLVector4a*>(ones) );
+	lenSquared.setAbs(lenSquared);
+	return _mm_comile_ss( lenSquared, tol );		
+}
+
+// Return true if this vector is normalized with respect to all components up to tolerance
+inline LLBool32 LLVector4a::isNormalized4( F32 tolerance ) const
+{
+	static LL_ALIGN_16(const U32 ones[4]) = { 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000 };
+	LLSimdScalar tol = _mm_load_ss( &tolerance );
+	tol = _mm_mul_ss( tol, tol );
+	LLVector4a lenSquared; lenSquared.setAllDot4( *this, *this );
+	lenSquared.sub( *reinterpret_cast<const LLVector4a*>(ones) );
+	lenSquared.setAbs(lenSquared);
+	return _mm_comile_ss( lenSquared, tol );		
+}
+
+// Set all elements to the length of vector 'v' 
+inline void LLVector4a::setAllLength3( const LLVector4a& v )
+{
+	LLVector4a lenSqrd;
+	lenSqrd.setAllDot3(v, v);
+	
+	mQ = _mm_sqrt_ps(lenSqrd.mQ);
+}
+
+// Get this vector's length
+inline LLSimdScalar LLVector4a::getLength3() const
+{
+	return _mm_sqrt_ss( dot3( (const LLVector4a)mQ ) );
+}
+
+// Set the components of this vector to the minimum of the corresponding components of lhs and rhs
+inline void LLVector4a::setMin(const LLVector4a& lhs, const LLVector4a& rhs)
+{
+	mQ = _mm_min_ps(lhs.mQ, rhs.mQ);
+}
+
+// Set the components of this vector to the maximum of the corresponding components of lhs and rhs
+inline void LLVector4a::setMax(const LLVector4a& lhs, const LLVector4a& rhs)
+{
+	mQ = _mm_max_ps(lhs.mQ, rhs.mQ);
+}
+
+// Set this to  (c * lhs) + rhs * ( 1 - c)
+inline void LLVector4a::setLerp(const LLVector4a& lhs, const LLVector4a& rhs, F32 c)
+{
+	LLVector4a a = lhs;
+	a.mul(c);
+	
+	LLVector4a b = rhs;
+	b.mul(1.f-c);
+	
+	setAdd(a, b);
+}
+
+inline LLBool32 LLVector4a::isFinite3() const
+{
+	static LL_ALIGN_16(const U32 nanOrInfMask[4]) = { 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000 };
+	const __m128i nanOrInfMaskV = *reinterpret_cast<const __m128i*> (nanOrInfMask);
+	const __m128i maskResult = _mm_and_si128( _mm_castps_si128(mQ), nanOrInfMaskV );
+	const LLVector4Logical equalityCheck = _mm_castsi128_ps(_mm_cmpeq_epi32( maskResult, nanOrInfMaskV ));
+	return !equalityCheck.areAnySet( LLVector4Logical::MASK_XYZ );
+}
+	
+inline LLBool32 LLVector4a::isFinite4() const
+{
+	static LL_ALIGN_16(const U32 nanOrInfMask[4]) = { 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000 };
+	const __m128i nanOrInfMaskV = *reinterpret_cast<const __m128i*> (nanOrInfMask);
+	const __m128i maskResult = _mm_and_si128( _mm_castps_si128(mQ), nanOrInfMaskV );
+	const LLVector4Logical equalityCheck = _mm_castsi128_ps(_mm_cmpeq_epi32( maskResult, nanOrInfMaskV ));
+	return !equalityCheck.areAnySet( LLVector4Logical::MASK_XYZW );
+}
+
+inline void LLVector4a::setRotatedInv( const LLRotation& rot, const LLVector4a& vec )
+{
+	LLRotation inv; inv.setTranspose( rot );
+	setRotated( inv, vec );
+}
+
+inline void LLVector4a::setRotatedInv( const LLQuaternion2& quat, const LLVector4a& vec )
+{
+	LLQuaternion2 invRot; invRot.setConjugate( quat );
+	setRotated(invRot, vec);
+}
+
+inline void LLVector4a::clamp( const LLVector4a& low, const LLVector4a& high )
+{
+	const LLVector4Logical highMask = greaterThan( high );
+	const LLVector4Logical lowMask = lessThan( low );
+
+	setSelectWithMask( highMask, high, *this );
+	setSelectWithMask( lowMask, low, *this );
+}
+
+
+////////////////////////////////////
+// LOGICAL
+////////////////////////////////////	
+// The functions in this section will compare the elements in this vector
+// to those in rhs and return an LLVector4Logical with all bits set in elements
+// where the comparison was true and all bits unset in elements where the comparison
+// was false. See llvector4logica.h
+////////////////////////////////////
+// WARNING: Other than equals3 and equals4, these functions do NOT account
+// for floating point tolerance. You should include the appropriate tolerance
+// in the inputs.
+////////////////////////////////////
+
+inline LLVector4Logical LLVector4a::greaterThan(const LLVector4a& rhs) const
+{	
+	return _mm_cmpgt_ps(mQ, rhs.mQ);
+}
+
+inline LLVector4Logical LLVector4a::lessThan(const LLVector4a& rhs) const
+{
+	return _mm_cmplt_ps(mQ, rhs.mQ);
+}
+
+inline LLVector4Logical LLVector4a::greaterEqual(const LLVector4a& rhs) const
+{
+	return _mm_cmpge_ps(mQ, rhs.mQ);
+}
+
+inline LLVector4Logical LLVector4a::lessEqual(const LLVector4a& rhs) const
+{
+	return _mm_cmple_ps(mQ, rhs.mQ);
+}
+
+inline LLVector4Logical LLVector4a::equal(const LLVector4a& rhs) const
+{
+	return _mm_cmpeq_ps(mQ, rhs.mQ);
+}
+
+// Returns true if this and rhs are componentwise equal up to the specified absolute tolerance
+inline bool LLVector4a::equals4(const LLVector4a& rhs, F32 tolerance ) const
+{
+	LLVector4a diff; diff.setSub( *this, rhs );
+	diff.setAbs( diff );
+	const LLQuad tol = _mm_set1_ps( tolerance );
+	const LLQuad cmp = _mm_cmplt_ps( diff, tol );
+	return (_mm_movemask_ps( cmp ) & LLVector4Logical::MASK_XYZW) == LLVector4Logical::MASK_XYZW;
+}
+
+inline bool LLVector4a::equals3(const LLVector4a& rhs, F32 tolerance ) const
+{
+	LLVector4a diff; diff.setSub( *this, rhs );
+	diff.setAbs( diff );
+	const LLQuad tol = _mm_set1_ps( tolerance );
+	const LLQuad t = _mm_cmplt_ps( diff, tol ); 
+	return (_mm_movemask_ps( t ) & LLVector4Logical::MASK_XYZ) == LLVector4Logical::MASK_XYZ;
+	
+}
+
+////////////////////////////////////
+// OPERATORS
+////////////////////////////////////	
+
+// Do NOT add aditional operators without consulting someone with SSE experience
+inline const LLVector4a& LLVector4a::operator= ( const LLVector4a& rhs )
+{
+	mQ = rhs.mQ;
+	return *this;
+}
+
+inline const LLVector4a& LLVector4a::operator= ( const LLQuad& rhs )
+{
+	mQ = rhs;
+	return *this;
+}
+
+inline LLVector4a::operator LLQuad() const
+{
+	return mQ;
+}
diff --git a/indra/llmath/llvector4logical.h b/indra/llmath/llvector4logical.h
new file mode 100644
index 0000000000..dd66b09d43
--- /dev/null
+++ b/indra/llmath/llvector4logical.h
@@ -0,0 +1,124 @@
+/** 
+ * @file llvector4logical.h
+ * @brief LLVector4Logical class header file - Companion class to LLVector4a for logical and bit-twiddling operations
+ *
+ * $LicenseInfo:firstyear=2010&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef	LL_VECTOR4LOGICAL_H
+#define	LL_VECTOR4LOGICAL_H
+
+
+////////////////////////////
+// LLVector4Logical
+////////////////////////////
+// This class is incomplete. If you need additional functionality,
+// for example setting/unsetting particular elements or performing
+// other boolean operations, feel free to implement. If you need
+// assistance in determining the most optimal implementation,
+// contact someone with SSE experience (Falcon, Richard, Davep, e.g.)
+////////////////////////////
+
+static LL_ALIGN_16(const U32 S_V4LOGICAL_MASK_TABLE[4*4]) =
+{
+	0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000,
+	0x00000000, 0xFFFFFFFF, 0x00000000, 0x00000000,
+	0x00000000, 0x00000000, 0xFFFFFFFF, 0x00000000,
+	0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF
+};
+
+class LLVector4Logical
+{
+public:
+	
+	enum {
+		MASK_X = 1,
+		MASK_Y = 1 << 1,
+		MASK_Z = 1 << 2,
+		MASK_W = 1 << 3,
+		MASK_XYZ = MASK_X | MASK_Y | MASK_Z,
+		MASK_XYZW = MASK_XYZ | MASK_W
+	};
+	
+	// Empty default ctor
+	LLVector4Logical() {}
+	
+	LLVector4Logical( const LLQuad& quad )
+	{
+		mQ = quad;
+	}
+	
+	// Create and return a mask consisting of the lowest order bit of each element
+	inline U32 getGatheredBits() const
+	{
+		return _mm_movemask_ps(mQ);
+	};	
+	
+	// Invert this mask
+	inline LLVector4Logical& invert()
+	{
+		static const LL_ALIGN_16(U32 allOnes[4]) = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
+		mQ = _mm_andnot_ps( mQ, *(LLQuad*)(allOnes) );
+		return *this;
+	}
+	
+	inline LLBool32 areAllSet( U32 mask ) const
+	{
+		return ( getGatheredBits() & mask) == mask;
+	}
+	
+	inline LLBool32 areAllSet() const
+	{
+		return areAllSet( MASK_XYZW );
+	}
+		
+	inline LLBool32 areAnySet( U32 mask ) const
+	{
+		return getGatheredBits() & mask;
+	}
+	
+	inline LLBool32 areAnySet() const
+	{
+		return areAnySet( MASK_XYZW );
+	}
+	
+	inline operator LLQuad() const
+	{
+		return mQ;
+	}
+
+	inline void clear() 
+	{
+		mQ = _mm_setzero_ps();
+	}
+
+	template<int N> void setElement()
+	{
+		mQ = _mm_or_ps( mQ, *reinterpret_cast<const LLQuad*>(S_V4LOGICAL_MASK_TABLE + 4*N) );
+	}
+	
+private:
+	
+	LLQuad mQ;
+};
+
+#endif //LL_VECTOR4ALOGICAL_H
diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp
index 71b92962fb..dc360818d6 100644
--- a/indra/llmath/llvolume.cpp
+++ b/indra/llmath/llvolume.cpp
@@ -1,5548 +1,7233 @@
-/** 
- * @file llvolume.cpp
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "llmath.h"
-
-#include <set>
-
-#include "llerror.h"
-#include "llmemtype.h"
-
-#include "llvolumemgr.h"
-#include "v2math.h"
-#include "v3math.h"
-#include "v4math.h"
-#include "m4math.h"
-#include "m3math.h"
-#include "lldarray.h"
-#include "llvolume.h"
-#include "llstl.h"
-
-#define DEBUG_SILHOUETTE_BINORMALS 0
-#define DEBUG_SILHOUETTE_NORMALS 0 // TomY: Use this to display normals using the silhouette
-#define DEBUG_SILHOUETTE_EDGE_MAP 0 // DaveP: Use this to display edge map using the silhouette
-
-const F32 CUT_MIN = 0.f;
-const F32 CUT_MAX = 1.f;
-const F32 MIN_CUT_DELTA = 0.02f;
-
-const F32 HOLLOW_MIN = 0.f;
-const F32 HOLLOW_MAX = 0.95f;
-const F32 HOLLOW_MAX_SQUARE	= 0.7f;
-
-const F32 TWIST_MIN = -1.f;
-const F32 TWIST_MAX =  1.f;
-
-const F32 RATIO_MIN = 0.f;
-const F32 RATIO_MAX = 2.f; // Tom Y: Inverted sense here: 0 = top taper, 2 = bottom taper
-
-const F32 HOLE_X_MIN= 0.05f;
-const F32 HOLE_X_MAX= 1.0f;
-
-const F32 HOLE_Y_MIN= 0.05f;
-const F32 HOLE_Y_MAX= 0.5f;
-
-const F32 SHEAR_MIN = -0.5f;
-const F32 SHEAR_MAX =  0.5f;
-
-const F32 REV_MIN = 1.f;
-const F32 REV_MAX = 4.f;
-
-const F32 TAPER_MIN = -1.f;
-const F32 TAPER_MAX =  1.f;
-
-const F32 SKEW_MIN	= -0.95f;
-const F32 SKEW_MAX	=  0.95f;
-
-const F32 SCULPT_MIN_AREA = 0.002f;
-const S32 SCULPT_MIN_AREA_DETAIL = 1;
-
-#define GEN_TRI_STRIP 0
-
-BOOL check_same_clock_dir( const LLVector3& pt1, const LLVector3& pt2, const LLVector3& pt3, const LLVector3& norm)
-{    
-	LLVector3 test = (pt2-pt1)%(pt3-pt2);
-
-	//answer
-	if(test * norm < 0) 
-	{
-		return FALSE;
-	}
-	else 
-	{
-		return TRUE;
-	}
-} 
-
-BOOL LLLineSegmentBoxIntersect(const LLVector3& start, const LLVector3& end, const LLVector3& center, const LLVector3& size)
-{
-	float fAWdU[3];
-	LLVector3 dir;
-	LLVector3 diff;
-
-	for (U32 i = 0; i < 3; i++)
-	{
-		dir.mV[i] = 0.5f * (end.mV[i] - start.mV[i]);
-		diff.mV[i] = (0.5f * (end.mV[i] + start.mV[i])) - center.mV[i];
-		fAWdU[i] = fabsf(dir.mV[i]);
-		if(fabsf(diff.mV[i])>size.mV[i] + fAWdU[i]) return false;
-	}
-
-	float f;
-	f = dir.mV[1] * diff.mV[2] - dir.mV[2] * diff.mV[1];    if(fabsf(f)>size.mV[1]*fAWdU[2] + size.mV[2]*fAWdU[1])  return false;
-	f = dir.mV[2] * diff.mV[0] - dir.mV[0] * diff.mV[2];    if(fabsf(f)>size.mV[0]*fAWdU[2] + size.mV[2]*fAWdU[0])  return false;
-	f = dir.mV[0] * diff.mV[1] - dir.mV[1] * diff.mV[0];    if(fabsf(f)>size.mV[0]*fAWdU[1] + size.mV[1]*fAWdU[0])  return false;
-	
-	return true;
-}
-
-
-// intersect test between triangle vert0, vert1, vert2 and a ray from orig in direction dir.
-// returns TRUE if intersecting and returns barycentric coordinates in intersection_a, intersection_b,
-// and returns the intersection point along dir in intersection_t.
-
-// Moller-Trumbore algorithm
-BOOL LLTriangleRayIntersect(const LLVector3& vert0, const LLVector3& vert1, const LLVector3& vert2, const LLVector3& orig, const LLVector3& dir,
-							F32* intersection_a, F32* intersection_b, F32* intersection_t, BOOL two_sided)
-{
-	F32 u, v, t;
-	
-	/* find vectors for two edges sharing vert0 */
-	LLVector3 edge1 = vert1 - vert0;
-	
-	LLVector3 edge2 = vert2 - vert0;;
-
-	/* begin calculating determinant - also used to calculate U parameter */
-	LLVector3 pvec = dir % edge2;
-	
-	/* if determinant is near zero, ray lies in plane of triangle */
-	F32 det = edge1 * pvec;
-
-	if (!two_sided)
-	{
-		if (det < F_APPROXIMATELY_ZERO)
-		{
-			return FALSE;
-		}
-
-		/* calculate distance from vert0 to ray origin */
-		LLVector3 tvec = orig - vert0;
-
-		/* calculate U parameter and test bounds */
-		u = tvec * pvec;	
-
-		if (u < 0.f || u > det)
-		{
-			return FALSE;
-		}
-	
-		/* prepare to test V parameter */
-		LLVector3 qvec = tvec % edge1;
-		
-		/* calculate V parameter and test bounds */
-		v = dir * qvec;
-		if (v < 0.f || u + v > det)
-		{
-			return FALSE;
-		}
-
-		/* calculate t, scale parameters, ray intersects triangle */
-		t = edge2 * qvec;
-		F32 inv_det = 1.0 / det;
-		t *= inv_det;
-		u *= inv_det;
-		v *= inv_det;
-	}
-	
-	else // two sided
-			{
-		if (det > -F_APPROXIMATELY_ZERO && det < F_APPROXIMATELY_ZERO)
-				{
-			return FALSE;
-				}
-		F32 inv_det = 1.0 / det;
-
-		/* calculate distance from vert0 to ray origin */
-		LLVector3 tvec = orig - vert0;
-		
-		/* calculate U parameter and test bounds */
-		u = (tvec * pvec) * inv_det;
-		if (u < 0.f || u > 1.f)
-		{
-			return FALSE;
-			}
-
-		/* prepare to test V parameter */
-		LLVector3 qvec = tvec - edge1;
-		
-		/* calculate V parameter and test bounds */
-		v = (dir * qvec) * inv_det;
-		
-		if (v < 0.f || u + v > 1.f)
-		{
-			return FALSE;
-		}
-
-		/* calculate t, ray intersects triangle */
-		t = (edge2 * qvec) * inv_det;
-	}
-	
-	if (intersection_a != NULL)
-		*intersection_a = u;
-	if (intersection_b != NULL)
-		*intersection_b = v;
-	if (intersection_t != NULL)
-		*intersection_t = t;
-	
-	
-	return TRUE;
-} 
-
-
-//-------------------------------------------------------------------
-// statics
-//-------------------------------------------------------------------
-
-
-//----------------------------------------------------
-
-LLProfile::Face* LLProfile::addCap(S16 faceID)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	Face *face   = vector_append(mFaces, 1);
-	
-	face->mIndex = 0;
-	face->mCount = mTotal;
-	face->mScaleU= 1.0f;
-	face->mCap   = TRUE;
-	face->mFaceID = faceID;
-	return face;
-}
-
-LLProfile::Face* LLProfile::addFace(S32 i, S32 count, F32 scaleU, S16 faceID, BOOL flat)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	Face *face   = vector_append(mFaces, 1);
-	
-	face->mIndex = i;
-	face->mCount = count;
-	face->mScaleU= scaleU;
-
-	face->mFlat = flat;
-	face->mCap   = FALSE;
-	face->mFaceID = faceID;
-	return face;
-}
-
-// What is the bevel parameter used for? - DJS 04/05/02
-// Bevel parameter is currently unused but presumedly would support
-// filleted and chamfered corners
-void LLProfile::genNGon(const LLProfileParams& params, S32 sides, F32 offset, F32 bevel, F32 ang_scale, S32 split)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	// Generate an n-sided "circular" path.
-	// 0 is (1,0), and we go counter-clockwise along a circular path from there.
-	const F32 tableScale[] = { 1, 1, 1, 0.5f, 0.707107f, 0.53f, 0.525f, 0.5f };
-	F32 scale = 0.5f;
-	F32 t, t_step, t_first, t_fraction, ang, ang_step;
-	LLVector3 pt1,pt2;
-
-	F32 begin  = params.getBegin();
-	F32 end    = params.getEnd();
-
-	t_step = 1.0f / sides;
-	ang_step = 2.0f*F_PI*t_step*ang_scale;
-
-	// Scale to have size "match" scale.  Compensates to get object to generally fill bounding box.
-
-	S32 total_sides = llround(sides / ang_scale);	// Total number of sides all around
-
-	if (total_sides < 8)
-	{
-		scale = tableScale[total_sides];
-	}
-
-	t_first = floor(begin * sides) / (F32)sides;
-
-	// pt1 is the first point on the fractional face.
-	// Starting t and ang values for the first face
-	t = t_first;
-	ang = 2.0f*F_PI*(t*ang_scale + offset);
-	pt1.setVec(cos(ang)*scale,sin(ang)*scale, t);
-
-	// Increment to the next point.
-	// pt2 is the end point on the fractional face
-	t += t_step;
-	ang += ang_step;
-	pt2.setVec(cos(ang)*scale,sin(ang)*scale,t);
-
-	t_fraction = (begin - t_first)*sides;
-
-	// Only use if it's not almost exactly on an edge.
-	if (t_fraction < 0.9999f)
-	{
-		LLVector3 new_pt = lerp(pt1, pt2, t_fraction);
-		mProfile.push_back(new_pt);
-	}
-
-	// There's lots of potential here for floating point error to generate unneeded extra points - DJS 04/05/02
-	while (t < end)
-	{
-		// Iterate through all the integer steps of t.
-		pt1.setVec(cos(ang)*scale,sin(ang)*scale,t);
-
-		if (mProfile.size() > 0) {
-			LLVector3 p = mProfile[mProfile.size()-1];
-			for (S32 i = 0; i < split && mProfile.size() > 0; i++) {
-				mProfile.push_back(p+(pt1-p) * 1.0f/(float)(split+1) * (float)(i+1));
-			}
-		}
-		mProfile.push_back(pt1);
-
-		t += t_step;
-		ang += ang_step;
-	}
-
-	t_fraction = (end - (t - t_step))*sides;
-
-	// pt1 is the first point on the fractional face
-	// pt2 is the end point on the fractional face
-	pt2.setVec(cos(ang)*scale,sin(ang)*scale,t);
-
-	// Find the fraction that we need to add to the end point.
-	t_fraction = (end - (t - t_step))*sides;
-	if (t_fraction > 0.0001f)
-	{
-		LLVector3 new_pt = lerp(pt1, pt2, t_fraction);
-		
-		if (mProfile.size() > 0) {
-			LLVector3 p = mProfile[mProfile.size()-1];
-			for (S32 i = 0; i < split && mProfile.size() > 0; i++) {
-				mProfile.push_back(p+(new_pt-p) * 1.0f/(float)(split+1) * (float)(i+1));
-			}
-		}
-		mProfile.push_back(new_pt);
-	}
-
-	// If we're sliced, the profile is open.
-	if ((end - begin)*ang_scale < 0.99f)
-	{
-		if ((end - begin)*ang_scale > 0.5f)
-		{
-			mConcave = TRUE;
-		}
-		else
-		{
-			mConcave = FALSE;
-		}
-		mOpen = TRUE;
-		if (params.getHollow() <= 0)
-		{
-			// put center point if not hollow.
-			mProfile.push_back(LLVector3(0,0,0));
-		}
-	}
-	else
-	{
-		// The profile isn't open.
-		mOpen = FALSE;
-		mConcave = FALSE;
-	}
-
-	mTotal = mProfile.size();
-}
-
-void LLProfile::genNormals(const LLProfileParams& params)
-{
-	S32 count = mProfile.size();
-
-	S32 outer_count;
-	if (mTotalOut)
-	{
-		outer_count = mTotalOut;
-	}
-	else
-	{
-		outer_count = mTotal / 2;
-	}
-
-	mEdgeNormals.resize(count * 2);
-	mEdgeCenters.resize(count * 2);
-	mNormals.resize(count);
-
-	LLVector2 pt0,pt1;
-
-	BOOL hollow = (params.getHollow() > 0);
-
-	S32 i0, i1, i2, i3, i4;
-
-	// Parametrically generate normal
-	for (i2 = 0; i2 < count; i2++)
-	{
-		mNormals[i2].mV[0] = mProfile[i2].mV[0];
-		mNormals[i2].mV[1] = mProfile[i2].mV[1];
-		if (hollow && (i2 >= outer_count))
-		{
-			mNormals[i2] *= -1.f;
-		}
-		if (mNormals[i2].magVec() < 0.001)
-		{
-			// Special case for point at center, get adjacent points.
-			i1 = (i2 - 1) >= 0 ? i2 - 1 : count - 1;
-			i0 = (i1 - 1) >= 0 ? i1 - 1 : count - 1;
-			i3 = (i2 + 1) < count ? i2 + 1 : 0;
-			i4 = (i3 + 1) < count ? i3 + 1 : 0;
-
-			pt0.setVec(mProfile[i1].mV[VX] + mProfile[i1].mV[VX] - mProfile[i0].mV[VX], 
-				mProfile[i1].mV[VY] + mProfile[i1].mV[VY] - mProfile[i0].mV[VY]);
-			pt1.setVec(mProfile[i3].mV[VX] + mProfile[i3].mV[VX] - mProfile[i4].mV[VX], 
-				mProfile[i3].mV[VY] + mProfile[i3].mV[VY] - mProfile[i4].mV[VY]);
-
-			mNormals[i2] = pt0 + pt1;
-			mNormals[i2] *= 0.5f;
-		}
-		mNormals[i2].normVec();
-	}
-
-	S32 num_normal_sets = isConcave() ? 2 : 1;
-	for (S32 normal_set = 0; normal_set < num_normal_sets; normal_set++)
-	{
-		S32 point_num;
-		for (point_num = 0; point_num < mTotal; point_num++)
-		{
-			LLVector3 point_1 = mProfile[point_num];
-			point_1.mV[VZ] = 0.f;
-
-			LLVector3 point_2;
-			
-			if (isConcave() && normal_set == 0 && point_num == (mTotal - 1) / 2)
-			{
-				point_2 = mProfile[mTotal - 1];
-			}
-			else if (isConcave() && normal_set == 1 && point_num == mTotal - 1)
-			{
-				point_2 = mProfile[(mTotal - 1) / 2];
-			}
-			else
-			{
-				LLVector3 delta_pos;
-				S32 neighbor_point = (point_num + 1) % mTotal;
-				while(delta_pos.magVecSquared() < 0.01f * 0.01f)
-				{
-					point_2 = mProfile[neighbor_point];
-					delta_pos = point_2 - point_1;
-					neighbor_point = (neighbor_point + 1) % mTotal;
-					if (neighbor_point == point_num)
-					{
-						break;
-					}
-				}
-			}
-
-			point_2.mV[VZ] = 0.f;
-			LLVector3 face_normal = (point_2 - point_1) % LLVector3::z_axis;
-			face_normal.normVec();
-			mEdgeNormals[normal_set * count + point_num] = face_normal;
-			mEdgeCenters[normal_set * count + point_num] = lerp(point_1, point_2, 0.5f);
-		}
-	}
-}
-
-
-// Hollow is percent of the original bounding box, not of this particular
-// profile's geometry.  Thus, a swept triangle needs lower hollow values than
-// a swept square.
-LLProfile::Face* LLProfile::addHole(const LLProfileParams& params, BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split)
-{
-	// Note that addHole will NOT work for non-"circular" profiles, if we ever decide to use them.
-
-	// Total add has number of vertices on outside.
-	mTotalOut = mTotal;
-
-	// Why is the "bevel" parameter -1? DJS 04/05/02
-	genNGon(params, llfloor(sides),offset,-1, ang_scale, split);
-
-	Face *face = addFace(mTotalOut, mTotal-mTotalOut,0,LL_FACE_INNER_SIDE, flat);
-
-	std::vector<LLVector3> pt;
-	pt.resize(mTotal) ;
-
-	for (S32 i=mTotalOut;i<mTotal;i++)
-	{
-		pt[i] = mProfile[i] * box_hollow;
-	}
-
-	S32 j=mTotal-1;
-	for (S32 i=mTotalOut;i<mTotal;i++)
-	{
-		mProfile[i] = pt[j--];
-	}
-
-	for (S32 i=0;i<(S32)mFaces.size();i++) 
-	{
-		if (mFaces[i].mCap)
-		{
-			mFaces[i].mCount *= 2;
-		}
-	}
-
-	return face;
-}
-
-
-
-BOOL LLProfile::generate(const LLProfileParams& params, BOOL path_open,F32 detail, S32 split,
-						 BOOL is_sculpted, S32 sculpt_size)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	if ((!mDirty) && (!is_sculpted))
-	{
-		return FALSE;
-	}
-	mDirty = FALSE;
-
-	if (detail < MIN_LOD)
-	{
-		llinfos << "Generating profile with LOD < MIN_LOD.  CLAMPING" << llendl;
-		detail = MIN_LOD;
-	}
-
-	mProfile.clear();
-	mFaces.clear();
-
-	// Generate the face data
-	S32 i;
-	F32 begin = params.getBegin();
-	F32 end = params.getEnd();
-	F32 hollow = params.getHollow();
-
-	// Quick validation to eliminate some server crashes.
-	if (begin > end - 0.01f)
-	{
-		llwarns << "LLProfile::generate() assertion failed (begin >= end)" << llendl;
-		return FALSE;
-	}
-
-	S32 face_num = 0;
-
-	switch (params.getCurveType() & LL_PCODE_PROFILE_MASK)
-	{
-	case LL_PCODE_PROFILE_SQUARE:
-		{
-			genNGon(params, 4,-0.375, 0, 1, split);
-			if (path_open)
-			{
-				addCap (LL_FACE_PATH_BEGIN);
-			}
-
-			for (i = llfloor(begin * 4.f); i < llfloor(end * 4.f + .999f); i++)
-			{
-				addFace((face_num++) * (split +1), split+2, 1, LL_FACE_OUTER_SIDE_0 << i, TRUE);
-			}
-
-			for (i = 0; i <(S32) mProfile.size(); i++)
-			{
-				// Scale by 4 to generate proper tex coords.
-				mProfile[i].mV[2] *= 4.f;
-			}
-
-			if (hollow)
-			{
-				switch (params.getCurveType() & LL_PCODE_HOLE_MASK)
-				{
-				case LL_PCODE_HOLE_TRIANGLE:
-					// This offset is not correct, but we can't change it now... DK 11/17/04
-				  	addHole(params, TRUE, 3, -0.375f, hollow, 1.f, split);
-					break;
-				case LL_PCODE_HOLE_CIRCLE:
-					// TODO: Compute actual detail levels for cubes
-				  	addHole(params, FALSE, MIN_DETAIL_FACES * detail, -0.375f, hollow, 1.f);
-					break;
-				case LL_PCODE_HOLE_SAME:
-				case LL_PCODE_HOLE_SQUARE:
-				default:
-					addHole(params, TRUE, 4, -0.375f, hollow, 1.f, split);
-					break;
-				}
-			}
-			
-			if (path_open) {
-				mFaces[0].mCount = mTotal;
-			}
-		}
-		break;
-	case  LL_PCODE_PROFILE_ISOTRI:
-	case  LL_PCODE_PROFILE_RIGHTTRI:
-	case  LL_PCODE_PROFILE_EQUALTRI:
-		{
-			genNGon(params, 3,0, 0, 1, split);
-			for (i = 0; i <(S32) mProfile.size(); i++)
-			{
-				// Scale by 3 to generate proper tex coords.
-				mProfile[i].mV[2] *= 3.f;
-			}
-
-			if (path_open)
-			{
-				addCap(LL_FACE_PATH_BEGIN);
-			}
-
-			for (i = llfloor(begin * 3.f); i < llfloor(end * 3.f + .999f); i++)
-			{
-				addFace((face_num++) * (split +1), split+2, 1, LL_FACE_OUTER_SIDE_0 << i, TRUE);
-			}
-			if (hollow)
-			{
-				// Swept triangles need smaller hollowness values,
-				// because the triangle doesn't fill the bounding box.
-				F32 triangle_hollow = hollow / 2.f;
-
-				switch (params.getCurveType() & LL_PCODE_HOLE_MASK)
-				{
-				case LL_PCODE_HOLE_CIRCLE:
-					// TODO: Actually generate level of detail for triangles
-					addHole(params, FALSE, MIN_DETAIL_FACES * detail, 0, triangle_hollow, 1.f);
-					break;
-				case LL_PCODE_HOLE_SQUARE:
-					addHole(params, TRUE, 4, 0, triangle_hollow, 1.f, split);
-					break;
-				case LL_PCODE_HOLE_SAME:
-				case LL_PCODE_HOLE_TRIANGLE:
-				default:
-					addHole(params, TRUE, 3, 0, triangle_hollow, 1.f, split);
-					break;
-				}
-			}
-		}
-		break;
-	case LL_PCODE_PROFILE_CIRCLE:
-		{
-			// If this has a square hollow, we should adjust the
-			// number of faces a bit so that the geometry lines up.
-			U8 hole_type=0;
-			F32 circle_detail = MIN_DETAIL_FACES * detail;
-			if (hollow)
-			{
-				hole_type = params.getCurveType() & LL_PCODE_HOLE_MASK;
-				if (hole_type == LL_PCODE_HOLE_SQUARE)
-				{
-					// Snap to the next multiple of four sides,
-					// so that corners line up.
-					circle_detail = llceil(circle_detail / 4.0f) * 4.0f;
-				}
-			}
-
-			S32 sides = (S32)circle_detail;
-
-			if (is_sculpted)
-				sides = sculpt_size;
-			
-			genNGon(params, sides);
-			
-			if (path_open)
-			{
-				addCap (LL_FACE_PATH_BEGIN);
-			}
-
-			if (mOpen && !hollow)
-			{
-				addFace(0,mTotal-1,0,LL_FACE_OUTER_SIDE_0, FALSE);
-			}
-			else
-			{
-				addFace(0,mTotal,0,LL_FACE_OUTER_SIDE_0, FALSE);
-			}
-
-			if (hollow)
-			{
-				switch (hole_type)
-				{
-				case LL_PCODE_HOLE_SQUARE:
-					addHole(params, TRUE, 4, 0, hollow, 1.f, split);
-					break;
-				case LL_PCODE_HOLE_TRIANGLE:
-					addHole(params, TRUE, 3, 0, hollow, 1.f, split);
-					break;
-				case LL_PCODE_HOLE_CIRCLE:
-				case LL_PCODE_HOLE_SAME:
-				default:
-					addHole(params, FALSE, circle_detail, 0, hollow, 1.f);
-					break;
-				}
-			}
-		}
-		break;
-	case LL_PCODE_PROFILE_CIRCLE_HALF:
-		{
-			// If this has a square hollow, we should adjust the
-			// number of faces a bit so that the geometry lines up.
-			U8 hole_type=0;
-			// Number of faces is cut in half because it's only a half-circle.
-			F32 circle_detail = MIN_DETAIL_FACES * detail * 0.5f;
-			if (hollow)
-			{
-				hole_type = params.getCurveType() & LL_PCODE_HOLE_MASK;
-				if (hole_type == LL_PCODE_HOLE_SQUARE)
-				{
-					// Snap to the next multiple of four sides (div 2),
-					// so that corners line up.
-					circle_detail = llceil(circle_detail / 2.0f) * 2.0f;
-				}
-			}
-			genNGon(params, llfloor(circle_detail), 0.5f, 0.f, 0.5f);
-			if (path_open)
-			{
-				addCap(LL_FACE_PATH_BEGIN);
-			}
-			if (mOpen && !params.getHollow())
-			{
-				addFace(0,mTotal-1,0,LL_FACE_OUTER_SIDE_0, FALSE);
-			}
-			else
-			{
-				addFace(0,mTotal,0,LL_FACE_OUTER_SIDE_0, FALSE);
-			}
-
-			if (hollow)
-			{
-				switch (hole_type)
-				{
-				case LL_PCODE_HOLE_SQUARE:
-					addHole(params, TRUE, 2, 0.5f, hollow, 0.5f, split);
-					break;
-				case LL_PCODE_HOLE_TRIANGLE:
-					addHole(params, TRUE, 3,  0.5f, hollow, 0.5f, split);
-					break;
-				case LL_PCODE_HOLE_CIRCLE:
-				case LL_PCODE_HOLE_SAME:
-				default:
-					addHole(params, FALSE, circle_detail,  0.5f, hollow, 0.5f);
-					break;
-				}
-			}
-
-			// Special case for openness of sphere
-			if ((params.getEnd() - params.getBegin()) < 1.f)
-			{
-				mOpen = TRUE;
-			}
-			else if (!hollow)
-			{
-				mOpen = FALSE;
-				mProfile.push_back(mProfile[0]);
-				mTotal++;
-			}
-		}
-		break;
-	default:
-	    llerrs << "Unknown profile: getCurveType()=" << params.getCurveType() << llendl;
-		break;
-	};
-
-	if (path_open)
-	{
-		addCap(LL_FACE_PATH_END); // bottom
-	}
-	
-	if ( mOpen) // interior edge caps
-	{
-		addFace(mTotal-1, 2,0.5,LL_FACE_PROFILE_BEGIN, TRUE); 
-
-		if (hollow)
-		{
-			addFace(mTotalOut-1, 2,0.5,LL_FACE_PROFILE_END, TRUE);
-		}
-		else
-		{
-			addFace(mTotal-2, 2,0.5,LL_FACE_PROFILE_END, TRUE);
-		}
-	}
-	
-	//genNormals(params);
-
-	return TRUE;
-}
-
-
-
-BOOL LLProfileParams::importFile(LLFILE *fp)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	const S32 BUFSIZE = 16384;
-	char buffer[BUFSIZE];	/* Flawfinder: ignore */
-	// *NOTE: changing the size or type of these buffers will require
-	// changing the sscanf below.
-	char keyword[256];	/* Flawfinder: ignore */
-	char valuestr[256];	/* Flawfinder: ignore */
-	keyword[0] = 0;
-	valuestr[0] = 0;
-	F32 tempF32;
-	U32 tempU32;
-
-	while (!feof(fp))
-	{
-		if (fgets(buffer, BUFSIZE, fp) == NULL)
-		{
-			buffer[0] = '\0';
-		}
-		
-		sscanf(	/* Flawfinder: ignore */
-			buffer,
-			" %255s %255s",
-			keyword, valuestr);
-		if (!strcmp("{", keyword))
-		{
-			continue;
-		}
-		if (!strcmp("}",keyword))
-		{
-			break;
-		}
-		else if (!strcmp("curve", keyword))
-		{
-			sscanf(valuestr,"%d",&tempU32);
-			setCurveType((U8) tempU32);
-		}
-		else if (!strcmp("begin",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setBegin(tempF32);
-		}
-		else if (!strcmp("end",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setEnd(tempF32);
-		}
-		else if (!strcmp("hollow",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setHollow(tempF32);
-		}
-		else
-		{
-			llwarns << "unknown keyword " << keyword << " in profile import" << llendl;
-		}
-	}
-
-	return TRUE;
-}
-
-
-BOOL LLProfileParams::exportFile(LLFILE *fp) const
-{
-	fprintf(fp,"\t\tprofile 0\n");
-	fprintf(fp,"\t\t{\n");
-	fprintf(fp,"\t\t\tcurve\t%d\n", getCurveType());
-	fprintf(fp,"\t\t\tbegin\t%g\n", getBegin());
-	fprintf(fp,"\t\t\tend\t%g\n", getEnd());
-	fprintf(fp,"\t\t\thollow\t%g\n", getHollow());
-	fprintf(fp, "\t\t}\n");
-	return TRUE;
-}
-
-
-BOOL LLProfileParams::importLegacyStream(std::istream& input_stream)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	const S32 BUFSIZE = 16384;
-	char buffer[BUFSIZE];	/* Flawfinder: ignore */
-	// *NOTE: changing the size or type of these buffers will require
-	// changing the sscanf below.
-	char keyword[256];	/* Flawfinder: ignore */
-	char valuestr[256];	/* Flawfinder: ignore */
-	keyword[0] = 0;
-	valuestr[0] = 0;
-	F32 tempF32;
-	U32 tempU32;
-
-	while (input_stream.good())
-	{
-		input_stream.getline(buffer, BUFSIZE);
-		sscanf(	/* Flawfinder: ignore */
-			buffer,
-			" %255s %255s",
-			keyword,
-			valuestr);
-		if (!strcmp("{", keyword))
-		{
-			continue;
-		}
-		if (!strcmp("}",keyword))
-		{
-			break;
-		}
-		else if (!strcmp("curve", keyword))
-		{
-			sscanf(valuestr,"%d",&tempU32);
-			setCurveType((U8) tempU32);
-		}
-		else if (!strcmp("begin",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setBegin(tempF32);
-		}
-		else if (!strcmp("end",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setEnd(tempF32);
-		}
-		else if (!strcmp("hollow",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setHollow(tempF32);
-		}
-		else
-		{
- 		llwarns << "unknown keyword " << keyword << " in profile import" << llendl;
-		}
-	}
-
-	return TRUE;
-}
-
-
-BOOL LLProfileParams::exportLegacyStream(std::ostream& output_stream) const
-{
-	output_stream <<"\t\tprofile 0\n";
-	output_stream <<"\t\t{\n";
-	output_stream <<"\t\t\tcurve\t" << (S32) getCurveType() << "\n";
-	output_stream <<"\t\t\tbegin\t" << getBegin() << "\n";
-	output_stream <<"\t\t\tend\t" << getEnd() << "\n";
-	output_stream <<"\t\t\thollow\t" << getHollow() << "\n";
-	output_stream << "\t\t}\n";
-	return TRUE;
-}
-
-LLSD LLProfileParams::asLLSD() const
-{
-	LLSD sd;
-
-	sd["curve"] = getCurveType();
-	sd["begin"] = getBegin();
-	sd["end"] = getEnd();
-	sd["hollow"] = getHollow();
-	return sd;
-}
-
-bool LLProfileParams::fromLLSD(LLSD& sd)
-{
-	setCurveType(sd["curve"].asInteger());
-	setBegin((F32)sd["begin"].asReal());
-	setEnd((F32)sd["end"].asReal());
-	setHollow((F32)sd["hollow"].asReal());
-	return true;
-}
-
-void LLProfileParams::copyParams(const LLProfileParams &params)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	setCurveType(params.getCurveType());
-	setBegin(params.getBegin());
-	setEnd(params.getEnd());
-	setHollow(params.getHollow());
-}
-
-
-LLPath::~LLPath()
-{
-}
-
-void LLPath::genNGon(const LLPathParams& params, S32 sides, F32 startOff, F32 end_scale, F32 twist_scale)
-{
-	// Generates a circular path, starting at (1, 0, 0), counterclockwise along the xz plane.
-	const F32 tableScale[] = { 1, 1, 1, 0.5f, 0.707107f, 0.53f, 0.525f, 0.5f };
-
-	F32 revolutions = params.getRevolutions();
-	F32 skew		= params.getSkew();
-	F32 skew_mag	= fabs(skew);
-	F32 hole_x		= params.getScaleX() * (1.0f - skew_mag);
-	F32 hole_y		= params.getScaleY();
-
-	// Calculate taper begin/end for x,y (Negative means taper the beginning)
-	F32 taper_x_begin	= 1.0f;
-	F32 taper_x_end		= 1.0f - params.getTaperX();
-	F32	taper_y_begin	= 1.0f;
-	F32	taper_y_end		= 1.0f - params.getTaperY();
-
-	if ( taper_x_end > 1.0f )
-	{
-		// Flip tapering.
-		taper_x_begin	= 2.0f - taper_x_end;
-		taper_x_end		= 1.0f;
-	}
-	if ( taper_y_end > 1.0f )
-	{
-		// Flip tapering.
-		taper_y_begin	= 2.0f - taper_y_end;
-		taper_y_end		= 1.0f;
-	}
-
-	// For spheres, the radius is usually zero.
-	F32 radius_start = 0.5f;
-	if (sides < 8)
-	{
-		radius_start = tableScale[sides];
-	}
-
-	// Scale the radius to take the hole size into account.
-	radius_start *= 1.0f - hole_y;
-	
-	// Now check the radius offset to calculate the start,end radius.  (Negative means
-	// decrease the start radius instead).
-	F32 radius_end    = radius_start;
-	F32 radius_offset = params.getRadiusOffset();
-	if (radius_offset < 0.f)
-	{
-		radius_start *= 1.f + radius_offset;
-	}
-	else
-	{
-		radius_end   *= 1.f - radius_offset;
-	}	
-
-	// Is the path NOT a closed loop?
-	mOpen = ( (params.getEnd()*end_scale - params.getBegin() < 1.0f) ||
-		      (skew_mag > 0.001f) ||
-			  (fabs(taper_x_end - taper_x_begin) > 0.001f) ||
-			  (fabs(taper_y_end - taper_y_begin) > 0.001f) ||
-			  (fabs(radius_end - radius_start) > 0.001f) );
-
-	F32 ang, c, s;
-	LLQuaternion twist, qang;
-	PathPt *pt;
-	LLVector3 path_axis (1.f, 0.f, 0.f);
-	//LLVector3 twist_axis(0.f, 0.f, 1.f);
-	F32 twist_begin = params.getTwistBegin() * twist_scale;
-	F32 twist_end	= params.getTwist() * twist_scale;
-
-	// We run through this once before the main loop, to make sure
-	// the path begins at the correct cut.
-	F32 step= 1.0f / sides;
-	F32 t	= params.getBegin();
-	pt		= vector_append(mPath, 1);
-	ang		= 2.0f*F_PI*revolutions * t;
-	s		= sin(ang)*lerp(radius_start, radius_end, t);	
-	c		= cos(ang)*lerp(radius_start, radius_end, t);
-
-
-	pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s)
-					  + lerp(-skew ,skew, t) * 0.5f,
-					c + lerp(0,params.getShear().mV[1],s), 
-					s);
-	pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t);
-	pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t);
-	pt->mTexT  = t;
-	
-	// Twist rotates the path along the x,y plane (I think) - DJS 04/05/02
-	twist.setQuat  (lerp(twist_begin,twist_end,t) * 2.f * F_PI - F_PI,0,0,1);
-	// Rotate the point around the circle's center.
-	qang.setQuat   (ang,path_axis);
-	pt->mRot   = twist * qang;
-
-	t+=step;
-
-	// Snap to a quantized parameter, so that cut does not
-	// affect most sample points.
-	t = ((S32)(t * sides)) / (F32)sides;
-
-	// Run through the non-cut dependent points.
-	while (t < params.getEnd())
-	{
-		pt		= vector_append(mPath, 1);
-
-		ang = 2.0f*F_PI*revolutions * t;
-		c   = cos(ang)*lerp(radius_start, radius_end, t);
-		s   = sin(ang)*lerp(radius_start, radius_end, t);
-
-		pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s)
-					      + lerp(-skew ,skew, t) * 0.5f,
-						c + lerp(0,params.getShear().mV[1],s), 
-						s);
-
-		pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t);
-		pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t);
-		pt->mTexT  = t;
-
-		// Twist rotates the path along the x,y plane (I think) - DJS 04/05/02
-		twist.setQuat  (lerp(twist_begin,twist_end,t) * 2.f * F_PI - F_PI,0,0,1);
-		// Rotate the point around the circle's center.
-		qang.setQuat   (ang,path_axis);
-		pt->mRot	= twist * qang;
-
-		t+=step;
-	}
-
-	// Make one final pass for the end cut.
-	t = params.getEnd();
-	pt		= vector_append(mPath, 1);
-	ang = 2.0f*F_PI*revolutions * t;
-	c   = cos(ang)*lerp(radius_start, radius_end, t);
-	s   = sin(ang)*lerp(radius_start, radius_end, t);
-
-	pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s)
-					  + lerp(-skew ,skew, t) * 0.5f,
-					c + lerp(0,params.getShear().mV[1],s), 
-					s);
-	pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t);
-	pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t);
-	pt->mTexT  = t;
-	
-	// Twist rotates the path along the x,y plane (I think) - DJS 04/05/02
-	twist.setQuat  (lerp(twist_begin,twist_end,t) * 2.f * F_PI - F_PI,0,0,1);
-	// Rotate the point around the circle's center.
-	qang.setQuat   (ang,path_axis);
-	pt->mRot   = twist * qang;
-
-	mTotal = mPath.size();
-}
-
-const LLVector2 LLPathParams::getBeginScale() const
-{
-	LLVector2 begin_scale(1.f, 1.f);
-	if (getScaleX() > 1)
-	{
-		begin_scale.mV[0] = 2-getScaleX();
-	}
-	if (getScaleY() > 1)
-	{
-		begin_scale.mV[1] = 2-getScaleY();
-	}
-	return begin_scale;
-}
-
-const LLVector2 LLPathParams::getEndScale() const
-{
-	LLVector2 end_scale(1.f, 1.f);
-	if (getScaleX() < 1)
-	{
-		end_scale.mV[0] = getScaleX();
-	}
-	if (getScaleY() < 1)
-	{
-		end_scale.mV[1] = getScaleY();
-	}
-	return end_scale;
-}
-
-BOOL LLPath::generate(const LLPathParams& params, F32 detail, S32 split,
-					  BOOL is_sculpted, S32 sculpt_size)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	if ((!mDirty) && (!is_sculpted))
-	{
-		return FALSE;
-	}
-
-	if (detail < MIN_LOD)
-	{
-		llinfos << "Generating path with LOD < MIN!  Clamping to 1" << llendl;
-		detail = MIN_LOD;
-	}
-
-	mDirty = FALSE;
-	S32 np = 2; // hardcode for line
-
-	mPath.clear();
-	mOpen = TRUE;
-
-	// Is this 0xf0 mask really necessary?  DK 03/02/05
-	switch (params.getCurveType() & 0xf0)
-	{
-	default:
-	case LL_PCODE_PATH_LINE:
-		{
-			// Take the begin/end twist into account for detail.
-			np    = llfloor(fabs(params.getTwistBegin() - params.getTwist()) * 3.5f * (detail-0.5f)) + 2;
-			if (np < split+2)
-			{
-				np = split+2;
-			}
-
-			mStep = 1.0f / (np-1);
-			
-			mPath.resize(np);
-
-			LLVector2 start_scale = params.getBeginScale();
-			LLVector2 end_scale = params.getEndScale();
-
-			for (S32 i=0;i<np;i++)
-			{
-				F32 t = lerp(params.getBegin(),params.getEnd(),(F32)i * mStep);
-				mPath[i].mPos.setVec(lerp(0,params.getShear().mV[0],t),
-									 lerp(0,params.getShear().mV[1],t),
-									 t - 0.5f);
-				mPath[i].mRot.setQuat(lerp(F_PI * params.getTwistBegin(),F_PI * params.getTwist(),t),0,0,1);
-				mPath[i].mScale.mV[0] = lerp(start_scale.mV[0],end_scale.mV[0],t);
-				mPath[i].mScale.mV[1] = lerp(start_scale.mV[1],end_scale.mV[1],t);
-				mPath[i].mTexT        = t;
-			}
-		}
-		break;
-
-	case LL_PCODE_PATH_CIRCLE:
-		{
-			// Increase the detail as the revolutions and twist increase.
-			F32 twist_mag = fabs(params.getTwistBegin() - params.getTwist());
-
-			S32 sides = (S32)llfloor(llfloor((MIN_DETAIL_FACES * detail + twist_mag * 3.5f * (detail-0.5f))) * params.getRevolutions());
-
-			if (is_sculpted)
-				sides = sculpt_size;
-			
-			genNGon(params, sides);
-		}
-		break;
-
-	case LL_PCODE_PATH_CIRCLE2:
-		{
-			if (params.getEnd() - params.getBegin() >= 0.99f &&
-				params.getScaleX() >= .99f)
-			{
-				mOpen = FALSE;
-			}
-
-			//genNGon(params, llfloor(MIN_DETAIL_FACES * detail), 4.f, 0.f);
-			genNGon(params, llfloor(MIN_DETAIL_FACES * detail));
-
-			F32 t     = 0.f;
-			F32 tStep = 1.0f / mPath.size();
-
-			F32 toggle = 0.5f;
-			for (S32 i=0;i<(S32)mPath.size();i++)
-			{
-				mPath[i].mPos.mV[0] = toggle;
-				if (toggle == 0.5f)
-					toggle = -0.5f;
-				else
-					toggle = 0.5f;
-				t += tStep;
-			}
-		}
-
-		break;
-
-	case LL_PCODE_PATH_TEST:
-
-		np     = 5;
-		mStep = 1.0f / (np-1);
-		
-		mPath.resize(np);
-
-		for (S32 i=0;i<np;i++)
-		{
-			F32 t = (F32)i * mStep;
-			mPath[i].mPos.setVec(0,
-								lerp(0,   -sin(F_PI*params.getTwist()*t)*0.5f,t),
-								lerp(-0.5, cos(F_PI*params.getTwist()*t)*0.5f,t));
-			mPath[i].mScale.mV[0] = lerp(1,params.getScale().mV[0],t);
-			mPath[i].mScale.mV[1] = lerp(1,params.getScale().mV[1],t);
-			mPath[i].mTexT  = t;
-			mPath[i].mRot.setQuat(F_PI * params.getTwist() * t,1,0,0);
-		}
-
-		break;
-	};
-
-	if (params.getTwist() != params.getTwistBegin()) mOpen = TRUE;
-
-	//if ((int(fabsf(params.getTwist() - params.getTwistBegin())*100))%100 != 0) {
-	//	mOpen = TRUE;
-	//}
-	
-	return TRUE;
-}
-
-BOOL LLDynamicPath::generate(const LLPathParams& params, F32 detail, S32 split,
-							 BOOL is_sculpted, S32 sculpt_size)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	mOpen = TRUE; // Draw end caps
-	if (getPathLength() == 0)
-	{
-		// Path hasn't been generated yet.
-		// Some algorithms later assume at least TWO path points.
-		resizePath(2);
-		for (U32 i = 0; i < 2; i++)
-		{
-			mPath[i].mPos.setVec(0, 0, 0);
-			mPath[i].mRot.setQuat(0, 0, 0);
-			mPath[i].mScale.setVec(1, 1);
-			mPath[i].mTexT = 0;
-		}
-	}
-
-	return TRUE;
-}
-
-
-BOOL LLPathParams::importFile(LLFILE *fp)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	const S32 BUFSIZE = 16384;
-	char buffer[BUFSIZE];	/* Flawfinder: ignore */
-	// *NOTE: changing the size or type of these buffers will require
-	// changing the sscanf below.
-	char keyword[256];	/* Flawfinder: ignore */
-	char valuestr[256];	/* Flawfinder: ignore */
-	keyword[0] = 0;
-	valuestr[0] = 0;
-
-	F32 tempF32;
-	F32 x, y;
-	U32 tempU32;
-
-	while (!feof(fp))
-	{
-		if (fgets(buffer, BUFSIZE, fp) == NULL)
-		{
-			buffer[0] = '\0';
-		}
-		
-		sscanf(	/* Flawfinder: ignore */
-			buffer,
-			" %255s %255s",
-			keyword, valuestr);
-		if (!strcmp("{", keyword))
-		{
-			continue;
-		}
-		if (!strcmp("}",keyword))
-		{
-			break;
-		}
-		else if (!strcmp("curve", keyword))
-		{
-			sscanf(valuestr,"%d",&tempU32);
-			setCurveType((U8) tempU32);
-		}
-		else if (!strcmp("begin",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setBegin(tempF32);
-		}
-		else if (!strcmp("end",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setEnd(tempF32);
-		}
-		else if (!strcmp("scale",keyword))
-		{
-			// Legacy for one dimensional scale per path
-			sscanf(valuestr,"%g",&tempF32);
-			setScale(tempF32, tempF32);
-		}
-		else if (!strcmp("scale_x", keyword))
-		{
-			sscanf(valuestr, "%g", &x);
-			setScaleX(x);
-		}
-		else if (!strcmp("scale_y", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setScaleY(y);
-		}
-		else if (!strcmp("shear_x", keyword))
-		{
-			sscanf(valuestr, "%g", &x);
-			setShearX(x);
-		}
-		else if (!strcmp("shear_y", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setShearY(y);
-		}
-		else if (!strcmp("twist",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setTwist(tempF32);
-		}
-		else if (!strcmp("twist_begin", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setTwistBegin(y);
-		}
-		else if (!strcmp("radius_offset", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setRadiusOffset(y);
-		}
-		else if (!strcmp("taper_x", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setTaperX(y);
-		}
-		else if (!strcmp("taper_y", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setTaperY(y);
-		}
-		else if (!strcmp("revolutions", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setRevolutions(y);
-		}
-		else if (!strcmp("skew", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setSkew(y);
-		}
-		else
-		{
-			llwarns << "unknown keyword " << " in path import" << llendl;
-		}
-	}
-	return TRUE;
-}
-
-
-BOOL LLPathParams::exportFile(LLFILE *fp) const
-{
-	fprintf(fp, "\t\tpath 0\n");
-	fprintf(fp, "\t\t{\n");
-	fprintf(fp, "\t\t\tcurve\t%d\n", getCurveType());
-	fprintf(fp, "\t\t\tbegin\t%g\n", getBegin());
-	fprintf(fp, "\t\t\tend\t%g\n", getEnd());
-	fprintf(fp, "\t\t\tscale_x\t%g\n", getScaleX() );
-	fprintf(fp, "\t\t\tscale_y\t%g\n", getScaleY() );
-	fprintf(fp, "\t\t\tshear_x\t%g\n", getShearX() );
-	fprintf(fp, "\t\t\tshear_y\t%g\n", getShearY() );
-	fprintf(fp,"\t\t\ttwist\t%g\n", getTwist());
-	
-	fprintf(fp,"\t\t\ttwist_begin\t%g\n", getTwistBegin());
-	fprintf(fp,"\t\t\tradius_offset\t%g\n", getRadiusOffset());
-	fprintf(fp,"\t\t\ttaper_x\t%g\n", getTaperX());
-	fprintf(fp,"\t\t\ttaper_y\t%g\n", getTaperY());
-	fprintf(fp,"\t\t\trevolutions\t%g\n", getRevolutions());
-	fprintf(fp,"\t\t\tskew\t%g\n", getSkew());
-
-	fprintf(fp, "\t\t}\n");
-	return TRUE;
-}
-
-
-BOOL LLPathParams::importLegacyStream(std::istream& input_stream)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	const S32 BUFSIZE = 16384;
-	char buffer[BUFSIZE];	/* Flawfinder: ignore */
-	// *NOTE: changing the size or type of these buffers will require
-	// changing the sscanf below.
-	char keyword[256];	/* Flawfinder: ignore */
-	char valuestr[256];	/* Flawfinder: ignore */
-	keyword[0] = 0;
-	valuestr[0] = 0;
-
-	F32 tempF32;
-	F32 x, y;
-	U32 tempU32;
-
-	while (input_stream.good())
-	{
-		input_stream.getline(buffer, BUFSIZE);
-		sscanf(	/* Flawfinder: ignore */
-			buffer,
-			" %255s %255s",
-			keyword, valuestr);
-		if (!strcmp("{", keyword))
-		{
-			continue;
-		}
-		if (!strcmp("}",keyword))
-		{
-			break;
-		}
-		else if (!strcmp("curve", keyword))
-		{
-			sscanf(valuestr,"%d",&tempU32);
-			setCurveType((U8) tempU32);
-		}
-		else if (!strcmp("begin",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setBegin(tempF32);
-		}
-		else if (!strcmp("end",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setEnd(tempF32);
-		}
-		else if (!strcmp("scale",keyword))
-		{
-			// Legacy for one dimensional scale per path
-			sscanf(valuestr,"%g",&tempF32);
-			setScale(tempF32, tempF32);
-		}
-		else if (!strcmp("scale_x", keyword))
-		{
-			sscanf(valuestr, "%g", &x);
-			setScaleX(x);
-		}
-		else if (!strcmp("scale_y", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setScaleY(y);
-		}
-		else if (!strcmp("shear_x", keyword))
-		{
-			sscanf(valuestr, "%g", &x);
-			setShearX(x);
-		}
-		else if (!strcmp("shear_y", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setShearY(y);
-		}
-		else if (!strcmp("twist",keyword))
-		{
-			sscanf(valuestr,"%g",&tempF32);
-			setTwist(tempF32);
-		}
-		else if (!strcmp("twist_begin", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setTwistBegin(y);
-		}
-		else if (!strcmp("radius_offset", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setRadiusOffset(y);
-		}
-		else if (!strcmp("taper_x", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setTaperX(y);
-		}
-		else if (!strcmp("taper_y", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setTaperY(y);
-		}
-		else if (!strcmp("revolutions", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setRevolutions(y);
-		}
-		else if (!strcmp("skew", keyword))
-		{
-			sscanf(valuestr, "%g", &y);
-			setSkew(y);
-		}
-		else
-		{
-			llwarns << "unknown keyword " << " in path import" << llendl;
-		}
-	}
-	return TRUE;
-}
-
-
-BOOL LLPathParams::exportLegacyStream(std::ostream& output_stream) const
-{
-	output_stream << "\t\tpath 0\n";
-	output_stream << "\t\t{\n";
-	output_stream << "\t\t\tcurve\t" << (S32) getCurveType() << "\n";
-	output_stream << "\t\t\tbegin\t" << getBegin() << "\n";
-	output_stream << "\t\t\tend\t" << getEnd() << "\n";
-	output_stream << "\t\t\tscale_x\t" << getScaleX()  << "\n";
-	output_stream << "\t\t\tscale_y\t" << getScaleY()  << "\n";
-	output_stream << "\t\t\tshear_x\t" << getShearX()  << "\n";
-	output_stream << "\t\t\tshear_y\t" << getShearY()  << "\n";
-	output_stream <<"\t\t\ttwist\t" << getTwist() << "\n";
-	
-	output_stream <<"\t\t\ttwist_begin\t" << getTwistBegin() << "\n";
-	output_stream <<"\t\t\tradius_offset\t" << getRadiusOffset() << "\n";
-	output_stream <<"\t\t\ttaper_x\t" << getTaperX() << "\n";
-	output_stream <<"\t\t\ttaper_y\t" << getTaperY() << "\n";
-	output_stream <<"\t\t\trevolutions\t" << getRevolutions() << "\n";
-	output_stream <<"\t\t\tskew\t" << getSkew() << "\n";
-
-	output_stream << "\t\t}\n";
-	return TRUE;
-}
-
-LLSD LLPathParams::asLLSD() const
-{
-	LLSD sd = LLSD();
-	sd["curve"] = getCurveType();
-	sd["begin"] = getBegin();
-	sd["end"] = getEnd();
-	sd["scale_x"] = getScaleX();
-	sd["scale_y"] = getScaleY();
-	sd["shear_x"] = getShearX();
-	sd["shear_y"] = getShearY();
-	sd["twist"] = getTwist();
-	sd["twist_begin"] = getTwistBegin();
-	sd["radius_offset"] = getRadiusOffset();
-	sd["taper_x"] = getTaperX();
-	sd["taper_y"] = getTaperY();
-	sd["revolutions"] = getRevolutions();
-	sd["skew"] = getSkew();
-
-	return sd;
-}
-
-bool LLPathParams::fromLLSD(LLSD& sd)
-{
-	setCurveType(sd["curve"].asInteger());
-	setBegin((F32)sd["begin"].asReal());
-	setEnd((F32)sd["end"].asReal());
-	setScaleX((F32)sd["scale_x"].asReal());
-	setScaleY((F32)sd["scale_y"].asReal());
-	setShearX((F32)sd["shear_x"].asReal());
-	setShearY((F32)sd["shear_y"].asReal());
-	setTwist((F32)sd["twist"].asReal());
-	setTwistBegin((F32)sd["twist_begin"].asReal());
-	setRadiusOffset((F32)sd["radius_offset"].asReal());
-	setTaperX((F32)sd["taper_x"].asReal());
-	setTaperY((F32)sd["taper_y"].asReal());
-	setRevolutions((F32)sd["revolutions"].asReal());
-	setSkew((F32)sd["skew"].asReal());
-	return true;
-}
-
-void LLPathParams::copyParams(const LLPathParams &params)
-{
-	setCurveType(params.getCurveType());
-	setBegin(params.getBegin());
-	setEnd(params.getEnd());
-	setScale(params.getScaleX(), params.getScaleY() );
-	setShear(params.getShearX(), params.getShearY() );
-	setTwist(params.getTwist());
-	setTwistBegin(params.getTwistBegin());
-	setRadiusOffset(params.getRadiusOffset());
-	setTaper( params.getTaperX(), params.getTaperY() );
-	setRevolutions(params.getRevolutions());
-	setSkew(params.getSkew());
-}
-
-S32 profile_delete_lock = 1 ; 
-LLProfile::~LLProfile()
-{
-	if(profile_delete_lock)
-	{
-		llerrs << "LLProfile should not be deleted here!" << llendl ;
-	}
-}
-
-
-S32 LLVolume::sNumMeshPoints = 0;
-
-LLVolume::LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL generate_single_face, const BOOL is_unique)
-	: mParams(params)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	mUnique = is_unique;
-	mFaceMask = 0x0;
-	mDetail = detail;
-	mSculptLevel = -2;
-	
-	// set defaults
-	if (mParams.getPathParams().getCurveType() == LL_PCODE_PATH_FLEXIBLE)
-	{
-		mPathp = new LLDynamicPath();
-	}
-	else
-	{
-		mPathp = new LLPath();
-	}
-	mProfilep = new LLProfile();
-
-	mGenerateSingleFace = generate_single_face;
-
-	generate();
-	if (mParams.getSculptID().isNull() && params.getSculptType() == LL_SCULPT_TYPE_NONE)
-	{
-		createVolumeFaces();
-	}
-}
-
-void LLVolume::resizePath(S32 length)
-{
-	mPathp->resizePath(length);
-	mVolumeFaces.clear();
-}
-
-void LLVolume::regen()
-{
-	generate();
-	createVolumeFaces();
-}
-
-void LLVolume::genBinormals(S32 face)
-{
-	mVolumeFaces[face].createBinormals();
-}
-
-LLVolume::~LLVolume()
-{
-	sNumMeshPoints -= mMesh.size();
-	delete mPathp;
-
-	profile_delete_lock = 0 ;
-	delete mProfilep;
-	profile_delete_lock = 1 ;
-
-	mPathp = NULL;
-	mProfilep = NULL;
-	mVolumeFaces.clear();
-}
-
-BOOL LLVolume::generate()
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	llassert_always(mProfilep);
-	
-	//Added 10.03.05 Dave Parks
-	// Split is a parameter to LLProfile::generate that tesselates edges on the profile 
-	// to prevent lighting and texture interpolation errors on triangles that are 
-	// stretched due to twisting or scaling on the path.  
-	S32 split = (S32) ((mDetail)*0.66f);
-	
-	if (mParams.getPathParams().getCurveType() == LL_PCODE_PATH_LINE &&
-		(mParams.getPathParams().getScale().mV[0] != 1.0f ||
-		 mParams.getPathParams().getScale().mV[1] != 1.0f) &&
-		(mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_SQUARE ||
-		 mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_ISOTRI ||
-		 mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_EQUALTRI ||
-		 mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_RIGHTTRI))
-	{
-		split = 0;
-	}
-		 
-	mLODScaleBias.setVec(0.5f, 0.5f, 0.5f);
-	
-	F32 profile_detail = mDetail;
-	F32 path_detail = mDetail;
-	
-	U8 path_type = mParams.getPathParams().getCurveType();
-	U8 profile_type = mParams.getProfileParams().getCurveType();
-	
-	if (path_type == LL_PCODE_PATH_LINE && profile_type == LL_PCODE_PROFILE_CIRCLE)
-	{ //cylinders don't care about Z-Axis
-		mLODScaleBias.setVec(0.6f, 0.6f, 0.0f);
-	}
-	else if (path_type == LL_PCODE_PATH_CIRCLE) 
-	{	
-		mLODScaleBias.setVec(0.6f, 0.6f, 0.6f);
-	}
-	
-	//********************************************************************
-	//debug info, to be removed
-	if((U32)(mPathp->mPath.size() * mProfilep->mProfile.size()) > (1u << 20))
-	{
-		llinfos << "sizeS: " << mPathp->mPath.size() << " sizeT: " << mProfilep->mProfile.size() << llendl ;
-		llinfos << "path_detail : " << path_detail << " split: " << split << " profile_detail: " << profile_detail << llendl ;
-		llinfos << mParams << llendl ;
-		llinfos << "more info to check if mProfilep is deleted or not." << llendl ;
-		llinfos << mProfilep->mNormals.size() << " : " << mProfilep->mFaces.size() << " : " << mProfilep->mEdgeNormals.size() << " : " << mProfilep->mEdgeCenters.size() << llendl ;
-
-		llerrs << "LLVolume corrupted!" << llendl ;
-	}
-	//********************************************************************
-
-	BOOL regenPath = mPathp->generate(mParams.getPathParams(), path_detail, split);
-	BOOL regenProf = mProfilep->generate(mParams.getProfileParams(), mPathp->isOpen(),profile_detail, split);
-
-	if (regenPath || regenProf ) 
-	{
-		S32 sizeS = mPathp->mPath.size();
-		S32 sizeT = mProfilep->mProfile.size();
-
-		//********************************************************************
-		//debug info, to be removed
-		if((U32)(sizeS * sizeT) > (1u << 20))
-		{
-			llinfos << "regenPath: " << (S32)regenPath << " regenProf: " << (S32)regenProf << llendl ;
-			llinfos << "sizeS: " << sizeS << " sizeT: " << sizeT << llendl ;
-			llinfos << "path_detail : " << path_detail << " split: " << split << " profile_detail: " << profile_detail << llendl ;
-			llinfos << mParams << llendl ;
-			llinfos << "more info to check if mProfilep is deleted or not." << llendl ;
-			llinfos << mProfilep->mNormals.size() << " : " << mProfilep->mFaces.size() << " : " << mProfilep->mEdgeNormals.size() << " : " << mProfilep->mEdgeCenters.size() << llendl ;
-
-			llerrs << "LLVolume corrupted!" << llendl ;
-		}
-		//********************************************************************
-
-		sNumMeshPoints -= mMesh.size();
-		mMesh.resize(sizeT * sizeS);
-		sNumMeshPoints += mMesh.size();		
-
-		//generate vertex positions
-
-		// Run along the path.
-		for (S32 s = 0; s < sizeS; ++s)
-		{
-			LLVector2  scale = mPathp->mPath[s].mScale;
-			LLQuaternion rot = mPathp->mPath[s].mRot;
-
-			// Run along the profile.
-			for (S32 t = 0; t < sizeT; ++t)
-			{
-				S32 m = s*sizeT + t;
-				Point& pt = mMesh[m];
-				
-				pt.mPos.mV[0] = mProfilep->mProfile[t].mV[0] * scale.mV[0];
-				pt.mPos.mV[1] = mProfilep->mProfile[t].mV[1] * scale.mV[1];
-				pt.mPos.mV[2] = 0.0f;
-				pt.mPos       = pt.mPos * rot;
-				pt.mPos      += mPathp->mPath[s].mPos;
-			}
-		}
-
-		for (std::vector<LLProfile::Face>::iterator iter = mProfilep->mFaces.begin();
-			 iter != mProfilep->mFaces.end(); ++iter)
-		{
-			LLFaceID id = iter->mFaceID;
-			mFaceMask |= id;
-		}
-		
-		return TRUE;
-	}
-	return FALSE;
-}
-
-
-void LLVolume::createVolumeFaces()
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-
-	if (mGenerateSingleFace)
-	{
-		// do nothing
-	}
-	else
-	{
-		S32 num_faces = getNumFaces();
-		BOOL partial_build = TRUE;
-		if (num_faces != mVolumeFaces.size())
-		{
-			partial_build = FALSE;
-			mVolumeFaces.resize(num_faces);
-		}
-		// Initialize volume faces with parameter data
-		for (S32 i = 0; i < (S32)mVolumeFaces.size(); i++)
-		{
-			LLVolumeFace& vf = mVolumeFaces[i];
-			LLProfile::Face& face = mProfilep->mFaces[i];
-			vf.mBeginS = face.mIndex;
-			vf.mNumS = face.mCount;
-			if (vf.mNumS < 0)
-			{
-				llerrs << "Volume face corruption detected." << llendl;
-			}
-
-			vf.mBeginT = 0;
-			vf.mNumT= getPath().mPath.size();
-			vf.mID = i;
-
-			// Set the type mask bits correctly
-			if (mParams.getProfileParams().getHollow() > 0)
-			{
-				vf.mTypeMask |= LLVolumeFace::HOLLOW_MASK;
-			}
-			if (mProfilep->isOpen())
-			{
-				vf.mTypeMask |= LLVolumeFace::OPEN_MASK;
-			}
-			if (face.mCap)
-			{
-				vf.mTypeMask |= LLVolumeFace::CAP_MASK;
-				if (face.mFaceID == LL_FACE_PATH_BEGIN)
-				{
-					vf.mTypeMask |= LLVolumeFace::TOP_MASK;
-				}
-				else
-				{
-					llassert(face.mFaceID == LL_FACE_PATH_END);
-					vf.mTypeMask |= LLVolumeFace::BOTTOM_MASK;
-				}
-			}
-			else if (face.mFaceID & (LL_FACE_PROFILE_BEGIN | LL_FACE_PROFILE_END))
-			{
-				vf.mTypeMask |= LLVolumeFace::FLAT_MASK | LLVolumeFace::END_MASK;
-			}
-			else
-			{
-				vf.mTypeMask |= LLVolumeFace::SIDE_MASK;
-				if (face.mFlat)
-				{
-					vf.mTypeMask |= LLVolumeFace::FLAT_MASK;
-				}
-				if (face.mFaceID & LL_FACE_INNER_SIDE)
-				{
-					vf.mTypeMask |= LLVolumeFace::INNER_MASK;
-					if (face.mFlat && vf.mNumS > 2)
-					{ //flat inner faces have to copy vert normals
-						vf.mNumS = vf.mNumS*2;
-						if (vf.mNumS < 0)
-						{
-							llerrs << "Volume face corruption detected." << llendl;
-						}
-					}
-				}
-				else
-				{
-					vf.mTypeMask |= LLVolumeFace::OUTER_MASK;
-				}
-			}
-		}
-
-		for (face_list_t::iterator iter = mVolumeFaces.begin();
-			 iter != mVolumeFaces.end(); ++iter)
-		{
-			(*iter).create(this, partial_build);
-		}
-	}
-}
-
-
-inline LLVector3 sculpt_rgb_to_vector(U8 r, U8 g, U8 b)
-{
-	// maps RGB values to vector values [0..255] -> [-0.5..0.5]
-	LLVector3 value;
-	value.mV[VX] = r / 255.f - 0.5f;
-	value.mV[VY] = g / 255.f - 0.5f;
-	value.mV[VZ] = b / 255.f - 0.5f;
-
-	return value;
-}
-
-inline U32 sculpt_xy_to_index(U32 x, U32 y, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components)
-{
-	U32 index = (x + y * sculpt_width) * sculpt_components;
-	return index;
-}
-
-
-inline U32 sculpt_st_to_index(S32 s, S32 t, S32 size_s, S32 size_t, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components)
-{
-	U32 x = (U32) ((F32)s/(size_s) * (F32) sculpt_width);
-	U32 y = (U32) ((F32)t/(size_t) * (F32) sculpt_height);
-
-	return sculpt_xy_to_index(x, y, sculpt_width, sculpt_height, sculpt_components);
-}
-
-
-inline LLVector3 sculpt_index_to_vector(U32 index, const U8* sculpt_data)
-{
-	LLVector3 v = sculpt_rgb_to_vector(sculpt_data[index], sculpt_data[index+1], sculpt_data[index+2]);
-
-	return v;
-}
-
-inline LLVector3 sculpt_st_to_vector(S32 s, S32 t, S32 size_s, S32 size_t, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data)
-{
-	U32 index = sculpt_st_to_index(s, t, size_s, size_t, sculpt_width, sculpt_height, sculpt_components);
-
-	return sculpt_index_to_vector(index, sculpt_data);
-}
-
-inline LLVector3 sculpt_xy_to_vector(U32 x, U32 y, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data)
-{
-	U32 index = sculpt_xy_to_index(x, y, sculpt_width, sculpt_height, sculpt_components);
-
-	return sculpt_index_to_vector(index, sculpt_data);
-}
-
-
-F32 LLVolume::sculptGetSurfaceArea()
-{
-	// test to see if image has enough variation to create non-degenerate geometry
-
-	F32 area = 0;
-
-	S32 sizeS = mPathp->mPath.size();
-	S32 sizeT = mProfilep->mProfile.size();
-			
-	for (S32 s = 0; s < sizeS-1; s++)
-	{
-		for (S32 t = 0; t < sizeT-1; t++)
-		{
-			// get four corners of quad
-			LLVector3 p1 = mMesh[(s  )*sizeT + (t  )].mPos;
-			LLVector3 p2 = mMesh[(s+1)*sizeT + (t  )].mPos;
-			LLVector3 p3 = mMesh[(s  )*sizeT + (t+1)].mPos;
-			LLVector3 p4 = mMesh[(s+1)*sizeT + (t+1)].mPos;
-
-			// compute the area of the quad by taking the length of the cross product of the two triangles
-			LLVector3 cross1 = (p1 - p2) % (p1 - p3);
-			LLVector3 cross2 = (p4 - p2) % (p4 - p3);
-			area += (cross1.magVec() + cross2.magVec()) / 2.0;
-		}
-	}
-
-	return area;
-}
-
-// create placeholder shape
-void LLVolume::sculptGeneratePlaceholder()
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	S32 sizeS = mPathp->mPath.size();
-	S32 sizeT = mProfilep->mProfile.size();
-	
-	S32 line = 0;
-
-	// for now, this is a sphere.
-	for (S32 s = 0; s < sizeS; s++)
-	{
-		for (S32 t = 0; t < sizeT; t++)
-		{
-			S32 i = t + line;
-			Point& pt = mMesh[i];
-
-			
-			F32 u = (F32)s/(sizeS-1);
-			F32 v = (F32)t/(sizeT-1);
-
-			const F32 RADIUS = (F32) 0.3;
-					
-			pt.mPos.mV[0] = (F32)(sin(F_PI * v) * cos(2.0 * F_PI * u) * RADIUS);
-			pt.mPos.mV[1] = (F32)(sin(F_PI * v) * sin(2.0 * F_PI * u) * RADIUS);
-			pt.mPos.mV[2] = (F32)(cos(F_PI * v) * RADIUS);
-
-		}
-		line += sizeT;
-	}
-}
-
-// create the vertices from the map
-void LLVolume::sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, U8 sculpt_type)
-{
-	U8 sculpt_stitching = sculpt_type & LL_SCULPT_TYPE_MASK;
-	BOOL sculpt_invert = sculpt_type & LL_SCULPT_FLAG_INVERT;
-	BOOL sculpt_mirror = sculpt_type & LL_SCULPT_FLAG_MIRROR;
-	BOOL reverse_horizontal = (sculpt_invert ? !sculpt_mirror : sculpt_mirror);  // XOR
-	
-	
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	S32 sizeS = mPathp->mPath.size();
-	S32 sizeT = mProfilep->mProfile.size();
-	
-	S32 line = 0;
-	for (S32 s = 0; s < sizeS; s++)
-	{
-		// Run along the profile.
-		for (S32 t = 0; t < sizeT; t++)
-		{
-			S32 i = t + line;
-			Point& pt = mMesh[i];
-
-			S32 reversed_t = t;
-
-			if (reverse_horizontal)
-			{
-				reversed_t = sizeT - t - 1;
-			}
-			
-			U32 x = (U32) ((F32)reversed_t/(sizeT-1) * (F32) sculpt_width);
-			U32 y = (U32) ((F32)s/(sizeS-1) * (F32) sculpt_height);
-
-			
-			if (y == 0)  // top row stitching
-			{
-				// pinch?
-				if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)
-				{
-					x = sculpt_width / 2;
-				}
-			}
-
-			if (y == sculpt_height)  // bottom row stitching
-			{
-				// wrap?
-				if (sculpt_stitching == LL_SCULPT_TYPE_TORUS)
-				{
-					y = 0;
-				}
-				else
-				{
-					y = sculpt_height - 1;
-				}
-
-				// pinch?
-				if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)
-				{
-					x = sculpt_width / 2;
-				}
-			}
-
-			if (x == sculpt_width)   // side stitching
-			{
-				// wrap?
-				if ((sculpt_stitching == LL_SCULPT_TYPE_SPHERE) ||
-					(sculpt_stitching == LL_SCULPT_TYPE_TORUS) ||
-					(sculpt_stitching == LL_SCULPT_TYPE_CYLINDER))
-				{
-					x = 0;
-				}
-					
-				else
-				{
-					x = sculpt_width - 1;
-				}
-			}
-
-			pt.mPos = sculpt_xy_to_vector(x, y, sculpt_width, sculpt_height, sculpt_components, sculpt_data);
-
-			if (sculpt_mirror)
-			{
-				pt.mPos.mV[VX] *= -1.f;
-			}
-		}
-		
-		line += sizeT;
-	}
-}
-
-
-const S32 SCULPT_REZ_1 = 6;  // changed from 4 to 6 - 6 looks round whereas 4 looks square
-const S32 SCULPT_REZ_2 = 8;
-const S32 SCULPT_REZ_3 = 16;
-const S32 SCULPT_REZ_4 = 32;
-
-S32 sculpt_sides(F32 detail)
-{
-
-	// detail is usually one of: 1, 1.5, 2.5, 4.0.
-	
-	if (detail <= 1.0)
-	{
-		return SCULPT_REZ_1;
-	}
-	if (detail <= 2.0)
-	{
-		return SCULPT_REZ_2;
-	}
-	if (detail <= 3.0)
-	{
-		return SCULPT_REZ_3;
-	}
-	else
-	{
-		return SCULPT_REZ_4;
-	}
-}
-
-
-
-// determine the number of vertices in both s and t direction for this sculpt
-void sculpt_calc_mesh_resolution(U16 width, U16 height, U8 type, F32 detail, S32& s, S32& t)
-{
-	// this code has the following properties:
-	// 1) the aspect ratio of the mesh is as close as possible to the ratio of the map
-	//    while still using all available verts
-	// 2) the mesh cannot have more verts than is allowed by LOD
-	// 3) the mesh cannot have more verts than is allowed by the map
-	
-	S32 max_vertices_lod = (S32)pow((double)sculpt_sides(detail), 2.0);
-	S32 max_vertices_map = width * height / 4;
-	
-	S32 vertices;
-	if (max_vertices_map > 0)
-		vertices = llmin(max_vertices_lod, max_vertices_map);
-	else
-		vertices = max_vertices_lod;
-	
-
-	F32 ratio;
-	if ((width == 0) || (height == 0))
-		ratio = 1.f;
-	else
-		ratio = (F32) width / (F32) height;
-
-	
-	s = (S32)fsqrtf(((F32)vertices / ratio));
-
-	s = llmax(s, 4);              // no degenerate sizes, please
-	t = vertices / s;
-
-	t = llmax(t, 4);              // no degenerate sizes, please
-	s = vertices / t;
-}
-
-// 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)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-    U8 sculpt_type = mParams.getSculptType();
-
-	BOOL data_is_empty = FALSE;
-
-	if (sculpt_width == 0 || sculpt_height == 0 || sculpt_components < 3 || sculpt_data == NULL)
-	{
-		sculpt_level = -1;
-		data_is_empty = TRUE;
-	}
-
-	S32 requested_sizeS = 0;
-	S32 requested_sizeT = 0;
-
-	sculpt_calc_mesh_resolution(sculpt_width, sculpt_height, sculpt_type, mDetail, requested_sizeS, 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
-
-	// weird crash bug - DEV-11158 - trying to collect more data:
-	if ((sizeS == 0) || (sizeT == 0))
-	{
-		llwarns << "sculpt bad mesh size " << sizeS << " " << sizeT << llendl;
-	}
-	
-	sNumMeshPoints -= mMesh.size();
-	mMesh.resize(sizeS * sizeT);
-	sNumMeshPoints += mMesh.size();
-
-	//generate vertex positions
-	if (!data_is_empty)
-	{
-		sculptGenerateMapVertices(sculpt_width, sculpt_height, sculpt_components, sculpt_data, sculpt_type);
-
-		// don't test lowest LOD to support legacy content DEV-33670
-		if (mDetail > SCULPT_MIN_AREA_DETAIL)
-		{
-			if (sculptGetSurfaceArea() < SCULPT_MIN_AREA)
-			{
-				data_is_empty = TRUE;
-			}
-		}
-	}
-
-	if (data_is_empty)
-	{
-		sculptGeneratePlaceholder();
-	}
-
-
-	
-	for (S32 i = 0; i < (S32)mProfilep->mFaces.size(); i++)
-	{
-		mFaceMask |= mProfilep->mFaces[i].mFaceID;
-	}
-
-	mSculptLevel = sculpt_level;
-
-	// Delete any existing faces so that they get regenerated
-	mVolumeFaces.clear();
-	
-	createVolumeFaces();
-}
-
-
-
-
-BOOL LLVolume::isCap(S32 face)
-{
-	return mProfilep->mFaces[face].mCap; 
-}
-
-BOOL LLVolume::isFlat(S32 face)
-{
-	return mProfilep->mFaces[face].mFlat;
-}
-
-
-bool LLVolumeParams::operator==(const LLVolumeParams &params) const
-{
-	return ( (getPathParams() == params.getPathParams()) &&
-			 (getProfileParams() == params.getProfileParams()) &&
-			 (mSculptID == params.mSculptID) &&
-			 (mSculptType == params.mSculptType) );
-}
-
-bool LLVolumeParams::operator!=(const LLVolumeParams &params) const
-{
-	return ( (getPathParams() != params.getPathParams()) ||
-			 (getProfileParams() != params.getProfileParams()) ||
-			 (mSculptID != params.mSculptID) ||
-			 (mSculptType != params.mSculptType) );
-}
-
-bool LLVolumeParams::operator<(const LLVolumeParams &params) const
-{
-	if( getPathParams() != params.getPathParams() )
-	{
-		return getPathParams() < params.getPathParams();
-	}
-	
-	if (getProfileParams() != params.getProfileParams())
-	{
-		return getProfileParams() < params.getProfileParams();
-	}
-	
-	if (mSculptID != params.mSculptID)
-	{
-		return mSculptID < params.mSculptID;
-	}
-
-
-	return mSculptType < params.mSculptType;
-
-
-}
-
-void LLVolumeParams::copyParams(const LLVolumeParams &params)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	mProfileParams.copyParams(params.mProfileParams);
-	mPathParams.copyParams(params.mPathParams);
-	mSculptID = params.getSculptID();
-	mSculptType = params.getSculptType();
-}
-
-// Less restricitve approx 0 for volumes
-const F32 APPROXIMATELY_ZERO = 0.001f;
-bool approx_zero( F32 f, F32 tolerance = APPROXIMATELY_ZERO)
-{
-	return (f >= -tolerance) && (f <= tolerance);
-}
-
-// return true if in range (or nearly so)
-static bool limit_range(F32& v, F32 min, F32 max, F32 tolerance = APPROXIMATELY_ZERO)
-{
-	F32 min_delta = v - min;
-	if (min_delta < 0.f)
-	{
-		v = min;
-		if (!approx_zero(min_delta, tolerance))
-			return false;
-	}
-	F32 max_delta = max - v;
-	if (max_delta < 0.f)
-	{
-		v = max;
-		if (!approx_zero(max_delta, tolerance))
-			return false;
-	}
-	return true;
-}
-
-bool LLVolumeParams::setBeginAndEndS(const F32 b, const F32 e)
-{
-	bool valid = true;
-
-	// First, clamp to valid ranges.
-	F32 begin = b;
-	valid &= limit_range(begin, 0.f, 1.f - MIN_CUT_DELTA);
-
-	F32 end = e;
-	if (end >= .0149f && end < MIN_CUT_DELTA) end = MIN_CUT_DELTA; // eliminate warning for common rounding error
-	valid &= limit_range(end, MIN_CUT_DELTA, 1.f);
-
-	valid &= limit_range(begin, 0.f, end - MIN_CUT_DELTA, .01f);
-
-	// Now set them.
-	mProfileParams.setBegin(begin);
-	mProfileParams.setEnd(end);
-
-	return valid;
-}
-
-bool LLVolumeParams::setBeginAndEndT(const F32 b, const F32 e)
-{
-	bool valid = true;
-
-	// First, clamp to valid ranges.
-	F32 begin = b;
-	valid &= limit_range(begin, 0.f, 1.f - MIN_CUT_DELTA);
-
-	F32 end = e;
-	valid &= limit_range(end, MIN_CUT_DELTA, 1.f);
-
-	valid &= limit_range(begin, 0.f, end - MIN_CUT_DELTA, .01f);
-
-	// Now set them.
-	mPathParams.setBegin(begin);
-	mPathParams.setEnd(end);
-
-	return valid;
-}			
-
-bool LLVolumeParams::setHollow(const F32 h)
-{
-	// Validate the hollow based on path and profile.
-	U8 profile 	= mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;
-	U8 hole_type 	= mProfileParams.getCurveType() & LL_PCODE_HOLE_MASK;
-	
-	F32 max_hollow = HOLLOW_MAX;
-
-	// Only square holes have trouble.
-	if (LL_PCODE_HOLE_SQUARE == hole_type)
-	{
-		switch(profile)
-		{
-		case LL_PCODE_PROFILE_CIRCLE:
-		case LL_PCODE_PROFILE_CIRCLE_HALF:
-		case LL_PCODE_PROFILE_EQUALTRI:
-			max_hollow = HOLLOW_MAX_SQUARE;
-		}
-	}
-
-	F32 hollow = h;
-	bool valid = limit_range(hollow, HOLLOW_MIN, max_hollow);
-	mProfileParams.setHollow(hollow); 
-
-	return valid;
-}	
-
-bool LLVolumeParams::setTwistBegin(const F32 b)
-{
-	F32 twist_begin = b;
-	bool valid = limit_range(twist_begin, TWIST_MIN, TWIST_MAX);
-	mPathParams.setTwistBegin(twist_begin);
-	return valid;
-}
-
-bool LLVolumeParams::setTwistEnd(const F32 e)
-{	
-	F32 twist_end = e;
-	bool valid = limit_range(twist_end, TWIST_MIN, TWIST_MAX);
-	mPathParams.setTwistEnd(twist_end);
-	return valid;
-}
-
-bool LLVolumeParams::setRatio(const F32 x, const F32 y)
-{
-	F32 min_x = RATIO_MIN;
-	F32 max_x = RATIO_MAX;
-	F32 min_y = RATIO_MIN;
-	F32 max_y = RATIO_MAX;
-	// If this is a circular path (and not a sphere) then 'ratio' is actually hole size.
-	U8 path_type 	= mPathParams.getCurveType();
-	U8 profile_type = mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;
-	if ( LL_PCODE_PATH_CIRCLE == path_type &&
-		 LL_PCODE_PROFILE_CIRCLE_HALF != profile_type)
-	{
-		// Holes are more restricted...
-		min_x = HOLE_X_MIN;
-		max_x = HOLE_X_MAX;
-		min_y = HOLE_Y_MIN;
-		max_y = HOLE_Y_MAX;
-	}
-
-	F32 ratio_x = x;
-	bool valid = limit_range(ratio_x, min_x, max_x);
-	F32 ratio_y = y;
-	valid &= limit_range(ratio_y, min_y, max_y);
-
-	mPathParams.setScale(ratio_x, ratio_y);
-
-	return valid;
-}
-
-bool LLVolumeParams::setShear(const F32 x, const F32 y)
-{
-	F32 shear_x = x;
-	bool valid = limit_range(shear_x, SHEAR_MIN, SHEAR_MAX);
-	F32 shear_y = y;
-	valid &= limit_range(shear_y, SHEAR_MIN, SHEAR_MAX);
-	mPathParams.setShear(shear_x, shear_y);
-	return valid;
-}
-
-bool LLVolumeParams::setTaperX(const F32 v)
-{
-	F32 taper = v;
-	bool valid = limit_range(taper, TAPER_MIN, TAPER_MAX);
-	mPathParams.setTaperX(taper);
-	return valid;
-}
-
-bool LLVolumeParams::setTaperY(const F32 v)
-{
-	F32 taper = v;
-	bool valid = limit_range(taper, TAPER_MIN, TAPER_MAX);
-	mPathParams.setTaperY(taper);
-	return valid;
-}
-
-bool LLVolumeParams::setRevolutions(const F32 r)
-{
-	F32 revolutions = r;
-	bool valid = limit_range(revolutions, REV_MIN, REV_MAX);
-	mPathParams.setRevolutions(revolutions);
-	return valid;
-}
-
-bool LLVolumeParams::setRadiusOffset(const F32 offset)
-{
-	bool valid = true;
-
-	// If this is a sphere, just set it to 0 and get out.
-	U8 path_type 	= mPathParams.getCurveType();
-	U8 profile_type = mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;
-	if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type ||
-		LL_PCODE_PATH_CIRCLE != path_type )
-	{
-		mPathParams.setRadiusOffset(0.f);
-		return true;
-	}
-
-	// Limit radius offset, based on taper and hole size y.
-	F32 radius_offset	= offset;
-	F32 taper_y    		= getTaperY();
-	F32 radius_mag		= fabs(radius_offset);
-	F32 hole_y_mag 		= fabs(getRatioY());
-	F32 taper_y_mag		= fabs(taper_y);
-	// Check to see if the taper effects us.
-	if ( (radius_offset > 0.f && taper_y < 0.f) ||
-			(radius_offset < 0.f && taper_y > 0.f) )
-	{
-		// The taper does not help increase the radius offset range.
-		taper_y_mag = 0.f;
-	}
-	F32 max_radius_mag = 1.f - hole_y_mag * (1.f - taper_y_mag) / (1.f - hole_y_mag);
-
-	// Enforce the maximum magnitude.
-	F32 delta = max_radius_mag - radius_mag;
-	if (delta < 0.f)
-	{
-		// Check radius offset sign.
-		if (radius_offset < 0.f)
-		{
-			radius_offset = -max_radius_mag;
-		}
-		else
-		{
-			radius_offset = max_radius_mag;
-		}
-		valid = approx_zero(delta, .1f);
-	}
-
-	mPathParams.setRadiusOffset(radius_offset);
-	return valid;
-}
-
-bool LLVolumeParams::setSkew(const F32 skew_value)
-{
-	bool valid = true;
-
-	// Check the skew value against the revolutions.
-	F32 skew		= llclamp(skew_value, SKEW_MIN, SKEW_MAX);
-	F32 skew_mag	= fabs(skew);
-	F32 revolutions = getRevolutions();
-	F32 scale_x		= getRatioX();
-	F32 min_skew_mag = 1.0f - 1.0f / (revolutions * scale_x + 1.0f);
-	// Discontinuity; A revolution of 1 allows skews below 0.5.
-	if ( fabs(revolutions - 1.0f) < 0.001)
-		min_skew_mag = 0.0f;
-
-	// Clip skew.
-	F32 delta = skew_mag - min_skew_mag;
-	if (delta < 0.f)
-	{
-		// Check skew sign.
-		if (skew < 0.0f)
-		{
-			skew = -min_skew_mag;
-		}
-		else 
-		{
-			skew = min_skew_mag;
-		}
-		valid = approx_zero(delta, .01f);
-	}
-
-	mPathParams.setSkew(skew);
-	return valid;
-}
-
-bool LLVolumeParams::setSculptID(const LLUUID sculpt_id, U8 sculpt_type)
-{
-	mSculptID = sculpt_id;
-	mSculptType = sculpt_type;
-	return true;
-}
-
-bool LLVolumeParams::setType(U8 profile, U8 path)
-{
-	bool result = true;
-	// First, check profile and path for validity.
-	U8 profile_type	= profile & LL_PCODE_PROFILE_MASK;
-	U8 hole_type 	= (profile & LL_PCODE_HOLE_MASK) >> 4;
-	U8 path_type	= path >> 4;
-
-	if (profile_type > LL_PCODE_PROFILE_MAX)
-	{
-		// Bad profile.  Make it square.
-		profile = LL_PCODE_PROFILE_SQUARE;
-		result = false;
-		llwarns << "LLVolumeParams::setType changing bad profile type (" << profile_type
-			 	<< ") to be LL_PCODE_PROFILE_SQUARE" << llendl;
-	}
-	else if (hole_type > LL_PCODE_HOLE_MAX)
-	{
-		// Bad hole.  Make it the same.
-		profile = profile_type;
-		result = false;
-		llwarns << "LLVolumeParams::setType changing bad hole type (" << hole_type
-			 	<< ") to be LL_PCODE_HOLE_SAME" << llendl;
-	}
-
-	if (path_type < LL_PCODE_PATH_MIN ||
-		path_type > LL_PCODE_PATH_MAX)
-	{
-		// Bad path.  Make it linear.
-		result = false;
-		llwarns << "LLVolumeParams::setType changing bad path (" << path
-			 	<< ") to be LL_PCODE_PATH_LINE" << llendl;
-		path = LL_PCODE_PATH_LINE;
-	}
-
-	mProfileParams.setCurveType(profile);
-	mPathParams.setCurveType(path);
-	return result;
-}
-
-// static 
-bool LLVolumeParams::validate(U8 prof_curve, F32 prof_begin, F32 prof_end, F32 hollow,
-		U8 path_curve, F32 path_begin, F32 path_end,
-		F32 scx, F32 scy, F32 shx, F32 shy,
-		F32 twistend, F32 twistbegin, F32 radiusoffset,
-		F32 tx, F32 ty, F32 revolutions, F32 skew)
-{
-	LLVolumeParams test_params;
-	if (!test_params.setType		(prof_curve, path_curve))
-	{
-	    	return false;
-	}
-	if (!test_params.setBeginAndEndS	(prof_begin, prof_end))
-	{
-	    	return false;
-	}
-	if (!test_params.setBeginAndEndT	(path_begin, path_end))
-	{
-	    	return false;
-	}
-	if (!test_params.setHollow		(hollow))
-	{
-	    	return false;
-	}
-	if (!test_params.setTwistBegin		(twistbegin))
-	{
-	    	return false;
-	}
-	if (!test_params.setTwistEnd		(twistend))
-	{
-	    	return false;
-	}
-	if (!test_params.setRatio		(scx, scy))
-	{
-	    	return false;
-	}
-	if (!test_params.setShear		(shx, shy))
-	{
-	    	return false;
-	}
-	if (!test_params.setTaper		(tx, ty))
-	{
-	    	return false;
-	}
-	if (!test_params.setRevolutions		(revolutions))
-	{
-	    	return false;
-	}
-	if (!test_params.setRadiusOffset	(radiusoffset))
-	{
-	    	return false;
-	}
-	if (!test_params.setSkew		(skew))
-	{
-	    	return false;
-	}
-	return true;
-}
-
-S32 *LLVolume::getTriangleIndices(U32 &num_indices) const
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	S32 expected_num_triangle_indices = getNumTriangleIndices();
-	if (expected_num_triangle_indices > MAX_VOLUME_TRIANGLE_INDICES)
-	{
-		// we don't allow LLVolumes with this many vertices
-		llwarns << "Couldn't allocate triangle indices" << llendl;
-		num_indices = 0;
-		return NULL;
-	}
-
-	S32* index = new S32[expected_num_triangle_indices];
-	S32 count = 0;
-
-	// Let's do this totally diffently, as we don't care about faces...
-	// Counter-clockwise triangles are forward facing...
-
-	BOOL open = getProfile().isOpen();
-	BOOL hollow = (mParams.getProfileParams().getHollow() > 0);
-	BOOL path_open = getPath().isOpen();
-	S32 size_s, size_s_out, size_t;
-	S32 s, t, i;
-	size_s = getProfile().getTotal();
-	size_s_out = getProfile().getTotalOut();
-	size_t = getPath().mPath.size();
-
-	// NOTE -- if the construction of the triangles below ever changes
-	// then getNumTriangleIndices() method may also have to be updated.
-
-	if (open)		/* Flawfinder: ignore */
-	{
-		if (hollow)
-		{
-			// Open hollow -- much like the closed solid, except we 
-			// we need to stitch up the gap between s=0 and s=size_s-1
-
-			for (t = 0; t < size_t - 1; t++)
-			{
-				// The outer face, first cut, and inner face
-				for (s = 0; s < size_s - 1; s++)
-				{
-					i  = s + t*size_s;
-					index[count++]  = i;				// x,y
-					index[count++]  = i + 1;			// x+1,y
-					index[count++]  = i + size_s;		// x,y+1
-	
-					index[count++]  = i + size_s;		// x,y+1
-					index[count++]  = i + 1;			// x+1,y
-					index[count++]  = i + size_s + 1;	// x+1,y+1
-				}
-
-				// The other cut face
-				index[count++]  = s + t*size_s;		// x,y
-				index[count++]  = 0 + t*size_s;		// x+1,y
-				index[count++]  = s + (t+1)*size_s;	// x,y+1
-	
-				index[count++]  = s + (t+1)*size_s;	// x,y+1
-				index[count++]  = 0 + t*size_s;		// x+1,y
-				index[count++]  = 0 + (t+1)*size_s;	// x+1,y+1
-			}
-
-			// Do the top and bottom caps, if necessary
-			if (path_open)
-			{
-				// Top cap
-				S32 pt1 = 0;
-				S32 pt2 = size_s-1;
-				S32 i   = (size_t - 1)*size_s;
-
-				while (pt2 - pt1 > 1)
-				{
-					// Use the profile points instead of the mesh, since you want
-					// the un-transformed profile distances.
-					LLVector3 p1 = getProfile().mProfile[pt1];
-					LLVector3 p2 = getProfile().mProfile[pt2];
-					LLVector3 pa = getProfile().mProfile[pt1+1];
-					LLVector3 pb = getProfile().mProfile[pt2-1];
-
-					p1.mV[VZ] = 0.f;
-					p2.mV[VZ] = 0.f;
-					pa.mV[VZ] = 0.f;
-					pb.mV[VZ] = 0.f;
-
-					// Use area of triangle to determine backfacing
-					F32 area_1a2, area_1ba, area_21b, area_2ab;
-					area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
-								(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
-								(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
-
-					area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-								(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
-								(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
-
-					area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
-								(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-					area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
-								(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
-								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-					BOOL use_tri1a2 = TRUE;
-					BOOL tri_1a2 = TRUE;
-					BOOL tri_21b = TRUE;
-
-					if (area_1a2 < 0)
-					{
-						tri_1a2 = FALSE;
-					}
-					if (area_2ab < 0)
-					{
-						// Can't use, because it contains point b
-						tri_1a2 = FALSE;
-					}
-					if (area_21b < 0)
-					{
-						tri_21b = FALSE;
-					}
-					if (area_1ba < 0)
-					{
-						// Can't use, because it contains point b
-						tri_21b = FALSE;
-					}
-
-					if (!tri_1a2)
-					{
-						use_tri1a2 = FALSE;
-					}
-					else if (!tri_21b)
-					{
-						use_tri1a2 = TRUE;
-					}
-					else
-					{
-						LLVector3 d1 = p1 - pa;
-						LLVector3 d2 = p2 - pb;
-
-						if (d1.magVecSquared() < d2.magVecSquared())
-						{
-							use_tri1a2 = TRUE;
-						}
-						else
-						{
-							use_tri1a2 = FALSE;
-						}
-					}
-
-					if (use_tri1a2)
-					{
-						index[count++] = pt1 + i;
-						index[count++] = pt1 + 1 + i;
-						index[count++] = pt2 + i;
-						pt1++;
-					}
-					else
-					{
-						index[count++] = pt1 + i;
-						index[count++] = pt2 - 1 + i;
-						index[count++] = pt2 + i;
-						pt2--;
-					}
-				}
-
-				// Bottom cap
-				pt1          = 0;
-				pt2          = size_s-1;
-				while (pt2 - pt1 > 1)
-				{
-					// Use the profile points instead of the mesh, since you want
-					// the un-transformed profile distances.
-					LLVector3 p1 = getProfile().mProfile[pt1];
-					LLVector3 p2 = getProfile().mProfile[pt2];
-					LLVector3 pa = getProfile().mProfile[pt1+1];
-					LLVector3 pb = getProfile().mProfile[pt2-1];
-
-					p1.mV[VZ] = 0.f;
-					p2.mV[VZ] = 0.f;
-					pa.mV[VZ] = 0.f;
-					pb.mV[VZ] = 0.f;
-
-					// Use area of triangle to determine backfacing
-					F32 area_1a2, area_1ba, area_21b, area_2ab;
-					area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
-								(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
-								(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
-
-					area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-								(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
-								(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
-
-					area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
-								(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-					area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
-								(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
-								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-					BOOL use_tri1a2 = TRUE;
-					BOOL tri_1a2 = TRUE;
-					BOOL tri_21b = TRUE;
-
-					if (area_1a2 < 0)
-					{
-						tri_1a2 = FALSE;
-					}
-					if (area_2ab < 0)
-					{
-						// Can't use, because it contains point b
-						tri_1a2 = FALSE;
-					}
-					if (area_21b < 0)
-					{
-						tri_21b = FALSE;
-					}
-					if (area_1ba < 0)
-					{
-						// Can't use, because it contains point b
-						tri_21b = FALSE;
-					}
-
-					if (!tri_1a2)
-					{
-						use_tri1a2 = FALSE;
-					}
-					else if (!tri_21b)
-					{
-						use_tri1a2 = TRUE;
-					}
-					else
-					{
-						LLVector3 d1 = p1 - pa;
-						LLVector3 d2 = p2 - pb;
-
-						if (d1.magVecSquared() < d2.magVecSquared())
-						{
-							use_tri1a2 = TRUE;
-						}
-						else
-						{
-							use_tri1a2 = FALSE;
-						}
-					}
-
-					if (use_tri1a2)
-					{
-						index[count++] = pt1;
-						index[count++] = pt2;
-						index[count++] = pt1 + 1;
-						pt1++;
-					}
-					else
-					{
-						index[count++] = pt1;
-						index[count++] = pt2;
-						index[count++] = pt2 - 1;
-						pt2--;
-					}
-				}
-			}
-		}
-		else
-		{
-			// Open solid
-
-			for (t = 0; t < size_t - 1; t++)
-			{
-				// Outer face + 1 cut face
-				for (s = 0; s < size_s - 1; s++)
-				{
-					i  = s + t*size_s;
-
-					index[count++]  = i;				// x,y
-					index[count++]  = i + 1;			// x+1,y
-					index[count++]  = i + size_s;		// x,y+1
-
-					index[count++]  = i + size_s;		// x,y+1
-					index[count++]  = i + 1;			// x+1,y
-					index[count++]  = i + size_s + 1;	// x+1,y+1
-				}
-
-				// The other cut face
-				index[count++] = (size_s - 1) + (t*size_s);		// x,y
-				index[count++] = 0 + t*size_s;					// x+1,y
-				index[count++] = (size_s - 1) + (t+1)*size_s;	// x,y+1
-
-				index[count++] = (size_s - 1) + (t+1)*size_s;	// x,y+1
-				index[count++] = 0 + (t*size_s);				// x+1,y
-				index[count++] = 0 + (t+1)*size_s;				// x+1,y+1
-			}
-
-			// Do the top and bottom caps, if necessary
-			if (path_open)
-			{
-				for (s = 0; s < size_s - 2; s++)
-				{
-					index[count++] = s+1;
-					index[count++] = s;
-					index[count++] = size_s - 1;
-				}
-
-				// We've got a top cap
-				S32 offset = (size_t - 1)*size_s;
-				for (s = 0; s < size_s - 2; s++)
-				{
-					// Inverted ordering from bottom cap.
-					index[count++] = offset + size_s - 1;
-					index[count++] = offset + s;
-					index[count++] = offset + s + 1;
-				}
-			}
-		}
-	}
-	else if (hollow)
-	{
-		// Closed hollow
-		// Outer face
-		
-		for (t = 0; t < size_t - 1; t++)
-		{
-			for (s = 0; s < size_s_out - 1; s++)
-			{
-				i  = s + t*size_s;
-
-				index[count++]  = i;				// x,y
-				index[count++]  = i + 1;			// x+1,y
-				index[count++]  = i + size_s;		// x,y+1
-
-				index[count++]  = i + size_s;		// x,y+1
-				index[count++]  = i + 1;			// x+1,y
-				index[count++]  = i + 1 + size_s;	// x+1,y+1
-			}
-		}
-
-		// Inner face
-		// Invert facing from outer face
-		for (t = 0; t < size_t - 1; t++)
-		{
-			for (s = size_s_out; s < size_s - 1; s++)
-			{
-				i  = s + t*size_s;
-
-				index[count++]  = i;				// x,y
-				index[count++]  = i + 1;			// x+1,y
-				index[count++]  = i + size_s;		// x,y+1
-
-				index[count++]  = i + size_s;		// x,y+1
-				index[count++]  = i + 1;			// x+1,y
-				index[count++]  = i + 1 + size_s;	// x+1,y+1
-			}
-		}
-
-		// Do the top and bottom caps, if necessary
-		if (path_open)
-		{
-			// Top cap
-			S32 pt1 = 0;
-			S32 pt2 = size_s-1;
-			S32 i   = (size_t - 1)*size_s;
-
-			while (pt2 - pt1 > 1)
-			{
-				// Use the profile points instead of the mesh, since you want
-				// the un-transformed profile distances.
-				LLVector3 p1 = getProfile().mProfile[pt1];
-				LLVector3 p2 = getProfile().mProfile[pt2];
-				LLVector3 pa = getProfile().mProfile[pt1+1];
-				LLVector3 pb = getProfile().mProfile[pt2-1];
-
-				p1.mV[VZ] = 0.f;
-				p2.mV[VZ] = 0.f;
-				pa.mV[VZ] = 0.f;
-				pb.mV[VZ] = 0.f;
-
-				// Use area of triangle to determine backfacing
-				F32 area_1a2, area_1ba, area_21b, area_2ab;
-				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
-							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
-							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
-
-				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
-							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
-
-				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
-							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
-							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				BOOL use_tri1a2 = TRUE;
-				BOOL tri_1a2 = TRUE;
-				BOOL tri_21b = TRUE;
-
-				if (area_1a2 < 0)
-				{
-					tri_1a2 = FALSE;
-				}
-				if (area_2ab < 0)
-				{
-					// Can't use, because it contains point b
-					tri_1a2 = FALSE;
-				}
-				if (area_21b < 0)
-				{
-					tri_21b = FALSE;
-				}
-				if (area_1ba < 0)
-				{
-					// Can't use, because it contains point b
-					tri_21b = FALSE;
-				}
-
-				if (!tri_1a2)
-				{
-					use_tri1a2 = FALSE;
-				}
-				else if (!tri_21b)
-				{
-					use_tri1a2 = TRUE;
-				}
-				else
-				{
-					LLVector3 d1 = p1 - pa;
-					LLVector3 d2 = p2 - pb;
-
-					if (d1.magVecSquared() < d2.magVecSquared())
-					{
-						use_tri1a2 = TRUE;
-					}
-					else
-					{
-						use_tri1a2 = FALSE;
-					}
-				}
-
-				if (use_tri1a2)
-				{
-					index[count++] = pt1 + i;
-					index[count++] = pt1 + 1 + i;
-					index[count++] = pt2 + i;
-					pt1++;
-				}
-				else
-				{
-					index[count++] = pt1 + i;
-					index[count++] = pt2 - 1 + i;
-					index[count++] = pt2 + i;
-					pt2--;
-				}
-			}
-
-			// Bottom cap
-			pt1          = 0;
-			pt2          = size_s-1;
-			while (pt2 - pt1 > 1)
-			{
-				// Use the profile points instead of the mesh, since you want
-				// the un-transformed profile distances.
-				LLVector3 p1 = getProfile().mProfile[pt1];
-				LLVector3 p2 = getProfile().mProfile[pt2];
-				LLVector3 pa = getProfile().mProfile[pt1+1];
-				LLVector3 pb = getProfile().mProfile[pt2-1];
-
-				p1.mV[VZ] = 0.f;
-				p2.mV[VZ] = 0.f;
-				pa.mV[VZ] = 0.f;
-				pb.mV[VZ] = 0.f;
-
-				// Use area of triangle to determine backfacing
-				F32 area_1a2, area_1ba, area_21b, area_2ab;
-				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
-							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
-							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
-
-				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
-							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
-
-				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
-							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
-							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				BOOL use_tri1a2 = TRUE;
-				BOOL tri_1a2 = TRUE;
-				BOOL tri_21b = TRUE;
-
-				if (area_1a2 < 0)
-				{
-					tri_1a2 = FALSE;
-				}
-				if (area_2ab < 0)
-				{
-					// Can't use, because it contains point b
-					tri_1a2 = FALSE;
-				}
-				if (area_21b < 0)
-				{
-					tri_21b = FALSE;
-				}
-				if (area_1ba < 0)
-				{
-					// Can't use, because it contains point b
-					tri_21b = FALSE;
-				}
-
-				if (!tri_1a2)
-				{
-					use_tri1a2 = FALSE;
-				}
-				else if (!tri_21b)
-				{
-					use_tri1a2 = TRUE;
-				}
-				else
-				{
-					LLVector3 d1 = p1 - pa;
-					LLVector3 d2 = p2 - pb;
-
-					if (d1.magVecSquared() < d2.magVecSquared())
-					{
-						use_tri1a2 = TRUE;
-					}
-					else
-					{
-						use_tri1a2 = FALSE;
-					}
-				}
-
-				if (use_tri1a2)
-				{
-					index[count++] = pt1;
-					index[count++] = pt2;
-					index[count++] = pt1 + 1;
-					pt1++;
-				}
-				else
-				{
-					index[count++] = pt1;
-					index[count++] = pt2;
-					index[count++] = pt2 - 1;
-					pt2--;
-				}
-			}
-		}		
-	}
-	else
-	{
-		// Closed solid.  Easy case.
-		for (t = 0; t < size_t - 1; t++)
-		{
-			for (s = 0; s < size_s - 1; s++)
-			{
-				// Should wrap properly, but for now...
-				i  = s + t*size_s;
-
-				index[count++]  = i;				// x,y
-				index[count++]  = i + 1;			// x+1,y
-				index[count++]  = i + size_s;		// x,y+1
-
-				index[count++]  = i + size_s;		// x,y+1
-				index[count++]  = i + 1;			// x+1,y
-				index[count++]  = i + size_s + 1;	// x+1,y+1
-			}
-		}
-
-		// Do the top and bottom caps, if necessary
-		if (path_open)
-		{
-			// bottom cap
-			for (s = 1; s < size_s - 2; s++)
-			{
-				index[count++] = s+1;
-				index[count++] = s;
-				index[count++] = 0;
-			}
-
-			// top cap
-			S32 offset = (size_t - 1)*size_s;
-			for (s = 1; s < size_s - 2; s++)
-			{
-				// Inverted ordering from bottom cap.
-				index[count++] = offset;
-				index[count++] = offset + s;
-				index[count++] = offset + s + 1;
-			}
-		}
-	}
-
-#ifdef LL_DEBUG
-	// assert that we computed the correct number of indices
-	if (count != expected_num_triangle_indices )
-	{
-		llerrs << "bad index count prediciton:"
-			<< "  expected=" << expected_num_triangle_indices 
-			<< " actual=" << count << llendl;
-	}
-#endif
-
-#if 0
-	// verify that each index does not point beyond the size of the mesh
-	S32 num_vertices = mMesh.size();
-	for (i = 0; i < count; i+=3)
-	{
-		llinfos << index[i] << ":" << index[i+1] << ":" << index[i+2] << llendl;
-		llassert(index[i] < num_vertices);
-		llassert(index[i+1] < num_vertices);
-		llassert(index[i+2] < num_vertices);
-	}
-#endif
-
-	num_indices = count;
-	return index;
-}
-
-S32 LLVolume::getNumTriangleIndices() const
-{
-	BOOL profile_open = getProfile().isOpen();
-	BOOL hollow = (mParams.getProfileParams().getHollow() > 0);
-	BOOL path_open = getPath().isOpen();
-
-	S32 size_s, size_s_out, size_t;
-	size_s = getProfile().getTotal();
-	size_s_out = getProfile().getTotalOut();
-	size_t = getPath().mPath.size();
-
-	S32 count = 0;
-	if (profile_open)		/* Flawfinder: ignore */
-	{
-		if (hollow)
-		{
-			// Open hollow -- much like the closed solid, except we 
-			// we need to stitch up the gap between s=0 and s=size_s-1
-			count = (size_t - 1) * (((size_s -1) * 6) + 6);
-		}
-		else
-		{
-			count = (size_t - 1) * (((size_s -1) * 6) + 6); 
-		}
-	}
-	else if (hollow)
-	{
-		// Closed hollow
-		// Outer face
-		count = (size_t - 1) * (size_s_out - 1) * 6;
-
-		// Inner face
-		count += (size_t - 1) * ((size_s - 1) - size_s_out) * 6;
-	}
-	else
-	{
-		// Closed solid.  Easy case.
-		count = (size_t - 1) * (size_s - 1) * 6;
-	}
-
-	if (path_open)
-	{
-		S32 cap_triangle_count = size_s - 3;
-		if ( profile_open
-			|| hollow )
-		{
-			cap_triangle_count = size_s - 2;
-		}
-		if ( cap_triangle_count > 0 )
-		{
-			// top and bottom caps
-			count += cap_triangle_count * 2 * 3;
-		}
-	}
-	return count;
-}
-
-//-----------------------------------------------------------------------------
-// generateSilhouetteVertices()
-//-----------------------------------------------------------------------------
-void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
-										  std::vector<LLVector3> &normals,
-										  std::vector<S32> &segments,
-										  const LLVector3& obj_cam_vec,
-										  const LLMatrix4& mat,
-										  const LLMatrix3& norm_mat,
-										  S32 face_mask)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	vertices.clear();
-	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)) {
-	
-		}
-		else {
-
-			//==============================================
-			//DEBUG draw edge map instead of silhouette edge
-			//==============================================
-
-#if DEBUG_SILHOUETTE_EDGE_MAP
-
-			//for each triangle
-			U32 count = face.mIndices.size();
-			for (U32 j = 0; j < count/3; j++) {
-				//get vertices
-				S32 v1 = face.mIndices[j*3+0];
-				S32 v2 = face.mIndices[j*3+1];
-				S32 v3 = face.mIndices[j*3+2];
-
-				//get current face center
-				LLVector3 cCenter = (face.mVertices[v1].mPosition + 
-									face.mVertices[v2].mPosition + 
-									face.mVertices[v3].mPosition) / 3.0f;
-
-				//for each edge
-				for (S32 k = 0; k < 3; k++) {
-                    S32 nIndex = face.mEdge[j*3+k];
-					if (nIndex <= -1) {
-						continue;
-					}
-
-					if (nIndex >= (S32) count/3) {
-						continue;
-					}
-					//get neighbor vertices
-					v1 = face.mIndices[nIndex*3+0];
-					v2 = face.mIndices[nIndex*3+1];
-					v3 = face.mIndices[nIndex*3+2];
-
-					//get neighbor face center
-					LLVector3 nCenter = (face.mVertices[v1].mPosition + 
-									face.mVertices[v2].mPosition + 
-									face.mVertices[v3].mPosition) / 3.0f;
-
-					//draw line
-					vertices.push_back(cCenter);
-					vertices.push_back(nCenter);
-					normals.push_back(LLVector3(1,1,1));
-					normals.push_back(LLVector3(1,1,1));
-					segments.push_back(vertices.size());
-				}
-			}
-		
-			continue;
-
-			//==============================================
-			//DEBUG
-			//==============================================
-
-			//==============================================
-			//DEBUG draw normals instead of silhouette edge
-			//==============================================
-#elif DEBUG_SILHOUETTE_NORMALS
-
-			//for each vertex
-			for (U32 j = 0; j < face.mVertices.size(); j++) {
-				vertices.push_back(face.mVertices[j].mPosition);
-				vertices.push_back(face.mVertices[j].mPosition + face.mVertices[j].mNormal*0.1f);
-				normals.push_back(LLVector3(0,0,1));
-				normals.push_back(LLVector3(0,0,1));
-				segments.push_back(vertices.size());
-#if DEBUG_SILHOUETTE_BINORMALS
-				vertices.push_back(face.mVertices[j].mPosition);
-				vertices.push_back(face.mVertices[j].mPosition + face.mVertices[j].mBinormal*0.1f);
-				normals.push_back(LLVector3(0,0,1));
-				normals.push_back(LLVector3(0,0,1));
-				segments.push_back(vertices.size());
-#endif
-			}
-						
-			continue;
-#else
-			//==============================================
-			//DEBUG
-			//==============================================
-
-			static const U8 AWAY = 0x01,
-							TOWARDS = 0x02;
-
-			//for each triangle
-			std::vector<U8> fFacing;
-			vector_append(fFacing, face.mIndices.size()/3);
-			for (U32 j = 0; j < face.mIndices.size()/3; j++) 
-			{
-				//approximate normal
-				S32 v1 = face.mIndices[j*3+0];
-				S32 v2 = face.mIndices[j*3+1];
-				S32 v3 = face.mIndices[j*3+2];
-
-				LLVector3 norm = (face.mVertices[v1].mPosition - face.mVertices[v2].mPosition) % 
-					(face.mVertices[v2].mPosition - face.mVertices[v3].mPosition);
-				
-				if (norm.magVecSquared() < 0.00000001f) 
-				{
-					fFacing[j] = AWAY | TOWARDS;
-				}
-				else 
-				{
-					//get view vector
-					LLVector3 view = (obj_cam_vec-face.mVertices[v1].mPosition);
-					bool away = view * norm > 0.0f; 
-					if (away) 
-					{
-						fFacing[j] = AWAY;
-					}
-					else 
-					{
-						fFacing[j] = TOWARDS;
-					}
-				}
-			}
-			
-			//for each triangle
-			for (U32 j = 0; j < face.mIndices.size()/3; j++) 
-			{
-				if (fFacing[j] == (AWAY | TOWARDS)) 
-				{ //this is a degenerate triangle
-					//take neighbor facing (degenerate faces get facing of one of their neighbors)
-					// *FIX IF NEEDED:  this does not deal with neighboring degenerate faces
-					for (S32 k = 0; k < 3; k++) 
-					{
-						S32 index = face.mEdge[j*3+k];
-						if (index != -1) 
-						{
-							fFacing[j] = fFacing[index];
-							break;
-						}
-					}
-					continue; //skip degenerate face
-				}
-
-				//for each edge
-				for (S32 k = 0; k < 3; k++) {
-					S32 index = face.mEdge[j*3+k];
-					if (index != -1 && fFacing[index] == (AWAY | TOWARDS)) {
-						//our neighbor is degenerate, make him face our direction
-						fFacing[face.mEdge[j*3+k]] = fFacing[j];
-						continue;
-					}
-
-					if (index == -1 ||		//edge has no neighbor, MUST be a silhouette edge
-						(fFacing[index] & fFacing[j]) == 0) { 	//we found a silhouette edge
-
-						S32 v1 = face.mIndices[j*3+k];
-						S32 v2 = face.mIndices[j*3+((k+1)%3)];
-						
-						vertices.push_back(face.mVertices[v1].mPosition*mat);
-						LLVector3 norm1 = face.mVertices[v1].mNormal * norm_mat;
-						norm1.normVec();
-						normals.push_back(norm1);
-
-						vertices.push_back(face.mVertices[v2].mPosition*mat);
-						LLVector3 norm2 = face.mVertices[v2].mNormal * norm_mat;
-						norm2.normVec();
-						normals.push_back(norm2);
-
-						segments.push_back(vertices.size());
-					}
-				}		
-			}
-#endif
-		}
-	}
-}
-
-S32 LLVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, 
-								   S32 face,
-								   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
-{
-	S32 hit_face = -1;
-	
-	S32 start_face;
-	S32 end_face;
-	
-	if (face == -1) // ALL_SIDES
-	{
-		start_face = 0;
-		end_face = getNumVolumeFaces() - 1;
-	}
-	else
-	{
-		start_face = face;
-		end_face = face;
-	}
-
-	LLVector3 dir = end - start;
-
-	F32 closest_t = 2.f; // must be larger than 1
-	
-	for (S32 i = start_face; i <= end_face; i++)
-	{
-		const LLVolumeFace &face = getVolumeFace((U32)i);
-
-		LLVector3 box_center = (face.mExtents[0] + face.mExtents[1]) / 2.f;
-		LLVector3 box_size   = face.mExtents[1] - face.mExtents[0];
-
-        if (LLLineSegmentBoxIntersect(start, end, box_center, box_size))
-		{
-			if (bi_normal != NULL) // if the caller wants binormals, we may need to generate them
-			{
-				genBinormals(i);
-			}
-			
-			for (U32 tri = 0; tri < face.mIndices.size()/3; tri++) 
-			{
-				S32 index1 = face.mIndices[tri*3+0];
-				S32 index2 = face.mIndices[tri*3+1];
-				S32 index3 = face.mIndices[tri*3+2];
-
-				F32 a, b, t;
-			
-				if (LLTriangleRayIntersect(face.mVertices[index1].mPosition,
-										   face.mVertices[index2].mPosition,
-										   face.mVertices[index3].mPosition,
-										   start, dir, &a, &b, &t, FALSE))
-				{
-					if ((t >= 0.f) &&      // if hit is after start
-						(t <= 1.f) &&      // and before end
-						(t < closest_t))   // and this hit is closer
-		{
-						closest_t = t;
-						hit_face = i;
-
-						if (intersection != NULL)
-						{
-							*intersection = start + dir * closest_t;
-						}
-			
-						if (tex_coord != NULL)
-			{
-							*tex_coord = ((1.f - a - b)  * face.mVertices[index1].mTexCoord +
-										  a              * face.mVertices[index2].mTexCoord +
-										  b              * face.mVertices[index3].mTexCoord);
-
-						}
-
-						if (normal != NULL)
-				{
-							*normal    = ((1.f - a - b)  * face.mVertices[index1].mNormal + 
-										  a              * face.mVertices[index2].mNormal +
-										  b              * face.mVertices[index3].mNormal);
-						}
-
-						if (bi_normal != NULL)
-					{
-							*bi_normal = ((1.f - a - b)  * face.mVertices[index1].mBinormal + 
-										  a              * face.mVertices[index2].mBinormal +
-										  b              * face.mVertices[index3].mBinormal);
-						}
-
-					}
-				}
-			}
-		}		
-	}
-	
-	
-	return hit_face;
-}
-
-class LLVertexIndexPair
-{
-public:
-	LLVertexIndexPair(const LLVector3 &vertex, const S32 index);
-
-	LLVector3 mVertex;
-	S32	mIndex;
-};
-
-LLVertexIndexPair::LLVertexIndexPair(const LLVector3 &vertex, const S32 index)
-{
-	mVertex = vertex;
-	mIndex = index;
-}
-
-const F32 VERTEX_SLOP = 0.00001f;
-const F32 VERTEX_SLOP_SQRD = VERTEX_SLOP * VERTEX_SLOP;
-
-struct lessVertex
-{
-	bool operator()(const LLVertexIndexPair *a, const LLVertexIndexPair *b)
-	{
-		const F32 slop = VERTEX_SLOP;
-
-		if (a->mVertex.mV[0] + slop < b->mVertex.mV[0])
-		{
-			return TRUE;
-		}
-		else if (a->mVertex.mV[0] - slop > b->mVertex.mV[0])
-		{
-			return FALSE;
-		}
-		
-		if (a->mVertex.mV[1] + slop < b->mVertex.mV[1])
-		{
-			return TRUE;
-		}
-		else if (a->mVertex.mV[1] - slop > b->mVertex.mV[1])
-		{
-			return FALSE;
-		}
-		
-		if (a->mVertex.mV[2] + slop < b->mVertex.mV[2])
-		{
-			return TRUE;
-		}
-		else if (a->mVertex.mV[2] - slop > b->mVertex.mV[2])
-		{
-			return FALSE;
-		}
-		
-		return FALSE;
-	}
-};
-
-struct lessTriangle
-{
-	bool operator()(const S32 *a, const S32 *b)
-	{
-		if (*a < *b)
-		{
-			return TRUE;
-		}
-		else if (*a > *b)
-		{
-			return FALSE;
-		}
-
-		if (*(a+1) < *(b+1))
-		{
-			return TRUE;
-		}
-		else if (*(a+1) > *(b+1))
-		{
-			return FALSE;
-		}
-
-		if (*(a+2) < *(b+2))
-		{
-			return TRUE;
-		}
-		else if (*(a+2) > *(b+2))
-		{
-			return FALSE;
-		}
-
-		return FALSE;
-	}
-};
-
-BOOL equalTriangle(const S32 *a, const S32 *b)
-{
-	if ((*a == *b) && (*(a+1) == *(b+1)) && (*(a+2) == *(b+2)))
-	{
-		return TRUE;
-	}
-	return FALSE;
-}
-
-BOOL LLVolume::cleanupTriangleData( const S32 num_input_vertices,
-									const std::vector<Point>& input_vertices,
-									const S32 num_input_triangles,
-									S32 *input_triangles,
-									S32 &num_output_vertices,
-									LLVector3 **output_vertices,
-									S32 &num_output_triangles,
-									S32 **output_triangles)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	/* Testing: avoid any cleanup
-	static BOOL skip_cleanup = TRUE;
-	if ( skip_cleanup )
-	{
-		num_output_vertices = num_input_vertices;
-		num_output_triangles = num_input_triangles;
-
-		*output_vertices = new LLVector3[num_input_vertices];
-		for (S32 index = 0; index < num_input_vertices; index++)
-		{
-			(*output_vertices)[index] = input_vertices[index].mPos;
-		}
-
-		*output_triangles = new S32[num_input_triangles*3];
-		memcpy(*output_triangles, input_triangles, 3*num_input_triangles*sizeof(S32));		// Flawfinder: ignore
-		return TRUE;
-	}
-	*/
-
-	// Here's how we do this:
-	// Create a structure which contains the original vertex index and the
-	// LLVector3 data.
-	// "Sort" the data by the vectors
-	// Create an array the size of the old vertex list, with a mapping of
-	// old indices to new indices.
-	// Go through triangles, shift so the lowest index is first
-	// Sort triangles by first index
-	// Remove duplicate triangles
-	// Allocate and pack new triangle data.
-
-	//LLTimer cleanupTimer;
-	//llinfos << "In vertices: " << num_input_vertices << llendl;
-	//llinfos << "In triangles: " << num_input_triangles << llendl;
-
-	S32 i;
-	typedef std::multiset<LLVertexIndexPair*, lessVertex> vertex_set_t;
-	vertex_set_t vertex_list;
-
-	LLVertexIndexPair *pairp = NULL;
-	for (i = 0; i < num_input_vertices; i++)
-	{
-		LLVertexIndexPair *new_pairp = new LLVertexIndexPair(input_vertices[i].mPos, i);
-		vertex_list.insert(new_pairp);
-	}
-
-	// Generate the vertex mapping and the list of vertices without
-	// duplicates.  This will crash if there are no vertices.
-	llassert(num_input_vertices > 0); // check for no vertices!
-	S32 *vertex_mapping = new S32[num_input_vertices];
-	LLVector3 *new_vertices = new LLVector3[num_input_vertices];
-	LLVertexIndexPair *prev_pairp = NULL;
-
-	S32 new_num_vertices;
-
-	new_num_vertices = 0;
-	for (vertex_set_t::iterator iter = vertex_list.begin(),
-			 end = vertex_list.end();
-		 iter != end; iter++)
-	{
-		pairp = *iter;
-		if (!prev_pairp || ((pairp->mVertex - prev_pairp->mVertex).magVecSquared() >= VERTEX_SLOP_SQRD))	
-		{
-			new_vertices[new_num_vertices] = pairp->mVertex;
-			//llinfos << "Added vertex " << new_num_vertices << " : " << pairp->mVertex << llendl;
-			new_num_vertices++;
-			// Update the previous
-			prev_pairp = pairp;
-		}
-		else
-		{
-			//llinfos << "Removed duplicate vertex " << pairp->mVertex << ", distance magVecSquared() is " << (pairp->mVertex - prev_pairp->mVertex).magVecSquared() << llendl;
-		}
-		vertex_mapping[pairp->mIndex] = new_num_vertices - 1;
-	}
-
-	// Iterate through triangles and remove degenerates, re-ordering vertices
-	// along the way.
-	S32 *new_triangles = new S32[num_input_triangles * 3];
-	S32 new_num_triangles = 0;
-
-	for (i = 0; i < num_input_triangles; i++)
-	{
-		S32 v1 = i*3;
-		S32 v2 = v1 + 1;
-		S32 v3 = v1 + 2;
-
-		//llinfos << "Checking triangle " << input_triangles[v1] << ":" << input_triangles[v2] << ":" << input_triangles[v3] << llendl;
-		input_triangles[v1] = vertex_mapping[input_triangles[v1]];
-		input_triangles[v2] = vertex_mapping[input_triangles[v2]];
-		input_triangles[v3] = vertex_mapping[input_triangles[v3]];
-
-		if ((input_triangles[v1] == input_triangles[v2])
-			|| (input_triangles[v1] == input_triangles[v3])
-			|| (input_triangles[v2] == input_triangles[v3]))
-		{
-			//llinfos << "Removing degenerate triangle " << input_triangles[v1] << ":" << input_triangles[v2] << ":" << input_triangles[v3] << llendl;
-			// Degenerate triangle, skip
-			continue;
-		}
-
-		if (input_triangles[v1] < input_triangles[v2])
-		{
-			if (input_triangles[v1] < input_triangles[v3])
-			{
-				// (0 < 1) && (0 < 2)
-				new_triangles[new_num_triangles*3] = input_triangles[v1];
-				new_triangles[new_num_triangles*3+1] = input_triangles[v2];
-				new_triangles[new_num_triangles*3+2] = input_triangles[v3];
-			}
-			else
-			{
-				// (0 < 1) && (2 < 0)
-				new_triangles[new_num_triangles*3] = input_triangles[v3];
-				new_triangles[new_num_triangles*3+1] = input_triangles[v1];
-				new_triangles[new_num_triangles*3+2] = input_triangles[v2];
-			}
-		}
-		else if (input_triangles[v2] < input_triangles[v3])
-		{
-			// (1 < 0) && (1 < 2)
-			new_triangles[new_num_triangles*3] = input_triangles[v2];
-			new_triangles[new_num_triangles*3+1] = input_triangles[v3];
-			new_triangles[new_num_triangles*3+2] = input_triangles[v1];
-		}
-		else
-		{
-			// (1 < 0) && (2 < 1)
-			new_triangles[new_num_triangles*3] = input_triangles[v3];
-			new_triangles[new_num_triangles*3+1] = input_triangles[v1];
-			new_triangles[new_num_triangles*3+2] = input_triangles[v2];
-		}
-		new_num_triangles++;
-	}
-
-	if (new_num_triangles == 0)
-	{
-		llwarns << "Created volume object with 0 faces." << llendl;
-		delete[] new_triangles;
-		delete[] vertex_mapping;
-		delete[] new_vertices;
-		return FALSE;
-	}
-
-	typedef std::set<S32*, lessTriangle> triangle_set_t;
-	triangle_set_t triangle_list;
-
-	for (i = 0; i < new_num_triangles; i++)
-	{
-		triangle_list.insert(&new_triangles[i*3]);
-	}
-
-	// Sort through the triangle list, and delete duplicates
-
-	S32 *prevp = NULL;
-	S32 *curp = NULL;
-
-	S32 *sorted_tris = new S32[new_num_triangles*3];
-	S32 cur_tri = 0;
-	for (triangle_set_t::iterator iter = triangle_list.begin(),
-			 end = triangle_list.end();
-		 iter != end; iter++)
-	{
-		curp = *iter;
-		if (!prevp || !equalTriangle(prevp, curp))
-		{
-			//llinfos << "Added triangle " << *curp << ":" << *(curp+1) << ":" << *(curp+2) << llendl;
-			sorted_tris[cur_tri*3] = *curp;
-			sorted_tris[cur_tri*3+1] = *(curp+1);
-			sorted_tris[cur_tri*3+2] = *(curp+2);
-			cur_tri++;
-			prevp = curp;
-		}
-		else
-		{
-			//llinfos << "Skipped triangle " << *curp << ":" << *(curp+1) << ":" << *(curp+2) << llendl;
-		}
-	}
-
-	*output_vertices = new LLVector3[new_num_vertices];
-	num_output_vertices = new_num_vertices;
-	for (i = 0; i < new_num_vertices; i++)
-	{
-		(*output_vertices)[i] = new_vertices[i];
-	}
-
-	*output_triangles = new S32[cur_tri*3];
-	num_output_triangles = cur_tri;
-	memcpy(*output_triangles, sorted_tris, 3*cur_tri*sizeof(S32));		/* Flawfinder: ignore */
-
-	/*
-	llinfos << "Out vertices: " << num_output_vertices << llendl;
-	llinfos << "Out triangles: " << num_output_triangles << llendl;
-	for (i = 0; i < num_output_vertices; i++)
-	{
-		llinfos << i << ":" << (*output_vertices)[i] << llendl;
-	}
-	for (i = 0; i < num_output_triangles; i++)
-	{
-		llinfos << i << ":" << (*output_triangles)[i*3] << ":" << (*output_triangles)[i*3+1] << ":" << (*output_triangles)[i*3+2] << llendl;
-	}
-	*/
-
-	//llinfos << "Out vertices: " << num_output_vertices << llendl;
-	//llinfos << "Out triangles: " << num_output_triangles << llendl;
-	delete[] vertex_mapping;
-	vertex_mapping = NULL;
-	delete[] new_vertices;
-	new_vertices = NULL;
-	delete[] new_triangles;
-	new_triangles = NULL;
-	delete[] sorted_tris;
-	sorted_tris = NULL;
-	triangle_list.clear();
-	std::for_each(vertex_list.begin(), vertex_list.end(), DeletePointer());
-	vertex_list.clear();
-	
-	return TRUE;
-}
-
-
-BOOL LLVolumeParams::importFile(LLFILE *fp)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	//llinfos << "importing volume" << llendl;
-	const S32 BUFSIZE = 16384;
-	char buffer[BUFSIZE];	/* Flawfinder: ignore */
-	// *NOTE: changing the size or type of this buffer will require
-	// changing the sscanf below.
-	char keyword[256];	/* Flawfinder: ignore */
-	keyword[0] = 0;
-
-	while (!feof(fp))
-	{
-		if (fgets(buffer, BUFSIZE, fp) == NULL)
-		{
-			buffer[0] = '\0';
-		}
-		
-		sscanf(buffer, " %255s", keyword);	/* Flawfinder: ignore */
-		if (!strcmp("{", keyword))
-		{
-			continue;
-		}
-		if (!strcmp("}",keyword))
-		{
-			break;
-		}
-		else if (!strcmp("profile", keyword))
-		{
-			mProfileParams.importFile(fp);
-		}
-		else if (!strcmp("path",keyword))
-		{
-			mPathParams.importFile(fp);
-		}
-		else
-		{
-			llwarns << "unknown keyword " << keyword << " in volume import" << llendl;
-		}
-	}
-
-	return TRUE;
-}
-
-BOOL LLVolumeParams::exportFile(LLFILE *fp) const
-{
-	fprintf(fp,"\tshape 0\n");
-	fprintf(fp,"\t{\n");
-	mPathParams.exportFile(fp);
-	mProfileParams.exportFile(fp);
-	fprintf(fp, "\t}\n");
-	return TRUE;
-}
-
-
-BOOL LLVolumeParams::importLegacyStream(std::istream& input_stream)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	//llinfos << "importing volume" << llendl;
-	const S32 BUFSIZE = 16384;
-	// *NOTE: changing the size or type of this buffer will require
-	// changing the sscanf below.
-	char buffer[BUFSIZE];		/* Flawfinder: ignore */
-	char keyword[256];		/* Flawfinder: ignore */
-	keyword[0] = 0;
-
-	while (input_stream.good())
-	{
-		input_stream.getline(buffer, BUFSIZE);
-		sscanf(buffer, " %255s", keyword);
-		if (!strcmp("{", keyword))
-		{
-			continue;
-		}
-		if (!strcmp("}",keyword))
-		{
-			break;
-		}
-		else if (!strcmp("profile", keyword))
-		{
-			mProfileParams.importLegacyStream(input_stream);
-		}
-		else if (!strcmp("path",keyword))
-		{
-			mPathParams.importLegacyStream(input_stream);
-		}
-		else
-		{
-			llwarns << "unknown keyword " << keyword << " in volume import" << llendl;
-		}
-	}
-
-	return TRUE;
-}
-
-BOOL LLVolumeParams::exportLegacyStream(std::ostream& output_stream) const
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	output_stream <<"\tshape 0\n";
-	output_stream <<"\t{\n";
-	mPathParams.exportLegacyStream(output_stream);
-	mProfileParams.exportLegacyStream(output_stream);
-	output_stream << "\t}\n";
-	return TRUE;
-}
-
-LLSD LLVolumeParams::asLLSD() const
-{
-	LLSD sd = LLSD();
-	sd["path"] = mPathParams;
-	sd["profile"] = mProfileParams;
-	return sd;
-}
-
-bool LLVolumeParams::fromLLSD(LLSD& sd)
-{
-	mPathParams.fromLLSD(sd["path"]);
-	mProfileParams.fromLLSD(sd["profile"]);
-	return true;
-}
-
-void LLVolumeParams::reduceS(F32 begin, F32 end)
-{
-	begin = llclampf(begin);
-	end = llclampf(end);
-	if (begin > end)
-	{
-		F32 temp = begin;
-		begin = end;
-		end = temp;
-	}
-	F32 a = mProfileParams.getBegin();
-	F32 b = mProfileParams.getEnd();
-	mProfileParams.setBegin(a + begin * (b - a));
-	mProfileParams.setEnd(a + end * (b - a));
-}
-
-void LLVolumeParams::reduceT(F32 begin, F32 end)
-{
-	begin = llclampf(begin);
-	end = llclampf(end);
-	if (begin > end)
-	{
-		F32 temp = begin;
-		begin = end;
-		end = temp;
-	}
-	F32 a = mPathParams.getBegin();
-	F32 b = mPathParams.getEnd();
-	mPathParams.setBegin(a + begin * (b - a));
-	mPathParams.setEnd(a + end * (b - a));
-}
-
-const F32 MIN_CONCAVE_PROFILE_WEDGE = 0.125f;	// 1/8 unity
-const F32 MIN_CONCAVE_PATH_WEDGE = 0.111111f;	// 1/9 unity
-
-// returns TRUE if the shape can be approximated with a convex shape 
-// for collison purposes
-BOOL LLVolumeParams::isConvex() const
-{
-	F32 path_length = mPathParams.getEnd() - mPathParams.getBegin();
-	F32 hollow = mProfileParams.getHollow();
-	 
-	U8 path_type = mPathParams.getCurveType();
-	if ( path_length > MIN_CONCAVE_PATH_WEDGE
-		&& ( mPathParams.getTwist() != mPathParams.getTwistBegin()
-		     || (hollow > 0.f 
-				 && LL_PCODE_PATH_LINE != path_type) ) )
-	{
-		// twist along a "not too short" path is concave
-		return FALSE;
-	}
-
-	F32 profile_length = mProfileParams.getEnd() - mProfileParams.getBegin();
-	BOOL same_hole = hollow == 0.f 
-					 || (mProfileParams.getCurveType() & LL_PCODE_HOLE_MASK) == LL_PCODE_HOLE_SAME;
-
-	F32 min_profile_wedge = MIN_CONCAVE_PROFILE_WEDGE;
-	U8 profile_type = mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;
-	if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type )
-	{
-		// it is a sphere and spheres get twice the minimum profile wedge
-		min_profile_wedge = 2.f * MIN_CONCAVE_PROFILE_WEDGE;
-	}
-
-	BOOL convex_profile = ( ( profile_length == 1.f
-						     || profile_length <= 0.5f )
-						   && hollow == 0.f )						// trivially convex
-						  || ( profile_length <= min_profile_wedge
-							  && same_hole );						// effectvely convex (even when hollow)
-
-	if (!convex_profile)
-	{
-		// profile is concave
-		return FALSE;
-	}
-
-	if ( LL_PCODE_PATH_LINE == path_type )
-	{
-		// straight paths with convex profile
-		return TRUE;
-	}
-
-	BOOL concave_path = (path_length < 1.0f) && (path_length > 0.5f);
-	if (concave_path)
-	{
-		return FALSE;
-	}
-
-	// we're left with spheres, toroids and tubes
-	if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type )
-	{
-		// at this stage all spheres must be convex
-		return TRUE;
-	}
-
-	// it's a toroid or tube		
-	if ( path_length <= MIN_CONCAVE_PATH_WEDGE )
-	{
-		// effectively convex
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-// debug
-void LLVolumeParams::setCube()
-{
-	mProfileParams.setCurveType(LL_PCODE_PROFILE_SQUARE);
-	mProfileParams.setBegin(0.f);
-	mProfileParams.setEnd(1.f);
-	mProfileParams.setHollow(0.f);
-
-	mPathParams.setBegin(0.f);
-	mPathParams.setEnd(1.f);
-	mPathParams.setScale(1.f, 1.f);
-	mPathParams.setShear(0.f, 0.f);
-	mPathParams.setCurveType(LL_PCODE_PATH_LINE);
-	mPathParams.setTwistBegin(0.f);
-	mPathParams.setTwistEnd(0.f);
-	mPathParams.setRadiusOffset(0.f);
-	mPathParams.setTaper(0.f, 0.f);
-	mPathParams.setRevolutions(0.f);
-	mPathParams.setSkew(0.f);
-}
-
-LLFaceID LLVolume::generateFaceMask()
-{
-	LLFaceID new_mask = 0x0000;
-
-	switch(mParams.getProfileParams().getCurveType() & LL_PCODE_PROFILE_MASK)
-	{
-	case LL_PCODE_PROFILE_CIRCLE:
-	case LL_PCODE_PROFILE_CIRCLE_HALF:
-		new_mask |= LL_FACE_OUTER_SIDE_0;
-		break;
-	case LL_PCODE_PROFILE_SQUARE:
-		{
-			for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 4.f); side < llceil(mParams.getProfileParams().getEnd() * 4.f); side++)
-			{
-				new_mask |= LL_FACE_OUTER_SIDE_0 << side;
-			}
-		}
-		break;
-	case LL_PCODE_PROFILE_ISOTRI:
-	case LL_PCODE_PROFILE_EQUALTRI:
-	case LL_PCODE_PROFILE_RIGHTTRI:
-		{
-			for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 3.f); side < llceil(mParams.getProfileParams().getEnd() * 3.f); side++)
-			{
-				new_mask |= LL_FACE_OUTER_SIDE_0 << side;
-			}
-		}
-		break;
-	default:
-		llerrs << "Unknown profile!" << llendl;
-		break;
-	}
-
-	// handle hollow objects
-	if (mParams.getProfileParams().getHollow() > 0)
-	{
-		new_mask |= LL_FACE_INNER_SIDE;
-	}
-
-	// handle open profile curves
-	if (mProfilep->isOpen())
-	{
-		new_mask |= LL_FACE_PROFILE_BEGIN | LL_FACE_PROFILE_END;
-	}
-
-	// handle open path curves
-	if (mPathp->isOpen())
-	{
-		new_mask |= LL_FACE_PATH_BEGIN | LL_FACE_PATH_END;
-	}
-
-	return new_mask;
-}
-
-BOOL LLVolume::isFaceMaskValid(LLFaceID face_mask)
-{
-	LLFaceID test_mask = 0;
-	for(S32 i = 0; i < getNumFaces(); i++)
-	{
-		test_mask |= mProfilep->mFaces[i].mFaceID;
-	}
-
-	return test_mask == face_mask;
-}
-
-BOOL LLVolume::isConvex() const
-{
-	// mParams.isConvex() may return FALSE even though the final
-	// geometry is actually convex due to LOD approximations.
-	// TODO -- provide LLPath and LLProfile with isConvex() methods
-	// that correctly determine convexity. -- Leviathan
-	return mParams.isConvex();
-}
-
-
-std::ostream& operator<<(std::ostream &s, const LLProfileParams &profile_params)
-{
-	s << "{type=" << (U32) profile_params.mCurveType;
-	s << ", begin=" << profile_params.mBegin;
-	s << ", end=" << profile_params.mEnd;
-	s << ", hollow=" << profile_params.mHollow;
-	s << "}";
-	return s;
-}
-
-
-std::ostream& operator<<(std::ostream &s, const LLPathParams &path_params)
-{
-	s << "{type=" << (U32) path_params.mCurveType;
-	s << ", begin=" << path_params.mBegin;
-	s << ", end=" << path_params.mEnd;
-	s << ", twist=" << path_params.mTwistEnd;
-	s << ", scale=" << path_params.mScale;
-	s << ", shear=" << path_params.mShear;
-	s << ", twist_begin=" << path_params.mTwistBegin;
-	s << ", radius_offset=" << path_params.mRadiusOffset;
-	s << ", taper=" << path_params.mTaper;
-	s << ", revolutions=" << path_params.mRevolutions;
-	s << ", skew=" << path_params.mSkew;
-	s << "}";
-	return s;
-}
-
-
-std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params)
-{
-	s << "{profileparams = " << volume_params.mProfileParams;
-	s << ", pathparams = " << volume_params.mPathParams;
-	s << "}";
-	return s;
-}
-
-
-std::ostream& operator<<(std::ostream &s, const LLProfile &profile)
-{
-	s << " {open=" << (U32) profile.mOpen;
-	s << ", dirty=" << profile.mDirty;
-	s << ", totalout=" << profile.mTotalOut;
-	s << ", total=" << profile.mTotal;
-	s << "}";
-	return s;
-}
-
-
-std::ostream& operator<<(std::ostream &s, const LLPath &path)
-{
-	s << "{open=" << (U32) path.mOpen;
-	s << ", dirty=" << path.mDirty;
-	s << ", step=" << path.mStep;
-	s << ", total=" << path.mTotal;
-	s << "}";
-	return s;
-}
-
-std::ostream& operator<<(std::ostream &s, const LLVolume &volume)
-{
-	s << "{params = " << volume.getParams();
-	s << ", path = " << *volume.mPathp;
-	s << ", profile = " << *volume.mProfilep;
-	s << "}";
-	return s;
-}
-
-
-std::ostream& operator<<(std::ostream &s, const LLVolume *volumep)
-{
-	s << "{params = " << volumep->getParams();
-	s << ", path = " << *(volumep->mPathp);
-	s << ", profile = " << *(volumep->mProfilep);
-	s << "}";
-	return s;
-}
-
-
-BOOL LLVolumeFace::create(LLVolume* volume, BOOL partial_build)
-{
-	BOOL ret = FALSE ;
-	if (mTypeMask & CAP_MASK)
-	{
-		ret = createCap(volume, partial_build);
-	}
-	else if ((mTypeMask & END_MASK) || (mTypeMask & SIDE_MASK))
-	{
-		ret = createSide(volume, partial_build);
-	}
-	else
-	{
-		llerrs << "Unknown/uninitialized face type!" << llendl;
-	}
-
-	//update the range of the texture coordinates
-	if(ret)
-	{
-		mTexCoordExtents[0].setVec(1.f, 1.f) ;
-		mTexCoordExtents[1].setVec(0.f, 0.f) ;
-
-		U32 end = mVertices.size() ;
-		for(U32 i = 0 ; i < end ; i++)
-		{
-			if(mTexCoordExtents[0].mV[0] > mVertices[i].mTexCoord.mV[0])
-			{
-				mTexCoordExtents[0].mV[0] = mVertices[i].mTexCoord.mV[0] ;
-			}
-			if(mTexCoordExtents[1].mV[0] < mVertices[i].mTexCoord.mV[0])
-			{
-				mTexCoordExtents[1].mV[0] = mVertices[i].mTexCoord.mV[0] ;
-			}
-
-			if(mTexCoordExtents[0].mV[1] > mVertices[i].mTexCoord.mV[1])
-			{
-				mTexCoordExtents[0].mV[1] = mVertices[i].mTexCoord.mV[1] ;
-			}
-			if(mTexCoordExtents[1].mV[1] < mVertices[i].mTexCoord.mV[1])
-			{
-				mTexCoordExtents[1].mV[1] = mVertices[i].mTexCoord.mV[1] ;
-			}			
-		}
-		mTexCoordExtents[0].mV[0] = llmax(0.f, mTexCoordExtents[0].mV[0]) ;
-		mTexCoordExtents[0].mV[1] = llmax(0.f, mTexCoordExtents[0].mV[1]) ;
-		mTexCoordExtents[1].mV[0] = llmin(1.f, mTexCoordExtents[1].mV[0]) ;
-		mTexCoordExtents[1].mV[1] = llmin(1.f, mTexCoordExtents[1].mV[1]) ;
-	}
-
-	return ret ;
-}
-
-void	LerpPlanarVertex(LLVolumeFace::VertexData& v0,
-				   LLVolumeFace::VertexData& v1,
-				   LLVolumeFace::VertexData& v2,
-				   LLVolumeFace::VertexData& vout,
-				   F32	coef01,
-				   F32	coef02)
-{
-	vout.mPosition = v0.mPosition + ((v1.mPosition-v0.mPosition)*coef01)+((v2.mPosition-v0.mPosition)*coef02);
-	vout.mTexCoord = v0.mTexCoord + ((v1.mTexCoord-v0.mTexCoord)*coef01)+((v2.mTexCoord-v0.mTexCoord)*coef02);
-	vout.mNormal = v0.mNormal;
-	vout.mBinormal = v0.mBinormal;
-}
-
-BOOL LLVolumeFace::createUnCutCubeCap(LLVolume* volume, BOOL partial_build)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	const std::vector<LLVolume::Point>& mesh = volume->getMesh();
-	const std::vector<LLVector3>& profile = volume->getProfile().mProfile;
-	S32 max_s = volume->getProfile().getTotal();
-	S32 max_t = volume->getPath().mPath.size();
-
-	// S32 i;
-	S32 num_vertices = 0, num_indices = 0;
-	S32	grid_size = (profile.size()-1)/4;
-	S32	quad_count = (grid_size * grid_size);
-
-	num_vertices = (grid_size+1)*(grid_size+1);
-	num_indices = quad_count * 4;
-
-	LLVector3& min = mExtents[0];
-	LLVector3& max = mExtents[1];
-
-	S32 offset = 0;
-	if (mTypeMask & TOP_MASK)
-		offset = (max_t-1) * max_s;
-	else
-		offset = mBeginS;
-
-	VertexData	corners[4];
-	VertexData baseVert;
-	for(int t = 0; t < 4; t++){
-		corners[t].mPosition = mesh[offset + (grid_size*t)].mPos;
-		corners[t].mTexCoord.mV[0] = profile[grid_size*t].mV[0]+0.5f;
-		corners[t].mTexCoord.mV[1] = 0.5f - profile[grid_size*t].mV[1];
-	}
-	baseVert.mNormal = 
-		((corners[1].mPosition-corners[0].mPosition) % 
-		(corners[2].mPosition-corners[1].mPosition));
-	baseVert.mNormal.normVec();
-	if(!(mTypeMask & TOP_MASK)){
-		baseVert.mNormal *= -1.0f;
-	}else{
-		//Swap the UVs on the U(X) axis for top face
-		LLVector2 swap;
-		swap = corners[0].mTexCoord;
-		corners[0].mTexCoord=corners[3].mTexCoord;
-		corners[3].mTexCoord=swap;
-		swap = corners[1].mTexCoord;
-		corners[1].mTexCoord=corners[2].mTexCoord;
-		corners[2].mTexCoord=swap;
-	}
-	baseVert.mBinormal = calc_binormal_from_triangle( 
-		corners[0].mPosition, corners[0].mTexCoord,
-		corners[1].mPosition, corners[1].mTexCoord,
-		corners[2].mPosition, corners[2].mTexCoord);
-	for(int t = 0; t < 4; t++){
-		corners[t].mBinormal = baseVert.mBinormal;
-		corners[t].mNormal = baseVert.mNormal;
-	}
-	mHasBinormals = TRUE;
-
-	if (partial_build)
-	{
-		mVertices.clear();
-	}
-
-	S32	vtop = mVertices.size();
-	for(int gx = 0;gx<grid_size+1;gx++){
-		for(int gy = 0;gy<grid_size+1;gy++){
-			VertexData newVert;
-			LerpPlanarVertex(
-				corners[0],
-				corners[1],
-				corners[3],
-				newVert,
-				(F32)gx/(F32)grid_size,
-				(F32)gy/(F32)grid_size);
-			mVertices.push_back(newVert);
-
-			if (gx == 0 && gy == 0)
-			{
-				min = max = newVert.mPosition;
-			}
-			else
-			{
-				update_min_max(min,max,newVert.mPosition);
-			}
-		}
-	}
-	
-	mCenter = (min + max) * 0.5f;
-
-	if (!partial_build)
-	{
-#if GEN_TRI_STRIP
-		mTriStrip.clear();
-#endif
-		S32 idxs[] = {0,1,(grid_size+1)+1,(grid_size+1)+1,(grid_size+1),0};
-		for(S32 gx = 0;gx<grid_size;gx++)
-		{
-			
-			for(S32 gy = 0;gy<grid_size;gy++)
-			{
-				if (mTypeMask & TOP_MASK)
-				{
-					for(S32 i=5;i>=0;i--)
-					{
-						mIndices.push_back(vtop+(gy*(grid_size+1))+gx+idxs[i]);
-					}
-					
-#if GEN_TRI_STRIP
-					if (gy == 0)
-					{
-						mTriStrip.push_back((gx+1)*(grid_size+1));
-						mTriStrip.push_back((gx+1)*(grid_size+1));
-						mTriStrip.push_back(gx*(grid_size+1));
-					}
-
-					mTriStrip.push_back(gy+1+(gx+1)*(grid_size+1));
-					mTriStrip.push_back(gy+1+gx*(grid_size+1));
-					
-					
-					if (gy == grid_size-1)
-					{
-						mTriStrip.push_back(gy+1+gx*(grid_size+1));
-					}
-#endif
-				}
-				else
-				{
-					for(S32 i=0;i<6;i++)
-					{
-						mIndices.push_back(vtop+(gy*(grid_size+1))+gx+idxs[i]);
-					}
-
-#if GEN_TRI_STRIP
-					if (gy == 0)
-					{
-						mTriStrip.push_back(gx*(grid_size+1));
-						mTriStrip.push_back(gx*(grid_size+1));
-						mTriStrip.push_back((gx+1)*(grid_size+1));
-					}
-
-					mTriStrip.push_back(gy+1+gx*(grid_size+1));
-					mTriStrip.push_back(gy+1+(gx+1)*(grid_size+1));
-					
-					if (gy == grid_size-1)
-					{
-						mTriStrip.push_back(gy+1+(gx+1)*(grid_size+1));
-					}
-#endif
-				}
-			}
-			
-		}
-
-#if GEN_TRI_STRIP
-		if (mTriStrip.size()%2 == 1)
-		{
-			mTriStrip.push_back(mTriStrip[mTriStrip.size()-1]);
-		}
-#endif
-	}
-		
-	return TRUE;
-}
-
-
-BOOL LLVolumeFace::createCap(LLVolume* volume, BOOL partial_build)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	if (!(mTypeMask & HOLLOW_MASK) && 
-		!(mTypeMask & OPEN_MASK) && 
-		((volume->getParams().getPathParams().getBegin()==0.0f)&&
-		(volume->getParams().getPathParams().getEnd()==1.0f))&&
-		(volume->getParams().getProfileParams().getCurveType()==LL_PCODE_PROFILE_SQUARE &&
-		 volume->getParams().getPathParams().getCurveType()==LL_PCODE_PATH_LINE)	
-		){
-		return createUnCutCubeCap(volume, partial_build);
-	}
-
-	S32 num_vertices = 0, num_indices = 0;
-
-	const std::vector<LLVolume::Point>& mesh = volume->getMesh();
-	const std::vector<LLVector3>& profile = volume->getProfile().mProfile;
-
-	// All types of caps have the same number of vertices and indices
-	num_vertices = profile.size();
-	num_indices = (profile.size() - 2)*3;
-
-	mVertices.resize(num_vertices);
-
-	if (!partial_build)
-	{
-		mIndices.resize(num_indices);
-	}
-
-	S32 max_s = volume->getProfile().getTotal();
-	S32 max_t = volume->getPath().mPath.size();
-
-	mCenter.clearVec();
-
-	S32 offset = 0;
-	if (mTypeMask & TOP_MASK)
-	{
-		offset = (max_t-1) * max_s;
-	}
-	else
-	{
-		offset = mBeginS;
-	}
-
-	// Figure out the normal, assume all caps are flat faces.
-	// Cross product to get normals.
-	
-	LLVector2 cuv;
-	LLVector2 min_uv, max_uv;
-
-	LLVector3& min = mExtents[0];
-	LLVector3& max = mExtents[1];
-
-	// Copy the vertices into the array
-	for (S32 i = 0; i < num_vertices; i++)
-	{
-		if (mTypeMask & TOP_MASK)
-		{
-			mVertices[i].mTexCoord.mV[0] = profile[i].mV[0]+0.5f;
-			mVertices[i].mTexCoord.mV[1] = profile[i].mV[1]+0.5f;
-		}
-		else
-		{
-			// Mirror for underside.
-			mVertices[i].mTexCoord.mV[0] = profile[i].mV[0]+0.5f;
-			mVertices[i].mTexCoord.mV[1] = 0.5f - profile[i].mV[1];
-		}
-
-		mVertices[i].mPosition = mesh[i + offset].mPos;
-		
-		if (i == 0)
-		{
-			min = max = mVertices[i].mPosition;
-			min_uv = max_uv = mVertices[i].mTexCoord;
-		}
-		else
-		{
-			update_min_max(min,max, mVertices[i].mPosition);
-			update_min_max(min_uv, max_uv, mVertices[i].mTexCoord);
-		}
-	}
-
-	mCenter = (min+max)*0.5f;
-	cuv = (min_uv + max_uv)*0.5f;
-
-	LLVector3 binormal = calc_binormal_from_triangle( 
-		mCenter, cuv,
-		mVertices[0].mPosition, mVertices[0].mTexCoord,
-		mVertices[1].mPosition, mVertices[1].mTexCoord);
-	binormal.normVec();
-
-	LLVector3 d0;
-	LLVector3 d1;
-	LLVector3 normal;
-
-	d0 = mCenter-mVertices[0].mPosition;
-	d1 = mCenter-mVertices[1].mPosition;
-
-	normal = (mTypeMask & TOP_MASK) ? (d0%d1) : (d1%d0);
-	normal.normVec();
-
-	VertexData vd;
-	vd.mPosition = mCenter;
-	vd.mNormal = normal;
-	vd.mBinormal = binormal;
-	vd.mTexCoord = cuv;
-	
-	if (!(mTypeMask & HOLLOW_MASK) && !(mTypeMask & OPEN_MASK))
-	{
-		mVertices.push_back(vd);
-		num_vertices++;
-		if (!partial_build)
-		{
-			vector_append(mIndices, 3);
-		}
-	}
-		
-	
-	for (S32 i = 0; i < num_vertices; i++)
-	{
-		mVertices[i].mBinormal = binormal;
-		mVertices[i].mNormal = normal;
-	}
-
-	mHasBinormals = TRUE;
-
-	if (partial_build)
-	{
-		return TRUE;
-	}
-
-	if (mTypeMask & HOLLOW_MASK)
-	{
-		if (mTypeMask & TOP_MASK)
-		{
-			// HOLLOW TOP
-			// Does it matter if it's open or closed? - djs
-
-			S32 pt1 = 0, pt2 = num_vertices - 1;
-			S32 i = 0;
-			while (pt2 - pt1 > 1)
-			{
-				// Use the profile points instead of the mesh, since you want
-				// the un-transformed profile distances.
-				LLVector3 p1 = profile[pt1];
-				LLVector3 p2 = profile[pt2];
-				LLVector3 pa = profile[pt1+1];
-				LLVector3 pb = profile[pt2-1];
-
-				p1.mV[VZ] = 0.f;
-				p2.mV[VZ] = 0.f;
-				pa.mV[VZ] = 0.f;
-				pb.mV[VZ] = 0.f;
-
-				// Use area of triangle to determine backfacing
-				F32 area_1a2, area_1ba, area_21b, area_2ab;
-				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
-							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
-							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
-
-				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
-							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
-
-				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
-							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
-							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				BOOL use_tri1a2 = TRUE;
-				BOOL tri_1a2 = TRUE;
-				BOOL tri_21b = TRUE;
-
-				if (area_1a2 < 0)
-				{
-					tri_1a2 = FALSE;
-				}
-				if (area_2ab < 0)
-				{
-					// Can't use, because it contains point b
-					tri_1a2 = FALSE;
-				}
-				if (area_21b < 0)
-				{
-					tri_21b = FALSE;
-				}
-				if (area_1ba < 0)
-				{
-					// Can't use, because it contains point b
-					tri_21b = FALSE;
-				}
-
-				if (!tri_1a2)
-				{
-					use_tri1a2 = FALSE;
-				}
-				else if (!tri_21b)
-				{
-					use_tri1a2 = TRUE;
-				}
-				else
-				{
-					LLVector3 d1 = p1 - pa;
-					LLVector3 d2 = p2 - pb;
-
-					if (d1.magVecSquared() < d2.magVecSquared())
-					{
-						use_tri1a2 = TRUE;
-					}
-					else
-					{
-						use_tri1a2 = FALSE;
-					}
-				}
-
-				if (use_tri1a2)
-				{
-					mIndices[i++] = pt1;
-					mIndices[i++] = pt1 + 1;
-					mIndices[i++] = pt2;
-					pt1++;
-				}
-				else
-				{
-					mIndices[i++] = pt1;
-					mIndices[i++] = pt2 - 1;
-					mIndices[i++] = pt2;
-					pt2--;
-				}
-			}
-
-			makeTriStrip();
-		}
-		else
-		{
-			// HOLLOW BOTTOM
-			// Does it matter if it's open or closed? - djs
-
-			llassert(mTypeMask & BOTTOM_MASK);
-			S32 pt1 = 0, pt2 = num_vertices - 1;
-
-			S32 i = 0;
-			while (pt2 - pt1 > 1)
-			{
-				// Use the profile points instead of the mesh, since you want
-				// the un-transformed profile distances.
-				LLVector3 p1 = profile[pt1];
-				LLVector3 p2 = profile[pt2];
-				LLVector3 pa = profile[pt1+1];
-				LLVector3 pb = profile[pt2-1];
-
-				p1.mV[VZ] = 0.f;
-				p2.mV[VZ] = 0.f;
-				pa.mV[VZ] = 0.f;
-				pb.mV[VZ] = 0.f;
-
-				// Use area of triangle to determine backfacing
-				F32 area_1a2, area_1ba, area_21b, area_2ab;
-				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +
-							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +
-							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);
-
-				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +
-							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);
-
-				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +
-							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +
-							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +
-							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);
-
-				BOOL use_tri1a2 = TRUE;
-				BOOL tri_1a2 = TRUE;
-				BOOL tri_21b = TRUE;
-
-				if (area_1a2 < 0)
-				{
-					tri_1a2 = FALSE;
-				}
-				if (area_2ab < 0)
-				{
-					// Can't use, because it contains point b
-					tri_1a2 = FALSE;
-				}
-				if (area_21b < 0)
-				{
-					tri_21b = FALSE;
-				}
-				if (area_1ba < 0)
-				{
-					// Can't use, because it contains point b
-					tri_21b = FALSE;
-				}
-
-				if (!tri_1a2)
-				{
-					use_tri1a2 = FALSE;
-				}
-				else if (!tri_21b)
-				{
-					use_tri1a2 = TRUE;
-				}
-				else
-				{
-					LLVector3 d1 = p1 - pa;
-					LLVector3 d2 = p2 - pb;
-
-					if (d1.magVecSquared() < d2.magVecSquared())
-					{
-						use_tri1a2 = TRUE;
-					}
-					else
-					{
-						use_tri1a2 = FALSE;
-					}
-				}
-
-				// Flipped backfacing from top
-				if (use_tri1a2)
-				{
-					mIndices[i++] = pt1;
-					mIndices[i++] = pt2;
-					mIndices[i++] = pt1 + 1;
-					pt1++;
-				}
-				else
-				{
-					mIndices[i++] = pt1;
-					mIndices[i++] = pt2;
-					mIndices[i++] = pt2 - 1;
-					pt2--;
-				}
-			}
-
-			makeTriStrip();
-		}
-	}
-	else
-	{
-		// Not hollow, generate the triangle fan.
-		U16 v1 = 2;
-		U16 v2 = 1;
-
-		if (mTypeMask & TOP_MASK)
-		{
-			v1 = 1;
-			v2 = 2;
-		}
-
-		for (S32 i = 0; i < (num_vertices - 2); i++)
-		{
-			mIndices[3*i] = num_vertices - 1;
-			mIndices[3*i+v1] = i;
-			mIndices[3*i+v2] = i + 1;
-		}
-
-#if GEN_TRI_STRIP
-		//make tri strip
-		if (mTypeMask & OPEN_MASK)
-		{
-			makeTriStrip();
-		}
-		else
-		{
-			S32 j = num_vertices-2;
-			if (mTypeMask & TOP_MASK)
-			{
-				mTriStrip.push_back(0);
-				for (S32 i = 0; i <= j; ++i)
-				{
-					mTriStrip.push_back(i);
-					if (i != j)
-					{
-						mTriStrip.push_back(j);
-					}
-					--j;
-				}
-			}
-			else
-			{
-				mTriStrip.push_back(j);
-				for (S32 i = 0; i <= j; ++i)
-				{
-					if (i != j)
-					{
-						mTriStrip.push_back(j);
-					}
-					mTriStrip.push_back(i);
-					--j;
-				}
-			}
-			
-			mTriStrip.push_back(mTriStrip[mTriStrip.size()-1]);
-
-			if (mTriStrip.size()%2 == 1)
-			{
-				mTriStrip.push_back(mTriStrip[mTriStrip.size()-1]);
-			}
-		}
-#endif
-	}
-		
-	return TRUE;
-}
-
-void LLVolumeFace::makeTriStrip()
-{
-#if GEN_TRI_STRIP
-	for (U32 i = 0; i < mIndices.size(); i+=3)
-	{
-		U16 i0 = mIndices[i];
-		U16 i1 = mIndices[i+1];
-		U16 i2 = mIndices[i+2];
-
-		if ((i/3)%2 == 1)
-		{
-			mTriStrip.push_back(i0);
-			mTriStrip.push_back(i0);
-			mTriStrip.push_back(i1);
-			mTriStrip.push_back(i2);
-			mTriStrip.push_back(i2);
-		}
-		else
-		{
-			mTriStrip.push_back(i2);
-			mTriStrip.push_back(i2);
-			mTriStrip.push_back(i1);
-			mTriStrip.push_back(i0);
-			mTriStrip.push_back(i0);
-		}
-	}
-
-	if (mTriStrip.size()%2 == 1)
-	{
-		mTriStrip.push_back(mTriStrip[mTriStrip.size()-1]);
-	}
-#endif
-}
-
-void LLVolumeFace::createBinormals()
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	if (!mHasBinormals)
-	{
-		//generate binormals
-		for (U32 i = 0; i < mIndices.size()/3; i++) 
-		{	//for each triangle
-			const VertexData& v0 = mVertices[mIndices[i*3+0]];
-			const VertexData& v1 = mVertices[mIndices[i*3+1]];
-			const VertexData& v2 = mVertices[mIndices[i*3+2]];
-						
-			//calculate binormal
-			LLVector3 binorm = calc_binormal_from_triangle(v0.mPosition, v0.mTexCoord,
-															v1.mPosition, v1.mTexCoord,
-															v2.mPosition, v2.mTexCoord);
-
-			for (U32 j = 0; j < 3; j++) 
-			{ //add triangle normal to vertices
-				mVertices[mIndices[i*3+j]].mBinormal += binorm; // * (weight_sum - d[j])/weight_sum;
-			}
-
-			//even out quad contributions
-			if (i % 2 == 0) 
-			{
-				mVertices[mIndices[i*3+2]].mBinormal += binorm;
-			}
-			else 
-			{
-				mVertices[mIndices[i*3+1]].mBinormal += binorm;
-			}
-		}
-
-		//normalize binormals
-		for (U32 i = 0; i < mVertices.size(); i++) 
-		{
-			mVertices[i].mBinormal.normVec();
-			mVertices[i].mNormal.normVec();
-		}
-
-		mHasBinormals = TRUE;
-	}
-}
-
-BOOL LLVolumeFace::createSide(LLVolume* volume, BOOL partial_build)
-{
-	LLMemType m1(LLMemType::MTYPE_VOLUME);
-	
-	BOOL flat = mTypeMask & FLAT_MASK;
-
-	U8 sculpt_type = volume->getParams().getSculptType();
-	U8 sculpt_stitching = sculpt_type & LL_SCULPT_TYPE_MASK;
-	BOOL sculpt_invert = sculpt_type & LL_SCULPT_FLAG_INVERT;
-	BOOL sculpt_mirror = sculpt_type & LL_SCULPT_FLAG_MIRROR;
-	BOOL sculpt_reverse_horizontal = (sculpt_invert ? !sculpt_mirror : sculpt_mirror);  // XOR
-	
-	S32 num_vertices, num_indices;
-
-	const std::vector<LLVolume::Point>& mesh = volume->getMesh();
-	const std::vector<LLVector3>& profile = volume->getProfile().mProfile;
-	const std::vector<LLPath::PathPt>& path_data = volume->getPath().mPath;
-
-	S32 max_s = volume->getProfile().getTotal();
-
-	S32 s, t, i;
-	F32 ss, tt;
-
-	num_vertices = mNumS*mNumT;
-	num_indices = (mNumS-1)*(mNumT-1)*6;
-
-	mVertices.resize(num_vertices);
-
-	if (!partial_build)
-	{
-		mIndices.resize(num_indices);
-		mEdge.resize(num_indices);
-	}
-	else
-	{
-		mHasBinormals = FALSE;
-	}
-
-	S32 begin_stex = llfloor( profile[mBeginS].mV[2] );
-	S32 num_s = ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2) ? mNumS/2 : mNumS;
-
-	S32 cur_vertex = 0;
-	// Copy the vertices into the array
-	for (t = mBeginT; t < mBeginT + mNumT; t++)
-	{
-		tt = path_data[t].mTexT;
-		for (s = 0; s < num_s; s++)
-		{
-			if (mTypeMask & END_MASK)
-			{
-				if (s)
-				{
-					ss = 1.f;
-				}
-				else
-				{
-					ss = 0.f;
-				}
-			}
-			else
-			{
-				// Get s value for tex-coord.
-				if (!flat)
-				{
-					ss = profile[mBeginS + s].mV[2];
-				}
-				else
-				{
-					ss = profile[mBeginS + s].mV[2] - begin_stex;
-				}
-			}
-
-			if (sculpt_reverse_horizontal)
-			{
-				ss = 1.f - ss;
-			}
-			
-			// Check to see if this triangle wraps around the array.
-			if (mBeginS + s >= max_s)
-			{
-				// We're wrapping
-				i = mBeginS + s + max_s*(t-1);
-			}
-			else
-			{
-				i = mBeginS + s + max_s*t;
-			}
-
-			mVertices[cur_vertex].mPosition = mesh[i].mPos;
-			mVertices[cur_vertex].mTexCoord = LLVector2(ss,tt);
-		
-			mVertices[cur_vertex].mNormal = LLVector3(0,0,0);
-			mVertices[cur_vertex].mBinormal = LLVector3(0,0,0);
-
-			cur_vertex++;
-
-			if ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2 && s > 0)
-			{
-				mVertices[cur_vertex].mPosition = mesh[i].mPos;
-				mVertices[cur_vertex].mTexCoord = LLVector2(ss,tt);
-			
-				mVertices[cur_vertex].mNormal = LLVector3(0,0,0);
-				mVertices[cur_vertex].mBinormal = LLVector3(0,0,0);
-				cur_vertex++;
-			}
-		}
-		
-		if ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2)
-		{
-			if (mTypeMask & OPEN_MASK)
-			{
-				s = num_s-1;
-			}
-			else
-			{
-				s = 0;
-			}
-
-			i = mBeginS + s + max_s*t;
-			ss = profile[mBeginS + s].mV[2] - begin_stex;
-			mVertices[cur_vertex].mPosition = mesh[i].mPos;
-			mVertices[cur_vertex].mTexCoord = LLVector2(ss,tt);
-		
-			mVertices[cur_vertex].mNormal = LLVector3(0,0,0);
-			mVertices[cur_vertex].mBinormal = LLVector3(0,0,0);
-
-			cur_vertex++;
-		}
-	}
-	
-
-	//get bounding box for this side
-	LLVector3& face_min = mExtents[0];
-	LLVector3& face_max = mExtents[1];
-	mCenter.clearVec();
-
-	face_min = face_max = mVertices[0].mPosition;
-	for (U32 i = 1; i < mVertices.size(); ++i)
-	{
-		update_min_max(face_min, face_max, mVertices[i].mPosition);
-	}
-
-	mCenter = (face_min + face_max) * 0.5f;
-
-	S32 cur_index = 0;
-	S32 cur_edge = 0;
-	BOOL flat_face = mTypeMask & FLAT_MASK;
-
-	if (!partial_build)
-	{
-#if GEN_TRI_STRIP
-		mTriStrip.clear();
-#endif
-
-		// Now we generate the indices.
-		for (t = 0; t < (mNumT-1); t++)
-		{
-#if GEN_TRI_STRIP
-			//prepend terminating index to strip
-			mTriStrip.push_back(mNumS*t);
-#endif
-
-			for (s = 0; s < (mNumS-1); s++)
-			{	
-				mIndices[cur_index++] = s   + mNumS*t;			//bottom left
-				mIndices[cur_index++] = s+1 + mNumS*(t+1);		//top right
-				mIndices[cur_index++] = s   + mNumS*(t+1);		//top left
-				mIndices[cur_index++] = s   + mNumS*t;			//bottom left
-				mIndices[cur_index++] = s+1 + mNumS*t;			//bottom right
-				mIndices[cur_index++] = s+1 + mNumS*(t+1);		//top right
-
-#if GEN_TRI_STRIP
-				if (s == 0)
-				{
-					mTriStrip.push_back(s+mNumS*t);
-					mTriStrip.push_back(s+mNumS*(t+1));
-				}
-				mTriStrip.push_back(s+1+mNumS*t);
-				mTriStrip.push_back(s+1+mNumS*(t+1));
-#endif
-				
-				mEdge[cur_edge++] = (mNumS-1)*2*t+s*2+1;						//bottom left/top right neighbor face 
-				if (t < mNumT-2) {												//top right/top left neighbor face 
-					mEdge[cur_edge++] = (mNumS-1)*2*(t+1)+s*2+1;
-				}
-				else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor
-					mEdge[cur_edge++] = -1;
-				}
-				else { //wrap on T
-					mEdge[cur_edge++] = s*2+1;
-				}
-				if (s > 0) {													//top left/bottom left neighbor face
-					mEdge[cur_edge++] = (mNumS-1)*2*t+s*2-1;
-				}
-				else if (flat_face ||  volume->getProfile().isOpen() == TRUE) { //no neighbor
-					mEdge[cur_edge++] = -1;
-				}
-				else {	//wrap on S
-					mEdge[cur_edge++] = (mNumS-1)*2*t+(mNumS-2)*2+1;
-				}
-				
-				if (t > 0) {													//bottom left/bottom right neighbor face
-					mEdge[cur_edge++] = (mNumS-1)*2*(t-1)+s*2;
-				}
-				else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor
-					mEdge[cur_edge++] = -1;
-				}
-				else { //wrap on T
-					mEdge[cur_edge++] = (mNumS-1)*2*(mNumT-2)+s*2;
-				}
-				if (s < mNumS-2) {												//bottom right/top right neighbor face
-					mEdge[cur_edge++] = (mNumS-1)*2*t+(s+1)*2;
-				}
-				else if (flat_face || volume->getProfile().isOpen() == TRUE) { //no neighbor
-					mEdge[cur_edge++] = -1;
-				}
-				else { //wrap on S
-					mEdge[cur_edge++] = (mNumS-1)*2*t;
-				}
-				mEdge[cur_edge++] = (mNumS-1)*2*t+s*2;							//top right/bottom left neighbor face	
-			}
-#if GEN_TRI_STRIP
-			//append terminating vertex to strip
-			mTriStrip.push_back(mNumS-1+mNumS*(t+1));
-#endif
-		}
-
-#if GEN_TRI_STRIP
-		if (mTriStrip.size()%2 == 1)
-		{
-			mTriStrip.push_back(mTriStrip[mTriStrip.size()-1]);
-		}
-#endif
-	}
-
-	//generate normals 
-	for (U32 i = 0; i < mIndices.size()/3; i++) //for each triangle
-	{
-		const U16* idx = &(mIndices[i*3]);
-			
-		VertexData* v[] = 
-		{	&mVertices[idx[0]], &mVertices[idx[1]], &mVertices[idx[2]] };
-					
-		//calculate triangle normal
-		LLVector3 norm = (v[0]->mPosition-v[1]->mPosition) % (v[0]->mPosition-v[2]->mPosition);
-
-		v[0]->mNormal += norm;
-		v[1]->mNormal += norm;
-		v[2]->mNormal += norm;
-
-		//even out quad contributions
-		v[i%2+1]->mNormal += norm;
-	}
-	
-	// 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 (sculpt_stitching == LL_SCULPT_TYPE_NONE)  // logic for non-sculpt volumes
-	{
-		if (volume->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 ((volume->getProfile().isOpen() == FALSE) && !(s_bottom_converges))
-		{ //wrap normals on S
-			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 (volume->getPathType() == LL_PCODE_PATH_CIRCLE &&
-			((volume->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);
-				}
-			}
-		}
-	}
-	
-	else  // logic for sculpt volumes
-	{
-		BOOL average_poles = FALSE;
-		BOOL wrap_s = FALSE;
-		BOOL wrap_t = FALSE;
-
-		if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)
-			average_poles = TRUE;
-
-		if ((sculpt_stitching == LL_SCULPT_TYPE_SPHERE) ||
-			(sculpt_stitching == LL_SCULPT_TYPE_TORUS) ||
-			(sculpt_stitching == LL_SCULPT_TYPE_CYLINDER))
-			wrap_s = TRUE;
-
-		if (sculpt_stitching == LL_SCULPT_TYPE_TORUS)
-			wrap_t = TRUE;
-			
-		
-		if (average_poles)
-		{
-			// 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;
-			}
-
-		}
-
-		
-		if (wrap_s)
-		{
-			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 (wrap_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;
-			}
-			
-		}
-
-	}
-
-	return TRUE;
-}
-
-// Finds binormal based on three vertices with texture coordinates.
-// Fills in dummy values if the triangle has degenerate texture coordinates.
-LLVector3 calc_binormal_from_triangle( 
-	const LLVector3& pos0,
-	const LLVector2& tex0,
-	const LLVector3& pos1,
-	const LLVector2& tex1,
-	const LLVector3& pos2,
-	const LLVector2& tex2)
-{
-	LLVector3 rx0( pos0.mV[VX], tex0.mV[VX], tex0.mV[VY] );
-	LLVector3 rx1( pos1.mV[VX], tex1.mV[VX], tex1.mV[VY] );
-	LLVector3 rx2( pos2.mV[VX], tex2.mV[VX], tex2.mV[VY] );
-	
-	LLVector3 ry0( pos0.mV[VY], tex0.mV[VX], tex0.mV[VY] );
-	LLVector3 ry1( pos1.mV[VY], tex1.mV[VX], tex1.mV[VY] );
-	LLVector3 ry2( pos2.mV[VY], tex2.mV[VX], tex2.mV[VY] );
-
-	LLVector3 rz0( pos0.mV[VZ], tex0.mV[VX], tex0.mV[VY] );
-	LLVector3 rz1( pos1.mV[VZ], tex1.mV[VX], tex1.mV[VY] );
-	LLVector3 rz2( pos2.mV[VZ], tex2.mV[VX], tex2.mV[VY] );
-	
-	LLVector3 r0 = (rx0 - rx1) % (rx0 - rx2);
-	LLVector3 r1 = (ry0 - ry1) % (ry0 - ry2);
-	LLVector3 r2 = (rz0 - rz1) % (rz0 - rz2);
-
-	if( r0.mV[VX] && r1.mV[VX] && r2.mV[VX] )
-	{
-		LLVector3 binormal(
-				-r0.mV[VZ] / r0.mV[VX],
-				-r1.mV[VZ] / r1.mV[VX],
-				-r2.mV[VZ] / r2.mV[VX]);
-		// binormal.normVec();
-		return binormal;
-	}
-	else
-	{
-		return LLVector3( 0, 1 , 0 );
-	}
-}
+/** 

+

+ * @file llvolume.cpp

+ *

+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2010, Linden Research, Inc.

+ * 

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ * 

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ * 

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+ * 

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

+ * $/LicenseInfo$

+ */

+

+#include "linden_common.h"

+#include "llmemory.h"

+#include "llmath.h"

+

+#include <set>

+#if !LL_WINDOWS

+#include <stdint.h>

+#endif

+

+#include "llerror.h"

+#include "llmemtype.h"

+

+#include "llvolumemgr.h"

+#include "v2math.h"

+#include "v3math.h"

+#include "v4math.h"

+#include "m4math.h"

+#include "m3math.h"

+#include "llmatrix3a.h"

+#include "lloctree.h"

+#include "lldarray.h"

+#include "llvolume.h"

+#include "llvolumeoctree.h"

+#include "llstl.h"

+#include "llsdserialize.h"

+#include "llvector4a.h"

+#include "llmatrix4a.h"

+

+#define DEBUG_SILHOUETTE_BINORMALS 0

+#define DEBUG_SILHOUETTE_NORMALS 0 // TomY: Use this to display normals using the silhouette

+#define DEBUG_SILHOUETTE_EDGE_MAP 0 // DaveP: Use this to display edge map using the silhouette

+

+const F32 CUT_MIN = 0.f;

+const F32 CUT_MAX = 1.f;

+const F32 MIN_CUT_DELTA = 0.02f;

+

+const F32 HOLLOW_MIN = 0.f;

+const F32 HOLLOW_MAX = 0.95f;

+const F32 HOLLOW_MAX_SQUARE	= 0.7f;

+

+const F32 TWIST_MIN = -1.f;

+const F32 TWIST_MAX =  1.f;

+

+const F32 RATIO_MIN = 0.f;

+const F32 RATIO_MAX = 2.f; // Tom Y: Inverted sense here: 0 = top taper, 2 = bottom taper

+

+const F32 HOLE_X_MIN= 0.05f;

+const F32 HOLE_X_MAX= 1.0f;

+

+const F32 HOLE_Y_MIN= 0.05f;

+const F32 HOLE_Y_MAX= 0.5f;

+

+const F32 SHEAR_MIN = -0.5f;

+const F32 SHEAR_MAX =  0.5f;

+

+const F32 REV_MIN = 1.f;

+const F32 REV_MAX = 4.f;

+

+const F32 TAPER_MIN = -1.f;

+const F32 TAPER_MAX =  1.f;

+

+const F32 SKEW_MIN	= -0.95f;

+const F32 SKEW_MAX	=  0.95f;

+

+const F32 SCULPT_MIN_AREA = 0.002f;

+const S32 SCULPT_MIN_AREA_DETAIL = 1;

+

+extern BOOL gDebugGL;

+

+void assert_aligned(void* ptr, uintptr_t alignment)

+{

+#if 0

+	uintptr_t t = (uintptr_t) ptr;

+	if (t%alignment != 0)

+	{

+		llerrs << "WTF?" << llendl;

+	}

+#endif

+}

+

+BOOL check_same_clock_dir( const LLVector3& pt1, const LLVector3& pt2, const LLVector3& pt3, const LLVector3& norm)

+{    

+	LLVector3 test = (pt2-pt1)%(pt3-pt2);

+

+	//answer

+	if(test * norm < 0) 

+	{

+		return FALSE;

+	}

+	else 

+	{

+		return TRUE;

+	}

+} 

+

+BOOL LLLineSegmentBoxIntersect(const LLVector3& start, const LLVector3& end, const LLVector3& center, const LLVector3& size)

+{

+	return LLLineSegmentBoxIntersect(start.mV, end.mV, center.mV, size.mV);

+}

+

+BOOL LLLineSegmentBoxIntersect(const F32* start, const F32* end, const F32* center, const F32* size)

+{

+	F32 fAWdU[3];

+	F32 dir[3];

+	F32 diff[3];

+

+	for (U32 i = 0; i < 3; i++)

+	{

+		dir[i] = 0.5f * (end[i] - start[i]);

+		diff[i] = (0.5f * (end[i] + start[i])) - center[i];

+		fAWdU[i] = fabsf(dir[i]);

+		if(fabsf(diff[i])>size[i] + fAWdU[i]) return false;

+	}

+

+	float f;

+	f = dir[1] * diff[2] - dir[2] * diff[1];    if(fabsf(f)>size[1]*fAWdU[2] + size[2]*fAWdU[1])  return false;

+	f = dir[2] * diff[0] - dir[0] * diff[2];    if(fabsf(f)>size[0]*fAWdU[2] + size[2]*fAWdU[0])  return false;

+	f = dir[0] * diff[1] - dir[1] * diff[0];    if(fabsf(f)>size[0]*fAWdU[1] + size[1]*fAWdU[0])  return false;

+	

+	return true;

+}

+

+

+

+// intersect test between triangle vert0, vert1, vert2 and a ray from orig in direction dir.

+// returns TRUE if intersecting and returns barycentric coordinates in intersection_a, intersection_b,

+// and returns the intersection point along dir in intersection_t.

+

+// Moller-Trumbore algorithm

+BOOL LLTriangleRayIntersect(const LLVector4a& vert0, const LLVector4a& vert1, const LLVector4a& vert2, const LLVector4a& orig, const LLVector4a& dir,

+							F32& intersection_a, F32& intersection_b, F32& intersection_t)

+{

+	

+	/* find vectors for two edges sharing vert0 */

+	LLVector4a edge1;

+	edge1.setSub(vert1, vert0);

+	

+	LLVector4a edge2;

+	edge2.setSub(vert2, vert0);

+

+	/* begin calculating determinant - also used to calculate U parameter */

+	LLVector4a pvec;

+	pvec.setCross3(dir, edge2);

+

+	/* if determinant is near zero, ray lies in plane of triangle */

+	LLVector4a det;

+	det.setAllDot3(edge1, pvec);

+	

+	if (det.greaterEqual(LLVector4a::getEpsilon()).getGatheredBits() & 0x7)

+	{

+		/* calculate distance from vert0 to ray origin */

+		LLVector4a tvec;

+		tvec.setSub(orig, vert0);

+

+		/* calculate U parameter and test bounds */

+		LLVector4a u;

+		u.setAllDot3(tvec,pvec);

+

+		if ((u.greaterEqual(LLVector4a::getZero()).getGatheredBits() & 0x7) &&

+			(u.lessEqual(det).getGatheredBits() & 0x7))

+		{

+			/* prepare to test V parameter */

+			LLVector4a qvec;

+			qvec.setCross3(tvec, edge1);

+			

+			/* calculate V parameter and test bounds */

+			LLVector4a v;

+			v.setAllDot3(dir, qvec);

+

+			

+			//if (!(v < 0.f || u + v > det))

+

+			LLVector4a sum_uv;

+			sum_uv.setAdd(u, v);

+

+			S32 v_gequal = v.greaterEqual(LLVector4a::getZero()).getGatheredBits() & 0x7;

+			S32 sum_lequal = sum_uv.lessEqual(det).getGatheredBits() & 0x7;

+

+			if (v_gequal  && sum_lequal)

+			{

+				/* calculate t, scale parameters, ray intersects triangle */

+				LLVector4a t;

+				t.setAllDot3(edge2,qvec);

+

+				t.div(det);

+				u.div(det);

+				v.div(det);

+				

+				intersection_a = u[0];

+				intersection_b = v[0];

+				intersection_t = t[0];

+				return TRUE;

+			}

+		}

+	}

+		

+	return FALSE;

+} 

+

+BOOL LLTriangleRayIntersectTwoSided(const LLVector4a& vert0, const LLVector4a& vert1, const LLVector4a& vert2, const LLVector4a& orig, const LLVector4a& dir,

+							F32& intersection_a, F32& intersection_b, F32& intersection_t)

+{

+	F32 u, v, t;

+	

+	/* find vectors for two edges sharing vert0 */

+	LLVector4a edge1;

+	edge1.setSub(vert1, vert0);

+	

+	

+	LLVector4a edge2;

+	edge2.setSub(vert2, vert0);

+

+	/* begin calculating determinant - also used to calculate U parameter */

+	LLVector4a pvec;

+	pvec.setCross3(dir, edge2);

+

+	/* if determinant is near zero, ray lies in plane of triangle */

+	F32 det = edge1.dot3(pvec).getF32();

+

+	

+	if (det > -F_APPROXIMATELY_ZERO && det < F_APPROXIMATELY_ZERO)

+	{

+		return FALSE;

+	}

+

+	F32 inv_det = 1.f / det;

+

+	/* calculate distance from vert0 to ray origin */

+	LLVector4a tvec;

+	tvec.setSub(orig, vert0);

+	

+	/* calculate U parameter and test bounds */

+	u = (tvec.dot3(pvec).getF32()) * inv_det;

+	if (u < 0.f || u > 1.f)

+	{

+		return FALSE;

+	}

+

+	/* prepare to test V parameter */

+	tvec.sub(edge1);

+		

+	/* calculate V parameter and test bounds */

+	v = (dir.dot3(tvec).getF32()) * inv_det;

+	

+	if (v < 0.f || u + v > 1.f)

+	{

+		return FALSE;

+	}

+

+	/* calculate t, ray intersects triangle */

+	t = (edge2.dot3(tvec).getF32()) * inv_det;

+	

+	intersection_a = u;

+	intersection_b = v;

+	intersection_t = t;

+	

+	

+	return TRUE;

+} 

+

+//helper for non-aligned vectors

+BOOL LLTriangleRayIntersect(const LLVector3& vert0, const LLVector3& vert1, const LLVector3& vert2, const LLVector3& orig, const LLVector3& dir,

+							F32& intersection_a, F32& intersection_b, F32& intersection_t, BOOL two_sided)

+{

+	LLVector4a vert0a, vert1a, vert2a, origa, dira;

+	vert0a.load3(vert0.mV);

+	vert1a.load3(vert1.mV);

+	vert2a.load3(vert2.mV);

+	origa.load3(orig.mV);

+	dira.load3(dir.mV);

+

+	if (two_sided)

+	{

+		return LLTriangleRayIntersectTwoSided(vert0a, vert1a, vert2a, origa, dira, 

+				intersection_a, intersection_b, intersection_t);

+	}

+	else

+	{

+		return LLTriangleRayIntersect(vert0a, vert1a, vert2a, origa, dira, 

+				intersection_a, intersection_b, intersection_t);

+	}

+}

+

+class LLVolumeOctreeRebound : public LLOctreeTravelerDepthFirst<LLVolumeTriangle>

+{

+public:

+	const LLVolumeFace* mFace;

+

+	LLVolumeOctreeRebound(const LLVolumeFace* face)

+	{

+		mFace = face;

+	}

+

+	virtual void visit(const LLOctreeNode<LLVolumeTriangle>* branch)

+	{ //this is a depth first traversal, so it's safe to assum all children have complete

+		//bounding data

+

+		LLVolumeOctreeListener* node = (LLVolumeOctreeListener*) branch->getListener(0);

+

+		LLVector4a& min = node->mExtents[0];

+		LLVector4a& max = node->mExtents[1];

+

+		if (!branch->getData().empty())

+		{ //node has data, find AABB that binds data set

+			const LLVolumeTriangle* tri = *(branch->getData().begin());

+			

+			//initialize min/max to first available vertex

+			min = *(tri->mV[0]);

+			max = *(tri->mV[0]);

+			

+			for (LLOctreeNode<LLVolumeTriangle>::const_element_iter iter = 

+				branch->getData().begin(); iter != branch->getData().end(); ++iter)

+			{ //for each triangle in node

+

+				//stretch by triangles in node

+				tri = *iter;

+				

+				min.setMin(min, *tri->mV[0]);

+				min.setMin(min, *tri->mV[1]);

+				min.setMin(min, *tri->mV[2]);

+

+				max.setMax(max, *tri->mV[0]);

+				max.setMax(max, *tri->mV[1]);

+				max.setMax(max, *tri->mV[2]);

+			}

+		}

+		else if (!branch->getChildren().empty())

+		{ //no data, but child nodes exist

+			LLVolumeOctreeListener* child = (LLVolumeOctreeListener*) branch->getChild(0)->getListener(0);

+

+			//initialize min/max to extents of first child

+			min = child->mExtents[0];

+			max = child->mExtents[1];

+		}

+		else

+		{

+			llerrs << "WTF? Empty leaf" << llendl;

+		}

+

+		for (S32 i = 0; i < branch->getChildCount(); ++i)

+		{  //stretch by child extents

+			LLVolumeOctreeListener* child = (LLVolumeOctreeListener*) branch->getChild(i)->getListener(0);

+			min.setMin(min, child->mExtents[0]);

+			max.setMax(max, child->mExtents[1]);

+		}

+

+		node->mBounds[0].setAdd(min, max);

+		node->mBounds[0].mul(0.5f);

+

+		node->mBounds[1].setSub(max,min);

+		node->mBounds[1].mul(0.5f);

+	}

+};

+

+//-------------------------------------------------------------------

+// statics

+//-------------------------------------------------------------------

+

+

+//----------------------------------------------------

+

+LLProfile::Face* LLProfile::addCap(S16 faceID)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	Face *face   = vector_append(mFaces, 1);

+	

+	face->mIndex = 0;

+	face->mCount = mTotal;

+	face->mScaleU= 1.0f;

+	face->mCap   = TRUE;

+	face->mFaceID = faceID;

+	return face;

+}

+

+LLProfile::Face* LLProfile::addFace(S32 i, S32 count, F32 scaleU, S16 faceID, BOOL flat)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	Face *face   = vector_append(mFaces, 1);

+	

+	face->mIndex = i;

+	face->mCount = count;

+	face->mScaleU= scaleU;

+

+	face->mFlat = flat;

+	face->mCap   = FALSE;

+	face->mFaceID = faceID;

+	return face;

+}

+

+// What is the bevel parameter used for? - DJS 04/05/02

+// Bevel parameter is currently unused but presumedly would support

+// filleted and chamfered corners

+void LLProfile::genNGon(const LLProfileParams& params, S32 sides, F32 offset, F32 bevel, F32 ang_scale, S32 split)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	// Generate an n-sided "circular" path.

+	// 0 is (1,0), and we go counter-clockwise along a circular path from there.

+	const F32 tableScale[] = { 1, 1, 1, 0.5f, 0.707107f, 0.53f, 0.525f, 0.5f };

+	F32 scale = 0.5f;

+	F32 t, t_step, t_first, t_fraction, ang, ang_step;

+	LLVector3 pt1,pt2;

+

+	F32 begin  = params.getBegin();

+	F32 end    = params.getEnd();

+

+	t_step = 1.0f / sides;

+	ang_step = 2.0f*F_PI*t_step*ang_scale;

+

+	// Scale to have size "match" scale.  Compensates to get object to generally fill bounding box.

+

+	S32 total_sides = llround(sides / ang_scale);	// Total number of sides all around

+

+	if (total_sides < 8)

+	{

+		scale = tableScale[total_sides];

+	}

+

+	t_first = floor(begin * sides) / (F32)sides;

+

+	// pt1 is the first point on the fractional face.

+	// Starting t and ang values for the first face

+	t = t_first;

+	ang = 2.0f*F_PI*(t*ang_scale + offset);

+	pt1.setVec(cos(ang)*scale,sin(ang)*scale, t);

+

+	// Increment to the next point.

+	// pt2 is the end point on the fractional face

+	t += t_step;

+	ang += ang_step;

+	pt2.setVec(cos(ang)*scale,sin(ang)*scale,t);

+

+	t_fraction = (begin - t_first)*sides;

+

+	// Only use if it's not almost exactly on an edge.

+	if (t_fraction < 0.9999f)

+	{

+		LLVector3 new_pt = lerp(pt1, pt2, t_fraction);

+		mProfile.push_back(new_pt);

+	}

+

+	// There's lots of potential here for floating point error to generate unneeded extra points - DJS 04/05/02

+	while (t < end)

+	{

+		// Iterate through all the integer steps of t.

+		pt1.setVec(cos(ang)*scale,sin(ang)*scale,t);

+

+		if (mProfile.size() > 0) {

+			LLVector3 p = mProfile[mProfile.size()-1];

+			for (S32 i = 0; i < split && mProfile.size() > 0; i++) {

+				mProfile.push_back(p+(pt1-p) * 1.0f/(float)(split+1) * (float)(i+1));

+			}

+		}

+		mProfile.push_back(pt1);

+

+		t += t_step;

+		ang += ang_step;

+	}

+

+	t_fraction = (end - (t - t_step))*sides;

+

+	// pt1 is the first point on the fractional face

+	// pt2 is the end point on the fractional face

+	pt2.setVec(cos(ang)*scale,sin(ang)*scale,t);

+

+	// Find the fraction that we need to add to the end point.

+	t_fraction = (end - (t - t_step))*sides;

+	if (t_fraction > 0.0001f)

+	{

+		LLVector3 new_pt = lerp(pt1, pt2, t_fraction);

+		

+		if (mProfile.size() > 0) {

+			LLVector3 p = mProfile[mProfile.size()-1];

+			for (S32 i = 0; i < split && mProfile.size() > 0; i++) {

+				mProfile.push_back(p+(new_pt-p) * 1.0f/(float)(split+1) * (float)(i+1));

+			}

+		}

+		mProfile.push_back(new_pt);

+	}

+

+	// If we're sliced, the profile is open.

+	if ((end - begin)*ang_scale < 0.99f)

+	{

+		if ((end - begin)*ang_scale > 0.5f)

+		{

+			mConcave = TRUE;

+		}

+		else

+		{

+			mConcave = FALSE;

+		}

+		mOpen = TRUE;

+		if (params.getHollow() <= 0)

+		{

+			// put center point if not hollow.

+			mProfile.push_back(LLVector3(0,0,0));

+		}

+	}

+	else

+	{

+		// The profile isn't open.

+		mOpen = FALSE;

+		mConcave = FALSE;

+	}

+

+	mTotal = mProfile.size();

+}

+

+void LLProfile::genNormals(const LLProfileParams& params)

+{

+	S32 count = mProfile.size();

+

+	S32 outer_count;

+	if (mTotalOut)

+	{

+		outer_count = mTotalOut;

+	}

+	else

+	{

+		outer_count = mTotal / 2;

+	}

+

+	mEdgeNormals.resize(count * 2);

+	mEdgeCenters.resize(count * 2);

+	mNormals.resize(count);

+

+	LLVector2 pt0,pt1;

+

+	BOOL hollow = (params.getHollow() > 0);

+

+	S32 i0, i1, i2, i3, i4;

+

+	// Parametrically generate normal

+	for (i2 = 0; i2 < count; i2++)

+	{

+		mNormals[i2].mV[0] = mProfile[i2].mV[0];

+		mNormals[i2].mV[1] = mProfile[i2].mV[1];

+		if (hollow && (i2 >= outer_count))

+		{

+			mNormals[i2] *= -1.f;

+		}

+		if (mNormals[i2].magVec() < 0.001)

+		{

+			// Special case for point at center, get adjacent points.

+			i1 = (i2 - 1) >= 0 ? i2 - 1 : count - 1;

+			i0 = (i1 - 1) >= 0 ? i1 - 1 : count - 1;

+			i3 = (i2 + 1) < count ? i2 + 1 : 0;

+			i4 = (i3 + 1) < count ? i3 + 1 : 0;

+

+			pt0.setVec(mProfile[i1].mV[VX] + mProfile[i1].mV[VX] - mProfile[i0].mV[VX], 

+				mProfile[i1].mV[VY] + mProfile[i1].mV[VY] - mProfile[i0].mV[VY]);

+			pt1.setVec(mProfile[i3].mV[VX] + mProfile[i3].mV[VX] - mProfile[i4].mV[VX], 

+				mProfile[i3].mV[VY] + mProfile[i3].mV[VY] - mProfile[i4].mV[VY]);

+

+			mNormals[i2] = pt0 + pt1;

+			mNormals[i2] *= 0.5f;

+		}

+		mNormals[i2].normVec();

+	}

+

+	S32 num_normal_sets = isConcave() ? 2 : 1;

+	for (S32 normal_set = 0; normal_set < num_normal_sets; normal_set++)

+	{

+		S32 point_num;

+		for (point_num = 0; point_num < mTotal; point_num++)

+		{

+			LLVector3 point_1 = mProfile[point_num];

+			point_1.mV[VZ] = 0.f;

+

+			LLVector3 point_2;

+			

+			if (isConcave() && normal_set == 0 && point_num == (mTotal - 1) / 2)

+			{

+				point_2 = mProfile[mTotal - 1];

+			}

+			else if (isConcave() && normal_set == 1 && point_num == mTotal - 1)

+			{

+				point_2 = mProfile[(mTotal - 1) / 2];

+			}

+			else

+			{

+				LLVector3 delta_pos;

+				S32 neighbor_point = (point_num + 1) % mTotal;

+				while(delta_pos.magVecSquared() < 0.01f * 0.01f)

+				{

+					point_2 = mProfile[neighbor_point];

+					delta_pos = point_2 - point_1;

+					neighbor_point = (neighbor_point + 1) % mTotal;

+					if (neighbor_point == point_num)

+					{

+						break;

+					}

+				}

+			}

+

+			point_2.mV[VZ] = 0.f;

+			LLVector3 face_normal = (point_2 - point_1) % LLVector3::z_axis;

+			face_normal.normVec();

+			mEdgeNormals[normal_set * count + point_num] = face_normal;

+			mEdgeCenters[normal_set * count + point_num] = lerp(point_1, point_2, 0.5f);

+		}

+	}

+}

+

+

+// Hollow is percent of the original bounding box, not of this particular

+// profile's geometry.  Thus, a swept triangle needs lower hollow values than

+// a swept square.

+LLProfile::Face* LLProfile::addHole(const LLProfileParams& params, BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split)

+{

+	// Note that addHole will NOT work for non-"circular" profiles, if we ever decide to use them.

+

+	// Total add has number of vertices on outside.

+	mTotalOut = mTotal;

+

+	// Why is the "bevel" parameter -1? DJS 04/05/02

+	genNGon(params, llfloor(sides),offset,-1, ang_scale, split);

+

+	Face *face = addFace(mTotalOut, mTotal-mTotalOut,0,LL_FACE_INNER_SIDE, flat);

+

+	std::vector<LLVector3> pt;

+	pt.resize(mTotal) ;

+

+	for (S32 i=mTotalOut;i<mTotal;i++)

+	{

+		pt[i] = mProfile[i] * box_hollow;

+	}

+

+	S32 j=mTotal-1;

+	for (S32 i=mTotalOut;i<mTotal;i++)

+	{

+		mProfile[i] = pt[j--];

+	}

+

+	for (S32 i=0;i<(S32)mFaces.size();i++) 

+	{

+		if (mFaces[i].mCap)

+		{

+			mFaces[i].mCount *= 2;

+		}

+	}

+

+	return face;

+}

+

+

+

+BOOL LLProfile::generate(const LLProfileParams& params, BOOL path_open,F32 detail, S32 split,

+						 BOOL is_sculpted, S32 sculpt_size)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	if ((!mDirty) && (!is_sculpted))

+	{

+		return FALSE;

+	}

+	mDirty = FALSE;

+

+	if (detail < MIN_LOD)

+	{

+		llinfos << "Generating profile with LOD < MIN_LOD.  CLAMPING" << llendl;

+		detail = MIN_LOD;

+	}

+

+	mProfile.clear();

+	mFaces.clear();

+

+	// Generate the face data

+	S32 i;

+	F32 begin = params.getBegin();

+	F32 end = params.getEnd();

+	F32 hollow = params.getHollow();

+

+	// Quick validation to eliminate some server crashes.

+	if (begin > end - 0.01f)

+	{

+		llwarns << "LLProfile::generate() assertion failed (begin >= end)" << llendl;

+		return FALSE;

+	}

+

+	S32 face_num = 0;

+

+	switch (params.getCurveType() & LL_PCODE_PROFILE_MASK)

+	{

+	case LL_PCODE_PROFILE_SQUARE:

+		{

+			genNGon(params, 4,-0.375, 0, 1, split);

+			if (path_open)

+			{

+				addCap (LL_FACE_PATH_BEGIN);

+			}

+

+			for (i = llfloor(begin * 4.f); i < llfloor(end * 4.f + .999f); i++)

+			{

+				addFace((face_num++) * (split +1), split+2, 1, LL_FACE_OUTER_SIDE_0 << i, TRUE);

+			}

+

+			for (i = 0; i <(S32) mProfile.size(); i++)

+			{

+				// Scale by 4 to generate proper tex coords.

+				mProfile[i].mV[2] *= 4.f;

+			}

+

+			if (hollow)

+			{

+				switch (params.getCurveType() & LL_PCODE_HOLE_MASK)

+				{

+				case LL_PCODE_HOLE_TRIANGLE:

+					// This offset is not correct, but we can't change it now... DK 11/17/04

+				  	addHole(params, TRUE, 3, -0.375f, hollow, 1.f, split);

+					break;

+				case LL_PCODE_HOLE_CIRCLE:

+					// TODO: Compute actual detail levels for cubes

+				  	addHole(params, FALSE, MIN_DETAIL_FACES * detail, -0.375f, hollow, 1.f);

+					break;

+				case LL_PCODE_HOLE_SAME:

+				case LL_PCODE_HOLE_SQUARE:

+				default:

+					addHole(params, TRUE, 4, -0.375f, hollow, 1.f, split);

+					break;

+				}

+			}

+			

+			if (path_open) {

+				mFaces[0].mCount = mTotal;

+			}

+		}

+		break;

+	case  LL_PCODE_PROFILE_ISOTRI:

+	case  LL_PCODE_PROFILE_RIGHTTRI:

+	case  LL_PCODE_PROFILE_EQUALTRI:

+		{

+			genNGon(params, 3,0, 0, 1, split);

+			for (i = 0; i <(S32) mProfile.size(); i++)

+			{

+				// Scale by 3 to generate proper tex coords.

+				mProfile[i].mV[2] *= 3.f;

+			}

+

+			if (path_open)

+			{

+				addCap(LL_FACE_PATH_BEGIN);

+			}

+

+			for (i = llfloor(begin * 3.f); i < llfloor(end * 3.f + .999f); i++)

+			{

+				addFace((face_num++) * (split +1), split+2, 1, LL_FACE_OUTER_SIDE_0 << i, TRUE);

+			}

+			if (hollow)

+			{

+				// Swept triangles need smaller hollowness values,

+				// because the triangle doesn't fill the bounding box.

+				F32 triangle_hollow = hollow / 2.f;

+

+				switch (params.getCurveType() & LL_PCODE_HOLE_MASK)

+				{

+				case LL_PCODE_HOLE_CIRCLE:

+					// TODO: Actually generate level of detail for triangles

+					addHole(params, FALSE, MIN_DETAIL_FACES * detail, 0, triangle_hollow, 1.f);

+					break;

+				case LL_PCODE_HOLE_SQUARE:

+					addHole(params, TRUE, 4, 0, triangle_hollow, 1.f, split);

+					break;

+				case LL_PCODE_HOLE_SAME:

+				case LL_PCODE_HOLE_TRIANGLE:

+				default:

+					addHole(params, TRUE, 3, 0, triangle_hollow, 1.f, split);

+					break;

+				}

+			}

+		}

+		break;

+	case LL_PCODE_PROFILE_CIRCLE:

+		{

+			// If this has a square hollow, we should adjust the

+			// number of faces a bit so that the geometry lines up.

+			U8 hole_type=0;

+			F32 circle_detail = MIN_DETAIL_FACES * detail;

+			if (hollow)

+			{

+				hole_type = params.getCurveType() & LL_PCODE_HOLE_MASK;

+				if (hole_type == LL_PCODE_HOLE_SQUARE)

+				{

+					// Snap to the next multiple of four sides,

+					// so that corners line up.

+					circle_detail = llceil(circle_detail / 4.0f) * 4.0f;

+				}

+			}

+

+			S32 sides = (S32)circle_detail;

+

+			if (is_sculpted)

+				sides = sculpt_size;

+			

+			genNGon(params, sides);

+			

+			if (path_open)

+			{

+				addCap (LL_FACE_PATH_BEGIN);

+			}

+

+			if (mOpen && !hollow)

+			{

+				addFace(0,mTotal-1,0,LL_FACE_OUTER_SIDE_0, FALSE);

+			}

+			else

+			{

+				addFace(0,mTotal,0,LL_FACE_OUTER_SIDE_0, FALSE);

+			}

+

+			if (hollow)

+			{

+				switch (hole_type)

+				{

+				case LL_PCODE_HOLE_SQUARE:

+					addHole(params, TRUE, 4, 0, hollow, 1.f, split);

+					break;

+				case LL_PCODE_HOLE_TRIANGLE:

+					addHole(params, TRUE, 3, 0, hollow, 1.f, split);

+					break;

+				case LL_PCODE_HOLE_CIRCLE:

+				case LL_PCODE_HOLE_SAME:

+				default:

+					addHole(params, FALSE, circle_detail, 0, hollow, 1.f);

+					break;

+				}

+			}

+		}

+		break;

+	case LL_PCODE_PROFILE_CIRCLE_HALF:

+		{

+			// If this has a square hollow, we should adjust the

+			// number of faces a bit so that the geometry lines up.

+			U8 hole_type=0;

+			// Number of faces is cut in half because it's only a half-circle.

+			F32 circle_detail = MIN_DETAIL_FACES * detail * 0.5f;

+			if (hollow)

+			{

+				hole_type = params.getCurveType() & LL_PCODE_HOLE_MASK;

+				if (hole_type == LL_PCODE_HOLE_SQUARE)

+				{

+					// Snap to the next multiple of four sides (div 2),

+					// so that corners line up.

+					circle_detail = llceil(circle_detail / 2.0f) * 2.0f;

+				}

+			}

+			genNGon(params, llfloor(circle_detail), 0.5f, 0.f, 0.5f);

+			if (path_open)

+			{

+				addCap(LL_FACE_PATH_BEGIN);

+			}

+			if (mOpen && !params.getHollow())

+			{

+				addFace(0,mTotal-1,0,LL_FACE_OUTER_SIDE_0, FALSE);

+			}

+			else

+			{

+				addFace(0,mTotal,0,LL_FACE_OUTER_SIDE_0, FALSE);

+			}

+

+			if (hollow)

+			{

+				switch (hole_type)

+				{

+				case LL_PCODE_HOLE_SQUARE:

+					addHole(params, TRUE, 2, 0.5f, hollow, 0.5f, split);

+					break;

+				case LL_PCODE_HOLE_TRIANGLE:

+					addHole(params, TRUE, 3,  0.5f, hollow, 0.5f, split);

+					break;

+				case LL_PCODE_HOLE_CIRCLE:

+				case LL_PCODE_HOLE_SAME:

+				default:

+					addHole(params, FALSE, circle_detail,  0.5f, hollow, 0.5f);

+					break;

+				}

+			}

+

+			// Special case for openness of sphere

+			if ((params.getEnd() - params.getBegin()) < 1.f)

+			{

+				mOpen = TRUE;

+			}

+			else if (!hollow)

+			{

+				mOpen = FALSE;

+				mProfile.push_back(mProfile[0]);

+				mTotal++;

+			}

+		}

+		break;

+	default:

+	    llerrs << "Unknown profile: getCurveType()=" << params.getCurveType() << llendl;

+		break;

+	};

+

+	if (path_open)

+	{

+		addCap(LL_FACE_PATH_END); // bottom

+	}

+	

+	if ( mOpen) // interior edge caps

+	{

+		addFace(mTotal-1, 2,0.5,LL_FACE_PROFILE_BEGIN, TRUE); 

+

+		if (hollow)

+		{

+			addFace(mTotalOut-1, 2,0.5,LL_FACE_PROFILE_END, TRUE);

+		}

+		else

+		{

+			addFace(mTotal-2, 2,0.5,LL_FACE_PROFILE_END, TRUE);

+		}

+	}

+	

+	//genNormals(params);

+

+	return TRUE;

+}

+

+

+

+BOOL LLProfileParams::importFile(LLFILE *fp)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	const S32 BUFSIZE = 16384;

+	char buffer[BUFSIZE];	/* Flawfinder: ignore */

+	// *NOTE: changing the size or type of these buffers will require

+	// changing the sscanf below.

+	char keyword[256];	/* Flawfinder: ignore */

+	char valuestr[256];	/* Flawfinder: ignore */

+	keyword[0] = 0;

+	valuestr[0] = 0;

+	F32 tempF32;

+	U32 tempU32;

+

+	while (!feof(fp))

+	{

+		if (fgets(buffer, BUFSIZE, fp) == NULL)

+		{

+			buffer[0] = '\0';

+		}

+		

+		sscanf(	/* Flawfinder: ignore */

+			buffer,

+			" %255s %255s",

+			keyword, valuestr);

+		if (!strcmp("{", keyword))

+		{

+			continue;

+		}

+		if (!strcmp("}",keyword))

+		{

+			break;

+		}

+		else if (!strcmp("curve", keyword))

+		{

+			sscanf(valuestr,"%d",&tempU32);

+			setCurveType((U8) tempU32);

+		}

+		else if (!strcmp("begin",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setBegin(tempF32);

+		}

+		else if (!strcmp("end",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setEnd(tempF32);

+		}

+		else if (!strcmp("hollow",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setHollow(tempF32);

+		}

+		else

+		{

+			llwarns << "unknown keyword " << keyword << " in profile import" << llendl;

+		}

+	}

+

+	return TRUE;

+}

+

+

+BOOL LLProfileParams::exportFile(LLFILE *fp) const

+{

+	fprintf(fp,"\t\tprofile 0\n");

+	fprintf(fp,"\t\t{\n");

+	fprintf(fp,"\t\t\tcurve\t%d\n", getCurveType());

+	fprintf(fp,"\t\t\tbegin\t%g\n", getBegin());

+	fprintf(fp,"\t\t\tend\t%g\n", getEnd());

+	fprintf(fp,"\t\t\thollow\t%g\n", getHollow());

+	fprintf(fp, "\t\t}\n");

+	return TRUE;

+}

+

+

+BOOL LLProfileParams::importLegacyStream(std::istream& input_stream)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	const S32 BUFSIZE = 16384;

+	char buffer[BUFSIZE];	/* Flawfinder: ignore */

+	// *NOTE: changing the size or type of these buffers will require

+	// changing the sscanf below.

+	char keyword[256];	/* Flawfinder: ignore */

+	char valuestr[256];	/* Flawfinder: ignore */

+	keyword[0] = 0;

+	valuestr[0] = 0;

+	F32 tempF32;

+	U32 tempU32;

+

+	while (input_stream.good())

+	{

+		input_stream.getline(buffer, BUFSIZE);

+		sscanf(	/* Flawfinder: ignore */

+			buffer,

+			" %255s %255s",

+			keyword,

+			valuestr);

+		if (!strcmp("{", keyword))

+		{

+			continue;

+		}

+		if (!strcmp("}",keyword))

+		{

+			break;

+		}

+		else if (!strcmp("curve", keyword))

+		{

+			sscanf(valuestr,"%d",&tempU32);

+			setCurveType((U8) tempU32);

+		}

+		else if (!strcmp("begin",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setBegin(tempF32);

+		}

+		else if (!strcmp("end",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setEnd(tempF32);

+		}

+		else if (!strcmp("hollow",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setHollow(tempF32);

+		}

+		else

+		{

+ 		llwarns << "unknown keyword " << keyword << " in profile import" << llendl;

+		}

+	}

+

+	return TRUE;

+}

+

+

+BOOL LLProfileParams::exportLegacyStream(std::ostream& output_stream) const

+{

+	output_stream <<"\t\tprofile 0\n";

+	output_stream <<"\t\t{\n";

+	output_stream <<"\t\t\tcurve\t" << (S32) getCurveType() << "\n";

+	output_stream <<"\t\t\tbegin\t" << getBegin() << "\n";

+	output_stream <<"\t\t\tend\t" << getEnd() << "\n";

+	output_stream <<"\t\t\thollow\t" << getHollow() << "\n";

+	output_stream << "\t\t}\n";

+	return TRUE;

+}

+

+LLSD LLProfileParams::asLLSD() const

+{

+	LLSD sd;

+

+	sd["curve"] = getCurveType();

+	sd["begin"] = getBegin();

+	sd["end"] = getEnd();

+	sd["hollow"] = getHollow();

+	return sd;

+}

+

+bool LLProfileParams::fromLLSD(LLSD& sd)

+{

+	setCurveType(sd["curve"].asInteger());

+	setBegin((F32)sd["begin"].asReal());

+	setEnd((F32)sd["end"].asReal());

+	setHollow((F32)sd["hollow"].asReal());

+	return true;

+}

+

+void LLProfileParams::copyParams(const LLProfileParams &params)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	setCurveType(params.getCurveType());

+	setBegin(params.getBegin());

+	setEnd(params.getEnd());

+	setHollow(params.getHollow());

+}

+

+

+LLPath::~LLPath()

+{

+}

+

+void LLPath::genNGon(const LLPathParams& params, S32 sides, F32 startOff, F32 end_scale, F32 twist_scale)

+{

+	// Generates a circular path, starting at (1, 0, 0), counterclockwise along the xz plane.

+	const F32 tableScale[] = { 1, 1, 1, 0.5f, 0.707107f, 0.53f, 0.525f, 0.5f };

+

+	F32 revolutions = params.getRevolutions();

+	F32 skew		= params.getSkew();

+	F32 skew_mag	= fabs(skew);

+	F32 hole_x		= params.getScaleX() * (1.0f - skew_mag);

+	F32 hole_y		= params.getScaleY();

+

+	// Calculate taper begin/end for x,y (Negative means taper the beginning)

+	F32 taper_x_begin	= 1.0f;

+	F32 taper_x_end		= 1.0f - params.getTaperX();

+	F32	taper_y_begin	= 1.0f;

+	F32	taper_y_end		= 1.0f - params.getTaperY();

+

+	if ( taper_x_end > 1.0f )

+	{

+		// Flip tapering.

+		taper_x_begin	= 2.0f - taper_x_end;

+		taper_x_end		= 1.0f;

+	}

+	if ( taper_y_end > 1.0f )

+	{

+		// Flip tapering.

+		taper_y_begin	= 2.0f - taper_y_end;

+		taper_y_end		= 1.0f;

+	}

+

+	// For spheres, the radius is usually zero.

+	F32 radius_start = 0.5f;

+	if (sides < 8)

+	{

+		radius_start = tableScale[sides];

+	}

+

+	// Scale the radius to take the hole size into account.

+	radius_start *= 1.0f - hole_y;

+	

+	// Now check the radius offset to calculate the start,end radius.  (Negative means

+	// decrease the start radius instead).

+	F32 radius_end    = radius_start;

+	F32 radius_offset = params.getRadiusOffset();

+	if (radius_offset < 0.f)

+	{

+		radius_start *= 1.f + radius_offset;

+	}

+	else

+	{

+		radius_end   *= 1.f - radius_offset;

+	}	

+

+	// Is the path NOT a closed loop?

+	mOpen = ( (params.getEnd()*end_scale - params.getBegin() < 1.0f) ||

+		      (skew_mag > 0.001f) ||

+			  (fabs(taper_x_end - taper_x_begin) > 0.001f) ||

+			  (fabs(taper_y_end - taper_y_begin) > 0.001f) ||

+			  (fabs(radius_end - radius_start) > 0.001f) );

+

+	F32 ang, c, s;

+	LLQuaternion twist, qang;

+	PathPt *pt;

+	LLVector3 path_axis (1.f, 0.f, 0.f);

+	//LLVector3 twist_axis(0.f, 0.f, 1.f);

+	F32 twist_begin = params.getTwistBegin() * twist_scale;

+	F32 twist_end	= params.getTwist() * twist_scale;

+

+	// We run through this once before the main loop, to make sure

+	// the path begins at the correct cut.

+	F32 step= 1.0f / sides;

+	F32 t	= params.getBegin();

+	pt		= vector_append(mPath, 1);

+	ang		= 2.0f*F_PI*revolutions * t;

+	s		= sin(ang)*lerp(radius_start, radius_end, t);	

+	c		= cos(ang)*lerp(radius_start, radius_end, t);

+

+

+	pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s)

+					  + lerp(-skew ,skew, t) * 0.5f,

+					c + lerp(0,params.getShear().mV[1],s), 

+					s);

+	pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t);

+	pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t);

+	pt->mTexT  = t;

+	

+	// Twist rotates the path along the x,y plane (I think) - DJS 04/05/02

+	twist.setQuat  (lerp(twist_begin,twist_end,t) * 2.f * F_PI - F_PI,0,0,1);

+	// Rotate the point around the circle's center.

+	qang.setQuat   (ang,path_axis);

+	pt->mRot   = twist * qang;

+

+	t+=step;

+

+	// Snap to a quantized parameter, so that cut does not

+	// affect most sample points.

+	t = ((S32)(t * sides)) / (F32)sides;

+

+	// Run through the non-cut dependent points.

+	while (t < params.getEnd())

+	{

+		pt		= vector_append(mPath, 1);

+

+		ang = 2.0f*F_PI*revolutions * t;

+		c   = cos(ang)*lerp(radius_start, radius_end, t);

+		s   = sin(ang)*lerp(radius_start, radius_end, t);

+

+		pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s)

+					      + lerp(-skew ,skew, t) * 0.5f,

+						c + lerp(0,params.getShear().mV[1],s), 

+						s);

+

+		pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t);

+		pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t);

+		pt->mTexT  = t;

+

+		// Twist rotates the path along the x,y plane (I think) - DJS 04/05/02

+		twist.setQuat  (lerp(twist_begin,twist_end,t) * 2.f * F_PI - F_PI,0,0,1);

+		// Rotate the point around the circle's center.

+		qang.setQuat   (ang,path_axis);

+		pt->mRot	= twist * qang;

+

+		t+=step;

+	}

+

+	// Make one final pass for the end cut.

+	t = params.getEnd();

+	pt		= vector_append(mPath, 1);

+	ang = 2.0f*F_PI*revolutions * t;

+	c   = cos(ang)*lerp(radius_start, radius_end, t);

+	s   = sin(ang)*lerp(radius_start, radius_end, t);

+

+	pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s)

+					  + lerp(-skew ,skew, t) * 0.5f,

+					c + lerp(0,params.getShear().mV[1],s), 

+					s);

+	pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t);

+	pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t);

+	pt->mTexT  = t;

+	

+	// Twist rotates the path along the x,y plane (I think) - DJS 04/05/02

+	twist.setQuat  (lerp(twist_begin,twist_end,t) * 2.f * F_PI - F_PI,0,0,1);

+	// Rotate the point around the circle's center.

+	qang.setQuat   (ang,path_axis);

+	pt->mRot   = twist * qang;

+

+	mTotal = mPath.size();

+}

+

+const LLVector2 LLPathParams::getBeginScale() const

+{

+	LLVector2 begin_scale(1.f, 1.f);

+	if (getScaleX() > 1)

+	{

+		begin_scale.mV[0] = 2-getScaleX();

+	}

+	if (getScaleY() > 1)

+	{

+		begin_scale.mV[1] = 2-getScaleY();

+	}

+	return begin_scale;

+}

+

+const LLVector2 LLPathParams::getEndScale() const

+{

+	LLVector2 end_scale(1.f, 1.f);

+	if (getScaleX() < 1)

+	{

+		end_scale.mV[0] = getScaleX();

+	}

+	if (getScaleY() < 1)

+	{

+		end_scale.mV[1] = getScaleY();

+	}

+	return end_scale;

+}

+

+BOOL LLPath::generate(const LLPathParams& params, F32 detail, S32 split,

+					  BOOL is_sculpted, S32 sculpt_size)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	if ((!mDirty) && (!is_sculpted))

+	{

+		return FALSE;

+	}

+

+	if (detail < MIN_LOD)

+	{

+		llinfos << "Generating path with LOD < MIN!  Clamping to 1" << llendl;

+		detail = MIN_LOD;

+	}

+

+	mDirty = FALSE;

+	S32 np = 2; // hardcode for line

+

+	mPath.clear();

+	mOpen = TRUE;

+

+	// Is this 0xf0 mask really necessary?  DK 03/02/05

+	switch (params.getCurveType() & 0xf0)

+	{

+	default:

+	case LL_PCODE_PATH_LINE:

+		{

+			// Take the begin/end twist into account for detail.

+			np    = llfloor(fabs(params.getTwistBegin() - params.getTwist()) * 3.5f * (detail-0.5f)) + 2;

+			if (np < split+2)

+			{

+				np = split+2;

+			}

+

+			mStep = 1.0f / (np-1);

+			

+			mPath.resize(np);

+

+			LLVector2 start_scale = params.getBeginScale();

+			LLVector2 end_scale = params.getEndScale();

+

+			for (S32 i=0;i<np;i++)

+			{

+				F32 t = lerp(params.getBegin(),params.getEnd(),(F32)i * mStep);

+				mPath[i].mPos.setVec(lerp(0,params.getShear().mV[0],t),

+									 lerp(0,params.getShear().mV[1],t),

+									 t - 0.5f);

+				mPath[i].mRot.setQuat(lerp(F_PI * params.getTwistBegin(),F_PI * params.getTwist(),t),0,0,1);

+				mPath[i].mScale.mV[0] = lerp(start_scale.mV[0],end_scale.mV[0],t);

+				mPath[i].mScale.mV[1] = lerp(start_scale.mV[1],end_scale.mV[1],t);

+				mPath[i].mTexT        = t;

+			}

+		}

+		break;

+

+	case LL_PCODE_PATH_CIRCLE:

+		{

+			// Increase the detail as the revolutions and twist increase.

+			F32 twist_mag = fabs(params.getTwistBegin() - params.getTwist());

+

+			S32 sides = (S32)llfloor(llfloor((MIN_DETAIL_FACES * detail + twist_mag * 3.5f * (detail-0.5f))) * params.getRevolutions());

+

+			if (is_sculpted)

+				sides = sculpt_size;

+			

+			genNGon(params, sides);

+		}

+		break;

+

+	case LL_PCODE_PATH_CIRCLE2:

+		{

+			if (params.getEnd() - params.getBegin() >= 0.99f &&

+				params.getScaleX() >= .99f)

+			{

+				mOpen = FALSE;

+			}

+

+			//genNGon(params, llfloor(MIN_DETAIL_FACES * detail), 4.f, 0.f);

+			genNGon(params, llfloor(MIN_DETAIL_FACES * detail));

+

+			F32 t     = 0.f;

+			F32 tStep = 1.0f / mPath.size();

+

+			F32 toggle = 0.5f;

+			for (S32 i=0;i<(S32)mPath.size();i++)

+			{

+				mPath[i].mPos.mV[0] = toggle;

+				if (toggle == 0.5f)

+					toggle = -0.5f;

+				else

+					toggle = 0.5f;

+				t += tStep;

+			}

+		}

+

+		break;

+

+	case LL_PCODE_PATH_TEST:

+

+		np     = 5;

+		mStep = 1.0f / (np-1);

+		

+		mPath.resize(np);

+

+		for (S32 i=0;i<np;i++)

+		{

+			F32 t = (F32)i * mStep;

+			mPath[i].mPos.setVec(0,

+								lerp(0,   -sin(F_PI*params.getTwist()*t)*0.5f,t),

+								lerp(-0.5, cos(F_PI*params.getTwist()*t)*0.5f,t));

+			mPath[i].mScale.mV[0] = lerp(1,params.getScale().mV[0],t);

+			mPath[i].mScale.mV[1] = lerp(1,params.getScale().mV[1],t);

+			mPath[i].mTexT  = t;

+			mPath[i].mRot.setQuat(F_PI * params.getTwist() * t,1,0,0);

+		}

+

+		break;

+	};

+

+	if (params.getTwist() != params.getTwistBegin()) mOpen = TRUE;

+

+	//if ((int(fabsf(params.getTwist() - params.getTwistBegin())*100))%100 != 0) {

+	//	mOpen = TRUE;

+	//}

+	

+	return TRUE;

+}

+

+BOOL LLDynamicPath::generate(const LLPathParams& params, F32 detail, S32 split,

+							 BOOL is_sculpted, S32 sculpt_size)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	mOpen = TRUE; // Draw end caps

+	if (getPathLength() == 0)

+	{

+		// Path hasn't been generated yet.

+		// Some algorithms later assume at least TWO path points.

+		resizePath(2);

+		for (U32 i = 0; i < 2; i++)

+		{

+			mPath[i].mPos.setVec(0, 0, 0);

+			mPath[i].mRot.setQuat(0, 0, 0);

+			mPath[i].mScale.setVec(1, 1);

+			mPath[i].mTexT = 0;

+		}

+	}

+

+	return TRUE;

+}

+

+

+BOOL LLPathParams::importFile(LLFILE *fp)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	const S32 BUFSIZE = 16384;

+	char buffer[BUFSIZE];	/* Flawfinder: ignore */

+	// *NOTE: changing the size or type of these buffers will require

+	// changing the sscanf below.

+	char keyword[256];	/* Flawfinder: ignore */

+	char valuestr[256];	/* Flawfinder: ignore */

+	keyword[0] = 0;

+	valuestr[0] = 0;

+

+	F32 tempF32;

+	F32 x, y;

+	U32 tempU32;

+

+	while (!feof(fp))

+	{

+		if (fgets(buffer, BUFSIZE, fp) == NULL)

+		{

+			buffer[0] = '\0';

+		}

+		

+		sscanf(	/* Flawfinder: ignore */

+			buffer,

+			" %255s %255s",

+			keyword, valuestr);

+		if (!strcmp("{", keyword))

+		{

+			continue;

+		}

+		if (!strcmp("}",keyword))

+		{

+			break;

+		}

+		else if (!strcmp("curve", keyword))

+		{

+			sscanf(valuestr,"%d",&tempU32);

+			setCurveType((U8) tempU32);

+		}

+		else if (!strcmp("begin",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setBegin(tempF32);

+		}

+		else if (!strcmp("end",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setEnd(tempF32);

+		}

+		else if (!strcmp("scale",keyword))

+		{

+			// Legacy for one dimensional scale per path

+			sscanf(valuestr,"%g",&tempF32);

+			setScale(tempF32, tempF32);

+		}

+		else if (!strcmp("scale_x", keyword))

+		{

+			sscanf(valuestr, "%g", &x);

+			setScaleX(x);

+		}

+		else if (!strcmp("scale_y", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setScaleY(y);

+		}

+		else if (!strcmp("shear_x", keyword))

+		{

+			sscanf(valuestr, "%g", &x);

+			setShearX(x);

+		}

+		else if (!strcmp("shear_y", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setShearY(y);

+		}

+		else if (!strcmp("twist",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setTwist(tempF32);

+		}

+		else if (!strcmp("twist_begin", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setTwistBegin(y);

+		}

+		else if (!strcmp("radius_offset", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setRadiusOffset(y);

+		}

+		else if (!strcmp("taper_x", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setTaperX(y);

+		}

+		else if (!strcmp("taper_y", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setTaperY(y);

+		}

+		else if (!strcmp("revolutions", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setRevolutions(y);

+		}

+		else if (!strcmp("skew", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setSkew(y);

+		}

+		else

+		{

+			llwarns << "unknown keyword " << " in path import" << llendl;

+		}

+	}

+	return TRUE;

+}

+

+

+BOOL LLPathParams::exportFile(LLFILE *fp) const

+{

+	fprintf(fp, "\t\tpath 0\n");

+	fprintf(fp, "\t\t{\n");

+	fprintf(fp, "\t\t\tcurve\t%d\n", getCurveType());

+	fprintf(fp, "\t\t\tbegin\t%g\n", getBegin());

+	fprintf(fp, "\t\t\tend\t%g\n", getEnd());

+	fprintf(fp, "\t\t\tscale_x\t%g\n", getScaleX() );

+	fprintf(fp, "\t\t\tscale_y\t%g\n", getScaleY() );

+	fprintf(fp, "\t\t\tshear_x\t%g\n", getShearX() );

+	fprintf(fp, "\t\t\tshear_y\t%g\n", getShearY() );

+	fprintf(fp,"\t\t\ttwist\t%g\n", getTwist());

+	

+	fprintf(fp,"\t\t\ttwist_begin\t%g\n", getTwistBegin());

+	fprintf(fp,"\t\t\tradius_offset\t%g\n", getRadiusOffset());

+	fprintf(fp,"\t\t\ttaper_x\t%g\n", getTaperX());

+	fprintf(fp,"\t\t\ttaper_y\t%g\n", getTaperY());

+	fprintf(fp,"\t\t\trevolutions\t%g\n", getRevolutions());

+	fprintf(fp,"\t\t\tskew\t%g\n", getSkew());

+

+	fprintf(fp, "\t\t}\n");

+	return TRUE;

+}

+

+

+BOOL LLPathParams::importLegacyStream(std::istream& input_stream)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	const S32 BUFSIZE = 16384;

+	char buffer[BUFSIZE];	/* Flawfinder: ignore */

+	// *NOTE: changing the size or type of these buffers will require

+	// changing the sscanf below.

+	char keyword[256];	/* Flawfinder: ignore */

+	char valuestr[256];	/* Flawfinder: ignore */

+	keyword[0] = 0;

+	valuestr[0] = 0;

+

+	F32 tempF32;

+	F32 x, y;

+	U32 tempU32;

+

+	while (input_stream.good())

+	{

+		input_stream.getline(buffer, BUFSIZE);

+		sscanf(	/* Flawfinder: ignore */

+			buffer,

+			" %255s %255s",

+			keyword, valuestr);

+		if (!strcmp("{", keyword))

+		{

+			continue;

+		}

+		if (!strcmp("}",keyword))

+		{

+			break;

+		}

+		else if (!strcmp("curve", keyword))

+		{

+			sscanf(valuestr,"%d",&tempU32);

+			setCurveType((U8) tempU32);

+		}

+		else if (!strcmp("begin",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setBegin(tempF32);

+		}

+		else if (!strcmp("end",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setEnd(tempF32);

+		}

+		else if (!strcmp("scale",keyword))

+		{

+			// Legacy for one dimensional scale per path

+			sscanf(valuestr,"%g",&tempF32);

+			setScale(tempF32, tempF32);

+		}

+		else if (!strcmp("scale_x", keyword))

+		{

+			sscanf(valuestr, "%g", &x);

+			setScaleX(x);

+		}

+		else if (!strcmp("scale_y", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setScaleY(y);

+		}

+		else if (!strcmp("shear_x", keyword))

+		{

+			sscanf(valuestr, "%g", &x);

+			setShearX(x);

+		}

+		else if (!strcmp("shear_y", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setShearY(y);

+		}

+		else if (!strcmp("twist",keyword))

+		{

+			sscanf(valuestr,"%g",&tempF32);

+			setTwist(tempF32);

+		}

+		else if (!strcmp("twist_begin", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setTwistBegin(y);

+		}

+		else if (!strcmp("radius_offset", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setRadiusOffset(y);

+		}

+		else if (!strcmp("taper_x", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setTaperX(y);

+		}

+		else if (!strcmp("taper_y", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setTaperY(y);

+		}

+		else if (!strcmp("revolutions", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setRevolutions(y);

+		}

+		else if (!strcmp("skew", keyword))

+		{

+			sscanf(valuestr, "%g", &y);

+			setSkew(y);

+		}

+		else

+		{

+			llwarns << "unknown keyword " << " in path import" << llendl;

+		}

+	}

+	return TRUE;

+}

+

+

+BOOL LLPathParams::exportLegacyStream(std::ostream& output_stream) const

+{

+	output_stream << "\t\tpath 0\n";

+	output_stream << "\t\t{\n";

+	output_stream << "\t\t\tcurve\t" << (S32) getCurveType() << "\n";

+	output_stream << "\t\t\tbegin\t" << getBegin() << "\n";

+	output_stream << "\t\t\tend\t" << getEnd() << "\n";

+	output_stream << "\t\t\tscale_x\t" << getScaleX()  << "\n";

+	output_stream << "\t\t\tscale_y\t" << getScaleY()  << "\n";

+	output_stream << "\t\t\tshear_x\t" << getShearX()  << "\n";

+	output_stream << "\t\t\tshear_y\t" << getShearY()  << "\n";

+	output_stream <<"\t\t\ttwist\t" << getTwist() << "\n";

+	

+	output_stream <<"\t\t\ttwist_begin\t" << getTwistBegin() << "\n";

+	output_stream <<"\t\t\tradius_offset\t" << getRadiusOffset() << "\n";

+	output_stream <<"\t\t\ttaper_x\t" << getTaperX() << "\n";

+	output_stream <<"\t\t\ttaper_y\t" << getTaperY() << "\n";

+	output_stream <<"\t\t\trevolutions\t" << getRevolutions() << "\n";

+	output_stream <<"\t\t\tskew\t" << getSkew() << "\n";

+

+	output_stream << "\t\t}\n";

+	return TRUE;

+}

+

+LLSD LLPathParams::asLLSD() const

+{

+	LLSD sd = LLSD();

+	sd["curve"] = getCurveType();

+	sd["begin"] = getBegin();

+	sd["end"] = getEnd();

+	sd["scale_x"] = getScaleX();

+	sd["scale_y"] = getScaleY();

+	sd["shear_x"] = getShearX();

+	sd["shear_y"] = getShearY();

+	sd["twist"] = getTwist();

+	sd["twist_begin"] = getTwistBegin();

+	sd["radius_offset"] = getRadiusOffset();

+	sd["taper_x"] = getTaperX();

+	sd["taper_y"] = getTaperY();

+	sd["revolutions"] = getRevolutions();

+	sd["skew"] = getSkew();

+

+	return sd;

+}

+

+bool LLPathParams::fromLLSD(LLSD& sd)

+{

+	setCurveType(sd["curve"].asInteger());

+	setBegin((F32)sd["begin"].asReal());

+	setEnd((F32)sd["end"].asReal());

+	setScaleX((F32)sd["scale_x"].asReal());

+	setScaleY((F32)sd["scale_y"].asReal());

+	setShearX((F32)sd["shear_x"].asReal());

+	setShearY((F32)sd["shear_y"].asReal());

+	setTwist((F32)sd["twist"].asReal());

+	setTwistBegin((F32)sd["twist_begin"].asReal());

+	setRadiusOffset((F32)sd["radius_offset"].asReal());

+	setTaperX((F32)sd["taper_x"].asReal());

+	setTaperY((F32)sd["taper_y"].asReal());

+	setRevolutions((F32)sd["revolutions"].asReal());

+	setSkew((F32)sd["skew"].asReal());

+	return true;

+}

+

+void LLPathParams::copyParams(const LLPathParams &params)

+{

+	setCurveType(params.getCurveType());

+	setBegin(params.getBegin());

+	setEnd(params.getEnd());

+	setScale(params.getScaleX(), params.getScaleY() );

+	setShear(params.getShearX(), params.getShearY() );

+	setTwist(params.getTwist());

+	setTwistBegin(params.getTwistBegin());

+	setRadiusOffset(params.getRadiusOffset());

+	setTaper( params.getTaperX(), params.getTaperY() );

+	setRevolutions(params.getRevolutions());

+	setSkew(params.getSkew());

+}

+

+S32 profile_delete_lock = 1 ; 

+LLProfile::~LLProfile()

+{

+	if(profile_delete_lock)

+	{

+		llerrs << "LLProfile should not be deleted here!" << llendl ;

+	}

+}

+

+

+S32 LLVolume::sNumMeshPoints = 0;

+

+LLVolume::LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL generate_single_face, const BOOL is_unique)

+	: mParams(params)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	mUnique = is_unique;

+	mFaceMask = 0x0;

+	mDetail = detail;

+	mSculptLevel = -2;

+	mIsTetrahedron = FALSE;

+	mLODScaleBias.setVec(1,1,1);

+	mHullPoints = NULL;

+	mHullIndices = NULL;

+	mNumHullPoints = 0;

+	mNumHullIndices = 0;

+

+	// set defaults

+	if (mParams.getPathParams().getCurveType() == LL_PCODE_PATH_FLEXIBLE)

+	{

+		mPathp = new LLDynamicPath();

+	}

+	else

+	{

+		mPathp = new LLPath();

+	}

+	mProfilep = new LLProfile();

+

+	mGenerateSingleFace = generate_single_face;

+

+	generate();

+	

+	if (mParams.getSculptID().isNull() && mParams.getSculptType() == LL_SCULPT_TYPE_NONE)

+	{

+		createVolumeFaces();

+	}

+}

+

+void LLVolume::resizePath(S32 length)

+{

+	mPathp->resizePath(length);

+	mVolumeFaces.clear();

+}

+

+void LLVolume::regen()

+{

+	generate();

+	createVolumeFaces();

+}

+

+void LLVolume::genBinormals(S32 face)

+{

+	mVolumeFaces[face].createBinormals();

+}

+

+LLVolume::~LLVolume()

+{

+	sNumMeshPoints -= mMesh.size();

+	delete mPathp;

+

+	profile_delete_lock = 0 ;

+	delete mProfilep;

+	profile_delete_lock = 1 ;

+

+	mPathp = NULL;

+	mProfilep = NULL;

+	mVolumeFaces.clear();

+

+	free(mHullPoints);

+	mHullPoints = NULL;

+	free(mHullIndices);

+	mHullIndices = NULL;

+}

+

+BOOL LLVolume::generate()

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	llassert_always(mProfilep);

+	

+	//Added 10.03.05 Dave Parks

+	// Split is a parameter to LLProfile::generate that tesselates edges on the profile 

+	// to prevent lighting and texture interpolation errors on triangles that are 

+	// stretched due to twisting or scaling on the path.  

+	S32 split = (S32) ((mDetail)*0.66f);

+	

+	if (mParams.getPathParams().getCurveType() == LL_PCODE_PATH_LINE &&

+		(mParams.getPathParams().getScale().mV[0] != 1.0f ||

+		 mParams.getPathParams().getScale().mV[1] != 1.0f) &&

+		(mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_SQUARE ||

+		 mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_ISOTRI ||

+		 mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_EQUALTRI ||

+		 mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_RIGHTTRI))

+	{

+		split = 0;

+	}

+		 

+	mLODScaleBias.setVec(0.5f, 0.5f, 0.5f);

+	

+	F32 profile_detail = mDetail;

+	F32 path_detail = mDetail;

+	

+	U8 path_type = mParams.getPathParams().getCurveType();

+	U8 profile_type = mParams.getProfileParams().getCurveType();

+	

+	if (path_type == LL_PCODE_PATH_LINE && profile_type == LL_PCODE_PROFILE_CIRCLE)

+	{ //cylinders don't care about Z-Axis

+		mLODScaleBias.setVec(0.6f, 0.6f, 0.0f);

+	}

+	else if (path_type == LL_PCODE_PATH_CIRCLE) 

+	{	

+		mLODScaleBias.setVec(0.6f, 0.6f, 0.6f);

+	}

+	

+	//********************************************************************

+	//debug info, to be removed

+	if((U32)(mPathp->mPath.size() * mProfilep->mProfile.size()) > (1u << 20))

+	{

+		llinfos << "sizeS: " << mPathp->mPath.size() << " sizeT: " << mProfilep->mProfile.size() << llendl ;

+		llinfos << "path_detail : " << path_detail << " split: " << split << " profile_detail: " << profile_detail << llendl ;

+		llinfos << mParams << llendl ;

+		llinfos << "more info to check if mProfilep is deleted or not." << llendl ;

+		llinfos << mProfilep->mNormals.size() << " : " << mProfilep->mFaces.size() << " : " << mProfilep->mEdgeNormals.size() << " : " << mProfilep->mEdgeCenters.size() << llendl ;

+

+		llerrs << "LLVolume corrupted!" << llendl ;

+	}

+	//********************************************************************

+

+	BOOL regenPath = mPathp->generate(mParams.getPathParams(), path_detail, split);

+	BOOL regenProf = mProfilep->generate(mParams.getProfileParams(), mPathp->isOpen(),profile_detail, split);

+

+	if (regenPath || regenProf ) 

+	{

+		S32 sizeS = mPathp->mPath.size();

+		S32 sizeT = mProfilep->mProfile.size();

+

+		//********************************************************************

+		//debug info, to be removed

+		if((U32)(sizeS * sizeT) > (1u << 20))

+		{

+			llinfos << "regenPath: " << (S32)regenPath << " regenProf: " << (S32)regenProf << llendl ;

+			llinfos << "sizeS: " << sizeS << " sizeT: " << sizeT << llendl ;

+			llinfos << "path_detail : " << path_detail << " split: " << split << " profile_detail: " << profile_detail << llendl ;

+			llinfos << mParams << llendl ;

+			llinfos << "more info to check if mProfilep is deleted or not." << llendl ;

+			llinfos << mProfilep->mNormals.size() << " : " << mProfilep->mFaces.size() << " : " << mProfilep->mEdgeNormals.size() << " : " << mProfilep->mEdgeCenters.size() << llendl ;

+

+			llerrs << "LLVolume corrupted!" << llendl ;

+		}

+		//********************************************************************

+

+		sNumMeshPoints -= mMesh.size();

+		mMesh.resize(sizeT * sizeS);

+		sNumMeshPoints += mMesh.size();		

+

+		//generate vertex positions

+

+		// Run along the path.

+		for (S32 s = 0; s < sizeS; ++s)

+		{

+			LLVector2  scale = mPathp->mPath[s].mScale;

+			LLQuaternion rot = mPathp->mPath[s].mRot;

+

+			// Run along the profile.

+			for (S32 t = 0; t < sizeT; ++t)

+			{

+				S32 m = s*sizeT + t;

+				Point& pt = mMesh[m];

+				

+				pt.mPos.mV[0] = mProfilep->mProfile[t].mV[0] * scale.mV[0];

+				pt.mPos.mV[1] = mProfilep->mProfile[t].mV[1] * scale.mV[1];

+				pt.mPos.mV[2] = 0.0f;

+				pt.mPos       = pt.mPos * rot;

+				pt.mPos      += mPathp->mPath[s].mPos;

+			}

+		}

+

+		for (std::vector<LLProfile::Face>::iterator iter = mProfilep->mFaces.begin();

+			 iter != mProfilep->mFaces.end(); ++iter)

+		{

+			LLFaceID id = iter->mFaceID;

+			mFaceMask |= id;

+		}

+		

+		return TRUE;

+	}

+	return FALSE;

+}

+

+void LLVolumeFace::VertexData::init()

+{

+	if (!mData)

+	{

+		mData = (LLVector4a*) malloc(sizeof(LLVector4a)*2);

+	}

+}

+

+LLVolumeFace::VertexData::VertexData()

+{

+	mData = NULL;

+	init();

+}

+	

+LLVolumeFace::VertexData::VertexData(const VertexData& rhs)

+{

+	mData = NULL;

+	*this = rhs;

+}

+

+const LLVolumeFace::VertexData& LLVolumeFace::VertexData::operator=(const LLVolumeFace::VertexData& rhs)

+{

+	if (this != &rhs)

+	{

+		init();

+		LLVector4a::memcpyNonAliased16((F32*) mData, (F32*) rhs.mData, 2*sizeof(LLVector4a));

+		mTexCoord = rhs.mTexCoord;

+	}

+	return *this;

+}

+

+LLVolumeFace::VertexData::~VertexData()

+{

+	free(mData);

+	mData = NULL;

+}

+

+LLVector4a& LLVolumeFace::VertexData::getPosition()

+{

+	return mData[POSITION];

+}

+

+LLVector4a& LLVolumeFace::VertexData::getNormal()

+{

+	return mData[NORMAL];

+}

+

+const LLVector4a& LLVolumeFace::VertexData::getPosition() const

+{

+	return mData[POSITION];

+}

+

+const LLVector4a& LLVolumeFace::VertexData::getNormal() const

+{

+	return mData[NORMAL];

+}

+

+

+void LLVolumeFace::VertexData::setPosition(const LLVector4a& pos)

+{

+	mData[POSITION] = pos;

+}

+

+void LLVolumeFace::VertexData::setNormal(const LLVector4a& norm)

+{

+	mData[NORMAL] = norm;

+}

+

+bool LLVolumeFace::VertexData::operator<(const LLVolumeFace::VertexData& rhs)const

+{

+	const F32* lp = this->getPosition().getF32ptr();

+	const F32* rp = rhs.getPosition().getF32ptr();

+

+	if (lp[0] != rp[0])

+	{

+		return lp[0] < rp[0];

+	}

+

+	if (rp[1] != lp[1])

+	{

+		return lp[1] < rp[1];

+	}

+

+	if (rp[2] != lp[2])

+	{

+		return lp[2] < rp[2];

+	}

+

+	lp = getNormal().getF32ptr();

+	rp = rhs.getNormal().getF32ptr();

+

+	if (lp[0] != rp[0])

+	{

+		return lp[0] < rp[0];

+	}

+

+	if (rp[1] != lp[1])

+	{

+		return lp[1] < rp[1];

+	}

+

+	if (rp[2] != lp[2])

+	{

+		return lp[2] < rp[2];

+	}

+

+	if (mTexCoord.mV[0] != rhs.mTexCoord.mV[0])

+	{

+		return mTexCoord.mV[0] < rhs.mTexCoord.mV[0];

+	}

+

+	return mTexCoord.mV[1] < rhs.mTexCoord.mV[1];

+}

+

+bool LLVolumeFace::VertexData::operator==(const LLVolumeFace::VertexData& rhs)const

+{

+	return mData[POSITION].equals3(rhs.getPosition()) &&

+			mData[NORMAL].equals3(rhs.getNormal()) &&

+			mTexCoord == rhs.mTexCoord;

+}

+

+bool LLVolumeFace::VertexData::compareNormal(const LLVolumeFace::VertexData& rhs, F32 angle_cutoff) const

+{

+	bool retval = false;

+	if (rhs.mData[POSITION].equals3(mData[POSITION]) && rhs.mTexCoord == mTexCoord)

+	{

+		if (angle_cutoff > 1.f)

+		{

+			retval = (mData[NORMAL].equals3(rhs.mData[NORMAL]));

+		}

+		else

+		{

+			F32 cur_angle = rhs.mData[NORMAL].dot3(mData[NORMAL]).getF32();

+			retval = cur_angle > angle_cutoff;

+		}

+	}

+

+	return retval;

+}

+

+bool LLVolume::unpackVolumeFaces(std::istream& is, S32 size)

+{

+	//input stream is now pointing at a zlib compressed block of LLSD

+	//decompress block

+	LLSD mdl;

+	if (!unzip_llsd(mdl, is, size))

+	{

+		llwarns << "not a valid mesh asset!" << llendl;

+		return false;

+	}

+	

+	{

+		U32 face_count = mdl.size();

+

+		if (face_count == 0)

+		{

+			llerrs << "WTF?" << llendl;

+		}

+

+		mVolumeFaces.resize(face_count);

+

+		for (U32 i = 0; i < face_count; ++i)

+		{

+			LLSD::Binary pos = mdl[i]["Position"];

+			LLSD::Binary norm = mdl[i]["Normal"];

+			LLSD::Binary tc = mdl[i]["TexCoord0"];

+			LLSD::Binary idx = mdl[i]["TriangleList"];

+

+			LLVolumeFace& face = mVolumeFaces[i];

+

+			//copy out indices

+			face.resizeIndices(idx.size()/2);

+			

+			if (idx.empty() || face.mNumIndices < 3)

+			{ //why is there an empty index list?

+				llerrs <<"WTF?" << llendl;

+				continue;

+			}

+

+			U16* indices = (U16*) &(idx[0]);

+			for (U32 j = 0; j < idx.size()/2; ++j)

+			{

+				face.mIndices[j] = indices[j];

+			}

+

+			//copy out vertices

+			U32 num_verts = pos.size()/(3*2);

+			face.resizeVertices(num_verts);

+

+			if (mdl[i].has("Weights"))

+			{

+				face.allocateWeights(num_verts);

+

+				LLSD::Binary weights = mdl[i]["Weights"];

+

+				U32 idx = 0;

+

+				U32 cur_vertex = 0;

+				while (idx < weights.size() && cur_vertex < num_verts)

+				{

+					const U8 END_INFLUENCES = 0xFF;

+					U8 joint = weights[idx++];

+

+					U32 cur_influence = 0;

+					LLVector4 wght(0,0,0,0);

+

+					while (joint != END_INFLUENCES && idx < weights.size())

+					{

+						U16 influence = weights[idx++];

+						influence |= ((U16) weights[idx++] << 8);

+

+						F32 w = llclamp((F32) influence / 65535.f, 0.f, 0.99999f);

+						wght.mV[cur_influence++] = (F32) joint + w;

+

+						if (cur_influence >= 4)

+						{

+							joint = END_INFLUENCES;

+						}

+						else

+						{

+							joint = weights[idx++];

+						}

+					}

+

+					face.mWeights[cur_vertex].loadua(wght.mV);

+

+					cur_vertex++;

+				}

+

+				if (cur_vertex != num_verts || idx != weights.size())

+				{

+					llwarns << "Vertex weight count does not match vertex count!" << llendl;

+				}

+					

+			}

+

+			LLVector3 minp;

+			LLVector3 maxp;

+			LLVector2 min_tc; 

+			LLVector2 max_tc; 

+		

+			minp.setValue(mdl[i]["PositionDomain"]["Min"]);

+			maxp.setValue(mdl[i]["PositionDomain"]["Max"]);

+			LLVector4a min_pos, max_pos;

+			min_pos.load3(minp.mV);

+			max_pos.load3(maxp.mV);

+

+			min_tc.setValue(mdl[i]["TexCoord0Domain"]["Min"]);

+			max_tc.setValue(mdl[i]["TexCoord0Domain"]["Max"]);

+

+			LLVector4a pos_range;

+			pos_range.setSub(max_pos, min_pos);

+			LLVector2 tc_range = max_tc - min_tc;

+

+			LLVector4a* pos_out = face.mPositions;

+			LLVector4a* norm_out = face.mNormals;

+			LLVector2* tc_out = face.mTexCoords;

+

+			for (U32 j = 0; j < num_verts; ++j)

+			{

+				U16* v = (U16*) &(pos[j*3*2]);

+

+				pos_out->set((F32) v[0], (F32) v[1], (F32) v[2]);

+				pos_out->div(65535.f);

+				pos_out->mul(pos_range);

+				pos_out->add(min_pos);

+

+				pos_out++;

+

+				U16* n = (U16*) &(norm[j*3*2]);

+

+				norm_out->set((F32) n[0], (F32) n[1], (F32) n[2]);

+				norm_out->div(65535.f);

+				norm_out->mul(2.f);

+				norm_out->sub(1.f);

+				norm_out++;

+

+				U16* t = (U16*) &(tc[j*2*2]);

+

+				tc_out->mV[0] = (F32) t[0] / 65535.f * tc_range.mV[0] + min_tc.mV[0];

+				tc_out->mV[1] =	(F32) t[1] / 65535.f * tc_range.mV[1] + min_tc.mV[1];

+

+				tc_out++;

+			}

+

+			

+			// modifier flags?

+			bool do_mirror = (mParams.getSculptType() & LL_SCULPT_FLAG_MIRROR);

+			bool do_invert = (mParams.getSculptType() &LL_SCULPT_FLAG_INVERT);

+			

+			

+			// translate to actions:

+			bool do_reflect_x = false;

+			bool do_reverse_triangles = false;

+			bool do_invert_normals = false;

+			

+			if (do_mirror)

+			{

+				do_reflect_x = true;

+				do_reverse_triangles = !do_reverse_triangles;

+			}

+			

+			if (do_invert)

+			{

+				do_invert_normals = true;

+				do_reverse_triangles = !do_reverse_triangles;

+			}

+			

+			// now do the work

+

+			if (do_reflect_x)

+			{

+				LLVector4a* p = (LLVector4a*) face.mPositions;

+				LLVector4a* n = (LLVector4a*) face.mNormals;

+				

+				for (S32 i = 0; i < face.mNumVertices; i++)

+				{

+					p[i].mul(-1.0f);

+					n[i].mul(-1.0f);

+				}

+			}

+

+			if (do_invert_normals)

+			{

+				LLVector4a* n = (LLVector4a*) face.mNormals;

+				

+				for (S32 i = 0; i < face.mNumVertices; i++)

+				{

+					n[i].mul(-1.0f);

+				}

+			}

+

+			if (do_reverse_triangles)

+			{

+				for (U32 j = 0; j < face.mNumIndices; j += 3)

+				{

+					// swap the 2nd and 3rd index

+					S32 swap = face.mIndices[j+1];

+					face.mIndices[j+1] = face.mIndices[j+2];

+					face.mIndices[j+2] = swap;

+				}

+			}

+

+			//calculate bounding box

+			LLVector4a& min = face.mExtents[0];

+			LLVector4a& max = face.mExtents[1];

+

+			min.clear();

+			max.clear();

+			min = max = face.mPositions[0];

+

+			for (S32 i = 1; i < face.mNumVertices; ++i)

+			{

+				min.setMin(min, face.mPositions[i]);

+				max.setMax(max, face.mPositions[i]);

+			}

+		}

+	}

+

+	mSculptLevel = 0;  // success!

+

+	cacheOptimize();

+

+	return true;

+}

+

+void tetrahedron_set_normal(LLVolumeFace::VertexData* cv)

+{

+	LLVector4a v0;

+	v0.setSub(cv[1].getPosition(), cv[0].getNormal());

+	LLVector4a v1;

+	v1.setSub(cv[2].getNormal(), cv[0].getPosition());

+	

+	cv[0].getNormal().setCross3(v0,v1);

+	cv[0].getNormal().normalize3fast();

+	cv[1].setNormal(cv[0].getNormal());

+	cv[2].setNormal(cv[1].getNormal());

+}

+

+BOOL LLVolume::isTetrahedron()

+{

+	return mIsTetrahedron;

+}

+

+void LLVolume::makeTetrahedron()

+{

+	mVolumeFaces.clear();

+

+	LLVolumeFace face;

+

+	F32 x = 0.25f;

+	LLVector4a p[] = 

+	{ //unit tetrahedron corners

+		LLVector4a(x,x,x),

+		LLVector4a(-x,-x,x),

+		LLVector4a(-x,x,-x),

+		LLVector4a(x,-x,-x)

+	};

+

+	face.mExtents[0].splat(-x);

+	face.mExtents[1].splat(x);

+	

+	LLVolumeFace::VertexData cv[3];

+

+	//set texture coordinates

+	cv[0].mTexCoord = LLVector2(0,0);

+	cv[1].mTexCoord = LLVector2(1,0);

+	cv[2].mTexCoord = LLVector2(0.5f, 0.5f*F_SQRT3);

+

+

+	//side 1

+	cv[0].setPosition(p[1]);

+	cv[1].setPosition(p[0]);

+	cv[2].setPosition(p[2]);

+

+	tetrahedron_set_normal(cv);

+

+	face.resizeVertices(12);

+	face.resizeIndices(12);

+

+	LLVector4a* v = (LLVector4a*) face.mPositions;

+	LLVector4a* n = (LLVector4a*) face.mNormals;

+	LLVector2* tc = (LLVector2*) face.mTexCoords;

+

+	v[0] = cv[0].getPosition();

+	v[1] = cv[1].getPosition();

+	v[2] = cv[2].getPosition();

+	v += 3;

+

+	n[0] = cv[0].getNormal();

+	n[1] = cv[1].getNormal();

+	n[2] = cv[2].getNormal();

+	n += 3;

+

+	tc[0] = cv[0].mTexCoord;

+	tc[1] = cv[1].mTexCoord;

+	tc[2] = cv[2].mTexCoord;

+	tc += 3;

+

+	

+	//side 2

+	cv[0].setPosition(p[3]);

+	cv[1].setPosition(p[0]);

+	cv[2].setPosition(p[1]);

+

+	tetrahedron_set_normal(cv);

+

+	v[0] = cv[0].getPosition();

+	v[1] = cv[1].getPosition();

+	v[2] = cv[2].getPosition();

+	v += 3;

+

+	n[0] = cv[0].getNormal();

+	n[1] = cv[1].getNormal();

+	n[2] = cv[2].getNormal();

+	n += 3;

+

+	tc[0] = cv[0].mTexCoord;

+	tc[1] = cv[1].mTexCoord;

+	tc[2] = cv[2].mTexCoord;

+	tc += 3;

+	

+	//side 3

+	cv[0].setPosition(p[3]);

+	cv[1].setPosition(p[1]);

+	cv[2].setPosition(p[2]);

+

+	tetrahedron_set_normal(cv);

+

+	v[0] = cv[0].getPosition();

+	v[1] = cv[1].getPosition();

+	v[2] = cv[2].getPosition();

+	v += 3;

+

+	n[0] = cv[0].getNormal();

+	n[1] = cv[1].getNormal();

+	n[2] = cv[2].getNormal();

+	n += 3;

+

+	tc[0] = cv[0].mTexCoord;

+	tc[1] = cv[1].mTexCoord;

+	tc[2] = cv[2].mTexCoord;

+	tc += 3;

+	

+	//side 4

+	cv[0].setPosition(p[2]);

+	cv[1].setPosition(p[0]);

+	cv[2].setPosition(p[3]);

+

+	tetrahedron_set_normal(cv);

+

+	v[0] = cv[0].getPosition();

+	v[1] = cv[1].getPosition();

+	v[2] = cv[2].getPosition();

+	v += 3;

+

+	n[0] = cv[0].getNormal();

+	n[1] = cv[1].getNormal();

+	n[2] = cv[2].getNormal();

+	n += 3;

+

+	tc[0] = cv[0].mTexCoord;

+	tc[1] = cv[1].mTexCoord;

+	tc[2] = cv[2].mTexCoord;

+	tc += 3;

+	

+	//set index buffer

+	for (U16 i = 0; i < 12; i++)

+	{

+		face.mIndices[i] = i;

+	}

+	

+	mVolumeFaces.push_back(face);

+	mSculptLevel = 0;

+	mIsTetrahedron = TRUE;

+}

+

+void LLVolume::copyVolumeFaces(const LLVolume* volume)

+{

+	mVolumeFaces = volume->mVolumeFaces;

+	mSculptLevel = 0;

+	mIsTetrahedron = FALSE;

+}

+

+void LLVolume::cacheOptimize()

+{

+	for (S32 i = 0; i < mVolumeFaces.size(); ++i)

+	{

+		mVolumeFaces[i].cacheOptimize();

+	}

+}

+

+

+S32	LLVolume::getNumFaces() const

+{

+	U8 sculpt_type = (mParams.getSculptType() & LL_SCULPT_TYPE_MASK);

+

+	if (sculpt_type == LL_SCULPT_TYPE_MESH)

+	{

+		return LL_SCULPT_MESH_MAX_FACES;

+	}

+

+	return (S32)mProfilep->mFaces.size();

+}

+

+

+void LLVolume::createVolumeFaces()

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+

+	if (mGenerateSingleFace)

+	{

+		// do nothing

+	}

+	else

+	{

+		S32 num_faces = getNumFaces();

+		BOOL partial_build = TRUE;

+		if (num_faces != mVolumeFaces.size())

+		{

+			partial_build = FALSE;

+			mVolumeFaces.resize(num_faces);

+		}

+		// Initialize volume faces with parameter data

+		for (S32 i = 0; i < (S32)mVolumeFaces.size(); i++)

+		{

+			LLVolumeFace& vf = mVolumeFaces[i];

+			LLProfile::Face& face = mProfilep->mFaces[i];

+			vf.mBeginS = face.mIndex;

+			vf.mNumS = face.mCount;

+			if (vf.mNumS < 0)

+			{

+				llerrs << "Volume face corruption detected." << llendl;

+			}

+

+			vf.mBeginT = 0;

+			vf.mNumT= getPath().mPath.size();

+			vf.mID = i;

+

+			// Set the type mask bits correctly

+			if (mParams.getProfileParams().getHollow() > 0)

+			{

+				vf.mTypeMask |= LLVolumeFace::HOLLOW_MASK;

+			}

+			if (mProfilep->isOpen())

+			{

+				vf.mTypeMask |= LLVolumeFace::OPEN_MASK;

+			}

+			if (face.mCap)

+			{

+				vf.mTypeMask |= LLVolumeFace::CAP_MASK;

+				if (face.mFaceID == LL_FACE_PATH_BEGIN)

+				{

+					vf.mTypeMask |= LLVolumeFace::TOP_MASK;

+				}

+				else

+				{

+					llassert(face.mFaceID == LL_FACE_PATH_END);

+					vf.mTypeMask |= LLVolumeFace::BOTTOM_MASK;

+				}

+			}

+			else if (face.mFaceID & (LL_FACE_PROFILE_BEGIN | LL_FACE_PROFILE_END))

+			{

+				vf.mTypeMask |= LLVolumeFace::FLAT_MASK | LLVolumeFace::END_MASK;

+			}

+			else

+			{

+				vf.mTypeMask |= LLVolumeFace::SIDE_MASK;

+				if (face.mFlat)

+				{

+					vf.mTypeMask |= LLVolumeFace::FLAT_MASK;

+				}

+				if (face.mFaceID & LL_FACE_INNER_SIDE)

+				{

+					vf.mTypeMask |= LLVolumeFace::INNER_MASK;

+					if (face.mFlat && vf.mNumS > 2)

+					{ //flat inner faces have to copy vert normals

+						vf.mNumS = vf.mNumS*2;

+						if (vf.mNumS < 0)

+						{

+							llerrs << "Volume face corruption detected." << llendl;

+						}

+					}

+				}

+				else

+				{

+					vf.mTypeMask |= LLVolumeFace::OUTER_MASK;

+				}

+			}

+		}

+

+		for (face_list_t::iterator iter = mVolumeFaces.begin();

+			 iter != mVolumeFaces.end(); ++iter)

+		{

+			(*iter).create(this, partial_build);

+		}

+	}

+}

+

+

+inline LLVector3 sculpt_rgb_to_vector(U8 r, U8 g, U8 b)

+{

+	// maps RGB values to vector values [0..255] -> [-0.5..0.5]

+	LLVector3 value;

+	value.mV[VX] = r / 255.f - 0.5f;

+	value.mV[VY] = g / 255.f - 0.5f;

+	value.mV[VZ] = b / 255.f - 0.5f;

+

+	return value;

+}

+

+inline U32 sculpt_xy_to_index(U32 x, U32 y, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components)

+{

+	U32 index = (x + y * sculpt_width) * sculpt_components;

+	return index;

+}

+

+

+inline U32 sculpt_st_to_index(S32 s, S32 t, S32 size_s, S32 size_t, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components)

+{

+	U32 x = (U32) ((F32)s/(size_s) * (F32) sculpt_width);

+	U32 y = (U32) ((F32)t/(size_t) * (F32) sculpt_height);

+

+	return sculpt_xy_to_index(x, y, sculpt_width, sculpt_height, sculpt_components);

+}

+

+

+inline LLVector3 sculpt_index_to_vector(U32 index, const U8* sculpt_data)

+{

+	LLVector3 v = sculpt_rgb_to_vector(sculpt_data[index], sculpt_data[index+1], sculpt_data[index+2]);

+

+	return v;

+}

+

+inline LLVector3 sculpt_st_to_vector(S32 s, S32 t, S32 size_s, S32 size_t, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data)

+{

+	U32 index = sculpt_st_to_index(s, t, size_s, size_t, sculpt_width, sculpt_height, sculpt_components);

+

+	return sculpt_index_to_vector(index, sculpt_data);

+}

+

+inline LLVector3 sculpt_xy_to_vector(U32 x, U32 y, U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data)

+{

+	U32 index = sculpt_xy_to_index(x, y, sculpt_width, sculpt_height, sculpt_components);

+

+	return sculpt_index_to_vector(index, sculpt_data);

+}

+

+

+F32 LLVolume::sculptGetSurfaceArea()

+{

+	// test to see if image has enough variation to create non-degenerate geometry

+

+	F32 area = 0;

+

+	S32 sizeS = mPathp->mPath.size();

+	S32 sizeT = mProfilep->mProfile.size();

+			

+	for (S32 s = 0; s < sizeS-1; s++)

+	{

+		for (S32 t = 0; t < sizeT-1; t++)

+		{

+			// get four corners of quad

+			LLVector3 p1 = mMesh[(s  )*sizeT + (t  )].mPos;

+			LLVector3 p2 = mMesh[(s+1)*sizeT + (t  )].mPos;

+			LLVector3 p3 = mMesh[(s  )*sizeT + (t+1)].mPos;

+			LLVector3 p4 = mMesh[(s+1)*sizeT + (t+1)].mPos;

+

+			// compute the area of the quad by taking the length of the cross product of the two triangles

+			LLVector3 cross1 = (p1 - p2) % (p1 - p3);

+			LLVector3 cross2 = (p4 - p2) % (p4 - p3);

+			area += (cross1.magVec() + cross2.magVec()) / 2.0;

+		}

+	}

+

+	return area;

+}

+

+// create placeholder shape

+void LLVolume::sculptGeneratePlaceholder()

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	S32 sizeS = mPathp->mPath.size();

+	S32 sizeT = mProfilep->mProfile.size();

+	

+	S32 line = 0;

+

+	// for now, this is a sphere.

+	for (S32 s = 0; s < sizeS; s++)

+	{

+		for (S32 t = 0; t < sizeT; t++)

+		{

+			S32 i = t + line;

+			Point& pt = mMesh[i];

+

+			

+			F32 u = (F32)s/(sizeS-1);

+			F32 v = (F32)t/(sizeT-1);

+

+			const F32 RADIUS = (F32) 0.3;

+					

+			pt.mPos.mV[0] = (F32)(sin(F_PI * v) * cos(2.0 * F_PI * u) * RADIUS);

+			pt.mPos.mV[1] = (F32)(sin(F_PI * v) * sin(2.0 * F_PI * u) * RADIUS);

+			pt.mPos.mV[2] = (F32)(cos(F_PI * v) * RADIUS);

+

+		}

+		line += sizeT;

+	}

+}

+

+// create the vertices from the map

+void LLVolume::sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, U8 sculpt_type)

+{

+	U8 sculpt_stitching = sculpt_type & LL_SCULPT_TYPE_MASK;

+	BOOL sculpt_invert = sculpt_type & LL_SCULPT_FLAG_INVERT;

+	BOOL sculpt_mirror = sculpt_type & LL_SCULPT_FLAG_MIRROR;

+	BOOL reverse_horizontal = (sculpt_invert ? !sculpt_mirror : sculpt_mirror);  // XOR

+	

+	

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	S32 sizeS = mPathp->mPath.size();

+	S32 sizeT = mProfilep->mProfile.size();

+	

+	S32 line = 0;

+	for (S32 s = 0; s < sizeS; s++)

+	{

+		// Run along the profile.

+		for (S32 t = 0; t < sizeT; t++)

+		{

+			S32 i = t + line;

+			Point& pt = mMesh[i];

+

+			S32 reversed_t = t;

+

+			if (reverse_horizontal)

+			{

+				reversed_t = sizeT - t - 1;

+			}

+			

+			U32 x = (U32) ((F32)reversed_t/(sizeT-1) * (F32) sculpt_width);

+			U32 y = (U32) ((F32)s/(sizeS-1) * (F32) sculpt_height);

+

+			

+			if (y == 0)  // top row stitching

+			{

+				// pinch?

+				if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)

+				{

+					x = sculpt_width / 2;

+				}

+			}

+

+			if (y == sculpt_height)  // bottom row stitching

+			{

+				// wrap?

+				if (sculpt_stitching == LL_SCULPT_TYPE_TORUS)

+				{

+					y = 0;

+				}

+				else

+				{

+					y = sculpt_height - 1;

+				}

+

+				// pinch?

+				if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)

+				{

+					x = sculpt_width / 2;

+				}

+			}

+

+			if (x == sculpt_width)   // side stitching

+			{

+				// wrap?

+				if ((sculpt_stitching == LL_SCULPT_TYPE_SPHERE) ||

+					(sculpt_stitching == LL_SCULPT_TYPE_TORUS) ||

+					(sculpt_stitching == LL_SCULPT_TYPE_CYLINDER))

+				{

+					x = 0;

+				}

+					

+				else

+				{

+					x = sculpt_width - 1;

+				}

+			}

+

+			pt.mPos = sculpt_xy_to_vector(x, y, sculpt_width, sculpt_height, sculpt_components, sculpt_data);

+

+			if (sculpt_mirror)

+			{

+				pt.mPos.mV[VX] *= -1.f;

+			}

+		}

+		

+		line += sizeT;

+	}

+}

+

+

+const S32 SCULPT_REZ_1 = 6;  // changed from 4 to 6 - 6 looks round whereas 4 looks square

+const S32 SCULPT_REZ_2 = 8;

+const S32 SCULPT_REZ_3 = 16;

+const S32 SCULPT_REZ_4 = 32;

+

+S32 sculpt_sides(F32 detail)

+{

+

+	// detail is usually one of: 1, 1.5, 2.5, 4.0.

+	

+	if (detail <= 1.0)

+	{

+		return SCULPT_REZ_1;

+	}

+	if (detail <= 2.0)

+	{

+		return SCULPT_REZ_2;

+	}

+	if (detail <= 3.0)

+	{

+		return SCULPT_REZ_3;

+	}

+	else

+	{

+		return SCULPT_REZ_4;

+	}

+}

+

+

+

+// determine the number of vertices in both s and t direction for this sculpt

+void sculpt_calc_mesh_resolution(U16 width, U16 height, U8 type, F32 detail, S32& s, S32& t)

+{

+	// this code has the following properties:

+	// 1) the aspect ratio of the mesh is as close as possible to the ratio of the map

+	//    while still using all available verts

+	// 2) the mesh cannot have more verts than is allowed by LOD

+	// 3) the mesh cannot have more verts than is allowed by the map

+	

+	S32 max_vertices_lod = (S32)pow((double)sculpt_sides(detail), 2.0);

+	S32 max_vertices_map = width * height / 4;

+	

+	S32 vertices;

+	if (max_vertices_map > 0)

+		vertices = llmin(max_vertices_lod, max_vertices_map);

+	else

+		vertices = max_vertices_lod;

+	

+

+	F32 ratio;

+	if ((width == 0) || (height == 0))

+		ratio = 1.f;

+	else

+		ratio = (F32) width / (F32) height;

+

+	

+	s = (S32)(F32) sqrt(((F32)vertices / ratio));

+

+	s = llmax(s, 4);              // no degenerate sizes, please

+	t = vertices / s;

+

+	t = llmax(t, 4);              // no degenerate sizes, please

+	s = vertices / t;

+}

+

+// 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)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+    U8 sculpt_type = mParams.getSculptType();

+

+	BOOL data_is_empty = FALSE;

+

+	if (sculpt_width == 0 || sculpt_height == 0 || sculpt_components < 3 || sculpt_data == NULL)

+	{

+		sculpt_level = -1;

+		data_is_empty = TRUE;

+	}

+

+	S32 requested_sizeS = 0;

+	S32 requested_sizeT = 0;

+

+	sculpt_calc_mesh_resolution(sculpt_width, sculpt_height, sculpt_type, mDetail, requested_sizeS, 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

+

+	// weird crash bug - DEV-11158 - trying to collect more data:

+	if ((sizeS == 0) || (sizeT == 0))

+	{

+		llwarns << "sculpt bad mesh size " << sizeS << " " << sizeT << llendl;

+	}

+	

+	sNumMeshPoints -= mMesh.size();

+	mMesh.resize(sizeS * sizeT);

+	sNumMeshPoints += mMesh.size();

+

+	//generate vertex positions

+	if (!data_is_empty)

+	{

+		sculptGenerateMapVertices(sculpt_width, sculpt_height, sculpt_components, sculpt_data, sculpt_type);

+

+		// don't test lowest LOD to support legacy content DEV-33670

+		if (mDetail > SCULPT_MIN_AREA_DETAIL)

+		{

+			if (sculptGetSurfaceArea() < SCULPT_MIN_AREA)

+			{

+				data_is_empty = TRUE;

+			}

+		}

+	}

+

+	if (data_is_empty)

+	{

+		sculptGeneratePlaceholder();

+	}

+

+

+	

+	for (S32 i = 0; i < (S32)mProfilep->mFaces.size(); i++)

+	{

+		mFaceMask |= mProfilep->mFaces[i].mFaceID;

+	}

+

+	mSculptLevel = sculpt_level;

+

+	// Delete any existing faces so that they get regenerated

+	mVolumeFaces.clear();

+	

+	createVolumeFaces();

+}

+

+

+

+

+BOOL LLVolume::isCap(S32 face)

+{

+	return mProfilep->mFaces[face].mCap; 

+}

+

+BOOL LLVolume::isFlat(S32 face)

+{

+	return mProfilep->mFaces[face].mFlat;

+}

+

+

+bool LLVolumeParams::isSculpt() const

+{

+	return mSculptID.notNull();

+}

+

+bool LLVolumeParams::isMeshSculpt() const

+{

+	return isSculpt() && ((mSculptType & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH);

+}

+

+bool LLVolumeParams::operator==(const LLVolumeParams &params) const

+{

+	return ( (getPathParams() == params.getPathParams()) &&

+			 (getProfileParams() == params.getProfileParams()) &&

+			 (mSculptID == params.mSculptID) &&

+			 (mSculptType == params.mSculptType) );

+}

+

+bool LLVolumeParams::operator!=(const LLVolumeParams &params) const

+{

+	return ( (getPathParams() != params.getPathParams()) ||

+			 (getProfileParams() != params.getProfileParams()) ||

+			 (mSculptID != params.mSculptID) ||

+			 (mSculptType != params.mSculptType) );

+}

+

+bool LLVolumeParams::operator<(const LLVolumeParams &params) const

+{

+	if( getPathParams() != params.getPathParams() )

+	{

+		return getPathParams() < params.getPathParams();

+	}

+	

+	if (getProfileParams() != params.getProfileParams())

+	{

+		return getProfileParams() < params.getProfileParams();

+	}

+	

+	if (mSculptID != params.mSculptID)

+	{

+		return mSculptID < params.mSculptID;

+	}

+

+	return mSculptType < params.mSculptType;

+

+

+}

+

+void LLVolumeParams::copyParams(const LLVolumeParams &params)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	mProfileParams.copyParams(params.mProfileParams);

+	mPathParams.copyParams(params.mPathParams);

+	mSculptID = params.getSculptID();

+	mSculptType = params.getSculptType();

+}

+

+// Less restricitve approx 0 for volumes

+const F32 APPROXIMATELY_ZERO = 0.001f;

+bool approx_zero( F32 f, F32 tolerance = APPROXIMATELY_ZERO)

+{

+	return (f >= -tolerance) && (f <= tolerance);

+}

+

+// return true if in range (or nearly so)

+static bool limit_range(F32& v, F32 min, F32 max, F32 tolerance = APPROXIMATELY_ZERO)

+{

+	F32 min_delta = v - min;

+	if (min_delta < 0.f)

+	{

+		v = min;

+		if (!approx_zero(min_delta, tolerance))

+			return false;

+	}

+	F32 max_delta = max - v;

+	if (max_delta < 0.f)

+	{

+		v = max;

+		if (!approx_zero(max_delta, tolerance))

+			return false;

+	}

+	return true;

+}

+

+bool LLVolumeParams::setBeginAndEndS(const F32 b, const F32 e)

+{

+	bool valid = true;

+

+	// First, clamp to valid ranges.

+	F32 begin = b;

+	valid &= limit_range(begin, 0.f, 1.f - MIN_CUT_DELTA);

+

+	F32 end = e;

+	if (end >= .0149f && end < MIN_CUT_DELTA) end = MIN_CUT_DELTA; // eliminate warning for common rounding error

+	valid &= limit_range(end, MIN_CUT_DELTA, 1.f);

+

+	valid &= limit_range(begin, 0.f, end - MIN_CUT_DELTA, .01f);

+

+	// Now set them.

+	mProfileParams.setBegin(begin);

+	mProfileParams.setEnd(end);

+

+	return valid;

+}

+

+bool LLVolumeParams::setBeginAndEndT(const F32 b, const F32 e)

+{

+	bool valid = true;

+

+	// First, clamp to valid ranges.

+	F32 begin = b;

+	valid &= limit_range(begin, 0.f, 1.f - MIN_CUT_DELTA);

+

+	F32 end = e;

+	valid &= limit_range(end, MIN_CUT_DELTA, 1.f);

+

+	valid &= limit_range(begin, 0.f, end - MIN_CUT_DELTA, .01f);

+

+	// Now set them.

+	mPathParams.setBegin(begin);

+	mPathParams.setEnd(end);

+

+	return valid;

+}			

+

+bool LLVolumeParams::setHollow(const F32 h)

+{

+	// Validate the hollow based on path and profile.

+	U8 profile 	= mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;

+	U8 hole_type 	= mProfileParams.getCurveType() & LL_PCODE_HOLE_MASK;

+	

+	F32 max_hollow = HOLLOW_MAX;

+

+	// Only square holes have trouble.

+	if (LL_PCODE_HOLE_SQUARE == hole_type)

+	{

+		switch(profile)

+		{

+		case LL_PCODE_PROFILE_CIRCLE:

+		case LL_PCODE_PROFILE_CIRCLE_HALF:

+		case LL_PCODE_PROFILE_EQUALTRI:

+			max_hollow = HOLLOW_MAX_SQUARE;

+		}

+	}

+

+	F32 hollow = h;

+	bool valid = limit_range(hollow, HOLLOW_MIN, max_hollow);

+	mProfileParams.setHollow(hollow); 

+

+	return valid;

+}	

+

+bool LLVolumeParams::setTwistBegin(const F32 b)

+{

+	F32 twist_begin = b;

+	bool valid = limit_range(twist_begin, TWIST_MIN, TWIST_MAX);

+	mPathParams.setTwistBegin(twist_begin);

+	return valid;

+}

+

+bool LLVolumeParams::setTwistEnd(const F32 e)

+{	

+	F32 twist_end = e;

+	bool valid = limit_range(twist_end, TWIST_MIN, TWIST_MAX);

+	mPathParams.setTwistEnd(twist_end);

+	return valid;

+}

+

+bool LLVolumeParams::setRatio(const F32 x, const F32 y)

+{

+	F32 min_x = RATIO_MIN;

+	F32 max_x = RATIO_MAX;

+	F32 min_y = RATIO_MIN;

+	F32 max_y = RATIO_MAX;

+	// If this is a circular path (and not a sphere) then 'ratio' is actually hole size.

+	U8 path_type 	= mPathParams.getCurveType();

+	U8 profile_type = mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;

+	if ( LL_PCODE_PATH_CIRCLE == path_type &&

+		 LL_PCODE_PROFILE_CIRCLE_HALF != profile_type)

+	{

+		// Holes are more restricted...

+		min_x = HOLE_X_MIN;

+		max_x = HOLE_X_MAX;

+		min_y = HOLE_Y_MIN;

+		max_y = HOLE_Y_MAX;

+	}

+

+	F32 ratio_x = x;

+	bool valid = limit_range(ratio_x, min_x, max_x);

+	F32 ratio_y = y;

+	valid &= limit_range(ratio_y, min_y, max_y);

+

+	mPathParams.setScale(ratio_x, ratio_y);

+

+	return valid;

+}

+

+bool LLVolumeParams::setShear(const F32 x, const F32 y)

+{

+	F32 shear_x = x;

+	bool valid = limit_range(shear_x, SHEAR_MIN, SHEAR_MAX);

+	F32 shear_y = y;

+	valid &= limit_range(shear_y, SHEAR_MIN, SHEAR_MAX);

+	mPathParams.setShear(shear_x, shear_y);

+	return valid;

+}

+

+bool LLVolumeParams::setTaperX(const F32 v)

+{

+	F32 taper = v;

+	bool valid = limit_range(taper, TAPER_MIN, TAPER_MAX);

+	mPathParams.setTaperX(taper);

+	return valid;

+}

+

+bool LLVolumeParams::setTaperY(const F32 v)

+{

+	F32 taper = v;

+	bool valid = limit_range(taper, TAPER_MIN, TAPER_MAX);

+	mPathParams.setTaperY(taper);

+	return valid;

+}

+

+bool LLVolumeParams::setRevolutions(const F32 r)

+{

+	F32 revolutions = r;

+	bool valid = limit_range(revolutions, REV_MIN, REV_MAX);

+	mPathParams.setRevolutions(revolutions);

+	return valid;

+}

+

+bool LLVolumeParams::setRadiusOffset(const F32 offset)

+{

+	bool valid = true;

+

+	// If this is a sphere, just set it to 0 and get out.

+	U8 path_type 	= mPathParams.getCurveType();

+	U8 profile_type = mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;

+	if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type ||

+		LL_PCODE_PATH_CIRCLE != path_type )

+	{

+		mPathParams.setRadiusOffset(0.f);

+		return true;

+	}

+

+	// Limit radius offset, based on taper and hole size y.

+	F32 radius_offset	= offset;

+	F32 taper_y    		= getTaperY();

+	F32 radius_mag		= fabs(radius_offset);

+	F32 hole_y_mag 		= fabs(getRatioY());

+	F32 taper_y_mag		= fabs(taper_y);

+	// Check to see if the taper effects us.

+	if ( (radius_offset > 0.f && taper_y < 0.f) ||

+			(radius_offset < 0.f && taper_y > 0.f) )

+	{

+		// The taper does not help increase the radius offset range.

+		taper_y_mag = 0.f;

+	}

+	F32 max_radius_mag = 1.f - hole_y_mag * (1.f - taper_y_mag) / (1.f - hole_y_mag);

+

+	// Enforce the maximum magnitude.

+	F32 delta = max_radius_mag - radius_mag;

+	if (delta < 0.f)

+	{

+		// Check radius offset sign.

+		if (radius_offset < 0.f)

+		{

+			radius_offset = -max_radius_mag;

+		}

+		else

+		{

+			radius_offset = max_radius_mag;

+		}

+		valid = approx_zero(delta, .1f);

+	}

+

+	mPathParams.setRadiusOffset(radius_offset);

+	return valid;

+}

+

+bool LLVolumeParams::setSkew(const F32 skew_value)

+{

+	bool valid = true;

+

+	// Check the skew value against the revolutions.

+	F32 skew		= llclamp(skew_value, SKEW_MIN, SKEW_MAX);

+	F32 skew_mag	= fabs(skew);

+	F32 revolutions = getRevolutions();

+	F32 scale_x		= getRatioX();

+	F32 min_skew_mag = 1.0f - 1.0f / (revolutions * scale_x + 1.0f);

+	// Discontinuity; A revolution of 1 allows skews below 0.5.

+	if ( fabs(revolutions - 1.0f) < 0.001)

+		min_skew_mag = 0.0f;

+

+	// Clip skew.

+	F32 delta = skew_mag - min_skew_mag;

+	if (delta < 0.f)

+	{

+		// Check skew sign.

+		if (skew < 0.0f)

+		{

+			skew = -min_skew_mag;

+		}

+		else 

+		{

+			skew = min_skew_mag;

+		}

+		valid = approx_zero(delta, .01f);

+	}

+

+	mPathParams.setSkew(skew);

+	return valid;

+}

+

+bool LLVolumeParams::setSculptID(const LLUUID sculpt_id, U8 sculpt_type)

+{

+	mSculptID = sculpt_id;

+	mSculptType = sculpt_type;

+	return true;

+}

+

+bool LLVolumeParams::setType(U8 profile, U8 path)

+{

+	bool result = true;

+	// First, check profile and path for validity.

+	U8 profile_type	= profile & LL_PCODE_PROFILE_MASK;

+	U8 hole_type 	= (profile & LL_PCODE_HOLE_MASK) >> 4;

+	U8 path_type	= path >> 4;

+

+	if (profile_type > LL_PCODE_PROFILE_MAX)

+	{

+		// Bad profile.  Make it square.

+		profile = LL_PCODE_PROFILE_SQUARE;

+		result = false;

+		llwarns << "LLVolumeParams::setType changing bad profile type (" << profile_type

+			 	<< ") to be LL_PCODE_PROFILE_SQUARE" << llendl;

+	}

+	else if (hole_type > LL_PCODE_HOLE_MAX)

+	{

+		// Bad hole.  Make it the same.

+		profile = profile_type;

+		result = false;

+		llwarns << "LLVolumeParams::setType changing bad hole type (" << hole_type

+			 	<< ") to be LL_PCODE_HOLE_SAME" << llendl;

+	}

+

+	if (path_type < LL_PCODE_PATH_MIN ||

+		path_type > LL_PCODE_PATH_MAX)

+	{

+		// Bad path.  Make it linear.

+		result = false;

+		llwarns << "LLVolumeParams::setType changing bad path (" << path

+			 	<< ") to be LL_PCODE_PATH_LINE" << llendl;

+		path = LL_PCODE_PATH_LINE;

+	}

+

+	mProfileParams.setCurveType(profile);

+	mPathParams.setCurveType(path);

+	return result;

+}

+

+// static 

+bool LLVolumeParams::validate(U8 prof_curve, F32 prof_begin, F32 prof_end, F32 hollow,

+		U8 path_curve, F32 path_begin, F32 path_end,

+		F32 scx, F32 scy, F32 shx, F32 shy,

+		F32 twistend, F32 twistbegin, F32 radiusoffset,

+		F32 tx, F32 ty, F32 revolutions, F32 skew)

+{

+	LLVolumeParams test_params;

+	if (!test_params.setType		(prof_curve, path_curve))

+	{

+	    	return false;

+	}

+	if (!test_params.setBeginAndEndS	(prof_begin, prof_end))

+	{

+	    	return false;

+	}

+	if (!test_params.setBeginAndEndT	(path_begin, path_end))

+	{

+	    	return false;

+	}

+	if (!test_params.setHollow		(hollow))

+	{

+	    	return false;

+	}

+	if (!test_params.setTwistBegin		(twistbegin))

+	{

+	    	return false;

+	}

+	if (!test_params.setTwistEnd		(twistend))

+	{

+	    	return false;

+	}

+	if (!test_params.setRatio		(scx, scy))

+	{

+	    	return false;

+	}

+	if (!test_params.setShear		(shx, shy))

+	{

+	    	return false;

+	}

+	if (!test_params.setTaper		(tx, ty))

+	{

+	    	return false;

+	}

+	if (!test_params.setRevolutions		(revolutions))

+	{

+	    	return false;

+	}

+	if (!test_params.setRadiusOffset	(radiusoffset))

+	{

+	    	return false;

+	}

+	if (!test_params.setSkew		(skew))

+	{

+	    	return false;

+	}

+	return true;

+}

+

+S32 *LLVolume::getTriangleIndices(U32 &num_indices) const

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	S32 expected_num_triangle_indices = getNumTriangleIndices();

+	if (expected_num_triangle_indices > MAX_VOLUME_TRIANGLE_INDICES)

+	{

+		// we don't allow LLVolumes with this many vertices

+		llwarns << "Couldn't allocate triangle indices" << llendl;

+		num_indices = 0;

+		return NULL;

+	}

+

+	S32* index = new S32[expected_num_triangle_indices];

+	S32 count = 0;

+

+	// Let's do this totally diffently, as we don't care about faces...

+	// Counter-clockwise triangles are forward facing...

+

+	BOOL open = getProfile().isOpen();

+	BOOL hollow = (mParams.getProfileParams().getHollow() > 0);

+	BOOL path_open = getPath().isOpen();

+	S32 size_s, size_s_out, size_t;

+	S32 s, t, i;

+	size_s = getProfile().getTotal();

+	size_s_out = getProfile().getTotalOut();

+	size_t = getPath().mPath.size();

+

+	// NOTE -- if the construction of the triangles below ever changes

+	// then getNumTriangleIndices() method may also have to be updated.

+

+	if (open)		/* Flawfinder: ignore */

+	{

+		if (hollow)

+		{

+			// Open hollow -- much like the closed solid, except we 

+			// we need to stitch up the gap between s=0 and s=size_s-1

+

+			for (t = 0; t < size_t - 1; t++)

+			{

+				// The outer face, first cut, and inner face

+				for (s = 0; s < size_s - 1; s++)

+				{

+					i  = s + t*size_s;

+					index[count++]  = i;				// x,y

+					index[count++]  = i + 1;			// x+1,y

+					index[count++]  = i + size_s;		// x,y+1

+	

+					index[count++]  = i + size_s;		// x,y+1

+					index[count++]  = i + 1;			// x+1,y

+					index[count++]  = i + size_s + 1;	// x+1,y+1

+				}

+

+				// The other cut face

+				index[count++]  = s + t*size_s;		// x,y

+				index[count++]  = 0 + t*size_s;		// x+1,y

+				index[count++]  = s + (t+1)*size_s;	// x,y+1

+	

+				index[count++]  = s + (t+1)*size_s;	// x,y+1

+				index[count++]  = 0 + t*size_s;		// x+1,y

+				index[count++]  = 0 + (t+1)*size_s;	// x+1,y+1

+			}

+

+			// Do the top and bottom caps, if necessary

+			if (path_open)

+			{

+				// Top cap

+				S32 pt1 = 0;

+				S32 pt2 = size_s-1;

+				S32 i   = (size_t - 1)*size_s;

+

+				while (pt2 - pt1 > 1)

+				{

+					// Use the profile points instead of the mesh, since you want

+					// the un-transformed profile distances.

+					LLVector3 p1 = getProfile().mProfile[pt1];

+					LLVector3 p2 = getProfile().mProfile[pt2];

+					LLVector3 pa = getProfile().mProfile[pt1+1];

+					LLVector3 pb = getProfile().mProfile[pt2-1];

+

+					p1.mV[VZ] = 0.f;

+					p2.mV[VZ] = 0.f;

+					pa.mV[VZ] = 0.f;

+					pb.mV[VZ] = 0.f;

+

+					// Use area of triangle to determine backfacing

+					F32 area_1a2, area_1ba, area_21b, area_2ab;

+					area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +

+								(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +

+								(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);

+

+					area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+								(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +

+								(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);

+

+					area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +

+								(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+					area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +

+								(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +

+								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+					BOOL use_tri1a2 = TRUE;

+					BOOL tri_1a2 = TRUE;

+					BOOL tri_21b = TRUE;

+

+					if (area_1a2 < 0)

+					{

+						tri_1a2 = FALSE;

+					}

+					if (area_2ab < 0)

+					{

+						// Can't use, because it contains point b

+						tri_1a2 = FALSE;

+					}

+					if (area_21b < 0)

+					{

+						tri_21b = FALSE;

+					}

+					if (area_1ba < 0)

+					{

+						// Can't use, because it contains point b

+						tri_21b = FALSE;

+					}

+

+					if (!tri_1a2)

+					{

+						use_tri1a2 = FALSE;

+					}

+					else if (!tri_21b)

+					{

+						use_tri1a2 = TRUE;

+					}

+					else

+					{

+						LLVector3 d1 = p1 - pa;

+						LLVector3 d2 = p2 - pb;

+

+						if (d1.magVecSquared() < d2.magVecSquared())

+						{

+							use_tri1a2 = TRUE;

+						}

+						else

+						{

+							use_tri1a2 = FALSE;

+						}

+					}

+

+					if (use_tri1a2)

+					{

+						index[count++] = pt1 + i;

+						index[count++] = pt1 + 1 + i;

+						index[count++] = pt2 + i;

+						pt1++;

+					}

+					else

+					{

+						index[count++] = pt1 + i;

+						index[count++] = pt2 - 1 + i;

+						index[count++] = pt2 + i;

+						pt2--;

+					}

+				}

+

+				// Bottom cap

+				pt1          = 0;

+				pt2          = size_s-1;

+				while (pt2 - pt1 > 1)

+				{

+					// Use the profile points instead of the mesh, since you want

+					// the un-transformed profile distances.

+					LLVector3 p1 = getProfile().mProfile[pt1];

+					LLVector3 p2 = getProfile().mProfile[pt2];

+					LLVector3 pa = getProfile().mProfile[pt1+1];

+					LLVector3 pb = getProfile().mProfile[pt2-1];

+

+					p1.mV[VZ] = 0.f;

+					p2.mV[VZ] = 0.f;

+					pa.mV[VZ] = 0.f;

+					pb.mV[VZ] = 0.f;

+

+					// Use area of triangle to determine backfacing

+					F32 area_1a2, area_1ba, area_21b, area_2ab;

+					area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +

+								(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +

+								(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);

+

+					area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+								(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +

+								(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);

+

+					area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +

+								(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+					area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +

+								(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +

+								(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+					BOOL use_tri1a2 = TRUE;

+					BOOL tri_1a2 = TRUE;

+					BOOL tri_21b = TRUE;

+

+					if (area_1a2 < 0)

+					{

+						tri_1a2 = FALSE;

+					}

+					if (area_2ab < 0)

+					{

+						// Can't use, because it contains point b

+						tri_1a2 = FALSE;

+					}

+					if (area_21b < 0)

+					{

+						tri_21b = FALSE;

+					}

+					if (area_1ba < 0)

+					{

+						// Can't use, because it contains point b

+						tri_21b = FALSE;

+					}

+

+					if (!tri_1a2)

+					{

+						use_tri1a2 = FALSE;

+					}

+					else if (!tri_21b)

+					{

+						use_tri1a2 = TRUE;

+					}

+					else

+					{

+						LLVector3 d1 = p1 - pa;

+						LLVector3 d2 = p2 - pb;

+

+						if (d1.magVecSquared() < d2.magVecSquared())

+						{

+							use_tri1a2 = TRUE;

+						}

+						else

+						{

+							use_tri1a2 = FALSE;

+						}

+					}

+

+					if (use_tri1a2)

+					{

+						index[count++] = pt1;

+						index[count++] = pt2;

+						index[count++] = pt1 + 1;

+						pt1++;

+					}

+					else

+					{

+						index[count++] = pt1;

+						index[count++] = pt2;

+						index[count++] = pt2 - 1;

+						pt2--;

+					}

+				}

+			}

+		}

+		else

+		{

+			// Open solid

+

+			for (t = 0; t < size_t - 1; t++)

+			{

+				// Outer face + 1 cut face

+				for (s = 0; s < size_s - 1; s++)

+				{

+					i  = s + t*size_s;

+

+					index[count++]  = i;				// x,y

+					index[count++]  = i + 1;			// x+1,y

+					index[count++]  = i + size_s;		// x,y+1

+

+					index[count++]  = i + size_s;		// x,y+1

+					index[count++]  = i + 1;			// x+1,y

+					index[count++]  = i + size_s + 1;	// x+1,y+1

+				}

+

+				// The other cut face

+				index[count++] = (size_s - 1) + (t*size_s);		// x,y

+				index[count++] = 0 + t*size_s;					// x+1,y

+				index[count++] = (size_s - 1) + (t+1)*size_s;	// x,y+1

+

+				index[count++] = (size_s - 1) + (t+1)*size_s;	// x,y+1

+				index[count++] = 0 + (t*size_s);				// x+1,y

+				index[count++] = 0 + (t+1)*size_s;				// x+1,y+1

+			}

+

+			// Do the top and bottom caps, if necessary

+			if (path_open)

+			{

+				for (s = 0; s < size_s - 2; s++)

+				{

+					index[count++] = s+1;

+					index[count++] = s;

+					index[count++] = size_s - 1;

+				}

+

+				// We've got a top cap

+				S32 offset = (size_t - 1)*size_s;

+				for (s = 0; s < size_s - 2; s++)

+				{

+					// Inverted ordering from bottom cap.

+					index[count++] = offset + size_s - 1;

+					index[count++] = offset + s;

+					index[count++] = offset + s + 1;

+				}

+			}

+		}

+	}

+	else if (hollow)

+	{

+		// Closed hollow

+		// Outer face

+		

+		for (t = 0; t < size_t - 1; t++)

+		{

+			for (s = 0; s < size_s_out - 1; s++)

+			{

+				i  = s + t*size_s;

+

+				index[count++]  = i;				// x,y

+				index[count++]  = i + 1;			// x+1,y

+				index[count++]  = i + size_s;		// x,y+1

+

+				index[count++]  = i + size_s;		// x,y+1

+				index[count++]  = i + 1;			// x+1,y

+				index[count++]  = i + 1 + size_s;	// x+1,y+1

+			}

+		}

+

+		// Inner face

+		// Invert facing from outer face

+		for (t = 0; t < size_t - 1; t++)

+		{

+			for (s = size_s_out; s < size_s - 1; s++)

+			{

+				i  = s + t*size_s;

+

+				index[count++]  = i;				// x,y

+				index[count++]  = i + 1;			// x+1,y

+				index[count++]  = i + size_s;		// x,y+1

+

+				index[count++]  = i + size_s;		// x,y+1

+				index[count++]  = i + 1;			// x+1,y

+				index[count++]  = i + 1 + size_s;	// x+1,y+1

+			}

+		}

+

+		// Do the top and bottom caps, if necessary

+		if (path_open)

+		{

+			// Top cap

+			S32 pt1 = 0;

+			S32 pt2 = size_s-1;

+			S32 i   = (size_t - 1)*size_s;

+

+			while (pt2 - pt1 > 1)

+			{

+				// Use the profile points instead of the mesh, since you want

+				// the un-transformed profile distances.

+				LLVector3 p1 = getProfile().mProfile[pt1];

+				LLVector3 p2 = getProfile().mProfile[pt2];

+				LLVector3 pa = getProfile().mProfile[pt1+1];

+				LLVector3 pb = getProfile().mProfile[pt2-1];

+

+				p1.mV[VZ] = 0.f;

+				p2.mV[VZ] = 0.f;

+				pa.mV[VZ] = 0.f;

+				pb.mV[VZ] = 0.f;

+

+				// Use area of triangle to determine backfacing

+				F32 area_1a2, area_1ba, area_21b, area_2ab;

+				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +

+							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +

+							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);

+

+				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +

+							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);

+

+				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +

+							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +

+							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				BOOL use_tri1a2 = TRUE;

+				BOOL tri_1a2 = TRUE;

+				BOOL tri_21b = TRUE;

+

+				if (area_1a2 < 0)

+				{

+					tri_1a2 = FALSE;

+				}

+				if (area_2ab < 0)

+				{

+					// Can't use, because it contains point b

+					tri_1a2 = FALSE;

+				}

+				if (area_21b < 0)

+				{

+					tri_21b = FALSE;

+				}

+				if (area_1ba < 0)

+				{

+					// Can't use, because it contains point b

+					tri_21b = FALSE;

+				}

+

+				if (!tri_1a2)

+				{

+					use_tri1a2 = FALSE;

+				}

+				else if (!tri_21b)

+				{

+					use_tri1a2 = TRUE;

+				}

+				else

+				{

+					LLVector3 d1 = p1 - pa;

+					LLVector3 d2 = p2 - pb;

+

+					if (d1.magVecSquared() < d2.magVecSquared())

+					{

+						use_tri1a2 = TRUE;

+					}

+					else

+					{

+						use_tri1a2 = FALSE;

+					}

+				}

+

+				if (use_tri1a2)

+				{

+					index[count++] = pt1 + i;

+					index[count++] = pt1 + 1 + i;

+					index[count++] = pt2 + i;

+					pt1++;

+				}

+				else

+				{

+					index[count++] = pt1 + i;

+					index[count++] = pt2 - 1 + i;

+					index[count++] = pt2 + i;

+					pt2--;

+				}

+			}

+

+			// Bottom cap

+			pt1          = 0;

+			pt2          = size_s-1;

+			while (pt2 - pt1 > 1)

+			{

+				// Use the profile points instead of the mesh, since you want

+				// the un-transformed profile distances.

+				LLVector3 p1 = getProfile().mProfile[pt1];

+				LLVector3 p2 = getProfile().mProfile[pt2];

+				LLVector3 pa = getProfile().mProfile[pt1+1];

+				LLVector3 pb = getProfile().mProfile[pt2-1];

+

+				p1.mV[VZ] = 0.f;

+				p2.mV[VZ] = 0.f;

+				pa.mV[VZ] = 0.f;

+				pb.mV[VZ] = 0.f;

+

+				// Use area of triangle to determine backfacing

+				F32 area_1a2, area_1ba, area_21b, area_2ab;

+				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +

+							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +

+							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);

+

+				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +

+							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);

+

+				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +

+							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +

+							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				BOOL use_tri1a2 = TRUE;

+				BOOL tri_1a2 = TRUE;

+				BOOL tri_21b = TRUE;

+

+				if (area_1a2 < 0)

+				{

+					tri_1a2 = FALSE;

+				}

+				if (area_2ab < 0)

+				{

+					// Can't use, because it contains point b

+					tri_1a2 = FALSE;

+				}

+				if (area_21b < 0)

+				{

+					tri_21b = FALSE;

+				}

+				if (area_1ba < 0)

+				{

+					// Can't use, because it contains point b

+					tri_21b = FALSE;

+				}

+

+				if (!tri_1a2)

+				{

+					use_tri1a2 = FALSE;

+				}

+				else if (!tri_21b)

+				{

+					use_tri1a2 = TRUE;

+				}

+				else

+				{

+					LLVector3 d1 = p1 - pa;

+					LLVector3 d2 = p2 - pb;

+

+					if (d1.magVecSquared() < d2.magVecSquared())

+					{

+						use_tri1a2 = TRUE;

+					}

+					else

+					{

+						use_tri1a2 = FALSE;

+					}

+				}

+

+				if (use_tri1a2)

+				{

+					index[count++] = pt1;

+					index[count++] = pt2;

+					index[count++] = pt1 + 1;

+					pt1++;

+				}

+				else

+				{

+					index[count++] = pt1;

+					index[count++] = pt2;

+					index[count++] = pt2 - 1;

+					pt2--;

+				}

+			}

+		}		

+	}

+	else

+	{

+		// Closed solid.  Easy case.

+		for (t = 0; t < size_t - 1; t++)

+		{

+			for (s = 0; s < size_s - 1; s++)

+			{

+				// Should wrap properly, but for now...

+				i  = s + t*size_s;

+

+				index[count++]  = i;				// x,y

+				index[count++]  = i + 1;			// x+1,y

+				index[count++]  = i + size_s;		// x,y+1

+

+				index[count++]  = i + size_s;		// x,y+1

+				index[count++]  = i + 1;			// x+1,y

+				index[count++]  = i + size_s + 1;	// x+1,y+1

+			}

+		}

+

+		// Do the top and bottom caps, if necessary

+		if (path_open)

+		{

+			// bottom cap

+			for (s = 1; s < size_s - 2; s++)

+			{

+				index[count++] = s+1;

+				index[count++] = s;

+				index[count++] = 0;

+			}

+

+			// top cap

+			S32 offset = (size_t - 1)*size_s;

+			for (s = 1; s < size_s - 2; s++)

+			{

+				// Inverted ordering from bottom cap.

+				index[count++] = offset;

+				index[count++] = offset + s;

+				index[count++] = offset + s + 1;

+			}

+		}

+	}

+

+#ifdef LL_DEBUG

+	// assert that we computed the correct number of indices

+	if (count != expected_num_triangle_indices )

+	{

+		llerrs << "bad index count prediciton:"

+			<< "  expected=" << expected_num_triangle_indices 

+			<< " actual=" << count << llendl;

+	}

+#endif

+

+#if 0

+	// verify that each index does not point beyond the size of the mesh

+	S32 num_vertices = mMesh.size();

+	for (i = 0; i < count; i+=3)

+	{

+		llinfos << index[i] << ":" << index[i+1] << ":" << index[i+2] << llendl;

+		llassert(index[i] < num_vertices);

+		llassert(index[i+1] < num_vertices);

+		llassert(index[i+2] < num_vertices);

+	}

+#endif

+

+	num_indices = count;

+	return index;

+}

+

+S32 LLVolume::getNumTriangleIndices() const

+{

+	BOOL profile_open = getProfile().isOpen();

+	BOOL hollow = (mParams.getProfileParams().getHollow() > 0);

+	BOOL path_open = getPath().isOpen();

+

+	S32 size_s, size_s_out, size_t;

+	size_s = getProfile().getTotal();

+	size_s_out = getProfile().getTotalOut();

+	size_t = getPath().mPath.size();

+

+	S32 count = 0;

+	if (profile_open)		/* Flawfinder: ignore */

+	{

+		if (hollow)

+		{

+			// Open hollow -- much like the closed solid, except we 

+			// we need to stitch up the gap between s=0 and s=size_s-1

+			count = (size_t - 1) * (((size_s -1) * 6) + 6);

+		}

+		else

+		{

+			count = (size_t - 1) * (((size_s -1) * 6) + 6); 

+		}

+	}

+	else if (hollow)

+	{

+		// Closed hollow

+		// Outer face

+		count = (size_t - 1) * (size_s_out - 1) * 6;

+

+		// Inner face

+		count += (size_t - 1) * ((size_s - 1) - size_s_out) * 6;

+	}

+	else

+	{

+		// Closed solid.  Easy case.

+		count = (size_t - 1) * (size_s - 1) * 6;

+	}

+

+	if (path_open)

+	{

+		S32 cap_triangle_count = size_s - 3;

+		if ( profile_open

+			|| hollow )

+		{

+			cap_triangle_count = size_s - 2;

+		}

+		if ( cap_triangle_count > 0 )

+		{

+			// top and bottom caps

+			count += cap_triangle_count * 2 * 3;

+		}

+	}

+	return count;

+}

+

+

+S32 LLVolume::getNumTriangles() const

+{

+	U32 triangle_count = 0;

+

+	for (S32 i = 0; i < getNumVolumeFaces(); ++i)

+	{

+		triangle_count += getVolumeFace(i).mNumIndices/3;

+	}

+

+	return triangle_count;

+}

+

+

+//-----------------------------------------------------------------------------

+// generateSilhouetteVertices()

+//-----------------------------------------------------------------------------

+void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,

+										  std::vector<LLVector3> &normals,

+										  const LLVector3& obj_cam_vec_in,

+										  const LLMatrix4& mat_in,

+										  const LLMatrix3& norm_mat_in,

+										  S32 face_mask)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+

+	LLMatrix4a mat;

+	mat.loadu(mat_in);

+

+	LLMatrix4a norm_mat;

+	norm_mat.loadu(norm_mat_in);

+		

+	LLVector4a obj_cam_vec;

+	obj_cam_vec.load3(obj_cam_vec_in.mV);

+

+	vertices.clear();

+	normals.clear();

+

+	if ((mParams.getSculptType() & LL_SCULPT_TYPE_MASK) == LL_SCULPT_TYPE_MESH)

+	{

+		return;

+	}

+	

+	S32 cur_index = 0;

+	//for each face

+	for (face_list_t::iterator iter = mVolumeFaces.begin();

+		 iter != mVolumeFaces.end(); ++iter)

+	{

+		LLVolumeFace& face = *iter;

+	

+		if (!(face_mask & (0x1 << cur_index++)) ||

+		     face.mNumIndices == 0 || face.mEdge.empty())

+		{

+			continue;

+		}

+

+		if (face.mTypeMask & (LLVolumeFace::CAP_MASK)) {

+	

+		}

+		else {

+

+			//==============================================

+			//DEBUG draw edge map instead of silhouette edge

+			//==============================================

+

+#if DEBUG_SILHOUETTE_EDGE_MAP

+

+			//for each triangle

+			U32 count = face.mNumIndices;

+			for (U32 j = 0; j < count/3; j++) {

+				//get vertices

+				S32 v1 = face.mIndices[j*3+0];

+				S32 v2 = face.mIndices[j*3+1];

+				S32 v3 = face.mIndices[j*3+2];

+

+				//get current face center

+				LLVector3 cCenter = (face.mVertices[v1].getPosition() + 

+									face.mVertices[v2].getPosition() + 

+									face.mVertices[v3].getPosition()) / 3.0f;

+

+				//for each edge

+				for (S32 k = 0; k < 3; k++) {

+                    S32 nIndex = face.mEdge[j*3+k];

+					if (nIndex <= -1) {

+						continue;

+					}

+

+					if (nIndex >= (S32) count/3) {

+						continue;

+					}

+					//get neighbor vertices

+					v1 = face.mIndices[nIndex*3+0];

+					v2 = face.mIndices[nIndex*3+1];

+					v3 = face.mIndices[nIndex*3+2];

+

+					//get neighbor face center

+					LLVector3 nCenter = (face.mVertices[v1].getPosition() + 

+									face.mVertices[v2].getPosition() + 

+									face.mVertices[v3].getPosition()) / 3.0f;

+

+					//draw line

+					vertices.push_back(cCenter);

+					vertices.push_back(nCenter);

+					normals.push_back(LLVector3(1,1,1));

+					normals.push_back(LLVector3(1,1,1));

+					segments.push_back(vertices.size());

+				}

+			}

+		

+			continue;

+

+			//==============================================

+			//DEBUG

+			//==============================================

+

+			//==============================================

+			//DEBUG draw normals instead of silhouette edge

+			//==============================================

+#elif DEBUG_SILHOUETTE_NORMALS

+

+			//for each vertex

+			for (U32 j = 0; j < face.mNumVertices; j++) {

+				vertices.push_back(face.mVertices[j].getPosition());

+				vertices.push_back(face.mVertices[j].getPosition() + face.mVertices[j].getNormal()*0.1f);

+				normals.push_back(LLVector3(0,0,1));

+				normals.push_back(LLVector3(0,0,1));

+				segments.push_back(vertices.size());

+#if DEBUG_SILHOUETTE_BINORMALS

+				vertices.push_back(face.mVertices[j].getPosition());

+				vertices.push_back(face.mVertices[j].getPosition() + face.mVertices[j].mBinormal*0.1f);

+				normals.push_back(LLVector3(0,0,1));

+				normals.push_back(LLVector3(0,0,1));

+				segments.push_back(vertices.size());

+#endif

+			}

+						

+			continue;

+#else

+			//==============================================

+			//DEBUG

+			//==============================================

+

+			static const U8 AWAY = 0x01,

+							TOWARDS = 0x02;

+

+			//for each triangle

+			std::vector<U8> fFacing;

+			vector_append(fFacing, face.mNumIndices/3);

+

+			LLVector4a* v = (LLVector4a*) face.mPositions;

+			LLVector4a* n = (LLVector4a*) face.mNormals;

+

+			for (U32 j = 0; j < face.mNumIndices/3; j++) 

+			{

+				//approximate normal

+				S32 v1 = face.mIndices[j*3+0];

+				S32 v2 = face.mIndices[j*3+1];

+				S32 v3 = face.mIndices[j*3+2];

+

+				LLVector4a c1,c2;

+				c1.setSub(v[v1], v[v2]);

+				c2.setSub(v[v2], v[v3]);

+

+				LLVector4a norm;

+

+				norm.setCross3(c1, c2);

+

+				if (norm.dot3(norm) < 0.00000001f) 

+				{

+					fFacing[j] = AWAY | TOWARDS;

+				}

+				else 

+				{

+					//get view vector

+					LLVector4a view;

+					view.setSub(obj_cam_vec, v[v1]);

+					bool away = view.dot3(norm) > 0.0f; 

+					if (away) 

+					{

+						fFacing[j] = AWAY;

+					}

+					else 

+					{

+						fFacing[j] = TOWARDS;

+					}

+				}

+			}

+			

+			//for each triangle

+			for (U32 j = 0; j < face.mNumIndices/3; j++) 

+			{

+				if (fFacing[j] == (AWAY | TOWARDS)) 

+				{ //this is a degenerate triangle

+					//take neighbor facing (degenerate faces get facing of one of their neighbors)

+					// *FIX IF NEEDED:  this does not deal with neighboring degenerate faces

+					for (S32 k = 0; k < 3; k++) 

+					{

+						S32 index = face.mEdge[j*3+k];

+						if (index != -1) 

+						{

+							fFacing[j] = fFacing[index];

+							break;

+						}

+					}

+					continue; //skip degenerate face

+				}

+

+				//for each edge

+				for (S32 k = 0; k < 3; k++) {

+					S32 index = face.mEdge[j*3+k];

+					if (index != -1 && fFacing[index] == (AWAY | TOWARDS)) {

+						//our neighbor is degenerate, make him face our direction

+						fFacing[face.mEdge[j*3+k]] = fFacing[j];

+						continue;

+					}

+

+					if (index == -1 ||		//edge has no neighbor, MUST be a silhouette edge

+						(fFacing[index] & fFacing[j]) == 0) { 	//we found a silhouette edge

+

+						S32 v1 = face.mIndices[j*3+k];

+						S32 v2 = face.mIndices[j*3+((k+1)%3)];

+						

+						LLVector4a t;

+						mat.affineTransform(v[v1], t);

+						vertices.push_back(LLVector3(t[0], t[1], t[2]));

+

+						norm_mat.rotate(n[v1], t);

+

+						t.normalize3fast();

+						normals.push_back(LLVector3(t[0], t[1], t[2]));

+

+						mat.affineTransform(v[v2], t);

+						vertices.push_back(LLVector3(t[0], t[1], t[2]));

+						

+						norm_mat.rotate(n[v2], t);

+						t.normalize3fast();

+						normals.push_back(LLVector3(t[0], t[1], t[2]));

+					}

+				}		

+			}

+#endif

+		}

+	}

+}

+

+S32 LLVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, 

+								   S32 face,

+								   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)

+{

+	LLVector4a starta, enda;

+	starta.load3(start.mV);

+	enda.load3(end.mV);

+

+	return lineSegmentIntersect(starta, enda, face, intersection, tex_coord, normal, bi_normal);

+

+}

+

+

+S32 LLVolume::lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end, 

+								   S32 face,

+								   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)

+{

+	S32 hit_face = -1;

+	

+	S32 start_face;

+	S32 end_face;

+	

+	if (face == -1) // ALL_SIDES

+	{

+		start_face = 0;

+		end_face = getNumVolumeFaces() - 1;

+	}

+	else

+	{

+		start_face = face;

+		end_face = face;

+	}

+

+	LLVector4a dir;

+	dir.setSub(end, start);

+

+	F32 closest_t = 2.f; // must be larger than 1

+	

+	end_face = llmin(end_face, getNumVolumeFaces()-1);

+

+	for (S32 i = start_face; i <= end_face; i++)

+	{

+		LLVolumeFace &face = mVolumeFaces[i];

+

+		LLVector4a box_center;

+		box_center.setAdd(face.mExtents[0], face.mExtents[1]);

+		box_center.mul(0.5f);

+

+		LLVector4a box_size;

+		box_size.setSub(face.mExtents[1], face.mExtents[0]);

+

+        if (LLLineSegmentBoxIntersect(start, end, box_center, box_size))

+		{

+			if (bi_normal != NULL) // if the caller wants binormals, we may need to generate them

+			{

+				genBinormals(i);

+			}

+

+			if (!face.mOctree)

+			{

+				face.createOctree();

+			}

+			

+			//LLVector4a* p = (LLVector4a*) face.mPositions;

+

+			LLOctreeTriangleRayIntersect intersect(start, dir, &face, &closest_t, intersection, tex_coord, normal, bi_normal);

+			intersect.traverse(face.mOctree);

+			if (intersect.mHitFace)

+			{

+				hit_face = i;

+			}

+		}		

+	}

+	

+	

+	return hit_face;

+}

+

+class LLVertexIndexPair

+{

+public:

+	LLVertexIndexPair(const LLVector3 &vertex, const S32 index);

+

+	LLVector3 mVertex;

+	S32	mIndex;

+};

+

+LLVertexIndexPair::LLVertexIndexPair(const LLVector3 &vertex, const S32 index)

+{

+	mVertex = vertex;

+	mIndex = index;

+}

+

+const F32 VERTEX_SLOP = 0.00001f;

+const F32 VERTEX_SLOP_SQRD = VERTEX_SLOP * VERTEX_SLOP;

+

+struct lessVertex

+{

+	bool operator()(const LLVertexIndexPair *a, const LLVertexIndexPair *b)

+	{

+		const F32 slop = VERTEX_SLOP;

+

+		if (a->mVertex.mV[0] + slop < b->mVertex.mV[0])

+		{

+			return TRUE;

+		}

+		else if (a->mVertex.mV[0] - slop > b->mVertex.mV[0])

+		{

+			return FALSE;

+		}

+		

+		if (a->mVertex.mV[1] + slop < b->mVertex.mV[1])

+		{

+			return TRUE;

+		}

+		else if (a->mVertex.mV[1] - slop > b->mVertex.mV[1])

+		{

+			return FALSE;

+		}

+		

+		if (a->mVertex.mV[2] + slop < b->mVertex.mV[2])

+		{

+			return TRUE;

+		}

+		else if (a->mVertex.mV[2] - slop > b->mVertex.mV[2])

+		{

+			return FALSE;

+		}

+		

+		return FALSE;

+	}

+};

+

+struct lessTriangle

+{

+	bool operator()(const S32 *a, const S32 *b)

+	{

+		if (*a < *b)

+		{

+			return TRUE;

+		}

+		else if (*a > *b)

+		{

+			return FALSE;

+		}

+

+		if (*(a+1) < *(b+1))

+		{

+			return TRUE;

+		}

+		else if (*(a+1) > *(b+1))

+		{

+			return FALSE;

+		}

+

+		if (*(a+2) < *(b+2))

+		{

+			return TRUE;

+		}

+		else if (*(a+2) > *(b+2))

+		{

+			return FALSE;

+		}

+

+		return FALSE;

+	}

+};

+

+BOOL equalTriangle(const S32 *a, const S32 *b)

+{

+	if ((*a == *b) && (*(a+1) == *(b+1)) && (*(a+2) == *(b+2)))

+	{

+		return TRUE;

+	}

+	return FALSE;

+}

+

+BOOL LLVolume::cleanupTriangleData( const S32 num_input_vertices,

+									const std::vector<Point>& input_vertices,

+									const S32 num_input_triangles,

+									S32 *input_triangles,

+									S32 &num_output_vertices,

+									LLVector3 **output_vertices,

+									S32 &num_output_triangles,

+									S32 **output_triangles)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	/* Testing: avoid any cleanup

+	static BOOL skip_cleanup = TRUE;

+	if ( skip_cleanup )

+	{

+		num_output_vertices = num_input_vertices;

+		num_output_triangles = num_input_triangles;

+

+		*output_vertices = new LLVector3[num_input_vertices];

+		for (S32 index = 0; index < num_input_vertices; index++)

+		{

+			(*output_vertices)[index] = input_vertices[index].mPos;

+		}

+

+		*output_triangles = new S32[num_input_triangles*3];

+		memcpy(*output_triangles, input_triangles, 3*num_input_triangles*sizeof(S32));		// Flawfinder: ignore

+		return TRUE;

+	}

+	*/

+

+	// Here's how we do this:

+	// Create a structure which contains the original vertex index and the

+	// LLVector3 data.

+	// "Sort" the data by the vectors

+	// Create an array the size of the old vertex list, with a mapping of

+	// old indices to new indices.

+	// Go through triangles, shift so the lowest index is first

+	// Sort triangles by first index

+	// Remove duplicate triangles

+	// Allocate and pack new triangle data.

+

+	//LLTimer cleanupTimer;

+	//llinfos << "In vertices: " << num_input_vertices << llendl;

+	//llinfos << "In triangles: " << num_input_triangles << llendl;

+

+	S32 i;

+	typedef std::multiset<LLVertexIndexPair*, lessVertex> vertex_set_t;

+	vertex_set_t vertex_list;

+

+	LLVertexIndexPair *pairp = NULL;

+	for (i = 0; i < num_input_vertices; i++)

+	{

+		LLVertexIndexPair *new_pairp = new LLVertexIndexPair(input_vertices[i].mPos, i);

+		vertex_list.insert(new_pairp);

+	}

+

+	// Generate the vertex mapping and the list of vertices without

+	// duplicates.  This will crash if there are no vertices.

+	llassert(num_input_vertices > 0); // check for no vertices!

+	S32 *vertex_mapping = new S32[num_input_vertices];

+	LLVector3 *new_vertices = new LLVector3[num_input_vertices];

+	LLVertexIndexPair *prev_pairp = NULL;

+

+	S32 new_num_vertices;

+

+	new_num_vertices = 0;

+	for (vertex_set_t::iterator iter = vertex_list.begin(),

+			 end = vertex_list.end();

+		 iter != end; iter++)

+	{

+		pairp = *iter;

+		if (!prev_pairp || ((pairp->mVertex - prev_pairp->mVertex).magVecSquared() >= VERTEX_SLOP_SQRD))	

+		{

+			new_vertices[new_num_vertices] = pairp->mVertex;

+			//llinfos << "Added vertex " << new_num_vertices << " : " << pairp->mVertex << llendl;

+			new_num_vertices++;

+			// Update the previous

+			prev_pairp = pairp;

+		}

+		else

+		{

+			//llinfos << "Removed duplicate vertex " << pairp->mVertex << ", distance magVecSquared() is " << (pairp->mVertex - prev_pairp->mVertex).magVecSquared() << llendl;

+		}

+		vertex_mapping[pairp->mIndex] = new_num_vertices - 1;

+	}

+

+	// Iterate through triangles and remove degenerates, re-ordering vertices

+	// along the way.

+	S32 *new_triangles = new S32[num_input_triangles * 3];

+	S32 new_num_triangles = 0;

+

+	for (i = 0; i < num_input_triangles; i++)

+	{

+		S32 v1 = i*3;

+		S32 v2 = v1 + 1;

+		S32 v3 = v1 + 2;

+

+		//llinfos << "Checking triangle " << input_triangles[v1] << ":" << input_triangles[v2] << ":" << input_triangles[v3] << llendl;

+		input_triangles[v1] = vertex_mapping[input_triangles[v1]];

+		input_triangles[v2] = vertex_mapping[input_triangles[v2]];

+		input_triangles[v3] = vertex_mapping[input_triangles[v3]];

+

+		if ((input_triangles[v1] == input_triangles[v2])

+			|| (input_triangles[v1] == input_triangles[v3])

+			|| (input_triangles[v2] == input_triangles[v3]))

+		{

+			//llinfos << "Removing degenerate triangle " << input_triangles[v1] << ":" << input_triangles[v2] << ":" << input_triangles[v3] << llendl;

+			// Degenerate triangle, skip

+			continue;

+		}

+

+		if (input_triangles[v1] < input_triangles[v2])

+		{

+			if (input_triangles[v1] < input_triangles[v3])

+			{

+				// (0 < 1) && (0 < 2)

+				new_triangles[new_num_triangles*3] = input_triangles[v1];

+				new_triangles[new_num_triangles*3+1] = input_triangles[v2];

+				new_triangles[new_num_triangles*3+2] = input_triangles[v3];

+			}

+			else

+			{

+				// (0 < 1) && (2 < 0)

+				new_triangles[new_num_triangles*3] = input_triangles[v3];

+				new_triangles[new_num_triangles*3+1] = input_triangles[v1];

+				new_triangles[new_num_triangles*3+2] = input_triangles[v2];

+			}

+		}

+		else if (input_triangles[v2] < input_triangles[v3])

+		{

+			// (1 < 0) && (1 < 2)

+			new_triangles[new_num_triangles*3] = input_triangles[v2];

+			new_triangles[new_num_triangles*3+1] = input_triangles[v3];

+			new_triangles[new_num_triangles*3+2] = input_triangles[v1];

+		}

+		else

+		{

+			// (1 < 0) && (2 < 1)

+			new_triangles[new_num_triangles*3] = input_triangles[v3];

+			new_triangles[new_num_triangles*3+1] = input_triangles[v1];

+			new_triangles[new_num_triangles*3+2] = input_triangles[v2];

+		}

+		new_num_triangles++;

+	}

+

+	if (new_num_triangles == 0)

+	{

+		llwarns << "Created volume object with 0 faces." << llendl;

+		delete[] new_triangles;

+		delete[] vertex_mapping;

+		delete[] new_vertices;

+		return FALSE;

+	}

+

+	typedef std::set<S32*, lessTriangle> triangle_set_t;

+	triangle_set_t triangle_list;

+

+	for (i = 0; i < new_num_triangles; i++)

+	{

+		triangle_list.insert(&new_triangles[i*3]);

+	}

+

+	// Sort through the triangle list, and delete duplicates

+

+	S32 *prevp = NULL;

+	S32 *curp = NULL;

+

+	S32 *sorted_tris = new S32[new_num_triangles*3];

+	S32 cur_tri = 0;

+	for (triangle_set_t::iterator iter = triangle_list.begin(),

+			 end = triangle_list.end();

+		 iter != end; iter++)

+	{

+		curp = *iter;

+		if (!prevp || !equalTriangle(prevp, curp))

+		{

+			//llinfos << "Added triangle " << *curp << ":" << *(curp+1) << ":" << *(curp+2) << llendl;

+			sorted_tris[cur_tri*3] = *curp;

+			sorted_tris[cur_tri*3+1] = *(curp+1);

+			sorted_tris[cur_tri*3+2] = *(curp+2);

+			cur_tri++;

+			prevp = curp;

+		}

+		else

+		{

+			//llinfos << "Skipped triangle " << *curp << ":" << *(curp+1) << ":" << *(curp+2) << llendl;

+		}

+	}

+

+	*output_vertices = new LLVector3[new_num_vertices];

+	num_output_vertices = new_num_vertices;

+	for (i = 0; i < new_num_vertices; i++)

+	{

+		(*output_vertices)[i] = new_vertices[i];

+	}

+

+	*output_triangles = new S32[cur_tri*3];

+	num_output_triangles = cur_tri;

+	memcpy(*output_triangles, sorted_tris, 3*cur_tri*sizeof(S32));		/* Flawfinder: ignore */

+

+	/*

+	llinfos << "Out vertices: " << num_output_vertices << llendl;

+	llinfos << "Out triangles: " << num_output_triangles << llendl;

+	for (i = 0; i < num_output_vertices; i++)

+	{

+		llinfos << i << ":" << (*output_vertices)[i] << llendl;

+	}

+	for (i = 0; i < num_output_triangles; i++)

+	{

+		llinfos << i << ":" << (*output_triangles)[i*3] << ":" << (*output_triangles)[i*3+1] << ":" << (*output_triangles)[i*3+2] << llendl;

+	}

+	*/

+

+	//llinfos << "Out vertices: " << num_output_vertices << llendl;

+	//llinfos << "Out triangles: " << num_output_triangles << llendl;

+	delete[] vertex_mapping;

+	vertex_mapping = NULL;

+	delete[] new_vertices;

+	new_vertices = NULL;

+	delete[] new_triangles;

+	new_triangles = NULL;

+	delete[] sorted_tris;

+	sorted_tris = NULL;

+	triangle_list.clear();

+	std::for_each(vertex_list.begin(), vertex_list.end(), DeletePointer());

+	vertex_list.clear();

+	

+	return TRUE;

+}

+

+

+BOOL LLVolumeParams::importFile(LLFILE *fp)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	//llinfos << "importing volume" << llendl;

+	const S32 BUFSIZE = 16384;

+	char buffer[BUFSIZE];	/* Flawfinder: ignore */

+	// *NOTE: changing the size or type of this buffer will require

+	// changing the sscanf below.

+	char keyword[256];	/* Flawfinder: ignore */

+	keyword[0] = 0;

+

+	while (!feof(fp))

+	{

+		if (fgets(buffer, BUFSIZE, fp) == NULL)

+		{

+			buffer[0] = '\0';

+		}

+		

+		sscanf(buffer, " %255s", keyword);	/* Flawfinder: ignore */

+		if (!strcmp("{", keyword))

+		{

+			continue;

+		}

+		if (!strcmp("}",keyword))

+		{

+			break;

+		}

+		else if (!strcmp("profile", keyword))

+		{

+			mProfileParams.importFile(fp);

+		}

+		else if (!strcmp("path",keyword))

+		{

+			mPathParams.importFile(fp);

+		}

+		else

+		{

+			llwarns << "unknown keyword " << keyword << " in volume import" << llendl;

+		}

+	}

+

+	return TRUE;

+}

+

+BOOL LLVolumeParams::exportFile(LLFILE *fp) const

+{

+	fprintf(fp,"\tshape 0\n");

+	fprintf(fp,"\t{\n");

+	mPathParams.exportFile(fp);

+	mProfileParams.exportFile(fp);

+	fprintf(fp, "\t}\n");

+	return TRUE;

+}

+

+

+BOOL LLVolumeParams::importLegacyStream(std::istream& input_stream)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	//llinfos << "importing volume" << llendl;

+	const S32 BUFSIZE = 16384;

+	// *NOTE: changing the size or type of this buffer will require

+	// changing the sscanf below.

+	char buffer[BUFSIZE];		/* Flawfinder: ignore */

+	char keyword[256];		/* Flawfinder: ignore */

+	keyword[0] = 0;

+

+	while (input_stream.good())

+	{

+		input_stream.getline(buffer, BUFSIZE);

+		sscanf(buffer, " %255s", keyword);

+		if (!strcmp("{", keyword))

+		{

+			continue;

+		}

+		if (!strcmp("}",keyword))

+		{

+			break;

+		}

+		else if (!strcmp("profile", keyword))

+		{

+			mProfileParams.importLegacyStream(input_stream);

+		}

+		else if (!strcmp("path",keyword))

+		{

+			mPathParams.importLegacyStream(input_stream);

+		}

+		else

+		{

+			llwarns << "unknown keyword " << keyword << " in volume import" << llendl;

+		}

+	}

+

+	return TRUE;

+}

+

+BOOL LLVolumeParams::exportLegacyStream(std::ostream& output_stream) const

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	output_stream <<"\tshape 0\n";

+	output_stream <<"\t{\n";

+	mPathParams.exportLegacyStream(output_stream);

+	mProfileParams.exportLegacyStream(output_stream);

+	output_stream << "\t}\n";

+	return TRUE;

+}

+

+LLSD LLVolumeParams::sculptAsLLSD() const

+{

+	LLSD sd = LLSD();

+	sd["id"] = getSculptID();

+	sd["type"] = getSculptType();

+

+	return sd;

+}

+

+bool LLVolumeParams::sculptFromLLSD(LLSD& sd)

+{

+	setSculptID(sd["id"].asUUID(), (U8)sd["type"].asInteger());

+	return true;

+}

+

+LLSD LLVolumeParams::asLLSD() const

+{

+	LLSD sd = LLSD();

+	sd["path"] = mPathParams;

+	sd["profile"] = mProfileParams;

+	sd["sculpt"] = sculptAsLLSD();

+	

+	return sd;

+}

+

+bool LLVolumeParams::fromLLSD(LLSD& sd)

+{

+	mPathParams.fromLLSD(sd["path"]);

+	mProfileParams.fromLLSD(sd["profile"]);

+	sculptFromLLSD(sd["sculpt"]);

+		

+	return true;

+}

+

+void LLVolumeParams::reduceS(F32 begin, F32 end)

+{

+	begin = llclampf(begin);

+	end = llclampf(end);

+	if (begin > end)

+	{

+		F32 temp = begin;

+		begin = end;

+		end = temp;

+	}

+	F32 a = mProfileParams.getBegin();

+	F32 b = mProfileParams.getEnd();

+	mProfileParams.setBegin(a + begin * (b - a));

+	mProfileParams.setEnd(a + end * (b - a));

+}

+

+void LLVolumeParams::reduceT(F32 begin, F32 end)

+{

+	begin = llclampf(begin);

+	end = llclampf(end);

+	if (begin > end)

+	{

+		F32 temp = begin;

+		begin = end;

+		end = temp;

+	}

+	F32 a = mPathParams.getBegin();

+	F32 b = mPathParams.getEnd();

+	mPathParams.setBegin(a + begin * (b - a));

+	mPathParams.setEnd(a + end * (b - a));

+}

+

+const F32 MIN_CONCAVE_PROFILE_WEDGE = 0.125f;	// 1/8 unity

+const F32 MIN_CONCAVE_PATH_WEDGE = 0.111111f;	// 1/9 unity

+

+// returns TRUE if the shape can be approximated with a convex shape 

+// for collison purposes

+BOOL LLVolumeParams::isConvex() const

+{

+	if (!getSculptID().isNull())

+	{

+		// can't determine, be safe and say no:

+		return FALSE;

+	}

+	

+	F32 path_length = mPathParams.getEnd() - mPathParams.getBegin();

+	F32 hollow = mProfileParams.getHollow();

+	 

+	U8 path_type = mPathParams.getCurveType();

+	if ( path_length > MIN_CONCAVE_PATH_WEDGE

+		&& ( mPathParams.getTwist() != mPathParams.getTwistBegin()

+		     || (hollow > 0.f 

+				 && LL_PCODE_PATH_LINE != path_type) ) )

+	{

+		// twist along a "not too short" path is concave

+		return FALSE;

+	}

+

+	F32 profile_length = mProfileParams.getEnd() - mProfileParams.getBegin();

+	BOOL same_hole = hollow == 0.f 

+					 || (mProfileParams.getCurveType() & LL_PCODE_HOLE_MASK) == LL_PCODE_HOLE_SAME;

+

+	F32 min_profile_wedge = MIN_CONCAVE_PROFILE_WEDGE;

+	U8 profile_type = mProfileParams.getCurveType() & LL_PCODE_PROFILE_MASK;

+	if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type )

+	{

+		// it is a sphere and spheres get twice the minimum profile wedge

+		min_profile_wedge = 2.f * MIN_CONCAVE_PROFILE_WEDGE;

+	}

+

+	BOOL convex_profile = ( ( profile_length == 1.f

+						     || profile_length <= 0.5f )

+						   && hollow == 0.f )						// trivially convex

+						  || ( profile_length <= min_profile_wedge

+							  && same_hole );						// effectvely convex (even when hollow)

+

+	if (!convex_profile)

+	{

+		// profile is concave

+		return FALSE;

+	}

+

+	if ( LL_PCODE_PATH_LINE == path_type )

+	{

+		// straight paths with convex profile

+		return TRUE;

+	}

+

+	BOOL concave_path = (path_length < 1.0f) && (path_length > 0.5f);

+	if (concave_path)

+	{

+		return FALSE;

+	}

+

+	// we're left with spheres, toroids and tubes

+	if ( LL_PCODE_PROFILE_CIRCLE_HALF == profile_type )

+	{

+		// at this stage all spheres must be convex

+		return TRUE;

+	}

+

+	// it's a toroid or tube		

+	if ( path_length <= MIN_CONCAVE_PATH_WEDGE )

+	{

+		// effectively convex

+		return TRUE;

+	}

+

+	return FALSE;

+}

+

+// debug

+void LLVolumeParams::setCube()

+{

+	mProfileParams.setCurveType(LL_PCODE_PROFILE_SQUARE);

+	mProfileParams.setBegin(0.f);

+	mProfileParams.setEnd(1.f);

+	mProfileParams.setHollow(0.f);

+

+	mPathParams.setBegin(0.f);

+	mPathParams.setEnd(1.f);

+	mPathParams.setScale(1.f, 1.f);

+	mPathParams.setShear(0.f, 0.f);

+	mPathParams.setCurveType(LL_PCODE_PATH_LINE);

+	mPathParams.setTwistBegin(0.f);

+	mPathParams.setTwistEnd(0.f);

+	mPathParams.setRadiusOffset(0.f);

+	mPathParams.setTaper(0.f, 0.f);

+	mPathParams.setRevolutions(0.f);

+	mPathParams.setSkew(0.f);

+}

+

+LLFaceID LLVolume::generateFaceMask()

+{

+	LLFaceID new_mask = 0x0000;

+

+	switch(mParams.getProfileParams().getCurveType() & LL_PCODE_PROFILE_MASK)

+	{

+	case LL_PCODE_PROFILE_CIRCLE:

+	case LL_PCODE_PROFILE_CIRCLE_HALF:

+		new_mask |= LL_FACE_OUTER_SIDE_0;

+		break;

+	case LL_PCODE_PROFILE_SQUARE:

+		{

+			for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 4.f); side < llceil(mParams.getProfileParams().getEnd() * 4.f); side++)

+			{

+				new_mask |= LL_FACE_OUTER_SIDE_0 << side;

+			}

+		}

+		break;

+	case LL_PCODE_PROFILE_ISOTRI:

+	case LL_PCODE_PROFILE_EQUALTRI:

+	case LL_PCODE_PROFILE_RIGHTTRI:

+		{

+			for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 3.f); side < llceil(mParams.getProfileParams().getEnd() * 3.f); side++)

+			{

+				new_mask |= LL_FACE_OUTER_SIDE_0 << side;

+			}

+		}

+		break;

+	default:

+		llerrs << "Unknown profile!" << llendl;

+		break;

+	}

+

+	// handle hollow objects

+	if (mParams.getProfileParams().getHollow() > 0)

+	{

+		new_mask |= LL_FACE_INNER_SIDE;

+	}

+

+	// handle open profile curves

+	if (mProfilep->isOpen())

+	{

+		new_mask |= LL_FACE_PROFILE_BEGIN | LL_FACE_PROFILE_END;

+	}

+

+	// handle open path curves

+	if (mPathp->isOpen())

+	{

+		new_mask |= LL_FACE_PATH_BEGIN | LL_FACE_PATH_END;

+	}

+

+	return new_mask;

+}

+

+BOOL LLVolume::isFaceMaskValid(LLFaceID face_mask)

+{

+	LLFaceID test_mask = 0;

+	for(S32 i = 0; i < getNumFaces(); i++)

+	{

+		test_mask |= mProfilep->mFaces[i].mFaceID;

+	}

+

+	return test_mask == face_mask;

+}

+

+BOOL LLVolume::isConvex() const

+{

+	// mParams.isConvex() may return FALSE even though the final

+	// geometry is actually convex due to LOD approximations.

+	// TODO -- provide LLPath and LLProfile with isConvex() methods

+	// that correctly determine convexity. -- Leviathan

+	return mParams.isConvex();

+}

+

+

+std::ostream& operator<<(std::ostream &s, const LLProfileParams &profile_params)

+{

+	s << "{type=" << (U32) profile_params.mCurveType;

+	s << ", begin=" << profile_params.mBegin;

+	s << ", end=" << profile_params.mEnd;

+	s << ", hollow=" << profile_params.mHollow;

+	s << "}";

+	return s;

+}

+

+

+std::ostream& operator<<(std::ostream &s, const LLPathParams &path_params)

+{

+	s << "{type=" << (U32) path_params.mCurveType;

+	s << ", begin=" << path_params.mBegin;

+	s << ", end=" << path_params.mEnd;

+	s << ", twist=" << path_params.mTwistEnd;

+	s << ", scale=" << path_params.mScale;

+	s << ", shear=" << path_params.mShear;

+	s << ", twist_begin=" << path_params.mTwistBegin;

+	s << ", radius_offset=" << path_params.mRadiusOffset;

+	s << ", taper=" << path_params.mTaper;

+	s << ", revolutions=" << path_params.mRevolutions;

+	s << ", skew=" << path_params.mSkew;

+	s << "}";

+	return s;

+}

+

+

+std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params)

+{

+	s << "{profileparams = " << volume_params.mProfileParams;

+	s << ", pathparams = " << volume_params.mPathParams;

+	s << "}";

+	return s;

+}

+

+

+std::ostream& operator<<(std::ostream &s, const LLProfile &profile)

+{

+	s << " {open=" << (U32) profile.mOpen;

+	s << ", dirty=" << profile.mDirty;

+	s << ", totalout=" << profile.mTotalOut;

+	s << ", total=" << profile.mTotal;

+	s << "}";

+	return s;

+}

+

+

+std::ostream& operator<<(std::ostream &s, const LLPath &path)

+{

+	s << "{open=" << (U32) path.mOpen;

+	s << ", dirty=" << path.mDirty;

+	s << ", step=" << path.mStep;

+	s << ", total=" << path.mTotal;

+	s << "}";

+	return s;

+}

+

+std::ostream& operator<<(std::ostream &s, const LLVolume &volume)

+{

+	s << "{params = " << volume.getParams();

+	s << ", path = " << *volume.mPathp;

+	s << ", profile = " << *volume.mProfilep;

+	s << "}";

+	return s;

+}

+

+

+std::ostream& operator<<(std::ostream &s, const LLVolume *volumep)

+{

+	s << "{params = " << volumep->getParams();

+	s << ", path = " << *(volumep->mPathp);

+	s << ", profile = " << *(volumep->mProfilep);

+	s << "}";

+	return s;

+}

+

+LLVolumeFace::LLVolumeFace() : 

+	mID(0),

+	mTypeMask(0),

+	mBeginS(0),

+	mBeginT(0),

+	mNumS(0),

+	mNumT(0),

+	mNumVertices(0),

+	mNumIndices(0),

+	mPositions(NULL),

+	mNormals(NULL),

+	mBinormals(NULL),

+	mTexCoords(NULL),

+	mIndices(NULL),

+	mWeights(NULL),

+	mOctree(NULL)

+{

+	mExtents = (LLVector4a*) malloc(sizeof(LLVector4a)*3);

+	mCenter = mExtents+2;

+}

+

+LLVolumeFace::LLVolumeFace(const LLVolumeFace& src)

+:	mID(0),

+	mTypeMask(0),

+	mBeginS(0),

+	mBeginT(0),

+	mNumS(0),

+	mNumT(0),

+	mNumVertices(0),

+	mNumIndices(0),

+	mPositions(NULL),

+	mNormals(NULL),

+	mBinormals(NULL),

+	mTexCoords(NULL),

+	mIndices(NULL),

+	mWeights(NULL),

+	mOctree(NULL)

+{ 

+	mExtents = (LLVector4a*) malloc(sizeof(LLVector4a)*3);

+	mCenter = mExtents+2;

+	*this = src;

+}

+

+LLVolumeFace& LLVolumeFace::operator=(const LLVolumeFace& src)

+{

+	if (&src == this)

+	{ //self assignment, do nothing

+		return *this;

+	}

+

+	mID = src.mID;

+	mTypeMask = src.mTypeMask;

+	mBeginS = src.mBeginS;

+	mBeginT = src.mBeginT;

+	mNumS = src.mNumS;

+	mNumT = src.mNumT;

+

+	mExtents[0] = src.mExtents[0];

+	mExtents[1] = src.mExtents[1];

+	*mCenter = *src.mCenter;

+

+	mNumVertices = 0;

+	mNumIndices = 0;

+

+	freeData();

+	

+	LLVector4a::memcpyNonAliased16((F32*) mExtents, (F32*) src.mExtents, 3*sizeof(LLVector4a));

+

+	resizeVertices(src.mNumVertices);

+	resizeIndices(src.mNumIndices);

+

+	if (mNumVertices)

+	{

+		S32 vert_size = mNumVertices*sizeof(LLVector4a);

+		S32 tc_size = (mNumVertices*sizeof(LLVector2)+0xF) & ~0xF;

+			

+		LLVector4a::memcpyNonAliased16((F32*) mPositions, (F32*) src.mPositions, vert_size);

+		LLVector4a::memcpyNonAliased16((F32*) mNormals, (F32*) src.mNormals, vert_size);

+		LLVector4a::memcpyNonAliased16((F32*) mTexCoords, (F32*) src.mTexCoords, tc_size);

+

+

+		if (src.mBinormals)

+		{

+			allocateBinormals(src.mNumVertices);

+			LLVector4a::memcpyNonAliased16((F32*) mBinormals, (F32*) src.mBinormals, vert_size);

+		}

+		else

+		{

+			free(mBinormals);

+			mBinormals = NULL;

+		}

+

+		if (src.mWeights)

+		{

+			allocateWeights(src.mNumVertices);

+			LLVector4a::memcpyNonAliased16((F32*) mWeights, (F32*) src.mWeights, vert_size);

+		}

+		else

+		{

+			free(mWeights);

+			mWeights = NULL;

+		}

+	}

+

+	if (mNumIndices)

+	{

+		S32 idx_size = (mNumIndices*sizeof(U16)+0xF) & ~0xF;

+		

+		LLVector4a::memcpyNonAliased16((F32*) mIndices, (F32*) src.mIndices, idx_size);

+	}

+	

+	//delete 

+	return *this;

+}

+

+LLVolumeFace::~LLVolumeFace()

+{

+	free(mExtents);

+	mExtents = NULL;

+

+	freeData();

+}

+

+void LLVolumeFace::freeData()

+{

+	free(mPositions);

+	mPositions = NULL;

+	free( mNormals);

+	mNormals = NULL;

+	free(mTexCoords);

+	mTexCoords = NULL;

+	free(mIndices);

+	mIndices = NULL;

+	free(mBinormals);

+	mBinormals = NULL;

+	free(mWeights);

+	mWeights = NULL;

+

+	delete mOctree;

+	mOctree = NULL;

+}

+

+BOOL LLVolumeFace::create(LLVolume* volume, BOOL partial_build)

+{

+	//tree for this face is no longer valid

+	delete mOctree;

+	mOctree = NULL;

+

+	BOOL ret = FALSE ;

+	if (mTypeMask & CAP_MASK)

+	{

+		ret = createCap(volume, partial_build);

+	}

+	else if ((mTypeMask & END_MASK) || (mTypeMask & SIDE_MASK))

+	{

+		ret = createSide(volume, partial_build);

+	}

+	else

+	{

+		llerrs << "Unknown/uninitialized face type!" << llendl;

+	}

+

+	//update the range of the texture coordinates

+	if(ret)

+	{

+		mTexCoordExtents[0].setVec(1.f, 1.f) ;

+		mTexCoordExtents[1].setVec(0.f, 0.f) ;

+

+		for(U32 i = 0 ; i < mNumVertices ; i++)

+		{

+			if(mTexCoordExtents[0].mV[0] > mTexCoords[i].mV[0])

+			{

+				mTexCoordExtents[0].mV[0] = mTexCoords[i].mV[0] ;

+			}

+			if(mTexCoordExtents[1].mV[0] < mTexCoords[i].mV[0])

+			{

+				mTexCoordExtents[1].mV[0] = mTexCoords[i].mV[0] ;

+			}

+

+			if(mTexCoordExtents[0].mV[1] > mTexCoords[i].mV[1])

+			{

+				mTexCoordExtents[0].mV[1] = mTexCoords[i].mV[1] ;

+			}

+			if(mTexCoordExtents[1].mV[1] < mTexCoords[i].mV[1])

+			{

+				mTexCoordExtents[1].mV[1] = mTexCoords[i].mV[1] ;

+			}			

+		}

+		mTexCoordExtents[0].mV[0] = llmax(0.f, mTexCoordExtents[0].mV[0]) ;

+		mTexCoordExtents[0].mV[1] = llmax(0.f, mTexCoordExtents[0].mV[1]) ;

+		mTexCoordExtents[1].mV[0] = llmin(1.f, mTexCoordExtents[1].mV[0]) ;

+		mTexCoordExtents[1].mV[1] = llmin(1.f, mTexCoordExtents[1].mV[1]) ;

+	}

+

+	return ret ;

+}

+

+void LLVolumeFace::getVertexData(U16 index, LLVolumeFace::VertexData& cv)

+{

+	cv.setPosition(mPositions[index]);

+	cv.setNormal(mNormals[index]);

+	cv.mTexCoord = mTexCoords[index];

+}

+

+bool LLVolumeFace::VertexMapData::operator==(const LLVolumeFace::VertexData& rhs) const

+{

+	return getPosition().equals3(rhs.getPosition()) &&

+		mTexCoord == rhs.mTexCoord &&

+		getNormal().equals3(rhs.getNormal());

+}

+

+bool LLVolumeFace::VertexMapData::ComparePosition::operator()(const LLVector3& a, const LLVector3& b) const

+{

+	if (a.mV[0] != b.mV[0])

+	{

+		return a.mV[0] < b.mV[0];

+	}

+	

+	if (a.mV[1] != b.mV[1])

+	{

+		return a.mV[1] < b.mV[1];

+	}

+	

+	return a.mV[2] < b.mV[2];

+}

+

+void LLVolumeFace::optimize(F32 angle_cutoff)

+{

+	LLVolumeFace new_face;

+

+	//map of points to vector of vertices at that point

+	VertexMapData::PointMap point_map;

+

+	//remove redundant vertices

+	for (U32 i = 0; i < mNumIndices; ++i)

+	{

+		U16 index = mIndices[i];

+

+		LLVolumeFace::VertexData cv;

+		getVertexData(index, cv);

+		

+		BOOL found = FALSE;

+		VertexMapData::PointMap::iterator point_iter = point_map.find(LLVector3(cv.getPosition().getF32ptr()));

+		if (point_iter != point_map.end())

+		{ //duplicate point might exist

+			for (U32 j = 0; j < point_iter->second.size(); ++j)

+			{

+				LLVolumeFace::VertexData& tv = (point_iter->second)[j];

+				if (tv.compareNormal(cv, angle_cutoff))

+				{

+					found = TRUE;

+					new_face.pushIndex((point_iter->second)[j].mIndex);

+					break;

+				}

+			}

+		}

+

+		if (!found)

+		{

+			new_face.pushVertex(cv);

+			U16 index = (U16) new_face.mNumVertices-1;

+			new_face.pushIndex(index);

+

+			VertexMapData d;

+			d.setPosition(cv.getPosition());

+			d.mTexCoord = cv.mTexCoord;

+			d.setNormal(cv.getNormal());

+			d.mIndex = index;

+			if (point_iter != point_map.end())

+			{

+				point_iter->second.push_back(d);

+			}

+			else

+			{

+				point_map[LLVector3(d.getPosition().getF32ptr())].push_back(d);

+			}

+		}

+	}

+

+	swapData(new_face);

+}

+

+class LLVCacheTriangleData;

+

+class LLVCacheVertexData

+{

+public:

+	S32 mIdx;

+	S32 mCacheTag;

+	F32 mScore;

+	U32 mActiveTriangles;

+	std::vector<LLVCacheTriangleData*> mTriangles;

+

+	LLVCacheVertexData()

+	{

+		mCacheTag = -1;

+		mScore = 0.f;

+		mActiveTriangles = 0;

+		mIdx = -1;

+	}

+};

+

+class LLVCacheTriangleData

+{

+public:

+	bool mActive;

+	F32 mScore;

+	LLVCacheVertexData* mVertex[3];

+

+	LLVCacheTriangleData()

+	{

+		mActive = true;

+		mScore = 0.f;

+		mVertex[0] = mVertex[1] = mVertex[2] = NULL;

+	}

+

+	void complete()

+	{

+		mActive = false;

+		for (S32 i = 0; i < 3; ++i)

+		{

+			if (mVertex[i])

+			{

+				llassert_always(mVertex[i]->mActiveTriangles > 0);

+				mVertex[i]->mActiveTriangles--;

+			}

+		}

+	}

+

+	bool operator<(const LLVCacheTriangleData& rhs) const

+	{ //highest score first

+		return rhs.mScore < mScore;

+	}

+};

+

+const F32 FindVertexScore_CacheDecayPower = 1.5f;

+const F32 FindVertexScore_LastTriScore = 0.75f;

+const F32 FindVertexScore_ValenceBoostScale = 2.0f;

+const F32 FindVertexScore_ValenceBoostPower = 0.5f;

+const U32 MaxSizeVertexCache = 32;

+

+F32 find_vertex_score(LLVCacheVertexData& data)

+{

+	if (data.mActiveTriangles == 0)

+	{ //no triangle references this vertex

+		return -1.f;

+	}

+

+	F32 score = 0.f;

+

+	S32 cache_idx = data.mCacheTag;

+

+	if (cache_idx < 0)

+	{

+		//not in cache

+	}

+	else

+	{

+		if (cache_idx < 3)

+		{ //vertex was in the last triangle

+			score = FindVertexScore_LastTriScore;

+		}

+		else

+		{ //more points for being higher in the cache

+			F32 scaler = 1.f/(MaxSizeVertexCache-3);

+			score = 1.f-((cache_idx-3)*scaler);

+			score = powf(score, FindVertexScore_CacheDecayPower);

+		}

+	}

+

+	//bonus points for having low valence

+	F32 valence_boost = powf(data.mActiveTriangles, -FindVertexScore_ValenceBoostPower);

+	score += FindVertexScore_ValenceBoostScale * valence_boost;

+

+	return score;

+}

+

+class LLVCacheFIFO

+{

+public:

+	LLVCacheVertexData* mCache[MaxSizeVertexCache];

+	U32 mMisses;

+

+	LLVCacheFIFO()

+	{

+		mMisses = 0;

+		for (U32 i = 0; i < MaxSizeVertexCache; ++i)

+		{

+			mCache[i] = NULL;

+		}

+	}

+

+	void addVertex(LLVCacheVertexData* data)

+	{

+		if (data->mCacheTag == -1)

+		{

+			mMisses++;

+

+			S32 end = MaxSizeVertexCache-1;

+

+			if (mCache[end])

+			{

+				mCache[end]->mCacheTag = -1;

+			}

+

+			for (S32 i = end; i > 0; --i)

+			{

+				mCache[i] = mCache[i-1];

+				if (mCache[i])

+				{

+					mCache[i]->mCacheTag = i;

+				}

+			}

+

+			mCache[0] = data;

+			data->mCacheTag = 0;

+		}

+	}

+};

+

+class LLVCacheLRU

+{

+public:

+	LLVCacheVertexData* mCache[MaxSizeVertexCache+3];

+

+	LLVCacheTriangleData* mBestTriangle;

+	

+	U32 mMisses;

+

+	LLVCacheLRU()

+	{

+		for (U32 i = 0; i < MaxSizeVertexCache+3; ++i)

+		{

+			mCache[i] = NULL;

+		}

+

+		mBestTriangle = NULL;

+		mMisses = 0;

+	}

+

+	void addVertex(LLVCacheVertexData* data)

+	{

+		S32 end = MaxSizeVertexCache+2;

+		if (data->mCacheTag != -1)

+		{ //just moving a vertex to the front of the cache

+			end = data->mCacheTag;

+		}

+		else

+		{

+			mMisses++;

+			if (mCache[end])

+			{ //adding a new vertex, vertex at end of cache falls off

+				mCache[end]->mCacheTag = -1;

+			}

+		}

+

+		for (S32 i = end; i > 0; --i)

+		{ //adjust cache pointers and tags

+			mCache[i] = mCache[i-1];

+

+			if (mCache[i])

+			{

+				mCache[i]->mCacheTag = i;			

+			}

+		}

+

+		mCache[0] = data;

+		mCache[0]->mCacheTag = 0;

+	}

+

+	void addTriangle(LLVCacheTriangleData* data)

+	{

+		addVertex(data->mVertex[0]);

+		addVertex(data->mVertex[1]);

+		addVertex(data->mVertex[2]);

+	}

+

+	void updateScores()

+	{

+		for (U32 i = MaxSizeVertexCache; i < MaxSizeVertexCache+3; ++i)

+		{ //trailing 3 vertices aren't actually in the cache for scoring purposes

+			if (mCache[i])

+			{

+				mCache[i]->mCacheTag = -1;

+			}

+		}

+

+		for (U32 i = 0; i < MaxSizeVertexCache; ++i)

+		{ //update scores of vertices in cache

+			if (mCache[i])

+			{

+				mCache[i]->mScore = find_vertex_score(*(mCache[i]));

+				llassert_always(mCache[i]->mCacheTag == i);

+			}

+		}

+

+		mBestTriangle = NULL;

+		//update triangle scores

+		for (U32 i = 0; i < MaxSizeVertexCache+3; ++i)

+		{

+			if (mCache[i])

+			{

+				for (U32 j = 0; j < mCache[i]->mTriangles.size(); ++j)

+				{

+					LLVCacheTriangleData* tri = mCache[i]->mTriangles[j];

+					if (tri->mActive)

+					{

+						tri->mScore = tri->mVertex[0]->mScore;

+						tri->mScore += tri->mVertex[1]->mScore;

+						tri->mScore += tri->mVertex[2]->mScore;

+

+						if (!mBestTriangle || mBestTriangle->mScore < tri->mScore)

+						{

+							mBestTriangle = tri;

+						}

+					}

+				}

+			}

+		}

+

+		//knock trailing 3 vertices off the cache

+		for (U32 i = MaxSizeVertexCache; i < MaxSizeVertexCache+3; ++i)

+		{

+			if (mCache[i])

+			{

+				llassert_always(mCache[i]->mCacheTag == -1);

+				mCache[i] = NULL;

+			}

+		}

+	}

+};

+

+

+void LLVolumeFace::cacheOptimize()

+{ //optimize for vertex cache according to Forsyth method: 

+  // http://home.comcast.net/~tom_forsyth/papers/fast_vert_cache_opt.html

+	

+	LLVCacheLRU cache;

+	

+	//mapping of vertices to triangles and indices

+	std::vector<LLVCacheVertexData> vertex_data;

+

+	//mapping of triangles do vertices

+	std::vector<LLVCacheTriangleData> triangle_data;

+

+	triangle_data.resize(mNumIndices/3);

+	vertex_data.resize(mNumVertices);

+

+	for (U32 i = 0; i < mNumIndices; i++)

+	{ //populate vertex data and triangle data arrays

+		U16 idx = mIndices[i];

+		U32 tri_idx = i/3;

+

+		vertex_data[idx].mTriangles.push_back(&(triangle_data[tri_idx]));

+		vertex_data[idx].mIdx = idx;

+		triangle_data[tri_idx].mVertex[i%3] = &(vertex_data[idx]);

+	}

+

+	/*F32 pre_acmr = 1.f;

+	//measure cache misses from before rebuild

+	{

+		LLVCacheFIFO test_cache;

+		for (U32 i = 0; i < mNumIndices; ++i)

+		{

+			test_cache.addVertex(&vertex_data[mIndices[i]]);

+		}

+

+		for (U32 i = 0; i < mNumVertices; i++)

+		{

+			vertex_data[i].mCacheTag = -1;

+		}

+

+		pre_acmr = (F32) test_cache.mMisses/(mNumIndices/3);

+	}*/

+

+	for (U32 i = 0; i < mNumVertices; i++)

+	{ //initialize score values (no cache -- might try a fifo cache here)

+		vertex_data[i].mScore = find_vertex_score(vertex_data[i]);

+		vertex_data[i].mActiveTriangles = vertex_data[i].mTriangles.size();

+

+		for (U32 j = 0; j < vertex_data[i].mTriangles.size(); ++j)

+		{

+			vertex_data[i].mTriangles[j]->mScore += vertex_data[i].mScore;

+		}

+	}

+

+	//sort triangle data by score

+	std::sort(triangle_data.begin(), triangle_data.end());

+

+	std::vector<U16> new_indices;

+

+	LLVCacheTriangleData* tri;

+

+	//prime pump by adding first triangle to cache;

+	tri = &(triangle_data[0]);

+	cache.addTriangle(tri);

+	new_indices.push_back(tri->mVertex[0]->mIdx);

+	new_indices.push_back(tri->mVertex[1]->mIdx);

+	new_indices.push_back(tri->mVertex[2]->mIdx);

+	tri->complete();

+

+	U32 breaks = 0;

+	for (U32 i = 1; i < mNumIndices/3; ++i)

+	{

+		cache.updateScores();

+		tri = cache.mBestTriangle;

+		if (!tri)

+		{

+			breaks++;

+			for (U32 j = 0; j < triangle_data.size(); ++j)

+			{

+				if (triangle_data[j].mActive)

+				{

+					tri = &(triangle_data[j]);

+					break;

+				}

+			}

+		}	

+		

+		cache.addTriangle(tri);

+		new_indices.push_back(tri->mVertex[0]->mIdx);

+		new_indices.push_back(tri->mVertex[1]->mIdx);

+		new_indices.push_back(tri->mVertex[2]->mIdx);

+		tri->complete();

+	}

+

+	for (U32 i = 0; i < mNumIndices; ++i)

+	{

+		mIndices[i] = new_indices[i];

+	}

+

+	/*F32 post_acmr = 1.f;

+	//measure cache misses from after rebuild

+	{

+		LLVCacheFIFO test_cache;

+		for (U32 i = 0; i < mNumVertices; i++)

+		{

+			vertex_data[i].mCacheTag = -1;

+		}

+

+		for (U32 i = 0; i < mNumIndices; ++i)

+		{

+			test_cache.addVertex(&vertex_data[mIndices[i]]);

+		}

+		

+		post_acmr = (F32) test_cache.mMisses/(mNumIndices/3);

+	}*/

+

+	//optimize for pre-TnL cache

+	

+	//allocate space for new buffer

+	S32 num_verts = mNumVertices;

+	LLVector4a* pos = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+	LLVector4a* norm = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+	S32 size = ((num_verts*sizeof(LLVector2)) + 0xF) & ~0xF;

+	LLVector2* tc = (LLVector2*) malloc(size);

+

+	LLVector4a* wght = NULL;

+	if (mWeights)

+	{

+		wght = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+	}

+

+	LLVector4a* binorm = NULL;

+	if (mBinormals)

+	{

+		binorm = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+	}

+

+	//allocate mapping of old indices to new indices

+	std::vector<S32> new_idx;

+	new_idx.resize(mNumVertices, -1);

+

+	S32 cur_idx = 0;

+	for (U32 i = 0; i < mNumIndices; ++i)

+	{

+		U16 idx = mIndices[i];

+		if (new_idx[idx] == -1)

+		{ //this vertex hasn't been added yet

+			new_idx[idx] = cur_idx;

+

+			//copy vertex data

+			pos[cur_idx] = mPositions[idx];

+			norm[cur_idx] = mNormals[idx];

+			tc[cur_idx] = mTexCoords[idx];

+			if (mWeights)

+			{

+				wght[cur_idx] = mWeights[idx];

+			}

+			if (mBinormals)

+			{

+				binorm[cur_idx] = mBinormals[idx];

+			}

+

+			cur_idx++;

+		}

+	}

+

+	for (U32 i = 0; i < mNumIndices; ++i)

+	{

+		mIndices[i] = new_idx[mIndices[i]];

+	}

+	

+	free(mPositions);

+	free(mNormals);

+	free(mTexCoords);

+	free(mWeights);

+	free(mBinormals);

+

+	mPositions = pos;

+	mNormals = norm;

+	mTexCoords = tc;

+	mWeights = wght;

+	mBinormals = binorm;

+

+	//std::string result = llformat("ACMR pre/post: %.3f/%.3f  --  %d triangles %d breaks", pre_acmr, post_acmr, mNumIndices/3, breaks);

+	//llinfos << result << llendl;

+

+}

+

+void LLVolumeFace::createOctree(F32 scaler, const LLVector4a& center, const LLVector4a& size)

+{

+	if (mOctree)

+	{

+		return;

+	}

+

+	mOctree = new LLOctreeRoot<LLVolumeTriangle>(center, size, NULL);

+	new LLVolumeOctreeListener(mOctree);

+

+	for (U32 i = 0; i < mNumIndices; i+= 3)

+	{ //for each triangle

+		LLPointer<LLVolumeTriangle> tri = new LLVolumeTriangle();

+				

+		const LLVector4a& v0 = mPositions[mIndices[i]];

+		const LLVector4a& v1 = mPositions[mIndices[i+1]];

+		const LLVector4a& v2 = mPositions[mIndices[i+2]];

+

+		//store pointers to vertex data

+		tri->mV[0] = &v0;

+		tri->mV[1] = &v1;

+		tri->mV[2] = &v2;

+

+		//store indices

+		tri->mIndex[0] = mIndices[i];

+		tri->mIndex[1] = mIndices[i+1];

+		tri->mIndex[2] = mIndices[i+2];

+

+		//get minimum point

+		LLVector4a min = v0;

+		min.setMin(min, v1);

+		min.setMin(min, v2);

+

+		//get maximum point

+		LLVector4a max = v0;

+		max.setMax(max, v1);

+		max.setMax(max, v2);

+

+		//compute center

+		LLVector4a center;

+		center.setAdd(min, max);

+		center.mul(0.5f);

+

+		tri->mPositionGroup = center;

+

+		//compute "radius"

+		LLVector4a size;

+		size.setSub(max,min);

+		

+		tri->mRadius = size.getLength3().getF32() * scaler;

+		

+		//insert

+		mOctree->insert(tri);

+	}

+

+	//remove unneeded octree layers

+	while (!mOctree->balance())	{ }

+

+	//calculate AABB for each node

+	LLVolumeOctreeRebound rebound(this);

+	rebound.traverse(mOctree);

+

+	if (gDebugGL)

+	{

+		LLVolumeOctreeValidate validate;

+		validate.traverse(mOctree);

+	}

+}

+

+

+void LLVolumeFace::swapData(LLVolumeFace& rhs)

+{

+	llswap(rhs.mPositions, mPositions);

+	llswap(rhs.mNormals, mNormals);

+	llswap(rhs.mBinormals, mBinormals);

+	llswap(rhs.mTexCoords, mTexCoords);

+	llswap(rhs.mIndices,mIndices);

+	llswap(rhs.mNumVertices, mNumVertices);

+	llswap(rhs.mNumIndices, mNumIndices);

+}

+

+void	LerpPlanarVertex(LLVolumeFace::VertexData& v0,

+				   LLVolumeFace::VertexData& v1,

+				   LLVolumeFace::VertexData& v2,

+				   LLVolumeFace::VertexData& vout,

+				   F32	coef01,

+				   F32	coef02)

+{

+

+	LLVector4a lhs;

+	lhs.setSub(v1.getPosition(), v0.getPosition());

+	lhs.mul(coef01);

+	LLVector4a rhs;

+	rhs.setSub(v2.getPosition(), v0.getPosition());

+	rhs.mul(coef02);

+

+	rhs.add(lhs);

+	rhs.add(v0.getPosition());

+

+	vout.setPosition(rhs);

+		

+	vout.mTexCoord = v0.mTexCoord + ((v1.mTexCoord-v0.mTexCoord)*coef01)+((v2.mTexCoord-v0.mTexCoord)*coef02);

+	vout.setNormal(v0.getNormal());

+}

+

+BOOL LLVolumeFace::createUnCutCubeCap(LLVolume* volume, BOOL partial_build)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	const std::vector<LLVolume::Point>& mesh = volume->getMesh();

+	const std::vector<LLVector3>& profile = volume->getProfile().mProfile;

+	S32 max_s = volume->getProfile().getTotal();

+	S32 max_t = volume->getPath().mPath.size();

+

+	// S32 i;

+	S32 num_vertices = 0, num_indices = 0;

+	S32	grid_size = (profile.size()-1)/4;

+	S32	quad_count = (grid_size * grid_size);

+

+	num_vertices = (grid_size+1)*(grid_size+1);

+	num_indices = quad_count * 4;

+

+	LLVector4a& min = mExtents[0];

+	LLVector4a& max = mExtents[1];

+

+	S32 offset = 0;

+	if (mTypeMask & TOP_MASK)

+	{

+		offset = (max_t-1) * max_s;

+	}

+	else

+	{

+		offset = mBeginS;

+	}

+

+	{

+		VertexData	corners[4];

+		VertexData baseVert;

+		for(S32 t = 0; t < 4; t++)

+		{

+			corners[t].getPosition().load3( mesh[offset + (grid_size*t)].mPos.mV);

+			corners[t].mTexCoord.mV[0] = profile[grid_size*t].mV[0]+0.5f;

+			corners[t].mTexCoord.mV[1] = 0.5f - profile[grid_size*t].mV[1];

+		}

+

+		{

+			LLVector4a lhs;

+			lhs.setSub(corners[1].getPosition(), corners[0].getPosition());

+			LLVector4a rhs;

+			rhs.setSub(corners[2].getPosition(), corners[1].getPosition());

+			baseVert.getNormal().setCross3(lhs, rhs); 

+			baseVert.getNormal().normalize3fast();

+		}

+

+		if(!(mTypeMask & TOP_MASK))

+		{

+			baseVert.getNormal().mul(-1.0f);

+		}

+		else

+		{

+			//Swap the UVs on the U(X) axis for top face

+			LLVector2 swap;

+			swap = corners[0].mTexCoord;

+			corners[0].mTexCoord=corners[3].mTexCoord;

+			corners[3].mTexCoord=swap;

+			swap = corners[1].mTexCoord;

+			corners[1].mTexCoord=corners[2].mTexCoord;

+			corners[2].mTexCoord=swap;

+		}

+

+		LLVector4a binormal;

+		

+		calc_binormal_from_triangle( binormal,

+			corners[0].getPosition(), corners[0].mTexCoord,

+			corners[1].getPosition(), corners[1].mTexCoord,

+			corners[2].getPosition(), corners[2].mTexCoord);

+		

+		binormal.normalize3fast();

+

+		S32 size = (grid_size+1)*(grid_size+1);

+		resizeVertices(size);

+		allocateBinormals(size);

+

+		LLVector4a* pos = (LLVector4a*) mPositions;

+		LLVector4a* norm = (LLVector4a*) mNormals;

+		LLVector4a* binorm = (LLVector4a*) mBinormals;

+		LLVector2* tc = (LLVector2*) mTexCoords;

+

+		for(int gx = 0;gx<grid_size+1;gx++)

+		{

+			for(int gy = 0;gy<grid_size+1;gy++)

+			{

+				VertexData newVert;

+				LerpPlanarVertex(

+					corners[0],

+					corners[1],

+					corners[3],

+					newVert,

+					(F32)gx/(F32)grid_size,

+					(F32)gy/(F32)grid_size);

+

+				*pos++ = newVert.getPosition();

+				*norm++ = baseVert.getNormal();

+				*tc++ = newVert.mTexCoord;

+				*binorm++ = binormal;

+

+				if (gx == 0 && gy == 0)

+				{

+					min = newVert.getPosition();

+					max = min;

+				}

+				else

+				{

+					min.setMin(min, newVert.getPosition());

+					max.setMax(max, newVert.getPosition());

+				}

+			}

+		}

+	

+		mCenter->setAdd(min, max);

+		mCenter->mul(0.5f); 

+	}

+

+	if (!partial_build)

+	{

+		resizeIndices(grid_size*grid_size*6);

+

+		U16* out = mIndices;

+

+		S32 idxs[] = {0,1,(grid_size+1)+1,(grid_size+1)+1,(grid_size+1),0};

+		for(S32 gx = 0;gx<grid_size;gx++)

+		{

+			

+			for(S32 gy = 0;gy<grid_size;gy++)

+			{

+				if (mTypeMask & TOP_MASK)

+				{

+					for(S32 i=5;i>=0;i--)

+					{

+						*out++ = ((gy*(grid_size+1))+gx+idxs[i]);

+					}		

+				}

+				else

+				{

+					for(S32 i=0;i<6;i++)

+					{

+						*out++ = ((gy*(grid_size+1))+gx+idxs[i]);

+					}

+				}

+			}	

+		}

+	}

+		

+	return TRUE;

+}

+

+

+BOOL LLVolumeFace::createCap(LLVolume* volume, BOOL partial_build)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	if (!(mTypeMask & HOLLOW_MASK) && 

+		!(mTypeMask & OPEN_MASK) && 

+		((volume->getParams().getPathParams().getBegin()==0.0f)&&

+		(volume->getParams().getPathParams().getEnd()==1.0f))&&

+		(volume->getParams().getProfileParams().getCurveType()==LL_PCODE_PROFILE_SQUARE &&

+		 volume->getParams().getPathParams().getCurveType()==LL_PCODE_PATH_LINE)	

+		){

+		return createUnCutCubeCap(volume, partial_build);

+	}

+

+	S32 num_vertices = 0, num_indices = 0;

+

+	const std::vector<LLVolume::Point>& mesh = volume->getMesh();

+	const std::vector<LLVector3>& profile = volume->getProfile().mProfile;

+

+	// All types of caps have the same number of vertices and indices

+	num_vertices = profile.size();

+	num_indices = (profile.size() - 2)*3;

+

+	if (!(mTypeMask & HOLLOW_MASK) && !(mTypeMask & OPEN_MASK))

+	{

+		resizeVertices(num_vertices+1);

+		allocateBinormals(num_vertices+1);	

+

+		if (!partial_build)

+		{

+			resizeIndices(num_indices+3);

+		}

+	}

+	else

+	{

+		resizeVertices(num_vertices);

+		allocateBinormals(num_vertices);

+

+		if (!partial_build)

+		{

+			resizeIndices(num_indices);

+		}

+	}

+

+	S32 max_s = volume->getProfile().getTotal();

+	S32 max_t = volume->getPath().mPath.size();

+

+	mCenter->clear();

+

+	S32 offset = 0;

+	if (mTypeMask & TOP_MASK)

+	{

+		offset = (max_t-1) * max_s;

+	}

+	else

+	{

+		offset = mBeginS;

+	}

+

+	// Figure out the normal, assume all caps are flat faces.

+	// Cross product to get normals.

+	

+	LLVector2 cuv;

+	LLVector2 min_uv, max_uv;

+

+	LLVector4a& min = mExtents[0];

+	LLVector4a& max = mExtents[1];

+

+	LLVector2* tc = (LLVector2*) mTexCoords;

+	LLVector4a* pos = (LLVector4a*) mPositions;

+	LLVector4a* norm = (LLVector4a*) mNormals;

+	LLVector4a* binorm = (LLVector4a*) mBinormals;

+

+	// Copy the vertices into the array

+	for (S32 i = 0; i < num_vertices; i++)

+	{

+		if (mTypeMask & TOP_MASK)

+		{

+			tc[i].mV[0] = profile[i].mV[0]+0.5f;

+			tc[i].mV[1] = profile[i].mV[1]+0.5f;

+		}

+		else

+		{

+			// Mirror for underside.

+			tc[i].mV[0] = profile[i].mV[0]+0.5f;

+			tc[i].mV[1] = 0.5f - profile[i].mV[1];

+		}

+

+		pos[i].load3(mesh[i + offset].mPos.mV);

+		

+		if (i == 0)

+		{

+			max = pos[i];

+			min = max;

+			min_uv = max_uv = tc[i];

+		}

+		else

+		{

+			update_min_max(min,max,pos[i]);

+			update_min_max(min_uv, max_uv, tc[i]);

+		}

+	}

+

+	mCenter->setAdd(min, max);

+	mCenter->mul(0.5f); 

+

+	cuv = (min_uv + max_uv)*0.5f;

+

+	LLVector4a binormal;

+	calc_binormal_from_triangle(binormal,

+		*mCenter, cuv,

+		pos[0], tc[0],

+		pos[1], tc[1]);

+	binormal.normalize3fast();

+

+	LLVector4a normal;

+	LLVector4a d0, d1;

+	

+

+	d0.setSub(*mCenter, pos[0]);

+	d1.setSub(*mCenter, pos[1]);

+

+	if (mTypeMask & TOP_MASK)

+	{

+		normal.setCross3(d0, d1);

+	}

+	else

+	{

+		normal.setCross3(d1, d0);

+	}

+

+	normal.normalize3fast();

+

+	VertexData vd;

+	vd.setPosition(*mCenter);

+	vd.mTexCoord = cuv;

+	

+	if (!(mTypeMask & HOLLOW_MASK) && !(mTypeMask & OPEN_MASK))

+	{

+		pos[num_vertices] = *mCenter;

+		tc[num_vertices] = cuv;

+		num_vertices++;

+	}

+		

+	for (S32 i = 0; i < num_vertices; i++)

+	{

+		binorm[i].load4a(binormal.getF32ptr());

+		norm[i].load4a(normal.getF32ptr());

+	}

+

+	if (partial_build)

+	{

+		return TRUE;

+	}

+

+	if (mTypeMask & HOLLOW_MASK)

+	{

+		if (mTypeMask & TOP_MASK)

+		{

+			// HOLLOW TOP

+			// Does it matter if it's open or closed? - djs

+

+			S32 pt1 = 0, pt2 = num_vertices - 1;

+			S32 i = 0;

+			while (pt2 - pt1 > 1)

+			{

+				// Use the profile points instead of the mesh, since you want

+				// the un-transformed profile distances.

+				LLVector3 p1 = profile[pt1];

+				LLVector3 p2 = profile[pt2];

+				LLVector3 pa = profile[pt1+1];

+				LLVector3 pb = profile[pt2-1];

+

+				p1.mV[VZ] = 0.f;

+				p2.mV[VZ] = 0.f;

+				pa.mV[VZ] = 0.f;

+				pb.mV[VZ] = 0.f;

+

+				// Use area of triangle to determine backfacing

+				F32 area_1a2, area_1ba, area_21b, area_2ab;

+				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +

+							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +

+							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);

+

+				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +

+							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);

+

+				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +

+							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +

+							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				BOOL use_tri1a2 = TRUE;

+				BOOL tri_1a2 = TRUE;

+				BOOL tri_21b = TRUE;

+

+				if (area_1a2 < 0)

+				{

+					tri_1a2 = FALSE;

+				}

+				if (area_2ab < 0)

+				{

+					// Can't use, because it contains point b

+					tri_1a2 = FALSE;

+				}

+				if (area_21b < 0)

+				{

+					tri_21b = FALSE;

+				}

+				if (area_1ba < 0)

+				{

+					// Can't use, because it contains point b

+					tri_21b = FALSE;

+				}

+

+				if (!tri_1a2)

+				{

+					use_tri1a2 = FALSE;

+				}

+				else if (!tri_21b)

+				{

+					use_tri1a2 = TRUE;

+				}

+				else

+				{

+					LLVector3 d1 = p1 - pa;

+					LLVector3 d2 = p2 - pb;

+

+					if (d1.magVecSquared() < d2.magVecSquared())

+					{

+						use_tri1a2 = TRUE;

+					}

+					else

+					{

+						use_tri1a2 = FALSE;

+					}

+				}

+

+				if (use_tri1a2)

+				{

+					mIndices[i++] = pt1;

+					mIndices[i++] = pt1 + 1;

+					mIndices[i++] = pt2;

+					pt1++;

+				}

+				else

+				{

+					mIndices[i++] = pt1;

+					mIndices[i++] = pt2 - 1;

+					mIndices[i++] = pt2;

+					pt2--;

+				}

+			}

+		}

+		else

+		{

+			// HOLLOW BOTTOM

+			// Does it matter if it's open or closed? - djs

+

+			llassert(mTypeMask & BOTTOM_MASK);

+			S32 pt1 = 0, pt2 = num_vertices - 1;

+

+			S32 i = 0;

+			while (pt2 - pt1 > 1)

+			{

+				// Use the profile points instead of the mesh, since you want

+				// the un-transformed profile distances.

+				LLVector3 p1 = profile[pt1];

+				LLVector3 p2 = profile[pt2];

+				LLVector3 pa = profile[pt1+1];

+				LLVector3 pb = profile[pt2-1];

+

+				p1.mV[VZ] = 0.f;

+				p2.mV[VZ] = 0.f;

+				pa.mV[VZ] = 0.f;

+				pb.mV[VZ] = 0.f;

+

+				// Use area of triangle to determine backfacing

+				F32 area_1a2, area_1ba, area_21b, area_2ab;

+				area_1a2 =  (p1.mV[0]*pa.mV[1] - pa.mV[0]*p1.mV[1]) +

+							(pa.mV[0]*p2.mV[1] - p2.mV[0]*pa.mV[1]) +

+							(p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]);

+

+				area_1ba =  (p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*pa.mV[1] - pa.mV[0]*pb.mV[1]) +

+							(pa.mV[0]*p1.mV[1] - p1.mV[0]*pa.mV[1]);

+

+				area_21b =  (p2.mV[0]*p1.mV[1] - p1.mV[0]*p2.mV[1]) +

+							(p1.mV[0]*pb.mV[1] - pb.mV[0]*p1.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				area_2ab =  (p2.mV[0]*pa.mV[1] - pa.mV[0]*p2.mV[1]) +

+							(pa.mV[0]*pb.mV[1] - pb.mV[0]*pa.mV[1]) +

+							(pb.mV[0]*p2.mV[1] - p2.mV[0]*pb.mV[1]);

+

+				BOOL use_tri1a2 = TRUE;

+				BOOL tri_1a2 = TRUE;

+				BOOL tri_21b = TRUE;

+

+				if (area_1a2 < 0)

+				{

+					tri_1a2 = FALSE;

+				}

+				if (area_2ab < 0)

+				{

+					// Can't use, because it contains point b

+					tri_1a2 = FALSE;

+				}

+				if (area_21b < 0)

+				{

+					tri_21b = FALSE;

+				}

+				if (area_1ba < 0)

+				{

+					// Can't use, because it contains point b

+					tri_21b = FALSE;

+				}

+

+				if (!tri_1a2)

+				{

+					use_tri1a2 = FALSE;

+				}

+				else if (!tri_21b)

+				{

+					use_tri1a2 = TRUE;

+				}

+				else

+				{

+					LLVector3 d1 = p1 - pa;

+					LLVector3 d2 = p2 - pb;

+

+					if (d1.magVecSquared() < d2.magVecSquared())

+					{

+						use_tri1a2 = TRUE;

+					}

+					else

+					{

+						use_tri1a2 = FALSE;

+					}

+				}

+

+				// Flipped backfacing from top

+				if (use_tri1a2)

+				{

+					mIndices[i++] = pt1;

+					mIndices[i++] = pt2;

+					mIndices[i++] = pt1 + 1;

+					pt1++;

+				}

+				else

+				{

+					mIndices[i++] = pt1;

+					mIndices[i++] = pt2;

+					mIndices[i++] = pt2 - 1;

+					pt2--;

+				}

+			}

+		}

+	}

+	else

+	{

+		// Not hollow, generate the triangle fan.

+		U16 v1 = 2;

+		U16 v2 = 1;

+

+		if (mTypeMask & TOP_MASK)

+		{

+			v1 = 1;

+			v2 = 2;

+		}

+

+		for (S32 i = 0; i < (num_vertices - 2); i++)

+		{

+			mIndices[3*i] = num_vertices - 1;

+			mIndices[3*i+v1] = i;

+			mIndices[3*i+v2] = i + 1;

+		}

+

+

+	}

+		

+	return TRUE;

+}

+

+void LLVolumeFace::createBinormals()

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	if (!mBinormals)

+	{

+		allocateBinormals(mNumVertices);

+

+		//generate binormals

+		LLVector4a* pos = mPositions;

+		LLVector2* tc = (LLVector2*) mTexCoords;

+		LLVector4a* binorm = (LLVector4a*) mBinormals;

+

+		LLVector4a* end = mBinormals+mNumVertices;

+		while (binorm < end)

+		{

+			(*binorm++).clear();

+		}

+

+		binorm = mBinormals;

+

+		for (U32 i = 0; i < mNumIndices/3; i++) 

+		{	//for each triangle

+			const U16& i0 = mIndices[i*3+0];

+			const U16& i1 = mIndices[i*3+1];

+			const U16& i2 = mIndices[i*3+2];

+						

+			//calculate binormal

+			LLVector4a binormal;

+			calc_binormal_from_triangle(binormal,

+										pos[i0], tc[i0],

+										pos[i1], tc[i1],

+										pos[i2], tc[i2]);

+

+

+			//add triangle normal to vertices

+			binorm[i0].add(binormal);

+			binorm[i1].add(binormal);

+			binorm[i2].add(binormal);

+

+			//even out quad contributions

+			if (i % 2 == 0) 

+			{

+				binorm[i2].add(binormal);

+			}

+			else 

+			{

+				binorm[i1].add(binormal);

+			}

+		}

+

+		//normalize binormals

+		for (U32 i = 0; i < mNumVertices; i++) 

+		{

+			binorm[i].normalize3fast();

+			//bump map/planar projection code requires normals to be normalized

+			mNormals[i].normalize3fast();

+		}

+	}

+}

+

+void LLVolumeFace::resizeVertices(S32 num_verts)

+{

+	free(mPositions);

+	free(mNormals);

+	free(mBinormals);

+	free(mTexCoords);

+

+	mBinormals = NULL;

+

+	if (num_verts)

+	{

+		mPositions = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+		assert_aligned(mPositions, 16);

+		mNormals = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+		assert_aligned(mNormals, 16);

+

+		//pad texture coordinate block end to allow for QWORD reads

+		S32 size = ((num_verts*sizeof(LLVector2)) + 0xF) & ~0xF;

+		mTexCoords = (LLVector2*) malloc(size);

+		assert_aligned(mTexCoords, 16);

+	}

+	else

+	{

+		mPositions = NULL;

+		mNormals = NULL;

+		mTexCoords = NULL;

+	}

+

+	mNumVertices = num_verts;

+}

+

+void LLVolumeFace::pushVertex(const LLVolumeFace::VertexData& cv)

+{

+	pushVertex(cv.getPosition(), cv.getNormal(), cv.mTexCoord);

+}

+

+void LLVolumeFace::pushVertex(const LLVector4a& pos, const LLVector4a& norm, const LLVector2& tc)

+{

+	S32 new_verts = mNumVertices+1;

+	S32 new_size = new_verts*16;

+//	S32 old_size = mNumVertices*16;

+

+	//positions

+	mPositions = (LLVector4a*) realloc(mPositions, new_size);

+	

+	//normals

+	mNormals = (LLVector4a*) realloc(mNormals, new_size);

+	

+	//tex coords

+	new_size = ((new_verts*8)+0xF) & ~0xF;

+	mTexCoords = (LLVector2*) realloc(mTexCoords, new_size);

+	

+

+	//just clear binormals

+	free(mBinormals);

+	mBinormals = NULL;

+

+	mPositions[mNumVertices] = pos;

+	mNormals[mNumVertices] = norm;

+	mTexCoords[mNumVertices] = tc;

+

+	mNumVertices++;	

+}

+

+void LLVolumeFace::allocateBinormals(S32 num_verts)

+{

+	free(mBinormals);

+	mBinormals = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+}

+

+void LLVolumeFace::allocateWeights(S32 num_verts)

+{

+	free(mWeights);

+	mWeights = (LLVector4a*) malloc(sizeof(LLVector4a)*num_verts);

+}

+

+void LLVolumeFace::resizeIndices(S32 num_indices)

+{

+	free(mIndices);

+	

+	if (num_indices)

+	{

+		//pad index block end to allow for QWORD reads

+		S32 size = ((num_indices*sizeof(U16)) + 0xF) & ~0xF;

+		

+		mIndices = (U16*) malloc(size);

+	}

+	else

+	{

+		mIndices = NULL;

+	}

+

+	mNumIndices = num_indices;

+}

+

+void LLVolumeFace::pushIndex(const U16& idx)

+{

+	S32 new_count = mNumIndices + 1;

+	S32 new_size = ((new_count*2)+0xF) & ~0xF;

+

+	S32 old_size = ((mNumIndices*2)+0xF) & ~0xF;

+	if (new_size != old_size)

+	{

+		mIndices = (U16*) realloc(mIndices, new_size);

+	}

+	

+	mIndices[mNumIndices++] = idx;

+}

+

+void LLVolumeFace::fillFromLegacyData(std::vector<LLVolumeFace::VertexData>& v, std::vector<U16>& idx)

+{

+	resizeVertices(v.size());

+	resizeIndices(idx.size());

+

+	for (U32 i = 0; i < v.size(); ++i)

+	{

+		mPositions[i] = v[i].getPosition();

+		mNormals[i] = v[i].getNormal();

+		mTexCoords[i] = v[i].mTexCoord;

+	}

+

+	for (U32 i = 0; i < idx.size(); ++i)

+	{

+		mIndices[i] = idx[i];

+	}

+}

+

+void LLVolumeFace::appendFace(const LLVolumeFace& face, LLMatrix4& mat_in, LLMatrix4& norm_mat_in)

+{

+	U16 offset = mNumVertices;

+

+	S32 new_count = face.mNumVertices + mNumVertices;

+

+	if (new_count > 65536)

+	{

+		llerrs << "Cannot append face -- 16-bit overflow will occur." << llendl;

+	}

+	

+	if (face.mNumVertices == 0)

+	{

+		llerrs << "Cannot append empty face." << llendl;

+	}

+

+	//allocate new buffer space

+	mPositions = (LLVector4a*) realloc(mPositions, new_count*sizeof(LLVector4a));

+	assert_aligned(mPositions, 16);

+	mNormals = (LLVector4a*) realloc(mNormals, new_count*sizeof(LLVector4a));

+	assert_aligned(mNormals, 16);

+	mTexCoords = (LLVector2*) realloc(mTexCoords, (new_count*sizeof(LLVector2)+0xF) & ~0xF);

+	assert_aligned(mTexCoords, 16);

+	

+	mNumVertices = new_count;

+

+	//get destination address of appended face

+	LLVector4a* dst_pos = mPositions+offset;

+	LLVector2* dst_tc = mTexCoords+offset;

+	LLVector4a* dst_norm = mNormals+offset;

+

+	//get source addresses of appended face

+	const LLVector4a* src_pos = face.mPositions;

+	const LLVector2* src_tc = face.mTexCoords;

+	const LLVector4a* src_norm = face.mNormals;

+

+	//load aligned matrices

+	LLMatrix4a mat, norm_mat;

+	mat.loadu(mat_in);

+	norm_mat.loadu(norm_mat_in);

+

+	for (U32 i = 0; i < face.mNumVertices; ++i)

+	{

+		//transform appended face position and store

+		mat.affineTransform(src_pos[i], dst_pos[i]);

+

+		//transform appended face normal and store

+		norm_mat.rotate(src_norm[i], dst_norm[i]);

+		dst_norm[i].normalize3fast();

+

+		//copy appended face texture coordinate

+		dst_tc[i] = src_tc[i];

+

+		if (offset == 0 && i == 0)

+		{ //initialize bounding box

+			mExtents[0] = mExtents[1] = dst_pos[i];

+		}

+		else

+		{

+			//stretch bounding box

+			update_min_max(mExtents[0], mExtents[1], dst_pos[i]);

+		}

+	}

+

+

+	new_count = mNumIndices + face.mNumIndices;

+

+	//allocate new index buffer

+	mIndices = (U16*) realloc(mIndices, (new_count*sizeof(U16)+0xF) & ~0xF);

+	

+	//get destination address into new index buffer

+	U16* dst_idx = mIndices+mNumIndices;

+	mNumIndices = new_count;

+

+	for (U32 i = 0; i < face.mNumIndices; ++i)

+	{ //copy indices, offsetting by old vertex count

+		dst_idx[i] = face.mIndices[i]+offset;

+	}

+}

+

+BOOL LLVolumeFace::createSide(LLVolume* volume, BOOL partial_build)

+{

+	LLMemType m1(LLMemType::MTYPE_VOLUME);

+	

+	BOOL flat = mTypeMask & FLAT_MASK;

+

+	U8 sculpt_type = volume->getParams().getSculptType();

+	U8 sculpt_stitching = sculpt_type & LL_SCULPT_TYPE_MASK;

+	BOOL sculpt_invert = sculpt_type & LL_SCULPT_FLAG_INVERT;

+	BOOL sculpt_mirror = sculpt_type & LL_SCULPT_FLAG_MIRROR;

+	BOOL sculpt_reverse_horizontal = (sculpt_invert ? !sculpt_mirror : sculpt_mirror);  // XOR

+	

+	S32 num_vertices, num_indices;

+

+	const std::vector<LLVolume::Point>& mesh = volume->getMesh();

+	const std::vector<LLVector3>& profile = volume->getProfile().mProfile;

+	const std::vector<LLPath::PathPt>& path_data = volume->getPath().mPath;

+

+	S32 max_s = volume->getProfile().getTotal();

+

+	S32 s, t, i;

+	F32 ss, tt;

+

+	num_vertices = mNumS*mNumT;

+	num_indices = (mNumS-1)*(mNumT-1)*6;

+

+	if (!partial_build)

+	{

+		resizeVertices(num_vertices);

+		resizeIndices(num_indices);

+

+		if ((volume->getParams().getSculptType() & LL_SCULPT_TYPE_MASK) != LL_SCULPT_TYPE_MESH)

+		{

+			mEdge.resize(num_indices);

+		}

+	}

+

+	LLVector4a* pos = (LLVector4a*) mPositions;

+	LLVector4a* norm = (LLVector4a*) mNormals;

+	LLVector2* tc = (LLVector2*) mTexCoords;

+	S32 begin_stex = llfloor( profile[mBeginS].mV[2] );

+	S32 num_s = ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2) ? mNumS/2 : mNumS;

+

+	S32 cur_vertex = 0;

+	// Copy the vertices into the array

+	for (t = mBeginT; t < mBeginT + mNumT; t++)

+	{

+		tt = path_data[t].mTexT;

+		for (s = 0; s < num_s; s++)

+		{

+			if (mTypeMask & END_MASK)

+			{

+				if (s)

+				{

+					ss = 1.f;

+				}

+				else

+				{

+					ss = 0.f;

+				}

+			}

+			else

+			{

+				// Get s value for tex-coord.

+				if (!flat)

+				{

+					ss = profile[mBeginS + s].mV[2];

+				}

+				else

+				{

+					ss = profile[mBeginS + s].mV[2] - begin_stex;

+				}

+			}

+

+			if (sculpt_reverse_horizontal)

+			{

+				ss = 1.f - ss;

+			}

+			

+			// Check to see if this triangle wraps around the array.

+			if (mBeginS + s >= max_s)

+			{

+				// We're wrapping

+				i = mBeginS + s + max_s*(t-1);

+			}

+			else

+			{

+				i = mBeginS + s + max_s*t;

+			}

+

+			pos[cur_vertex].load3(mesh[i].mPos.mV);

+			tc[cur_vertex] = LLVector2(ss,tt);

+		

+			norm[cur_vertex].clear();

+			cur_vertex++;

+

+			if ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2 && s > 0)

+			{

+

+				pos[cur_vertex].load3(mesh[i].mPos.mV);

+				tc[cur_vertex] = LLVector2(ss,tt);

+			

+				norm[cur_vertex].clear();

+				

+				cur_vertex++;

+			}

+		}

+		

+		if ((mTypeMask & INNER_MASK) && (mTypeMask & FLAT_MASK) && mNumS > 2)

+		{

+			if (mTypeMask & OPEN_MASK)

+			{

+				s = num_s-1;

+			}

+			else

+			{

+				s = 0;

+			}

+

+			i = mBeginS + s + max_s*t;

+			ss = profile[mBeginS + s].mV[2] - begin_stex;

+			pos[cur_vertex].load3(mesh[i].mPos.mV);

+			tc[cur_vertex] = LLVector2(ss,tt);

+			norm[cur_vertex].clear(); 

+			

+			cur_vertex++;

+		}

+	}

+	

+

+	//get bounding box for this side

+	LLVector4a& face_min = mExtents[0];

+	LLVector4a& face_max = mExtents[1];

+	mCenter->clear();

+

+	face_min = face_max = pos[0];

+

+	for (U32 i = 1; i < mNumVertices; ++i)

+	{

+		update_min_max(face_min, face_max, pos[i]);

+	}

+

+	mCenter->setAdd(face_min, face_max);

+	mCenter->mul(0.5f);

+

+	S32 cur_index = 0;

+	S32 cur_edge = 0;

+	BOOL flat_face = mTypeMask & FLAT_MASK;

+

+	if (!partial_build)

+	{

+		// Now we generate the indices.

+		for (t = 0; t < (mNumT-1); t++)

+		{

+			for (s = 0; s < (mNumS-1); s++)

+			{	

+				mIndices[cur_index++] = s   + mNumS*t;			//bottom left

+				mIndices[cur_index++] = s+1 + mNumS*(t+1);		//top right

+				mIndices[cur_index++] = s   + mNumS*(t+1);		//top left

+				mIndices[cur_index++] = s   + mNumS*t;			//bottom left

+				mIndices[cur_index++] = s+1 + mNumS*t;			//bottom right

+				mIndices[cur_index++] = s+1 + mNumS*(t+1);		//top right

+

+				mEdge[cur_edge++] = (mNumS-1)*2*t+s*2+1;						//bottom left/top right neighbor face 

+				if (t < mNumT-2) {												//top right/top left neighbor face 

+					mEdge[cur_edge++] = (mNumS-1)*2*(t+1)+s*2+1;

+				}

+				else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor

+					mEdge[cur_edge++] = -1;

+				}

+				else { //wrap on T

+					mEdge[cur_edge++] = s*2+1;

+				}

+				if (s > 0) {													//top left/bottom left neighbor face

+					mEdge[cur_edge++] = (mNumS-1)*2*t+s*2-1;

+				}

+				else if (flat_face ||  volume->getProfile().isOpen() == TRUE) { //no neighbor

+					mEdge[cur_edge++] = -1;

+				}

+				else {	//wrap on S

+					mEdge[cur_edge++] = (mNumS-1)*2*t+(mNumS-2)*2+1;

+				}

+				

+				if (t > 0) {													//bottom left/bottom right neighbor face

+					mEdge[cur_edge++] = (mNumS-1)*2*(t-1)+s*2;

+				}

+				else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor

+					mEdge[cur_edge++] = -1;

+				}

+				else { //wrap on T

+					mEdge[cur_edge++] = (mNumS-1)*2*(mNumT-2)+s*2;

+				}

+				if (s < mNumS-2) {												//bottom right/top right neighbor face

+					mEdge[cur_edge++] = (mNumS-1)*2*t+(s+1)*2;

+				}

+				else if (flat_face || volume->getProfile().isOpen() == TRUE) { //no neighbor

+					mEdge[cur_edge++] = -1;

+				}

+				else { //wrap on S

+					mEdge[cur_edge++] = (mNumS-1)*2*t;

+				}

+				mEdge[cur_edge++] = (mNumS-1)*2*t+s*2;							//top right/bottom left neighbor face	

+			}

+		}

+	}

+

+	//clear normals

+	for (U32 i = 0; i < mNumVertices; i++)

+	{

+		mNormals[i].clear();

+	}

+

+	//generate normals 

+	for (U32 i = 0; i < mNumIndices/3; i++) //for each triangle

+	{

+		const U16* idx = &(mIndices[i*3]);

+		

+

+		LLVector4a* v[] = 

+		{	pos+idx[0], pos+idx[1], pos+idx[2] };

+		

+		LLVector4a* n[] = 

+		{	norm+idx[0], norm+idx[1], norm+idx[2] };

+		

+		//calculate triangle normal

+		LLVector4a a, b, c;

+		

+		a.setSub(*v[0], *v[1]);

+		b.setSub(*v[0], *v[2]);

+		c.setCross3(a,b);

+

+		n[0]->add(c);

+		n[1]->add(c);

+		n[2]->add(c);

+		

+		//even out quad contributions

+		n[i%2+1]->add(c);

+	}

+	

+	// adjust normals based on wrapping and stitching

+	

+	LLVector4a top;

+	top.setSub(pos[0], pos[mNumS*(mNumT-2)]);

+	BOOL s_bottom_converges = (top.dot3(top) < 0.000001f);

+

+	top.setSub(pos[mNumS-1], pos[mNumS*(mNumT-2)+mNumS-1]);

+	BOOL s_top_converges = (top.dot3(top) < 0.000001f);

+

+	if (sculpt_stitching == LL_SCULPT_TYPE_NONE)  // logic for non-sculpt volumes

+	{

+		if (volume->getPath().isOpen() == FALSE)

+		{ //wrap normals on T

+			for (S32 i = 0; i < mNumS; i++)

+			{

+				LLVector4a n;

+				n.setAdd(norm[i], norm[mNumS*(mNumT-1)+i]);

+				norm[i] = n;

+				norm[mNumS*(mNumT-1)+i] = n;

+			}

+		}

+

+		if ((volume->getProfile().isOpen() == FALSE) && !(s_bottom_converges))

+		{ //wrap normals on S

+			for (S32 i = 0; i < mNumT; i++)

+			{

+				LLVector4a n;

+				n.setAdd(norm[mNumS*i], norm[mNumS*i+mNumS-1]);

+				norm[mNumS * i] = n;

+				norm[mNumS * i+mNumS-1] = n;

+			}

+		}

+	

+		if (volume->getPathType() == LL_PCODE_PATH_CIRCLE &&

+			((volume->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++)

+				{

+					norm[mNumS*i].set(1,0,0);

+				}

+			}

+

+			if (s_top_converges)

+			{ //all upper S have same normal

+				for (S32 i = 0; i < mNumT; i++)

+				{

+					norm[mNumS*i+mNumS-1].set(-1,0,0);

+				}

+			}

+		}

+	}

+	else  // logic for sculpt volumes

+	{

+		BOOL average_poles = FALSE;

+		BOOL wrap_s = FALSE;

+		BOOL wrap_t = FALSE;

+

+		if (sculpt_stitching == LL_SCULPT_TYPE_SPHERE)

+			average_poles = TRUE;

+

+		if ((sculpt_stitching == LL_SCULPT_TYPE_SPHERE) ||

+			(sculpt_stitching == LL_SCULPT_TYPE_TORUS) ||

+			(sculpt_stitching == LL_SCULPT_TYPE_CYLINDER))

+			wrap_s = TRUE;

+

+		if (sculpt_stitching == LL_SCULPT_TYPE_TORUS)

+			wrap_t = TRUE;

+			

+		

+		if (average_poles)

+		{

+			// average normals for north pole

+		

+			LLVector4a average;

+			average.clear();

+

+			for (S32 i = 0; i < mNumS; i++)

+			{

+				average.add(norm[i]);

+			}

+

+			// set average

+			for (S32 i = 0; i < mNumS; i++)

+			{

+				norm[i] = average;

+			}

+

+			// average normals for south pole

+		

+			average.clear();

+

+			for (S32 i = 0; i < mNumS; i++)

+			{

+				average.add(norm[i + mNumS * (mNumT - 1)]);

+			}

+

+			// set average

+			for (S32 i = 0; i < mNumS; i++)

+			{

+				norm[i + mNumS * (mNumT - 1)] = average;

+			}

+

+		}

+

+		

+		if (wrap_s)

+		{

+			for (S32 i = 0; i < mNumT; i++)

+			{

+				LLVector4a n;

+				n.setAdd(norm[mNumS*i], norm[mNumS*i+mNumS-1]);

+				norm[mNumS * i] = n;

+				norm[mNumS * i+mNumS-1] = n;

+			}

+		}

+

+		if (wrap_t)

+		{

+			for (S32 i = 0; i < mNumS; i++)

+			{

+				LLVector4a n;

+				n.setAdd(norm[i], norm[mNumS*(mNumT-1)+i]);

+				norm[i] = n;

+				norm[mNumS*(mNumT-1)+i] = n;

+			}

+		}

+

+	}

+

+	return TRUE;

+}

+

+// Finds binormal based on three vertices with texture coordinates.

+// Fills in dummy values if the triangle has degenerate texture coordinates.

+void calc_binormal_from_triangle(LLVector4a& binormal,

+

+	const LLVector4a& pos0,

+	const LLVector2& tex0,

+	const LLVector4a& pos1,

+	const LLVector2& tex1,

+	const LLVector4a& pos2,

+	const LLVector2& tex2)

+{

+	LLVector4a rx0( pos0[VX], tex0.mV[VX], tex0.mV[VY] );

+	LLVector4a rx1( pos1[VX], tex1.mV[VX], tex1.mV[VY] );

+	LLVector4a rx2( pos2[VX], tex2.mV[VX], tex2.mV[VY] );

+	

+	LLVector4a ry0( pos0[VY], tex0.mV[VX], tex0.mV[VY] );

+	LLVector4a ry1( pos1[VY], tex1.mV[VX], tex1.mV[VY] );

+	LLVector4a ry2( pos2[VY], tex2.mV[VX], tex2.mV[VY] );

+

+	LLVector4a rz0( pos0[VZ], tex0.mV[VX], tex0.mV[VY] );

+	LLVector4a rz1( pos1[VZ], tex1.mV[VX], tex1.mV[VY] );

+	LLVector4a rz2( pos2[VZ], tex2.mV[VX], tex2.mV[VY] );

+	

+	LLVector4a lhs, rhs;

+

+	LLVector4a r0; 

+	lhs.setSub(rx0, rx1); rhs.setSub(rx0, rx2);

+	r0.setCross3(lhs, rhs);

+		

+	LLVector4a r1;

+	lhs.setSub(ry0, ry1); rhs.setSub(ry0, ry2);

+	r1.setCross3(lhs, rhs);

+

+	LLVector4a r2;

+	lhs.setSub(rz0, rz1); rhs.setSub(rz0, rz2);

+	r2.setCross3(lhs, rhs);

+

+	if( r0[VX] && r1[VX] && r2[VX] )

+	{

+		binormal.set(

+				-r0[VZ] / r0[VX],

+				-r1[VZ] / r1[VX],

+				-r2[VZ] / r2[VX]);

+		// binormal.normVec();

+	}

+	else

+	{

+		binormal.set( 0, 1 , 0 );

+	}

+}

diff --git a/indra/llmath/llvolume.h b/indra/llmath/llvolume.h
index 28b9895ff3..01bfbd858b 100644
--- a/indra/llmath/llvolume.h
+++ b/indra/llmath/llvolume.h
@@ -34,8 +34,13 @@ class LLPathParams;
 class LLVolumeParams;
 class LLProfile;
 class LLPath;
+
+template <class T> class LLOctreeNode;
+
+class LLVector4a;
 class LLVolumeFace;
 class LLVolume;
+class LLVolumeTriangle;
 
 #include "lldarray.h"
 #include "lluuid.h"
@@ -43,6 +48,8 @@ class LLVolume;
 //#include "vmath.h"
 #include "v2math.h"
 #include "v3math.h"
+#include "v3dmath.h"
+#include "v4math.h"
 #include "llquaternion.h"
 #include "llstrider.h"
 #include "v4coloru.h"
@@ -177,12 +184,14 @@ const U8 LL_SCULPT_TYPE_SPHERE    = 1;
 const U8 LL_SCULPT_TYPE_TORUS     = 2;
 const U8 LL_SCULPT_TYPE_PLANE     = 3;
 const U8 LL_SCULPT_TYPE_CYLINDER  = 4;
-
-const U8 LL_SCULPT_TYPE_MASK      = LL_SCULPT_TYPE_SPHERE | LL_SCULPT_TYPE_TORUS | LL_SCULPT_TYPE_PLANE | LL_SCULPT_TYPE_CYLINDER;
+const U8 LL_SCULPT_TYPE_MESH      = 5;
+const U8 LL_SCULPT_TYPE_MASK      = LL_SCULPT_TYPE_SPHERE | LL_SCULPT_TYPE_TORUS | LL_SCULPT_TYPE_PLANE |
+	LL_SCULPT_TYPE_CYLINDER | LL_SCULPT_TYPE_MESH;
 
 const U8 LL_SCULPT_FLAG_INVERT    = 64;
 const U8 LL_SCULPT_FLAG_MIRROR    = 128;
 
+const S32 LL_SCULPT_MESH_MAX_FACES = 8;
 
 class LLProfileParams
 {
@@ -569,6 +578,9 @@ public:
 	BOOL importLegacyStream(std::istream& input_stream);
 	BOOL exportLegacyStream(std::ostream& output_stream) const;
 
+	LLSD sculptAsLLSD() const;
+	bool sculptFromLLSD(LLSD& sd);
+	
 	LLSD asLLSD() const;
 	operator LLSD() const { return asLLSD(); }
 	bool fromLLSD(LLSD& sd);
@@ -628,7 +640,8 @@ public:
 	const F32&  getSkew() const			{ return mPathParams.getSkew();			}
 	const LLUUID& getSculptID() const	{ return mSculptID;						}
 	const U8& getSculptType() const     { return mSculptType;                   }
-
+	bool isSculpt() const;
+	bool isMeshSculpt() const;
 	BOOL isConvex() const;
 
 	// 'begin' and 'end' should be in range [0, 1] (they will be clamped)
@@ -779,30 +792,88 @@ public:
 class LLVolumeFace
 {
 public:
-	LLVolumeFace() : 
-		mID(0),
-		mTypeMask(0),
-		mHasBinormals(FALSE),
-		mBeginS(0),
-		mBeginT(0),
-		mNumS(0),
-		mNumT(0)
+	class VertexData
 	{
-	}
+		enum 
+		{
+			POSITION = 0,
+			NORMAL = 1
+		};
+
+	private:
+		void init();
+	public:
+		VertexData();
+		VertexData(const VertexData& rhs);
+		const VertexData& operator=(const VertexData& rhs);
+
+		~VertexData();
+		LLVector4a& getPosition();
+		LLVector4a& getNormal();
+		const LLVector4a& getPosition() const;
+		const LLVector4a& getNormal() const;
+		void setPosition(const LLVector4a& pos);
+		void setNormal(const LLVector4a& norm);
+		
+
+		LLVector2 mTexCoord;
+
+		bool operator<(const VertexData& rhs) const;
+		bool operator==(const VertexData& rhs) const;
+		bool compareNormal(const VertexData& rhs, F32 angle_cutoff) const;
+
+	private:
+		LLVector4a* mData;
+	};
+
+	LLVolumeFace();
+	LLVolumeFace(const LLVolumeFace& src);
+	LLVolumeFace& operator=(const LLVolumeFace& rhs);
+
+	~LLVolumeFace();
+private:
+	void freeData();
+public:
 
 	BOOL create(LLVolume* volume, BOOL partial_build = FALSE);
 	void createBinormals();
-	void makeTriStrip();
 	
-	class VertexData
+	void appendFace(const LLVolumeFace& face, LLMatrix4& transform, LLMatrix4& normal_tranform);
+
+	void resizeVertices(S32 num_verts);
+	void allocateBinormals(S32 num_verts);
+	void allocateWeights(S32 num_verts);
+	void resizeIndices(S32 num_indices);
+	void fillFromLegacyData(std::vector<LLVolumeFace::VertexData>& v, std::vector<U16>& idx);
+
+	void pushVertex(const VertexData& cv);
+	void pushVertex(const LLVector4a& pos, const LLVector4a& norm, const LLVector2& tc);
+	void pushIndex(const U16& idx);
+
+	void swapData(LLVolumeFace& rhs);
+
+	void getVertexData(U16 indx, LLVolumeFace::VertexData& cv);
+
+	class VertexMapData : public LLVolumeFace::VertexData
 	{
 	public:
-		LLVector3 mPosition;
-		LLVector3 mNormal;
-		LLVector3 mBinormal;
-		LLVector2 mTexCoord;
+		U16 mIndex;
+
+		bool operator==(const LLVolumeFace::VertexData& rhs) const;
+
+		struct ComparePosition
+		{
+			bool operator()(const LLVector3& a, const LLVector3& b) const;
+		};
+
+		typedef std::map<LLVector3, std::vector<VertexMapData>, VertexMapData::ComparePosition > PointMap;
 	};
 
+	void optimize(F32 angle_cutoff = 2.f);
+	void cacheOptimize();
+
+	void createOctree(F32 scaler = 0.25f, const LLVector4a& center = LLVector4a(0,0,0), const LLVector4a& size = LLVector4a(0.5f,0.5f,0.5f));
+
 	enum
 	{
 		SINGLE_MASK =	0x0001,
@@ -821,23 +892,35 @@ public:
 public:
 	S32 mID;
 	U32 mTypeMask;
-	LLVector3 mCenter;
-	BOOL mHasBinormals;
-
+	
 	// Only used for INNER/OUTER faces
 	S32 mBeginS;
 	S32 mBeginT;
 	S32 mNumS;
 	S32 mNumT;
 
-	LLVector3 mExtents[2]; //minimum and maximum point of face
-	LLVector2 mTexCoordExtents[2]; //minimum and maximum of texture coordinates of the face.
+	LLVector4a* mExtents; //minimum and maximum point of face
+	LLVector4a* mCenter;
+	LLVector2   mTexCoordExtents[2]; //minimum and maximum of texture coordinates of the face.
+
+	S32 mNumVertices;
+	S32 mNumIndices;
+
+	LLVector4a* mPositions;
+	LLVector4a* mNormals;
+	LLVector4a* mBinormals;
+	LLVector2*  mTexCoords;
+	U16* mIndices;
 
-	std::vector<VertexData> mVertices;
-	std::vector<U16>	mIndices;
-	std::vector<U16>	mTriStrip;
 	std::vector<S32>	mEdge;
 
+	//list of skin weights for rigged volumes
+	// format is mWeights[vertex_index].mV[influence] = <joint_index>.<weight>
+	// mWeights.size() should be empty or match mVertices.size()  
+	LLVector4a* mWeights;
+
+	LLOctreeNode<LLVolumeTriangle>* mOctree;
+
 private:
 	BOOL createUnCutCubeCap(LLVolume* volume, BOOL partial_build = FALSE);
 	BOOL createCap(LLVolume* volume, BOOL partial_build = FALSE);
@@ -848,8 +931,7 @@ class LLVolume : public LLRefCount
 {
 	friend class LLVolumeLODGroup;
 
-private:
-	LLVolume(const LLVolume&);  // Don't implement
+protected:
 	~LLVolume(); // use unref
 
 public:
@@ -871,7 +953,7 @@ public:
 	
 	U8 getProfileType()	const								{ return mParams.getProfileParams().getCurveType(); }
 	U8 getPathType() const									{ return mParams.getPathParams().getCurveType(); }
-	S32	getNumFaces() const									{ return (S32)mProfilep->mFaces.size(); }
+	S32	getNumFaces() const;
 	S32 getNumVolumeFaces() const							{ return mVolumeFaces.size(); }
 	F32 getDetail() const									{ return mDetail; }
 	const LLVolumeParams& getParams() const					{ return mParams; }
@@ -893,15 +975,17 @@ public:
 	BOOL isUnique() const									{ return mUnique; }
 
 	S32 getSculptLevel() const                              { return mSculptLevel; }
-	
+	void setSculptLevel(S32 level)							{ mSculptLevel = level; }
+
 	S32 *getTriangleIndices(U32 &num_indices) const;
 
 	// returns number of triangle indeces required for path/profile mesh
 	S32 getNumTriangleIndices() const;
 
+	S32 getNumTriangles() 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,
@@ -917,6 +1001,13 @@ public:
 							 LLVector3* normal = NULL,               // return the surface normal at the intersection point
 							 LLVector3* bi_normal = NULL             // return the surface bi-normal at the intersection point
 		);
+
+	S32 lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end, 
+								   S32 face = 1,
+								   LLVector3* intersection = NULL,
+								   LLVector2* tex_coord = NULL,
+								   LLVector3* normal = NULL,
+								   LLVector3* bi_normal = NULL);
 	
 	// The following cleans up vertices and triangles,
 	// getting rid of degenerate triangles and duplicate vertices,
@@ -938,11 +1029,14 @@ public:
 	friend std::ostream& operator<<(std::ostream &s, const LLVolume *volumep);		// HACK to bypass Windoze confusion over 
 																				// conversion if *(LLVolume*) to LLVolume&
 	const LLVolumeFace &getVolumeFace(const S32 f) const {return mVolumeFaces[f];} // DO NOT DELETE VOLUME WHILE USING THIS REFERENCE, OR HOLD A POINTER TO THIS VOLUMEFACE
-
+	
 	U32					mFaceMask;			// bit array of which faces exist in this volume
 	LLVector3			mLODScaleBias;		// vector for biasing LOD based on scale
 	
 	void sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, S32 sculpt_level);
+	void copyVolumeFaces(const LLVolume* volume);
+	void cacheOptimize();
+
 private:
 	void sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, U8 sculpt_type);
 	F32 sculptGetSurfaceArea();
@@ -953,35 +1047,56 @@ private:
 protected:
 	BOOL generate();
 	void createVolumeFaces();
+public:
+	virtual bool unpackVolumeFaces(std::istream& is, S32 size);
+
+	virtual void makeTetrahedron();
+	virtual BOOL isTetrahedron();
 
  protected:
 	BOOL mUnique;
 	F32 mDetail;
 	S32 mSculptLevel;
+	BOOL mIsTetrahedron;
 	
 	LLVolumeParams mParams;
 	LLPath *mPathp;
 	LLProfile *mProfilep;
 	std::vector<Point> mMesh;
-
+	
 	BOOL mGenerateSingleFace;
 	typedef std::vector<LLVolumeFace> face_list_t;
 	face_list_t mVolumeFaces;
+
+public:
+	LLVector4a* mHullPoints;
+	U16* mHullIndices;
+	S32 mNumHullPoints;
+	S32 mNumHullIndices;
 };
 
 std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params);
 
-LLVector3 calc_binormal_from_triangle(
-		const LLVector3& pos0,
+void calc_binormal_from_triangle(
+		LLVector4a& binormal,
+		const LLVector4a& pos0,
 		const LLVector2& tex0,
-		const LLVector3& pos1,
+		const LLVector4a& pos1,
 		const LLVector2& tex1,
-		const LLVector3& pos2,
+		const LLVector4a& pos2,
 		const LLVector2& tex2);
 
+BOOL LLLineSegmentBoxIntersect(const F32* start, const F32* end, const F32* center, const F32* size);
 BOOL LLLineSegmentBoxIntersect(const LLVector3& start, const LLVector3& end, const LLVector3& center, const LLVector3& size);
+BOOL LLLineSegmentBoxIntersect(const LLVector4a& start, const LLVector4a& end, const LLVector4a& center, const LLVector4a& size);
+
 BOOL LLTriangleRayIntersect(const LLVector3& vert0, const LLVector3& vert1, const LLVector3& vert2, const LLVector3& orig, const LLVector3& dir,
-							F32* intersection_a, F32* intersection_b, F32* intersection_t, BOOL two_sided);
+							F32& intersection_a, F32& intersection_b, F32& intersection_t, BOOL two_sided);
+
+BOOL LLTriangleRayIntersect(const LLVector4a& vert0, const LLVector4a& vert1, const LLVector4a& vert2, const LLVector4a& orig, const LLVector4a& dir,
+							F32& intersection_a, F32& intersection_b, F32& intersection_t);
+BOOL LLTriangleRayIntersectTwoSided(const LLVector4a& vert0, const LLVector4a& vert1, const LLVector4a& vert2, const LLVector4a& orig, const LLVector4a& dir,
+							F32& intersection_a, F32& intersection_b, F32& intersection_t);
 	
 	
 
diff --git a/indra/llmath/llvolumemgr.cpp b/indra/llmath/llvolumemgr.cpp
index 88c195936c..c60b750088 100644
--- a/indra/llmath/llvolumemgr.cpp
+++ b/indra/llmath/llvolumemgr.cpp
@@ -314,7 +314,7 @@ BOOL LLVolumeLODGroup::derefLOD(LLVolume *volumep)
 		{
 			llassert_always(mLODRefs[i] > 0);
 			mLODRefs[i]--;
-#if 1 // SJB: Possible opt: keep other lods around
+#if 0 // SJB: Possible opt: keep other lods around
 			if (!mLODRefs[i])
 			{
 				mVolumeLODs[i] = NULL;
@@ -369,6 +369,19 @@ F32 LLVolumeLODGroup::getVolumeScaleFromDetail(const S32 detail)
 	return mDetailScales[detail];
 }
 
+S32 LLVolumeLODGroup::getVolumeDetailFromScale(const F32 detail)
+{
+	for (S32 i = 1; i < 4; i++)
+	{
+		if (mDetailScales[i] > detail)
+		{
+			return i-1;
+		}
+	}
+
+	return 3;
+}
+
 F32 LLVolumeLODGroup::dump()
 {
 	F32 usage = 0.f;
diff --git a/indra/llmath/llvolumemgr.h b/indra/llmath/llvolumemgr.h
index 5257da2693..c75906f675 100644
--- a/indra/llmath/llvolumemgr.h
+++ b/indra/llmath/llvolumemgr.h
@@ -53,6 +53,7 @@ public:
 	static S32 getDetailFromTan(const F32 tan_angle);
 	static void getDetailProximity(const F32 tan_angle, F32 &to_lower, F32& to_higher);
 	static F32 getVolumeScaleFromDetail(const S32 detail);
+	static S32 getVolumeDetailFromScale(F32 scale);
 
 	LLVolume* refLOD(const S32 detail);
 	BOOL derefLOD(LLVolume *volumep);
diff --git a/indra/llmath/llvolumeoctree.cpp b/indra/llmath/llvolumeoctree.cpp
new file mode 100644
index 0000000000..b5a935c2b5
--- /dev/null
+++ b/indra/llmath/llvolumeoctree.cpp
@@ -0,0 +1,256 @@
+/** 
+
+ * @file llvolumeoctree.cpp
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llvolumeoctree.h"
+#include "llvector4a.h"
+
+BOOL LLLineSegmentBoxIntersect(const LLVector4a& start, const LLVector4a& end, const LLVector4a& center, const LLVector4a& size)
+{
+	LLVector4a fAWdU;
+	LLVector4a dir;
+	LLVector4a diff;
+
+	dir.setSub(end, start);
+	dir.mul(0.5f);
+
+	diff.setAdd(end,start);
+	diff.mul(0.5f);
+	diff.sub(center);
+	fAWdU.setAbs(dir); 
+
+	LLVector4a rhs;
+	rhs.setAdd(size, fAWdU);
+
+	LLVector4a lhs;
+	lhs.setAbs(diff);
+
+	U32 grt = lhs.greaterThan(rhs).getGatheredBits();
+
+	if (grt & 0x7)
+	{
+		return false;
+	}
+	
+	LLVector4a f;
+	f.setCross3(dir, diff);
+	f.setAbs(f);
+
+	LLVector4a v0, v1;
+
+	v0 = _mm_shuffle_ps(size, size,_MM_SHUFFLE(3,0,0,1));
+	v1 = _mm_shuffle_ps(fAWdU, fAWdU, _MM_SHUFFLE(3,1,2,2));
+	lhs.setMul(v0, v1);
+
+	v0 = _mm_shuffle_ps(size, size, _MM_SHUFFLE(3,1,2,2));
+	v1 = _mm_shuffle_ps(fAWdU, fAWdU, _MM_SHUFFLE(3,0,0,1));
+	rhs.setMul(v0, v1);
+	rhs.add(lhs);
+	
+	grt = f.greaterThan(rhs).getGatheredBits();
+
+	return (grt & 0x7) ? false : true;
+}
+
+
+LLVolumeOctreeListener::LLVolumeOctreeListener(LLOctreeNode<LLVolumeTriangle>* node)
+{
+	node->addListener(this);
+}
+
+LLVolumeOctreeListener::~LLVolumeOctreeListener()
+{
+
+}
+	
+void LLVolumeOctreeListener::handleChildAddition(const LLOctreeNode<LLVolumeTriangle>* parent, 
+	LLOctreeNode<LLVolumeTriangle>* child)
+{
+	new LLVolumeOctreeListener(child);
+}
+
+
+LLOctreeTriangleRayIntersect::LLOctreeTriangleRayIntersect(const LLVector4a& start, const LLVector4a& dir, 
+							   const LLVolumeFace* face, F32* closest_t,
+							   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
+   : mFace(face),
+     mStart(start),
+	 mDir(dir),
+	 mIntersection(intersection),
+	 mTexCoord(tex_coord),
+	 mNormal(normal),
+	 mBinormal(bi_normal),
+	 mClosestT(closest_t),
+	 mHitFace(false)
+{
+	mEnd.setAdd(mStart, mDir);
+}
+
+void LLOctreeTriangleRayIntersect::traverse(const LLOctreeNode<LLVolumeTriangle>* node)
+{
+	LLVolumeOctreeListener* vl = (LLVolumeOctreeListener*) node->getListener(0);
+
+	/*const F32* start = mStart.getF32();
+	const F32* end = mEnd.getF32();
+	const F32* center = vl->mBounds[0].getF32();
+	const F32* size = vl->mBounds[1].getF32();*/
+
+	//if (LLLineSegmentBoxIntersect(mStart, mEnd, vl->mBounds[0], vl->mBounds[1]))
+	if (LLLineSegmentBoxIntersect(mStart.getF32ptr(), mEnd.getF32ptr(), vl->mBounds[0].getF32ptr(), vl->mBounds[1].getF32ptr()))
+	{
+		node->accept(this);
+		for (S32 i = 0; i < node->getChildCount(); ++i)
+		{
+			traverse(node->getChild(i));
+		}
+	}
+}
+
+void LLOctreeTriangleRayIntersect::visit(const LLOctreeNode<LLVolumeTriangle>* node)
+{
+	for (LLOctreeNode<LLVolumeTriangle>::const_element_iter iter = 
+			node->getData().begin(); iter != node->getData().end(); ++iter)
+	{
+		const LLVolumeTriangle* tri = *iter;
+
+		F32 a, b, t;
+		
+		if (LLTriangleRayIntersect(*tri->mV[0], *tri->mV[1], *tri->mV[2],
+				mStart, mDir, a, b, t))
+		{
+			if ((t >= 0.f) &&      // if hit is after start
+				(t <= 1.f) &&      // and before end
+				(t < *mClosestT))   // and this hit is closer
+			{
+				*mClosestT = t;
+				mHitFace = true;
+
+				if (mIntersection != NULL)
+				{
+					LLVector4a intersect = mDir;
+					intersect.mul(*mClosestT);
+					intersect.add(mStart);
+					mIntersection->set(intersect.getF32ptr());
+				}
+
+
+				if (mTexCoord != NULL)
+				{
+					LLVector2* tc = (LLVector2*) mFace->mTexCoords;
+					*mTexCoord = ((1.f - a - b)  * tc[tri->mIndex[0]] +
+						a              * tc[tri->mIndex[1]] +
+						b              * tc[tri->mIndex[2]]);
+
+				}
+
+				if (mNormal != NULL)
+				{
+					LLVector4* norm = (LLVector4*) mFace->mNormals;
+
+					*mNormal    = ((1.f - a - b)  * LLVector3(norm[tri->mIndex[0]]) + 
+						a              * LLVector3(norm[tri->mIndex[1]]) +
+						b              * LLVector3(norm[tri->mIndex[2]]));
+				}
+
+				if (mBinormal != NULL)
+				{
+					LLVector4* binormal = (LLVector4*) mFace->mBinormals;
+					*mBinormal = ((1.f - a - b)  * LLVector3(binormal[tri->mIndex[0]]) + 
+							a              * LLVector3(binormal[tri->mIndex[1]]) +
+							b              * LLVector3(binormal[tri->mIndex[2]]));
+				}
+			}
+		}
+	}
+}
+
+const LLVector4a& LLVolumeTriangle::getPositionGroup() const
+{
+	return mPositionGroup;
+}
+
+const F32& LLVolumeTriangle::getBinRadius() const
+{
+	return mRadius;
+}
+
+
+//TEST CODE
+
+void LLVolumeOctreeValidate::visit(const LLOctreeNode<LLVolumeTriangle>* branch)
+{
+	LLVolumeOctreeListener* node = (LLVolumeOctreeListener*) branch->getListener(0);
+
+	//make sure bounds matches extents
+	LLVector4a& min = node->mExtents[0];
+	LLVector4a& max = node->mExtents[1];
+
+	LLVector4a& center = node->mBounds[0];
+	LLVector4a& size = node->mBounds[1];
+
+	LLVector4a test_min, test_max;
+	test_min.setSub(center, size);
+	test_max.setAdd(center, size);
+
+	if (!test_min.equals3(min, 0.001f) ||
+		!test_max.equals3(max, 0.001f))
+	{
+		llerrs << "Bad bounding box data found." << llendl;
+	}
+
+	test_min.sub(LLVector4a(0.001f));
+	test_max.add(LLVector4a(0.001f));
+
+	for (U32 i = 0; i < branch->getChildCount(); ++i)
+	{
+		LLVolumeOctreeListener* child = (LLVolumeOctreeListener*) branch->getChild(i)->getListener(0);
+
+		//make sure all children fit inside this node
+		if (child->mExtents[0].lessThan(test_min).areAnySet(LLVector4Logical::MASK_XYZ) ||
+			child->mExtents[1].greaterThan(test_max).areAnySet(LLVector4Logical::MASK_XYZ))
+		{
+			llerrs << "Child protrudes from bounding box." << llendl;
+		}
+	}
+
+	//children fit, check data
+	for (LLOctreeNode<LLVolumeTriangle>::const_element_iter iter = branch->getData().begin(); 
+			iter != branch->getData().end(); ++iter)
+	{
+		const LLVolumeTriangle* tri = *iter;
+
+		//validate triangle
+		for (U32 i = 0; i < 3; i++)
+		{
+			if (tri->mV[i]->greaterThan(test_max).areAnySet(LLVector4Logical::MASK_XYZ) ||
+				tri->mV[i]->lessThan(test_min).areAnySet(LLVector4Logical::MASK_XYZ))
+			{
+				llerrs << "Triangle protrudes from node." << llendl;
+			}
+		}
+	}
+}
+
+
diff --git a/indra/llmath/llvolumeoctree.h b/indra/llmath/llvolumeoctree.h
new file mode 100644
index 0000000000..688d91dc40
--- /dev/null
+++ b/indra/llmath/llvolumeoctree.h
@@ -0,0 +1,134 @@
+/** 
+ * @file llvolumeoctree.h
+ * @brief LLVolume octree classes.
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLVOLUME_OCTREE_H
+#define LL_LLVOLUME_OCTREE_H
+
+#include "linden_common.h"
+#include "llmemory.h"
+
+#include "lloctree.h"
+#include "llvolume.h"
+#include "llvector4a.h"
+
+class LLVolumeTriangle : public LLRefCount
+{
+public:
+	LLVolumeTriangle()
+	{
+		
+	}
+
+	LLVolumeTriangle(const LLVolumeTriangle& rhs)
+	{
+		*this = rhs;
+	}
+
+	const LLVolumeTriangle& operator=(const LLVolumeTriangle& rhs)
+	{
+		llerrs << "Illegal operation!" << llendl;
+		return *this;
+	}
+
+	~LLVolumeTriangle()
+	{
+	
+	}
+
+	LLVector4a mPositionGroup;
+
+	const LLVector4a* mV[3];
+	U16 mIndex[3];
+
+	F32 mRadius;
+
+	virtual const LLVector4a& getPositionGroup() const;
+	virtual const F32& getBinRadius() const;
+};
+
+class LLVolumeOctreeListener : public LLOctreeListener<LLVolumeTriangle>
+{
+public:
+	
+	LLVolumeOctreeListener(LLOctreeNode<LLVolumeTriangle>* node);
+	~LLVolumeOctreeListener();
+	
+	LLVolumeOctreeListener(const LLVolumeOctreeListener& rhs)
+	{
+		*this = rhs;
+	}
+
+	const LLVolumeOctreeListener& operator=(const LLVolumeOctreeListener& rhs)
+	{
+		llerrs << "Illegal operation!" << llendl;
+		return *this;
+	}
+
+	 //LISTENER FUNCTIONS
+	virtual void handleChildAddition(const LLOctreeNode<LLVolumeTriangle>* parent, 
+		LLOctreeNode<LLVolumeTriangle>* child);
+	virtual void handleStateChange(const LLTreeNode<LLVolumeTriangle>* node) { }
+	virtual void handleChildRemoval(const LLOctreeNode<LLVolumeTriangle>* parent, 
+			const LLOctreeNode<LLVolumeTriangle>* child) {	}
+	virtual void handleInsertion(const LLTreeNode<LLVolumeTriangle>* node, LLVolumeTriangle* tri) { }
+	virtual void handleRemoval(const LLTreeNode<LLVolumeTriangle>* node, LLVolumeTriangle* tri) { }
+	virtual void handleDestruction(const LLTreeNode<LLVolumeTriangle>* node) { }
+	
+
+public:
+	LLVector4a mBounds[2]; // bounding box (center, size) of this node and all its children (tight fit to objects)
+	LLVector4a mExtents[2]; // extents (min, max) of this node and all its children
+};
+
+class LLOctreeTriangleRayIntersect : public LLOctreeTraveler<LLVolumeTriangle>
+{
+public:
+	const LLVolumeFace* mFace;
+	LLVector4a mStart;
+	LLVector4a mDir;
+	LLVector4a mEnd;
+	LLVector3* mIntersection;
+	LLVector2* mTexCoord;
+	LLVector3* mNormal;
+	LLVector3* mBinormal;
+	F32* mClosestT;
+	bool mHitFace;
+
+	LLOctreeTriangleRayIntersect(const LLVector4a& start, const LLVector4a& dir, 
+								   const LLVolumeFace* face, F32* closest_t,
+								   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal);
+
+	void traverse(const LLOctreeNode<LLVolumeTriangle>* node);
+
+	virtual void visit(const LLOctreeNode<LLVolumeTriangle>* node);
+};
+
+class LLVolumeOctreeValidate : public LLOctreeTraveler<LLVolumeTriangle>
+{
+	virtual void visit(const LLOctreeNode<LLVolumeTriangle>* branch);
+};
+
+#endif
diff --git a/indra/llmath/m4math.cpp b/indra/llmath/m4math.cpp
index 946b1553fe..bad4deb4de 100644
--- a/indra/llmath/m4math.cpp
+++ b/indra/llmath/m4math.cpp
@@ -215,8 +215,33 @@ const LLMatrix4&	LLMatrix4::transpose()
 
 F32 LLMatrix4::determinant() const
 {
-	llerrs << "Not implemented!" << llendl;
-	return 0.f;
+	F32 value =
+	    mMatrix[0][3] * mMatrix[1][2] * mMatrix[2][1] * mMatrix[3][0] -
+	    mMatrix[0][2] * mMatrix[1][3] * mMatrix[2][1] * mMatrix[3][0] -
+	    mMatrix[0][3] * mMatrix[1][1] * mMatrix[2][2] * mMatrix[3][0] +
+	    mMatrix[0][1] * mMatrix[1][3] * mMatrix[2][2] * mMatrix[3][0] +
+	    mMatrix[0][2] * mMatrix[1][1] * mMatrix[2][3] * mMatrix[3][0] -
+	    mMatrix[0][1] * mMatrix[1][2] * mMatrix[2][3] * mMatrix[3][0] -
+	    mMatrix[0][3] * mMatrix[1][2] * mMatrix[2][0] * mMatrix[3][1] +
+	    mMatrix[0][2] * mMatrix[1][3] * mMatrix[2][0] * mMatrix[3][1] +
+	    mMatrix[0][3] * mMatrix[1][0] * mMatrix[2][2] * mMatrix[3][1] -
+	    mMatrix[0][0] * mMatrix[1][3] * mMatrix[2][2] * mMatrix[3][1] -
+	    mMatrix[0][2] * mMatrix[1][0] * mMatrix[2][3] * mMatrix[3][1] +
+	    mMatrix[0][0] * mMatrix[1][2] * mMatrix[2][3] * mMatrix[3][1] +
+	    mMatrix[0][3] * mMatrix[1][1] * mMatrix[2][0] * mMatrix[3][2] -
+	    mMatrix[0][1] * mMatrix[1][3] * mMatrix[2][0] * mMatrix[3][2] -
+	    mMatrix[0][3] * mMatrix[1][0] * mMatrix[2][1] * mMatrix[3][2] +
+	    mMatrix[0][0] * mMatrix[1][3] * mMatrix[2][1] * mMatrix[3][2] +
+	    mMatrix[0][1] * mMatrix[1][0] * mMatrix[2][3] * mMatrix[3][2] -
+	    mMatrix[0][0] * mMatrix[1][1] * mMatrix[2][3] * mMatrix[3][2] -
+	    mMatrix[0][2] * mMatrix[1][1] * mMatrix[2][0] * mMatrix[3][3] +
+	    mMatrix[0][1] * mMatrix[1][2] * mMatrix[2][0] * mMatrix[3][3] +
+	    mMatrix[0][2] * mMatrix[1][0] * mMatrix[2][1] * mMatrix[3][3] -
+	    mMatrix[0][0] * mMatrix[1][2] * mMatrix[2][1] * mMatrix[3][3] -
+	    mMatrix[0][1] * mMatrix[1][0] * mMatrix[2][2] * mMatrix[3][3] +
+		mMatrix[0][0] * mMatrix[1][1] * mMatrix[2][2] * mMatrix[3][3];
+
+	return value;
 }
 
 // Only works for pure orthonormal, homogeneous transform matrices.
@@ -422,6 +447,17 @@ const LLMatrix4&  	LLMatrix4::initRotTrans(const LLQuaternion &q, const LLVector
 	return (*this);
 }
 
+const LLMatrix4& LLMatrix4::initScale(const LLVector3 &scale)
+{
+	setIdentity();
+
+	mMatrix[VX][VX] = scale.mV[VX];
+	mMatrix[VY][VY] = scale.mV[VY];
+	mMatrix[VZ][VZ] = scale.mV[VZ];
+	
+	return (*this);
+}
+
 const LLMatrix4& LLMatrix4::initAll(const LLVector3 &scale, const LLQuaternion &q, const LLVector3 &pos)
 {
 	F32		sx, sy, sz;
@@ -642,37 +678,6 @@ const LLMatrix4&  	LLMatrix4::initMatrix(const LLMatrix3 &mat, const LLVector4 &
 
 // LLMatrix4 Operators
 
-
-/* Not implemented to help enforce code consistency with the syntax of
-   row-major notation.  This is a Good Thing.
-LLVector4 operator*(const LLMatrix4 &a, const LLVector4 &b)
-{
-	// Operate "to the right" on column-vector b
-	LLVector4	vec;
-	vec.mV[VX] = a.mMatrix[VX][VX] * b.mV[VX] + 
-				 a.mMatrix[VY][VX] * b.mV[VY] + 
- 				 a.mMatrix[VZ][VX] * b.mV[VZ] +
-				 a.mMatrix[VW][VX] * b.mV[VW];
-
-	vec.mV[VY] = a.mMatrix[VX][VY] * b.mV[VX] + 
-				 a.mMatrix[VY][VY] * b.mV[VY] + 
-				 a.mMatrix[VZ][VY] * b.mV[VZ] +
-				 a.mMatrix[VW][VY] * b.mV[VW];
-
-	vec.mV[VZ] = a.mMatrix[VX][VZ] * b.mV[VX] + 
-			  	 a.mMatrix[VY][VZ] * b.mV[VY] + 
-				 a.mMatrix[VZ][VZ] * b.mV[VZ] +
-				 a.mMatrix[VW][VZ] * b.mV[VW];
-
-	vec.mV[VW] = a.mMatrix[VX][VW] * b.mV[VX] + 
-				 a.mMatrix[VY][VW] * b.mV[VY] + 
-				 a.mMatrix[VZ][VW] * b.mV[VZ] +
-				 a.mMatrix[VW][VW] * b.mV[VW];
-	return vec;
-}
-*/
-
-
 LLVector4 operator*(const LLVector4 &a, const LLMatrix4 &b)
 {
 	// Operate "to the left" on row-vector a
@@ -768,6 +773,23 @@ bool operator!=(const LLMatrix4 &a, const LLMatrix4 &b)
 	return FALSE;
 }
 
+bool operator<(const LLMatrix4& a, const LLMatrix4 &b)
+{
+	U32		i, j;
+	for (i = 0; i < NUM_VALUES_IN_MAT4; i++)
+	{
+		for (j = 0; j < NUM_VALUES_IN_MAT4; j++)
+		{
+			if (a.mMatrix[i][j] != b.mMatrix[i][j])
+			{
+				return a.mMatrix[i][j] < b.mMatrix[i][j];
+			}
+		}
+	}
+
+	return false;
+}
+
 const LLMatrix4& operator*=(LLMatrix4 &a, F32 k)
 {
 	U32		i, j;
@@ -807,4 +829,54 @@ std::ostream& operator<<(std::ostream& s, const LLMatrix4 &a)
 	return s;
 }
 
+LLSD LLMatrix4::getValue() const
+{
+	LLSD ret;
+	
+	ret[0] = mMatrix[0][0];
+	ret[1] = mMatrix[0][1];
+	ret[2] = mMatrix[0][2];
+	ret[3] = mMatrix[0][3];
+
+	ret[4] = mMatrix[1][0];
+	ret[5] = mMatrix[1][1];
+	ret[6] = mMatrix[1][2];
+	ret[7] = mMatrix[1][3];
+
+	ret[8] = mMatrix[2][0];
+	ret[9] = mMatrix[2][1];
+	ret[10] = mMatrix[2][2];
+	ret[11] = mMatrix[2][3];
+
+	ret[12] = mMatrix[3][0];
+	ret[13] = mMatrix[3][1];
+	ret[14] = mMatrix[3][2];
+	ret[15] = mMatrix[3][3];
+
+	return ret;
+}
+
+void LLMatrix4::setValue(const LLSD& data) 
+{
+	mMatrix[0][0] = data[0].asReal();
+	mMatrix[0][1] = data[1].asReal();
+	mMatrix[0][2] = data[2].asReal();
+	mMatrix[0][3] = data[3].asReal();
+
+	mMatrix[1][0] = data[4].asReal();
+	mMatrix[1][1] = data[5].asReal();
+	mMatrix[1][2] = data[6].asReal();
+	mMatrix[1][3] = data[7].asReal();
+
+	mMatrix[2][0] = data[8].asReal();
+	mMatrix[2][1] = data[9].asReal();
+	mMatrix[2][2] = data[10].asReal();
+	mMatrix[2][3] = data[11].asReal();
+
+	mMatrix[3][0] = data[12].asReal();
+	mMatrix[3][1] = data[13].asReal();
+	mMatrix[3][2] = data[14].asReal();
+	mMatrix[3][3] = data[15].asReal();
+}
+
 
diff --git a/indra/llmath/m4math.h b/indra/llmath/m4math.h
index 6ec9958491..a7dce10397 100644
--- a/indra/llmath/m4math.h
+++ b/indra/llmath/m4math.h
@@ -119,6 +119,8 @@ public:
 
 	~LLMatrix4(void);										// Destructor
 
+	LLSD getValue() const;
+	void setValue(const LLSD&);
 
 	//////////////////////////////
 	//
@@ -132,6 +134,7 @@ public:
 
 	// various useful matrix functions
 	const LLMatrix4& setIdentity();					// Load identity matrix
+	bool isIdentity() const;
 	const LLMatrix4& setZero();						// Clears matrix to all zeros.
 
 	const LLMatrix4& initRotation(const F32 angle, const F32 x, const F32 y, const F32 z);	// Calculate rotation matrix by rotating angle radians about (x, y, z)
@@ -153,6 +156,7 @@ public:
 	const LLMatrix4& initRotTrans(const F32 roll, const F32 pitch, const F32 yaw, const LLVector4 &pos); // Rotation from Euler + translation
 	const LLMatrix4& initRotTrans(const LLQuaternion &q, const LLVector4 &pos);	// Set with Quaternion and position
 
+	const LLMatrix4& initScale(const LLVector3 &scale);
 
 	// Set all
 	const LLMatrix4& initAll(const LLVector3 &scale, const LLQuaternion &q, const LLVector3 &pos);	
@@ -219,10 +223,7 @@ public:
 	// Operators
 	//
 
-// Not implemented to enforce code that agrees with symbolic syntax
-//		friend LLVector4 operator*(const LLMatrix4 &a, const LLVector4 &b);		// Apply rotation a to vector b
-
-//	friend inline LLMatrix4 operator*(const LLMatrix4 &a, const LLMatrix4 &b);		// Return a * b
+	//	friend inline LLMatrix4 operator*(const LLMatrix4 &a, const LLMatrix4 &b);		// Return a * b
 	friend LLVector4 operator*(const LLVector4 &a, const LLMatrix4 &b);		// Return transform of vector a by matrix b
 	friend const LLVector3 operator*(const LLVector3 &a, const LLMatrix4 &b);		// Return full transform of a by matrix b
 	friend LLVector4 rotate_vector(const LLVector4 &a, const LLMatrix4 &b);	// Rotates a but does not translate
@@ -230,6 +231,7 @@ public:
 
 	friend bool operator==(const LLMatrix4 &a, const LLMatrix4 &b);			// Return a == b
 	friend bool operator!=(const LLMatrix4 &a, const LLMatrix4 &b);			// Return a != b
+	friend bool operator<(const LLMatrix4 &a, const LLMatrix4& b);			// Return a < b
 
 	friend const LLMatrix4& operator+=(LLMatrix4 &a, const LLMatrix4 &b);	// Return a + b
 	friend const LLMatrix4& operator-=(LLMatrix4 &a, const LLMatrix4 &b);	// Return a - b
@@ -263,6 +265,30 @@ inline const LLMatrix4&	LLMatrix4::setIdentity()
 	return (*this);
 }
 
+inline bool LLMatrix4::isIdentity() const
+{
+	return
+		mMatrix[0][0] == 1.f &&
+		mMatrix[0][1] == 0.f &&
+		mMatrix[0][2] == 0.f &&
+		mMatrix[0][3] == 0.f &&
+
+		mMatrix[1][0] == 0.f &&
+		mMatrix[1][1] == 1.f &&
+		mMatrix[1][2] == 0.f &&
+		mMatrix[1][3] == 0.f &&
+
+		mMatrix[2][0] == 0.f &&
+		mMatrix[2][1] == 0.f &&
+		mMatrix[2][2] == 1.f &&
+		mMatrix[2][3] == 0.f &&
+
+		mMatrix[3][0] == 0.f &&
+		mMatrix[3][1] == 0.f &&
+		mMatrix[3][2] == 0.f &&
+		mMatrix[3][3] == 1.f;
+}
+
 
 /*
 inline LLMatrix4 operator*(const LLMatrix4 &a, const LLMatrix4 &b)
diff --git a/indra/llmath/tests/llquaternion_test.cpp b/indra/llmath/tests/llquaternion_test.cpp
index 9e79b299ff..e69010b2d6 100644
--- a/indra/llmath/tests/llquaternion_test.cpp
+++ b/indra/llmath/tests/llquaternion_test.cpp
@@ -29,12 +29,12 @@
 #include "linden_common.h"
 #include "../test/lltut.h"
 
-#include "../llquaternion.h"
 #include "../v4math.h"
 #include "../v3math.h"
 #include "../v3dmath.h"
 #include "../m4math.h"
 #include "../m3math.h"
+#include "../llquaternion.h"
 
 namespace tut
 {
diff --git a/indra/llmath/tests/v2math_test.cpp b/indra/llmath/tests/v2math_test.cpp
index 9747996b25..4d6a2eca93 100644
--- a/indra/llmath/tests/v2math_test.cpp
+++ b/indra/llmath/tests/v2math_test.cpp
@@ -85,7 +85,7 @@ namespace tut
 		F32 x = 2.2345f, y = 3.5678f ;
 		LLVector2 vec2(x,y);
 		ensure("magVecSquared:Fail ", is_approx_equal(vec2.magVecSquared(), (x*x + y*y)));
-		ensure("magVec:Fail ", is_approx_equal(vec2.magVec(), fsqrtf(x*x + y*y)));
+		ensure("magVec:Fail ", is_approx_equal(vec2.magVec(), (F32) sqrt(x*x + y*y)));
 	}
 
 	template<> template<>
@@ -407,7 +407,7 @@ namespace tut
 		ensure_equals("dist_vec_squared values are not equal",val2, val1);
 
 		val1 = 	dist_vec(vec2, vec3);
-		val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2));
+		val2 = (F32) sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2));
 		ensure_equals("dist_vec values are not equal",val2, val1);
 	}
 
@@ -431,7 +431,7 @@ namespace tut
 		LLVector2 vec2(x1, y1);
 
 		F32 vecMag = vec2.normVec();
-		F32 mag = fsqrtf(x1*x1 + y1*y1);
+		F32 mag = (F32) sqrt(x1*x1 + y1*y1);
 
 		F32 oomag = 1.f / mag;
 		val1 = x1 * oomag;
diff --git a/indra/llmath/tests/v3color_test.cpp b/indra/llmath/tests/v3color_test.cpp
index 2c00f00ab3..29d1c483ab 100644
--- a/indra/llmath/tests/v3color_test.cpp
+++ b/indra/llmath/tests/v3color_test.cpp
@@ -93,7 +93,7 @@ namespace tut
 		F32 r = 2.3436212f, g = 1231.f, b = 4.7849321232f;
 		LLColor3 llcolor3(r,g,b);
 		ensure("magVecSquared:Fail ", is_approx_equal(llcolor3.magVecSquared(), (r*r + g*g + b*b)));
-		ensure("magVec:Fail ", is_approx_equal(llcolor3.magVec(), fsqrtf(r*r + g*g + b*b)));
+		ensure("magVec:Fail ", is_approx_equal(llcolor3.magVec(), (F32) sqrt(r*r + g*g + b*b)));
 	}
 
 	template<> template<>
@@ -103,7 +103,7 @@ namespace tut
 		F32 val1, val2,val3;
 		LLColor3 llcolor3(r,g,b);
 		F32 vecMag = llcolor3.normVec();
-		F32 mag = fsqrtf(r*r + g*g + b*b);
+		F32 mag = (F32) sqrt(r*r + g*g + b*b);
 		F32 oomag = 1.f / mag;
 		val1 = r * oomag;
 		val2 = g * oomag;
@@ -286,7 +286,7 @@ namespace tut
 		F32 r1 =1.f, g1 = 2.f,b1 = 1.2f, r2 = -2.3f, g2 = 1.11f, b2 = 1234.234f;
 		LLColor3 llcolor3(r1,g1,b1),llcolor3a(r2,g2,b2);
 		F32 val = distVec(llcolor3,llcolor3a);
-		ensure("distVec failed ", is_approx_equal(fsqrtf((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val));
+		ensure("distVec failed ", is_approx_equal((F32) sqrt((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val));
 		
 		F32 val1 = distVec_squared(llcolor3,llcolor3a);
 		ensure("distVec_squared failed ", is_approx_equal(((r1-r2)*(r1-r2) + (g1-g2)*(g1-g2) + (b1-b2)*(b1-b2)) ,val1));
diff --git a/indra/llmath/tests/v3dmath_test.cpp b/indra/llmath/tests/v3dmath_test.cpp
index b67346f4e5..20b26faa12 100644
--- a/indra/llmath/tests/v3dmath_test.cpp
+++ b/indra/llmath/tests/v3dmath_test.cpp
@@ -30,11 +30,11 @@
 #include "llsd.h"
 #include "../test/lltut.h"
 
-#include "../llquaternion.h"
 #include "../m3math.h"
 #include "../v4math.h"
 #include "../v3dmath.h"
 #include "../v3dmath.h"
+#include "../llquaternion.h"
 
 namespace tut
 {
@@ -403,7 +403,7 @@ namespace tut
 		LLVector3d vec3D(x,y,z);
 		F64 res = (x*x + y*y + z*z) - vec3D.magVecSquared();
 		ensure("1:magVecSquared:Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));
-		res = fsqrtf(x*x + y*y + z*z) - vec3D.magVec();
+		res = (F32) sqrt(x*x + y*y + z*z) - vec3D.magVec();
 		ensure("2:magVec: Fail ", ((-F_APPROXIMATELY_ZERO <= res)&& (res <=F_APPROXIMATELY_ZERO)));	
 	}
 
diff --git a/indra/llmath/tests/v3math_test.cpp b/indra/llmath/tests/v3math_test.cpp
index e4732bf861..df7a77002f 100644
--- a/indra/llmath/tests/v3math_test.cpp
+++ b/indra/llmath/tests/v3math_test.cpp
@@ -30,12 +30,12 @@
 #include "../test/lltut.h"
 #include "llsd.h"
 
-#include "../llquaternion.h"
-#include "../llquantize.h"
 #include "../v3dmath.h"
 #include "../m3math.h"
 #include "../v4math.h"
 #include "../v3math.h"
+#include "../llquaternion.h"
+#include "../llquantize.h"
 
 
 namespace tut
@@ -149,7 +149,7 @@ namespace tut
 		F32 x = 2.32f, y = 1.212f, z = -.12f;
 		LLVector3 vec3(x,y,z);		
 		ensure("1:magVecSquared:Fail ", is_approx_equal(vec3.magVecSquared(), (x*x + y*y + z*z)));
-		ensure("2:magVec:Fail ", is_approx_equal(vec3.magVec(), fsqrtf(x*x + y*y + z*z)));
+		ensure("2:magVec:Fail ", is_approx_equal(vec3.magVec(), (F32) sqrt(x*x + y*y + z*z)));
 	}
 
 	template<> template<>
@@ -509,7 +509,7 @@ namespace tut
 		F32 val1,val2;
 		LLVector3 vec3(x1,y1,z1),vec3a(x2,y2,z2);
 		val1 = dist_vec(vec3,vec3a);
-		val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
+		val2 = (F32) sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
 		ensure_equals("1:dist_vec: Fail ",val2, val1);
 		val1 = dist_vec_squared(vec3,vec3a);
 		val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
diff --git a/indra/llmath/tests/v4color_test.cpp b/indra/llmath/tests/v4color_test.cpp
index fbd43625d1..d7eec3c87f 100644
--- a/indra/llmath/tests/v4color_test.cpp
+++ b/indra/llmath/tests/v4color_test.cpp
@@ -155,7 +155,7 @@ namespace tut
 		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
 		LLColor4 llcolor4(r,g,b);
 		ensure("magVecSquared:Fail ", is_approx_equal(llcolor4.magVecSquared(), (r*r + g*g + b*b)));
-		ensure("magVec:Fail ", is_approx_equal(llcolor4.magVec(), fsqrtf(r*r + g*g + b*b)));
+		ensure("magVec:Fail ", is_approx_equal(llcolor4.magVec(), (F32) sqrt(r*r + g*g + b*b)));
 	}
 
 	template<> template<>
@@ -164,7 +164,7 @@ namespace tut
 		F32 r = 0x20, g = 0xFFFF, b = 0xFF;
 		LLColor4 llcolor4(r,g,b);
 		F32 vecMag = llcolor4.normVec();
-		F32 mag = fsqrtf(r*r + g*g + b*b);
+		F32 mag = (F32) sqrt(r*r + g*g + b*b);
 		F32 oomag = 1.f / mag;
 		F32 val1 = r * oomag, val2 = g * oomag,	val3 = b * oomag;
 		ensure("1:normVec failed ", (is_approx_equal(val1, llcolor4.mV[0]) && is_approx_equal(val2, llcolor4.mV[1]) && is_approx_equal(val3, llcolor4.mV[2]) && is_approx_equal(vecMag, mag)));
diff --git a/indra/llmath/tests/v4coloru_test.cpp b/indra/llmath/tests/v4coloru_test.cpp
index 6d84ba41ef..128f6f3564 100644
--- a/indra/llmath/tests/v4coloru_test.cpp
+++ b/indra/llmath/tests/v4coloru_test.cpp
@@ -135,7 +135,7 @@ namespace tut
 		U8 r = 0x12, g = 0xFF, b = 0xAF;
 		LLColor4U llcolor4u(r,g,b);
 		ensure("magVecSquared:Fail ", is_approx_equal(llcolor4u.magVecSquared(), (F32)(r*r + g*g + b*b)));
-		ensure("magVec:Fail ", is_approx_equal(llcolor4u.magVec(), fsqrtf(r*r + g*g + b*b)));
+		ensure("magVec:Fail ", is_approx_equal(llcolor4u.magVec(), (F32) sqrt((F32) (r*r + g*g + b*b))));
 	}
 
 	template<> template<>
diff --git a/indra/llmath/tests/v4math_test.cpp b/indra/llmath/tests/v4math_test.cpp
index b1f934e555..191ac864df 100644
--- a/indra/llmath/tests/v4math_test.cpp
+++ b/indra/llmath/tests/v4math_test.cpp
@@ -30,9 +30,9 @@
 #include "../test/lltut.h"
 #include "llsd.h"
 
-#include "../llquaternion.h"
 #include "../m4math.h"
 #include "../v4math.h"
+#include "../llquaternion.h"
 
 namespace tut
 {
@@ -96,7 +96,7 @@ namespace tut
 	{
 		F32 x = 10.f, y = -2.3f, z = -.023f;
 		LLVector4 vec4(x,y,z);
-		ensure("magVec:Fail ", is_approx_equal(vec4.magVec(), fsqrtf(x*x + y*y + z*z)));
+		ensure("magVec:Fail ", is_approx_equal(vec4.magVec(), (F32) sqrt(x*x + y*y + z*z)));
 		ensure("magVecSquared:Fail ", is_approx_equal(vec4.magVecSquared(), (x*x + y*y + z*z)));
 	}
 
@@ -337,7 +337,7 @@ namespace tut
 		F32 val1,val2;
 		LLVector4 vec4(x1,y1,z1),vec4a(x2,y2,z2);
 		val1 = dist_vec(vec4,vec4a);
-		val2 = fsqrtf((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
+		val2 = (F32) sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
 		ensure_equals("dist_vec: Fail ",val2, val1);
 		val1 = dist_vec_squared(vec4,vec4a);
 		val2 =((x1 - x2)*(x1 - x2) + (y1 - y2)* (y1 - y2) + (z1 - z2)* (z1 -z2));
diff --git a/indra/llmath/v2math.cpp b/indra/llmath/v2math.cpp
index 0180049b5d..a0cd642853 100644
--- a/indra/llmath/v2math.cpp
+++ b/indra/llmath/v2math.cpp
@@ -86,7 +86,7 @@ F32	dist_vec(const LLVector2 &a, const LLVector2 &b)
 {
 	F32 x = a.mV[0] - b.mV[0];
 	F32 y = a.mV[1] - b.mV[1];
-	return fsqrtf( x*x + y*y );
+	return (F32) sqrt( x*x + y*y );
 }
 
 F32	dist_vec_squared(const LLVector2 &a, const LLVector2 &b)
@@ -109,3 +109,18 @@ LLVector2 lerp(const LLVector2 &a, const LLVector2 &b, F32 u)
 		a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
 		a.mV[VY] + (b.mV[VY] - a.mV[VY]) * u );
 }
+
+LLSD LLVector2::getValue() const
+{
+	LLSD ret;
+	ret[0] = mV[0];
+	ret[1] = mV[1];
+	return ret;
+}
+
+void LLVector2::setValue(LLSD& sd)
+{
+	mV[0] = (F32) sd[0].asReal();
+	mV[1] = (F32) sd[1].asReal();
+}
+
diff --git a/indra/llmath/v2math.h b/indra/llmath/v2math.h
index f50a5e6633..8d5db96f5e 100644
--- a/indra/llmath/v2math.h
+++ b/indra/llmath/v2math.h
@@ -60,6 +60,9 @@ class LLVector2
 		void	set(const LLVector2 &vec);	// Sets LLVector2 to vec
 		void	set(const F32 *vec);			// Sets LLVector2 to vec
 
+		LLSD	getValue() const;
+		void	setValue(LLSD& sd);
+
 		void	setVec(F32 x, F32 y);	        // deprecated
 		void	setVec(const LLVector2 &vec);	// deprecated
 		void	setVec(const F32 *vec);			// deprecated
@@ -216,7 +219,7 @@ inline void	LLVector2::setVec(const F32 *vec)
 
 inline F32 LLVector2::length(void) const
 {
-	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
+	return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
 }
 
 inline F32 LLVector2::lengthSquared(void) const
@@ -226,7 +229,7 @@ inline F32 LLVector2::lengthSquared(void) const
 
 inline F32		LLVector2::normalize(void)
 {
-	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
+	F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
 	F32 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
@@ -253,7 +256,7 @@ inline bool LLVector2::isFinite() const
 // deprecated
 inline F32		LLVector2::magVec(void) const
 {
-	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
+	return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
 }
 
 // deprecated
@@ -265,7 +268,7 @@ inline F32		LLVector2::magVecSquared(void) const
 // deprecated
 inline F32		LLVector2::normVec(void)
 {
-	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1]);
+	F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1]);
 	F32 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
diff --git a/indra/llmath/v3color.h b/indra/llmath/v3color.h
index 327e452bf7..56cb2ae73e 100644
--- a/indra/llmath/v3color.h
+++ b/indra/llmath/v3color.h
@@ -278,7 +278,7 @@ inline F32		LLColor3::brightness(void) const
 
 inline F32		LLColor3::length(void) const
 {
-	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 }
 
 inline F32		LLColor3::lengthSquared(void) const
@@ -288,7 +288,7 @@ inline F32		LLColor3::lengthSquared(void) const
 
 inline F32		LLColor3::normalize(void)
 {
-	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 	F32 oomag;
 
 	if (mag)
@@ -304,7 +304,7 @@ inline F32		LLColor3::normalize(void)
 // deprecated
 inline F32		LLColor3::magVec(void) const
 {
-	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 }
 
 // deprecated
@@ -316,7 +316,7 @@ inline F32		LLColor3::magVecSquared(void) const
 // deprecated
 inline F32		LLColor3::normVec(void)
 {
-	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 	F32 oomag;
 
 	if (mag)
@@ -438,7 +438,7 @@ inline F32		distVec(const LLColor3 &a, const LLColor3 &b)
 	F32 x = a.mV[0] - b.mV[0];
 	F32 y = a.mV[1] - b.mV[1];
 	F32 z = a.mV[2] - b.mV[2];
-	return fsqrtf( x*x + y*y + z*z );
+	return (F32) sqrt( x*x + y*y + z*z );
 }
 
 inline F32		distVec_squared(const LLColor3 &a, const LLColor3 &b)
diff --git a/indra/llmath/v3dmath.h b/indra/llmath/v3dmath.h
index 664c986ad0..578dcdc8ea 100644
--- a/indra/llmath/v3dmath.h
+++ b/indra/llmath/v3dmath.h
@@ -234,7 +234,7 @@ inline const LLVector3d&	LLVector3d::setVec(const F64 *vec)
 
 inline F64 LLVector3d::normVec(void)
 {
-	F64 mag = fsqrtf(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
+	F64 mag = (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
 	F64 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
@@ -256,7 +256,7 @@ inline F64 LLVector3d::normVec(void)
 
 inline F64 LLVector3d::normalize(void)
 {
-	F64 mag = fsqrtf(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
+	F64 mag = (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
 	F64 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
@@ -280,7 +280,7 @@ inline F64 LLVector3d::normalize(void)
 
 inline F64	LLVector3d::magVec(void) const
 {
-	return fsqrtf(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
+	return (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
 }
 
 inline F64	LLVector3d::magVecSquared(void) const
@@ -290,7 +290,7 @@ inline F64	LLVector3d::magVecSquared(void) const
 
 inline F64	LLVector3d::length(void) const
 {
-	return fsqrtf(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
+	return (F32) sqrt(mdV[0]*mdV[0] + mdV[1]*mdV[1] + mdV[2]*mdV[2]);
 }
 
 inline F64	LLVector3d::lengthSquared(void) const
@@ -400,7 +400,7 @@ inline F64	dist_vec(const LLVector3d &a, const LLVector3d &b)
 	F64 x = a.mdV[0] - b.mdV[0];
 	F64 y = a.mdV[1] - b.mdV[1];
 	F64 z = a.mdV[2] - b.mdV[2];
-	return fsqrtf( x*x + y*y + z*z );
+	return (F32) sqrt( x*x + y*y + z*z );
 }
 
 inline F64	dist_vec_squared(const LLVector3d &a, const LLVector3d &b)
diff --git a/indra/llmath/v3math.cpp b/indra/llmath/v3math.cpp
index 18b15e08c4..e7107dee16 100644
--- a/indra/llmath/v3math.cpp
+++ b/indra/llmath/v3math.cpp
@@ -206,6 +206,28 @@ const LLVector3&	LLVector3::rotVec(const LLQuaternion &q)
 	return *this;
 }
 
+const LLVector3& LLVector3::transVec(const LLMatrix4& mat)
+{
+	setVec(
+			mV[VX] * mat.mMatrix[VX][VX] + 
+			mV[VY] * mat.mMatrix[VX][VY] + 
+			mV[VZ] * mat.mMatrix[VX][VZ] +
+			mat.mMatrix[VX][VW],
+			 
+			mV[VX] * mat.mMatrix[VY][VX] + 
+			mV[VY] * mat.mMatrix[VY][VY] + 
+			mV[VZ] * mat.mMatrix[VY][VZ] +
+			mat.mMatrix[VY][VW],
+
+			mV[VX] * mat.mMatrix[VZ][VX] + 
+			mV[VY] * mat.mMatrix[VZ][VY] + 
+			mV[VZ] * mat.mMatrix[VZ][VZ] +
+			mat.mMatrix[VZ][VW]);
+
+	return *this;
+}
+
+
 const LLVector3&	LLVector3::rotVec(F32 angle, const LLVector3 &vec)
 {
 	if ( !vec.isExactlyZero() && angle )
diff --git a/indra/llmath/v3math.h b/indra/llmath/v3math.h
index 4b3efe7394..0432aeba4c 100644
--- a/indra/llmath/v3math.h
+++ b/indra/llmath/v3math.h
@@ -34,6 +34,7 @@
 class LLVector2;
 class LLVector4;
 class LLMatrix3;
+class LLMatrix4;
 class LLVector3d;
 class LLQuaternion;
 
@@ -110,6 +111,7 @@ class LLVector3
 		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
@@ -277,7 +279,7 @@ inline void	LLVector3::setVec(const F32 *vec)
 
 inline F32 LLVector3::normalize(void)
 {
-	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 	F32 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
@@ -300,7 +302,7 @@ inline F32 LLVector3::normalize(void)
 // deprecated
 inline F32 LLVector3::normVec(void)
 {
-	F32 mag = fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	F32 mag = (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 	F32 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
@@ -324,7 +326,7 @@ inline F32 LLVector3::normVec(void)
 
 inline F32	LLVector3::length(void) const
 {
-	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 }
 
 inline F32	LLVector3::lengthSquared(void) const
@@ -334,7 +336,7 @@ inline F32	LLVector3::lengthSquared(void) const
 
 inline F32	LLVector3::magVec(void) const
 {
-	return fsqrtf(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
+	return (F32) sqrt(mV[0]*mV[0] + mV[1]*mV[1] + mV[2]*mV[2]);
 }
 
 inline F32	LLVector3::magVecSquared(void) const
@@ -468,7 +470,7 @@ inline F32	dist_vec(const LLVector3 &a, const LLVector3 &b)
 	F32 x = a.mV[0] - b.mV[0];
 	F32 y = a.mV[1] - b.mV[1];
 	F32 z = a.mV[2] - b.mV[2];
-	return fsqrtf( x*x + y*y + z*z );
+	return (F32) sqrt( x*x + y*y + z*z );
 }
 
 inline F32	dist_vec_squared(const LLVector3 &a, const LLVector3 &b)
@@ -537,6 +539,21 @@ inline void update_min_max(LLVector3& min, LLVector3& max, const LLVector3& pos)
 	}
 }
 
+inline void update_min_max(LLVector3& min, LLVector3& max, const F32* pos)
+{
+	for (U32 i = 0; i < 3; i++)
+	{
+		if (min.mV[i] > pos[i])
+		{
+			min.mV[i] = pos[i];
+		}
+		if (max.mV[i] < pos[i])
+		{
+			max.mV[i] = pos[i];
+		}
+	}
+}
+
 inline F32 angle_between(const LLVector3& a, const LLVector3& b)
 {
 	LLVector3 an = a;
diff --git a/indra/llmath/v4color.h b/indra/llmath/v4color.h
index 60d24e2e11..b047f86e6e 100644
--- a/indra/llmath/v4color.h
+++ b/indra/llmath/v4color.h
@@ -108,6 +108,7 @@ class LLColor4
 	
 	    const LLColor4& operator=(const LLColor3 &a);	// Assigns vec3 to vec4 and returns vec4
 		
+		bool operator<(const LLColor4& rhs) const;
 		friend std::ostream&	 operator<<(std::ostream& s, const LLColor4 &a);		// Print a
 		friend LLColor4 operator+(const LLColor4 &a, const LLColor4 &b);	// Return vector a + b
 		friend LLColor4 operator-(const LLColor4 &a, const LLColor4 &b);	// Return vector a minus b
@@ -385,7 +386,7 @@ inline const LLColor4&	LLColor4::setAlpha(F32 a)
 
 inline F32		LLColor4::length(void) const
 {
-	return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 }
 
 inline F32		LLColor4::lengthSquared(void) const
@@ -395,7 +396,7 @@ inline F32		LLColor4::lengthSquared(void) const
 
 inline F32		LLColor4::normalize(void)
 {
-	F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 	F32 oomag;
 
 	if (mag)
@@ -411,7 +412,7 @@ inline F32		LLColor4::normalize(void)
 // deprecated
 inline F32		LLColor4::magVec(void) const
 {
-	return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 }
 
 // deprecated
@@ -423,7 +424,7 @@ inline F32		LLColor4::magVecSquared(void) const
 // deprecated
 inline F32		LLColor4::normVec(void)
 {
-	F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 	F32 oomag;
 
 	if (mag)
@@ -589,6 +590,23 @@ inline LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u)
 		a.mV[VW] + (b.mV[VW] - a.mV[VW]) * u);
 }
 
+inline bool LLColor4::operator<(const LLColor4& rhs) const
+{
+	if (mV[0] != rhs.mV[0])
+	{
+		return mV[0] < rhs.mV[0];
+	}
+	if (mV[1] != rhs.mV[1])
+	{
+		return mV[1] < rhs.mV[1];
+	}
+	if (mV[2] != rhs.mV[2])
+	{
+		return mV[2] < rhs.mV[2];
+	}
+
+	return mV[3] < rhs.mV[3];
+}
 
 void LLColor4::clamp()
 {
diff --git a/indra/llmath/v4coloru.h b/indra/llmath/v4coloru.h
index 7471aebe02..12da7e2dd7 100644
--- a/indra/llmath/v4coloru.h
+++ b/indra/llmath/v4coloru.h
@@ -294,7 +294,7 @@ inline const LLColor4U&	LLColor4U::setAlpha(U8 a)
 
 inline F32		LLColor4U::length(void) const
 {
-	return fsqrtf( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
+	return (F32) sqrt( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
 }
 
 inline F32		LLColor4U::lengthSquared(void) const
@@ -305,7 +305,7 @@ inline F32		LLColor4U::lengthSquared(void) const
 // deprecated
 inline F32		LLColor4U::magVec(void) const
 {
-	return fsqrtf( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
+	return (F32) sqrt( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
 }
 
 // deprecated
diff --git a/indra/llmath/v4math.h b/indra/llmath/v4math.h
index e7028626f9..623c8b2003 100644
--- a/indra/llmath/v4math.h
+++ b/indra/llmath/v4math.h
@@ -315,7 +315,7 @@ inline void	LLVector4::setVec(const F32 *vec)
 
 inline F32		LLVector4::length(void) const
 {
-	return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 }
 
 inline F32		LLVector4::lengthSquared(void) const
@@ -325,7 +325,7 @@ inline F32		LLVector4::lengthSquared(void) const
 
 inline F32		LLVector4::magVec(void) const
 {
-	return fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 }
 
 inline F32		LLVector4::magVecSquared(void) const
@@ -457,7 +457,7 @@ inline LLVector4 lerp(const LLVector4 &a, const LLVector4 &b, F32 u)
 
 inline F32		LLVector4::normalize(void)
 {
-	F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 	F32 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
@@ -480,7 +480,7 @@ inline F32		LLVector4::normalize(void)
 // deprecated
 inline F32		LLVector4::normVec(void)
 {
-	F32 mag = fsqrtf(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+	F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
 	F32 oomag;
 
 	if (mag > FP_MAG_THRESHOLD)
diff --git a/indra/llmath/xform.h b/indra/llmath/xform.h
index 5159c1cbfe..1b50749b3e 100644
--- a/indra/llmath/xform.h
+++ b/indra/llmath/xform.h
@@ -32,11 +32,11 @@
 
 const F32 MAX_OBJECT_Z 		= 4096.f; // should match REGION_HEIGHT_METERS, Pre-havok4: 768.f
 const F32 MIN_OBJECT_Z 		= -256.f;
-const F32 DEFAULT_MAX_PRIM_SCALE = 10.f;
+const F32 DEFAULT_MAX_PRIM_SCALE = 64.f;
+const F32 DEFAULT_MAX_PRIM_SCALE_NO_MESH = 10.f;
 const F32 MIN_PRIM_SCALE = 0.01f;
 const F32 MAX_PRIM_SCALE = 65536.f;	// something very high but not near FLT_MAX
 
-
 class LLXform
 {
 protected: