1 files changed, 341 insertions, 143 deletions

diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp
index 309f535c39..455df837a9 100644
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -33,7 +33,6 @@
 #include "pipeline.h"
 #include "llviewercamera.h"
 #include "llimage.h"
-#include "llwlparammanager.h"
 #include "llviewershadermgr.h"
 #include "llglslshader.h"
 #include "llsky.h"
@@ -42,53 +41,26 @@
 #include "llface.h"
 #include "llrender.h"
 
-LLPointer<LLViewerTexture> LLDrawPoolWLSky::sCloudNoiseTexture = NULL;
+#include "llenvironment.h" 
+#include "llatmosphere.h"
 
-LLPointer<LLImageRaw> LLDrawPoolWLSky::sCloudNoiseRawImage = NULL;
+static LLStaticHashedString sCamPosLocal("camPosLocal");
+static LLStaticHashedString sCustomAlpha("custom_alpha");
 
 static LLGLSLShader* cloud_shader = NULL;
-static LLGLSLShader* sky_shader = NULL;
+static LLGLSLShader* sky_shader   = NULL;
+static LLGLSLShader* sun_shader   = NULL;
+static LLGLSLShader* moon_shader  = NULL;
 
+static float sStarTime;
 
 LLDrawPoolWLSky::LLDrawPoolWLSky(void) :
 	LLDrawPool(POOL_WL_SKY)
 {
-	const std::string cloudNoiseFilename(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", "clouds2.tga"));
-	LL_INFOS() << "loading WindLight cloud noise from " << cloudNoiseFilename << LL_ENDL;
-
-	LLPointer<LLImageFormatted> cloudNoiseFile(LLImageFormatted::createFromExtension(cloudNoiseFilename));
-
-	if(cloudNoiseFile.isNull()) {
-		LL_ERRS() << "Error: Failed to load cloud noise image " << cloudNoiseFilename << LL_ENDL;
-	}
-
-	if(cloudNoiseFile->load(cloudNoiseFilename))
-	{
-		sCloudNoiseRawImage = new LLImageRaw();
-
-		if(cloudNoiseFile->decode(sCloudNoiseRawImage, 0.0f))
-		{
-			//debug use			
-			LL_DEBUGS() << "cloud noise raw image width: " << sCloudNoiseRawImage->getWidth() << " : height: " << sCloudNoiseRawImage->getHeight() << " : components: " << 
-				(S32)sCloudNoiseRawImage->getComponents() << " : data size: " << sCloudNoiseRawImage->getDataSize() << LL_ENDL ;
-			llassert_always(sCloudNoiseRawImage->getData()) ;
-
-			sCloudNoiseTexture = LLViewerTextureManager::getLocalTexture(sCloudNoiseRawImage.get(), TRUE);
-		}
-		else
-		{
-			sCloudNoiseRawImage = NULL ;
-		}
-	}
-
-	LLWLParamManager::getInstance()->propagateParameters();
 }
 
 LLDrawPoolWLSky::~LLDrawPoolWLSky()
 {
-	//LL_INFOS() << "destructing wlsky draw pool." << LL_ENDL;
-	sCloudNoiseTexture = NULL;
-	sCloudNoiseRawImage = NULL;
 }
 
 LLViewerTexture *LLDrawPoolWLSky::getDebugTexture()
@@ -107,39 +79,69 @@ void LLDrawPoolWLSky::beginRenderPass( S32 pass )
 			LLPipeline::sUnderWaterRender ?
 				&gObjectFullbrightNoColorWaterProgram :
 				&gWLCloudProgram;
+
+    sun_shader =
+			LLPipeline::sUnderWaterRender ?
+				&gObjectFullbrightNoColorWaterProgram :
+				&gWLSunProgram;
+
+    moon_shader =
+			LLPipeline::sUnderWaterRender ?
+				&gObjectFullbrightNoColorWaterProgram :
+				&gWLMoonProgram;
 }
 
 void LLDrawPoolWLSky::endRenderPass( S32 pass )
 {
+    sky_shader   = nullptr;
+    cloud_shader = nullptr;
+    sun_shader   = nullptr;
+    moon_shader  = nullptr;
 }
 
 void LLDrawPoolWLSky::beginDeferredPass(S32 pass)
 {
 	sky_shader = &gDeferredWLSkyProgram;
 	cloud_shader = &gDeferredWLCloudProgram;
+
+    sun_shader =
+			LLPipeline::sUnderWaterRender ?
+				&gObjectFullbrightNoColorWaterProgram :
+				&gDeferredWLSunProgram;
+
+    moon_shader =
+			LLPipeline::sUnderWaterRender ?
+				&gObjectFullbrightNoColorWaterProgram :
+				&gDeferredWLMoonProgram;
 }
 
 void LLDrawPoolWLSky::endDeferredPass(S32 pass)
 {
-
+    sky_shader   = nullptr;
+    cloud_shader = nullptr;
+    sun_shader   = nullptr;
+    moon_shader  = nullptr;
 }
 
-void LLDrawPoolWLSky::renderDome(F32 camHeightLocal, LLGLSLShader * shader) const
+void LLDrawPoolWLSky::renderFsSky(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader * shader) const
 {
-	LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
+    gSky.mVOWLSkyp->drawFsSky();
+}
 
-	llassert_always(NULL != shader);
+void LLDrawPoolWLSky::renderDome(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader * shader) const
+{
+    llassert_always(NULL != shader);
 
 	gGL.pushMatrix();
 
 	//chop off translation
-	if (LLPipeline::sReflectionRender && origin.mV[2] > 256.f)
+	if (LLPipeline::sReflectionRender && camPosLocal.mV[2] > 256.f)
 	{
-		gGL.translatef(origin.mV[0], origin.mV[1], 256.f-origin.mV[2]*0.5f);
+		gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], 256.f-camPosLocal.mV[2]*0.5f);
 	}
 	else
 	{
-		gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
+		gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
 	}
 		
 
@@ -151,30 +153,66 @@ void LLDrawPoolWLSky::renderDome(F32 camHeightLocal, LLGLSLShader * shader) cons
 
 	gGL.translatef(0.f,-camHeightLocal, 0.f);
 	
-	// Draw WL Sky	
-	static LLStaticHashedString sCamPosLocal("camPosLocal");
+	// Draw WL Sky
 	shader->uniform3f(sCamPosLocal, 0.f, camHeightLocal, 0.f);
 
-	gSky.mVOWLSkyp->drawDome();
+    gSky.mVOWLSkyp->drawDome();
 
 	gGL.popMatrix();
 }
 
-void LLDrawPoolWLSky::renderSkyHaze(F32 camHeightLocal) const
+void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 camHeightLocal) const
 {
-	if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
-	{
-		LLGLDisable blend(GL_BLEND);
-
+    if (gPipeline.useAdvancedAtmospherics() && gPipeline.canUseWindLightShaders() && gAtmosphere)
+    {
 		sky_shader->bind();
 
-		/// Render the skydome
-		renderDome(camHeightLocal, sky_shader);	
+        // bind precomputed textures necessary for calculating sun and sky luminance
+        sky_shader->bindTexture(LLShaderMgr::TRANSMITTANCE_TEX, gAtmosphere->getTransmittance());
+        sky_shader->bindTexture(LLShaderMgr::SCATTER_TEX, gAtmosphere->getScattering());
+        sky_shader->bindTexture(LLShaderMgr::SINGLE_MIE_SCATTER_TEX, gAtmosphere->getMieScattering());
+        sky_shader->bindTexture(LLShaderMgr::ILLUMINANCE_TEX, gAtmosphere->getIlluminance());
+
+        LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
+        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);
+        sky_shader->uniform3fv(LLShaderMgr::DEFERRED_SUN_DIR, 1, sun_dir.mV);
+        sky_shader->uniform3fv(LLShaderMgr::DEFERRED_MOON_DIR, 1, moon_dir.mV);
+
+        llassert(sky_shader->getUniformLocation(LLShaderMgr::INVERSE_PROJECTION_MATRIX));
+
+        glh::matrix4f proj_mat = get_current_projection();
+		glh::matrix4f inv_proj = proj_mat.inverse();
+
+	    sky_shader->uniformMatrix4fv(LLShaderMgr::INVERSE_PROJECTION_MATRIX, 1, FALSE, inv_proj.m);
+
+        sky_shader->uniform3f(sCamPosLocal, camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
+
+        renderFsSky(camPosLocal, camHeightLocal, sky_shader);
+        
 		sky_shader->unbind();
 	}
 }
 
+void LLDrawPoolWLSky::renderSkyHaze(const LLVector3& camPosLocal, F32 camHeightLocal) const
+{
+    LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
+
+	if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
+	{
+        LLGLDisable blend(GL_BLEND);
+        sky_shader->bind();
+
+        /// Render the skydome
+        renderDome(origin, camHeightLocal, sky_shader);	
+
+		sky_shader->unbind();
+    }
+}
+
 void LLDrawPoolWLSky::renderStars(void) const
 {
 	LLGLSPipelineSkyBox gls_sky;
@@ -190,25 +228,39 @@ void LLDrawPoolWLSky::renderStars(void) const
 	
 	// *NOTE: we divide by two here and GL_ALPHA_SCALE by two below to avoid
 	// clamping and allow the star_alpha param to brighten the stars.
-	bool error;
 	LLColor4 star_alpha(LLColor4::black);
-	star_alpha.mV[3] = LLWLParamManager::getInstance()->mCurParams.getFloat("star_brightness", error) / 2.f;
 
-	// If start_brightness is not set, exit
-	if( error )
+    star_alpha.mV[3] = LLEnvironment::instance().getCurrentSky()->getStarBrightness() / 512.f;
+    
+	// If star brightness is not set, exit
+	if( star_alpha.mV[3] < 0.001 )
 	{
-		LL_WARNS() << "star_brightness missing in mCurParams" << LL_ENDL;
+		LL_DEBUGS("SKY") << "star_brightness below threshold." << LL_ENDL;
 		return;
 	}
 
-	gGL.getTexUnit(0)->bind(gSky.mVOSkyp->getBloomTex());
+    LLViewerTexture* tex_a = gSky.mVOSkyp->getBloomTex();
+    LLViewerTexture* tex_b = gSky.mVOSkyp->getBloomTexNext();
+	
+    if (tex_a && (!tex_b || (tex_a == tex_b)))
+    {
+        // Bind current and next sun textures
+		gGL.getTexUnit(0)->bind(tex_a);
+    }
+    else if (tex_b && !tex_a)
+    {
+        gGL.getTexUnit(0)->bind(tex_b);
+    }
+    else if (tex_b != tex_a)
+    {
+        gGL.getTexUnit(0)->bind(tex_a);
+    }
 
 	gGL.pushMatrix();
 	gGL.rotatef(gFrameTimeSeconds*0.01f, 0.f, 0.f, 1.f);
 	if (LLGLSLShader::sNoFixedFunction)
 	{
 		gCustomAlphaProgram.bind();
-		static LLStaticHashedString sCustomAlpha("custom_alpha");
 		gCustomAlphaProgram.uniform1f(sCustomAlpha, star_alpha.mV[3]);
 	}
 	else
@@ -220,6 +272,8 @@ void LLDrawPoolWLSky::renderStars(void) const
 
 	gSky.mVOWLSkyp->drawStars();
 
+    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
 	gGL.popMatrix();
 
 	if (LLGLSLShader::sNoFixedFunction)
@@ -233,19 +287,84 @@ void LLDrawPoolWLSky::renderStars(void) const
 	}
 }
 
-void LLDrawPoolWLSky::renderSkyClouds(F32 camHeightLocal) const
+void LLDrawPoolWLSky::renderStarsDeferred(void) const
 {
-	if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS) && sCloudNoiseTexture.notNull())
+	LLGLSPipelineSkyBox gls_sky;
+	LLGLEnable blend(GL_BLEND);
+	gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
+
+    F32 star_alpha = LLEnvironment::instance().getCurrentSky()->getStarBrightness() / 500.0f;
+
+	// If start_brightness is not set, exit
+	if(star_alpha < 0.001f)
+	{
+		LL_DEBUGS("SKY") << "star_brightness below threshold." << LL_ENDL;
+		return;
+	}
+
+	gDeferredStarProgram.bind();	
+
+    LLViewerTexture* tex_a = gSky.mVOSkyp->getBloomTex();
+    LLViewerTexture* tex_b = gSky.mVOSkyp->getBloomTexNext();
+
+    F32 blend_factor = LLEnvironment::instance().getCurrentSky()->getBlendFactor();
+	
+    if (tex_a && (!tex_b || (tex_a == tex_b)))
+    {
+        // Bind current and next sun textures
+		gGL.getTexUnit(0)->bind(tex_a);
+        gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
+        blend_factor = 0;
+    }
+    else if (tex_b && !tex_a)
+    {
+        gGL.getTexUnit(0)->bind(tex_b);
+        gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
+        blend_factor = 0;
+    }
+    else if (tex_b != tex_a)
+    {
+        gGL.getTexUnit(0)->bind(tex_a);
+        gGL.getTexUnit(1)->bind(tex_b);
+    }
+
+    gDeferredStarProgram.uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
+
+    if (LLPipeline::sRenderingWaterReflection)
+    {
+        star_alpha = 1.0f;
+    }
+	gDeferredStarProgram.uniform1f(sCustomAlpha, star_alpha);
+
+    sStarTime = (F32)LLFrameTimer::getElapsedSeconds() * 0.5f;
+
+    gDeferredStarProgram.uniform1f(LLShaderMgr::WATER_TIME, sStarTime);
+
+	gSky.mVOWLSkyp->drawStars();
+
+    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+    gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
+
+    gDeferredStarProgram.unbind();
+}
+
+void LLDrawPoolWLSky::renderSkyClouds(const LLVector3& camPosLocal, F32 camHeightLocal) const
+{
+	if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS) && gSky.mVOSkyp->getCloudNoiseTex())
 	{
 		LLGLEnable blend(GL_BLEND);
 		gGL.setSceneBlendType(LLRender::BT_ALPHA);
 		
-		gGL.getTexUnit(0)->bind(sCloudNoiseTexture);
-
 		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);
+
 		/// Render the skydome
-		renderDome(camHeightLocal, cloud_shader);
+        renderDome(camPosLocal, camHeightLocal, cloud_shader);
 
 		cloud_shader->unbind();
 	}
@@ -257,49 +376,110 @@ void LLDrawPoolWLSky::renderHeavenlyBodies()
 	LLGLEnable blend_on(GL_BLEND);
 	gPipeline.disableLights();
 
-#if 0 // when we want to re-add a texture sun disc, here's where to do it.
+    LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
+	gGL.pushMatrix();
+	gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);	        
+
 	LLFace * face = gSky.mVOSkyp->mFace[LLVOSky::FACE_SUN];
-	if (gSky.mVOSkyp->getSun().getDraw() && face->getGeomCount())
+
+    F32 blend_factor = LLEnvironment::instance().getCurrentSky()->getBlendFactor();
+    bool can_use_vertex_shaders = gPipeline.canUseVertexShaders();
+    bool can_use_windlight_shaders = gPipeline.canUseWindLightShaders();
+
+
+	if (gSky.mVOSkyp->getSun().getDraw() && face && face->getGeomCount())
 	{
-		LLViewerTexture * tex  = face->getTexture();
-		gGL.getTexUnit(0)->bind(tex);
-		LLColor4 color(gSky.mVOSkyp->getSun().getInterpColor());
-		LLFacePool::LLOverrideFaceColor color_override(this, color);
-		face->renderIndexed();
+		LLViewerTexture* tex_a = face->getTexture(LLRender::DIFFUSE_MAP);
+        LLViewerTexture* tex_b = face->getTexture(LLRender::ALTERNATE_DIFFUSE_MAP);
+
+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+        gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
+
+        // if we even have sun disc textures to work with...
+        if (tex_a || tex_b)
+        {
+            // if and only if we have a texture defined, render the sun disc
+            if (can_use_vertex_shaders && can_use_windlight_shaders)
+            {
+                sun_shader->bind();
+
+                if (tex_a && (!tex_b || (tex_a == tex_b)))
+                {
+                    // Bind current and next sun textures
+                    sun_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, tex_a, LLTexUnit::TT_TEXTURE);
+                    blend_factor = 0;
+                }
+                else if (tex_b && !tex_a)
+                {
+                    sun_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, tex_b, LLTexUnit::TT_TEXTURE);
+                    blend_factor = 0;
+                }
+                else if (tex_b != tex_a)
+                {
+                    sun_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, tex_a, LLTexUnit::TT_TEXTURE);
+                    sun_shader->bindTexture(LLShaderMgr::ALTERNATE_DIFFUSE_MAP, tex_b, LLTexUnit::TT_TEXTURE);
+                }
+
+                LLColor4 color(gSky.mVOSkyp->getSun().getInterpColor());
+
+                sun_shader->uniform4fv(LLShaderMgr::DIFFUSE_COLOR, 1, color.mV);
+                sun_shader->uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
+
+                LLFacePool::LLOverrideFaceColor color_override(this, color);
+                face->renderIndexed();
+
+                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+                gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
+
+                sun_shader->unbind();
+            }
+        }
 	}
