Merged in graham_linden/viewer-eep-graham (pull request #77)

SL-1936 and SL-1912 WIP

36 files changed, 2890 insertions, 170 deletions

diff --git a/indra/llinventory/llsettingssky.cpp b/indra/llinventory/llsettingssky.cpp
index bc7f4f2b5a..56449c0598 100644
--- a/indra/llinventory/llsettingssky.cpp
+++ b/indra/llinventory/llsettingssky.cpp
@@ -564,36 +564,53 @@ LLSettingsSky::validation_list_t LLSettingsSky::validationList()
     return validation;
 }
 
+LLSD LLSettingsSky::createDensityProfileLayer(
+    F32 width,
+    F32 exponential_term,
+    F32 exponential_scale_factor,
+    F32 linear_term,
+    F32 constant_term,
+    F32 aniso_factor)
+{
+    LLSD dflt_layer;
+    dflt_layer[SETTING_DENSITY_PROFILE_WIDTH]            = width; // 0 -> the entire atmosphere
+    dflt_layer[SETTING_DENSITY_PROFILE_EXP_TERM]         = exponential_term;
+    dflt_layer[SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR] = exponential_scale_factor;
+    dflt_layer[SETTING_DENSITY_PROFILE_LINEAR_TERM]      = linear_term;
+    dflt_layer[SETTING_DENSITY_PROFILE_CONSTANT_TERM]    = constant_term;
+
+    if (aniso_factor != 0.0f)
+    {
+        dflt_layer[SETTING_MIE_ANISOTROPY_FACTOR] = aniso_factor;
+    }
+
+    return dflt_layer;
+}
+
+LLSD LLSettingsSky::createSingleLayerDensityProfile(
+    F32 width,
+    F32 exponential_term,
+    F32 exponential_scale_factor,
+    F32 linear_term,
+    F32 constant_term,
+    F32 aniso_factor)
+{
+    LLSD dflt;
+    LLSD dflt_layer = createDensityProfileLayer(width, exponential_term, exponential_scale_factor, linear_term, constant_term, aniso_factor);
+    dflt.append(dflt_layer);
+    return dflt;
+}
+
 LLSD LLSettingsSky::rayleighConfigDefault()
 {
-    LLSD dflt_rayleigh;
-    LLSD dflt_rayleigh_layer;
-    dflt_rayleigh_layer[SETTING_DENSITY_PROFILE_WIDTH]            = 0.0f; // 0 -> the entire atmosphere
-    dflt_rayleigh_layer[SETTING_DENSITY_PROFILE_EXP_TERM]         = 1.0f;
-    dflt_rayleigh_layer[SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR] = -1.0f / 8000.0f;
-    dflt_rayleigh_layer[SETTING_DENSITY_PROFILE_LINEAR_TERM]      = 0.0f;
-    dflt_rayleigh_layer[SETTING_DENSITY_PROFILE_CONSTANT_TERM]    = 0.0f;
-    dflt_rayleigh.append(dflt_rayleigh_layer);
-    return dflt_rayleigh;
+    return createSingleLayerDensityProfile(0.0f,  1.0f, -1.0f / 8000.0f, 0.0f, 0.0f);
 }
 
 LLSD LLSettingsSky::absorptionConfigDefault()
 {
 // absorption (ozone) has two linear ramping zones
-    LLSD dflt_absorption_layer_a;
-    dflt_absorption_layer_a[SETTING_DENSITY_PROFILE_WIDTH]            = 25000.0f; // 0 -> the entire atmosphere
-    dflt_absorption_layer_a[SETTING_DENSITY_PROFILE_EXP_TERM]         = 0.0f;
-    dflt_absorption_layer_a[SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR] = 0.0f;
-    dflt_absorption_layer_a[SETTING_DENSITY_PROFILE_LINEAR_TERM]      = -1.0f / 25000.0f;
-    dflt_absorption_layer_a[SETTING_DENSITY_PROFILE_CONSTANT_TERM]    = -2.0f / 3.0f;
-
-    LLSD dflt_absorption_layer_b;
-    dflt_absorption_layer_b[SETTING_DENSITY_PROFILE_WIDTH]            = 0.0f; // 0 -> remainder of the atmosphere
-    dflt_absorption_layer_b[SETTING_DENSITY_PROFILE_EXP_TERM]         = 0.0f;
-    dflt_absorption_layer_b[SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR] = 0.0f;
-    dflt_absorption_layer_b[SETTING_DENSITY_PROFILE_LINEAR_TERM]      = -1.0f / 15000.0f;
-    dflt_absorption_layer_b[SETTING_DENSITY_PROFILE_CONSTANT_TERM]    = 8.0f  / 3.0f;
-
+    LLSD dflt_absorption_layer_a = createDensityProfileLayer(25000.0f, 0.0f, 0.0f, -1.0f / 25000.0f, -2.0f / 3.0f);
+    LLSD dflt_absorption_layer_b = createDensityProfileLayer(0.0f, 0.0f, 0.0f, -1.0f / 15000.0f, 8.0f / 3.0f);
     LLSD dflt_absorption;
     dflt_absorption.append(dflt_absorption_layer_a);
     dflt_absorption.append(dflt_absorption_layer_b);
@@ -602,15 +619,7 @@ LLSD LLSettingsSky::absorptionConfigDefault()
 
 LLSD LLSettingsSky::mieConfigDefault()
 {
-    LLSD dflt_mie;
-    LLSD dflt_mie_layer;
-    dflt_mie_layer[SETTING_DENSITY_PROFILE_WIDTH]            = 0.0f; // 0 -> the entire atmosphere
-    dflt_mie_layer[SETTING_DENSITY_PROFILE_EXP_TERM]         = 1.0f;
-    dflt_mie_layer[SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR] = -1.0f / 1200.0f;
-    dflt_mie_layer[SETTING_DENSITY_PROFILE_LINEAR_TERM]      = 0.0f;
-    dflt_mie_layer[SETTING_DENSITY_PROFILE_CONSTANT_TERM]    = 0.0f;
-    dflt_mie_layer[SETTING_MIE_ANISOTROPY_FACTOR]            = 0.8f;
-    dflt_mie.append(dflt_mie_layer);
+    LLSD dflt_mie = createSingleLayerDensityProfile(0.0f,  1.0f, -1.0f / 1200.0f, 0.0f, 0.0f, 0.8f);
     return dflt_mie;
 }
 
@@ -661,7 +670,7 @@ LLSD LLSettingsSky::defaults(const LLSettingsBase::TrackPosition& position)
         dfltsetting[SETTING_PLANET_RADIUS]      = 6360.0f;
         dfltsetting[SETTING_SKY_BOTTOM_RADIUS]  = 6360.0f;
         dfltsetting[SETTING_SKY_TOP_RADIUS]     = 6420.0f;
-        dfltsetting[SETTING_SUN_ARC_RADIANS]    = 0.00935f / 2.0f;    
+        dfltsetting[SETTING_SUN_ARC_RADIANS]    = 0.00045f;
 
         dfltsetting[SETTING_RAYLEIGH_CONFIG]    = rayleighConfigDefault();
         dfltsetting[SETTING_MIE_CONFIG]         = mieConfigDefault();
@@ -1152,9 +1161,27 @@ F32 LLSettingsSky::getSunArcRadians() const
 
 F32 LLSettingsSky::getMieAnisotropy() const
 {
-    return mSettings[SETTING_MIE_ANISOTROPY_FACTOR].asReal();
+    return getMieConfig()[SETTING_MIE_ANISOTROPY_FACTOR].asReal();
 }
-    
+ 
+LLSD LLSettingsSky::getRayleighConfig() const
+{
+    LLSD copy = *(mSettings[SETTING_RAYLEIGH_CONFIG].beginArray());
+    return copy;
+}
+
+LLSD LLSettingsSky::getMieConfig() const
+{
+    LLSD copy = *(mSettings[SETTING_MIE_CONFIG].beginArray());
+    return copy;
+}
+
+LLSD LLSettingsSky::getAbsorptionConfig() const
+{
+    LLSD copy = *(mSettings[SETTING_ABSORPTION_CONFIG].beginArray());
+    return copy;
+}
+   
 LLSD LLSettingsSky::getRayleighConfigs() const
 {
     return mSettings[SETTING_RAYLEIGH_CONFIG];
@@ -1170,6 +1197,21 @@ LLSD LLSettingsSky::getAbsorptionConfigs() const
     return mSettings[SETTING_ABSORPTION_CONFIG];
 }
 
+void LLSettingsSky::setRayleighConfigs(const LLSD& rayleighConfig)
+{
+    mSettings[SETTING_RAYLEIGH_CONFIG] = rayleighConfig;
+}
+
+void LLSettingsSky::setMieConfigs(const LLSD& mieConfig)
+{
+    mSettings[SETTING_MIE_CONFIG] = mieConfig;
+}
+
+void LLSettingsSky::setAbsorptionConfigs(const LLSD& absorptionConfig)
+{
+    mSettings[SETTING_ABSORPTION_CONFIG] = absorptionConfig;
+}
+
 LLUUID LLSettingsSky::getBloomTextureId() const
 {
     return mSettings[SETTING_BLOOM_TEXTUREID].asUUID();
diff --git a/indra/llinventory/llsettingssky.h b/indra/llinventory/llsettingssky.h
index 20b8d01879..a4ea8c98f4 100644
--- a/indra/llinventory/llsettingssky.h
+++ b/indra/llinventory/llsettingssky.h
@@ -116,12 +116,23 @@ public:
     F32 getSkyTopRadius() const;
     F32 getSunArcRadians() const;
     F32 getMieAnisotropy() const;   
+
+    // Return first (only) profile layer represented in LLSD
+    LLSD getRayleighConfig() const;
+    LLSD getMieConfig() const;
+    LLSD getAbsorptionConfig() const;
+
+    // Return entire LLSDArray of profile layers represented in LLSD
     LLSD getRayleighConfigs() const;
     LLSD getMieConfigs() const;
-
     LLSD getAbsorptionConfigs() const;
+
     LLUUID getBloomTextureId() const;
 
+    void setRayleighConfigs(const LLSD& rayleighConfig);
+    void setMieConfigs(const LLSD& mieConfig);
+    void setAbsorptionConfigs(const LLSD& absorptionConfig);
+
     //---------------------------------------------------------------------
     LLColor3 getAmbientColor() const;
     void setAmbientColor(const LLColor3 &val);
@@ -248,6 +259,22 @@ public:
     static LLUUID GetDefaultCloudNoiseTextureId();
     static LLUUID GetDefaultBloomTextureId();
 
+    static LLSD createDensityProfileLayer(
+                    F32 width,
+                    F32 exponential_term,
+                    F32 exponential_scale_factor,
+                    F32 linear_term,
+                    F32 constant_term,
+                    F32 aniso_factor = 0.0f);
+
+    static LLSD createSingleLayerDensityProfile(
+                    F32 width,
+                    F32 exponential_term,
+                    F32 exponential_scale_factor,
+                    F32 linear_term,
+                    F32 constant_term,
+                    F32 aniso_factor = 0.0f);
+
 protected:
     static const std::string SETTING_LEGACY_EAST_ANGLE;
     static const std::string SETTING_LEGACY_ENABLE_CLOUD_SCROLL;
diff --git a/indra/llrender/llatmosphere.cpp b/indra/llrender/llatmosphere.cpp
index 4edfd9efe9..12c6685354 100644
--- a/indra/llrender/llatmosphere.cpp
+++ b/indra/llrender/llatmosphere.cpp
@@ -78,6 +78,8 @@ const double kMieScaleHeight = 1200.0;
 const double kMieAngstromAlpha = 0.0;
 const double kMieAngstromBeta = 5.328e-3;
 const double kMieSingleScatteringAlbedo = 0.9;
+const double kGroundAlbedo = 0.1;
+
 const double max_sun_zenith_angle = F_PI * 2.0 / 3.0;
 
 AtmosphericModelSettings::AtmosphericModelSettings()
@@ -201,7 +203,7 @@ LLAtmosphere::LLAtmosphere()
         m_mie_scattering.push_back(mie * kMieSingleScatteringAlbedo);
         m_mie_extinction.push_back(mie);
         m_absorption_extinction.push_back(kMaxOzoneNumberDensity * kOzoneCrossSection[(l - kLambdaMin) / 10]);
-        m_ground_albedo.push_back(0.6f);
+        m_ground_albedo.push_back(kGroundAlbedo);
     }
 
     AtmosphericModelSettings defaults;
@@ -249,9 +251,8 @@ bool LLAtmosphere::configureAtmosphericModel(AtmosphericModelSettings& settings)
     getIlluminance()->setTexName(0);
 
     // Init libatmosphere model
-    m_config.num_scattering_orders = 4;
-
     m_model = new atmosphere::Model(
+                                m_config,
                                 m_wavelengths,
                                 m_solar_irradiance,
                                 settings.m_sunArcRadians,
@@ -268,9 +269,10 @@ bool LLAtmosphere::configureAtmosphericModel(AtmosphericModelSettings& settings)
                                 m_ground_albedo,
                                 max_sun_zenith_angle,
                                 1000.0,   
-                                15,
-                                false,
-                                true);
+                                3,
+                                false, // do not combine_scattering...we want indep textures
+                                false, // use 32F for 2d textures to avoid artifacts
+                                true); // use 16F for 3d textures to reduce footprint
 
     if (m_model)
     {
@@ -279,6 +281,7 @@ bool LLAtmosphere::configureAtmosphericModel(AtmosphericModelSettings& settings)
         getScattering()->setTexName(m_textures.scattering_texture);   
         getMieScattering()->setTexName(m_textures.single_mie_scattering_texture);
         getIlluminance()->setTexName(m_textures.illuminance_texture);
+        m_settings = settings;
     }
 
     return m_model != nullptr;
@@ -292,7 +295,7 @@ LLGLTexture* LLAtmosphere::getTransmittance()
         m_transmittance->generateGLTexture();
         m_transmittance->setAddressMode(LLTexUnit::eTextureAddressMode::TAM_CLAMP);
         m_transmittance->setFilteringOption(LLTexUnit::eTextureFilterOptions::TFO_BILINEAR);
-        m_transmittance->setExplicitFormat(GL_RGB16F_ARB, GL_RGB, GL_FLOAT);
+        m_transmittance->setExplicitFormat(GL_RGB32F_ARB, GL_RGB, GL_FLOAT);
         m_transmittance->setTarget(GL_TEXTURE_2D, LLTexUnit::TT_TEXTURE);
     }
     return m_transmittance;
@@ -334,7 +337,7 @@ LLGLTexture* LLAtmosphere::getIlluminance()
         m_illuminance->generateGLTexture();
         m_illuminance->setAddressMode(LLTexUnit::eTextureAddressMode::TAM_CLAMP);
         m_illuminance->setFilteringOption(LLTexUnit::eTextureFilterOptions::TFO_BILINEAR);
-        m_illuminance->setExplicitFormat(GL_RGB16F_ARB, GL_RGB, GL_FLOAT);
+        m_illuminance->setExplicitFormat(GL_RGB32F_ARB, GL_RGB, GL_FLOAT);
         m_illuminance->setTarget(GL_TEXTURE_2D, LLTexUnit::TT_TEXTURE);
     }
     return m_illuminance;
diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp
index 67898f1258..251c02dd77 100644
--- a/indra/llrender/llrender.cpp
+++ b/indra/llrender/llrender.cpp
@@ -1241,16 +1241,10 @@ void LLRender::syncMatrices()
 			}
 
             if (shader->getUniformLocation(LLShaderMgr::INVERSE_MODELVIEW_MATRIX))
-            {
-                glh::matrix4f ogl_to_cfr = copy_matrix((F32*)OGL_TO_CFR_ROTATION);
-                glh::matrix4f modelview  = ogl_to_cfr.inverse() * get_current_modelview();
-
-	            glh::matrix4f inv_modelview = modelview.inverse();
-	            shader->uniformMatrix4fv(LLShaderMgr::INVERSE_MODELVIEW_MATRIX, 1, FALSE, inv_modelview.m);
+            {                
+	            shader->uniformMatrix4fv(LLShaderMgr::INVERSE_MODELVIEW_MATRIX, 1, GL_FALSE, cached_inv_mdv.m); 
             }
 
-            shader->uniformMatrix4fv(LLShaderMgr::INVERSE_MODELVIEW_MATRIX, 1, GL_FALSE, cached_inv_mdv.m);
-
 			//update MVP matrix
 			mvp_done = true;
 			loc = shader->getUniformLocation(LLShaderMgr::MODELVIEW_PROJECTION_MATRIX);
diff --git a/indra/mac_crash_logger/CMakeLists.txt b/indra/mac_crash_logger/CMakeLists.txt
index ab20388261..f6c4dfb59d 100644
--- a/indra/mac_crash_logger/CMakeLists.txt
+++ b/indra/mac_crash_logger/CMakeLists.txt
@@ -85,7 +85,7 @@ add_custom_command(
   COMMAND ${CMAKE_COMMAND}
   ARGS
     -E
-    copy_directory
+    copy_if_different
     ${CMAKE_CURRENT_SOURCE_DIR}/CrashReporter.nib
     ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mac-crash-logger.app/Contents/Resources/CrashReporter.nib
   )
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 214b1a1965..8f4faf51da 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -8664,7 +8664,7 @@
     <key>Type</key>
     <string>Boolean</string>
     <key>Value</key>
-    <integer>0</integer>
+    <integer>1</integer>
   </map>
   <key>RenderLocalLights</key>
   <map>
diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
new file mode 100644
index 0000000000..864ba4859d
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -0,0 +1,314 @@
+/** 
+ * @file multiSpotLightF.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$
+ */
+ 
+#extension GL_ARB_texture_rectangle : enable
+#extension GL_ARB_shader_texture_lod : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform samplerCube environmentMap;
+uniform sampler2DRect lightMap;
+uniform sampler2D noiseMap;
+uniform sampler2D projectionMap;
+uniform sampler2D lightFunc;
+
+uniform mat4 proj_mat; //screen space to light space
+uniform float proj_near; //near clip for projection
+uniform vec3 proj_p; //plane projection is emitting from (in screen space)
+uniform vec3 proj_n;
+uniform float proj_focus; //distance from plane to begin blurring
+uniform float proj_lod;  //(number of mips in proj map)
+uniform float proj_range; //range between near clip and far clip plane of projection
+uniform float proj_ambient_lod;
+uniform float proj_ambiance;
+uniform float near_clip;
+uniform float far_clip;
+
+uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
+uniform float sun_wash;
+uniform int proj_shadow_idx;
+uniform float shadow_fade;
+
+uniform vec3 center;
+uniform float size;
+uniform vec3 color;
+uniform float falloff;
+
+VARYING vec4 vary_fragcoord;
+uniform vec2 screen_res;
+
+uniform mat4 inv_proj;
+
+vec3 srgb_to_linear(vec3 cs);
+vec3 linear_to_srgb(vec3 cl);
+vec3 decode_normal (vec2 enc);
+
+vec4 correctWithGamma(vec4 col)
+{
+	return vec4(srgb_to_linear(col.rgb), col.a);
+}
+
+vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
+{
+	vec4 ret = texture2DLod(projectionMap, tc, lod);
+	ret.rgb = srgb_to_linear(ret.rgb);
+	
+	vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
+	
+	float det = min(lod/(proj_lod*0.5), 1.0);
+	
+	float d = min(dist.x, dist.y);
+    
+    d *= min(1, d * (proj_lod - lod));
+	
+	float edge = 0.25*det;
+    
+	ret *= clamp(d/edge, 0.0, 1.0);
+	
+	return ret;
+}
+
+vec4 texture2DLodDiffuse(sampler2D projectionMap, vec2 tc, float lod)
+{
+	vec4 ret = texture2DLod(projectionMap, tc, lod);
+	ret = correctWithGamma(ret);
+
+	vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
+	
+	float det = min(lod/(proj_lod*0.5), 1.0);
+	
+	float d = min(dist.x, dist.y);
+	
+	float edge = 0.25*det;
+		
+	ret *= clamp(d/edge, 0.0, 1.0);
+	
+	return ret;
+}
+
+vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
+{
+	vec4 ret = texture2DLod(projectionMap, tc, lod);
+	ret = correctWithGamma(ret);
+
+	vec2 dist = tc-vec2(0.5);
+	
+	float d = dot(dist,dist);
+		
+	ret *= min(clamp((0.25-d)/0.25, 0.0, 1.0), 1.0);
+	
+	return ret;
+}
+
+
+vec4 getPosition(vec2 pos_screen)
+{
+	float depth = texture2DRect(depthMap, pos_screen.xy).r;
+	vec2 sc = pos_screen.xy*2.0;
+	sc /= screen_res;
+	sc -= vec2(1.0,1.0);
+	vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+	vec4 pos = inv_proj * ndc;
+	pos /= pos.w;
+	pos.w = 1.0;
+	return pos;
+}
+
+void main() 
+{
+	vec4 frag = vary_fragcoord;
+	frag.xyz /= frag.w;
+	frag.xyz = frag.xyz*0.5+0.5;
+	frag.xy *= screen_res;
+	
+	vec3 pos = getPosition(frag.xy).xyz;
+	vec3 lv = center.xyz-pos.xyz;
+	float dist = length(lv);
+	dist /= size;
+	if (dist > 1.0)
+	{
+		discard;
+	}
+	
+	float shadow = 1.0;
+	
+	if (proj_shadow_idx >= 0)
+	{
+		vec4 shd = texture2DRect(lightMap, frag.xy);
+		float sh[2];
+		sh[0] = shd.b;
+		sh[1] = shd.a;
+		shadow = min(sh[proj_shadow_idx]+shadow_fade, 1.0);
+	}
+	
+	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
+	
+	float envIntensity = norm.z;
+
+	norm = decode_normal(norm.xy);
+	
+	norm = normalize(norm);
+	float l_dist = -dot(lv, proj_n);
+	
+	vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
+	if (proj_tc.z < 0.0)
+	{
+		discard;
+	}
+	
+	proj_tc.xyz /= proj_tc.w;
+	
+	float fa = falloff+1.0;
+	float dist_atten = min(1.0-(dist-1.0*(1.0-fa))/fa, 1.0);
+	dist_atten *= dist_atten;
+	dist_atten *= 2.0;
+	if (dist_atten <= 0.0)
+	{
+		discard;
+	}
+	
+	lv = proj_origin-pos.xyz;
+	lv = normalize(lv);
+	float da = dot(norm, lv);
+
+	vec3 col = vec3(0,0,0);
+		
+	vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+	
+	vec4 spec = texture2DRect(specularRect, frag.xy);
+
+	vec3 dlit = vec3(0, 0, 0);
+
+	float noise = texture2D(noiseMap, frag.xy/128.0).b;
+	if (proj_tc.z > 0.0 &&
+		proj_tc.x < 1.0 &&
+		proj_tc.y < 1.0 &&
+		proj_tc.x > 0.0 &&
+		proj_tc.y > 0.0)
+	{
+		float amb_da = proj_ambiance;
+		float lit = 0.0;
+
+		if (da > 0.0)
+		{
+			lit = da * dist_atten * noise;
+
+			float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
+			float lod = diff * proj_lod;
+			
+			vec4 plcol = texture2DLodDiffuse(projectionMap, proj_tc.xy, lod);
+		
+			dlit = color.rgb * plcol.rgb * plcol.a;
+			
+			col = dlit*lit*diff_tex*shadow;
+			amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
+		}
+		
+		//float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
+		vec4 amb_plcol = texture2DLodAmbient(projectionMap, proj_tc.xy, proj_lod);
+							
+		amb_da += (da*da*0.5+0.5)*proj_ambiance;
+				
+		amb_da *= dist_atten * noise;
+			
+		amb_da = min(amb_da, 1.0-lit);
+			
+		col += amb_da*color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
+	}
+	
+
+	if (spec.a > 0.0)
+	{
+		vec3 npos = -normalize(pos);
+		dlit *= min(da*6.0, 1.0) * dist_atten;
+
+		//vec3 ref = dot(pos+lv, norm);
+		vec3 h = normalize(lv+npos);
+		float nh = dot(norm, h);
+		float nv = dot(norm, npos);
+		float vh = dot(npos, h);
+		float sa = nh;
+		float fres = pow(1 - dot(h, npos), 5)*0.4+0.5;
+
+		float gtdenom = 2 * nh;
+		float gt = max(0, min(gtdenom * nv / vh, gtdenom * da / vh));
+								
+		if (nh > 0.0)
+		{
+			float scol = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt/(nh*da);
+			col += dlit*scol*spec.rgb*shadow;
+			//col += spec.rgb;
+		}
+	}	
+	
+	
+	
+	
+
+	if (envIntensity > 0.0)
+	{
+		vec3 ref = reflect(normalize(pos), norm);
+		
+		//project from point pos in direction ref to plane proj_p, proj_n
+		vec3 pdelta = proj_p-pos;
+		float ds = dot(ref, proj_n);
+		
+		if (ds < 0.0)
+		{
+			vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
+			
+			vec4 stc = (proj_mat * vec4(pfinal.xyz, 1.0));
+
+			if (stc.z > 0.0)
+			{
+                stc /= stc.w;
+								
+				if (stc.x < 1.0 &&
+					stc.y < 1.0 &&
+					stc.x > 0.0 &&
+					stc.y > 0.0)
+				{
+					col += color.rgb * texture2DLodSpecular(projectionMap, stc.xy, (1 - spec.a) * (proj_lod * 0.6)).rgb * shadow * envIntensity;
+				}
+			}
+		}
+	}
+
+	//not sure why, but this line prevents MATBUG-194
+	col = max(col, vec3(0.0));
+
+	frag_color.rgb = col;	
+	frag_color.a = 0.0;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 47fa0efe06..7bfc114383 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file advancedAtmoF.glsl
+ * @file class3/skyF.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -24,17 +24,19 @@
  */
  
 #ifdef DEFINE_GL_FRAGCOLOR
-out vec4 frag_color;
+out vec4 frag_data[3];
 #else
-#define frag_color gl_FragColor
+#define frag_data gl_FragData
 #endif
 
-in vec3 view_pos;
-in vec3 view_dir;
+VARYING vec2 vary_frag;
 
-uniform vec3 cameraPosLocal;
+uniform vec3 camPosLocal;
 uniform vec3 sun_dir;
 uniform float sun_size;
+uniform float far_z;
+uniform mat4 inv_proj;
+uniform mat4 inv_modelview;
 
 uniform sampler2D transmittance_texture;
 uniform sampler3D scattering_texture;
@@ -44,42 +46,38 @@ uniform sampler2D irradiance_texture;
 vec3 GetSolarLuminance();
 vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 dir, out vec3 transmittance);
 vec3 GetSkyLuminanceToPoint(vec3 camPos, vec3 pos, float shadow_length, vec3 dir, out vec3 transmittance);
-vec3 GetSunAndSkyIlluminance(vec3 pos, vec3 norm, vec3 dir, out vec3 sky_irradiance);
 
 void main()
 {
-    vec3 view_direction = normalize(view_dir);
+    vec3 pos      = vec3((vary_frag * 2.0) - vec2(1.0, 1.0), 0.0);
+    vec4 view_pos = (inv_proj * vec4(pos, 1.0f));
+    view_pos /= view_pos.w;
+    vec3 view_ray = (inv_modelview * vec4(view_pos.xyz, 0.0f)).xyz;
 
-    vec3 sun_direction = sun_dir;
+    vec3 view_direction = normalize(view_ray);
+    vec3 sun_direction  = normalize(sun_dir);
 
-    vec3 camPos = cameraPosLocal + vec3(0, 0, 6360.0f);
+    vec3 camPos = (camPosLocal / 1000.0f) + vec3(0, 0, 6360.0f);
     vec3 transmittance;
-    vec3 sky_illum;
-
-    vec3 radiance_sun = GetSkyLuminance(camPos, view_direction, 0.0f, sun_direction, transmittance);
-    vec3 radiance2_sun = GetSunAndSkyIlluminance(camPos, view_direction, sun_direction, sky_illum);
-
-    radiance_sun *= transmittance;
-
+    vec3 radiance_sun  = GetSkyLuminance(camPos, view_direction, 0.0f, sun_direction, transmittance);
     vec3 solar_luminance = transmittance * GetSolarLuminance();
 
     // If the view ray intersects the Sun, add the Sun radiance.
-    if (dot(view_direction, sun_direction) >= sun_size)
+    float s = dot(view_direction, sun_direction);
+
+    // cheesy solar disc...
+    if (s >= (sun_size * 0.999))
     {
-        radiance_sun = radiance_sun + solar_luminance;
+        radiance_sun += pow(smoothstep(0.0, 1.3, (s - (sun_size * 0.9))), 2.0) * solar_luminance;
     }
+    s = smoothstep(0.9, 1.0, s) * 16.0f;
 
-    vec3 color = radiance_sun;
-    
-    color = vec3(1.0) - exp(-color * 0.0001);
-
-    //float d = dot(view_direction, sun_direction);
-    //frag_color.rgb = vec3(d, d >= sun_size ? 1.0f : 0.0f, 0.0f);
+    vec3 color = vec3(1.0) - exp(-radiance_sun * 0.0001);
 
-    frag_color.rgb = color;
-    //frag_color.rgb = vec3(dot(view_direction, sun_direction) > 0.95f ? 1.0 : 0.0, 0,0);
-    //frag_color.rgb = normalize(view_pos);
+    color = pow(color, vec3(1.0 / 2.2));
 
-    frag_color.a = 1.0;
+    frag_data[0] = vec4(color, 1.0 + s);
+    frag_data[1] = vec4(0.0);
+    frag_data[2] = vec4(0.0, 1.0, 0.0, 1.0);
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
index cf3eb658fc..a5cc49ca30 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -30,22 +30,14 @@ uniform mat4 inv_proj;
 uniform mat4 inv_modelview;
 
 ATTRIBUTE vec3 position;
+ATTRIBUTE vec2 texcoord0;
 
-// Inputs
-uniform vec3 camPosLocal;
-
-out vec3 view_pos;
-out vec3 view_dir;
+VARYING vec2 vary_frag;
 
 void main()
 {
-    // pass through untransformed fullscreen pos (clipspace)
-	gl_Position = vec4(position.xyz, 1.0);
-
-    view_pos = (inv_proj * vec4(position, 1.0f)).xyz;
-
-	// this will be normalized in the frag shader...
-	//view_dir = (inv_modelview * view_pos).xyz;
-    view_dir = view_pos - camPosLocal;
+    // pass through untransformed fullscreen pos at back of frustum for proper sky depth testing
+	gl_Position = vec4(position.xy, 1.0f, 1.0);
+    vary_frag = texcoord0;
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
new file mode 100644
index 0000000000..bda33c3213
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -0,0 +1,189 @@
+/** 
+ * @file softenLightF.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$
+ */
+ 
+#extension GL_ARB_texture_rectangle : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect lightMap;
+uniform sampler2DRect depthMap;
+uniform samplerCube environmentMap;
+uniform sampler2D	  lightFunc;
+
+uniform float blur_size;
+uniform float blur_fidelity;
+
+// Inputs
+uniform vec4 morphFactor;
+uniform vec3 camPosLocal;
+//uniform vec4 camPosWorld;
+uniform vec4 gamma;
+uniform vec4 sunlight_color;
+uniform vec4 ambient;
+uniform vec4 blue_horizon;
+uniform vec4 blue_density;
+uniform float haze_horizon;
+uniform float haze_density;
+uniform float cloud_shadow;
+uniform float density_multiplier;
+uniform float distance_multiplier;
+uniform float max_y;
+uniform vec4 glow;
+uniform float global_gamma;
+uniform float scene_light_strength;
+uniform mat3 env_mat;
+uniform vec4 shadow_clip;
+uniform mat3 ssao_effect_mat;
+
+uniform vec3 sun_dir;
+VARYING vec2 vary_fragcoord;
+
+uniform mat4 inv_proj;
+uniform mat4 inv_modelview;
+
+uniform vec2 screen_res;
+
+vec3 srgb_to_linear(vec3 cs);
+vec3 linear_to_srgb(vec3 cl);
+vec3 decode_normal (vec2 enc);
+
+vec4 getPosition_d(vec2 pos_screen, float depth)
+{
+	vec2 sc = pos_screen.xy*2.0;
+	sc /= screen_res;
+	sc -= vec2(1.0,1.0);
+	vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+	vec4 pos = inv_proj * ndc;
+	pos /= pos.w;
+	pos.w = 1.0;
+	return pos;
+}
+
+vec4 getPosition(vec2 pos_screen)
+{ //get position in screen space (world units) given window coordinate and depth map
+	float depth = texture2DRect(depthMap, pos_screen.xy).r;
+	return getPosition_d(pos_screen, depth);
+}
+
+
+#ifdef WATER_FOG
+vec4 applyWaterFogView(vec3 pos, vec4 color);
+#endif
+
+void main() 
+{
+	vec2 tc = vary_fragcoord.xy;
+	float depth = texture2DRect(depthMap, tc.xy).r;
+	vec3 pos = getPosition_d(tc, depth).xyz;
+	vec4 norm = texture2DRect(normalMap, tc);
+	float envIntensity = norm.z;
+	norm.xyz = decode_normal(norm.xy); // unpack norm
+		
+	float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
+
+	float light_gamma = 1.0/1.3;
+	da = pow(da, light_gamma);
+
+
+	vec4 diffuse = texture2DRect(diffuseRect, tc);
+
+	//convert to gamma space
+	diffuse.rgb = linear_to_srgb(diffuse.rgb);
+	
+	vec3 col;
+	float bloom = 0.0;
+	{
+		vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+		
+		vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
+		scol_ambocc = pow(scol_ambocc, vec2(light_gamma));
+
+		float scol = max(scol_ambocc.r, diffuse.a); 
+
+		float ambocc = scol_ambocc.g;
+
+                vec3 sunlit;
+                vec3 amblit;
+                vec3 additive;
+                vec3 atten;
+	
+		//calcFragAtmospherics(pos.xyz, ambocc, sunlit, amblit, additive, atten);
+		//col += atmosFragAffectDirectionalLight(max(min(da, scol), 0.0), sunlit);
+	
+		col *= diffuse.rgb;
+	
+		vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
+
+		if (spec.a > 0.0) // specular reflection
+		{
+			// the old infinite-sky shiny reflection
+			//
+			
+			float sa = dot(refnormpersp, sun_dir.xyz);
+			vec3 dumbshiny = sunlit*(texture2D(lightFunc, vec2(sa, spec.a)).r);
+			
+			// add the two types of shiny together
+			vec3 spec_contrib = dumbshiny * spec.rgb;
+			bloom = dot(spec_contrib, spec_contrib) / 6;
+			col += spec_contrib;
+		}
+	
+		
+		col = mix(col, diffuse.rgb, diffuse.a);
+
+		if (envIntensity > 0.0)
+		{ //add environmentmap
+			vec3 env_vec = env_mat * refnormpersp;
+			vec3 refcol = textureCube(environmentMap, env_vec).rgb;
+			col = mix(col.rgb, refcol, envintensity);
+		}
+						
+		if (norm.w < 0.5)
+		{
+			//col = mix(atmosFragLighting(col, additive, atten), fullbrightFragAtmosTransport(col, atten, additive), diffuse.a);
+			//col = mix(scaleFragSoftClip(col), fullbrightScaleSoftClipFrag(col, atten), diffuse.a);
+		}
+
+		#ifdef WATER_FOG
+			vec4 fogged = applyWaterFogView(pos,vec4(col, bloom));
+			col = fogged.rgb;
+			bloom = fogged.a;
+		#endif
+
+		col = srgb_to_linear(col);
+	}
+	
+	frag_color.rgb = col;
+	frag_color.a = bloom;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
new file mode 100644
index 0000000000..c840d72784
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
@@ -0,0 +1,42 @@
+/** 
+ * @file softenLightF.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 mat4 modelview_projection_matrix;
+
+ATTRIBUTE vec3 position;
+
+uniform vec2 screen_res;
+
+VARYING vec2 vary_fragcoord;
+
+void main()
+{
+	//transform vertex
+	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	gl_Position = pos; 
+	
+	
+	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
new file mode 100644
index 0000000000..a7da140b31
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -0,0 +1,313 @@
+/** 
+ * @file spotLightF.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$
+ */
+ 
+#extension GL_ARB_texture_rectangle : enable
+#extension GL_ARB_shader_texture_lod : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform samplerCube environmentMap;
+uniform sampler2DRect lightMap;
+uniform sampler2D noiseMap;
+uniform sampler2D projectionMap;
+uniform sampler2D lightFunc;
+
+uniform mat4 proj_mat; //screen space to light space
+uniform float proj_near; //near clip for projection
+uniform vec3 proj_p; //plane projection is emitting from (in screen space)
+uniform vec3 proj_n;
+uniform float proj_focus; //distance from plane to begin blurring
+uniform float proj_lod;  //(number of mips in proj map)
+uniform float proj_range; //range between near clip and far clip plane of projection
+uniform float proj_ambient_lod;
+uniform float proj_ambiance;
+uniform float near_clip;
+uniform float far_clip;
+
+uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
+uniform float sun_wash;
+uniform int proj_shadow_idx;
+uniform float shadow_fade;
+
+uniform float size;
+uniform vec3 color;
+uniform float falloff;
+
+VARYING vec3 trans_center;
+VARYING vec4 vary_fragcoord;
+uniform vec2 screen_res;
+
+uniform mat4 inv_proj;
+
+vec3 decode_normal (vec2 enc);
+vec3 srgb_to_linear(vec3 cs);
+vec3 linear_to_srgb(vec3 cl);
+
+vec4 correctWithGamma(vec4 col)
+{
+	return vec4(srgb_to_linear(col.rgb), col.a);
+}
+
+vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
+{
+	vec4 ret = texture2DLod(projectionMap, tc, lod);
+	ret.rgb = srgb_to_linear(ret.rgb);
+	
+	vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
+	
+	float det = min(lod/(proj_lod*0.5), 1.0);
+	
+	float d = min(dist.x, dist.y);
+    
+    d *= min(1, d * (proj_lod - lod));
+	
+	float edge = 0.25*det;
+    
+	ret *= clamp(d/edge, 0.0, 1.0);
+	
+	return ret;
+}
+
+vec4 texture2DLodDiffuse(sampler2D projectionMap, vec2 tc, float lod)
+{
+	vec4 ret = texture2DLod(projectionMap, tc, lod);
+	ret = correctWithGamma(ret);
+	
+	vec2 dist = vec2(0.5) - abs(tc-vec2(0.5));
+	
+	float det = min(lod/(proj_lod*0.5), 1.0);
+	
+	float d = min(dist.x, dist.y);
+	
+	float edge = 0.25*det;
+		
+	ret *= clamp(d/edge, 0.0, 1.0);
+	
+	return ret;
+}
+
+vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
+{
+	vec4 ret = texture2DLod(projectionMap, tc, lod);
+	ret = correctWithGamma(ret);
+	
+	vec2 dist = tc-vec2(0.5);
+	
+	float d = dot(dist,dist);
+		
+	ret *= min(clamp((0.25-d)/0.25, 0.0, 1.0), 1.0);
+	
+	return ret;
+}
+
+
+vec4 getPosition(vec2 pos_screen)
+{
+	float depth = texture2DRect(depthMap, pos_screen.xy).r;
+	vec2 sc = pos_screen.xy*2.0;
+	sc /= screen_res;
+	sc -= vec2(1.0,1.0);
+	vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+	vec4 pos = inv_proj * ndc;
+	pos /= pos.w;
+	pos.w = 1.0;
+	return pos;
+}
+
+void main() 
+{
+	vec4 frag = vary_fragcoord;
+	frag.xyz /= frag.w;
+	frag.xyz = frag.xyz*0.5+0.5;
+	frag.xy *= screen_res;
+	
+	vec3 pos = getPosition(frag.xy).xyz;
+	vec3 lv = trans_center.xyz-pos.xyz;
+	float dist = length(lv);
+	dist /= size;
+	if (dist > 1.0)
+	{
+		discard;
+	}
+	
+	float shadow = 1.0;
+	
+	if (proj_shadow_idx >= 0)
+	{
+		vec4 shd = texture2DRect(lightMap, frag.xy);
+		float sh[2];
+		sh[0] = shd.b;
+		sh[1] = shd.a;
+		shadow = min(sh[proj_shadow_idx]+shadow_fade, 1.0);
+	}
+	
+	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
+	float envIntensity = norm.z;
+	norm = decode_normal(norm.xy);
+	
+	norm = normalize(norm);
+	float l_dist = -dot(lv, proj_n);
+	
+	vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
+	if (proj_tc.z < 0.0)
+	{
+		discard;
+	}
+	
+	proj_tc.xyz /= proj_tc.w;
+	
+	float fa = falloff + 1.0;
+	float dist_atten = min(1.0 - (dist - 1.0 * (1.0 - fa)) / fa, 1.0);
+	dist_atten *= dist_atten;
+	dist_atten *= 2.0;
+
+	if (dist_atten <= 0.0)
+	{
+		discard;
+	}
+	
+	lv = proj_origin-pos.xyz;
+	lv = normalize(lv);
+	float da = dot(norm, lv);
+		
+	vec3 col = vec3(0,0,0);
+		
+	vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+		
+	vec4 spec = texture2DRect(specularRect, frag.xy);
+
+	vec3 dlit = vec3(0, 0, 0);
+
+	float noise = texture2D(noiseMap, frag.xy/128.0).b;
+	if (proj_tc.z > 0.0 &&
+		proj_tc.x < 1.0 &&
+		proj_tc.y < 1.0 &&
+		proj_tc.x > 0.0 &&
+		proj_tc.y > 0.0)
+	{
+		float amb_da = proj_ambiance;
+		float lit = 0.0;
+		
+		if (da > 0.0)
+		{
+			lit = da * dist_atten * noise;
+
+			float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
+			float lod = diff * proj_lod;
+			
+			vec4 plcol = texture2DLodDiffuse(projectionMap, proj_tc.xy, lod);
+		
+			dlit = color.rgb * plcol.rgb * plcol.a;
+			
+			col = dlit*lit*diff_tex*shadow;
+			amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
+		}
+		
+		//float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
+		vec4 amb_plcol = texture2DLodAmbient(projectionMap, proj_tc.xy, proj_lod);
+							
+		amb_da += (da*da*0.5+0.5)*proj_ambiance;
+				
+		amb_da *= dist_atten * noise;
+			
+		amb_da = min(amb_da, 1.0-lit);
+			
+		col += amb_da*color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
+	}
+	
+
+	if (spec.a > 0.0)
+	{
+		dlit *= min(da*6.0, 1.0) * dist_atten;
+		vec3 npos = -normalize(pos);
+
+		//vec3 ref = dot(pos+lv, norm);
+		vec3 h = normalize(lv+npos);
+		float nh = dot(norm, h);
+		float nv = dot(norm, npos);
+		float vh = dot(npos, h);
+		float sa = nh;
+		float fres = pow(1 - dot(h, npos), 5)*0.4+0.5;
+
+		float gtdenom = 2 * nh;
+		float gt = max(0, min(gtdenom * nv / vh, gtdenom * da / vh));
+								
+		if (nh > 0.0)
+		{
+			float scol = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt/(nh*da);
+			col += dlit*scol*spec.rgb*shadow;
+			//col += spec.rgb;
+		}
+	}	
+	
+	
+	
+	
+
+	if (envIntensity > 0.0)
+	{
+		vec3 ref = reflect(normalize(pos), norm);
+		
+		//project from point pos in direction ref to plane proj_p, proj_n
+		vec3 pdelta = proj_p-pos;
+		float ds = dot(ref, proj_n);
+		
+		if (ds < 0.0)
+		{
+			vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
+			
+			vec4 stc = (proj_mat * vec4(pfinal.xyz, 1.0));
+
+			if (stc.z > 0.0)
+			{
+				stc /= stc.w;
+								
+				if (stc.x < 1.0 &&
+					stc.y < 1.0 &&
+					stc.x > 0.0 &&
+					stc.y > 0.0)
+				{
+					col += color.rgb * texture2DLodSpecular(projectionMap, stc.xy, (1 - spec.a) * (proj_lod * 0.6)).rgb * shadow * envIntensity;
+				}
+			}
+		}
+	}
+	
+	//not sure why, but this line prevents MATBUG-194
+	col = max(col, vec3(0.0));
+
+	frag_color.rgb = col;	
+	frag_color.a = 0.0;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
new file mode 100644
index 0000000000..aa5e99a2f7
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
@@ -0,0 +1,247 @@
+/** 
+ * @file sunLightF.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$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+//class 2, shadows, no SSAO
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DShadow shadowMap0;
+uniform sampler2DShadow shadowMap1;
+uniform sampler2DShadow shadowMap2;
+uniform sampler2DShadow shadowMap3;
+uniform sampler2DShadow shadowMap4;
+uniform sampler2DShadow shadowMap5;
+
+
+// Inputs
+uniform mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+uniform float ssao_radius;
+uniform float ssao_max_radius;
+uniform float ssao_factor;
+uniform float ssao_factor_inv;
+
+VARYING vec2 vary_fragcoord;
+
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+uniform vec2 proj_shadow_res;
+uniform vec3 sun_dir;
+
+uniform vec2 shadow_res;
+uniform float shadow_bias;
+uniform float shadow_offset;
+
+uniform float spot_shadow_bias;
+uniform float spot_shadow_offset;
+
+vec3 decode_normal (vec2 enc);
+
+vec4 getPosition(vec2 pos_screen)
+{
+	float depth = texture2DRect(depthMap, pos_screen.xy).r;
+	vec2 sc = pos_screen.xy*2.0;
+	sc /= screen_res;
+	sc -= vec2(1.0,1.0);
+	vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+	vec4 pos = inv_proj * ndc;
+	pos /= pos.w;
+	pos.w = 1.0;
+	return pos;
+}
+
+float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
+{
+	stc.xyz /= stc.w;
+	stc.z += shadow_bias;
+
+	stc.x = floor(stc.x*shadow_res.x + fract(pos_screen.y*0.666666666))/shadow_res.x; // add some jitter to X sample pos according to Y to disguise the snapping going on here
+	float cs = shadow2D(shadowMap, stc.xyz).x;
+
+	float shadow = cs;
+
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(2.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(1.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(-2.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(-1.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
+
+			
+    return shadow*0.2;
+}
+
+float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
+{
+	stc.xyz /= stc.w;
+	stc.z += spot_shadow_bias*scl;
+	stc.x = floor(proj_shadow_res.x * stc.x + fract(pos_screen.y*0.666666666)) / proj_shadow_res.x; // snap
+
+	float cs = shadow2D(shadowMap, stc.xyz).x;
+	float shadow = cs;
+
+	vec2 off = 1.0/proj_shadow_res;
+	off.y *= 1.5;
+	
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(off.x*2.0, off.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(off.x, -off.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(-off.x, off.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(-off.x*2.0, -off.y, 0.0)).x;
+
+        return shadow*0.2;
+}
+
+void main() 
+{
+	vec2 pos_screen = vary_fragcoord.xy;
+	
+	//try doing an unproject here
+	
+	vec4 pos = getPosition(pos_screen);
+	
+	vec3 norm = texture2DRect(normalMap, pos_screen).xyz;
+	norm = decode_normal(norm.xy); // unpack norm
+		
+	/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
+	{
+		frag_color = vec4(0.0); // doesn't matter
+		return;
+	}*/
+	
+	float shadow = 0.0;
+	float dp_directional_light = max(0.0, dot(norm, sun_dir.xyz));
+	
+	vec3 shadow_pos = pos.xyz;
+	vec3 offset = sun_dir.xyz * (1.0-dp_directional_light);
+	
+	vec4 spos = vec4(shadow_pos+offset*shadow_offset, 1.0);
+	
+	if (spos.z > -shadow_clip.w)
+	{	
+		if (dp_directional_light == 0.0)
+		{
+			// if we know this point is facing away from the sun then we know it's in shadow without having to do a squirrelly shadow-map lookup
+			shadow = 0.0;
+		}
+		else
+		{
+			vec4 lpos;
+			
+			vec4 near_split = shadow_clip*-0.75;
+			vec4 far_split = shadow_clip*-1.25;
+			vec4 transition_domain = near_split-far_split;
+			float weight = 0.0;
+
+			if (spos.z < near_split.z)
+			{
+				lpos = shadow_matrix[3]*spos;
+				
+				float w = 1.0;
+				w -= max(spos.z-far_split.z, 0.0)/transition_domain.z;
+				shadow += pcfShadow(shadowMap3, lpos, 0.25, pos_screen)*w;
+				weight += w;
+				shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
+			}
+
+			if (spos.z < near_split.y && spos.z > far_split.z)
+			{
+				lpos = shadow_matrix[2]*spos;
+				
+				float w = 1.0;
+				w -= max(spos.z-far_split.y, 0.0)/transition_domain.y;
+				w -= max(near_split.z-spos.z, 0.0)/transition_domain.z;
+				shadow += pcfShadow(shadowMap2, lpos, 0.5, pos_screen)*w;
+				weight += w;
+			}
+
+			if (spos.z < near_split.x && spos.z > far_split.y)
+			{
+				lpos = shadow_matrix[1]*spos;
+
+				float w = 1.0;
+				w -= max(spos.z-far_split.x, 0.0)/transition_domain.x;
+				w -= max(near_split.y-spos.z, 0.0)/transition_domain.y;
+				shadow += pcfShadow(shadowMap1, lpos, 0.75, pos_screen)*w;
+				weight += w;
+			}
+
+			if (spos.z > far_split.x)
+			{
+				lpos = shadow_matrix[0]*spos;
+				
+				float w = 1.0;
+				w -= max(near_split.x-spos.z, 0.0)/transition_domain.x;
+				
+				shadow += pcfShadow(shadowMap0, lpos, 1.0, pos_screen)*w;
+				weight += w;
+			}
+		
+
+			shadow /= weight;
+
+			// take the most-shadowed value out of these two:
+			//  * the blurred sun shadow in the light (shadow) map
+			//  * an unblurred dot product between the sun and this norm
+			// the goal is to err on the side of most-shadow to fill-in shadow holes and reduce artifacting
+			shadow = min(shadow, dp_directional_light);
+			
+			//lpos.xy /= lpos.w*32.0;
+			//if (fract(lpos.x) < 0.1 || fract(lpos.y) < 0.1)
+			//{
+			//	shadow = 0.0;
+			//}
+			
+		}
+	}
+	else
+	{
+		// more distant than the shadow map covers
+		shadow = 1.0;
+	}
+	
+	frag_color[0] = shadow;
+	frag_color[1] = 1.0;
+	
+	spos = vec4(shadow_pos+norm*spot_shadow_offset, 1.0);
+	
+	//spotlight shadow 1
+	vec4 lpos = shadow_matrix[4]*spos;
+	frag_color[2] = pcfSpotShadow(shadowMap4, lpos, 0.8, pos_screen); 
+	
+	//spotlight shadow 2
+	lpos = shadow_matrix[5]*spos;
+	frag_color[3] = pcfSpotShadow(shadowMap5, lpos, 0.8, pos_screen); 
+
+	//frag_color.rgb = pos.xyz;
+	//frag_color.b = shadow;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
new file mode 100644
index 0000000000..58f3f2f91e
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
@@ -0,0 +1,308 @@
+/** 
+ * @file sunLightSSAOF.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$
+ */
+ 
+#extension GL_ARB_texture_rectangle : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+//class 2 -- shadows and SSAO
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DShadow shadowMap0;
+uniform sampler2DShadow shadowMap1;
+uniform sampler2DShadow shadowMap2;
+uniform sampler2DShadow shadowMap3;
+uniform sampler2DShadow shadowMap4;
+uniform sampler2DShadow shadowMap5;
+uniform sampler2D noiseMap;
+
+
+// Inputs
+uniform mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+uniform float ssao_radius;
+uniform float ssao_max_radius;
+uniform float ssao_factor;
+uniform float ssao_factor_inv;
+
+VARYING vec2 vary_fragcoord;
+
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+uniform vec2 proj_shadow_res;
+uniform vec3 sun_dir;
+
+uniform vec2 shadow_res;
+
+uniform float shadow_bias;
+uniform float shadow_offset;
+
+uniform float spot_shadow_bias;
+uniform float spot_shadow_offset;
+
+vec3 decode_normal (vec2 enc);
+
+vec4 getPosition(vec2 pos_screen)
+{
+	float depth = texture2DRect(depthMap, pos_screen.xy).r;
+	vec2 sc = pos_screen.xy*2.0;
+	sc /= screen_res;
+	sc -= vec2(1.0,1.0);
+	vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+	vec4 pos = inv_proj * ndc;
+	pos /= pos.w;
+	pos.w = 1.0;
+	return pos;
+}
+
+vec2 getKern(int i)
+{
+	vec2 kern[8];
+	// exponentially (^2) distant occlusion samples spread around origin
+	kern[0] = vec2(-1.0, 0.0) * 0.125*0.125;
+	kern[1] = vec2(1.0, 0.0) * 0.250*0.250;
+	kern[2] = vec2(0.0, 1.0) * 0.375*0.375;
+	kern[3] = vec2(0.0, -1.0) * 0.500*0.500;
+	kern[4] = vec2(0.7071, 0.7071) * 0.625*0.625;
+	kern[5] = vec2(-0.7071, -0.7071) * 0.750*0.750;
+	kern[6] = vec2(-0.7071, 0.7071) * 0.875*0.875;
+	kern[7] = vec2(0.7071, -0.7071) * 1.000*1.000;
+       
+	return kern[i];
+}
+
+//calculate decreases in ambient lighting when crowded out (SSAO)
+float calcAmbientOcclusion(vec4 pos, vec3 norm)
+{
+	float ret = 1.0;
+
+	vec2 pos_screen = vary_fragcoord.xy;
+	vec3 pos_world = pos.xyz;
+	vec2 noise_reflect = texture2D(noiseMap, vary_fragcoord.xy/128.0).xy;
+		
+	float angle_hidden = 0.0;
+	float points = 0;
+		
+	float scale = min(ssao_radius / -pos_world.z, ssao_max_radius);
+	
+	// it was found that keeping # of samples a constant was the fastest, probably due to compiler optimizations (unrolling?)
+	for (int i = 0; i < 8; i++)
+	{
+		vec2 samppos_screen = pos_screen + scale * reflect(getKern(i), noise_reflect);
+		vec3 samppos_world = getPosition(samppos_screen).xyz; 
+		
+		vec3 diff = pos_world - samppos_world;
+		float dist2 = dot(diff, diff);
+			
+		// assume each sample corresponds to an occluding sphere with constant radius, constant x-sectional area
+		// --> solid angle shrinking by the square of distance
+		//radius is somewhat arbitrary, can approx with just some constant k * 1 / dist^2
+		//(k should vary inversely with # of samples, but this is taken care of later)
+		
+		float funky_val = (dot((samppos_world - 0.05*norm - pos_world), norm) > 0.0) ? 1.0 : 0.0;
+		angle_hidden = angle_hidden + funky_val * min(1.0/dist2, ssao_factor_inv);
+			
+		// 'blocked' samples (significantly closer to camera relative to pos_world) are "no data", not "no occlusion" 
+		float diffz_val = (diff.z > -1.0) ? 1.0 : 0.0;
+		points = points + diffz_val;
+	}
+		
+	angle_hidden = min(ssao_factor*angle_hidden/points, 1.0);
+	
+	float points_val = (points > 0.0) ? 1.0 : 0.0;
+	ret = (1.0 - (points_val * angle_hidden));
+
+	ret = max(ret, 0.0);
+	return min(ret, 1.0);
+}
+
+float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
+{
+	stc.xyz /= stc.w;
+	stc.z += shadow_bias;
+
+	stc.x = floor(stc.x*shadow_res.x + fract(pos_screen.y*0.666666666))/shadow_res.x;
+	float cs = shadow2D(shadowMap, stc.xyz).x;
+	
+	float shadow = cs;
+	
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(2.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
+    shadow += shadow2D(shadowMap, stc.xyz+vec3(1.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
+    shadow += shadow2D(shadowMap, stc.xyz+vec3(-1.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
+    shadow += shadow2D(shadowMap, stc.xyz+vec3(-2.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
+	         
+        return shadow*0.2;
+}
+
+float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
+{
+	stc.xyz /= stc.w;
+	stc.z += spot_shadow_bias*scl;
+	stc.x = floor(proj_shadow_res.x * stc.x + fract(pos_screen.y*0.666666666)) / proj_shadow_res.x; // snap
+		
+	float cs = shadow2D(shadowMap, stc.xyz).x;
+	float shadow = cs;
+
+	vec2 off = 1.0/proj_shadow_res;
+	off.y *= 1.5;
+	
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(off.x*2.0, off.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(off.x, -off.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(-off.x, off.y, 0.0)).x;
+	shadow += shadow2D(shadowMap, stc.xyz+vec3(-off.x*2.0, -off.y, 0.0)).x;
+
+        return shadow*0.2;
+}
+
+void main() 
+{
+	vec2 pos_screen = vary_fragcoord.xy;
+	
+	//try doing an unproject here
+	
+	vec4 pos = getPosition(pos_screen);
+	
+	vec3 norm = texture2DRect(normalMap, pos_screen).xyz;
+	norm = decode_normal(norm.xy); // unpack norm
+		
+	/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
+	{
+		frag_color = vec4(0.0); // doesn't matter
+		return;
+	}*/
+	
+	float shadow = 0.0;
+	float dp_directional_light = max(0.0, dot(norm, sun_dir.xyz));
+	
+	vec3 shadow_pos = pos.xyz;
+	vec3 offset = sun_dir.xyz * (1.0-dp_directional_light);
+	
+	vec4 spos = vec4(shadow_pos+offset*shadow_offset, 1.0);
+	
+	if (spos.z > -shadow_clip.w)
+	{	
+		if (dp_directional_light == 0.0)
+		{
+			// if we know this point is facing away from the sun then we know it's in shadow without having to do a squirrelly shadow-map lookup
+			shadow = 0.0;
+		}
+		else
+		{
+			vec4 lpos;
+
+			vec4 near_split = shadow_clip*-0.75;
+			vec4 far_split = shadow_clip*-1.25;
+			vec4 transition_domain = near_split-far_split;
+			float weight = 0.0;
+
+			if (spos.z < near_split.z)
+			{
+				lpos = shadow_matrix[3]*spos;
+				
+				float w = 1.0;
+				w -= max(spos.z-far_split.z, 0.0)/transition_domain.z;
+				shadow += pcfShadow(shadowMap3, lpos, 0.25, pos_screen)*w;
+				weight += w;
+				shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
+			}
+
+			if (spos.z < near_split.y && spos.z > far_split.z)
+			{
+				lpos = shadow_matrix[2]*spos;
+				
+				float w = 1.0;
+				w -= max(spos.z-far_split.y, 0.0)/transition_domain.y;
+				w -= max(near_split.z-spos.z, 0.0)/transition_domain.z;
+				shadow += pcfShadow(shadowMap2, lpos, 0.5, pos_screen)*w;
+				weight += w;
+			}
+
+			if (spos.z < near_split.x && spos.z > far_split.y)
+			{
+				lpos = shadow_matrix[1]*spos;
+				
+				float w = 1.0;
+				w -= max(spos.z-far_split.x, 0.0)/transition_domain.x;
+				w -= max(near_split.y-spos.z, 0.0)/transition_domain.y;
+				shadow += pcfShadow(shadowMap1, lpos, 0.75, pos_screen)*w;
+				weight += w;
+			}
+
+			if (spos.z > far_split.x)
+			{
+				lpos = shadow_matrix[0]*spos;
+								
+				float w = 1.0;
+				w -= max(near_split.x-spos.z, 0.0)/transition_domain.x;
+				
+				shadow += pcfShadow(shadowMap0, lpos, 1.0, pos_screen)*w;
+				weight += w;
+			}
+		
+
+			shadow /= weight;
+
+			// take the most-shadowed value out of these two:
+			//  * the blurred sun shadow in the light (shadow) map
+			//  * an unblurred dot product between the sun and this norm
+			// the goal is to err on the side of most-shadow to fill-in shadow holes and reduce artifacting
+			shadow = min(shadow, dp_directional_light);
+			
+			//lpos.xy /= lpos.w*32.0;
+			//if (fract(lpos.x) < 0.1 || fract(lpos.y) < 0.1)
+			//{
+			//	shadow = 0.0;
+			//}
+			
+		}
+	}
+	else
+	{
+		// more distant than the shadow map covers
+		shadow = 1.0;
+	}
+	
+	frag_color[0] = shadow;
+	frag_color[1] = calcAmbientOcclusion(pos, norm);
+	
+	spos = vec4(shadow_pos+norm*spot_shadow_offset, 1.0);
+	
+	//spotlight shadow 1
+	vec4 lpos = shadow_matrix[4]*spos;
+	frag_color[2] = pcfSpotShadow(shadowMap4, lpos, 0.8, pos_screen);
+	
+	//spotlight shadow 2
+	lpos = shadow_matrix[5]*spos;
+	frag_color[3] = pcfSpotShadow(shadowMap5, lpos, 0.8, pos_screen);
+
+	//frag_color.rgb = pos.xyz;
+	//frag_color.b = shadow;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightV.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightV.glsl
new file mode 100644
index 0000000000..bc5eb5181d
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightV.glsl
@@ -0,0 +1,41 @@
+/** 
+ * @file sunLightV.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 mat4 modelview_projection_matrix;
+
+ATTRIBUTE vec3 position;
+
+VARYING vec2 vary_fragcoord;
+
+uniform vec2 screen_res;
+
+void main()
+{
+	//transform vertex
+	vec4 pos = modelview_projection_matrix * vec4(position.xyz, 1.0);
+	gl_Position = pos; 
+	
+	vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;	
+}
diff --git a/indra/newview/featuretable.txt b/indra/newview/featuretable.txt
index e99b94f150..1d6fb82d10 100644
--- a/indra/newview/featuretable.txt
+++ b/indra/newview/featuretable.txt
@@ -66,6 +66,7 @@ RenderCompressTextures		1	1
 RenderShaderLightingMaxLevel	1	3
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 1
 RenderShadowDetail			1	2
 RenderUseStreamVBO			1	1
 RenderFSAASamples			1	16
@@ -98,6 +99,7 @@ VertexShaderEnable			1	0
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -129,6 +131,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -159,6 +162,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -189,6 +193,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -219,6 +224,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -249,6 +255,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -279,6 +286,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	2
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -309,6 +317,7 @@ WindLightUseAtmosShaders	1	1
 WLSkyDetail					1	128
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 1
 RenderShadowDetail			1	2
 RenderFSAASamples			1	2
 
@@ -320,6 +329,7 @@ RenderVBOEnable				1	0
 RenderShadowDetail			1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 
 //
 // Class 0 Hardware (just old)
@@ -375,6 +385,7 @@ WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
 RenderShadowDetail			0	0
+RenderUseAdvancedAtmospherics 0 0
 
 //
 // No Vertex Shaders available
@@ -388,6 +399,7 @@ WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
 RenderShadowDetail			0	0
+RenderUseAdvancedAtmospherics 0 0
 
 //
 // GL_ARB_map_buffer_range exists
diff --git a/indra/newview/featuretable_linux.txt b/indra/newview/featuretable_linux.txt
index 801a622e93..18feae162f 100644
--- a/indra/newview/featuretable_linux.txt
+++ b/indra/newview/featuretable_linux.txt
@@ -66,6 +66,7 @@ RenderCompressTextures		1	1
 RenderShaderLightingMaxLevel	1	3
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 1
 RenderShadowDetail			1	2
 RenderFSAASamples			1	16
 RenderMaxTextureIndex		1	16
@@ -97,6 +98,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -128,6 +130,7 @@ VertexShaderEnable			1	0
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -158,6 +161,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -188,6 +192,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -217,6 +222,7 @@ RenderVolumeLODFactor		1	1.125
 VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
+RenderUseAdvancedAtmospherics 1 0
 RenderDeferredSSAO			1	0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
@@ -248,6 +254,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -278,6 +285,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	2
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -308,6 +316,7 @@ WindLightUseAtmosShaders	1	1
 WLSkyDetail					1	128
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 1
 RenderShadowDetail			1	2
 RenderFSAASamples			1	2
 
@@ -319,6 +328,7 @@ RenderVBOEnable				1	0
 RenderShadowDetail			1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 
 //
 // Class 0 Hardware (just old)
@@ -373,6 +383,7 @@ VertexShaderEnable			0	0
 WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
+RenderUseAdvancedAtmospherics 0 0
 RenderShadowDetail			0	0
 
 //
@@ -386,6 +397,7 @@ VertexShaderEnable			0	0
 WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
+RenderUseAdvancedAtmospherics 0 0
 RenderShadowDetail			0	0
 
 //
@@ -413,6 +425,7 @@ RenderReflectionDetail		0	0
 WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
+RenderUseAdvancedAtmospherics 0 0
 RenderShadowDetail			0	0
 
 //
diff --git a/indra/newview/featuretable_mac.txt b/indra/newview/featuretable_mac.txt
index 1f891ee4d7..3f5edede98 100644
--- a/indra/newview/featuretable_mac.txt
+++ b/indra/newview/featuretable_mac.txt
@@ -66,6 +66,7 @@ RenderCompressTextures		1	1
 RenderShaderLightingMaxLevel	1	3
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 1
 RenderShadowDetail			1	2
 RenderUseStreamVBO			1	1
 RenderFSAASamples			1	16
@@ -98,6 +99,7 @@ VertexShaderEnable			1	0
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -129,6 +131,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -159,6 +162,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	0
@@ -189,6 +193,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -219,6 +224,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -249,6 +255,7 @@ VertexShaderEnable			1	1
 WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 0
 RenderShadowDetail			1	0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
@@ -280,6 +287,7 @@ WindLightUseAtmosShaders	1	1
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
 RenderShadowDetail			1	2
+RenderUseAdvancedAtmospherics 1 0
 WLSkyDetail					1	48
 RenderFSAASamples			1	2
 
@@ -309,6 +317,7 @@ WindLightUseAtmosShaders	1	1
 WLSkyDetail					1	128
 RenderDeferred				1	1
 RenderDeferredSSAO			1	1
+RenderUseAdvancedAtmospherics 1 1
 RenderShadowDetail			1	2
 RenderFSAASamples			1	2
 
@@ -320,6 +329,7 @@ RenderVBOEnable				1	0
 RenderShadowDetail			1	0
 RenderDeferred				1	0
 RenderDeferredSSAO			1	0
+RenderUseAdvancedAtmospherics 1 0
 
 //
 // Class 0 Hardware (just old)
@@ -368,6 +378,7 @@ VertexShaderEnable			0	0
 WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
+RenderUseAdvancedAtmospherics 0 0
 RenderShadowDetail			0	0
 
 //
@@ -381,6 +392,7 @@ VertexShaderEnable			0	0
 WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
+RenderUseAdvancedAtmospherics 0 0
 RenderShadowDetail			0	0
 
 //
@@ -407,6 +419,7 @@ RenderReflectionDetail		0	0
 WindLightUseAtmosShaders	0	0
 RenderDeferred				0	0
 RenderDeferredSSAO			0	0
+RenderUseAdvancedAtmospherics 0 0
 RenderShadowDetail			0	0
 
 //
diff --git a/indra/newview/lldensityctrl.cpp b/indra/newview/lldensityctrl.cpp
new file mode 100644
index 0000000000..298a309e7c
--- /dev/null
+++ b/indra/newview/lldensityctrl.cpp
@@ -0,0 +1,225 @@
+/**
+* @file lldensityctrl.cpp
+* @brief Control for specifying density over a height range for sky settings.
+*
+* $LicenseInfo:firstyear=2011&license=viewerlgpl$
+* Second Life Viewer Source Code
+* Copyright (C) 2011, Linden Research, Inc.
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation;
+* version 2.1 of the License only.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*
+* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+* $/LicenseInfo$
+*/
+
+#include "llviewerprecompiledheaders.h"
+
+#include "lldensityctrl.h"
+
+#include "llslider.h"
+#include "llsliderctrl.h"
+#include "llsettingssky.h"
+
+static LLDefaultChildRegistry::Register<LLDensityCtrl> register_density_control("densityctrl");
+
+const std::string LLDensityCtrl::DENSITY_RAYLEIGH("density_rayleigh");
+const std::string LLDensityCtrl::DENSITY_MIE("density_mie");
+const std::string LLDensityCtrl::DENSITY_ABSORPTION("density_absorption");
+
+namespace
+{   
+    const std::string   FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL("level_exponential");
+    const std::string   FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL_SCALE("exponential_scale");
+    const std::string   FIELD_SKY_DENSITY_PROFILE_LINEAR("level_linear");
+    const std::string   FIELD_SKY_DENSITY_PROFILE_CONSTANT("level_constant");
+    const std::string   FIELD_SKY_DENSITY_MAX_ALTITUDE("max_altitude");
+    const std::string   FIELD_SKY_DENSITY_ANISO_FACTOR("aniso_factor");
+    const std::string   FIELD_SKY_DENSITY_ANISO_FACTOR_LABEL("aniso_factor_label");
+}
+
+const std::string& LLDensityCtrl::NameForDensityProfileType(DensityProfileType t)
+{
+    switch (t)
+    {
+        case Rayleigh:   return DENSITY_RAYLEIGH;
+        case Mie:        return DENSITY_MIE;
+        case Absorption: return DENSITY_ABSORPTION;
+        default:
+            break;
+    }
+
+    llassert(false);
+    return DENSITY_RAYLEIGH;
+}
+
+LLDensityCtrl::Params::Params()
+: image_density_feedback("image_density_feedback")
+, lbl_exponential("label_exponential")
+, lbl_exponential_scale("label_exponential_scale")
+, lbl_linear("label_linear")
+, lbl_constant("label_constant")
+, lbl_max_altitude("label_max_altitude")
+, lbl_aniso_factor("label_aniso_factor")
+, profile_type(LLDensityCtrl::Rayleigh)
+{
+}
+
+LLDensityCtrl::LLDensityCtrl(const Params& params)
+: mProfileType(params.profile_type)
+, mImgDensityFeedback(params.image_density_feedback)
+{
+
+}
+
+LLSD LLDensityCtrl::getProfileConfig()
+{
+    LLSD config;
+    switch (mProfileType)
+    {
+        case Rayleigh:   return mSkySettings->getRayleighConfigs();
+        case Mie:        return mSkySettings->getMieConfigs();
+        case Absorption: return mSkySettings->getAbsorptionConfigs();
+        default:
+            break;
+    }
+    llassert(false);
+    return config;
+}
+
+BOOL LLDensityCtrl::postBuild()
+{
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onExponentialChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL_SCALE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onExponentialScaleFactorChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_LINEAR)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onLinearChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_CONSTANT)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onConstantChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MAX_ALTITUDE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onMaxAltitudeChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ANISO_FACTOR)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onAnisoFactorChanged(); });
+
+    if (mProfileType != Mie)
+    {
+        getChild<LLUICtrl>(FIELD_SKY_DENSITY_ANISO_FACTOR_LABEL)->setValue(false);
+        getChild<LLUICtrl>(FIELD_SKY_DENSITY_ANISO_FACTOR)->setVisible(false);
+    }
+
+    return TRUE;
+}
+
+void LLDensityCtrl::setEnabled(BOOL enabled)
+{
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL_SCALE)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_LINEAR)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_PROFILE_CONSTANT)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MAX_ALTITUDE)->setEnabled(enabled);
+
+    if (mProfileType == Mie)
+    {
+        getChild<LLUICtrl>(FIELD_SKY_DENSITY_ANISO_FACTOR)->setEnabled(enabled);
+    }
+}
+
+void LLDensityCtrl::refresh()
+{
+    if (!mSkySettings)
+    {
+        setAllChildrenEnabled(FALSE);
+        setEnabled(FALSE);
+        return;
+    }
+
+    setEnabled(TRUE);
+    setAllChildrenEnabled(TRUE);
+
+    LLSD config = getProfileConfig();
+
+    getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL)->setValue(config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM]);
+    getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL_SCALE)->setValue(config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR]);
+    getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_LINEAR)->setValue(config[LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM]);
+    getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_CONSTANT)->setValue(config[LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM]);
+    getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MAX_ALTITUDE)->setValue(config[LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH]);
+
+    if (mProfileType == Mie)
+    {        
+        getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_ANISO_FACTOR)->setValue(config[LLSettingsSky::SETTING_MIE_ANISOTROPY_FACTOR]);
+    }
+}
+
+void LLDensityCtrl::updateProfile()
+{
+    F32 exponential_term  = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL)->getValueF32();
+    F32 exponential_scale = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_EXPONENTIAL_SCALE)->getValueF32();
+    F32 linear_term       = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_LINEAR)->getValueF32();
+    F32 constant_term     = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_PROFILE_CONSTANT)->getValueF32();
+    F32 max_alt           = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MAX_ALTITUDE)->getValueF32();
+    F32 aniso_factor      = 0.0f;
+
+    if (mProfileType == Mie)
+    {
+        aniso_factor = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_ANISO_FACTOR)->getValueF32();
+    }
+
+    LLSD profile = LLSettingsSky::createSingleLayerDensityProfile(max_alt, exponential_term, exponential_scale, linear_term, constant_term, aniso_factor);
+
+    switch (mProfileType)
+    {
+        case Rayleigh: mSkySettings->setRayleighConfigs(profile); break;
+        case Mie: mSkySettings->setMieConfigs(profile); break;
+        case Absorption: mSkySettings->setAbsorptionConfigs(profile); break;
+        default:
+            break;
+    }
+}
+
+void LLDensityCtrl::onExponentialChanged()
+{
+    updateProfile();
+    updatePreview();
+}
+
+void LLDensityCtrl::onExponentialScaleFactorChanged()
+{
+    updateProfile();
+    updatePreview();
+}
+
+void LLDensityCtrl::onLinearChanged()
+{
+    updateProfile();
+    updatePreview();
+}
+
+void LLDensityCtrl::onConstantChanged()
+{
+    updateProfile();
+    updatePreview();
+}
+
+void LLDensityCtrl::onMaxAltitudeChanged()
+{
+    updateProfile();
+    updatePreview();
+}
+
+void LLDensityCtrl::onAnisoFactorChanged()
+{
+    updateProfile();
+}
+
+void LLDensityCtrl::updatePreview()
+{
+    // AdvancedAtmospherics TODO
+    // Generate image according to current density profile
+}
+
diff --git a/indra/newview/lldensityctrl.h b/indra/newview/lldensityctrl.h
new file mode 100644
index 0000000000..789022803c
--- /dev/null
+++ b/indra/newview/lldensityctrl.h
@@ -0,0 +1,104 @@
+/**
+* @file lldensityctrl.h
+* @brief Control for specifying density over a height range for sky settings.
+*
+* $LicenseInfo:firstyear=2011&license=viewerlgpl$
+* Second Life Viewer Source Code
+* Copyright (C) 2011, Linden Research, Inc.
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation;
+* version 2.1 of the License only.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*
+* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+* $/LicenseInfo$
+*/
+
+#ifndef LLDENSITY_CTRL_H
+#define LLDENSITY_CTRL_H
+
+#include "lluictrl.h"
+#include "llsettingssky.h"
+#include "lltextbox.h"
+#include "llsliderctrl.h"
+
+class LLDensityCtrl : public LLUICtrl
+{
+public:
+    static const std::string DENSITY_RAYLEIGH;
+    static const std::string DENSITY_MIE;
+    static const std::string DENSITY_ABSORPTION;
+
+    // Type of density profile this tab is updating
+    enum DensityProfileType
+    {
+        Rayleigh,
+        Mie,
+        Absorption
+    };
+
+    static const std::string& NameForDensityProfileType(DensityProfileType t);
+
+    struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
+    {
+        Optional<LLTextBox::Params>         lbl_exponential,
+            lbl_exponential_scale,
+            lbl_linear,
+            lbl_constant,
+            lbl_max_altitude,
+            lbl_aniso_factor;
+
+        Optional<LLSliderCtrl::Params> exponential_slider,
+        exponential_scale_slider,
+        linear_slider,
+        constant_slider,
+        aniso_factor_slider;
+
+        Optional<LLUIImage*> image_density_feedback;
+
+        DensityProfileType profile_type;
+        Params();
+    };
+
+    virtual BOOL	        postBuild() override;
+    virtual void	        setEnabled(BOOL enabled) override;
+
+    void setProfileType(DensityProfileType t) { mProfileType = t; }
+
+    void refresh();
+    void updateProfile();
+
+    LLSettingsSky::ptr_t    getSky() const                                          { return mSkySettings; }
+    void                    setSky(const LLSettingsSky::ptr_t &sky)                 { mSkySettings = sky; refresh(); }
+
+protected:
+    friend class LLUICtrlFactory;
+    LLDensityCtrl(const Params&);
+
+    LLSD getProfileConfig();
+    void updatePreview();
+
+private:
+    void onExponentialChanged();
+    void onExponentialScaleFactorChanged();
+    void onLinearChanged();
+    void onConstantChanged();
+    void onMaxAltitudeChanged();
+    void onAnisoFactorChanged();
+
+    DensityProfileType    mProfileType = Rayleigh;
+    LLUIImage*            mImgDensityFeedback = nullptr;
+    LLSettingsSky::ptr_t  mSkySettings;
+};
+
+#endif LLDENSITY_CTRL_H
diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp
index 26454d2bd1..e7929e0bbf 100644
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -94,7 +94,7 @@ void LLDrawPoolWLSky::beginRenderPass( S32 pass )
 void LLDrawPoolWLSky::endRenderPass( S32 pass )
 {
     sky_shader   = nullptr;
-	cloud_shader = nullptr;
+    cloud_shader = nullptr;
     sun_shader   = nullptr;
     moon_shader  = nullptr;
 }
@@ -118,7 +118,7 @@ void LLDrawPoolWLSky::beginDeferredPass(S32 pass)
 void LLDrawPoolWLSky::endDeferredPass(S32 pass)
 {
     sky_shader   = nullptr;
-	cloud_shader = nullptr;
+    cloud_shader = nullptr;
     sun_shader   = nullptr;
     moon_shader  = nullptr;
 }
@@ -163,7 +163,7 @@ void LLDrawPoolWLSky::renderDome(const LLVector3& camPosLocal, F32 camHeightLoca
 
 void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 camHeightLocal) const
 {
-    if (gPipeline.useAdvancedAtmospherics() && gPipeline.canUseWindLightShaders() && gAtmosphere)
+    if (gPipeline.useAdvancedAtmospherics() && gPipeline.canUseWindLightShaders())
     {
 		sky_shader->bind();
 
@@ -174,8 +174,8 @@ void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 ca
         sky_shader->bindTexture(LLShaderMgr::ILLUMINANCE_TEX, gAtmosphere->getIlluminance());
 
         LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
-        LLVector4 sun_dir = LLEnvironment::instance().getClampedSunNorm();
-        LLVector4 moon_dir = LLEnvironment::instance().getClampedMoonNorm();
+        LLVector3 sun_dir  = LLEnvironment::instance().getSunDirection();
+        LLVector3 moon_dir = LLEnvironment::instance().getMoonDirection();
 
         F32 sunSize = (float)cosf(psky->getSunArcRadians());
         sky_shader->uniform1f(LLShaderMgr::SUN_SIZE, sunSize);
@@ -189,17 +189,10 @@ void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 ca
 
 	    sky_shader->uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, FALSE, inv_proj.m);
 
-        // clouds are rendered along with sky in adv atmo
-        if (gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS) && gSky.mVOSkyp->getCloudNoiseTex())
-        {
-            sky_shader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP, gSky.mVOSkyp->getCloudNoiseTex());
-            sky_shader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP_NEXT, gSky.mVOSkyp->getCloudNoiseTexNext());
-        }
-
         sky_shader->uniform3f(sCamPosLocal, camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
 
         renderFsSky(camPosLocal, camHeightLocal, sky_shader);
-
+        
 		sky_shader->unbind();
 	}
 }
@@ -357,10 +350,11 @@ void LLDrawPoolWLSky::renderSkyClouds(const LLVector3& camPosLocal, F32 camHeigh
 		LLGLEnable blend(GL_BLEND);
 		gGL.setSceneBlendType(LLRender::BT_ALPHA);
 		
-		gGL.getTexUnit(0)->bind(gSky.mVOSkyp->getCloudNoiseTex());
-        gGL.getTexUnit(1)->bind(gSky.mVOSkyp->getCloudNoiseTexNext());
-
 		cloud_shader->bind();
+
+        cloud_shader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP, gSky.mVOSkyp->getCloudNoiseTex());
+        cloud_shader->bindTexture(LLShaderMgr::CLOUD_NOISE_MAP_NEXT, gSky.mVOSkyp->getCloudNoiseTexNext());
+
         F32 blend_factor = LLEnvironment::instance().getCurrentSky()->getBlendFactor();
         cloud_shader->uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
 
@@ -505,21 +499,22 @@ void LLDrawPoolWLSky::renderDeferred(S32 pass)
     if (gPipeline.canUseWindLightShaders())
     {
         {
-            // Disable depth-test for sky, but re-enable depth writes for the cloud
-            // rendering below so the cloud shader can write out depth for the stars to test against
             LLGLDepthTest depth(GL_TRUE, GL_FALSE);
+
             if (gPipeline.useAdvancedAtmospherics())
             {
+                //LLGLSquashToFarClip far_clip(get_current_projection());
 	            renderSkyHazeDeferred(origin, camHeightLocal);
             }
             else
             {
+                // Disable depth-test for sky, but re-enable depth writes for the cloud
+                // rendering below so the cloud shader can write out depth for the stars to test against            
                 renderSkyHaze(origin, camHeightLocal);   
-		        
+		    
             }
             renderHeavenlyBodies();
         }
-
         renderSkyClouds(origin, camHeightLocal);
     }    
     gGL.setColorMask(true, true);
diff --git a/indra/newview/llenvironment.cpp b/indra/newview/llenvironment.cpp
index 3a1aec6319..4b60ed4e68 100644
--- a/indra/newview/llenvironment.cpp
+++ b/indra/newview/llenvironment.cpp
@@ -358,6 +358,7 @@ void LLEnvironment::getAtmosphericModelSettings(AtmosphericModelSettings& settin
         layer.width             = layerConfig[LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH].asReal();
         settingsOut.m_mieProfile.push_back(layer);
     }
+    settingsOut.m_mieAnisotropy = psky->getMieAnisotropy();
 
     LLSD absorption = psky->getAbsorptionConfigs();
     settingsOut.m_absorptionProfile.clear();
diff --git a/indra/newview/llfloatereditextdaycycle.cpp b/indra/newview/llfloatereditextdaycycle.cpp
index 166d53fc74..4cab1160c0 100644
--- a/indra/newview/llfloatereditextdaycycle.cpp
+++ b/indra/newview/llfloatereditextdaycycle.cpp
@@ -62,6 +62,8 @@
 #include "llenvironment.h"
 #include "lltrans.h"
 
+extern LLControlGroup gSavedSettings;
+
 //=========================================================================
 namespace {
     const std::string track_tabs[] = {
@@ -197,9 +199,33 @@ BOOL LLFloaterEditExtDayCycle::postBuild()
     LLTabContainer* tab_container = mSkyTabLayoutContainer->getChild<LLTabContainer>("sky_tabs"); 
     S32 tab_count = tab_container->getTabCount();
 
+    LLSettingsEditPanel *panel = nullptr;
+
+    // Add or remove density tab as necessary
+    // Must be before operation on all tabs below
+    if (gSavedSettings.getBOOL("RenderUseAdvancedAtmospherics"))
+    {
+        panel = dynamic_cast<LLPanelSettingsSky*>(tab_container->getChildView("panel_settings_sky_density"));
+        if (!panel)
+        {
+            panel = new LLPanelSettingsSkyDensityTab;
+            panel->buildFromFile("panel_settings_sky_density.xml");
+            tab_container->addTabPanel(LLTabContainer::TabPanelParams().panel(panel).select_tab(false));
+        }
+    }
+    else
+    {
+        panel = dynamic_cast<LLPanelSettingsSky*>(tab_container->getChildView("panel_settings_sky_density"));
+        if (panel)
+        {
+            tab_container->removeTabPanel(panel);
+        }
+        delete panel;
+    }
+    
     for (S32 idx = 0; idx < tab_count; ++idx)
     {
-        LLSettingsEditPanel *panel = static_cast<LLSettingsEditPanel *>(tab_container->getPanelByIndex(idx));
+        panel = static_cast<LLSettingsEditPanel *>(tab_container->getPanelByIndex(idx));
         if (panel)
             panel->setOnDirtyFlagChanged([this](LLPanel *, bool val) { onPanelDirtyFlagChanged(val); });
     }
@@ -817,7 +843,7 @@ void LLFloaterEditExtDayCycle::updateWaterTabs(const LLSettingsWaterPtr_t &p_wat
 
 void LLFloaterEditExtDayCycle::updateSkyTabs(const LLSettingsSkyPtr_t &p_sky)
 {
-    LLView* tab_container = mSkyTabLayoutContainer->getChild<LLView>(TABS_SKYS); //can't extract panels directly, since they are in 'tuple'
+    LLTabContainer* tab_container = mSkyTabLayoutContainer->getChild<LLTabContainer>(TABS_SKYS); //can't extract panels directly, since they are in 'tuple'
 
     LLPanelSettingsSky* panel;
     panel = dynamic_cast<LLPanelSettingsSky*>(tab_container->getChildView("atmosphere_panel"));
@@ -835,6 +861,29 @@ void LLFloaterEditExtDayCycle::updateSkyTabs(const LLSettingsSkyPtr_t &p_sky)
     {
         panel->setSky(p_sky);
     }
+
+    if (gSavedSettings.getBOOL("RenderUseAdvancedAtmospherics"))
+    {
+        panel = dynamic_cast<LLPanelSettingsSky*>(tab_container->getChildView("panel_settings_sky_density"));
+        if (!panel)
+        {
+            panel = new LLPanelSettingsSkyDensityTab;
+            panel->buildFromFile("panel_settings_sky_density.xml");
+            panel->setOnDirtyFlagChanged([this](LLPanel *, bool value) { onPanelDirtyFlagChanged(value); });
+            tab_container->addTabPanel(LLTabContainer::TabPanelParams().panel(panel).select_tab(false));
+        }
+        panel->setSky(std::static_pointer_cast<LLSettingsSky>(p_sky));
+    }
+    else
+    {
+        panel = dynamic_cast<LLPanelSettingsSky*>(tab_container->getChildView("panel_settings_sky_density"));
+        if (panel)
+        {
+            tab_container->removeTabPanel(panel);
+        }
+        delete panel;
+    }
+
 }
 
 void LLFloaterEditExtDayCycle::updateButtons()
diff --git a/indra/newview/llfloaterfixedenvironment.cpp b/indra/newview/llfloaterfixedenvironment.cpp
index 47b07a8315..09a05eb7e2 100644
--- a/indra/newview/llfloaterfixedenvironment.cpp
+++ b/indra/newview/llfloaterfixedenvironment.cpp
@@ -55,6 +55,8 @@
 #include "llsettingsvo.h"
 #include "llinventorymodel.h"
 
+extern LLControlGroup gSavedSettings;
+
 namespace
 {
     const std::string FIELD_SETTINGS_NAME("settings_name");
@@ -634,6 +636,14 @@ BOOL LLFloaterFixedEnvironmentSky::postBuild()
     panel->setOnDirtyFlagChanged([this](LLPanel *, bool value) { onPanelDirtyFlagChanged(value); });
     mTab->addTabPanel(LLTabContainer::TabPanelParams().panel(panel).select_tab(false));
 
+    if (gSavedSettings.getBOOL("RenderUseAdvancedAtmospherics"))
+    {
+        panel = new LLPanelSettingsSkyDensityTab;
+        panel->buildFromFile("panel_settings_sky_density.xml");
+        panel->setSky(std::static_pointer_cast<LLSettingsSky>(mSettings));
+        panel->setOnDirtyFlagChanged([this](LLPanel *, bool value) { onPanelDirtyFlagChanged(value); });
+        mTab->addTabPanel(LLTabContainer::TabPanelParams().panel(panel).select_tab(false));
+    }
     return TRUE;
 }
 
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 4ce35643b1..2a22dd461a 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -811,6 +811,17 @@ void LLFloaterPreferenceGraphicsAdvanced::onVertexShaderEnable()
 	refreshEnabledGraphics();
 }
 
+void LLFloaterPreferenceGraphicsAdvanced::onAdvancedAtmosphericsEnable()
+{
+	LLFloaterPreference* instance = LLFloaterReg::findTypedInstance<LLFloaterPreference>("preferences");
+	if (instance)
+	{
+		instance->refresh();
+	}
+
+	refreshEnabledGraphics();
+}
+
 void LLFloaterPreferenceGraphicsAdvanced::refreshEnabledGraphics()
 {
 	refreshEnabledState();
@@ -1351,6 +1362,13 @@ void LLFloaterPreferenceGraphicsAdvanced::refreshEnabledState()
 	ctrl_ssao->setEnabled(enabled);
 	ctrl_dof->setEnabled(enabled);
 
+#if USE_ADVANCED_ATMOSPHERICS
+    LLCheckBoxCtrl* ctrl_advanced_atmo = getChild<LLCheckBoxCtrl>("UseAdvancedAtmo");
+
+    bool advanced_atmo_enabled = enabled && LLFeatureManager::getInstance()->isFeatureAvailable("RenderUseAdvancedAtmospherics");
+    ctrl_advanced_atmo->setEnabled(advanced_atmo_enabled);
+#endif
+
 	enabled = enabled && LLFeatureManager::getInstance()->isFeatureAvailable("RenderShadowDetail");
 
 	ctrl_shadow->setEnabled(enabled);
@@ -2714,7 +2732,10 @@ void LLPanelPreferenceGraphics::setHardwareDefaults()
 LLFloaterPreferenceGraphicsAdvanced::LLFloaterPreferenceGraphicsAdvanced(const LLSD& key)
 	: LLFloater(key)
 {
-	mCommitCallbackRegistrar.add("Pref.VertexShaderEnable",		boost::bind(&LLFloaterPreferenceGraphicsAdvanced::onVertexShaderEnable, this));
+	mCommitCallbackRegistrar.add("Pref.VertexShaderEnable",		       boost::bind(&LLFloaterPreferenceGraphicsAdvanced::onVertexShaderEnable, this));
+#if USE_ADVANCED_ATMOSPHERICS
+    mCommitCallbackRegistrar.add("Pref.AdvancedAtmosphericsEnable",	   boost::bind(&LLFloaterPreferenceGraphicsAdvanced::onAdvancedAtmosphericsEnable, this));
+#endif
 	mCommitCallbackRegistrar.add("Pref.UpdateIndirectMaxNonImpostors", boost::bind(&LLFloaterPreferenceGraphicsAdvanced::updateMaxNonImpostors,this));
 	mCommitCallbackRegistrar.add("Pref.UpdateIndirectMaxComplexity",   boost::bind(&LLFloaterPreferenceGraphicsAdvanced::updateMaxComplexity,this));
 }
diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h
index 8339a18296..973ca25c37 100644
--- a/indra/newview/llfloaterpreference.h
+++ b/indra/newview/llfloaterpreference.h
@@ -295,6 +295,7 @@ class LLFloaterPreferenceGraphicsAdvanced : public LLFloater
 	void refresh();
 	// callback for when client turns on shaders
 	void onVertexShaderEnable();
+    void onAdvancedAtmosphericsEnable();
 	LOG_CLASS(LLFloaterPreferenceGraphicsAdvanced);
 };
 
diff --git a/indra/newview/llpaneleditsky.cpp b/indra/newview/llpaneleditsky.cpp
index 59dc7c8a2d..1b41529795 100644
--- a/indra/newview/llpaneleditsky.cpp
+++ b/indra/newview/llpaneleditsky.cpp
@@ -29,10 +29,13 @@
 #include "llpaneleditsky.h"
 
 #include "llslider.h"
+#include "llsliderctrl.h"
 #include "lltexturectrl.h"
 #include "llcolorswatch.h"
 #include "llvirtualtrackball.h"
-
+#include "llsettingssky.h"
+#include "llenvironment.h"
+#include "llatmosphere.h"
 
 namespace
 {   
@@ -70,6 +73,25 @@ namespace
     const std::string   FIELD_SKY_MOON_IMAGE("moon_image");
     const std::string   FIELD_SKY_MOON_SCALE("moon_scale");
 
+    const std::string   FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL("rayleigh_exponential");
+    const std::string   FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL_SCALE("rayleigh_exponential_scale");
+    const std::string   FIELD_SKY_DENSITY_RAYLEIGH_LINEAR("rayleigh_linear");
+    const std::string   FIELD_SKY_DENSITY_RAYLEIGH_CONSTANT("rayleigh_constant");
+    const std::string   FIELD_SKY_DENSITY_RAYLEIGH_MAX_ALTITUDE("rayleigh_max_altitude");
+
+    const std::string   FIELD_SKY_DENSITY_MIE_EXPONENTIAL("mie_exponential");
+    const std::string   FIELD_SKY_DENSITY_MIE_EXPONENTIAL_SCALE("mie_exponential_scale");
+    const std::string   FIELD_SKY_DENSITY_MIE_LINEAR("mie_linear");
+    const std::string   FIELD_SKY_DENSITY_MIE_CONSTANT("mie_constant");
+    const std::string   FIELD_SKY_DENSITY_MIE_ANISO("mie_aniso_factor");
+    const std::string   FIELD_SKY_DENSITY_MIE_MAX_ALTITUDE("mie_max_altitude");
+
+    const std::string   FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL("absorption_exponential");
+    const std::string   FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL_SCALE("absorption_exponential_scale");
+    const std::string   FIELD_SKY_DENSITY_ABSORPTION_LINEAR("absorption_linear");
+    const std::string   FIELD_SKY_DENSITY_ABSORPTION_CONSTANT("absorption_constant");
+    const std::string   FIELD_SKY_DENSITY_ABSORPTION_MAX_ALTITUDE("absorption_max_altitude");
+
     const F32 SLIDER_SCALE_SUN_AMBIENT(3.0f);
     const F32 SLIDER_SCALE_BLUE_HORIZON_DENSITY(2.0f);
     const F32 SLIDER_SCALE_GLOW_R(20.0f);
@@ -81,6 +103,7 @@ namespace
 static LLPanelInjector<LLPanelSettingsSkyAtmosTab> t_settings_atmos("panel_settings_atmos");
 static LLPanelInjector<LLPanelSettingsSkyCloudTab> t_settings_cloud("panel_settings_cloud");
 static LLPanelInjector<LLPanelSettingsSkySunMoonTab> t_settings_sunmoon("panel_settings_sunmoon");
+static LLPanelInjector<LLPanelSettingsSkyDensityTab> t_settings_density("panel_settings_density");
 
 //==========================================================================
 LLPanelSettingsSky::LLPanelSettingsSky() :
@@ -489,3 +512,240 @@ void LLPanelSettingsSkySunMoonTab::onMoonScaleChanged()
     mSkySettings->update();
     setIsDirty();
 }
+
+ 
+LLPanelSettingsSkyDensityTab::LLPanelSettingsSkyDensityTab()
+{    
+}
+
+BOOL LLPanelSettingsSkyDensityTab::postBuild()
+{
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onRayleighExponentialChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL_SCALE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onRayleighExponentialScaleChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_LINEAR)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onRayleighLinearChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_CONSTANT)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onRayleighConstantChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_MAX_ALTITUDE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onRayleighMaxAltitudeChanged(); });
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onMieExponentialChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL_SCALE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onMieExponentialScaleChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_LINEAR)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onMieLinearChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_CONSTANT)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onMieConstantChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_ANISO)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onMieAnisoFactorChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_MAX_ALTITUDE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onMieMaxAltitudeChanged(); });
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onAbsorptionExponentialChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL_SCALE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onAbsorptionExponentialScaleChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_LINEAR)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onAbsorptionLinearChanged(); });
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_CONSTANT)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onAbsorptionConstantChanged(); });
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_MAX_ALTITUDE)->setCommitCallback([this](LLUICtrl *, const LLSD &) { onAbsorptionMaxAltitudeChanged(); });
+
+    refresh();
+    return TRUE;
+}
+
+void LLPanelSettingsSkyDensityTab::setEnabled(BOOL enabled)
+{
+    LLPanelSettingsSky::setEnabled(enabled);
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL_SCALE)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_LINEAR)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_CONSTANT)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_MAX_ALTITUDE)->setEnabled(enabled);
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL_SCALE)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_LINEAR)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_CONSTANT)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_ANISO)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_MAX_ALTITUDE)->setEnabled(enabled);
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL_SCALE)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_LINEAR)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_CONSTANT)->setEnabled(enabled);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_MAX_ALTITUDE)->setEnabled(enabled);
+}
+
+void LLPanelSettingsSkyDensityTab::refresh()
+{
+    if (!mSkySettings)
+    {
+        setAllChildrenEnabled(FALSE);
+        setEnabled(FALSE);
+        return;
+    }
+
+    setEnabled(TRUE);
+    setAllChildrenEnabled(TRUE);
+
+    // Get first (only) profile layer of each type for editing
+    LLSD rayleigh_config    = mSkySettings->getRayleighConfig();
+    LLSD mie_config         = mSkySettings->getMieConfig();
+    LLSD absorption_config  = mSkySettings->getAbsorptionConfig();
+
+    F32 rayleigh_exponential_term    = rayleigh_config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM].asReal();
+    F32 rayleigh_exponential_scale   = rayleigh_config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR].asReal();
+    F32 rayleigh_linear_term         = rayleigh_config[LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM].asReal();
+    F32 rayleigh_constant_term       = rayleigh_config[LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM].asReal();
+    F32 rayleigh_max_alt             = rayleigh_config[LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH].asReal();
+
+    F32 mie_exponential_term         = mie_config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM].asReal();
+    F32 mie_exponential_scale        = mie_config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR].asReal();
+    F32 mie_linear_term              = mie_config[LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM].asReal();
+    F32 mie_constant_term            = mie_config[LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM].asReal();
+    F32 mie_aniso_factor             = mie_config[LLSettingsSky::SETTING_MIE_ANISOTROPY_FACTOR].asReal();
+    F32 mie_max_alt                  = mie_config[LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH].asReal();
+
+    F32 absorption_exponential_term  = absorption_config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM].asReal();
+    F32 absorption_exponential_scale = absorption_config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR].asReal();
+    F32 absorption_linear_term       = absorption_config[LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM].asReal();
+    F32 absorption_constant_term     = absorption_config[LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM].asReal();
+    F32 absorption_max_alt           = absorption_config[LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH].asReal();
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL)->setValue(rayleigh_exponential_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL_SCALE)->setValue(rayleigh_exponential_scale);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_LINEAR)->setValue(rayleigh_linear_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_CONSTANT)->setValue(rayleigh_constant_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_RAYLEIGH_MAX_ALTITUDE)->setValue(rayleigh_max_alt);
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL)->setValue(mie_exponential_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL_SCALE)->setValue(mie_exponential_scale);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_LINEAR)->setValue(mie_linear_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_CONSTANT)->setValue(mie_constant_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_ANISO)->setValue(mie_aniso_factor);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_MIE_MAX_ALTITUDE)->setValue(mie_max_alt);
+
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL)->setValue(absorption_exponential_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL_SCALE)->setValue(absorption_exponential_scale);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_LINEAR)->setValue(absorption_linear_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_CONSTANT)->setValue(absorption_constant_term);
+    getChild<LLUICtrl>(FIELD_SKY_DENSITY_ABSORPTION_MAX_ALTITUDE)->setValue(absorption_max_alt);
+}
+
+void LLPanelSettingsSkyDensityTab::updateProfile()
+{
+    F32 rayleigh_exponential_term    = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL)->getValueF32();
+    F32 rayleigh_exponential_scale   = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_RAYLEIGH_EXPONENTIAL_SCALE)->getValueF32();
+    F32 rayleigh_linear_term         = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_RAYLEIGH_LINEAR)->getValueF32();
+    F32 rayleigh_constant_term       = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_RAYLEIGH_CONSTANT)->getValueF32();
+    F32 rayleigh_max_alt             = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_RAYLEIGH_MAX_ALTITUDE)->getValueF32();
+
+    F32 mie_exponential_term         = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL)->getValueF32();
+    F32 mie_exponential_scale        = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MIE_EXPONENTIAL_SCALE)->getValueF32();
+    F32 mie_linear_term              = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MIE_LINEAR)->getValueF32();
+    F32 mie_constant_term            = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MIE_CONSTANT)->getValueF32();
+    F32 mie_aniso_factor             = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MIE_ANISO)->getValueF32();
+    F32 mie_max_alt                  = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_MIE_MAX_ALTITUDE)->getValueF32();
+
+    F32 absorption_exponential_term  = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL)->getValueF32();
+    F32 absorption_exponential_scale = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_ABSORPTION_EXPONENTIAL_SCALE)->getValueF32();
+    F32 absorption_linear_term       = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_ABSORPTION_LINEAR)->getValueF32();
+    F32 absorption_constant_term     = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_ABSORPTION_CONSTANT)->getValueF32();
+    F32 absorption_max_alt           = getChild<LLSliderCtrl>(FIELD_SKY_DENSITY_ABSORPTION_MAX_ALTITUDE)->getValueF32();
+
+    LLSD rayleigh_config    = LLSettingsSky::createSingleLayerDensityProfile(rayleigh_max_alt, rayleigh_exponential_term, rayleigh_exponential_scale, rayleigh_linear_term, rayleigh_constant_term);
+    LLSD mie_config         = LLSettingsSky::createSingleLayerDensityProfile(mie_max_alt, mie_exponential_term, mie_exponential_scale, mie_linear_term, mie_constant_term, mie_aniso_factor);
+    LLSD absorption_layer   = LLSettingsSky::createSingleLayerDensityProfile(absorption_max_alt, absorption_exponential_term, absorption_exponential_scale, absorption_linear_term, absorption_constant_term);
+
+    static LLSD absorption_layer_ozone = LLSettingsSky::createDensityProfileLayer(0.0f, 0.0f, 0.0f, -1.0f / 15000.0f, 8.0f / 3.0f);
+
+    LLSD absorption_config;
+    absorption_config.append(absorption_layer);
+    absorption_config.append(absorption_layer_ozone);
+
+    mSkySettings->setRayleighConfigs(rayleigh_config);
+    mSkySettings->setMieConfigs(mie_config);
+    mSkySettings->setAbsorptionConfigs(absorption_config);
+
+    mSkySettings->update();
+    setIsDirty();
+
+    if (gAtmosphere)
+    {
+        AtmosphericModelSettings atmospheric_settings;
+        LLEnvironment::getAtmosphericModelSettings(atmospheric_settings, mSkySettings);
+        gAtmosphere->configureAtmosphericModel(atmospheric_settings);
+    }
+}
+
+void LLPanelSettingsSkyDensityTab::onRayleighExponentialChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onRayleighExponentialScaleChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onRayleighLinearChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onRayleighConstantChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onRayleighMaxAltitudeChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onMieExponentialChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onMieExponentialScaleChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onMieLinearChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onMieConstantChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onMieAnisoFactorChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onMieMaxAltitudeChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onAbsorptionExponentialChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onAbsorptionExponentialScaleChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onAbsorptionLinearChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onAbsorptionConstantChanged()
+{
+    updateProfile();
+}
+
+void LLPanelSettingsSkyDensityTab::onAbsorptionMaxAltitudeChanged()
+{
+    updateProfile();
+}
diff --git a/indra/newview/llpaneleditsky.h b/indra/newview/llpaneleditsky.h
index ae4f433955..b34271f610 100644
--- a/indra/newview/llpaneleditsky.h
+++ b/indra/newview/llpaneleditsky.h
@@ -29,7 +29,6 @@
 
 #include "llpanel.h"
 #include "llsettingssky.h"
-
 #include "llfloaterfixedenvironment.h"
 
 //=========================================================================
@@ -126,4 +125,41 @@ private:
     void                    onMoonScaleChanged();
     void                    onMoonImageChanged();
 };
+
+// single subtab of the density settings tab
+class LLPanelSettingsSkyDensityTab : public LLPanelSettingsSky
+{
+    LOG_CLASS(LLPanelSettingsSkyDensityTab);
+
+public:
+    LLPanelSettingsSkyDensityTab();
+
+    virtual BOOL postBuild() override;
+    virtual void setEnabled(BOOL enabled) override;
+
+protected:
+    virtual void refresh() override;
+
+    void onRayleighExponentialChanged();
+    void onRayleighExponentialScaleChanged();
+    void onRayleighLinearChanged();
+    void onRayleighConstantChanged();
+    void onRayleighMaxAltitudeChanged();
+
+    void onMieExponentialChanged();
+    void onMieExponentialScaleChanged();
+    void onMieLinearChanged();
+    void onMieConstantChanged();
+    void onMieAnisoFactorChanged();
+    void onMieMaxAltitudeChanged();
+
+    void onAbsorptionExponentialChanged();
+    void onAbsorptionExponentialScaleChanged();
+    void onAbsorptionLinearChanged();
+    void onAbsorptionConstantChanged();
+    void onAbsorptionMaxAltitudeChanged();
+
+    // update the settings for our profile type
+    void updateProfile();
+};
 #endif // LLPANEL_EDIT_SKY_H
diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index 88984d518a..ebc55fa0dd 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -410,6 +410,17 @@ static bool handleRenderDeferredChanged(const LLSD& newvalue)
 	return true;
 }
 
+static bool handleRenderUseAdvancedAtmosphericsChanged(const LLSD& newvalue)
+{
+	if (gPipeline.isInit())
+	{
+		LLPipeline::refreshCachedSettings();
+        // Need to reload shaders when changing atmospherics implementations...
+        LLViewerShaderMgr::instance()->setShaders();
+	}
+	return true;
+}
+
 // This looks a great deal like handleRenderDeferredChanged because
 // Advanced Lighting (Materials) implies bumps and shiny so disabling
 // bumps should further disable that feature.
@@ -644,6 +655,7 @@ void settings_setup_listeners()
 	gSavedSettings.getControl("RenderDebugPipeline")->getSignal()->connect(boost::bind(&handleRenderDebugPipelineChanged, _2));
 	gSavedSettings.getControl("RenderResolutionDivisor")->getSignal()->connect(boost::bind(&handleRenderResolutionDivisorChanged, _2));
 	gSavedSettings.getControl("RenderDeferred")->getSignal()->connect(boost::bind(&handleRenderDeferredChanged, _2));
+    gSavedSettings.getControl("RenderUseAdvancedAtmospherics")->getSignal()->connect(boost::bind(&handleRenderUseAdvancedAtmosphericsChanged, _2));
 	gSavedSettings.getControl("RenderShadowDetail")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
 	gSavedSettings.getControl("RenderDeferredSSAO")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _2));
 	gSavedSettings.getControl("RenderPerformanceTest")->getSignal()->connect(boost::bind(&handleRenderPerfTestChanged, _2));
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index cd378c0a56..5e7e87c163 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -2139,7 +2139,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredWLSkyProgram.mShaderFiles.push_back(make_pair("deferred/skyF.glsl", GL_FRAGMENT_SHADER_ARB));
         gDeferredWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
 		gDeferredWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
-        if (mVertexShaderLevel[SHADER_WINDLIGHT] >= 3)
+        if (mVertexShaderLevel[SHADER_WINDLIGHT] > 1)
         {
             gDeferredWLSkyProgram.mExtraLinkObject = gAtmosphere->getAtmosphericShaderForLink();
         }
@@ -3537,13 +3537,13 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		return TRUE;
 	}
 
-    if (mVertexShaderLevel[SHADER_WINDLIGHT] >= 3)
+    if (mVertexShaderLevel[SHADER_WINDLIGHT] > 1)
     {
         // Prepare precomputed atmospherics textures using libatmosphere
         LLAtmosphere::initClass();
     }
 
-	if (success && (mVertexShaderLevel[SHADER_WINDLIGHT] < 3))
+	if (success)
 	{
 		gWLSkyProgram.mName = "Windlight Sky Shader";
 		//gWLSkyProgram.mFeatures.hasGamma = true;
@@ -3567,7 +3567,7 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		success = gWLCloudProgram.createShader(NULL, NULL);
 	}
 
-    if (success && (mVertexShaderLevel[SHADER_WINDLIGHT] < 3))
+    if (success)
 	{
 		gWLSunProgram.mName = "Windlight Sun Program";
 		gWLSunProgram.mShaderFiles.clear();
@@ -3585,7 +3585,7 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		success = gWLSunProgram.createShader(NULL, NULL);
 	}
 
-    if (success && (mVertexShaderLevel[SHADER_WINDLIGHT] < 3))
+    if (success)
 	{
 		gWLMoonProgram.mName = "Windlight Moon Program";
 		gWLMoonProgram.mShaderFiles.clear();
diff --git a/indra/newview/llvowlsky.cpp b/indra/newview/llvowlsky.cpp
index 741d0e3992..933bf9bf12 100644
--- a/indra/newview/llvowlsky.cpp
+++ b/indra/newview/llvowlsky.cpp
@@ -160,49 +160,45 @@ BOOL LLVOWLSky::updateGeometry(LLDrawable * drawable)
 	LLStrider<LLVector2>	texCoords;
 	LLStrider<U16>			indices;
 
-    if (gPipeline.useAdvancedAtmospherics())
+    if (mFsSkyVerts.isNull())
     {
-        if (mFsSkyVerts.isNull())
-        {
-            mFsSkyVerts = new LLVertexBuffer(LLDrawPoolWLSky::ADV_ATMO_SKY_VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
-
-            if (!mFsSkyVerts->allocateBuffer(4, 6, TRUE))
-		    {
-			    LL_WARNS() << "Failed to allocate Vertex Buffer on full screen sky update" << LL_ENDL;
-		    }
-
-		    BOOL success = mFsSkyVerts->getVertexStrider(vertices)
-			            && mFsSkyVerts->getTexCoord0Strider(texCoords)
-			            && mFsSkyVerts->getIndexStrider(indices);
-
-		    if(!success) 
-		    {
-			    LL_ERRS() << "Failed updating WindLight fullscreen sky geometry." << LL_ENDL;
-		    }
-
-            *vertices++ = LLVector3(-1.0f, -1.0f, 0.0f);
-            *vertices++ = LLVector3( 1.0f, -1.0f, 0.0f);
-            *vertices++ = LLVector3(-1.0f,  1.0f, 0.0f);
-            *vertices++ = LLVector3( 1.0f,  1.0f, 0.0f);
-
-		    *texCoords++ = LLVector2(0.0f, 0.0f);
-            *texCoords++ = LLVector2(1.0f, 0.0f);
-            *texCoords++ = LLVector2(0.0f, 1.0f);
-            *texCoords++ = LLVector2(1.0f, 1.0f);
-
-		    *indices++ = 0;
-		    *indices++ = 1;
-		    *indices++ = 2;
-            *indices++ = 1;
-		    *indices++ = 3;
-		    *indices++ = 2;
-
-            mFsSkyVerts->flush();
-        }
-
-        return TRUE;
+        mFsSkyVerts = new LLVertexBuffer(LLDrawPoolWLSky::ADV_ATMO_SKY_VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
+
+        if (!mFsSkyVerts->allocateBuffer(4, 6, TRUE))
+		{
+			LL_WARNS() << "Failed to allocate Vertex Buffer on full screen sky update" << LL_ENDL;
+		}
+
+		BOOL success = mFsSkyVerts->getVertexStrider(vertices)
+			        && mFsSkyVerts->getTexCoord0Strider(texCoords)
+			        && mFsSkyVerts->getIndexStrider(indices);
+
+		if(!success) 
+		{
+			LL_ERRS() << "Failed updating WindLight fullscreen sky geometry." << LL_ENDL;
+		}
+
+        *vertices++ = LLVector3(-1.0f, -1.0f, 0.0f);
+        *vertices++ = LLVector3( 1.0f, -1.0f, 0.0f);
+        *vertices++ = LLVector3(-1.0f,  1.0f, 0.0f);
+        *vertices++ = LLVector3( 1.0f,  1.0f, 0.0f);
+
+		*texCoords++ = LLVector2(0.0f, 0.0f);
+        *texCoords++ = LLVector2(1.0f, 0.0f);
+        *texCoords++ = LLVector2(0.0f, 1.0f);
+        *texCoords++ = LLVector2(1.0f, 1.0f);
+
+		*indices++ = 0;
+		*indices++ = 1;
+		*indices++ = 2;
+        *indices++ = 1;
+		*indices++ = 3;
+		*indices++ = 2;
+
+        mFsSkyVerts->flush();
     }
 
+    if(mFanVerts.isNull())
 	{
 		mFanVerts = new LLVertexBuffer(LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
 		if (!mFanVerts->allocateBuffer(getFanNumVerts(), getFanNumIndices(), TRUE))
@@ -324,8 +320,6 @@ void LLVOWLSky::drawFsSky(void)
 		updateGeometry(mDrawable);
 	}
 
-    //LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_LEQUAL);
-    LLGLDepthTest gls_depth(GL_FALSE, GL_FALSE, GL_ALWAYS);
     LLGLDisable disable_blend(GL_BLEND);
 
 	mFsSkyVerts->setBuffer(LLDrawPoolWLSky::ADV_ATMO_SKY_VERTEX_DATA_MASK);
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index bfb7eb3f6a..1522403990 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -424,8 +424,7 @@ void LLPipeline::init()
 	gOctreeMinSize = gSavedSettings.getF32("OctreeMinimumNodeSize");
 	sDynamicLOD = gSavedSettings.getBOOL("RenderDynamicLOD");
 	sRenderBump = gSavedSettings.getBOOL("RenderObjectBump");
-	sUseTriStrips = gSavedSettings.getBOOL("RenderUseTriStrips");
-	sUseAdvancedAtmospherics = gSavedSettings.getBOOL("RenderUseAdvancedAtmospherics");
+	sUseTriStrips = gSavedSettings.getBOOL("RenderUseTriStrips");	
 	LLVertexBuffer::sUseStreamDraw = gSavedSettings.getBOOL("RenderUseStreamVBO");
 	LLVertexBuffer::sUseVAO = gSavedSettings.getBOOL("RenderUseVAO");
 	LLVertexBuffer::sPreferStreamDraw = gSavedSettings.getBOOL("RenderPreferStreamDraw");
@@ -1049,6 +1048,7 @@ void LLPipeline::refreshCachedSettings()
 	RenderAvatarVP = gSavedSettings.getBOOL("RenderAvatarVP");
 	WindLightUseAtmosShaders = gSavedSettings.getBOOL("WindLightUseAtmosShaders");
 	RenderDeferred = gSavedSettings.getBOOL("RenderDeferred");
+    sUseAdvancedAtmospherics = WindLightUseAtmosShaders && gSavedSettings.getBOOL("RenderUseAdvancedAtmospherics");
 	RenderDeferredSunWash = gSavedSettings.getF32("RenderDeferredSunWash");
 	RenderFSAASamples = gSavedSettings.getU32("RenderFSAASamples");
 	RenderResolutionDivisor = gSavedSettings.getU32("RenderResolutionDivisor");
diff --git a/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml b/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml
index c8843db28b..aec71fda07 100644
--- a/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml
+++ b/indra/newview/skins/default/xui/en/floater_edit_ext_day_cycle.xml
@@ -520,6 +520,17 @@ Select a key frame from the timeline above to edit settings.
                                 left_delta="0"
                                 top_pad="5"
                                 name="moon_panel" />
+                        <!-- added programatically so it doesn't show up whether we want it or not
+                        <panel
+                                border="true"
+                                class="panel_settings_density"
+                                filename="panel_settings_sky_density.xml"
+                                label="Density"
+                                layout="topleft"
+                                left_delta="0"
+                                top_pad="5"
+                                name="density_panel" />
+                         -->
                     </tab_container>
                 </layout_panel>        
             </layout_stack>
diff --git a/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml b/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml
index c2500951a6..4b202ec21e 100644
--- a/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml
+++ b/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml
@@ -819,6 +819,22 @@
       function="Pref.VertexShaderEnable" />
   </check_box>
 
+  <!--
+  <check_box
+    control_name="RenderUseAdvancedAtmospherics"
+    height="16"
+    initial_value="true"
+    label="Advanced Atmospherics"
+    layout="topleft"
+    left="480"
+    name="UseAdvancedAtmo"
+    top_delta="16"
+    width="240">
+    <check_box.commit_callback
+      function="Pref.AdvancedAtmosphericsEnable" />
+  </check_box>
+  -->
+
   <text
     type="string"
     length="1"
diff --git a/indra/newview/skins/default/xui/en/panel_settings_sky_density.xml b/indra/newview/skins/default/xui/en/panel_settings_sky_density.xml
new file mode 100644
index 0000000000..e071b30c80
--- /dev/null
+++ b/indra/newview/skins/default/xui/en/panel_settings_sky_density.xml
@@ -0,0 +1,273 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<panel
+        border="true"
+        follows="all"
+        label="Density"
+        layout="topleft"
+        left="0"
+        help_topic="sky_density"
+        name="panel_settings_sky_density"
+        top="0">
+    <layout_stack 
+            follows="all"
+            layout="topleft"
+            left="5"
+            top="5"
+            right="-5"
+            bottom="-5"
+            orientation="vertical">
+        <layout_panel
+                border="true"
+                bevel_style="in"
+                auto_resize="true"
+                user_resize="true"
+                visible="true"
+                height="14">
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    left_delta="5"
+                    min_val="0"
+                    max_val="1"
+                    name="rayleigh_exponential"
+                    label="Rayleigh Exponential Term:"
+                    top_pad="12"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="-0.01"
+                    max_val="0.01"
+                    name="rayleigh_exponential_scale"
+                    label="Rayleigh Exponential Scale:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="0"
+                    max_val="0.00001"
+                    name="rayleigh_linear"
+                    label="Rayleigh Linear Term:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="0"
+                    max_val="1"
+                    name="rayleigh_constant"
+                    label="Rayleigh Constant Term:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="1"
+                    follows="left|top"
+                    height="14"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="1000"
+                    max_val="40000"
+                    name="rayleigh_max_altitude"
+                    label="Rayleigh Max Altitude:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+        </layout_panel>
+        <layout_panel
+                border="true"
+                bevel_style="in"
+                auto_resize="true"
+                user_resize="true"
+                visible="true"
+                height="16">
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    left_delta="5"
+                    min_val="0"
+                    max_val="3.0"
+                    name="mie_exponential"
+                    label="Mie Exponential Term:"
+                    top_pad="12"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="-0.01"
+                    max_val="0.01"
+                    name="mie_exponential_scale"
+                    label="Mie Exponential Scale:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="0"
+                    max_val="0.000004"
+                    name="mie_linear"
+                    label="Mie Linear Term:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="0"
+                    max_val="1"
+                    name="mie_constant"
+                    label="Mie Constant Term:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="2"
+                    follows="left|top"
+                    height="14"
+                    increment="0.01"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="0.2"
+                    max_val="1.8"
+                    name="mie_aniso_factor"
+                    label="Mie Aniso Factor:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="1"
+                    follows="left|top"
+                    height="14"
+                    increment="0.1"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="1000"
+                    max_val="30000"
+                    name="mie_max_altitude"
+                    label="Mie Max Altitude:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+        </layout_panel>
+        <layout_panel
+                border="true"
+                bevel_style="in"
+                auto_resize="true"
+                user_resize="true"
+                visible="true"
+                height="14">
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    left_delta="5"
+                    min_val="0"
+                    max_val="1"
+                    name="absorption_exponential"
+                    label="Absorption Exponential Term:"
+                    top_pad="8"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="-1"
+                    max_val="1"
+                    name="absorption_exponential_scale"
+                    label="Absorption Exponential Scale:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="0"
+                    max_val="1"
+                    name="absorption_linear"
+                    label="Absorption Linear Term:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="6"
+                    follows="left|top"
+                    height="14"
+                    increment="0.0000001"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="0"
+                    max_val="1"
+                    name="absorption_constant"
+                    label="Absorption Constant Term:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+            <slider
+                    decimal_digits="1"
+                    follows="left|top"
+                    height="14"
+                    increment="0.1"
+                    initial_value="0"
+                    layout="topleft"
+                    min_val="1000"
+                    max_val="25000"
+                    name="absorption_max_altitude"
+                    label="Absorption Max Altitude:"
+                    width="400"
+                    label_width="160"
+                    can_edit_text="true"/>
+        </layout_panel>
+    </layout_stack>
+</panel> 
diff --git a/indra/newview/skins/default/xui/en/widgets/density_ctrl.xml b/indra/newview/skins/default/xui/en/widgets/density_ctrl.xml
new file mode 100644
index 0000000000..0f3f0159db
--- /dev/null
+++ b/indra/newview/skins/default/xui/en/widgets/density_ctrl.xml
@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<densityctrl
+ border="true"
+ follows="all"
+ label="Density"
+ name="density_ctrl"
+ layout="topleft"
+ left="0"
+ top="0"
+ width="320"
+ height="240">
+    <text
+     follows="left|top"
+     height="11"
+     layout="topleft"
+     left="15"
+     top_pad="-5"
+     width="120">
+Exponential Term
+    </text>
+    <slider
+     decimal_digits="2"
+     follows="left|top"
+     height="16"
+     increment="0.01"
+     initial_value="0"
+     layout="topleft"
+     left="15"
+     min_val="0"
+     max_val="1"
+     name="level_exponential"
+     top_delta="15"
+     width="200"
+     can_edit_text="true"/>
+
+    <view
+     left_pad="15"
+     top="15"
+     name="preview_image"
+     height="140"
+     width="140"
+     follows="left|top"
+    />
+    <text
+     follows="left|top"
+     height="11"
+     layout="topleft"
+     left="15"
+     top_pad="-5"
+     width="120">
+Exponential Scale Factor
+    </text>
+    <slider
+     decimal_digits="2"
+     follows="left|top"
+     height="16"
+     increment="0.01"
+     initial_value="0"
+     layout="topleft"
+     left="15"
+     min_val="0"
+     max_val="1"
+     name="exponential_scale"
+     top_delta="15"
+     width="200"
+     can_edit_text="true"/>
+
+    <text
+     follows="left|top"
+     height="11"
+     layout="topleft"
+     left="15"
+     top_pad="-5"
+     width="120">
+Linear Term
+    </text>
+    <slider
+     decimal_digits="2"
+     follows="left|top"
+     height="16"
+     increment="0.01"
+     initial_value="0"
+     layout="topleft"
+     left="15"
+     min_val="0"
+     max_val="1"
+     name="level_linear"
+     top_delta="15"
+     width="200"
+     can_edit_text="true"/>
+
+    <text
+     follows="left|top"
+     height="11"
+     layout="topleft"
+     left="15"
+     top_pad="-5"
+     width="120">
+Constant Term
+    </text>
+    <slider
+     decimal_digits="2"
+     follows="left|top"
+     height="16"
+     increment="0.01"
+     initial_value="0"
+     layout="topleft"
+     left="15"
+     min_val="0"
+     max_val="1"
+     name="level_constant"
+     top_delta="15"
+     width="200"
+     can_edit_text="true"/>
+
+    <text
+     follows="left|top"
+     height="11"
+     layout="topleft"
+     left="15"
+     top_pad="15"
+     width="80">
+Max Altitude
+    </text>
+    <slider
+     decimal_digits="0"
+     follows="left|top"
+     height="16"
+     increment="1"
+     initial_value="0"
+     layout="topleft"
+     left="15"
+     min_val="1000"
+     max_val="40000"
+     name="max_altitude"
+     top_delta="15"
+     width="200"
+     can_edit_text="true"/>
+
+    <text
+     follows="left|top"
+     height="11"
+     layout="topleft"
+     name="aniso_factor_label"
+     left="15"
+     top_pad="15"
+     width="80">
+Anisotropy Factor
+    </text>
+    <slider
+     decimal_digits="0"
+     follows="left|top"
+     height="16"
+     increment="1"
+     initial_value="0"
+     layout="topleft"
+     left="15"
+     min_val="1000"
+     max_val="40000"
+     name="aniso_factor"
+     top_delta="15"
+     width="200"
+     can_edit_text="true"/>
+</densityctrl>