Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Inusaito Sayori
2015-05-16 04:13:11 -04:00
parent 2c1f1255fa 690f3614c1
commit b7f2d741e7
40 changed files with 473 additions and 1198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
indra/libhacd/hacdHACD.cpp
View File

@@ -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!!!!

126
indra/llcommon/llstat.cpp
View File

@@ -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);
mLastTime = 0.f;
llassert_always(mNumBins > 1);
reset();
@@ -115,16 +113,8 @@ void LLStat::addValue(const F32 value)
}
// Increment the bin counters.
mCurBin++;
if ((U32)mCurBin >= mNumBins)
{
mCurBin = 0;
}
mNextBin++;
if ((U32)mNextBin >= mNumBins)
{
mNextBin = 0;
}
mCurBin = ++mCurBin % mNumBins;
mNextBin = ++mNextBin % mNumBins;
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 = mLastValue;
if (mNumBins == 0)
F32 current_max = getCurrent();
for (S32 i = 0; i < (S32)mNumValues; i++)
{
current_max = 0.f;
}
else
{
for (i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
// Skip the bin we're currently filling.
if (i == mNextBin)
{
// Skip the bin we're currently filling.
if (i == mNextBin)
{
continue;
}
if (mBins[i].mValue > current_max)
{
current_max = mBins[i].mValue;
}
continue;
}
current_max = llmax(current_max, mBins[i].mValue);
}
return current_max;
}
F32 LLStat::getMean() const
{
S32 i;
F32 current_mean = 0.f;
F32 current_mean = getCurrent();
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 = mLastValue;
F32 current_min = getCurrent();
if (mNumBins == 0)
for (S32 i = 0; i < (S32)mNumValues; i++)
{
current_min = 0.f;
}
else
{
for (i = 0; (i < (S32)mNumBins) && (i < (S32)mNumValues); i++)
// Skip the bin we're currently filling.
if (i == mNextBin)
{
// Skip the bin we're currently filling.
if (i == mNextBin)
{
continue;
}
if (mBins[i].mValue < current_min)
{
current_min = mBins[i].mValue;
}
continue;
}
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)
{
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++)
for (S32 i = 0; 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;
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;
}
F32 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;
}

7
indra/llcommon/llstat.h
View File

@@ -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
{

295
indra/llmath/llperlin.cpp
View File

@@ -24,271 +24,34 @@
*/
#include "linden_common.h"
#include "llmath.h"
#include "llperlin.h"
#define B 0x100
#define BM 0xff
#define N 0x1000
#define NF32 (4096.f)
#define NP 12 /* 2^N */
#define NM 0xfff
static S32 p[B + B + 2];
static F32 g3[B + B + 2][3];
static F32 g2[B + B + 2][2];
static F32 g1[B + B + 2];
bool LLPerlinNoise::sInitialized = 0;
static void normalize2(F32 v[2])
{
F32 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 = 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 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;
}
//Random values taken from http://mrl.nyu.edu/~perlin/noise/
const U8 LLPerlinNoise::p[LLPerlinNoise::sPremutationCount] =
{ 151, 160, 137, 91, 90, 15,
131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
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,
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,
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,
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,
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,
131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
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,
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,
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,
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,
138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
};

155
indra/llmath/llperlin.h
View File

@@ -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);
static F32 noise2(F32 x, F32 y);
static F32 noise3(F32 x, F32 y, F32 z);
static F32 turbulence2(F32 x, F32 y, F32 freq);
static F32 turbulence3(F32 x, F32 y, F32 z, F32 freq);
static F32 clouds3(F32 x, F32 y, F32 z, F32 freq);
template<typename T>
static F32 noise(const T& x, U32 wrap_at);
template<typename T>
static F32 noise(const T& x)
{
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 void init(void);
static F32 s_curve(const F32 t)
{
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_

12
indra/llrender/llpostprocess.cpp
View File

@@ -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 };

2
indra/llrender/llrender.cpp
View File

@@ -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)
{

18
indra/llwindow/lldxhardware.cpp
View File

@@ -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;

2
indra/newview/CMakeLists.txt
View File

@@ -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

1
indra/newview/llcylinder.cpp
View File

@@ -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"

10
indra/newview/lldrawpoolalpha.cpp
View File

@@ -216,8 +216,7 @@ void LLDrawPoolAlpha::render(S32 pass)
gGL.setColorMask(true, true);
}
bool write_depth = LLDrawPoolWater::sSkipScreenCopy
|| (deferred_render && pass == 1)
bool write_depth = (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(shaders)
if (LLGLSLShader::sNoFixedFunction)
{
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);

24
indra/newview/lldrawpoolavatar.cpp
View File

@@ -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);

4
indra/newview/lldrawpoolbump.cpp
View File

@@ -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();
}

2
indra/newview/lldrawpooltree.cpp
View File

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

3
indra/newview/lldrawpoolwater.cpp
View File

@@ -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;

1
indra/newview/lldrawpoolwater.h
View File

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

12
indra/newview/lldrawpoolwlsky.cpp
View File

@@ -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();

