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

SL-19148 Decruft some forward shaders and drawpools. Fix HUDs being in wrong color space.

master
Dave Parks 2023-02-03 17:18:39 -06:00
parent 4259ea7953
commit 830cb6b665
66 changed files with 295 additions and 2478 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
indra/llrender/llglslshader.cpp
View File

@ -87,7 +87,6 @@ LLShaderFeatures::LLShaderFeatures()
, calculatesAtmospherics(false)
, hasLighting(false)
, isAlphaLighting(false)
, isShiny(false)
, isFullbright(false)
, isSpecular(false)
, hasWaterFog(false)

1
indra/llrender/llglslshader.h
View File

@ -40,7 +40,6 @@ public:
bool calculatesAtmospherics;
bool hasLighting; // implies no transport (it's possible to have neither though)
bool isAlphaLighting; // indicates lighting shaders need not be linked in (lighting performed directly in alpha shader to match deferred lighting functions)
bool isShiny;
bool isFullbright; // implies no lighting
bool isSpecular;
bool hasWaterFog; // implies no gamma

89
indra/llrender/llshadermgr.cpp
View File

@ -296,9 +296,6 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
{
return FALSE;
}
// Test hasFullbright and hasShiny and attach fullbright and
// fullbright shiny atmos transport if we split them out.
}
// NOTE order of shader object attaching is VERY IMPORTANT!!!
@ -390,30 +387,11 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
}
}
}
// NOTE order of shader object attaching is VERY IMPORTANT!!!
else if (features->isFullbright)
{
if (features->isShiny && features->hasWaterFog)
{
if (features->disableTextureIndex)
{
if (!shader->attachFragmentObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
if (!shader->attachFragmentObject("lighting/lightFullbrightShinyWaterF.glsl"))
{
return FALSE;
}
shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
}
}
else if (features->hasWaterFog)
if (features->hasWaterFog)
{
if (features->disableTextureIndex)
{
@ -445,26 +423,6 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
}
}
else if (features->isShiny)
{
if (features->disableTextureIndex)
{
if (!shader->attachFragmentObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
if (!shader->attachFragmentObject("lighting/lightFullbrightShinyF.glsl"))
{
return FALSE;
}
shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
}
}
else
{
if (features->disableTextureIndex)
@ -505,50 +463,6 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
}
}
}
// NOTE order of shader object attaching is VERY IMPORTANT!!!
else if (features->isShiny)
{
if (features->hasWaterFog)
{
if (features->disableTextureIndex)
{
if (!shader->attachFragmentObject("lighting/lightShinyWaterNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
if (!shader->attachFragmentObject("lighting/lightShinyWaterF.glsl"))
{
return FALSE;
}
shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
}
}
else
{
if (features->disableTextureIndex)
{
if (!shader->attachFragmentObject("lighting/lightShinyNonIndexedF.glsl"))
{
return FALSE;
}
}
else
{
if (!shader->attachFragmentObject("lighting/lightShinyF.glsl"))
{
return FALSE;
}
shader->mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels-1, 1);
}
}
}
if (features->mIndexedTextureChannels <= 1)
{
if (!shader->attachVertexObject("objects/nonindexedTextureV.glsl"))
@ -1422,7 +1336,6 @@ 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");
mReservedUniforms.push_back("moisture_level");
mReservedUniforms.push_back("droplet_radius");
mReservedUniforms.push_back("ice_level");

1
indra/llrender/llshadermgr.h
View File

@ -255,7 +255,6 @@ public:
ILLUMINANCE_TEX, // "irradiance_texture"
BLEND_FACTOR, // "blend_factor"
NO_ATMO, // "no_atmo"
MOISTURE_LEVEL, // "moisture_level"
DROPLET_RADIUS, // "droplet_radius"
ICE_LEVEL, // "ice_level"

4
indra/newview/CMakeLists.txt
View File

@ -186,7 +186,6 @@ set(viewer_SOURCE_FILES
lldrawpoolalpha.cpp
lldrawpoolavatar.cpp
lldrawpoolbump.cpp
lldrawpoolground.cpp
lldrawpoolmaterials.cpp
lldrawpoolpbropaque.cpp
lldrawpoolsimple.cpp
@ -718,7 +717,6 @@ set(viewer_SOURCE_FILES
llvoavatarself.cpp
llvocache.cpp
llvograss.cpp
llvoground.cpp
llvoicecallhandler.cpp
llvoicechannel.cpp
llvoiceclient.cpp
@ -834,7 +832,6 @@ set(viewer_HEADER_FILES
lldrawpoolbump.h
lldrawpoolmaterials.h
lldrawpoolpbropaque.h
lldrawpoolground.h
lldrawpoolsimple.h
lldrawpoolsky.h
lldrawpoolterrain.h
@ -1358,7 +1355,6 @@ set(viewer_HEADER_FILES
llvoavatarself.h
llvocache.h
llvograss.h
llvoground.h
llvoicechannel.h
llvoiceclient.h
llvoicevisualizer.h

11
indra/newview/app_settings/settings.xml
View File

@ -10073,17 +10073,6 @@
<key>Value</key>
<real>1.3</real>
</map>
<key>RenderGround</key>
<map>
<key>Comment</key>
<string>Determines whether we can render the ground pool or not</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>1</integer>
</map>
<key>DisableAllRenderTypes</key>
<map>
<key>Comment</key>

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

@ -27,19 +27,15 @@
/*[EXTRA_CODE_HERE]*/
#ifdef DEFINE_GL_FRAGCOLOR
out vec4 frag_color;
#else
#define frag_color gl_FragColor
#endif
#if !defined(HAS_DIFFUSE_LOOKUP)
uniform sampler2D diffuseMap;
#endif
VARYING vec3 vary_position;
VARYING vec4 vertex_color;
VARYING vec2 vary_texcoord0;
in vec3 vary_position;
in vec4 vertex_color;
in vec2 vary_texcoord0;
#ifdef WATER_FOG
vec4 applyWaterFogView(vec3 pos, vec4 color);
@ -68,7 +64,7 @@ void main()
#ifdef HAS_DIFFUSE_LOOKUP
vec4 color = diffuseLookup(vary_texcoord0.xy);
#else
vec4 color = texture2D(diffuseMap, vary_texcoord0.xy);
vec4 color = texture(diffuseMap, vary_texcoord0.xy);
#endif
float final_alpha = color.a * vertex_color.a;
@ -91,7 +87,10 @@ void main()
color.a = final_alpha;
#endif
frag_color.rgb = srgb_to_linear(color.rgb);
#ifndef IS_HUD
color.rgb = srgb_to_linear(color.rgb);
#endif
frag_color.rgb = color.rgb;
frag_color.a = color.a;
}

78
indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl
View File

@ -22,85 +22,13 @@
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
/*[EXTRA_CODE_HERE]*/
#ifdef DEFINE_GL_FRAGCOLOR
//debug stub
out vec4 frag_color;
#else
#define frag_color gl_FragColor
#endif
#ifndef HAS_DIFFUSE_LOOKUP
uniform sampler2D diffuseMap;
#endif
VARYING vec4 vertex_color;
VARYING vec2 vary_texcoord0;
VARYING vec3 vary_texcoord1;
VARYING vec3 vary_position;
uniform samplerCube environmentMap;
// render_hud_attachments() -> HUD objects set LLShaderMgr::NO_ATMO; used in LLDrawPoolAlpha::beginRenderPass()
uniform int no_atmo;
vec3 fullbrightShinyAtmosTransport(vec3 light);
vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
vec3 fullbrightScaleSoftClip(vec3 light);
void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
vec3 linear_to_srgb(vec3 c);
vec3 srgb_to_linear(vec3 c);
// See:
// class1\deferred\fullbrightShinyF.glsl
// class1\lighting\lightFullbrightShinyF.glsl
void main()
{
#ifdef HAS_DIFFUSE_LOOKUP
vec4 color = diffuseLookup(vary_texcoord0.xy);
#else
vec4 color = texture2D(diffuseMap, vary_texcoord0.xy);
#endif
color.rgb *= vertex_color.rgb;
// SL-9632 HUDs are affected by Atmosphere
if (no_atmo == 0)
{
vec3 sunlit;
vec3 amblit;
vec3 additive;
vec3 atten;
vec3 pos = vary_position.xyz;
calcAtmosphericVars(pos.xyz, vec3(0), 1.0, sunlit, amblit, additive, atten, false);
vec3 envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;
float env_intensity = vertex_color.a;
//color.rgb = srgb_to_linear(color.rgb);
color.rgb = mix(color.rgb, envColor.rgb, env_intensity);
color.rgb = fullbrightAtmosTransportFrag(color.rgb, additive, atten);
color.rgb = fullbrightScaleSoftClip(color.rgb);
}
/*
// NOTE: HUD objects will be full bright. Uncomment if you want "some" environment lighting effecting these HUD objects.
else
{
vec3 envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;
float env_intensity = vertex_color.a;
color.rgb = mix(color.rgb, envColor.rgb, env_intensity);
}
*/
color.a = 1.0;
//color.rgb = linear_to_srgb(color.rgb);
frag_color = color;
frag_color = vec4(0.25, 0.5, 0, 1.0);
}

11
indra/newview/app_settings/shaders/class1/lighting/lightAlphaMaskF.glsl
View File

@ -31,9 +31,6 @@ out vec4 frag_color;
uniform float minimum_alpha;
// render_hud_attachments() -> HUD objects set LLShaderMgr::NO_ATMO;
uniform int no_atmo;
vec3 atmosLighting(vec3 light);
vec3 scaleSoftClip(vec3 light);
@ -51,12 +48,8 @@ void default_lighting()
color *= vertex_color;
// SL-9632 HUDs are affected by Atmosphere
if (no_atmo == 0)
{
color.rgb = atmosLighting(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
}
color.rgb = atmosLighting(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
frag_color = color;
}

15
indra/newview/app_settings/shaders/class1/lighting/lightFullbrightAlphaMaskF.glsl
View File

@ -32,9 +32,6 @@ out vec4 frag_color;
uniform float minimum_alpha;
uniform float texture_gamma; // either 1.0 or 2.2; see: "::TEXTURE_GAMMA"
// render_hud_attachments() -> HUD objects set LLShaderMgr::NO_ATMO; used in LLDrawPoolAlpha::beginRenderPass()
uniform int no_atmo;
vec3 fullbrightAtmosTransport(vec3 light);
vec3 fullbrightScaleSoftClip(vec3 light);
@ -54,16 +51,8 @@ void fullbright_lighting()
color.rgb = pow(color.rgb, vec3(texture_gamma));
// SL-9632 HUDs are affected by Atmosphere
if (no_atmo == 0)
{
color.rgb = fullbrightAtmosTransport(color.rgb);
color.rgb = fullbrightScaleSoftClip(color.rgb);
}
//*TODO: Are we missing an inverse pow() here?
// class1\lighting\lightFullbrightF.glsl has:
// color.rgb = pow(color.rgb, vec3(1.0/texture_gamma));
color.rgb = fullbrightAtmosTransport(color.rgb);
color.rgb = fullbrightScaleSoftClip(color.rgb);
frag_color = color;
}

11
indra/newview/app_settings/shaders/class1/lighting/lightFullbrightF.glsl
View File

@ -34,9 +34,6 @@ VARYING vec2 vary_texcoord0;
uniform float texture_gamma;
// render_hud_attachments() -> HUD objects set LLShaderMgr::NO_ATMO;
uniform int no_atmo;
vec3 fullbrightAtmosTransport(vec3 light);
vec3 fullbrightScaleSoftClip(vec3 light);
@ -46,12 +43,8 @@ void fullbright_lighting()
color.rgb = pow(color.rgb, vec3(texture_gamma));
// SL-9632 HUDs are affected by Atmosphere
if (no_atmo == 0)
{
color.rgb = fullbrightAtmosTransport(color.rgb);
color.rgb = fullbrightScaleSoftClip(color.rgb);
}
color.rgb = fullbrightAtmosTransport(color.rgb);
color.rgb = fullbrightScaleSoftClip(color.rgb);
color.rgb = pow(color.rgb, vec3(1.0/texture_gamma));

15
indra/newview/app_settings/shaders/class1/lighting/lightFullbrightShinyF.glsl
View File

@ -35,9 +35,6 @@ VARYING vec3 vary_texcoord1;
uniform samplerCube environmentMap;
// render_hud_attachments() -> HUD objects set LLShaderMgr::NO_ATMO; used in LLDrawPoolAlpha::beginRenderPass()
uniform int no_atmo;
vec3 fullbrightShinyAtmosTransport(vec3 light);
vec3 fullbrightScaleSoftClip(vec3 light);
@ -49,23 +46,11 @@ void fullbright_shiny_lighting()
vec4 color = diffuseLookup(vary_texcoord0.xy);
color.rgb *= vertex_color.rgb;
// SL-9632 HUDs are affected by Atmosphere
if (no_atmo == 0)
{
vec3 envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;
color.rgb = mix(color.rgb, envColor.rgb, vertex_color.a*0.75); // MAGIC NUMBER SL-12574; ALM: Off, Quality > Low
color.rgb = fullbrightShinyAtmosTransport(color.rgb);
color.rgb = fullbrightScaleSoftClip(color.rgb);
}
/*
// NOTE: HUD objects will be full bright. Uncomment if you want "some" environment lighting effecting these HUD objects.
else
{
vec3 envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;
color.rgb = mix(color.rgb, envColor.rgb, vertex_color.a*0.75); // MAGIC NUMBER SL-12574; ALM: Off, Quality > Low
}
*/
color.a = 1.0;

15
indra/newview/app_settings/shaders/class1/lighting/lightShinyF.glsl
View File

@ -23,15 +23,10 @@
* $/LicenseInfo$
*/
#ifdef DEFINE_GL_FRAGCOLOR
out vec4 frag_color;
#else
#define frag_color gl_FragColor
#endif
VARYING vec4 vertex_color;
VARYING vec2 vary_texcoord0;
VARYING vec3 vary_texcoord1;
in vec4 vertex_color;
in vec2 vary_texcoord0;
in vec3 vary_texcoord1;
uniform samplerCube environmentMap;
@ -39,7 +34,7 @@ vec3 scaleSoftClip(vec3 light);
vec3 atmosLighting(vec3 light);
vec4 applyWaterFog(vec4 color);
void shiny_lighting()
vec4 shiny_lighting()
{
vec4 color = diffuseLookup(vary_texcoord0.xy);
color.rgb *= vertex_color.rgb;
@ -51,6 +46,6 @@ void shiny_lighting()
color.rgb = scaleSoftClip(color.rgb);
color.a = 1.0;
frag_color = color;
return color;
}

13
indra/newview/app_settings/shaders/class1/lighting/lightShinyNonIndexedF.glsl
View File

@ -23,15 +23,10 @@
* $/LicenseInfo$
*/
#ifdef DEFINE_GL_FRAGCOLOR
out vec4 frag_color;
#else
#define frag_color gl_FragColor
#endif
VARYING vec4 vertex_color;
VARYING vec2 vary_texcoord0;
VARYING vec3 vary_texcoord1;
in vec4 vertex_color;
in vec2 vary_texcoord0;
in vec3 vary_texcoord1;
uniform samplerCube environmentMap;
uniform sampler2D diffuseMap;
@ -52,6 +47,6 @@ void shiny_lighting()
color.rgb = scaleSoftClip(color.rgb);
color.a = 1.0;
frag_color = color;
return color;
}

33
indra/newview/app_settings/shaders/class1/objects/shinyF.glsl
View File

@ -1,33 +0,0 @@
/**
* @file shinyF.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$
*/
void shiny_lighting();
void main()
{
shiny_lighting();
}

78
indra/newview/app_settings/shaders/class1/objects/shinyV.glsl
View File

@ -1,78 +0,0 @@
/**
* @file shinyV.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$
*/
uniform mat3 normal_matrix;
uniform mat4 texture_matrix0;
uniform mat4 texture_matrix1;
uniform mat4 modelview_matrix;
uniform mat4 modelview_projection_matrix;
ATTRIBUTE vec3 position;
void passTextureIndex();
ATTRIBUTE vec2 texcoord0;
ATTRIBUTE vec3 normal;
ATTRIBUTE vec4 diffuse_color;
VARYING vec4 vertex_color;
VARYING vec2 vary_texcoord0;
VARYING vec3 vary_texcoord1;
vec4 calcLighting(vec3 pos, vec3 norm, vec4 color);
void calcAtmospherics(vec3 inPositionEye);
uniform vec4 origin;
#ifdef HAS_SKIN
mat4 getObjectSkinnedTransform();
uniform mat4 projection_matrix;
#endif
void main()
{
//transform vertex
vec4 vert = vec4(position.xyz,1.0);
passTextureIndex();
#ifdef HAS_SKIN
mat4 mat = getObjectSkinnedTransform();
mat = modelview_matrix * mat;
vec4 pos = mat * vert;
gl_Position = projection_matrix * pos;
vec3 norm = normalize((mat*vec4(normal.xyz+position.xyz,1.0)).xyz-pos.xyz);
#else
vec4 pos = (modelview_matrix * vert);
gl_Position = modelview_projection_matrix*vec4(position.xyz, 1.0);
vec3 norm = normalize(normal_matrix * normal);
#endif
vec3 ref = reflect(pos.xyz, -norm);
vary_texcoord0 = (texture_matrix0*vec4(texcoord0,0,1)).xy;
vary_texcoord1 = (texture_matrix1 * vec4(ref,1.0)).xyz;
calcAtmospherics(pos.xyz);
vertex_color = calcLighting(pos.xyz, norm, diffuse_color);
}

33
indra/newview/app_settings/shaders/class1/objects/shinyWaterF.glsl
View File

@ -1,33 +0,0 @@
/**
* @file shinyWaterF.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$
*/
void shiny_lighting_water();
void main()
{
shiny_lighting_water();
}

34
indra/newview/app_settings/shaders/class1/objects/simpleV.glsl
View File

@ -28,9 +28,6 @@ uniform mat4 texture_matrix0;
uniform mat4 modelview_matrix;
uniform mat4 modelview_projection_matrix;
// render_hud_attachments() -> HUD objects set LLShaderMgr::NO_ATMO; used in LLDrawPoolAlpha::beginRenderPass()
uniform int no_atmo;
ATTRIBUTE vec3 position;
void passTextureIndex();
ATTRIBUTE vec2 texcoord0;
@ -58,30 +55,21 @@ void main()
passTextureIndex();
vary_texcoord0 = (texture_matrix0 * vec4(texcoord0, 0, 1)).xy;
// SL-9632 HUDs are affected by Atmosphere
if (no_atmo == 1)
{
vertex_color = diffuse_color;
gl_Position = modelview_projection_matrix*vec4(position.xyz, 1.0);
}
else
{
#ifdef HAS_SKIN
mat4 mat = getObjectSkinnedTransform();
mat = modelview_matrix * mat;
mat4 mat = getObjectSkinnedTransform();
mat = modelview_matrix * mat;
vec4 pos = mat * vert;
vec3 norm = normalize((mat*vec4(normal.xyz+vert.xyz,1.0)).xyz-pos.xyz);
vec4 pos = mat * vert;
vec3 norm = normalize((mat*vec4(normal.xyz+vert.xyz,1.0)).xyz-pos.xyz);
gl_Position = projection_matrix * pos;
gl_Position = projection_matrix * pos;
#else
vec4 pos = (modelview_matrix * vert);
vec3 norm = normalize(normal_matrix * normal);
gl_Position = modelview_projection_matrix*vec4(position.xyz, 1.0);
vec4 pos = (modelview_matrix * vert);
vec3 norm = normalize(normal_matrix * normal);
gl_Position = modelview_projection_matrix*vec4(position.xyz, 1.0);
#endif
calcAtmospherics(pos.xyz);
vertex_color = calcLighting(pos.xyz, norm, diffuse_color);
}
calcAtmospherics(pos.xyz);
vertex_color = calcLighting(pos.xyz, norm, diffuse_color);
}

2
indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersF.glsl
View File

@ -25,11 +25,9 @@
uniform vec4 sunlight_color;
uniform vec4 light_ambient;
uniform int no_atmo;
vec3 atmosAmbient()
{
if (no_atmo == 1) return vec3(0.16);
return light_ambient.rgb;
}

2
indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl
View File

@ -25,11 +25,9 @@
uniform vec4 sunlight_color;
uniform vec4 light_ambient;
uniform int no_atmo;
vec3 atmosAmbient()
{
if (no_atmo == 1) return vec3(0.66);
return light_ambient.rgb;
}

2
indra/newview/app_settings/shaders/class1/windlight/gammaF.glsl
View File

@ -23,8 +23,6 @@
* $/LicenseInfo$
*/
uniform int no_atmo;
vec3 scaleSoftClipFrag(vec3 light)
{
// For compatibility with lower cards. Do nothing.

2
indra/newview/app_settings/shaders/class1/windlight/transportF.glsl
View File

@ -23,8 +23,6 @@
* $/LicenseInfo$
*/
uniform int no_atmo;
vec3 atmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
{
/* stub function for fallback compatibility on class1 hardware */

3
indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl
View File

@ -300,6 +300,9 @@ void main()
#endif // #else // FOR_IMPOSTOR
#ifdef IS_HUD
color.rgb = linear_to_srgb(color.rgb);
#endif
frag_color = color;
}

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

@ -27,17 +27,11 @@ vec3 getAdditiveColor();
vec3 getAtmosAttenuation();
vec3 scaleSoftClipFrag(vec3 light);
uniform int no_atmo;
vec3 srgb_to_linear(vec3 col);
vec3 linear_to_srgb(vec3 col);
vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten)
{
if (no_atmo == 1)
{
return light;
}
light *= atten.r;
light += additive;
return light * 2.0;

1
indra/newview/app_settings/shaders/class2/windlight/atmosphericsFuncs.glsl
View File

@ -45,7 +45,6 @@ uniform float max_y;
uniform vec3 glow;
uniform float scene_light_strength;
uniform mat3 ssao_effect_mat;
uniform int no_atmo;
uniform float sun_moon_glow_factor;
float getAmbientClamp() { return 1.0f; }

2
indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersF.glsl
View File

@ -26,11 +26,9 @@
// Output variables
uniform float scene_light_strength;
uniform int no_atmo;
vec3 atmosFragAmbient(vec3 light, vec3 amblit)
{
if (no_atmo == 1) return light;
return amblit + light / 2.0;
}

2
indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersV.glsl
View File

@ -33,11 +33,9 @@ vec3 getAtmosAttenuation();
vec3 getPositionEye();
uniform float scene_light_strength;
uniform int no_atmo;
vec3 atmosAmbient()
{
if (no_atmo == 1) return vec3(0.16);
return getAmblitColor();
}

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

@ -23,7 +23,6 @@
* $/LicenseInfo$
*/
uniform float gamma;
uniform int no_atmo;
vec3 getAtmosAttenuation();
vec3 getAdditiveColor();
@ -33,10 +32,6 @@ vec3 linear_to_srgb(vec3 col);
vec3 scaleSoftClipFragLinear(vec3 light)
{ // identical to non-linear version and that's probably close enough
if (no_atmo == 1)
{
return light;
}
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, vec3(gamma)); // s/b inverted already CPU-side
@ -45,10 +40,6 @@ vec3 scaleSoftClipFragLinear(vec3 light)
vec3 scaleSoftClipFrag(vec3 light)
{
if (no_atmo == 1)
{
return light;
}
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, vec3(gamma)); // s/b inverted already CPU-side

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

@ -30,8 +30,6 @@
vec3 getAdditiveColor();
vec3 getAtmosAttenuation();
uniform int no_atmo;
vec3 srgb_to_linear(vec3 col);
vec3 linear_to_srgb(vec3 col);

49
indra/newview/app_settings/shaders/class3/deferred/fullbrightShinyF.glsl
View File

@ -43,9 +43,6 @@ VARYING vec3 vary_position;
uniform samplerCube environmentMap;
// render_hud_attachments() -> HUD objects set LLShaderMgr::NO_ATMO; used in LLDrawPoolAlpha::beginRenderPass()
uniform int no_atmo;
vec3 fullbrightShinyAtmosTransport(vec3 light);
vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
vec3 fullbrightScaleSoftClip(vec3 light);
@ -59,12 +56,8 @@ vec3 srgb_to_linear(vec3 c);
void sampleReflectionProbesLegacy(inout vec3 ambenv, inout vec3 glossenv, inout vec3 legacyenv,
vec2 tc, vec3 pos, vec3 norm, float glossiness, float envIntensity);
void applyGlossEnv(inout vec3 color, vec3 glossenv, vec4 spec, vec3 pos, vec3 norm);
void applyLegacyEnv(inout vec3 color, vec3 legacyenv, vec4 spec, vec3 pos, vec3 norm, float envIntensity);
// See:
// class1\deferred\fullbrightShinyF.glsl
// class1\lighting\lightFullbrightShinyF.glsl
void main()
{
#ifdef HAS_DIFFUSE_LOOKUP
@ -76,32 +69,32 @@ void main()
color.rgb *= vertex_color.rgb;
// SL-9632 HUDs are affected by Atmosphere
if (no_atmo == 0)
{
vec3 sunlit;
vec3 amblit;
vec3 additive;
vec3 atten;
vec3 pos = vary_position;
calcAtmosphericVars(pos.xyz, vec3(0), 1.0, sunlit, amblit, additive, atten, false);
#ifndef IS_HUD
vec3 sunlit;
vec3 amblit;
vec3 additive;
vec3 atten;
vec3 pos = vary_position;
calcAtmosphericVars(pos.xyz, vec3(0), 1.0, sunlit, amblit, additive, atten, false);
float env_intensity = vertex_color.a;
float env_intensity = vertex_color.a;
vec3 ambenv;
vec3 glossenv;
vec3 legacyenv;
vec3 norm = normalize(vary_texcoord1.xyz);
vec4 spec = vec4(0,0,0,0);
sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, vec2(0), pos.xyz, norm.xyz, spec.a, env_intensity);
applyLegacyEnv(color.rgb, legacyenv, spec, pos, norm, env_intensity);
vec3 ambenv;
vec3 glossenv;
vec3 legacyenv;
vec3 norm = normalize(vary_texcoord1.xyz);
vec4 spec = vec4(0,0,0,0);
sampleReflectionProbesLegacy(ambenv, glossenv, legacyenv, vec2(0), pos.xyz, norm.xyz, spec.a, env_intensity);
applyLegacyEnv(color.rgb, legacyenv, spec, pos, norm, env_intensity);
color.rgb = fullbrightAtmosTransportFrag(color.rgb, additive, atten);
color.rgb = fullbrightScaleSoftClip(color.rgb);
}
color.rgb = fullbrightAtmosTransportFrag(color.rgb, additive, atten);
color.rgb = fullbrightScaleSoftClip(color.rgb);
color.rgb = srgb_to_linear(color.rgb);
#endif
color.a = 1.0;
color.rgb = srgb_to_linear(color.rgb);
frag_color = color;
}

1
indra/newview/featuretable.txt
View File

@ -41,7 +41,6 @@ RenderFlexTimeFactor 1 1.0
RenderFogRatio 1 4.0
RenderGamma 1 0
RenderGlowResolutionPow 1 9
RenderGround 1 1
RenderMaxPartCount 1 8192
RenderObjectBump 1 1
RenderLocalLights 1 1

1
indra/newview/featuretable_mac.txt
View File

@ -41,7 +41,6 @@ RenderFlexTimeFactor 1 1.0
RenderFogRatio 1 4.0
RenderGamma 1 0
RenderGlowResolutionPow 1 9
RenderGround 1 1
RenderMaxPartCount 1 8192
RenderObjectBump 1 1
RenderLocalLights 1 1

6
indra/newview/llagent.cpp
View File

@ -940,11 +940,7 @@ void LLAgent::setRegion(LLViewerRegion *regionp)
{
gSky.mVOSkyp->setRegion(regionp);
}
if (gSky.mVOGroundp)
{
gSky.mVOGroundp->setRegion(regionp);
}
if (regionp->capabilitiesReceived())
{
regionp->requestSimulatorFeatures();

4
indra/newview/lldrawable.cpp
View File

@ -499,7 +499,6 @@ void LLDrawable::makeActive()
pcode == LLViewerObject::LL_VO_SURFACE_PATCH ||
pcode == LLViewerObject::LL_VO_PART_GROUP ||
pcode == LLViewerObject::LL_VO_HUD_PART_GROUP ||
pcode == LLViewerObject::LL_VO_GROUND ||
pcode == LLViewerObject::LL_VO_SKY)
{
LL_ERRS() << "Static viewer object has active drawable!" << LL_ENDL;
@ -984,8 +983,7 @@ void LLDrawable::shiftPos(const LLVector4a &shift_vector)
bool rebuild = (!volume &&
getRenderType() != LLPipeline::RENDER_TYPE_TREE &&
getRenderType() != LLPipeline::RENDER_TYPE_TERRAIN &&
getRenderType() != LLPipeline::RENDER_TYPE_SKY &&
getRenderType() != LLPipeline::RENDER_TYPE_GROUND);
getRenderType() != LLPipeline::RENDER_TYPE_SKY);
if (rebuild)
{

7
indra/newview/lldrawpool.cpp
View File

@ -36,7 +36,6 @@
#include "lldrawpoolavatar.h"
#include "lldrawpoolbump.h"
#include "lldrawpoolmaterials.h"
#include "lldrawpoolground.h"
#include "lldrawpoolpbropaque.h"
#include "lldrawpoolsimple.h"
#include "lldrawpoolsky.h"
@ -80,9 +79,6 @@ LLDrawPool *LLDrawPool::createPool(const U32 type, LLViewerTexture *tex0)
case POOL_FULLBRIGHT:
poolp = new LLDrawPoolFullbright();
break;
case POOL_INVISIBLE:
poolp = new LLDrawPoolInvisible();
break;
case POOL_GLOW:
poolp = new LLDrawPoolGlow();
break;
@ -109,9 +105,6 @@ LLDrawPool *LLDrawPool::createPool(const U32 type, LLViewerTexture *tex0)
case POOL_WATER:
poolp = new LLDrawPoolWater();
break;
case POOL_GROUND:
poolp = new LLDrawPoolGround();
break;
case POOL_BUMP:
poolp = new LLDrawPoolBump();
break;

7
indra/newview/lldrawpool.h
View File

@ -54,7 +54,6 @@ public:
// based on fill rate and likelihood to occlude future passes (faster, large occluders first).
//
POOL_SIMPLE = 1,
POOL_GROUND,
POOL_FULLBRIGHT,
POOL_BUMP,
POOL_TERRAIN,
@ -66,7 +65,6 @@ public:
POOL_FULLBRIGHT_ALPHA_MASK,
POOL_SKY,
POOL_WL_SKY,
POOL_INVISIBLE, // see below *
POOL_AVATAR,
POOL_CONTROL_AV, // Animesh
POOL_GLOW,
@ -76,11 +74,6 @@ public:
POOL_ALPHA_POST_WATER,
POOL_ALPHA, // note there is no actual "POOL_ALPHA" but pre-water and post-water pools consume POOL_ALPHA faces
NUM_POOL_TYPES,
// * invisiprims work by rendering to the depth buffer but not the color buffer, occluding anything rendered after them
// - and the LLDrawPool types enum controls what order things are rendered in
// - so, it has absolute control over what invisprims block
// ...invisiprims being rendered in pool_invisible
// ...shiny/bump mapped objects in rendered in POOL_BUMP
};
LLDrawPool(const U32 type);

83
indra/newview/lldrawpoolalpha.cpp
View File

@ -113,7 +113,6 @@ static void prepare_alpha_shader(LLGLSLShader* shader, bool textureGamma, bool d
{
shader->bind();
}
shader->uniform1i(LLShaderMgr::NO_ATMO, (LLPipeline::sRenderingHUDs) ? 1 : 0);
shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f / 2.2f));
if (LLPipeline::sRenderingHUDs)
@ -173,16 +172,25 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
}
// prepare shaders
emissive_shader = (LLPipeline::sRenderDeferred) ? &gDeferredEmissiveProgram :
(LLPipeline::sUnderWaterRender) ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
llassert(LLPipeline::sRenderDeferred);
emissive_shader = &gDeferredEmissiveProgram;
prepare_alpha_shader(emissive_shader, true, false, water_sign);
fullbright_shader = (LLPipeline::sImpostorRender) ? &gDeferredFullbrightAlphaMaskProgram :
(LLPipeline::sUnderWaterRender) ? &gDeferredFullbrightWaterAlphaProgram : &gDeferredFullbrightAlphaMaskAlphaProgram;
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 : &gDeferredAlphaProgram;
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;
@ -193,8 +201,11 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
prepare_alpha_shader(&gDeferredPBRAlphaProgram, false, true, water_sign);
// first pass, render rigged objects only and render to depth buffer
forwardRender(true);
if (!LLPipeline::sRenderingHUDs)
{
// first pass, render rigged objects only and render to depth buffer
forwardRender(true);
}
// second pass, regular forward alpha rendering
forwardRender();
@ -222,54 +233,6 @@ void LLDrawPoolAlpha::renderPostDeferred(S32 pass)
deferred_render = FALSE;
}
//set some generic parameters for forward (non-deferred) rendering
static void prepare_forward_shader(LLGLSLShader* shader, F32 minimum_alpha)
{
shader->bind();
shader->setMinimumAlpha(minimum_alpha);
shader->uniform1i(LLShaderMgr::NO_ATMO, LLPipeline::sRenderingHUDs ? 1 : 0);
//also prepare rigged variant
if (shader->mRiggedVariant && shader->mRiggedVariant != shader)
{
prepare_forward_shader(shader->mRiggedVariant, minimum_alpha);
}
}
void LLDrawPoolAlpha::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
simple_shader = (LLPipeline::sImpostorRender) ? &gObjectSimpleImpostorProgram :
(LLPipeline::sUnderWaterRender) ? &gObjectSimpleWaterProgram : &gObjectSimpleAlphaMaskProgram;
fullbright_shader = (LLPipeline::sImpostorRender) ? &gObjectFullbrightAlphaMaskProgram :
(LLPipeline::sUnderWaterRender) ? &gObjectFullbrightWaterProgram : &gObjectFullbrightAlphaMaskProgram;
emissive_shader = (LLPipeline::sImpostorRender) ? &gObjectEmissiveProgram :
(LLPipeline::sUnderWaterRender) ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
F32 minimum_alpha = MINIMUM_ALPHA;
if (LLPipeline::sImpostorRender)
{
minimum_alpha = MINIMUM_IMPOSTOR_ALPHA;
}
prepare_forward_shader(fullbright_shader, minimum_alpha);
prepare_forward_shader(simple_shader, minimum_alpha);
for (int i = 0; i < LLMaterial::SHADER_COUNT; ++i)
{
prepare_forward_shader(LLPipeline::sUnderWaterRender ? &gDeferredMaterialWaterProgram[i] : &gDeferredMaterialProgram[i], minimum_alpha);
}
//first pass -- rigged only and drawn to depth buffer
forwardRender(true);
//second pass -- non-rigged, no depth buffer writes
forwardRender();
}
void LLDrawPoolAlpha::forwardRender(bool rigged)
{
gPipeline.enableLightsDynamic();
@ -707,7 +670,11 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, bool depth_only, bool rigged)
light_enabled = TRUE;
}
if (deferred_render && mat)
if (LLPipeline::sRenderingHUDs)
{
target_shader = fullbright_shader;
}
else if (deferred_render && mat)
{
U32 mask = params.mShaderMask;

1
indra/newview/lldrawpoolalpha.h
View File

@ -58,7 +58,6 @@ public:
/*virtual*/ void renderPostDeferred(S32 pass);
/*virtual*/ S32 getNumPasses() { return 1; }
virtual void render(S32 pass = 0);
void forwardRender(bool write_depth = false);
/*virtual*/ void prerender();

41
indra/newview/lldrawpoolavatar.cpp
View File

@ -520,14 +520,6 @@ 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
@ -586,14 +578,6 @@ 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()
@ -641,14 +625,6 @@ 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
@ -658,14 +634,6 @@ 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);
}
}
}
@ -708,15 +676,6 @@ 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();
}

201
indra/newview/lldrawpoolbump.cpp
View File

@ -210,90 +210,6 @@ S32 LLDrawPoolBump::numBumpPasses()
return 1;
}
S32 LLDrawPoolBump::getNumPasses()
{
return numBumpPasses();
}
void LLDrawPoolBump::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_BUMP);
if (!gPipeline.hasRenderType(LLDrawPool::POOL_SIMPLE))
{
return;
}
for (int i = 0; i < 2; ++i)
{
mRigged = i == 1;
// first pass -- shiny
beginShiny();
renderShiny();
endShiny();
//second pass -- fullbright shiny
if (mShaderLevel > 1)
{
beginFullbrightShiny();
renderFullbrightShiny();
endFullbrightShiny();
}
//third pass -- bump
beginBump();
renderBump(LLRenderPass::PASS_BUMP);
endBump();
}
}
//static
void LLDrawPoolBump::beginShiny()
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_SHINY);
mShiny = TRUE;
sVertexMask = VERTEX_MASK_SHINY;
// Second pass: environment map
if (mShaderLevel > 1)
{
sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD0;
}
if (LLPipeline::sUnderWaterRender)
{
shader = &gObjectShinyWaterProgram;
}
else
{
shader = &gObjectShinyProgram;
}
if (mRigged)
{
llassert(shader->mRiggedVariant);
shader = shader->mRiggedVariant;
}
shader->bind();
if (LLPipeline::sRenderingHUDs)
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
bindCubeMap(shader, mShaderLevel, diffuse_channel, cube_channel);
if (mShaderLevel > 1)
{ //indexed texture rendering, channel 0 is always diffuse
diffuse_channel = 0;
}
}
//static
void LLDrawPoolBump::bindCubeMap(LLGLSLShader* shader, S32 shader_level, S32& diffuse_channel, S32& cube_channel)
@ -342,38 +258,6 @@ void LLDrawPoolBump::bindCubeMap(LLGLSLShader* shader, S32 shader_level, S32& di
}
}
void LLDrawPoolBump::renderShiny()
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_SHINY);
if( gSky.mVOSkyp->getCubeMap() && !LLPipeline::sReflectionProbesEnabled )
{
LLGLEnable blend_enable(GL_BLEND);
if (mShaderLevel > 1)
{
if (mRigged)
{
LLRenderPass::pushRiggedBatches(LLRenderPass::PASS_SHINY_RIGGED, true, true);
}
else
{
LLRenderPass::pushBatches(LLRenderPass::PASS_SHINY, true, true);
}
}
else
{
if (mRigged)
{
gPipeline.renderRiggedGroups(this, LLRenderPass::PASS_SHINY_RIGGED, true);
}
else
{
gPipeline.renderGroups(this, LLRenderPass::PASS_SHINY, true);
}
}
}
}
//static
void LLDrawPoolBump::unbindCubeMap(LLGLSLShader* shader, S32 shader_level, S32& diffuse_channel, S32& cube_channel)
{
@ -399,21 +283,6 @@ void LLDrawPoolBump::unbindCubeMap(LLGLSLShader* shader, S32 shader_level, S32&
}
}
void LLDrawPoolBump::endShiny()
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_SHINY);
unbindCubeMap(shader, mShaderLevel, diffuse_channel, cube_channel);
if (shader)
{
shader->unbind();
}
diffuse_channel = -1;
cube_channel = 0;
mShiny = FALSE;
}
void LLDrawPoolBump::beginFullbrightShiny()
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_SHINY);
@ -421,22 +290,11 @@ void LLDrawPoolBump::beginFullbrightShiny()
sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD0;
// Second pass: environment map
if (LLPipeline::sUnderWaterRender)
{
shader = &gObjectFullbrightShinyWaterProgram;
}
else
{
if (LLPipeline::sRenderDeferred)
{
shader = &gDeferredFullbrightShinyProgram;
}
else
{
shader = &gObjectFullbrightShinyProgram;
}
}
shader = &gDeferredFullbrightShinyProgram;
if (LLPipeline::sRenderingHUDs)
{
shader = &gHUDFullbrightShinyProgram;
}
if (mRigged)
{
@ -466,15 +324,7 @@ 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);
@ -682,18 +532,7 @@ void LLDrawPoolBump::endBump(U32 pass)
S32 LLDrawPoolBump::getNumDeferredPasses()
{
#if 0 //DEPRECATED -- RenderObjectBump should always be TRUE
if (gSavedSettings.getBOOL("RenderObjectBump"))
{
return 1;
}
else
{
return 0;
}
#else
return 1;
#endif
}
void LLDrawPoolBump::renderDeferred(S32 pass)
@ -754,8 +593,11 @@ void LLDrawPoolBump::renderDeferred(S32 pass)
void LLDrawPoolBump::renderPostDeferred(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL
for (int i = 0; i < 2; ++i)
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
S32 num_passes = LLPipeline::sRenderingHUDs ? 1 : 2; // skip rigged pass when rendering HUDs
for (int i = 0; i < num_passes; ++i)
{ // two passes -- static and rigged
mRigged = (i == 1);
@ -1446,24 +1288,3 @@ void LLDrawPoolBump::pushBatch(LLDrawInfo& params, bool texture, bool batch_text
}
}
void LLDrawPoolInvisible::render(S32 pass)
{ //render invisiprims
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_INVISIBLE);
if (gPipeline.shadersLoaded())
{
gOcclusionProgram.bind();
}
U32 invisi_mask = LLVertexBuffer::MAP_VERTEX;
//glStencilMask(0); //deprecated
gGL.setColorMask(false, false);
pushBatches(LLRenderPass::PASS_INVISIBLE, invisi_mask, FALSE);
gGL.setColorMask(true, false);
//glStencilMask(0xFFFFFFFF); //deprecated
if (gPipeline.shadersLoaded())
{
gOcclusionProgram.unbind();
}
}

27
indra/newview/lldrawpoolbump.h
View File

@ -52,8 +52,6 @@ public:
LLDrawPoolBump();
virtual void render(S32 pass = 0) override;
virtual S32 getNumPasses() override;
/*virtual*/ void prerender() override;
void pushBatch(LLDrawInfo& params, bool texture, bool batch_textures = false) override;
@ -62,10 +60,6 @@ public:
S32 numBumpPasses();
void beginShiny();
void renderShiny();
void endShiny();
void beginFullbrightShiny();
void renderFullbrightShiny();
void endFullbrightShiny();
@ -167,25 +161,4 @@ private:
extern LLBumpImageList gBumpImageList;
class LLDrawPoolInvisible : public LLRenderPass
{
public:
LLDrawPoolInvisible() : LLRenderPass(LLDrawPool::POOL_INVISIBLE) { }
enum
{
VERTEX_DATA_MASK = LLVertexBuffer::MAP_VERTEX
};
virtual U32 getVertexDataMask() { return VERTEX_DATA_MASK; }
virtual void prerender() { }
virtual void render(S32 pass = 0);
virtual void beginRenderPass( S32 pass ) { }
virtual void endRenderPass( S32 pass ) { }
virtual S32 getNumPasses() {return 1;}
};
#endif // LL_LLDRAWPOOLBUMP_H

76
indra/newview/lldrawpoolground.cpp
View File

@ -1,76 +0,0 @@
/**
* @file lldrawpoolground.cpp
* @brief LLDrawPoolGround class implementation
*
* $LicenseInfo:firstyear=2002&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, 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$
*/
#include "llviewerprecompiledheaders.h"
#include "lldrawpoolground.h"
#include "llviewercontrol.h"
#include "lldrawable.h"
#include "llface.h"
#include "llsky.h"
#include "llviewercamera.h"
#include "llviewerwindow.h"
#include "llworld.h"
#include "pipeline.h"
#include "llagent.h"
#include "llviewerregion.h"
#include "llviewershadermgr.h"
LLDrawPoolGround::LLDrawPoolGround() :
LLFacePool(POOL_GROUND)
{
}
void LLDrawPoolGround::prerender()
{
mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_ENVIRONMENT);
}
void LLDrawPoolGround::render(S32 pass)
{
if (mDrawFace.empty() || !gSavedSettings.getBOOL("RenderGround"))
{
return;
}
LLGLSPipelineDepthTestSkyBox gls_skybox(true, false);
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
F32 water_height = gAgent.getRegion()->getWaterHeight();
gGL.pushMatrix();
LLVector3 origin = LLViewerCamera::getInstance()->getOrigin();
gGL.translatef(origin.mV[0], origin.mV[1], llmax(origin.mV[2], water_height));
LLFace *facep = mDrawFace[0];
LLOverrideFaceColor col(this, gSky.mVOSkyp->getGLFogColor());
facep->renderIndexed();
gGL.popMatrix();
}

50
indra/newview/lldrawpoolground.h
View File

@ -1,50 +0,0 @@
/**
* @file lldrawpoolground.h
* @brief LLDrawPoolGround class definition
*
* $LicenseInfo:firstyear=2002&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, 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$
*/
#ifndef LL_LLDRAWPOOLGROUND_H
#define LL_LLDRAWPOOLGROUND_H
#include "lldrawpool.h"
class LLDrawPoolGround : public LLFacePool
{
public:
enum
{
VERTEX_DATA_MASK = LLVertexBuffer::MAP_VERTEX |
LLVertexBuffer::MAP_TEXCOORD0
};
virtual U32 getVertexDataMask() { return VERTEX_DATA_MASK; }
LLDrawPoolGround();
/*virtual*/ void prerender();
/*virtual*/ void render(S32 pass = 0);
};
#endif // LL_LLDRAWPOOLGROUND_H

9
indra/newview/lldrawpoolmaterials.cpp
View File

