SL-20611 Make haze effect local lights -- move sky and water haze to their own passes and unify sky and water haze in forward rendering shaders.
RunitaiLinden
parent
361efcb926
commit
bdb53fd56d
|
|
@ -81,14 +81,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
|
|||
// NOTE order of shader object attaching is VERY IMPORTANT!!!
|
||||
if (features->calculatesAtmospherics)
|
||||
{
|
||||
if (features->hasWaterFog)
|
||||
{
|
||||
if (!shader->attachVertexObject("windlight/atmosphericsVarsWaterV.glsl"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
else if (!shader->attachVertexObject("windlight/atmosphericsVarsV.glsl"))
|
||||
if (!shader->attachVertexObject("windlight/atmosphericsVarsV.glsl"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
|
@ -201,14 +194,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
|
|||
|
||||
if(features->calculatesAtmospherics || features->hasGamma || features->isDeferred)
|
||||
{
|
||||
if (features->hasWaterFog)
|
||||
{
|
||||
if (!shader->attachFragmentObject("windlight/atmosphericsVarsWaterF.glsl"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
else if (!shader->attachFragmentObject("windlight/atmosphericsVarsF.glsl"))
|
||||
if (!shader->attachFragmentObject("windlight/atmosphericsVarsF.glsl"))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
|
@ -292,7 +278,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
|
|||
}
|
||||
|
||||
// NOTE order of shader object attaching is VERY IMPORTANT!!!
|
||||
if (features->hasWaterFog)
|
||||
if (features->hasWaterFog || features->hasAtmospherics)
|
||||
{
|
||||
if (!shader->attachFragmentObject("environment/waterFogF.glsl"))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -35,9 +35,7 @@ in vec3 vary_position;
|
|||
in vec4 vertex_color;
|
||||
in vec2 vary_texcoord0;
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 applyWaterFogView(vec3 pos, vec4 color);
|
||||
#endif
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color);
|
||||
|
||||
vec3 srgb_to_linear(vec3 cs);
|
||||
vec3 linear_to_srgb(vec3 cl);
|
||||
|
|
@ -86,18 +84,14 @@ void main()
|
|||
calcAtmosphericVars(pos.xyz, vec3(0), 1.0, sunlit, amblit, additive, atten);
|
||||
#endif
|
||||
|
||||
#ifdef WATER_FOG
|
||||
|
||||
vec4 fogged = applyWaterFogView(pos, vec4(color.rgb, final_alpha));
|
||||
color.rgb = fogged.rgb;
|
||||
color.a = fogged.a;
|
||||
#else
|
||||
color.a = final_alpha;
|
||||
#endif
|
||||
|
||||
#ifndef IS_HUD
|
||||
color.rgb = srgb_to_linear(color.rgb);
|
||||
color.rgb = atmosFragLighting(color.rgb, additive, atten);
|
||||
|
||||
vec4 fogged = applyWaterFogViewLinear(pos, vec4(color.rgb, final_alpha));
|
||||
color.rgb = fogged.rgb;
|
||||
color.a = fogged.a;
|
||||
#endif
|
||||
|
||||
frag_color = max(color, vec4(0));
|
||||
|
|
|
|||
|
|
@ -30,12 +30,12 @@ uniform vec4 waterFogColor;
|
|||
uniform float waterFogDensity;
|
||||
uniform float waterFogKS;
|
||||
|
||||
vec3 getPositionEye();
|
||||
|
||||
vec3 srgb_to_linear(vec3 col);
|
||||
vec3 linear_to_srgb(vec3 col);
|
||||
|
||||
vec4 applyWaterFogView(vec3 pos, vec4 color)
|
||||
// get a water fog color that will apply the appropriate haze to a color given
|
||||
// a blend function of (ONE, SOURCE_ALPHA)
|
||||
vec4 getWaterFogViewNoClip(vec3 pos)
|
||||
{
|
||||
vec3 view = normalize(pos);
|
||||
//normalize view vector
|
||||
|
|
@ -67,38 +67,44 @@ vec4 applyWaterFogView(vec3 pos, vec4 color)
|
|||
float L = min(t1/t2*t3, 1.0);
|
||||
|
||||
float D = pow(0.98, l*kd);
|
||||
|
||||
color.rgb = color.rgb * D + kc.rgb * L;
|
||||
|
||||
return color;
|
||||
return vec4(srgb_to_linear(kc.rgb*L), D);
|
||||
}
|
||||
|
||||
vec4 applyWaterFogViewLinearNoClip(vec3 pos, vec4 color, vec3 sunlit)
|
||||
vec4 getWaterFogView(vec3 pos)
|
||||
{
|
||||
color.rgb = linear_to_srgb(color.rgb);
|
||||
color = applyWaterFogView(pos, color);
|
||||
color.rgb = srgb_to_linear(color.rgb);
|
||||
if (dot(pos, waterPlane.xyz) + waterPlane.w > 0.0)
|
||||
{
|
||||
return vec4(0,0,0,1);
|
||||
}
|
||||
|
||||
return getWaterFogViewNoClip(pos);
|
||||
}
|
||||
|
||||
vec4 applyWaterFogView(vec3 pos, vec4 color)
|
||||
{
|
||||
vec4 fogged = getWaterFogView(pos);
|
||||
|
||||
color.rgb = color.rgb * fogged.a + fogged.rgb;
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color, vec3 sunlit)
|
||||
vec4 applyWaterFogViewLinearNoClip(vec3 pos, vec4 color)
|
||||
{
|
||||
vec4 fogged = getWaterFogViewNoClip(pos);
|
||||
color.rgb *= fogged.a;
|
||||
color.rgb += fogged.rgb;
|
||||
return color;
|
||||
}
|
||||
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color)
|
||||
{
|
||||
if (dot(pos, waterPlane.xyz) + waterPlane.w > 0.0)
|
||||
{
|
||||
return color;
|
||||
}
|
||||
|
||||
return applyWaterFogViewLinearNoClip(pos, color, sunlit);
|
||||
}
|
||||
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color)
|
||||
{
|
||||
return applyWaterFogViewLinear(pos, color, vec3(1));
|
||||
}
|
||||
|
||||
vec4 applyWaterFog(vec4 color)
|
||||
{
|
||||
//normalize view vector
|
||||
return applyWaterFogViewLinear(getPositionEye(), color);
|
||||
return applyWaterFogViewLinearNoClip(pos, color);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@ vec3 getSunlitColor();
|
|||
vec3 getAmblitColor();
|
||||
vec3 getAdditiveColor();
|
||||
vec3 getAtmosAttenuation();
|
||||
vec3 getPositionEye();
|
||||
|
||||
uniform float scene_light_strength;
|
||||
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@ void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, ou
|
|||
|
||||
void calcAtmospherics(vec3 inPositionEye) {
|
||||
vec3 P = inPositionEye;
|
||||
setPositionEye(P);
|
||||
vec3 tmpsunlit = vec3(1);
|
||||
vec3 tmpamblit = vec3(1);
|
||||
vec3 tmpaddlit = vec3(1);
|
||||
|
|
|
|||
|
|
@ -44,5 +44,5 @@ vec3 getAdditiveColor()
|
|||
|
||||
vec3 getAtmosAttenuation()
|
||||
{
|
||||
return vec3(vary_AtmosAttenuation);
|
||||
return vary_AtmosAttenuation;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,7 +31,6 @@ vec3 additive_color;
|
|||
vec3 atmos_attenuation;
|
||||
vec3 sunlit_color;
|
||||
vec3 amblit_color;
|
||||
vec3 position_eye;
|
||||
|
||||
vec3 getSunlitColor()
|
||||
{
|
||||
|
|
@ -51,16 +50,6 @@ vec3 getAtmosAttenuation()
|
|||
return atmos_attenuation;
|
||||
}
|
||||
|
||||
vec3 getPositionEye()
|
||||
{
|
||||
return position_eye;
|
||||
}
|
||||
|
||||
void setPositionEye(vec3 v)
|
||||
{
|
||||
position_eye = v;
|
||||
}
|
||||
|
||||
void setSunlitColor(vec3 v)
|
||||
{
|
||||
sunlit_color = v;
|
||||
|
|
|
|||
|
|
@ -1,50 +0,0 @@
|
|||
/**
|
||||
* @file class2\wl\atmosphericVarsWaterF.glsl
|
||||
*
|
||||
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
|
||||
* Second Life Viewer Source Code
|
||||
* Copyright (C) 2007, 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$
|
||||
*/
|
||||
|
||||
in vec3 vary_PositionEye;
|
||||
in vec3 vary_AdditiveColor;
|
||||
in vec3 vary_AtmosAttenuation;
|
||||
|
||||
vec3 getSunlitColor()
|
||||
{
|
||||
return vec3(0,0,0);
|
||||
}
|
||||
vec3 getAmblitColor()
|
||||
{
|
||||
return vec3(0,0,0);
|
||||
}
|
||||
vec3 getAdditiveColor()
|
||||
{
|
||||
return vary_AdditiveColor;
|
||||
}
|
||||
vec3 getAtmosAttenuation()
|
||||
{
|
||||
return vary_AtmosAttenuation;
|
||||
}
|
||||
vec3 getPositionEye()
|
||||
{
|
||||
return vary_PositionEye;
|
||||
}
|
||||
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
/**
|
||||
* @file class2\wl\atmosphericVarsWaterV.glsl
|
||||
*
|
||||
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
|
||||
* Second Life Viewer Source Code
|
||||
* Copyright (C) 2007, 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$
|
||||
*/
|
||||
|
||||
out vec3 vary_PositionEye;
|
||||
out vec3 vary_AdditiveColor;
|
||||
out vec3 vary_AtmosAttenuation;
|
||||
|
||||
vec3 atmos_attenuation;
|
||||
vec3 sunlit_color;
|
||||
vec3 amblit_color;
|
||||
|
||||
vec3 getSunlitColor()
|
||||
{
|
||||
return sunlit_color;
|
||||
}
|
||||
vec3 getAmblitColor()
|
||||
{
|
||||
return amblit_color;
|
||||
}
|
||||
|
||||
vec3 getAdditiveColor()
|
||||
{
|
||||
return vary_AdditiveColor;
|
||||
}
|
||||
vec3 getAtmosAttenuation()
|
||||
{
|
||||
return atmos_attenuation;
|
||||
}
|
||||
|
||||
vec3 getPositionEye()
|
||||
{
|
||||
return vary_PositionEye;
|
||||
}
|
||||
|
||||
void setPositionEye(vec3 v)
|
||||
{
|
||||
vary_PositionEye = v;
|
||||
}
|
||||
|
||||
void setSunlitColor(vec3 v)
|
||||
{
|
||||
sunlit_color = v;
|
||||
}
|
||||
|
||||
void setAmblitColor(vec3 v)
|
||||
{
|
||||
amblit_color = v;
|
||||
}
|
||||
|
||||
void setAdditiveColor(vec3 v)
|
||||
{
|
||||
vary_AdditiveColor = v;
|
||||
}
|
||||
|
||||
void setAtmosAttenuation(vec3 v)
|
||||
{
|
||||
atmos_attenuation = v;
|
||||
vary_AtmosAttenuation = v;
|
||||
}
|
||||
|
|
@ -65,9 +65,7 @@ uniform vec3 light_diffuse[8];
|
|||
|
||||
void waterClip(vec3 pos);
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color, vec3 sunlit);
|
||||
#endif
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color);
|
||||
|
||||
vec3 srgb_to_linear(vec3 c);
|
||||
vec3 linear_to_srgb(vec3 c);
|
||||
|
|
@ -270,12 +268,6 @@ void main()
|
|||
|
||||
color.rgb *= diffuse_linear.rgb;
|
||||
|
||||
color.rgb = atmosFragLightingLinear(color.rgb, additive, atten);
|
||||
|
||||
#ifdef WATER_FOG
|
||||
color = applyWaterFogViewLinear(pos.xyz, color, sunlit_linear);
|
||||
#endif // WATER_FOG
|
||||
|
||||
vec4 light = vec4(0,0,0,0);
|
||||
|
||||
#define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, diffuse_linear.rgb, pos.xyz, norm, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, light_attenuation[i].w);
|
||||
|
|
@ -291,6 +283,10 @@ void main()
|
|||
// sum local light contrib in linear colorspace
|
||||
color.rgb += light.rgb;
|
||||
|
||||
color.rgb = atmosFragLightingLinear(color.rgb, additive, atten);
|
||||
|
||||
color = applyWaterFogViewLinear(pos.xyz, color);
|
||||
|
||||
#endif // #else // FOR_IMPOSTOR
|
||||
|
||||
#ifdef IS_HUD
|
||||
|
|
|
|||
|
|
@ -84,9 +84,7 @@ vec3 linear_to_srgb(vec3 c);
|
|||
void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 norm, vec3 light_dir, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive);
|
||||
vec3 atmosFragLightingLinear(vec3 color, vec3 additive, vec3 atten);
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color, vec3 sunlit);
|
||||
#endif
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color);
|
||||
|
||||
void calcHalfVectors(vec3 lv, vec3 n, vec3 v, out vec3 h, out vec3 l, out float nh, out float nl, out float nv, out float vh, out float lightDist);
|
||||
float calcLegacyDistanceAttenuation(float distance, float falloff);
|
||||
|
|
@ -228,13 +226,6 @@ void main()
|
|||
|
||||
color = pbrBaseLight(diffuseColor, specularColor, metallic, v, norm.xyz, perceptualRoughness, light_dir, sunlit_linear, scol, radiance, irradiance, colorEmissive, ao, additive, atten);
|
||||
|
||||
color.rgb = atmosFragLightingLinear(color.rgb, additive, atten);
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 temp = applyWaterFogViewLinear(pos, vec4(color, 0.0), sunlit_linear);
|
||||
color = temp.rgb;
|
||||
#endif
|
||||
|
||||
vec3 light = vec3(0);
|
||||
|
||||
// Punctual lights
|
||||
|
|
@ -250,7 +241,11 @@ void main()
|
|||
|
||||
color.rgb += light.rgb;
|
||||
|
||||
color.rgb = atmosFragLightingLinear(color.rgb, additive, atten);
|
||||
|
||||
vec4 temp = applyWaterFogViewLinear(pos, vec4(color, 0.0));
|
||||
color = temp.rgb;
|
||||
|
||||
float a = basecolor.a*vertex_color.a;
|
||||
|
||||
frag_color = max(vec4(color.rgb,a), vec4(0));
|
||||
|
|
|
|||
|
|
@ -40,6 +40,8 @@ in vec3 vary_position;
|
|||
uniform samplerCube environmentMap;
|
||||
|
||||
vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten);
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color);
|
||||
|
||||
void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
|
||||
|
||||
vec3 linear_to_srgb(vec3 c);
|
||||
|
|
@ -84,6 +86,7 @@ void main()
|
|||
|
||||
applyLegacyEnv(color.rgb, legacyenv, spec, pos, norm, env_intensity);
|
||||
color.rgb = atmosFragLighting(color.rgb, additive, atten);
|
||||
color = applyWaterFogViewLinear(pos.xyz, color);
|
||||
#endif
|
||||
|
||||
color.a = 1.0;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,109 @@
|
|||
/**
|
||||
* @file class3/deferred/hazeF.glsl
|
||||
*
|
||||
* $LicenseInfo:firstyear=2023&license=viewerlgpl$
|
||||
* Second Life Viewer Source Code
|
||||
* Copyright (C) 2023, 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$
|
||||
*/
|
||||
|
||||
out vec4 frag_color;
|
||||
|
||||
uniform sampler2D normalMap;
|
||||
|
||||
// Inputs
|
||||
uniform vec3 sun_dir;
|
||||
uniform vec3 moon_dir;
|
||||
uniform int sun_up_factor;
|
||||
in vec2 vary_fragcoord;
|
||||
|
||||
vec3 getNorm(vec2 pos_screen);
|
||||
vec4 getPositionWithDepth(vec2 pos_screen, float depth);
|
||||
void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 norm, vec3 light_dir, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive);
|
||||
|
||||
float getDepth(vec2 pos_screen);
|
||||
|
||||
vec3 linear_to_srgb(vec3 c);
|
||||
vec3 srgb_to_linear(vec3 c);
|
||||
|
||||
uniform vec4 waterPlane;
|
||||
|
||||
uniform int cube_snapshot;
|
||||
|
||||
uniform float sky_hdr_scale;
|
||||
|
||||
void main()
|
||||
{
|
||||
vec2 tc = vary_fragcoord.xy;
|
||||
float depth = getDepth(tc.xy);
|
||||
vec4 pos = getPositionWithDepth(tc, depth);
|
||||
vec4 norm = texture(normalMap, tc);
|
||||
norm.xyz = getNorm(tc);
|
||||
vec3 light_dir = (sun_up_factor == 1) ? sun_dir : moon_dir;
|
||||
|
||||
vec3 color = vec3(0);
|
||||
float bloom = 0.0;
|
||||
|
||||
vec3 sunlit;
|
||||
vec3 amblit;
|
||||
vec3 additive;
|
||||
vec3 atten;
|
||||
|
||||
calcAtmosphericVarsLinear(pos.xyz, norm.xyz, light_dir, sunlit, amblit, additive, atten);
|
||||
|
||||
vec3 sunlit_linear = srgb_to_linear(sunlit);
|
||||
vec3 amblit_linear = amblit;
|
||||
|
||||
bool do_atmospherics = false;
|
||||
|
||||
// mask off atmospherics below water
|
||||
if (dot(pos.xyz, waterPlane.xyz) + waterPlane.w > 0.0)
|
||||
{
|
||||
do_atmospherics = true;
|
||||
}
|
||||
|
||||
vec3 irradiance = vec3(0);
|
||||
vec3 radiance = vec3(0);
|
||||
|
||||
if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
|
||||
{
|
||||
}
|
||||
else if (!GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_ATMOS))
|
||||
{
|
||||
//should only be true of WL sky, just port over base color value
|
||||
discard;
|
||||
}
|
||||
|
||||
float alpha = 0.0;
|
||||
|
||||
if (do_atmospherics)
|
||||
{
|
||||
alpha = atten.r;
|
||||
color = srgb_to_linear(additive*2.0);
|
||||
color *= sky_hdr_scale;
|
||||
}
|
||||
else
|
||||
{
|
||||
color = vec3(0,0,0);
|
||||
alpha = 1.0;
|
||||
}
|
||||
|
||||
frag_color.rgb = max(color.rgb, vec3(0)); //output linear since local lights will be added to this shader's results
|
||||
frag_color.a = alpha;
|
||||
}
|
||||
|
|
@ -37,9 +37,7 @@
|
|||
uniform float emissive_brightness; // fullbright flag, 1.0 == fullbright, 0.0 otherwise
|
||||
uniform int sun_up_factor;
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color, vec3 sunlit);
|
||||
#endif
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color);
|
||||
|
||||
vec3 atmosFragLightingLinear(vec3 l, vec3 additive, vec3 atten);
|
||||
vec3 scaleSoftClipFragLinear(vec3 l);
|
||||
|
|
@ -386,13 +384,6 @@ void main()
|
|||
glare += cur_glare;
|
||||
}
|
||||
|
||||
color.rgb = atmosFragLightingLinear(color.rgb, additive, atten);
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 temp = applyWaterFogViewLinear(pos, vec4(color, 0.0), sunlit_linear);
|
||||
color = temp.rgb;
|
||||
#endif
|
||||
|
||||
vec3 npos = normalize(-pos.xyz);
|
||||
vec3 light = vec3(0, 0, 0);
|
||||
|
||||
|
|
@ -408,6 +399,11 @@ void main()
|
|||
|
||||
color += light;
|
||||
|
||||
color.rgb = atmosFragLightingLinear(color.rgb, additive, atten);
|
||||
|
||||
vec4 temp = applyWaterFogViewLinear(pos, vec4(color, 0.0));
|
||||
color = temp.rgb;
|
||||
|
||||
glare *= 1.0-emissive;
|
||||
glare = min(glare, 1.0);
|
||||
float al = max(diffcol.a, glare) * vertex_color.a;
|
||||
|
|
|
|||
|
|
@ -83,10 +83,6 @@ uniform vec4 waterPlane;
|
|||
|
||||
uniform int cube_snapshot;
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color);
|
||||
#endif
|
||||
|
||||
uniform float sky_hdr_scale;
|
||||
|
||||
void calcHalfVectors(vec3 lv, vec3 n, vec3 v, out vec3 h, out vec3 l, out float nh, out float nl, out float nv, out float vh, out float lightDist);
|
||||
|
|
@ -167,18 +163,6 @@ void main()
|
|||
vec3 sunlit_linear = srgb_to_linear(sunlit);
|
||||
vec3 amblit_linear = amblit;
|
||||
|
||||
bool do_atmospherics = false;
|
||||
|
||||
#ifndef WATER_FOG
|
||||
// when above water, mask off atmospherics below water
|
||||
if (dot(pos.xyz, waterPlane.xyz) + waterPlane.w > 0.0)
|
||||
{
|
||||
do_atmospherics = true;
|
||||
}
|
||||
#else
|
||||
do_atmospherics = true;
|
||||
#endif
|
||||
|
||||
vec3 irradiance = vec3(0);
|
||||
vec3 radiance = vec3(0);
|
||||
|
||||
|
|
@ -203,11 +187,6 @@ void main()
|
|||
|
||||
vec3 v = -normalize(pos.xyz);
|
||||
color = pbrBaseLight(diffuseColor, specularColor, metallic, v, norm.xyz, perceptualRoughness, light_dir, sunlit_linear, scol, radiance, irradiance, colorEmissive, ao, additive, atten);
|
||||
|
||||
if (do_atmospherics)
|
||||
{
|
||||
color = atmosFragLightingLinear(color, additive, atten);
|
||||
}
|
||||
}
|
||||
else if (!GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_ATMOS))
|
||||
{
|
||||
|
|
@ -273,21 +252,8 @@ void main()
|
|||
{ // add environment map
|
||||
applyLegacyEnv(color, legacyenv, spec, pos.xyz, norm.xyz, envIntensity);
|
||||
}
|
||||
|
||||
|
||||
if (do_atmospherics)
|
||||
{
|
||||
color = atmosFragLightingLinear(color, additive, atten);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef WATER_FOG
|
||||
vec4 fogged = applyWaterFogViewLinear(pos.xyz, vec4(color, bloom));
|
||||
color = fogged.rgb;
|
||||
#endif
|
||||
|
||||
frag_color.rgb = max(color.rgb, vec3(0)); //output linear since local lights will be added to this shader's results
|
||||
frag_color.a = 0.0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,58 @@
|
|||
/**
|
||||
* @file class3/deferred/waterHazeF.glsl
|
||||
*
|
||||
* $LicenseInfo:firstyear=2023&license=viewerlgpl$
|
||||
* Second Life Viewer Source Code
|
||||
* Copyright (C) 2023, 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$
|
||||
*/
|
||||
|
||||
out vec4 frag_color;
|
||||
|
||||
// Inputs
|
||||
in vec2 vary_fragcoord;
|
||||
|
||||
uniform sampler2D normalMap;
|
||||
|
||||
vec4 getPositionWithDepth(vec2 pos_screen, float depth);
|
||||
float getDepth(vec2 pos_screen);
|
||||
|
||||
vec4 getWaterFogView(vec3 pos);
|
||||
|
||||
void main()
|
||||
{
|
||||
vec2 tc = vary_fragcoord.xy;
|
||||
float depth = getDepth(tc.xy);
|
||||
vec4 pos = getPositionWithDepth(tc, depth);
|
||||
vec4 norm = texture(normalMap, tc);
|
||||
|
||||
if (GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_PBR))
|
||||
{
|
||||
}
|
||||
else if (!GET_GBUFFER_FLAG(GBUFFER_FLAG_HAS_ATMOS))
|
||||
{
|
||||
//should only be true of WL sky, just port over base color value
|
||||
discard;
|
||||
}
|
||||
|
||||
vec4 fogged = getWaterFogView(pos.xyz);
|
||||
|
||||
frag_color.rgb = max(fogged.rgb, vec3(0)); //output linear since local lights will be added to this shader's results
|
||||
frag_color.a = fogged.a;
|
||||
}
|
||||
|
|
@ -55,7 +55,7 @@ in vec4 littleWave;
|
|||
in vec4 view;
|
||||
in vec3 vary_position;
|
||||
|
||||
vec4 applyWaterFogViewLinearNoClip(vec3 pos, vec4 color, vec3 sunlit);
|
||||
vec4 applyWaterFogViewLinearNoClip(vec3 pos, vec4 color);
|
||||
|
||||
void main()
|
||||
{
|
||||
|
|
@ -77,5 +77,5 @@ void main()
|
|||
vec4 fb = vec4(waterFogColorLinear, 0.0);
|
||||
#endif
|
||||
|
||||
frag_color = max(applyWaterFogViewLinearNoClip(vary_position, fb, vec3(1)), vec4(0));
|
||||
frag_color = max(applyWaterFogViewLinearNoClip(vary_position, fb), vec4(0));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen);
|
|||
vec3 scaleSoftClipFragLinear(vec3 l);
|
||||
vec3 atmosFragLightingLinear(vec3 light, vec3 additive, vec3 atten);
|
||||
void calcAtmosphericVarsLinear(vec3 inPositionEye, vec3 norm, vec3 light_dir, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive);
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color, vec3 sunlit);
|
||||
vec4 applyWaterFogViewLinear(vec3 pos, vec4 color);
|
||||
|
||||
// PBR interface
|
||||
vec2 BRDF(float NoV, float roughness);
|
||||
|
|
@ -223,7 +223,6 @@ void main()
|
|||
refPos = getPositionWithNDC(vec3(distort2 * 2.0 - vec2(1.0), depth * 2.0 - 1.0));
|
||||
}
|
||||
|
||||
fb = applyWaterFogViewLinear(refPos, fb, sunlit);
|
||||
#else
|
||||
vec4 fb = applyWaterFogViewLinear(viewVec*2048.0, vec4(1.0), sunlit_linear);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -178,27 +178,24 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
|
|||
|
||||
fullbright_shader =
|
||||
(LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
|
||||
(LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterAlphaProgram :
|
||||
(LLPipeline::sRenderingHUDs) ? &gHUDFullbrightAlphaMaskAlphaProgram :
|
||||
&gDeferredFullbrightAlphaMaskAlphaProgram;
|
||||
prepare_alpha_shader(fullbright_shader, true, true, water_sign);
|
||||
|
||||
simple_shader =
|
||||
(LLPipeline::sImpostorRender) ? &gDeferredAlphaImpostorProgram :
|
||||
(LLPipeline::sUnderWaterRender) ? &gDeferredAlphaWaterProgram :
|
||||
(LLPipeline::sRenderingHUDs) ? &gHUDAlphaProgram :
|
||||
&gDeferredAlphaProgram;
|
||||
|
||||
prepare_alpha_shader(simple_shader, false, true, water_sign); //prime simple shader (loads shadow relevant uniforms)
|
||||
|
||||
LLGLSLShader* materialShader = LLPipeline::sUnderWaterRender ? gDeferredMaterialWaterProgram : gDeferredMaterialProgram;
|
||||
LLGLSLShader* materialShader = gDeferredMaterialProgram;
|
||||
for (int i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
|
||||
{
|
||||
prepare_alpha_shader(&materialShader[i], false, true, water_sign);
|
||||
}
|
||||
|
||||
pbr_shader =
|
||||
(LLPipeline::sUnderWaterRender) ? &gDeferredPBRAlphaWaterProgram :
|
||||
(LLPipeline::sRenderingHUDs) ? &gHUDPBRAlphaProgram :
|
||||
&gDeferredPBRAlphaProgram;
|
||||
|
||||
|
|
@ -727,11 +724,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
|
|||
|
||||
llassert(mask < LLMaterial::SHADER_COUNT);
|
||||
target_shader = &(gDeferredMaterialProgram[mask]);
|
||||
|
||||
if (LLPipeline::sUnderWaterRender)
|
||||
{
|
||||
target_shader = &(gDeferredMaterialWaterProgram[mask]);
|
||||
}
|
||||
}
|
||||
else if (!params.mFullbright)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -509,14 +509,7 @@ void LLDrawPoolAvatar::beginRigid()
|
|||
|
||||
if (gPipeline.shadersLoaded())
|
||||
{
|
||||
if (LLPipeline::sUnderWaterRender)
|
||||
{
|
||||
sVertexProgram = &gObjectAlphaMaskNoColorWaterProgram;
|
||||
}
|
||||
else
|
||||
{
|
||||
sVertexProgram = &gObjectAlphaMaskNoColorProgram;
|
||||
}
|
||||
sVertexProgram = &gObjectAlphaMaskNoColorProgram;
|
||||
|
||||
if (sVertexProgram != NULL)
|
||||
{ //eyeballs render with the specular shader
|
||||
|
|
|
|||
|
|
@ -82,14 +82,7 @@ void LLDrawPoolMaterials::beginDeferredPass(S32 pass)
|
|||
|
||||
U32 idx = shader_idx[pass];
|
||||
|
||||
if (LLPipeline::sUnderWaterRender)
|
||||
{
|
||||
mShader = &(gDeferredMaterialWaterProgram[idx]);
|
||||
}
|
||||
else
|
||||
{
|
||||
mShader = &(gDeferredMaterialProgram[idx]);
|
||||
}
|
||||
mShader = &(gDeferredMaterialProgram[idx]);
|
||||
|
||||
if (rigged)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -193,10 +193,6 @@ void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
|
|||
{
|
||||
shader = &gHUDFullbrightProgram;
|
||||
}
|
||||
else if (LLPipeline::sUnderWaterRender)
|
||||
{
|
||||
shader = &gDeferredFullbrightWaterProgram;
|
||||
}
|
||||
else
|
||||
{
|
||||
shader = &gDeferredFullbrightProgram;
|
||||
|
|
@ -225,10 +221,6 @@ void LLDrawPoolFullbrightAlphaMask::renderPostDeferred(S32 pass)
|
|||
{
|
||||
shader = &gHUDFullbrightAlphaMaskProgram;
|
||||
}
|
||||
else if (LLPipeline::sUnderWaterRender)
|
||||
{
|
||||
shader = &gDeferredFullbrightAlphaMaskWaterProgram;
|
||||
}
|
||||
else
|
||||
{
|
||||
shader = &gDeferredFullbrightAlphaMaskProgram;
|
||||
|
|
|
|||
|
|
@ -983,7 +983,7 @@ void LLSettingsVOWater::applySpecial(void *ptarget, bool force)
|
|||
|
||||
LLEnvironment& env = LLEnvironment::instance();
|
||||
|
||||
auto group = LLGLSLShader::SG_WATER;
|
||||
auto group = LLGLSLShader::SG_ANY;
|
||||
LLShaderUniforms* shader = &((LLShaderUniforms*)ptarget)[group];
|
||||
|
||||
{
|
||||
|
|
|
|||
|
|
@ -50,6 +50,7 @@
|
|||
#include "llquaternion.h"
|
||||
#include "llwindow.h" // getPixelAspectRatio()
|
||||
#include "lltracerecording.h"
|
||||
#include "llenvironment.h"
|
||||
|
||||
// System includes
|
||||
#include <iomanip> // for setprecision
|
||||
|
|
@ -96,35 +97,37 @@ LLViewerCamera::LLViewerCamera() : LLCamera()
|
|||
gSavedSettings.getControl("CameraAngle")->getCommitSignal()->connect(boost::bind(&LLViewerCamera::updateCameraAngle, this, _2));
|
||||
}
|
||||
|
||||
void LLViewerCamera::updateCameraLocation(const LLVector3 ¢er,
|
||||
const LLVector3 &up_direction,
|
||||
const LLVector3 &point_of_interest)
|
||||
void LLViewerCamera::updateCameraLocation(const LLVector3 ¢er, const LLVector3 &up_direction, const LLVector3 &point_of_interest)
|
||||
{
|
||||
// do not update if avatar didn't move
|
||||
if (!LLViewerJoystick::getInstance()->getCameraNeedsUpdate())
|
||||
{
|
||||
return;
|
||||
}
|
||||
// do not update if avatar didn't move
|
||||
if (!LLViewerJoystick::getInstance()->getCameraNeedsUpdate())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
LLVector3 last_position;
|
||||
LLVector3 last_axis;
|
||||
last_position = getOrigin();
|
||||
last_axis = getAtAxis();
|
||||
LLVector3 last_position;
|
||||
LLVector3 last_axis;
|
||||
last_position = getOrigin();
|
||||
last_axis = getAtAxis();
|
||||
|
||||
mLastPointOfInterest = point_of_interest;
|
||||
mLastPointOfInterest = point_of_interest;
|
||||
|
||||
LLViewerRegion * regp = gAgent.getRegion();
|
||||
F32 water_height = (NULL != regp) ? regp->getWaterHeight() : 0.f;
|
||||
LLViewerRegion *regp = gAgent.getRegion();
|
||||
F32 water_height = (NULL != regp) ? regp->getWaterHeight() : 0.f;
|
||||
|
||||
LLVector3 origin = center;
|
||||
if (origin.mV[2] > water_height)
|
||||
{
|
||||
origin.mV[2] = llmax(origin.mV[2], water_height+0.20f);
|
||||
}
|
||||
else
|
||||
{
|
||||
origin.mV[2] = llmin(origin.mV[2], water_height-0.20f);
|
||||
}
|
||||
LLVector3 origin = center;
|
||||
|
||||
if (LLEnvironment::instance().getCurrentWater()->getFogMod() != 1.f)
|
||||
{
|
||||
if (origin.mV[2] > water_height)
|
||||
{
|
||||
origin.mV[2] = llmax(origin.mV[2], water_height + 0.20f);
|
||||
}
|
||||
else
|
||||
{
|
||||
origin.mV[2] = llmin(origin.mV[2], water_height - 0.20f);
|
||||
}
|
||||
}
|
||||
|
||||
setOriginAndLookAt(origin, up_direction, point_of_interest);
|
||||
|
||||
|
|
|
|||
|
|
@ -99,7 +99,6 @@ LLGLSLShader gSkinnedObjectFullbrightAlphaMaskProgram;
|
|||
LLGLSLShader gObjectBumpProgram;
|
||||
LLGLSLShader gSkinnedObjectBumpProgram;
|
||||
LLGLSLShader gObjectAlphaMaskNoColorProgram;
|
||||
LLGLSLShader gObjectAlphaMaskNoColorWaterProgram;
|
||||
|
||||
//environment shaders
|
||||
LLGLSLShader gWaterProgram;
|
||||
|
|
@ -138,7 +137,6 @@ LLGLSLShader gDeferredSkinnedDiffuseProgram;
|
|||
LLGLSLShader gDeferredSkinnedBumpProgram;
|
||||
LLGLSLShader gDeferredBumpProgram;
|
||||
LLGLSLShader gDeferredTerrainProgram;
|
||||
LLGLSLShader gDeferredTerrainWaterProgram;
|
||||
LLGLSLShader gDeferredTreeProgram;
|
||||
LLGLSLShader gDeferredTreeShadowProgram;
|
||||
LLGLSLShader gDeferredSkinnedTreeShadowProgram;
|
||||
|
|
@ -149,9 +147,10 @@ LLGLSLShader gDeferredMultiLightProgram[16];
|
|||
LLGLSLShader gDeferredSpotLightProgram;
|
||||
LLGLSLShader gDeferredMultiSpotLightProgram;
|
||||
LLGLSLShader gDeferredSunProgram;
|
||||
LLGLSLShader gHazeProgram;
|
||||
LLGLSLShader gHazeWaterProgram;
|
||||
LLGLSLShader gDeferredBlurLightProgram;
|
||||
LLGLSLShader gDeferredSoftenProgram;
|
||||
LLGLSLShader gDeferredSoftenWaterProgram;
|
||||
LLGLSLShader gDeferredShadowProgram;
|
||||
LLGLSLShader gDeferredSkinnedShadowProgram;
|
||||
LLGLSLShader gDeferredShadowCubeProgram;
|
||||
|
|
@ -171,8 +170,6 @@ LLGLSLShader gHUDAlphaProgram;
|
|||
LLGLSLShader gDeferredSkinnedAlphaProgram;
|
||||
LLGLSLShader gDeferredAlphaImpostorProgram;
|
||||
LLGLSLShader gDeferredSkinnedAlphaImpostorProgram;
|
||||
LLGLSLShader gDeferredAlphaWaterProgram;
|
||||
LLGLSLShader gDeferredSkinnedAlphaWaterProgram;
|
||||
LLGLSLShader gDeferredAvatarEyesProgram;
|
||||
LLGLSLShader gDeferredFullbrightProgram;
|
||||
LLGLSLShader gHUDFullbrightProgram;
|
||||
|
|
@ -180,12 +177,6 @@ LLGLSLShader gDeferredFullbrightAlphaMaskProgram;
|
|||
LLGLSLShader gHUDFullbrightAlphaMaskProgram;
|
||||
LLGLSLShader gDeferredFullbrightAlphaMaskAlphaProgram;
|
||||
LLGLSLShader gHUDFullbrightAlphaMaskAlphaProgram;
|
||||
LLGLSLShader gDeferredFullbrightWaterProgram;
|
||||
LLGLSLShader gDeferredSkinnedFullbrightWaterProgram;
|
||||
LLGLSLShader gDeferredFullbrightWaterAlphaProgram;
|
||||
LLGLSLShader gDeferredSkinnedFullbrightWaterAlphaProgram;
|
||||
LLGLSLShader gDeferredFullbrightAlphaMaskWaterProgram;
|
||||
LLGLSLShader gDeferredSkinnedFullbrightAlphaMaskWaterProgram;
|
||||
LLGLSLShader gDeferredEmissiveProgram;
|
||||
LLGLSLShader gDeferredSkinnedEmissiveProgram;
|
||||
LLGLSLShader gDeferredPostProgram;
|
||||
|
|
@ -215,7 +206,6 @@ LLGLSLShader gDeferredBufferVisualProgram;
|
|||
|
||||
// Deferred materials shaders
|
||||
LLGLSLShader gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
|
||||
LLGLSLShader gDeferredMaterialWaterProgram[LLMaterial::SHADER_COUNT*2];
|
||||
LLGLSLShader gHUDPBROpaqueProgram;
|
||||
LLGLSLShader gPBRGlowProgram;
|
||||
LLGLSLShader gPBRGlowSkinnedProgram;
|
||||
|
|
@ -224,8 +214,6 @@ LLGLSLShader gDeferredSkinnedPBROpaqueProgram;
|
|||
LLGLSLShader gHUDPBRAlphaProgram;
|
||||
LLGLSLShader gDeferredPBRAlphaProgram;
|
||||
LLGLSLShader gDeferredSkinnedPBRAlphaProgram;
|
||||
LLGLSLShader gDeferredPBRAlphaWaterProgram;
|
||||
LLGLSLShader gDeferredSkinnedPBRAlphaWaterProgram;
|
||||
|
||||
//helper for making a rigged variant of a given shader
|
||||
bool make_rigged_variant(LLGLSLShader& shader, LLGLSLShader& riggedShader)
|
||||
|
|
@ -258,30 +246,22 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
|
|||
mShaderList.push_back(&gObjectFullbrightAlphaMaskProgram);
|
||||
mShaderList.push_back(&gSkinnedObjectFullbrightAlphaMaskProgram);
|
||||
mShaderList.push_back(&gObjectAlphaMaskNoColorProgram);
|
||||
mShaderList.push_back(&gObjectAlphaMaskNoColorWaterProgram);
|
||||
mShaderList.push_back(&gUnderWaterProgram);
|
||||
mShaderList.push_back(&gDeferredSunProgram);
|
||||
mShaderList.push_back(&gHazeProgram);
|
||||
mShaderList.push_back(&gHazeWaterProgram);
|
||||
mShaderList.push_back(&gDeferredSoftenProgram);
|
||||
mShaderList.push_back(&gDeferredSoftenWaterProgram);
|
||||
mShaderList.push_back(&gDeferredAlphaProgram);
|
||||
mShaderList.push_back(&gHUDAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredAlphaImpostorProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedAlphaImpostorProgram);
|
||||
mShaderList.push_back(&gDeferredAlphaWaterProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedAlphaWaterProgram);
|
||||
mShaderList.push_back(&gDeferredFullbrightProgram);
|
||||
mShaderList.push_back(&gHUDFullbrightProgram);
|
||||
mShaderList.push_back(&gDeferredFullbrightAlphaMaskProgram);
|
||||
mShaderList.push_back(&gHUDFullbrightAlphaMaskProgram);
|
||||
mShaderList.push_back(&gDeferredFullbrightAlphaMaskAlphaProgram);
|
||||
mShaderList.push_back(&gHUDFullbrightAlphaMaskAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredFullbrightWaterProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedFullbrightWaterProgram);
|
||||
mShaderList.push_back(&gDeferredFullbrightWaterAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedFullbrightWaterAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredFullbrightAlphaMaskWaterProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedFullbrightAlphaMaskWaterProgram);
|
||||
mShaderList.push_back(&gDeferredFullbrightShinyProgram);
|
||||
mShaderList.push_back(&gHUDFullbrightShinyProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedFullbrightShinyProgram);
|
||||
|
|
@ -291,17 +271,14 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
|
|||
mShaderList.push_back(&gDeferredEmissiveProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedEmissiveProgram);
|
||||
mShaderList.push_back(&gDeferredAvatarEyesProgram);
|
||||
mShaderList.push_back(&gDeferredTerrainWaterProgram);
|
||||
mShaderList.push_back(&gDeferredAvatarAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredAvatarAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredWLSkyProgram);
|
||||
mShaderList.push_back(&gDeferredWLCloudProgram);
|
||||
mShaderList.push_back(&gDeferredWLMoonProgram);
|
||||
mShaderList.push_back(&gDeferredWLSunProgram);
|
||||
mShaderList.push_back(&gDeferredPBRAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredPBRAlphaWaterProgram);
|
||||
mShaderList.push_back(&gHUDPBRAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedPBRAlphaProgram);
|
||||
mShaderList.push_back(&gDeferredSkinnedPBRAlphaWaterProgram);
|
||||
mShaderList.push_back(&gDeferredPostGammaCorrectProgram); // for gamma
|
||||
mShaderList.push_back(&gNoPostGammaCorrectProgram);
|
||||
mShaderList.push_back(&gLegacyPostGammaCorrectProgram);
|
||||
|
|
@ -594,7 +571,6 @@ std::string LLViewerShaderMgr::loadBasicShaders()
|
|||
|
||||
vector< pair<string, S32> > shaders;
|
||||
shaders.push_back( make_pair( "windlight/atmosphericsVarsV.glsl", mShaderLevel[SHADER_WINDLIGHT] ) );
|
||||
shaders.push_back( make_pair( "windlight/atmosphericsVarsWaterV.glsl", mShaderLevel[SHADER_WINDLIGHT] ) );
|
||||
shaders.push_back( make_pair( "windlight/atmosphericsHelpersV.glsl", mShaderLevel[SHADER_WINDLIGHT] ) );
|
||||
shaders.push_back( make_pair( "lighting/lightFuncV.glsl", mShaderLevel[SHADER_LIGHTING] ) );
|
||||
shaders.push_back( make_pair( "lighting/sumLightsV.glsl", sum_lights_class ) );
|
||||
|
|
@ -674,7 +650,6 @@ std::string LLViewerShaderMgr::loadBasicShaders()
|
|||
|
||||
std::vector<S32> index_channels;
|
||||
index_channels.push_back(-1); shaders.push_back( make_pair( "windlight/atmosphericsVarsF.glsl", mShaderLevel[SHADER_WINDLIGHT] ) );
|
||||
index_channels.push_back(-1); shaders.push_back( make_pair( "windlight/atmosphericsVarsWaterF.glsl", mShaderLevel[SHADER_WINDLIGHT] ) );
|
||||
index_channels.push_back(-1); shaders.push_back( make_pair( "windlight/atmosphericsHelpersF.glsl", mShaderLevel[SHADER_WINDLIGHT] ) );
|
||||
index_channels.push_back(-1); shaders.push_back( make_pair( "windlight/gammaF.glsl", mShaderLevel[SHADER_WINDLIGHT]) );
|
||||
index_channels.push_back(-1); shaders.push_back( make_pair( "windlight/atmosphericsFuncs.glsl", mShaderLevel[SHADER_WINDLIGHT] ) );
|
||||
|
|
@ -908,7 +883,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredSkinnedBumpProgram.unload();
|
||||
gDeferredImpostorProgram.unload();
|
||||
gDeferredTerrainProgram.unload();
|
||||
gDeferredTerrainWaterProgram.unload();
|
||||
gDeferredLightProgram.unload();
|
||||
for (U32 i = 0; i < LL_DEFERRED_MULTI_LIGHT_COUNT; ++i)
|
||||
{
|
||||
|
|
@ -919,7 +893,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredSunProgram.unload();
|
||||
gDeferredBlurLightProgram.unload();
|
||||
gDeferredSoftenProgram.unload();
|
||||
gDeferredSoftenWaterProgram.unload();
|
||||
gDeferredShadowProgram.unload();
|
||||
gDeferredSkinnedShadowProgram.unload();
|
||||
gDeferredShadowCubeProgram.unload();
|
||||
|
|
@ -937,20 +910,12 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredAlphaProgram.unload();
|
||||
gHUDAlphaProgram.unload();
|
||||
gDeferredSkinnedAlphaProgram.unload();
|
||||
gDeferredAlphaWaterProgram.unload();
|
||||
gDeferredSkinnedAlphaWaterProgram.unload();
|
||||
gDeferredFullbrightProgram.unload();
|
||||
gHUDFullbrightProgram.unload();
|
||||
gDeferredFullbrightAlphaMaskProgram.unload();
|
||||
gHUDFullbrightAlphaMaskProgram.unload();
|
||||
gDeferredFullbrightAlphaMaskAlphaProgram.unload();
|
||||
gHUDFullbrightAlphaMaskAlphaProgram.unload();
|
||||
gDeferredFullbrightWaterProgram.unload();
|
||||
gDeferredSkinnedFullbrightWaterProgram.unload();
|
||||
gDeferredFullbrightWaterAlphaProgram.unload();
|
||||
gDeferredSkinnedFullbrightWaterAlphaProgram.unload();
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.unload();
|
||||
gDeferredSkinnedFullbrightAlphaMaskWaterProgram.unload();
|
||||
gDeferredEmissiveProgram.unload();
|
||||
gDeferredSkinnedEmissiveProgram.unload();
|
||||
gDeferredAvatarEyesProgram.unload();
|
||||
|
|
@ -984,7 +949,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
for (U32 i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
|
||||
{
|
||||
gDeferredMaterialProgram[i].unload();
|
||||
gDeferredMaterialWaterProgram[i].unload();
|
||||
}
|
||||
|
||||
gHUDPBROpaqueProgram.unload();
|
||||
|
|
@ -993,8 +957,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredSkinnedPBROpaqueProgram.unload();
|
||||
gDeferredPBRAlphaProgram.unload();
|
||||
gDeferredSkinnedPBRAlphaProgram.unload();
|
||||
gDeferredPBRAlphaWaterProgram.unload();
|
||||
gDeferredSkinnedPBRAlphaWaterProgram.unload();
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
|
@ -1084,15 +1046,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredMaterialProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
|
||||
|
||||
gDeferredMaterialWaterProgram[1].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialWaterProgram[5].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialWaterProgram[9].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialWaterProgram[13].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialWaterProgram[1+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialWaterProgram[5+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialWaterProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
|
||||
gDeferredMaterialWaterProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = false;
|
||||
|
||||
for (U32 i = 0; i < LLMaterial::SHADER_COUNT*2; ++i)
|
||||
{
|
||||
if (success)
|
||||
|
|
@ -1158,77 +1111,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
success = gDeferredMaterialProgram[i].createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
mShaderList.push_back(&gDeferredMaterialWaterProgram[i]);
|
||||
|
||||
gDeferredMaterialWaterProgram[i].mName = llformat("Deferred Underwater Material Shader %d", i);
|
||||
|
||||
U32 alpha_mode = i & 0x3;
|
||||
|
||||
gDeferredMaterialWaterProgram[i].mShaderFiles.clear();
|
||||
gDeferredMaterialWaterProgram[i].mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER));
|
||||
gDeferredMaterialWaterProgram[i].mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER));
|
||||
gDeferredMaterialWaterProgram[i].mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
gDeferredMaterialWaterProgram[i].mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
|
||||
gDeferredMaterialWaterProgram[i].clearPermutations();
|
||||
|
||||
bool has_normal_map = (i & 0x8) > 0;
|
||||
bool has_specular_map = (i & 0x4) > 0;
|
||||
|
||||
if (has_normal_map)
|
||||
{
|
||||
gDeferredMaterialWaterProgram[i].addPermutation("HAS_NORMAL_MAP", "1");
|
||||
}
|
||||
|
||||
if (has_specular_map)
|
||||
{
|
||||
gDeferredMaterialWaterProgram[i].addPermutation("HAS_SPECULAR_MAP", "1");
|
||||
}
|
||||
|
||||
gDeferredMaterialWaterProgram[i].addPermutation("DIFFUSE_ALPHA_MODE", llformat("%d", alpha_mode));
|
||||
if (alpha_mode != 0)
|
||||
{
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasAlphaMask = true;
|
||||
gDeferredMaterialWaterProgram[i].addPermutation("HAS_ALPHA_MASK", "1");
|
||||
}
|
||||
|
||||
if (use_sun_shadow)
|
||||
{
|
||||
gDeferredMaterialWaterProgram[i].addPermutation("HAS_SUN_SHADOW", "1");
|
||||
}
|
||||
|
||||
bool has_skin = i & 0x10;
|
||||
if (has_skin)
|
||||
{
|
||||
gDeferredMaterialWaterProgram[i].addPermutation("HAS_SKIN", "1");
|
||||
}
|
||||
else
|
||||
{
|
||||
gDeferredMaterialWaterProgram[i].mRiggedVariant = &(gDeferredMaterialWaterProgram[i + 0x10]);
|
||||
}
|
||||
gDeferredMaterialWaterProgram[i].addPermutation("WATER_FOG","1");
|
||||
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasReflectionProbes = true;
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasWaterFog = true;
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasSrgb = true;
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.encodesNormal = true;
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.calculatesAtmospherics = true;
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasAtmospherics = true;
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasGamma = true;
|
||||
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasShadows = use_sun_shadow;
|
||||
|
||||
if (has_skin)
|
||||
{
|
||||
gDeferredMaterialWaterProgram[i].mFeatures.hasObjectSkinning = true;
|
||||
}
|
||||
|
||||
success = gDeferredMaterialWaterProgram[i].createShader(NULL, NULL);//&mWLUniforms);
|
||||
llassert(success);
|
||||
}
|
||||
}
|
||||
|
||||
gDeferredMaterialProgram[1].mFeatures.hasLighting = true;
|
||||
|
|
@ -1240,15 +1122,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredMaterialProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
|
||||
|
||||
gDeferredMaterialWaterProgram[1].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialWaterProgram[5].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialWaterProgram[9].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialWaterProgram[13].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialWaterProgram[1+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialWaterProgram[5+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialWaterProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
|
||||
gDeferredMaterialWaterProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredPBROpaqueProgram.mName = "Deferred PBR Opaque Shader";
|
||||
|
|
@ -1356,62 +1229,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
shader->mRiggedVariant->mFeatures.hasLighting = true;
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
LLGLSLShader* shader = &gDeferredPBRAlphaWaterProgram;
|
||||
shader->mName = "Deferred PBR Alpha Underwater Shader";
|
||||
|
||||
shader->mFeatures.calculatesLighting = false;
|
||||
shader->mFeatures.hasLighting = false;
|
||||
shader->mFeatures.isAlphaLighting = true;
|
||||
shader->mFeatures.hasWaterFog = true;
|
||||
shader->mFeatures.hasSrgb = true;
|
||||
shader->mFeatures.encodesNormal = true;
|
||||
shader->mFeatures.calculatesAtmospherics = true;
|
||||
shader->mFeatures.hasAtmospherics = true;
|
||||
shader->mFeatures.hasGamma = true;
|
||||
shader->mFeatures.hasShadows = use_sun_shadow;
|
||||
shader->mFeatures.isDeferred = true; // include deferredUtils
|
||||
shader->mFeatures.hasReflectionProbes = mShaderLevel[SHADER_DEFERRED];
|
||||
|
||||
shader->mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
|
||||
shader->mShaderFiles.clear();
|
||||
shader->mShaderFiles.push_back(make_pair("deferred/pbralphaV.glsl", GL_VERTEX_SHADER));
|
||||
shader->mShaderFiles.push_back(make_pair("deferred/pbralphaF.glsl", GL_FRAGMENT_SHADER));
|
||||
|
||||
shader->clearPermutations();
|
||||
|
||||
U32 alpha_mode = LLMaterial::DIFFUSE_ALPHA_MODE_BLEND;
|
||||
shader->addPermutation("DIFFUSE_ALPHA_MODE", llformat("%d", alpha_mode));
|
||||
shader->addPermutation("HAS_NORMAL_MAP", "1");
|
||||
shader->addPermutation("HAS_SPECULAR_MAP", "1"); // PBR: Packed: Occlusion, Metal, Roughness
|
||||
shader->addPermutation("HAS_EMISSIVE_MAP", "1");
|
||||
shader->addPermutation("USE_VERTEX_COLOR", "1");
|
||||
shader->addPermutation("WATER_FOG", "1");
|
||||
|
||||
if (use_sun_shadow)
|
||||
{
|
||||
shader->addPermutation("HAS_SUN_SHADOW", "1");
|
||||
}
|
||||
|
||||
shader->mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
success = make_rigged_variant(*shader, gDeferredSkinnedPBRAlphaWaterProgram);
|
||||
if (success)
|
||||
{
|
||||
success = shader->createShader(NULL, NULL);
|
||||
}
|
||||
llassert(success);
|
||||
|
||||
// Alpha Shader Hack
|
||||
// See: LLRender::syncMatrices()
|
||||
shader->mFeatures.calculatesLighting = true;
|
||||
shader->mFeatures.hasLighting = true;
|
||||
|
||||
shader->mRiggedVariant->mFeatures.calculatesLighting = true;
|
||||
shader->mRiggedVariant->mFeatures.hasLighting = true;
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
LLGLSLShader* shader = &gHUDPBRAlphaProgram;
|
||||
|
|
@ -1737,68 +1554,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
}
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
LLGLSLShader* shader[] = {
|
||||
&gDeferredAlphaWaterProgram,
|
||||
&gDeferredSkinnedAlphaWaterProgram
|
||||
};
|
||||
|
||||
gDeferredAlphaWaterProgram.mRiggedVariant = &gDeferredSkinnedAlphaWaterProgram;
|
||||
|
||||
gDeferredAlphaWaterProgram.mName = "Deferred Alpha Underwater Shader";
|
||||
gDeferredSkinnedAlphaWaterProgram.mName = "Deferred Skinned Alpha Underwater Shader";
|
||||
|
||||
for (int i = 0; i < 2 && success; ++i)
|
||||
{
|
||||
shader[i]->mFeatures.calculatesLighting = false;
|
||||
shader[i]->mFeatures.hasLighting = false;
|
||||
shader[i]->mFeatures.isAlphaLighting = true;
|
||||
shader[i]->mFeatures.disableTextureIndex = true; //hack to disable auto-setup of texture channels
|
||||
shader[i]->mFeatures.hasWaterFog = true;
|
||||
shader[i]->mFeatures.hasSrgb = true;
|
||||
shader[i]->mFeatures.encodesNormal = true;
|
||||
shader[i]->mFeatures.calculatesAtmospherics = true;
|
||||
shader[i]->mFeatures.hasAtmospherics = true;
|
||||
shader[i]->mFeatures.hasGamma = true;
|
||||
shader[i]->mFeatures.hasShadows = use_sun_shadow;
|
||||
shader[i]->mFeatures.hasReflectionProbes = true;
|
||||
shader[i]->mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
|
||||
shader[i]->mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
shader[i]->mShaderFiles.clear();
|
||||
shader[i]->mShaderFiles.push_back(make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
|
||||
shader[i]->mShaderFiles.push_back(make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER));
|
||||
|
||||
shader[i]->clearPermutations();
|
||||
shader[i]->addPermutation("USE_INDEXED_TEX", "1");
|
||||
shader[i]->addPermutation("WATER_FOG", "1");
|
||||
shader[i]->addPermutation("USE_VERTEX_COLOR", "1");
|
||||
shader[i]->addPermutation("HAS_ALPHA_MASK", "1");
|
||||
if (use_sun_shadow)
|
||||
{
|
||||
shader[i]->addPermutation("HAS_SUN_SHADOW", "1");
|
||||
}
|
||||
|
||||
if (i == 1)
|
||||
{ // rigged variant
|
||||
shader[i]->mFeatures.hasObjectSkinning = true;
|
||||
shader[i]->addPermutation("HAS_SKIN", "1");
|
||||
}
|
||||
else
|
||||
{
|
||||
shader[i]->mRiggedVariant = shader[1];
|
||||
}
|
||||
shader[i]->mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
|
||||
success = shader[i]->createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
|
||||
// Hack
|
||||
shader[i]->mFeatures.calculatesLighting = true;
|
||||
shader[i]->mFeatures.hasLighting = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredAvatarEyesProgram.mName = "Deferred Avatar Eyes Shader";
|
||||
|
|
@ -1825,6 +1580,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredFullbrightProgram.mFeatures.hasGamma = true;
|
||||
gDeferredFullbrightProgram.mFeatures.hasAtmospherics = true;
|
||||
gDeferredFullbrightProgram.mFeatures.hasSrgb = true;
|
||||
gDeferredFullbrightProgram.mFeatures.hasWaterFog = true;
|
||||
gDeferredFullbrightProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
|
||||
gDeferredFullbrightProgram.mShaderFiles.clear();
|
||||
gDeferredFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
|
||||
|
|
@ -1860,6 +1616,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredFullbrightAlphaMaskProgram.mFeatures.hasGamma = true;
|
||||
gDeferredFullbrightAlphaMaskProgram.mFeatures.hasAtmospherics = true;
|
||||
gDeferredFullbrightAlphaMaskProgram.mFeatures.hasSrgb = true;
|
||||
gDeferredFullbrightAlphaMaskProgram.mFeatures.hasWaterFog = true;
|
||||
gDeferredFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
|
||||
gDeferredFullbrightAlphaMaskProgram.mShaderFiles.clear();
|
||||
gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
|
||||
|
|
@ -1933,71 +1690,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredFullbrightWaterProgram.mName = "Deferred Fullbright Underwater Shader";
|
||||
gDeferredFullbrightWaterProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gDeferredFullbrightWaterProgram.mFeatures.hasGamma = true;
|
||||
gDeferredFullbrightWaterProgram.mFeatures.hasAtmospherics = true;
|
||||
gDeferredFullbrightWaterProgram.mFeatures.hasWaterFog = true;
|
||||
gDeferredFullbrightWaterProgram.mFeatures.hasSrgb = true;
|
||||
gDeferredFullbrightWaterProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
|
||||
gDeferredFullbrightWaterProgram.mShaderFiles.clear();
|
||||
gDeferredFullbrightWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
|
||||
gDeferredFullbrightWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
|
||||
gDeferredFullbrightWaterProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
gDeferredFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
gDeferredFullbrightWaterProgram.addPermutation("WATER_FOG","1");
|
||||
success = make_rigged_variant(gDeferredFullbrightWaterProgram, gDeferredSkinnedFullbrightWaterProgram);
|
||||
success = success && gDeferredFullbrightWaterProgram.createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredFullbrightWaterAlphaProgram.mName = "Deferred Fullbright Underwater Alpha Shader";
|
||||
gDeferredFullbrightWaterAlphaProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gDeferredFullbrightWaterAlphaProgram.mFeatures.hasGamma = true;
|
||||
gDeferredFullbrightWaterAlphaProgram.mFeatures.hasAtmospherics = true;
|
||||
gDeferredFullbrightWaterAlphaProgram.mFeatures.hasWaterFog = true;
|
||||
gDeferredFullbrightWaterAlphaProgram.mFeatures.hasSrgb = true;
|
||||
gDeferredFullbrightWaterAlphaProgram.mFeatures.isDeferred = true;
|
||||
gDeferredFullbrightWaterAlphaProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
|
||||
gDeferredFullbrightWaterAlphaProgram.mShaderFiles.clear();
|
||||
gDeferredFullbrightWaterAlphaProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
|
||||
gDeferredFullbrightWaterAlphaProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
|
||||
gDeferredFullbrightWaterAlphaProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
gDeferredFullbrightWaterAlphaProgram.mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
gDeferredFullbrightWaterAlphaProgram.clearPermutations();
|
||||
gDeferredFullbrightWaterAlphaProgram.addPermutation("WATER_FOG", "1");
|
||||
gDeferredFullbrightWaterAlphaProgram.addPermutation("IS_ALPHA", "1");
|
||||
success = make_rigged_variant(gDeferredFullbrightWaterAlphaProgram, gDeferredSkinnedFullbrightWaterAlphaProgram);
|
||||
success = success && gDeferredFullbrightWaterAlphaProgram.createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mName = "Deferred Fullbright Underwater Alpha Masking Shader";
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.hasGamma = true;
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.hasAtmospherics = true;
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.hasWaterFog = true;
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.hasSrgb = true;
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.clear();
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.clearPermutations();
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.addPermutation("HAS_ALPHA_MASK","1");
|
||||
gDeferredFullbrightAlphaMaskWaterProgram.addPermutation("WATER_FOG","1");
|
||||
success = make_rigged_variant(gDeferredFullbrightAlphaMaskWaterProgram, gDeferredSkinnedFullbrightAlphaMaskWaterProgram);
|
||||
success = success && gDeferredFullbrightAlphaMaskWaterProgram.createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredFullbrightShinyProgram.mName = "Deferred FullbrightShiny Shader";
|
||||
|
|
@ -2084,40 +1776,53 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredSoftenWaterProgram.mName = "Deferred Soften Underwater Shader";
|
||||
gDeferredSoftenWaterProgram.mShaderFiles.clear();
|
||||
gDeferredSoftenWaterProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER));
|
||||
gDeferredSoftenWaterProgram.mShaderFiles.push_back(make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER));
|
||||
if (success)
|
||||
{
|
||||
gHazeProgram.mName = "Haze Shader";
|
||||
gHazeProgram.mShaderFiles.clear();
|
||||
gHazeProgram.mFeatures.hasSrgb = true;
|
||||
gHazeProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gHazeProgram.mFeatures.hasAtmospherics = true;
|
||||
gHazeProgram.mFeatures.hasGamma = true;
|
||||
gHazeProgram.mFeatures.isDeferred = true;
|
||||
gHazeProgram.mFeatures.hasShadows = use_sun_shadow;
|
||||
gHazeProgram.mFeatures.hasReflectionProbes = mShaderLevel[SHADER_DEFERRED] > 2;
|
||||
|
||||
gDeferredSoftenWaterProgram.clearPermutations();
|
||||
gDeferredSoftenWaterProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
gDeferredSoftenWaterProgram.addPermutation("WATER_FOG", "1");
|
||||
gDeferredSoftenWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
gDeferredSoftenWaterProgram.mFeatures.hasWaterFog = true;
|
||||
gDeferredSoftenWaterProgram.mFeatures.hasSrgb = true;
|
||||
gDeferredSoftenWaterProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gDeferredSoftenWaterProgram.mFeatures.hasAtmospherics = true;
|
||||
gDeferredSoftenWaterProgram.mFeatures.hasGamma = true;
|
||||
gDeferredSoftenWaterProgram.mFeatures.isDeferred = true;
|
||||
gDeferredSoftenWaterProgram.mFeatures.hasShadows = use_sun_shadow;
|
||||
gDeferredSoftenWaterProgram.mFeatures.hasReflectionProbes = mShaderLevel[SHADER_DEFERRED] > 2;
|
||||
gHazeProgram.clearPermutations();
|
||||
gHazeProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER));
|
||||
gHazeProgram.mShaderFiles.push_back(make_pair("deferred/hazeF.glsl", GL_FRAGMENT_SHADER));
|
||||
|
||||
if (use_sun_shadow)
|
||||
{
|
||||
gDeferredSoftenWaterProgram.addPermutation("HAS_SUN_SHADOW", "1");
|
||||
}
|
||||
gHazeProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
|
||||
if (gSavedSettings.getBOOL("RenderDeferredSSAO"))
|
||||
{ //if using SSAO, take screen space light map into account as if shadows are enabled
|
||||
gDeferredSoftenWaterProgram.mShaderLevel = llmax(gDeferredSoftenWaterProgram.mShaderLevel, 2);
|
||||
gDeferredSoftenWaterProgram.addPermutation("HAS_SSAO", "1");
|
||||
}
|
||||
success = gHazeProgram.createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
|
||||
if (success)
|
||||
{
|
||||
gHazeWaterProgram.mName = "Water Haze Shader";
|
||||
gHazeWaterProgram.mShaderFiles.clear();
|
||||
gHazeWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
gHazeWaterProgram.mFeatures.hasWaterFog = true;
|
||||
gHazeWaterProgram.mFeatures.hasSrgb = true;
|
||||
gHazeWaterProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gHazeWaterProgram.mFeatures.hasAtmospherics = true;
|
||||
gHazeWaterProgram.mFeatures.hasGamma = true;
|
||||
gHazeWaterProgram.mFeatures.isDeferred = true;
|
||||
gHazeWaterProgram.mFeatures.hasShadows = use_sun_shadow;
|
||||
gHazeWaterProgram.mFeatures.hasReflectionProbes = mShaderLevel[SHADER_DEFERRED] > 2;
|
||||
|
||||
gHazeWaterProgram.clearPermutations();
|
||||
gHazeWaterProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER));
|
||||
gHazeWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterHazeF.glsl", GL_FRAGMENT_SHADER));
|
||||
|
||||
gHazeWaterProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
|
||||
success = gHazeWaterProgram.createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
success = gDeferredSoftenWaterProgram.createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
|
|
@ -2277,31 +1982,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredTerrainWaterProgram.mName = "Deferred Terrain Underwater Shader";
|
||||
gDeferredTerrainWaterProgram.mFeatures.encodesNormal = true;
|
||||
gDeferredTerrainWaterProgram.mFeatures.hasSrgb = true;
|
||||
gDeferredTerrainWaterProgram.mFeatures.calculatesLighting = false;
|
||||
gDeferredTerrainWaterProgram.mFeatures.hasLighting = false;
|
||||
gDeferredTerrainWaterProgram.mFeatures.isAlphaLighting = true;
|
||||
gDeferredTerrainWaterProgram.mFeatures.disableTextureIndex = true; //hack to disable auto-setup of texture channels
|
||||
gDeferredTerrainWaterProgram.mFeatures.hasWaterFog = true;
|
||||
gDeferredTerrainWaterProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gDeferredTerrainWaterProgram.mFeatures.hasAtmospherics = true;
|
||||
gDeferredTerrainWaterProgram.mFeatures.hasGamma = true;
|
||||
|
||||
gDeferredTerrainWaterProgram.mShaderFiles.clear();
|
||||
gDeferredTerrainWaterProgram.mShaderFiles.push_back(make_pair("deferred/terrainV.glsl", GL_VERTEX_SHADER));
|
||||
gDeferredTerrainWaterProgram.mShaderFiles.push_back(make_pair("deferred/terrainF.glsl", GL_FRAGMENT_SHADER));
|
||||
gDeferredTerrainWaterProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
|
||||
gDeferredTerrainWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
gDeferredTerrainWaterProgram.clearPermutations();
|
||||
gDeferredTerrainWaterProgram.addPermutation("WATER_FOG", "1");
|
||||
success = gDeferredTerrainWaterProgram.createShader(NULL, NULL);
|
||||
llassert(success);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gDeferredAvatarProgram.mName = "Deferred Avatar Shader";
|
||||
|
|
@ -2331,6 +2011,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
|
|||
gDeferredAvatarAlphaProgram.mFeatures.isDeferred = true;
|
||||
gDeferredAvatarAlphaProgram.mFeatures.hasShadows = true;
|
||||
gDeferredAvatarAlphaProgram.mFeatures.hasReflectionProbes = true;
|
||||
gDeferredAvatarAlphaProgram.mFeatures.hasWaterFog = true;
|
||||
|
||||
gDeferredAvatarAlphaProgram.mShaderFiles.clear();
|
||||
gDeferredAvatarAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
|
||||
|
|
@ -2660,24 +2341,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
|
|||
success = gObjectAlphaMaskNoColorProgram.createShader(NULL, NULL);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gObjectAlphaMaskNoColorWaterProgram.mName = "No color alpha mask Water Shader";
|
||||
gObjectAlphaMaskNoColorWaterProgram.mFeatures.calculatesLighting = true;
|
||||
gObjectAlphaMaskNoColorWaterProgram.mFeatures.calculatesAtmospherics = true;
|
||||
gObjectAlphaMaskNoColorWaterProgram.mFeatures.hasWaterFog = true;
|
||||
gObjectAlphaMaskNoColorWaterProgram.mFeatures.hasAtmospherics = true;
|
||||
gObjectAlphaMaskNoColorWaterProgram.mFeatures.hasLighting = true;
|
||||
gObjectAlphaMaskNoColorWaterProgram.mFeatures.disableTextureIndex = true;
|
||||
gObjectAlphaMaskNoColorWaterProgram.mFeatures.hasAlphaMask = true;
|
||||
gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.clear();
|
||||
gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleNoColorV.glsl", GL_VERTEX_SHADER));
|
||||
gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
|
||||
gObjectAlphaMaskNoColorWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
|
||||
gObjectAlphaMaskNoColorWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
|
||||
success = gObjectAlphaMaskNoColorWaterProgram.createShader(NULL, NULL);
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
gImpostorProgram.mName = "Impostor Shader";
|
||||
|
|
|
|||
|
|
@ -175,7 +175,6 @@ extern LLGLSLShader gSkinnedObjectFullbrightAlphaMaskProgram;
|
|||
extern LLGLSLShader gObjectBumpProgram;
|
||||
extern LLGLSLShader gSkinnedObjectBumpProgram;
|
||||
extern LLGLSLShader gObjectAlphaMaskNoColorProgram;
|
||||
extern LLGLSLShader gObjectAlphaMaskNoColorWaterProgram;
|
||||
|
||||
//environment shaders
|
||||
extern LLGLSLShader gWaterProgram;
|
||||
|
|
@ -211,7 +210,6 @@ extern LLGLSLShader gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram;
|
|||
extern LLGLSLShader gDeferredNonIndexedDiffuseProgram;
|
||||
extern LLGLSLShader gDeferredBumpProgram;
|
||||
extern LLGLSLShader gDeferredTerrainProgram;
|
||||
extern LLGLSLShader gDeferredTerrainWaterProgram;
|
||||
extern LLGLSLShader gDeferredTreeProgram;
|
||||
extern LLGLSLShader gDeferredTreeShadowProgram;
|
||||
extern LLGLSLShader gDeferredLightProgram;
|
||||
|
|
@ -219,10 +217,11 @@ extern LLGLSLShader gDeferredMultiLightProgram[LL_DEFERRED_MULTI_LIGHT_COUNT];
|
|||
extern LLGLSLShader gDeferredSpotLightProgram;
|
||||
extern LLGLSLShader gDeferredMultiSpotLightProgram;
|
||||
extern LLGLSLShader gDeferredSunProgram;
|
||||
extern LLGLSLShader gHazeProgram;
|
||||
extern LLGLSLShader gHazeWaterProgram;
|
||||
extern LLGLSLShader gDeferredBlurLightProgram;
|
||||
extern LLGLSLShader gDeferredAvatarProgram;
|
||||
extern LLGLSLShader gDeferredSoftenProgram;
|
||||
extern LLGLSLShader gDeferredSoftenWaterProgram;
|
||||
extern LLGLSLShader gDeferredShadowProgram;
|
||||
extern LLGLSLShader gDeferredShadowCubeProgram;
|
||||
extern LLGLSLShader gDeferredShadowAlphaMaskProgram;
|
||||
|
|
@ -251,10 +250,6 @@ extern LLGLSLShader gDeferredFullbrightAlphaMaskProgram;
|
|||
extern LLGLSLShader gHUDFullbrightAlphaMaskProgram;
|
||||
extern LLGLSLShader gDeferredFullbrightAlphaMaskAlphaProgram;
|
||||
extern LLGLSLShader gHUDFullbrightAlphaMaskAlphaProgram;
|
||||
extern LLGLSLShader gDeferredAlphaWaterProgram;
|
||||
extern LLGLSLShader gDeferredFullbrightWaterProgram;
|
||||
extern LLGLSLShader gDeferredFullbrightWaterAlphaProgram;
|
||||
extern LLGLSLShader gDeferredFullbrightAlphaMaskWaterProgram;
|
||||
extern LLGLSLShader gDeferredEmissiveProgram;
|
||||
extern LLGLSLShader gDeferredAvatarEyesProgram;
|
||||
extern LLGLSLShader gDeferredAvatarAlphaProgram;
|
||||
|
|
@ -271,12 +266,10 @@ extern LLGLSLShader gDeferredBufferVisualProgram;
|
|||
|
||||
// Deferred materials shaders
|
||||
extern LLGLSLShader gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
|
||||
extern LLGLSLShader gDeferredMaterialWaterProgram[LLMaterial::SHADER_COUNT*2];
|
||||
|
||||
extern LLGLSLShader gHUDPBROpaqueProgram;
|
||||
extern LLGLSLShader gPBRGlowProgram;
|
||||
extern LLGLSLShader gDeferredPBROpaqueProgram;
|
||||
extern LLGLSLShader gDeferredPBRAlphaProgram;
|
||||
extern LLGLSLShader gDeferredPBRAlphaWaterProgram;
|
||||
extern LLGLSLShader gHUDPBRAlphaProgram;
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -7875,7 +7875,7 @@ void LLPipeline::renderDeferredLighting()
|
|||
|
||||
if (RenderDeferredAtmospheric)
|
||||
{ // apply sunlight contribution
|
||||
LLGLSLShader &soften_shader = LLPipeline::sUnderWaterRender ? gDeferredSoftenWaterProgram : gDeferredSoftenProgram;
|
||||
LLGLSLShader &soften_shader = gDeferredSoftenProgram;
|
||||
|
||||
LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("renderDeferredLighting - atmospherics");
|
||||
LL_PROFILE_GPU_ZONE("atmospherics");
|
||||
|
|
@ -7904,7 +7904,7 @@ void LLPipeline::renderDeferredLighting()
|
|||
mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3);
|
||||
}
|
||||
|
||||
unbindDeferredShader(LLPipeline::sUnderWaterRender ? gDeferredSoftenWaterProgram : gDeferredSoftenProgram);
|
||||
unbindDeferredShader(gDeferredSoftenProgram);
|
||||
}
|
||||
|
||||
static LLCachedControl<S32> local_light_count(gSavedSettings, "RenderLocalLightCount", 256);
|
||||
|
|
@ -8056,7 +8056,7 @@ void LLPipeline::renderDeferredLighting()
|
|||
|
||||
LLVector4a center;
|
||||
center.load3(drawablep->getPositionAgent().mV);
|
||||
const F32 *c = center.getF32ptr();
|
||||
const F32* c = center.getF32ptr();
|
||||
F32 s = volume->getLightRadius() * 1.5f;
|
||||
|
||||
sVisibleLightCount++;
|
||||
|
|
@ -8105,8 +8105,8 @@ void LLPipeline::renderDeferredLighting()
|
|||
U32 idx = count - 1;
|
||||
bindDeferredShader(gDeferredMultiLightProgram[idx]);
|
||||
gDeferredMultiLightProgram[idx].uniform1i(LLShaderMgr::MULTI_LIGHT_COUNT, count);
|
||||
gDeferredMultiLightProgram[idx].uniform4fv(LLShaderMgr::MULTI_LIGHT, count, (GLfloat *) light);
|
||||
gDeferredMultiLightProgram[idx].uniform4fv(LLShaderMgr::MULTI_LIGHT_COL, count, (GLfloat *) col);
|
||||
gDeferredMultiLightProgram[idx].uniform4fv(LLShaderMgr::MULTI_LIGHT, count, (GLfloat*)light);
|
||||
gDeferredMultiLightProgram[idx].uniform4fv(LLShaderMgr::MULTI_LIGHT_COL, count, (GLfloat*)col);
|
||||
gDeferredMultiLightProgram[idx].uniform1f(LLShaderMgr::MULTI_LIGHT_FAR_Z, far_z);
|
||||
far_z = 0.f;
|
||||
count = 0;
|
||||
|
|
@ -8124,11 +8124,11 @@ void LLPipeline::renderDeferredLighting()
|
|||
|
||||
for (LLDrawable::drawable_list_t::iterator iter = fullscreen_spot_lights.begin(); iter != fullscreen_spot_lights.end(); ++iter)
|
||||
{
|
||||
LLDrawable *drawablep = *iter;
|
||||
LLVOVolume *volume = drawablep->getVOVolume();
|
||||
LLVector3 center = drawablep->getPositionAgent();
|
||||
F32 * c = center.mV;
|
||||
F32 light_size_final = volume->getLightRadius() * 1.5f;
|
||||
LLDrawable* drawablep = *iter;
|
||||
LLVOVolume* volume = drawablep->getVOVolume();
|
||||
LLVector3 center = drawablep->getPositionAgent();
|
||||
F32* c = center.mV;
|
||||
F32 light_size_final = volume->getLightRadius() * 1.5f;
|
||||
F32 light_falloff_final = volume->getLightFalloff(DEFERRED_LIGHT_FALLOFF);
|
||||
|
||||
sVisibleLightCount++;
|
||||
|
|
@ -8154,12 +8154,56 @@ void LLPipeline::renderDeferredLighting()
|
|||
}
|
||||
|
||||
|
||||
|
||||
if (RenderDeferredAtmospheric)
|
||||
{
|
||||
LLGLEnable blend(GL_BLEND);
|
||||
gGL.blendFunc(LLRender::BF_ONE, LLRender::BF_SOURCE_ALPHA);
|
||||
gGL.setColorMask(true, false);
|
||||
|
||||
for (U32 i = 0; i < 2; ++i)
|
||||
{
|
||||
// apply haze
|
||||
LLGLSLShader &haze_shader = i == 0 ? gHazeProgram : gHazeWaterProgram;
|
||||
|
||||
LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("renderDeferredLighting - haze");
|
||||
LL_PROFILE_GPU_ZONE("haze");
|
||||
bindDeferredShader(haze_shader);
|
||||
|
||||
static LLCachedControl<F32> ssao_scale(gSavedSettings, "RenderSSAOIrradianceScale", 0.5f);
|
||||
static LLCachedControl<F32> ssao_max(gSavedSettings, "RenderSSAOIrradianceMax", 0.25f);
|
||||
static LLStaticHashedString ssao_scale_str("ssao_irradiance_scale");
|
||||
static LLStaticHashedString ssao_max_str("ssao_irradiance_max");
|
||||
|
||||
haze_shader.uniform1f(ssao_scale_str, ssao_scale);
|
||||
haze_shader.uniform1f(ssao_max_str, ssao_max);
|
||||
|
||||
LLEnvironment &environment = LLEnvironment::instance();
|
||||
haze_shader.uniform1i(LLShaderMgr::SUN_UP_FACTOR, environment.getIsSunUp() ? 1 : 0);
|
||||
haze_shader.uniform3fv(LLShaderMgr::LIGHTNORM, 1, environment.getClampedLightNorm().mV);
|
||||
|
||||
haze_shader.uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, LLDrawPoolAlpha::sWaterPlane.mV);
|
||||
|
||||
{
|
||||
LLGLDepthTest depth(GL_FALSE);
|
||||
|
||||
// full screen blit
|
||||
mScreenTriangleVB->setBuffer();
|
||||
mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3);
|
||||
}
|
||||
|
||||
unbindDeferredShader(haze_shader);
|
||||
}
|
||||
|
||||
gGL.setSceneBlendType(LLRender::BT_ALPHA);
|
||||
}
|
||||
|
||||
|
||||
gGL.setColorMask(true, true);
|
||||
}
|
||||
|
||||
{ // render non-deferred geometry (alpha, fullbright, glow)
|
||||
LLGLDisable blend(GL_BLEND);
|
||||
//LLGLDisable stencil(GL_STENCIL_TEST);
|
||||
|
||||
pushRenderTypeMask();
|
||||
andRenderTypeMask(LLPipeline::RENDER_TYPE_ALPHA,
|
||||
|
|
|
|||
Loading…
Reference in New Issue