Full v2.6 renderer.

indra/newview/app_settings/shaders/class3/deferred/giDownsampleF.glsl

@@ -0,0 +1,86 @@
+/** 
+ * @file giDownsampleF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+uniform sampler2DRect giLightMap;
+
+uniform vec2 kern[32];
+uniform float dist_factor;
+uniform float blur_size;
+uniform vec2 delta;
+uniform int kern_length;
+uniform float kern_scale;
+uniform vec3 blur_quad;
+
+varying vec2 vary_fragcoord;
+
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+vec4 getPosition(vec2 pos_screen)
+{
+	float depth = texture2DRect(depthMap, pos_screen.xy).a;
+	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 getDepth(vec2 pos_screen)
+{
+	float z = texture2DRect(depthMap, pos_screen.xy).a;
+	z = z*2.0-1.0;
+	vec4 ndc = vec4(0.0, 0.0, z, 1.0);
+	vec4 p = inv_proj*ndc;
+	return p.z/p.w;
+}
+
+void main() 
+{
+	vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz;
+	norm = vec3((norm.xy-0.5)*2.0,norm.z); // unpack norm
+	float depth = getDepth(vary_fragcoord.xy);
+		
+	vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+	vec2 dlt = kern_scale * delta/(vec2(1.0,1.0)+norm.xy*norm.xy);
+	dlt /= clamp(-depth*blur_quad.x, 1.0, 3.0);
+	float defined_weight = kern[0].x;
+	vec3 col = ccol*kern[0].x;
+	
+	for (int i = 0; i < kern_length; i++)
+	{
+		vec2 tc = vary_fragcoord.xy + kern[i].y*dlt;
+		vec3 sampNorm = texture2DRect(normalMap, tc.xy).xyz;
+		sampNorm = vec3((sampNorm.xy-0.5)*2.0,sampNorm.z); // unpack norm
+		
+		float d = dot(norm.xyz, sampNorm);
+		
+		if (d > 0.5)
+		{
+			float sampdepth = getDepth(tc.xy);
+			sampdepth -= depth;
+			if (sampdepth*sampdepth < blur_quad.z)
+			{
+	    		col += texture2DRect(giLightMap, tc).rgb*kern[i].x;
+				defined_weight += kern[i].x;
+			}
+		}
+	}
+
+	col /= defined_weight;
+	
+	//col = ccol;
+	
+	col = col*blur_quad.y;
+	
+	gl_FragData[0].xyz = col;
+	
+	//gl_FragColor = ccol;
+}

indra/newview/app_settings/shaders/class3/deferred/giDownsampleV.glsl

@@ -0,0 +1,17 @@
+/** 
+ * @file postgiV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+varying vec2 vary_fragcoord;
+uniform vec2 screen_res;
+
+void main()
+{
+	//transform vertex
+	gl_Position = ftransform(); 
+	vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+}

indra/newview/app_settings/shaders/class3/deferred/giF.glsl

@@ -0,0 +1,191 @@
+/** 
+ * @file giF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect lightMap;
+uniform sampler2DRect specularRect;
+
+uniform sampler2D noiseMap;
+
+uniform sampler2D		diffuseGIMap;
+uniform sampler2D		specularGIMap;
+uniform sampler2D		normalGIMap;
+uniform sampler2D		depthGIMap;
+
+uniform sampler2D		lightFunc;
+
+// Inputs
+varying vec2 vary_fragcoord;
+
+uniform vec2 screen_res;
+
+uniform vec4 sunlight_color;
+
+uniform mat4 inv_proj;
+uniform mat4 gi_mat;  //gPipeline.mGIMatrix - eye space to sun space
+uniform mat4 gi_mat_proj; //gPipeline.mGIMatrixProj - eye space to projected sun space
+uniform mat4 gi_norm_mat; //gPipeline.mGINormalMatrix - eye space normal to sun space normal matrix
+uniform mat4 gi_inv_proj; //gPipeline.mGIInvProj - projected sun space to sun space
+uniform float gi_sample_width;
+uniform float gi_noise;
+uniform float gi_attenuation;
+uniform float gi_range;
+
+vec4 getPosition(vec2 pos_screen)
+{
+	float depth = texture2DRect(depthMap, pos_screen.xy).a;
+	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 getGIPosition(vec2 gi_tc)
+{
+	float depth = texture2D(depthGIMap, gi_tc).a;
+	vec2 sc = gi_tc*2.0;
+	sc -= vec2(1.0, 1.0);
+	vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
+	vec4 pos = gi_inv_proj*ndc;
+	pos.xyz /= pos.w;
+	pos.w = 1.0;
+	return pos;
+}
+
+vec3 giAmbient(vec3 pos, vec3 norm)
+{
+	vec4 gi_c = gi_mat_proj * vec4(pos, 1.0);
+	gi_c.xyz /= gi_c.w;
+
+	vec4 gi_pos = gi_mat*vec4(pos,1.0);
+	vec3 gi_norm = (gi_norm_mat*vec4(norm,1.0)).xyz;
+	gi_norm = normalize(gi_norm);
+	
+	vec4 c_spec = texture2DRect(specularRect, vary_fragcoord.xy);
+	vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).rgb;
+	gi_pos.xyz += nz.x*gi_noise*gi_norm.xyz;
+	vec2 tcx = gi_norm.xy;
+	vec2 tcy = gi_norm.yx;
+	
+	vec4 eye_pos = gi_mat*vec4(0,0,0,1.0);
+	
+	vec3 eye_dir = normalize(gi_pos.xyz-eye_pos.xyz);
+	vec3 eye_ref = reflect(eye_dir, gi_norm);
+	
+	float da = 0.0; //texture2DRect(lightMap, vary_fragcoord.xy).r*0.5;
+	vec3 fdiff = vec3(da);
+	float fda = da;
+	
+	vec3 rcol = vec3(0,0,0);
+	
+	float fsa = 0.0;
+	
+
+	for (int i = -1; i <= 1; i += 2 )
+	{
+		for (int j = -1; j <= 1; j+= 2)
+		{
+			vec2 tc = vec2(i, j)*0.75+gi_norm.xy*nz.z;
+			tc += nz.xy*2.0;
+			tc *= gi_sample_width*0.25;
+			tc += gi_c.xy;
+			
+			vec3 lnorm = -(texture2D(normalGIMap, tc.xy).xyz*2.0-1.0);
+			vec3 lpos = getGIPosition(tc.xy).xyz;
+							
+			vec3 at = lpos-gi_pos.xyz;
+			float dist = length(at);
+			float dist_atten = clamp(1.0/(gi_attenuation*dist), 0.0, 1.0);
+			
+						
+			if (dist_atten > 0.01)
+			{ //possible contribution of indirect light to this surface
+				vec3 ldir = at;
+				
+				float ld = -dot(ldir, lnorm);
+				
+				if (ld < 0.0)
+				{  					
+					float ang_atten = dot(ldir, gi_norm);
+				
+					if (ang_atten > 0.0)
+					{  
+						vec4 spec = texture2D(specularGIMap, tc.xy);
+						at = normalize(at);
+						vec3 diff;		
+						
+						float da = 0.0;
+												
+						//contribution from indirect source to visible pixel
+						vec3 ha = at;
+						ha.z -= 1.0;
+						ha = normalize(ha);
+						if (spec.a > 0.0)
+						{
+							float sa = dot(ha,lnorm);
+							da = texture2D(lightFunc, vec2(sa, spec.a)).a;
+						}
+						else
+						{
+							da = -lnorm.z;
+						}
+						
+						diff = texture2D(diffuseGIMap, tc.xy).rgb+spec.rgb*spec.a*2.0;
+												
+						if (da > 0.0)
+						{ //contribution from visible pixel to eye
+							vec3 ha = normalize(at-eye_dir);
+							if (c_spec.a > 0.0)
+							{
+								float sa = dot(ha, gi_norm);
+								da = dist_atten*texture2D(lightFunc, vec2(sa, c_spec.a)).a;
+							}
+							else
+							{
+								da = dist_atten*dot(gi_norm, normalize(ldir));
+							}
+							fda += da;
+							fdiff += da*(c_spec.rgb*c_spec.a*2.0+vec3(1,1,1))*diff.rgb;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	fdiff *= sunlight_color.rgb;
+	
+	vec3 ret = fda*fdiff;
+	
+	return clamp(ret,vec3(0.0), vec3(1.0));
+}
+
+void main() 
+{
+	vec2 pos_screen = vary_fragcoord.xy;
+	vec4 pos = getPosition(pos_screen);
+	
+	float rad = gi_range*0.5;
+	
+	vec3 norm = texture2DRect(normalMap, pos_screen).xyz;
+	norm = vec3((norm.xy-0.5)*2.0,norm.z); // unpack norm
+	float dist = max(length(pos.xyz)-rad, 0.0);
+	
+	float da = clamp(1.0-dist/rad, 0.0, 1.0);
+	
+	vec3 ambient = da > 0.0 ? giAmbient(pos.xyz, norm) : vec3(0);
+	
+		
+	gl_FragData[0].xyz = mix(vec3(0), ambient, da);
+}

indra/newview/app_settings/shaders/class3/deferred/giFinalF.glsl

@@ -0,0 +1,25 @@
+/** 
+ * @file giFinalF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2D	  bloomMap;
+uniform sampler2DRect edgeMap;
+
+uniform vec2 screen_res;
+varying vec2 vary_fragcoord;
+
+
+void main() 
+{
+	vec4 bloom = texture2D(bloomMap, vary_fragcoord.xy/screen_res);
+	vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
+	
+	gl_FragColor = bloom + diff;
+	//gl_FragColor.rgb = vec3(texture2DRect(edgeMap, vary_fragcoord.xy).a);
+}

indra/newview/app_settings/shaders/class3/deferred/giFinalV.glsl

@@ -0,0 +1,17 @@
+/** 
+ * @file giFinalV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+varying vec2 vary_fragcoord;
+uniform vec2 screen_res;
+
+void main()
+{
+	//transform vertex
+	gl_Position = ftransform(); 
+	vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+}

indra/newview/app_settings/shaders/class3/deferred/giV.glsl

@@ -0,0 +1,22 @@
+/** 
+ * @file giV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+varying vec2 vary_fragcoord;
+
+uniform vec2 screen_res;
+
+void main()
+{
+	//transform vertex
+	gl_Position = ftransform(); 
+	vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+	vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;	
+	vec4 tex = gl_MultiTexCoord0;
+	tex.w = 1.0;
+
+	gl_FrontColor = gl_Color;
+}

indra/newview/app_settings/shaders/class3/deferred/luminanceF.glsl

@@ -0,0 +1,19 @@
+/** 
+ * @file luminanceF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect lightMap;
+uniform sampler2DRect diffuseRect;
+
+varying vec2 vary_fragcoord;
+void main() 
+{
+	float i = texture2DRect(lightMap, vary_fragcoord.xy).r;
+	gl_FragColor.rgb = vec3(i);
+	gl_FragColor.a = 1.0;
+}

indra/newview/app_settings/shaders/class3/deferred/luminanceV.glsl

@@ -0,0 +1,20 @@
+/** 
+ * @file giV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+varying vec2 vary_fragcoord;
+
+uniform vec2 screen_res;
+
+void main()
+{
+	//transform vertex
+	gl_Position = ftransform(); 
+	vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+	vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;	
+
+	gl_FrontColor = gl_Color;
+}

indra/newview/app_settings/shaders/class3/deferred/postDeferredF.glsl

@@ -0,0 +1,80 @@
+/** 
+ * @file postDeferredF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+ 
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+
+uniform sampler2DRect localLightMap;
+uniform sampler2DRect sunLightMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2DRect edgeMap;
+
+uniform sampler2D	  luminanceMap;
+
+uniform sampler2DRect lightMap;
+
+uniform sampler2D	  lightFunc;
+uniform sampler2D	  noiseMap;
+
+uniform float sun_lum_scale;
+uniform float sun_lum_offset;
+uniform float lum_scale;
+uniform float lum_lod;
+uniform vec4 ambient;
+uniform float gi_brightness;
+uniform float gi_luminance;
+
+uniform vec4 sunlight_color;
+
+uniform vec2 screen_res;
+varying vec2 vary_fragcoord;
+
+void main() 
+{
+	vec2 tc = vary_fragcoord.xy;
+	vec4 lcol = texture2DLod(luminanceMap, vec2(0.5, 0.5), lum_lod);
+	
+	vec3 gi_col = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+	vec4 sun_col =	texture2DRect(sunLightMap, vary_fragcoord.xy);
+	vec3 local_col = texture2DRect(localLightMap, vary_fragcoord.xy).rgb;
+	
+	float scol = texture2DRect(lightMap, vary_fragcoord.xy).r;
+			
+	vec3 diff = texture2DRect(diffuseRect, vary_fragcoord.xy).rgb;
+	vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+	
+	gi_col = gi_col*(diff.rgb+spec.rgb*spec.a);
+
+	float lum = 1.0-clamp(pow(lcol.r, gi_brightness)+sun_lum_offset, 0.0, 1.0);
+	
+	lum *= sun_lum_scale;
+	
+	sun_col *= 1.0+(lum*lum_scale*scol);
+					  
+	vec4 col;
+	col.rgb = gi_col+sun_col.rgb+local_col;
+	
+	col.a = sun_col.a;
+	
+	vec3 bcol = vec3(0,0,0);
+	float tweight = 0.0;
+	for (int i = 0; i < 16; i++)
+	{
+		float weight = (float(i)+1.0)/2.0;
+		bcol += texture2DLod(luminanceMap, vary_fragcoord.xy/screen_res, weight).rgb*weight*weight*weight;
+		tweight += weight*weight;
+	}
+	
+	bcol /= tweight;
+	bcol *= gi_luminance;
+	col.rgb += bcol*lum;
+	
+	gl_FragColor = col;
+	//gl_FragColor.rgb = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
+}

indra/newview/app_settings/shaders/class3/deferred/postDeferredV.glsl

@@ -0,0 +1,17 @@
+/** 
+ * @file postDeferredV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+varying vec2 vary_fragcoord;
+uniform vec2 screen_res;
+
+void main()
+{
+	//transform vertex
+	gl_Position = ftransform(); 
+	vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+}

indra/newview/app_settings/shaders/class3/deferred/postgiF.glsl

@@ -0,0 +1,69 @@
+/** 
+ * @file postgiF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect depthMap;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect giLightMap;
+uniform sampler2D	noiseMap;
+uniform sampler2D	giMip;
+uniform sampler2DRect edgeMap;
+
+
+uniform vec2 delta;
+uniform float kern_scale;
+uniform float gi_edge_weight;
+uniform float gi_blur_brightness;
+
+varying vec2 vary_fragcoord;
+
+void main() 
+{
+	vec2 dlt = kern_scale*delta;
+	float defined_weight = 0.0; 
+	vec3 col = vec3(0.0); 
+	
+	float e = 1.0;
+	
+	for (int i = 1; i < 8; i++)
+	{
+		vec2 tc = vary_fragcoord.xy + float(i) * dlt;
+		
+		e = max(e, 0.0);
+		float wght = e;
+		
+	   	col += texture2DRect(giLightMap, tc).rgb*wght;
+		defined_weight += wght;
+				
+		e *= e;
+		e -=(texture2DRect(edgeMap, tc.xy-dlt*0.25).a+
+			texture2DRect(edgeMap, tc.xy+dlt*0.25).a)*gi_edge_weight;
+	}
+
+	e = 1.0;
+	
+	for (int i = 1; i < 8; i++)
+	{
+		vec2 tc = vary_fragcoord.xy - float(i) * dlt;
+		
+		e = max(e,0.0);
+		float wght = e;
+		
+	   	col += texture2DRect(giLightMap, tc).rgb*wght;
+		defined_weight += wght;
+	
+		e *= e;
+		e -= (texture2DRect(edgeMap, tc.xy-dlt*0.25).a+
+			texture2DRect(edgeMap, tc.xy+dlt*0.25).a)*gi_edge_weight;
+		
+	}
+	
+	col /= max(defined_weight, 0.01);
+
+	gl_FragColor.rgb = col * gi_blur_brightness;
+}

indra/newview/app_settings/shaders/class3/deferred/postgiV.glsl

@@ -0,0 +1,17 @@
+/** 
+ * @file postgiV.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+varying vec2 vary_fragcoord;
+uniform vec2 screen_res;
+
+void main()
+{
+	//transform vertex
+	gl_Position = ftransform(); 
+	vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+}

indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl

@@ -0,0 +1,356 @@
+/** 
+ * @file softenLightF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+#extension GL_ARB_texture_rectangle : enable
+
+uniform sampler2DRect diffuseRect;
+uniform sampler2DRect specularRect;
+uniform sampler2DRect normalMap;
+uniform sampler2DRect lightMap;
+uniform sampler2D	  noiseMap;
+uniform samplerCube environmentMap;
+uniform sampler2D	  lightFunc;
+uniform vec3 gi_quad;
+
+uniform float blur_size;
+uniform float blur_fidelity;
+
+// Inputs
+uniform vec4 morphFactor;
+uniform vec3 camPosLocal;
+//uniform vec4 camPosWorld;
+uniform vec4 gamma;
+uniform vec4 lightnorm;
+uniform vec4 sunlight_color;
+uniform vec4 ambient;
+uniform vec4 blue_horizon;
+uniform vec4 blue_density;
+uniform vec4 haze_horizon;
+uniform vec4 haze_density;
+uniform vec4 cloud_shadow;
+uniform vec4 density_multiplier;
+uniform vec4 distance_multiplier;
+uniform vec4 max_y;
+uniform vec4 glow;
+uniform float scene_light_strength;
+uniform vec3 env_mat[3];
+uniform vec4 shadow_clip;
+uniform mat3 ssao_effect_mat;
+
+uniform sampler2DRect depthMap;
+uniform mat4 inv_proj;
+uniform vec2 screen_res;
+
+varying vec4 vary_light;
+varying vec2 vary_fragcoord;
+
+vec3 vary_PositionEye;
+
+vec3 vary_SunlitColor;
+vec3 vary_AmblitColor;
+vec3 vary_AdditiveColor;
+vec3 vary_AtmosAttenuation;
+uniform float gi_ambiance;
+
+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).a;
+	return getPosition_d(pos_screen, depth);
+}
+
+vec3 getPositionEye()
+{
+	return vary_PositionEye;
+}
+vec3 getSunlitColor()
+{
+	return vary_SunlitColor;
+}
+vec3 getAmblitColor()
+{
+	return vary_AmblitColor;
+}
+vec3 getAdditiveColor()
+{
+	return vary_AdditiveColor;
+}
+vec3 getAtmosAttenuation()
+{
+	return vary_AtmosAttenuation;
+}
+
+
+void setPositionEye(vec3 v)
+{
+	vary_PositionEye = v;
+}
+
+void setSunlitColor(vec3 v)
+{
+	vary_SunlitColor = v;
+}
+
+void setAmblitColor(vec3 v)
+{
+	vary_AmblitColor = v;
+}
+
+void setAdditiveColor(vec3 v)
+{
+	vary_AdditiveColor = v;
+}
+
+void setAtmosAttenuation(vec3 v)
+{
+	vary_AtmosAttenuation = v;
+}
+
+void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
+
+	vec3 P = inPositionEye;
+	setPositionEye(P);
+	
+	//(TERRAIN) limit altitude
+	if (P.y > max_y.x) P *= (max_y.x / P.y);
+	if (P.y < -max_y.x) P *= (-max_y.x / P.y);
+
+	vec3 tmpLightnorm = lightnorm.xyz;
+
+	vec3 Pn = normalize(P);
+	float Plen = length(P);
+
+	vec4 temp1 = vec4(0);
+	vec3 temp2 = vec3(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 * 1.0 + vec4(haze_density.r) * 0.25) * (density_multiplier.x * max_y.x);
+		//I had thought blue_density and haze_density should have equal weighting,
+		//but attenuation due to haze_density tends to seem too strong
+
+	temp1 = blue_density + vec4(haze_density.r);
+	blue_weight = blue_density / temp1;
+	haze_weight = vec4(haze_density.r) / temp1;
+
+	//(TERRAIN) compute sunlight from lightnorm only (for short rays like terrain)
+	temp2.y = max(0.0, tmpLightnorm.y);
+	temp2.y = 1. / temp2.y;
+	sunlight *= exp( - light_atten * temp2.y);
+
+	// main atmospheric scattering line integral
+	temp2.z = Plen * density_multiplier.x;
+
+	// Transparency (-> temp1)
+	// ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier.x in a variable because the ati
+	// compiler gets confused.
+	temp1 = exp(-temp1 * temp2.z * distance_multiplier.x);
+
+	//final atmosphere attenuation factor
+	setAtmosAttenuation(temp1.rgb);
+	
+	//compute haze glow
+	//(can use temp2.x as temp because we haven't used it yet)
+	temp2.x = dot(Pn, tmpLightnorm.xyz);
+	temp2.x = 1. - temp2.x;
+		//temp2.x is 0 at the sun and increases away from sun
+	temp2.x = max(temp2.x, .03);	//was glow.y
+		//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*gi_ambiance + (vec4(1.) - ambient*gi_ambiance) * cloud_shadow.x * 0.5;
+	
+	/*  decrease value and saturation (that in HSV, not HSL) for occluded areas
+	 * // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
+	 * // The following line of code performs the equivalent of:
+	 * float ambAlpha = tmpAmbient.a;
+	 * float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
+	 * vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
+	 * tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat, ambAlpha);
+	 */
+	tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
+
+	//haze color
+	setAdditiveColor(
+		vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow.x) + tmpAmbient)
+	  + (haze_horizon.r * haze_weight) * (sunlight*(1.-cloud_shadow.x) * temp2.x
+		  + tmpAmbient)));
+
+	//brightness of surface both sunlight and ambient
+	setSunlitColor(vec3(sunlight * .5));
+	setAmblitColor(vec3(tmpAmbient * .25));
+	setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
+}
+
+vec3 atmosLighting(vec3 light)
+{
+	light *= getAtmosAttenuation().r;
+	light += getAdditiveColor();
+	return (2.0 * light);
+}
+
+vec3 atmosTransport(vec3 light) {
+	light *= getAtmosAttenuation().r;
+	light += getAdditiveColor() * 2.0;
+	return light;
+}
+vec3 atmosGetDiffuseSunlightColor()
+{
+	return getSunlitColor();
+}
+
+vec3 scaleDownLight(vec3 light)
+{
+	return (light / scene_light_strength );
+}
+
+vec3 scaleUpLight(vec3 light)
+{
+	return (light * scene_light_strength);
+}
+
+vec3 atmosAmbient(vec3 light)
+{
+	return getAmblitColor() + light / 2.0;
+}
+
+vec3 atmosAffectDirectionalLight(float lightIntensity)
+{
+	return getSunlitColor() * lightIntensity;
+}
+
+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() 
+{
+	vec2 tc = vary_fragcoord.xy;
+	float depth = texture2DRect(depthMap, tc.xy).a;
+	vec3 pos = getPosition_d(tc, depth).xyz;
+	vec3 norm = texture2DRect(normalMap, tc).xyz;
+	norm = vec3((norm.xy-0.5)*2.0,norm.z); // unpack norm
+	//vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).xyz;
+	
+	float da = max(dot(norm.xyz, vary_light.xyz), 0.0);
+	
+	vec4 diffuse = texture2DRect(diffuseRect, tc);
+	vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
+	
+	da = texture2D(lightFunc, vec2(da, 0.0)).a;
+		
+	vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
+	float scol = max(scol_ambocc.r, diffuse.a); 
+	float ambocc = scol_ambocc.g;
+	
+	calcAtmospherics(pos.xyz, ambocc);
+	
+	vec3 col = atmosAmbient(vec3(0));
+	col += atmosAffectDirectionalLight(max(min(da, scol), diffuse.a));
+	
+	col *= diffuse.rgb;
+	
+	if (spec.a > 0.0) // specular reflection
+	{
+		// the old infinite-sky shiny reflection
+		//
+		vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
+		float sa = dot(refnormpersp, vary_light.xyz);
+		vec3 dumbshiny = vary_SunlitColor*scol*texture2D(lightFunc, vec2(sa, spec.a)).a;
+
+		/*
+		// screen-space cheap fakey reflection map
+		//
+		vec3 refnorm = normalize(reflect(vec3(0,0,-1), norm.xyz));
+		depth -= 0.5; // unbias depth
+		// first figure out where we'll make our 2D guess from
+		vec2 ref2d = (0.25 * screen_res.y) * (refnorm.xy) * abs(refnorm.z) / depth;
+		// Offset the guess source a little according to a trivial
+		// checkerboard dither function and spec.a.
+		// This is meant to be similar to sampling a blurred version
+		// of the diffuse map.  LOD would be better in that regard.
+		// The goal of the blur is to soften reflections in surfaces
+		// with low shinyness, and also to disguise our lameness.
+		float checkerboard = floor(mod(tc.x+tc.y, 2.0)); // 0.0, 1.0
+		float checkoffset = (3.0 + (7.0*(1.0-spec.a)))*(checkerboard-0.5);
+
+		ref2d += vec2(checkoffset, checkoffset);
+		ref2d += tc.xy; // use as offset from destination
+		// Get attributes from the 2D guess point.
+		// We average two samples of diffuse (not of anything else) per
+		// pixel to try to reduce aliasing some more.
+		vec3 refcol = 0.5 * (texture2DRect(diffuseRect, ref2d + vec2(0.0, -checkoffset)).rgb +
+				     texture2DRect(diffuseRect, ref2d + vec2(-checkoffset, 0.0)).rgb);
+		float refdepth = texture2DRect(depthMap, ref2d).a;
+		vec3 refpos = getPosition_d(ref2d, refdepth).xyz;
+		float refshad = texture2DRect(lightMap, ref2d).r;
+		vec3 refn = texture2DRect(normalMap, ref2d).rgb;
+		refn = vec3((refn.xy-0.5)*2.0,refn.z); // unpack norm
+		refn = normalize(refn);
+		// figure out how appropriate our guess actually was
+		float refapprop = max(0.0, dot(-refnorm, normalize(pos - refpos)));
+		// darken reflections from points which face away from the reflected ray - our guess was a back-face
+		//refapprop *= step(dot(refnorm, refn), 0.0);
+		refapprop = min(refapprop, max(0.0, -dot(refnorm, refn))); // more conservative variant
+		// get appropriate light strength for guess-point.
+		// reflect light direction to increase the illusion that
+		// these are reflections.
+		vec3 reflight = reflect(lightnorm.xyz, norm.xyz);
+		float reflit = min(max(dot(refn, reflight.xyz), 0.0), refshad);
+		// apply sun color to guess-point, dampen according to inappropriateness of guess
+		float refmod = min(refapprop, reflit);
+		vec3 refprod = vary_SunlitColor * refcol.rgb * refmod;
+		vec3 ssshiny = (refprod * spec.a);
+		ssshiny *= 0.3; // dampen it even more
+		*/
+		vec3 ssshiny = vec3(0,0,0);
+
+		// add the two types of shiny together
+		col += (ssshiny + dumbshiny) * spec.rgb;
+	}
+	
+	col = atmosLighting(col);
+	col = scaleSoftClip(col);
+		
+	gl_FragColor.rgb = col;
+	
+	//gl_FragColor.rgb = gi_col.rgb;
+	gl_FragColor.a = 0.0;
+	
+	//gl_FragColor.rg = scol_ambocc.rg;
+	//gl_FragColor.rgb = texture2DRect(lightMap, vary_fragcoord.xy).rgb;
+	//gl_FragColor.rgb = norm.rgb*0.5+0.5;
+	//gl_FragColor.rgb = vec3(ambocc);
+	//gl_FragColor.rgb = vec3(scol);
+}

indra/newview/app_settings/shaders/class3/deferred/softenLightV.glsl

@@ -0,0 +1,24 @@
+/** 
+ * @file softenLightF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+uniform vec2 screen_res;
+
+varying vec4 vary_light;
+varying vec2 vary_fragcoord;
+void main()
+{
+	//transform vertex
+	gl_Position = ftransform(); 
+	
+	vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
+	vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
+		
+	vec4 tex = gl_MultiTexCoord0;
+	tex.w = 1.0;
+	
+	vary_light = gl_MultiTexCoord0;
+}

indra/newview/app_settings/shaders/class3/deferred/treeF.glsl

@@ -0,0 +1,19 @@
+/** 
+ * @file treeF.glsl
+ *
+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$
+ * $/LicenseInfo$
+ */
+
+uniform sampler2D diffuseMap;
+
+varying vec3 vary_normal;
+
+void main() 
+{
+	vec4 col = texture2D(diffuseMap, gl_TexCoord[0].xy);
+	gl_FragData[0] = vec4(gl_Color.rgb*col.rgb, col.a <= 0.5 ? 0.0 : 0.005);
+	gl_FragData[1] = vec4(0,0,0,0);
+	vec3 nvn = normalize(vary_normal);
+	gl_FragData[2] = vec4(nvn.xy * 0.5 + 0.5, nvn.z, 0.0);
+}

indra/newview/app_settings/shaders/class3/lighting/sumLightsV.glsl

@@ -6,7 +6,7 @@
  */
 
 float calcDirectionalLight(vec3 n, vec3 l);
-float calcPointLight(vec3 v, vec3 n, vec4 lp, float la);
+float calcPointLightOrSpotLight(vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float is_pointlight);
 
 vec3 atmosAmbient(vec3 light);
 vec3 atmosAffectDirectionalLight(float lightIntensity);
@@ -15,24 +15,21 @@ vec3 scaleUpLight(vec3 light);
 
 vec4 sumLights(vec3 pos, vec3 norm, vec4 color, vec4 baseLight)
 {
-	vec4 col;
-	col.a = color.a;
+	vec4 col = vec4(0.0, 0.0, 0.0, color.a);
 	
-	// Add windlight lights
-	col.rgb = atmosAffectDirectionalLight(calcDirectionalLight(norm, gl_LightSource[0].position.xyz));
-	col.rgb += atmosAmbient(baseLight.rgb);
-	col.rgb = scaleUpLight(col.rgb);
-
 	// Collect normal lights (need to be divided by two, as we later multiply by 2)
-	col.rgb += gl_LightSource[2].diffuse.rgb*calcPointLight(pos, norm, gl_LightSource[2].position, gl_LightSource[2].linearAttenuation);
-	col.rgb += gl_LightSource[3].diffuse.rgb*calcPointLight(pos, norm, gl_LightSource[3].position, gl_LightSource[3].linearAttenuation);
-	col.rgb += gl_LightSource[4].diffuse.rgb*calcPointLight(pos, norm, gl_LightSource[4].position, gl_LightSource[4].linearAttenuation);
-	col.rgb += gl_LightSource[5].diffuse.rgb*calcPointLight(pos, norm, gl_LightSource[5].position, gl_LightSource[5].linearAttenuation);
- 	col.rgb += gl_LightSource[6].diffuse.rgb*calcPointLight(pos, norm, gl_LightSource[6].position, gl_LightSource[6].linearAttenuation);
- 	col.rgb += gl_LightSource[7].diffuse.rgb*calcPointLight(pos, norm, gl_LightSource[7].position, gl_LightSource[7].linearAttenuation);
+	col.rgb += gl_LightSource[2].diffuse.rgb*calcPointLightOrSpotLight(pos.xyz, norm, gl_LightSource[2].position, gl_LightSource[2].spotDirection.xyz, gl_LightSource[2].linearAttenuation, gl_LightSource[2].specular.a);
+	col.rgb += gl_LightSource[3].diffuse.rgb*calcPointLightOrSpotLight(pos.xyz, norm, gl_LightSource[3].position, gl_LightSource[3].spotDirection.xyz, gl_LightSource[3].linearAttenuation, gl_LightSource[3].specular.a);
+	col.rgb += gl_LightSource[4].diffuse.rgb*calcPointLightOrSpotLight(pos.xyz, norm, gl_LightSource[4].position, gl_LightSource[4].spotDirection.xyz, gl_LightSource[4].linearAttenuation, gl_LightSource[4].specular.a);
+	col.rgb += gl_LightSource[5].diffuse.rgb*calcPointLightOrSpotLight(pos.xyz, norm, gl_LightSource[5].position, gl_LightSource[5].spotDirection.xyz, gl_LightSource[5].linearAttenuation, gl_LightSource[5].specular.a);
+	col.rgb += gl_LightSource[6].diffuse.rgb*calcPointLightOrSpotLight(pos.xyz, norm, gl_LightSource[6].position, gl_LightSource[6].spotDirection.xyz, gl_LightSource[6].linearAttenuation, gl_LightSource[6].specular.a);
+	col.rgb += gl_LightSource[7].diffuse.rgb*calcPointLightOrSpotLight(pos.xyz, norm, gl_LightSource[7].position, gl_LightSource[7].spotDirection.xyz, gl_LightSource[7].linearAttenuation, gl_LightSource[7].specular.a);
 	col.rgb += gl_LightSource[1].diffuse.rgb*calcDirectionalLight(norm, gl_LightSource[1].position.xyz);
 	col.rgb = scaleDownLight(col.rgb);
-				
+
+	// Add windlight lights
+	col.rgb += atmosAffectDirectionalLight(calcDirectionalLight(norm, gl_LightSource[0].position.xyz));
+	col.rgb += atmosAmbient(baseLight.rgb);
 
 	col.rgb = min(col.rgb*color.rgb, 1.0);