WIP - Make EEP match production.

1 files changed, 130 insertions, 163 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index a8a5cc22db..85d664ea1f 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
@@ -216,98 +216,63 @@ void main()
 {
     vec2 pos_screen = vary_texcoord0.xy;
 
-    vec4 diffuse_srgb = texture2D(diffuseMap, vary_texcoord0.xy);
-    diffuse_srgb.rgb *= vertex_color.rgb;
-    
-    // For some reason the Transparency slider sets vertex_color.a to 0.0 both for
-    // fully opaque and for fully transparent objects. This code assumes the 0 alpha
-    // is always from the opaque end of the scale. TODO: Remove the conditional once
-    // the root cause of the slider ambiguity is fixed.
-    if (vertex_color.a > 0.0)
-    {
-        diffuse_srgb.a *= vertex_color.a;
-    }
-    vec4 diffuse_linear = vec4(srgb_to_linear(diffuse_srgb.rgb), diffuse_srgb.a);
+    vec4 diffcol = texture2D(diffuseMap, vary_texcoord0.xy);
+	diffcol.rgb *= vertex_color.rgb;
 
 #if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_MASK)
-    if (diffuse_linear.a < minimum_alpha)
+    if (diffcol.a < minimum_alpha)
     {
         discard;
     }
 #endif
 
-#ifdef HAS_SPECULAR_MAP
+#if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_BLEND)
+	vec3 gamma_diff = diffcol.rgb;
+	diffcol.rgb = srgb_to_linear(diffcol.rgb);
+#endif
+
+#if HAS_SPECULAR_MAP != 0
     vec4 spec = texture2D(specularMap, vary_texcoord2.xy);
     spec.rgb *= specular_color.rgb;
 #else
     vec4 spec = vec4(specular_color.rgb, 1.0);
 #endif
 
-    vec3 norm = vec3(0);
-    float bmap_specular = 1.0;
+#if HAS_NORMAL_MAP
+	vec4 norm = texture2D(bumpMap, vary_texcoord1.xy);
 
-#ifdef HAS_NORMAL_MAP
-    vec4 bump_sample = texture2D(bumpMap, vary_texcoord1.xy);
-    norm = (bump_sample.xyz * 2) - vec3(1);
-    bmap_specular = bump_sample.w;
-
-    // convert sampled normal to tangent space normal
-    norm = vec3(dot(norm, vary_mat0),
-        dot(norm, vary_mat1),
-        dot(norm, vary_mat2));
+	norm.xyz = norm.xyz * 2 - 1;
+
+	vec3 tnorm = vec3(dot(norm.xyz,vary_mat0),
+			  dot(norm.xyz,vary_mat1),
+			  dot(norm.xyz,vary_mat2));
 #else
-    norm = vary_normal;
+	vec4 norm = vec4(0,0,0,1.0);
+	vec3 tnorm = vary_normal;
 #endif
 
-    norm = normalize(norm);
-
-    vec2 abnormal = encode_normal(norm);
+    norm.xyz = normalize(tnorm.xyz);
 
-    vec4 final_color = vec4(diffuse_linear.rgb, 0.0);
-
-#if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_EMISSIVE)
-    final_color.a = diffuse_linear.a * 0.5; // SL-12171
-#endif
+    vec2 abnormal = encode_normal(norm.xyz);
 
-    final_color.a = max(final_color.a, emissive_brightness);
-
-    // Texture
-    //     [x] Full Bright (emissive_brightness >= 1.0)
-    //     Shininess (specular)
-    //       [X] Texture
-    //       Environment Intensity = 1
-    // NOTE: There are two shaders that are used depending on the EI byte value:
-    //     EI = 0        fullbright
-    //     EI > 0 .. 255 material
-    // When it is passed to us it is normalized.
-    // We can either modify the output environment intensity
-    //   OR
-    // adjust the final color via:
-    //     final_color *= 0.666666;
-    // We don't remap the environment intensity but adjust the final color to closely simulate what non-EEP is doing.
-    vec4 final_normal = vec4(abnormal, env_intensity, 0.0);
-
-    vec3 color = vec3(0.0);
-    float al = 0;
+    vec4 final_color = diffcol;
 
-#ifdef HAS_SPECULAR_MAP
-    if (emissive_brightness >= 1.0) // ie, if fullbright
-    {
-        float ei = env_intensity*0.5 + 0.5;
-        final_normal = vec4(abnormal, ei, 0.0);
-    }
+#if (DIFFUSE_ALPHA_MODE != DIFFUSE_ALPHA_MODE_EMISSIVE)
+	final_color.a = emissive_brightness;
+#else
+	final_color.a = max(final_color.a, emissive_brightness);
 #endif
 
     vec4 final_specular = spec;
-
-    final_specular.a = specular_color.a;
-
-#ifdef HAS_SPECULAR_MAP
-    final_specular.a *= bmap_specular;
-    final_normal.z *= spec.a;
+    
+#if HAS_SPECULAR_MAP != 0
+    vec4 final_normal = vec4(encode_normal(normalize(tnorm)), env_intensity * spec.a, 0.0);
+	final_specular.a = specular_color.a * norm.a;
+#else
+	vec4 final_normal = vec4(encode_normal(normalize(tnorm)), env_intensity, 0.0);
+	final_specular.a = specular_color.a;
 #endif
 
-
 #if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_BLEND)
 
     //forward rendering, output just lit sRGBA
@@ -316,13 +281,15 @@ void main()
     float shadow = 1.0f;
 
 #ifdef HAS_SUN_SHADOW
-    shadow = sampleDirectionalShadow(pos.xyz, norm, pos_screen);
+    shadow = sampleDirectionalShadow(pos.xyz, norm.xyz, pos_screen);
 #endif
 
     spec = final_specular;
-
+    vec4 diffuse = final_color;
     float envIntensity = final_normal.z;
 
+    vec3 color = vec3(0,0,0);
+
     vec3 light_dir = (sun_up_factor == 1) ? sun_dir : moon_dir;
 
     float bloom = 0.0;
@@ -333,117 +300,118 @@ void main()
 
     calcAtmosphericVars(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
     
-    if (emissive_brightness >= 1.0)	// fullbright, skip lighting calculations
-    {
-        color = fullbrightAtmosTransportFrag(diffuse_srgb.rgb, additive, atten);
-        color = fullbrightScaleSoftClip(color);
 
-        al = diffuse_srgb.a;
-    }
-    else // not fullbright, calculate lighting
-    {
-        vec3 refnormpersp = normalize(reflect(pos.xyz, norm));
-
-        //we're in sRGB space, so gamma correct this dot product so 
-        // lighting from the sun stays sharp
-        float da = clamp(dot(normalize(norm.xyz), light_dir.xyz), 0.0, 1.0);
-        da = pow(da, 1.0 / 1.3);
-
-        //darken ambient for normals perpendicular to light vector so surfaces in shadow 
-        // and facing away from light still have some definition to them.
-        // do NOT gamma correct this dot product so ambient lighting stays soft
-        float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
-        ambient *= 0.5;
-        ambient *= ambient;
-        ambient = (1.0 - ambient);
-
-        vec3 sun_contrib = min(da, shadow) * sunlit;
-
-#if !defined(AMBIENT_KILL)
-        color = amblit;
-        color *= ambient;
-#endif
+    vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
 
-#if !defined(SUNLIGHT_KILL)
-        color += sun_contrib;
-#endif
-        color *= diffuse_srgb.rgb;
+    //we're in sRGB space, so gamma correct this dot product so 
+    // lighting from the sun stays sharp
+    float da = clamp(dot(normalize(norm.xyz), light_dir.xyz), 0.0, 1.0);
+    da = pow(da, 1.0 / 1.3);
 
-        float glare = 0.0;
+    color = amblit;
 
-        if (spec.a > 0.0) // specular reflection
-        {
-            vec3 npos = -normalize(pos.xyz);
+    //darken ambient for normals perpendicular to light vector so surfaces in shadow 
+    // and facing away from light still have some definition to them.
+    // do NOT gamma correct this dot product so ambient lighting stays soft
+    float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
+    ambient *= 0.5;
+    ambient *= ambient;
+    ambient = (1.0 - ambient);
 
-            //vec3 ref = dot(pos+lv, norm);
-            vec3 h = normalize(light_dir.xyz + 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 sun_contrib = min(da, shadow) * sunlit;
+    
+    color *= ambient;
 
-            float gtdenom = 2 * nh;
-            float gt = max(0, min(gtdenom * nv / vh, gtdenom * da / vh));
+    color += sun_contrib;
 
-            if (nh > 0.0)
-            {
-                float scol = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt / (nh*da);
-                vec3 sp = sun_contrib*scol / 6.0f;
-                sp = clamp(sp, vec3(0), vec3(1));
-                bloom = dot(sp, sp) / 4.0;
-#if !defined(SUNLIGHT_KILL)
-                color += sp * spec.rgb;
-#endif
-            }
-        }
+    color *= gamma_diff.rgb;
 
-        if (envIntensity > 0.0)
-        {
-            //add environmentmap
-            vec3 env_vec = env_mat * refnormpersp;
+    float glare = 0.0;
 
-            vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
+    if (spec.a > 0.0) // specular reflection
+    {
+#if 1 //EEP
 
-#if !defined(SUNLIGHT_KILL)
-            color = mix(color, reflected_color, envIntensity);
-#endif
-            float cur_glare = max(reflected_color.r, reflected_color.g);
-            cur_glare = max(cur_glare, reflected_color.b);
-            cur_glare *= envIntensity*4.0;
-            glare += cur_glare;
+        vec3 npos = -normalize(pos.xyz);
+
+        //vec3 ref = dot(pos+lv, norm);
+        vec3 h = normalize(light_dir.xyz + npos);
+        float nh = dot(norm.xyz, h);
+        float nv = dot(norm.xyz, 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);
+            vec3 sp = sun_contrib*scol / 6.0f;
+            sp = clamp(sp, vec3(0), vec3(1));
+            bloom = dot(sp, sp) / 4.0;
+            color += sp * spec.rgb;
         }
+#else // PRODUCTION
+        float sa = dot(refnormpersp, sun_dir.xyz);
+		vec3 dumbshiny = sunlit*shadow*(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;
+
+		glare = max(spec_contrib.r, spec_contrib.g);
+		glare = max(glare, spec_contrib.b);
+
+		color += spec_contrib;
+#endif
+    }
 
-        color = atmosFragLighting(color, additive, atten);
-        color = scaleSoftClipFrag(color);
+    color = mix(color.rgb, diffcol.rgb, diffuse.a);
+    
+    if (envIntensity > 0.0)
+    {
+        //add environmentmap
+        vec3 env_vec = env_mat * refnormpersp;
 
-        vec3 npos = normalize(-pos.xyz);
+        vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
 
-        vec3 light = vec3(0, 0, 0);
+        color = mix(color, reflected_color, envIntensity);
 
-        //convert to linear before adding local lights
-        color = srgb_to_linear(color);
+        float cur_glare = max(reflected_color.r, reflected_color.g);
+        cur_glare = max(cur_glare, reflected_color.b);
+        cur_glare *= envIntensity*4.0;
+        glare += cur_glare;
+    }
 
-#define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, npos, diffuse_linear.rgb, final_specular, pos.xyz, norm, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, glare, light_attenuation[i].w );
+    color = atmosFragLighting(color, additive, atten);
+    color = scaleSoftClipFrag(color);
 
-        LIGHT_LOOP(1)
-            LIGHT_LOOP(2)
-            LIGHT_LOOP(3)
-            LIGHT_LOOP(4)
-            LIGHT_LOOP(5)
-            LIGHT_LOOP(6)
-            LIGHT_LOOP(7)
+    //convert to linear before adding local lights
+    color = srgb_to_linear(color);
 
-            glare = min(glare, 1.0);
-        al = max(diffuse_linear.a, glare)*vertex_color.a;
+    vec3 npos = normalize(-pos.xyz);
 
-#if !defined(LOCAL_LIGHT_KILL)
-        color += light;
-#endif
+    vec3 light = vec3(0, 0, 0);
+    
+#define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, npos, diffuse.rgb, final_specular, pos.xyz, norm.xyz, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, glare, light_attenuation[i].w );
 
-        //convert to srgb as this color is being written post gamma correction
-        color = linear_to_srgb(color);
-    }
+    LIGHT_LOOP(1)
+        LIGHT_LOOP(2)
+        LIGHT_LOOP(3)
+        LIGHT_LOOP(4)
+        LIGHT_LOOP(5)
+        LIGHT_LOOP(6)
+        LIGHT_LOOP(7)
+
+    color += light;
+
+    glare = min(glare, 1.0);
+    float al = max(diffcol.a, glare)*vertex_color.a;
+
+    //convert to srgb as this color is being written post gamma correction
+    color = linear_to_srgb(color);
 
 #ifdef WATER_FOG
     vec4 temp = applyWaterFogView(pos, vec4(color, al));
@@ -451,13 +419,12 @@ void main()
     al = temp.a;
 #endif
 
-    // Don't allow alpha to exceed input value - SL-12592
-    frag_color = vec4(color, min(al, diffuse_srgb.a));
+    frag_color = vec4(color, al);
 
 #else // mode is not DIFFUSE_ALPHA_MODE_BLEND, encode to gbuffer 
 
     // deferred path
-    frag_data[0] = vec4(linear_to_srgb(final_color.rgb), final_color.a); //gbuffer is sRGB
+    frag_data[0] = final_color; //gbuffer is sRGB
     frag_data[1] = final_specular; // XYZ = Specular color. W = Specular exponent.
     frag_data[2] = final_normal; // XY = Normal.  Z = Env. intensity.
 #endif