Merge branch 'master' of git://github.com/Shyotl/SingularityViewer

indra/libhacd/hacdHACD.cpp

@@ -138,7 +138,11 @@ namespace HACD
             if (m_callBack)
             {
                 char msg[1024];
+#if _MSC_VER
+                sprintf(msg, "nCC %Iu\n", m_graph.m_nCCs);
+#else
                 sprintf(msg, "nCC %zu\n", m_graph.m_nCCs);
+#endif
                 (*m_callBack)(msg, 0.0, 0.0,  m_graph.GetNVertices());
                 
             }
@@ -679,7 +683,11 @@ namespace HACD
                 {
 					if ((!condition1) && m_callBack)
 					{
+#if _MSC_VER
+						sprintf(msg, "\n-> %Iu\t%f\t%f\t%f\n", m_pqueue.size(), m_graph.m_vertices[v1].m_surf*100.0/m_area, m_graph.m_vertices[v2].m_surf*100.0/m_area, m_graph.m_edges[currentEdge.m_name].m_concavity);
+#else
 						sprintf(msg, "\n-> %zu\t%f\t%f\t%f\n", m_pqueue.size(), m_graph.m_vertices[v1].m_surf*100.0/m_area, m_graph.m_vertices[v2].m_surf*100.0/m_area, m_graph.m_edges[currentEdge.m_name].m_concavity);
+#endif
 						(*m_callBack)(msg, progress, globalConcavity,  m_graph.GetNVertices());
 					}
 					globalConcavity = std::max<double>(globalConcavity ,m_graph.m_edges[currentEdge.m_name].m_concavity);
@@ -879,7 +887,11 @@ namespace HACD
                 if (m_callBack) 
                 {
                     char msg[1024];
+#if _MSC_VER
+                    sprintf(msg, "\t CH(%Iu) \t %Iu \t %lf \t %Iu \t %f \t %Iu\n", v, p, m_graph.m_vertices[v].m_concavity, m_graph.m_vertices[v].m_distPoints.Size(),  m_graph.m_vertices[v].m_surf*100.0/m_area, m_graph.m_vertices[v].m_ancestors.size());
+#else
                     sprintf(msg, "\t CH(%zu) \t %zu \t %lf \t %zu \t %f \t %zu\n", v, p, m_graph.m_vertices[v].m_concavity, m_graph.m_vertices[v].m_distPoints.Size(),  m_graph.m_vertices[v].m_surf*100.0/m_area, m_graph.m_vertices[v].m_ancestors.size());
+#endif
 					(*m_callBack)(msg, 0.0, 0.0, m_nClusters);
 					p++;
                 }
@@ -977,7 +989,8 @@ namespace HACD
                     m_convexHulls[p].AddPoint(m_points[point.m_name], point.m_name);
                 }
             }
-			m_convexHulls[p].SetDistPoints(0); //&m_graph.m_vertices[v].m_distPoints
+			if (p < m_nClusters)
+				m_convexHulls[p].SetDistPoints(0); //&m_graph.m_vertices[v].m_distPoints
             if (fullCH)
             {
 				while (m_convexHulls[p].Process() == ICHullErrorInconsistent)		// if we face problems when constructing the visual-hull. really ugly!!!!

indra/llcommon/llstat.cpp

@@ -44,7 +44,6 @@ LLFrameTimer LLStat::sFrameTimer;
 void LLStat::reset()
 {
 	mNumValues = 0;
-	mLastValue = 0.f;
 	delete[] mBins;
 	mBins      = new ValueEntry[mNumBins];
 	mCurBin = mNumBins-1;
@@ -57,8 +56,7 @@ LLStat::LLStat(std::string name, S32 num_bins, BOOL use_frame_timer)
 	mName(name),
 	mBins(NULL)
 {
-	llassert(mNumBins > 0);
+	llassert_always(mNumBins > 1);
-	mLastTime  = 0.f;
 
 	reset();
 
@@ -115,16 +113,8 @@ void LLStat::addValue(const F32 value)
 	}
 
 	// Increment the bin counters.
-	mCurBin++;
+	mCurBin = ++mCurBin % mNumBins;
-	if ((U32)mCurBin >= mNumBins)
+	mNextBin = ++mNextBin % mNumBins;
-	{
-		mCurBin = 0;
-	}
-	mNextBin++;
-	if ((U32)mNextBin >= mNumBins)
-	{
-		mNextBin = 0;
-	}
 
 	mBins[mCurBin].mValue = value;
 	if (mUseFrameTimer)
@@ -137,10 +127,6 @@ void LLStat::addValue(const F32 value)
 	}
 	mBins[mCurBin].mDT = (F32)(mBins[mCurBin].mTime - mBins[mCurBin].mBeginTime);
 
-	//this value is used to prime the min/max calls
-	mLastTime = mBins[mCurBin].mTime;
-	mLastValue = value;
-
 	// Set the begin time for the next stat segment.
 	mBins[mNextBin].mBeginTime = mBins[mCurBin].mTime;
 	mBins[mNextBin].mTime = mBins[mCurBin].mTime;
@@ -150,36 +136,25 @@ void LLStat::addValue(const F32 value)
 
 F32 LLStat::getMax() const
 {
-	S32 i;
+	F32 current_max = getCurrent();
-	F32 current_max = mLastValue;
+	for (S32 i = 0; i < (S32)mNumValues; i++)
-	if (mNumBins == 0)
 	{
-		current_max = 0.f;
+		// Skip the bin we're currently filling.
-	}
+		if (i == mNextBin)
-	else
-	{
-		for (i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
 		{
-			// Skip the bin we're currently filling.
+			continue;
-			if (i == mNextBin)
-			{
-				continue;
-			}
-			if (mBins[i].mValue > current_max)
-			{
-				current_max = mBins[i].mValue;
-			}
 		}
+		current_max = llmax(current_max, mBins[i].mValue);
 	}
+
 	return current_max;
 }
 
 F32 LLStat::getMean() const
 {
-	S32 i;
+	F32 current_mean = getCurrent();
-	F32 current_mean = 0.f;
 	S32 samples = 0;
-	for (i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
+	for (S32 i = 0; i < (S32)mNumValues; i++)
 	{
 		// Skip the bin we're currently filling.
 		if (i == mNextBin)
@@ -204,28 +179,18 @@ F32 LLStat::getMean() const
 
 F32 LLStat::getMin() const
 {
-	S32 i;
+	F32 current_min = getCurrent();
-	F32 current_min = mLastValue;
 
-	if (mNumBins == 0)
+	for (S32 i = 0; i < (S32)mNumValues; i++)
 	{
-		current_min = 0.f;
+		// Skip the bin we're currently filling.
-	}
+		if (i == mNextBin)
-	else
-	{
-		for (i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
 		{
-			// Skip the bin we're currently filling.
+			continue;
-			if (i == mNextBin)
-			{
-				continue;
-			}
-			if (mBins[i].mValue < current_min)
-			{
-				current_min = mBins[i].mValue;
-			}
 		}
+		current_min = llmin(current_min, mBins[i].mValue);
 	}
+
 	return current_min;
 }
 
@@ -262,7 +227,7 @@ F32 LLStat::getPrevPerSec(S32 age) const
 		// Bogus for bin we're currently working on.
 		return 0.f;
 	}
-	return mBins[bin].mValue / mBins[bin].mDT;
+	return (U32(bin) < mNumValues) ? (mBins[bin].mValue / mBins[bin].mDT) : 0.f;
 }
 
 F64 LLStat::getPrevBeginTime(S32 age) const
@@ -316,7 +281,7 @@ F32 LLStat::getCurrent() const
 
 F32 LLStat::getCurrentPerSec() const
 {
-	return mBins[mCurBin].mValue / mBins[mCurBin].mDT;
+	return (U32(mCurBin) < mNumValues) ? (mBins[mCurBin].mValue / mBins[mCurBin].mDT) : 0.f;
 }
 
 F32 LLStat::getCurrentDuration() const
@@ -324,13 +289,17 @@ F32 LLStat::getCurrentDuration() const
 	return mBins[mCurBin].mDT;
 }
 
+F64 LLStat::getCurrentTime() const
+{
+	return mBins[mCurBin].mTime;
+}
+
 F32 LLStat::getMeanPerSec() const
 {
-	S32 i;
 	F32 value = 0.f;
 	F32 dt    = 0.f;
 
-	for (i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
+	for (S32 i = 0; i < (S32)mNumValues; i++)
 	{
 		// Skip the bin we're currently filling.
 		if (i == mNextBin)
@@ -355,7 +324,7 @@ F32 LLStat::getMeanDuration() const
 {
 	F32 dur = 0.0f;
 	S32 count = 0;
-	for (S32 i=0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
+	for (S32 i=0; i < (S32)mNumValues; i++)
 	{
 		if (i == mNextBin)
 		{
@@ -378,22 +347,9 @@ F32 LLStat::getMeanDuration() const
 
 F32 LLStat::getMaxPerSec() const
 {
-	F32 value;
+	F32 value = 0.f;
 
-	if (mNextBin != 0)
+	for (S32 i = 0; i < (S32)mNumValues; i++)
-	{
-		value = mBins[0].mValue/mBins[0].mDT;
-	}
-	else if (mNumValues > 0)
-	{
-		value = mBins[1].mValue/mBins[1].mDT;
-	}
-	else
-	{
-		value = 0.f;
-	}
-
-	for (S32 i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
 	{
 		// Skip the bin we're currently filling.
 		if (i == mNextBin)
@@ -407,23 +363,9 @@ F32 LLStat::getMaxPerSec() const
 
 F32 LLStat::getMinPerSec() const
 {
-	S32 i;
+	F32 value = 0.f;
-	F32 value;
-	
-	if (mNextBin != 0)
-	{
-		value = mBins[0].mValue/mBins[0].mDT;
-	}
-	else if (mNumValues > 0)
-	{
-		value = mBins[1].mValue/mBins[0].mDT;
-	}
-	else
-	{
-		value = 0.f;
-	}
 
-	for (i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
+	for (S32 i = 0; i < (S32)mNumValues; i++)
 	{
 		// Skip the bin we're currently filling.
 		if (i == mNextBin)
@@ -455,7 +397,3 @@ S32 LLStat::getNextBin() const
 	return mNextBin;
 }
 
-F64 LLStat::getLastTime() const
-{
-	return mLastTime;
-}

indra/llcommon/llstat.h

@@ -61,7 +61,8 @@ public:
 	F32 getCurrent() const;
 	F32 getCurrentPerSec() const;
 	F32 getCurrentDuration() const;
-	
+	F64 getCurrentTime() const;
+
 	F64 getPrevBeginTime(S32 age) const;
 	F64 getPrevTime(S32 age) const;
 	F64 getBinTime(S32 bin) const;
@@ -77,13 +78,11 @@ public:
 	U32 getNumValues() const;
 	S32 getNumBins() const;
 
-	F64 getLastTime() const;
+	
 private:
 	BOOL mUseFrameTimer;
 	U32 mNumValues;
 	U32 mNumBins;
-	F32 mLastValue;
-	F64 mLastTime;
 
 	struct ValueEntry
 	{

indra/llmath/llperlin.cpp

@@ -24,271 +24,34 @@
  */
 
 #include "linden_common.h"
-#include "llmath.h"
-
 #include "llperlin.h"
 
-#define B 0x100
+//Random values taken from http://mrl.nyu.edu/~perlin/noise/
-#define BM 0xff
+const U8 LLPerlinNoise::p[LLPerlinNoise::sPremutationCount] =
-#define N 0x1000
+{ 151, 160, 137, 91, 90, 15,
-#define NF32 (4096.f)
+131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
-#define NP 12   /* 2^N */
+190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
-#define NM 0xfff
+88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
-
+77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244,
-static S32 p[B + B + 2];
+102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196,
-static F32 g3[B + B + 2][3];
+135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123,
-static F32 g2[B + B + 2][2];
+5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42,
-static F32 g1[B + B + 2];
+223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,
-
+129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228,
-bool LLPerlinNoise::sInitialized = 0;
+251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107,
-
+49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
-static void normalize2(F32 v[2])
+138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180,
-{
+151, 160, 137, 91, 90, 15,
-	F32 s = 1.f/(F32)sqrt(v[0] * v[0] + v[1] * v[1]);
+131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
-	v[0] = v[0] * s;
+190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
-	v[1] = v[1] * s;
+88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
-}
+77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244,
-
+102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196,
-static void normalize3(F32 v[3])
+135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123,
-{
+5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42,
-	F32 s = 1.f/(F32)sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,
-	v[0] = v[0] * s;
+129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228,
-	v[1] = v[1] * s;
+251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107,
-	v[2] = v[2] * s;
+49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
-}
+138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
-
+};
-static void fast_setup(F32 vec, U8 &b0, U8 &b1, F32 &r0, F32 &r1)
-{
-	S32 t_S32;
-
-	r1	= vec + NF32;
-	t_S32 = lltrunc(r1);
-	b0 = (U8)t_S32;
-	b1 = b0 + 1;
-	r0 = r1 - t_S32;
-	r1 = r0 - 1.f;
-}
-
-
-void LLPerlinNoise::init(void)
-{
-	int i, j, k;
-
-	for (i = 0 ; i < B ; i++)
-	{
-		p[i] = i;
-
-		g1[i] = (F32)((rand() % (B + B)) - B) / B;
-
-		for (j = 0 ; j < 2 ; j++)
-			g2[i][j] = (F32)((rand() % (B + B)) - B) / B;
-		normalize2(g2[i]);
-
-		for (j = 0 ; j < 3 ; j++)
-			g3[i][j] = (F32)((rand() % (B + B)) - B) / B;
-		normalize3(g3[i]);
-	}
-
-	while (--i)
-	{
-		k = p[i];
-		p[i] = p[j = rand() % B];
-		p[j] = k;
-	}
-
-	for (i = 0 ; i < B + 2 ; i++)
-	{
-		p[B + i] = p[i];
-		g1[B + i] = g1[i];
-		for (j = 0 ; j < 2 ; j++)
-			g2[B + i][j] = g2[i][j];
-		for (j = 0 ; j < 3 ; j++)
-			g3[B + i][j] = g3[i][j];
-	}
-
-	sInitialized = true;
-}
-
-
-//============================================================================
-// Noise functions
-
-#define s_curve(t) ( t * t * (3.f - 2.f * t) )
-
-#define lerp_m(t, a, b) ( a + t * (b - a) )
-
-F32 LLPerlinNoise::noise1(F32 x)
-{
-	int bx0, bx1;
-	F32 rx0, rx1, sx, t, u, v;
-
-	if (!sInitialized)
-		init();
-
-	t = x + N;
-	bx0 = (lltrunc(t)) & BM;
-	bx1 = (bx0+1) & BM;
-	rx0 = t - lltrunc(t);
-	rx1 = rx0 - 1.f;
-
-	sx = s_curve(rx0);
-
-	u = rx0 * g1[ p[ bx0 ] ];
-	v = rx1 * g1[ p[ bx1 ] ];
-
-	return lerp_m(sx, u, v);
-}
-
-static F32 fast_at2(F32 rx, F32 ry, F32 *q)
-{
-	return rx * q[0] + ry * q[1];
-}
-
-F32 LLPerlinNoise::noise2(F32 x, F32 y)
-{
-	U8 bx0, bx1, by0, by1;
-	U32 b00, b10, b01, b11;
-	F32 rx0, rx1, ry0, ry1, *q, sx, sy, a, b, u, v;
-	S32 i, j;
-
-	if (!sInitialized)
-		init();
-
-	fast_setup(x, bx0, bx1, rx0, rx1);
-	fast_setup(y, by0, by1, ry0, ry1);
-
-	i = *(p + bx0);
-	j = *(p + bx1);
-
-	b00 = *(p + i + by0);
-	b10 = *(p + j + by0);
-	b01 = *(p + i + by1);
-	b11 = *(p + j + by1);
-
-	sx = s_curve(rx0);
-	sy = s_curve(ry0);
-
-
-	q = *(g2 + b00);
-	u = fast_at2(rx0, ry0, q);
-	q = *(g2 + b10); 
-	v = fast_at2(rx1, ry0, q);
-	a = lerp_m(sx, u, v);
-
-	q = *(g2 + b01); 
-	u = fast_at2(rx0,ry1,q);
-	q = *(g2 + b11); 
-	v = fast_at2(rx1,ry1,q);
-	b = lerp_m(sx, u, v);
-
-	return lerp_m(sy, a, b);
-}
-
-static F32 fast_at3(F32 rx, F32 ry, F32 rz, F32 *q)
-{
-	return rx * q[0] + ry * q[1] + rz * q[2];
-}
-
-F32 LLPerlinNoise::noise3(F32 x, F32 y, F32 z)
-{
-	U8 bx0, bx1, by0, by1, bz0, bz1;
-	S32 b00, b10, b01, b11;
-	F32 rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
-	S32 i, j;
-
-	if (!sInitialized)
-		init();
-
-	fast_setup(x, bx0,bx1, rx0,rx1);
-	fast_setup(y, by0,by1, ry0,ry1);
-	fast_setup(z, bz0,bz1, rz0,rz1);
-
-	i = p[ bx0 ];
-	j = p[ bx1 ];
-
-	b00 = p[ i + by0 ];
-	b10 = p[ j + by0 ];
-	b01 = p[ i + by1 ];
-	b11 = p[ j + by1 ];
-
-	t  = s_curve(rx0);
-	sy = s_curve(ry0);
-	sz = s_curve(rz0);
-
-	q = g3[ b00 + bz0 ]; 
-	u = fast_at3(rx0,ry0,rz0,q);
-	q = g3[ b10 + bz0 ];
-	v = fast_at3(rx1,ry0,rz0,q);
-	a = lerp_m(t, u, v);
-
-	q = g3[ b01 + bz0 ];
-	u = fast_at3(rx0,ry1,rz0,q);
-	q = g3[ b11 + bz0 ];
-	v = fast_at3(rx1,ry1,rz0,q);
-	b = lerp_m(t, u, v);
-
-	c = lerp_m(sy, a, b);
-
-	q = g3[ b00 + bz1 ];
-	u = fast_at3(rx0,ry0,rz1,q);
-	q = g3[ b10 + bz1 ];
-	v = fast_at3(rx1,ry0,rz1,q);
-	a = lerp_m(t, u, v);
-
-	q = g3[ b01 + bz1 ];
-	u = fast_at3(rx0,ry1,rz1,q);
-	q = g3[ b11 + bz1 ];
-	v = fast_at3(rx1,ry1,rz1,q);
-	b = lerp_m(t, u, v);
-
-	d = lerp_m(sy, a, b);
-
-	return lerp_m(sz, c, d);
-}
-
-F32 LLPerlinNoise::turbulence2(F32 x, F32 y, F32 freq)
-{
-	F32 t, lx, ly;
-
-	for (t = 0.f ; freq >= 1.f ; freq *= 0.5f)
-	{
-		lx = freq * x;
-		ly = freq * y;
-		t += noise2(lx, ly)/freq;
-	}
-	return t;
-}
-
-F32 LLPerlinNoise::turbulence3(F32 x, F32 y, F32 z, F32 freq)
-{
-	F32 t, lx, ly, lz;
-
-	for (t = 0.f ; freq >= 1.f ; freq *= 0.5f)
-	{
-		lx = freq * x;
-		ly = freq * y;
-		lz = freq * z;
-		t += noise3(lx,ly,lz)/freq;
-//		t += fabs(noise3(lx,ly,lz)) / freq;					// Like snow - bubbly at low frequencies
-//		t += sqrt(fabs(noise3(lx,ly,lz))) / freq;			// Better at low freq
-//		t += (noise3(lx,ly,lz)*noise3(lx,ly,lz)) / freq;		
-	}
-	return t;
-}
-
-F32 LLPerlinNoise::clouds3(F32 x, F32 y, F32 z, F32 freq)
-{
-	F32 t, lx, ly, lz;
-
-	for (t = 0.f ; freq >= 1.f ; freq *= 0.5f)
-	{
-		lx = freq * x;
-		ly = freq * y;
-		lz = freq * z;
-//		t += noise3(lx,ly,lz)/freq;
-//		t += fabs(noise3(lx,ly,lz)) / freq;					// Like snow - bubbly at low frequencies
-//		t += sqrt(fabs(noise3(lx,ly,lz))) / freq;			// Better at low freq
-		t += (noise3(lx,ly,lz)*noise3(lx,ly,lz)) / freq;		
-	}
-	return t;
-}

indra/llmath/llperlin.h

@@ -27,20 +27,159 @@
 #define LL_PERLIN_H
 
 #include "stdtypes.h"
+#include "llmath.h"
+#include "v2math.h"
+#include "v3math.h"
 
 // namespace wrapper
 class LLPerlinNoise
 {
 public:
-	static F32 noise1(F32 x);
+	template<typename T>
-	static F32 noise2(F32 x, F32 y);
+	static F32 noise(const T& x, U32 wrap_at);
-	static F32 noise3(F32 x, F32 y, F32 z);
+	template<typename T>
-	static F32 turbulence2(F32 x, F32 y, F32 freq);
+	static F32 noise(const T& x)
-	static F32 turbulence3(F32 x, F32 y, F32 z, F32 freq);
+	{
-	static F32 clouds3(F32 x, F32 y, F32 z, F32 freq);
+		return noise(x, 256);
+	}
+	template<>
+	static F32 noise(const F32& x, U32 wrap_at)
+	{
+		U8 b[1][2];
+		F32 r[1][2], s[1], u, v;
+
+		fast_setup(&x, b, r, s, wrap_at);
+
+		u = grad(p[b[VX][0]], r[VX][0]);
+		v = grad(p[b[VX][1]], r[VX][1]);
+
+		return lerp(u, v, s[VX]);
+	}
+	template <>
+	static F32 noise(const LLVector2& vec, U32 wrap_at)
+	{
+		U8 b[2][2];
+		F32 r[2][2], s[2], u, v, A, B;
+
+		fast_setup(vec.mV, b, r, s, wrap_at);
+
+		u = grad(p[p[b[VX][0]] + b[VY][0]], r[VX][0], r[VY][0]);
+		v = grad(p[p[b[VX][1]] + b[VY][0]], r[VX][1], r[VY][0]);
+		A = lerp(u, v, s[VX]);
+
+		u = grad(p[p[b[VX][0]] + b[VY][1]], r[VX][0], r[VY][1]);
+		v = grad(p[p[b[VX][1]] + b[VY][1]], r[VX][1], r[VY][1]);
+		B = lerp(u, v, s[VX]);
+
+		return lerp(A, B, s[VY]);
+	}
+	template <>
+	static F32 noise(const LLVector3& vec, U32 wrap_at)
+	{
+		U8 b[3][2];
+		F32 r[3][2], s[3], u, v, A, B, C, D;
+
+		fast_setup(vec.mV, b, r, s, wrap_at);
+
+		u = grad(p[p[p[b[VX][0]] + b[VY][0]] + b[VZ][0]], r[VX][0], r[VY][0], r[VZ][0]);
+		v = grad(p[p[p[b[VX][1]] + b[VY][0]] + b[VZ][0]], r[VX][1], r[VY][0], r[VZ][0]);
+		A = lerp(u, v, s[VX]);
+
+		u = grad(p[p[p[b[VX][0]] + b[VY][1]] + b[VZ][0]], r[VX][0], r[VY][1], r[VZ][0]);
+		v = grad(p[p[p[b[VX][1]] + b[VY][1]] + b[VZ][0]], r[VX][1], r[VY][1], r[VZ][0]);
+		B = lerp(u, v, s[VX]);
+
+		C = lerp(A, B, s[VY]);
+
+		u = grad(p[p[p[b[VX][0]] + b[VY][0]] + b[VZ][1]], r[VX][0], r[VY][0], r[VZ][1]);
+		v = grad(p[p[p[b[VX][1]] + b[VY][0]] + b[VZ][1]], r[VX][1], r[VY][0], r[VZ][1]);
+		A = lerp(u, v, s[VX]);
+
+		u = grad(p[p[p[b[VX][0]] + b[VY][1]] + b[VZ][1]], r[VX][0], r[VY][1], r[VZ][1]);
+		v = grad(p[p[p[b[VX][1]] + b[VY][1]] + b[VZ][1]], r[VX][1], r[VY][1], r[VZ][1]);
+		B = lerp(u, v, s[VX]);
+
+		D = lerp(A, B, s[VY]);
+
+		return lerp(C, D, s[VZ]);
+	}
+	template <typename T>
+	static F32 turbulence(const T& vec, F32 freq, U32 wrap_at = 256)
+	{
+		F32 t;
+		for (t = 0.f; freq >= 1.f; freq *= 0.5f)
+		{
+			t += noise(vec * freq, wrap_at) / freq;
+			//		t += fabs(noise(vec * freq)) / freq;					// Like snow - bubbly at low frequencies
+			//		t += sqrt(fabs(noise(vec * freq))) / freq;				// Better at low freq
+			//		t += (noise(vec * freq)*noise(vec * freq)) / freq;
+		}
+		return t;
+	}
+	template <typename T>
+	static F32 clouds(const T& vec, F32 freq, U32 wrap_at = 256)
+	{
+		F32 t;
+		for (t = 0.f; freq >= 1.f; freq *= 0.5f)
+		{
+			//		t += noise(vec * freq)/freq;
+			//		t += fabs(noise(vec * freq)) / freq;					// Like snow - bubbly at low frequencies
+			//		t += sqrt(fabs(noise(vec * freq))) / freq;				// Better at low freq
+			t += (noise(vec * freq, wrap_at)*noise(vec * freq, wrap_at)) / freq;
+		}
+		return t;
+	}
 private:
-	static bool sInitialized;
+	static F32 s_curve(const F32 t)
-	static void init(void);
+	{
+		return t * t * t * (t * (6.f * t - 15.f) + 10.f);		//5th degree
+		//return t * t * (3.f - 2.f * t);						//3rd degree
+	}
+
+	static F32 grad(U32 hash, F32 x)
+	{
+		return x * (2.f*F32(hash) / 255.f - 1.f);
+	}
+
+	static F32 grad(U32 hash, F32 x, F32 y)
+	{
+		//Rotated slightly off the axes. Reduces directional artifacts.
+		//Scaled to match the old perlin method's output range
+		static const F32 l[2] = { .466666667f, .933333332f };
+		static const LLVector2 vecs[] = {
+			LLVector2(l[0], l[1]), LLVector2(l[0], -l[1]), LLVector2(-l[0], l[1]), LLVector2(-l[0], -l[1]),
+			LLVector2(l[1], l[0]), LLVector2(l[1], -l[0]), LLVector2(-l[1], l[0]), LLVector2(-l[1], -l[0]) };
+
+		return vecs[hash % LL_ARRAY_SIZE(vecs)] * LLVector2(x, y);
+	}
+
+	static F32 grad(U32 hash, F32 x, F32 y, F32 z)
+	{
+		static const LLVector3 vecs[] = {
+			OO_SQRT3*LLVector3(1, 1, 0), OO_SQRT3*LLVector3(-1, 1, 0), OO_SQRT3*LLVector3(1, -1, 0), OO_SQRT3*LLVector3(-1, -1, 0),
+			OO_SQRT3*LLVector3(1, 0, 1), OO_SQRT3*LLVector3(-1, 0, 1), OO_SQRT3*LLVector3(1, 0, -1), OO_SQRT3*LLVector3(-1, 0, -1),
+			OO_SQRT3*LLVector3(0, 1, 1), OO_SQRT3*LLVector3(0, -1, 1), OO_SQRT3*LLVector3(0, 1, -1), OO_SQRT3*LLVector3(0, -1, -1) };
+
+		return vecs[hash % LL_ARRAY_SIZE(vecs)] * LLVector3(x, y, z);
+	}
+
+	template <int N>
+	static void fast_setup(const F32* vec, U8 (&b)[N][2], F32 (&r)[N][2], F32 (&s)[N], const U32& wrap_at)
+	{
+		const U32 limit = llclamp(wrap_at, U32(1), U32(256));
+		for (U32 i = 0; i < N; ++i)
+		{
+			const S32 t_S32 = lltrunc(vec[i]);
+			b[i][0] = (t_S32) % limit;
+			b[i][1] = (t_S32 + 1) % limit;
+			r[i][0] = vec[i] - F32(t_S32);
+			r[i][1] = r[i][0] - 1.f;
+			s[i] = s_curve(r[i][0]);
+		}
+	}
+
+	static const U32 sPremutationCount = 512;
+	static const U8 p[sPremutationCount];
 };
 
 #endif // LL_PERLIN_

indra/llrender/llpostprocess.cpp

@@ -35,15 +35,16 @@
 #include "llpostprocess.h"
 
 #include "lldir.h"
+#include "llfasttimer.h"
 #include "llgl.h"
 #include "llglslshader.h"
+#include "llmatrix4a.h"
+#include "llperlin.h"
 #include "llrender.h"
 #include "llsdserialize.h"
 #include "llsdutil.h"
 #include "llsdutil_math.h"
 #include "llvertexbuffer.h"
-#include "llfasttimer.h"
-#include "llmatrix4a.h"
 
 extern LLGLSLShader			gPostColorFilterProgram;
 extern LLGLSLShader			gPostNightVisionProgram;
@@ -457,7 +458,8 @@ void LLPostProcess::createNoiseTexture()
 	std::vector<GLubyte> buffer(NOISE_SIZE * NOISE_SIZE);
 	for (unsigned int i = 0; i < NOISE_SIZE; i++){
 		for (unsigned int k = 0; k < NOISE_SIZE; k++){
-			buffer[(i * NOISE_SIZE) + k] = (GLubyte)((double) rand() / ((double) RAND_MAX + 1.f) * 255.f);
+			F32 pnoise = LLPerlinNoise::noise(LLVector2(i, k) * .5f) * (1.f/.7f);
+			buffer[i * NOISE_SIZE + k] = (GLubyte)(llclamp(.5f + pnoise * .5f, 0.f, 1.f) * 255.f);
 		}
 	}
 
@@ -637,8 +639,8 @@ void LLPostProcess::drawOrthoQuad(QuadType type)
 		mVBO->getTexCoord1Strider(uv2);
 
 		float offs[2] = {
-			ll_round(((float) rand() / (float) RAND_MAX) * (float)NOISE_SIZE)/float(NOISE_SIZE),
+			/*ll_round*/(((float) rand() / (float) RAND_MAX) * (float)NOISE_SIZE)/float(NOISE_SIZE),
-			ll_round(((float) rand() / (float) RAND_MAX) * (float)NOISE_SIZE)/float(NOISE_SIZE) };
+			/*ll_round*/(((float) rand() / (float) RAND_MAX) * (float)NOISE_SIZE)/float(NOISE_SIZE) };
 		float scale[2] = {
 			(float)mScreenWidth * mNoiseTextureScale,
 			(float)mScreenHeight * mNoiseTextureScale };

indra/llrender/llrender.cpp

@@ -194,7 +194,7 @@ void LLTexUnit::enable(eTextureType type)
 		mCurrTexType = type;
 
 		gGL.flush();
-		if (!LLGLSLShader::sNoFixedFunction && 
+		if (!LLGLSLShader::sNoFixedFunction &&
 			//type != LLTexUnit::TT_MULTISAMPLE_TEXTURE &&
 			mIndex < gGLManager.mNumTextureUnits)
 		{

indra/llwindow/lldxhardware.cpp

@@ -183,11 +183,11 @@ HRESULT GetVideoMemoryViaWMI( WCHAR* strInputDeviceID, DWORD* pdwAdapterRam )
 						SAFE_RELEASE( pVideoControllers[iController] );
 					}
 				}
+				SAFE_RELEASE(pEnumVideoControllers);
 			}
 
 			if( pClassName )
 				SysFreeString( pClassName );
-			SAFE_RELEASE( pEnumVideoControllers );
 		}
 
 		if( pNamespace )
@@ -449,7 +449,13 @@ BOOL LLDXHardware::getInfo(BOOL vram_only)
 	BOOL ok = FALSE;
     HRESULT       hr;
 
-    CoInitialize(NULL);
+    hr = CoInitialize(NULL);
+	if (FAILED(hr))
+	{
+		LL_WARNS("AppInit") << "COM library initialization failed!" << LL_ENDL;
+		gWriteDebug("COM library initialization failed!\n");
+		return FALSE;
+	}
 
     IDxDiagProvider *dx_diag_providerp = NULL;
     IDxDiagContainer *dx_diag_rootp = NULL;
@@ -709,7 +715,13 @@ LLSD LLDXHardware::getDisplayInfo()
 	LLTimer hw_timer;
     HRESULT       hr;
 	LLSD ret;
-    CoInitialize(NULL);
+    hr = CoInitialize(NULL);
+	if (FAILED(hr))
+	{
+		LL_WARNS("AppInit") << "COM library initialization failed!" << LL_ENDL;
+		gWriteDebug("COM library initialization failed!\n");
+		return ret;
+	}
 
     IDxDiagProvider *dx_diag_providerp = NULL;
     IDxDiagContainer *dx_diag_rootp = NULL;

indra/newview/CMakeLists.txt

@@ -581,7 +581,6 @@ set(viewer_SOURCE_FILES
     llworldmipmap.cpp
     llxmlrpcresponder.cpp
     m7wlinterface.cpp
-    noise.cpp
     pipeline.cpp
     qtoolalign.cpp
     rlvactions.cpp
@@ -1119,7 +1118,6 @@ set(viewer_HEADER_FILES
     llxmlrpcresponder.h
     m7wlinterface.h
     macmain.h
-    noise.h
     pipeline.h
     qtoolalign.h
     rlvactions.h

indra/newview/llcylinder.cpp

@@ -37,7 +37,6 @@
 #include "llerror.h"
 #include "math.h"
 #include "llmath.h"
-#include "noise.h"
 #include "v3math.h"
 #include "llvertexbuffer.h"
 #include "llgl.h"

indra/newview/lldrawpoolalpha.cpp

@@ -216,8 +216,7 @@ void LLDrawPoolAlpha::render(S32 pass)
 		gGL.setColorMask(true, true);
 	}
 	
-	bool write_depth = LLDrawPoolWater::sSkipScreenCopy
+	bool write_depth = (deferred_render && pass == 1)
-						 || (deferred_render && pass == 1)
 						 // we want depth written so that rendered alpha will
 						 // contribute to the alpha mask used for impostors
 						 || LLPipeline::sImpostorRenderAlphaDepthPass;
@@ -271,8 +270,7 @@ void LLDrawPoolAlpha::render(S32 pass)
 
 	if (sShowDebugAlpha)
 	{
-		BOOL shaders = gPipeline.canUseVertexShaders();
+		if (LLGLSLShader::sNoFixedFunction)
-		if(shaders) 
 		{
 			gHighlightProgram.bind();
 		}
@@ -292,7 +290,7 @@ void LLDrawPoolAlpha::render(S32 pass)
 		pushBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
 		pushBatches(LLRenderPass::PASS_ALPHA_INVISIBLE, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0, FALSE);
 
-		if(shaders) 
+		if (LLGLSLShader::sNoFixedFunction)
 		{
 			gHighlightProgram.unbind();
 		}
@@ -337,7 +335,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
 	BOOL initialized_lighting = FALSE;
 	BOOL light_enabled = TRUE;
 	
-	BOOL use_shaders = gPipeline.canUseVertexShaders();
+	BOOL use_shaders = LLGLSLShader::sNoFixedFunction;
 
 	BOOL depth_only = (pass == 1 && !LLPipeline::sImpostorRender);
 		

indra/newview/lldrawpoolavatar.cpp

@@ -47,7 +47,7 @@
 #include "llsky.h"
 #include "llviewercamera.h"
 #include "llviewerregion.h"
-#include "noise.h"
+#include "llperlin.h"
 #include "pipeline.h"
 #include "llviewershadermgr.h"
 #include "llvovolume.h"
@@ -644,7 +644,7 @@ void LLDrawPoolAvatar::endImpostor()
 
 void LLDrawPoolAvatar::beginRigid()
 {
-	if (gPipeline.canUseVertexShaders())
+	if (LLGLSLShader::sNoFixedFunction)
 	{
 		if (LLPipeline::sUnderWaterRender)
 		{
@@ -724,18 +724,18 @@ void LLDrawPoolAvatar::endDeferredRigid()
 
 void LLDrawPoolAvatar::beginSkinned()
 {
-	if(!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		sVertexProgram = NULL;
 		return;
 	}
 
-	if (sShaderLevel > 0)
+	if (sShaderLevel > 0)	// for hardware blending
 	{
 		if (LLPipeline::sUnderWaterRender)
 		{
 			sVertexProgram = &gAvatarWaterProgram;
-			sShaderLevel = llmin((U32) 1, sShaderLevel);
+			sShaderLevel = 1;
 		}
 		else
 		{
@@ -797,7 +797,7 @@ void LLDrawPoolAvatar::endSkinned()
 void LLDrawPoolAvatar::beginRiggedSimple()
 {
 	sDiffuseChannel = 0;
-	if(!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		sVertexProgram = NULL;
 		return;
@@ -845,7 +845,7 @@ void LLDrawPoolAvatar::endRiggedFullbrightAlpha()
 void LLDrawPoolAvatar::beginRiggedGlow()
 {
 	sDiffuseChannel = 0;
-	if(!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		sVertexProgram = NULL;
 		return;
@@ -867,7 +867,7 @@ void LLDrawPoolAvatar::endRiggedGlow()
 void LLDrawPoolAvatar::beginRiggedFullbright()
 {
 	sDiffuseChannel = 0;
-	if(!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		sVertexProgram = NULL;
 		return;
@@ -908,7 +908,7 @@ void LLDrawPoolAvatar::endRiggedFullbright()
 
 void LLDrawPoolAvatar::beginRiggedShinySimple()
 {
-	if(!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		sVertexProgram = NULL;
 		return;
@@ -935,7 +935,7 @@ void LLDrawPoolAvatar::endRiggedShinySimple()
 
 void LLDrawPoolAvatar::beginRiggedFullbrightShiny()
 {
-	if(!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		sVertexProgram = NULL;
 		return;
@@ -1322,7 +1322,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
 		return;
 	}
 	
-	if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
+	if (sShaderLevel >= SHADER_LEVEL_CLOTH)
 	{
 		LLMatrix4 rot_mat;
 		LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
@@ -1338,7 +1338,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
 		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_WIND, 1, wind.mV);
 		F32 phase = -1.f * (avatarp->mRipplePhase);
 
-		F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
+		F32 freq = 7.f + (LLPerlinNoise::noise(avatarp->mRipplePhase) * 2.f);
 		LLVector4 sin_params(freq, freq, freq, phase);
 		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_SINWAVE, 1, sin_params.mV);
 

indra/newview/lldrawpoolbump.cpp

@@ -1550,7 +1550,7 @@ void LLDrawPoolInvisible::render(S32 pass)
 { //render invisiprims
 	LLFastTimer t(FTM_RENDER_INVISIBLE);
   
-	if (gPipeline.canUseVertexShaders())
+	if (LLGLSLShader::sNoFixedFunction)
 	{
 		gOcclusionProgram.bind();
 	}
@@ -1562,7 +1562,7 @@ void LLDrawPoolInvisible::render(S32 pass)
 	gGL.setColorMask(true, false);
 	glStencilMask(0xFFFFFFFF);
 
-	if (gPipeline.canUseVertexShaders())
+	if (LLGLSLShader::sNoFixedFunction)
 	{
 		gOcclusionProgram.unbind();
 	}

indra/newview/lldrawpooltree.cpp

@@ -79,7 +79,7 @@ void LLDrawPoolTree::beginRenderPass(S32 pass)
 		shader = &gTreeProgram;
 	}
 
-	if (gPipeline.canUseVertexShaders())
+	if (LLGLSLShader::sNoFixedFunction)
 	{
 		shader->bind();
 		shader->setMinimumAlpha(0.5f);

indra/newview/lldrawpoolwater.cpp

@@ -63,7 +63,6 @@ static float sTime;
 
 BOOL deferred_render = FALSE;
 
-BOOL LLDrawPoolWater::sSkipScreenCopy = FALSE;
 BOOL LLDrawPoolWater::sNeedsReflectionUpdate = TRUE;
 BOOL LLDrawPoolWater::sNeedsDistortionUpdate = TRUE;
 LLColor4 LLDrawPoolWater::sWaterFogColor = LLColor4(0.2f, 0.5f, 0.5f, 0.f);
@@ -185,7 +184,7 @@ void LLDrawPoolWater::render(S32 pass)
 
 	LLGLEnable blend(GL_BLEND);
 
-	if ((mVertexShaderLevel > 0) && !sSkipScreenCopy)
+	if (mVertexShaderLevel > 0)
 	{
 		shade();
 		return;

indra/newview/lldrawpoolwater.h

@@ -49,7 +49,6 @@ protected:
 	LLPointer<LLViewerTexture> mWaterNormp;
 
 public:
-	static BOOL sSkipScreenCopy;
 	static BOOL sNeedsReflectionUpdate;
 	static BOOL sNeedsDistortionUpdate;
 	static LLVector3 sLightDir;

indra/newview/lldrawpoolwlsky.cpp

@@ -219,7 +219,7 @@ void LLDrawPoolWLSky::renderStars(void) const
 	//New
 	gGL.getTexUnit(0)->bind(gSky.mVOSkyp->getBloomTex());
 
-	if (gPipeline.canUseVertexShaders())
+	if (LLGLSLShader::sNoFixedFunction)
 	{
 		static LLStaticHashedString sCustomAlpha("custom_alpha");
 		star_shader->uniform1f(sCustomAlpha, star_alpha.mV[3]);
@@ -235,7 +235,7 @@ void LLDrawPoolWLSky::renderStars(void) const
 
 	gGL.popMatrix();
 
-	if (!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		// and disable the combiner states
 		gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
@@ -294,7 +294,7 @@ void LLDrawPoolWLSky::renderHeavenlyBodies()
 		// since LLImageGL::bind detects that it's a noop, and optimizes it out.
 		gGL.getTexUnit(0)->bind(face->getTexture());
 		
-		if (gPipeline.canUseVertexShaders())
+		if (LLGLSLShader::sNoFixedFunction)
 		{
 			// Okay, so the moon isn't a star, but it's close enough.
 			static LLStaticHashedString sCustomAlpha("custom_alpha");
@@ -310,7 +310,7 @@ void LLDrawPoolWLSky::renderHeavenlyBodies()
 		face->getVertexBuffer()->setBuffer(LLDrawPoolWLSky::STAR_VERTEX_DATA_MASK);
 		face->getVertexBuffer()->draw(LLRender::TRIANGLES, face->getVertexBuffer()->getNumIndices(), 0);
 		
-		if (!gPipeline.canUseVertexShaders())
+		if (!LLGLSLShader::sNoFixedFunction)
 		{
 			gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
 		}
@@ -387,7 +387,7 @@ void LLDrawPoolWLSky::render(S32 pass)
 
 		gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
 
-		if(gPipeline.canUseVertexShaders())
+		if (LLGLSLShader::sNoFixedFunction)
 			star_shader->bind();
 		// *NOTE: have to bind a texture here since register combiners blending in
 		// renderStars() requires something to be bound and we might as well only
@@ -398,7 +398,7 @@ void LLDrawPoolWLSky::render(S32 pass)
 
 		renderStars();
 
-		if(gPipeline.canUseVertexShaders())
+		if (LLGLSLShader::sNoFixedFunction)
 			star_shader->unbind();
 		
 

indra/newview/llfeaturemanager.cpp

@@ -559,7 +559,6 @@ void LLFeatureManager::setGraphicsLevel(S32 level, bool skipFeatures)
 
 	LLViewerShaderMgr::sSkipReload = false;
 	LLViewerShaderMgr::instance()->setShaders();
-	gPipeline.refreshCachedSettings();
 }
 
 void LLFeatureManager::applyBaseMasks()

indra/newview/llfloaterenvsettings.cpp

@@ -141,7 +141,7 @@ void LLFloaterEnvSettings::syncMenu()
 		childEnable("EnvUseEstateTimeButton");
 	}
 
-	if(!gPipeline.canUseVertexShaders())
+	if (!LLGLSLShader::sNoFixedFunction)
 	{
 		childDisable("EnvWaterColor");
 		childDisable("EnvWaterColorText");

indra/newview/llframestatview.cpp

@@ -133,7 +133,7 @@ void LLFrameStatView::draw()
 
 	for (i = 0; i < mNumStats; i++)
 	{
-		if (mStats[i]->getLastTime() >= min_last_time)
+		if (mStats[i]->getCurrentTime() >= min_last_time)
 		{
 			is_active[i] = TRUE;
 		}

indra/newview/llpaneldisplay.cpp

@@ -507,11 +507,9 @@ void LLPanelDisplay::refreshEnabledState()
 	//I actually recommend RenderUseFBO:FALSE for ati users when not using deferred, so RenderUseFBO shouldn't control visibility of the element.
 	// Instead, gGLManager.mHasFramebufferObject seems better as it is determined by hardware and not current user settings. -Shyotl
 	//Enabling deferred will force RenderUseFBO to TRUE.
-	BOOL can_defer = gGLManager.mHasFramebufferObject &&
+	BOOL can_defer = LLPipeline::isRenderDeferredCapable() &&
-		LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred") && //Ensure it's enabled in the gpu feature table
+		gSavedSettings.getBOOL("VertexShaderEnable") && //Basic Shaders
-		LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP") && //Hardware Skinning. Deferred forces RenderAvatarVP to true
+		wlatmos; //Atmospheric Shaders
-		LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") && gSavedSettings.getBOOL("VertexShaderEnable") && //Basic Shaders
-		LLFeatureManager::getInstance()->isFeatureAvailable("WindLightUseAtmosShaders") && wlatmos; //Atmospheric Shaders
 
 
 	mCtrlDeferred->setEnabled(can_defer);

indra/newview/llsurface.cpp

@@ -49,7 +49,6 @@
 #include "pipeline.h"
 #include "llviewerregion.h"
 #include "llvlcomposition.h"
-#include "noise.h"
 #include "llviewercamera.h"
 #include "llglheaders.h"
 #include "lldrawpoolterrain.h"

indra/newview/llsurfacepatch.cpp

@@ -41,7 +41,7 @@
 #include "llviewerregion.h"
 #include "llvlcomposition.h"
 #include "lldrawpool.h"
-#include "noise.h"
+#include "llperlin.h"
 
 extern bool gShiftFrame;
 extern U64 gFrameTime;
@@ -230,12 +230,11 @@ void LLSurfacePatch::eval(const U32 x, const U32 y, const U32 stride, LLVector3
 	const F32 xyScale = 4.9215f*7.f; //0.93284f;
 	const F32 xyScaleInv = (1.f / xyScale)*(0.2222222222f);
 
-	F32 vec[3] = {
+	LLVector2 vec(
-					(F32)fmod((F32)(mOriginGlobal.mdV[0] + x)*xyScaleInv, 256.f), // <FS:ND/> Added (F32) for proper array initialization
+		(F32)fmod((F32)(mOriginGlobal.mdV[0] + x)*xyScaleInv, 256.f), // <FS:ND/> Added (F32) for proper array initialization
-					(F32)fmod((F32)(mOriginGlobal.mdV[1] + y)*xyScaleInv, 256.f), // <FS:ND/> Added (F32) for proper array initialization
+		(F32)fmod((F32)(mOriginGlobal.mdV[1] + y)*xyScaleInv, 256.f) // <FS:ND/> Added (F32) for proper array initialization
-					0.f
+		);
-				};
+	F32 rand_val = llclamp(LLPerlinNoise::noise(vec)* 0.75f + 0.5f, 0.f, 1.f);
-	F32 rand_val = llclamp(noise2(vec)* 0.75f + 0.5f, 0.f, 1.f);
 	tex1->mV[1] = rand_val;
 
 

indra/newview/llviewercontrol.cpp

@@ -205,7 +205,6 @@ bool handleRenderAvatarComplexityLimitChanged(const LLSD& newvalue)
 
 bool handleRenderTransparentWaterChanged(const LLSD& newvalue)
 {
-	LLPipeline::sWaterReflections = gGLManager.mHasCubeMap && gSavedSettings.getBOOL("VertexShaderEnable");
 	if (gPipeline.isInit())	//If water is opaque then distortion/reflection fbos will not be needed.
 	{
 		gPipeline.releaseGLBuffers();
@@ -466,17 +465,9 @@ static bool handleRenderLocalLightsChanged(const LLSD& newvalue)
 
 static bool handleRenderDeferredChanged(const LLSD& newvalue)
 {
-	bool can_defer = LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred");
-	bool old_deferred = !newvalue.asBoolean() && can_defer;
-	LLRenderTarget::sUseFBO = (newvalue.asBoolean() && can_defer) || gSavedSettings.getBOOL("RenderUseFBO");
 	if (gPipeline.isInit())
 	{
-		LLPipeline::refreshCachedSettings();
+		if (LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred"))
-		gPipeline.updateRenderDeferred();
-		gPipeline.releaseGLBuffers();
-		gPipeline.createGLBuffers();
-		gPipeline.resetVertexBuffers();
-		if (old_deferred != newvalue.asBoolean())
 		{
 			LLViewerShaderMgr::instance()->setShaders();
 		}
@@ -486,13 +477,11 @@ static bool handleRenderDeferredChanged(const LLSD& newvalue)
 
 static bool handleRenderUseFBOChanged(const LLSD& newvalue)
 {
-	bool can_defer = LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred");
+	LLRenderTarget::sUseFBO = newvalue.asBoolean() || LLPipeline::sRenderDeferred;
-	LLRenderTarget::sUseFBO = newvalue.asBoolean() || (gSavedSettings.getBOOL("RenderDeferred") && can_defer);
 	if (gPipeline.isInit())
 	{
 		gPipeline.releaseGLBuffers();
 		gPipeline.createGLBuffers();
-		gPipeline.resetVertexBuffers();
 	}
 	return true;
 }

indra/newview/llviewerdisplay.cpp

@@ -733,7 +733,7 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot, boo
 		LLGLState::checkTextureChannels();
 		LLGLState::checkClientArrays();
 
-		BOOL to_texture = gPipeline.canUseVertexShaders() &&
+		BOOL to_texture = LLGLSLShader::sNoFixedFunction &&
 						LLPipeline::sRenderGlow;
 
 		LLAppViewer::instance()->pingMainloopTimeout("Display:Swap");
@@ -959,7 +959,7 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot, boo
 			else
 			{
 				gPipeline.mScreen.bindTarget();
-				if (LLPipeline::sUnderWaterRender && !gPipeline.canUseWindLightShaders())
+				if (LLPipeline::sUnderWaterRender)
 				{
 					const LLColor4 &col = LLDrawPoolWater::sWaterFogColor;
 					glClearColor(col.mV[0], col.mV[1], col.mV[2], 0.f);
@@ -1343,7 +1343,7 @@ void render_ui(F32 zoom_factor, int subfield, bool tiling)
 	}
 	
 	{
-		BOOL to_texture = gPipeline.canUseVertexShaders() &&
+		BOOL to_texture = LLGLSLShader::sNoFixedFunction &&
 							LLPipeline::sRenderGlow;
 
 		if (to_texture)
@@ -1351,7 +1351,7 @@ void render_ui(F32 zoom_factor, int subfield, bool tiling)
 			gPipeline.renderBloom(gSnapshot, zoom_factor, subfield, tiling);
 		}
 
-		if(gPipeline.canUseVertexShaders())
+		if (LLGLSLShader::sNoFixedFunction)
 		{
 			LLPostProcess::getInstance()->renderEffects(gViewerWindow->getWindowDisplayWidth(), gViewerWindow->getWindowDisplayHeight());
 		}

indra/newview/llviewermenu.cpp

@@ -1686,7 +1686,6 @@ class LLAdvancedToggleWireframe : public view_listener_t
 // [/RLVa:KB]
 //		gUseWireframe = !(gUseWireframe);
 //		gWindowResized = TRUE; // Singu Note: We don't use this (yet?)
-		LLPipeline::updateRenderDeferred();
 		gPipeline.resetVertexBuffers();
 //		return true;
 	}

indra/newview/llviewershadermgr.cpp

@@ -133,8 +133,6 @@ LLGLSLShader		gHighlightSpecularProgram(LLViewerShaderMgr::SHADER_INTERFACE);
  //avatar shader handles
 LLGLSLShader		gAvatarProgram(LLViewerShaderMgr::SHADER_AVATAR);
 LLGLSLShader		gAvatarWaterProgram(LLViewerShaderMgr::SHADER_AVATAR);
-LLGLSLShader		gAvatarEyeballProgram(LLViewerShaderMgr::SHADER_AVATAR);
-LLGLSLShader		gAvatarPickProgram(LLViewerShaderMgr::SHADER_AVATAR);			//Not in mShaderList
 LLGLSLShader		gImpostorProgram(LLViewerShaderMgr::SHADER_OBJECT);
 
  // Effects Shaders
@@ -207,8 +205,7 @@ LLGLSLShaderArray<LLViewerShaderMgr::SHADER_DEFERRED>	gDeferredMaterialProgram[L
 LLGLSLShaderArray<LLViewerShaderMgr::SHADER_DEFERRED>	gDeferredMaterialWaterProgram[LLMaterial::SHADER_COUNT*2];
 
 LLViewerShaderMgr::LLViewerShaderMgr() :
-	mVertexShaderLevel(SHADER_COUNT, 0),
+	mVertexShaderLevel(SHADER_COUNT, 0)
-	mMaxAvatarShaderLevel(0)
 {}
 
 LLViewerShaderMgr::~LLViewerShaderMgr()
@@ -241,7 +238,7 @@ void LLViewerShaderMgr::initAttribsAndUniforms(void)
 
 S32 LLViewerShaderMgr::getVertexShaderLevel(S32 type)
 {
-	return LLPipeline::sDisableShaders ? 0 : mVertexShaderLevel[type];
+	return mVertexShaderLevel[type];
 }
 
 //============================================================================
@@ -257,6 +254,10 @@ void LLViewerShaderMgr::setShaders()
 		return;
 	}
 
+	//Since setShaders can be reentrant, be sure to clear out stale shader objects that may be left over from parent call.
+	unloadShaderObjects();
+	unloadShaders();
+
 	LLGLSLShader::sIndexedTextureChannels = llmax(llmin(gGLManager.mNumTextureImageUnits, (S32) gSavedSettings.getU32("RenderMaxTextureIndex")), 1);
 	static const LLCachedControl<bool> no_texture_indexing("ShyotlUseLegacyTextureBatching",false);
 	if(no_texture_indexing)
@@ -284,16 +285,16 @@ void LLViewerShaderMgr::setShaders()
 	initAttribsAndUniforms();
 	gPipeline.releaseGLBuffers();
 
-	if (gSavedSettings.getBOOL("VertexShaderEnable"))
+	bool want_shaders = LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") &&
+						gSavedSettings.getBOOL("VertexShaderEnable") && 
+						(gGLManager.mGLSLVersionMajor > 1 || gGLManager.mGLSLVersionMinor >= 10);
+
+	bool want_deferred = want_shaders && LLPipeline::isRenderDeferredDesired();
+
+	if (want_shaders)
 	{
-		LLPipeline::sWaterReflections = gGLManager.mHasCubeMap;
+		//sRenderGlow needs set as it's referenced in the shader load process.
-		LLPipeline::sRenderGlow = gSavedSettings.getBOOL("RenderGlow"); 
+		LLPipeline::sRenderGlow = want_deferred || gSavedSettings.getBOOL("RenderGlow");
-		LLPipeline::updateRenderDeferred();
-	}
-	else
-	{
-		LLPipeline::sRenderGlow = FALSE;
-		LLPipeline::sWaterReflections = FALSE;
 	}
 	
 	//hack to reset buffers that change behavior with shaders
@@ -311,21 +312,10 @@ void LLViewerShaderMgr::setShaders()
 	LL_INFOS("ShaderLoading") << "\n~~~~~~~~~~~~~~~~~~\n Loading Shaders:\n~~~~~~~~~~~~~~~~~~" << LL_ENDL;
 	LL_INFOS("ShaderLoading") << llformat("Using GLSL %d.%d", gGLManager.mGLSLVersionMajor, gGLManager.mGLSLVersionMinor) << llendl;
 
-	for (S32 i = 0; i < SHADER_COUNT; i++)
-	{
-		mVertexShaderLevel[i] = 0;
-	}
-	mMaxAvatarShaderLevel = 0;
-
-	LLGLSLShader::sNoFixedFunction = false;
 	LLVertexBuffer::unbind();
-	if (LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") 
+	
-		&& (gGLManager.mGLSLVersionMajor > 1 || gGLManager.mGLSLVersionMinor >= 10)
+	if (want_shaders)
-		&& gSavedSettings.getBOOL("VertexShaderEnable"))
 	{
-		//using shaders, disable fixed function
-		LLGLSLShader::sNoFixedFunction = true;
-
 		S32 light_class = 2;
 		S32 env_class = 2;
 		S32 obj_class = 2;
@@ -340,11 +330,8 @@ void LLViewerShaderMgr::setShaders()
 		{
 			transform_class = 0;
 		}
-		
+
-		if (LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred") &&
+		if (want_deferred)
-		    gSavedSettings.getBOOL("RenderDeferred") &&
-			gSavedSettings.getBOOL("RenderAvatarVP") &&
-			gSavedSettings.getBOOL("WindLightUseAtmosShaders"))
 		{
 			if (gSavedSettings.getS32("RenderShadowDetail") > 0)
 			{ //shadows
@@ -393,9 +380,6 @@ void LLViewerShaderMgr::setShaders()
 
 		if (loaded)
 		{
-			gPipeline.mVertexShadersEnabled = TRUE;
-			gPipeline.mVertexShadersLoaded = 1;
-
 			// Load all shaders to set max levels
 			loaded = loadShadersEnvironment();
 
@@ -421,75 +405,58 @@ void LLViewerShaderMgr::setShaders()
 			
 			if (loaded)
 			{
-				loaded = loadTransformShaders();
+				loadTransformShaders();
-				if(!loaded)	//Failed to load. Just wipe all transformfeedback shaders and continue like nothing happened.
-				{
-					mVertexShaderLevel[SHADER_TRANSFORM] = 0;
-					unloadShaderClass(SHADER_TRANSFORM);
-					loaded = true;
-				}
 			}
 
 			if (loaded)
 			{
 				// Load max avatar shaders to set the max level
-				mVertexShaderLevel[SHADER_AVATAR] = 3;
+				bool can_skin = want_deferred || (LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP") && gSavedSettings.getBOOL("RenderAvatarVP"));
-				mMaxAvatarShaderLevel = 3;
 				
-				if (LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP") && gSavedSettings.getBOOL("RenderAvatarVP") && loadShadersObject())
+				if (can_skin)
 				{ //hardware skinning is enabled and rigged attachment shaders loaded correctly
-					BOOL avatar_cloth = gSavedSettings.getBOOL("RenderAvatarCloth");
-					S32 avatar_class = 1;
-				
-					// cloth is a class3 shader
-					if(avatar_cloth)
-					{
-						avatar_class = 3;
-					}
 
 					// Set the actual level
-					mVertexShaderLevel[SHADER_AVATAR] = avatar_class;
+					mVertexShaderLevel[SHADER_AVATAR] = gSavedSettings.getBOOL("RenderAvatarCloth") ? 3 : 1;
-					loadShadersAvatar();
+
-					if (mVertexShaderLevel[SHADER_AVATAR] != avatar_class)
+					if(!loadShadersAvatar() || !loadShadersObject())
 					{
-						if (mVertexShaderLevel[SHADER_AVATAR] == 0)
+						can_skin = false;
-						{
+					}
-							gSavedSettings.setBOOL("RenderAvatarVP", FALSE);
+					else if (mVertexShaderLevel[SHADER_AVATAR] < 3)
-						}
+					{
-						if(llmax(mVertexShaderLevel[SHADER_AVATAR]-1,0) >= 3)
+						gSavedSettings.setBOOL("RenderAvatarCloth", false);
-						{
-							avatar_cloth = true;
-						}
-						else
-						{
-							avatar_cloth = false;
-						}
-						gSavedSettings.setBOOL("RenderAvatarCloth", avatar_cloth);
 					}
 				}
-				else
+
+				if (!can_skin)
 				{ //hardware skinning not possible, neither is deferred rendering
-					mVertexShaderLevel[SHADER_AVATAR] = 0;
 					mVertexShaderLevel[SHADER_DEFERRED] = 0;
+					mVertexShaderLevel[SHADER_AVATAR] = 0;
+					unloadShaderClass(SHADER_AVATAR);
+					unloadShaderClass(SHADER_OBJECT);
 
-					if (gSavedSettings.getBOOL("RenderAvatarVP"))
+					want_deferred = false;	//Deferred requires skinned shaders.
-					{
-						gSavedSettings.setBOOL("RenderDeferred", FALSE);
-						gSavedSettings.setBOOL("RenderAvatarCloth", FALSE);
-						gSavedSettings.setBOOL("RenderAvatarVP", FALSE);
-					}
 
-					loadShadersAvatar(); // unloads
+					gSavedSettings.setBOOL("RenderDeferred", FALSE);
+					gSavedSettings.setBOOL("RenderAvatarCloth", FALSE);
+					gSavedSettings.setBOOL("RenderAvatarVP", FALSE);
 
 					loaded = loadShadersObject();
 				}
 			}
 
+			if (loaded)
+			{
+				loaded = loadShadersInterface();
+			}
+
 			if (!loaded)
 			{ //some shader absolutely could not load, try to fall back to a simpler setting
 				if (gSavedSettings.getBOOL("WindLightUseAtmosShaders"))
 				{ //disable windlight and try again
 					gSavedSettings.setBOOL("WindLightUseAtmosShaders", FALSE);
+					gSavedSettings.setBOOL("RenderDeferred", FALSE);
 					reentrance = false;
 					setShaders();
 					return;
@@ -498,48 +465,38 @@ void LLViewerShaderMgr::setShaders()
 				if (gSavedSettings.getBOOL("VertexShaderEnable"))
 				{ //disable shaders outright and try again
 					gSavedSettings.setBOOL("VertexShaderEnable", FALSE);
+					gSavedSettings.setBOOL("RenderDeferred", FALSE);
 					reentrance = false;
 					setShaders();
 					return;
 				}
-			}		
+			}
-
+			else if (!loadShadersDeferred())
-			if (loaded && !loadShadersDeferred())
+			{
-			{ //everything else succeeded but deferred failed, disable deferred and try again
 				gSavedSettings.setBOOL("RenderDeferred", FALSE);
 				reentrance = false;
 				setShaders();
 				return;
 			}
 		}
-		else
+		if (!loaded)
 		{
-			LLGLSLShader::sNoFixedFunction = false;
+			llassert_always(!LLRender::sGLCoreProfile);	//This is bad...
-			LLGLSLShader::sIndexedTextureChannels = 1;
+			unloadShaders();
-			gPipeline.mVertexShadersEnabled = FALSE;
+		}
-			gPipeline.mVertexShadersLoaded = 0;
+		else //Shaders loaded
-			for (S32 i = 0; i < SHADER_COUNT; i++)
+		{
-				mVertexShaderLevel[i] = 0;
+			//using shaders, disable fixed function
+			LLGLSLShader::sNoFixedFunction = true;
+			LLPipeline::sWaterReflections = gGLManager.mHasCubeMap;
+			LLPipeline::sRenderDeferred = want_deferred;
 		}
 
 		//Flag base shader objects for deletion
 		//Don't worry-- they won't be deleted until no programs refrence them.
-		std::multimap<std::string, LLShaderMgr::CachedObjectInfo >::iterator it = mShaderObjects.begin();
+		unloadShaderObjects();
-		for(; it!=mShaderObjects.end();++it)
-			if(it->second.mHandle)
-				glDeleteObjectARB(it->second.mHandle);
-		mShaderObjects.clear(); 
 	}
-	else
+
-	{
-		LLGLSLShader::sNoFixedFunction = false;
-		LLGLSLShader::sIndexedTextureChannels = 1;
-		gPipeline.mVertexShadersEnabled = FALSE;
-		gPipeline.mVertexShadersLoaded = 0;
-		for (S32 i = 0; i < SHADER_COUNT; i++)
-				mVertexShaderLevel[i] = 0;
-	}
-	
 	if (gViewerWindow)
 	{
 		gViewerWindow->setCursor(UI_CURSOR_ARROW);
@@ -565,7 +522,21 @@ void LLViewerShaderMgr::unloadShaders()
 	for (S32 i = 0; i < SHADER_COUNT; i++)
 		mVertexShaderLevel[i] = 0;
 
-	gPipeline.mVertexShadersLoaded = 0;
+	//Unset all shader-dependent static variables.
+	LLGLSLShader::sNoFixedFunction = false;
+	LLGLSLShader::sIndexedTextureChannels = 1;
+	LLPipeline::sRenderDeferred = false;
+	LLPipeline::sWaterReflections = FALSE;
+	LLPipeline::sRenderGlow = FALSE;
+}
+
+void LLViewerShaderMgr::unloadShaderObjects()
+{
+	std::multimap<std::string, LLShaderMgr::CachedObjectInfo >::iterator it = mShaderObjects.begin();
+	for (; it != mShaderObjects.end(); ++it)
+		if (it->second.mHandle)
+			glDeleteObjectARB(it->second.mHandle);
+	mShaderObjects.clear();
 }
 
 BOOL LLViewerShaderMgr::loadBasicShaders()
@@ -713,18 +684,19 @@ BOOL LLViewerShaderMgr::loadShadersEnvironment()
 	if (!success)
 	{
 		mVertexShaderLevel[SHADER_ENVIRONMENT] = 0;
-		return FALSE;
+		unloadShaderClass(SHADER_ENVIRONMENT);
+	}
+	else
+	{
+		LLWorld::getInstance()->updateWaterObjects();
 	}
 	
-	LLWorld::getInstance()->updateWaterObjects();
+	return success;
-	
-	return TRUE;
 }
 
 BOOL LLViewerShaderMgr::loadShadersWater()
 {
 	BOOL success = TRUE;
-	BOOL terrainWaterSuccess = TRUE;
 
 	if (mVertexShaderLevel[SHADER_WATER] == 0)
 	{
@@ -775,33 +747,20 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 		gTerrainWaterProgram.mShaderFiles.push_back(make_pair("environment/terrainWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gTerrainWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_ENVIRONMENT];
 		gTerrainWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		terrainWaterSuccess = gTerrainWaterProgram.createShader(NULL, NULL);
+		success = gTerrainWaterProgram.createShader(NULL, NULL);
-	}	
-
-	/// Keep track of water shader levels
-	if (gWaterProgram.mShaderLevel != mVertexShaderLevel[SHADER_WATER]
-		|| gUnderWaterProgram.mShaderLevel != mVertexShaderLevel[SHADER_WATER])
-	{
-		mVertexShaderLevel[SHADER_WATER] = llmin(gWaterProgram.mShaderLevel, gUnderWaterProgram.mShaderLevel);
 	}
 
 	if (!success)
 	{
 		mVertexShaderLevel[SHADER_WATER] = 0;
-		return FALSE;
+		unloadShaderClass(SHADER_WATER);
 	}
-
+	else
-	// if we failed to load the terrain water shaders and we need them (using class2 water),
-	// then drop down to class1 water.
-	if (mVertexShaderLevel[SHADER_WATER] > 1 && !terrainWaterSuccess)
 	{
-		mVertexShaderLevel[SHADER_WATER]--;
+		LLWorld::getInstance()->updateWaterObjects();
-		return loadShadersWater();
 	}
-	
-	LLWorld::getInstance()->updateWaterObjects();
 
-	return TRUE;
+	return success;
 }
 
 BOOL LLViewerShaderMgr::loadShadersEffects()
@@ -980,6 +939,12 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 
 	#endif
 
+	if (!success)
+	{
+		mVertexShaderLevel[SHADER_EFFECT] = 0;
+		unloadShaderClass(SHADER_EFFECT);
+	}
+
 	return success;
 
 }
@@ -1426,20 +1391,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAlphaWaterProgram.mFeatures.calculatesLighting = true;
 		gDeferredAlphaWaterProgram.mFeatures.hasLighting = true;
 	}
-
-	/*if (success)
-	{
-		gDeferredAvatarEyesProgram.mName = "Deferred Avatar Eyes Shader";
-		gDeferredAvatarEyesProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredAvatarEyesProgram.mFeatures.hasGamma = true;
-		gDeferredAvatarEyesProgram.mFeatures.hasTransport = true;
-		gDeferredAvatarEyesProgram.mFeatures.disableTextureIndex = true;
-		gDeferredAvatarEyesProgram.mShaderFiles.clear();
-		gDeferredAvatarEyesProgram.mShaderFiles.push_back(make_pair("deferred/avatarEyesV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredAvatarEyesProgram.mShaderFiles.push_back(make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gDeferredAvatarEyesProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
-		success = gDeferredAvatarEyesProgram.createShader(NULL, NULL);
-	}*/
 	
 	if (success)
 	{
@@ -1831,6 +1782,12 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		success = gNormalMapGenProgram.createShader(NULL, NULL);
 	}
 
+	if (!success)
+	{
+		mVertexShaderLevel[SHADER_DEFERRED] = 0;
+		unloadShaderClass(SHADER_DEFERRED);
+	}
+
 	return success;
 }
 
@@ -2138,13 +2095,13 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		}
 	}
 
-	if( !success )
+	if (!success)
 	{
 		mVertexShaderLevel[SHADER_OBJECT] = 0;
-		return FALSE;
+		unloadShaderClass(SHADER_OBJECT);
 	}
 	
-	return TRUE;
+	return success;
 }
 
 BOOL LLViewerShaderMgr::loadShadersAvatar()
@@ -2193,52 +2150,15 @@ BOOL LLViewerShaderMgr::loadShadersAvatar()
 			gAvatarWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;				
 			success = gAvatarWaterProgram.createShader(NULL, NULL);
 		}
-
-		/// Keep track of avatar levels
-		if (gAvatarProgram.mShaderLevel != mVertexShaderLevel[SHADER_AVATAR])
-		{
-			mMaxAvatarShaderLevel = mVertexShaderLevel[SHADER_AVATAR] = gAvatarProgram.mShaderLevel;
-		}
-	}
-
-	if (success)
-	{
-		gAvatarPickProgram.mName = "Avatar Pick Shader";
-		gAvatarPickProgram.mFeatures.hasSkinning = true;
-		gAvatarPickProgram.mFeatures.disableTextureIndex = true;
-		gAvatarPickProgram.mShaderFiles.clear();
-		gAvatarPickProgram.mShaderFiles.push_back(make_pair("avatar/pickAvatarV.glsl", GL_VERTEX_SHADER_ARB));
-		gAvatarPickProgram.mShaderFiles.push_back(make_pair("avatar/pickAvatarF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gAvatarPickProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
-		success = gAvatarPickProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		/*gAvatarEyeballProgram.mName = "Avatar Eyeball Program";
-		gAvatarEyeballProgram.mFeatures.calculatesLighting = true;
-		gAvatarEyeballProgram.mFeatures.isSpecular = true;
-		gAvatarEyeballProgram.mFeatures.calculatesAtmospherics = true;
-		gAvatarEyeballProgram.mFeatures.hasGamma = true;
-		gAvatarEyeballProgram.mFeatures.hasAtmospherics = true;
-		gAvatarEyeballProgram.mFeatures.hasLighting = true;
-		gAvatarEyeballProgram.mFeatures.hasAlphaMask = true;
-		gAvatarEyeballProgram.mFeatures.disableTextureIndex = true;
-		gAvatarEyeballProgram.mShaderFiles.clear();
-		gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballV.glsl", GL_VERTEX_SHADER_ARB));
-		gAvatarEyeballProgram.mShaderFiles.push_back(make_pair("avatar/eyeballF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gAvatarEyeballProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
-		success = gAvatarEyeballProgram.createShader(NULL, NULL);*/
 	}
 
 	if( !success )
 	{
 		mVertexShaderLevel[SHADER_AVATAR] = 0;
-		mMaxAvatarShaderLevel = 0;
+		unloadShaderClass(SHADER_AVATAR);
-		return FALSE;
 	}
 	
-	return TRUE;
+	return success;
 }
 
 BOOL LLViewerShaderMgr::loadShadersInterface()
@@ -2474,13 +2394,13 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 		success = gAlphaMaskProgram.createShader(NULL, NULL);
 	}
 
-	if( !success )
+	if (!success)
 	{
 		mVertexShaderLevel[SHADER_INTERFACE] = 0;
-		return FALSE;
+		unloadShaderClass(SHADER_INTERFACE);
 	}
-	
+
-	return TRUE;
+	return success;
 }
 
 BOOL LLViewerShaderMgr::loadShadersWindLight()
@@ -2517,6 +2437,12 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		success = gWLCloudProgram.createShader(NULL, NULL);
 	}
 
+	if (!success)
+	{
+		mVertexShaderLevel[SHADER_WINDLIGHT] = 0;
+		unloadShaderClass(SHADER_WINDLIGHT);
+	}
+
 	return success;
 }
 
@@ -2601,6 +2527,12 @@ BOOL LLViewerShaderMgr::loadTransformShaders()
 		success = gTransformTangentProgram.createShader(NULL, NULL, 1, varyings);
 	}
 
+
+	if (!success)
+	{
+		mVertexShaderLevel[SHADER_TRANSFORM] = 0;
+		unloadShaderClass(SHADER_TRANSFORM);
+	}
 	
 	return success;
 }

indra/newview/llviewershadermgr.h

@@ -57,6 +57,7 @@ public:
 	void initAttribsAndUniforms(void);
 	void setShaders();
 	void unloadShaders();
+	void unloadShaderObjects();
 	S32 getVertexShaderLevel(S32 type);
 	BOOL loadBasicShaders();
 	BOOL loadShadersEffects();
@@ -70,7 +71,6 @@ public:
 	BOOL loadTransformShaders();
 
 	std::vector<S32> mVertexShaderLevel;
-	S32	mMaxAvatarShaderLevel;
 
 	enum EShaderClass
 	{
@@ -252,8 +252,6 @@ extern LLGLSLShader			gHighlightSpecularProgram;
 // avatar shader handles
 extern LLGLSLShader			gAvatarProgram;
 extern LLGLSLShader			gAvatarWaterProgram;
-extern LLGLSLShader			gAvatarEyeballProgram;
-extern LLGLSLShader			gAvatarPickProgram;
 extern LLGLSLShader			gImpostorProgram;
 
 // WindLight shader handles

indra/newview/llviewerwindow.cpp

@@ -472,7 +472,7 @@ public:
 		static const LLCachedControl<bool> debug_show_render_info("DebugShowRenderInfo");
 		if (debug_show_render_info)
 		{
-			if (gPipeline.getUseVertexShaders() == 0)
+			if (!LLGLSLShader::sNoFixedFunction)
 			{
 				addText(xpos, ypos, "Shaders Disabled");
 				ypos += y_inc;

indra/newview/llvlcomposition.cpp

@@ -42,7 +42,7 @@
 #include "llviewertexture.h"
 #include "llviewertexturelist.h"
 #include "llviewerregion.h"
-#include "noise.h"
+#include "llperlin.h"
 #include "llregionhandle.h" // for from_region_handle
 #include "llviewercontrol.h"
 
@@ -152,7 +152,7 @@ BOOL LLVLComposition::generateHeights(const F32 x, const F32 y,
 	// For perlin noise generation...
 	const F32 slope_squared = 1.5f*1.5f;
 	const F32 xyScale = 4.9215f; //0.93284f;
-	const F32 zScale = 4; //0.92165f;
+	//const F32 zScale = 4; //0.92165f;	//Unused
 	const F32 z_offset = 0.f;
 	const F32 noise_magnitude = 2.f;		//  Degree to which noise modulates composition layer (versus
 											//  simple height)
@@ -162,7 +162,7 @@ BOOL LLVLComposition::generateHeights(const F32 x, const F32 y,
 	const S32 NUM_TEXTURES = 4;
 
 	const F32 xyScaleInv = (1.f / xyScale);
-	const F32 zScaleInv = (1.f / zScale);
+	//const F32 zScaleInv = (1.f / zScale);	//Unused
 
 // <FS:CR> Aurora Sim
 	//const F32 inv_width = 1.f/mWidth;
@@ -174,9 +174,6 @@ BOOL LLVLComposition::generateHeights(const F32 x, const F32 y,
 	{
 		for (S32 i = x_begin; i < x_end; i++)
 		{
-
-			F32 vec[3];
-			F32 vec1[3];
 			F32 twiddle;
 
 			// Bilinearly interpolate the start height and height range of the textures
@@ -196,18 +193,18 @@ BOOL LLVLComposition::generateHeights(const F32 x, const F32 y,
 			F32 height = mSurfacep->resolveHeightRegion(location) + z_offset;
 
 			// Step 0: Measure the exact height at this texel
-			vec[0] = (F32)(origin_global.mdV[VX]+location.mV[VX])*xyScaleInv;	//  Adjust to non-integer lattice
+
-			vec[1] = (F32)(origin_global.mdV[VY]+location.mV[VY])*xyScaleInv;
+			// Adjust to non - integer lattice
-			vec[2] = height*zScaleInv;
+			LLVector2 vec = (LLVector2(LLVector3(origin_global)) + LLVector2(location));
+			vec *= xyScaleInv;
+			//vec[VZ] = height*zScaleInv;	//Unused.
+
 			//
 			//  Choose material value by adding to the exact height a random value 
 			//
-			vec1[0] = vec[0]*(0.2222222222f);
+			twiddle = LLPerlinNoise::noise(vec*0.2222222222f)*6.5f;			//  Low freq component for large divisions
-			vec1[1] = vec[1]*(0.2222222222f);
-			vec1[2] = vec[2]*(0.2222222222f);
-			twiddle = noise2(vec1)*6.5f;					//  Low freq component for large divisions
 
-			twiddle += turbulence2(vec, 2)*slope_squared;	//  High frequency component
+			twiddle += LLPerlinNoise::turbulence(vec, 2.f)*slope_squared;	//  High frequency component
 			twiddle *= noise_magnitude;
 
 			F32 scaled_noisy_height = (height + twiddle - start_height) * F32(NUM_TEXTURES) / height_range;

indra/newview/llvoavatar.cpp

@@ -38,7 +38,7 @@
 #include <ctype.h>
 
 #include "llaudioengine.h"
-#include "noise.h"
+#include "llperlin.h"
 #include "raytrace.h"
 
 #include "llagent.h" //  Get state values from here
@@ -417,14 +417,8 @@ public:
 	// must return FALSE when the motion is completed.
 	virtual BOOL onUpdate(F32 time, U8* joint_mask)
 	{
-		F32 nx[2];
+		F32 noiseX = LLPerlinNoise::noise(LLVector2(time*TORSO_NOISE_SPEED, 0));
-		nx[0]=time*TORSO_NOISE_SPEED;
+		F32 noiseY = LLPerlinNoise::noise(LLVector2(0, time*TORSO_NOISE_SPEED));
-		nx[1]=0.0f;
-		F32 ny[2];
-		ny[0]=0.0f;
-		ny[1]=time*TORSO_NOISE_SPEED;
-		F32 noiseX = noise2(nx);
-		F32 noiseY = noise2(ny);
 
 		F32 rx = TORSO_NOISE_AMOUNT * DEG_TO_RAD * noiseX / 0.42f;
 		F32 ry = TORSO_NOISE_AMOUNT * DEG_TO_RAD * noiseY / 0.42f;
@@ -3043,7 +3037,7 @@ void LLVOAvatar::idleUpdateWindEffect()
 		}
 		mWindVec = lerp(mWindVec, wind, interp);
 	
-		F32 wind_freq = hover_strength + llclamp(8.f + (speed * 0.7f) + (noise1(mRipplePhase) * 4.f), 8.f, 25.f);
+		F32 wind_freq = hover_strength + llclamp(8.f + (speed * 0.7f) + (LLPerlinNoise::noise(mRipplePhase) * 4.f), 8.f, 25.f);
 		mWindFreq = lerp(mWindFreq, wind_freq, interp);
 
 		if (mBelowWater)
@@ -3052,9 +3046,9 @@ void LLVOAvatar::idleUpdateWindEffect()
 		}
 
 		mRipplePhase += (time_delta * mWindFreq);
-		if (mRipplePhase > F_TWO_PI)
+		if (mRipplePhase > 256.f)
 		{
-			mRipplePhase = fmodf(mRipplePhase, F_TWO_PI);
+			mRipplePhase = fmodf(mRipplePhase, 256.f);
 		}
 	}
 }

indra/newview/llvopartgroup.cpp

@@ -49,6 +49,7 @@
 #include "llviewerregion.h"
 #include "pipeline.h"
 #include "llspatialpartition.h"
+#include "llglslshader.h"
 
 const F32 MAX_PART_LIFETIME = 120.f;
 
@@ -715,7 +716,7 @@ void LLVOPartGroup::getGeometry(S32 idx,
 	*colorsp++ = color;
 
 	//Only add emissive attributes if glowing (doing it for all particles is INCREDIBLY inefficient as it leads to a second, slower, render pass.)
-	if (gPipeline.canUseVertexShaders() && (pglow.mV[3] > 0 || part.mGlow.mV[3] > 0))
+	if (LLGLSLShader::sNoFixedFunction && (pglow.mV[3] > 0 || part.mGlow.mV[3] > 0))
 	{ //only write glow if it is not zero
 		*emissivep++ = pglow;
 		*emissivep++ = pglow;

indra/newview/llvotree.cpp

@@ -55,7 +55,7 @@
 #include "llviewerobjectlist.h"
 #include "llviewerregion.h"
 #include "llworld.h"
-#include "noise.h"
+#include "llperlin.h"
 #include "pipeline.h"
 #include "llspatialpartition.h"
 //#include "llviewerwindow.h"
@@ -841,7 +841,7 @@ BOOL LLVOTree::updateGeometry(LLDrawable *drawable)
 								sin(nangle * DEG_TO_RAD)*start_radius*nvec_scale, 
 								z*nvec_scalez); 
 					// First and last slice at 0 radius (to bring in top/bottom of structure)
-					radius = start_radius + turbulence3((F32*)&nvec.mV, (F32)fractal_depth)*noise_scale;
+					radius = start_radius + LLPerlinNoise::turbulence(nvec, (F32)fractal_depth)*noise_scale;
 
 					if (slices - 1 == j)
 					{

indra/newview/llvovolume.cpp

@@ -4670,7 +4670,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 									pool->addRiggedFace(facep, fullbright ? LLDrawPoolAvatar::RIGGED_FULLBRIGHT_ALPHA : LLDrawPoolAvatar::RIGGED_ALPHA);
 								}
 							}
-							else if (gPipeline.canUseVertexShaders()
+							else if (LLGLSLShader::sNoFixedFunction
 								&& LLPipeline::sRenderBump 
 								&& te->getShiny() 
 								&& can_be_shiny)
@@ -5227,7 +5227,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 		spec_mask = spec_mask | LLVertexBuffer::MAP_EMISSIVE;
 	}
 
-	BOOL batch_textures = gPipeline.getUseVertexShaders();
+	BOOL batch_textures = LLGLSLShader::sNoFixedFunction;
 
 	U32 additional_flags = 0x0;
 	if(batch_textures)
@@ -6004,7 +6004,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFac
 				{
 					registerFace(group, facep, LLRenderPass::PASS_ALPHA);
 				}
-				else if (gPipeline.canUseVertexShaders()
+				else if (LLGLSLShader::sNoFixedFunction
 					&& LLPipeline::sRenderBump 
 					&& te->getShiny() 
 					&& can_be_shiny)
@@ -6039,7 +6039,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFac
 					registerFace(group, facep, LLRenderPass::PASS_ALPHA);
 				}
 			}
-			else if (gPipeline.canUseVertexShaders()
+			else if (LLGLSLShader::sNoFixedFunction
 				&& LLPipeline::sRenderBump 
 				&& te->getShiny()
 				&& can_be_shiny)
@@ -6120,7 +6120,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFac
 				}
 				
 				
-				if (!gPipeline.canUseVertexShaders() &&
+				if (!LLGLSLShader::sNoFixedFunction &&
 					!is_alpha &&
 					te->getShiny() &&
 					LLPipeline::sRenderBump)
@@ -6151,8 +6151,8 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, LLFac
 			tex = facep->getTexture();
 
 			bool is_alpha =			facep->getPoolType() == LLDrawPool::POOL_ALPHA;
-			bool is_shiny_shader =	facep->getPoolType() == LLDrawPool::POOL_BUMP && gPipeline.canUseVertexShaders() && te->getShiny();
+			bool is_shiny_shader =	facep->getPoolType() == LLDrawPool::POOL_BUMP && LLGLSLShader::sNoFixedFunction && te->getShiny();
-			bool is_shiny_fixed =	facep->getPoolType() == LLDrawPool::POOL_BUMP && !gPipeline.canUseVertexShaders() && te->getShiny();
+			bool is_shiny_fixed =	facep->getPoolType() == LLDrawPool::POOL_BUMP && !LLGLSLShader::sNoFixedFunction && te->getShiny();
 			bool is_fullbright =	facep->isState(LLFace::FULLBRIGHT);
 
 			if (facep->getPoolType() == LLDrawPool::POOL_MATERIALS)

indra/newview/llwaterparammanager.cpp

@@ -298,7 +298,7 @@ bool LLWaterParamManager::savePresetToNotecard(const std::string & name)
 void LLWaterParamManager::propagateParameters(void)
 {
 	// bind the variables only if we're using shaders
-	if(gPipeline.canUseVertexShaders())
+	if(LLGLSLShader::sNoFixedFunction)
 	{
 		std::vector<LLGLSLShader*>::iterator shaders_iter=mShaderList.begin();
 		for(; shaders_iter != mShaderList.end(); ++shaders_iter)
@@ -387,7 +387,7 @@ void LLWaterParamManager::update(LLViewerCamera * cam)
 	stop_glerror();
 
 	// only do this if we're dealing with shaders
-	if(gPipeline.canUseVertexShaders()) 
+	if(LLGLSLShader::sNoFixedFunction) 
 	{
 		//transform water plane to eye space
 		LLVector4a enorm(0.f, 0.f, 1.f);

indra/newview/llwind.cpp

@@ -47,7 +47,6 @@
 #include "patch_code.h"
 
 // viewer
-#include "noise.h"
 #include "v4color.h"
 #include "llagent.h"
 #include "llviewerregion.h"

indra/newview/noise.cpp

@@ -1,90 +0,0 @@
-/** 
- * @file noise.cpp
- * @brief Perlin noise routines for procedural textures, etc
- *
- * $LicenseInfo:firstyear=2000&license=viewergpl$
- * 
- * Copyright (c) 2000-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "noise.h"
-
-#include "llrand.h"
-
-// static
-#define B 0x100
-S32 p[B + B + 2];
-F32 g3[B + B + 2][3];
-F32 g2[B + B + 2][2];
-F32 g1[B + B + 2];
-S32 gNoiseStart = 1;
-
-
-F32 noise2(F32 *vec)
-{
-	U8 bx0, bx1, by0, by1;
-	U32 b00, b10, b01, b11;
-	F32 rx0, rx1, ry0, ry1, *q, sx, sy, a, b, u, v;
-	S32 i, j;
-
-	if (gNoiseStart) {
-		gNoiseStart = 0;
-		init();
-	}
-
-
-	fast_setup(*vec, bx0, bx1, rx0, rx1);
-	fast_setup(*(vec + 1), by0, by1, ry0, ry1);
-
-	i = *(p + bx0);
-	j = *(p + bx1);
-
-	b00 = *(p + i + by0);
-	b10 = *(p + j + by0);
-	b01 = *(p + i + by1);
-	b11 = *(p + j + by1);
-
-	sx = s_curve(rx0);
-	sy = s_curve(ry0);
-
-
-	q = *(g2 + b00);
-	u = fast_at2(rx0, ry0, q);
-	q = *(g2 + b10); 
-	v = fast_at2(rx1, ry0, q);
-	a = lerp_m(sx, u, v);
-
-	q = *(g2 + b01); 
-	u = fast_at2(rx0,ry1,q);
-	q = *(g2 + b11); 
-	v = fast_at2(rx1,ry1,q);
-	b = lerp_m(sx, u, v);
-
-	return lerp_m(sy, a, b);
-}
-

indra/newview/noise.h

@@ -1,363 +0,0 @@
-/** 
- * @file noise.h
- * @brief Perlin noise routines for procedural textures, etc
- *
- * $LicenseInfo:firstyear=2000&license=viewergpl$
- * 
- * Copyright (c) 2000-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LL_NOISE_H
-#define LL_NOISE_H
-
-#include "llmath.h"
-
-F32 turbulence2(F32 *v, F32 freq);
-F32 turbulence3(float *v, float freq);
-F32 clouds3(float *v, float freq);
-F32 noise2(float *vec);
-F32 noise3(float *vec);
-
-inline F32 bias(F32 a, F32 b)
-{
-	return (F32)pow(a, (F32)(log(b) / log(0.5f)));
-}
-
-inline F32 gain(F32 a, F32 b)
-{
-	F32 p = (F32) (log(1.f - b) / log(0.5f));
-
-	if (a < .001f)
-		return 0.f;
-	else if (a > .999f)
-		return 1.f;
-	if (a < 0.5f)
-		return (F32)(pow(2 * a, p) / 2.f);
-	else
-		return (F32)(1.f - pow(2 * (1.f - a), p) / 2.f);
-}
-
-inline F32 turbulence2(F32 *v, F32 freq)
-{
-	F32 t, vec[2];
-
-	for (t = 0.f ; freq >= 1.f ; freq *= 0.5f) {
-		vec[0] = freq * v[0];
-		vec[1] = freq * v[1];
-		t += noise2(vec)/freq;
-	}
-	return t;
-}
-
-inline F32 turbulence3(F32 *v, F32 freq)
-{
-	F32 t, vec[3];
-
-	for (t = 0.f ; freq >= 1.f ; freq *= 0.5f) {
-		vec[0] = freq * v[0];
-		vec[1] = freq * v[1];
-		vec[2] = freq * v[2];
-		t += noise3(vec)/freq;
-//		t += fabs(noise3(vec)) / freq;				// Like snow - bubbly at low frequencies
-//		t += sqrt(fabs(noise3(vec))) / freq;		// Better at low freq
-//		t += (noise3(vec)*noise3(vec)) / freq;		
-	}
-	return t;
-}
-
-inline F32 clouds3(F32 *v, F32 freq)
-{
-	F32 t, vec[3];
-
-	for (t = 0.f ; freq >= 1.f ; freq *= 0.5f) {
-		vec[0] = freq * v[0];
-		vec[1] = freq * v[1];
-		vec[2] = freq * v[2];
-		//t += noise3(vec)/freq;
-//		t += fabs(noise3(vec)) / freq;				// Like snow - bubbly at low frequencies
-//		t += sqrt(fabs(noise3(vec))) / freq;		// Better at low freq
-		t += (noise3(vec)*noise3(vec)) / freq;		
-	}
-	return t;
-}
-
-/* noise functions over 1, 2, and 3 dimensions */
-
-#define B 0x100
-#define BM 0xff
-
-#define N 0x1000
-#define NF32 (4096.f)
-#define NP 12   /* 2^N */
-#define NM 0xfff
-
-extern S32 p[B + B + 2];
-extern F32 g3[B + B + 2][3];
-extern F32 g2[B + B + 2][2];
-extern F32 g1[B + B + 2];
-extern S32 gNoiseStart;
-
-static void init(void);
-
-#define s_curve(t) ( t * t * (3.f - 2.f * t) )
-
-#define lerp_m(t, a, b) ( a + t * (b - a) )
-
-#define setup_noise(i,b0,b1,r0,r1)\
-	t = vec[i] + N;\
-	b0 = (lltrunc(t)) & BM;\
-	b1 = (b0+1) & BM;\
-	r0 = t - lltrunc(t);\
-	r1 = r0 - 1.f;
-
-
-inline void fast_setup(F32 vec, U8 &b0, U8 &b1, F32 &r0, F32 &r1)
-{
-	S32 t_S32;
-
-	r1	= vec + NF32;
-	t_S32 = lltrunc(r1);
-	b0 = (U8)t_S32;
-	b1 = b0 + 1;
-	r0 = r1 - t_S32;
-	r1 = r0 - 1.f;
-}
-
-inline F32 noise1(const F32 arg)
-{
-	int bx0, bx1;
-	F32 rx0, rx1, sx, t, u, v, vec[1];
-
-	vec[0] = arg;
-	if (gNoiseStart) {
-		gNoiseStart = 0;
-		init();
-	}
-
-	setup_noise(0, bx0,bx1, rx0,rx1);
-
-	sx = s_curve(rx0);
-
-	u = rx0 * g1[ p[ bx0 ] ];
-	v = rx1 * g1[ p[ bx1 ] ];
-
-	return lerp_m(sx, u, v);
-}
-
-inline F32 fast_at2(F32 rx, F32 ry, F32 *q)
-{
-	return rx * (*q) + ry * (*(q + 1));
-}
-
-
-
-inline F32 fast_at3(F32 rx, F32 ry, F32 rz, F32 *q)
-{
-	return rx * (*q) + ry * (*(q + 1)) + rz * (*(q + 2));
-}
-
-
-
-inline F32 noise3(F32 *vec)
-{
-	U8 bx0, bx1, by0, by1, bz0, bz1;
-	S32 b00, b10, b01, b11;
-	F32 rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
-	S32 i, j;
-
-	if (gNoiseStart) {
-		gNoiseStart = 0;
-		init();
-	}
-
-	fast_setup(*vec, bx0,bx1, rx0,rx1);
-	fast_setup(*(vec + 1), by0,by1, ry0,ry1);
-	fast_setup(*(vec + 2), bz0,bz1, rz0,rz1);
-
-	i = p[ bx0 ];
-	j = p[ bx1 ];
-
-	b00 = p[ i + by0 ];
-	b10 = p[ j + by0 ];
-	b01 = p[ i + by1 ];
-	b11 = p[ j + by1 ];
-
-	t  = s_curve(rx0);
-	sy = s_curve(ry0);
-	sz = s_curve(rz0);
-
-	q = g3[ b00 + bz0 ]; 
-	u = fast_at3(rx0,ry0,rz0,q);
-	q = g3[ b10 + bz0 ];
-	v = fast_at3(rx1,ry0,rz0,q);
-	a = lerp_m(t, u, v);
-
-	q = g3[ b01 + bz0 ];
-	u = fast_at3(rx0,ry1,rz0,q);
-	q = g3[ b11 + bz0 ];
-	v = fast_at3(rx1,ry1,rz0,q);
-	b = lerp_m(t, u, v);
-
-	c = lerp_m(sy, a, b);
-
-	q = g3[ b00 + bz1 ];
-	u = fast_at3(rx0,ry0,rz1,q);
-	q = g3[ b10 + bz1 ];
-	v = fast_at3(rx1,ry0,rz1,q);
-	a = lerp_m(t, u, v);
-
-	q = g3[ b01 + bz1 ];
-	u = fast_at3(rx0,ry1,rz1,q);
-	q = g3[ b11 + bz1 ];
-	v = fast_at3(rx1,ry1,rz1,q);
-	b = lerp_m(t, u, v);
-
-	d = lerp_m(sy, a, b);
-
-	return lerp_m(sz, c, d);
-}
-
-
-/*
-F32 noise3(F32 *vec)
-{
-	int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
-	F32 rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
-	S32 i, j;
-
-	if (gNoiseStart) {
-		gNoiseStart = 0;
-		init();
-	}
-
-	setup_noise(0, bx0,bx1, rx0,rx1);
-	setup_noise(1, by0,by1, ry0,ry1);
-	setup_noise(2, bz0,bz1, rz0,rz1);
-
-	i = p[ bx0 ];
-	j = p[ bx1 ];
-
-	b00 = p[ i + by0 ];
-	b10 = p[ j + by0 ];
-	b01 = p[ i + by1 ];
-	b11 = p[ j + by1 ];
-
-	t  = s_curve(rx0);
-	sy = s_curve(ry0);
-	sz = s_curve(rz0);
-
-#define at3(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
-
-	q = g3[ b00 + bz0 ] ; u = at3(rx0,ry0,rz0);
-	q = g3[ b10 + bz0 ] ; v = at3(rx1,ry0,rz0);
-	a = lerp_m(t, u, v);
-
-	q = g3[ b01 + bz0 ] ; u = at3(rx0,ry1,rz0);
-	q = g3[ b11 + bz0 ] ; v = at3(rx1,ry1,rz0);
-	b = lerp_m(t, u, v);
-
-	c = lerp_m(sy, a, b);
-
-	q = g3[ b00 + bz1 ] ; u = at3(rx0,ry0,rz1);
-	q = g3[ b10 + bz1 ] ; v = at3(rx1,ry0,rz1);
-	a = lerp_m(t, u, v);
-
-	q = g3[ b01 + bz1 ] ; u = at3(rx0,ry1,rz1);
-	q = g3[ b11 + bz1 ] ; v = at3(rx1,ry1,rz1);
-	b = lerp_m(t, u, v);
-
-	d = lerp_m(sy, a, b);
-
-	return lerp_m(sz, c, d);
-}
-*/
-
-static void normalize2(F32 v[2])
-{
-	F32 s;
-
-	s = 1.f/(F32)sqrt(v[0] * v[0] + v[1] * v[1]);
-	v[0] = v[0] * s;
-	v[1] = v[1] * s;
-}
-
-static void normalize3(F32 v[3])
-{
-	F32 s;
-
-	s = 1.f/(F32)sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-	v[0] = v[0] * s;
-	v[1] = v[1] * s;
-	v[2] = v[2] * s;
-}
-
-static void init(void)
-{
-	// we want repeatable noise (e.g. for stable terrain texturing), so seed with known value
-	srand(42);
-	int i, j, k;
-
-	for (i = 0 ; i < B ; i++) {
-		p[i] = i;
-
-		g1[i] = (F32)((rand() % (B + B)) - B) / B;
-
-		for (j = 0 ; j < 2 ; j++)
-			g2[i][j] = (F32)((rand() % (B + B)) - B) / B;
-		normalize2(g2[i]);
-
-		for (j = 0 ; j < 3 ; j++)
-			g3[i][j] = (F32)((rand() % (B + B)) - B) / B;
-		normalize3(g3[i]);
-	}
-
-	while (--i) {
-		k = p[i];
-		p[i] = p[j = rand() % B];
-		p[j] = k;
-	}
-
-	for (i = 0 ; i < B + 2 ; i++) {
-		p[B + i] = p[i];
-		g1[B + i] = g1[i];
-		for (j = 0 ; j < 2 ; j++)
-			g2[B + i][j] = g2[i][j];
-		for (j = 0 ; j < 3 ; j++)
-			g3[B + i][j] = g3[i][j];
-	}
-
-	// reintroduce entropy
-	srand(time(NULL));		// Flawfinder: ignore
-}
-
-#undef B
-#undef BM
-#undef N
-#undef NF32
-#undef NP
-#undef NM
-
-#endif // LL_NOISE_

indra/newview/pipeline.cpp

@@ -212,7 +212,6 @@ static LLFastTimer::DeclareTimer FTM_STATESORT_POSTSORT("Post Sort");
 //static LLStaticHashedString sAlphaScale("alpha_scale");
 static LLStaticHashedString sNormMat("norm_mat");
 //static LLStaticHashedString sOffset("offset");
-static LLStaticHashedString sScreenRes("screenRes");
 static LLStaticHashedString sDelta("delta");
 static LLStaticHashedString sDistFactor("dist_factor");
 static LLStaticHashedString sKern("kern");
@@ -309,7 +308,6 @@ S32		LLPipeline::sUseOcclusion = 0;
 BOOL	LLPipeline::sDelayVBUpdate = FALSE;
 BOOL	LLPipeline::sAutoMaskAlphaDeferred = TRUE;
 BOOL	LLPipeline::sAutoMaskAlphaNonDeferred = FALSE;
-BOOL	LLPipeline::sDisableShaders = FALSE;
 BOOL	LLPipeline::sRenderBump = TRUE;
 BOOL	LLPipeline::sNoAlpha = FALSE;
 BOOL	LLPipeline::sUseFarClip = TRUE;
@@ -364,10 +362,7 @@ LLPipeline::LLPipeline() :
 	mMeanBatchSize(0),
 	mTrianglesDrawn(0),
 	mNumVisibleNodes(0),
-
 	mInitialized(FALSE),
-	mVertexShadersEnabled(FALSE),
-	mVertexShadersLoaded(0),
 	mTransformFeedbackPrimitives(0),
 	mRenderDebugFeatureMask(0),
 	mRenderDebugMask(0),
@@ -405,9 +400,6 @@ void LLPipeline::init()
 {
 	refreshCachedSettings();
 
-	bool can_defer = LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred");
-	LLRenderTarget::sUseFBO				= gSavedSettings.getBOOL("RenderUseFBO") || (gSavedSettings.getBOOL("RenderDeferred") && can_defer);
-
 	gOctreeMaxCapacity = gSavedSettings.getU32("OctreeMaxNodeCapacity");
 	gOctreeReserveCapacity = llmin(gSavedSettings.getU32("OctreeReserveNodeCapacity"),U32(512));
 	sDynamicLOD = gSavedSettings.getBOOL("RenderDynamicLOD");
@@ -494,11 +486,11 @@ void LLPipeline::init()
 	gSavedSettings.getControl("RenderAvatarMaxVisible")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
 	//gSavedSettings.getControl("RenderDelayVBUpdate")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
 	gSavedSettings.getControl("UseOcclusion")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
-	gSavedSettings.getControl("VertexShaderEnable")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
+	//gSavedSettings.getControl("VertexShaderEnable")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));	//Already registered to handleSetShaderChanged
-	gSavedSettings.getControl("RenderDeferred")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
+	//gSavedSettings.getControl("RenderDeferred")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));	//Already registered to handleSetShaderChanged
 	gSavedSettings.getControl("RenderFSAASamples")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
-	gSavedSettings.getControl("RenderAvatarVP")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
+	//gSavedSettings.getControl("RenderAvatarVP")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));	//Already registered to handleSetShaderChanged
-	gSavedSettings.getControl("WindLightUseAtmosShaders")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
+	//gSavedSettings.getControl("WindLightUseAtmosShaders")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings)); //Already registered to handleSetShaderChanged
 }
 
 LLPipeline::~LLPipeline()
@@ -635,7 +627,7 @@ void LLPipeline::throttleNewMemoryAllocation(BOOL disable)
 void LLPipeline::resizeScreenTexture()
 {
 	LLFastTimer ft(FTM_RESIZE_SCREEN_TEXTURE);
-	if (gPipeline.canUseVertexShaders() && assertInitialized())
+	if (LLGLSLShader::sNoFixedFunction && assertInitialized())
 	{
 		GLuint resX = gViewerWindow->getWorldViewWidthRaw();
 		GLuint resY = gViewerWindow->getWorldViewHeightRaw();
@@ -937,25 +929,28 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
 	return true;
 }
 
-//static
+bool LLPipeline::isRenderDeferredCapable()
-void LLPipeline::updateRenderDeferred()
 {
-	sRenderDeferred = (gSavedSettings.getBOOL("RenderDeferred") && 
+	return gGLManager.mHasFramebufferObject &&
-		LLRenderTarget::sUseFBO &&
 		LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred") &&
-		gSavedSettings.getBOOL("RenderObjectBump") &&
+		LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP") &&			//Hardware Skinning. Deferred forces RenderAvatarVP to true
-		gSavedSettings.getBOOL("VertexShaderEnable") && 
+		LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") &&		//Basic Shaders
-		gSavedSettings.getBOOL("RenderAvatarVP") &&
+		LLFeatureManager::getInstance()->isFeatureAvailable("WindLightUseAtmosShaders") &&	//Atmospheric Shaders
-		gSavedSettings.getBOOL("WindLightUseAtmosShaders") &&
+		LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable");
-		!gUseWireframe);	
-	if (sRenderDeferred)
-	{ //must render glow when rendering deferred since post effect pass is needed to present any lighting at all
-		sRenderGlow = TRUE;
-	}
 }
+
+bool LLPipeline::isRenderDeferredDesired()
+{
+	return isRenderDeferredCapable() &&
+		gSavedSettings.getBOOL("RenderDeferred") &&
+		gSavedSettings.getBOOL("VertexShaderEnable") &&
+		gSavedSettings.getBOOL("WindLightUseAtmosShaders");
+}
+
 //static
 void LLPipeline::refreshCachedSettings()
 {
+	LLRenderTarget::sUseFBO = gSavedSettings.getBOOL("RenderUseFBO") || LLPipeline::sRenderDeferred;
 	LLPipeline::sAutoMaskAlphaDeferred = gSavedSettings.getBOOL("RenderAutoMaskAlphaDeferred");
 	LLPipeline::sAutoMaskAlphaNonDeferred = gSavedSettings.getBOOL("RenderAutoMaskAlphaNonDeferred");
 	LLPipeline::sUseFarClip = gSavedSettings.getBOOL("RenderUseFarClip");
@@ -968,8 +963,6 @@ void LLPipeline::refreshCachedSettings()
 			&& LLFeatureManager::getInstance()->isFeatureAvailable("UseOcclusion") 
 			&& gSavedSettings.getBOOL("UseOcclusion") 
 			&& gGLManager.mHasOcclusionQuery) ? 2 : 0;
-	
-	updateRenderDeferred();
 }
 
 void LLPipeline::releaseGLBuffers()
@@ -1044,8 +1037,6 @@ void LLPipeline::createGLBuffers()
 	stop_glerror();
 	assertInitialized();
 
-	updateRenderDeferred();
-
 	bool materials_in_water = false;
 
 #if MATERIALS_IN_REFLECTIONS
@@ -1215,7 +1206,7 @@ void LLPipeline::restoreGL()
 {
 	assertInitialized();
 
-	if (mVertexShadersEnabled)
+	if (LLGLSLShader::sNoFixedFunction)
 	{
 		LLViewerShaderMgr::instance()->setShaders();
 	}
@@ -1237,29 +1228,9 @@ void LLPipeline::restoreGL()
 	resetLocalLights(); //Default all gl light parameters. Fixes light brightness problems on fullscren toggle
 }
 
-
-BOOL LLPipeline::canUseVertexShaders()
-{
-	static const std::string vertex_shader_enable_feature_string = "VertexShaderEnable";
-
-	if (sDisableShaders ||
-		!gGLManager.mHasVertexShader ||
-		!gGLManager.mHasFragmentShader ||
-		!LLFeatureManager::getInstance()->isFeatureAvailable(vertex_shader_enable_feature_string) ||
-		(assertInitialized() && mVertexShadersLoaded != 1) )
-	{
-		return FALSE;
-	}
-	else
-	{
-		return TRUE;
-	}
-}
-
 BOOL LLPipeline::canUseWindLightShaders() const
 {
-	return (!LLPipeline::sDisableShaders &&
+	return (gWLSkyProgram.mProgramObject != 0 &&
-			gWLSkyProgram.mProgramObject != 0 &&
 			LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_WINDLIGHT) > 1);
 }
 
@@ -1277,8 +1248,6 @@ BOOL LLPipeline::canUseAntiAliasing() const
 void LLPipeline::unloadShaders()
 {
 	LLViewerShaderMgr::instance()->unloadShaders();
-
-	mVertexShadersLoaded = 0;
 }
 
 void LLPipeline::assertInitializedDoError()
@@ -1322,7 +1291,7 @@ S32 LLPipeline::setLightingDetail(S32 level)
 	}
 	level = llclamp(level, 0, getMaxLightingDetail());
 	//Bugfix: If setshaders was called with RenderLocalLights off then enabling RenderLocalLights later will not work. Reloading shaders fixes this.
-	if (level != mLightingDetail && mVertexShadersLoaded)
+	if (level != mLightingDetail && LLGLSLShader::sNoFixedFunction)
 	{
 		LLViewerShaderMgr::instance()->setShaders();
 	}
@@ -2291,7 +2260,7 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_cl
 	BOOL to_texture =	LLPipeline::sUseOcclusion > 1 &&
 						!hasRenderType(LLPipeline::RENDER_TYPE_HUD) && 
 						LLViewerCamera::sCurCameraID == LLViewerCamera::CAMERA_WORLD &&
-						gPipeline.canUseVertexShaders() &&
+						LLGLSLShader::sNoFixedFunction &&
 						sRenderGlow;
 
 	if (to_texture)
@@ -2359,7 +2328,7 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_cl
 	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 
 	bool bound_shader = false;
-	if (gPipeline.canUseVertexShaders() && LLGLSLShader::sCurBoundShader == 0)
+	if (LLGLSLShader::sNoFixedFunction && LLGLSLShader::sCurBoundShader == 0)
 	{ //if no shader is currently bound, use the occlusion shader instead of fixed function if we can
 		// (shadow render uses a special shader that clamps to clip planes)
 		bound_shader = true;
@@ -6783,7 +6752,7 @@ void LLPipeline::doResetVertexBuffers()
 
 	sRenderBump = gSavedSettings.getBOOL("RenderObjectBump");
 	LLVertexBuffer::sUseStreamDraw = gSavedSettings.getBOOL("ShyotlRenderUseStreamVBO");
-	LLVertexBuffer::sUseVAO = gSavedSettings.getBOOL("RenderUseVAO") && gPipeline.canUseVertexShaders(); //Temporary workaround for vaos being broken when shaders are off
+	LLVertexBuffer::sUseVAO = gSavedSettings.getBOOL("RenderUseVAO") && LLGLSLShader::sNoFixedFunction; //Temporary workaround for vaos being broken when shaders are off
 	LLVertexBuffer::sPreferStreamDraw = gSavedSettings.getBOOL("RenderPreferStreamDraw");
 	LLVertexBuffer::sEnableVBOs = gSavedSettings.getBOOL("RenderVBOEnable");
 	LLVertexBuffer::sDisableVBOMapping = LLVertexBuffer::sEnableVBOs;// && gSavedSettings.getBOOL("RenderVBOMappingDisable") ; //Temporary workaround for vbo mapping being straight up broken
@@ -6893,7 +6862,7 @@ void LLPipeline::bindScreenToTexture()
 static LLFastTimer::DeclareTimer FTM_RENDER_BLOOM("Bloom");
 void LLPipeline::renderBloom(BOOL for_snapshot, F32 zoom_factor, int subfield, bool tiling)
 {
-	if (!(gPipeline.canUseVertexShaders() &&
+	if (!(LLGLSLShader::sNoFixedFunction &&
 		sRenderGlow))
 	{
 		return;

indra/newview/pipeline.h

@@ -236,9 +236,6 @@ public:
 	S32			getLightingDetail() const { return mLightingDetail; }
 	S32			getMaxLightingDetail() const;
 		
-	void		setUseVertexShaders(BOOL use_shaders);
-	BOOL		getUseVertexShaders() const { return mVertexShadersEnabled; }
-	BOOL		canUseVertexShaders();
 	BOOL		canUseWindLightShaders() const;
 	BOOL		canUseWindLightShadersOnObjects() const;
 	BOOL		canUseAntiAliasing() const;
@@ -412,7 +409,8 @@ public:
 	static BOOL getRenderHighlights(void* data);
 	static void setRenderHighlightTextureChannel(LLRender::eTexIndex channel); // sets which UV setup to display in highlight overlay
 
-	static void updateRenderDeferred();
+	static bool isRenderDeferredCapable();
+	static bool isRenderDeferredDesired();
 	static void refreshCachedSettings();
 
 	static void throttleNewMemoryAllocation(BOOL disable);
@@ -567,7 +565,6 @@ public:
 	static BOOL				sDelayVBUpdate;
 	static BOOL				sAutoMaskAlphaDeferred;
 	static BOOL				sAutoMaskAlphaNonDeferred;
-	static BOOL				sDisableShaders; // if TRUE, rendering will be done without shaders
 	static BOOL				sRenderBump;
 	static BOOL				sNoAlpha;
 	static BOOL				sUseFarClip;
@@ -657,7 +654,6 @@ private:
 public:
 	BOOL					mInitialized;
 	BOOL					mVertexShadersEnabled;
-	S32						mVertexShadersLoaded; // 0 = no, 1 = yes, -1 = failed
 
 	U32						mTransformFeedbackPrimitives; //number of primitives expected to be generated by transform feedback
 private: