SL-17574 Add probe detail combo box to advanced graphics preferences. Fix spot light shadows not working in probes.

1 files changed, 210 insertions, 177 deletions

diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 28dc3781ba..8bac5131cf 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -739,7 +739,8 @@ void LLPipeline::requestResizeShadowTexture()
 
 void LLPipeline::resizeShadowTexture()
 {
-    releaseShadowTargets();
+    releaseSunShadowTargets();
+    releaseSpotShadowTargets();
     allocateShadowBuffer(mRT->width, mRT->height);
     gResizeShadowTexture = FALSE;
 }
@@ -754,7 +755,8 @@ void LLPipeline::resizeScreenTexture()
 		if (gResizeScreenTexture || (resX != mRT->screen.getWidth()) || (resY != mRT->screen.getHeight()))
 		{
 			releaseScreenBuffers();
-            releaseShadowTargets();
+            releaseSunShadowTargets();
+            releaseSpotShadowTargets();
 		    allocateScreenBuffer(resX,resY);
             gResizeScreenTexture = FALSE;
 		}
@@ -913,7 +915,8 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
     {
         mRT->deferredLight.release();
 
-        releaseShadowTargets();
+        releaseSunShadowTargets();
+        releaseSpotShadowTargets();
 
 		mRT->fxaaBuffer.release();
 		mRT->screen.release();
@@ -942,66 +945,66 @@ inline U32 BlurHappySize(U32 x, F32 scale) { return U32( x * scale + 16.0f) & ~0
 bool LLPipeline::allocateShadowBuffer(U32 resX, U32 resY)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY;
-	if (LLPipeline::sRenderDeferred)
-	{
-		S32 shadow_detail = RenderShadowDetail;
+    if (LLPipeline::sRenderDeferred)
+    {
+        S32 shadow_detail = RenderShadowDetail;
 
-		const U32 occlusion_divisor = 3;
+        const U32 occlusion_divisor = 3;
 
-		F32 scale = llmax(0.f,RenderShadowResolutionScale);
-		U32 sun_shadow_map_width  = BlurHappySize(resX, scale);
-		U32 sun_shadow_map_height = BlurHappySize(resY, scale);
+        F32 scale = llmax(0.f, RenderShadowResolutionScale);
+        U32 sun_shadow_map_width = BlurHappySize(resX, scale);
+        U32 sun_shadow_map_height = BlurHappySize(resY, scale);
 
-		if (shadow_detail > 0)
-		{ //allocate 4 sun shadow maps
-			for (U32 i = 0; i < 4; i++)
-			{
-				if (!mRT->shadow[i].allocate(sun_shadow_map_width, sun_shadow_map_height, 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE))
+        if (shadow_detail > 0)
+        { //allocate 4 sun shadow maps
+            for (U32 i = 0; i < 4; i++)
+            {
+                if (!mRT->shadow[i].allocate(sun_shadow_map_width, sun_shadow_map_height, 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE))
                 {
                     return false;
                 }
 
-                if (!mRT->shadowOcclusion[i].allocate(sun_shadow_map_width/occlusion_divisor, sun_shadow_map_height/occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE))
+                if (!mRT->shadowOcclusion[i].allocate(sun_shadow_map_width / occlusion_divisor, sun_shadow_map_height / occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_TEXTURE))
                 {
                     return false;
                 }
-			}
-		}
-		else
-		{
-			for (U32 i = 0; i < 4; i++)
-			{
-                releaseShadowTarget(i);
-			}
-		}
+            }
+        }
+        else
+        {
+            for (U32 i = 0; i < 4; i++)
+            {
+                releaseSunShadowTarget(i);
+            }
+        }
 
-		U32 width = (U32) (resX*scale);
-		U32 height = width;
+        if (!gCubeSnapshot) // hack to not allocate spot shadow maps during ReflectionMapManager init
+        {
+            U32 width = (U32)(resX * scale);
+            U32 height = width;
 
-		if (shadow_detail > 1)
-		{ //allocate two spot shadow maps
-			U32 spot_shadow_map_width = width;
-            U32 spot_shadow_map_height = height;
-			for (U32 i = 4; i < 6; i++)
-			{
-                if (!mRT->shadow[i].allocate(spot_shadow_map_width, spot_shadow_map_height, 0, TRUE, FALSE))
-		{
-                    return false;
-			}
-                if (!mRT->shadowOcclusion[i].allocate(spot_shadow_map_width/occlusion_divisor, height/occlusion_divisor, 0, TRUE, FALSE))
-		{
-			return false;
-		}
-	}
+            if (shadow_detail > 1)
+            { //allocate two spot shadow maps
+                U32 spot_shadow_map_width = width;
+                U32 spot_shadow_map_height = height;
+                for (U32 i = 0; i < 2; i++)
+                {
+                    if (!mSpotShadow[i].allocate(spot_shadow_map_width, spot_shadow_map_height, 0, TRUE, FALSE))
+                    {
+                        return false;
+                    }
+                    if (!mSpotShadowOcclusion[i].allocate(spot_shadow_map_width / occlusion_divisor, height / occlusion_divisor, 0, TRUE, FALSE))
+                    {
+                        return false;
+                    }
+                }
+            }
+            else
+            {
+                releaseSpotShadowTargets();
+            }
         }
-	else
-	{
-            for (U32 i = 4; i < 6; i++)
-		{
-                releaseShadowTarget(i);
-		}
-	}
-	}
+    }
 
 	return true;
 }
@@ -1175,7 +1178,8 @@ void LLPipeline::releaseLUTBuffers()
 
 void LLPipeline::releaseShadowBuffers()
 {
-    releaseShadowTargets();
+    releaseSunShadowTargets();
+    releaseSpotShadowTargets();
 }
 
 void LLPipeline::releaseScreenBuffers()
@@ -1191,20 +1195,33 @@ void LLPipeline::releaseScreenBuffers()
 }
 		
 		
-void LLPipeline::releaseShadowTarget(U32 index)
+void LLPipeline::releaseSunShadowTarget(U32 index)
 {
+    llassert(index < 4);
     mRT->shadow[index].release();
     mRT->shadowOcclusion[index].release();
 }
 
-void LLPipeline::releaseShadowTargets()
+void LLPipeline::releaseSunShadowTargets()
 {
-	for (U32 i = 0; i < 6; i++)
+	for (U32 i = 0; i < 4; i++)
 	{
-        releaseShadowTarget(i);
+        releaseSunShadowTarget(i);
 	}
 }
 
+void LLPipeline::releaseSpotShadowTargets()
+{
+    if (!gCubeSnapshot) // hack to avoid freeing spot shadows during ReflectionMapManager init
+    {
+        for (U32 i = 0; i < 2; i++)
+        {
+            mSpotShadow[i].release();
+            mSpotShadowOcclusion[i].release();
+        }
+    }
+}
+
 void LLPipeline::createGLBuffers()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE;
@@ -8162,7 +8179,7 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_
 
 	for (U32 i = 0; i < 4; i++)
 	{
-        LLRenderTarget* shadow_target = getShadowTarget(i);
+        LLRenderTarget* shadow_target = getSunShadowTarget(i);
         if (shadow_target)
         {
 		channel = shader.enableTexture(LLShaderMgr::DEFERRED_SHADOW0+i, LLTexUnit::TT_TEXTURE);
@@ -8170,7 +8187,7 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_
 		if (channel > -1)
 		{
 			stop_glerror();
-                gGL.getTexUnit(channel)->bind(getShadowTarget(i), TRUE);
+                gGL.getTexUnit(channel)->bind(getSunShadowTarget(i), TRUE);
                 gGL.getTexUnit(channel)->setTextureFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
 			gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
 			stop_glerror();
@@ -8182,27 +8199,27 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_
 	}
     }
 
-	for (U32 i = 4; i < 6; i++)
-	{
-		channel = shader.enableTexture(LLShaderMgr::DEFERRED_SHADOW0+i);
-		stop_glerror();
-		if (channel > -1)
-		{
-			stop_glerror();
-			LLRenderTarget* shadow_target = getShadowTarget(i);
-			if (shadow_target)
-			{
-				gGL.getTexUnit(channel)->bind(shadow_target, TRUE);
-				gGL.getTexUnit(channel)->setTextureFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
-			gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
-			stop_glerror();
-			
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
-			stop_glerror();
-		}
-	}
-	}
+    for (U32 i = 4; i < 6; i++)
+    {
+        channel = shader.enableTexture(LLShaderMgr::DEFERRED_SHADOW0 + i);
+        stop_glerror();
+        if (channel > -1)
+        {
+            stop_glerror();
+            LLRenderTarget* shadow_target = getSpotShadowTarget(i-4);
+            if (shadow_target)
+            {
+                gGL.getTexUnit(channel)->bind(shadow_target, TRUE);
+                gGL.getTexUnit(channel)->setTextureFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
+                gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
+                stop_glerror();
+
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
+                stop_glerror();
+            }
+        }
+    }
 
 	stop_glerror();
 
@@ -8313,7 +8330,7 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_
 	shader.uniform3fv(LLShaderMgr::DEFERRED_SUN_DIR, 1, mTransformedSunDir.mV);
     shader.uniform3fv(LLShaderMgr::DEFERRED_MOON_DIR, 1, mTransformedMoonDir.mV);
 	shader.uniform2f(LLShaderMgr::DEFERRED_SHADOW_RES, mRT->shadow[0].getWidth(), mRT->shadow[0].getHeight());
-	shader.uniform2f(LLShaderMgr::DEFERRED_PROJ_SHADOW_RES, mRT->shadow[4].getWidth(), mRT->shadow[4].getHeight());
+	shader.uniform2f(LLShaderMgr::DEFERRED_PROJ_SHADOW_RES, mSpotShadow[0].getWidth(), mSpotShadow[0].getHeight());
 	shader.uniform1f(LLShaderMgr::DEFERRED_DEPTH_CUTOFF, RenderEdgeDepthCutoff);
 	shader.uniform1f(LLShaderMgr::DEFERRED_NORM_CUTOFF, RenderEdgeNormCutoff);
 	
@@ -9077,7 +9094,7 @@ void LLPipeline::setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep)
 		shader.uniform1f(LLShaderMgr::PROJECTOR_SHADOW_FADE, 1.f);
 	}
 
-    if (!gCubeSnapshot)
+    //if (!gCubeSnapshot)
 	{
 		LLDrawable* potential = drawablep;
 		//determine if this is a good light for casting shadows
@@ -9668,7 +9685,9 @@ void LLPipeline::renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera
         gDeferredShadowCubeProgram.bind();
     }
 
-    LLRenderTarget& occlusion_target = mRT->shadowOcclusion[LLViewerCamera::sCurCameraID - 1];
+    LLRenderTarget& occlusion_target = LLViewerCamera::sCurCameraID >= LLViewerCamera::CAMERA_SPOT_SHADOW0 ?
+        mSpotShadowOcclusion[LLViewerCamera::sCurCameraID - LLViewerCamera::CAMERA_SPOT_SHADOW0] :
+        mRT->shadowOcclusion[LLViewerCamera::sCurCameraID - LLViewerCamera::CAMERA_SUN_SHADOW0];
 
     occlusion_target.bindTarget();
     updateCull(shadow_cam, result);
@@ -9812,7 +9831,9 @@ void LLPipeline::renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera
     gGLLastMatrix = NULL;
     gGL.loadMatrix(gGLModelView);
 
-    LLRenderTarget& occlusion_source = mRT->shadow[LLViewerCamera::sCurCameraID - 1];
+    LLRenderTarget& occlusion_source = LLViewerCamera::sCurCameraID >= LLViewerCamera::CAMERA_SPOT_SHADOW0 ?
+        mSpotShadow[LLViewerCamera::sCurCameraID - LLViewerCamera::CAMERA_SPOT_SHADOW0] :
+        mRT->shadow[LLViewerCamera::sCurCameraID - LLViewerCamera::CAMERA_SUN_SHADOW0];
 
     if (occlude > 1)
     {
@@ -10087,11 +10108,18 @@ void LLPipeline::generateHighlight(LLCamera& camera)
 	}
 }
 
