From 3e472948db34e8efc905b5b50249f4587ba1507f Mon Sep 17 00:00:00 2001
From: Runitai Linden <davep@lindenlab.com>
Date: Fri, 20 Mar 2020 16:50:37 -0500
Subject: [PATCH] WIP - Make EEP match production.
---
.../shaders/class1/deferred/fullbrightF.glsl | 2 -
.../class1/deferred/fullbrightShinyF.glsl | 4 +-
.../shaders/class1/deferred/materialF.glsl | 293 ++++++++----------
.../shaders/class1/deferred/softenLightF.glsl | 83 ++---
.../shaders/class1/deferred/waterF.glsl | 9 +-
.../class1/environment/terrainWaterF.glsl | 10 +-
.../shaders/class1/environment/waterF.glsl | 173 ++++++-----
.../shaders/class2/deferred/softenLightF.glsl | 14 +-
.../class2/windlight/atmosphericsV.glsl | 128 +++++++-
.../shaders/class2/windlight/transportF.glsl | 17 +-
10 files changed, 391 insertions(+), 342 deletions(-)
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index 46ec20c8b09..57420158ca2 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
@@ -79,8 +79,6 @@ void main()
color.rgb = fogged.rgb;
color.a = fogged.a;
#else
- color.rgb = fullbrightAtmosTransport(color.rgb);
- color.rgb = fullbrightScaleSoftClip(color.rgb);
color.a = final_alpha;
#endif
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl
index 523e7f9e04a..af903eeda89 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl
@@ -51,12 +51,12 @@ void main()
#else
vec4 color = texture2D(diffuseMap, vary_texcoord0.xy);
#endif
-
+
color.rgb *= vertex_color.rgb;
vec3 envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;
- color.rgb = mix(color.rgb, envColor.rgb, vertex_color.a*0.75); // MAGIC NUMBER SL-12574; ALM: Off, Quality > Low
+ color.rgb = mix(color.rgb, envColor.rgb, vertex_color.a);
color.rgb = pow(color.rgb,vec3(2.2f,2.2f,2.2f));
diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index a8a5cc22dba..85d664ea1f3 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
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 20ac78947be..5b94baf7e60 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -63,6 +63,8 @@ void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, ou
float getAmbientClamp();
vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
vec3 scaleSoftClipFrag(vec3 l);
+vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
+vec3 fullbrightScaleSoftClip(vec3 light);
vec3 linear_to_srgb(vec3 c);
vec3 srgb_to_linear(vec3 c);
@@ -81,11 +83,13 @@ void main()
norm.xyz = getNorm(tc);
vec3 light_dir = (sun_up_factor == 1) ? sun_dir : moon_dir;
- float da = clamp(dot(normalize(norm.xyz), light_dir.xyz), 0.0, 1.0);
- da = pow(da, 1.0/1.3);
+ float da = clamp(dot(norm.xyz, light_dir.xyz), 0.0, 1.0);
+ //da = pow(da, 1.0/1.3);
+
+ vec4 diffuse = texture2DRect(diffuseRect, tc);
- vec4 diffuse_srgb = texture2DRect(diffuseRect, tc);
- vec4 diffuse_linear = vec4(srgb_to_linear(diffuse_srgb.rgb), diffuse_srgb.a);
+ //convert to gamma space
+ //diffuse.rgb = linear_to_srgb(diffuse.rgb);
vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
vec3 color = vec3(0);
@@ -100,34 +104,27 @@ void main()
calcAtmosphericVars(pos.xyz, light_dir, ambocc, sunlit, amblit, additive, atten, false);
+ color.rgb = amblit;
+
float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
ambient *= 0.5;
ambient *= ambient;
ambient = (1.0 - ambient);
- vec3 sun_contrib = da * sunlit;
-
-#if !defined(AMBIENT_KILL)
- color.rgb = amblit;
color.rgb *= ambient;
-#endif
-vec3 post_ambient = color.rgb;
+ vec3 sun_contrib = da * sunlit;
-#if !defined(SUNLIGHT_KILL)
color.rgb += sun_contrib;
-#endif
-
-vec3 post_sunlight = color.rgb;
- color.rgb *= diffuse_srgb.rgb;
-
-vec3 post_diffuse = color.rgb;
+ color.rgb *= diffuse.rgb;
vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
if (spec.a > 0.0) // specular reflection
{
+
+#if 1 //EEP
vec3 npos = -normalize(pos.xyz);
//vec3 ref = dot(pos+lv, norm);
@@ -140,71 +137,55 @@ vec3 post_diffuse = color.rgb;
float gtdenom = 2 * nh;
float gt = max(0, min(gtdenom * nv / vh, gtdenom * da / vh));
-
+
if (nh > 0.0)
{
float scontrib = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt/(nh*da);
vec3 sp = sun_contrib*scontrib / 6.0;
sp = clamp(sp, vec3(0), vec3(1));
bloom += dot(sp, sp) / 4.0;
-#if !defined(SUNLIGHT_KILL)
color += sp * spec.rgb;
-#endif
}
+#else //PRODUCTION
+ float sa = dot(refnormpersp, light_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;
+ color.rgb += spec_contrib;
+#endif
+
}
- vec3 post_spec = color.rgb;
+ color.rgb = mix(color.rgb, diffuse.rgb, diffuse.a);
if (envIntensity > 0.0)
{ //add environmentmap
vec3 env_vec = env_mat * refnormpersp;
vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
-#if !defined(SUNLIGHT_KILL)
- color = mix(color.rgb, reflected_color, envIntensity*0.75); // MAGIC NUMBER SL-12574; ALM: On, Quality <= Mid+
-#endif
+ color = mix(color.rgb, reflected_color, envIntensity);
}
- else
- {
- color.rgb = mix(color.rgb, diffuse_srgb.rgb, diffuse_srgb.a);
- }
-
-vec3 post_env = color.rgb;
-
- if (norm.w < 1)
+
+ if (norm.w < 0.5)
{
-#if !defined(SUNLIGHT_KILL)
- color = atmosFragLighting(color, additive, atten);
- color = scaleSoftClipFrag(color);
-#endif
+ color = mix(atmosFragLighting(color, additive, atten), fullbrightAtmosTransportFrag(color, additive, atten), diffuse.a);
+ color = mix(scaleSoftClipFrag(color), fullbrightScaleSoftClip(color), diffuse.a);
}
-vec3 post_atmo = color.rgb;
-
#ifdef WATER_FOG
vec4 fogged = applyWaterFogView(pos.xyz,vec4(color, bloom));
color = fogged.rgb;
bloom = fogged.a;
#endif
-// srgb colorspace debuggables
-//color.rgb = amblit;
-//color.rgb = sunlit;
-//color.rgb = post_ambient;
-//color.rgb = sun_contrib;
-//color.rgb = post_sunlight;
-//color.rgb = diffuse_srgb.rgb;
-//color.rgb = post_diffuse;
-//color.rgb = post_spec;
-//color.rgb = post_env;
-//color.rgb = post_atmo;
-
}
// linear debuggables
//color.rgb = vec3(final_da);
//color.rgb = vec3(ambient);
//color.rgb = vec3(scol);
-//color.rgb = diffuse_linear.rgb;
+//color.rgb = diffuse_srgb.rgb;
// convert to linear as fullscreen lights need to sum in linear colorspace
// and will be gamma (re)corrected downstream...
diff --git a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
index b86867c4606..ceb4b8033d9 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
@@ -164,14 +164,15 @@ void main()
color.rgb += spec * specular;
- //color.rgb = atmosTransport(color.rgb);
+ color.rgb = atmosTransport(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
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(0); // speccolor, spec
- frag_data[2] = vec4(encode_normal(screenspacewavef.xyz*0.5+0.5), 0.0, 0);// normalxy, 0, 0
+ //frag_data[0] = color;
+ frag_data[0] = color;
+ frag_data[1] = vec4(0); // speccolor, spec
+ frag_data[2] = vec4(encode_normal(screenspacewavef.xyz), 0.05, 0);// normalxy, 0, 0
}
diff --git a/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl b/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl
index bbfec3b5320..e53bb461773 100644
--- a/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl
@@ -39,6 +39,8 @@ uniform sampler2D detail_2;
uniform sampler2D detail_3;
uniform sampler2D alpha_ramp;
+vec3 atmosLighting(vec3 light);
+
vec4 applyWaterFog(vec4 color);
void main()
@@ -55,10 +57,10 @@ void main()
float alpha2 = texture2D(alpha_ramp,vary_texcoord1.xy).a;
float alphaFinal = texture2D(alpha_ramp, vary_texcoord1.zw).a;
vec4 outColor = mix( mix(color3, color2, alpha2), mix(color1, color0, alpha1), alphaFinal );
-
- outColor.rgb *= vertex_color.rgb;
+
+ /// Add WL Components
+ outColor.rgb = atmosLighting(outColor.rgb * vertex_color.rgb);
+
outColor = applyWaterFog(outColor);
-
frag_color = outColor;
}
-
diff --git a/indra/newview/app_settings/shaders/class1/environment/waterF.glsl b/indra/newview/app_settings/shaders/class1/environment/waterF.glsl
index b3ae64bd82b..d1e6c7da1a8 100644
--- a/indra/newview/app_settings/shaders/class1/environment/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/environment/waterF.glsl
@@ -1,5 +1,5 @@
/**
- * @file class1/environment/waterF.glsl
+ * @file waterF.glsl
*
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
* Second Life Viewer Source Code
@@ -32,7 +32,7 @@ out vec4 frag_color;
vec3 scaleSoftClip(vec3 inColor);
vec3 atmosTransport(vec3 inColor);
-uniform sampler2D bumpMap;
+uniform sampler2D bumpMap;
uniform sampler2D bumpMap2;
uniform float blend_factor;
uniform sampler2D screenTex;
@@ -50,7 +50,7 @@ uniform vec3 normScale;
uniform float fresnelScale;
uniform float fresnelOffset;
uniform float blurMultiplier;
-uniform int water_edge;
+
//bigWave is (refCoord.w, view.w);
VARYING vec4 refCoord;
@@ -59,27 +59,27 @@ VARYING vec4 view;
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));
+ vec3 n = 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
+ vec4 color;
+
+ float dist = length(view.xy);
+
+ //normalize view vector
+ vec3 viewVec = normalize(view.xyz);
+
+ //get wave normals
+ //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;
@@ -88,80 +88,81 @@ void main()
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;
- df1 *= 0.666666f;
- refcol *= df1;
-
- 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*0.16/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 and nvidia compiler bug
- color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.9999999);
- color.rgb += spec * specular;
-
- color.a = spec * sunAngle2;
-
- //color.rgb = atmosTransport(color.rgb);
+
+ //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 and nvidia compiler bug
+ color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.99999);
+ color.rgb += spec * specular;
+
+ color.rgb = atmosTransport(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
+ color.a = spec * sunAngle2;
+
+ frag_color = color;
#if defined(WATER_EDGE)
gl_FragDepth = 0.9999847f;
#endif
-
- frag_color = color;
+
}
+
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
index 9c7a4df7674..0658b3ede53 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
@@ -63,6 +63,8 @@ void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, ou
float getAmbientClamp();
vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
vec3 scaleSoftClipFrag(vec3 l);
+vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
+vec3 fullbrightScaleSoftClip(vec3 light);
vec3 linear_to_srgb(vec3 c);
vec3 srgb_to_linear(vec3 c);
@@ -162,6 +164,8 @@ vec3 post_diffuse = color.rgb;
vec3 post_spec = color.rgb;
+ color.rgb = mix(color.rgb, diffuse_srgb.rgb, diffuse_srgb.a);
+
if (envIntensity > 0.0)
{ //add environmentmap
vec3 env_vec = env_mat * refnormpersp;
@@ -170,19 +174,15 @@ vec3 post_diffuse = color.rgb;
color = mix(color.rgb, reflected_color, envIntensity*0.75); // MAGIC NUMBER SL-12574; ALM: On, Quality >= High
#endif
}
- else
- {
- color.rgb = mix(color.rgb, diffuse_srgb.rgb, diffuse_srgb.a);
- }
vec3 post_env = color.rgb;
- if (norm.w < 1)
+ if (norm.w < 0.5)
{
#if !defined(SUNLIGHT_KILL)
vec3 p = normalize(pos.xyz);
- color = atmosFragLighting(color, additive, atten);
- color = scaleSoftClipFrag(color);
+ color = mix(atmosFragLighting(color, additive, atten), fullbrightAtmosTransportFrag(color, additive, atten), diffuse_srgb.a);
+ color = mix(scaleSoftClipFrag(color), fullbrightScaleSoftClip(color), diffuse_srgb.a);
#endif
}
diff --git a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl
index a4bd0d566ba..445d7c63521 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl
@@ -32,20 +32,124 @@ void setPositionEye(vec3 v);
vec3 getAdditiveColor();
-void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten, bool use_ao);
+//VARYING vec4 vary_CloudUVs;
+//VARYING float vary_CloudDensity;
+
+// Inputs
+uniform vec4 morphFactor;
+uniform vec3 camPosLocal;
+//uniform vec4 camPosWorld;
+
+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 distance_multiplier;
+uniform float max_y;
+uniform vec4 glow;
void calcAtmospherics(vec3 inPositionEye) {
+
+ vec3 P = inPositionEye;
+ setPositionEye(P);
+
+ //(TERRAIN) limit altitude
+ if (P.y > max_y) P *= (max_y / P.y);
+ if (P.y < -max_y) P *= (-max_y / 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 + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
+ //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);
+ blue_weight = blue_density / temp1;
+ haze_weight = vec4(haze_density) / 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;
+
+ // Transparency (-> temp1)
+ // ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier in a variable because the ati
+ // compiler gets confused.
+ temp1 = exp(-temp1 * temp2.z * distance_multiplier);
+
+ //final atmosphere attenuation factor
+ setAtmosAttenuation(temp1.rgb);
+ //vary_AtmosAttenuation = distance_multiplier / 10000.;
+ //vary_AtmosAttenuation = density_multiplier * 100.;
+ //vary_AtmosAttenuation = vec4(Plen / 100000., 0., 0., 1.);
+
+ //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 + (vec4(1.) - ambient) * cloud_shadow * 0.5;
+
+ //haze color
+ setAdditiveColor(
+ vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow) + tmpAmbient)
+ + (haze_horizon * haze_weight) * (sunlight*(1.-cloud_shadow) * temp2.x
+ + tmpAmbient)));
+
+ //brightness of surface both sunlight and ambient
+ setSunlitColor(vec3(sunlight * .5));
+ setAmblitColor(vec3(tmpAmbient * .25));
+ setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
+
+ // vary_SunlitColor = vec3(0);
+ // vary_AmblitColor = vec3(0);
+ // vary_AdditiveColor = vec4(Pn, 1.0);
+
+ /*
+ const float cloudShadowScale = 100.;
+ // Get cloud uvs for shadowing
+ vec3 cloudPos = inPositionEye + camPosWorld - cloudShadowScale / 2.;
+ vary_CloudUVs.xy = cloudPos.xz / cloudShadowScale;
+
+ // We can take uv1 and multiply it by (TerrainSpan / CloudSpan)
+// cloudUVs *= (((worldMaxZ - worldMinZ) * 20) /40000.);
+ vary_CloudUVs *= (10000./40000.);
- vec3 P = inPositionEye;
- setPositionEye(P);
- vec3 tmpsunlit = vec3(1);
- vec3 tmpamblit = vec3(1);
- vec3 tmpaddlit = vec3(1);
- vec3 tmpattenlit = vec3(1);
- calcAtmosphericVars(inPositionEye, vec3(0), 1, tmpsunlit, tmpamblit, tmpaddlit, tmpattenlit, false);
- setSunlitColor(tmpsunlit);
- setAmblitColor(tmpamblit);
- setAdditiveColor(tmpaddlit);
- setAtmosAttenuation(tmpattenlit);
+ // Offset by sun vector * (CloudAltitude / CloudSpan)
+ vary_CloudUVs.x += tmpLightnorm.x / tmpLightnorm.y * (3000./40000.);
+ vary_CloudUVs.y += tmpLightnorm.z / tmpLightnorm.y * (3000./40000.);
+ */
}
diff --git a/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl b/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
index f69d36f7158..b0cf9b00029 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
@@ -34,14 +34,9 @@ uniform int no_atmo;
vec3 atmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
{
- if (no_atmo == 1)
- {
- return light * 2.0;
- }
- // fullbright responds minimally to atmos scatter effects
- light *= min(15.0 * atten.r, 1.0);
- light += (0.1 * additive);
- return light * 2.0;
+ light *= atten.r;
+ light += additive * 2.0;
+ return light;
}
vec3 atmosTransport(vec3 light)
@@ -52,7 +47,7 @@ vec3 atmosTransport(vec3 light)
vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
{
float brightness = dot(light.rgb * 0.5, vec3(0.3333)) + 0.1;
- return atmosTransportFrag(light * 0.5, additive * brightness, atten);
+ return mix(atmosTransport(light.rgb), light.rgb + additive, brightness * brightness);
}
vec3 fullbrightAtmosTransport(vec3 light)
@@ -62,6 +57,6 @@ vec3 fullbrightAtmosTransport(vec3 light)
vec3 fullbrightShinyAtmosTransport(vec3 light)
{
- float brightness = dot(light.rgb * 0.5, vec3(0.33333)) + 0.1;
- return atmosTransportFrag(light * 0.5, getAdditiveColor() * (brightness * brightness), getAtmosAttenuation());
+ float brightness = dot(light.rgb, vec3(0.33333));
+ return mix(atmosTransport(light.rgb), (light.rgb + getAdditiveColor().rgb) * (2.0 - brightness), brightness * brightness);
}
--
GitLab