@ -98,15 +98,6 @@ void LLDrawPoolMaterials::beginDeferredPass(S32 pass)
}
gPipeline.bindDeferredShader(*mShader);
if (LLPipeline::sRenderingHUDs)
{
mShader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
mShader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
void LLDrawPoolMaterials::endDeferredPass(S32 pass)

334
indra/newview/lldrawpoolsimple.cpp
View File

@ -46,15 +46,6 @@ static LLTrace::BlockTimerStatHandle FTM_RENDER_GRASS_DEFERRED("Deferred Grass")
static void setup_simple_shader(LLGLSLShader* shader)
{
shader->bind();
if (LLPipeline::sRenderingHUDs)
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
}
else
{
shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
}
}
static void setup_glow_shader(LLGLSLShader* shader)
@ -79,13 +70,9 @@ static void setup_fullbright_shader(LLGLSLShader* shader)
void LLDrawPoolGlow::renderPostDeferred(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_GLOW);
render(&gDeferredEmissiveProgram);
}
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
LLGLSLShader* shader = &gDeferredEmissiveProgram;
void LLDrawPoolGlow::render(LLGLSLShader* shader)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_GLOW);
LLGLEnable blend(GL_BLEND);
LLGLDisable test(GL_ALPHA_TEST);
gGL.flush();
@ -110,93 +97,11 @@ void LLDrawPoolGlow::render(LLGLSLShader* shader)
gGL.setSceneBlendType(LLRender::BT_ALPHA);
}
S32 LLDrawPoolGlow::getNumPasses()
{
return 1;
}
void LLDrawPoolGlow::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
LLGLSLShader* shader = LLPipeline::sUnderWaterRender ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
render(shader);
}
LLDrawPoolSimple::LLDrawPoolSimple() :
LLRenderPass(POOL_SIMPLE)
{
}
void LLDrawPoolSimple::prerender()
{
mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
S32 LLDrawPoolSimple::getNumPasses()
{
return 1;
}
void LLDrawPoolSimple::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE);
LLGLDisable blend(GL_BLEND);
LLGLSLShader* shader = nullptr;
if (LLPipeline::sImpostorRender)
{
shader = &gObjectSimpleImpostorProgram;
}
else if (LLPipeline::sUnderWaterRender)
{
shader = &gObjectSimpleWaterProgram;
}
else
{
shader = &gObjectSimpleProgram;
}
{ //render simple
gPipeline.enableLightsDynamic();
// first pass -- static objects
{
setup_simple_shader(shader);
pushBatches(LLRenderPass::PASS_SIMPLE, true, true);
if (LLPipeline::sRenderDeferred)
{ //if deferred rendering is enabled, bump faces aren't registered as simple
//render bump faces here as simple so bump faces will appear under water
pushBatches(LLRenderPass::PASS_BUMP, true, true);
pushBatches(LLRenderPass::PASS_MATERIAL, true, true);
pushBatches(LLRenderPass::PASS_SPECMAP, true, true);
pushBatches(LLRenderPass::PASS_NORMMAP, true, true);
pushBatches(LLRenderPass::PASS_NORMSPEC, true, true);
}
}
//second pass, rigged
{
shader = shader->mRiggedVariant;
setup_simple_shader(shader);
pushRiggedBatches(LLRenderPass::PASS_SIMPLE_RIGGED, true, true);
if (LLPipeline::sRenderDeferred)
{ //if deferred rendering is enabled, bump faces aren't registered as simple
//render bump faces here as simple so bump faces will appear under water
pushRiggedBatches(LLRenderPass::PASS_BUMP_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_MATERIAL_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_SPECMAP_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_NORMMAP_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_RIGGED, true, true);
}
}
}
}
static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_MASK("Alpha Mask");
LLDrawPoolAlphaMask::LLDrawPoolAlphaMask() :
@ -204,76 +109,11 @@ LLDrawPoolAlphaMask::LLDrawPoolAlphaMask() :
{
}
void LLDrawPoolAlphaMask::prerender()
{
mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
void LLDrawPoolAlphaMask::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
LLGLDisable blend(GL_BLEND);
LLGLSLShader* shader = nullptr;
if (LLPipeline::sUnderWaterRender)
{
shader = &gObjectSimpleWaterAlphaMaskProgram;
}
else
{
shader = &gObjectSimpleAlphaMaskProgram;
}
// render static
setup_simple_shader(shader);
pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, true, true);
pushMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, true, true);
pushMaskBatches(LLRenderPass::PASS_SPECMAP_MASK, true, true);
pushMaskBatches(LLRenderPass::PASS_NORMMAP_MASK, true, true);
pushMaskBatches(LLRenderPass::PASS_NORMSPEC_MASK, true, true);
// render rigged
setup_simple_shader(shader->mRiggedVariant);
pushRiggedMaskBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, true, true);
pushRiggedMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK_RIGGED, true, true);
pushRiggedMaskBatches(LLRenderPass::PASS_SPECMAP_MASK_RIGGED, true, true);
pushRiggedMaskBatches(LLRenderPass::PASS_NORMMAP_MASK_RIGGED, true, true);
pushRiggedMaskBatches(LLRenderPass::PASS_NORMSPEC_MASK_RIGGED, true, true);
}
LLDrawPoolFullbrightAlphaMask::LLDrawPoolFullbrightAlphaMask() :
LLRenderPass(POOL_FULLBRIGHT_ALPHA_MASK)
{
}
void LLDrawPoolFullbrightAlphaMask::prerender()
{
mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
void LLDrawPoolFullbrightAlphaMask::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK);
LLGLSLShader* shader = nullptr;
if (LLPipeline::sUnderWaterRender)
{
shader = &gObjectFullbrightWaterAlphaMaskProgram;
}
else
{
shader = &gObjectFullbrightAlphaMaskProgram;
}
// render static
setup_fullbright_shader(shader);
pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, true, true);
// render rigged
setup_fullbright_shader(shader->mRiggedVariant);
pushRiggedMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, true, true);
}
//===============================
//DEFERRED IMPLEMENTATION
//===============================
@ -322,102 +162,13 @@ LLDrawPoolGrass::LLDrawPoolGrass() :
}
void LLDrawPoolGrass::prerender()
{
mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
void LLDrawPoolGrass::beginRenderPass(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_GRASS);
stop_glerror();
if (LLPipeline::sUnderWaterRender)
{
simple_shader = &gObjectAlphaMaskNonIndexedWaterProgram;
}
else
{
simple_shader = &gObjectAlphaMaskNonIndexedProgram;
}
if (mShaderLevel > 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
{
gGL.flush();
LLGLSLShader::unbind();
}
}
void LLDrawPoolGrass::endRenderPass(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_GRASS);
LLRenderPass::endRenderPass(pass);
if (mShaderLevel > 0)
{
simple_shader->unbind();
}
else
{
gGL.flush();
}
}
void LLDrawPoolGrass::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
LLGLDisable blend(GL_BLEND);
{
//LL_RECORD_BLOCK_TIME(FTM_RENDER_GRASS);
LLGLEnable test(GL_ALPHA_TEST);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
//render grass
LLRenderPass::pushBatches(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
}
void LLDrawPoolGrass::beginDeferredPass(S32 pass)
{
}
void LLDrawPoolGrass::endDeferredPass(S32 pass)
{
}
void LLDrawPoolGrass::renderDeferred(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
{
//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::pushBatches(LLRenderPass::PASS_GRASS, getVertexDataMask());
}
@ -430,18 +181,16 @@ LLDrawPoolFullbright::LLDrawPoolFullbright() :
{
}
void LLDrawPoolFullbright::prerender()
{
mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_FULLBRIGHT);
LLGLSLShader* shader = nullptr;
if (LLPipeline::sUnderWaterRender)
if (LLPipeline::sRenderingHUDs)
{
shader = &gHUDFullbrightProgram;
}
else if (LLPipeline::sUnderWaterRender)
{
shader = &gDeferredFullbrightWaterProgram;
}
@ -456,47 +205,12 @@ void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
setup_fullbright_shader(shader);
pushBatches(LLRenderPass::PASS_FULLBRIGHT, true, true);
// render rigged
setup_fullbright_shader(shader->mRiggedVariant);
pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_RIGGED, true, true);
}
void LLDrawPoolFullbright::render(S32 pass)
{ //render fullbright
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_FULLBRIGHT);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
stop_glerror();
LLGLSLShader* shader = nullptr;
if (LLPipeline::sUnderWaterRender)
if (!LLPipeline::sRenderingHUDs)
{
shader = &gObjectFullbrightWaterProgram;
// render rigged
setup_fullbright_shader(shader->mRiggedVariant);
pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_RIGGED, true, true);
}
else
{
shader = &gObjectFullbrightProgram;
}
// render static
setup_fullbright_shader(shader);
pushBatches(LLRenderPass::PASS_FULLBRIGHT, true, true);
pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE, true, true);
pushBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE, true, true);
pushBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE, true, true);
pushBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE, true, true);
// render rigged
setup_fullbright_shader(shader->mRiggedVariant);
pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE_RIGGED, true, true);
pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE_RIGGED, true, true);
}
S32 LLDrawPoolFullbright::getNumPasses()
{
return 1;
}
void LLDrawPoolFullbrightAlphaMask::renderPostDeferred(S32 pass)
@ -506,32 +220,28 @@ void LLDrawPoolFullbrightAlphaMask::renderPostDeferred(S32 pass)
LLGLSLShader* shader = nullptr;
if (LLPipeline::sRenderingHUDs)
{
shader = &gDeferredFullbrightAlphaMaskProgram;
shader = &gHUDFullbrightAlphaMaskProgram;
}
else if (LLPipeline::sRenderDeferred)
else if (LLPipeline::sUnderWaterRender)
{
if (LLPipeline::sUnderWaterRender)
{
shader = &gDeferredFullbrightAlphaMaskWaterProgram;
}
else
{
shader = &gDeferredFullbrightAlphaMaskProgram;
}
shader = &gDeferredFullbrightAlphaMaskWaterProgram;
}
else
{
shader = &gObjectFullbrightAlphaMaskProgram;
shader = &gDeferredFullbrightAlphaMaskProgram;
}
LLGLDisable blend(GL_BLEND);
LLGLDisable blend(GL_BLEND);
// render static
setup_fullbright_shader(shader);
pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, true, true);
// render rigged
setup_fullbright_shader(shader->mRiggedVariant);
pushRiggedMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, true, true);
if (!LLPipeline::sRenderingHUDs)
{
// render rigged
setup_fullbright_shader(shader->mRiggedVariant);
pushRiggedMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, true, true);
}
}

49
indra/newview/lldrawpoolsimple.h
View File

@ -47,11 +47,6 @@ public:
S32 getNumDeferredPasses() override;
void renderDeferred(S32 pass) override;
/// We need two passes so we can handle emissive materials separately.
S32 getNumPasses() override;
void render(S32 pass = 0) override;
void prerender() override;
};
class LLDrawPoolGrass : public LLRenderPass
@ -68,17 +63,8 @@ public:
LLDrawPoolGrass();
/*virtual*/ S32 getNumDeferredPasses() { return 1; }
/*virtual*/ void beginDeferredPass(S32 pass);
/*virtual*/ void endDeferredPass(S32 pass);
/*virtual*/ void renderDeferred(S32 pass);
/*virtual*/ void beginRenderPass(S32 pass);
/*virtual*/ void endRenderPass(S32 pass);
/// We need two passes so we can handle emissive materials separately.
/*virtual*/ S32 getNumPasses() { return 1; }
/*virtual*/ void render(S32 pass = 0);
/*virtual*/ void prerender();
S32 getNumDeferredPasses() override { return 1; }
void renderDeferred(S32 pass) override;
};
class LLDrawPoolAlphaMask : public LLRenderPass
@ -97,11 +83,6 @@ public:
/*virtual*/ S32 getNumDeferredPasses() { return 1; }
/*virtual*/ void renderDeferred(S32 pass);
/*virtual*/ S32 getNumPasses() { return 1; }
/*virtual*/ void render(S32 pass = 0);
/*virtual*/ void prerender();
};
class LLDrawPoolFullbrightAlphaMask : public LLRenderPass
@ -119,10 +100,6 @@ public:
/*virtual*/ S32 getNumPostDeferredPasses() { return 1; }
/*virtual*/ void renderPostDeferred(S32 pass);
/*virtual*/ S32 getNumPasses() { return 1; }
/*virtual*/ void render(S32 pass = 0);
/*virtual*/ void prerender();
};
@ -139,13 +116,8 @@ public:
LLDrawPoolFullbright();
/*virtual*/ S32 getNumPostDeferredPasses() { return 1; }
/*virtual*/ void renderPostDeferred(S32 pass);
/*virtual*/ S32 getNumPasses();
/*virtual*/ void render(S32 pass = 0);
/*virtual*/ void prerender();
S32 getNumPostDeferredPasses() override { return 1; }
void renderPostDeferred(S32 pass) override;
};
class LLDrawPoolGlow : public LLRenderPass
@ -162,17 +134,8 @@ public:
virtual U32 getVertexDataMask() { return VERTEX_DATA_MASK; }
virtual void prerender() { }
/*virtual*/ S32 getNumPostDeferredPasses() { return 1; }
/*virtual*/ void renderPostDeferred(S32 pass);
void render(LLGLSLShader* shader);
/*virtual*/ S32 getNumPasses();
void render(S32 pass = 0);
S32 getNumPostDeferredPasses() override { return 1; }
void renderPostDeferred(S32 pass) override;
};
#endif // LL_LLDRAWPOOLSIMPLE_H

137
indra/newview/lldrawpooltree.cpp
View File

@ -50,94 +50,6 @@ LLDrawPoolTree::LLDrawPoolTree(LLViewerTexture *texturep) :
mTexturep->setAddressMode(LLTexUnit::TAM_WRAP);
}
void LLDrawPoolTree::prerender()
{
mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
}
void LLDrawPoolTree::beginRenderPass(S32 pass)
{
LL_RECORD_BLOCK_TIME(FTM_RENDER_TREES);
if (LLPipeline::sUnderWaterRender)
{
shader = &gTreeWaterProgram;
}
else
{
shader = &gTreeProgram;
}
if (gPipeline.shadersLoaded())
{
shader->bind();
shader->setMinimumAlpha(0.5f);
gGL.diffuseColor4f(1,1,1,1);
}
else
{
gPipeline.enableLightsDynamic();
gGL.flush();
}
}
void LLDrawPoolTree::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED;
if (mDrawFace.empty())
{
return;
}
LLGLState test(GL_ALPHA_TEST, 0);
gGL.getTexUnit(sDiffTex)->bindFast(mTexturep);
mTexturep->addTextureStats(1024.f * 1024.f); // <=== keep Linden tree textures at full res
for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
iter != mDrawFace.end(); iter++)
{
LLFace *face = *iter;
LLVertexBuffer* buff = face->getVertexBuffer();
if(buff)
{
LLMatrix4* model_matrix = &(face->getDrawable()->getRegion()->mRenderMatrix);
if (model_matrix != gGLLastMatrix)
{
gGLLastMatrix = model_matrix;
gGL.loadMatrix(gGLModelView);
if (model_matrix)
{
llassert(gGL.getMatrixMode() == LLRender::MM_MODELVIEW);
gGL.multMatrix((GLfloat*) model_matrix->mMatrix);
}
gPipeline.mMatrixOpCount++;
}
buff->setBuffer();
buff->drawRange(LLRender::TRIANGLES, 0, buff->getNumVerts()-1, buff->getNumIndices(), 0);
}
}
}
void LLDrawPoolTree::endRenderPass(S32 pass)
{
LL_RECORD_BLOCK_TIME(FTM_RENDER_TREES);
if (gPipeline.canUseWindLightShadersOnObjects())
{
shader->unbind();
}
if (mShaderLevel <= 0)
{
gGL.flush();
}
}
//============================================
// deferred implementation
//============================================
@ -153,7 +65,44 @@ void LLDrawPoolTree::beginDeferredPass(S32 pass)
void LLDrawPoolTree::renderDeferred(S32 pass)
{
LL_PROFILE_ZONE_SCOPED;
render(pass);
LL_PROFILE_ZONE_SCOPED;
if (mDrawFace.empty())
{
return;
}
LLGLState test(GL_ALPHA_TEST, 0);
gGL.getTexUnit(sDiffTex)->bindFast(mTexturep);
mTexturep->addTextureStats(1024.f * 1024.f); // <=== keep Linden tree textures at full res
for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
iter != mDrawFace.end(); iter++)
{
LLFace* face = *iter;
LLVertexBuffer* buff = face->getVertexBuffer();
if (buff)
{
LLMatrix4* model_matrix = &(face->getDrawable()->getRegion()->mRenderMatrix);
if (model_matrix != gGLLastMatrix)
{
gGLLastMatrix = model_matrix;
gGL.loadMatrix(gGLModelView);
if (model_matrix)
{
llassert(gGL.getMatrixMode() == LLRender::MM_MODELVIEW);
gGL.multMatrix((GLfloat*)model_matrix->mMatrix);
}
gPipeline.mMatrixOpCount++;
}
buff->setBuffer();
buff->drawRange(LLRender::TRIANGLES, 0, buff->getNumVerts() - 1, buff->getNumIndices(), 0);
}
}
}
void LLDrawPoolTree::endDeferredPass(S32 pass)
@ -182,7 +131,7 @@ void LLDrawPoolTree::beginShadowPass(S32 pass)
void LLDrawPoolTree::renderShadow(S32 pass)
{
render(pass);
renderDeferred(pass);
}
void LLDrawPoolTree::endShadowPass(S32 pass)
@ -196,14 +145,6 @@ void LLDrawPoolTree::endShadowPass(S32 pass)
BOOL LLDrawPoolTree::verify() const
{
/* BOOL ok = TRUE;
if (!ok)
{
printDebugInfo();
}
return ok;*/
return TRUE;
}

6
indra/newview/lldrawpooltree.h
View File

@ -45,8 +45,6 @@ public:
LLDrawPoolTree(LLViewerTexture *texturep);
/*virtual*/ void prerender();
/*virtual*/ S32 getNumDeferredPasses() { return 1; }
/*virtual*/ void beginDeferredPass(S32 pass);
/*virtual*/ void endDeferredPass(S32 pass);
@ -57,10 +55,6 @@ public:
/*virtual*/ void endShadowPass(S32 pass);
/*virtual*/ void renderShadow(S32 pass);
/*virtual*/ void beginRenderPass( S32 pass );
/*virtual*/ void render(S32 pass = 0);
/*virtual*/ void endRenderPass( S32 pass );
/*virtual*/ S32 getNumPasses() { return 1; }
/*virtual*/ BOOL verify() const;
/*virtual*/ LLViewerTexture *getTexture();
/*virtual*/ LLViewerTexture *getDebugTexture();

191
indra/newview/lldrawpoolwlsky.cpp
View File

@ -69,51 +69,14 @@ LLViewerTexture *LLDrawPoolWLSky::getDebugTexture()
return NULL;
}
void LLDrawPoolWLSky::beginRenderPass( S32 pass )
{
sky_shader =
LLPipeline::sUnderWaterRender ?
&gObjectFullbrightNoColorWaterProgram :
&gWLSkyProgram;
cloud_shader =
LLPipeline::sUnderWaterRender ?
&gObjectFullbrightNoColorWaterProgram :
&gWLCloudProgram;
sun_shader =
LLPipeline::sUnderWaterRender ?
&gObjectFullbrightNoColorWaterProgram :
&gWLSunProgram;
moon_shader =
LLPipeline::sUnderWaterRender ?
&gObjectFullbrightNoColorWaterProgram :
&gWLMoonProgram;
}
void LLDrawPoolWLSky::endRenderPass( S32 pass )
{
sky_shader = nullptr;
cloud_shader = nullptr;
sun_shader = nullptr;
moon_shader = nullptr;
}
void LLDrawPoolWLSky::beginDeferredPass(S32 pass)
{
sky_shader = &gDeferredWLSkyProgram;
cloud_shader = &gDeferredWLCloudProgram;
sun_shader =
LLPipeline::sUnderWaterRender ?
&gObjectFullbrightNoColorWaterProgram :
&gDeferredWLSunProgram;
sun_shader = &gDeferredWLSunProgram;
moon_shader =
LLPipeline::sUnderWaterRender ?
&gObjectFullbrightNoColorWaterProgram :
&gDeferredWLMoonProgram;
moon_shader = &gDeferredWLMoonProgram;
}
void LLDrawPoolWLSky::endDeferredPass(S32 pass)
@ -124,11 +87,6 @@ void LLDrawPoolWLSky::endDeferredPass(S32 pass)
moon_shader = nullptr;
}
void LLDrawPoolWLSky::renderFsSky(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader * shader) const
{
gSky.mVOWLSkyp->drawFsSky();
}
void LLDrawPoolWLSky::renderDome(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader * shader) const
{
llassert_always(NULL != shader);
@ -213,74 +171,6 @@ void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 ca
}
}
void LLDrawPoolWLSky::renderSkyHaze(const LLVector3& camPosLocal, F32 camHeightLocal) const
{
LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
{
LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
LLGLSPipelineDepthTestSkyBox sky(true, false);
sky_shader->bind();
sky_shader->uniform1i(LLShaderMgr::SUN_UP_FACTOR, 1);
sky_shader->uniform1f(LLShaderMgr::SUN_MOON_GLOW_FACTOR, psky->getSunMoonGlowFactor());
renderDome(origin, camHeightLocal, sky_shader);
sky_shader->unbind();
}
}
void LLDrawPoolWLSky::renderStars(const LLVector3& camPosLocal) const
{
LLGLSPipelineBlendSkyBox gls_skybox(true, false);
// *NOTE: have to have bound the cloud noise texture already since register
// combiners blending below requires something to be bound
// and we might as well only bind once.
gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
// *NOTE: we divide by two here and GL_ALPHA_SCALE by two below to avoid
// clamping and allow the star_alpha param to brighten the stars.
LLColor4 star_alpha(LLColor4::black);
star_alpha.mV[3] = LLEnvironment::instance().getCurrentSky()->getStarBrightness() / 512.f;
// If star brightness is not set, exit
if( star_alpha.mV[3] < 0.001 )
{
LL_DEBUGS("SKY") << "star_brightness below threshold." << LL_ENDL;
return;
}
LLViewerTexture* tex_a = gSky.mVOSkyp->getBloomTex();
LLViewerTexture* tex_b = gSky.mVOSkyp->getBloomTexNext();
if (tex_a && (!tex_b || (tex_a == tex_b)))
{
// Bind current and next sun textures
gGL.getTexUnit(0)->bind(tex_a);
}
else if (tex_b && !tex_a)
{
gGL.getTexUnit(0)->bind(tex_b);
}
else if (tex_b != tex_a)
{
gGL.getTexUnit(0)->bind(tex_a);
}
gGL.pushMatrix();
gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
gGL.rotatef(gFrameTimeSeconds*0.01f, 0.f, 0.f, 1.f);
gStarsProgram.bind();
gStarsProgram.uniform1f(sCustomAlpha, star_alpha.mV[3]);
gSky.mVOWLSkyp->drawStars();
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gGL.popMatrix();
gStarsProgram.unbind(); // SL-14113 was gCustomAlphaProgram
}
void LLDrawPoolWLSky::renderStarsDeferred(const LLVector3& camPosLocal) const
{
if (!gSky.mVOSkyp)
@ -406,65 +296,10 @@ void LLDrawPoolWLSky::renderSkyCloudsDeferred(const LLVector3& camPosLocal, F32
}
}
void LLDrawPoolWLSky::renderSkyClouds(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader* cloudshader) const
{
if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS) && gSky.mVOSkyp && gSky.mVOSkyp->getCloudNoiseTex())
{
LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
LLGLSPipelineBlendSkyBox pipeline(true, true);
cloudshader->bind();
LLPointer<LLViewerTexture> cloud_noise = gSky.mVOSkyp->getCloudNoiseTex();
LLPointer<LLViewerTexture> cloud_noise_next = gSky.mVOSkyp->getCloudNoiseTexNext();
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
F32 cloud_variance = psky ? psky->getCloudVariance() : 0.0f;
F32 blend_factor = psky ? psky->getBlendFactor() : 0.0f;
// if we even have sun disc textures to work with...
if (cloud_noise || cloud_noise_next)
{
if (cloud_noise && (!cloud_noise_next || (cloud_noise == cloud_noise_next)))
{
// Bind current and next sun textures
cloudshader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP, cloud_noise, LLTexUnit::TT_TEXTURE);
blend_factor = 0;
}
else if (cloud_noise_next && !cloud_noise)
{
cloudshader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP, cloud_noise_next, LLTexUnit::TT_TEXTURE);
blend_factor = 0;
}
else if (cloud_noise_next != cloud_noise)
{
cloudshader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP, cloud_noise, LLTexUnit::TT_TEXTURE);
cloudshader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP_NEXT, cloud_noise_next, LLTexUnit::TT_TEXTURE);
}
}
cloudshader->uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
cloudshader->uniform1f(LLShaderMgr::CLOUD_VARIANCE, cloud_variance);
cloudshader->uniform1f(LLShaderMgr::SUN_MOON_GLOW_FACTOR, psky->getSunMoonGlowFactor());
/// Render the skydome
renderDome(camPosLocal, camHeightLocal, cloudshader);
cloudshader->unbind();
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
}
}
void LLDrawPoolWLSky::renderHeavenlyBodies()
{
if (!gSky.mVOSkyp) return;
//LLGLSPipelineBlendSkyBox gls_skybox(true, false);
LLGLSPipelineBlendSkyBox gls_skybox(true, true); // SL-14113 we need moon to write to depth to clip stars behind
LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
@ -602,29 +437,7 @@ void LLDrawPoolWLSky::renderDeferred(S32 pass)
gGL.setColorMask(true, true);
}
void LLDrawPoolWLSky::render(S32 pass)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_WL_SKY);
if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
{
return;
}
const F32 camHeightLocal = LLEnvironment::instance().getCamHeight();
LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
renderSkyHaze(origin, camHeightLocal);
renderHeavenlyBodies();
renderStars(origin);
renderSkyClouds(origin, camHeightLocal, cloud_shader);
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
}
void LLDrawPoolWLSky::prerender()
{
//LL_INFOS() << "wlsky prerendering pass." << LL_ENDL;
}
LLViewerTexture* LLDrawPoolWLSky::getTexture()
{

10
indra/newview/lldrawpoolwlsky.h
View File

@ -51,11 +51,6 @@ public:
/*virtual*/ void renderDeferred(S32 pass);
/*virtual*/ LLViewerTexture *getDebugTexture();
/*virtual*/ void beginRenderPass( S32 pass );
/*virtual*/ void endRenderPass( S32 pass );
/*virtual*/ S32 getNumPasses() { return 1; }
/*virtual*/ void render(S32 pass = 0);
/*virtual*/ void prerender();
/*virtual*/ U32 getVertexDataMask() { return SKY_VERTEX_DATA_MASK; }
/*virtual*/ BOOL verify() const { return TRUE; } // Verify that all data in the draw pool is correct!
/*virtual*/ S32 getShaderLevel() const { return mShaderLevel; }
@ -69,17 +64,12 @@ public:
static void cleanupGL();
static void restoreGL();
private:
void renderFsSky(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader * shader) const;
void renderDome(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader * shader) const;
void renderSkyHaze(const LLVector3& camPosLocal, F32 camHeightLocal) const;
void renderSkyClouds(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader* cloudshader) const;
void renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 camHeightLocal) const;
void renderSkyCloudsDeferred(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader* cloudshader) const;
void renderStarsDeferred(const LLVector3& camPosLocal) const;
void renderStars(const LLVector3& camPosLocal) const;
void renderHeavenlyBodies();
};

8
indra/newview/llsky.cpp
View File

@ -85,7 +85,6 @@ void LLSky::cleanup()
{
mVOSkyp = NULL;
mVOWLSkyp = NULL;
mVOGroundp = NULL;
}
void LLSky::destroyGL()
@ -114,12 +113,10 @@ void LLSky::restoreGL()
void LLSky::resetVertexBuffers()
{
if (gSky.mVOSkyp.notNull() && gSky.mVOGroundp.notNull())
if (gSky.mVOSkyp.notNull())
{
gPipeline.resetVertexBuffers(gSky.mVOSkyp->mDrawable);
gPipeline.resetVertexBuffers(gSky.mVOGroundp->mDrawable);
gPipeline.markRebuild(gSky.mVOSkyp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
gPipeline.markRebuild(gSky.mVOGroundp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
}
if (gSky.mVOWLSkyp.notNull())
{
@ -208,9 +205,6 @@ void LLSky::init()
mVOSkyp->init();
gPipeline.createObject(mVOSkyp.get());
mVOGroundp = (LLVOGround*)gObjectList.createObjectViewer(LLViewerObject::LL_VO_GROUND, NULL);
gPipeline.createObject(mVOGroundp.get());
gSky.setFogRatio(gSavedSettings.getF32("RenderFogRatio"));
mUpdatedThisFrame = TRUE;

2
indra/newview/llsky.h
View File

@ -34,7 +34,6 @@
#include "v4color.h"
#include "v4coloru.h"
#include "llvosky.h"
#include "llvoground.h"
class LLViewerCamera;
@ -88,7 +87,6 @@ public:
public:
LLPointer<LLVOSky> mVOSkyp; // Pointer to the LLVOSky object (only one, ever!)
LLPointer<LLVOGround> mVOGroundp;
LLPointer<LLVOWLSky> mVOWLSkyp;
protected:

3
indra/newview/llspatialpartition.cpp
View File

@ -2845,8 +2845,7 @@ void renderTexelDensity(LLDrawable* drawable)
}
LLGLEnable _(GL_BLEND);
//gObjectFullbrightProgram.bind();
LLMatrix4 checkerboard_matrix;
S32 discard_level = -1;

1
indra/newview/lltoolpie.cpp
View File

@ -642,7 +642,6 @@ bool LLToolPie::walkToClickedLocation()
mPick = saved_pick;
return false;
}
return true;
}
bool LLToolPie::teleportToClickedLocation()

4
indra/newview/llviewercontrol.cpp
View File

@ -171,8 +171,7 @@ static bool handleRenderPerfTestChanged(const LLSD& newvalue)
if (!status)
{
gPipeline.clearRenderTypeMask(LLPipeline::RENDER_TYPE_WL_SKY,
LLPipeline::RENDER_TYPE_GROUND,
LLPipeline::RENDER_TYPE_TERRAIN,
LLPipeline::RENDER_TYPE_TERRAIN,
LLPipeline::RENDER_TYPE_GRASS,
LLPipeline::RENDER_TYPE_TREE,
LLPipeline::RENDER_TYPE_WATER,
@ -186,7 +185,6 @@ static bool handleRenderPerfTestChanged(const LLSD& newvalue)
else
{
gPipeline.setRenderTypeMask(LLPipeline::RENDER_TYPE_WL_SKY,
LLPipeline::RENDER_TYPE_GROUND,
LLPipeline::RENDER_TYPE_TERRAIN,
LLPipeline::RENDER_TYPE_GRASS,
LLPipeline::RENDER_TYPE_TREE,

4
indra/newview/llviewermenu.cpp
View File

@ -764,10 +764,6 @@ U32 render_type_from_string(std::string render_type)
{
return LLPipeline::RENDER_TYPE_WATER;
}
else if ("ground" == render_type)
{
return LLPipeline::RENDER_TYPE_GROUND;
}
else if ("volume" == render_type)
{
return LLPipeline::RENDER_TYPE_VOLUME;

4
indra/newview/llviewerobject.cpp
View File

@ -84,7 +84,6 @@
#include "llvoavatar.h"
#include "llvoavatarself.h"
#include "llvograss.h"
#include "llvoground.h"
#include "llvolume.h"
#include "llvolumemessage.h"
#include "llvopartgroup.h"
@ -163,7 +162,6 @@ LLViewerObject *LLViewerObject::createObject(const LLUUID &id, const LLPCode pco
&& pcode != LL_VO_VOID_WATER
&& pcode != LL_VO_WL_SKY
&& pcode != LL_VO_SKY
&& pcode != LL_VO_GROUND
&& pcode != LL_VO_PART_GROUP
)
{
@ -235,8 +233,6 @@ LLViewerObject *LLViewerObject::createObject(const LLUUID &id, const LLPCode pco
res = new LLVOVoidWater(id, pcode, regionp); break;
case LL_VO_WATER:
res = new LLVOWater(id, pcode, regionp); break;
case LL_VO_GROUND:
res = new LLVOGround(id, pcode, regionp); break;
case LL_VO_PART_GROUP:
res = new LLVOPartGroup(id, pcode, regionp); break;
case LL_VO_HUD_PART_GROUP:

1
indra/newview/llviewerobject.h
View File

@ -672,7 +672,6 @@ public:
LL_VO_SKY = LL_PCODE_APP | 0x60,
LL_VO_VOID_WATER = LL_PCODE_APP | 0x70,
LL_VO_WATER = LL_PCODE_APP | 0x80,
LL_VO_GROUND = LL_PCODE_APP | 0x90,
LL_VO_PART_GROUP = LL_PCODE_APP | 0xa0,
LL_VO_TRIANGLE_TORUS = LL_PCODE_APP | 0xb0,
LL_VO_HUD_PART_GROUP = LL_PCODE_APP | 0xc0,

622
indra/newview/llviewershadermgr.cpp
View File

@ -97,49 +97,12 @@ LLGLSLShader gCopyProgram;
LLGLSLShader gCopyDepthProgram;
//object shaders
LLGLSLShader gObjectSimpleProgram;
LLGLSLShader gSkinnedObjectSimpleProgram;
LLGLSLShader gObjectSimpleImpostorProgram;
LLGLSLShader gSkinnedObjectSimpleImpostorProgram;
LLGLSLShader gObjectPreviewProgram;
LLGLSLShader gPhysicsPreviewProgram;
LLGLSLShader gObjectSimpleWaterProgram;
LLGLSLShader gSkinnedObjectSimpleWaterProgram;
LLGLSLShader gObjectSimpleAlphaMaskProgram;
LLGLSLShader gSkinnedObjectSimpleAlphaMaskProgram;
LLGLSLShader gObjectSimpleWaterAlphaMaskProgram;
LLGLSLShader gSkinnedObjectSimpleWaterAlphaMaskProgram;
LLGLSLShader gObjectFullbrightProgram;
LLGLSLShader gSkinnedObjectFullbrightProgram;
LLGLSLShader gObjectFullbrightWaterProgram;
LLGLSLShader gSkinnedObjectFullbrightWaterProgram;
LLGLSLShader gObjectEmissiveProgram;
LLGLSLShader gSkinnedObjectEmissiveProgram;
LLGLSLShader gObjectEmissiveWaterProgram;
LLGLSLShader gSkinnedObjectEmissiveWaterProgram;
LLGLSLShader gObjectFullbrightAlphaMaskProgram;
LLGLSLShader gSkinnedObjectFullbrightAlphaMaskProgram;
LLGLSLShader gObjectFullbrightWaterAlphaMaskProgram;
LLGLSLShader gSkinnedObjectFullbrightWaterAlphaMaskProgram;
LLGLSLShader gObjectFullbrightShinyProgram;
LLGLSLShader gSkinnedObjectFullbrightShinyProgram;
LLGLSLShader gObjectFullbrightShinyWaterProgram;
LLGLSLShader gSkinnedObjectFullbrightShinyWaterProgram;
LLGLSLShader gObjectShinyProgram;
LLGLSLShader gSkinnedObjectShinyProgram;
LLGLSLShader gObjectShinyWaterProgram;
LLGLSLShader gSkinnedObjectShinyWaterProgram;
LLGLSLShader gObjectBumpProgram;
LLGLSLShader gSkinnedObjectBumpProgram;
LLGLSLShader gTreeProgram;
LLGLSLShader gTreeWaterProgram;
LLGLSLShader gObjectFullbrightNoColorProgram;
LLGLSLShader gObjectFullbrightNoColorWaterProgram;
LLGLSLShader gObjectSimpleNonIndexedTexGenProgram;
LLGLSLShader gObjectSimpleNonIndexedTexGenWaterProgram;
LLGLSLShader gObjectAlphaMaskNonIndexedProgram;
LLGLSLShader gObjectAlphaMaskNonIndexedWaterProgram;
LLGLSLShader gObjectAlphaMaskNoColorProgram;
LLGLSLShader gObjectAlphaMaskNoColorWaterProgram;
@ -224,6 +187,7 @@ LLGLSLShader gDeferredAvatarShadowProgram;
LLGLSLShader gDeferredAvatarAlphaShadowProgram;
LLGLSLShader gDeferredAvatarAlphaMaskShadowProgram;
LLGLSLShader gDeferredAlphaProgram;
LLGLSLShader gHUDAlphaProgram;
LLGLSLShader gDeferredSkinnedAlphaProgram;
LLGLSLShader gDeferredAlphaImpostorProgram;
LLGLSLShader gDeferredSkinnedAlphaImpostorProgram;
@ -231,8 +195,11 @@ LLGLSLShader gDeferredAlphaWaterProgram;
LLGLSLShader gDeferredSkinnedAlphaWaterProgram;
LLGLSLShader gDeferredAvatarEyesProgram;
LLGLSLShader gDeferredFullbrightProgram;
LLGLSLShader gHUDFullbrightProgram;
LLGLSLShader gDeferredFullbrightAlphaMaskProgram;
LLGLSLShader gHUDFullbrightAlphaMaskProgram;
LLGLSLShader gDeferredFullbrightAlphaMaskAlphaProgram;
LLGLSLShader gHUDFullbrightAlphaMaskAlphaProgram;
LLGLSLShader gDeferredFullbrightWaterProgram;
LLGLSLShader gDeferredSkinnedFullbrightWaterProgram;
LLGLSLShader gDeferredFullbrightWaterAlphaProgram;
@ -253,6 +220,7 @@ LLGLSLShader gDeferredWLSunProgram;
LLGLSLShader gDeferredWLMoonProgram;
LLGLSLShader gDeferredStarProgram;
LLGLSLShader gDeferredFullbrightShinyProgram;
LLGLSLShader gHUDFullbrightShinyProgram;
LLGLSLShader gDeferredSkinnedFullbrightShinyProgram;
LLGLSLShader gDeferredSkinnedFullbrightProgram;
LLGLSLShader gDeferredSkinnedFullbrightAlphaMaskProgram;
@ -295,69 +263,37 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
mShaderList.push_back(&gWLSunProgram);
mShaderList.push_back(&gWLMoonProgram);
mShaderList.push_back(&gAvatarProgram);
mShaderList.push_back(&gObjectShinyProgram);
mShaderList.push_back(&gSkinnedObjectShinyProgram);
mShaderList.push_back(&gWaterProgram);
mShaderList.push_back(&gWaterEdgeProgram);
mShaderList.push_back(&gAvatarEyeballProgram);
mShaderList.push_back(&gObjectSimpleProgram);
mShaderList.push_back(&gSkinnedObjectSimpleProgram);
mShaderList.push_back(&gObjectSimpleImpostorProgram);
mShaderList.push_back(&gSkinnedObjectSimpleImpostorProgram);
mShaderList.push_back(&gObjectPreviewProgram);
mShaderList.push_back(&gImpostorProgram);
mShaderList.push_back(&gObjectFullbrightNoColorProgram);
mShaderList.push_back(&gObjectFullbrightNoColorWaterProgram);
mShaderList.push_back(&gObjectSimpleAlphaMaskProgram);
mShaderList.push_back(&gSkinnedObjectSimpleAlphaMaskProgram);
mShaderList.push_back(&gObjectBumpProgram);
mShaderList.push_back(&gSkinnedObjectBumpProgram);
mShaderList.push_back(&gObjectEmissiveProgram);
mShaderList.push_back(&gSkinnedObjectEmissiveProgram);
mShaderList.push_back(&gObjectEmissiveWaterProgram);
mShaderList.push_back(&gSkinnedObjectEmissiveWaterProgram);
mShaderList.push_back(&gObjectFullbrightProgram);
mShaderList.push_back(&gSkinnedObjectFullbrightProgram);
mShaderList.push_back(&gObjectFullbrightAlphaMaskProgram);
mShaderList.push_back(&gSkinnedObjectFullbrightAlphaMaskProgram);
mShaderList.push_back(&gObjectFullbrightShinyProgram);
mShaderList.push_back(&gSkinnedObjectFullbrightShinyProgram);
mShaderList.push_back(&gObjectFullbrightShinyWaterProgram);
mShaderList.push_back(&gSkinnedObjectFullbrightShinyWaterProgram);
mShaderList.push_back(&gObjectSimpleNonIndexedTexGenProgram);
mShaderList.push_back(&gObjectSimpleNonIndexedTexGenWaterProgram);
mShaderList.push_back(&gObjectAlphaMaskNonIndexedProgram);
mShaderList.push_back(&gObjectAlphaMaskNonIndexedWaterProgram);
mShaderList.push_back(&gObjectAlphaMaskNoColorProgram);
mShaderList.push_back(&gObjectAlphaMaskNoColorWaterProgram);
mShaderList.push_back(&gTreeProgram);
mShaderList.push_back(&gTreeWaterProgram);
mShaderList.push_back(&gTerrainProgram);
mShaderList.push_back(&gTerrainWaterProgram);
mShaderList.push_back(&gObjectSimpleWaterProgram);
mShaderList.push_back(&gSkinnedObjectSimpleWaterProgram);
mShaderList.push_back(&gObjectFullbrightWaterProgram);
mShaderList.push_back(&gSkinnedObjectFullbrightWaterProgram);
mShaderList.push_back(&gObjectSimpleWaterAlphaMaskProgram);
mShaderList.push_back(&gSkinnedObjectSimpleWaterAlphaMaskProgram);
mShaderList.push_back(&gObjectFullbrightWaterAlphaMaskProgram);
mShaderList.push_back(&gSkinnedObjectFullbrightWaterAlphaMaskProgram);
mShaderList.push_back(&gAvatarWaterProgram);
mShaderList.push_back(&gObjectShinyWaterProgram);
mShaderList.push_back(&gSkinnedObjectShinyWaterProgram);
mShaderList.push_back(&gUnderWaterProgram);
mShaderList.push_back(&gDeferredSunProgram);
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);
@ -365,6 +301,7 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
mShaderList.push_back(&gDeferredFullbrightAlphaMaskWaterProgram);
mShaderList.push_back(&gDeferredSkinnedFullbrightAlphaMaskWaterProgram);
mShaderList.push_back(&gDeferredFullbrightShinyProgram);
mShaderList.push_back(&gHUDFullbrightShinyProgram);
mShaderList.push_back(&gDeferredSkinnedFullbrightShinyProgram);
mShaderList.push_back(&gDeferredSkinnedFullbrightProgram);
mShaderList.push_back(&gDeferredSkinnedFullbrightAlphaMaskProgram);
@ -682,54 +619,17 @@ void LLViewerShaderMgr::unloadShaders()
gOneTextureNoColorProgram.unload();
gSolidColorProgram.unload();
gObjectFullbrightNoColorProgram.unload();
gObjectFullbrightNoColorWaterProgram.unload();
gObjectSimpleProgram.unload();
gSkinnedObjectSimpleProgram.unload();
gObjectSimpleImpostorProgram.unload();
gSkinnedObjectSimpleImpostorProgram.unload();
gObjectPreviewProgram.unload();
gPhysicsPreviewProgram.unload();
gImpostorProgram.unload();
gObjectSimpleAlphaMaskProgram.unload();
gSkinnedObjectSimpleAlphaMaskProgram.unload();
gObjectBumpProgram.unload();
gSkinnedObjectBumpProgram.unload();
gObjectSimpleWaterProgram.unload();
gSkinnedObjectSimpleWaterProgram.unload();
gObjectSimpleWaterAlphaMaskProgram.unload();
gSkinnedObjectSimpleWaterAlphaMaskProgram.unload();
gObjectFullbrightProgram.unload();
gSkinnedObjectFullbrightProgram.unload();
gObjectFullbrightWaterProgram.unload();
gSkinnedObjectFullbrightWaterProgram.unload();
gObjectEmissiveProgram.unload();
gSkinnedObjectEmissiveProgram.unload();
gObjectEmissiveWaterProgram.unload();
gSkinnedObjectEmissiveWaterProgram.unload();
gObjectFullbrightAlphaMaskProgram.unload();
gSkinnedObjectFullbrightAlphaMaskProgram.unload();
gObjectFullbrightWaterAlphaMaskProgram.unload();
gSkinnedObjectFullbrightWaterAlphaMaskProgram.unload();
gObjectShinyProgram.unload();
gSkinnedObjectShinyProgram.unload();
gObjectFullbrightShinyProgram.unload();
gSkinnedObjectFullbrightShinyProgram.unload();
gObjectFullbrightShinyWaterProgram.unload();
gSkinnedObjectFullbrightShinyWaterProgram.unload();
gObjectShinyWaterProgram.unload();
gSkinnedObjectShinyWaterProgram.unload();
gObjectSimpleNonIndexedTexGenProgram.unload();
gObjectSimpleNonIndexedTexGenWaterProgram.unload();
gObjectAlphaMaskNonIndexedProgram.unload();
gObjectAlphaMaskNonIndexedWaterProgram.unload();
gObjectAlphaMaskNoColorProgram.unload();
gObjectAlphaMaskNoColorWaterProgram.unload();
gTreeProgram.unload();
gTreeWaterProgram.unload();
gWaterProgram.unload();
gWaterEdgeProgram.unload();
gUnderWaterProgram.unload();
@ -925,10 +825,6 @@ std::string LLViewerShaderMgr::loadBasicShaders()
index_channels.push_back(-1); shaders.push_back( make_pair( "lighting/lightWaterAlphaMaskNonIndexedF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(-1); shaders.push_back( make_pair( "lighting/lightFullbrightWaterNonIndexedF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(-1); shaders.push_back( make_pair( "lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(-1); shaders.push_back( make_pair( "lighting/lightShinyNonIndexedF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(-1); shaders.push_back( make_pair( "lighting/lightFullbrightShinyNonIndexedF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(-1); shaders.push_back( make_pair( "lighting/lightShinyWaterNonIndexedF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(-1); shaders.push_back( make_pair( "lighting/lightFullbrightShinyWaterNonIndexedF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightAlphaMaskF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightFullbrightF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
@ -937,10 +833,6 @@ std::string LLViewerShaderMgr::loadBasicShaders()
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightWaterAlphaMaskF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightFullbrightWaterF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightFullbrightWaterAlphaMaskF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightShinyF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightFullbrightShinyF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightShinyWaterF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
index_channels.push_back(ch); shaders.push_back( make_pair( "lighting/lightFullbrightShinyWaterF.glsl", mShaderLevel[SHADER_LIGHTING] ) );
for (U32 i = 0; i < shaders.size(); i++)
{
@ -1264,12 +1156,16 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
gDeferredAvatarProgram.unload();
gDeferredAvatarAlphaProgram.unload();
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();
@ -1292,6 +1188,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
gDeferredWLMoonProgram.unload();
gDeferredStarProgram.unload();
gDeferredFullbrightShinyProgram.unload();
gHUDFullbrightShinyProgram.unload();
gDeferredSkinnedFullbrightShinyProgram.unload();
gDeferredSkinnedFullbrightProgram.unload();
gDeferredSkinnedFullbrightAlphaMaskProgram.unload();
@ -1935,11 +1832,18 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
if (success)
{
for (int i = 0; i < 2 && success; ++i)
for (int i = 0; i < 3 && success; ++i)
{
LLGLSLShader* shader = nullptr;
bool rigged = i == 1;
if (!rigged)
bool rigged = (i == 1);
bool hud = (i == 2);
if (hud)
{
shader = &gHUDAlphaProgram;
shader->mName = "HUD Alpha Shader";
}
else if (!rigged)
{
shader = &gDeferredAlphaProgram;
shader->mName = "Deferred Alpha Shader";
@ -2000,6 +1904,11 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
shader->addPermutation("HAS_SKIN", "1");
}
if (hud)
{
shader->addPermutation("IS_HUD", "1");
}
shader->mShaderLevel = mShaderLevel[SHADER_DEFERRED];
success = shader->createShader(NULL, NULL);
@ -2185,6 +2094,24 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
llassert(success);
}
if (success)
{
gHUDFullbrightProgram.mName = "HUD Fullbright Shader";
gHUDFullbrightProgram.mFeatures.calculatesAtmospherics = true;
gHUDFullbrightProgram.mFeatures.hasGamma = true;
gHUDFullbrightProgram.mFeatures.hasTransport = true;
gHUDFullbrightProgram.mFeatures.hasSrgb = true;
gHUDFullbrightProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
gHUDFullbrightProgram.mShaderFiles.clear();
gHUDFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
gHUDFullbrightProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
gHUDFullbrightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
gHUDFullbrightProgram.clearPermutations();
gHUDFullbrightProgram.addPermutation("IS_HUD", "1");
success = gHUDFullbrightProgram.createShader(NULL, NULL);
llassert(success);
}
if (success)
{
gDeferredFullbrightAlphaMaskProgram.mName = "Deferred Fullbright Alpha Masking Shader";
@ -2204,6 +2131,25 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
llassert(success);
}
if (success)
{
gHUDFullbrightAlphaMaskProgram.mName = "HUD Fullbright Alpha Masking Shader";
gHUDFullbrightAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
gHUDFullbrightAlphaMaskProgram.mFeatures.hasGamma = true;
gHUDFullbrightAlphaMaskProgram.mFeatures.hasTransport = true;
gHUDFullbrightAlphaMaskProgram.mFeatures.hasSrgb = true;
gHUDFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
gHUDFullbrightAlphaMaskProgram.mShaderFiles.clear();
gHUDFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
gHUDFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
gHUDFullbrightAlphaMaskProgram.clearPermutations();
gHUDFullbrightAlphaMaskProgram.addPermutation("HAS_ALPHA_MASK", "1");
gHUDFullbrightAlphaMaskProgram.addPermutation("IS_HUD", "1");
gHUDFullbrightAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
success = gHUDFullbrightAlphaMaskProgram.createShader(NULL, NULL);
llassert(success);
}
if (success)
{
gDeferredFullbrightAlphaMaskAlphaProgram.mName = "Deferred Fullbright Alpha Masking Alpha Shader";
@ -2225,6 +2171,27 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
llassert(success);
}
if (success)
{
gHUDFullbrightAlphaMaskAlphaProgram.mName = "HUD Fullbright Alpha Masking Alpha Shader";
gHUDFullbrightAlphaMaskAlphaProgram.mFeatures.calculatesAtmospherics = true;
gHUDFullbrightAlphaMaskAlphaProgram.mFeatures.hasGamma = true;
gHUDFullbrightAlphaMaskAlphaProgram.mFeatures.hasTransport = true;
gHUDFullbrightAlphaMaskAlphaProgram.mFeatures.hasSrgb = true;
gHUDFullbrightAlphaMaskAlphaProgram.mFeatures.isDeferred = true;
gHUDFullbrightAlphaMaskAlphaProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
gHUDFullbrightAlphaMaskAlphaProgram.mShaderFiles.clear();
gHUDFullbrightAlphaMaskAlphaProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
gHUDFullbrightAlphaMaskAlphaProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
gHUDFullbrightAlphaMaskAlphaProgram.clearPermutations();
gHUDFullbrightAlphaMaskAlphaProgram.addPermutation("HAS_ALPHA_MASK", "1");
gHUDFullbrightAlphaMaskAlphaProgram.addPermutation("IS_ALPHA", "1");
gHUDFullbrightAlphaMaskAlphaProgram.addPermutation("IS_HUD", "1");
gHUDFullbrightAlphaMaskAlphaProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
success = success && gHUDFullbrightAlphaMaskAlphaProgram.createShader(NULL, NULL);
llassert(success);
}
if (success)
{
gDeferredFullbrightWaterProgram.mName = "Deferred Fullbright Underwater Shader";
@ -2308,6 +2275,26 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
llassert(success);
}
if (success)
{
gHUDFullbrightShinyProgram.mName = "Deferred FullbrightShiny Shader";
gHUDFullbrightShinyProgram.mFeatures.calculatesAtmospherics = true;
gHUDFullbrightShinyProgram.mFeatures.hasAtmospherics = true;
gHUDFullbrightShinyProgram.mFeatures.hasGamma = true;
gHUDFullbrightShinyProgram.mFeatures.hasTransport = true;
gHUDFullbrightShinyProgram.mFeatures.hasSrgb = true;
gHUDFullbrightShinyProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
gHUDFullbrightShinyProgram.mShaderFiles.clear();
gHUDFullbrightShinyProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
gHUDFullbrightShinyProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
gHUDFullbrightShinyProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
gHUDFullbrightShinyProgram.mFeatures.hasReflectionProbes = true;
gHUDFullbrightShinyProgram.clearPermutations();
gHUDFullbrightShinyProgram.addPermutation("IS_HUD", "1");
success = gHUDFullbrightShinyProgram.createShader(NULL, NULL);
llassert(success);
}
if (success)
{
gDeferredEmissiveProgram.mName = "Deferred Emissive Shader";
@ -2961,129 +2948,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
}
}
if (success)
{
gObjectSimpleProgram.mName = "Simple Shader";
gObjectSimpleProgram.mFeatures.calculatesLighting = true;
gObjectSimpleProgram.mFeatures.calculatesAtmospherics = true;
gObjectSimpleProgram.mFeatures.hasGamma = true;
gObjectSimpleProgram.mFeatures.hasAtmospherics = true;
gObjectSimpleProgram.mFeatures.hasLighting = true;
gObjectSimpleProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectSimpleProgram.mShaderFiles.clear();
gObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
gObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
gObjectSimpleProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = make_rigged_variant(gObjectSimpleProgram, gSkinnedObjectSimpleProgram);
success = success && gObjectSimpleProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightProgram.mName = "Fullbright Shader";
gObjectFullbrightProgram.mFeatures.calculatesAtmospherics = true;
gObjectFullbrightProgram.mFeatures.hasGamma = true;
gObjectFullbrightProgram.mFeatures.hasTransport = true;
gObjectFullbrightProgram.mFeatures.isFullbright = true;
gObjectFullbrightProgram.mFeatures.hasSrgb = true;
gObjectFullbrightProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectFullbrightProgram.mShaderFiles.clear();
gObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
gObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
gObjectFullbrightProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = make_rigged_variant(gObjectFullbrightProgram, gSkinnedObjectFullbrightProgram);
success = success && gObjectFullbrightProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightShinyWaterProgram.mName = "Fullbright Shiny Water Shader";
gObjectFullbrightShinyWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectFullbrightShinyWaterProgram.mFeatures.isFullbright = true;
gObjectFullbrightShinyWaterProgram.mFeatures.isShiny = true;
gObjectFullbrightShinyWaterProgram.mFeatures.hasGamma = true;
gObjectFullbrightShinyWaterProgram.mFeatures.hasTransport = true;
gObjectFullbrightShinyWaterProgram.mFeatures.hasWaterFog = true;
gObjectFullbrightShinyWaterProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectFullbrightShinyWaterProgram.mShaderFiles.clear();
gObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
gObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectFullbrightShinyWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectFullbrightShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = make_rigged_variant(gObjectFullbrightShinyWaterProgram, gSkinnedObjectFullbrightShinyWaterProgram);
success = success && gObjectFullbrightShinyWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectSimpleNonIndexedTexGenProgram.mName = "Non indexed tex-gen Shader";
gObjectSimpleNonIndexedTexGenProgram.mFeatures.calculatesLighting = true;
gObjectSimpleNonIndexedTexGenProgram.mFeatures.calculatesAtmospherics = true;
gObjectSimpleNonIndexedTexGenProgram.mFeatures.hasGamma = true;
gObjectSimpleNonIndexedTexGenProgram.mFeatures.hasAtmospherics = true;
gObjectSimpleNonIndexedTexGenProgram.mFeatures.hasLighting = true;
gObjectSimpleNonIndexedTexGenProgram.mFeatures.disableTextureIndex = true;
gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.clear();
gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.push_back(make_pair("objects/simpleTexGenV.glsl", GL_VERTEX_SHADER));
gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
gObjectSimpleNonIndexedTexGenProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = gObjectSimpleNonIndexedTexGenProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectSimpleNonIndexedTexGenWaterProgram.mName = "Non indexed tex-gen Water Shader";
gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.calculatesLighting = true;
gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.hasWaterFog = true;
gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.hasAtmospherics = true;
gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.hasLighting = true;
gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.disableTextureIndex = true;
gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.clear();
gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleTexGenV.glsl", GL_VERTEX_SHADER));
gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectSimpleNonIndexedTexGenWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectSimpleNonIndexedTexGenWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = gObjectSimpleNonIndexedTexGenWaterProgram.createShader(NULL, NULL);
}
#if 1 // DEPRECATED -- forward rendering is deprecated
if (success)
{
gObjectAlphaMaskNonIndexedProgram.mName = "Non indexed alpha mask Shader";
gObjectAlphaMaskNonIndexedProgram.mFeatures.calculatesLighting = true;
gObjectAlphaMaskNonIndexedProgram.mFeatures.calculatesAtmospherics = true;
gObjectAlphaMaskNonIndexedProgram.mFeatures.hasGamma = true;
gObjectAlphaMaskNonIndexedProgram.mFeatures.hasAtmospherics = true;
gObjectAlphaMaskNonIndexedProgram.mFeatures.hasLighting = true;
gObjectAlphaMaskNonIndexedProgram.mFeatures.disableTextureIndex = true;
gObjectAlphaMaskNonIndexedProgram.mFeatures.hasAlphaMask = true;
gObjectAlphaMaskNonIndexedProgram.mShaderFiles.clear();
gObjectAlphaMaskNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER));
gObjectAlphaMaskNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
gObjectAlphaMaskNonIndexedProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = gObjectAlphaMaskNonIndexedProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectAlphaMaskNonIndexedWaterProgram.mName = "Non indexed alpha mask Water Shader";
gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.calculatesLighting = true;
gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasWaterFog = true;
gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasAtmospherics = true;
gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasLighting = true;
gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasAlphaMask = true;
gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.clear();
gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER));
gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectAlphaMaskNonIndexedWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectAlphaMaskNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = gObjectAlphaMaskNonIndexedWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectAlphaMaskNoColorProgram.mName = "No color alpha mask Shader";
@ -3119,73 +2983,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
success = gObjectAlphaMaskNoColorWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gTreeProgram.mName = "Tree Shader";
gTreeProgram.mFeatures.calculatesLighting = true;
gTreeProgram.mFeatures.calculatesAtmospherics = true;
gTreeProgram.mFeatures.hasGamma = true;
gTreeProgram.mFeatures.hasAtmospherics = true;
gTreeProgram.mFeatures.hasLighting = true;
gTreeProgram.mFeatures.disableTextureIndex = true;
gTreeProgram.mFeatures.hasAlphaMask = true;
gTreeProgram.mShaderFiles.clear();
gTreeProgram.mShaderFiles.push_back(make_pair("objects/treeV.glsl", GL_VERTEX_SHADER));
gTreeProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
gTreeProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = gTreeProgram.createShader(NULL, NULL);
}
if (success)
{
gTreeWaterProgram.mName = "Tree Water Shader";
gTreeWaterProgram.mFeatures.calculatesLighting = true;
gTreeWaterProgram.mFeatures.calculatesAtmospherics = true;
gTreeWaterProgram.mFeatures.hasWaterFog = true;
gTreeWaterProgram.mFeatures.hasAtmospherics = true;
gTreeWaterProgram.mFeatures.hasLighting = true;
gTreeWaterProgram.mFeatures.disableTextureIndex = true;
gTreeWaterProgram.mFeatures.hasAlphaMask = true;
gTreeWaterProgram.mShaderFiles.clear();
gTreeWaterProgram.mShaderFiles.push_back(make_pair("objects/treeV.glsl", GL_VERTEX_SHADER));
gTreeWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
gTreeWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gTreeWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = gTreeWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightNoColorProgram.mName = "Non Indexed no color Fullbright Shader";
gObjectFullbrightNoColorProgram.mFeatures.calculatesAtmospherics = true;
gObjectFullbrightNoColorProgram.mFeatures.hasGamma = true;
gObjectFullbrightNoColorProgram.mFeatures.hasTransport = true;
gObjectFullbrightNoColorProgram.mFeatures.isFullbright = true;
gObjectFullbrightNoColorProgram.mFeatures.hasSrgb = true;
gObjectFullbrightNoColorProgram.mFeatures.disableTextureIndex = true;
gObjectFullbrightNoColorProgram.mShaderFiles.clear();
gObjectFullbrightNoColorProgram.mShaderFiles.push_back(make_pair("objects/fullbrightNoColorV.glsl", GL_VERTEX_SHADER));
gObjectFullbrightNoColorProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
gObjectFullbrightNoColorProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = gObjectFullbrightNoColorProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightNoColorWaterProgram.mName = "Non Indexed no color Fullbright Water Shader";
gObjectFullbrightNoColorWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectFullbrightNoColorWaterProgram.mFeatures.isFullbright = true;
gObjectFullbrightNoColorWaterProgram.mFeatures.hasWaterFog = true;
gObjectFullbrightNoColorWaterProgram.mFeatures.hasTransport = true;
gObjectFullbrightNoColorWaterProgram.mFeatures.disableTextureIndex = true;
gObjectFullbrightNoColorWaterProgram.mShaderFiles.clear();
gObjectFullbrightNoColorWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightNoColorV.glsl", GL_VERTEX_SHADER));
gObjectFullbrightNoColorWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectFullbrightNoColorWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectFullbrightNoColorWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = gObjectFullbrightNoColorWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gImpostorProgram.mName = "Impostor Shader";
@ -3234,133 +3031,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
gPhysicsPreviewProgram.mFeatures.hasLighting = false;
}
if (success)
{
gObjectSimpleImpostorProgram.mName = "Simple Impostor Shader";
gObjectSimpleImpostorProgram.mFeatures.calculatesLighting = true;
gObjectSimpleImpostorProgram.mFeatures.calculatesAtmospherics = true;
gObjectSimpleImpostorProgram.mFeatures.hasGamma = true;
gObjectSimpleImpostorProgram.mFeatures.hasAtmospherics = true;
gObjectSimpleImpostorProgram.mFeatures.hasLighting = true;
gObjectSimpleImpostorProgram.mFeatures.mIndexedTextureChannels = 0;
// force alpha mask version of lighting so we can weed out
// transparent pixels from impostor temp buffer
//
gObjectSimpleImpostorProgram.mFeatures.hasAlphaMask = true;
gObjectSimpleImpostorProgram.mShaderFiles.clear();
gObjectSimpleImpostorProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
gObjectSimpleImpostorProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
gObjectSimpleImpostorProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = make_rigged_variant(gObjectSimpleImpostorProgram, gSkinnedObjectSimpleImpostorProgram);
success = success && gObjectSimpleImpostorProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectSimpleWaterProgram.mName = "Simple Water Shader";
gObjectSimpleWaterProgram.mFeatures.calculatesLighting = true;
gObjectSimpleWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectSimpleWaterProgram.mFeatures.hasWaterFog = true;
gObjectSimpleWaterProgram.mFeatures.hasAtmospherics = true;
gObjectSimpleWaterProgram.mFeatures.hasLighting = true;
gObjectSimpleWaterProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectSimpleWaterProgram.mShaderFiles.clear();
gObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
gObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectSimpleWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectSimpleWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
make_rigged_variant(gObjectSimpleWaterProgram, gSkinnedObjectSimpleWaterProgram);
success = gObjectSimpleWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectSimpleAlphaMaskProgram.mName = "Simple Alpha Mask Shader";
gObjectSimpleAlphaMaskProgram.mFeatures.calculatesLighting = true;
gObjectSimpleAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
gObjectSimpleAlphaMaskProgram.mFeatures.hasGamma = true;
gObjectSimpleAlphaMaskProgram.mFeatures.hasAtmospherics = true;
gObjectSimpleAlphaMaskProgram.mFeatures.hasLighting = true;
gObjectSimpleAlphaMaskProgram.mFeatures.hasAlphaMask = true;
gObjectSimpleAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectSimpleAlphaMaskProgram.mShaderFiles.clear();
gObjectSimpleAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
gObjectSimpleAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
gObjectSimpleAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = make_rigged_variant(gObjectSimpleAlphaMaskProgram, gSkinnedObjectSimpleAlphaMaskProgram);
success = success && gObjectSimpleAlphaMaskProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectSimpleWaterAlphaMaskProgram.mName = "Simple Water Alpha Mask Shader";
gObjectSimpleWaterAlphaMaskProgram.mFeatures.calculatesLighting = true;
gObjectSimpleWaterAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasWaterFog = true;
gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasAtmospherics = true;
gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasLighting = true;
gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasAlphaMask = true;
gObjectSimpleWaterAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.clear();
gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectSimpleWaterAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectSimpleWaterAlphaMaskProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = make_rigged_variant(gObjectSimpleWaterAlphaMaskProgram, gSkinnedObjectSimpleWaterAlphaMaskProgram);
success = success && gObjectSimpleWaterAlphaMaskProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightWaterProgram.mName = "Fullbright Water Shader";
gObjectFullbrightWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectFullbrightWaterProgram.mFeatures.isFullbright = true;
gObjectFullbrightWaterProgram.mFeatures.hasWaterFog = true;
gObjectFullbrightWaterProgram.mFeatures.hasTransport = true;
gObjectFullbrightWaterProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectFullbrightWaterProgram.mShaderFiles.clear();
gObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
gObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectFullbrightWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = make_rigged_variant(gObjectFullbrightWaterProgram, gSkinnedObjectFullbrightWaterProgram);
success = success && gObjectFullbrightWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectEmissiveProgram.mName = "Emissive Shader";
gObjectEmissiveProgram.mFeatures.calculatesAtmospherics = true;
gObjectEmissiveProgram.mFeatures.hasGamma = true;
gObjectEmissiveProgram.mFeatures.hasTransport = true;
gObjectEmissiveProgram.mFeatures.isFullbright = true;
gObjectEmissiveProgram.mFeatures.hasSrgb = true;
gObjectEmissiveProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectEmissiveProgram.mShaderFiles.clear();
gObjectEmissiveProgram.mShaderFiles.push_back(make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER));
gObjectEmissiveProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
gObjectEmissiveProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = make_rigged_variant(gObjectEmissiveProgram, gSkinnedObjectEmissiveProgram);
success = success && gObjectEmissiveProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectEmissiveWaterProgram.mName = "Emissive Water Shader";
gObjectEmissiveWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectEmissiveWaterProgram.mFeatures.isFullbright = true;
gObjectEmissiveWaterProgram.mFeatures.hasWaterFog = true;
gObjectEmissiveWaterProgram.mFeatures.hasTransport = true;
gObjectEmissiveWaterProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectEmissiveWaterProgram.mShaderFiles.clear();
gObjectEmissiveWaterProgram.mShaderFiles.push_back(make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER));
gObjectEmissiveWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectEmissiveWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectEmissiveWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = make_rigged_variant(gObjectEmissiveWaterProgram, gSkinnedObjectEmissiveWaterProgram);
success = success && gObjectEmissiveWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightAlphaMaskProgram.mName = "Fullbright Alpha Mask Shader";
@ -3379,78 +3049,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
success = success && gObjectFullbrightAlphaMaskProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightWaterAlphaMaskProgram.mName = "Fullbright Water Alpha Mask Shader";
gObjectFullbrightWaterAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
gObjectFullbrightWaterAlphaMaskProgram.mFeatures.isFullbright = true;
gObjectFullbrightWaterAlphaMaskProgram.mFeatures.hasWaterFog = true;
gObjectFullbrightWaterAlphaMaskProgram.mFeatures.hasTransport = true;
gObjectFullbrightWaterAlphaMaskProgram.mFeatures.hasAlphaMask = true;
gObjectFullbrightWaterAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.clear();
gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectFullbrightWaterAlphaMaskProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectFullbrightWaterAlphaMaskProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = make_rigged_variant(gObjectFullbrightWaterAlphaMaskProgram, gSkinnedObjectFullbrightWaterAlphaMaskProgram);
success = success && gObjectFullbrightWaterAlphaMaskProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectShinyProgram.mName = "Shiny Shader";
gObjectShinyProgram.mFeatures.calculatesAtmospherics = true;
gObjectShinyProgram.mFeatures.calculatesLighting = true;
gObjectShinyProgram.mFeatures.hasGamma = true;
gObjectShinyProgram.mFeatures.hasAtmospherics = true;
gObjectShinyProgram.mFeatures.isShiny = true;
gObjectShinyProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectShinyProgram.mShaderFiles.clear();
gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER));
gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER));
gObjectShinyProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = make_rigged_variant(gObjectShinyProgram, gSkinnedObjectShinyProgram);
success = success && gObjectShinyProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectShinyWaterProgram.mName = "Shiny Water Shader";
gObjectShinyWaterProgram.mFeatures.calculatesAtmospherics = true;
gObjectShinyWaterProgram.mFeatures.calculatesLighting = true;
gObjectShinyWaterProgram.mFeatures.isShiny = true;
gObjectShinyWaterProgram.mFeatures.hasWaterFog = true;
gObjectShinyWaterProgram.mFeatures.hasAtmospherics = true;
gObjectShinyWaterProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectShinyWaterProgram.mShaderFiles.clear();
gObjectShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER));
gObjectShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER));
gObjectShinyWaterProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
gObjectShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
success = make_rigged_variant(gObjectShinyWaterProgram, gSkinnedObjectShinyWaterProgram);
success = success && gObjectShinyWaterProgram.createShader(NULL, NULL);
}
if (success)
{
gObjectFullbrightShinyProgram.mName = "Fullbright Shiny Shader";
gObjectFullbrightShinyProgram.mFeatures.calculatesAtmospherics = true;
gObjectFullbrightShinyProgram.mFeatures.isFullbright = true;
gObjectFullbrightShinyProgram.mFeatures.isShiny = true;
gObjectFullbrightShinyProgram.mFeatures.hasGamma = true;
gObjectFullbrightShinyProgram.mFeatures.hasTransport = true;
gObjectFullbrightShinyProgram.mFeatures.mIndexedTextureChannels = 0;
gObjectFullbrightShinyProgram.mShaderFiles.clear();
gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
gObjectFullbrightShinyProgram.mShaderLevel = mShaderLevel[SHADER_OBJECT];
success = make_rigged_variant(gObjectFullbrightShinyProgram, gSkinnedObjectFullbrightShinyProgram);
success = success && gObjectFullbrightShinyProgram.createShader(NULL, NULL);
}
#endif
if (!success)
{
mShaderLevel[SHADER_OBJECT] = 0;

48
indra/newview/llviewershadermgr.h
View File

@ -177,41 +177,14 @@ extern LLGLSLShader gOneTextureFilterProgram;
extern LLGLSLShader gOneTextureNoColorProgram;
//object shaders
extern LLGLSLShader gObjectSimpleProgram;
extern LLGLSLShader gObjectSimpleImpostorProgram;
extern LLGLSLShader gObjectPreviewProgram;
extern LLGLSLShader gPhysicsPreviewProgram;
extern LLGLSLShader gObjectSimpleAlphaMaskProgram;
extern LLGLSLShader gObjectSimpleWaterProgram;
extern LLGLSLShader gObjectSimpleWaterAlphaMaskProgram;
extern LLGLSLShader gObjectSimpleNonIndexedTexGenProgram;
extern LLGLSLShader gObjectSimpleNonIndexedTexGenWaterProgram;
extern LLGLSLShader gObjectAlphaMaskNonIndexedProgram;
extern LLGLSLShader gObjectAlphaMaskNonIndexedWaterProgram;
extern LLGLSLShader gObjectAlphaMaskNoColorProgram;
extern LLGLSLShader gObjectAlphaMaskNoColorWaterProgram;
extern LLGLSLShader gObjectFullbrightProgram;
extern LLGLSLShader gObjectFullbrightWaterProgram;
extern LLGLSLShader gObjectFullbrightNoColorProgram;
extern LLGLSLShader gObjectFullbrightNoColorWaterProgram;
extern LLGLSLShader gObjectEmissiveProgram;
extern LLGLSLShader gObjectEmissiveWaterProgram;
extern LLGLSLShader gObjectFullbrightAlphaMaskProgram;
extern LLGLSLShader gObjectFullbrightWaterAlphaMaskProgram;
extern LLGLSLShader gObjectEmissiveNonIndexedProgram;
extern LLGLSLShader gObjectEmissiveNonIndexedWaterProgram;
extern LLGLSLShader gObjectBumpProgram;
extern LLGLSLShader gTreeProgram;
extern LLGLSLShader gTreeWaterProgram;
extern LLGLSLShader gObjectSimpleLODProgram;
extern LLGLSLShader gObjectFullbrightLODProgram;
extern LLGLSLShader gObjectFullbrightShinyProgram;
extern LLGLSLShader gObjectFullbrightShinyWaterProgram;
extern LLGLSLShader gObjectShinyProgram;
extern LLGLSLShader gObjectShinyWaterProgram;
extern LLGLSLShader gObjectPreviewProgram;
extern LLGLSLShader gPhysicsPreviewProgram;
extern LLGLSLShader gObjectFullbrightAlphaMaskProgram;
extern LLGLSLShader gSkinnedObjectFullbrightAlphaMaskProgram;
extern LLGLSLShader gObjectBumpProgram;
extern LLGLSLShader gSkinnedObjectBumpProgram;
extern LLGLSLShader gObjectAlphaMaskNoColorProgram;
extern LLGLSLShader gObjectAlphaMaskNoColorWaterProgram;
//environment shaders
extern LLGLSLShader gMoonProgram;
@ -292,10 +265,14 @@ extern LLGLSLShader gDeferredAvatarShadowProgram;
extern LLGLSLShader gDeferredAvatarAlphaShadowProgram;
extern LLGLSLShader gDeferredAvatarAlphaMaskShadowProgram;
extern LLGLSLShader gDeferredAlphaProgram;
extern LLGLSLShader gHUDAlphaProgram;
extern LLGLSLShader gDeferredAlphaImpostorProgram;
extern LLGLSLShader gDeferredFullbrightProgram;
extern LLGLSLShader gHUDFullbrightProgram;
extern LLGLSLShader gDeferredFullbrightAlphaMaskProgram;
extern LLGLSLShader gHUDFullbrightAlphaMaskProgram;
extern LLGLSLShader gDeferredFullbrightAlphaMaskAlphaProgram;
extern LLGLSLShader gHUDFullbrightAlphaMaskAlphaProgram;
extern LLGLSLShader gDeferredAlphaWaterProgram;
extern LLGLSLShader gDeferredFullbrightWaterProgram;
extern LLGLSLShader gDeferredFullbrightWaterAlphaProgram;
@ -309,6 +286,7 @@ extern LLGLSLShader gDeferredWLSunProgram;
extern LLGLSLShader gDeferredWLMoonProgram;
extern LLGLSLShader gDeferredStarProgram;
extern LLGLSLShader gDeferredFullbrightShinyProgram;
extern LLGLSLShader gHUDFullbrightShinyProgram;
extern LLGLSLShader gNormalMapGenProgram;
extern LLGLSLShader gDeferredGenBrdfLutProgram;

166
indra/newview/llvoground.cpp
View File

@ -1,166 +0,0 @@
/**
* @file llvoground.cpp
* @brief LLVOGround class implementation
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, 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$
*/
#include "llviewerprecompiledheaders.h"
#include "llvoground.h"
#include "lldrawpoolground.h"
#include "llviewercontrol.h"
#include "lldrawable.h"
#include "llface.h"
#include "llsky.h"
#include "llviewercamera.h"
#include "llviewerregion.h"
#include "pipeline.h"
LLVOGround::LLVOGround(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
: LLStaticViewerObject(id, pcode, regionp, TRUE)
{
mbCanSelect = FALSE;
}
LLVOGround::~LLVOGround()
{
}
void LLVOGround::idleUpdate(LLAgent &agent, const F64 &time)
{
}
void LLVOGround::updateTextures()
{
}
LLDrawable *LLVOGround::createDrawable(LLPipeline *pipeline)
{
pipeline->allocDrawable(this);
mDrawable->setLit(FALSE);
mDrawable->setRenderType(LLPipeline::RENDER_TYPE_GROUND);
LLDrawPoolGround *poolp = (LLDrawPoolGround*) gPipeline.getPool(LLDrawPool::POOL_GROUND);
mDrawable->addFace(poolp, NULL);
return mDrawable;
}
// TO DO - this always returns TRUE,
BOOL LLVOGround::updateGeometry(LLDrawable *drawable)
{
LLStrider<LLVector3> verticesp;
LLStrider<LLVector3> normalsp;
LLStrider<LLVector2> texCoordsp;
LLStrider<U16> indicesp;
S32 index_offset;
LLFace *face;
LLDrawPoolGround *poolp = (LLDrawPoolGround*) gPipeline.getPool(LLDrawPool::POOL_GROUND);
if (drawable->getNumFaces() < 1)
drawable->addFace(poolp, NULL);
face = drawable->getFace(0);
if (!face)
return TRUE;
if (!face->getVertexBuffer())
{
face->setSize(5, 12);
LLVertexBuffer* buff = new LLVertexBuffer(LLDrawPoolGround::VERTEX_DATA_MASK);
if (!buff->allocateBuffer(face->getGeomCount(), face->getIndicesCount()))
{
LL_WARNS() << "Failed to allocate Vertex Buffer for VOGround to "
<< face->getGeomCount() << " vertices and "
<< face->getIndicesCount() << " indices" << LL_ENDL;
}
face->setGeomIndex(0);
face->setIndicesIndex(0);
face->setVertexBuffer(buff);
}
index_offset = face->getGeometry(verticesp,normalsp,texCoordsp, indicesp);
if (-1 == index_offset)
{
return TRUE;
}
///////////////////////////////////////
//
//
//
LLVector3 at_dir = LLViewerCamera::getInstance()->getAtAxis();
at_dir.mV[VZ] = 0.f;
if (at_dir.normVec() < 0.01)
{
// We really don't care, as we're not looking anywhere near the horizon.
}
LLVector3 left_dir = LLViewerCamera::getInstance()->getLeftAxis();
left_dir.mV[VZ] = 0.f;
left_dir.normVec();
// Our center top point
LLColor4 ground_color = gSky.getSkyFogColor();
ground_color.mV[3] = 1.f;
face->setFaceColor(ground_color);
*(verticesp++) = LLVector3(64, 64, 0);
*(verticesp++) = LLVector3(-64, 64, 0);
*(verticesp++) = LLVector3(-64, -64, 0);
*(verticesp++) = LLVector3(64, -64, 0);
*(verticesp++) = LLVector3(0, 0, -1024);
// Triangles for each side
*indicesp++ = index_offset + 0;
*indicesp++ = index_offset + 1;
*indicesp++ = index_offset + 4;
*indicesp++ = index_offset + 1;
*indicesp++ = index_offset + 2;
*indicesp++ = index_offset + 4;
*indicesp++ = index_offset + 2;
*indicesp++ = index_offset + 3;
*indicesp++ = index_offset + 4;
*indicesp++ = index_offset + 3;
*indicesp++ = index_offset + 0;
*indicesp++ = index_offset + 4;
*(texCoordsp++) = LLVector2(0.f, 0.f);
*(texCoordsp++) = LLVector2(1.f, 0.f);
*(texCoordsp++) = LLVector2(1.f, 1.f);
*(texCoordsp++) = LLVector2(0.f, 1.f);
*(texCoordsp++) = LLVector2(0.5f, 0.5f);
face->getVertexBuffer()->unmapBuffer();
LLPipeline::sCompiles++;
return TRUE;
}

54
indra/newview/llvoground.h
View File

@ -1,54 +0,0 @@
/**
* @file llvoground.h
* @brief LLVOGround class header file
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, 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$
*/
#ifndef LL_LLVOGROUND_H
#define LL_LLVOGROUND_H
#include "stdtypes.h"
#include "v3color.h"
#include "v4coloru.h"
#include "llviewertexture.h"
#include "llviewerobject.h"
class LLVOGround : public LLStaticViewerObject
{
protected:
~LLVOGround();
public:
LLVOGround(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp);
/*virtual*/ void idleUpdate(LLAgent &agent, const F64 &time);
// Graphical stuff for objects - maybe broken out into render class
// later?
/*virtual*/ void updateTextures();
/*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
/*virtual*/ BOOL updateGeometry(LLDrawable *drawable);
};
#endif // LL_LLVOGROUND_H

1
indra/newview/llvosky.cpp
View File

@ -767,7 +767,6 @@ bool LLVOSky::updateSky()
mForceUpdate = FALSE;
mForceUpdateThrottle.setTimerExpirySec(UPDATE_EXPRY);
gPipeline.markRebuild(gSky.mVOGroundp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
if (mDrawable.notNull() && mDrawable->getFace(0) && !mDrawable->getFace(0)->getVertexBuffer())
{

57
indra/newview/pipeline.cpp
View File

@ -55,7 +55,6 @@
#include "lldrawable.h"
#include "lldrawpoolalpha.h"
#include "lldrawpoolavatar.h"
#include "lldrawpoolground.h"
#include "lldrawpoolbump.h"
#include "lldrawpooltree.h"
#include "lldrawpoolwater.h"
@ -86,7 +85,6 @@
#include "llviewerwindow.h" // For getSpinAxis
#include "llvoavatarself.h"
#include "llvocache.h"
#include "llvoground.h"
#include "llvosky.h"
#include "llvowlsky.h"
#include "llvotree.h"
@ -430,7 +428,6 @@ void LLPipeline::init()
getPool(LLDrawPool::POOL_FULLBRIGHT_ALPHA_MASK);
getPool(LLDrawPool::POOL_GRASS);
getPool(LLDrawPool::POOL_FULLBRIGHT);
getPool(LLDrawPool::POOL_INVISIBLE);
getPool(LLDrawPool::POOL_BUMP);
getPool(LLDrawPool::POOL_MATERIALS);
getPool(LLDrawPool::POOL_GLOW);
@ -459,12 +456,6 @@ void LLPipeline::init()
else
{
setAllRenderTypes(); // By default, all rendering types start enabled
// Don't turn on ground when this is set
// Mac Books with intel 950s need this
if(!gSavedSettings.getBOOL("RenderGround"))
{
toggleRenderType(RENDER_TYPE_GROUND);
}
}
// make sure RenderPerformanceTest persists (hackity hack hack)
@ -649,14 +640,10 @@ void LLPipeline::cleanup()
mTerrainPool = NULL;
delete mWaterPool;
mWaterPool = NULL;
delete mGroundPool;
mGroundPool = NULL;
delete mSimplePool;
mSimplePool = NULL;
delete mFullbrightPool;
mFullbrightPool = NULL;
delete mInvisiblePool;
mInvisiblePool = NULL;
delete mGlowPool;
mGlowPool = NULL;
delete mBumpPool;
@ -1518,10 +1505,6 @@ LLDrawPool *LLPipeline::findPool(const U32 type, LLViewerTexture *tex0)
poolp = mFullbrightPool;
break;
case LLDrawPool::POOL_INVISIBLE:
poolp = mInvisiblePool;
break;
case LLDrawPool::POOL_GLOW:
poolp = mGlowPool;
break;
@ -1559,10 +1542,6 @@ LLDrawPool *LLPipeline::findPool(const U32 type, LLViewerTexture *tex0)
poolp = mWaterPool;
break;
case LLDrawPool::POOL_GROUND:
poolp = mGroundPool;
break;
case LLDrawPool::POOL_WL_SKY:
poolp = mWLSkyPool;
break;
@ -3168,7 +3147,6 @@ void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
if (hasAnyRenderType(LLPipeline::RENDER_TYPE_AVATAR,
LLPipeline::RENDER_TYPE_CONTROL_AV,
LLPipeline::RENDER_TYPE_GROUND,
LLPipeline::RENDER_TYPE_TERRAIN,
LLPipeline::RENDER_TYPE_TREE,
LLPipeline::RENDER_TYPE_SKY,
@ -5164,18 +5142,6 @@ void LLPipeline::addToQuickLookup( LLDrawPool* new_poolp )
}
break;
case LLDrawPool::POOL_INVISIBLE:
if (mInvisiblePool)
{
llassert(0);
LL_WARNS() << "Ignoring duplicate simple pool." << LL_ENDL;
}
else
{
mInvisiblePool = (LLRenderPass*) new_poolp;
}
break;
case LLDrawPool::POOL_GLOW:
if (mGlowPool)
{
@ -5269,18 +5235,6 @@ void LLPipeline::addToQuickLookup( LLDrawPool* new_poolp )
}
break;
case LLDrawPool::POOL_GROUND:
if( mGroundPool )
{
llassert(0);
LL_WARNS() << "LLPipeline::addPool(): Ignoring duplicate Ground Pool" << LL_ENDL;
}
else
{
mGroundPool = new_poolp;
}
break;
case LLDrawPool::POOL_WL_SKY:
if( mWLSkyPool )
{
@ -5350,11 +5304,6 @@ void LLPipeline::removeFromQuickLookup( LLDrawPool* poolp )
mFullbrightPool = NULL;
break;
case LLDrawPool::POOL_INVISIBLE:
llassert(mInvisiblePool == poolp);
mInvisiblePool = NULL;
break;
case LLDrawPool::POOL_WL_SKY:
llassert(mWLSkyPool == poolp);
mWLSkyPool = NULL;
@ -5421,11 +5370,6 @@ void LLPipeline::removeFromQuickLookup( LLDrawPool* poolp )
mWaterPool = NULL;
break;
case LLDrawPool::POOL_GROUND:
llassert( poolp == mGroundPool );
mGroundPool = NULL;
break;
case LLDrawPool::POOL_GLTF_PBR:
llassert( poolp == mPBROpaquePool );
mPBROpaquePool = NULL;
@ -10255,7 +10199,6 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar, bool preview_avatar)
clearRenderTypeMask(
RENDER_TYPE_SKY,
RENDER_TYPE_WL_SKY,
RENDER_TYPE_GROUND,
RENDER_TYPE_TERRAIN,
RENDER_TYPE_GRASS,
RENDER_TYPE_CONTROL_AV, // Animesh

4
indra/newview/pipeline.h
View File

@ -459,7 +459,6 @@ public:
// Following are pool types (some are also object types)
RENDER_TYPE_SKY = LLDrawPool::POOL_SKY,
RENDER_TYPE_WL_SKY = LLDrawPool::POOL_WL_SKY,
RENDER_TYPE_GROUND = LLDrawPool::POOL_GROUND,
RENDER_TYPE_TERRAIN = LLDrawPool::POOL_TERRAIN,
RENDER_TYPE_SIMPLE = LLDrawPool::POOL_SIMPLE,
RENDER_TYPE_GRASS = LLDrawPool::POOL_GRASS,
@ -471,7 +470,6 @@ public:
RENDER_TYPE_AVATAR = LLDrawPool::POOL_AVATAR,
RENDER_TYPE_CONTROL_AV = LLDrawPool::POOL_CONTROL_AV, // Animesh
RENDER_TYPE_TREE = LLDrawPool::POOL_TREE,
RENDER_TYPE_INVISIBLE = LLDrawPool::POOL_INVISIBLE,
RENDER_TYPE_VOIDWATER = LLDrawPool::POOL_VOIDWATER,
RENDER_TYPE_WATER = LLDrawPool::POOL_WATER,
RENDER_TYPE_GLTF_PBR = LLDrawPool::POOL_GLTF_PBR,
@ -892,13 +890,11 @@ protected:
LLDrawPool* mSkyPool = nullptr;
LLDrawPool* mTerrainPool = nullptr;
LLDrawPool* mWaterPool = nullptr;
LLDrawPool* mGroundPool = nullptr;
LLRenderPass* mSimplePool = nullptr;
LLRenderPass* mGrassPool = nullptr;
LLRenderPass* mAlphaMaskPool = nullptr;
LLRenderPass* mFullbrightAlphaMaskPool = nullptr;
LLRenderPass* mFullbrightPool = nullptr;
LLDrawPool* mInvisiblePool = nullptr;
LLDrawPool* mGlowPool = nullptr;
LLDrawPool* mBumpPool = nullptr;
LLDrawPool* mMaterialsPool = nullptr;

11
indra/newview/skins/default/xui/en/menu_viewer.xml
View File

@ -2046,17 +2046,6 @@ function="World.EnvPreset"
function="Advanced.ToggleRenderType"
parameter="water" />
</menu_item_check>
<menu_item_check
label="Ground"
name="Rendering Type Ground"
shortcut="control|alt|shift|8">
<menu_item_check.on_check
function="Advanced.CheckRenderType"
parameter="ground" />
<menu_item_check.on_click
function="Advanced.ToggleRenderType"
parameter="ground" />
</menu_item_check>
<menu_item_check
label="Volume"
name="Rendering Type Volume"