WIP - Make EEP match production.
Runitai Linden
parent
8c1b9d3e7a
commit
3e472948db
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
norm.xyz = norm.xyz * 2 - 1;
|
||||
|
||||
// convert sampled normal to tangent space normal
|
||||
norm = vec3(dot(norm, vary_mat0),
|
||||
dot(norm, vary_mat1),
|
||||
dot(norm, vary_mat2));
|
||||
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);
|
||||
norm.xyz = normalize(tnorm.xyz);
|
||||
|
||||
vec2 abnormal = encode_normal(norm);
|
||||
vec2 abnormal = encode_normal(norm.xyz);
|
||||
|
||||
vec4 final_color = vec4(diffuse_linear.rgb, 0.0);
|
||||
vec4 final_color = diffcol;
|
||||
|
||||
#if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_EMISSIVE)
|
||||
final_color.a = diffuse_linear.a * 0.5; // SL-12171
|
||||
#endif
|
||||
|
||||
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;
|
||||
|
||||
#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,131 +300,131 @@ void main()
|
|||
|
||||
calcAtmosphericVars(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
|
||||
|
||||
if (emissive_brightness >= 1.0) // fullbright, skip lighting calculations
|
||||
|
||||
vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
|
||||
|
||||
//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);
|
||||
|
||||
color = amblit;
|
||||
|
||||
//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;
|
||||
|
||||
color *= ambient;
|
||||
|
||||
color += sun_contrib;
|
||||
|
||||
color *= gamma_diff.rgb;
|
||||
|
||||
float glare = 0.0;
|
||||
|
||||
if (spec.a > 0.0) // specular reflection
|
||||
{
|
||||
color = fullbrightAtmosTransportFrag(diffuse_srgb.rgb, additive, atten);
|
||||
color = fullbrightScaleSoftClip(color);
|
||||
#if 1 //EEP
|
||||
|
||||
al = diffuse_srgb.a;
|
||||
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
|
||||
}
|
||||
else // not fullbright, calculate lighting
|
||||
|
||||
color = mix(color.rgb, diffcol.rgb, diffuse.a);
|
||||
|
||||
if (envIntensity > 0.0)
|
||||
{
|
||||
vec3 refnormpersp = normalize(reflect(pos.xyz, norm));
|
||||
//add environmentmap
|
||||
vec3 env_vec = env_mat * refnormpersp;
|
||||
|
||||
//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);
|
||||
vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
|
||||
|
||||
//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);
|
||||
color = mix(color, reflected_color, envIntensity);
|
||||
|
||||
vec3 sun_contrib = min(da, shadow) * sunlit;
|
||||
|
||||
#if !defined(AMBIENT_KILL)
|
||||
color = amblit;
|
||||
color *= ambient;
|
||||
#endif
|
||||
|
||||
#if !defined(SUNLIGHT_KILL)
|
||||
color += sun_contrib;
|
||||
#endif
|
||||
color *= diffuse_srgb.rgb;
|
||||
|
||||
float glare = 0.0;
|
||||
|
||||
if (spec.a > 0.0) // specular reflection
|
||||
{
|
||||
vec3 npos = -normalize(pos.xyz);
|
||||
|
||||
//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;
|
||||
|
||||
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;
|
||||
#if !defined(SUNLIGHT_KILL)
|
||||
color += sp * spec.rgb;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
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, 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;
|
||||
}
|
||||
|
||||
color = atmosFragLighting(color, additive, atten);
|
||||
color = scaleSoftClipFrag(color);
|
||||
|
||||
vec3 npos = normalize(-pos.xyz);
|
||||
|
||||
vec3 light = vec3(0, 0, 0);
|
||||
|
||||
//convert to linear before adding local lights
|
||||
color = srgb_to_linear(color);
|
||||
|
||||
#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 );
|
||||
|
||||
LIGHT_LOOP(1)
|
||||
LIGHT_LOOP(2)
|
||||
LIGHT_LOOP(3)
|
||||
LIGHT_LOOP(4)
|
||||
LIGHT_LOOP(5)
|
||||
LIGHT_LOOP(6)
|
||||
LIGHT_LOOP(7)
|
||||
|
||||
glare = min(glare, 1.0);
|
||||
al = max(diffuse_linear.a, glare)*vertex_color.a;
|
||||
|
||||
#if !defined(LOCAL_LIGHT_KILL)
|
||||
color += light;
|
||||
#endif
|
||||
|
||||
//convert to srgb as this color is being written post gamma correction
|
||||
color = linear_to_srgb(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;
|
||||
}
|
||||
|
||||
color = atmosFragLighting(color, additive, atten);
|
||||
color = scaleSoftClipFrag(color);
|
||||
|
||||
//convert to linear before adding local lights
|
||||
color = srgb_to_linear(color);
|
||||
|
||||
vec3 npos = normalize(-pos.xyz);
|
||||
|
||||
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 );
|
||||
|
||||
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));
|
||||
color = temp.rgb;
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
color.rgb *= ambient;
|
||||
|
||||
vec3 sun_contrib = da * sunlit;
|
||||
|
||||
#if !defined(AMBIENT_KILL)
|
||||
color.rgb = amblit;
|
||||
color.rgb *= ambient;
|
||||
#endif
|
||||
|
||||
vec3 post_ambient = color.rgb;
|
||||
|
||||
#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
|
||||
|
||||
if (norm.w < 0.5)
|
||||
{
|
||||
color.rgb = mix(color.rgb, diffuse_srgb.rgb, diffuse_srgb.a);
|
||||
color = mix(atmosFragLighting(color, additive, atten), fullbrightAtmosTransportFrag(color, additive, atten), diffuse.a);
|
||||
color = mix(scaleSoftClipFrag(color), fullbrightScaleSoftClip(color), diffuse.a);
|
||||
}
|
||||
|
||||
vec3 post_env = color.rgb;
|
||||
|
||||
if (norm.w < 1)
|
||||
{
|
||||
#if !defined(SUNLIGHT_KILL)
|
||||
color = atmosFragLighting(color, additive, atten);
|
||||
color = scaleSoftClipFrag(color);
|
||||
#endif
|
||||
}
|
||||
|
||||
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...
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 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);
|
||||
|
||||
//get specular component
|
||||
float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
|
||||
|
||||
//harden specular
|
||||
spec = pow(spec, 128.0);
|
||||
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);
|
||||
|
||||
//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;
|
||||
//get specular component
|
||||
float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
|
||||
|
||||
//harden specular
|
||||
spec = pow(spec, 128.0);
|
||||
|
||||
color.a = spec * sunAngle2;
|
||||
|
||||
//color.rgb = atmosTransport(color.rgb);
|
||||
//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;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 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);
|
||||
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.);
|
||||
|
||||
// Offset by sun vector * (CloudAltitude / CloudSpan)
|
||||
vary_CloudUVs.x += tmpLightnorm.x / tmpLightnorm.y * (3000./40000.);
|
||||
vary_CloudUVs.y += tmpLightnorm.z / tmpLightnorm.y * (3000./40000.);
|
||||
*/
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue