Merge with viewer-bear which was just merged with viewer-release
callum_linden
commit
bd41392b7e
1
.hgtags
1
.hgtags
|
|
@ -463,3 +463,4 @@ fb1630153bac5552046ea914af3f14deabc1def8 3.6.0-materials-beta1
|
|||
69429d81ae4dd321eda2607901ef0a0fde71b54c 3.6.0-release
|
||||
69429d81ae4dd321eda2607901ef0a0fde71b54c 3.6.0-release
|
||||
0a56f33ad6aa112032b14a41dad759ad377bdde9 3.6.0-release
|
||||
75cf8e855ae1af6895a35da475314c2b5acf1850 3.6.1-release
|
||||
|
|
|
|||
|
|
@ -149,6 +149,9 @@ void LLGLSLShader::clearStats()
|
|||
mTimeElapsed = 0;
|
||||
mSamplesDrawn = 0;
|
||||
mDrawCalls = 0;
|
||||
mTextureStateFetched = false;
|
||||
mTextureMagFilter.clear();
|
||||
mTextureMinFilter.clear();
|
||||
}
|
||||
|
||||
void LLGLSLShader::dumpStats()
|
||||
|
|
@ -161,6 +164,16 @@ void LLGLSLShader::dumpStats()
|
|||
{
|
||||
llinfos << mShaderFiles[i].first << llendl;
|
||||
}
|
||||
for (U32 i = 0; i < mTexture.size(); ++i)
|
||||
{
|
||||
GLint idx = mTexture[i];
|
||||
|
||||
if (idx >= 0)
|
||||
{
|
||||
GLint uniform_idx = getUniformLocation(i);
|
||||
llinfos << std::hex << mTextureMagFilter[i] << "/" << mTextureMinFilter[i] << std::dec << llendl;
|
||||
}
|
||||
}
|
||||
llinfos << "=============================================" << llendl;
|
||||
|
||||
F32 ms = mTimeElapsed/1000000.f;
|
||||
|
|
@ -211,6 +224,39 @@ void LLGLSLShader::placeProfileQuery()
|
|||
glGenQueriesARB(1, &mTimerQuery);
|
||||
}
|
||||
|
||||
if (!mTextureStateFetched)
|
||||
{
|
||||
mTextureStateFetched = true;
|
||||
mTextureMagFilter.resize(mTexture.size());
|
||||
mTextureMinFilter.resize(mTexture.size());
|
||||
|
||||
U32 cur_active = gGL.getCurrentTexUnitIndex();
|
||||
|
||||
for (U32 i = 0; i < mTexture.size(); ++i)
|
||||
{
|
||||
GLint idx = mTexture[i];
|
||||
|
||||
if (idx >= 0)
|
||||
{
|
||||
gGL.getTexUnit(idx)->activate();
|
||||
|
||||
U32 mag = 0xFFFFFFFF;
|
||||
U32 min = 0xFFFFFFFF;
|
||||
|
||||
U32 type = LLTexUnit::getInternalType(gGL.getTexUnit(idx)->getCurrType());
|
||||
|
||||
glGetTexParameteriv(type, GL_TEXTURE_MAG_FILTER, (GLint*) &mag);
|
||||
glGetTexParameteriv(type, GL_TEXTURE_MIN_FILTER, (GLint*) &min);
|
||||
|
||||
mTextureMagFilter[i] = mag;
|
||||
mTextureMinFilter[i] = min;
|
||||
}
|
||||
}
|
||||
|
||||
gGL.getTexUnit(cur_active)->activate();
|
||||
}
|
||||
|
||||
|
||||
glBeginQueryARB(GL_SAMPLES_PASSED, 1);
|
||||
glBeginQueryARB(GL_TIME_ELAPSED, mTimerQuery);
|
||||
#endif
|
||||
|
|
@ -575,6 +621,7 @@ void LLGLSLShader::mapUniform(GLint index, const vector<LLStaticHashedString> *
|
|||
|
||||
LLStaticHashedString hashedName(name);
|
||||
mUniformMap[hashedName] = location;
|
||||
|
||||
LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
|
||||
|
||||
//find the index of this uniform
|
||||
|
|
@ -1154,6 +1201,22 @@ void LLGLSLShader::uniform1i(const LLStaticHashedString& uniform, GLint v)
|
|||
}
|
||||
}
|
||||
|
||||
void LLGLSLShader::uniform2i(const string& uniform, GLint i, GLint j)
|
||||
{
|
||||
GLint location = getUniformLocation(uniform);
|
||||
|
||||
if (location >= 0)
|
||||
{
|
||||
std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
|
||||
LLVector4 vec(i,j,0.f,0.f);
|
||||
if (iter == mValue.end() || shouldChange(iter->second,vec))
|
||||
{
|
||||
glUniform2iARB(location, i, j);
|
||||
mValue[location] = vec;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LLGLSLShader::uniform1f(const LLStaticHashedString& uniform, GLfloat v)
|
||||
{
|
||||
GLint location = getUniformLocation(uniform);
|
||||
|
|
|
|||
|
|
@ -111,6 +111,19 @@ public:
|
|||
void uniform2fv(U32 index, U32 count, const GLfloat* v);
|
||||
void uniform3fv(U32 index, U32 count, const GLfloat* v);
|
||||
void uniform4fv(U32 index, U32 count, const GLfloat* v);
|
||||
|
||||
void uniform1i(const std::string& uniform, GLint i);
|
||||
void uniform2i(const std::string& uniform, GLint i, GLint j);
|
||||
void uniform1f(const std::string& uniform, GLfloat v);
|
||||
void uniform2f(const std::string& uniform, GLfloat x, GLfloat y);
|
||||
void uniform3f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z);
|
||||
void uniform4f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
|
||||
void uniform1iv(const std::string& uniform, U32 count, const GLint* i);
|
||||
void uniform1fv(const std::string& uniform, U32 count, const GLfloat* v);
|
||||
void uniform2fv(const std::string& uniform, U32 count, const GLfloat* v);
|
||||
void uniform3fv(const std::string& uniform, U32 count, const GLfloat* v);
|
||||
void uniform4fv(const std::string& uniform, U32 count, const GLfloat* v);
|
||||
|
||||
void uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
|
||||
void uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
|
||||
void uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
|
||||
|
|
@ -190,6 +203,11 @@ public:
|
|||
static U64 sTotalSamplesDrawn;
|
||||
U32 mDrawCalls;
|
||||
static U32 sTotalDrawCalls;
|
||||
|
||||
bool mTextureStateFetched;
|
||||
std::vector<U32> mTextureMagFilter;
|
||||
std::vector<U32> mTextureMinFilter;
|
||||
|
||||
};
|
||||
|
||||
//UI shader (declared here so llui_libtest will link properly)
|
||||
|
|
|
|||
|
|
@ -53,11 +53,19 @@ void check_framebuffer_status()
|
|||
bool LLRenderTarget::sUseFBO = false;
|
||||
U32 LLRenderTarget::sCurFBO = 0;
|
||||
|
||||
|
||||
extern S32 gGLViewport[4];
|
||||
|
||||
U32 LLRenderTarget::sCurResX = 0;
|
||||
U32 LLRenderTarget::sCurResY = 0;
|
||||
|
||||
LLRenderTarget::LLRenderTarget() :
|
||||
mResX(0),
|
||||
mResY(0),
|
||||
mFBO(0),
|
||||
mPreviousFBO(0),
|
||||
mPreviousResX(0),
|
||||
mPreviousResY(0),
|
||||
mDepth(0),
|
||||
mStencil(0),
|
||||
mUseDepth(false),
|
||||
|
|
@ -390,13 +398,12 @@ void LLRenderTarget::bindTarget()
|
|||
{
|
||||
if (mFBO)
|
||||
{
|
||||
mPreviousFBO = sCurFBO;
|
||||
|
||||
stop_glerror();
|
||||
|
||||
mPreviousFBO = sCurFBO;
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
|
||||
sCurFBO = mFBO;
|
||||
|
||||
|
||||
stop_glerror();
|
||||
if (gGLManager.mHasDrawBuffers)
|
||||
{ //setup multiple render targets
|
||||
|
|
@ -418,7 +425,12 @@ void LLRenderTarget::bindTarget()
|
|||
stop_glerror();
|
||||
}
|
||||
|
||||
mPreviousResX = sCurResX;
|
||||
mPreviousResY = sCurResY;
|
||||
glViewport(0, 0, mResX, mResY);
|
||||
sCurResX = mResX;
|
||||
sCurResY = mResY;
|
||||
|
||||
sBoundTarget = this;
|
||||
}
|
||||
|
||||
|
|
@ -495,6 +507,20 @@ void LLRenderTarget::flush(bool fetch_depth)
|
|||
stop_glerror();
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, mPreviousFBO);
|
||||
sCurFBO = mPreviousFBO;
|
||||
|
||||
if (mPreviousFBO)
|
||||
{
|
||||
glViewport(0, 0, mPreviousResX, mPreviousResY);
|
||||
sCurResX = mPreviousResX;
|
||||
sCurResY = mPreviousResY;
|
||||
}
|
||||
else
|
||||
{
|
||||
glViewport(gGLViewport[0],gGLViewport[1],gGLViewport[2],gGLViewport[3]);
|
||||
sCurResX = gGLViewport[2];
|
||||
sCurResY = gGLViewport[3];
|
||||
}
|
||||
|
||||
stop_glerror();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -63,6 +63,9 @@ public:
|
|||
static bool sUseFBO;
|
||||
static U32 sBytesAllocated;
|
||||
static U32 sCurFBO;
|
||||
static U32 sCurResX;
|
||||
static U32 sCurResY;
|
||||
|
||||
|
||||
LLRenderTarget();
|
||||
~LLRenderTarget();
|
||||
|
|
@ -147,6 +150,9 @@ protected:
|
|||
std::vector<U32> mInternalFormat;
|
||||
U32 mFBO;
|
||||
U32 mPreviousFBO;
|
||||
U32 mPreviousResX;
|
||||
U32 mPreviousResY;
|
||||
|
||||
U32 mDepth;
|
||||
bool mStencil;
|
||||
bool mUseDepth;
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
3.6.1
|
||||
3.6.2
|
||||
|
|
|
|||
|
|
@ -7743,7 +7743,7 @@
|
|||
<key>Type</key>
|
||||
<string>S32</string>
|
||||
<key>Value</key>
|
||||
<integer>4</integer>
|
||||
<integer>3</integer>
|
||||
</map>
|
||||
|
||||
<key>OctreeAlphaDistanceFactor</key>
|
||||
|
|
@ -8527,7 +8527,6 @@
|
|||
<key>Value</key>
|
||||
<real>1.0</real>
|
||||
</map>
|
||||
|
||||
<key>RenderDeferredTreeShadowBias</key>
|
||||
<map>
|
||||
<key>Comment</key>
|
||||
|
|
|
|||
|
|
@ -26,28 +26,23 @@
|
|||
|
||||
ATTRIBUTE vec4 weight4;
|
||||
|
||||
uniform mat4 matrixPalette[64];
|
||||
uniform mat4 matrixPalette[32];
|
||||
|
||||
mat4 getObjectSkinnedTransform()
|
||||
{
|
||||
int i;
|
||||
|
||||
float w0 = fract(weight4.x);
|
||||
float w1 = fract(weight4.y);
|
||||
float w2 = fract(weight4.z);
|
||||
float w3 = fract(weight4.w);
|
||||
|
||||
int i0 = int(floor(weight4.x));
|
||||
int i1 = int(floor(weight4.y));
|
||||
int i2 = int(floor(weight4.z));
|
||||
int i3 = int(floor(weight4.w));
|
||||
|
||||
//float scale = 1.0/(w.x+w.y+w.z+w.w);
|
||||
//w *= scale;
|
||||
vec4 w = fract(weight4);
|
||||
vec4 index = floor(weight4);
|
||||
|
||||
mat4 mat = matrixPalette[i0]*w0;
|
||||
mat += matrixPalette[i1]*w1;
|
||||
mat += matrixPalette[i2]*w2;
|
||||
mat += matrixPalette[i3]*w3;
|
||||
float scale = 1.0/(w.x+w.y+w.z+w.w);
|
||||
w *= scale;
|
||||
|
||||
mat4 mat = matrixPalette[int(index.x)]*w.x;
|
||||
mat += matrixPalette[int(index.y)]*w.y;
|
||||
mat += matrixPalette[int(index.z)]*w.z;
|
||||
mat += matrixPalette[int(index.w)]*w.w;
|
||||
|
||||
return mat;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -78,6 +78,7 @@ uniform vec2 screen_res;
|
|||
vec3 calcDirectionalLight(vec3 n, vec3 l)
|
||||
{
|
||||
float a = max(dot(n,l),0.0);
|
||||
a = pow(a, 1.0/1.3);
|
||||
return vec3(a,a,a);
|
||||
}
|
||||
|
||||
|
|
@ -87,7 +88,7 @@ vec3 calcPointLightOrSpotLight(vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float
|
|||
vec3 lv = lp.xyz-v;
|
||||
|
||||
//get distance
|
||||
float d = dot(lv,lv);
|
||||
float d = length(lv);
|
||||
|
||||
float da = 0.0;
|
||||
|
||||
|
|
@ -97,9 +98,11 @@ vec3 calcPointLightOrSpotLight(vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float
|
|||
lv = normalize(lv);
|
||||
|
||||
//distance attenuation
|
||||
float dist2 = d/la;
|
||||
da = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
da = pow(da, 2.2) * 2.2;
|
||||
float dist = d/la;
|
||||
da = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
da *= da;
|
||||
da *= 1.4;
|
||||
|
||||
|
||||
// spotlight coefficient.
|
||||
float spot = max(dot(-ln, lv), is_pointlight);
|
||||
|
|
@ -212,6 +215,7 @@ void main()
|
|||
#else
|
||||
vec4 diff = texture2D(diffuseMap,vary_texcoord0.xy);
|
||||
#endif
|
||||
vec4 gamma_diff = diff;
|
||||
|
||||
diff.rgb = pow(diff.rgb, vec3(2.2f, 2.2f, 2.2f));
|
||||
|
||||
|
|
@ -224,7 +228,7 @@ void main()
|
|||
vec3 normal = vary_norm;
|
||||
|
||||
vec3 l = light_position[0].xyz;
|
||||
vec3 dlight = calcDirectionalLight(normal, l) * 2.6;
|
||||
vec3 dlight = calcDirectionalLight(normal, l);
|
||||
dlight = dlight * vary_directional.rgb * vary_pointlight_col;
|
||||
|
||||
#if HAS_SHADOW
|
||||
|
|
@ -233,13 +237,16 @@ void main()
|
|||
vec4 col = vec4(vary_ambient + dlight, vertex_color_alpha);
|
||||
#endif
|
||||
|
||||
vec4 color = diff * col;
|
||||
vec4 color = gamma_diff * col;
|
||||
|
||||
color.rgb = atmosLighting(color.rgb);
|
||||
|
||||
color.rgb = scaleSoftClip(color.rgb);
|
||||
|
||||
color.rgb = pow(color.rgb, vec3(2.2));
|
||||
col = vec4(0,0,0,0);
|
||||
|
||||
|
||||
#define LIGHT_LOOP(i) col.rgb += light_diffuse[i].rgb * calcPointLightOrSpotLight(pos.xyz, normal, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z);
|
||||
|
||||
LIGHT_LOOP(1)
|
||||
|
|
@ -250,7 +257,7 @@ void main()
|
|||
LIGHT_LOOP(6)
|
||||
LIGHT_LOOP(7)
|
||||
|
||||
color.rgb += diff.rgb * vary_pointlight_col * col.rgb;
|
||||
color.rgb += diff.rgb * pow(vary_pointlight_col, vec3(2.2)) * col.rgb;
|
||||
|
||||
color.rgb = pow(color.rgb, vec3(1.0/2.2));
|
||||
|
||||
|
|
|
|||
|
|
@ -58,8 +58,6 @@ mat4 getSkinnedTransform();
|
|||
vec4 calcLighting(vec3 pos, vec3 norm, vec4 color, vec4 baseCol);
|
||||
void calcAtmospherics(vec3 inPositionEye);
|
||||
|
||||
vec3 calcDirectionalLight(vec3 n, vec3 l);
|
||||
|
||||
vec3 atmosAmbient(vec3 light);
|
||||
vec3 atmosAffectDirectionalLight(float lightIntensity);
|
||||
vec3 scaleDownLight(vec3 light);
|
||||
|
|
@ -88,12 +86,6 @@ uniform vec3 light_diffuse[8];
|
|||
|
||||
uniform vec3 sun_dir;
|
||||
|
||||
vec3 calcDirectionalLight(vec3 n, vec3 l)
|
||||
{
|
||||
float a = max(dot(n,l),0.0);
|
||||
return vec3(a,a,a);
|
||||
}
|
||||
|
||||
vec3 calcPointLightOrSpotLight(vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float fa, float is_pointlight)
|
||||
{
|
||||
//get light vector
|
||||
|
|
@ -184,7 +176,7 @@ void main()
|
|||
//vec4 color = calcLighting(pos.xyz, norm, diffuse_color, vec4(0.));
|
||||
vec4 col = vec4(0.0, 0.0, 0.0, diffuse_color.a);
|
||||
|
||||
vec3 diff = pow(diffuse_color.rgb, vec3(2.2));
|
||||
vec3 diff = diffuse_color.rgb;
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -46,11 +46,6 @@ VARYING vec2 vary_fragcoord;
|
|||
uniform mat4 inv_proj;
|
||||
uniform vec2 screen_res;
|
||||
|
||||
vec3 getKern(int i)
|
||||
{
|
||||
return kern[i];
|
||||
}
|
||||
|
||||
vec4 getPosition(vec2 pos_screen)
|
||||
{
|
||||
float depth = texture2DRect(depthMap, pos_screen.xy).r;
|
||||
|
|
@ -110,7 +105,7 @@ void main()
|
|||
vec2 dlt = kern_scale * delta / (1.0+norm.xy*norm.xy);
|
||||
dlt /= max(-pos.z*dist_factor, 1.0);
|
||||
|
||||
vec2 defined_weight = getKern(0).xy; // special case the first (centre) sample's weight in the blur; we have to sample it anyway so we get it for 'free'
|
||||
vec2 defined_weight = kern[0].xy; // special case the first (centre) sample's weight in the blur; we have to sample it anyway so we get it for 'free'
|
||||
vec4 col = defined_weight.xyxx * ccol;
|
||||
|
||||
// relax tolerance according to distance to avoid speckling artifacts, as angles and distances are a lot more abrupt within a small screen area at larger distances
|
||||
|
|
@ -120,28 +115,33 @@ void main()
|
|||
float tc_mod = 0.5*(tc.x + tc.y); // mod(tc.x+tc.y,2)
|
||||
tc_mod -= floor(tc_mod);
|
||||
tc_mod *= 2.0;
|
||||
tc += ( (tc_mod - 0.5) * getKern(1).z * dlt * 0.5 );
|
||||
tc += ( (tc_mod - 0.5) * kern[1].z * dlt * 0.5 );
|
||||
|
||||
for (int i = 1; i < 4; i++)
|
||||
{
|
||||
vec2 samptc = tc + getKern(i).z*dlt;
|
||||
vec3 samppos = getPosition(samptc).xyz;
|
||||
vec2 samptc = tc + kern[i].z*dlt;
|
||||
vec3 samppos = getPosition(samptc).xyz;
|
||||
|
||||
float d = dot(norm.xyz, samppos.xyz-pos.xyz);// dist from plane
|
||||
|
||||
if (d*d <= pointplanedist_tolerance_pow2)
|
||||
{
|
||||
col += texture2DRect(lightMap, samptc)*getKern(i).xyxx;
|
||||
defined_weight += getKern(i).xy;
|
||||
col += texture2DRect(lightMap, samptc)*kern[i].xyxx;
|
||||
defined_weight += kern[i].xy;
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 1; i < 4; i++)
|
||||
{
|
||||
vec2 samptc = tc - getKern(i).z*dlt;
|
||||
vec3 samppos = getPosition(samptc).xyz;
|
||||
vec2 samptc = tc - kern[i].z*dlt;
|
||||
vec3 samppos = getPosition(samptc).xyz;
|
||||
|
||||
float d = dot(norm.xyz, samppos.xyz-pos.xyz);// dist from plane
|
||||
|
||||
if (d*d <= pointplanedist_tolerance_pow2)
|
||||
{
|
||||
col += texture2DRect(lightMap, samptc)*getKern(i).xyxx;
|
||||
defined_weight += getKern(i).xy;
|
||||
col += texture2DRect(lightMap, samptc)*kern[i].xyxx;
|
||||
defined_weight += kern[i].xy;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -43,10 +43,12 @@ vec2 encode_normal(vec3 n)
|
|||
void main()
|
||||
{
|
||||
vec3 col = vertex_color.rgb * diffuseLookup(vary_texcoord0.xy).rgb;
|
||||
|
||||
vec3 spec;
|
||||
spec.rgb = vec3(vertex_color.a);
|
||||
|
||||
frag_data[0] = vec4(col, 0.0);
|
||||
frag_data[1] = vertex_color.aaaa; // spec
|
||||
frag_data[1] = vec4(vec3(vertex_color.a), vertex_color.a+(1.0-vertex_color.a)*vertex_color.a); // spec - from former class3 - maybe better, but not so well tested
|
||||
frag_data[1] = vec4(spec, vertex_color.a); // spec
|
||||
vec3 nvn = normalize(vary_normal);
|
||||
frag_data[2] = vec4(encode_normal(nvn.xyz), vertex_color.a, 0.0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -127,7 +127,7 @@ vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 npos, vec3 diffuse, vec4 spe
|
|||
vec3 lv = lp.xyz-v;
|
||||
|
||||
//get distance
|
||||
float d = dot(lv,lv);
|
||||
float d = length(lv);
|
||||
|
||||
float da = 1.0;
|
||||
|
||||
|
|
@ -139,8 +139,10 @@ vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 npos, vec3 diffuse, vec4 spe
|
|||
lv = normalize(lv);
|
||||
|
||||
//distance attenuation
|
||||
float dist2 = d/la;
|
||||
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
float dist = d/la;
|
||||
float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
dist_atten *= dist_atten;
|
||||
dist_atten *= 1.4;
|
||||
|
||||
// spotlight coefficient.
|
||||
float spot = max(dot(-ln, lv), is_pointlight);
|
||||
|
|
@ -321,9 +323,9 @@ void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
|
|||
+ tmpAmbient)));
|
||||
|
||||
//brightness of surface both sunlight and ambient
|
||||
setSunlitColor(pow(vec3(sunlight * .5), vec3(2.2)) * 2.2);
|
||||
setAmblitColor(pow(vec3(tmpAmbient * .25), vec3(2.2)) * 2.2);
|
||||
setAdditiveColor(pow(getAdditiveColor() * vec3(1.0 - temp1), vec3(2.2)) * 2.2);
|
||||
setSunlitColor(vec3(sunlight * .5));
|
||||
setAmblitColor(vec3(tmpAmbient * .25));
|
||||
setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
|
||||
}
|
||||
|
||||
vec3 atmosLighting(vec3 light)
|
||||
|
|
@ -617,8 +619,8 @@ void main()
|
|||
|
||||
col.rgb *= ambient;
|
||||
|
||||
col.rgb = col.rgb + atmosAffectDirectionalLight(final_da * 2.6);
|
||||
col.rgb *= diffuse.rgb;
|
||||
col.rgb = col.rgb + atmosAffectDirectionalLight(pow(final_da, 1.0/1.3));
|
||||
col.rgb *= old_diffcol.rgb;
|
||||
|
||||
|
||||
float glare = 0.0;
|
||||
|
|
@ -647,9 +649,8 @@ void main()
|
|||
{
|
||||
//add environmentmap
|
||||
vec3 env_vec = env_mat * refnormpersp;
|
||||
float exponent = mix(2.2, 1.0, diffuse.a);
|
||||
|
||||
vec3 refcol = pow(textureCube(environmentMap, env_vec).rgb, vec3(exponent))*exponent;
|
||||
|
||||
vec3 refcol = textureCube(environmentMap, env_vec).rgb;
|
||||
|
||||
col = mix(col.rgb, refcol,
|
||||
envIntensity);
|
||||
|
|
@ -660,13 +661,12 @@ void main()
|
|||
glare += cur_glare;
|
||||
}
|
||||
|
||||
float exponent = mix(1.0, 2.2, diffuse.a);
|
||||
col = pow(col, vec3(exponent));
|
||||
|
||||
|
||||
col = mix(atmosLighting(col), fullbrightAtmosTransport(col), diffuse.a);
|
||||
col = mix(scaleSoftClip(col), fullbrightScaleSoftClip(col), diffuse.a);
|
||||
|
||||
//convert to linear space before adding local lights
|
||||
col = pow(col, vec3(2.2));
|
||||
|
||||
|
||||
vec3 npos = normalize(-pos.xyz);
|
||||
|
||||
|
|
@ -681,6 +681,7 @@ void main()
|
|||
LIGHT_LOOP(7)
|
||||
|
||||
|
||||
//convert to gamma space for display on screen
|
||||
col.rgb = pow(col.rgb, vec3(1.0/2.2));
|
||||
|
||||
frag_color.rgb = col.rgb;
|
||||
|
|
|
|||
|
|
@ -127,9 +127,9 @@ void main()
|
|||
bool light_contrib = (i < light_count);
|
||||
|
||||
vec3 lv = light[i].xyz-pos;
|
||||
float dist2 = dot(lv,lv);
|
||||
dist2 /= light[i].w;
|
||||
if (dist2 > 1.0)
|
||||
float dist = length(lv);
|
||||
dist /= light[i].w;
|
||||
if (dist > 1.0)
|
||||
{
|
||||
light_contrib = false;
|
||||
}
|
||||
|
|
@ -146,10 +146,10 @@ void main()
|
|||
da = dot(norm, lv);
|
||||
|
||||
float fa = light_col[i].a+1.0;
|
||||
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
dist_atten *= dist_atten;
|
||||
dist_atten *= 2.0;
|
||||
|
||||
dist_atten = pow(dist_atten, 2.2) * 2.2;
|
||||
|
||||
dist_atten *= noise;
|
||||
|
||||
float lit = da * dist_atten;
|
||||
|
|
|
|||
|
|
@ -177,9 +177,9 @@ void main()
|
|||
|
||||
vec3 pos = getPosition(frag.xy).xyz;
|
||||
vec3 lv = center.xyz-pos.xyz;
|
||||
float dist2 = dot(lv,lv);
|
||||
dist2 /= size;
|
||||
if (dist2 > 1.0)
|
||||
float dist = length(lv);
|
||||
dist /= size;
|
||||
if (dist > 1.0)
|
||||
{
|
||||
discard;
|
||||
}
|
||||
|
|
@ -201,8 +201,10 @@ void main()
|
|||
proj_tc.xyz /= proj_tc.w;
|
||||
|
||||
float fa = falloff+1.0;
|
||||
float dist_atten = min(1.0-(dist2-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten = pow(dist_atten, 2.2) * 2.2;
|
||||
float dist_atten = min(1.0-(dist-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten *= dist_atten;
|
||||
dist_atten *= 2.0;
|
||||
|
||||
if (dist_atten <= 0.0)
|
||||
{
|
||||
discard;
|
||||
|
|
|
|||
|
|
@ -110,9 +110,9 @@ void main()
|
|||
|
||||
vec3 pos = getPosition(frag.xy).xyz;
|
||||
vec3 lv = trans_center.xyz-pos;
|
||||
float dist2 = dot(lv,lv);
|
||||
dist2 /= size;
|
||||
if (dist2 > 1.0)
|
||||
float dist = length(lv);
|
||||
dist /= size;
|
||||
if (dist > 1.0)
|
||||
{
|
||||
discard;
|
||||
}
|
||||
|
|
@ -133,8 +133,10 @@ void main()
|
|||
|
||||
vec3 col = texture2DRect(diffuseRect, frag.xy).rgb;
|
||||
float fa = falloff+1.0;
|
||||
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
dist_atten = pow(dist_atten, 2.2) * 2.2;
|
||||
float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
|
||||
dist_atten *= dist_atten;
|
||||
dist_atten *= 2.0;
|
||||
|
||||
float lit = da * dist_atten * noise;
|
||||
|
||||
col = color.rgb*lit*col;
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ VARYING vec3 trans_center;
|
|||
void main()
|
||||
{
|
||||
//transform vertex
|
||||
vec3 p = position*sqrt(size)+center;
|
||||
vec3 p = position*size+center;
|
||||
vec4 pos = modelview_projection_matrix * vec4(p.xyz, 1.0);
|
||||
vary_fragcoord = pos;
|
||||
trans_center = (modelview_matrix*vec4(center.xyz, 1.0)).xyz;
|
||||
|
|
|
|||
|
|
@ -248,9 +248,9 @@ void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
|
|||
+ tmpAmbient)));
|
||||
|
||||
//brightness of surface both sunlight and ambient
|
||||
setSunlitColor(pow(vec3(sunlight * .5), vec3(global_gamma)) * global_gamma);
|
||||
setAmblitColor(pow(vec3(tmpAmbient * .25), vec3(global_gamma)) * global_gamma);
|
||||
setAdditiveColor(pow(getAdditiveColor() * vec3(1.0 - temp1), vec3(global_gamma)) * global_gamma);
|
||||
setSunlitColor(vec3(sunlight * .5));
|
||||
setAmblitColor(vec3(tmpAmbient * .25));
|
||||
setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
|
||||
}
|
||||
|
||||
vec3 atmosLighting(vec3 light)
|
||||
|
|
@ -325,8 +325,13 @@ void main()
|
|||
norm.xyz = decode_normal(norm.xy); // unpack norm
|
||||
|
||||
float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
|
||||
da = pow(da, 1.0/1.3);
|
||||
|
||||
vec4 diffuse = texture2DRect(diffuseRect, tc);
|
||||
|
||||
//convert to gamma space
|
||||
diffuse.rgb = pow(diffuse.rgb, vec3(1.0/2.2));
|
||||
|
||||
vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
|
||||
vec3 col;
|
||||
float bloom = 0.0;
|
||||
|
|
@ -341,7 +346,7 @@ void main()
|
|||
|
||||
col.rgb *= ambient;
|
||||
|
||||
col += atmosAffectDirectionalLight(max(min(da, 1.0) * 2.6, 0.0));
|
||||
col += atmosAffectDirectionalLight(max(min(da, 1.0), 0.0));
|
||||
|
||||
col *= diffuse.rgb;
|
||||
|
||||
|
|
@ -362,23 +367,18 @@ void main()
|
|||
}
|
||||
|
||||
|
||||
col = mix(col.rgb, pow(diffuse.rgb, vec3(1.0/2.2)), diffuse.a);
|
||||
|
||||
|
||||
col = mix(col.rgb, diffuse.rgb, diffuse.a);
|
||||
|
||||
if (envIntensity > 0.0)
|
||||
{ //add environmentmap
|
||||
vec3 env_vec = env_mat * refnormpersp;
|
||||
|
||||
float exponent = mix(2.2, 1.0, diffuse.a);
|
||||
vec3 refcol = pow(textureCube(environmentMap, env_vec).rgb, vec3(exponent))*exponent;
|
||||
|
||||
vec3 refcol = textureCube(environmentMap, env_vec).rgb;
|
||||
|
||||
col = mix(col.rgb, refcol,
|
||||
envIntensity);
|
||||
|
||||
}
|
||||
|
||||
float exponent = mix(1.0, 2.2, diffuse.a);
|
||||
col = pow(col, vec3(exponent));
|
||||
|
||||
if (norm.w < 0.5)
|
||||
{
|
||||
|
|
@ -386,10 +386,12 @@ void main()
|
|||
col = mix(scaleSoftClip(col), fullbrightScaleSoftClip(col), diffuse.a);
|
||||
}
|
||||
|
||||
col = pow(col, vec3(2.2));
|
||||
|
||||
//col = vec3(1,0,1);
|
||||
//col.g = envIntensity;
|
||||
}
|
||||
|
||||
|
||||
frag_color.rgb = col;
|
||||
|
||||
frag_color.a = bloom;
|
||||
|
|
|
|||
|
|
@ -175,9 +175,9 @@ void main()
|
|||
|
||||
vec3 pos = getPosition(frag.xy).xyz;
|
||||
vec3 lv = trans_center.xyz-pos.xyz;
|
||||
float dist2 = dot(lv,lv);
|
||||
dist2 /= size;
|
||||
if (dist2 > 1.0)
|
||||
float dist = length(lv);
|
||||
dist /= size;
|
||||
if (dist > 1.0)
|
||||
{
|
||||
discard;
|
||||
}
|
||||
|
|
@ -199,8 +199,10 @@ void main()
|
|||
proj_tc.xyz /= proj_tc.w;
|
||||
|
||||
float fa = falloff+1.0;
|
||||
float dist_atten = min(1.0-(dist2-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten = pow(dist_atten, 2.2) * 2.2;
|
||||
float dist_atten = min(1.0-(dist-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten *= dist_atten;
|
||||
dist_atten *= 2.0;
|
||||
|
||||
if (dist_atten <= 0.0)
|
||||
{
|
||||
discard;
|
||||
|
|
@ -279,10 +281,7 @@ void main()
|
|||
//col += spec.rgb;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if (envIntensity > 0.0)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -0,0 +1,67 @@
|
|||
/**
|
||||
* @file debugF.glsl
|
||||
*
|
||||
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
|
||||
* Second Life Viewer Source Code
|
||||
* Copyright (C) 2011, Linden Research, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation;
|
||||
* version 2.1 of the License only.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
||||
* $/LicenseInfo$
|
||||
*/
|
||||
|
||||
#ifdef DEFINE_GL_FRAGCOLOR
|
||||
out vec4 frag_color;
|
||||
#else
|
||||
#define frag_color gl_FragColor
|
||||
#endif
|
||||
|
||||
uniform sampler2D depthMap;
|
||||
|
||||
uniform float delta;
|
||||
|
||||
VARYING vec2 tc0;
|
||||
VARYING vec2 tc1;
|
||||
VARYING vec2 tc2;
|
||||
VARYING vec2 tc3;
|
||||
VARYING vec2 tc4;
|
||||
VARYING vec2 tc5;
|
||||
VARYING vec2 tc6;
|
||||
VARYING vec2 tc7;
|
||||
VARYING vec2 tc8;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec4 depth1 =
|
||||
vec4(texture2D(depthMap, tc0).r,
|
||||
texture2D(depthMap, tc1).r,
|
||||
texture2D(depthMap, tc2).r,
|
||||
texture2D(depthMap, tc3).r);
|
||||
|
||||
vec4 depth2 =
|
||||
vec4(texture2D(depthMap, tc4).r,
|
||||
texture2D(depthMap, tc5).r,
|
||||
texture2D(depthMap, tc6).r,
|
||||
texture2D(depthMap, tc7).r);
|
||||
|
||||
depth1 = min(depth1, depth2);
|
||||
float depth = min(depth1.x, depth1.y);
|
||||
depth = min(depth, depth1.z);
|
||||
depth = min(depth, depth1.w);
|
||||
depth = min(depth, texture2D(depthMap, tc8).r);
|
||||
|
||||
gl_FragDepth = depth;
|
||||
}
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
/**
|
||||
* @file debugF.glsl
|
||||
*
|
||||
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
|
||||
* Second Life Viewer Source Code
|
||||
* Copyright (C) 2011, Linden Research, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation;
|
||||
* version 2.1 of the License only.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
||||
* $/LicenseInfo$
|
||||
*/
|
||||
|
||||
#extension GL_ARB_texture_rectangle : enable
|
||||
|
||||
#ifdef DEFINE_GL_FRAGCOLOR
|
||||
out vec4 frag_color;
|
||||
#else
|
||||
#define frag_color gl_FragColor
|
||||
#endif
|
||||
|
||||
uniform sampler2DRect depthMap;
|
||||
|
||||
uniform float delta;
|
||||
|
||||
VARYING vec2 tc0;
|
||||
VARYING vec2 tc1;
|
||||
VARYING vec2 tc2;
|
||||
VARYING vec2 tc3;
|
||||
VARYING vec2 tc4;
|
||||
VARYING vec2 tc5;
|
||||
VARYING vec2 tc6;
|
||||
VARYING vec2 tc7;
|
||||
VARYING vec2 tc8;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec4 depth1 =
|
||||
vec4(texture2DRect(depthMap, tc0).r,
|
||||
texture2DRect(depthMap, tc1).r,
|
||||
texture2DRect(depthMap, tc2).r,
|
||||
texture2DRect(depthMap, tc3).r);
|
||||
|
||||
vec4 depth2 =
|
||||
vec4(texture2DRect(depthMap, tc4).r,
|
||||
texture2DRect(depthMap, tc5).r,
|
||||
texture2DRect(depthMap, tc6).r,
|
||||
texture2DRect(depthMap, tc7).r);
|
||||
|
||||
depth1 = min(depth1, depth2);
|
||||
float depth = min(depth1.x, depth1.y);
|
||||
depth = min(depth, depth1.z);
|
||||
depth = min(depth, depth1.w);
|
||||
depth = min(depth, texture2DRect(depthMap, tc8).r);
|
||||
|
||||
gl_FragDepth = depth;
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
/**
|
||||
* @file debugV.glsl
|
||||
*
|
||||
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
|
||||
* Second Life Viewer Source Code
|
||||
* Copyright (C) 2011, Linden Research, Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation;
|
||||
* version 2.1 of the License only.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*
|
||||
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
||||
* $/LicenseInfo$
|
||||
*/
|
||||
|
||||
uniform mat4 modelview_projection_matrix;
|
||||
|
||||
ATTRIBUTE vec3 position;
|
||||
|
||||
uniform vec2 screen_res;
|
||||
|
||||
uniform vec2 delta;
|
||||
|
||||
VARYING vec2 tc0;
|
||||
VARYING vec2 tc1;
|
||||
VARYING vec2 tc2;
|
||||
VARYING vec2 tc3;
|
||||
VARYING vec2 tc4;
|
||||
VARYING vec2 tc5;
|
||||
VARYING vec2 tc6;
|
||||
VARYING vec2 tc7;
|
||||
VARYING vec2 tc8;
|
||||
|
||||
void main()
|
||||
{
|
||||
gl_Position = vec4(position, 1.0);
|
||||
|
||||
vec2 tc = (position.xy*0.5+0.5)*screen_res;
|
||||
tc0 = tc+vec2(-delta.x,-delta.y);
|
||||
tc1 = tc+vec2(0,-delta.y);
|
||||
tc2 = tc+vec2(delta.x,-delta.y);
|
||||
tc3 = tc+vec2(-delta.x,0);
|
||||
tc4 = tc+vec2(0,0);
|
||||
tc5 = tc+vec2(delta.x,0);
|
||||
tc6 = tc+vec2(-delta.x,delta.y);
|
||||
tc7 = tc+vec2(0,delta.y);
|
||||
tc8 = tc+vec2(delta.x,delta.y);
|
||||
}
|
||||
|
||||
|
|
@ -179,9 +179,9 @@ void main()
|
|||
|
||||
vec3 pos = getPosition(frag.xy).xyz;
|
||||
vec3 lv = center.xyz-pos.xyz;
|
||||
float dist2 = dot(lv,lv);
|
||||
dist2 /= size;
|
||||
if (dist2 > 1.0)
|
||||
float dist = length(lv);
|
||||
dist /= size;
|
||||
if (dist > 1.0)
|
||||
{
|
||||
discard;
|
||||
}
|
||||
|
|
@ -215,8 +215,9 @@ void main()
|
|||
proj_tc.xyz /= proj_tc.w;
|
||||
|
||||
float fa = falloff+1.0;
|
||||
float dist_atten = min(1.0-(dist2-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten = pow(dist_atten, 2.2) * 2.2;
|
||||
float dist_atten = min(1.0-(dist-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten *= dist_atten;
|
||||
dist_atten *= 2.0;
|
||||
if (dist_atten <= 0.0)
|
||||
{
|
||||
discard;
|
||||
|
|
|
|||
|
|
@ -254,9 +254,13 @@ void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
|
|||
+ tmpAmbient)));
|
||||
|
||||
//brightness of surface both sunlight and ambient
|
||||
setSunlitColor(pow(vec3(sunlight * .5), vec3(global_gamma)) * global_gamma);
|
||||
/*setSunlitColor(pow(vec3(sunlight * .5), vec3(global_gamma)) * global_gamma);
|
||||
setAmblitColor(pow(vec3(tmpAmbient * .25), vec3(global_gamma)) * global_gamma);
|
||||
setAdditiveColor(pow(getAdditiveColor() * vec3(1.0 - temp1), vec3(global_gamma)) * global_gamma);
|
||||
setAdditiveColor(pow(getAdditiveColor() * vec3(1.0 - temp1), vec3(global_gamma)) * global_gamma);*/
|
||||
|
||||
setSunlitColor(vec3(sunlight * .5));
|
||||
setAmblitColor(vec3(tmpAmbient * .25));
|
||||
setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
|
||||
}
|
||||
|
||||
vec3 atmosLighting(vec3 light)
|
||||
|
|
@ -332,7 +336,14 @@ void main()
|
|||
|
||||
float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
|
||||
|
||||
float light_gamma = 1.0/1.3;
|
||||
da = pow(da, light_gamma);
|
||||
|
||||
|
||||
vec4 diffuse = texture2DRect(diffuseRect, tc);
|
||||
|
||||
//convert to gamma space
|
||||
diffuse.rgb = pow(diffuse.rgb, vec3(1.0/2.2));
|
||||
|
||||
vec3 col;
|
||||
float bloom = 0.0;
|
||||
|
|
@ -340,7 +351,12 @@ void main()
|
|||
vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
|
||||
|
||||
vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
|
||||
scol_ambocc = pow(scol_ambocc, vec2(light_gamma));
|
||||
|
||||
float scol = max(scol_ambocc.r, diffuse.a);
|
||||
|
||||
|
||||
|
||||
float ambocc = scol_ambocc.g;
|
||||
|
||||
calcAtmospherics(pos.xyz, ambocc);
|
||||
|
|
@ -353,7 +369,7 @@ void main()
|
|||
|
||||
col.rgb *= ambient;
|
||||
|
||||
col += atmosAffectDirectionalLight(max(min(da, scol) * 2.6, 0.0));
|
||||
col += atmosAffectDirectionalLight(max(min(da, scol), 0.0));
|
||||
|
||||
col *= diffuse.rgb;
|
||||
|
||||
|
|
@ -374,30 +390,27 @@ void main()
|
|||
}
|
||||
|
||||
|
||||
col = mix(col.rgb, pow(diffuse.rgb, vec3(1.0/2.2)), diffuse.a);
|
||||
|
||||
|
||||
col = mix(col, diffuse.rgb, diffuse.a);
|
||||
|
||||
if (envIntensity > 0.0)
|
||||
{ //add environmentmap
|
||||
vec3 env_vec = env_mat * refnormpersp;
|
||||
|
||||
float exponent = mix(2.2, 1.0, diffuse.a);
|
||||
vec3 refcol = pow(textureCube(environmentMap, env_vec).rgb, vec3(exponent))*exponent;
|
||||
vec3 refcol = textureCube(environmentMap, env_vec).rgb;
|
||||
|
||||
col = mix(col.rgb, refcol,
|
||||
envIntensity);
|
||||
|
||||
}
|
||||
|
||||
float exponent = mix(1.0, 2.2, diffuse.a);
|
||||
col = pow(col, vec3(exponent));
|
||||
|
||||
|
||||
if (norm.w < 0.5)
|
||||
{
|
||||
col = mix(atmosLighting(col), fullbrightAtmosTransport(col), diffuse.a);
|
||||
col = mix(scaleSoftClip(col), fullbrightScaleSoftClip(col), diffuse.a);
|
||||
}
|
||||
|
||||
col = pow(col, vec3(2.2));
|
||||
|
||||
//col = vec3(1,0,1);
|
||||
//col.g = envIntensity;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -178,9 +178,9 @@ void main()
|
|||
|
||||
vec3 pos = getPosition(frag.xy).xyz;
|
||||
vec3 lv = trans_center.xyz-pos.xyz;
|
||||
float dist2 = dot(lv,lv);
|
||||
dist2 /= size;
|
||||
if (dist2 > 1.0)
|
||||
float dist = length(lv);
|
||||
dist /= size;
|
||||
if (dist > 1.0)
|
||||
{
|
||||
discard;
|
||||
}
|
||||
|
|
@ -212,8 +212,10 @@ void main()
|
|||
proj_tc.xyz /= proj_tc.w;
|
||||
|
||||
float fa = falloff+1.0;
|
||||
float dist_atten = min(1.0-(dist2-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten = pow(dist_atten, 2.2) * 2.2;
|
||||
float dist_atten = min(1.0-(dist-1.0*(1.0-fa))/fa, 1.0);
|
||||
dist_atten *= dist_atten;
|
||||
dist_atten *= 2.0;
|
||||
|
||||
if (dist_atten <= 0.0)
|
||||
{
|
||||
discard;
|
||||
|
|
|
|||
|
|
@ -54,7 +54,6 @@ uniform float density_multiplier;
|
|||
uniform float distance_multiplier;
|
||||
uniform float max_y;
|
||||
uniform vec4 glow;
|
||||
uniform float global_gamma;
|
||||
|
||||
void calcAtmospherics(vec3 inPositionEye) {
|
||||
|
||||
|
|
@ -132,9 +131,9 @@ void calcAtmospherics(vec3 inPositionEye) {
|
|||
+ tmpAmbient)));
|
||||
|
||||
//brightness of surface both sunlight and ambient
|
||||
setSunlitColor(pow(vec3(sunlight * .5), vec3(global_gamma)) * global_gamma);
|
||||
setAmblitColor(pow(vec3(tmpAmbient * .25), vec3(global_gamma)) * global_gamma);
|
||||
setAdditiveColor(pow(getAdditiveColor() * vec3(1.0 - temp1), vec3(global_gamma)) * global_gamma);
|
||||
setSunlitColor(vec3(sunlight * .5));
|
||||
setAmblitColor(vec3(tmpAmbient * .25));
|
||||
setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
|
||||
|
||||
// vary_SunlitColor = vec3(0);
|
||||
// vary_AmblitColor = vec3(0);
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
|
||||
/**
|
||||
* @file llmeshrepository.cpp
|
||||
* @brief Mesh repository implementation.
|
||||
|
|
|
|||
|
|
@ -1500,6 +1500,8 @@ BOOL LLSpatialGroup::rebound()
|
|||
if (mOctreeNode->getChildCount() == 1 && mOctreeNode->getElementCount() == 0)
|
||||
{
|
||||
LLSpatialGroup* group = (LLSpatialGroup*) mOctreeNode->getChild(0)->getListener(0);
|
||||
|
||||
//rebound single child
|
||||
group->rebound();
|
||||
|
||||
//copy single child's bounding box
|
||||
|
|
@ -1508,10 +1510,11 @@ BOOL LLSpatialGroup::rebound()
|
|||
mExtents[0] = group->mExtents[0];
|
||||
mExtents[1] = group->mExtents[1];
|
||||
|
||||
//treat this node as a "chute" to a deeper level of the tree
|
||||
group->setState(SKIP_FRUSTUM_CHECK);
|
||||
}
|
||||
else if (mOctreeNode->isLeaf())
|
||||
{ //copy object bounding box if this is a leaf
|
||||
{ //copy object bounding box if this is a leaf
|
||||
boundObjects(TRUE, mExtents[0], mExtents[1]);
|
||||
mBounds[0] = mObjectBounds[0];
|
||||
mBounds[1] = mObjectBounds[1];
|
||||
|
|
@ -1520,14 +1523,17 @@ BOOL LLSpatialGroup::rebound()
|
|||
{
|
||||
LLVector4a& newMin = mExtents[0];
|
||||
LLVector4a& newMax = mExtents[1];
|
||||
|
||||
//get bounding box of first child
|
||||
LLSpatialGroup* group = (LLSpatialGroup*) mOctreeNode->getChild(0)->getListener(0);
|
||||
group->clearState(SKIP_FRUSTUM_CHECK);
|
||||
group->rebound();
|
||||
|
||||
//initialize to first child
|
||||
newMin = group->mExtents[0];
|
||||
newMax = group->mExtents[1];
|
||||
|
||||
//first, rebound children
|
||||
//rebound remaining children, expanding bounding box to encompass children
|
||||
for (U32 i = 1; i < mOctreeNode->getChildCount(); i++)
|
||||
{
|
||||
group = (LLSpatialGroup*) mOctreeNode->getChild(i)->getListener(0);
|
||||
|
|
@ -2520,7 +2526,7 @@ void pushBufferVerts(LLVertexBuffer* buffer, U32 mask)
|
|||
}
|
||||
}
|
||||
|
||||
void pushBufferVerts(LLSpatialGroup* group, U32 mask)
|
||||
void pushBufferVerts(LLSpatialGroup* group, U32 mask, bool push_alpha = true)
|
||||
{
|
||||
if (group->mSpatialPartition->mRenderByGroup)
|
||||
{
|
||||
|
|
@ -2529,7 +2535,10 @@ void pushBufferVerts(LLSpatialGroup* group, U32 mask)
|
|||
LLDrawInfo* params = *(group->mDrawMap.begin()->second.begin());
|
||||
LLRenderPass::applyModelMatrix(*params);
|
||||
|
||||
pushBufferVerts(group->mVertexBuffer, mask);
|
||||
if (push_alpha)
|
||||
{
|
||||
pushBufferVerts(group->mVertexBuffer, mask);
|
||||
}
|
||||
|
||||
for (LLSpatialGroup::buffer_map_t::iterator i = group->mBufferMap.begin(); i != group->mBufferMap.end(); ++i)
|
||||
{
|
||||
|
|
@ -2543,10 +2552,10 @@ void pushBufferVerts(LLSpatialGroup* group, U32 mask)
|
|||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
/*else
|
||||
{
|
||||
drawBox(group->mBounds[0], group->mBounds[1]);
|
||||
}
|
||||
//drawBox(group->mBounds[0], group->mBounds[1]);
|
||||
}*/
|
||||
}
|
||||
|
||||
void pushVertsColorCoded(LLSpatialGroup* group, U32 mask)
|
||||
|
|
@ -2719,17 +2728,53 @@ void renderOctree(LLSpatialGroup* group)
|
|||
// drawBoxOutline(LLVector3(node->getCenter()), LLVector3(node->getSize()));
|
||||
}
|
||||
|
||||
std::set<LLSpatialGroup*> visible_selected_groups;
|
||||
|
||||
void renderVisibility(LLSpatialGroup* group, LLCamera* camera)
|
||||
{
|
||||
LLGLEnable blend(GL_BLEND);
|
||||
/*LLGLEnable blend(GL_BLEND);
|
||||
gGL.setSceneBlendType(LLRender::BT_ALPHA);
|
||||
LLGLEnable cull(GL_CULL_FACE);
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);*/
|
||||
|
||||
BOOL render_objects = (!LLPipeline::sUseOcclusion || !group->isOcclusionState(LLSpatialGroup::OCCLUDED)) && group->isVisible() &&
|
||||
/*BOOL render_objects = (!LLPipeline::sUseOcclusion || !group->isOcclusionState(LLSpatialGroup::OCCLUDED)) && group->isVisible() &&
|
||||
!group->isEmpty();
|
||||
|
||||
|
||||
if (render_objects)
|
||||
{
|
||||
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
|
||||
|
||||
LLGLDisable blend(GL_BLEND);
|
||||
gGL.diffuseColor4f(0.f, 0.75f, 0.f,0.5f);
|
||||
pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX, false);
|
||||
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
||||
glLineWidth(4.f);
|
||||
gGL.diffuseColor4f(0.f, 0.5f, 0.f, 1.f);
|
||||
pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX, false);
|
||||
glLineWidth(1.f);
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
||||
|
||||
bool selected = false;
|
||||
|
||||
for (LLSpatialGroup::element_iter iter = group->getDataBegin(); iter != group->getDataEnd(); ++iter)
|
||||
{
|
||||
LLDrawable* drawable = *iter;
|
||||
if (drawable->getVObj().notNull() && drawable->getVObj()->isSelected())
|
||||
{
|
||||
selected = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (selected)
|
||||
{ //store for rendering occlusion volume as overlay
|
||||
visible_selected_groups.insert(group);
|
||||
}
|
||||
}*/
|
||||
|
||||
/*if (render_objects)
|
||||
{
|
||||
LLGLDepthTest depth_under(GL_TRUE, GL_FALSE, GL_GREATER);
|
||||
gGL.diffuseColor4f(0, 0.5f, 0, 0.5f);
|
||||
|
|
@ -2754,6 +2799,59 @@ void renderVisibility(LLSpatialGroup* group, LLCamera* camera)
|
|||
gGL.diffuseColor4f(0.f, 0.75f, 0.f,0.5f);
|
||||
gGL.diffuseColor4f(0.f, 0.75f, 0.f, 0.5f);
|
||||
pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX);
|
||||
|
||||
bool selected = false;
|
||||
|
||||
for (LLSpatialGroup::element_iter iter = group->getDataBegin(); iter != group->getDataEnd(); ++iter)
|
||||
{
|
||||
LLDrawable* drawable = *iter;
|
||||
if (drawable->getVObj().notNull() && drawable->getVObj()->isSelected())
|
||||
{
|
||||
selected = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (selected)
|
||||
{ //store for rendering occlusion volume as overlay
|
||||
visible_selected_groups.insert(group);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
}
|
||||
|
||||
void renderXRay(LLSpatialGroup* group, LLCamera* camera)
|
||||
{
|
||||
BOOL render_objects = (!LLPipeline::sUseOcclusion || !group->isOcclusionState(LLSpatialGroup::OCCLUDED)) && group->isVisible() &&
|
||||
!group->isEmpty();
|
||||
|
||||
if (render_objects)
|
||||
{
|
||||
pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX, false);
|
||||
|
||||
bool selected = false;
|
||||
|
||||
for (LLSpatialGroup::element_iter iter = group->getDataBegin(); iter != group->getDataEnd(); ++iter)
|
||||
{
|
||||
LLDrawable* drawable = *iter;
|
||||
if (drawable->getVObj().notNull() && drawable->getVObj()->isSelected())
|
||||
{
|
||||
selected = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (selected)
|
||||
{ //store for rendering occlusion volume as overlay
|
||||
|
||||
if (!group->mSpatialPartition->isBridge())
|
||||
{
|
||||
visible_selected_groups.insert(group);
|
||||
}
|
||||
else
|
||||
{
|
||||
visible_selected_groups.insert(group->mSpatialPartition->asBridge()->getSpatialGroup());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -4247,6 +4345,48 @@ public:
|
|||
}
|
||||
};
|
||||
|
||||
class LLOctreeRenderXRay : public LLOctreeTraveler<LLDrawable>
|
||||
{
|
||||
public:
|
||||
LLCamera* mCamera;
|
||||
LLOctreeRenderXRay(LLCamera* camera): mCamera(camera) {}
|
||||
|
||||
virtual void traverse(const LLSpatialGroup::OctreeNode* node)
|
||||
{
|
||||
LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
|
||||
|
||||
if (!mCamera || mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1]))
|
||||
{
|
||||
node->accept(this);
|
||||
stop_glerror();
|
||||
|
||||
for (U32 i = 0; i < node->getChildCount(); i++)
|
||||
{
|
||||
traverse(node->getChild(i));
|
||||
stop_glerror();
|
||||
}
|
||||
|
||||
//render visibility wireframe
|
||||
if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCCLUSION))
|
||||
{
|
||||
group->rebuildGeom();
|
||||
group->rebuildMesh();
|
||||
|
||||
gGL.flush();
|
||||
gGL.pushMatrix();
|
||||
gGLLastMatrix = NULL;
|
||||
gGL.loadMatrix(gGLModelView);
|
||||
renderXRay(group, mCamera);
|
||||
stop_glerror();
|
||||
gGLLastMatrix = NULL;
|
||||
gGL.popMatrix();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
virtual void visit(const LLSpatialGroup::OctreeNode* node) {}
|
||||
|
||||
};
|
||||
|
||||
class LLOctreeRenderPhysicsShapes : public LLOctreeTraveler<LLDrawable>
|
||||
{
|
||||
|
|
@ -4474,6 +4614,26 @@ void LLSpatialPartition::renderDebug()
|
|||
LLOctreeRenderNonOccluded render_debug(camera);
|
||||
render_debug.traverse(mOctree);
|
||||
|
||||
|
||||
if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCCLUSION))
|
||||
{
|
||||
{
|
||||
LLGLEnable cull(GL_CULL_FACE);
|
||||
|
||||
LLGLEnable blend(GL_BLEND);
|
||||
LLGLDepthTest depth_under(GL_TRUE, GL_FALSE, GL_GREATER);
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
||||
gGL.diffuseColor4f(0.5f, 0.0f, 0, 0.25f);
|
||||
|
||||
LLGLEnable offset(GL_POLYGON_OFFSET_LINE);
|
||||
glPolygonOffset(-1.f, -1.f);
|
||||
|
||||
LLOctreeRenderXRay xray(camera);
|
||||
xray.traverse(mOctree);
|
||||
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
||||
}
|
||||
}
|
||||
if (LLGLSLShader::sNoFixedFunction)
|
||||
{
|
||||
gDebugProgram.unbind();
|
||||
|
|
|
|||
|
|
@ -673,6 +673,7 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
|
|||
|
||||
static LLCullResult result;
|
||||
LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD;
|
||||
LLPipeline::sUnderWaterRender = LLViewerCamera::getInstance()->cameraUnderWater() ? TRUE : FALSE;
|
||||
gPipeline.updateCull(*LLViewerCamera::getInstance(), result, water_clip);
|
||||
stop_glerror();
|
||||
|
||||
|
|
@ -879,7 +880,7 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
|
|||
//}
|
||||
|
||||
LLPipeline::sUnderWaterRender = LLViewerCamera::getInstance()->cameraUnderWater() ? TRUE : FALSE;
|
||||
|
||||
|
||||
LLGLState::checkStates();
|
||||
LLGLState::checkClientArrays();
|
||||
|
||||
|
|
|
|||
|
|
@ -100,6 +100,8 @@ LLGLSLShader gTwoTextureAddProgram;
|
|||
LLGLSLShader gOneTextureNoColorProgram;
|
||||
LLGLSLShader gDebugProgram;
|
||||
LLGLSLShader gClipProgram;
|
||||
LLGLSLShader gDownsampleDepthProgram;
|
||||
LLGLSLShader gDownsampleDepthRectProgram;
|
||||
LLGLSLShader gAlphaMaskProgram;
|
||||
|
||||
//object shaders
|
||||
|
|
@ -668,6 +670,8 @@ void LLViewerShaderMgr::unloadShaders()
|
|||
gOcclusionCubeProgram.unload();
|
||||
gDebugProgram.unload();
|
||||
gClipProgram.unload();
|
||||
gDownsampleDepthProgram.unload();
|
||||
gDownsampleDepthRectProgram.unload();
|
||||
gAlphaMaskProgram.unload();
|
||||
gUIProgram.unload();
|
||||
gPathfindingProgram.unload();
|
||||
|
|
@ -2966,6 +2970,26 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
|
|||
success = gClipProgram.createShader(NULL, NULL);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDownsampleDepthProgram.mName = "DownsampleDepth Shader";
|
||||
gDownsampleDepthProgram.mShaderFiles.clear();
|
||||
gDownsampleDepthProgram.mShaderFiles.push_back(make_pair("interface/downsampleDepthV.glsl", GL_VERTEX_SHADER_ARB));
|
||||
gDownsampleDepthProgram.mShaderFiles.push_back(make_pair("interface/downsampleDepthF.glsl", GL_FRAGMENT_SHADER_ARB));
|
||||
gDownsampleDepthProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
|
||||
success = gDownsampleDepthProgram.createShader(NULL, NULL);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDownsampleDepthRectProgram.mName = "DownsampleDepthRect Shader";
|
||||
gDownsampleDepthRectProgram.mShaderFiles.clear();
|
||||
gDownsampleDepthRectProgram.mShaderFiles.push_back(make_pair("interface/downsampleDepthV.glsl", GL_VERTEX_SHADER_ARB));
|
||||
gDownsampleDepthRectProgram.mShaderFiles.push_back(make_pair("interface/downsampleDepthRectF.glsl", GL_FRAGMENT_SHADER_ARB));
|
||||
gDownsampleDepthRectProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
|
||||
success = gDownsampleDepthRectProgram.createShader(NULL, NULL);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gAlphaMaskProgram.mName = "Alpha Mask Shader";
|
||||
|
|
|
|||
|
|
@ -164,6 +164,8 @@ extern LLGLSLShader gSplatTextureRectProgram;
|
|||
extern LLGLSLShader gGlowCombineFXAAProgram;
|
||||
extern LLGLSLShader gDebugProgram;
|
||||
extern LLGLSLShader gClipProgram;
|
||||
extern LLGLSLShader gDownsampleDepthProgram;
|
||||
extern LLGLSLShader gDownsampleDepthRectProgram;
|
||||
|
||||
//output tex0[tc0] + tex1[tc1]
|
||||
extern LLGLSLShader gTwoTextureAddProgram;
|
||||
|
|
@ -256,6 +258,7 @@ extern LLGLSLShader gWLCloudProgram;
|
|||
extern LLGLSLShader gPostColorFilterProgram;
|
||||
extern LLGLSLShader gPostNightVisionProgram;
|
||||
|
||||
|
||||
// Deferred rendering shaders
|
||||
extern LLGLSLShader gDeferredImpostorProgram;
|
||||
extern LLGLSLShader gDeferredWaterProgram;
|
||||
|
|
@ -303,7 +306,6 @@ extern LLGLSLShader gDeferredSkinnedFullbrightShinyProgram;
|
|||
extern LLGLSLShader gDeferredSkinnedFullbrightProgram;
|
||||
extern LLGLSLShader gNormalMapGenProgram;
|
||||
|
||||
|
||||
// Deferred materials shaders
|
||||
extern LLGLSLShader gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
|
||||
|
||||
|
|
|
|||
|
|
@ -3546,7 +3546,12 @@ F32 LLVOVolume::getBinRadius()
|
|||
}
|
||||
else if (mDrawable->isStatic())
|
||||
{
|
||||
radius = llmax((S32) mDrawable->getRadius(), 1)*size_factor;
|
||||
F32 szf = size_factor;
|
||||
|
||||
radius = llmax(mDrawable->getRadius(), szf);
|
||||
|
||||
radius = powf(radius, 1.f+szf/radius);
|
||||
|
||||
radius *= 1.f + mDrawable->mDistanceWRTCamera * distance_factor[1];
|
||||
radius += mDrawable->mDistanceWRTCamera * distance_factor[0];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -291,7 +291,7 @@ std::string gPoolNames[] =
|
|||
"POOL_ALPHA"
|
||||
};
|
||||
|
||||
void drawBox(const LLVector3& c, const LLVector3& r);
|
||||
void drawBox(const LLVector4a& c, const LLVector4a& r);
|
||||
void drawBoxOutline(const LLVector3& pos, const LLVector3& size);
|
||||
U32 nhpo2(U32 v);
|
||||
LLVertexBuffer* ll_create_cube_vb(U32 type_mask, U32 usage);
|
||||
|
|
@ -942,9 +942,12 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
|
|||
S32 shadow_detail = RenderShadowDetail;
|
||||
BOOL ssao = RenderDeferredSSAO;
|
||||
|
||||
const U32 occlusion_divisor = 3;
|
||||
|
||||
//allocate deferred rendering color buffers
|
||||
if (!mDeferredScreen.allocate(resX, resY, GL_SRGB8_ALPHA8, TRUE, TRUE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
|
||||
if (!mDeferredDepth.allocate(resX, resY, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
|
||||
if (!mOcclusionDepth.allocate(resX/occlusion_divisor, resY/occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
|
||||
if (!addDeferredAttachments(mDeferredScreen)) return false;
|
||||
|
||||
GLuint screenFormat = GL_RGBA16;
|
||||
|
|
@ -985,6 +988,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
|
|||
for (U32 i = 0; i < 4; i++)
|
||||
{
|
||||
if (!mShadow[i].allocate(sun_shadow_map_width,U32(resY*scale), 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE)) return false;
|
||||
if (!mShadowOcclusion[i].allocate(mShadow[i].getWidth()/occlusion_divisor, mShadow[i].getHeight()/occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE)) return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -992,6 +996,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
|
|||
for (U32 i = 0; i < 4; i++)
|
||||
{
|
||||
mShadow[i].release();
|
||||
mShadowOcclusion[i].release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1004,6 +1009,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
|
|||
for (U32 i = 4; i < 6; i++)
|
||||
{
|
||||
if (!mShadow[i].allocate(spot_shadow_map_width, height, 0, TRUE, FALSE)) return false;
|
||||
if (!mShadowOcclusion[i].allocate(mShadow[i].getWidth()/occlusion_divisor, mShadow[i].getHeight()/occlusion_divisor, 0, TRUE, FALSE)) return false;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -1011,6 +1017,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
|
|||
for (U32 i = 4; i < 6; i++)
|
||||
{
|
||||
mShadow[i].release();
|
||||
mShadowOcclusion[i].release();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1027,11 +1034,13 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
|
|||
for (U32 i = 0; i < 6; i++)
|
||||
{
|
||||
mShadow[i].release();
|
||||
mShadowOcclusion[i].release();
|
||||
}
|
||||
mFXAABuffer.release();
|
||||
mScreen.release();
|
||||
mDeferredScreen.release(); //make sure to release any render targets that share a depth buffer with mDeferredScreen first
|
||||
mDeferredDepth.release();
|
||||
mOcclusionDepth.release();
|
||||
|
||||
if (!mScreen.allocate(resX, resY, GL_RGBA, TRUE, TRUE, LLTexUnit::TT_RECT_TEXTURE, FALSE)) return false;
|
||||
}
|
||||
|
|
@ -1410,6 +1419,8 @@ void LLPipeline::createLUTBuffers()
|
|||
//LLImageGL::setManualImage(LLTexUnit::getInternalType(LLTexUnit::TT_TEXTURE), 0, GL_UNSIGNED_BYTE, lightResX, lightResY, GL_RED, GL_UNSIGNED_BYTE, ls, false);
|
||||
gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
|
||||
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_TRILINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
|
||||
delete [] ls;
|
||||
}
|
||||
|
|
@ -2443,7 +2454,14 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_cl
|
|||
|
||||
if (to_texture)
|
||||
{
|
||||
mScreen.bindTarget();
|
||||
if (LLPipeline::sRenderDeferred && !LLPipeline::sUnderWaterRender)
|
||||
{
|
||||
mOcclusionDepth.bindTarget();
|
||||
}
|
||||
else
|
||||
{
|
||||
mScreen.bindTarget();
|
||||
}
|
||||
}
|
||||
|
||||
if (sUseOcclusion > 1)
|
||||
|
|
@ -2581,7 +2599,14 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_cl
|
|||
|
||||
if (to_texture)
|
||||
{
|
||||
mScreen.flush();
|
||||
if (LLPipeline::sRenderDeferred && !LLPipeline::sUnderWaterRender)
|
||||
{
|
||||
mOcclusionDepth.flush();
|
||||
}
|
||||
else
|
||||
{
|
||||
mScreen.flush();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2649,6 +2674,73 @@ void LLPipeline::markOccluder(LLSpatialGroup* group)
|
|||
}
|
||||
}
|
||||
|
||||
void LLPipeline::downsampleDepthBuffer(LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space)
|
||||
{
|
||||
LLGLSLShader* last_shader = LLGLSLShader::sCurBoundShaderPtr;
|
||||
|
||||
LLGLSLShader* shader = NULL;
|
||||
|
||||
if (scratch_space)
|
||||
{
|
||||
scratch_space->copyContents(source,
|
||||
0, 0, source.getWidth(), source.getHeight(),
|
||||
0, 0, scratch_space->getWidth(), scratch_space->getHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST);
|
||||
}
|
||||
|
||||
dest.bindTarget();
|
||||
dest.clear(GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
LLStrider<LLVector3> vert;
|
||||
mDeferredVB->getVertexStrider(vert);
|
||||
LLStrider<LLVector2> tc0;
|
||||
|
||||
vert[0].set(-1,1,0);
|
||||
vert[1].set(-1,-3,0);
|
||||
vert[2].set(3,1,0);
|
||||
|
||||
if (source.getUsage() == LLTexUnit::TT_RECT_TEXTURE)
|
||||
{
|
||||
shader = &gDownsampleDepthRectProgram;
|
||||
shader->bind();
|
||||
shader->uniform2f(sDelta, 1.f, 1.f);
|
||||
shader->uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, source.getWidth(), source.getHeight());
|
||||
}
|
||||
else
|
||||
{
|
||||
shader = &gDownsampleDepthProgram;
|
||||
shader->bind();
|
||||
shader->uniform2f(sDelta, 1.f/source.getWidth(), 1.f/source.getHeight());
|
||||
shader->uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, 1.f, 1.f);
|
||||
}
|
||||
|
||||
gGL.getTexUnit(0)->bind(scratch_space ? scratch_space : &source, TRUE);
|
||||
|
||||
{
|
||||
LLGLDepthTest depth(GL_TRUE, GL_TRUE, GL_ALWAYS);
|
||||
mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
|
||||
mDeferredVB->drawArrays(LLRender::TRIANGLES, 0, 3);
|
||||
}
|
||||
|
||||
dest.flush();
|
||||
|
||||
if (last_shader)
|
||||
{
|
||||
last_shader->bind();
|
||||
}
|
||||
else
|
||||
{
|
||||
shader->unbind();
|
||||
}
|
||||
}
|
||||
|
||||
void LLPipeline::doOcclusion(LLCamera& camera, LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space)
|
||||
{
|
||||
downsampleDepthBuffer(source, dest, scratch_space);
|
||||
dest.bindTarget();
|
||||
doOcclusion(camera);
|
||||
dest.flush();
|
||||
}
|
||||
|
||||
void LLPipeline::doOcclusion(LLCamera& camera)
|
||||
{
|
||||
if (LLPipeline::sUseOcclusion > 1 && sCull->hasOcclusionGroups())
|
||||
|
|
@ -4561,7 +4653,7 @@ void LLPipeline::renderGeomDeferred(LLCamera& camera)
|
|||
gGL.setColorMask(true, false);
|
||||
}
|
||||
|
||||
void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
|
||||
void LLPipeline::renderGeomPostDeferred(LLCamera& camera, bool do_occlusion)
|
||||
{
|
||||
LLFastTimer t(FTM_POST_DEFERRED_POOLS);
|
||||
U32 cur_type = 0;
|
||||
|
|
@ -4576,7 +4668,7 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
|
|||
gGL.setColorMask(true, false);
|
||||
|
||||
pool_set_t::iterator iter1 = mPools.begin();
|
||||
BOOL occlude = LLPipeline::sUseOcclusion > 1;
|
||||
BOOL occlude = LLPipeline::sUseOcclusion > 1 && do_occlusion;
|
||||
|
||||
while ( iter1 != mPools.end() )
|
||||
{
|
||||
|
|
@ -4590,7 +4682,7 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
|
|||
gGLLastMatrix = NULL;
|
||||
gGL.loadMatrix(gGLModelView);
|
||||
LLGLSLShader::bindNoShader();
|
||||
doOcclusion(camera);
|
||||
doOcclusion(camera, mScreen, mOcclusionDepth, &mDeferredDepth);
|
||||
gGL.setColorMask(true, false);
|
||||
}
|
||||
|
||||
|
|
@ -4796,6 +4888,7 @@ void LLPipeline::renderPhysicsDisplay()
|
|||
mPhysicsDisplay.flush();
|
||||
}
|
||||
|
||||
extern std::set<LLSpatialGroup*> visible_selected_groups;
|
||||
|
||||
void LLPipeline::renderDebug()
|
||||
{
|
||||
|
|
@ -5206,6 +5299,27 @@ void LLPipeline::renderDebug()
|
|||
}
|
||||
}
|
||||
|
||||
if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCCLUSION) && LLGLSLShader::sNoFixedFunction)
|
||||
{ //render visible selected group occlusion geometry
|
||||
gDebugProgram.bind();
|
||||
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
|
||||
gGL.diffuseColor3f(1,0,1);
|
||||
for (std::set<LLSpatialGroup*>::iterator iter = visible_selected_groups.begin(); iter != visible_selected_groups.end(); ++iter)
|
||||
{
|
||||
LLSpatialGroup* group = *iter;
|
||||
|
||||
LLVector4a fudge;
|
||||
fudge.splat(0.25f); //SG_OCCLUSION_FUDGE
|
||||
|
||||
LLVector4a size;
|
||||
size.setAdd(fudge, group->mBounds[1]);
|
||||
|
||||
drawBox(group->mBounds[0], size);
|
||||
}
|
||||
}
|
||||
|
||||
visible_selected_groups.clear();
|
||||
|
||||
if (LLGLSLShader::sNoFixedFunction)
|
||||
{
|
||||
gUIProgram.bind();
|
||||
|
|
@ -5860,9 +5974,9 @@ void LLPipeline::setupAvatarLights(BOOL for_edit)
|
|||
|
||||
if (LLPipeline::sRenderDeferred)
|
||||
{
|
||||
diffuse.mV[0] = powf(diffuse.mV[0], 2.2f);
|
||||
/*diffuse.mV[0] = powf(diffuse.mV[0], 2.2f);
|
||||
diffuse.mV[1] = powf(diffuse.mV[1], 2.2f);
|
||||
diffuse.mV[2] = powf(diffuse.mV[2], 2.2f);
|
||||
diffuse.mV[2] = powf(diffuse.mV[2], 2.2f);*/
|
||||
}
|
||||
|
||||
mHWLightColors[1] = diffuse;
|
||||
|
|
@ -5907,9 +6021,9 @@ void LLPipeline::setupAvatarLights(BOOL for_edit)
|
|||
|
||||
if (LLPipeline::sRenderDeferred)
|
||||
{
|
||||
backlight_diffuse.mV[0] = powf(backlight_diffuse.mV[0], 2.2f);
|
||||
/*backlight_diffuse.mV[0] = powf(backlight_diffuse.mV[0], 2.2f);
|
||||
backlight_diffuse.mV[1] = powf(backlight_diffuse.mV[1], 2.2f);
|
||||
backlight_diffuse.mV[2] = powf(backlight_diffuse.mV[2], 2.2f);
|
||||
backlight_diffuse.mV[2] = powf(backlight_diffuse.mV[2], 2.2f);*/
|
||||
}
|
||||
|
||||
mHWLightColors[1] = backlight_diffuse;
|
||||
|
|
@ -6121,9 +6235,9 @@ void LLPipeline::setupHWLights(LLDrawPool* pool)
|
|||
|
||||
if (LLPipeline::sRenderDeferred)
|
||||
{
|
||||
light_diffuse.mV[0] = powf(light_diffuse.mV[0], 2.2f);
|
||||
/*light_diffuse.mV[0] = powf(light_diffuse.mV[0], 2.2f);
|
||||
light_diffuse.mV[1] = powf(light_diffuse.mV[1], 2.2f);
|
||||
light_diffuse.mV[2] = powf(light_diffuse.mV[2], 2.2f);
|
||||
light_diffuse.mV[2] = powf(light_diffuse.mV[2], 2.2f);*/
|
||||
}
|
||||
|
||||
mHWLightColors[0] = light_diffuse;
|
||||
|
|
@ -6196,9 +6310,9 @@ void LLPipeline::setupHWLights(LLDrawPool* pool)
|
|||
|
||||
if (LLPipeline::sRenderDeferred)
|
||||
{
|
||||
light_color.mV[0] = powf(light_color.mV[0], 2.2f);
|
||||
/*light_color.mV[0] = powf(light_color.mV[0], 2.2f);
|
||||
light_color.mV[1] = powf(light_color.mV[1], 2.2f);
|
||||
light_color.mV[2] = powf(light_color.mV[2], 2.2f);
|
||||
light_color.mV[2] = powf(light_color.mV[2], 2.2f);*/
|
||||
}
|
||||
|
||||
mHWLightColors[cur_light] = light_color;
|
||||
|
|
@ -6211,7 +6325,7 @@ void LLPipeline::setupHWLights(LLDrawPool* pool)
|
|||
if (sRenderDeferred)
|
||||
{
|
||||
F32 size = light_radius*1.5f;
|
||||
light_state->setLinearAttenuation(size*size);
|
||||
light_state->setLinearAttenuation(size);
|
||||
light_state->setQuadraticAttenuation(light->getLightFalloff()*0.5f+1.f);
|
||||
}
|
||||
else
|
||||
|
|
@ -6276,9 +6390,9 @@ void LLPipeline::setupHWLights(LLDrawPool* pool)
|
|||
|
||||
if (LLPipeline::sRenderDeferred)
|
||||
{
|
||||
light_color.mV[0] = powf(light_color.mV[0], 2.2f);
|
||||
/*light_color.mV[0] = powf(light_color.mV[0], 2.2f);
|
||||
light_color.mV[1] = powf(light_color.mV[1], 2.2f);
|
||||
light_color.mV[2] = powf(light_color.mV[2], 2.2f);
|
||||
light_color.mV[2] = powf(light_color.mV[2], 2.2f);*/
|
||||
}
|
||||
|
||||
mHWLightColors[2] = light_color;
|
||||
|
|
@ -8278,11 +8392,7 @@ void LLPipeline::renderDeferredLighting()
|
|||
|
||||
LLStrider<LLVector3> vert;
|
||||
mDeferredVB->getVertexStrider(vert);
|
||||
LLStrider<LLVector2> tc0;
|
||||
LLStrider<LLVector2> tc1;
|
||||
mDeferredVB->getTexCoord0Strider(tc0);
|
||||
mDeferredVB->getTexCoord1Strider(tc1);
|
||||
|
||||
|
||||
vert[0].set(-1,1,0);
|
||||
vert[1].set(-1,-3,0);
|
||||
vert[2].set(3,1,0);
|
||||
|
|
@ -8462,7 +8572,7 @@ void LLPipeline::renderDeferredLighting()
|
|||
LLPipeline::END_RENDER_TYPES);
|
||||
|
||||
|
||||
renderGeomPostDeferred(*LLViewerCamera::getInstance());
|
||||
renderGeomPostDeferred(*LLViewerCamera::getInstance(), false);
|
||||
gPipeline.popRenderTypeMask();
|
||||
}
|
||||
|
||||
|
|
@ -8556,13 +8666,13 @@ void LLPipeline::renderDeferredLighting()
|
|||
continue;
|
||||
}
|
||||
|
||||
col.mV[0] = powf(col.mV[0], 2.2f);
|
||||
/*col.mV[0] = powf(col.mV[0], 2.2f);
|
||||
col.mV[1] = powf(col.mV[1], 2.2f);
|
||||
col.mV[2] = powf(col.mV[2], 2.2f);
|
||||
col.mV[2] = powf(col.mV[2], 2.2f);*/
|
||||
|
||||
LLFastTimer ftm(FTM_LOCAL_LIGHTS);
|
||||
gDeferredLightProgram.uniform3fv(LLShaderMgr::LIGHT_CENTER, 1, c);
|
||||
gDeferredLightProgram.uniform1f(LLShaderMgr::LIGHT_SIZE, s*s);
|
||||
gDeferredLightProgram.uniform1f(LLShaderMgr::LIGHT_SIZE, s);
|
||||
gDeferredLightProgram.uniform3fv(LLShaderMgr::DIFFUSE_COLOR, 1, col.mV);
|
||||
gDeferredLightProgram.uniform1f(LLShaderMgr::LIGHT_FALLOFF, volume->getLightFalloff()*0.5f);
|
||||
gGL.syncMatrices();
|
||||
|
|
@ -8583,7 +8693,7 @@ void LLPipeline::renderDeferredLighting()
|
|||
glh::vec3f tc(c);
|
||||
mat.mult_matrix_vec(tc);
|
||||
|
||||
fullscreen_lights.push_back(LLVector4(tc.v[0], tc.v[1], tc.v[2], s*s));
|
||||
fullscreen_lights.push_back(LLVector4(tc.v[0], tc.v[1], tc.v[2], s));
|
||||
light_colors.push_back(LLVector4(col.mV[0], col.mV[1], col.mV[2], volume->getLightFalloff()*0.5f));
|
||||
}
|
||||
}
|
||||
|
|
@ -8616,12 +8726,12 @@ void LLPipeline::renderDeferredLighting()
|
|||
setupSpotLight(gDeferredSpotLightProgram, drawablep);
|
||||
|
||||
LLColor3 col = volume->getLightColor();
|
||||
col.mV[0] = powf(col.mV[0], 2.2f);
|
||||
/*col.mV[0] = powf(col.mV[0], 2.2f);
|
||||
col.mV[1] = powf(col.mV[1], 2.2f);
|
||||
col.mV[2] = powf(col.mV[2], 2.2f);
|
||||
col.mV[2] = powf(col.mV[2], 2.2f);*/
|
||||
|
||||
gDeferredSpotLightProgram.uniform3fv(LLShaderMgr::LIGHT_CENTER, 1, c);
|
||||
gDeferredSpotLightProgram.uniform1f(LLShaderMgr::LIGHT_SIZE, s*s);
|
||||
gDeferredSpotLightProgram.uniform1f(LLShaderMgr::LIGHT_SIZE, s);
|
||||
gDeferredSpotLightProgram.uniform3fv(LLShaderMgr::DIFFUSE_COLOR, 1, col.mV);
|
||||
gDeferredSpotLightProgram.uniform1f(LLShaderMgr::LIGHT_FALLOFF, volume->getLightFalloff()*0.5f);
|
||||
gGL.syncMatrices();
|
||||
|
|
@ -8668,11 +8778,11 @@ void LLPipeline::renderDeferredLighting()
|
|||
col[count] = light_colors.front();
|
||||
light_colors.pop_front();
|
||||
|
||||
col[count].mV[0] = powf(col[count].mV[0], 2.2f);
|
||||
/*col[count].mV[0] = powf(col[count].mV[0], 2.2f);
|
||||
col[count].mV[1] = powf(col[count].mV[1], 2.2f);
|
||||
col[count].mV[2] = powf(col[count].mV[2], 2.2f);
|
||||
col[count].mV[2] = powf(col[count].mV[2], 2.2f);*/
|
||||
|
||||
far_z = llmin(light[count].mV[2]-sqrtf(light[count].mV[3]), far_z);
|
||||
far_z = llmin(light[count].mV[2]-light[count].mV[3], far_z);
|
||||
//col[count] = pow4fsrgb(col[count], 2.2f);
|
||||
count++;
|
||||
if (count == max_count || fullscreen_lights.empty())
|
||||
|
|
@ -8715,12 +8825,12 @@ void LLPipeline::renderDeferredLighting()
|
|||
|
||||
LLColor3 col = volume->getLightColor();
|
||||
|
||||
col.mV[0] = powf(col.mV[0], 2.2f);
|
||||
/*col.mV[0] = powf(col.mV[0], 2.2f);
|
||||
col.mV[1] = powf(col.mV[1], 2.2f);
|
||||
col.mV[2] = powf(col.mV[2], 2.2f);
|
||||
col.mV[2] = powf(col.mV[2], 2.2f);*/
|
||||
|
||||
gDeferredMultiSpotLightProgram.uniform3fv(LLShaderMgr::LIGHT_CENTER, 1, tc.v);
|
||||
gDeferredMultiSpotLightProgram.uniform1f(LLShaderMgr::LIGHT_SIZE, s*s);
|
||||
gDeferredMultiSpotLightProgram.uniform1f(LLShaderMgr::LIGHT_SIZE, s);
|
||||
gDeferredMultiSpotLightProgram.uniform3fv(LLShaderMgr::DIFFUSE_COLOR, 1, col.mV);
|
||||
gDeferredMultiSpotLightProgram.uniform1f(LLShaderMgr::LIGHT_FALLOFF, volume->getLightFalloff()*0.5f);
|
||||
mDeferredVB->drawArrays(LLRender::TRIANGLES, 0, 3);
|
||||
|
|
@ -9396,9 +9506,15 @@ void LLPipeline::renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera
|
|||
gDeferredShadowCubeProgram.bind();
|
||||
}
|
||||
|
||||
LLRenderTarget& occlusion_target = mShadowOcclusion[LLViewerCamera::sCurCameraID-1];
|
||||
|
||||
occlusion_target.bindTarget();
|
||||
updateCull(shadow_cam, result);
|
||||
occlusion_target.flush();
|
||||
|
||||
stateSort(shadow_cam, result);
|
||||
|
||||
|
||||
//generate shadow map
|
||||
gGL.matrixMode(LLRender::MM_PROJECTION);
|
||||
gGL.pushMatrix();
|
||||
|
|
@ -9486,7 +9602,10 @@ void LLPipeline::renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera
|
|||
gDeferredShadowCubeProgram.bind();
|
||||
gGLLastMatrix = NULL;
|
||||
gGL.loadMatrix(gGLModelView);
|
||||
doOcclusion(shadow_cam);
|
||||
|
||||
LLRenderTarget& occlusion_source = mShadow[LLViewerCamera::sCurCameraID-1];
|
||||
|
||||
doOcclusion(shadow_cam, occlusion_source, occlusion_target);
|
||||
|
||||
if (use_shader)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -177,6 +177,12 @@ public:
|
|||
// Object related methods
|
||||
void markVisible(LLDrawable *drawablep, LLCamera& camera);
|
||||
void markOccluder(LLSpatialGroup* group);
|
||||
|
||||
//downsample source to dest, taking the maximum depth value per pixel in source and writing to dest
|
||||
// if source's depth buffer cannot be bound for reading, a scratch space depth buffer must be provided
|
||||
void downsampleDepthBuffer(LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
|
||||
|
||||
void doOcclusion(LLCamera& camera, LLRenderTarget& source, LLRenderTarget& dest, LLRenderTarget* scratch_space = NULL);
|
||||
void doOcclusion(LLCamera& camera);
|
||||
void markNotCulled(LLSpatialGroup* group, LLCamera &camera);
|
||||
void markMoved(LLDrawable *drawablep, BOOL damped_motion = FALSE);
|
||||
|
|
@ -282,7 +288,7 @@ public:
|
|||
|
||||
void renderGeom(LLCamera& camera, BOOL forceVBOUpdate = FALSE);
|
||||
void renderGeomDeferred(LLCamera& camera);
|
||||
void renderGeomPostDeferred(LLCamera& camera);
|
||||
void renderGeomPostDeferred(LLCamera& camera, bool do_occlusion=true);
|
||||
void renderGeomShadow(LLCamera& camera);
|
||||
void bindDeferredShader(LLGLSLShader& shader, U32 light_index = 0, U32 noise_map = 0xFFFFFFFF);
|
||||
void setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep);
|
||||
|
|
@ -610,6 +616,7 @@ public:
|
|||
LLRenderTarget mFXAABuffer;
|
||||
LLRenderTarget mEdgeMap;
|
||||
LLRenderTarget mDeferredDepth;
|
||||
LLRenderTarget mOcclusionDepth;
|
||||
LLRenderTarget mDeferredLight;
|
||||
LLRenderTarget mHighlight;
|
||||
LLRenderTarget mPhysicsDisplay;
|
||||
|
|
@ -622,6 +629,7 @@ public:
|
|||
|
||||
//sun shadow map
|
||||
LLRenderTarget mShadow[6];
|
||||
LLRenderTarget mShadowOcclusion[6];
|
||||
std::vector<LLVector3> mShadowFrustPoints[4];
|
||||
LLVector4 mShadowError;
|
||||
LLVector4 mShadowFOV;
|
||||
|
|
|
|||
|
|
@ -172,7 +172,7 @@ class ViewerManifest(LLManifest):
|
|||
def app_name(self):
|
||||
app_suffix='Test'
|
||||
channel_type=self.channel_lowerword()
|
||||
if channel_type == 'release' :
|
||||
if channel_type.startswith('release') :
|
||||
app_suffix='Viewer'
|
||||
elif re.match('^(beta|project).*',channel_type) :
|
||||
app_suffix=self.channel_unique()
|
||||
|
|
@ -182,8 +182,8 @@ class ViewerManifest(LLManifest):
|
|||
icon_path="icons/"
|
||||
channel_type=self.channel_lowerword()
|
||||
print "Icon channel type '%s'" % channel_type
|
||||
if channel_type == 'release' :
|
||||
icon_path += channel_type
|
||||
if channel_type.startswith('release') :
|
||||
icon_path += 'release'
|
||||
elif re.match('^beta.*',channel_type) :
|
||||
icon_path += 'beta'
|
||||
elif re.match('^project.*',channel_type) :
|
||||
|
|
@ -242,7 +242,7 @@ class WindowsManifest(ViewerManifest):
|
|||
def final_exe(self):
|
||||
app_suffix="Test"
|
||||
channel_type=self.channel_lowerword()
|
||||
if channel_type == 'release' :
|
||||
if channel_type.startswith('release') :
|
||||
app_suffix=''
|
||||
elif re.match('^(beta|project).*',channel_type) :
|
||||
app_suffix=''.join(self.channel_unique().split())
|
||||
|
|
|
|||
Loading…
Reference in New Issue