1
indra/newview/llfeaturemanager.cpp
View File

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

2
indra/newview/llfloaterenvsettings.cpp
View File

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

2
indra/newview/llframestatview.cpp
View File

@@ -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;
}

8
indra/newview/llpaneldisplay.cpp
View File

@@ -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 &&
LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred") && //Ensure it's enabled in the gpu feature table
LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP") && //Hardware Skinning. Deferred forces RenderAvatarVP to true
LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") && gSavedSettings.getBOOL("VertexShaderEnable") && //Basic Shaders
LLFeatureManager::getInstance()->isFeatureAvailable("WindLightUseAtmosShaders") && wlatmos; //Atmospheric Shaders
BOOL can_defer = LLPipeline::isRenderDeferredCapable() &&
gSavedSettings.getBOOL("VertexShaderEnable") && //Basic Shaders
wlatmos; //Atmospheric Shaders
mCtrlDeferred->setEnabled(can_defer);

1
indra/newview/llsurface.cpp
View File

@@ -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"

13
indra/newview/llsurfacepatch.cpp
View File

@@ -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] = {
(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
0.f
};
F32 rand_val = llclamp(noise2(vec)* 0.75f + 0.5f, 0.f, 1.f);
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[1] + y)*xyScaleInv, 256.f) // <FS:ND/> Added (F32) for proper array initialization
);
F32 rand_val = llclamp(LLPerlinNoise::noise(vec)* 0.75f + 0.5f, 0.f, 1.f);
tex1->mV[1] = rand_val;

15
indra/newview/llviewercontrol.cpp
View File

@@ -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();
gPipeline.updateRenderDeferred();
gPipeline.releaseGLBuffers();
gPipeline.createGLBuffers();
gPipeline.resetVertexBuffers();
if (old_deferred != newvalue.asBoolean())
if (LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred"))
{
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() || (gSavedSettings.getBOOL("RenderDeferred") && can_defer);
LLRenderTarget::sUseFBO = newvalue.asBoolean() || LLPipeline::sRenderDeferred;
if (gPipeline.isInit())
{
gPipeline.releaseGLBuffers();
gPipeline.createGLBuffers();
gPipeline.resetVertexBuffers();
}
return true;
}

8
indra/newview/llviewerdisplay.cpp
View File

@@ -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());
}

1
indra/newview/llviewermenu.cpp
View File

@@ -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;
}

308
indra/newview/llviewershadermgr.cpp
View File

@@ -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),
mMaxAvatarShaderLevel(0)
mVertexShaderLevel(SHADER_COUNT, 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;
LLPipeline::sRenderGlow = gSavedSettings.getBOOL("RenderGlow");
LLPipeline::updateRenderDeferred();
}
else
{
LLPipeline::sRenderGlow = FALSE;
LLPipeline::sWaterReflections = FALSE;
//sRenderGlow needs set as it's referenced in the shader load process.
LLPipeline::sRenderGlow = want_deferred || gSavedSettings.getBOOL("RenderGlow");
}
//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)
&& gSavedSettings.getBOOL("VertexShaderEnable"))
if (want_shaders)
{
//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") &&
gSavedSettings.getBOOL("RenderDeferred") &&
gSavedSettings.getBOOL("RenderAvatarVP") &&
gSavedSettings.getBOOL("WindLightUseAtmosShaders"))
if (want_deferred)
{
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();
if(!loaded) //Failed to load. Just wipe all transformfeedback shaders and continue like nothing happened.
{
mVertexShaderLevel[SHADER_TRANSFORM] = 0;
unloadShaderClass(SHADER_TRANSFORM);
loaded = true;
}
loadTransformShaders();
}
if (loaded)
{
// Load max avatar shaders to set the max level
mVertexShaderLevel[SHADER_AVATAR] = 3;
mMaxAvatarShaderLevel = 3;
bool can_skin = want_deferred || (LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP") && gSavedSettings.getBOOL("RenderAvatarVP"));
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;
loadShadersAvatar();
if (mVertexShaderLevel[SHADER_AVATAR] != avatar_class)
mVertexShaderLevel[SHADER_AVATAR] = gSavedSettings.getBOOL("RenderAvatarCloth") ? 3 : 1;
if(!loadShadersAvatar() || !loadShadersObject())
{
if (mVertexShaderLevel[SHADER_AVATAR] == 0)
{
gSavedSettings.setBOOL("RenderAvatarVP", FALSE);
}
if(llmax(mVertexShaderLevel[SHADER_AVATAR]-1,0) >= 3)
{
avatar_cloth = true;
}
else
{
avatar_cloth = false;
}
gSavedSettings.setBOOL("RenderAvatarCloth", avatar_cloth);
can_skin = false;
}
else if (mVertexShaderLevel[SHADER_AVATAR] < 3)
{
gSavedSettings.setBOOL("RenderAvatarCloth", false);
}
}
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"))
{
gSavedSettings.setBOOL("RenderDeferred", FALSE);
gSavedSettings.setBOOL("RenderAvatarCloth", FALSE);
gSavedSettings.setBOOL("RenderAvatarVP", FALSE);
}
want_deferred = false; //Deferred requires skinned shaders.
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;
}
}
if (loaded && !loadShadersDeferred())
{ //everything else succeeded but deferred failed, disable deferred and try again
}
else if (!loadShadersDeferred())
{
gSavedSettings.setBOOL("RenderDeferred", FALSE);
reentrance = false;
setShaders();
return;
}
}
else
if (!loaded)
{
LLGLSLShader::sNoFixedFunction = false;
LLGLSLShader::sIndexedTextureChannels = 1;
gPipeline.mVertexShadersEnabled = FALSE;
gPipeline.mVertexShadersLoaded = 0;
for (S32 i = 0; i < SHADER_COUNT; i++)
mVertexShaderLevel[i] = 0;
llassert_always(!LLRender::sGLCoreProfile); //This is bad...
unloadShaders();
}
else //Shaders loaded
{
//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();
for(; it!=mShaderObjects.end();++it)
if(it->second.mHandle)
glDeleteObjectARB(it->second.mHandle);
mShaderObjects.clear();
unloadShaderObjects();
}
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 TRUE;
return success;
}
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);
}
/// 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);
success = gTerrainWaterProgram.createShader(NULL, NULL);
}
if (!success)
{
mVertexShaderLevel[SHADER_WATER] = 0;
return FALSE;
unloadShaderClass(SHADER_WATER);
}
// 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)
else
{
mVertexShaderLevel[SHADER_WATER]--;
return loadShadersWater();
LLWorld::getInstance()->updateWaterObjects();
}
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;
return FALSE;
unloadShaderClass(SHADER_AVATAR);
}
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;
}

