From 0d7fa932d579f3fb6140658db7efb01fcd8f5ceb Mon Sep 17 00:00:00 2001
From: "Graham Linden graham@lindenlab.com"
 <Graham Linden graham@lindenlab.com>
Date: Fri, 20 Apr 2018 18:14:29 +0100
Subject: Move class3 sky/cloud shaders to where they need to be to get picked
 up by ALM.

Modify autobuild.xml to use new libatmo w/ state save/restore fixes (addresses font render glitch).

Put in nSight debug support.
---
 .../shaders/class3/deferred/cloudsF.glsl           | 104 +++++++++++
 .../shaders/class3/deferred/cloudsV.glsl           | 190 +++++++++++++++++++++
 .../app_settings/shaders/class3/deferred/skyF.glsl |  69 ++++++++
 .../app_settings/shaders/class3/deferred/skyV.glsl |  43 +++++
 4 files changed, 406 insertions(+)
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/skyV.glsl

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
new file mode 100644
index 0000000000..96c70651b1
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -0,0 +1,104 @@
+/** 
+ * @file WLCloudsF.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+ 
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+/////////////////////////////////////////////////////////////////////////
+// The fragment shader for the sky
+/////////////////////////////////////////////////////////////////////////
+
+VARYING vec4 vary_CloudColorSun;
+VARYING vec4 vary_CloudColorAmbient;
+VARYING float vary_CloudDensity;
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec2 vary_texcoord3;
+
+uniform sampler2D cloud_noise_texture;
+uniform vec4 cloud_pos_density1;
+uniform vec4 cloud_pos_density2;
+uniform vec4 gamma;
+
+/// Soft clips the light with a gamma correction
+vec3 scaleSoftClip(vec3 light) {
+	//soft clip effect:
+	light = 1. - clamp(light, vec3(0.), vec3(1.));
+	light = 1. - pow(light, gamma.xxx);
+
+	return light;
+}
+
+void main()
+{
+	// Set variables
+	vec2 uv1 = vary_texcoord0.xy;
+	vec2 uv2 = vary_texcoord1.xy;
+
+	vec4 cloudColorSun = vary_CloudColorSun;
+	vec4 cloudColorAmbient = vary_CloudColorAmbient;
+	float cloudDensity = vary_CloudDensity;
+	vec2 uv3 = vary_texcoord2.xy;
+	vec2 uv4 = vary_texcoord3.xy;
+
+	// Offset texture coords
+	uv1 += cloud_pos_density1.xy;	//large texture, visible density
+	uv2 += cloud_pos_density1.xy;	//large texture, self shadow
+	uv3 += cloud_pos_density2.xy;	//small texture, visible density
+	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
+
+
+	// Compute alpha1, the main cloud opacity
+	float alpha1 = (texture2D(cloud_noise_texture, uv1).x - 0.5) + (texture2D(cloud_noise_texture, uv3).x - 0.5) * cloud_pos_density2.z;
+	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10. * cloud_pos_density1.z, 1.);
+
+	// And smooth
+	alpha1 = 1. - alpha1 * alpha1;
+	alpha1 = 1. - alpha1 * alpha1;	
+
+
+	// Compute alpha2, for self shadowing effect
+	// (1 - alpha2) will later be used as percentage of incoming sunlight
+	float alpha2 = (texture2D(cloud_noise_texture, uv2).x - 0.5);
+	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
+
+	// And smooth
+	alpha2 = 1. - alpha2;
+	alpha2 = 1. - alpha2 * alpha2;	
+
+	// Combine
+	vec4 color;
+	color = (cloudColorSun*(1.-alpha2) + cloudColorAmbient);
+	color *= 2.;
+
+	/// Gamma correct for WL (soft clip effect).
+	frag_color.rgb = scaleSoftClip(color.rgb);
+	frag_color.a = alpha1;
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
new file mode 100644
index 0000000000..c1dd45cd67
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
@@ -0,0 +1,190 @@
+/** 
+ * @file WLCloudsV.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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;
+ATTRIBUTE vec2 texcoord0;
+
+//////////////////////////////////////////////////////////////////////////
+// The vertex shader for creating the atmospheric sky
+///////////////////////////////////////////////////////////////////////////////
+
+// Output parameters
+VARYING vec4 vary_CloudColorSun;
+VARYING vec4 vary_CloudColorAmbient;
+VARYING float vary_CloudDensity;
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec2 vary_texcoord3;
+
+// Inputs
+uniform vec3 camPosLocal;
+
+uniform vec4 lightnorm;
+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 max_y;
+
+uniform vec4 glow;
+
+uniform vec4 cloud_color;
+
+uniform float cloud_scale;
+
+void main()
+{
+
+	// World / view / projection
+	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
+
+	vary_texcoord0 = texcoord0;
+
+	// Get relative position
+	vec3 P = position.xyz - camPosLocal.xyz + vec3(0,50,0);
+
+	// Set altitude
+	if (P.y > 0.)
+	{
+		P *= (max_y / P.y);
+	}
+	else
+	{
+		P *= (-32000. / P.y);
+	}
+
+	// Can normalize then
+	vec3 Pn = normalize(P);
+	float  Plen = length(P);
+
+	// Initialize temp variables
+	vec4 temp1 = vec4(0.);
+	vec4 temp2 = vec4(0.);
+	vec4 blue_weight;
+	vec4 haze_weight;
+	vec4 sunlight = sunlight_color;
+	vec4 light_atten;
+
+
+	// Sunlight attenuation effect (hue and brightness) due to atmosphere
+	// this is used later for sunlight modulation at various altitudes
+	light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
+
+	// Calculate relative weights
+	temp1 = blue_density + haze_density;
+	blue_weight = blue_density / temp1;
+	haze_weight = haze_density / temp1;
+
+	// Compute sunlight from P & lightnorm (for long rays like sky)
+	temp2.y = max(0., max(0., Pn.y) * 1.0 + lightnorm.y );
+	temp2.y = 1. / temp2.y;
+	sunlight *= exp( - light_atten * temp2.y);
+
+	// Distance
+	temp2.z = Plen * density_multiplier;
+
+	// Transparency (-> temp1)
+	// ATI Bugfix -- can't store temp1*temp2.z in a variable because the ati
+	// compiler gets confused.
+	temp1 = exp(-temp1 * temp2.z);
+
+
+	// Compute haze glow
+	temp2.x = dot(Pn, lightnorm.xyz);
+	temp2.x = 1. - temp2.x;
+		// temp2.x is 0 at the sun and increases away from sun
+	temp2.x = max(temp2.x, .001);	
+		// Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
+	temp2.x *= glow.x;
+		// Higher glow.x gives dimmer glow (because next step is 1 / "angle")
+	temp2.x = pow(temp2.x, glow.z);
+		// glow.z should be negative, so we're doing a sort of (1 / "angle") function
+
+	// Add "minimum anti-solar illumination"
+	temp2.x += .25;
+
+	// Increase ambient when there are more clouds
+	vec4 tmpAmbient = ambient;
+	tmpAmbient += (1. - tmpAmbient) * cloud_shadow * 0.5; 
+
+	// Dim sunlight by cloud shadow percentage
+	sunlight *= (1. - cloud_shadow);
+
+	// Haze color below cloud
+	vec4 additiveColorBelowCloud = (	  blue_horizon * blue_weight * (sunlight + tmpAmbient)
+				+ (haze_horizon * haze_weight) * (sunlight * temp2.x + tmpAmbient)
+			 );	
+
+	// CLOUDS
+
+	sunlight = sunlight_color;
+	temp2.y = max(0., lightnorm.y * 2.);
+	temp2.y = 1. / temp2.y;
+	sunlight *= exp( - light_atten * temp2.y);
+
+	// Cloud color out
+	vary_CloudColorSun = (sunlight * temp2.x) * cloud_color;
+	vary_CloudColorAmbient = tmpAmbient * cloud_color;
+	
+	// Attenuate cloud color by atmosphere
+	temp1 = sqrt(temp1);	//less atmos opacity (more transparency) below clouds
+	vary_CloudColorSun *= temp1;
+	vary_CloudColorAmbient *= temp1;
+	vec4 oHazeColorBelowCloud = additiveColorBelowCloud * (1. - temp1);
+
+	// Make a nice cloud density based on the cloud_shadow value that was passed in.
+	vary_CloudDensity = 2. * (cloud_shadow - 0.25);
+
+
+	// Texture coords
+	vary_texcoord0 = texcoord0;
+	vary_texcoord0.xy -= 0.5;
+	vary_texcoord0.xy /= cloud_scale;
+	vary_texcoord0.xy += 0.5;
+
+	vary_texcoord1 = vary_texcoord0;
+	vary_texcoord1.x += lightnorm.x * 0.0125;
+	vary_texcoord1.y += lightnorm.z * 0.0125;
+
+	vary_texcoord2 = vary_texcoord0 * 16.;
+	vary_texcoord3 = vary_texcoord1 * 16.;
+
+	// Combine these to minimize register use
+	vary_CloudColorAmbient += oHazeColorBelowCloud;
+
+	// needs this to compile on mac
+	//vary_AtmosAttenuation = vec3(0.0,0.0,0.0);
+
+	// END CLOUDS
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
new file mode 100644
index 0000000000..0223f94e55
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -0,0 +1,69 @@
+/** 
+ * @file advancedAtmoF.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+ 
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+in vec3 view_dir;
+
+uniform vec3 cameraPosLocal;
+uniform vec3 sun_direction;
+uniform vec2 sun_size;
+
+uniform sampler2D cloud_noise_texture;
+uniform sampler2D transmittance_texture;
+uniform sampler3D scattering_texture;
+uniform sampler3D single_mie_scattering_texture;
+uniform sampler2D irradiance_texture;
+
+vec3 GetSolarLuminance();
+vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 sun_dir, out vec3 transmittance);
+vec3 GetSkyLuminanceToPoint(vec3 camPos, vec3 pos, float shadow_length, vec3 sun_dir, out vec3 transmittance);
+vec3 GetSunAndSkyIlluminance(vec3 pos, vec3 norm, vec3 sun_dir, out vec3 sky_irradiance);
+
+void main()
+{
+    vec3 view_direction = normalize(view_dir);
+
+    vec3 camPos = cameraPosLocal + vec3(0, 0, 6360.0f);
+    vec3 transmittance;
+    vec3 radiance = GetSkyLuminance(camPos, view_direction, 0.0f, sun_direction, transmittance);
+
+    // If the view ray intersects the Sun, add the Sun radiance.
+    if (dot(view_direction, sun_direction) >= sun_size.y)
+    {
+        radiance = radiance + (transmittance * GetSolarLuminance());
+    }
+
+    vec3 color = vec3(1.0) - exp(-radiance);
+    color = pow(color, vec3(1.0 / 2.2));
+
+    frag_color.rgb = color;
+    frag_color.a = 1.0;
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
new file mode 100644
index 0000000000..52a7595379
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -0,0 +1,43 @@
+/** 
+ * @file advancedAtmoV.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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;
+
+// Inputs
+uniform vec3 camPosLocal;
+
+out vec3 view_dir;
+
+void main()
+{
+	// World / view / projection
+	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
+
+	// this will be normalized in the frag shader...
+	view_dir = position.xyz - camPosLocal.xyz; 
+}
+
-- 
cgit v1.2.3


From 3116416fcb8dfd54ef2807e9e75959429c946d79 Mon Sep 17 00:00:00 2001
From: "Graham Linden graham@lindenlab.com"
 <Graham Linden graham@lindenlab.com>
Date: Tue, 1 May 2018 00:10:11 +0100
Subject: Le Merge

---
 .../app_settings/shaders/class3/deferred/skyF.glsl | 28 +++++++++++++++++-----
 .../app_settings/shaders/class3/deferred/skyV.glsl | 14 ++++++++---
 2 files changed, 33 insertions(+), 9 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 0223f94e55..5185a9f8f4 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -29,11 +29,12 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
+in vec3 view_pos;
 in vec3 view_dir;
 
 uniform vec3 cameraPosLocal;
-uniform vec3 sun_direction;
-uniform vec2 sun_size;
+uniform vec3 sun_dir;
+uniform float sun_size;
 
 uniform sampler2D cloud_noise_texture;
 uniform sampler2D transmittance_texture;
@@ -50,20 +51,35 @@ void main()
 {
     vec3 view_direction = normalize(view_dir);
 
+    vec3 sun_direction = sun_dir;
+
     vec3 camPos = cameraPosLocal + vec3(0, 0, 6360.0f);
     vec3 transmittance;
+    vec3 sky_illum;
     vec3 radiance = GetSkyLuminance(camPos, view_direction, 0.0f, sun_direction, transmittance);
+    vec3 radiance2 = GetSunAndSkyIlluminance(camPos, view_direction, sun_direction, sky_illum);
+
+    radiance *= 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.y)
+    if (dot(view_direction, sun_direction) >= sun_size)
     {
-        radiance = radiance + (transmittance * GetSolarLuminance());
+        radiance = radiance + solar_luminance;
     }
 
-    vec3 color = vec3(1.0) - exp(-radiance);
-    color = pow(color, vec3(1.0 / 2.2));
+    vec3 color = radiance;
+    
+    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);
 
     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);
+
     frag_color.a = 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 52a7595379..cf3eb658fc 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -23,21 +23,29 @@
  * $/LicenseInfo$
  */
  
+uniform vec3 cameraPosLocal;
 uniform mat4 modelview_projection_matrix;
+uniform mat4 modelview_matrix;
+uniform mat4 inv_proj;
+uniform mat4 inv_modelview;
 
 ATTRIBUTE vec3 position;
 
 // Inputs
 uniform vec3 camPosLocal;
 
+out vec3 view_pos;
 out vec3 view_dir;
 
 void main()
 {
-	// World / view / projection
-	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
+    // 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 = position.xyz - camPosLocal.xyz; 
+	//view_dir = (inv_modelview * view_pos).xyz;
+    view_dir = view_pos - camPosLocal;
 }
 
-- 
cgit v1.2.3


From fc8d0de673da0e02915556008a365aca67472eba Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 11 Jun 2018 22:39:57 +0100
Subject: Make cloud rendering use textures defined in sky settings and add
 code to shaders to lerp between current and next cloud texture.

---
 .../app_settings/shaders/class3/deferred/cloudsF.glsl     | 15 +++++++++++++--
 .../app_settings/shaders/class3/deferred/skyF.glsl        |  1 -
 2 files changed, 13 insertions(+), 3 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index 96c70651b1..44b41cc0b8 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -42,10 +42,21 @@ VARYING vec2 vary_texcoord2;
 VARYING vec2 vary_texcoord3;
 
 uniform sampler2D cloud_noise_texture;
+uniform sampler2D cloud_noise_texture_next;
+uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
 uniform vec4 gamma;
 
+vec4 cloudNoise(vec2 uv)
+{
+	vec4 a = texture2D(cloud_noise_texture, uv);
+	vec4 b = texture2D(cloud_noise_texture_next, uv);
+    vec4 samp = mix(a, b, blend_factor);
+	return samp;
+}
+
+
 /// Soft clips the light with a gamma correction
 vec3 scaleSoftClip(vec3 light) {
 	//soft clip effect:
@@ -75,7 +86,7 @@ void main()
 
 
 	// Compute alpha1, the main cloud opacity
-	float alpha1 = (texture2D(cloud_noise_texture, uv1).x - 0.5) + (texture2D(cloud_noise_texture, uv3).x - 0.5) * cloud_pos_density2.z;
+	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
 	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10. * cloud_pos_density1.z, 1.);
 
 	// And smooth
@@ -85,7 +96,7 @@ void main()
 
 	// Compute alpha2, for self shadowing effect
 	// (1 - alpha2) will later be used as percentage of incoming sunlight
-	float alpha2 = (texture2D(cloud_noise_texture, uv2).x - 0.5);
+	float alpha2 = (cloudNoise(uv2).x - 0.5);
 	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
 
 	// And smooth
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 5185a9f8f4..a439aa64d7 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -36,7 +36,6 @@ uniform vec3 cameraPosLocal;
 uniform vec3 sun_dir;
 uniform float sun_size;
 
-uniform sampler2D cloud_noise_texture;
 uniform sampler2D transmittance_texture;
 uniform sampler3D scattering_texture;
 uniform sampler3D single_mie_scattering_texture;
-- 
cgit v1.2.3


From 67ab0084f87c40bf31d7fadded55cc9ea6299ca2 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 12 Jun 2018 18:42:07 +0100
Subject: Fix env panel forward action.

Make env panel update environment when jumping frame to frame.

Add separate funcs for sun/moon vectors in various coord systems.

Make haze glow only pay attention to sun (i.e. fix sun glow when moon is near horizon in daytime).
---
 indra/newview/app_settings/shaders/class3/deferred/skyF.glsl | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index a439aa64d7..0fb990611e 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -34,6 +34,7 @@ in vec3 view_dir;
 
 uniform vec3 cameraPosLocal;
 uniform vec3 sun_dir;
+uniform vec3 moon_dir;
 uniform float sun_size;
 
 uniform sampler2D transmittance_texture;
@@ -42,9 +43,9 @@ uniform sampler3D single_mie_scattering_texture;
 uniform sampler2D irradiance_texture;
 
 vec3 GetSolarLuminance();
-vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 sun_dir, out vec3 transmittance);
-vec3 GetSkyLuminanceToPoint(vec3 camPos, vec3 pos, float shadow_length, vec3 sun_dir, out vec3 transmittance);
-vec3 GetSunAndSkyIlluminance(vec3 pos, vec3 norm, vec3 sun_dir, out vec3 sky_irradiance);
+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()
 {
@@ -55,8 +56,9 @@ void main()
     vec3 camPos = cameraPosLocal + vec3(0, 0, 6360.0f);
     vec3 transmittance;
     vec3 sky_illum;
-    vec3 radiance = GetSkyLuminance(camPos, view_direction, 0.0f, sun_direction, transmittance);
-    vec3 radiance2 = GetSunAndSkyIlluminance(camPos, view_direction, sun_direction, 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 *= transmittance;
 
-- 
cgit v1.2.3


From ffdd6c3d7dad87e9873067a923d4e7ce9e6d4d2c Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 10 Jul 2018 23:26:35 +0100
Subject: Make advanced atmo sky shader compile again.

Make atmospheric model avoid redundant work when settings don't change.

Point autobuild.xml at libatmosphere with op== to compare density profiles.
---
 indra/newview/app_settings/shaders/class3/deferred/skyF.glsl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 0fb990611e..43c0505046 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -60,17 +60,17 @@ void main()
     vec3 radiance_sun = GetSkyLuminance(camPos, view_direction, 0.0f, sun_direction, transmittance);
     vec3 radiance2_sun = GetSunAndSkyIlluminance(camPos, view_direction, sun_direction, sky_illum);
 
-    radiance *= transmittance;
+    radiance_sun *= 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)
     {
-        radiance = radiance + solar_luminance;
+        radiance_sun = radiance_sun + solar_luminance;
     }
 
-    vec3 color = radiance;
+    vec3 color = radiance_sun;
     
     color = vec3(1.0) - exp(-color * 0.0001);
 
@@ -79,7 +79,7 @@ void main()
 
     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);
+    //frag_color.rgb = normalize(view_pos);
 
     frag_color.a = 1.0;
 }
-- 
cgit v1.2.3


From facc678391417c5fa8ca659adc1d449bba2fd349 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 9 Aug 2018 22:46:47 +0100
Subject: MAINT-8951

Remove moon_dir related shader code causing sunlight shadow artifacting.
---
 indra/newview/app_settings/shaders/class3/deferred/skyF.glsl | 1 -
 1 file changed, 1 deletion(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 43c0505046..47fa0efe06 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -34,7 +34,6 @@ in vec3 view_dir;
 
 uniform vec3 cameraPosLocal;
 uniform vec3 sun_dir;
-uniform vec3 moon_dir;
 uniform float sun_size;
 
 uniform sampler2D transmittance_texture;
-- 
cgit v1.2.3


From 32631f09a57548c2bbf7e09211a2053ff2e4e47d Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 4 Sep 2018 23:41:36 +0100
Subject: 8283/4 WIP

---
 indra/newview/app_settings/shaders/class3/deferred/skyF.glsl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 47fa0efe06..01c873584f 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
-- 
cgit v1.2.3


From 451ab80ca65a7ae75316442086f42b6553ea6bbe Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 6 Sep 2018 22:50:26 +0100
Subject: Fix tex format mismatch between what libatmosphere was generating and
 what we were claiming to use in rendering.

First pass at sky shader using libatmosphere sky radiance lookup.

Add atmo density controls to ext daycycle floater tabs.
---
 .../app_settings/shaders/class3/deferred/skyF.glsl | 49 ++++++++++------------
 .../app_settings/shaders/class3/deferred/skyV.glsl | 14 ++-----
 2 files changed, 24 insertions(+), 39 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 01c873584f..ef94190d45 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -24,17 +24,19 @@
  */
  
 #ifdef DEFINE_GL_FRAGCOLOR
-out vec4 frag_color;
+out vec4 frag_data[4];
 #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,33 @@ 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)
     {
-        radiance_sun = radiance_sun + solar_luminance;
+        radiance_sun += solar_luminance;
     }
 
-    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);
-
-    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);
+    vec3 color = vec3(1.0) - exp(-radiance_sun * 0.0001);
+    color = pow(color, vec3(1.0 / 2.2));
 
-    frag_color.a = 1.0;
+    frag_data[0] = vec4(color, 1.0);
+    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..90217aed02 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;
+    vary_frag = texcoord0;
 }
 
-- 
cgit v1.2.3


From 4bd2b8b98ba1c562dfd65975a87ef5ee3db35633 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 7 Sep 2018 17:24:29 +0100
Subject: Fix createDensityProfileLayer dropping passed in values.

Enable sky density panel to update advanced atmo precomputed textures.

Take wild stab at appropriate ranges for density parameters in edit panel UI.

Clean up debug-only code that isn't necessary anymore.

Point autobuild at latest version of libatmosphere package.
---
 indra/newview/app_settings/shaders/class3/deferred/skyV.glsl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
index 90217aed02..89873e83ca 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -36,8 +36,8 @@ VARYING vec2 vary_frag;
 
 void main()
 {
-    // pass through untransformed fullscreen pos (clipspace)
-	gl_Position = vec4(position.xyz, 1.0);
+    // pass through untransformed fullscreen pos at back of frustum for proper sky depth testing
+	gl_Position = vec4(position.xy, 0.99f, 1.0);
     vary_frag = texcoord0;
 }
 
-- 
cgit v1.2.3


From 642a4ddd60745db292c543a5cea3b1e5fe606795 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 10 Sep 2018 20:39:48 +0100
Subject: Fixes for switching between atmospherics implementations on the fly.

---
 indra/newview/app_settings/shaders/class3/deferred/skyF.glsl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index ef94190d45..cd0efe8cbb 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -24,7 +24,7 @@
  */
  
 #ifdef DEFINE_GL_FRAGCOLOR
-out vec4 frag_data[4];
+out vec4 frag_data[3];
 #else
 #define frag_data gl_FragData
 #endif
-- 
cgit v1.2.3


From ef2c61275eafa7d1fd3afa3f0eb76397632f12c9 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 10 Sep 2018 21:18:37 +0100
Subject: Move fname back inside class loop. grumble stringstream grumble.

Fix sky depth-testing with advanced atmospherics.
---
 indra/newview/app_settings/shaders/class3/deferred/skyV.glsl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
index 89873e83ca..a5cc49ca30 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -37,7 +37,7 @@ VARYING vec2 vary_frag;
 void main()
 {
     // pass through untransformed fullscreen pos at back of frustum for proper sky depth testing
-	gl_Position = vec4(position.xy, 0.99f, 1.0);
+	gl_Position = vec4(position.xy, 1.0f, 1.0);
     vary_frag = texcoord0;
 }
 
-- 
cgit v1.2.3


From 555dfdc6ef0dab37bc4eaf6ae0b00a857f0609da Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 10 Sep 2018 23:21:34 +0100
Subject: Add copies of existing lighting shaders for advanced atmo path.

Enable advanced atmo by default.

Disable nSight in settings.xml

Remove MSVC debug pragmas.
---
 .../shaders/class3/deferred/multiSpotLightF.glsl   | 314 +++++++++++++++++++++
 .../app_settings/shaders/class3/deferred/skyF.glsl |  13 +-
 .../shaders/class3/deferred/softenLightF.glsl      | 189 +++++++++++++
 .../shaders/class3/deferred/softenLightV.glsl      |  42 +++
 .../shaders/class3/deferred/spotLightF.glsl        | 313 ++++++++++++++++++++
 .../shaders/class3/deferred/sunLightF.glsl         | 247 ++++++++++++++++
 .../shaders/class3/deferred/sunLightSSAOF.glsl     | 308 ++++++++++++++++++++
 .../shaders/class3/deferred/sunLightV.glsl         |  41 +++
 8 files changed, 1463 insertions(+), 4 deletions(-)
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/sunLightV.glsl

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

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 cd0efe8cbb..7bfc114383 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -55,7 +55,7 @@ void main()
     vec3 view_ray = (inv_modelview * vec4(view_pos.xyz, 0.0f)).xyz;
 
     vec3 view_direction = normalize(view_ray);
-    vec3 sun_direction = normalize(sun_dir);
+    vec3 sun_direction  = normalize(sun_dir);
 
     vec3 camPos = (camPosLocal / 1000.0f) + vec3(0, 0, 6360.0f);
     vec3 transmittance;
@@ -63,15 +63,20 @@ void main()
     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 += 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 = vec3(1.0) - exp(-radiance_sun * 0.0001);
+
     color = pow(color, vec3(1.0 / 2.2));
 
-    frag_data[0] = vec4(color, 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/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;	
+}
-- 
cgit v1.2.3


From a167f8857fd242e007a6bcbcee80a54a953f29f3 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 14 Sep 2018 18:42:41 +0100
Subject: SL-1491

Fix name at top of the 3 softenLight shaders so we can differentiate which is in use when using nSight debug.

Made class2 softenLightF shader modulate the atmospherics additive to only specular shading to fix lens flare on terrain etc.
---
 indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index bda33c3213..d2fd70c9e2 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file softenLightF.glsl
+ * @file class3/deferred/softenLightF.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
-- 
cgit v1.2.3


From 1df7760d315430766bba44d4d4c64480b4a6138f Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 14 Sep 2018 21:52:52 +0100
Subject: SL-9632 add uniform and code to supress atmospherics in all shaders
 that could be used by HUDs

Make sky and cloud shaders use common scaleSoftClip implementation in gammaF.glsl
---
 indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index 44b41cc0b8..d9fcc0a9ea 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -58,13 +58,7 @@ vec4 cloudNoise(vec2 uv)
 
 
 /// Soft clips the light with a gamma correction
-vec3 scaleSoftClip(vec3 light) {
-	//soft clip effect:
-	light = 1. - clamp(light, vec3(0.), vec3(1.));
-	light = 1. - pow(light, gamma.xxx);
-
-	return light;
-}
+vec3 scaleSoftClip(vec3 light);
 
 void main()
 {
-- 
cgit v1.2.3


From 5eed233618abd7020e130799be2abe0f986543f6 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 5 Oct 2018 21:32:42 +0100
Subject: SL-1925

More settings for rainbow/halo atmospheric effects, final default asset UUIDs, and shader mods.
---
 .../app_settings/shaders/class3/deferred/skyF.glsl | 40 +++++++++++++++++++---
 1 file changed, 35 insertions(+), 5 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 7bfc114383..2073fc066f 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -42,25 +42,46 @@ uniform sampler2D transmittance_texture;
 uniform sampler3D scattering_texture;
 uniform sampler3D single_mie_scattering_texture;
 uniform sampler2D irradiance_texture;
+uniform sampler2D rainbow_map;
+uniform sampler2D halo_map;
+
+uniform float moisture_level;
+uniform float droplet_radius;
+uniform float ice_level;
 
 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 rainbow(float d)
+{
+   float rad = (droplet_radius - 5.0f) / 1024.0f;
+   return pow(texture2D(rainbow_map, vec2(rad, d)).rgb, vec3(1.8)) * moisture_level;
+}
+
+vec3 halo22(float d)
+{
+   float v = sqrt(max(0, 1 - (d*d)));
+   return texture2D(halo_map, vec2(0, v)).rgb * ice_level;
+}
+
 void main()
 {
-    vec3 pos      = vec3((vary_frag * 2.0) - vec2(1.0, 1.0), 0.0);
+    vec3 pos      = vec3((vary_frag * 2.0) - vec2(1.0, 1.0f), 1.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 view_ray = (inv_modelview * vec4(view_pos.xyz, 0.0f)).xyz + camPosLocal;
 
     vec3 view_direction = normalize(view_ray);
     vec3 sun_direction  = normalize(sun_dir);
+    vec3 earth_center   = vec3(0, 0, -6360.0f);
+    vec3 camPos = (camPosLocal / 1000.0f) - earth_center;
 
-    vec3 camPos = (camPosLocal / 1000.0f) + vec3(0, 0, 6360.0f);
     vec3 transmittance;
     vec3 radiance_sun  = GetSkyLuminance(camPos, view_direction, 0.0f, sun_direction, transmittance);
-    vec3 solar_luminance = transmittance * GetSolarLuminance();
+    vec3 solar_luminance = GetSolarLuminance();
 
     // If the view ray intersects the Sun, add the Sun radiance.
     float s = dot(view_direction, sun_direction);
@@ -68,12 +89,21 @@ void main()
     // cheesy solar disc...
     if (s >= (sun_size * 0.999))
     {
-        radiance_sun += pow(smoothstep(0.0, 1.3, (s - (sun_size * 0.9))), 2.0) * solar_luminance;
+        radiance_sun += pow(smoothstep(0.0, 1.3, (s - (sun_size * 0.9))), 2.0) * solar_luminance * transmittance;
     }
     s = smoothstep(0.9, 1.0, s) * 16.0f;
 
     vec3 color = vec3(1.0) - exp(-radiance_sun * 0.0001);
 
+    float optic_d = dot(view_direction, sun_direction);
+
+    vec3 halo_22 = halo22(optic_d);
+
+    if (optic_d <= 0)
+    color.rgb += rainbow(optic_d);
+
+    color.rgb += halo_22;
+
     color = pow(color, vec3(1.0 / 2.2));
 
     frag_data[0] = vec4(color, 1.0 + s);
-- 
cgit v1.2.3


From f8aac192378462b5824d28808ed84833e2cbfe0f Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 9 Oct 2018 18:44:43 +0100
Subject: SL-1289

add cloud_variance control for randomized perturbance of clouds to break up tiling monotony
---
 .../shaders/class3/deferred/cloudsF.glsl           | 37 ++++++++++++----------
 1 file changed, 21 insertions(+), 16 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index d9fcc0a9ea..9f06319da3 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -36,10 +36,6 @@ out vec4 frag_color;
 VARYING vec4 vary_CloudColorSun;
 VARYING vec4 vary_CloudColorAmbient;
 VARYING float vary_CloudDensity;
-VARYING vec2 vary_texcoord0;
-VARYING vec2 vary_texcoord1;
-VARYING vec2 vary_texcoord2;
-VARYING vec2 vary_texcoord3;
 
 uniform sampler2D cloud_noise_texture;
 uniform sampler2D cloud_noise_texture_next;
@@ -47,19 +43,25 @@ uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
 uniform vec4 gamma;
+uniform float cloud_scale;
+uniform float cloud_variance;
 
-vec4 cloudNoise(vec2 uv)
-{
-	vec4 a = texture2D(cloud_noise_texture, uv);
-	vec4 b = texture2D(cloud_noise_texture_next, uv);
-    vec4 samp = mix(a, b, blend_factor);
-	return samp;
-}
-
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec2 vary_texcoord3;
 
 /// Soft clips the light with a gamma correction
 vec3 scaleSoftClip(vec3 light);
 
+vec4 cloudNoise(vec2 uv)
+{
+   vec4 a = texture2D(cloud_noise_texture, uv);
+   vec4 b = texture2D(cloud_noise_texture_next, uv);
+   vec4 cloud_noise_sample = mix(a, b, blend_factor);
+   return cloud_noise_sample;
+}
+
 void main()
 {
 	// Set variables
@@ -72,16 +74,19 @@ void main()
 	vec2 uv3 = vary_texcoord2.xy;
 	vec2 uv4 = vary_texcoord3.xy;
 
+    vec2 disturbance = vec2(cloudNoise(uv1 / 16.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
+
 	// Offset texture coords
-	uv1 += cloud_pos_density1.xy;	//large texture, visible density
+	uv1 += cloud_pos_density1.xy + disturbance;	//large texture, visible density
 	uv2 += cloud_pos_density1.xy;	//large texture, self shadow
-	uv3 += cloud_pos_density2.xy;	//small texture, visible density
+	uv3 += cloud_pos_density2.xy + disturbance;	//small texture, visible density
 	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
 
 
 	// Compute alpha1, the main cloud opacity
+
 	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
-	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10. * cloud_pos_density1.z, 1.);
+	alpha1 = min(max(alpha1 + cloudDensity, 0.) * (10. + disturbance.y) * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha1 = 1. - alpha1 * alpha1;
@@ -91,7 +96,7 @@ void main()
 	// Compute alpha2, for self shadowing effect
 	// (1 - alpha2) will later be used as percentage of incoming sunlight
 	float alpha2 = (cloudNoise(uv2).x - 0.5);
-	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
+	alpha2 = min(max(alpha2 + cloudDensity, 0.) * (2.5 + disturbance.x) * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha2 = 1. - alpha2;
-- 
cgit v1.2.3


From 4f267a5723e7da2de36b9f2295e4942a4c8bf6c5 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 1 Nov 2018 20:28:47 +0100
Subject: SL-9994

Make shaders use consistent naming and parameter order for transport and atmospheric helpers.

Share transport and gamma correction code where possible.

Add lots of asserts and other validation for when things don't go as planned.

Engage dumpShaderSource to get more source output with shader compilation fail.
---
 .../shaders/class3/deferred/softenLightF.glsl          | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index d2fd70c9e2..2615400e52 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -115,7 +115,6 @@ void main()
 	float light_gamma = 1.0/1.3;
 	da = pow(da, light_gamma);
 
-
 	vec4 diffuse = texture2DRect(diffuseRect, tc);
 
 	//convert to gamma space
@@ -133,14 +132,6 @@ void main()
 
 		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));
@@ -158,8 +149,7 @@ void main()
 			bloom = dot(spec_contrib, spec_contrib) / 6;
 			col += spec_contrib;
 		}
-	
-		
+
 		col = mix(col, diffuse.rgb, diffuse.a);
 
 		if (envIntensity > 0.0)
@@ -169,12 +159,6 @@ void main()
 			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;
-- 
cgit v1.2.3


From 2929998982f37221a58b9fa8037748a2e905f4b1 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 6 Nov 2018 19:33:04 +0000
Subject: Move to using a shared deferredUtil object for getting pos/norm from
 gbuffer.

Eliminate 20+ callsites with copy-paste of getPosition and/or getNorm code.

Make pipeline use getShadowTarget/releaseShadowTarget consistently.
---
 .../shaders/class3/deferred/cloudsF.glsl           |  77 ++++++++----
 .../shaders/class3/deferred/cloudsV.glsl           | 136 ++-------------------
 .../shaders/class3/deferred/multiSpotLightF.glsl   |  13 +-
 .../app_settings/shaders/class3/deferred/skyF.glsl |  13 +-
 .../app_settings/shaders/class3/deferred/skyV.glsl |   8 +-
 .../shaders/class3/deferred/softenLightF.glsl      | 107 +++++++++-------
 .../shaders/class3/deferred/softenLightV.glsl      |  12 +-
 .../shaders/class3/deferred/spotLightF.glsl        |  13 +-
 .../shaders/class3/deferred/sunLightF.glsl         |  22 +---
 .../shaders/class3/deferred/sunLightSSAOF.glsl     |  89 ++------------
 10 files changed, 149 insertions(+), 341 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index 9f06319da3..f8373215f0 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file WLCloudsF.glsl
+ * @file class3/deferred/cloudsF.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -24,9 +24,9 @@
  */
  
 #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
 
 /////////////////////////////////////////////////////////////////////////
@@ -36,20 +36,37 @@ out vec4 frag_color;
 VARYING vec4 vary_CloudColorSun;
 VARYING vec4 vary_CloudColorAmbient;
 VARYING float vary_CloudDensity;
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec2 vary_texcoord3;
+VARYING vec3 vary_pos;
 
 uniform sampler2D cloud_noise_texture;
 uniform sampler2D cloud_noise_texture_next;
 uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
-uniform vec4 gamma;
+uniform vec4 sunlight_color;
+uniform vec4 cloud_color;
+uniform float cloud_shadow;
 uniform float cloud_scale;
 uniform float cloud_variance;
-
-VARYING vec2 vary_texcoord0;
-VARYING vec2 vary_texcoord1;
-VARYING vec2 vary_texcoord2;
-VARYING vec2 vary_texcoord3;
+uniform vec3 ambient;
+uniform vec3 camPosLocal;
+uniform vec3 sun_dir;
+uniform float sun_size;
+uniform float far_z;
+
+uniform sampler2D transmittance_texture;
+uniform sampler3D scattering_texture;
+uniform sampler3D single_mie_scattering_texture;
+uniform sampler2D irradiance_texture;
+uniform sampler2D sh_input_r;
+uniform sampler2D sh_input_g;
+uniform sampler2D sh_input_b;
+
+vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 dir, out vec3 transmittance);
 
 /// Soft clips the light with a gamma correction
 vec3 scaleSoftClip(vec3 light);
@@ -67,11 +84,9 @@ void main()
 	// Set variables
 	vec2 uv1 = vary_texcoord0.xy;
 	vec2 uv2 = vary_texcoord1.xy;
-
-	vec4 cloudColorSun = vary_CloudColorSun;
-	vec4 cloudColorAmbient = vary_CloudColorAmbient;
-	float cloudDensity = vary_CloudDensity;
 	vec2 uv3 = vary_texcoord2.xy;
+	float cloudDensity = 2.0 * (cloud_shadow - 0.25);
+
 	vec2 uv4 = vary_texcoord3.xy;
 
     vec2 disturbance = vec2(cloudNoise(uv1 / 16.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
@@ -82,33 +97,53 @@ void main()
 	uv3 += cloud_pos_density2.xy + disturbance;	//small texture, visible density
 	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
 
+    float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0));
 
-	// Compute alpha1, the main cloud opacity
+    cloudDensity *= 1.0 - (density_variance * density_variance);
 
+	// Compute alpha1, the main cloud opacity
 	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
-	alpha1 = min(max(alpha1 + cloudDensity, 0.) * (10. + disturbance.y) * cloud_pos_density1.z, 1.);
+	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha1 = 1. - alpha1 * alpha1;
 	alpha1 = 1. - alpha1 * alpha1;	
 
+    if (alpha1 < 0.001f)
+    {
+        discard;
+    }
 
 	// Compute alpha2, for self shadowing effect
 	// (1 - alpha2) will later be used as percentage of incoming sunlight
 	float alpha2 = (cloudNoise(uv2).x - 0.5);
-	alpha2 = min(max(alpha2 + cloudDensity, 0.) * (2.5 + disturbance.x) * cloud_pos_density1.z, 1.);
+	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha2 = 1. - alpha2;
 	alpha2 = 1. - alpha2 * alpha2;	
 
+    vec3 view_ray = vary_pos.xyz + camPosLocal;
+
+    vec3 view_direction = normalize(view_ray);
+    vec3 sun_direction  = normalize(sun_dir);
+    vec3 earth_center   = vec3(0, 0, -6360.0f);
+    vec3 camPos = (camPosLocal / 1000.0f) - earth_center;
+
+    vec3 transmittance;
+    vec3 radiance_sun  = GetSkyLuminance(camPos, view_direction, 1.0 - alpha1, sun_direction, transmittance);
+
+    vec3 sun_color = vec3(1.0) - exp(-radiance_sun * 0.0001);
+
 	// Combine
 	vec4 color;
-	color = (cloudColorSun*(1.-alpha2) + cloudColorAmbient);
-	color *= 2.;
 
-	/// Gamma correct for WL (soft clip effect).
-	frag_color.rgb = scaleSoftClip(color.rgb);
-	frag_color.a = alpha1;
+    color.rgb = sun_color * cloud_color.rgb * (1. - alpha2);
+    color.rgb = pow(color.rgb, vec3(1.0 / 2.2));
+    color.rgb += ambient;
+
+	frag_data[0] = vec4(color.rgb, alpha1);
+	frag_data[1] = vec4(0);
+	frag_data[2] = vec4(0,1,0,1);
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
index c1dd45cd67..53b6d88ef5 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
@@ -24,6 +24,7 @@
  */
 
 uniform mat4 modelview_projection_matrix;
+uniform mat4 modelview_matrix;
 
 ATTRIBUTE vec3 position;
 ATTRIBUTE vec2 texcoord0;
@@ -33,158 +34,37 @@ ATTRIBUTE vec2 texcoord0;
 ///////////////////////////////////////////////////////////////////////////////
 
 // Output parameters
-VARYING vec4 vary_CloudColorSun;
-VARYING vec4 vary_CloudColorAmbient;
-VARYING float vary_CloudDensity;
 VARYING vec2 vary_texcoord0;
 VARYING vec2 vary_texcoord1;
 VARYING vec2 vary_texcoord2;
 VARYING vec2 vary_texcoord3;
+VARYING vec3 vary_pos;
 
 // Inputs
-uniform vec3 camPosLocal;
-
-uniform vec4 lightnorm;
-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 max_y;
-
-uniform vec4 glow;
-
-uniform vec4 cloud_color;
-
 uniform float cloud_scale;
+uniform vec4  lightnorm;
+uniform vec3  camPosLocal;
 
 void main()
 {
+    vary_pos = position;
 
 	// World / view / projection
 	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
 
-	vary_texcoord0 = texcoord0;
-
-	// Get relative position
-	vec3 P = position.xyz - camPosLocal.xyz + vec3(0,50,0);
-
-	// Set altitude
-	if (P.y > 0.)
-	{
-		P *= (max_y / P.y);
-	}
-	else
-	{
-		P *= (-32000. / P.y);
-	}
-
-	// Can normalize then
-	vec3 Pn = normalize(P);
-	float  Plen = length(P);
-
-	// Initialize temp variables
-	vec4 temp1 = vec4(0.);
-	vec4 temp2 = vec4(0.);
-	vec4 blue_weight;
-	vec4 haze_weight;
-	vec4 sunlight = sunlight_color;
-	vec4 light_atten;
-
-
-	// Sunlight attenuation effect (hue and brightness) due to atmosphere
-	// this is used later for sunlight modulation at various altitudes
-	light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
-
-	// Calculate relative weights
-	temp1 = blue_density + haze_density;
-	blue_weight = blue_density / temp1;
-	haze_weight = haze_density / temp1;
-
-	// Compute sunlight from P & lightnorm (for long rays like sky)
-	temp2.y = max(0., max(0., Pn.y) * 1.0 + lightnorm.y );
-	temp2.y = 1. / temp2.y;
-	sunlight *= exp( - light_atten * temp2.y);
-
-	// Distance
-	temp2.z = Plen * density_multiplier;
-
-	// Transparency (-> temp1)
-	// ATI Bugfix -- can't store temp1*temp2.z in a variable because the ati
-	// compiler gets confused.
-	temp1 = exp(-temp1 * temp2.z);
-
-
-	// Compute haze glow
-	temp2.x = dot(Pn, lightnorm.xyz);
-	temp2.x = 1. - temp2.x;
-		// temp2.x is 0 at the sun and increases away from sun
-	temp2.x = max(temp2.x, .001);	
-		// Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
-	temp2.x *= glow.x;
-		// Higher glow.x gives dimmer glow (because next step is 1 / "angle")
-	temp2.x = pow(temp2.x, glow.z);
-		// glow.z should be negative, so we're doing a sort of (1 / "angle") function
-
-	// Add "minimum anti-solar illumination"
-	temp2.x += .25;
-
-	// Increase ambient when there are more clouds
-	vec4 tmpAmbient = ambient;
-	tmpAmbient += (1. - tmpAmbient) * cloud_shadow * 0.5; 
-
-	// Dim sunlight by cloud shadow percentage
-	sunlight *= (1. - cloud_shadow);
-
-	// Haze color below cloud
-	vec4 additiveColorBelowCloud = (	  blue_horizon * blue_weight * (sunlight + tmpAmbient)
-				+ (haze_horizon * haze_weight) * (sunlight * temp2.x + tmpAmbient)
-			 );	
-
-	// CLOUDS
-
-	sunlight = sunlight_color;
-	temp2.y = max(0., lightnorm.y * 2.);
-	temp2.y = 1. / temp2.y;
-	sunlight *= exp( - light_atten * temp2.y);
-
-	// Cloud color out
-	vary_CloudColorSun = (sunlight * temp2.x) * cloud_color;
-	vary_CloudColorAmbient = tmpAmbient * cloud_color;
-	
-	// Attenuate cloud color by atmosphere
-	temp1 = sqrt(temp1);	//less atmos opacity (more transparency) below clouds
-	vary_CloudColorSun *= temp1;
-	vary_CloudColorAmbient *= temp1;
-	vec4 oHazeColorBelowCloud = additiveColorBelowCloud * (1. - temp1);
-
-	// Make a nice cloud density based on the cloud_shadow value that was passed in.
-	vary_CloudDensity = 2. * (cloud_shadow - 0.25);
-
-
 	// Texture coords
 	vary_texcoord0 = texcoord0;
 	vary_texcoord0.xy -= 0.5;
-	vary_texcoord0.xy /= cloud_scale;
-	vary_texcoord0.xy += 0.5;
+    vary_texcoord0.xy /= cloud_scale;
+    vary_texcoord0.xy += 0.5;
 
 	vary_texcoord1 = vary_texcoord0;
 	vary_texcoord1.x += lightnorm.x * 0.0125;
-	vary_texcoord1.y += lightnorm.z * 0.0125;
+    vary_texcoord1.y += lightnorm.z * 0.0125;
 
 	vary_texcoord2 = vary_texcoord0 * 16.;
 	vary_texcoord3 = vary_texcoord1 * 16.;
 
-	// Combine these to minimize register use
-	vary_CloudColorAmbient += oHazeColorBelowCloud;
-
-	// needs this to compile on mac
-	//vary_AtmosAttenuation = vec3(0.0,0.0,0.0);
-
 	// END CLOUDS
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index 864ba4859d..0848adba73 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -133,18 +133,7 @@ vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 }
 
 
-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;
-}
+vec4 getPosition(vec2 pos_screen);
 
 void main() 
 {
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 2073fc066f..d0514f7d23 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 class3/skyF.glsl
+ * @file class3/deferred/skyF.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -44,6 +44,7 @@ uniform sampler3D single_mie_scattering_texture;
 uniform sampler2D irradiance_texture;
 uniform sampler2D rainbow_map;
 uniform sampler2D halo_map;
+uniform vec4 gamma;
 
 uniform float moisture_level;
 uniform float droplet_radius;
@@ -53,6 +54,7 @@ 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 ColorFromRadiance(vec3 radiance);
 vec3 rainbow(float d)
 {
    float rad = (droplet_radius - 5.0f) / 1024.0f;
@@ -93,18 +95,15 @@ void main()
     }
     s = smoothstep(0.9, 1.0, s) * 16.0f;
 
-    vec3 color = vec3(1.0) - exp(-radiance_sun * 0.0001);
+    vec3 color = ColorFromRadiance(radiance_sun);
 
     float optic_d = dot(view_direction, sun_direction);
-
     vec3 halo_22 = halo22(optic_d);
 
-    if (optic_d <= 0)
-    color.rgb += rainbow(optic_d);
-
+    color.rgb += rainbow(optic_d) * optic_d;
     color.rgb += halo_22;
 
-    color = pow(color, vec3(1.0 / 2.2));
+    color = pow(color, vec3(1.0/2.2));
 
     frag_data[0] = vec4(color, 1.0 + s);
     frag_data[1] = vec4(0.0);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
index a5cc49ca30..2eb222ada4 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file advancedAtmoV.glsl
+ * @file class3/deferred/skyV.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -23,12 +23,6 @@
  * $/LicenseInfo$
  */
  
-uniform vec3 cameraPosLocal;
-uniform mat4 modelview_projection_matrix;
-uniform mat4 modelview_matrix;
-uniform mat4 inv_proj;
-uniform mat4 inv_modelview;
-
 ATTRIBUTE vec3 position;
 ATTRIBUTE vec2 texcoord0;
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 2615400e52..ecf6858136 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -38,30 +38,21 @@ uniform sampler2DRect specularRect;
 uniform sampler2DRect normalMap;
 uniform sampler2DRect lightMap;
 uniform sampler2DRect depthMap;
-uniform samplerCube environmentMap;
-uniform sampler2D	  lightFunc;
+uniform sampler2D     lightFunc;
 
 uniform float blur_size;
+uniform samplerCube environmentMap;
+
 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;
@@ -74,28 +65,29 @@ uniform mat4 inv_modelview;
 
 uniform vec2 screen_res;
 
+uniform sampler2D transmittance_texture;
+uniform sampler3D scattering_texture;
+uniform sampler3D single_mie_scattering_texture;
+uniform sampler2D irradiance_texture;
+
+uniform sampler2D sh_input_r;
+uniform sampler2D sh_input_g;
+uniform sampler2D sh_input_b;
+
+vec3 GetSunAndSkyIrradiance(vec3 camPos, vec3 norm, vec3 dir, out vec3 sky_irradiance);
+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 scaleSoftClipFrag(vec3 c);
+vec3 fullbrightScaleSoftClipFrag(vec3 c);
 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);
-}
-
+vec3 ColorFromRadiance(vec3 radiance);
+vec4 getPositionWithDepth(vec2 pos_screen, float depth);
+vec4 getPosition(vec2 pos_screen);
+vec3 getNorm(vec2 pos_screen);
 
 #ifdef WATER_FOG
 vec4 applyWaterFogView(vec3 pos, vec4 color);
@@ -105,24 +97,22 @@ void main()
 {
 	vec2 tc = vary_fragcoord.xy;
 	float depth = texture2DRect(depthMap, tc.xy).r;
-	vec3 pos = getPosition_d(tc, depth).xyz;
+	vec3 pos = getPositionWithDepth(tc, depth).xyz;
 	vec4 norm = texture2DRect(normalMap, tc);
 	float envIntensity = norm.z;
-	norm.xyz = decode_normal(norm.xy); // unpack norm
-		
+    norm.xyz = decode_normal(norm.xy);
+
 	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);
+	vec4 diffuse = texture2DRect(diffuseRect, tc); // linear
 
-	//convert to gamma space
-	diffuse.rgb = linear_to_srgb(diffuse.rgb);
-	
 	vec3 col;
 	float bloom = 0.0;
 	{
+        vec3 camPos = (camPosLocal / 1000.0f) + vec3(0, 0, 6360.0f);
+
 		vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
 		
 		vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
@@ -132,17 +122,37 @@ void main()
 
 		float ambocc = scol_ambocc.g;
 
-		col *= diffuse.rgb;
-	
+        vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
+        vec4 l1r = texture2D(sh_input_r, vec2(0,0));
+        vec4 l1g = texture2D(sh_input_g, vec2(0,0));
+        vec4 l1b = texture2D(sh_input_b, vec2(0,0));
+
+        vec3 indirect = vec3(dot(l1r, l1tap * vec4(1, norm.xyz)),
+                             dot(l1g, l1tap * vec4(1, norm.xyz)),
+                             dot(l1b, l1tap * vec4(1, norm.xyz)));
+
+        indirect = clamp(indirect, vec3(0), vec3(1.0));
+
+        vec3 transmittance;
+        vec3 sky_irradiance;
+        vec3 sun_irradiance = GetSunAndSkyIrradiance(camPos, norm.xyz, sun_dir, sky_irradiance);
+        vec3 inscatter = GetSkyLuminanceToPoint(camPos, (pos / 1000.f) + vec3(0, 0, 6360.0f), scol, sun_dir, transmittance);
+
+        vec3 radiance   = scol * (sun_irradiance + sky_irradiance) + inscatter;
+        vec3 atmo_color = ColorFromRadiance(radiance);
+
+        col = atmo_color + indirect;
+        col *= transmittance;
+        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);
+			vec3 dumbshiny = scol * texture2D(lightFunc, vec2(sa, spec.a)).r * atmo_color;
 			
 			// add the two types of shiny together
 			vec3 spec_contrib = dumbshiny * spec.rgb;
@@ -155,17 +165,24 @@ void main()
 		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);
+            vec3 sun_direction  = (inv_modelview * vec4(sun_dir, 1.0)).xyz;
+            vec3 radiance_sun  = GetSkyLuminance(camPos, env_vec, 0.0f, sun_direction, transmittance);
+            vec3 refcol = ColorFromRadiance(radiance_sun);
+			col = mix(col.rgb, refcol, envIntensity);
 		}
 						
+		/*if (norm.w < 0.5)
+		{
+			col = scaleSoftClipFrag(col);
+		}*/
+
 		#ifdef WATER_FOG
 			vec4 fogged = applyWaterFogView(pos,vec4(col, bloom));
 			col = fogged.rgb;
 			bloom = fogged.a;
 		#endif
 
-		col = srgb_to_linear(col);
+        col = pow(col, vec3(light_gamma));
 	}
 	
 	frag_color.rgb = col;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
index c840d72784..9d872b8df8 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file softenLightF.glsl
+ * @file class3/deferred/softenLightV.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -22,21 +22,17 @@
  * 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;
 
+uniform mat4 modelview_projection_matrix;
+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/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index a7da140b31..80e2a9dd55 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -133,18 +133,7 @@ vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 }
 
 
-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;
-}
+vec4 getPosition(vec2 pos_screen);
 
 void main() 
 {
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
index aa5e99a2f7..894534b105 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
@@ -68,19 +68,8 @@ 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;
-}
+vec4 getPosition(vec2 pos_screen);
+vec3 getNorm(vec2 pos_screen);
 
 float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
 {
@@ -124,13 +113,8 @@ float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_scr
 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
+	vec3 norm = getNorm(pos_screen);
 		
 	/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
 	{
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
index 58f3f2f91e..0870a80a32 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
@@ -68,81 +68,11 @@ 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];
-}
+vec4 getPosition(vec2 pos_screen);
+vec3 getNorm(vec2 pos_screen);
 
 //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 calcAmbientOcclusion(vec4 pos, vec3 norm, pos_screen);
 
 float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
 {
@@ -184,14 +114,9 @@ float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_scr
 
 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
+	vec2 pos_screen = vary_fragcoord.xy;	
+	vec4 pos        = getPosition(pos_screen);
+	vec3 norm       = getNorm(pos_screen);
 		
 	/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
 	{
@@ -291,7 +216,7 @@ void main()
 	}
 	
 	frag_color[0] = shadow;
-	frag_color[1] = calcAmbientOcclusion(pos, norm);
+	frag_color[1] = calcAmbientOcclusion(pos, norm, pos_screen);
 	
 	spos = vec4(shadow_pos+norm*spot_shadow_offset, 1.0);
 	
-- 
cgit v1.2.3


From db270df7cc00c1e2519749831e7e98c2c10e3ee6 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 9 Nov 2018 18:31:29 +0000
Subject: Back out changes causing broken shadows and other render shenanigans.

---
 .../shaders/class3/deferred/cloudsF.glsl           |  77 ++++--------
 .../shaders/class3/deferred/cloudsV.glsl           | 136 +++++++++++++++++++--
 .../shaders/class3/deferred/multiSpotLightF.glsl   |  13 +-
 .../app_settings/shaders/class3/deferred/skyF.glsl |  13 +-
 .../app_settings/shaders/class3/deferred/skyV.glsl |   8 +-
 .../shaders/class3/deferred/softenLightF.glsl      | 107 +++++++---------
 .../shaders/class3/deferred/softenLightV.glsl      |  12 +-
 .../shaders/class3/deferred/spotLightF.glsl        |  13 +-
 .../shaders/class3/deferred/sunLightF.glsl         |  22 +++-
 .../shaders/class3/deferred/sunLightSSAOF.glsl     |  89 ++++++++++++--
 10 files changed, 341 insertions(+), 149 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index f8373215f0..9f06319da3 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file class3/deferred/cloudsF.glsl
+ * @file WLCloudsF.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -24,9 +24,9 @@
  */
  
 #ifdef DEFINE_GL_FRAGCOLOR
-out vec4 frag_data[3];
+out vec4 frag_color;
 #else
-#define frag_data gl_FragData
+#define frag_color gl_FragColor
 #endif
 
 /////////////////////////////////////////////////////////////////////////
@@ -36,37 +36,20 @@ out vec4 frag_data[3];
 VARYING vec4 vary_CloudColorSun;
 VARYING vec4 vary_CloudColorAmbient;
 VARYING float vary_CloudDensity;
-VARYING vec2 vary_texcoord0;
-VARYING vec2 vary_texcoord1;
-VARYING vec2 vary_texcoord2;
-VARYING vec2 vary_texcoord3;
-VARYING vec3 vary_pos;
 
 uniform sampler2D cloud_noise_texture;
 uniform sampler2D cloud_noise_texture_next;
 uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
-uniform vec4 sunlight_color;
-uniform vec4 cloud_color;
-uniform float cloud_shadow;
+uniform vec4 gamma;
 uniform float cloud_scale;
 uniform float cloud_variance;
-uniform vec3 ambient;
-uniform vec3 camPosLocal;
-uniform vec3 sun_dir;
-uniform float sun_size;
-uniform float far_z;
-
-uniform sampler2D transmittance_texture;
-uniform sampler3D scattering_texture;
-uniform sampler3D single_mie_scattering_texture;
-uniform sampler2D irradiance_texture;
-uniform sampler2D sh_input_r;
-uniform sampler2D sh_input_g;
-uniform sampler2D sh_input_b;
-
-vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 dir, out vec3 transmittance);
+
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec2 vary_texcoord3;
 
 /// Soft clips the light with a gamma correction
 vec3 scaleSoftClip(vec3 light);
@@ -84,9 +67,11 @@ void main()
 	// Set variables
 	vec2 uv1 = vary_texcoord0.xy;
 	vec2 uv2 = vary_texcoord1.xy;
-	vec2 uv3 = vary_texcoord2.xy;
-	float cloudDensity = 2.0 * (cloud_shadow - 0.25);
 
+	vec4 cloudColorSun = vary_CloudColorSun;
+	vec4 cloudColorAmbient = vary_CloudColorAmbient;
+	float cloudDensity = vary_CloudDensity;
+	vec2 uv3 = vary_texcoord2.xy;
 	vec2 uv4 = vary_texcoord3.xy;
 
     vec2 disturbance = vec2(cloudNoise(uv1 / 16.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
@@ -97,53 +82,33 @@ void main()
 	uv3 += cloud_pos_density2.xy + disturbance;	//small texture, visible density
 	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
 
-    float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0));
-
-    cloudDensity *= 1.0 - (density_variance * density_variance);
 
 	// Compute alpha1, the main cloud opacity
+
 	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
-	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
+	alpha1 = min(max(alpha1 + cloudDensity, 0.) * (10. + disturbance.y) * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha1 = 1. - alpha1 * alpha1;
 	alpha1 = 1. - alpha1 * alpha1;	
 
-    if (alpha1 < 0.001f)
-    {
-        discard;
-    }
 
 	// Compute alpha2, for self shadowing effect
 	// (1 - alpha2) will later be used as percentage of incoming sunlight
 	float alpha2 = (cloudNoise(uv2).x - 0.5);
-	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
+	alpha2 = min(max(alpha2 + cloudDensity, 0.) * (2.5 + disturbance.x) * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha2 = 1. - alpha2;
 	alpha2 = 1. - alpha2 * alpha2;	
 
-    vec3 view_ray = vary_pos.xyz + camPosLocal;
-
-    vec3 view_direction = normalize(view_ray);
-    vec3 sun_direction  = normalize(sun_dir);
-    vec3 earth_center   = vec3(0, 0, -6360.0f);
-    vec3 camPos = (camPosLocal / 1000.0f) - earth_center;
-
-    vec3 transmittance;
-    vec3 radiance_sun  = GetSkyLuminance(camPos, view_direction, 1.0 - alpha1, sun_direction, transmittance);
-
-    vec3 sun_color = vec3(1.0) - exp(-radiance_sun * 0.0001);
-
 	// Combine
 	vec4 color;
+	color = (cloudColorSun*(1.-alpha2) + cloudColorAmbient);
+	color *= 2.;
 
-    color.rgb = sun_color * cloud_color.rgb * (1. - alpha2);
-    color.rgb = pow(color.rgb, vec3(1.0 / 2.2));
-    color.rgb += ambient;
-
-	frag_data[0] = vec4(color.rgb, alpha1);
-	frag_data[1] = vec4(0);
-	frag_data[2] = vec4(0,1,0,1);
+	/// Gamma correct for WL (soft clip effect).
+	frag_color.rgb = scaleSoftClip(color.rgb);
+	frag_color.a = alpha1;
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
index 53b6d88ef5..c1dd45cd67 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
@@ -24,7 +24,6 @@
  */
 
 uniform mat4 modelview_projection_matrix;
-uniform mat4 modelview_matrix;
 
 ATTRIBUTE vec3 position;
 ATTRIBUTE vec2 texcoord0;
@@ -34,37 +33,158 @@ ATTRIBUTE vec2 texcoord0;
 ///////////////////////////////////////////////////////////////////////////////
 
 // Output parameters
+VARYING vec4 vary_CloudColorSun;
+VARYING vec4 vary_CloudColorAmbient;
+VARYING float vary_CloudDensity;
 VARYING vec2 vary_texcoord0;
 VARYING vec2 vary_texcoord1;
 VARYING vec2 vary_texcoord2;
 VARYING vec2 vary_texcoord3;
-VARYING vec3 vary_pos;
 
 // Inputs
+uniform vec3 camPosLocal;
+
+uniform vec4 lightnorm;
+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 max_y;
+
+uniform vec4 glow;
+
+uniform vec4 cloud_color;
+
 uniform float cloud_scale;
-uniform vec4  lightnorm;
-uniform vec3  camPosLocal;
 
 void main()
 {
-    vary_pos = position;
 
 	// World / view / projection
 	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
 
+	vary_texcoord0 = texcoord0;
+
+	// Get relative position
+	vec3 P = position.xyz - camPosLocal.xyz + vec3(0,50,0);
+
+	// Set altitude
+	if (P.y > 0.)
+	{
+		P *= (max_y / P.y);
+	}
+	else
+	{
+		P *= (-32000. / P.y);
+	}
+
+	// Can normalize then
+	vec3 Pn = normalize(P);
+	float  Plen = length(P);
+
+	// Initialize temp variables
+	vec4 temp1 = vec4(0.);
+	vec4 temp2 = vec4(0.);
+	vec4 blue_weight;
+	vec4 haze_weight;
+	vec4 sunlight = sunlight_color;
+	vec4 light_atten;
+
+
+	// Sunlight attenuation effect (hue and brightness) due to atmosphere
+	// this is used later for sunlight modulation at various altitudes
+	light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
+
+	// Calculate relative weights
+	temp1 = blue_density + haze_density;
+	blue_weight = blue_density / temp1;
+	haze_weight = haze_density / temp1;
+
+	// Compute sunlight from P & lightnorm (for long rays like sky)
+	temp2.y = max(0., max(0., Pn.y) * 1.0 + lightnorm.y );
+	temp2.y = 1. / temp2.y;
+	sunlight *= exp( - light_atten * temp2.y);
+
+	// Distance
+	temp2.z = Plen * density_multiplier;
+
+	// Transparency (-> temp1)
+	// ATI Bugfix -- can't store temp1*temp2.z in a variable because the ati
+	// compiler gets confused.
+	temp1 = exp(-temp1 * temp2.z);
+
+
+	// Compute haze glow
+	temp2.x = dot(Pn, lightnorm.xyz);
+	temp2.x = 1. - temp2.x;
+		// temp2.x is 0 at the sun and increases away from sun
+	temp2.x = max(temp2.x, .001);	
+		// Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
+	temp2.x *= glow.x;
+		// Higher glow.x gives dimmer glow (because next step is 1 / "angle")
+	temp2.x = pow(temp2.x, glow.z);
+		// glow.z should be negative, so we're doing a sort of (1 / "angle") function
+
+	// Add "minimum anti-solar illumination"
+	temp2.x += .25;
+
+	// Increase ambient when there are more clouds
+	vec4 tmpAmbient = ambient;
+	tmpAmbient += (1. - tmpAmbient) * cloud_shadow * 0.5; 
+
+	// Dim sunlight by cloud shadow percentage
+	sunlight *= (1. - cloud_shadow);
+
+	// Haze color below cloud
+	vec4 additiveColorBelowCloud = (	  blue_horizon * blue_weight * (sunlight + tmpAmbient)
+				+ (haze_horizon * haze_weight) * (sunlight * temp2.x + tmpAmbient)
+			 );	
+
+	// CLOUDS
+
+	sunlight = sunlight_color;
+	temp2.y = max(0., lightnorm.y * 2.);
+	temp2.y = 1. / temp2.y;
+	sunlight *= exp( - light_atten * temp2.y);
+
+	// Cloud color out
+	vary_CloudColorSun = (sunlight * temp2.x) * cloud_color;
+	vary_CloudColorAmbient = tmpAmbient * cloud_color;
+	
+	// Attenuate cloud color by atmosphere
+	temp1 = sqrt(temp1);	//less atmos opacity (more transparency) below clouds
+	vary_CloudColorSun *= temp1;
+	vary_CloudColorAmbient *= temp1;
+	vec4 oHazeColorBelowCloud = additiveColorBelowCloud * (1. - temp1);
+
+	// Make a nice cloud density based on the cloud_shadow value that was passed in.
+	vary_CloudDensity = 2. * (cloud_shadow - 0.25);
+
+
 	// Texture coords
 	vary_texcoord0 = texcoord0;
 	vary_texcoord0.xy -= 0.5;
-    vary_texcoord0.xy /= cloud_scale;
-    vary_texcoord0.xy += 0.5;
+	vary_texcoord0.xy /= cloud_scale;
+	vary_texcoord0.xy += 0.5;
 
 	vary_texcoord1 = vary_texcoord0;
 	vary_texcoord1.x += lightnorm.x * 0.0125;
-    vary_texcoord1.y += lightnorm.z * 0.0125;
+	vary_texcoord1.y += lightnorm.z * 0.0125;
 
 	vary_texcoord2 = vary_texcoord0 * 16.;
 	vary_texcoord3 = vary_texcoord1 * 16.;
 
+	// Combine these to minimize register use
+	vary_CloudColorAmbient += oHazeColorBelowCloud;
+
+	// needs this to compile on mac
+	//vary_AtmosAttenuation = vec3(0.0,0.0,0.0);
+
 	// END CLOUDS
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index 0848adba73..864ba4859d 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -133,7 +133,18 @@ vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 }
 
 
-vec4 getPosition(vec2 pos_screen);
+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() 
 {
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index d0514f7d23..2073fc066f 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 class3/deferred/skyF.glsl
+ * @file class3/skyF.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -44,7 +44,6 @@ uniform sampler3D single_mie_scattering_texture;
 uniform sampler2D irradiance_texture;
 uniform sampler2D rainbow_map;
 uniform sampler2D halo_map;
-uniform vec4 gamma;
 
 uniform float moisture_level;
 uniform float droplet_radius;
@@ -54,7 +53,6 @@ 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 ColorFromRadiance(vec3 radiance);
 vec3 rainbow(float d)
 {
    float rad = (droplet_radius - 5.0f) / 1024.0f;
@@ -95,15 +93,18 @@ void main()
     }
     s = smoothstep(0.9, 1.0, s) * 16.0f;
 
-    vec3 color = ColorFromRadiance(radiance_sun);
+    vec3 color = vec3(1.0) - exp(-radiance_sun * 0.0001);
 
     float optic_d = dot(view_direction, sun_direction);
+
     vec3 halo_22 = halo22(optic_d);
 
-    color.rgb += rainbow(optic_d) * optic_d;
+    if (optic_d <= 0)
+    color.rgb += rainbow(optic_d);
+
     color.rgb += halo_22;
 
-    color = pow(color, vec3(1.0/2.2));
+    color = pow(color, vec3(1.0 / 2.2));
 
     frag_data[0] = vec4(color, 1.0 + s);
     frag_data[1] = vec4(0.0);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
index 2eb222ada4..a5cc49ca30 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file class3/deferred/skyV.glsl
+ * @file advancedAtmoV.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -23,6 +23,12 @@
  * $/LicenseInfo$
  */
  
+uniform vec3 cameraPosLocal;
+uniform mat4 modelview_projection_matrix;
+uniform mat4 modelview_matrix;
+uniform mat4 inv_proj;
+uniform mat4 inv_modelview;
+
 ATTRIBUTE vec3 position;
 ATTRIBUTE vec2 texcoord0;
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index ecf6858136..2615400e52 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -38,21 +38,30 @@ uniform sampler2DRect specularRect;
 uniform sampler2DRect normalMap;
 uniform sampler2DRect lightMap;
 uniform sampler2DRect depthMap;
-uniform sampler2D     lightFunc;
-
-uniform float blur_size;
 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;
@@ -65,29 +74,28 @@ uniform mat4 inv_modelview;
 
 uniform vec2 screen_res;
 
-uniform sampler2D transmittance_texture;
-uniform sampler3D scattering_texture;
-uniform sampler3D single_mie_scattering_texture;
-uniform sampler2D irradiance_texture;
-
-uniform sampler2D sh_input_r;
-uniform sampler2D sh_input_g;
-uniform sampler2D sh_input_b;
-
-vec3 GetSunAndSkyIrradiance(vec3 camPos, vec3 norm, vec3 dir, out vec3 sky_irradiance);
-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 scaleSoftClipFrag(vec3 c);
-vec3 fullbrightScaleSoftClipFrag(vec3 c);
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cl);
 vec3 decode_normal (vec2 enc);
 
-vec3 ColorFromRadiance(vec3 radiance);
-vec4 getPositionWithDepth(vec2 pos_screen, float depth);
-vec4 getPosition(vec2 pos_screen);
-vec3 getNorm(vec2 pos_screen);
+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);
@@ -97,22 +105,24 @@ void main()
 {
 	vec2 tc = vary_fragcoord.xy;
 	float depth = texture2DRect(depthMap, tc.xy).r;
-	vec3 pos = getPositionWithDepth(tc, depth).xyz;
+	vec3 pos = getPosition_d(tc, depth).xyz;
 	vec4 norm = texture2DRect(normalMap, tc);
 	float envIntensity = norm.z;
-    norm.xyz = decode_normal(norm.xy);
-
+	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); // linear
+	vec4 diffuse = texture2DRect(diffuseRect, tc);
 
+	//convert to gamma space
+	diffuse.rgb = linear_to_srgb(diffuse.rgb);
+	
 	vec3 col;
 	float bloom = 0.0;
 	{
-        vec3 camPos = (camPosLocal / 1000.0f) + vec3(0, 0, 6360.0f);
-
 		vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
 		
 		vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
@@ -122,37 +132,17 @@ void main()
 
 		float ambocc = scol_ambocc.g;
 
-        vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
-        vec4 l1r = texture2D(sh_input_r, vec2(0,0));
-        vec4 l1g = texture2D(sh_input_g, vec2(0,0));
-        vec4 l1b = texture2D(sh_input_b, vec2(0,0));
-
-        vec3 indirect = vec3(dot(l1r, l1tap * vec4(1, norm.xyz)),
-                             dot(l1g, l1tap * vec4(1, norm.xyz)),
-                             dot(l1b, l1tap * vec4(1, norm.xyz)));
-
-        indirect = clamp(indirect, vec3(0), vec3(1.0));
-
-        vec3 transmittance;
-        vec3 sky_irradiance;
-        vec3 sun_irradiance = GetSunAndSkyIrradiance(camPos, norm.xyz, sun_dir, sky_irradiance);
-        vec3 inscatter = GetSkyLuminanceToPoint(camPos, (pos / 1000.f) + vec3(0, 0, 6360.0f), scol, sun_dir, transmittance);
-
-        vec3 radiance   = scol * (sun_irradiance + sky_irradiance) + inscatter;
-        vec3 atmo_color = ColorFromRadiance(radiance);
-
-        col = atmo_color + indirect;
-        col *= transmittance;
-        col *= diffuse.rgb;
-
+		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 = scol * texture2D(lightFunc, vec2(sa, spec.a)).r * atmo_color;
+			vec3 dumbshiny = sunlit*(texture2D(lightFunc, vec2(sa, spec.a)).r);
 			
 			// add the two types of shiny together
 			vec3 spec_contrib = dumbshiny * spec.rgb;
@@ -165,24 +155,17 @@ void main()
 		if (envIntensity > 0.0)
 		{ //add environmentmap
 			vec3 env_vec = env_mat * refnormpersp;
-            vec3 sun_direction  = (inv_modelview * vec4(sun_dir, 1.0)).xyz;
-            vec3 radiance_sun  = GetSkyLuminance(camPos, env_vec, 0.0f, sun_direction, transmittance);
-            vec3 refcol = ColorFromRadiance(radiance_sun);
-			col = mix(col.rgb, refcol, envIntensity);
+			vec3 refcol = textureCube(environmentMap, env_vec).rgb;
+			col = mix(col.rgb, refcol, envintensity);
 		}
 						
-		/*if (norm.w < 0.5)
-		{
-			col = scaleSoftClipFrag(col);
-		}*/
-
 		#ifdef WATER_FOG
 			vec4 fogged = applyWaterFogView(pos,vec4(col, bloom));
 			col = fogged.rgb;
 			bloom = fogged.a;
 		#endif
 
-        col = pow(col, vec3(light_gamma));
+		col = srgb_to_linear(col);
 	}
 	
 	frag_color.rgb = col;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
index 9d872b8df8..c840d72784 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file class3/deferred/softenLightV.glsl
+ * @file softenLightF.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -22,17 +22,21 @@
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
-ATTRIBUTE vec3 position;
-
-VARYING vec2 vary_fragcoord;
 
 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
index 80e2a9dd55..a7da140b31 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -133,7 +133,18 @@ vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 }
 
 
-vec4 getPosition(vec2 pos_screen);
+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() 
 {
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
index 894534b105..aa5e99a2f7 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
@@ -68,8 +68,19 @@ uniform float spot_shadow_bias;
 uniform float spot_shadow_offset;
 
 vec3 decode_normal (vec2 enc);
-vec4 getPosition(vec2 pos_screen);
-vec3 getNorm(vec2 pos_screen);
+
+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)
 {
@@ -113,8 +124,13 @@ float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_scr
 void main() 
 {
 	vec2 pos_screen = vary_fragcoord.xy;
+	
+	//try doing an unproject here
+	
 	vec4 pos = getPosition(pos_screen);
-	vec3 norm = getNorm(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
 	{
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
index 0870a80a32..58f3f2f91e 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
@@ -68,11 +68,81 @@ uniform float shadow_offset;
 uniform float spot_shadow_bias;
 uniform float spot_shadow_offset;
 
-vec4 getPosition(vec2 pos_screen);
-vec3 getNorm(vec2 pos_screen);
+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, pos_screen);
+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)
 {
@@ -114,9 +184,14 @@ float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_scr
 
 void main() 
 {
-	vec2 pos_screen = vary_fragcoord.xy;	
-	vec4 pos        = getPosition(pos_screen);
-	vec3 norm       = getNorm(pos_screen);
+	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
 	{
@@ -216,7 +291,7 @@ void main()
 	}
 	
 	frag_color[0] = shadow;
-	frag_color[1] = calcAmbientOcclusion(pos, norm, pos_screen);
+	frag_color[1] = calcAmbientOcclusion(pos, norm);
 	
 	spos = vec4(shadow_pos+norm*spot_shadow_offset, 1.0);
 	
-- 
cgit v1.2.3


From d614bf11357d9ff1fef59c7ff11eff73b211dcac Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 9 Nov 2018 21:11:37 +0000
Subject: Yes, Maurice, baby steps.

---
 .../shaders/class3/deferred/cloudsF.glsl           |  77 ++++++++----
 .../shaders/class3/deferred/cloudsV.glsl           | 136 ++-------------------
 .../shaders/class3/deferred/multiSpotLightF.glsl   |  13 +-
 .../app_settings/shaders/class3/deferred/skyF.glsl |  13 +-
 .../app_settings/shaders/class3/deferred/skyV.glsl |   8 +-
 .../shaders/class3/deferred/softenLightF.glsl      | 107 +++++++++-------
 .../shaders/class3/deferred/softenLightV.glsl      |  12 +-
 .../shaders/class3/deferred/spotLightF.glsl        |  13 +-
 .../shaders/class3/deferred/sunLightF.glsl         |  22 +---
 .../shaders/class3/deferred/sunLightSSAOF.glsl     |  89 ++------------
 10 files changed, 149 insertions(+), 341 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index 9f06319da3..f8373215f0 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file WLCloudsF.glsl
+ * @file class3/deferred/cloudsF.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -24,9 +24,9 @@
  */
  
 #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
 
 /////////////////////////////////////////////////////////////////////////
@@ -36,20 +36,37 @@ out vec4 frag_color;
 VARYING vec4 vary_CloudColorSun;
 VARYING vec4 vary_CloudColorAmbient;
 VARYING float vary_CloudDensity;
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec2 vary_texcoord3;
+VARYING vec3 vary_pos;
 
 uniform sampler2D cloud_noise_texture;
 uniform sampler2D cloud_noise_texture_next;
 uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
-uniform vec4 gamma;
+uniform vec4 sunlight_color;
+uniform vec4 cloud_color;
+uniform float cloud_shadow;
 uniform float cloud_scale;
 uniform float cloud_variance;
-
-VARYING vec2 vary_texcoord0;
-VARYING vec2 vary_texcoord1;
-VARYING vec2 vary_texcoord2;
-VARYING vec2 vary_texcoord3;
+uniform vec3 ambient;
+uniform vec3 camPosLocal;
+uniform vec3 sun_dir;
+uniform float sun_size;
+uniform float far_z;
+
+uniform sampler2D transmittance_texture;
+uniform sampler3D scattering_texture;
+uniform sampler3D single_mie_scattering_texture;
+uniform sampler2D irradiance_texture;
+uniform sampler2D sh_input_r;
+uniform sampler2D sh_input_g;
+uniform sampler2D sh_input_b;
+
+vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 dir, out vec3 transmittance);
 
 /// Soft clips the light with a gamma correction
 vec3 scaleSoftClip(vec3 light);
@@ -67,11 +84,9 @@ void main()
 	// Set variables
 	vec2 uv1 = vary_texcoord0.xy;
 	vec2 uv2 = vary_texcoord1.xy;
-
-	vec4 cloudColorSun = vary_CloudColorSun;
-	vec4 cloudColorAmbient = vary_CloudColorAmbient;
-	float cloudDensity = vary_CloudDensity;
 	vec2 uv3 = vary_texcoord2.xy;
+	float cloudDensity = 2.0 * (cloud_shadow - 0.25);
+
 	vec2 uv4 = vary_texcoord3.xy;
 
     vec2 disturbance = vec2(cloudNoise(uv1 / 16.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
@@ -82,33 +97,53 @@ void main()
 	uv3 += cloud_pos_density2.xy + disturbance;	//small texture, visible density
 	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
 
+    float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0));
 
-	// Compute alpha1, the main cloud opacity
+    cloudDensity *= 1.0 - (density_variance * density_variance);
 
+	// Compute alpha1, the main cloud opacity
 	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
-	alpha1 = min(max(alpha1 + cloudDensity, 0.) * (10. + disturbance.y) * cloud_pos_density1.z, 1.);
+	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha1 = 1. - alpha1 * alpha1;
 	alpha1 = 1. - alpha1 * alpha1;	
 
+    if (alpha1 < 0.001f)
+    {
+        discard;
+    }
 
 	// Compute alpha2, for self shadowing effect
 	// (1 - alpha2) will later be used as percentage of incoming sunlight
 	float alpha2 = (cloudNoise(uv2).x - 0.5);
-	alpha2 = min(max(alpha2 + cloudDensity, 0.) * (2.5 + disturbance.x) * cloud_pos_density1.z, 1.);
+	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
 
 	// And smooth
 	alpha2 = 1. - alpha2;
 	alpha2 = 1. - alpha2 * alpha2;	
 
+    vec3 view_ray = vary_pos.xyz + camPosLocal;
+
+    vec3 view_direction = normalize(view_ray);
+    vec3 sun_direction  = normalize(sun_dir);
+    vec3 earth_center   = vec3(0, 0, -6360.0f);
+    vec3 camPos = (camPosLocal / 1000.0f) - earth_center;
+
+    vec3 transmittance;
+    vec3 radiance_sun  = GetSkyLuminance(camPos, view_direction, 1.0 - alpha1, sun_direction, transmittance);
+
+    vec3 sun_color = vec3(1.0) - exp(-radiance_sun * 0.0001);
+
 	// Combine
 	vec4 color;
-	color = (cloudColorSun*(1.-alpha2) + cloudColorAmbient);
-	color *= 2.;
 
-	/// Gamma correct for WL (soft clip effect).
-	frag_color.rgb = scaleSoftClip(color.rgb);
-	frag_color.a = alpha1;
+    color.rgb = sun_color * cloud_color.rgb * (1. - alpha2);
+    color.rgb = pow(color.rgb, vec3(1.0 / 2.2));
+    color.rgb += ambient;
+
+	frag_data[0] = vec4(color.rgb, alpha1);
+	frag_data[1] = vec4(0);
+	frag_data[2] = vec4(0,1,0,1);
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
index c1dd45cd67..53b6d88ef5 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
@@ -24,6 +24,7 @@
  */
 
 uniform mat4 modelview_projection_matrix;
+uniform mat4 modelview_matrix;
 
 ATTRIBUTE vec3 position;
 ATTRIBUTE vec2 texcoord0;
@@ -33,158 +34,37 @@ ATTRIBUTE vec2 texcoord0;
 ///////////////////////////////////////////////////////////////////////////////
 
 // Output parameters
-VARYING vec4 vary_CloudColorSun;
-VARYING vec4 vary_CloudColorAmbient;
-VARYING float vary_CloudDensity;
 VARYING vec2 vary_texcoord0;
 VARYING vec2 vary_texcoord1;
 VARYING vec2 vary_texcoord2;
 VARYING vec2 vary_texcoord3;
+VARYING vec3 vary_pos;
 
 // Inputs
-uniform vec3 camPosLocal;
-
-uniform vec4 lightnorm;
-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 max_y;
-
-uniform vec4 glow;
-
-uniform vec4 cloud_color;
-
 uniform float cloud_scale;
+uniform vec4  lightnorm;
+uniform vec3  camPosLocal;
 
 void main()
 {
+    vary_pos = position;
 
 	// World / view / projection
 	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
 
-	vary_texcoord0 = texcoord0;
-
-	// Get relative position
-	vec3 P = position.xyz - camPosLocal.xyz + vec3(0,50,0);
-
-	// Set altitude
-	if (P.y > 0.)
-	{
-		P *= (max_y / P.y);
-	}
-	else
-	{
-		P *= (-32000. / P.y);
-	}
-
-	// Can normalize then
-	vec3 Pn = normalize(P);
-	float  Plen = length(P);
-
-	// Initialize temp variables
-	vec4 temp1 = vec4(0.);
-	vec4 temp2 = vec4(0.);
-	vec4 blue_weight;
-	vec4 haze_weight;
-	vec4 sunlight = sunlight_color;
-	vec4 light_atten;
-
-
-	// Sunlight attenuation effect (hue and brightness) due to atmosphere
-	// this is used later for sunlight modulation at various altitudes
-	light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
-
-	// Calculate relative weights
-	temp1 = blue_density + haze_density;
-	blue_weight = blue_density / temp1;
-	haze_weight = haze_density / temp1;
-
-	// Compute sunlight from P & lightnorm (for long rays like sky)
-	temp2.y = max(0., max(0., Pn.y) * 1.0 + lightnorm.y );
-	temp2.y = 1. / temp2.y;
-	sunlight *= exp( - light_atten * temp2.y);
-
-	// Distance
-	temp2.z = Plen * density_multiplier;
-
-	// Transparency (-> temp1)
-	// ATI Bugfix -- can't store temp1*temp2.z in a variable because the ati
-	// compiler gets confused.
-	temp1 = exp(-temp1 * temp2.z);
-
-
-	// Compute haze glow
-	temp2.x = dot(Pn, lightnorm.xyz);
-	temp2.x = 1. - temp2.x;
-		// temp2.x is 0 at the sun and increases away from sun
-	temp2.x = max(temp2.x, .001);	
-		// Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
-	temp2.x *= glow.x;
-		// Higher glow.x gives dimmer glow (because next step is 1 / "angle")
-	temp2.x = pow(temp2.x, glow.z);
-		// glow.z should be negative, so we're doing a sort of (1 / "angle") function
-
-	// Add "minimum anti-solar illumination"
-	temp2.x += .25;
-
-	// Increase ambient when there are more clouds
-	vec4 tmpAmbient = ambient;
-	tmpAmbient += (1. - tmpAmbient) * cloud_shadow * 0.5; 
-
-	// Dim sunlight by cloud shadow percentage
-	sunlight *= (1. - cloud_shadow);
-
-	// Haze color below cloud
-	vec4 additiveColorBelowCloud = (	  blue_horizon * blue_weight * (sunlight + tmpAmbient)
-				+ (haze_horizon * haze_weight) * (sunlight * temp2.x + tmpAmbient)
-			 );	
-
-	// CLOUDS
-
-	sunlight = sunlight_color;
-	temp2.y = max(0., lightnorm.y * 2.);
-	temp2.y = 1. / temp2.y;
-	sunlight *= exp( - light_atten * temp2.y);
-
-	// Cloud color out
-	vary_CloudColorSun = (sunlight * temp2.x) * cloud_color;
-	vary_CloudColorAmbient = tmpAmbient * cloud_color;
-	
-	// Attenuate cloud color by atmosphere
-	temp1 = sqrt(temp1);	//less atmos opacity (more transparency) below clouds
-	vary_CloudColorSun *= temp1;
-	vary_CloudColorAmbient *= temp1;
-	vec4 oHazeColorBelowCloud = additiveColorBelowCloud * (1. - temp1);
-
-	// Make a nice cloud density based on the cloud_shadow value that was passed in.
-	vary_CloudDensity = 2. * (cloud_shadow - 0.25);
-
-
 	// Texture coords
 	vary_texcoord0 = texcoord0;
 	vary_texcoord0.xy -= 0.5;
-	vary_texcoord0.xy /= cloud_scale;
-	vary_texcoord0.xy += 0.5;
+    vary_texcoord0.xy /= cloud_scale;
+    vary_texcoord0.xy += 0.5;
 
 	vary_texcoord1 = vary_texcoord0;
 	vary_texcoord1.x += lightnorm.x * 0.0125;
-	vary_texcoord1.y += lightnorm.z * 0.0125;
+    vary_texcoord1.y += lightnorm.z * 0.0125;
 
 	vary_texcoord2 = vary_texcoord0 * 16.;
 	vary_texcoord3 = vary_texcoord1 * 16.;
 
-	// Combine these to minimize register use
-	vary_CloudColorAmbient += oHazeColorBelowCloud;
-
-	// needs this to compile on mac
-	//vary_AtmosAttenuation = vec3(0.0,0.0,0.0);
-
 	// END CLOUDS
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index 864ba4859d..0848adba73 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -133,18 +133,7 @@ vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 }
 
 
-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;
-}
+vec4 getPosition(vec2 pos_screen);
 
 void main() 
 {
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index 2073fc066f..d0514f7d23 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 class3/skyF.glsl
+ * @file class3/deferred/skyF.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -44,6 +44,7 @@ uniform sampler3D single_mie_scattering_texture;
 uniform sampler2D irradiance_texture;
 uniform sampler2D rainbow_map;
 uniform sampler2D halo_map;
+uniform vec4 gamma;
 
 uniform float moisture_level;
 uniform float droplet_radius;
@@ -53,6 +54,7 @@ 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 ColorFromRadiance(vec3 radiance);
 vec3 rainbow(float d)
 {
    float rad = (droplet_radius - 5.0f) / 1024.0f;
@@ -93,18 +95,15 @@ void main()
     }
     s = smoothstep(0.9, 1.0, s) * 16.0f;
 
-    vec3 color = vec3(1.0) - exp(-radiance_sun * 0.0001);
+    vec3 color = ColorFromRadiance(radiance_sun);
 
     float optic_d = dot(view_direction, sun_direction);
-
     vec3 halo_22 = halo22(optic_d);
 
-    if (optic_d <= 0)
-    color.rgb += rainbow(optic_d);
-
+    color.rgb += rainbow(optic_d) * optic_d;
     color.rgb += halo_22;
 
-    color = pow(color, vec3(1.0 / 2.2));
+    color = pow(color, vec3(1.0/2.2));
 
     frag_data[0] = vec4(color, 1.0 + s);
     frag_data[1] = vec4(0.0);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
index a5cc49ca30..2eb222ada4 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyV.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file advancedAtmoV.glsl
+ * @file class3/deferred/skyV.glsl
  *
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -23,12 +23,6 @@
  * $/LicenseInfo$
  */
  
-uniform vec3 cameraPosLocal;
-uniform mat4 modelview_projection_matrix;
-uniform mat4 modelview_matrix;
-uniform mat4 inv_proj;
-uniform mat4 inv_modelview;
-
 ATTRIBUTE vec3 position;
 ATTRIBUTE vec2 texcoord0;
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 2615400e52..ecf6858136 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -38,30 +38,21 @@ uniform sampler2DRect specularRect;
 uniform sampler2DRect normalMap;
 uniform sampler2DRect lightMap;
 uniform sampler2DRect depthMap;
-uniform samplerCube environmentMap;
-uniform sampler2D	  lightFunc;
+uniform sampler2D     lightFunc;
 
 uniform float blur_size;
+uniform samplerCube environmentMap;
+
 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;
@@ -74,28 +65,29 @@ uniform mat4 inv_modelview;
 
 uniform vec2 screen_res;
 
+uniform sampler2D transmittance_texture;
+uniform sampler3D scattering_texture;
+uniform sampler3D single_mie_scattering_texture;
+uniform sampler2D irradiance_texture;
+
+uniform sampler2D sh_input_r;
+uniform sampler2D sh_input_g;
+uniform sampler2D sh_input_b;
+
+vec3 GetSunAndSkyIrradiance(vec3 camPos, vec3 norm, vec3 dir, out vec3 sky_irradiance);
+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 scaleSoftClipFrag(vec3 c);
+vec3 fullbrightScaleSoftClipFrag(vec3 c);
 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);
-}
-
+vec3 ColorFromRadiance(vec3 radiance);
+vec4 getPositionWithDepth(vec2 pos_screen, float depth);
+vec4 getPosition(vec2 pos_screen);
+vec3 getNorm(vec2 pos_screen);
 
 #ifdef WATER_FOG
 vec4 applyWaterFogView(vec3 pos, vec4 color);
@@ -105,24 +97,22 @@ void main()
 {
 	vec2 tc = vary_fragcoord.xy;
 	float depth = texture2DRect(depthMap, tc.xy).r;
-	vec3 pos = getPosition_d(tc, depth).xyz;
+	vec3 pos = getPositionWithDepth(tc, depth).xyz;
 	vec4 norm = texture2DRect(normalMap, tc);
 	float envIntensity = norm.z;
-	norm.xyz = decode_normal(norm.xy); // unpack norm
-		
+    norm.xyz = decode_normal(norm.xy);
+
 	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);
+	vec4 diffuse = texture2DRect(diffuseRect, tc); // linear
 
-	//convert to gamma space
-	diffuse.rgb = linear_to_srgb(diffuse.rgb);
-	
 	vec3 col;
 	float bloom = 0.0;
 	{
+        vec3 camPos = (camPosLocal / 1000.0f) + vec3(0, 0, 6360.0f);
+
 		vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
 		
 		vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
@@ -132,17 +122,37 @@ void main()
 
 		float ambocc = scol_ambocc.g;
 
-		col *= diffuse.rgb;
-	
+        vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
+        vec4 l1r = texture2D(sh_input_r, vec2(0,0));
+        vec4 l1g = texture2D(sh_input_g, vec2(0,0));
+        vec4 l1b = texture2D(sh_input_b, vec2(0,0));
+
+        vec3 indirect = vec3(dot(l1r, l1tap * vec4(1, norm.xyz)),
+                             dot(l1g, l1tap * vec4(1, norm.xyz)),
+                             dot(l1b, l1tap * vec4(1, norm.xyz)));
+
+        indirect = clamp(indirect, vec3(0), vec3(1.0));
+
+        vec3 transmittance;
+        vec3 sky_irradiance;
+        vec3 sun_irradiance = GetSunAndSkyIrradiance(camPos, norm.xyz, sun_dir, sky_irradiance);
+        vec3 inscatter = GetSkyLuminanceToPoint(camPos, (pos / 1000.f) + vec3(0, 0, 6360.0f), scol, sun_dir, transmittance);
+
+        vec3 radiance   = scol * (sun_irradiance + sky_irradiance) + inscatter;
+        vec3 atmo_color = ColorFromRadiance(radiance);
+
+        col = atmo_color + indirect;
+        col *= transmittance;
+        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);
+			vec3 dumbshiny = scol * texture2D(lightFunc, vec2(sa, spec.a)).r * atmo_color;
 			
 			// add the two types of shiny together
 			vec3 spec_contrib = dumbshiny * spec.rgb;
@@ -155,17 +165,24 @@ void main()
 		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);
+            vec3 sun_direction  = (inv_modelview * vec4(sun_dir, 1.0)).xyz;
+            vec3 radiance_sun  = GetSkyLuminance(camPos, env_vec, 0.0f, sun_direction, transmittance);
+            vec3 refcol = ColorFromRadiance(radiance_sun);
+			col = mix(col.rgb, refcol, envIntensity);
 		}
 						
+		/*if (norm.w < 0.5)
+		{
+			col = scaleSoftClipFrag(col);
+		}*/
+
 		#ifdef WATER_FOG
 			vec4 fogged = applyWaterFogView(pos,vec4(col, bloom));
 			col = fogged.rgb;
 			bloom = fogged.a;
 		#endif
 
-		col = srgb_to_linear(col);
+        col = pow(col, vec3(light_gamma));
 	}
 	
 	frag_color.rgb = col;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
index c840d72784..9d872b8df8 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file softenLightF.glsl
+ * @file class3/deferred/softenLightV.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -22,21 +22,17 @@
  * 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;
 
+uniform mat4 modelview_projection_matrix;
+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/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index a7da140b31..80e2a9dd55 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -133,18 +133,7 @@ vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 }
 
 
-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;
-}
+vec4 getPosition(vec2 pos_screen);
 
 void main() 
 {
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
index aa5e99a2f7..894534b105 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
@@ -68,19 +68,8 @@ 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;
-}
+vec4 getPosition(vec2 pos_screen);
+vec3 getNorm(vec2 pos_screen);
 
 float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
 {
@@ -124,13 +113,8 @@ float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_scr
 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
+	vec3 norm = getNorm(pos_screen);
 		
 	/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
 	{
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
index 58f3f2f91e..0870a80a32 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
@@ -68,81 +68,11 @@ 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];
-}
+vec4 getPosition(vec2 pos_screen);
+vec3 getNorm(vec2 pos_screen);
 
 //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 calcAmbientOcclusion(vec4 pos, vec3 norm, pos_screen);
 
 float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
 {
@@ -184,14 +114,9 @@ float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_scr
 
 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
+	vec2 pos_screen = vary_fragcoord.xy;	
+	vec4 pos        = getPosition(pos_screen);
+	vec3 norm       = getNorm(pos_screen);
 		
 	/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
 	{
@@ -291,7 +216,7 @@ void main()
 	}
 	
 	frag_color[0] = shadow;
-	frag_color[1] = calcAmbientOcclusion(pos, norm);
+	frag_color[1] = calcAmbientOcclusion(pos, norm, pos_screen);
 	
 	spos = vec4(shadow_pos+norm*spot_shadow_offset, 1.0);
 	
-- 
cgit v1.2.3


From 07bff3129adaabb90f09b71fa65c8be0c3ecef5d Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Wed, 19 Dec 2018 14:59:19 -0800
Subject: Add new shaders for advanced atmo SH env lighting calcs.

---
 .../shaders/class3/deferred/deferredUtil.glsl      |  75 ++++++++
 .../class3/deferred/depthToShadowVolumeG.glsl      | 202 +++++++++++++++++++++
 .../shaders/class3/deferred/gatherSkyShF.glsl      |  70 +++++++
 .../shaders/class3/deferred/gatherSkyShV.glsl      |  40 ++++
 .../shaders/class3/deferred/genSkyShF.glsl         | 112 ++++++++++++
 .../shaders/class3/deferred/genSkyShV.glsl         |  37 ++++
 .../shaders/class3/deferred/indirect.glsl          |  44 +++++
 .../shaders/class3/deferred/lightUtil.glsl         | 117 ++++++++++++
 .../shaders/class3/deferred/pointShadowBlurF.glsl  |  37 ++++
 .../shaders/class3/deferred/shVisF.glsl            |  73 ++++++++
 .../shaders/class3/deferred/shVisV.glsl            |  33 ++++
 .../shaders/class3/deferred/shadowAlphaBlendF.glsl |  58 ++++++
 .../shaders/class3/deferred/shadowAlphaBlendV.glsl |  66 +++++++
 .../shaders/class3/deferred/shadowAlphaMaskF.glsl  |  74 ++++++++
 .../shaders/class3/deferred/shadowAlphaMaskV.glsl  |  67 +++++++
 .../shaders/class3/deferred/shadowCubeV.glsl       |  50 +++++
 .../shaders/class3/deferred/shadowF.glsl           |  49 +++++
 .../shaders/class3/deferred/shadowUtil.glsl        | 157 ++++++++++++++++
 .../shaders/class3/deferred/shadowV.glsl           |  62 +++++++
 .../shaders/class3/deferred/softenLightF.glsl      |   4 +-
 20 files changed, 1424 insertions(+), 3 deletions(-)
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/gatherSkyShF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/gatherSkyShV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/genSkyShV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/indirect.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/lightUtil.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/pointShadowBlurF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shVisF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shVisV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowUtil.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl b/indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl
new file mode 100644
index 0000000000..cccd01e0d7
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl
@@ -0,0 +1,75 @@
+/** 
+ * @file class3/deferred/deferredUtil.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 sampler2DRect   normalMap;
+uniform sampler2DRect   depthMap;
+
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+vec3 decode_normal(vec2 enc);
+
+vec2 getScreenCoordinate(vec2 screenpos)
+{
+    vec2 sc = screenpos.xy * 2.0;
+    if (screen_res.x > 0 && screen_res.y > 0)
+    {
+       sc /= screen_res;
+    }
+    return sc - vec2(1.0, 1.0);
+}
+
+vec3 getNorm(vec2 screenpos)
+{
+   vec2 enc_norm = texture2DRect(normalMap, screenpos.xy).xy;
+   return decode_normal(enc_norm);
+}
+
+float getDepth(vec2 pos_screen)
+{
+    float depth = texture2DRect(depthMap, pos_screen).r;
+    return depth;
+}
+
+vec4 getPosition(vec2 pos_screen)
+{
+    float depth = getDepth(pos_screen);
+    vec2 sc = getScreenCoordinate(pos_screen);
+    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 getPositionWithDepth(vec2 pos_screen, float depth)
+{
+    vec2 sc = getScreenCoordinate(pos_screen);
+    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;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl b/indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl
new file mode 100644
index 0000000000..5734e2abb2
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl
@@ -0,0 +1,202 @@
+/** 
+ * @file depthToShadowVolumeG.glsl
+ *
+ * $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$
+ */
+#extension GL_ARB_geometry_shader4  : enable
+#extension GL_ARB_texture_rectangle : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+layout (triangles) in;
+layout (triangle_strip, max_vertices = 128) out;
+
+uniform sampler2DRect depthMap;
+uniform mat4 shadowMatrix[6]; 
+uniform vec4 lightpos;
+
+VARYING vec2 vary_texcoord0;
+
+out vec3 to_vec;
+
+void cross_products(out vec4 ns[3], int a, int b, int c)
+{
+   ns[0] = cross(gl_PositionIn[b].xyz - gl_PositionIn[a].xyz, gl_PositionIn[c].xyz - gl_PositionIn[a].xyz);
+   ns[1] = cross(gl_PositionIn[c].xyz - gl_PositionIn[b].xyz, gl_PositionIn[a].xyz - gl_PositionIn[b].xyz);
+   ns[2] = cross(gl_PositionIn[a].xyz - gl_PositionIn[c].xyz, gl_PositionIn[b].xyz - gl_PositionIn[c].xyz);
+}
+
+vec3 getLightDirection(vec4 lightpos, vec3 pos)
+{
+
+    vec3 lightdir = lightpos.xyz - lightpos.w * pos;
+    return lightdir;
+}
+
+void emitTri(vec4 v[3])
+{
+    gl_Position = proj_matrix * v[0];
+    EmitVertex();
+
+    gl_Position = proj_matrix * v[1];
+    EmitVertex();
+
+    gl_Position = proj_matrix * v[2];
+    EmitVertex();
+
+    EndPrimitive();
+}
+
+void emitQuad(vec4 v[4]
+{
+    // Emit a quad as a triangle strip.
+    gl_Position = proj_matrix*v[0];
+    EmitVertex();
+
+    gl_Position = proj_matrix*v[1];
+    EmitVertex();
+
+    gl_Position = proj_matrix*v[2];
+    EmitVertex();
+
+    gl_Position = proj_matrix*v[3];
+    EmitVertex(); 
+
+    EndPrimitive();
+}
+
+void emitPrimitives(int layer)
+{
+    int i = layer;
+    gl_Layer = i;
+
+    vec4 depth1 = vec4(texture2DRect(depthMap, tc0).rg, texture2DRect(depthMap, tc1).rg));
+    vec3 depth2 = vec4(texture2DRect(depthMap, tc2).rg, texture2DRect(depthMap, tc3).rg));
+    vec3 depth3 = vec4(texture2DRect(depthMap, tc4).rg, texture2DRect(depthMap, tc5).rg));
+    vec3 depth4 = vec4(texture2DRect(depthMap, tc6).rg, texture2DRect(depthMap, tc7).rg));
+
+    depth1 = min(depth1, depth2);
+    depth1 = min(depth1, depth3);
+    depth1 = min(depth1, depth4);
+
+    vec2 depth = min(depth1.xy, depth1.zw);
+
+    int side = sqrt(gl_VerticesIn);
+
+    for (int j = 0; j < side; j++)
+    {
+        for (int k = 0; k < side; ++k)
+        {
+            vec3 pos = gl_PositionIn[(j * side) + k].xyz;
+            vec4 v = shadowMatrix[i] * vec4(pos, 1.0);
+            gl_Position = v;
+            to_vec = pos - light_position.xyz * depth;
+            EmitVertex();
+        }
+
+        EndPrimitive();
+    }
+
+    vec3 norms[3]; // Normals
+    vec3 lightdir3]; // Directions toward light
+
+    vec4 v[4]; // Temporary vertices
+
+    vec4 or_pos[3] =
+    {  // Triangle oriented toward light source
+        gl_PositionIn[0],
+        gl_PositionIn[2],
+        gl_PositionIn[4]
+    };
+
+    // Compute normal at each vertex.
+    cross_products(n, 0, 2, 4);
+
+    // Compute direction from vertices to light.
+    lightdir[0] = getLightDirection(lightpos, gl_PositionIn[0].xyz);
+    lightdir[1] = getLightDirection(lightpos, gl_PositionIn[2].xyz);
+    lightdir[2] = getLightDirection(lightpos, gl_PositionIn[4].xyz);
+
+    // Check if the main triangle faces the light.
+    bool faces_light = true;
+    if (!(dot(ns[0],d[0]) > 0
+         |dot(ns[1],d[1]) > 0
+         |dot(ns[2],d[2]) > 0))
+    {
+        // Flip vertex winding order in or_pos.
+        or_pos[1] = gl_PositionIn[4];
+        or_pos[2] = gl_PositionIn[2];
+        faces_light = false;
+    }
+
+    // Near cap: simply render triangle.
+    emitTri(or_pos);
+
+    // Far cap: extrude positions to infinity.
+    v[0] =vec4(lightpos.w * or_pos[0].xyz - lightpos.xyz,0);
+    v[1] =vec4(lightpos.w * or_pos[2].xyz - lightpos.xyz,0);
+    v[2] =vec4(lightpos.w * or_pos[1].xyz - lightpos.xyz,0);
+
+    emitTri(v);
+
+    // Loop over all edges and extrude if needed.
+    for ( int i=0; i<3; i++ ) 
+    {
+       // Compute indices of neighbor triangle.
+       int v0 = i*2;
+       int nb = (i*2+1);
+       int v1 = (i*2+2) % 6;
+       cross_products(n, v0, nb, v1);
+
+       // Compute direction to light, again as above.
+       d[0] =lightpos.xyz-lightpos.w*gl_PositionIn[v0].xyz;
+       d[1] =lightpos.xyz-lightpos.w*gl_PositionIn[nb].xyz;
+       d[2] =lightpos.xyz-lightpos.w*gl_PositionIn[v1].xyz;
+
+       bool is_parallel = gl_PositionIn[nb].w < 1e-5;
+
+       // Extrude the edge if it does not have a
+       // neighbor, or if it's a possible silhouette.
+       if (is_parallel ||
+          ( faces_light != (dot(ns[0],d[0])>0 ||
+                            dot(ns[1],d[1])>0 ||
+                            dot(ns[2],d[2])>0) ))
+       {
+           // Make sure sides are oriented correctly.
+           int i0 = faces_light ? v0 : v1;
+           int i1 = faces_light ? v1 : v0;
+
+           v[0] = gl_PositionIn[i0];
+           v[1] = vec4(lightpos.w*gl_PositionIn[i0].xyz - lightpos.xyz, 0);
+           v[2] = gl_PositionIn[i1];
+           v[3] = vec4(lightpos.w*gl_PositionIn[i1].xyz - lightpos.xyz, 0);
+
+           emitQuad(v);
+       }
+    }
+}
+
+void main()
+{
+    // Output
+    emitPrimitives(0);
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/gatherSkyShF.glsl b/indra/newview/app_settings/shaders/class3/deferred/gatherSkyShF.glsl
new file mode 100644
index 0000000000..34d26cddea
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/gatherSkyShF.glsl
@@ -0,0 +1,70 @@
+/** 
+ * @file class3/deferred/gatherSkyShF.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+ 
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_data[3];
+#else
+#define frag_data gl_FragData
+#endif
+
+VARYING vec2 vary_frag;
+
+uniform vec2 screen_res;
+uniform sampler2D sh_input_r;
+uniform sampler2D sh_input_g;
+uniform sampler2D sh_input_b;
+
+void main()
+{
+    vec2 offset	  = vec2(2.0) / screen_res;
+
+    vec4 r = vec4(0);
+    vec4 g = vec4(0);
+    vec4 b = vec4(0);
+
+    vec2 tc = vary_frag * 2.0;
+
+	r += texture2D(sh_input_r, tc + vec2(0,        0));
+	r += texture2D(sh_input_r, tc + vec2(offset.x, 0));
+	r += texture2D(sh_input_r, tc + vec2(0,        offset.y));
+	r += texture2D(sh_input_r, tc + vec2(offset.x, offset.y));
+    r /= 4.0f;
+
+	g += texture2D(sh_input_g, tc + vec2(0,        0));
+	g += texture2D(sh_input_g, tc + vec2(offset.x, 0));
+	g += texture2D(sh_input_g, tc + vec2(0,        offset.y));
+	g += texture2D(sh_input_g, tc + vec2(offset.x, offset.y));
+    g /= 4.0f;
+
+	b += texture2D(sh_input_b, tc + vec2(0,        0));
+	b += texture2D(sh_input_b, tc + vec2(offset.x, 0));
+	b += texture2D(sh_input_b, tc + vec2(0,        offset.y));
+	b += texture2D(sh_input_b, tc + vec2(offset.x, offset.y));
+    b /= 4.0f;
+
+    frag_data[0] = r;
+    frag_data[1] = g;
+    frag_data[2] = b;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/gatherSkyShV.glsl b/indra/newview/app_settings/shaders/class3/deferred/gatherSkyShV.glsl
new file mode 100644
index 0000000000..337c8a50fe
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/gatherSkyShV.glsl
@@ -0,0 +1,40 @@
+/** 
+ * @file gatherSkyShV.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+ 
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec2 texcoord0;
+
+VARYING vec2 vary_frag;
+uniform vec2 screen_res;
+
+void main()
+{
+    // pass through untransformed fullscreen pos
+    float oo_divisor = screen_res.x / 64.0;
+    vec3 pos = (position.xyz * oo_divisor) + vec3(oo_divisor - 1, oo_divisor - 1, 0);
+	gl_Position = vec4(pos.xyz, 1.0);
+    vary_frag = texcoord0 * oo_divisor;
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl b/indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl
new file mode 100644
index 0000000000..c02e6d1e57
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl
@@ -0,0 +1,112 @@
+/** 
+ * @file class3/deferred/genSkyShF.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+ 
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_data[3];
+#else
+#define frag_data gl_FragData
+#endif
+
+VARYING vec2 vary_frag;
+
+uniform vec3 sun_dir;
+
+uniform sampler2D transmittance_texture;
+uniform sampler3D scattering_texture;
+uniform sampler3D single_mie_scattering_texture;
+uniform sampler2D irradiance_texture;
+uniform vec4 gamma;
+
+vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 dir, out vec3 transmittance);
+
+vec3 calcDirection(vec2 tc)
+{
+     float phi = tc.y * 2.0 * 3.14159265;
+     float cosTheta = sqrt(1.0 - tc.x);
+     float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
+     return vec3(cos(phi) * sinTheta, sin(phi) * sinTheta, cosTheta);
+}
+
+// reverse mapping above to convert a hemisphere direction into phi/theta values
+void getPhiAndThetaFromDirection(vec3 dir, out float phi, out float theta)
+{
+     float sin_theta;
+     float cos_theta;
+     cos_theta = dir.z;
+     theta     = acos(cos_theta);
+     sin_theta = sin(theta);
+     phi       = abs(sin_theta) > 0.0001 ? acos(dir.x / sin_theta) : 1.0;
+}
+
+// reverse mapping above to convert a hemisphere direction into an SH texture sample pos
+vec2 calcShUvFromDirection(vec3 dir)
+{
+    vec2 uv;
+    float phi;
+    float theta;
+    getPhiAndThetaFromDirection(dir, phi, theta);
+    uv.y = phi   / 2.0 * 3.14159265;
+    uv.x = theta / 2.0 * 3.14159265;
+    return uv;
+}
+
+void projectToL1(vec3 n, vec3 c, vec4 basis, out vec4 coeffs[3])
+{
+    coeffs[0] = vec4(basis.x, n * basis.yzw * c.r);
+    coeffs[1] = vec4(basis.x, n * basis.yzw * c.g);
+    coeffs[2] = vec4(basis.x, n * basis.yzw * c.b);
+}
+
+void main()
+{
+    float Y00 = sqrt(1.0 / 3.14159265) * 0.5;
+    float Y1x = sqrt(3.0 / 3.14159265) * 0.5;
+    float Y1y = Y1x;
+    float Y1z = Y1x;
+
+    vec4 L1 = vec4(Y00, Y1x, Y1y, Y1z);
+
+    vec3 view_direction = calcDirection(vary_frag);
+    vec3 sun_direction  = normalize(sun_dir);
+    vec3 cam_pos        = vec3(0, 0, 6360);
+
+    vec3 transmittance;
+    vec3 radiance = GetSkyLuminance(cam_pos, view_direction, 0.0f, sun_direction, transmittance);
+
+    vec3 color = vec3(1.0) - exp(-radiance * 0.0001);
+
+    color = pow(color, vec3(1.0/2.2));
+
+    vec4 coeffs[3];
+    coeffs[0] = vec4(0);
+    coeffs[1] = vec4(0);
+    coeffs[2] = vec4(0);
+
+    projectToL1(view_direction, color.rgb, L1, coeffs);
+
+    frag_data[0] = coeffs[0];
+    frag_data[1] = coeffs[1];
+    frag_data[2] = coeffs[2];
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/genSkyShV.glsl b/indra/newview/app_settings/shaders/class3/deferred/genSkyShV.glsl
new file mode 100644
index 0000000000..b466883dc7
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/genSkyShV.glsl
@@ -0,0 +1,37 @@
+/** 
+ * @file genSkyShV.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+ 
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec2 texcoord0;
+
+VARYING vec2 vary_frag;
+
+void main()
+{
+    // pass through untransformed fullscreen pos
+	gl_Position = vec4(position.xyz, 1.0);
+    vary_frag = texcoord0;
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/indirect.glsl b/indra/newview/app_settings/shaders/class3/deferred/indirect.glsl
new file mode 100644
index 0000000000..33c5667cae
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/indirect.glsl
@@ -0,0 +1,44 @@
+/** 
+ * @file class3/deferred/indirect.glsl
+ *
+ * $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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+uniform sampler2D sh_input_r;
+uniform sampler2D sh_input_g;
+uniform sampler2D sh_input_b;
+
+vec3 GetIndirect(vec3 norm)
+{
+    vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
+    vec4 l1r = texture2D(sh_input_r, vec2(0,0));
+    vec4 l1g = texture2D(sh_input_g, vec2(0,0));
+    vec4 l1b = texture2D(sh_input_b, vec2(0,0));
+    vec3 indirect = vec3(dot(l1r, l1tap * vec4(1, norm.xyz)),
+                         dot(l1g, l1tap * vec4(1, norm.xyz)),
+                         dot(l1b, l1tap * vec4(1, norm.xyz)));
+    indirect = clamp(indirect, vec3(0), vec3(1.0));
+    return indirect;
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/lightUtil.glsl b/indra/newview/app_settings/shaders/class3/deferred/lightUtil.glsl
new file mode 100644
index 0000000000..8bb3f07fc6
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/lightUtil.glsl
@@ -0,0 +1,117 @@
+/** 
+ * @file lightInfo.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$
+ */
+
+struct DirectionalLightInfo
+{
+    vec4 pos;
+    float depth;
+    vec4 normal;
+    vec3 normalizedLightDirection;
+    vec3 normalizedToLight;
+    float lightIntensity;
+    vec3 lightDiffuseColor;
+    float specExponent;
+    float shadow;
+};
+
+struct SpotLightInfo
+{
+    vec4 pos;
+    float depth;
+    vec4 normal;
+    vec3 normalizedLightDirection;
+    vec3 normalizedToLight;
+    float lightIntensity;
+    float attenuation;
+    float distanceToLight;
+    vec3 lightDiffuseColor;
+    float innerHalfAngleCos;
+    float outerHalfAngleCos;
+    float spotExponent;
+    float specExponent;
+    float shadow;
+};
+
+struct PointLightInfo
+{
+    vec4 pos;
+    float depth;
+    vec4 normal;
+    vec3 normalizedToLight;
+    float lightIntensity;
+    float attenuation;
+    float distanceToLight;
+    vec3 lightDiffuseColor;
+    float lightRadius;
+    float specExponent;
+    vec3 worldspaceLightDirection;
+    float shadow;
+};
+
+float attenuate(float attenuationSelection, float distanceToLight)
+{
+// LLRENDER_REVIEW
+// sh/could eventually consume attenuation func defined in texture
+    return (attenuationSelection == 0.0f) ? 1.0f : // none
+           (attenuationSelection <  1.0f) ? (1.0f / distanceToLight) : // linear atten 
+           (attenuationSelection <  2.0f) ? (1.0f / (distanceToLight*distanceToLight)) // quadratic atten
+										  : (1.0f / (distanceToLight*distanceToLight*distanceToLight));	// cubic atten    
+}
+
+
+vec3 lightDirectional(struct DirectionalLightInfo dli)
+{
+    float lightIntensity = dli.lightIntensity;
+	lightIntensity *= dot(dli.normal.xyz, dli.normalizedLightDirection);
+    //lightIntensity *= directionalShadowSample(vec4(dli.pos.xyz, 1.0f), dli.depth, dli.directionalShadowMap, dli.directionalShadowMatrix);
+	return lightIntensity * dli.lightDiffuseColor;
+}
+
+
+vec3 lightSpot(struct SpotLightInfo sli)    
+{
+	float penumbraRange = (sli.outerHalfAngleCos - sli.innerHalfAngleCos);
+    float coneAngleCos = max(dot(sli.normalizedLightDirection, sli.normalizedToLight), 0.0);
+	float coneAttenFactor = (coneAngleCos <= sli.outerHalfAngleCos) ? 1.0f : pow(smoothstep(1,0, sli.outerHalfAngleCos / penumbraRange), sli.spotExponent);
+    float distanceAttenuation = attenuate(sli.attenuation, sli.distanceToLight);
+    float lightIntensity = sli.lightIntensity;
+    lightIntensity *= distanceAttenuation;
+	lightIntensity *= max(dot(sli.normal.xyz, sli.normalizedLightDirection), 0.0);
+	lightIntensity *= coneAttenFactor;
+    lightIntensity *= sli.shadow;
+	return lightIntensity * sli.lightDiffuseColor;
+}
+
+vec3 lightPoint(struct PointLightInfo pli)
+{
+    float padRadius = pli.lightRadius * 0.1; // distance for which to perform smoothed dropoff past light radius
+	float distanceAttenuation =	attenuate(pli.attenuation, pli.distanceToLight);
+    float lightIntensity = pli.lightIntensity;
+    lightIntensity*= distanceAttenuation;    
+	lightIntensity *= clamp((padRadius - pli.distanceToLight + pli.lightRadius) / padRadius, 0.0, 1.0);
+    lightIntensity *= pli.shadow;
+    lightIntensity *= max(dot(pli.normal.xyz, pli.normalizedToLight), 0.0);
+	return lightIntensity * pli.lightDiffuseColor;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/pointShadowBlurF.glsl b/indra/newview/app_settings/shaders/class3/deferred/pointShadowBlurF.glsl
new file mode 100644
index 0000000000..ca9ce3a2e1
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/pointShadowBlurF.glsl
@@ -0,0 +1,37 @@
+/** 
+ * @file pointShadowBlur.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 samplerCube cube_map; 
+
+in vec3 to_vec;
+
+out vec4 fragColor;
+
+void main() 
+{
+	vec4 vcol = texture(cube_map, to_vec);
+	fragColor = vec4(vcol.rgb, 1.0);
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shVisF.glsl b/indra/newview/app_settings/shaders/class3/deferred/shVisF.glsl
new file mode 100644
index 0000000000..c8991f7a18
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shVisF.glsl
@@ -0,0 +1,73 @@
+/** 
+ * @file class3/deferred/shVisF.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$
+ */
+
+#ifdef DEFINE_GL_FRAGCOLOR
+    out vec4 frag_color;
+#else
+    #define frag_color gl_FragColor
+#endif
+
+/////////////////////////////////////////////////////////////////////////
+// Fragment shader for L1 SH debug rendering
+/////////////////////////////////////////////////////////////////////////
+
+uniform sampler2D sh_input_r;
+uniform sampler2D sh_input_g;
+uniform sampler2D sh_input_b;
+
+uniform mat3 inv_modelviewprojection;
+
+VARYING vec4 vary_pos;
+
+void main(void) 
+{
+    vec2 coord = vary_pos.xy + vec2(0.5,0.5);
+
+    coord.x *= (1.6/0.9);
+
+    if (dot(coord, coord) > 0.25)
+    {
+        discard;
+    }
+
+    vec4 n = vec4(coord*2.0, 0.0, 1);
+    //n.y = -n.y;
+    n.z = sqrt(max(1.0-n.x*n.x-n.y*n.y, 0.0));
+    //n.xyz = inv_modelviewprojection * n.xyz;
+
+    vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
+    vec4 l1r = texture2D(sh_input_r, vec2(0,0));
+    vec4 l1g = texture2D(sh_input_g, vec2(0,0));
+    vec4 l1b = texture2D(sh_input_b, vec2(0,0));
+    vec3 indirect = vec3(
+                      dot(l1r, l1tap * n),
+                      dot(l1g, l1tap * n),
+                      dot(l1b, l1tap * n));
+
+    //indirect = pow(indirect, vec3(0.45));
+    indirect *= 3.0;
+
+	frag_color = vec4(indirect, 1.0);
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shVisV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shVisV.glsl
new file mode 100644
index 0000000000..8f32dfde79
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shVisV.glsl
@@ -0,0 +1,33 @@
+/** 
+ * @file class3/deferred/shVisV.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$
+ */
+ATTRIBUTE vec3 position;
+VARYING vec4 vary_pos;
+
+void main()
+{
+    // Output
+    vary_pos = vec4(position, 1);
+    gl_Position = vary_pos;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl
new file mode 100644
index 0000000000..01599d81c4
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl
@@ -0,0 +1,58 @@
+/** 
+ * @file shadowAlphaMaskF.glsl
+ *
+ * $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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2D diffuseMap;
+
+#if !DEPTH_CLAMP
+VARYING float pos_zd2;
+#endif
+
+VARYING float pos_w;
+
+VARYING float target_pos_x;
+VARYING vec4 vertex_color;
+VARYING vec2 vary_texcoord0;
+VARYING vec3 pos;
+
+vec4 computeMoments(float depth, float a);
+
+void main() 
+{
+	float alpha = diffuseLookup(vary_texcoord0.xy).a * vertex_color.a;
+
+    frag_color = computeMoments(length(pos), float a);
+
+#if !DEPTH_CLAMP
+	gl_FragDepth = max(pos_zd2/pos_w+0.5, 0.0);
+#endif
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl
new file mode 100644
index 0000000000..3fb2bafca4
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl
@@ -0,0 +1,66 @@
+/** 
+ * @file shadowAlphaMaskV.glsl
+ *
+ * $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$
+ */
+
+uniform mat4 texture_matrix0;
+uniform mat4 modelview_projection_matrix;
+uniform float shadow_target_width;
+
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec4 diffuse_color;
+ATTRIBUTE vec2 texcoord0;
+
+#if !DEPTH_CLAMP
+VARYING float pos_zd2;
+#endif
+
+VARYING float target_pos_x;
+VARYING vec4 pos;
+VARYING vec4 vertex_color;
+VARYING vec2 vary_texcoord0;
+
+void passTextureIndex();
+
+void main()
+{
+	//transform vertex
+	vec4 pre_pos = vec4(position.xyz, 1.0);
+	vec4 pos = modelview_projection_matrix * pre_pos;
+	target_pos_x = 0.5 * (shadow_target_width - 1.0) * pos.x;
+
+	pos_w = pos.w;
+
+#if !DEPTH_CLAMP
+	pos_zd2 = pos.z * 0.5;
+	
+	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+#else
+	gl_Position = pos;
+#endif
+	
+	passTextureIndex();
+
+	vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
+	vertex_color = diffuse_color;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl
new file mode 100644
index 0000000000..d6ed5b6bb0
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl
@@ -0,0 +1,74 @@
+/** 
+ * @file class3/deferred/shadowAlphaMaskF.glsl
+ *
+ * $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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2D diffuseMap;
+
+#if !DEPTH_CLAMP
+VARYING float pos_zd2;
+#endif
+
+VARYING float pos_w;
+
+VARYING float target_pos_x;
+VARYING vec4 vertex_color;
+VARYING vec2 vary_texcoord0;
+
+vec4 getPosition(vec2 screen_coord);
+vec4 computeMoments(float depth, float a);
+
+void main() 
+{
+    vec4 pos = getPosition(vary_texcoord0.xy);
+
+    float alpha = diffuseLookup(vary_texcoord0.xy).a * vertex_color.a;
+
+    if (alpha < 0.05) // treat as totally transparent
+    {
+        discard;
+    }
+
+    if (alpha < 0.88) // treat as semi-transparent
+    {
+        if (fract(0.5*floor(target_pos_x / pos_w )) < 0.25)
+        {
+            discard;
+        }
+    }
+
+    frag_color = computeMoments(length(pos.xyz), alpha);
+    
+#if !DEPTH_CLAMP
+    gl_FragDepth = max(pos_zd2/pos_w+0.5, 0.0);
+#endif
+
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl
new file mode 100644
index 0000000000..bc7fe003f2
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl
@@ -0,0 +1,67 @@
+/** 
+ * @file class3/deferred/shadowAlphaMaskV.glsl
+ *
+ * $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$
+ */
+
+uniform mat4 texture_matrix0;
+uniform mat4 modelview_projection_matrix;
+uniform float shadow_target_width;
+
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec4 diffuse_color;
+ATTRIBUTE vec2 texcoord0;
+
+#if !DEPTH_CLAMP
+VARYING float pos_zd2;
+#endif
+
+VARYING vec4 pos;
+VARYING float target_pos_x;
+VARYING vec4 vertex_color;
+VARYING vec2 vary_texcoord0;
+
+void passTextureIndex();
+
+void main()
+{
+	//transform vertex
+	vec4 pre_pos = vec4(position.xyz, 1.0);
+
+	pos = modelview_projection_matrix * pre_pos;
+
+	target_pos_x = 0.5 * (shadow_target_width - 1.0) * pos.x;
+
+#if !DEPTH_CLAMP
+	pos_zd2 = pos.z * 0.5;
+	
+	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+#else
+	gl_Position = pos;
+#endif
+	
+	passTextureIndex();
+
+	vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
+
+	vertex_color = diffuse_color;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl
new file mode 100644
index 0000000000..923de09ada
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl
@@ -0,0 +1,50 @@
+/** 
+ * @file class3/deferred/shadowCubeV.glsl
+ *
+ * $LicenseInfo:firstyear=2011&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;
+
+#if !DEPTH_CLAMP
+VARYING vec4 post_pos;
+#endif
+
+uniform vec3 box_center;
+uniform vec3 box_size;
+
+void main()
+{
+	//transform vertex
+	vec3 p = position*box_size+box_center;
+	vec4 pos = modelview_projection_matrix*vec4(p.xyz, 1.0);
+
+#if !DEPTH_CLAMP
+	post_pos = pos;
+
+	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+#else
+	gl_Position = pos;
+#endif
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl
new file mode 100644
index 0000000000..5a6c8728c0
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl
@@ -0,0 +1,49 @@
+/** 
+ * @file class3/deferred/shadowF.glsl
+ *
+ * $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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2D diffuseMap;
+
+#if !DEPTH_CLAMP
+VARYING float pos_zd2;
+#endif
+
+VARYING vec4 pos;
+VARYING float target_pos_x;
+
+vec4 computeMoments(float depth, float a);
+
+void main() 
+{
+    frag_color = computeMoments(length(pos), 1.0);
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowUtil.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowUtil.glsl
new file mode 100644
index 0000000000..2f69a353e8
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowUtil.glsl
@@ -0,0 +1,157 @@
+/** 
+ * @file class3/deferred/shadowUtil.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 sampler2D       shadowMap0;
+uniform sampler2D       shadowMap1;
+uniform sampler2D       shadowMap2;
+uniform sampler2D       shadowMap3;
+uniform sampler2D       shadowMap4;
+uniform sampler2D       shadowMap5;
+
+uniform vec3 sun_dir;
+uniform vec3 moon_dir;
+uniform vec2 shadow_res;
+uniform vec2 proj_shadow_res;
+uniform mat4 shadow_matrix[6];
+uniform vec4 shadow_clip;
+uniform float shadow_bias;
+
+uniform float spot_shadow_bias;
+uniform float spot_shadow_offset;
+
+float getDepth(vec2 screenpos);
+vec3 getNorm(vec2 screenpos);
+vec4 getPosition(vec2 pos_screen);
+
+float ReduceLightBleeding(float p_max, float Amount)
+{
+    return smoothstep(Amount, 1, p_max);
+}
+
+float ChebyshevUpperBound(vec2 m, float t, float min_v, float Amount)
+{
+    float p = (t <= m.x) ? 1.0 : 0.0;
+
+    float v = m.y - (m.x*m.x);
+    v = max(v, min_v);
+
+    float d = t - m.x;
+
+    float p_max = v / (v + d*d);
+
+    p_max = ReduceLightBleeding(p_max, Amount);
+
+    return max(p, p_max);
+}
+
+vec4 computeMoments(float depth, float a)
+{
+    float m1 = depth;
+    float dx = dFdx(depth);
+    float dy = dFdy(depth);
+    float m2 = m1*m1 + 0.25 * a * (dx*dx + dy*dy);
+    return vec4(m1, m2, a, max(dx, dy));
+}
+
+float vsmDirectionalSample(vec4 stc, float depth, sampler2D shadowMap, mat4 shadowMatrix)
+{
+    vec4 lpos = shadowMatrix * stc;
+    vec4 moments = texture2D(shadowMap, lpos.xy);
+    return ChebyshevUpperBound(moments.rg, depth - shadow_bias * 256.0f, 0.125, 0.9);
+}
+
+float vsmSpotSample(vec4 stc, float depth, sampler2D shadowMap, mat4 shadowMatrix)
+{
+    vec4 lpos = shadowMatrix * stc;
+    vec4 moments = texture2D(shadowMap, lpos.xy);
+    lpos.xyz /= lpos.w;
+    lpos.xy *= 0.5;
+    lpos.xy += 0.5;
+    return ChebyshevUpperBound(moments.rg, depth - spot_shadow_bias * 16.0f, 0.125, 0.9);
+}
+
+#if VSM_POINT_SHADOWS
+float vsmPointSample(float lightDistance, vec3 lightDirection, samplerCube shadow_cube_map)
+{
+    vec4 moments = textureCube(shadow_cube_map, light_direction);
+    return ChebyshevUpperBound(moments.rg, light_distance, 0.01, 0.25);
+}
+#endif
+
+float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen)
+{
+	if (pos.z < -shadow_clip.w)
+    {
+        discard;
+    }
+
+    float depth = getDepth(pos_screen);
+
+    vec4 spos       = vec4(pos,1.0);
+    vec4 near_split = shadow_clip*-0.75;
+    vec4 far_split  = shadow_clip*-1.25;
+
+    float shadow = 0.0f;
+    float weight = 1.0;
+
+    if (spos.z < near_split.z)
+    {
+        shadow += vsmDirectionalSample(spos, depth, shadowMap3, shadow_matrix[3]);
+        weight += 1.0f;
+    }
+    if (spos.z < near_split.y)
+    {
+        shadow += vsmDirectionalSample(spos, depth, shadowMap2, shadow_matrix[2]);
+        weight += 1.0f;
+    }
+    if (spos.z < near_split.x)
+    {
+        shadow += vsmDirectionalSample(spos, depth, shadowMap1, shadow_matrix[1]);
+        weight += 1.0f;
+    }
+    if (spos.z > far_split.x)
+    {
+        shadow += vsmDirectionalSample(spos, depth, shadowMap0, shadow_matrix[0]);
+        weight += 1.0f;
+    }
+
+    shadow /= weight;
+
+    return shadow;
+}
+
+float sampleSpotShadow(vec3 pos, vec3 norm, int index, vec2 pos_screen)
+{
+	if (pos.z < -shadow_clip.w)
+    {
+        discard;
+    }
+
+    float depth = getDepth(pos_screen);
+
+    pos += norm * spot_shadow_offset;
+    return vsmSpotSample(vec4(pos, 1.0), depth, (index == 0) ? shadowMap4 : shadowMap5, shadow_matrix[4 + index]);
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl
new file mode 100644
index 0000000000..9a5edaf091
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl
@@ -0,0 +1,62 @@
+/** 
+ * @file class3/deferred/shadowV.glsl
+ *
+ * $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$
+ */
+
+uniform mat4 modelview_projection_matrix;
+uniform float shadow_target_width;
+uniform mat4 texture_matrix0;
+
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec2 texcoord0;
+
+#if !DEPTH_CLAMP
+VARYING float pos_zd2;
+#endif
+
+VARYING vec4 pos;
+VARYING float target_pos_x;
+VARYING vec4 vertex_color;
+VARYING vec2 vary_texcoord0;
+
+void passTextureIndex();
+
+void main()
+{
+	//transform vertex
+	vec4 pre_pos = vec4(position.xyz, 1.0);
+
+	pos = modelview_projection_matrix * pre_pos;
+
+	target_pos_x = 0.5 * (shadow_target_width - 1.0) * pos.x;
+
+#if !DEPTH_CLAMP
+	pos_zd2 = pos.z * 0.5;
+	
+	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+#else
+	gl_Position = pos;
+#endif
+	
+	vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index ecf6858136..b84d3efbaa 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -40,15 +40,13 @@ uniform sampler2DRect lightMap;
 uniform sampler2DRect depthMap;
 uniform sampler2D     lightFunc;
 
-uniform float blur_size;
 uniform samplerCube environmentMap;
-
+uniform float blur_size;
 uniform float blur_fidelity;
 
 // Inputs
 uniform vec4 morphFactor;
 uniform vec3 camPosLocal;
-uniform vec4 gamma;
 uniform float cloud_shadow;
 uniform float max_y;
 uniform vec4 glow;
-- 
cgit v1.2.3


From 01da53764bebc99fd692b3eb68f8520c6cfa2a97 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 3 Jan 2019 16:21:07 -0800
Subject: Fix per-frag fullbright soft clip convenience funcs to include
 additive and atten args.

---
 indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl | 1 -
 1 file changed, 1 deletion(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index b84d3efbaa..ed06e5a6ac 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -77,7 +77,6 @@ vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 dir,
 vec3 GetSkyLuminanceToPoint(vec3 camPos, vec3 pos, float shadow_length, vec3 dir, out vec3 transmittance);
 
 vec3 scaleSoftClipFrag(vec3 c);
-vec3 fullbrightScaleSoftClipFrag(vec3 c);
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cl);
 vec3 decode_normal (vec2 enc);
-- 
cgit v1.2.3


From 2312efbf3ae09013bc86a2378bed43a743f2df3e Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 4 Jan 2019 10:17:09 -0800
Subject: Add new shaders for generating shadows from clouds.

Add new class3 shadow shaders for VSM shadows.

Add disabled shadow pass in WLSky for using above.
---
 .../shaders/class3/deferred/attachmentShadowF.glsl |  44 +++++
 .../shaders/class3/deferred/attachmentShadowV.glsl |  51 ++++++
 .../shaders/class3/deferred/avatarShadowF.glsl     |  52 ++++++
 .../shaders/class3/deferred/avatarShadowV.glsl     |  68 ++++++++
 .../shaders/class3/deferred/cloudShadowF.glsl      | 114 ++++++++++++
 .../shaders/class3/deferred/cloudShadowV.glsl      |  63 +++++++
 .../shaders/class3/deferred/cloudsF.glsl           |  16 +-
 .../shaders/class3/deferred/softenLightF.glsl      | 117 ++++++-------
 .../shaders/class3/deferred/sunLightF.glsl         | 187 +-------------------
 .../shaders/class3/deferred/sunLightSSAOF.glsl     | 192 ++-------------------
 .../shaders/class3/deferred/treeShadowF.glsl       |  59 +++++++
 .../shaders/class3/deferred/treeShadowV.glsl       |  43 +++++
 .../shaders/class3/deferred/underWaterF.glsl       | 118 +++++++++++++
 .../shaders/class3/deferred/waterF.glsl            | 175 +++++++++++++++++++
 .../shaders/class3/deferred/waterV.glsl            |  95 ++++++++++
 15 files changed, 969 insertions(+), 425 deletions(-)
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/attachmentShadowF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/treeShadowV.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/waterF.glsl
 create mode 100644 indra/newview/app_settings/shaders/class3/deferred/waterV.glsl

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowF.glsl
new file mode 100644
index 0000000000..d973326f93
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowF.glsl
@@ -0,0 +1,44 @@
+/** 
+ * @file avatarShadowF.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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2D diffuseMap;
+
+VARYING vec4 pos;
+VARYING vec2 vary_texcoord0;
+
+vec4 computeMoments(float depth, float a);
+
+void main() 
+{
+    frag_color = computeMoments(length(pos), 1.0);
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl
new file mode 100644
index 0000000000..3be9cb3de8
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl
@@ -0,0 +1,51 @@
+/** 
+ * @file attachmentShadowV.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 projection_matrix;
+uniform mat4 modelview_matrix;
+uniform mat4 texture_matrix0;
+
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec2 texcoord0;
+
+mat4 getObjectSkinnedTransform();
+
+VARYING vec4 pos;
+
+void main()
+{
+	//transform vertex
+	mat4 mat = getObjectSkinnedTransform();
+	
+	mat = modelview_matrix * mat;
+	pos = (mat*vec4(position.xyz, 1.0));
+	pos = projection_matrix * vec4(pos.xyz, 1.0);
+
+#if !DEPTH_CLAMP
+	pos.z = max(pos.z, -pos.w+0.01);
+	gl_Position = pos;
+#else
+	gl_Position = pos;
+#endif
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl
new file mode 100644
index 0000000000..f4e5a61e36
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl
@@ -0,0 +1,52 @@
+/** 
+ * @file avatarShadowF.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$
+ */
+
+/*[EXTRA_CODE_HERE]*/ 
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2D diffuseMap;
+
+#if !DEPTH_CLAMP
+VARYING vec4 post_pos;
+#endif
+
+VARYING vec4 pos;
+
+vec4 computeMoments(float depth, float a);
+
+void main() 
+{
+    frag_color = computeMoments(length(pos), 1.0);
+
+#if !DEPTH_CLAMP
+	gl_FragDepth = max(post_pos.z/post_pos.w*0.5+0.5, 0.0);
+#endif
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl
new file mode 100644
index 0000000000..96ca2fd707
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl
@@ -0,0 +1,68 @@
+/** 
+ * @file avatarShadowV.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 projection_matrix;
+
+mat4 getSkinnedTransform();
+
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec3 normal;
+ATTRIBUTE vec2 texcoord0;
+
+#if !DEPTH_CLAMP
+VARYING vec4 post_pos;
+#endif
+
+VARYING vec4 pos;
+
+void main()
+{
+	vec3 norm;
+	
+	vec4 pos_in = vec4(position.xyz, 1.0);
+	mat4 trans = getSkinnedTransform();
+
+	pos.x = dot(trans[0], pos_in);
+	pos.y = dot(trans[1], pos_in);
+	pos.z = dot(trans[2], pos_in);
+	pos.w = 1.0;
+	
+	norm.x = dot(trans[0].xyz, normal);
+	norm.y = dot(trans[1].xyz, normal);
+	norm.z = dot(trans[2].xyz, normal);
+	norm = normalize(norm);
+	
+	pos = projection_matrix * pos;
+
+#if !DEPTH_CLAMP
+	post_pos = pos;
+	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+#else
+	gl_Position = pos;
+#endif
+
+}
+
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
new file mode 100644
index 0000000000..65af2821be
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
@@ -0,0 +1,114 @@
+/** 
+ * @file class3/deferred/cloudsF.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+ 
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform sampler2D diffuseMap;
+
+VARYING vec4 pos;
+VARYING float target_pos_x;
+VARYING float vary_CloudDensity;
+VARYING vec2 vary_texcoord0;
+VARYING vec2 vary_texcoord1;
+VARYING vec2 vary_texcoord2;
+VARYING vec2 vary_texcoord3;
+
+uniform sampler2D cloud_noise_texture;
+uniform sampler2D cloud_noise_texture_next;
+uniform float blend_factor;
+uniform vec4 cloud_pos_density1;
+uniform vec4 cloud_pos_density2;
+uniform vec4 sunlight_color;
+uniform vec4 cloud_color;
+uniform float cloud_shadow;
+uniform float cloud_scale;
+uniform float cloud_variance;
+uniform vec3 ambient;
+uniform vec3 camPosLocal;
+uniform vec3 sun_dir;
+uniform float sun_size;
+uniform float far_z;
+
+vec4 cloudNoise(vec2 uv)
+{
+   vec4 a = texture2D(cloud_noise_texture, uv);
+   vec4 b = texture2D(cloud_noise_texture_next, uv);
+   vec4 cloud_noise_sample = mix(a, b, blend_factor);
+   return normalize(cloud_noise_sample);
+}
+
+vec4 computeMoments(float depth, float alpha);
+
+void main()
+{
+	// Set variables
+	vec2 uv1 = vary_texcoord0.xy;
+	vec2 uv2 = vary_texcoord1.xy;
+	vec2 uv3 = vary_texcoord2.xy;
+	float cloudDensity = 2.0 * (cloud_shadow - 0.25);
+
+	vec2 uv4 = vary_texcoord3.xy;
+
+    vec2 disturbance  = vec2(cloudNoise(uv1 / 8.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
+    vec2 disturbance2 = vec2(cloudNoise((uv1 + uv3) / 4.0f).x, cloudNoise((uv4 + uv2) / 8.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
+
+	// Offset texture coords
+	uv1 += cloud_pos_density1.xy + (disturbance * 0.02);	//large texture, visible density
+	uv2 += cloud_pos_density1.xy;	//large texture, self shadow
+	uv3 += cloud_pos_density2.xy;	//small texture, visible density
+	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
+
+    float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0 + disturbance2.x + disturbance2.y));
+
+    cloudDensity *= 1.0 - (density_variance * density_variance);
+
+	// Compute alpha1, the main cloud opacity
+	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
+	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
+
+	// And smooth
+	alpha1 = 1. - alpha1 * alpha1;
+	alpha1 = 1. - alpha1 * alpha1;	
+
+    if (alpha1 < 0.001f)
+    {
+        discard;
+    }
+
+	// Compute alpha2, for self shadowing effect
+	// (1 - alpha2) will later be used as percentage of incoming sunlight
+	float alpha2 = (cloudNoise(uv2).x - 0.5);
+	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
+
+	// And smooth
+	alpha2 = 1. - alpha2;
+	alpha2 = 1. - alpha2 * alpha2;	
+
+    frag_color = computeMoments(length(pos), alpha1);
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl
new file mode 100644
index 0000000000..cb27b2c2c5
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl
@@ -0,0 +1,63 @@
+/** 
+ * @file cloudShadowV.glsl
+ *
+ * $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$
+ */
+
+uniform mat4 texture_matrix0;
+uniform mat4 modelview_projection_matrix;
+uniform float shadow_target_width;
+
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec4 diffuse_color;
+ATTRIBUTE vec2 texcoord0;
+
+#if !DEPTH_CLAMP
+VARYING float pos_zd2;
+#endif
+
+VARYING vec4 pos;
+VARYING float target_pos_x;
+VARYING vec2 vary_texcoord0;
+VARYING vec4 vertex_color;
+
+void passTextureIndex();
+
+void main()
+{
+	//transform vertex
+	vec4 pre_pos = vec4(position.xyz, 1.0);
+	pos = modelview_projection_matrix * pre_pos;
+	target_pos_x = 0.5 * (shadow_target_width - 1.0) * pos.x;
+
+#if !DEPTH_CLAMP
+	pos_zd2 = pos.z * 0.5;
+	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+#else
+	gl_Position = pos;
+#endif
+	
+	passTextureIndex();
+
+	vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
+	vertex_color = diffuse_color;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index f8373215f0..015caad749 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -138,9 +138,23 @@ void main()
 	// Combine
 	vec4 color;
 
+    vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
+
+    vec4 l1r = texture2D(sh_input_r, vec2(0,0));
+    vec4 l1g = texture2D(sh_input_g, vec2(0,0));
+    vec4 l1b = texture2D(sh_input_b, vec2(0,0));
+
+    vec3 sun_indir = vec3(-view_direction.xy, view_direction.z);
+    vec3 amb = vec3(dot(l1r, l1tap * vec4(1, sun_indir)),
+                    dot(l1g, l1tap * vec4(1, sun_indir)),
+                    dot(l1b, l1tap * vec4(1, sun_indir)));
+
+
+    amb = max(vec3(0), amb);
+
     color.rgb = sun_color * cloud_color.rgb * (1. - alpha2);
     color.rgb = pow(color.rgb, vec3(1.0 / 2.2));
-    color.rgb += ambient;
+    color.rgb += amb;
 
 	frag_data[0] = vec4(color.rgb, alpha1);
 	frag_data[1] = vec4(0);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index ed06e5a6ac..9411e905d3 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -76,11 +76,7 @@ vec3 GetSunAndSkyIrradiance(vec3 camPos, vec3 norm, vec3 dir, out vec3 sky_irrad
 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 scaleSoftClipFrag(vec3 c);
-vec3 srgb_to_linear(vec3 cs);
-vec3 linear_to_srgb(vec3 cl);
-vec3 decode_normal (vec2 enc);
-
+vec3 decode_normal(vec2 xy);
 vec3 ColorFromRadiance(vec3 radiance);
 vec4 getPositionWithDepth(vec2 pos_screen, float depth);
 vec4 getPosition(vec2 pos_screen);
@@ -92,32 +88,31 @@ vec4 applyWaterFogView(vec3 pos, vec4 color);
 
 void main() 
 {
-	vec2 tc = vary_fragcoord.xy;
-	float depth = texture2DRect(depthMap, tc.xy).r;
-	vec3 pos = getPositionWithDepth(tc, depth).xyz;
-	vec4 norm = texture2DRect(normalMap, tc);
-	float envIntensity = norm.z;
+    vec2 tc = vary_fragcoord.xy;
+    float depth = texture2DRect(depthMap, tc.xy).r;
+    vec3 pos = getPositionWithDepth(tc, depth).xyz;
+    vec4 norm = texture2DRect(normalMap, tc);
+    float envIntensity = norm.z;
     norm.xyz = decode_normal(norm.xy);
 
-	float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
-
-	float light_gamma = 1.0/1.3;
+    float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
+              da = pow(da, global_gamma + 0.3);
 
-	vec4 diffuse = texture2DRect(diffuseRect, tc); // linear
+    vec4 diffuse = texture2DRect(diffuseRect, tc); // linear
 
-	vec3 col;
-	float bloom = 0.0;
-	{
+    vec3 col;
+    float bloom = 0.0;
+    {
         vec3 camPos = (camPosLocal / 1000.0f) + vec3(0, 0, 6360.0f);
 
-		vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
-		
-		vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
-		scol_ambocc = pow(scol_ambocc, vec2(light_gamma));
+        vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+        
+        vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
+//        scol_ambocc = pow(scol_ambocc, vec3(global_gamma + 0.3));
 
-		float scol = max(scol_ambocc.r, diffuse.a); 
+        float scol = max(scol_ambocc.r, diffuse.a); 
 
-		float ambocc = scol_ambocc.g;
+        float ambocc = scol_ambocc.g;
 
         vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
         vec4 l1r = texture2D(sh_input_r, vec2(0,0));
@@ -142,46 +137,44 @@ void main()
         col *= transmittance;
         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 = scol * texture2D(lightFunc, vec2(sa, spec.a)).r * atmo_color;
-			
-			// 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 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 = scol * texture2D(lightFunc, vec2(sa, spec.a)).r * atmo_color;
+            
+            // 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 sun_direction  = (inv_modelview * vec4(sun_dir, 1.0)).xyz;
             vec3 radiance_sun  = GetSkyLuminance(camPos, env_vec, 0.0f, sun_direction, transmittance);
             vec3 refcol = ColorFromRadiance(radiance_sun);
-			col = mix(col.rgb, refcol, envIntensity);
-		}
-						
-		/*if (norm.w < 0.5)
-		{
-			col = scaleSoftClipFrag(col);
-		}*/
-
-		#ifdef WATER_FOG
-			vec4 fogged = applyWaterFogView(pos,vec4(col, bloom));
-			col = fogged.rgb;
-			bloom = fogged.a;
-		#endif
-
-        col = pow(col, vec3(light_gamma));
-	}
-	
-	frag_color.rgb = col;
-	frag_color.a = bloom;
+            col = mix(col.rgb, refcol, envIntensity);
+        }
+                        
+        /*if (norm.w < 0.5)
+        {
+            col = scaleSoftClipFrag(col);
+        }*/
+
+        #ifdef WATER_FOG
+            vec4 fogged = applyWaterFogView(pos,vec4(col, bloom));
+            col = fogged.rgb;
+            bloom = fogged.a;
+        #endif
+    }
+    
+    frag_color.rgb = col;
+    frag_color.a = bloom;
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
index 894534b105..e230ebb71c 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file sunLightF.glsl
+ * @file class3\deferred\sunLightF.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -35,197 +35,24 @@ out vec4 frag_color;
 
 //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);
 vec3 getNorm(vec2 pos_screen);
 
-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;
-}
+float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen); 
+float sampleSpotShadow(vec3 pos, vec3 norm, int index, vec2 pos_screen); 
 
 void main() 
 {
 	vec2 pos_screen = vary_fragcoord.xy;
 	vec4 pos = getPosition(pos_screen);
 	vec3 norm = getNorm(pos_screen);
-		
-	/*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;
+	frag_color.r = sampleDirectionalShadow(pos.xyz, norm, pos_screen);
+	frag_color.g = 1.0f;
+    frag_color.b = sampleSpotShadow(pos.xyz, norm, 0, pos_screen);
+    frag_color.a = sampleSpotShadow(pos.xyz, norm, 1, pos_screen);
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
index 0870a80a32..342a2ff3ed 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightSSAOF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file sunLightSSAOF.glsl
+ * @file class3\deferred\sunLightSSAOF.glsl
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2007, Linden Research, Inc.
@@ -34,200 +34,28 @@ out vec4 frag_color;
 
 //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;
-
 vec4 getPosition(vec2 pos_screen);
 vec3 getNorm(vec2 pos_screen);
 
-//calculate decreases in ambient lighting when crowded out (SSAO)
-float calcAmbientOcclusion(vec4 pos, vec3 norm, pos_screen);
-
-float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl, vec2 pos_screen)
-{
-	stc.xyz /= stc.w;
-	stc.z += shadow_bias;
+float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen);
+float sampleSpotShadow(vec3 pos, vec3 norm, int index, vec2 pos_screen);
 
-	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;
-}
+//calculate decreases in ambient lighting when crowded out (SSAO)
+float calcAmbientOcclusion(vec4 pos, vec3 norm, vec2 pos_screen);
 
 void main() 
 {
-	vec2 pos_screen = vary_fragcoord.xy;	
+	vec2 pos_screen = vary_fragcoord.xy;
 	vec4 pos        = getPosition(pos_screen);
 	vec3 norm       = getNorm(pos_screen);
-		
-	/*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, pos_screen);
-	
-	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;
+	frag_color.r = sampleDirectionalShadow(pos.xyz, norm, pos_screen);
+    frag_color.b = calcAmbientOcclusion(pos, norm, pos_screen);
+    frag_color.b = sampleSpotShadow(pos.xyz, norm, 0, pos_screen);
+    frag_color.a = sampleSpotShadow(pos.xyz, norm, 1, pos_screen);
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl
new file mode 100644
index 0000000000..693af31bf2
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl
@@ -0,0 +1,59 @@
+/** 
+ * @file treeShadowF.glsl
+ *
+ * $LicenseInfo:firstyear=2005&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2005, 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$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_color;
+#else
+#define frag_color gl_FragColor
+#endif
+
+uniform float minimum_alpha;
+
+uniform sampler2D diffuseMap;
+
+VARYING vec4 pos;
+VARYING vec2 vary_texcoord0;
+
+vec4 computeMoments(float d, float a);
+
+void main() 
+{
+	float alpha = texture2D(diffuseMap, vary_texcoord0.xy).a;
+
+	if (alpha < minimum_alpha)
+	{
+		discard;
+	}
+
+    frag_color = computeMoments(length(pos), 1.0);
+
+#if !DEPTH_CLAMP
+	gl_FragDepth = max(pos.z/pos.w*0.5+0.5, 0.0);
+#endif
+
+}
+
diff --git a/indra/newview/app_settings/shaders/class3/deferred/treeShadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/treeShadowV.glsl
new file mode 100644
index 0000000000..15e769ac10
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/treeShadowV.glsl
@@ -0,0 +1,43 @@
+/** 
+ * @file treeShadowV.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 texture_matrix0;
+uniform mat4 modelview_projection_matrix;
+ 
+ATTRIBUTE vec3 position;
+ATTRIBUTE vec2 texcoord0;
+
+VARYING vec4 pos;
+VARYING vec2 vary_texcoord0;
+
+void main()
+{
+	//transform vertex
+	pos = modelview_projection_matrix*vec4(position.xyz, 1.0);
+
+	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
+	
+	vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl b/indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl
new file mode 100644
index 0000000000..9d18d1afd8
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl
@@ -0,0 +1,118 @@
+/**
+ * @file underWaterF.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$
+ */
+ 
+/*[EXTRA_CODE_HERE]*/
+
+#ifdef DEFINE_GL_FRAGCOLOR
+out vec4 frag_data[3];
+#else
+#define frag_data gl_FragData
+#endif
+
+uniform sampler2D diffuseMap;
+uniform sampler2D bumpMap;   
+uniform sampler2D screenTex;
+uniform sampler2D refTex;
+uniform sampler2D screenDepth;
+
+uniform vec4 fogCol;
+uniform vec3 lightDir;
+uniform vec3 specular;
+uniform float lightExp;
+uniform vec2 fbScale;
+uniform float refScale;
+uniform float znear;
+uniform float zfar;
+uniform float kd;
+uniform vec4 waterPlane;
+uniform vec3 eyeVec;
+uniform vec4 waterFogColor;
+uniform float waterFogDensity;
+uniform float waterFogKS;
+uniform vec2 screenRes;
+
+//bigWave is (refCoord.w, view.w);
+VARYING vec4 refCoord;
+VARYING vec4 littleWave;
+VARYING vec4 view;
+
+vec3 srgb_to_linear(vec3 cs);
+vec3 linear_to_srgb(vec3 cl);
+
+vec2 encode_normal(vec3 n);
+
+vec4 applyWaterFog(vec4 color, vec3 viewVec)
+{
+	//normalize view vector
+	vec3 view = normalize(viewVec);
+	float es = -view.z;
+
+	//find intersection point with water plane and eye vector
+	
+	//get eye depth
+	float e0 = max(-waterPlane.w, 0.0);
+	
+	//get object depth
+	float depth = length(viewVec);
+		
+	//get "thickness" of water
+	float l = max(depth, 0.1);
+
+	float kd = waterFogDensity;
+	float ks = waterFogKS;
+	vec4 kc = waterFogColor;
+	
+	float F = 0.98;
+	
+	float t1 = -kd * pow(F, ks * e0);
+	float t2 = kd + ks * es;
+	float t3 = pow(F, t2*l) - 1.0;
+	
+	float L = min(t1/t2*t3, 1.0);
+	
+	float D = pow(0.98, l*kd);
+	return color * D + kc * L;
+}
+
+void main() 
+{
+	vec4 color;
+	    
+	//get detail normals
+	vec3 wave1 = texture2D(bumpMap, vec2(refCoord.w, view.w)).xyz*2.0-1.0;
+	vec3 wave2 = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0;
+	vec3 wave3 = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0;    
+	vec3 wavef = normalize(wave1+wave2+wave3);
+	
+	//figure out distortion vector (ripply)   
+	vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
+	distort = distort+wavef.xy*refScale;
+		
+	vec4 fb = texture2D(screenTex, distort);
+
+	frag_data[0] = vec4(fb.rgb, 1.0); // diffuse
+	frag_data[1] = vec4(0.5,0.5,0.5, 0.95); // speccolor*spec, spec
+	frag_data[2] = vec4(encode_normal(wavef), 0.0, 0.0); // normalxyz, displace
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl
new file mode 100644
index 0000000000..2a144ba23a
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl
@@ -0,0 +1,175 @@
+/** 
+ * @file waterF.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_data[3];
+#else
+#define frag_data gl_FragData
+#endif
+
+uniform sampler2D bumpMap;   
+uniform sampler2D bumpMap2;
+uniform float blend_factor;
+uniform sampler2D screenTex;
+uniform sampler2D refTex;
+
+uniform float sunAngle;
+uniform float sunAngle2;
+uniform vec3 lightDir;
+uniform vec3 specular;
+uniform float lightExp;
+uniform float refScale;
+uniform float kd;
+uniform vec2 screenRes;
+uniform vec3 normScale;
+uniform float fresnelScale;
+uniform float fresnelOffset;
+uniform float blurMultiplier;
+uniform vec2 screen_res;
+uniform mat4 norm_mat; //region space to screen space
+
+//bigWave is (refCoord.w, view.w);
+VARYING vec4 refCoord;
+VARYING vec4 littleWave;
+VARYING vec4 view;
+VARYING vec4 vary_position;
+
+vec3 scaleSoftClip(vec3 c);
+vec3 srgb_to_linear(vec3 cs);
+vec2 encode_normal(vec3 n);
+
+vec3 BlendNormal(vec3 bump1, vec3 bump2)
+{
+    //vec3 normal   = bump1.xyz * vec3( 2.0,  2.0, 2.0) - vec3(1.0, 1.0,  0.0);
+    //vec3 normal2  = bump2.xyz * vec3(-2.0, -2.0, 2.0) + vec3(1.0, 1.0, -1.0);
+    //vec3 n        = normalize(normal * dot(normal, normal2) - (normal2 * normal.z));
+    vec3 n = normalize(mix(bump1, bump2, blend_factor));
+    return n;
+}
+
+void main() 
+{
+	vec4 color;
+	float dist = length(view.xy);
+	
+	//normalize view vector
+	vec3 viewVec = normalize(view.xyz);
+	
+	//get wave normals
+	vec3 wave1_a = texture2D(bumpMap, vec2(refCoord.w, view.w)).xyz*2.0-1.0;
+	vec3 wave2_a = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0;
+	vec3 wave3_a = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0;
+
+
+	vec3 wave1_b = texture2D(bumpMap2, vec2(refCoord.w, view.w)).xyz*2.0-1.0;
+	vec3 wave2_b = texture2D(bumpMap2, littleWave.xy).xyz*2.0-1.0;
+	vec3 wave3_b = texture2D(bumpMap2, littleWave.zw).xyz*2.0-1.0;
+
+    vec3 wave1 = BlendNormal(wave1_a, wave1_b);
+    vec3 wave2 = BlendNormal(wave2_a, wave2_b);
+    vec3 wave3 = BlendNormal(wave3_a, wave3_b);
+
+	//get base fresnel components	
+	
+	vec3 df = vec3(
+					dot(viewVec, wave1),
+					dot(viewVec, (wave2 + wave3) * 0.5),
+					dot(viewVec, wave3)
+				 ) * fresnelScale + fresnelOffset;
+	df *= df;
+		    
+	vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
+	
+	float dist2 = dist;
+	dist = max(dist, 5.0);
+	
+	float dmod = sqrt(dist);
+	
+	vec2 dmod_scale = vec2(dmod*dmod, dmod);
+	
+	//get reflected color
+	vec2 refdistort1 = wave1.xy*normScale.x;
+	vec2 refvec1 = distort+refdistort1/dmod_scale;
+	vec4 refcol1 = texture2D(refTex, refvec1);
+	
+	vec2 refdistort2 = wave2.xy*normScale.y;
+	vec2 refvec2 = distort+refdistort2/dmod_scale;
+	vec4 refcol2 = texture2D(refTex, refvec2);
+	
+	vec2 refdistort3 = wave3.xy*normScale.z;
+	vec2 refvec3 = distort+refdistort3/dmod_scale;
+	vec4 refcol3 = texture2D(refTex, refvec3);
+
+	vec4 refcol = refcol1 + refcol2 + refcol3;
+	float df1 = df.x + df.y + df.z;
+	refcol *= df1 * 0.333;
+	
+	vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5;
+	wavef.z *= max(-viewVec.z, 0.1);
+	wavef = normalize(wavef);
+	
+	float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset;
+	
+	vec2 refdistort4 = wavef.xy*0.125;
+	refdistort4.y -= abs(refdistort4.y);
+	vec2 refvec4 = distort+refdistort4/dmod;
+	float dweight = min(dist2*blurMultiplier, 1.0);
+	vec4 baseCol = texture2D(refTex, refvec4);
+
+	refcol = mix(baseCol*df2, refcol, dweight);
+
+	//get specular component
+	float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
+		
+	//harden specular
+	spec = pow(spec, 128.0);
+
+	//figure out distortion vector (ripply)   
+	vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0);
+		
+	vec4 fb = texture2D(screenTex, distort2);
+	
+	//mix with reflection
+	// Note we actually want to use just df1, but multiplying by 0.999999 gets around an nvidia compiler bug
+	color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.99999);
+
+    color.rgb *= 2.0f;
+    color.rgb = scaleSoftClip(color.rgb);
+	
+	vec4 pos = vary_position;
+	
+	color.rgb += spec * specular;
+	color.a    = spec * sunAngle2;
+    
+	vec3 screenspacewavef = normalize((norm_mat*vec4(wavef, 1.0)).xyz);
+	
+	frag_data[0] = vec4(color.rgb, color); // diffuse
+	frag_data[1] = vec4(spec * specular, spec);		// speccolor, spec
+	frag_data[2] = vec4(encode_normal(wavef.xyz), 0.05, 0);// normalxy, 0, 0
+}
diff --git a/indra/newview/app_settings/shaders/class3/deferred/waterV.glsl b/indra/newview/app_settings/shaders/class3/deferred/waterV.glsl
new file mode 100644
index 0000000000..02000d90ca
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class3/deferred/waterV.glsl
@@ -0,0 +1,95 @@
+/** 
+ * @file waterV.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_matrix;
+uniform mat4 modelview_projection_matrix;
+
+ATTRIBUTE vec3 position;
+
+
+uniform vec2 d1;
+uniform vec2 d2;
+uniform float time;
+uniform vec3 eyeVec;
+uniform float waterHeight;
+
+VARYING vec4 refCoord;
+VARYING vec4 littleWave;
+VARYING vec4 view;
+
+VARYING vec4 vary_position;
+
+float wave(vec2 v, float t, float f, vec2 d, float s) 
+{
+   return (dot(d, v)*f + t*s)*f;
+}
+
+void main()
+{
+	//transform vertex
+	vec4 pos = vec4(position.xyz, 1.0);
+	mat4 modelViewProj = modelview_projection_matrix;
+	
+	vec4 oPosition;
+		    
+	//get view vector
+	vec3 oEyeVec;
+	oEyeVec.xyz = pos.xyz-eyeVec;
+		
+	float d = length(oEyeVec.xy);
+	float ld = min(d, 2560.0);
+	
+	pos.xy = eyeVec.xy + oEyeVec.xy/d*ld;
+	view.xyz = oEyeVec;
+		
+	d = clamp(ld/1536.0-0.5, 0.0, 1.0);	
+	d *= d;
+		
+	oPosition = vec4(position, 1.0);
+	oPosition.z = mix(oPosition.z, max(eyeVec.z*0.75, 0.0), d);
+	vary_position = modelview_matrix * oPosition;
+	oPosition = modelViewProj * oPosition;
+	
+	refCoord.xyz = oPosition.xyz + vec3(0,0,0.2);
+	
+	//get wave position parameter (create sweeping horizontal waves)
+	vec3 v = pos.xyz;
+	v.x += (cos(v.x*0.08/*+time*0.01*/)+sin(v.y*0.02))*6.0;
+	    
+	//push position for further horizon effect.
+	pos.xyz = oEyeVec.xyz*(waterHeight/oEyeVec.z);
+	pos.w = 1.0;
+	pos = modelview_matrix*pos;
+	
+	//pass wave parameters to pixel shader
+	vec2 bigWave =  (v.xy) * vec2(0.04,0.04)  + d1 * time * 0.055;
+	//get two normal map (detail map) texture coordinates
+	littleWave.xy = (v.xy) * vec2(0.45, 0.9)   + d2 * time * 0.13;
+	littleWave.zw = (v.xy) * vec2(0.1, 0.2) + d1 * time * 0.1;
+	view.w = bigWave.y;
+	refCoord.w = bigWave.x;
+	
+	gl_Position = oPosition;
+}
-- 
cgit v1.2.3


From c0f67e8d6a20933d35539888b229e3ac77fa22ec Mon Sep 17 00:00:00 2001
From: andreykproductengine <andreykproductengine@lindenlab.com>
Date: Thu, 10 Jan 2019 19:54:02 +0200
Subject: Fix for lineendings in depthToShadowVolumeG.glsl

---
 .../class3/deferred/depthToShadowVolumeG.glsl      | 404 ++++++++++-----------
 1 file changed, 202 insertions(+), 202 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl b/indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl
index 5734e2abb2..cdaff4b09f 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/depthToShadowVolumeG.glsl
@@ -1,202 +1,202 @@
-/** 
- * @file depthToShadowVolumeG.glsl
- *
- * $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$
- */
-#extension GL_ARB_geometry_shader4  : enable
-#extension GL_ARB_texture_rectangle : enable
-
-/*[EXTRA_CODE_HERE]*/
-
-layout (triangles) in;
-layout (triangle_strip, max_vertices = 128) out;
-
-uniform sampler2DRect depthMap;
-uniform mat4 shadowMatrix[6]; 
-uniform vec4 lightpos;
-
-VARYING vec2 vary_texcoord0;
-
-out vec3 to_vec;
-
-void cross_products(out vec4 ns[3], int a, int b, int c)
-{
-   ns[0] = cross(gl_PositionIn[b].xyz - gl_PositionIn[a].xyz, gl_PositionIn[c].xyz - gl_PositionIn[a].xyz);
-   ns[1] = cross(gl_PositionIn[c].xyz - gl_PositionIn[b].xyz, gl_PositionIn[a].xyz - gl_PositionIn[b].xyz);
-   ns[2] = cross(gl_PositionIn[a].xyz - gl_PositionIn[c].xyz, gl_PositionIn[b].xyz - gl_PositionIn[c].xyz);
-}
-
-vec3 getLightDirection(vec4 lightpos, vec3 pos)
-{
-
-    vec3 lightdir = lightpos.xyz - lightpos.w * pos;
-    return lightdir;
-}
-
-void emitTri(vec4 v[3])
-{
-    gl_Position = proj_matrix * v[0];
-    EmitVertex();
-
-    gl_Position = proj_matrix * v[1];
-    EmitVertex();
-
-    gl_Position = proj_matrix * v[2];
-    EmitVertex();
-
-    EndPrimitive();
-}
-
-void emitQuad(vec4 v[4]
-{
-    // Emit a quad as a triangle strip.
-    gl_Position = proj_matrix*v[0];
-    EmitVertex();
-
-    gl_Position = proj_matrix*v[1];
-    EmitVertex();
-
-    gl_Position = proj_matrix*v[2];
-    EmitVertex();
-
-    gl_Position = proj_matrix*v[3];
-    EmitVertex(); 
-
-    EndPrimitive();
-}
-
-void emitPrimitives(int layer)
-{
-    int i = layer;
-    gl_Layer = i;
-
-    vec4 depth1 = vec4(texture2DRect(depthMap, tc0).rg, texture2DRect(depthMap, tc1).rg));
-    vec3 depth2 = vec4(texture2DRect(depthMap, tc2).rg, texture2DRect(depthMap, tc3).rg));
-    vec3 depth3 = vec4(texture2DRect(depthMap, tc4).rg, texture2DRect(depthMap, tc5).rg));
-    vec3 depth4 = vec4(texture2DRect(depthMap, tc6).rg, texture2DRect(depthMap, tc7).rg));
-
-    depth1 = min(depth1, depth2);
-    depth1 = min(depth1, depth3);
-    depth1 = min(depth1, depth4);
-
-    vec2 depth = min(depth1.xy, depth1.zw);
-
-    int side = sqrt(gl_VerticesIn);
-
-    for (int j = 0; j < side; j++)
-    {
-        for (int k = 0; k < side; ++k)
-        {
-            vec3 pos = gl_PositionIn[(j * side) + k].xyz;
-            vec4 v = shadowMatrix[i] * vec4(pos, 1.0);
-            gl_Position = v;
-            to_vec = pos - light_position.xyz * depth;
-            EmitVertex();
-        }
-
-        EndPrimitive();
-    }
-
-    vec3 norms[3]; // Normals
-    vec3 lightdir3]; // Directions toward light
-
-    vec4 v[4]; // Temporary vertices
-
-    vec4 or_pos[3] =
-    {  // Triangle oriented toward light source
-        gl_PositionIn[0],
-        gl_PositionIn[2],
-        gl_PositionIn[4]
-    };
-
-    // Compute normal at each vertex.
-    cross_products(n, 0, 2, 4);
-
-    // Compute direction from vertices to light.
-    lightdir[0] = getLightDirection(lightpos, gl_PositionIn[0].xyz);
-    lightdir[1] = getLightDirection(lightpos, gl_PositionIn[2].xyz);
-    lightdir[2] = getLightDirection(lightpos, gl_PositionIn[4].xyz);
-
-    // Check if the main triangle faces the light.
-    bool faces_light = true;
-    if (!(dot(ns[0],d[0]) > 0
-         |dot(ns[1],d[1]) > 0
-         |dot(ns[2],d[2]) > 0))
-    {
-        // Flip vertex winding order in or_pos.
-        or_pos[1] = gl_PositionIn[4];
-        or_pos[2] = gl_PositionIn[2];
-        faces_light = false;
-    }
-
-    // Near cap: simply render triangle.
-    emitTri(or_pos);
-
-    // Far cap: extrude positions to infinity.
-    v[0] =vec4(lightpos.w * or_pos[0].xyz - lightpos.xyz,0);
-    v[1] =vec4(lightpos.w * or_pos[2].xyz - lightpos.xyz,0);
-    v[2] =vec4(lightpos.w * or_pos[1].xyz - lightpos.xyz,0);
-
-    emitTri(v);
-
-    // Loop over all edges and extrude if needed.
-    for ( int i=0; i<3; i++ ) 
-    {
-       // Compute indices of neighbor triangle.
-       int v0 = i*2;
-       int nb = (i*2+1);
-       int v1 = (i*2+2) % 6;
-       cross_products(n, v0, nb, v1);
-
-       // Compute direction to light, again as above.
-       d[0] =lightpos.xyz-lightpos.w*gl_PositionIn[v0].xyz;
-       d[1] =lightpos.xyz-lightpos.w*gl_PositionIn[nb].xyz;
-       d[2] =lightpos.xyz-lightpos.w*gl_PositionIn[v1].xyz;
-
-       bool is_parallel = gl_PositionIn[nb].w < 1e-5;
-
-       // Extrude the edge if it does not have a
-       // neighbor, or if it's a possible silhouette.
-       if (is_parallel ||
-          ( faces_light != (dot(ns[0],d[0])>0 ||
-                            dot(ns[1],d[1])>0 ||
-                            dot(ns[2],d[2])>0) ))
-       {
-           // Make sure sides are oriented correctly.
-           int i0 = faces_light ? v0 : v1;
-           int i1 = faces_light ? v1 : v0;
-
-           v[0] = gl_PositionIn[i0];
-           v[1] = vec4(lightpos.w*gl_PositionIn[i0].xyz - lightpos.xyz, 0);
-           v[2] = gl_PositionIn[i1];
-           v[3] = vec4(lightpos.w*gl_PositionIn[i1].xyz - lightpos.xyz, 0);
-
-           emitQuad(v);
-       }
-    }
-}
-
-void main()
-{
-    // Output
-    emitPrimitives(0);
-}
+/** 
+ * @file depthToShadowVolumeG.glsl
+ *
+ * $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$
+ */
+#extension GL_ARB_geometry_shader4  : enable
+#extension GL_ARB_texture_rectangle : enable
+
+/*[EXTRA_CODE_HERE]*/
+
+layout (triangles) in;
+layout (triangle_strip, max_vertices = 128) out;
+
+uniform sampler2DRect depthMap;
+uniform mat4 shadowMatrix[6]; 
+uniform vec4 lightpos;
+
+VARYING vec2 vary_texcoord0;
+
+out vec3 to_vec;
+
+void cross_products(out vec4 ns[3], int a, int b, int c)
+{
+   ns[0] = cross(gl_PositionIn[b].xyz - gl_PositionIn[a].xyz, gl_PositionIn[c].xyz - gl_PositionIn[a].xyz);
+   ns[1] = cross(gl_PositionIn[c].xyz - gl_PositionIn[b].xyz, gl_PositionIn[a].xyz - gl_PositionIn[b].xyz);
+   ns[2] = cross(gl_PositionIn[a].xyz - gl_PositionIn[c].xyz, gl_PositionIn[b].xyz - gl_PositionIn[c].xyz);
+}
+
+vec3 getLightDirection(vec4 lightpos, vec3 pos)
+{
+
+    vec3 lightdir = lightpos.xyz - lightpos.w * pos;
+    return lightdir;
+}
+
+void emitTri(vec4 v[3])
+{
+    gl_Position = proj_matrix * v[0];
+    EmitVertex();
+
+    gl_Position = proj_matrix * v[1];
+    EmitVertex();
+
+    gl_Position = proj_matrix * v[2];
+    EmitVertex();
+
+    EndPrimitive();
+}
+
+void emitQuad(vec4 v[4]
+{
+    // Emit a quad as a triangle strip.
+    gl_Position = proj_matrix*v[0];
+    EmitVertex();
+
+    gl_Position = proj_matrix*v[1];
+    EmitVertex();
+
+    gl_Position = proj_matrix*v[2];
+    EmitVertex();
+
+    gl_Position = proj_matrix*v[3];
+    EmitVertex(); 
+
+    EndPrimitive();
+}
+
+void emitPrimitives(int layer)
+{
+    int i = layer;
+    gl_Layer = i;
+
+    vec4 depth1 = vec4(texture2DRect(depthMap, tc0).rg, texture2DRect(depthMap, tc1).rg));
+    vec3 depth2 = vec4(texture2DRect(depthMap, tc2).rg, texture2DRect(depthMap, tc3).rg));
+    vec3 depth3 = vec4(texture2DRect(depthMap, tc4).rg, texture2DRect(depthMap, tc5).rg));
+    vec3 depth4 = vec4(texture2DRect(depthMap, tc6).rg, texture2DRect(depthMap, tc7).rg));
+
+    depth1 = min(depth1, depth2);
+    depth1 = min(depth1, depth3);
+    depth1 = min(depth1, depth4);
+
+    vec2 depth = min(depth1.xy, depth1.zw);
+
+    int side = sqrt(gl_VerticesIn);
+
+    for (int j = 0; j < side; j++)
+    {
+        for (int k = 0; k < side; ++k)
+        {
+            vec3 pos = gl_PositionIn[(j * side) + k].xyz;
+            vec4 v = shadowMatrix[i] * vec4(pos, 1.0);
+            gl_Position = v;
+            to_vec = pos - light_position.xyz * depth;
+            EmitVertex();
+        }
+
+        EndPrimitive();
+    }
+
+    vec3 norms[3]; // Normals
+    vec3 lightdir3]; // Directions toward light
+
+    vec4 v[4]; // Temporary vertices
+
+    vec4 or_pos[3] =
+    {  // Triangle oriented toward light source
+        gl_PositionIn[0],
+        gl_PositionIn[2],
+        gl_PositionIn[4]
+    };
+
+    // Compute normal at each vertex.
+    cross_products(n, 0, 2, 4);
+
+    // Compute direction from vertices to light.
+    lightdir[0] = getLightDirection(lightpos, gl_PositionIn[0].xyz);
+    lightdir[1] = getLightDirection(lightpos, gl_PositionIn[2].xyz);
+    lightdir[2] = getLightDirection(lightpos, gl_PositionIn[4].xyz);
+
+    // Check if the main triangle faces the light.
+    bool faces_light = true;
+    if (!(dot(ns[0],d[0]) > 0
+         |dot(ns[1],d[1]) > 0
+         |dot(ns[2],d[2]) > 0))
+    {
+        // Flip vertex winding order in or_pos.
+        or_pos[1] = gl_PositionIn[4];
+        or_pos[2] = gl_PositionIn[2];
+        faces_light = false;
+    }
+
+    // Near cap: simply render triangle.
+    emitTri(or_pos);
+
+    // Far cap: extrude positions to infinity.
+    v[0] =vec4(lightpos.w * or_pos[0].xyz - lightpos.xyz,0);
+    v[1] =vec4(lightpos.w * or_pos[2].xyz - lightpos.xyz,0);
+    v[2] =vec4(lightpos.w * or_pos[1].xyz - lightpos.xyz,0);
+
+    emitTri(v);
+
+    // Loop over all edges and extrude if needed.
+    for ( int i=0; i<3; i++ ) 
+    {
+       // Compute indices of neighbor triangle.
+       int v0 = i*2;
+       int nb = (i*2+1);
+       int v1 = (i*2+2) % 6;
+       cross_products(n, v0, nb, v1);
+
+       // Compute direction to light, again as above.
+       d[0] =lightpos.xyz-lightpos.w*gl_PositionIn[v0].xyz;
+       d[1] =lightpos.xyz-lightpos.w*gl_PositionIn[nb].xyz;
+       d[2] =lightpos.xyz-lightpos.w*gl_PositionIn[v1].xyz;
+
+       bool is_parallel = gl_PositionIn[nb].w < 1e-5;
+
+       // Extrude the edge if it does not have a
+       // neighbor, or if it's a possible silhouette.
+       if (is_parallel ||
+          ( faces_light != (dot(ns[0],d[0])>0 ||
+                            dot(ns[1],d[1])>0 ||
+                            dot(ns[2],d[2])>0) ))
+       {
+           // Make sure sides are oriented correctly.
+           int i0 = faces_light ? v0 : v1;
+           int i1 = faces_light ? v1 : v0;
+
+           v[0] = gl_PositionIn[i0];
+           v[1] = vec4(lightpos.w*gl_PositionIn[i0].xyz - lightpos.xyz, 0);
+           v[2] = gl_PositionIn[i1];
+           v[3] = vec4(lightpos.w*gl_PositionIn[i1].xyz - lightpos.xyz, 0);
+
+           emitQuad(v);
+       }
+    }
+}
+
+void main()
+{
+    // Output
+    emitPrimitives(0);
+}
-- 
cgit v1.2.3


From 066eb59808d5649c745fdc6c37b62f2eb9a19b6f Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 17 Jan 2019 08:32:09 -0800
Subject: SL-10368

Fix OSX shader compile bug from use of #if FOO instead of #ifdef FOO or #if defined(FOO)
preventing atmospherics (and thus ALM) from working on OSX.
---
 .../app_settings/shaders/class3/deferred/attachmentShadowV.glsl     | 6 ++----
 .../newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl | 4 ++--
 .../newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl | 4 ++--
 .../newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl  | 4 ++--
 .../app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl     | 4 ++--
 .../app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl     | 4 ++--
 .../app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl      | 4 ++--
 .../app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl      | 4 ++--
 indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl | 4 ++--
 indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl     | 2 +-
 indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl     | 4 ++--
 indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl | 2 +-
 12 files changed, 22 insertions(+), 24 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl
index 3be9cb3de8..1a655e6467 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/attachmentShadowV.glsl
@@ -42,10 +42,8 @@ void main()
 	pos = (mat*vec4(position.xyz, 1.0));
 	pos = projection_matrix * vec4(pos.xyz, 1.0);
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	pos.z = max(pos.z, -pos.w+0.01);
-	gl_Position = pos;
-#else
-	gl_Position = pos;
 #endif
+	gl_Position = pos;
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl
index f4e5a61e36..48eefc7a73 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 
 uniform sampler2D diffuseMap;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING vec4 post_pos;
 #endif
 
@@ -45,7 +45,7 @@ void main()
 {
     frag_color = computeMoments(length(pos), 1.0);
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	gl_FragDepth = max(post_pos.z/post_pos.w*0.5+0.5, 0.0);
 #endif
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl
index 96ca2fd707..164b355f20 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/avatarShadowV.glsl
@@ -31,7 +31,7 @@ ATTRIBUTE vec3 position;
 ATTRIBUTE vec3 normal;
 ATTRIBUTE vec2 texcoord0;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING vec4 post_pos;
 #endif
 
@@ -56,7 +56,7 @@ void main()
 	
 	pos = projection_matrix * pos;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	post_pos = pos;
 	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
 #else
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl
index cb27b2c2c5..effb070f93 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowV.glsl
@@ -31,7 +31,7 @@ ATTRIBUTE vec3 position;
 ATTRIBUTE vec4 diffuse_color;
 ATTRIBUTE vec2 texcoord0;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING float pos_zd2;
 #endif
 
@@ -49,7 +49,7 @@ void main()
 	pos = modelview_projection_matrix * pre_pos;
 	target_pos_x = 0.5 * (shadow_target_width - 1.0) * pos.x;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	pos_zd2 = pos.z * 0.5;
 	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
 #else
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl
index 01599d81c4..345c07a354 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 
 uniform sampler2D diffuseMap;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING float pos_zd2;
 #endif
 
@@ -52,7 +52,7 @@ void main()
 
     frag_color = computeMoments(length(pos), float a);
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	gl_FragDepth = max(pos_zd2/pos_w+0.5, 0.0);
 #endif
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl
index 3fb2bafca4..af1461c297 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaBlendV.glsl
@@ -31,7 +31,7 @@ ATTRIBUTE vec3 position;
 ATTRIBUTE vec4 diffuse_color;
 ATTRIBUTE vec2 texcoord0;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING float pos_zd2;
 #endif
 
@@ -51,7 +51,7 @@ void main()
 
 	pos_w = pos.w;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	pos_zd2 = pos.z * 0.5;
 	
 	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl
index d6ed5b6bb0..50f1ffd626 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 
 uniform sampler2D diffuseMap;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING float pos_zd2;
 #endif
 
@@ -67,7 +67,7 @@ void main()
 
     frag_color = computeMoments(length(pos.xyz), alpha);
     
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
     gl_FragDepth = max(pos_zd2/pos_w+0.5, 0.0);
 #endif
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl
index bc7fe003f2..6a646f5e9e 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowAlphaMaskV.glsl
@@ -31,7 +31,7 @@ ATTRIBUTE vec3 position;
 ATTRIBUTE vec4 diffuse_color;
 ATTRIBUTE vec2 texcoord0;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING float pos_zd2;
 #endif
 
@@ -51,7 +51,7 @@ void main()
 
 	target_pos_x = 0.5 * (shadow_target_width - 1.0) * pos.x;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	pos_zd2 = pos.z * 0.5;
 	
 	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl
index 923de09ada..db8c75fb8a 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowCubeV.glsl
@@ -27,7 +27,7 @@ uniform mat4 modelview_projection_matrix;
 
 ATTRIBUTE vec3 position;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING vec4 post_pos;
 #endif
 
@@ -40,7 +40,7 @@ void main()
 	vec3 p = position*box_size+box_center;
 	vec4 pos = modelview_projection_matrix*vec4(p.xyz, 1.0);
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	post_pos = pos;
 
 	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl
index 5a6c8728c0..3350267130 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowF.glsl
@@ -33,7 +33,7 @@ out vec4 frag_color;
 
 uniform sampler2D diffuseMap;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING float pos_zd2;
 #endif
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl b/indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl
index 9a5edaf091..6577fe0ecf 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/shadowV.glsl
@@ -30,7 +30,7 @@ uniform mat4 texture_matrix0;
 ATTRIBUTE vec3 position;
 ATTRIBUTE vec2 texcoord0;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 VARYING float pos_zd2;
 #endif
 
@@ -50,7 +50,7 @@ void main()
 
 	target_pos_x = 0.5 * (shadow_target_width - 1.0) * pos.x;
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	pos_zd2 = pos.z * 0.5;
 	
 	gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl
index 693af31bf2..41673d1669 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/treeShadowF.glsl
@@ -51,7 +51,7 @@ void main()
 
     frag_color = computeMoments(length(pos), 1.0);
 
-#if !DEPTH_CLAMP
+#if !defined(DEPTH_CLAMP)
 	gl_FragDepth = max(pos.z/pos.w*0.5+0.5, 0.0);
 #endif
 
-- 
cgit v1.2.3


From 966dc7fc8fb1fade861e8070e9c5fbbfe4d0cb45 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 24 Jan 2019 14:54:11 -0800
Subject: SL-10276 SL-9851

Fix cloud shaders to ignore clouds when cloud_scale is 0.

Fix creation of heavenly body geo to avoid degenerate vector math
and not randomly flip orientation when crossing zenith.

Add sun_up_factor to eliminate sun glow around moon when sun is down.
---
 .../shaders/class3/deferred/cloudShadowF.glsl      | 91 ++++++++++++----------
 .../shaders/class3/deferred/cloudsF.glsl           | 63 ++++++++-------
 .../shaders/class3/deferred/cloudsV.glsl           | 22 +++---
 3 files changed, 94 insertions(+), 82 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
index 65af2821be..95d5b52b45 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
@@ -67,48 +67,55 @@ vec4 computeMoments(float depth, float alpha);
 
 void main()
 {
-	// Set variables
-	vec2 uv1 = vary_texcoord0.xy;
-	vec2 uv2 = vary_texcoord1.xy;
-	vec2 uv3 = vary_texcoord2.xy;
-	float cloudDensity = 2.0 * (cloud_shadow - 0.25);
-
-	vec2 uv4 = vary_texcoord3.xy;
-
-    vec2 disturbance  = vec2(cloudNoise(uv1 / 8.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
-    vec2 disturbance2 = vec2(cloudNoise((uv1 + uv3) / 4.0f).x, cloudNoise((uv4 + uv2) / 8.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
-
-	// Offset texture coords
-	uv1 += cloud_pos_density1.xy + (disturbance * 0.02);	//large texture, visible density
-	uv2 += cloud_pos_density1.xy;	//large texture, self shadow
-	uv3 += cloud_pos_density2.xy;	//small texture, visible density
-	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
-
-    float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0 + disturbance2.x + disturbance2.y));
-
-    cloudDensity *= 1.0 - (density_variance * density_variance);
-
-	// Compute alpha1, the main cloud opacity
-	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
-	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
-
-	// And smooth
-	alpha1 = 1. - alpha1 * alpha1;
-	alpha1 = 1. - alpha1 * alpha1;	
-
-    if (alpha1 < 0.001f)
+    if (cloud_scale >= 0.001)
     {
-        discard;
+        // Set variables
+        vec2 uv1 = vary_texcoord0.xy;
+        vec2 uv2 = vary_texcoord1.xy;
+        vec2 uv3 = vary_texcoord2.xy;
+        float cloudDensity = 2.0 * (cloud_shadow - 0.25);
+    
+        vec2 uv4 = vary_texcoord3.xy;
+    
+        vec2 disturbance  = vec2(cloudNoise(uv1 / 8.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
+        vec2 disturbance2 = vec2(cloudNoise((uv1 + uv3) / 4.0f).x, cloudNoise((uv4 + uv2) / 8.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
+    
+        // Offset texture coords
+        uv1 += cloud_pos_density1.xy + (disturbance * 0.02);    //large texture, visible density
+        uv2 += cloud_pos_density1.xy;   //large texture, self shadow
+        uv3 += cloud_pos_density2.xy;   //small texture, visible density
+        uv4 += cloud_pos_density2.xy;   //small texture, self shadow
+    
+        float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0 + disturbance2.x + disturbance2.y));
+    
+        cloudDensity *= 1.0 - (density_variance * density_variance);
+    
+        // Compute alpha1, the main cloud opacity
+        float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
+        alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
+    
+        // And smooth
+        alpha1 = 1. - alpha1 * alpha1;
+        alpha1 = 1. - alpha1 * alpha1;  
+    
+        if (alpha1 < 0.001f)
+        {
+            discard;
+        }
+    
+        // Compute alpha2, for self shadowing effect
+        // (1 - alpha2) will later be used as percentage of incoming sunlight
+        float alpha2 = (cloudNoise(uv2).x - 0.5);
+        alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
+    
+        // And smooth
+        alpha2 = 1. - alpha2;
+        alpha2 = 1. - alpha2 * alpha2;  
+    
+        frag_color = computeMoments(length(pos), alpha1);
+    }
+    else
+    {
+        frag_color = vec4(0);
     }
-
-	// Compute alpha2, for self shadowing effect
-	// (1 - alpha2) will later be used as percentage of incoming sunlight
-	float alpha2 = (cloudNoise(uv2).x - 0.5);
-	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
-
-	// And smooth
-	alpha2 = 1. - alpha2;
-	alpha2 = 1. - alpha2 * alpha2;	
-
-    frag_color = computeMoments(length(pos), alpha1);
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index 015caad749..c111456782 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -81,47 +81,52 @@ vec4 cloudNoise(vec2 uv)
 
 void main()
 {
-	// Set variables
-	vec2 uv1 = vary_texcoord0.xy;
-	vec2 uv2 = vary_texcoord1.xy;
-	vec2 uv3 = vary_texcoord2.xy;
-	float cloudDensity = 2.0 * (cloud_shadow - 0.25);
+    // Set variables
+    vec2 uv1 = vary_texcoord0.xy;
+    vec2 uv2 = vary_texcoord1.xy;
+    vec2 uv3 = vary_texcoord2.xy;
+    float cloudDensity = 2.0 * (cloud_shadow - 0.25);
 
-	vec2 uv4 = vary_texcoord3.xy;
+    if (cloud_scale < 0.001)
+    {
+        discard;
+    }
+
+    vec2 uv4 = vary_texcoord3.xy;
 
     vec2 disturbance = vec2(cloudNoise(uv1 / 16.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
 
-	// Offset texture coords
-	uv1 += cloud_pos_density1.xy + disturbance;	//large texture, visible density
-	uv2 += cloud_pos_density1.xy;	//large texture, self shadow
-	uv3 += cloud_pos_density2.xy + disturbance;	//small texture, visible density
-	uv4 += cloud_pos_density2.xy;	//small texture, self shadow
+    // Offset texture coords
+    uv1 += cloud_pos_density1.xy + disturbance; //large texture, visible density
+    uv2 += cloud_pos_density1.xy;   //large texture, self shadow
+    uv3 += cloud_pos_density2.xy + disturbance; //small texture, visible density
+    uv4 += cloud_pos_density2.xy;   //small texture, self shadow
 
     float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0));
 
     cloudDensity *= 1.0 - (density_variance * density_variance);
 
-	// Compute alpha1, the main cloud opacity
-	float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
-	alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
+    // Compute alpha1, the main cloud opacity
+    float alpha1 = (cloudNoise(uv1).x - 0.5) + (cloudNoise(uv3).x - 0.5) * cloud_pos_density2.z;
+    alpha1 = min(max(alpha1 + cloudDensity, 0.) * 10 * cloud_pos_density1.z, 1.);
 
-	// And smooth
-	alpha1 = 1. - alpha1 * alpha1;
-	alpha1 = 1. - alpha1 * alpha1;	
+    // And smooth
+    alpha1 = 1. - alpha1 * alpha1;
+    alpha1 = 1. - alpha1 * alpha1;  
 
     if (alpha1 < 0.001f)
     {
         discard;
     }
 
-	// Compute alpha2, for self shadowing effect
-	// (1 - alpha2) will later be used as percentage of incoming sunlight
-	float alpha2 = (cloudNoise(uv2).x - 0.5);
-	alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
+    // Compute alpha2, for self shadowing effect
+    // (1 - alpha2) will later be used as percentage of incoming sunlight
+    float alpha2 = (cloudNoise(uv2).x - 0.5);
+    alpha2 = min(max(alpha2 + cloudDensity, 0.) * 2.5 * cloud_pos_density1.z, 1.);
 
-	// And smooth
-	alpha2 = 1. - alpha2;
-	alpha2 = 1. - alpha2 * alpha2;	
+    // And smooth
+    alpha2 = 1. - alpha2;
+    alpha2 = 1. - alpha2 * alpha2;  
 
     vec3 view_ray = vary_pos.xyz + camPosLocal;
 
@@ -135,8 +140,8 @@ void main()
 
     vec3 sun_color = vec3(1.0) - exp(-radiance_sun * 0.0001);
 
-	// Combine
-	vec4 color;
+    // Combine
+    vec4 color;
 
     vec4 l1tap = vec4(1.0/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265), sqrt(3)/sqrt(4*3.14159265));
 
@@ -156,8 +161,8 @@ void main()
     color.rgb = pow(color.rgb, vec3(1.0 / 2.2));
     color.rgb += amb;
 
-	frag_data[0] = vec4(color.rgb, alpha1);
-	frag_data[1] = vec4(0);
-	frag_data[2] = vec4(0,1,0,1);
+    frag_data[0] = vec4(color.rgb, alpha1);
+    frag_data[1] = vec4(0);
+    frag_data[2] = vec4(0,1,0,1);
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
index 53b6d88ef5..71e422ddf0 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsV.glsl
@@ -49,22 +49,22 @@ void main()
 {
     vary_pos = position;
 
-	// World / view / projection
-	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
+    // World / view / projection
+    gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
 
-	// Texture coords
-	vary_texcoord0 = texcoord0;
-	vary_texcoord0.xy -= 0.5;
-    vary_texcoord0.xy /= cloud_scale;
+    // Texture coords
+    vary_texcoord0 = texcoord0;
+    vary_texcoord0.xy -= 0.5;
+    vary_texcoord0.xy /= max(0.001, cloud_scale);
     vary_texcoord0.xy += 0.5;
 
-	vary_texcoord1 = vary_texcoord0;
-	vary_texcoord1.x += lightnorm.x * 0.0125;
+    vary_texcoord1 = vary_texcoord0;
+    vary_texcoord1.x += lightnorm.x * 0.0125;
     vary_texcoord1.y += lightnorm.z * 0.0125;
 
-	vary_texcoord2 = vary_texcoord0 * 16.;
-	vary_texcoord3 = vary_texcoord1 * 16.;
+    vary_texcoord2 = vary_texcoord0 * 16.;
+    vary_texcoord3 = vary_texcoord1 * 16.;
 
-	// END CLOUDS
+    // END CLOUDS
 }
 
-- 
cgit v1.2.3


From acbc7f4cddd6ad999c2bc7690c10b85a414a8102 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Wed, 30 Jan 2019 08:37:07 -0800
Subject: SL-10415, SL-10434

Further tweaking of directional shadow sampling to balance between peter-panning and shadow acne.

Move stars to just this side of the sky some to reduce parallax.

Remove decodeNormF and uses of decode_normal in favor of unified use of getNorm
(try to help the Intel HD x000 compiler learn to link correctly).
---
 .../app_settings/shaders/class3/deferred/deferredUtil.glsl | 14 +++++++++-----
 .../shaders/class3/deferred/multiSpotLightF.glsl           |  4 ++--
 .../app_settings/shaders/class3/deferred/softenLightF.glsl |  3 +--
 .../app_settings/shaders/class3/deferred/spotLightF.glsl   |  4 ++--
 .../app_settings/shaders/class3/deferred/sunLightF.glsl    |  1 -
 5 files changed, 14 insertions(+), 12 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl b/indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl
index cccd01e0d7..e27bbce094 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/deferredUtil.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file class3/deferred/deferredUtil.glsl
+ * @file class1/deferred/deferredUtil.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -29,8 +29,6 @@ uniform sampler2DRect   depthMap;
 uniform mat4 inv_proj;
 uniform vec2 screen_res;
 
-vec3 decode_normal(vec2 enc);
-
 vec2 getScreenCoordinate(vec2 screenpos)
 {
     vec2 sc = screenpos.xy * 2.0;
@@ -43,8 +41,14 @@ vec2 getScreenCoordinate(vec2 screenpos)
 
 vec3 getNorm(vec2 screenpos)
 {
-   vec2 enc_norm = texture2DRect(normalMap, screenpos.xy).xy;
-   return decode_normal(enc_norm);
+   vec2 enc = texture2DRect(normalMap, screenpos.xy).xy;
+   vec2 fenc = enc*4-2;
+   float f = dot(fenc,fenc);
+   float g = sqrt(1-f/4);
+   vec3 n;
+   n.xy = fenc*g;
+   n.z = 1-f/2;
+   return n;
 }
 
 float getDepth(vec2 pos_screen)
diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index 0848adba73..72bccc5627 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -73,7 +73,7 @@ uniform mat4 inv_proj;
 
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cl);
-vec3 decode_normal (vec2 enc);
+vec3 getNorm(vec2 pos_screen);
 
 vec4 correctWithGamma(vec4 col)
 {
@@ -166,7 +166,7 @@ void main()
 	
 	float envIntensity = norm.z;
 
-	norm = decode_normal(norm.xy);
+	norm = getNorm(frag.xy);
 	
 	norm = normalize(norm);
 	float l_dist = -dot(lv, proj_n);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 9411e905d3..ad721a80d6 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -76,7 +76,6 @@ vec3 GetSunAndSkyIrradiance(vec3 camPos, vec3 norm, vec3 dir, out vec3 sky_irrad
 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 decode_normal(vec2 xy);
 vec3 ColorFromRadiance(vec3 radiance);
 vec4 getPositionWithDepth(vec2 pos_screen, float depth);
 vec4 getPosition(vec2 pos_screen);
@@ -93,7 +92,7 @@ void main()
     vec3 pos = getPositionWithDepth(tc, depth).xyz;
     vec4 norm = texture2DRect(normalMap, tc);
     float envIntensity = norm.z;
-    norm.xyz = decode_normal(norm.xy);
+    norm.xyz = getNorm(tc);
 
     float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
               da = pow(da, global_gamma + 0.3);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index 80e2a9dd55..3b2b0d5718 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -71,7 +71,7 @@ uniform vec2 screen_res;
 
 uniform mat4 inv_proj;
 
-vec3 decode_normal (vec2 enc);
+vec3 getNorm(vec2 pos_screen);
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cl);
 
@@ -164,7 +164,7 @@ void main()
 	
 	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
 	float envIntensity = norm.z;
-	norm = decode_normal(norm.xy);
+	norm = getNorm(frag.xy);
 	
 	norm = normalize(norm);
 	float l_dist = -dot(lv, proj_n);
diff --git a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
index e230ebb71c..112b498c90 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/sunLightF.glsl
@@ -38,7 +38,6 @@ out vec4 frag_color;
 // Inputs
 VARYING vec2 vary_fragcoord;
 
-vec3 decode_normal (vec2 enc);
 vec4 getPosition(vec2 pos_screen);
 vec3 getNorm(vec2 pos_screen);
 
-- 
cgit v1.2.3


From 8890c3238ab4ae8bbf1bc123284f9c6d4db4f9d6 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Wed, 6 Feb 2019 16:42:23 -0800
Subject: SL-10478

Fix side-effects of having both sun and moon as potential directional light contributors.
We pass an int to the shader indicating which to prefer instead of making per-pixel decisions
and pass the moonlight color/di independently.

Obsolete llsettingssky fade color which was unused elsewhere and cached for no reason.
---
 indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl | 1 -
 indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl      | 1 -
 2 files changed, 2 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
index 95d5b52b45..c0ba804a30 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
@@ -44,7 +44,6 @@ uniform sampler2D cloud_noise_texture_next;
 uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
-uniform vec4 sunlight_color;
 uniform vec4 cloud_color;
 uniform float cloud_shadow;
 uniform float cloud_scale;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index c111456782..cc7a86f35c 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -47,7 +47,6 @@ uniform sampler2D cloud_noise_texture_next;
 uniform float blend_factor;
 uniform vec4 cloud_pos_density1;
 uniform vec4 cloud_pos_density2;
-uniform vec4 sunlight_color;
 uniform vec4 cloud_color;
 uniform float cloud_shadow;
 uniform float cloud_scale;
-- 
cgit v1.2.3


From edf8ba6e5ff0fc2b5ef55219c82af7b0f20437d9 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Wed, 20 Mar 2019 13:07:21 -0700
Subject: SL-10449

Fix name of attenuation setter used.

Fix flipped light vec.

Make class3 lights use shadows on projector ambiance too.
---
 .../app_settings/shaders/class3/deferred/multiSpotLightF.glsl        | 2 +-
 indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl   | 5 +----
 2 files changed, 2 insertions(+), 5 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index 72bccc5627..0c113282b5 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -228,7 +228,7 @@ void main()
 		//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 += (da*da*0.5+0.5)*(1.0-shadow)*proj_ambiance;
 				
 		amb_da *= dist_atten * noise;
 			
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index 3b2b0d5718..00b276f585 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -227,7 +227,7 @@ void main()
 		//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 += (da*da*0.5+0.5)*(1.0-shadow)*proj_ambiance;
 				
 		amb_da *= dist_atten * noise;
 			
@@ -261,9 +261,6 @@ void main()
 		}
 	}	
 	
-	
-	
-	
 
 	if (envIntensity > 0.0)
 	{
-- 
cgit v1.2.3


From 09981714c306b9bf89a8e65c49318ccc6c30580f Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Wed, 27 Mar 2019 09:38:26 -0700
Subject: Fix projector falloff and attenuation handling.

---
 .../shaders/class3/deferred/multiSpotLightF.glsl   | 369 ++++++++++----------
 .../shaders/class3/deferred/spotLightF.glsl        | 373 ++++++++++-----------
 2 files changed, 370 insertions(+), 372 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index 0c113282b5..dec9afcfb7 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -77,59 +77,59 @@ vec3 getNorm(vec2 pos_screen);
 
 vec4 correctWithGamma(vec4 col)
 {
-	return vec4(srgb_to_linear(col.rgb), col.a);
+    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);
+    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;
+    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);
+    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;
+    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);
+    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;
+    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;
 }
 
 
@@ -137,167 +137,166 @@ vec4 getPosition(vec2 pos_screen);
 
 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;
+    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);
+        shadow = (proj_shadow_idx == 0) ? shd.b : shd.a;
+        shadow = clamp(shadow, 0.0, 1.0);
+        shadow += shadow_fade;
+    }
+    
+    vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
+    
+    float envIntensity = norm.z;
 
-	norm = getNorm(frag.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);
+    norm = getNorm(frag.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*0.5)+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 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);
+    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;
+    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;
+        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)*(1.0-shadow)*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;
-	}
-	
+            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)*(1.0-shadow)*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;
+    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;
+        //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;
-		}
-	}	
-	
-	
-	
-	
+        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 (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)
-			{
+            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;
-				}
-			}
-		}
-	}
+                                
+                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));
+    //not sure why, but this line prevents MATBUG-194
+    col = max(col, vec3(0.0));
 
-	frag_color.rgb = col;	
-	frag_color.a = 0.0;
+    frag_color.rgb = col;   
+    frag_color.a = 0.0;
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index 00b276f585..6a813cac15 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -77,59 +77,59 @@ vec3 linear_to_srgb(vec3 cl);
 
 vec4 correctWithGamma(vec4 col)
 {
-	return vec4(srgb_to_linear(col.rgb), col.a);
+    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);
+    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;
+    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 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 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;
 }
 
 
@@ -137,163 +137,162 @@ vec4 getPosition(vec2 pos_screen);
 
 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 = getNorm(frag.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;
+    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);
+        shadow = (proj_shadow_idx == 0) ? shd.b : shd.a;
+        shadow = clamp(shadow, 0.0, 1.0);
+        shadow += shadow_fade;
+    }
+    
+    vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
+    float envIntensity = norm.z;
+    norm = getNorm(frag.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*0.5) + 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);
+    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);
+    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 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)*(1.0-shadow)*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;
-	}
-	
+            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)*(1.0-shadow)*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);
+    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;
+        //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;
-		}
-	}	
-	
+        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 (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));
+            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;
+    frag_color.rgb = col;   
+    frag_color.a = 0.0;
 }
-- 
cgit v1.2.3


From 03426a7ddbf1b3bb8349241d3b52962026f7504a Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 28 Mar 2019 13:23:59 -0700
Subject: SL-10829, SL-10830

