Merge from viewer-release

10 files changed, 53 insertions, 84 deletions

diff --git a/indra/llmath/llline.cpp b/indra/llmath/llline.cpp
index f26231840b..cfee315b55 100755
--- a/indra/llmath/llline.cpp
+++ b/indra/llmath/llline.cpp
@@ -30,7 +30,6 @@
 #include "llline.h"
 #include "llrand.h"
 
-const F32 SOME_SMALL_NUMBER = 1.0e-5f;
 const F32 SOME_VERY_SMALL_NUMBER = 1.0e-8f;
 
 LLLine::LLLine()
diff --git a/indra/llmath/llmath.h b/indra/llmath/llmath.h
index a8b27ad189..93b9f22b25 100755
--- a/indra/llmath/llmath.h
+++ b/indra/llmath/llmath.h
@@ -206,16 +206,16 @@ inline S32 llceil( F32 f )
 
 #ifndef BOGUS_ROUND
 // Use this round.  Does an arithmetic round (0.5 always rounds up)
-inline S32 llround(const F32 val)
+inline S32 ll_round(const F32 val)
 {
 	return llfloor(val + 0.5f);
 }
 
 #else // BOGUS_ROUND
-// Old llround implementation - does banker's round (toward nearest even in the case of a 0.5.
+// Old ll_round implementation - does banker's round (toward nearest even in the case of a 0.5.
 // Not using this because we don't have a consistent implementation on both platforms, use
 // llfloor(val + 0.5f), which is consistent on all platforms.
-inline S32 llround(const F32 val)
+inline S32 ll_round(const F32 val)
 {
 	#if LL_WINDOWS
 		// Note: assumes that the floating point control word is set to rounding mode (the default)
@@ -254,12 +254,12 @@ inline int round_int(double x)
 }
 #endif // BOGUS_ROUND
 
-inline F32 llround( F32 val, F32 nearest )
+inline F32 ll_round( F32 val, F32 nearest )
 {
 	return F32(floor(val * (1.0f / nearest) + 0.5f)) * nearest;
 }
 
-inline F64 llround( F64 val, F64 nearest )
+inline F64 ll_round( F64 val, F64 nearest )
 {
 	return F64(floor(val * (1.0 / nearest) + 0.5)) * nearest;
 }
@@ -309,25 +309,6 @@ const S32 LL_SHIFT_AMOUNT			= 16;                    //16.16 fixed point represe
 	#define LL_MAN_INDEX				1
 #endif
 
-/* Deprecated: use llround(), lltrunc(), or llfloor() instead
-// ================================================================================================
-// Real2Int
-// ================================================================================================
-inline S32 F64toS32(F64 val)
-{
-	val		= val + LL_DOUBLE_TO_FIX_MAGIC;
-	return ((S32*)&val)[LL_MAN_INDEX] >> LL_SHIFT_AMOUNT; 
-}
-
-// ================================================================================================
-// Real2Int
-// ================================================================================================
-inline S32 F32toS32(F32 val)
-{
-	return F64toS32 ((F64)val);
-}
-*/
-
 ////////////////////////////////////////////////
 //
 // Fast exp and log
@@ -351,9 +332,7 @@ static union
 #define LL_EXP_A (1048576 * OO_LN2) // use 1512775 for integer
 #define LL_EXP_C (60801)			// this value of C good for -4 < y < 4
 
-#define LL_FAST_EXP(y) (LLECO.n.i = llround(F32(LL_EXP_A*(y))) + (1072693248 - LL_EXP_C), LLECO.d)
-
-
+#define LL_FAST_EXP(y) (LLECO.n.i = ll_round(F32(LL_EXP_A*(y))) + (1072693248 - LL_EXP_C), LLECO.d)
 
 inline F32 llfastpow(const F32 x, const F32 y)
 {
@@ -370,9 +349,6 @@ inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
 		bar *= 10.f;
 	}
 
-	//F32 new_foo = (F32)llround(foo * bar);
-	// the llround() implementation sucks.  Don't us it.
-
 	F32 sign = (foo > 0.f) ? 1.f : -1.f;
 	F32 new_foo = F32( S64(foo * bar + sign * 0.5f));
 	new_foo /= bar;
diff --git a/indra/llmath/lloctree.h b/indra/llmath/lloctree.h
index 7b5240c651..280d2653d3 100755
--- a/indra/llmath/lloctree.h
+++ b/indra/llmath/lloctree.h
@@ -322,7 +322,7 @@ public:
 		//is it here?
 		if (isInside(data->getPositionGroup()))
 		{
-			if (((getElementCount() < gOctreeMaxCapacity || getSize()[0] <= gOctreeMinSize) && contains(data->getBinRadius()) ||
+			if ((((getElementCount() < gOctreeMaxCapacity || getSize()[0] <= gOctreeMinSize) && contains(data->getBinRadius())) ||
 				(data->getBinRadius() > getSize()[0] &&	parent && parent->getElementCount() >= gOctreeMaxCapacity))) 
 			{ //it belongs here
 				mData.push_back(NULL);
@@ -445,7 +445,7 @@ public:
 			mDataEnd = &mData[0];
 		}
 
-		notifyRemoval(data);
+		this->notifyRemoval(data);
 		checkAlive();
 	}
 
@@ -711,7 +711,7 @@ public:
 			//(don't notify listeners of addition)
 			for (U32 i = 0; i < child->getChildCount(); i++)
 			{
-				addChild(child->getChild(i), TRUE);
+				this->addChild(child->getChild(i), TRUE);
 			}
 
 			//destroy child
@@ -755,10 +755,10 @@ public:
 			return false;
 		}
 
-		if (this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup()))
+		if (this->getSize()[0] > data->getBinRadius() && this->isInside(data->getPositionGroup()))
 		{
 			//we got it, just act like a branch
-			oct_node* node = getNodeAt(data);
+			oct_node* node = this->getNodeAt(data);
 			if (node == this)
 			{
 				LLOctreeNode<T>::insert(data);
@@ -771,7 +771,7 @@ public:
 		else if (this->getChildCount() == 0)
 		{
 			//first object being added, just wrap it up
-			while (!(this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
+			while (!(this->getSize()[0] > data->getBinRadius() && this->isInside(data->getPositionGroup())))
 			{
 				LLVector4a center, size;
 				center = this->getCenter();
@@ -786,7 +786,7 @@ public:
 		}
 		else
 		{
-			while (!(this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
+			while (!(this->getSize()[0] > data->getBinRadius() && this->isInside(data->getPositionGroup())))
 			{
 				//the data is outside the root node, we need to grow
 				LLVector4a center(this->getCenter());
@@ -814,7 +814,7 @@ public:
 
 				//clear our children and add the root copy
 				this->clearChildren();
-				addChild(newnode);
+				this->addChild(newnode);
 			}
 
 			//insert the data
diff --git a/indra/llmath/llquantize.h b/indra/llmath/llquantize.h
index 1595dbecf8..10c950abbb 100755
--- a/indra/llmath/llquantize.h
+++ b/indra/llmath/llquantize.h
@@ -52,7 +52,7 @@ inline U16 F32_to_U16_ROUND(F32 val, F32 lower, F32 upper)
 	val /= (upper - lower);
 
 	// round the value.   Sreturn the U16
-	return (U16)(llround(val*U16MAX));
+	return (U16)(ll_round(val*U16MAX));
 }
 
 
@@ -92,7 +92,7 @@ inline U8 F32_to_U8_ROUND(F32 val, F32 lower, F32 upper)
 	val /= (upper - lower);
 
 	// return the rounded U8
-	return (U8)(llround(val*U8MAX));
+	return (U8)(ll_round(val*U8MAX));
 }
 
 
diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp
index adf6e790d3..c2198b91a7 100755
--- a/indra/llmath/llvolume.cpp
+++ b/indra/llmath/llvolume.cpp
@@ -56,8 +56,6 @@
 #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;
@@ -560,7 +558,7 @@ void LLProfile::genNGon(const LLProfileParams& params, S32 sides, F32 offset, F3
 
 	// 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
+	S32 total_sides = ll_round(sides / ang_scale);	// Total number of sides all around
 
 	if (total_sides < 8)
 	{
@@ -2076,7 +2074,7 @@ LLVolume::LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL ge
 
 	generate();
 	
-	if (mParams.getSculptID().isNull() && mParams.getSculptType() == LL_SCULPT_TYPE_NONE || mParams.getSculptType() == LL_SCULPT_TYPE_MESH)
+	if ((mParams.getSculptID().isNull() && mParams.getSculptType() == LL_SCULPT_TYPE_NONE) || mParams.getSculptType() == LL_SCULPT_TYPE_MESH)
 	{
 		createVolumeFaces();
 	}
@@ -4038,7 +4036,6 @@ LLVertexIndexPair::LLVertexIndexPair(const LLVector3 &vertex, const S32 index)
 }
 
 const F32 VERTEX_SLOP = 0.00001f;
-const F32 VERTEX_SLOP_SQRD = VERTEX_SLOP * VERTEX_SLOP;
 
 struct lessVertex
 {
@@ -4925,9 +4922,7 @@ F64 find_vertex_score(LLVCacheVertexData& data)
 {
 	F64 score = -1.0;
 
-	if (data.mActiveTriangles >= 0)
-	{ 
-		score = 0.0;
+	score = 0.0;
 
 	S32 cache_idx = data.mCacheTag;
 
@@ -4949,9 +4944,8 @@ F64 find_vertex_score(LLVCacheVertexData& data)
 	}
 
 	//bonus points for having low valence
-		F64 valence_boost = pow((F64)data.mActiveTriangles, -FindVertexScore_ValenceBoostPower);
+	F64 valence_boost = pow((F64)data.mActiveTriangles, -FindVertexScore_ValenceBoostPower);
 	score += FindVertexScore_ValenceBoostScale * valence_boost;
-	}
 
 	return score;
 }
diff --git a/indra/llmath/tests/llquaternion_test.cpp b/indra/llmath/tests/llquaternion_test.cpp
index e69010b2d6..3490829743 100755
--- a/indra/llmath/tests/llquaternion_test.cpp
+++ b/indra/llmath/tests/llquaternion_test.cpp
@@ -175,10 +175,10 @@ namespace tut
 	void llquat_test_object_t::test<6>()
 	{
 		LLQuaternion quat1(3.0f, 2.0f, 6.0f, 0.0f), quat2(1.0f, 1.0f, 1.0f, 1.0f);
-		ensure("1. The two values are different", llround(12.000000f, 2) == llround(dot(quat1, quat2), 2));
+		ensure("1. The two values are different", ll_round(12.000000f, 2) == ll_round(dot(quat1, quat2), 2));
 
 		LLQuaternion quat0(3.0f, 9.334f, 34.5f, 23.0f), quat(34.5f, 23.23f, 2.0f, 45.5f);
-		ensure("2. The two values are different", llround(1435.828807f, 2) == llround(dot(quat0, quat), 2));
+		ensure("2. The two values are different", ll_round(1435.828807f, 2) == ll_round(dot(quat0, quat), 2));
 	}
 
 	//test case for LLQuaternion &LLQuaternion::constrain(F32 radians) fn.
diff --git a/indra/llmath/tests/mathmisc_test.cpp b/indra/llmath/tests/mathmisc_test.cpp
index 91a2e6c009..f12140cf8f 100755
--- a/indra/llmath/tests/mathmisc_test.cpp
+++ b/indra/llmath/tests/mathmisc_test.cpp
@@ -128,33 +128,33 @@ namespace tut
 	void math_object::test<8>()
 	{
 		F32 val = 430903.2f;
-		S32 val1 = llround(val);
-		ensure("float llround value 1", (430903 == val1));
+		S32 val1 = ll_round(val);
+		ensure("float ll_round value 1", (430903 == val1));
 		val = -430903.9f;
-		val1 = llround(val);
-		ensure("float llround value 2", (-430904 == val1));
+		val1 = ll_round(val);
+		ensure("float ll_round value 2", (-430904 == val1));
 	}
 
 	template<> template<>
 	void math_object::test<9>()
 	{
 		F32 val = 430905.2654f, nearest = 100.f;
-		val = llround(val, nearest);
-		ensure("float llround value 1", (430900 == val));
+		val = ll_round(val, nearest);
+		ensure("float ll_round value 1", (430900 == val));
 		val = -430905.2654f, nearest = 10.f;
-		val = llround(val, nearest);
-		ensure("float llround value 1", (-430910 == val));
+		val = ll_round(val, nearest);
+		ensure("float ll_round value 1", (-430910 == val));
 	}
 
 	template<> template<>
 	void math_object::test<10>()
 	{
 		F64 val = 430905.2654, nearest = 100.0;
-		val = llround(val, nearest);
-		ensure("double llround value 1", (430900 == val));
+		val = ll_round(val, nearest);
+		ensure("double ll_round value 1", (430900 == val));
 		val = -430905.2654, nearest = 10.0;
-		val = llround(val, nearest);
-		ensure("double llround value 1", (-430910.00000 == val));
+		val = ll_round(val, nearest);
+		ensure("double ll_round value 1", (-430910.00000 == val));
 	}
 
 	template<> template<>
diff --git a/indra/llmath/tests/v4coloru_test.cpp b/indra/llmath/tests/v4coloru_test.cpp
index 128f6f3564..12e607a820 100755
--- a/indra/llmath/tests/v4coloru_test.cpp
+++ b/indra/llmath/tests/v4coloru_test.cpp
@@ -300,8 +300,8 @@ namespace tut
 		LLColor4U llcolor4u(r,g,b,a),llcolor4u1;
 		const F32 fVal = 3.f;
 		llcolor4u1 = llcolor4u.multAll(fVal);
-		ensure("multAll:Fail to multiply ", (((U8)llround(r * fVal) == llcolor4u1.mV[VX]) && (U8)llround(g * fVal) == llcolor4u1.mV[VY]
-											&& ((U8)llround(b * fVal) == llcolor4u1.mV[VZ])&& ((U8)llround(a * fVal) == llcolor4u1.mV[VW])));		
+		ensure("multAll:Fail to multiply ", (((U8)ll_round(r * fVal) == llcolor4u1.mV[VX]) && (U8)ll_round(g * fVal) == llcolor4u1.mV[VY]
+											&& ((U8)ll_round(b * fVal) == llcolor4u1.mV[VZ])&& ((U8)ll_round(a * fVal) == llcolor4u1.mV[VW])));		
 	}
 
 	template<> template<>
@@ -329,8 +329,8 @@ namespace tut
 		llcolor4u.setVecScaleClamp(color3);
 		const S32 MAX_COLOR = 255;
 		F32 color_scale_factor = MAX_COLOR/r;
-		S32 r2 = llround(r * color_scale_factor);
-		S32 g2 = llround(g * color_scale_factor);
+		S32 r2 = ll_round(r * color_scale_factor);
+		S32 g2 = ll_round(g * color_scale_factor);
 		ensure("setVecScaleClamp():Fail to add the value ",  ((r2 == llcolor4u.mV[VX]) && (g2 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
 	}
 }
diff --git a/indra/llmath/v4color.cpp b/indra/llmath/v4color.cpp
index cd2be7c8fd..79a64b24f2 100755
--- a/indra/llmath/v4color.cpp
+++ b/indra/llmath/v4color.cpp
@@ -125,10 +125,10 @@ LLColor4 LLColor4::cyan6(0.2f, 0.6f, 0.6f, 1.0f);
 LLColor4::operator const LLColor4U() const
 {
 	return LLColor4U(
-		(U8)llclampb(llround(mV[VRED]*255.f)),
-		(U8)llclampb(llround(mV[VGREEN]*255.f)),
-		(U8)llclampb(llround(mV[VBLUE]*255.f)),
-		(U8)llclampb(llround(mV[VALPHA]*255.f)));
+		(U8)llclampb(ll_round(mV[VRED]*255.f)),
+		(U8)llclampb(ll_round(mV[VGREEN]*255.f)),
+		(U8)llclampb(ll_round(mV[VBLUE]*255.f)),
+		(U8)llclampb(ll_round(mV[VALPHA]*255.f)));
 }
 
 LLColor4::LLColor4(const LLColor3 &vec, F32 a)
diff --git a/indra/llmath/v4coloru.h b/indra/llmath/v4coloru.h
index 12da7e2dd7..fddad34978 100755
--- a/indra/llmath/v4coloru.h
+++ b/indra/llmath/v4coloru.h
@@ -353,10 +353,10 @@ inline LLColor4U LLColor4U::multAll(const F32 k)
 {
 	// Round to nearest
 	return LLColor4U(
-		(U8)llround(mV[VX] * k),
-		(U8)llround(mV[VY] * k),
-		(U8)llround(mV[VZ] * k),
-		(U8)llround(mV[VW] * k));
+		(U8)ll_round(mV[VX] * k),
+		(U8)ll_round(mV[VY] * k),
+		(U8)ll_round(mV[VZ] * k),
+		(U8)ll_round(mV[VW] * k));
 }
 /*
 inline LLColor4U operator*(const LLColor4U &a, U8 k)
@@ -471,7 +471,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
 		color_scale_factor /= max_color;
 	}
 	const S32 MAX_COLOR = 255;
-	S32 r = llround(color.mV[0] * color_scale_factor);
+	S32 r = ll_round(color.mV[0] * color_scale_factor);
 	if (r > MAX_COLOR)
 	{
 		r = MAX_COLOR;
@@ -482,7 +482,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
 	}
 	mV[0] = r;
 
-	S32 g = llround(color.mV[1] * color_scale_factor);
+	S32 g = ll_round(color.mV[1] * color_scale_factor);
 	if (g > MAX_COLOR)
 	{
 		g = MAX_COLOR;
@@ -493,7 +493,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
 	}
 	mV[1] = g;
 
-	S32 b = llround(color.mV[2] * color_scale_factor);
+	S32 b = ll_round(color.mV[2] * color_scale_factor);
 	if (b > MAX_COLOR)
 	{
 		b = MAX_COLOR;
@@ -505,7 +505,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
 	mV[2] = b;
 
 	// Alpha shouldn't be scaled, just clamped...
-	S32 a = llround(color.mV[3] * MAX_COLOR);
+	S32 a = ll_round(color.mV[3] * MAX_COLOR);
 	if (a > MAX_COLOR)
 	{
 		a = MAX_COLOR;
@@ -527,7 +527,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
 	}
 
 	const S32 MAX_COLOR = 255;
-	S32 r = llround(color.mV[0] * color_scale_factor);
+	S32 r = ll_round(color.mV[0] * color_scale_factor);
 	if (r > MAX_COLOR)
 	{
 		r = MAX_COLOR;
@@ -539,7 +539,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
 	}
 	mV[0] = r;
 
-	S32 g = llround(color.mV[1] * color_scale_factor);
+	S32 g = ll_round(color.mV[1] * color_scale_factor);
 	if (g > MAX_COLOR)
 	{
 		g = MAX_COLOR;
@@ -551,7 +551,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
 	}
 	mV[1] = g;
 
-	S32 b = llround(color.mV[2] * color_scale_factor);
+	S32 b = ll_round(color.mV[2] * color_scale_factor);
 	if (b > MAX_COLOR)
 	{
 		b = MAX_COLOR;