1// -*-C++-*- 2#version 120 3 4// written by Thorsten Renk, Oct 2011, based on default.frag 5// Ambient term comes in gl_Color.rgb. 6varying vec4 diffuse_term; 7varying vec3 normal; 8varying vec3 relPos; 9varying vec2 rawPos; 10varying vec3 worldPos; 11varying vec3 ecViewdir; 12 13 14 15varying float steepness; 16varying vec2 grad_dir; 17 18varying float flogz; 19 20 21uniform float fg_Fcoef; 22 23uniform float visibility; 24uniform float avisibility; 25uniform float scattering; 26uniform float terminator; 27uniform float terrain_alt; 28uniform float hazeLayerAltitude; 29uniform float overcast; 30uniform float eye_alt; 31uniform float snowlevel; 32uniform float dust_cover_factor; 33uniform float lichen_cover_factor; 34uniform float wetness; 35uniform float fogstructure; 36uniform float snow_thickness_factor; 37uniform float cloud_self_shading; 38uniform float contrast; 39uniform float air_pollution; 40uniform float intrinsic_wetness; 41uniform float transition_model; 42uniform float overlay_bias; 43uniform float crack_depth; 44uniform float crack_pattern_stretch; 45uniform float grain_fade_power; 46uniform float rock_brightness; 47uniform float overlay_alpha; 48uniform float dust_resistance; 49uniform float slopeline_strength; 50uniform float landing_light1_offset; 51uniform float landing_light2_offset; 52uniform float landing_light3_offset; 53uniform float osg_SimulationTime; 54 55uniform vec3 base_color; 56uniform vec3 overlay_color; 57 58uniform int wind_effects; 59uniform int cloud_shadow_flag; 60uniform int rock_strata; 61uniform int use_searchlight; 62uniform int use_landing_light; 63uniform int use_alt_landing_light; 64 65const float EarthRadius = 5800000.0; 66const float terminator_width = 200000.0; 67 68float alt; 69float eShade; 70float yprime_alt; 71float mie_angle; 72 73float shadow_func (in float x, in float y, in float noise, in float dist); 74float Noise2D(in vec2 coord, in float wavelength); 75float Noise3D(in vec3 coord, in float wavelength); 76float VoronoiNoise2D(in vec2 coord, in float wavelength, in float xrand, in float yrand); 77float SlopeLines2D(in vec2 coord, in vec2 gradDir, in float wavelength, in float steepness); 78float Strata3D(in vec3 coord, in float wavelength, in float variation); 79float fog_func (in float targ, in float alt); 80float rayleigh_in_func(in float dist, in float air_pollution, in float avisibility, in float eye_alt, in float vertex_alt); 81float alt_factor(in float eye_alt, in float vertex_alt); 82float light_distance_fading(in float dist); 83float fog_backscatter(in float avisibility); 84 85vec3 rayleigh_out_shift(in vec3 color, in float outscatter); 86vec3 get_hazeColor(in float light_arg); 87vec3 searchlight(); 88vec3 landing_light(in float offset, in float offsetv); 89vec3 filter_combined (in vec3 color) ; 90 91float light_func (in float x, in float a, in float b, in float c, in float d, in float e) 92{ 93x = x - 0.5; 94 95// use the asymptotics to shorten computations 96if (x > 30.0) {return e;} 97if (x < -15.0) {return 0.0;} 98 99return e / pow((1.0 + a * exp(-b * (x-c)) ),(1.0/d)); 100} 101 102 103// a fade function for procedural scales which are smaller than a pixel 104 105float detail_fade (in float scale, in float angle, in float dist) 106{ 107float fade_dist = 2000.0 * scale * angle/max(pow(steepness,4.0), 0.1); 108 109return 1.0 - smoothstep(0.5 * fade_dist, fade_dist, dist); 110} 111 112 113 114void main() 115{ 116 117 118yprime_alt = diffuse_term.a; 119//diffuse_term.a = 1.0; 120mie_angle = gl_Color.a; 121float effective_scattering = min(scattering, cloud_self_shading); 122 123// distance to fragment 124float dist = length(relPos); 125// angle of view vector with horizon 126float ct = dot(vec3(0.0, 0.0, 1.0), relPos)/dist; 127// float altitude of fragment above sea level 128float msl_altitude = (relPos.z + eye_alt); 129 130 131 vec3 shadedFogColor = vec3(0.55, 0.67, 0.88); 132// this is taken from default.frag 133 vec3 n; 134 float NdotL, NdotHV, fogFactor; 135 vec4 color = gl_Color; 136 color.a = 1.0; 137 vec3 lightDir = gl_LightSource[0].position.xyz; 138 vec3 halfVector = normalize(normalize(lightDir) + normalize(ecViewdir)); 139 vec4 texel; 140 vec4 snow_texel; 141 vec4 detail_texel; 142 vec4 mix_texel; 143 vec4 grain_texel; 144 vec4 dot_texel; 145 vec4 gradient_texel; 146 vec4 foam_texel; 147 vec4 fragColor; 148 vec4 specular = vec4(0.0); 149 float intensity; 150 151 152 153// Perlin noise 154 155float noise_100m = Noise2D(rawPos.xy,100.0); 156float noise_50m = Noise2D(rawPos.xy, 50.0); 157float noise_25m = Noise2D(rawPos.xy, 25.0); 158float noise_10m = Noise2D(rawPos.xy, 10.0); 159float noise_5m = Noise2D(rawPos.xy ,5.0); 160float noise_2m = Noise2D(rawPos.xy ,2.0); 161float noise_1m = Noise2D(rawPos.xy ,1.0); 162float noise_05m = Noise2D(rawPos.xy,0.5); 163float noise_02m = Noise2D(rawPos.xy,0.2); 164float noise_01m = Noise2D(rawPos.xy, 0.1); 165 166float noisegrad_10m; 167float noisegrad_5m; 168float noisegrad_2m; 169float noisegrad_1m; 170float noisegrad_05m; 171float noisegrad_02m; 172float noisegrad_01m; 173 174 175 176 177 178float noise_250m = Noise3D(worldPos.xyz,250.0); 179float noise_500m = Noise3D(worldPos.xyz, 500.0); 180float noise_1500m = Noise3D(worldPos.xyz, 1500.0); 181float noise_2000m = Noise3D(worldPos.xyz, 2000.0); 182 183// dot noise 184 185float dotnoise_2m = 0.0; 186float dotnoise_10m = 0.0; 187float dotnoise_15m = 0.0; 188 189float dotnoisegrad_10m; 190 191// slope noise 192 193float slopenoise_50m = SlopeLines2D(rawPos, grad_dir, 50.0, steepness); 194float slopenoise_100m = SlopeLines2D(rawPos, grad_dir, 100.0, steepness); 195 196float snownoise_25m = mix(noise_25m, slopenoise_50m, clamp(3.0*(1.0-steepness),0.0,1.0)); 197float snownoise_50m = mix(noise_50m, slopenoise_100m, clamp(3.0*(1.0-steepness),0.0,1.0)); 198 199 200 201 202 203// get the texels 204 205 float noise_term; 206 float snow_alpha; 207 float local_autumn_factor; 208 209 // we need to fade procedural structures when they get smaller than a single pixel, for this we need 210 // to know under what angle we see the surface 211 212 float view_angle = abs(dot(normalize(normal), normalize(ecViewdir))); 213 214 215 // the snow texel is generated procedurally 216 if (msl_altitude +500.0 > snowlevel) 217 { 218 snow_texel = vec4 (0.95, 0.95, 0.95, 1.0) * (0.9 + 0.1* noise_500m + 0.1* (1.0 - noise_10m) ); 219 snow_texel.r = snow_texel.r * (0.9 + 0.05 * (noise_10m + noise_5m)); 220 snow_texel.g = snow_texel.g * (0.9 + 0.05 * (noise_10m + noise_5m)); 221 snow_texel.a = 1.0; 222 noise_term = 0.1 * (noise_500m-0.5) ; 223 noise_term = noise_term + 0.2 * (snownoise_50m -0.5) * detail_fade(50.0, view_angle, 0.5*dist) ; 224 noise_term = noise_term + 0.2 * (snownoise_25m -0.5) * detail_fade(25.0, view_angle, 0.5*dist) ; 225 noise_term = noise_term + 0.3 * (noise_10m -0.5) * detail_fade(10.0, view_angle, 0.8*dist) ; 226 noise_term = noise_term + 0.3 * (noise_5m - 0.5) * detail_fade(5.0, view_angle, dist); 227 noise_term = noise_term + 0.15 * (noise_2m -0.5) * detail_fade(2.0, view_angle, dist); 228 noise_term = noise_term + 0.08 * (noise_1m -0.5) * detail_fade(1.0, view_angle, dist); 229 snow_texel.a = snow_texel.a * 0.2+0.8* smoothstep(0.2,0.8, 0.3 +noise_term + snow_thickness_factor +0.0001*(msl_altitude -snowlevel) ); 230 } 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 // strata noise 246 247 float stratnoise_50m; 248 float stratnoise_10m; 249 250 if (rock_strata==1) 251 { 252 stratnoise_50m = Strata3D(vec3 (rawPos.x, rawPos.y, msl_altitude), 50.0, 0.2); 253 stratnoise_10m = Strata3D(vec3 (rawPos.x, rawPos.y, msl_altitude), 10.0, 0.2); 254 stratnoise_50m = mix(stratnoise_50m, 1.0, smoothstep(0.8,0.9, steepness)); 255 stratnoise_10m = mix(stratnoise_10m, 1.0, smoothstep(0.8,0.9, steepness)); 256 texel *= (0.4 + 0.4 * stratnoise_50m + 0.2 * stratnoise_10m); 257 } 258 259 260 261 262 263 264 265 // procedural rock texture generation 266 267 texel.rgb = base_color; 268 269 // use powers of Perlin noise to generate the base pattern 270 271 float grainy_noise; 272 float fade_norm; 273 274 float gfp = grain_fade_power; 275 float gfptmp; 276 277 grainy_noise = (0.5 * (1.0-slopenoise_100m) + 0.5 *noise_50m) + gfp * (0.5 * slopenoise_50m + 0.5 * noise_25m); 278 fade_norm = 1.0+gfp; 279 280 gfptmp = gfp * gfp; 281 grainy_noise += noise_10m * gfptmp * detail_fade(10.0, view_angle, dist) ; 282 fade_norm += gfptmp * detail_fade(10.0, view_angle, dist) ; 283 284 gfptmp = gfptmp * gfp; 285 grainy_noise += noise_5m * gfptmp * detail_fade(5.0, view_angle, dist) ; 286 fade_norm += gfptmp * detail_fade(5.0, view_angle, dist) ; 287 288 gfptmp = gfptmp * gfp; 289 grainy_noise += noise_2m * gfptmp * detail_fade(2.0, view_angle, dist) ; 290 fade_norm += gfptmp * detail_fade(2.0, view_angle, dist) ; 291 292 gfptmp = gfptmp * gfp; 293 grainy_noise += noise_1m * gfptmp * detail_fade(1.0, view_angle, dist) ; 294 fade_norm += gfptmp * detail_fade(1.0, view_angle, dist) ; 295 296 gfptmp = gfptmp * gfp; 297 grainy_noise += noise_05m * gfptmp * detail_fade(0.5, view_angle, dist) ; 298 fade_norm += gfptmp * detail_fade(0.5, view_angle, dist) ; 299 300 grainy_noise = grainy_noise/fade_norm; 301 grainy_noise = smoothstep(-0.2, 1.2, grainy_noise); 302 303 // generate the crack pattern from isovalue lines of stretched Perlin noise 304 305 float cnoise_500m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 500.0); 306 float cnoise_250m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 250.0); 307 float cnoise_100m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 100.0); 308 float cnoise_50m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 50.0); 309 float cnoise_25m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 25.0); 310 float cnoise_10m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 10.0); 311 float cnoise_5m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 5.0); 312 float cnoise_2m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 2.0); 313 float cnoise_1m = Noise2D(vec2(rawPos.x+10.0, crack_pattern_stretch * rawPos.y), 1.0); 314 315 float crack_noise; 316 float crack_factor; 317 float crack_size; 318 float scrack_noise; 319 float scrack_size; 320 321 crack_noise = cnoise_500m + 0.65 * cnoise_250m + 0.42 * cnoise_100m * detail_fade(50.0, view_angle, dist) ; 322 crack_noise = crack_noise + 0.27 * cnoise_50m * detail_fade(25.0, view_angle, dist) ; 323 crack_noise = crack_noise + 0.17 * cnoise_25m * detail_fade(10.0, view_angle, dist) ; 324 crack_noise = crack_noise + 0.11 * cnoise_10m * detail_fade(5.0, view_angle, dist) ; 325 crack_noise = 0.381 * crack_noise; 326 327 328 329 scrack_noise = cnoise_10m + 0.65 * cnoise_5m * detail_fade(5.0, view_angle, dist); 330 scrack_noise = scrack_noise + 0.3 * cnoise_2m + 0.1 * cnoise_1m * detail_fade(1.0, view_angle, dist); 331 scrack_noise = 0.48 * scrack_noise; 332 333 crack_size = 0.02 +0.00001 * dist; 334 crack_factor = smoothstep(0.5-crack_size,0.50,crack_noise) * (1.0-smoothstep(0.51,0.51+crack_size,crack_noise)); 335 //crack_factor = step(0.5-0.2*crack_size,crack_noise) * (1.0-step(0.5+0.2*crack_size,crack_noise)); 336 337 crack_size *= 0.5; 338 crack_factor += smoothstep(0.42,0.42+crack_size,crack_noise) * (1.0-smoothstep(0.43,0.43+crack_size,crack_noise)); 339 340 scrack_size = crack_size * 4.0; 341 crack_factor += 0.75 * smoothstep(0.5-scrack_size,0.50,scrack_noise) * (1.0-smoothstep(0.51,0.51+scrack_size,scrack_noise))* (1.0- smoothstep(250.0,1000.0,dist)); 342 343 344 crack_factor = crack_factor * min(1.0,0.03/crack_size); 345 346 347 348// distribution of overlay color 349 350 351 float overlay_noise; 352 float overlay_factor; 353 354 overlay_noise = 0.381 * (noise_50m + 0.65 * noise_25m + 0.42 * noise_10m + 0.27 * noise_5m + 0.17 * noise_2m + 0.11 * noise_1m); 355 overlay_noise = overlay_noise + 0.1 * (smoothstep(0.8,0.9, steepness)); 356 357 overlay_factor = smoothstep(0.7, 0.72, overlay_noise + overlay_bias) + (1.0 - smoothstep(0.2, 0.22, overlay_noise - overlay_bias)); 358 359 360 361// merge the noise components 362 363 //grainy_noise = grainy_noise * (1.0-crack_depth * crack_factor) + 0.5 * crack_depth * crack_factor; 364 texel.rgb = ((1.0 - contrast) + contrast * grainy_noise ) * texel.rgb; 365 texel.rgb = mix(texel.rgb, overlay_color.rgb,overlay_alpha * overlay_factor); 366 texel.rgb = texel.rgb * ((1.0-crack_depth) +crack_depth*(1.0-crack_factor * (0.5 + 0.5 * noise_50m) )); 367 368 texel.rgb = texel.rgb * rock_brightness; 369 370 texel.rgb = texel.rgb * (1.0 + 0.4 * (noise_01m-0.5) * detail_fade(0.1, view_angle, dist)) ; 371 372 373const vec4 dust_color = vec4 (0.76, 0.65, 0.45, 1.0); 374const vec4 lichen_color = vec4 (0.17, 0.20, 0.06, 1.0); 375 376// mix vegetation 377float gradient_factor = smoothstep(0.5, 1.0, steepness); 378texel = mix(texel, lichen_color, gradient_factor * (0.4 * lichen_cover_factor + 0.8 * lichen_cover_factor * 0.5 * (noise_10m + (1.0 - noise_5m))) ); 379// mix dust 380texel = mix(texel, dust_color, clamp(0.5 * dust_cover_factor *dust_resistance + 3.0 * dust_cover_factor * dust_resistance *(((noise_1500m - 0.5) * 0.125)+0.125 ) - 0.03*slopenoise_100m,0.0, 1.0) ); 381// mix snow 382float snow_mix_factor = 0.0; 383if (msl_altitude +500.0 > snowlevel) 384 { 385 386 snow_alpha = smoothstep(0.65, 0.85, abs(steepness)); 387 snow_alpha += (1.0 - snow_alpha) * crack_factor; 388 389 snow_mix_factor = snow_texel.a* smoothstep(snowlevel, snowlevel+200.0, snow_alpha * msl_altitude + (noise_2000m + 0.1 * noise_10m -0.55) *400.0); 390 texel = mix(texel, snow_texel, snow_mix_factor); 391 } 392 393 394 395 396// get distribution of water when terrain is wet 397 398float combined_wetness = min(1.0, wetness + intrinsic_wetness); 399float water_threshold1; 400float water_threshold2; 401float water_factor =0.0; 402 403 404if ((dist < 5000.0) && (combined_wetness>0.0)) 405 { 406 water_threshold1 = 1.0-0.5* combined_wetness; 407 water_threshold2 = 1.0 - 0.3 * combined_wetness; 408 water_factor = smoothstep(water_threshold1, water_threshold2 , (0.3 * (2.0 * (1.0-noise_10m) + (1.0 -noise_5m)) * (1.0 - smoothstep(2000.0, 5000.0, dist))) - 5.0 * (1.0 -steepness)); 409 } 410 411// darken wet terrain 412 413 texel.rgb = texel.rgb * (1.0 - 0.6 * combined_wetness); 414 415 416 417// light computations 418 419 420 vec4 light_specular = gl_LightSource[0].specular; 421 422 // If gl_Color.a == 0, this is a back-facing polygon and the 423 // normal should be reversed. 424 //n = (2.0 * gl_Color.a - 1.0) * normal; 425 n = normal; 426 n = normalize(n); 427 428 NdotL = dot(n, lightDir); 429 430 noisegrad_10m = (noise_10m - Noise2D(rawPos.xy+ 0.05 * normalize(lightDir.xy),10.0))/0.05; 431 noisegrad_5m = (noise_5m - Noise2D(rawPos.xy+ 0.05 * normalize(lightDir.xy),5.0))/0.05; 432 noisegrad_2m = (noise_2m - Noise2D(rawPos.xy+ 0.05 * normalize(lightDir.xy),2.0))/0.05; 433 noisegrad_1m = (noise_1m - Noise2D(rawPos.xy+ 0.05 * normalize(lightDir.xy),1.0))/0.05; 434 noisegrad_05m = (noise_05m - Noise2D(rawPos.xy+ 0.05 * normalize(lightDir.xy),0.5))/0.05; 435 436 437 dotnoisegrad_10m = 0.0;//(dotnoise_10m - DotNoise2D(rawPos.xy+ 0.05 * normalize(lightDir.xy),10.0 * dot_size,0.5, 0.0))/0.05; 438 439 440 //NdotL = NdotL + (noisegrad_10m * detail_fade(10.0, view_angle,dist) + 0.8* noisegrad_5m * detail_fade(5.0, view_angle,dist)); 441 //NdotL = NdotL + 0.4 * noisegrad_2m * detail_fade(2.0,view_angle,dist); 442 //NdotL = NdotL + 0.2 * noisegrad_2m * detail_fade(2.0,view_angle,dist); 443 //NdotL = NdotL + 0.05 * noisegrad_1m * detail_fade(1.0, view_angle,dist); 444 //NdotL = NdotL + 0.02 * noisegrad_05m * detail_fade(0.5, view_angle,dist); 445 446 //NdotL = NdotL + (1.0-snow_mix_factor) * 0.3* dot_texel.a * (0.5* dotnoisegrad_10m * detail_fade(1.0 * dot_size, view_angle, dist) +0.5 * dotnoisegrad_10m * noise_01m * detail_fade(0.1, view_angle, dist)) ; 447 //NdotL = NdotL + 0.2 * grainy_noise; 448 449 float snow_factor; 450 float fresnel; 451 452 if (NdotL > 0.0) { 453 if (cloud_shadow_flag == 1) {NdotL = NdotL * shadow_func(relPos.x, relPos.y, 0.3 * noise_250m + 0.5 * noise_500m+0.2 * noise_1500m, dist);} 454 color += diffuse_term * NdotL; 455 NdotHV = max(dot(n, halfVector), 0.0); 456 457 fresnel = 1.0 + 5.0 * (1.0-smoothstep(0.0,0.2, dot(normalize(ecViewdir),n))); 458 snow_factor = 0.2 * smoothstep(0.7,0.9,snow_mix_factor) * fresnel; 459 460 //if (gl_FrontMaterial.shininess > 0.0) 461 specular.rgb = ((gl_FrontMaterial.specular.rgb * 0.1 + snow_factor * vec3(1.0,1.0,1.0) + (water_factor * vec3 (1.0, 1.0, 1.0))) 462 * light_specular.rgb 463 * pow(NdotHV, max(gl_FrontMaterial.shininess,4.0) + (20.0 * water_factor))); 464 } 465 color.a = 1.0;//diffuse_term.a; 466 // This shouldn't be necessary, but our lighting becomes very 467 // saturated. Clamping the color before modulating by the texture 468 // is closer to what the OpenGL fixed function pipeline does. 469 color = clamp(color, 0.0, 1.0); 470 471 vec3 secondary_light = vec3 (0.0,0.0,0.0); 472 473 if (use_searchlight == 1) 474 { 475 secondary_light += searchlight(); 476 } 477 if (use_landing_light == 1) 478 { 479 secondary_light += landing_light(landing_light1_offset, landing_light3_offset); 480 } 481 if (use_alt_landing_light == 1) 482 { 483 secondary_light += landing_light(landing_light2_offset, landing_light3_offset); 484 } 485 color.rgb +=secondary_light * light_distance_fading(dist); 486 487 488 fragColor = color * texel + specular; 489 490float lightArg = (terminator-yprime_alt)/100000.0; 491vec3 hazeColor = get_hazeColor(lightArg); 492 493 494 495// Rayleigh color shift due to out-scattering 496 float rayleigh_length = 0.5 * avisibility * (2.5 - 1.9 * air_pollution)/alt_factor(eye_alt, eye_alt+relPos.z); 497 float outscatter = 1.0-exp(-dist/rayleigh_length); 498 fragColor.rgb = rayleigh_out_shift(fragColor.rgb,outscatter); 499 500// Rayleigh color shift due to in-scattering 501 502 float rShade = 1.0 - 0.9 * smoothstep(-terminator_width+ terminator, terminator_width + terminator, yprime_alt + 420000.0); 503 float lightIntensity = length(hazeColor * effective_scattering) * rShade; 504 vec3 rayleighColor = vec3 (0.17, 0.52, 0.87) * lightIntensity; 505 float rayleighStrength = rayleigh_in_func(dist, air_pollution, avisibility/max(lightIntensity,0.05), eye_alt, eye_alt + relPos.z); 506 fragColor.rgb = mix(fragColor.rgb, rayleighColor,rayleighStrength); 507 508 509// here comes the terrain haze model 510 511 512float delta_z = hazeLayerAltitude - eye_alt; 513 514float mvisibility = min(visibility,avisibility); 515 516if (dist > 0.04 * mvisibility) 517 518{ 519 520alt = eye_alt; 521 522 523float transmission; 524float vAltitude; 525float delta_zv; 526float H; 527float distance_in_layer; 528float transmission_arg; 529 530 531 532 533// we solve the geometry what part of the light path is attenuated normally and what is through the haze layer 534 535if (delta_z > 0.0) // we're inside the layer 536 { 537 if (ct < 0.0) // we look down 538 { 539 distance_in_layer = dist; 540 vAltitude = min(distance_in_layer,mvisibility) * ct; 541 delta_zv = delta_z - vAltitude; 542 } 543 else // we may look through upper layer edge 544 { 545 H = dist * ct; 546 if (H > delta_z) {distance_in_layer = dist/H * delta_z;} 547 else {distance_in_layer = dist;} 548 vAltitude = min(distance_in_layer,visibility) * ct; 549 delta_zv = delta_z - vAltitude; 550 } 551 } 552 else // we see the layer from above, delta_z < 0.0 553 { 554 H = dist * -ct; 555 if (H < (-delta_z)) // we don't see into the layer at all, aloft visibility is the only fading 556 { 557 distance_in_layer = 0.0; 558 delta_zv = 0.0; 559 } 560 else 561 { 562 vAltitude = H + delta_z; 563 distance_in_layer = vAltitude/H * dist; 564 vAltitude = min(distance_in_layer,visibility) * (-ct); 565 delta_zv = vAltitude; 566 } 567 } 568 569// blur of the haze layer edge 570 571float blur_thickness = 50.0; 572float cphi = dot(vec3(0.0, 1.0, 0.0), relPos)/dist; 573float ctlayer = delta_z/dist-0.01 + 0.02 * Noise2D(vec2(cphi,1.0),0.1) -0.01; 574float ctblur = 0.035 ; 575 576float blur_dist; 577 578if (abs(delta_z) < 400.0) 579 { 580 blur_dist = dist * (1.0-smoothstep(0.0,300.0,-delta_z)) * smoothstep(-400.0,-200.0, -delta_z); 581 blur_dist = blur_dist * smoothstep(ctlayer-4.0*ctblur, ctlayer-ctblur, ct) * (1.0-smoothstep(ctlayer+0.5*ctblur, ctlayer+ctblur, ct)); 582 distance_in_layer = max(distance_in_layer, blur_dist); 583 } 584 585 586// ground haze cannot be thinner than aloft visibility in the model, 587// so we need to use aloft visibility otherwise 588 589 590transmission_arg = (dist-distance_in_layer)/avisibility; 591 592 593float eqColorFactor; 594 595 596 597if (visibility < avisibility) 598 { 599 transmission_arg = transmission_arg + (distance_in_layer/(1.0 * visibility + 1.0 * visibility * fogstructure * 0.06 * (noise_1500m + noise_2000m -1.0) )); 600 // this combines the Weber-Fechner intensity 601 eqColorFactor = 1.0 - 0.1 * delta_zv/visibility - (1.0 - effective_scattering); 602 } 603else 604 { 605 transmission_arg = transmission_arg + (distance_in_layer/(1.0 * avisibility + 1.0 * avisibility * fogstructure * 0.06 * (noise_1500m + noise_2000m - 1.0) )); 606 // this combines the Weber-Fechner intensity 607 eqColorFactor = 1.0 - 0.1 * delta_zv/avisibility - (1.0 - effective_scattering); 608 } 609 610 611 612transmission = fog_func(transmission_arg, alt); 613 614// there's always residual intensity, we should never be driven to zero 615if (eqColorFactor < 0.2) eqColorFactor = 0.2; 616 617 618 619 620 621 622 623// now dim the light for haze 624eShade = 1.0 - 0.9 * smoothstep(-terminator_width+ terminator, terminator_width + terminator, yprime_alt); 625 626// Mie-like factor 627 628 if (lightArg < 10.0) 629 { 630 intensity = length(hazeColor); 631 float mie_magnitude = 0.5 * smoothstep(350000.0, 150000.0, terminator-sqrt(2.0 * EarthRadius * terrain_alt)); 632 hazeColor = intensity * ((1.0 - mie_magnitude) + mie_magnitude * mie_angle) * normalize(mix(hazeColor, vec3 (0.5, 0.58, 0.65), mie_magnitude * (0.5 - 0.5 * mie_angle)) ); 633 } 634 635intensity = length(hazeColor); 636 637if (intensity > 0.0) // this needs to be a condition, because otherwise hazeColor doesn't come out correctly 638{ 639 640 641 // high altitude desaturation of the haze color 642 hazeColor = intensity * normalize (mix(hazeColor, intensity * vec3 (1.0,1.0,1.0), 0.7* smoothstep(5000.0, 50000.0, alt))); 643 644 // blue hue of haze 645 hazeColor.x = hazeColor.x * 0.83; 646 hazeColor.y = hazeColor.y * 0.9; 647 648 649 // additional blue in indirect light 650 float fade_out = max(0.65 - 0.3 *overcast, 0.45); 651 intensity = length(hazeColor); 652 hazeColor = intensity * normalize(mix(hazeColor, 1.5* shadedFogColor, 1.0 -smoothstep(0.25, fade_out,eShade) )); 653 654 // change haze color to blue hue for strong fogging 655 hazeColor = intensity * normalize(mix(hazeColor, shadedFogColor, (1.0-smoothstep(0.5,0.9,eqColorFactor)))); 656 657 658 659 // reduce haze intensity when looking at shaded surfaces, only in terminator region 660 float shadow = mix( min(1.0 + dot(n,lightDir),1.0), 1.0, 1.0-smoothstep(0.1, 0.4, transmission)); 661 hazeColor = mix(shadow * hazeColor, hazeColor, 0.3 + 0.7* smoothstep(250000.0, 400000.0, terminator)); 662 } 663 664// don't let the light fade out too rapidly 665lightArg = (terminator + 200000.0)/100000.0; 666float minLightIntensity = min(0.2,0.16 * lightArg + 0.5); 667vec3 minLight = minLightIntensity * vec3 (0.2, 0.3, 0.4); 668 669hazeColor.rgb *= eqColorFactor * eShade; 670hazeColor.rgb = max(hazeColor.rgb, minLight.rgb); 671 672 673fragColor.rgb = mix(hazeColor + secondary_light * fog_backscatter(mvisibility), fragColor.rgb,transmission); 674 675} 676 677fragColor.rgb = filter_combined(fragColor.rgb); 678 679gl_FragColor = fragColor; 680// logarithmic depth 681gl_FragDepth = log2(flogz) * fg_Fcoef * 0.5; 682 683} 684 685