livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

SL-9632 add uniform and code to supress atmospherics in all shaders that could be used by HUDs 

Make sky and cloud shaders use common scaleSoftClip implementation in gammaF.glsl
master
Graham Linden 2018-09-14 21:52:52 +01:00
parent a167f8857f
commit 1df7760d31
20 changed files with 405 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
indra/llrender/llshadermgr.cpp
View File

@ -1319,6 +1319,7 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("single_mie_scattering_texture");
mReservedUniforms.push_back("irradiance_texture");
mReservedUniforms.push_back("blend_factor");
mReservedUniforms.push_back("no_atmo");
llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);

1
indra/llrender/llshadermgr.h
View File

@ -233,6 +233,7 @@ public:
ILLUMINANCE_TEX,
BLEND_FACTOR,
NO_ATMO,
END_RESERVED_UNIFORMS
} eGLSLReservedUniforms;

8
indra/newview/app_settings/shaders/class1/deferred/cloudsF.glsl
View File

@ -51,13 +51,7 @@ VARYING vec2 vary_texcoord2;
VARYING vec2 vary_texcoord3;
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light) {
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
return light;
}
vec3 scaleSoftClip(vec3 light);
vec4 cloudNoise(vec2 uv)
{

2
indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
View File

@ -1,5 +1,5 @@
/**
* @file fullbrightF.glsl
* @file deferred/fullbrightF.glsl
*
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
* Second Life Viewer Source Code

8
indra/newview/app_settings/shaders/class1/deferred/skyF.glsl
View File

@ -40,13 +40,7 @@ VARYING vec4 vary_HazeColor;
uniform vec4 gamma;
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light) {
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
return light;
}
vec3 scaleSoftClip(vec3 light);
void main()
{

2
indra/newview/app_settings/shaders/class1/objects/fullbrightF.glsl
View File

@ -1,5 +1,5 @@
/**
* @file fullbrightF.glsl
* @file objects/fullbrightF.glsl
*
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
* Second Life Viewer Source Code

14
indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl
View File

@ -43,9 +43,14 @@ uniform float max_y;
uniform vec4 glow;
uniform float scene_light_strength;
uniform mat3 ssao_effect_mat;
uniform int no_atmo;
vec3 scaleFragSoftClip(vec3 light)
{
if (no_atmo == 1)
{
return light;
}
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
@ -54,14 +59,17 @@ vec3 scaleFragSoftClip(vec3 light)
vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten)
{
light *= atten.r;
light += additive;
if (no_atmo == 0)
{
light *= atten.r;
light += additive;
}
return (2.0 * light);
}
vec3 atmosLighting(vec3 light)
{
return atmosFragLighting(light, getAdditiveColor(), getAtmosAttenuation());
return (no_atmo == 1) ? light : atmosFragLighting(light, getAdditiveColor(), getAtmosAttenuation());
}
void calcFragAtmospherics(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten) {

8
indra/newview/app_settings/shaders/class2/windlight/cloudsF.glsl
View File

@ -49,13 +49,7 @@ uniform vec4 cloud_pos_density2;
uniform vec4 gamma;
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light) {
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
return light;
}
vec3 scaleSoftClip(vec3 light);
vec4 cloudNoise(vec2 uv)
{

9
indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl
View File

@ -26,11 +26,16 @@
uniform vec4 gamma;
uniform int no_atmo;
vec3 getAtmosAttenuation();
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light) {
if (no_atmo == 1)
{
return light;
}
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
@ -40,10 +45,10 @@ vec3 scaleSoftClip(vec3 light) {
vec3 fullbrightScaleSoftClipFrag(vec3 light, vec3 atten)
{
return mix(scaleSoftClip(light.rgb), light.rgb, atten);
return (no_atmo == 1) ? light : mix(scaleSoftClip(light.rgb), light.rgb, atten);
}
vec3 fullbrightScaleSoftClip(vec3 light) {
return fullbrightScaleSoftClipFrag(light.rgb, getAtmosAttenuation());
return (no_atmo == 1) ? light : fullbrightScaleSoftClipFrag(light.rgb, getAtmosAttenuation());
}

8
indra/newview/app_settings/shaders/class2/windlight/skyF.glsl
View File

@ -38,13 +38,7 @@ VARYING vec4 vary_HazeColor;
uniform vec4 gamma;
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light) {
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
return light;
}
vec3 scaleSoftClip(vec3 light);
void main()
{

22
indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
View File

@ -32,31 +32,43 @@ vec3 getAtmosAttenuation();
uniform sampler2D cloudMap;
uniform vec4 cloud_pos_density1;
uniform int no_atmo;
vec3 atmosFragTransport(vec3 light, vec3 atten, vec3 additive) {
light *= atten.r;
light += additive * 2.0;
if (no_atmo == 0)
{
light *= atten.r;
light += additive * 2.0;
}
return light;
}
vec3 fullbrightFragAtmosTransport(vec3 light, vec3 atten, vec3 additive) {
if (no_atmo == 1)
{
return light;
}
float brightness = dot(light.rgb, vec3(0.33333));
return mix(atmosFragTransport(light.rgb, atten, additive), light.rgb + additive.rgb, brightness * brightness);
}
vec3 fullbrightFragShinyAtmosTransport(vec3 light, vec3 atten, vec3 additive) {
if (no_atmo == 1)
{
return light;
}
float brightness = dot(light.rgb, vec3(0.33333));
return mix(atmosFragTransport(light.rgb, atten, additive), (light.rgb + additive.rgb) * (2.0 - brightness), brightness * brightness);
}
vec3 atmosTransport(vec3 light) {
return atmosFragTransport(light, getAtmosAttenuation(), getAdditiveColor());
return (no_atmo == 1) ? light : atmosFragTransport(light, getAtmosAttenuation(), getAdditiveColor());
}
vec3 fullbrightAtmosTransport(vec3 light) {
return fullbrightFragAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
return (no_atmo == 1) ? light : fullbrightFragAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
}
vec3 fullbrightShinyAtmosTransport(vec3 light) {
return fullbrightFragShinyAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
return (no_atmo == 1) ? light : fullbrightFragShinyAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
}

8
indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
View File

@ -58,13 +58,7 @@ vec4 cloudNoise(vec2 uv)
/// Soft clips the light with a gamma correction
vec3 scaleSoftClip(vec3 light) {
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
return light;
}
vec3 scaleSoftClip(vec3 light);
void main()
{

24
indra/newview/app_settings/shaders/class3/windlight/transportF.glsl
View File

@ -32,31 +32,43 @@ vec3 getAtmosAttenuation();
uniform sampler2D cloudMap;
uniform vec4 cloud_pos_density1;
uniform int no_atmo;
vec3 atmosFragTransport(vec3 light, vec3 atten, vec3 additive) {
light *= atten.r;
light += additive * 2.0;
if (no_atmo == 0)
{
light *= atten.r;
light += additive * 2.0;
}
return light;
}
vec3 fullbrightFragAtmosTransport(vec3 light, vec3 atten, vec3 additive) {
float brightness = dot(light.rgb, vec3(0.33333));
if (no_atmo)
{
return light;
}
loat brightness = dot(light.rgb, vec3(0.33333));
return mix(atmosFragTransport(light.rgb, atten, additive), light.rgb + additive.rgb, brightness * brightness);
}
vec3 fullbrightFragShinyAtmosTransport(vec3 light, vec3 atten, vec3 additive) {
if (no_atmo)
{
return light;
}
float brightness = dot(light.rgb, vec3(0.33333));
return mix(atmosFragTransport(light.rgb, atten, additive), (light.rgb + additive.rgb) * (2.0 - brightness), brightness * brightness);
}
vec3 atmosTransport(vec3 light) {
return atmosFragTransport(light, getAtmosAttenuation(), getAdditiveColor());
return no_atmo ? light : atmosFragTransport(light, getAtmosAttenuation(), getAdditiveColor());
}
vec3 fullbrightAtmosTransport(vec3 light) {
return fullbrightFragAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
return no_atmo ? light : fullbrightFragAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
}
vec3 fullbrightShinyAtmosTransport(vec3 light) {
return fullbrightFragShinyAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
return no_atmo ? light : fullbrightFragShinyAtmosTransport(light, getAtmosAttenuation(), getAdditiveColor());
}

51
indra/newview/lldrawpoolalpha.cpp
View File

@ -117,6 +117,14 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
fullbright_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
fullbright_shader->unbind();
if (LLPipeline::sRenderingHUDs)
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
//prime simple shader (loads shadow relevant uniforms)
gPipeline.bindDeferredShader(*simple_shader);
@ -260,17 +268,49 @@ void LLDrawPoolAlpha::render(S32 pass)
{
if (LLPipeline::sImpostorRender)
{
fullbright_shader->bind();
fullbright_shader->bind();
fullbright_shader->setMinimumAlpha(0.5f);
if (LLPipeline::sRenderingHUDs)
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
simple_shader->bind();
simple_shader->setMinimumAlpha(0.5f);
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
else
{
fullbright_shader->bind();
fullbright_shader->setMinimumAlpha(0.f);
if (LLPipeline::sRenderingHUDs)
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
simple_shader->bind();
simple_shader->setMinimumAlpha(0.f);
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
}
else
@ -610,7 +650,14 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
LLRender::BF_ONE, LLRender::BF_ONE); // add to alpha (glow)
emissive_shader->bind();
if (LLPipeline::sRenderingHUDs)
{
emissive_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
emissive_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
params.mVertexBuffer->setBuffer((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
// do the actual drawing, again

133
indra/newview/lldrawpoolavatar.cpp
View File

@ -670,6 +670,14 @@ void LLDrawPoolAvatar::beginRigid()
{ //eyeballs render with the specular shader
sVertexProgram->bind();
sVertexProgram->setMinimumAlpha(LLDrawPoolAvatar::sMinimumAlpha);
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
}
else
@ -720,6 +728,14 @@ void LLDrawPoolAvatar::beginDeferredRigid()
sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
sVertexProgram->bind();
sVertexProgram->setMinimumAlpha(LLDrawPoolAvatar::sMinimumAlpha);
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
void LLDrawPoolAvatar::endDeferredRigid()
@ -763,6 +779,14 @@ void LLDrawPoolAvatar::beginSkinned()
sVertexProgram->bind();
sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
gGL.getTexUnit(0)->activate();
}
else
@ -772,6 +796,14 @@ void LLDrawPoolAvatar::beginSkinned()
// software skinning, use a basic shader for windlight.
// TODO: find a better fallback method for software skinning.
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
}
@ -834,6 +866,14 @@ void LLDrawPoolAvatar::beginRiggedSimple()
{
sDiffuseChannel = 0;
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
}
@ -899,6 +939,16 @@ void LLDrawPoolAvatar::beginRiggedGlow()
sVertexProgram->bind();
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, LLPipeline::sRenderDeferred ? 2.2f : 1.1f);
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
}
@ -946,16 +996,22 @@ void LLDrawPoolAvatar::beginRiggedFullbright()
sDiffuseChannel = 0;
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else if (LLPipeline::sRenderDeferred)
{
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
}
else
{
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
}
@ -998,6 +1054,14 @@ void LLDrawPoolAvatar::beginRiggedShinySimple()
if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
{
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
}
}
@ -1048,17 +1112,32 @@ void LLDrawPoolAvatar::beginRiggedFullbrightShiny()
if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
{
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
}
else
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else if (LLPipeline::sRenderDeferred)
{
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
else
{
sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
}
@ -1080,6 +1159,14 @@ void LLDrawPoolAvatar::beginDeferredRiggedSimple()
sVertexProgram = &gDeferredSkinnedDiffuseProgram;
sDiffuseChannel = 0;
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
void LLDrawPoolAvatar::endDeferredRiggedSimple()
@ -1093,6 +1180,14 @@ void LLDrawPoolAvatar::beginDeferredRiggedBump()
{
sVertexProgram = &gDeferredSkinnedBumpProgram;
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
}
@ -1125,6 +1220,14 @@ void LLDrawPoolAvatar::beginDeferredRiggedMaterial(S32 pass)
}
sVertexProgram->bind();
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
@ -1158,7 +1261,15 @@ void LLDrawPoolAvatar::beginDeferredSkinned()
sVertexProgram->bind();
sVertexProgram->setMinimumAlpha(LLDrawPoolAvatar::sMinimumAlpha);
if (LLPipeline::sRenderingHUDs)
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
gGL.getTexUnit(0)->activate();
}

17
indra/newview/lldrawpoolbump.cpp
View File

@ -351,6 +351,14 @@ void LLDrawPoolBump::beginShiny(bool invisible)
shader = &gObjectShinyProgram;
}
shader->bind();
if (LLPipeline::sRenderingHUDs)
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
else
{
@ -534,6 +542,15 @@ void LLDrawPoolBump::beginFullbrightShiny()
LLVector4(gGLModelView+8),
LLVector4(gGLModelView+12));
shader->bind();
if (LLPipeline::sRenderingHUDs)
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
LLVector3 vec = LLVector3(gShinyOrigin) * mat;
LLVector4 vec4(vec, gShinyOrigin.mV[3]);
shader->uniform4fv(LLViewerShaderMgr::SHINY_ORIGIN, 1, vec4.mV);

9
indra/newview/lldrawpoolmaterials.cpp
View File

@ -81,6 +81,15 @@ void LLDrawPoolMaterials::beginDeferredPass(S32 pass)
mShader->bind();
if (LLPipeline::sRenderingHUDs)
{
mShader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
mShader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
diffuse_channel = mShader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
LL_RECORD_BLOCK_TIME(FTM_RENDER_MATERIALS);

155
indra/newview/lldrawpoolsimple.cpp
View File

@ -47,6 +47,14 @@ void LLDrawPoolGlow::beginPostDeferredPass(S32 pass)
{
gDeferredEmissiveProgram.bind();
gDeferredEmissiveProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
if (LLPipeline::sRenderingHUDs)
{
gDeferredEmissiveProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
gDeferredEmissiveProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
static LLTrace::BlockTimerStatHandle FTM_RENDER_GLOW_PUSH("Glow Push");
@ -119,6 +127,15 @@ void LLDrawPoolGlow::render(S32 pass)
shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
}
if (LLPipeline::sRenderingHUDs)
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
gGL.setColorMask(false, true);
@ -170,6 +187,15 @@ void LLDrawPoolSimple::beginRenderPass(S32 pass)
if (mVertexShaderLevel > 0)
{
simple_shader->bind();
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
else
{
@ -263,6 +289,15 @@ void LLDrawPoolAlphaMask::beginRenderPass(S32 pass)
if (mVertexShaderLevel > 0)
{
simple_shader->bind();
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
else
{
@ -296,6 +331,15 @@ void LLDrawPoolAlphaMask::render(S32 pass)
simple_shader->bind();
simple_shader->setMinimumAlpha(0.33f);
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
pushMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
pushMaskBatches(LLRenderPass::PASS_SPECMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
@ -336,6 +380,15 @@ void LLDrawPoolFullbrightAlphaMask::beginRenderPass(S32 pass)
if (mVertexShaderLevel > 0)
{
simple_shader->bind();
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
else
{
@ -369,12 +422,24 @@ void LLDrawPoolFullbrightAlphaMask::render(S32 pass)
{
simple_shader->bind();
simple_shader->setMinimumAlpha(0.33f);
if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
{
simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
} else {
simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
if (LLPipeline::sRenderDeferred)
{
simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
}
else
{
simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
}
}
}
pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
//LLGLSLShader::bindNoShader();
@ -397,6 +462,15 @@ void LLDrawPoolSimple::beginDeferredPass(S32 pass)
{
LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE_DEFERRED);
gDeferredDiffuseProgram.bind();
if (LLPipeline::sRenderingHUDs)
{
gDeferredDiffuseProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
gDeferredDiffuseProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
void LLDrawPoolSimple::endDeferredPass(S32 pass)
@ -435,6 +509,16 @@ void LLDrawPoolAlphaMask::renderDeferred(S32 pass)
LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK_DEFERRED);
gDeferredDiffuseAlphaMaskProgram.bind();
gDeferredDiffuseAlphaMaskProgram.setMinimumAlpha(0.33f);
if (LLPipeline::sRenderingHUDs)
{
gDeferredDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
gDeferredDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
}
pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
gDeferredDiffuseAlphaMaskProgram.unbind();
}
@ -471,6 +555,14 @@ void LLDrawPoolGrass::beginRenderPass(S32 pass)
{
simple_shader->bind();
simple_shader->setMinimumAlpha(0.5f);
if (LLPipeline::sRenderingHUDs)
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
else
{
@ -527,6 +619,16 @@ void LLDrawPoolGrass::renderDeferred(S32 pass)
LL_RECORD_BLOCK_TIME(FTM_RENDER_GRASS_DEFERRED);
gDeferredNonIndexedDiffuseAlphaMaskProgram.bind();
gDeferredNonIndexedDiffuseAlphaMaskProgram.setMinimumAlpha(0.5f);
if (LLPipeline::sRenderingHUDs)
{
gDeferredNonIndexedDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
gDeferredNonIndexedDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
}
//render grass
LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
@ -553,6 +655,15 @@ void LLDrawPoolFullbright::beginPostDeferredPass(S32 pass)
else
{
gDeferredFullbrightProgram.bind();
if (LLPipeline::sRenderingHUDs)
{
gDeferredFullbrightProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
gDeferredFullbrightProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
}
@ -621,6 +732,15 @@ void LLDrawPoolFullbright::render(S32 pass)
fullbright_shader->uniform1f(LLViewerShaderMgr::FULLBRIGHT, 1.f);
fullbright_shader->uniform1f(LLViewerShaderMgr::TEXTURE_GAMMA, 1.f);
if (LLPipeline::sRenderingHUDs)
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
pushBatches(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask, TRUE, TRUE);
pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE, fullbright_mask, TRUE, TRUE);
@ -651,23 +771,32 @@ S32 LLDrawPoolFullbright::getNumPasses()
void LLDrawPoolFullbrightAlphaMask::beginPostDeferredPass(S32 pass)
{
if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
{
gObjectFullbrightAlphaMaskProgram.bind();
if (LLPipeline::sRenderingHUDs)
{
gObjectFullbrightAlphaMaskProgram.bind();
gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
}
else
{
if (LLPipeline::sUnderWaterRender)
gObjectFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else if (LLPipeline::sRenderDeferred)
{
if (LLPipeline::sUnderWaterRender)
{
gDeferredFullbrightAlphaMaskWaterProgram.bind();
gDeferredFullbrightAlphaMaskWaterProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
gDeferredFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
gDeferredFullbrightAlphaMaskProgram.bind();
gDeferredFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
gDeferredFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
else
{
gObjectFullbrightAlphaMaskProgram.bind();
gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
gObjectFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}

2
indra/newview/llhudtext.cpp
View File

@ -588,8 +588,6 @@ void LLHUDText::renderAllHUD()
LLVertexBuffer::unbind();
LLVertexBuffer::unbind();
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();

4
indra/newview/llviewershadermgr.cpp
View File

@ -2110,6 +2110,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
gDeferredWLSkyProgram.mName = "Deferred Windlight Sky Shader";
//gWLSkyProgram.mFeatures.hasGamma = true;
gDeferredWLSkyProgram.mShaderFiles.clear();
gDeferredWLSkyProgram.mFeatures.hasGamma = true;
gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyV.glsl", GL_VERTEX_SHADER_ARB));
gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyF.glsl", GL_FRAGMENT_SHADER_ARB));
gDeferredWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
@ -2126,6 +2127,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
{
gDeferredWLCloudProgram.mName = "Deferred Windlight Cloud Program";
gDeferredWLCloudProgram.mShaderFiles.clear();
gDeferredWLCloudProgram.mFeatures.hasGamma = true;
gDeferredWLCloudProgram.mShaderFiles.push_back(make_pair("deferred/cloudsV.glsl", GL_VERTEX_SHADER_ARB));
gDeferredWLCloudProgram.mShaderFiles.push_back(make_pair("deferred/cloudsF.glsl", GL_FRAGMENT_SHADER_ARB));
gDeferredWLCloudProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
@ -3526,6 +3528,7 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
gWLSkyProgram.mName = "Windlight Sky Shader";
//gWLSkyProgram.mFeatures.hasGamma = true;
gWLSkyProgram.mShaderFiles.clear();
gWLSkyProgram.mFeatures.hasGamma = true;
gWLSkyProgram.mShaderFiles.push_back(make_pair("windlight/skyV.glsl", GL_VERTEX_SHADER_ARB));
gWLSkyProgram.mShaderFiles.push_back(make_pair("windlight/skyF.glsl", GL_FRAGMENT_SHADER_ARB));
gWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
@ -3538,6 +3541,7 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
gWLCloudProgram.mName = "Windlight Cloud Program";
//gWLCloudProgram.mFeatures.hasGamma = true;
gWLCloudProgram.mShaderFiles.clear();
gWLCloudProgram.mFeatures.hasGamma = true;
gWLCloudProgram.mShaderFiles.push_back(make_pair("windlight/cloudsV.glsl", GL_VERTEX_SHADER_ARB));
gWLCloudProgram.mShaderFiles.push_back(make_pair("windlight/cloudsF.glsl", GL_FRAGMENT_SHADER_ARB));
gWLCloudProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];