-LLRenderTarget* LLPipeline::getShadowTarget(U32 i)
+LLRenderTarget* LLPipeline::getSunShadowTarget(U32 i)
 {
+    llassert(i < 4);
     return &mRT->shadow[i];
 }
 
+LLRenderTarget* LLPipeline::getSpotShadowTarget(U32 i)
+{
+    llassert(i < 2);
+    return &mSpotShadow[i];
+}
+
 static LLTrace::BlockTimerStatHandle FTM_GEN_SUN_SHADOW("Gen Sun Shadow");
 static LLTrace::BlockTimerStatHandle FTM_GEN_SUN_SHADOW_SPOT_RENDER("Spot Shadow Render");
 
@@ -10371,7 +10399,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
 				mShadowFrustPoints[j].clear();
 			}
 
-			LLViewerCamera::sCurCameraID = (LLViewerCamera::eCameraID)(LLViewerCamera::CAMERA_SHADOW0+j);
+			LLViewerCamera::sCurCameraID = (LLViewerCamera::eCameraID)(LLViewerCamera::CAMERA_SUN_SHADOW0+j);
 
 			//restore render matrices
 			set_current_modelview(saved_view);
@@ -10745,116 +10773,119 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
 	{
         if (!gCubeSnapshot) //skip updating spot shadow maps during cubemap updates
         {
-		    LLTrace::CountStatHandle<>* velocity_stat = LLViewerCamera::getVelocityStat();
-		    F32 fade_amt = gFrameIntervalSeconds.value() 
-			    * llmax(LLTrace::get_frame_recording().getLastRecording().getSum(*velocity_stat) / LLTrace::get_frame_recording().getLastRecording().getDuration().value(), 1.0);
-
-		    //update shadow targets
-		    for (U32 i = 0; i < 2; i++)
-		    { //for each current shadow
-			    LLViewerCamera::sCurCameraID = (LLViewerCamera::eCameraID)(LLViewerCamera::CAMERA_SHADOW4+i);
-
-			    if (mShadowSpotLight[i].notNull() && 
-				    (mShadowSpotLight[i] == mTargetShadowSpotLight[0] ||
-				    mShadowSpotLight[i] == mTargetShadowSpotLight[1]))
-			    { //keep this spotlight
-				    mSpotLightFade[i] = llmin(mSpotLightFade[i]+fade_amt, 1.f);
-			    }
-			    else
-			    { //fade out this light
-				    mSpotLightFade[i] = llmax(mSpotLightFade[i]-fade_amt, 0.f);
-				
-				    if (mSpotLightFade[i] == 0.f || mShadowSpotLight[i].isNull())
-				    { //faded out, grab one of the pending spots (whichever one isn't already taken)
-					    if (mTargetShadowSpotLight[0] != mShadowSpotLight[(i+1)%2])
-					    {
-						    mShadowSpotLight[i] = mTargetShadowSpotLight[0];
-					    }
-					    else
-					    {
-						    mShadowSpotLight[i] = mTargetShadowSpotLight[1];
-					    }
-				    }
-			    }
-		    }
-
-            for (S32 i = 0; i < 2; i++)
-            {
-                set_current_modelview(saved_view);
-                set_current_projection(saved_proj);
+            LLTrace::CountStatHandle<>* velocity_stat = LLViewerCamera::getVelocityStat();
+            F32 fade_amt = gFrameIntervalSeconds.value()
+                * llmax(LLTrace::get_frame_recording().getLastRecording().getSum(*velocity_stat) / LLTrace::get_frame_recording().getLastRecording().getDuration().value(), 1.0);
+
+            //update shadow targets
+            for (U32 i = 0; i < 2; i++)
+            { //for each current shadow
+                LLViewerCamera::sCurCameraID = (LLViewerCamera::eCameraID)(LLViewerCamera::CAMERA_SPOT_SHADOW0 + i);
+
+                if (mShadowSpotLight[i].notNull() &&
+                    (mShadowSpotLight[i] == mTargetShadowSpotLight[0] ||
+                        mShadowSpotLight[i] == mTargetShadowSpotLight[1]))
+                { //keep this spotlight
+                    mSpotLightFade[i] = llmin(mSpotLightFade[i] + fade_amt, 1.f);
+                }
+                else
+                { //fade out this light
+                    mSpotLightFade[i] = llmax(mSpotLightFade[i] - fade_amt, 0.f);
 
-                if (mShadowSpotLight[i].isNull())
-                {
-                    continue;
+                    if (mSpotLightFade[i] == 0.f || mShadowSpotLight[i].isNull())
+                    { //faded out, grab one of the pending spots (whichever one isn't already taken)
+                        if (mTargetShadowSpotLight[0] != mShadowSpotLight[(i + 1) % 2])
+                        {
+                            mShadowSpotLight[i] = mTargetShadowSpotLight[0];
+                        }
+                        else
+                        {
+                            mShadowSpotLight[i] = mTargetShadowSpotLight[1];
+                        }
+                    }
                 }
+            }
+        }
 
-                LLVOVolume* volume = mShadowSpotLight[i]->getVOVolume();
+        for (S32 i = 0; i < 2; i++)
+        {
+            set_current_modelview(saved_view);
+            set_current_projection(saved_proj);
 
-                if (!volume)
-                {
-                    mShadowSpotLight[i] = NULL;
-                    continue;
-                }
+            if (mShadowSpotLight[i].isNull())
+            {
+                continue;
+            }
 
-                LLDrawable* drawable = mShadowSpotLight[i];
+            LLVOVolume* volume = mShadowSpotLight[i]->getVOVolume();
 
-                LLVector3 params = volume->getSpotLightParams();
-                F32 fov = params.mV[0];
+            if (!volume)
+            {
+                mShadowSpotLight[i] = NULL;
+                continue;
+            }
 
-                //get agent->light space matrix (modelview)
-                LLVector3 center = drawable->getPositionAgent();
-                LLQuaternion quat = volume->getRenderRotation();
+            LLDrawable* drawable = mShadowSpotLight[i];
 
-                //get near clip plane
-                LLVector3 scale = volume->getScale();
-                LLVector3 at_axis(0, 0, -scale.mV[2] * 0.5f);
-                at_axis *= quat;
+            LLVector3 params = volume->getSpotLightParams();
+            F32 fov = params.mV[0];
 
-                LLVector3 np = center + at_axis;
-                at_axis.normVec();
+            //get agent->light space matrix (modelview)
+            LLVector3 center = drawable->getPositionAgent();
+            LLQuaternion quat = volume->getRenderRotation();
 
-                //get origin that has given fov for plane np, at_axis, and given scale
-                F32 dist = (scale.mV[1] * 0.5f) / tanf(fov * 0.5f);
+            //get near clip plane
+            LLVector3 scale = volume->getScale();
+            LLVector3 at_axis(0, 0, -scale.mV[2] * 0.5f);
+            at_axis *= quat;
 
-                LLVector3 origin = np - at_axis * dist;
+            LLVector3 np = center + at_axis;
+            at_axis.normVec();
 
-                LLMatrix4 mat(quat, LLVector4(origin, 1.f));
+            //get origin that has given fov for plane np, at_axis, and given scale
+            F32 dist = (scale.mV[1] * 0.5f) / tanf(fov * 0.5f);
 
-                view[i + 4] = glh::matrix4f((F32*)mat.mMatrix);
+            LLVector3 origin = np - at_axis * dist;
 
-                view[i + 4] = view[i + 4].inverse();
+            LLMatrix4 mat(quat, LLVector4(origin, 1.f));
 
-                //get perspective matrix
-                F32 near_clip = dist + 0.01f;
-                F32 width = scale.mV[VX];
-                F32 height = scale.mV[VY];
-                F32 far_clip = dist + volume->getLightRadius() * 1.5f;
+            view[i + 4] = glh::matrix4f((F32*)mat.mMatrix);
 
-                F32 fovy = fov * RAD_TO_DEG;
-                F32 aspect = width / height;
+            view[i + 4] = view[i + 4].inverse();
 
-                proj[i + 4] = gl_perspective(fovy, aspect, near_clip, far_clip);
+            //get perspective matrix
+            F32 near_clip = dist + 0.01f;
+            F32 width = scale.mV[VX];
+            F32 height = scale.mV[VY];
+            F32 far_clip = dist + volume->getLightRadius() * 1.5f;
 
-                //translate and scale to from [-1, 1] to [0, 1]
-                glh::matrix4f trans(0.5f, 0.f, 0.f, 0.5f,
-                    0.f, 0.5f, 0.f, 0.5f,
-                    0.f, 0.f, 0.5f, 0.5f,
-                    0.f, 0.f, 0.f, 1.f);
+            F32 fovy = fov * RAD_TO_DEG;
+            F32 aspect = width / height;
 
-                set_current_modelview(view[i + 4]);
-                set_current_projection(proj[i + 4]);
+            proj[i + 4] = gl_perspective(fovy, aspect, near_clip, far_clip);
 
-                mSunShadowMatrix[i + 4] = trans * proj[i + 4] * view[i + 4] * inv_view;
+            //translate and scale to from [-1, 1] to [0, 1]
+            glh::matrix4f trans(0.5f, 0.f, 0.f, 0.5f,
+                0.f, 0.5f, 0.f, 0.5f,
+                0.f, 0.f, 0.5f, 0.5f,
+                0.f, 0.f, 0.f, 1.f);
 
-                for (U32 j = 0; j < 16; j++)
-                {
-                    gGLLastModelView[j] = mShadowModelview[i + 4].m[j];
-                    gGLLastProjection[j] = mShadowProjection[i + 4].m[j];
-                }
+            set_current_modelview(view[i + 4]);
+            set_current_projection(proj[i + 4]);
 
-                mShadowModelview[i + 4] = view[i + 4];
-                mShadowProjection[i + 4] = proj[i + 4];
+            mSunShadowMatrix[i + 4] = trans * proj[i + 4] * view[i + 4] * inv_view;
 
+            for (U32 j = 0; j < 16; j++)
+            {
+                gGLLastModelView[j] = mShadowModelview[i + 4].m[j];
+                gGLLastProjection[j] = mShadowProjection[i + 4].m[j];
+            }
+
+            mShadowModelview[i + 4] = view[i + 4];
+            mShadowProjection[i + 4] = proj[i + 4];
+
+            if (!gCubeSnapshot) //skip updating spot shadow maps during cubemap updates
+            {
                 LLCamera shadow_cam = camera;
                 shadow_cam.setFar(far_clip);
                 shadow_cam.setOrigin(origin);
@@ -10863,15 +10894,17 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
 
                 stop_glerror();
 
-                mRT->shadow[i + 4].bindTarget();
-                mRT->shadow[i + 4].getViewport(gGLViewport);
-                mRT->shadow[i + 4].clear();
+                //
+                
+                mSpotShadow[i].bindTarget();
+                mSpotShadow[i].getViewport(gGLViewport);
+                mSpotShadow[i].clear();
 
-                U32 target_width = mRT->shadow[i + 4].getWidth();
+                U32 target_width = mSpotShadow[i].getWidth();
 
                 static LLCullResult result[2];
 
-                LLViewerCamera::sCurCameraID = (LLViewerCamera::eCameraID)(LLViewerCamera::CAMERA_SHADOW0 + i + 4);
+                LLViewerCamera::sCurCameraID = (LLViewerCamera::eCameraID)(LLViewerCamera::CAMERA_SPOT_SHADOW0 + i);
 
                 RenderSpotLight = drawable;
 
@@ -10879,7 +10912,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera)
 
                 RenderSpotLight = nullptr;
 
-                mRT->shadow[i + 4].flush();
+                mSpotShadow[i].flush();
             }
         }
 	}