Commits

leslie_linden committed 4570481

SH-1618 FIX
SH-1619 FIX
SH-1620 FIX
SH-2621 FIX

* Got lighting, shadows, and ambient occlusion working on ATI macs.
* Re-enabled ambient occlusion on ATI macs.
* Re-enabled depth of field on ATI macs.

Reviewed by Runitai Linden.

  • Participants
  • Parent commits d363fe6

Comments (0)

Files changed (3)

indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl

 uniform mat4 inv_proj;
 uniform vec2 screen_res;
 
+vec3 getKern(int i)
+{
+	return kern[i];
+}
+
 vec4 getPosition(vec2 pos_screen)
 {
 	float depth = texture2DRect(depthMap, pos_screen.xy).r;
 	vec2 dlt = kern_scale * delta / (1.0+norm.xy*norm.xy);
 	dlt /= max(-pos.z*dist_factor, 1.0);
 	
-	vec2 defined_weight = kern[0].xy; // special case the first (centre) sample's weight in the blur; we have to sample it anyway so we get it for 'free'
+	vec2 defined_weight = getKern(0).xy; // special case the first (centre) sample's weight in the blur; we have to sample it anyway so we get it for 'free'
 	vec4 col = defined_weight.xyxx * ccol;
 
 	// relax tolerance according to distance to avoid speckling artifacts, as angles and distances are a lot more abrupt within a small screen area at larger distances
 	float pointplanedist_tolerance_pow2 = pos.z*pos.z*0.00005;
 
 	// perturb sampling origin slightly in screen-space to hide edge-ghosting artifacts where smoothing radius is quite large
-	tc += ( (mod(tc.x+tc.y,2) - 0.5) * kern[1].z * dlt * 0.5 );
+	float tc_mod = 0.5*(tc.x + tc.y); // mod(tc.x+tc.y,2)
+	tc_mod -= floor(tc_mod);
+	tc_mod *= 2.0;
+	tc += ( (tc_mod - 0.5) * getKern(1).z * dlt * 0.5 );
 
 	for (int i = 1; i < 4; i++)
 	{
-		vec2 samptc = tc + kern[i].z*dlt;
+		vec2 samptc = tc + getKern(i).z*dlt;
 	        vec3 samppos = getPosition(samptc).xyz; 
 		float d = dot(norm.xyz, samppos.xyz-pos.xyz);// dist from plane
 		if (d*d <= pointplanedist_tolerance_pow2)
 		{
-			col += texture2DRect(lightMap, samptc)*kern[i].xyxx;
-			defined_weight += kern[i].xy;
+			col += texture2DRect(lightMap, samptc)*getKern(i).xyxx;
+			defined_weight += getKern(i).xy;
 		}
 	}
 	for (int i = 1; i < 4; i++)
 	{
-		vec2 samptc = tc - kern[i].z*dlt;
+		vec2 samptc = tc - getKern(i).z*dlt;
 	        vec3 samppos = getPosition(samptc).xyz; 
 		float d = dot(norm.xyz, samppos.xyz-pos.xyz);// dist from plane
 		if (d*d <= pointplanedist_tolerance_pow2)
 		{
-			col += texture2DRect(lightMap, samptc)*kern[i].xyxx;
-			defined_weight += kern[i].xy;
+			col += texture2DRect(lightMap, samptc)*getKern(i).xyxx;
+			defined_weight += getKern(i).xy;
 		}
 	}
 

indra/newview/app_settings/shaders/class2/deferred/sunLightSSAOF.glsl

 uniform sampler2DShadow shadowMap5;
 uniform sampler2D noiseMap;
 
+
 // Inputs
 uniform mat4 shadow_matrix[6];
 uniform vec4 shadow_clip;
 uniform float ssao_factor_inv;
 
 VARYING vec2 vary_fragcoord;
-uniform vec3 sun_dir;
 
 uniform mat4 inv_proj;
 uniform vec2 screen_res;
 uniform vec2 shadow_res;
 uniform vec2 proj_shadow_res;
+uniform vec3 sun_dir;
 
 uniform float shadow_bias;
 uniform float shadow_offset;
 	return pos;
 }
 
-//calculate decreases in ambient lighting when crowded out (SSAO)
-float calcAmbientOcclusion(vec4 pos, vec3 norm)
+vec2 getKern(int i)
 {
-	float ret = 1.0;
-
 	vec2 kern[8];
 	// exponentially (^2) distant occlusion samples spread around origin
 	kern[0] = vec2(-1.0, 0.0) * 0.125*0.125;
 	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;
-	int points = 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(kern[i], noise_reflect);
+		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);
 			
 		// --> 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)
-			
-		angle_hidden = angle_hidden + float(dot((samppos_world - 0.05*norm - pos_world), norm) > 0.0) * min(1.0/dist2, ssao_factor_inv);
+		
+		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" 
-		points = points + int(diff.z > -1.0);
+		float diffz_val = (diff.z > -1.0) ? 1.0 : 0.0;
+		points = points + diffz_val;
 	}
 		
-	angle_hidden = min(ssao_factor*angle_hidden/float(points), 1.0);
-		
-	ret = (1.0 - (float(points != 0) * angle_hidden));
+	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);
 }
 
 	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, off.y, 0.0)).x, cs);
 	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, -off.y, 0.0)).x, cs);
 	
-			
 	return shadow/5.0;
 	
 	//return shadow;
 	gl_FragColor[0] = shadow;
 	gl_FragColor[1] = calcAmbientOcclusion(pos, norm);
 	
-	spos.xyz = shadow_pos+norm*spot_shadow_offset;
+	spos = vec4(shadow_pos+norm*spot_shadow_offset, 1.0);
 	
 	//spotlight shadow 1
 	vec4 lpos = shadow_matrix[4]*spos;

indra/newview/featuretable_mac.txt

-version 30
+version 31
 // The version number above should be implemented IF AND ONLY IF some
 // change has been made that is sufficiently important to justify
 // resetting the graphics preferences of all users to the recommended
 RenderDeferredSSAO			0	0
 
 list ATI
-RenderDeferredSSAO			0	0
+RenderDeferredSSAO			1	0
 
 list Intel
 RenderAnisotropic			1	0