4
indra/newview/llviewershadermgr.h
View File

@@ -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

2
indra/newview/llviewerwindow.cpp
View File

@@ -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;

25
indra/newview/llvlcomposition.cpp
View File

@@ -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;
vec[2] = height*zScaleInv;
// Adjust to non - integer lattice
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);
vec1[1] = vec[1]*(0.2222222222f);
vec1[2] = vec[2]*(0.2222222222f);
twiddle = noise2(vec1)*6.5f; // Low freq component for large divisions
twiddle = LLPerlinNoise::noise(vec*0.2222222222f)*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;

18
indra/newview/llvoavatar.cpp
View File

@@ -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];
nx[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 noiseX = LLPerlinNoise::noise(LLVector2(time*TORSO_NOISE_SPEED, 0));
F32 noiseY = LLPerlinNoise::noise(LLVector2(0, time*TORSO_NOISE_SPEED));
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);
}
}
}

3
indra/newview/llvopartgroup.cpp
View File

@@ -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;

4
indra/newview/llvotree.cpp
View File

@@ -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)
{

14
indra/newview/llvovolume.cpp
View File

@@ -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_fixed = 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 && !LLGLSLShader::sNoFixedFunction && te->getShiny();
bool is_fullbright = facep->isState(LLFace::FULLBRIGHT);
if (facep->getPoolType() == LLDrawPool::POOL_MATERIALS)

4
indra/newview/llwaterparammanager.cpp
View File

@@ -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);

1
indra/newview/llwind.cpp
View File

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

90
indra/newview/noise.cpp
View File

@@ -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);
}

363
indra/newview/noise.h
View File

@@ -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_

87
indra/newview/pipeline.cpp
View File

@@ -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("RenderDeferred")->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)); //Already registered to handleSetShaderChanged
gSavedSettings.getControl("RenderFSAASamples")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
gSavedSettings.getControl("RenderAvatarVP")->getCommitSignal()->connect(boost::bind(&LLPipeline::refreshCachedSettings));
gSavedSettings.getControl("WindLightUseAtmosShaders")->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)); //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
void LLPipeline::updateRenderDeferred()
bool LLPipeline::isRenderDeferredCapable()
{
sRenderDeferred = (gSavedSettings.getBOOL("RenderDeferred") &&
LLRenderTarget::sUseFBO &&
return gGLManager.mHasFramebufferObject &&
LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferred") &&
gSavedSettings.getBOOL("RenderObjectBump") &&
gSavedSettings.getBOOL("VertexShaderEnable") &&
gSavedSettings.getBOOL("RenderAvatarVP") &&
gSavedSettings.getBOOL("WindLightUseAtmosShaders") &&
!gUseWireframe);
if (sRenderDeferred)
{ //must render glow when rendering deferred since post effect pass is needed to present any lighting at all
sRenderGlow = TRUE;
}
LLFeatureManager::getInstance()->isFeatureAvailable("RenderAvatarVP") && //Hardware Skinning. Deferred forces RenderAvatarVP to true
LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable") && //Basic Shaders
LLFeatureManager::getInstance()->isFeatureAvailable("WindLightUseAtmosShaders") && //Atmospheric Shaders
LLFeatureManager::getInstance()->isFeatureAvailable("VertexShaderEnable");
}
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 &&
gWLSkyProgram.mProgramObject != 0 &&
return (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;

8
indra/newview/pipeline.h
View File

@@ -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: