1 files changed, 133 insertions, 92 deletions

diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp
index b14235f25c..305215f541 100644
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file lldrawpoolwlsky.cpp
  * @brief LLDrawPoolWLSky class implementation
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -33,7 +33,7 @@
 #include "llimage.h"
 #include "llrender.h"
 #include "llatmosphere.h"
-#include "llenvironment.h" 
+#include "llenvironment.h"
 #include "llglslshader.h"
 #include "llgl.h"
 
@@ -44,8 +44,9 @@
 #include "llsky.h"
 #include "llvowlsky.h"
 #include "llsettingsvo.h"
+#include "llviewercontrol.h"
 
-extern BOOL gCubeSnapshot;
+extern bool gCubeSnapshot;
 
 static LLStaticHashedString sCamPosLocal("camPosLocal");
 static LLStaticHashedString sCustomAlpha("custom_alpha");
@@ -58,7 +59,7 @@ static LLGLSLShader* moon_shader  = NULL;
 static float sStarTime;
 
 LLDrawPoolWLSky::LLDrawPoolWLSky(void) :
-	LLDrawPool(POOL_WL_SKY)
+    LLDrawPool(POOL_WL_SKY)
 {
 }
 
@@ -68,13 +69,13 @@ LLDrawPoolWLSky::~LLDrawPoolWLSky()
 
 LLViewerTexture *LLDrawPoolWLSky::getDebugTexture()
 {
-	return NULL;
+    return NULL;
 }
 
 void LLDrawPoolWLSky::beginDeferredPass(S32 pass)
 {
-	sky_shader = &gDeferredWLSkyProgram;
-	cloud_shader = &gDeferredWLCloudProgram;
+    sky_shader = &gDeferredWLSkyProgram;
+    cloud_shader = &gDeferredWLCloudProgram;
 
     sun_shader = &gDeferredWLSunProgram;
 
@@ -97,34 +98,47 @@ void LLDrawPoolWLSky::renderDome(const LLVector3& camPosLocal, F32 camHeightLoca
     llassert_always(NULL != shader);
 
     gGL.matrixMode(LLRender::MM_MODELVIEW);
-	gGL.pushMatrix();
-
-	//chop off translation
-	if (LLPipeline::sReflectionRender && camPosLocal.mV[2] > 256.f)
-	{
-		gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], 256.f-camPosLocal.mV[2]*0.5f);
-	}
-	else
-	{
-		gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
-	}
-		
-
-	// the windlight sky dome works most conveniently in a coordinate system
-	// where Y is up, so permute our basis vectors accordingly.
-	gGL.rotatef(120.f, 1.f / F_SQRT3, 1.f / F_SQRT3, 1.f / F_SQRT3);
-
-	gGL.scalef(0.333f, 0.333f, 0.333f);
-
-	gGL.translatef(0.f,-camHeightLocal, 0.f);
-	
-	// Draw WL Sky
-	shader->uniform3f(sCamPosLocal, 0.f, camHeightLocal, 0.f);
+    gGL.pushMatrix();
+
+    //chop off translation
+    if (LLPipeline::sReflectionRender && camPosLocal.mV[2] > 256.f)
+    {
+        gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], 256.f-camPosLocal.mV[2]*0.5f);
+    }
+    else
+    {
+        gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
+    }
+
+
+    // the windlight sky dome works most conveniently in a coordinate system
+    // where Y is up, so permute our basis vectors accordingly.
+    gGL.rotatef(120.f, 1.f / F_SQRT3, 1.f / F_SQRT3, 1.f / F_SQRT3);
+
+    gGL.scalef(0.333f, 0.333f, 0.333f);
+
+    gGL.translatef(0.f,-camHeightLocal, 0.f);
+
+    // Draw WL Sky
+    shader->uniform3f(sCamPosLocal, 0.f, camHeightLocal, 0.f);
 
     gSky.mVOWLSkyp->drawDome();
 
     gGL.matrixMode(LLRender::MM_MODELVIEW);
-	gGL.popMatrix();
+    gGL.popMatrix();
+}
+
+extern LLPointer<LLImageGL> gEXRImage;
+
+static bool use_hdri_sky()
+{
+    static LLCachedControl<F32> hdri_split(gSavedSettings, "RenderHDRISplitScreen", 1.f);
+    static LLCachedControl<bool> irradiance_only(gSavedSettings, "RenderHDRIIrradianceOnly", false);
+
+    return gCubeSnapshot && (!irradiance_only || !gPipeline.mReflectionMapManager.isRadiancePass()) ? gEXRImage.notNull() : // always use HDRI for reflection probes when available
+        gEXRImage.notNull() ? hdri_split > 0.f : // fallback to EEP sky when split screen is zero
+        false; // no HDRI available, always use EEP sky
+
 }
 
 void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 camHeightLocal) const
@@ -136,11 +150,36 @@ void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 ca
 
     LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
 
-	if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
-	{
-        LLGLSPipelineDepthTestSkyBox sky(true, true);
+    if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY))
+    {
+        if (use_hdri_sky())
+        {
+            sky_shader = &gEnvironmentMapProgram;
+            sky_shader->bind();
+            S32 idx = sky_shader->enableTexture(LLShaderMgr::ENVIRONMENT_MAP);
+            if (idx > -1)
+            {
+                gGL.getTexUnit(idx)->bind(gEXRImage);
+            }
+
+            static LLCachedControl<F32> hdri_exposure(gSavedSettings, "RenderHDRIExposure", 0.0f);
+            static LLCachedControl<F32> hdri_rotation(gSavedSettings, "RenderHDRIRotation", 0.f);
+            static LLCachedControl<F32> hdri_split(gSavedSettings, "RenderHDRISplitScreen", 1.f);
+            static LLStaticHashedString hdri_split_screen("hdri_split_screen");
+
+            LLMatrix3 rot;
+            rot.setRot(0.f, hdri_rotation*DEG_TO_RAD, 0.f);
 
-        sky_shader->bind();
+            sky_shader->uniform1f(LLShaderMgr::SKY_HDR_SCALE, powf(2.f, hdri_exposure));
+            sky_shader->uniformMatrix3fv(LLShaderMgr::DEFERRED_ENV_MAT, 1, GL_FALSE, (F32*) rot.mMatrix);
+            sky_shader->uniform1f(hdri_split_screen, gCubeSnapshot ? 1.f : hdri_split);
+        }
+        else
+        {
+            sky_shader->bind();
+        }
+
+        LLGLSPipelineDepthTestSkyBox sky(true, true);
 
         sky_shader->uniform1i(LLShaderMgr::CUBE_SNAPSHOT, gCubeSnapshot ? 1 : 0);
 
@@ -172,43 +211,43 @@ void LLDrawPoolWLSky::renderSkyHazeDeferred(const LLVector3& camPosLocal, F32 ca
         sky_shader->uniform1i(LLShaderMgr::SUN_UP_FACTOR, psky->getIsSunUp() ? 1 : 0);
 
         /// Render the skydome
-        renderDome(origin, camHeightLocal, sky_shader);	
+        renderDome(origin, camHeightLocal, sky_shader);
 
-		sky_shader->unbind();
+        sky_shader->unbind();
     }
 }
 
 void LLDrawPoolWLSky::renderStarsDeferred(const LLVector3& camPosLocal) const
 {
-    if (!gSky.mVOSkyp)
+    if (!gSky.mVOSkyp || use_hdri_sky())
     {
         return;
     }
 
-	LLGLSPipelineBlendSkyBox gls_sky(true, false);
+    LLGLSPipelineBlendSkyBox gls_sky(true, false);
 
-	gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
+    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;
-	}
+    // If start_brightness is not set, exit
+    if(star_alpha < 0.001f)
+    {
+        LL_DEBUGS("SKY") << "star_brightness below threshold." << LL_ENDL;
+        return;
+    }
 
-	gDeferredStarProgram.bind();	
+    gDeferredStarProgram.bind();
 
     LLViewerTexture* tex_a = gSky.mVOSkyp->getBloomTex();
     LLViewerTexture* tex_b = gSky.mVOSkyp->getBloomTexNext();
 
-    F32 blend_factor = LLEnvironment::instance().getCurrentSky()->getBlendFactor();
-	
+    F32 blend_factor = (F32)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(0)->bind(tex_a);
         gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
         blend_factor = 0;
     }
@@ -224,40 +263,45 @@ void LLDrawPoolWLSky::renderStarsDeferred(const LLVector3& camPosLocal) const
         gGL.getTexUnit(1)->bind(tex_b);
     }
 
-	gGL.pushMatrix();
-	gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
-	gGL.rotatef(gFrameTimeSeconds*0.01f, 0.f, 0.f, 1.f);
+    gGL.pushMatrix();
+    gGL.translatef(camPosLocal.mV[0], camPosLocal.mV[1], camPosLocal.mV[2]);
+    gGL.rotatef(gFrameTimeSeconds*0.01f, 0.f, 0.f, 1.f);
     gDeferredStarProgram.uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
 
     if (LLPipeline::sReflectionRender)
     {
         star_alpha = 1.0f;
     }
-	gDeferredStarProgram.uniform1f(sCustomAlpha, star_alpha);
+    gDeferredStarProgram.uniform1f(sCustomAlpha, star_alpha);
 
     sStarTime = (F32)LLFrameTimer::getElapsedSeconds() * 0.5f;
 
     gDeferredStarProgram.uniform1f(LLShaderMgr::WATER_TIME, sStarTime);
 
-	gSky.mVOWLSkyp->drawStars();
+    gSky.mVOWLSkyp->drawStars();
 
     gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
     gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
 
     gDeferredStarProgram.unbind();
 
-	gGL.popMatrix();
+    gGL.popMatrix();
 }
 
 void LLDrawPoolWLSky::renderSkyCloudsDeferred(const LLVector3& camPosLocal, F32 camHeightLocal, LLGLSLShader* cloudshader) const
 {
-	if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS) && gSky.mVOSkyp && gSky.mVOSkyp->getCloudNoiseTex())
-	{
+    if (use_hdri_sky())
+    {
+        return;
+    }
+
+    if (gPipeline.canUseWindLightShaders() && gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS) && gSky.mVOSkyp && gSky.mVOSkyp->getCloudNoiseTex())
+    {
         LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
 
-		LLGLSPipelineBlendSkyBox pipeline(true, true);
-		
-		cloudshader->bind();
+        LLGLSPipelineBlendSkyBox pipeline(true, true);
+
+        cloudshader->bind();
 
         LLPointer<LLViewerTexture> cloud_noise      = gSky.mVOSkyp->getCloudNoiseTex();
         LLPointer<LLViewerTexture> cloud_noise_next = gSky.mVOSkyp->getCloudNoiseTexNext();
@@ -265,8 +309,8 @@ void LLDrawPoolWLSky::renderSkyCloudsDeferred(const LLVector3& camPosLocal, F32
         gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
         gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
 
-        F32 cloud_variance = psky ? psky->getCloudVariance() : 0.0f;
-        F32 blend_factor   = psky ? psky->getBlendFactor() : 0.0f;
+        F32 cloud_variance = psky ? (F32)psky->getCloudVariance() : 0.0f;
+        F32 blend_factor   = psky ? (F32)psky->getBlendFactor() : 0.0f;
 
         if (psky->getCloudScrollRate().isExactlyZero())
         {
@@ -298,36 +342,36 @@ void LLDrawPoolWLSky::renderSkyCloudsDeferred(const LLVector3& camPosLocal, F32
         cloudshader->uniform1f(LLShaderMgr::CLOUD_VARIANCE, cloud_variance);
         cloudshader->uniform1f(LLShaderMgr::SUN_MOON_GLOW_FACTOR, psky->getSunMoonGlowFactor());
 
-		/// Render the skydome
+        /// Render the skydome
         renderDome(camPosLocal, camHeightLocal, cloudshader);
 
-		cloudshader->unbind();
+        cloudshader->unbind();
 
         gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
         gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
-	}
+    }
 }
 
 void LLDrawPoolWLSky::renderHeavenlyBodies()
 {
-    if (!gSky.mVOSkyp) return;
+    if (!gSky.mVOSkyp || use_hdri_sky()) return;
 
     LLGLSPipelineBlendSkyBox gls_skybox(true, true); // SL-14113 we need moon to write to depth to clip stars behind
 
     LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
-	gGL.pushMatrix();
-	gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
+    gGL.pushMatrix();
+    gGL.translatef(origin.mV[0], origin.mV[1], origin.mV[2]);
 
-	LLFace * face = gSky.mVOSkyp->mFace[LLVOSky::FACE_SUN];
+    LLFace * face = gSky.mVOSkyp->mFace[LLVOSky::FACE_SUN];
 
-    F32 blend_factor = LLEnvironment::instance().getCurrentSky()->getBlendFactor();
+    F32 blend_factor = (F32)LLEnvironment::instance().getCurrentSky()->getBlendFactor();
     bool can_use_vertex_shaders = gPipeline.shadersLoaded();
     bool can_use_windlight_shaders = gPipeline.canUseWindLightShaders();
 
 
-	if (gSky.mVOSkyp->getSun().getDraw() && face && face->getGeomCount())
-	{
-		LLPointer<LLViewerTexture> tex_a = face->getTexture(LLRender::DIFFUSE_MAP);
+    if (gSky.mVOSkyp->getSun().getDraw() && face && face->getGeomCount())
+    {
+        LLPointer<LLViewerTexture> tex_a = face->getTexture(LLRender::DIFFUSE_MAP);
         LLPointer<LLViewerTexture> tex_b = face->getTexture(LLRender::ALTERNATE_DIFFUSE_MAP);
 
         gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
@@ -371,17 +415,17 @@ void LLDrawPoolWLSky::renderHeavenlyBodies()
                 sun_shader->unbind();
             }
         }
-	}
+    }
 
-	face = gSky.mVOSkyp->mFace[LLVOSky::FACE_MOON];
+    face = gSky.mVOSkyp->mFace[LLVOSky::FACE_MOON];
 
-	if (gSky.mVOSkyp->getMoon().getDraw() && face && face->getTexture(LLRender::DIFFUSE_MAP) && face->getGeomCount() && moon_shader)
-	{        
+    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);
 
-		LLColor4 color(gSky.mVOSkyp->getMoon().getInterpColor());
-		
+        LLColor4 color(gSky.mVOSkyp->getMoon().getInterpColor());
+
         if (can_use_vertex_shaders && can_use_windlight_shaders && (tex_a || tex_b))
         {
             moon_shader->bind();
@@ -428,18 +472,16 @@ void LLDrawPoolWLSky::renderHeavenlyBodies()
 void LLDrawPoolWLSky::renderDeferred(S32 pass)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_WL_SKY);
-	if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY) || gSky.mVOSkyp.isNull())
-	{
-		return;
-	}
+    if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY) || gSky.mVOSkyp.isNull())
+    {
+        return;
+    }
 
     // TODO: remove gSky.mVOSkyp and fold sun/moon into LLVOWLSky
     gSky.mVOSkyp->updateGeometry(gSky.mVOSkyp->mDrawable);
 
     const F32 camHeightLocal = LLEnvironment::instance().getCamHeight();
 
-	gGL.setColorMask(true, false);
-
     LLVector3 const & origin = LLViewerCamera::getInstance()->getOrigin();
 
     if (gPipeline.canUseWindLightShaders())
@@ -456,14 +498,13 @@ void LLDrawPoolWLSky::renderDeferred(S32 pass)
             renderSkyCloudsDeferred(origin, camHeightLocal, cloud_shader);
         }
     }
-    gGL.setColorMask(true, true);
 }
 
 
 
 LLViewerTexture* LLDrawPoolWLSky::getTexture()
 {
-	return NULL;
+    return NULL;
 }
 
 void LLDrawPoolWLSky::resetDrawOrders()