-#endif
 
-	LLFace * face = gSky.mVOSkyp->mFace[LLVOSky::FACE_MOON];
+	face = gSky.mVOSkyp->mFace[LLVOSky::FACE_MOON];
 
-	if (gSky.mVOSkyp->getMoon().getDraw() && face->getGeomCount())
-	{
-		// *NOTE: even though we already bound this texture above for the
-		// stars register combiners, we bind again here for defensive reasons,
-		// since LLImageGL::bind detects that it's a noop, and optimizes it out.
-		gGL.getTexUnit(0)->bind(face->getTexture());
-		LLColor4 color(gSky.mVOSkyp->getMoon().getInterpColor());
-		F32 a = gSky.mVOSkyp->getMoon().getDirection().mV[2];
-		if (a > 0.f)
-		{
-			a = a*a*4.f;
-		}
-			
-		color.mV[3] = llclamp(a, 0.f, 1.f);
-		
-		if (gPipeline.canUseVertexShaders())
-		{
-			gHighlightProgram.bind();
-		}
+	if (gSky.mVOSkyp->getMoon().getDraw() && face && face->getTexture(LLRender::DIFFUSE_MAP) && face->getGeomCount() && moon_shader)
+	{        
+        LLViewerTexture* tex_a = face->getTexture(LLRender::DIFFUSE_MAP);
+        LLViewerTexture* tex_b = face->getTexture(LLRender::ALTERNATE_DIFFUSE_MAP);
 
-		LLFacePool::LLOverrideFaceColor color_override(this, color);
+		LLColor4 color(gSky.mVOSkyp->getMoon().getInterpColor());
 		
-		face->renderIndexed();
-
-		if (gPipeline.canUseVertexShaders())
-		{
-			gHighlightProgram.unbind();
-		}
-	}
+        if (can_use_vertex_shaders && can_use_windlight_shaders)
+        {
+            moon_shader->bind();
+
+            if (tex_a && (!tex_b || (tex_a == tex_b)))
+            {
+                // Bind current and next sun textures
+                moon_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, tex_a, LLTexUnit::TT_TEXTURE);
+                blend_factor = 0;
+            }
+            else if (tex_b && !tex_a)
+            {
+                moon_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, tex_b, LLTexUnit::TT_TEXTURE);
+                blend_factor = 0;
+            }
+            else if (tex_b != tex_a)
+            {
+                moon_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, tex_a, LLTexUnit::TT_TEXTURE);
+                moon_shader->bindTexture(LLShaderMgr::ALTERNATE_DIFFUSE_MAP, tex_b, LLTexUnit::TT_TEXTURE);
+            }
+
+            moon_shader->uniform4fv(LLShaderMgr::DIFFUSE_COLOR, 1, color.mV);                
+            moon_shader->uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
+
+            LLFacePool::LLOverrideFaceColor color_override(this, color);
+            face->renderIndexed();
+
+            gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+            gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
+
+            moon_shader->unbind();
+        }
+    }
+
+    gGL.popMatrix();
 }
 
 void LLDrawPoolWLSky::renderDeferred(S32 pass)
@@ -310,43 +490,60 @@ void LLDrawPoolWLSky::renderDeferred(S32 pass)
 	}
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_WL_SKY);
 
-	const F32 camHeightLocal = LLWLParamManager::getInstance()->getDomeOffset() * LLWLParamManager::getInstance()->getDomeRadius();
+    const F32 camHeightLocal = LLEnvironment::instance().getCamHeight();
 
-	LLGLSNoFog disableFog;
-	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
+	LLGLSNoFog disableFog;	
 	LLGLDisable clip(GL_CLIP_PLANE0);
 
 	gGL.setColorMask(true, false);
 
-	LLGLSquashToFarClip far_clip(glh_get_current_projection());
-
-	renderSkyHaze(camHeightLocal);
-
-	LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
-	gGL.pushMatrix();
-
-		
-		gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
-
-		gDeferredStarProgram.bind();
-		// *NOTE: have to bind a texture here since register combiners blending in
-		// renderStars() requires something to be bound and we might as well only
-		// bind the moon's texture once.		
-		gGL.getTexUnit(0)->bind(gSky.mVOSkyp->mFace[LLVOSky::FACE_MOON]->getTexture());
-
-		renderHeavenlyBodies();
+	LLGLSquashToFarClip far_clip(get_current_projection());
+
+    LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
+
+    if (gPipeline.canUseWindLightShaders())
+    {
+        {
+            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);
+}
 
-		renderStars();
-		
-		gDeferredStarProgram.unbind();
+void LLDrawPoolWLSky::renderPostDeferred(S32 pass)
+{
+    LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
 
-	gGL.popMatrix();
+    LLGLSNoFog disableFog;	
+	LLGLDisable clip(GL_CLIP_PLANE0);
+    LLGLSquashToFarClip far_clip(get_current_projection());
 
-	renderSkyClouds(camHeightLocal);
+	gGL.pushMatrix();
+	gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
+    gGL.setColorMask(true, false);
 
-	gGL.setColorMask(true, true);
-	//gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+    // would be nice to do this here, but would need said bodies
+    // to render at a realistic distance for depth-testing against the clouds...
+    //renderHeavenlyBodies();
+    renderStarsDeferred();
 
+    gGL.popMatrix();
+    gGL.setColorMask(true, true);
 }
 
 void LLDrawPoolWLSky::render(S32 pass)
@@ -357,34 +554,41 @@ void LLDrawPoolWLSky::render(S32 pass)
 	}
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_WL_SKY);
 
-	const F32 camHeightLocal = LLWLParamManager::getInstance()->getDomeOffset() * LLWLParamManager::getInstance()->getDomeRadius();
+    const F32 camHeightLocal = LLEnvironment::instance().getCamHeight();
 
 	LLGLSNoFog disableFog;
 	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 	LLGLDisable clip(GL_CLIP_PLANE0);
 
-	LLGLSquashToFarClip far_clip(glh_get_current_projection());
+	LLGLSquashToFarClip far_clip(get_current_projection());
 
-	renderSkyHaze(camHeightLocal);
+    LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
 
-	LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
-	gGL.pushMatrix();
+	renderSkyHaze(origin, camHeightLocal);
 
-		gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
+    bool use_advanced = gPipeline.useAdvancedAtmospherics();
+    
+    if (!use_advanced)
+    {
+	    gGL.pushMatrix();
+
+        // MAINT-9006 keep sun position consistent between ALM and non-ALM rendering
+		//gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
 
 		// *NOTE: have to bind a texture here since register combiners blending in
 		// renderStars() requires something to be bound and we might as well only
 		// bind the moon's texture once.		
 		gGL.getTexUnit(0)->bind(gSky.mVOSkyp->mFace[LLVOSky::FACE_MOON]->getTexture());
+        gGL.getTexUnit(1)->bind(gSky.mVOSkyp->mFace[LLVOSky::FACE_MOON]->getTexture(LLRender::ALTERNATE_DIFFUSE_MAP));
 
 		renderHeavenlyBodies();
 
 		renderStars();
-		
 
-	gGL.popMatrix();
+	    gGL.popMatrix();
+    }
 
-	renderSkyClouds(camHeightLocal);
+	renderSkyClouds(origin, camHeightLocal);
 
 	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 }
@@ -411,15 +615,9 @@ void LLDrawPoolWLSky::resetDrawOrders()
 //static
 void LLDrawPoolWLSky::cleanupGL()
 {
-	sCloudNoiseTexture = NULL;
 }
 
 //static
 void LLDrawPoolWLSky::restoreGL()
 {
-	if(sCloudNoiseRawImage.notNull())
-	{
-		sCloudNoiseTexture = LLViewerTextureManager::getLocalTexture(sCloudNoiseRawImage.get(), TRUE);
-	}
 }
-