Replace old spot prio calc.

Replace fudge factors on light radius and falloff for deferred lights.
---
 indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl | 2 +-
 indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index dec9afcfb7..abb6a3a5d8 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -157,8 +157,8 @@ void main()
     {
         vec4 shd = texture2DRect(lightMap, frag.xy);
         shadow = (proj_shadow_idx == 0) ? shd.b : shd.a;
-        shadow = clamp(shadow, 0.0, 1.0);
         shadow += shadow_fade;
+        shadow = clamp(shadow, 0.0, 1.0);        
     }
     
     vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index 6a813cac15..afc542b8bc 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -157,8 +157,8 @@ void main()
     {
         vec4 shd = texture2DRect(lightMap, frag.xy);
         shadow = (proj_shadow_idx == 0) ? shd.b : shd.a;
-        shadow = clamp(shadow, 0.0, 1.0);
         shadow += shadow_fade;
+        shadow = clamp(shadow, 0.0, 1.0);
     }
     
     vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
-- 
cgit v1.2.3


From c4032528aff8ef1938e897ec583bbf25a3e713e1 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 2 May 2019 13:49:35 -0700
Subject: Roll back sRGB decode changes from contrib for now.

Fix direct light matching across alpha/blended-material/deferred.

Get diffuse lighting to match from Low to Ultra.
---
 .../shaders/class3/deferred/multiSpotLightF.glsl         | 16 ++--------------
 .../app_settings/shaders/class3/deferred/spotLightF.glsl | 11 -----------
 .../shaders/class3/deferred/underWaterF.glsl             |  3 ---
 .../app_settings/shaders/class3/deferred/waterF.glsl     |  1 -
 4 files changed, 2 insertions(+), 29 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index abb6a3a5d8..52de7ceaad 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -71,19 +71,11 @@ uniform vec2 screen_res;
 
 uniform mat4 inv_proj;
 
-vec3 srgb_to_linear(vec3 cs);
-vec3 linear_to_srgb(vec3 cl);
 vec3 getNorm(vec2 pos_screen);
 
-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));
     
@@ -103,7 +95,6 @@ vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
 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));
     
@@ -121,7 +112,6 @@ vec4 texture2DLodDiffuse(sampler2D projectionMap, vec2 tc, float lod)
 vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 {
     vec4 ret = texture2DLod(projectionMap, tc, lod);
-    ret = correctWithGamma(ret);
 
     vec2 dist = tc-vec2(0.5);
     
@@ -260,10 +250,6 @@ void main()
             //col += spec.rgb;
         }
     }   
-    
-    
-    
-    
 
     if (envIntensity > 0.0)
     {
@@ -297,6 +283,8 @@ void main()
     //not sure why, but this line prevents MATBUG-194
     col = max(col, vec3(0.0));
 
+    col = scaleDownLight(col);
+
     frag_color.rgb = col;   
     frag_color.a = 0.0;
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index afc542b8bc..bccd819a43 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -72,18 +72,10 @@ uniform vec2 screen_res;
 uniform mat4 inv_proj;
 
 vec3 getNorm(vec2 pos_screen);
-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));
     
@@ -103,7 +95,6 @@ vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
 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));
     
@@ -121,7 +112,6 @@ vec4 texture2DLodDiffuse(sampler2D projectionMap, vec2 tc, float lod)
 vec4 texture2DLodAmbient(sampler2D projectionMap, vec2 tc, float lod)
 {
     vec4 ret = texture2DLod(projectionMap, tc, lod);
-    ret = correctWithGamma(ret);
     
     vec2 dist = tc-vec2(0.5);
     
@@ -256,7 +246,6 @@ void main()
         {
             float scol = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt/(nh*da);
             col += dlit*scol*spec.rgb*shadow;
-            //col += spec.rgb;
         }
     }   
     
diff --git a/indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl b/indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl
index 9d18d1afd8..540226e672 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/underWaterF.glsl
@@ -58,9 +58,6 @@ VARYING vec4 refCoord;
 VARYING vec4 littleWave;
 VARYING vec4 view;
 
-vec3 srgb_to_linear(vec3 cs);
-vec3 linear_to_srgb(vec3 cl);
-
 vec2 encode_normal(vec3 n);
 
 vec4 applyWaterFog(vec4 color, vec3 viewVec)
diff --git a/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl
index 2a144ba23a..c65cf48c67 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/waterF.glsl
@@ -61,7 +61,6 @@ VARYING vec4 view;
 VARYING vec4 vary_position;
 
 vec3 scaleSoftClip(vec3 c);
-vec3 srgb_to_linear(vec3 cs);
 vec2 encode_normal(vec3 n);
 
 vec3 BlendNormal(vec3 bump1, vec3 bump2)
-- 
cgit v1.2.3


From 8d32aade01b0b87bd626a81f68b210538e90095b Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Fri, 3 May 2019 11:45:17 -0700
Subject: SL-11090

Tamp down bloom so we don't have to redo ten thousand gloss maps.
---
 indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index ad721a80d6..6400e5169e 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -146,8 +146,8 @@ void main()
             vec3 dumbshiny = scol * texture2D(lightFunc, vec2(sa, spec.a)).r * atmo_color;
             
             // add the two types of shiny together
-            vec3 spec_contrib = dumbshiny * spec.rgb;
-            bloom = dot(spec_contrib, spec_contrib) / 6;
+            vec3 spec_contrib = dumbshiny * spec.rgb * 0.25;
+            bloom = dot(spec_contrib, spec_contrib);
             col += spec_contrib;
         }
 
-- 
cgit v1.2.3


From 16d3279995bcb4a4766b721d0897b3d2199971d5 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 3 Jun 2019 11:30:41 -0700
Subject: SL-10966

Fix light atten and transmittance calcs breaking ambient color contrib to fog.

Needs to be tested on DRTSIM-415 or better to get legacy viewer settings that match EEP.
---
 indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl | 1 -
 indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl      | 1 -
 2 files changed, 2 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
index c0ba804a30..ae521afdad 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
@@ -48,7 +48,6 @@ uniform vec4 cloud_color;
 uniform float cloud_shadow;
 uniform float cloud_scale;
 uniform float cloud_variance;
-uniform vec3 ambient;
 uniform vec3 camPosLocal;
 uniform vec3 sun_dir;
 uniform float sun_size;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index cc7a86f35c..1abe2fab63 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -51,7 +51,6 @@ uniform vec4 cloud_color;
 uniform float cloud_shadow;
 uniform float cloud_scale;
 uniform float cloud_variance;
-uniform vec3 ambient;
 uniform vec3 camPosLocal;
 uniform vec3 sun_dir;
 uniform float sun_size;
-- 
cgit v1.2.3


From b79d0d2fdd047636598cbc9b088c3d4a10a84460 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 10 Jun 2019 09:15:35 -0700
Subject: SL-10969, SL-11051

Make fullbright alpha mask with mask cutoff == 0 not generate shadows.

Adjust handling of ambient across forward and deferred again.
---
 indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl | 1 -
 1 file changed, 1 deletion(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 6400e5169e..82a899ad65 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -53,7 +53,6 @@ uniform vec4 glow;
 uniform float global_gamma;
 uniform mat3 env_mat;
 uniform vec4 shadow_clip;
-uniform mat3 ssao_effect_mat;
 
 uniform vec3 sun_dir;
 VARYING vec2 vary_fragcoord;
-- 
cgit v1.2.3


From aa4b24beee1d6451370983517d7ac3755429e26f Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 22 Jul 2019 12:21:24 -0700
Subject: SL-11443

Make fullbright rigged objects with alpha mode none use fullbright shader instead of incorrectly using the material shader.

Increase effect of variance in cloud shaders.
---
 .../newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl  | 4 ++--
 indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl     | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
index ae521afdad..32210f60dc 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudShadowF.glsl
@@ -79,12 +79,12 @@ void main()
         vec2 disturbance2 = vec2(cloudNoise((uv1 + uv3) / 4.0f).x, cloudNoise((uv4 + uv2) / 8.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
     
         // Offset texture coords
-        uv1 += cloud_pos_density1.xy + (disturbance * 0.02);    //large texture, visible density
+        uv1 += cloud_pos_density1.xy + (disturbance * 0.2);    //large texture, visible density
         uv2 += cloud_pos_density1.xy;   //large texture, self shadow
         uv3 += cloud_pos_density2.xy;   //small texture, visible density
         uv4 += cloud_pos_density2.xy;   //small texture, self shadow
     
-        float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0 + disturbance2.x + disturbance2.y));
+        float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0 + disturbance2.x + disturbance2.y) * 4.0);
     
         cloudDensity *= 1.0 - (density_variance * density_variance);
     
diff --git a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
index 1abe2fab63..e40d7e7c75 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/cloudsF.glsl
@@ -95,12 +95,12 @@ void main()
     vec2 disturbance = vec2(cloudNoise(uv1 / 16.0f).x, cloudNoise((uv3 + uv1) / 16.0f).x) * cloud_variance * (1.0f - cloud_scale * 0.25f);
 
     // Offset texture coords
-    uv1 += cloud_pos_density1.xy + disturbance; //large texture, visible density
+    uv1 += cloud_pos_density1.xy + (disturbance * 0.2); //large texture, visible density
     uv2 += cloud_pos_density1.xy;   //large texture, self shadow
-    uv3 += cloud_pos_density2.xy + disturbance; //small texture, visible density
+    uv3 += cloud_pos_density2.xy; //small texture, visible density
     uv4 += cloud_pos_density2.xy;   //small texture, self shadow
 
-    float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0));
+    float density_variance = min(1.0, (disturbance.x* 2.0 + disturbance.y* 2.0) * 4.0);
 
     cloudDensity *= 1.0 - (density_variance * density_variance);
 
-- 
cgit v1.2.3


From b507d63566e8896af702dd10f5643dc29068a8a9 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 23 Jul 2019 11:36:22 -0700
Subject: SL-11621

Remove all references to unused shader var global_gamma.

Remove many unused decls for gamma from shaders.

Make post-deferred gamma correction use display_gamma.

Make setting display_gamma use the correct RenderDeferredDisplayGamma setting.
---
 indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl    | 1 -
 indra/newview/app_settings/shaders/class3/deferred/skyF.glsl         | 1 -
 indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl | 3 ---
 3 files changed, 5 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl b/indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl
index c02e6d1e57..d5d91c88f0 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/genSkyShF.glsl
@@ -37,7 +37,6 @@ uniform sampler2D transmittance_texture;
 uniform sampler3D scattering_texture;
 uniform sampler3D single_mie_scattering_texture;
 uniform sampler2D irradiance_texture;
-uniform vec4 gamma;
 
 vec3 GetSkyLuminance(vec3 camPos, vec3 view_dir, float shadow_length, vec3 dir, out vec3 transmittance);
 
diff --git a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
index d0514f7d23..6de01cb667 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/skyF.glsl
@@ -44,7 +44,6 @@ uniform sampler3D single_mie_scattering_texture;
 uniform sampler2D irradiance_texture;
 uniform sampler2D rainbow_map;
 uniform sampler2D halo_map;
-uniform vec4 gamma;
 
 uniform float moisture_level;
 uniform float droplet_radius;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 82a899ad65..978c25b86a 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -50,7 +50,6 @@ uniform vec3 camPosLocal;
 uniform float cloud_shadow;
 uniform float max_y;
 uniform vec4 glow;
-uniform float global_gamma;
 uniform mat3 env_mat;
 uniform vec4 shadow_clip;
 
@@ -94,7 +93,6 @@ void main()
     norm.xyz = getNorm(tc);
 
     float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
-              da = pow(da, global_gamma + 0.3);
 
     vec4 diffuse = texture2DRect(diffuseRect, tc); // linear
 
@@ -106,7 +104,6 @@ void main()
         vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
         
         vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
-//        scol_ambocc = pow(scol_ambocc, vec3(global_gamma + 0.3));
 
         float scol = max(scol_ambocc.r, diffuse.a); 
 
-- 
cgit v1.2.3


From 7c7d71269f5b47397d14bbe44e341e4ac1d96889 Mon Sep 17 00:00:00 2001
From: Runitai Linden <davep@lindenlab.com>
Date: Thu, 5 Mar 2020 16:28:06 -0600
Subject: WIP - Windlight sun lighting should happen in sRGB space, not linear
 space.  This keeps ambient from getting overblown and better matches
 environment lighting with ALM on/off.

---
 .../app_settings/shaders/class3/deferred/multiSpotLightF.glsl       | 3 ++-
 .../newview/app_settings/shaders/class3/deferred/softenLightF.glsl  | 6 ++++--
 indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl  | 2 +-
 3 files changed, 7 insertions(+), 4 deletions(-)

(limited to 'indra/newview/app_settings/shaders/class3/deferred')

diff --git a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
index 52de7ceaad..9d62b9d180 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/multiSpotLightF.glsl
@@ -183,7 +183,7 @@ void main()
 
     vec3 col = vec3(0,0,0);
         
-    vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+    vec3 diff_tex = srgb_to_linear(texture2DRect(diffuseRect, frag.xy).rgb);
     
     vec4 spec = texture2DRect(specularRect, frag.xy);
 
@@ -285,6 +285,7 @@ void main()
 
     col = scaleDownLight(col);
 
+    //output linear space color as gamma correction happens down stream
     frag_color.rgb = col;   
     frag_color.a = 0.0;
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index 978c25b86a..7ed9e7b4fc 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -94,7 +94,8 @@ void main()
 
     float da = max(dot(norm.xyz, sun_dir.xyz), 0.0);
 
-    vec4 diffuse = texture2DRect(diffuseRect, tc); // linear
+    vec4 diffuse = texture2DRect(diffuseRect, tc); // sRGB
+    diffuse.rgb = srgb_to_linear(diffuse.rgb);
 
     vec3 col;
     float bloom = 0.0;
@@ -169,7 +170,8 @@ void main()
             bloom = fogged.a;
         #endif
     }
-    
+
+    //output linear since gamma correction happens down stream
     frag_color.rgb = col;
     frag_color.a = bloom;
 }
diff --git a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
index bccd819a43..56b0f4e5ce 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/spotLightF.glsl
@@ -182,7 +182,7 @@ void main()
         
     vec3 col = vec3(0,0,0);
         
-    vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
+    vec3 diff_tex = srgb_to_linear(texture2DRect(diffuseRect, frag.xy).rgb);
         
     vec4 spec = texture2DRect(specularRect, frag.xy);
 
-- 
cgit v1.2.3