From 44f1d9239b64b5ab74d742eeab0543e4c27243ca Mon Sep 17 00:00:00 2001 From: osquallo Date: Sat, 21 Mar 2020 14:18:06 +0100 Subject: [PATCH] ADD sky shaderand panorama sky. --- assets/sky/sky.shader | 396 ++++++++++++++++++++++++++++++++++++++++++ project.godot | 6 + scenes/game/game.tscn | 76 +++++++- scenes/game/sky.gd | 71 ++++++++ 4 files changed, 547 insertions(+), 2 deletions(-) create mode 100644 assets/sky/sky.shader create mode 100644 scenes/game/sky.gd diff --git a/assets/sky/sky.shader b/assets/sky/sky.shader new file mode 100644 index 0000000..77e8b59 --- /dev/null +++ b/assets/sky/sky.shader @@ -0,0 +1,396 @@ +shader_type canvas_item; + +// USING https://www.shadertoy.com/view/XtBXDw (base on it) + +uniform float iTime; +uniform int iFrame; +uniform sampler2D iChannel0; +uniform float COVERAGE :hint_range(0,1); //0.5 +uniform float THICKNESS :hint_range(0,100); //25. +uniform float ABSORPTION :hint_range(0,10); //1.030725 +uniform int STEPS :hint_range(0,100); //25 + + + +//////////////////////////////// +uniform float earth_radius_km = 6371; +uniform float atmo_radius_km = 6471; +uniform float cam_height_m = 1.8; +//uniform vec3 sun_pos = vec3(0.0, 0.1, -0.5); +uniform vec3 sun_pos = vec3(1.0, 1.0, 1.0); +uniform float sun_intensity = 22.0; +uniform vec3 rayleigh_coeff = vec3(5.5, 13.0, 22.4); // we divide this by 100000 +uniform float mie_coeff = 21.0; // we divide this by 100000 +uniform float rayleigh_scale = 800; +uniform float mie_scale = 120; +uniform float mie_scatter_dir = 0.758; + +uniform sampler2D night_sky : hint_black_albedo; +uniform mat3 rotate_night_sky; + + + +// Atmosphere code from: https://github.com/wwwtyro/glsl-atmosphere +vec2 rsi(vec3 r0, vec3 rd, float sr) { + // ray-sphere intersection that assumes + // the sphere is centered at the origin. + // No intersection when result.x > result.y + float a = dot(rd, rd); + float b = 2.0 * dot(rd, r0); + float c = dot(r0, r0) - (sr * sr); + float d = (b*b) - 4.0*a*c; + if (d < 0.0) return vec2(100000.0,-100000.0); + return vec2( + (-b - sqrt(d))/(2.0*a), + (-b + sqrt(d))/(2.0*a) + ); +} + +vec3 atmosphere(vec3 r, vec3 r0, vec3 pSun, float iSun, float rPlanet, float rAtmos, vec3 kRlh, float kMie, float shRlh, float shMie, float g) { + float PI = 3.14159265358979; + int iSteps = 16; + int jSteps = 8; + + // Normalize the sun and view directions. + pSun = normalize(pSun); + r = normalize(r); + + // Calculate the step size of the primary ray. + vec2 p = rsi(r0, r, rAtmos); + if (p.x > p.y) return vec3(0,0,0); + p.y = min(p.y, rsi(r0, r, rPlanet).x); + float iStepSize = (p.y - p.x) / float(iSteps); + + // Initialize the primary ray time. + float iTimeBis = 0.0; + + // Initialize accumulators for Rayleigh and Mie scattering. + vec3 totalRlh = vec3(0,0,0); + vec3 totalMie = vec3(0,0,0); + + // Initialize optical depth accumulators for the primary ray. + float iOdRlh = 0.0; + float iOdMie = 0.0; + + // Calculate the Rayleigh and Mie phases. + float mu = dot(r, pSun); + float mumu = mu * mu; + float gg = g * g; + float pRlh = 3.0 / (16.0 * PI) * (1.0 + mumu); + float pMie = 3.0 / (8.0 * PI) * ((1.0 - gg) * (mumu + 1.0)) / (pow(1.0 + gg - 2.0 * mu * g, 1.5) * (2.0 + gg)); + + // Sample the primary ray. + for (int i = 0; i < iSteps; i++) { + // Calculate the primary ray sample position. + vec3 iPos = r0 + r * (iTimeBis + iStepSize * 0.5); + + // Calculate the height of the sample. + float iHeight = length(iPos) - rPlanet; + + // Calculate the optical depth of the Rayleigh and Mie scattering for this step. + float odStepRlh = exp(-iHeight / shRlh) * iStepSize; + float odStepMie = exp(-iHeight / shMie) * iStepSize; + + // Accumulate optical depth. + iOdRlh += odStepRlh; + iOdMie += odStepMie; + + // Calculate the step size of the secondary ray. + float jStepSize = rsi(iPos, pSun, rAtmos).y / float(jSteps); + + // Initialize the secondary ray time. + float jTime = 0.0; + + // Initialize optical depth accumulators for the secondary ray. + float jOdRlh = 0.0; + float jOdMie = 0.0; + + // Sample the secondary ray. + for (int j = 0; j < jSteps; j++) { + // Calculate the secondary ray sample position. + vec3 jPos = iPos + pSun * (jTime + jStepSize * 0.5); + + // Calculate the height of the sample. + float jHeight = length(jPos) - rPlanet; + + // Accumulate the optical depth. + jOdRlh += exp(-jHeight / shRlh) * jStepSize; + jOdMie += exp(-jHeight / shMie) * jStepSize; + + // Increment the secondary ray time. + jTime += jStepSize; + } + + // Calculate attenuation. + vec3 attn = exp(-(kMie * (iOdMie + jOdMie) + kRlh * (iOdRlh + jOdRlh))); + + // Accumulate scattering. + totalRlh += odStepRlh * attn; + totalMie += odStepMie * attn; + + // Increment the primary ray time. + iTimeBis += iStepSize; + + } + + // Calculate and return the final color. + return iSun * (pRlh * kRlh * totalRlh + pMie * kMie * totalMie); +} + +// and our application + +vec3 ray_dir_from_uv(vec2 uv) { + float PI = 3.14159265358979; + vec3 dir; + + float x = sin(PI * uv.y); + dir.y = cos(PI * uv.y); + + dir.x = x * sin(2.0 * PI * (0.5 - uv.x)); + dir.z = x * cos(2.0 * PI * (0.5 - uv.x)); + + return dir; +} + +vec2 uv_from_ray_dir(vec3 dir) { + float PI = 3.14159265358979; + vec2 uv; + + uv.y = acos(dir.y) / PI; + + dir.y = 0.0; + dir = normalize(dir); + uv.x = acos(dir.z) / (2.0 * PI); + if (dir.x < 0.0) { + uv.x = 1.0 - uv.x; + } + uv.x = 0.5 - uv.x; + if (uv.x < 0.0) { + uv.x += 1.0; + } + + return uv; +} +//////////////////////////////// + + + +float noise( in vec3 x ) +{ + x*=0.01; + float z = x.z*256.0; + vec2 offz = vec2(0.317,0.123); + vec2 uv1 = x.xy + offz*floor(z); + vec2 uv2 = uv1 + offz; + return mix(textureLod( iChannel0, uv1 ,0.0).x,textureLod( iChannel0, uv2 ,0.0).x,fract(z)); +} + +float fbm(vec3 pos,float lacunarity){ + vec3 p = pos; + float + t = 0.51749673 * noise(p); p *= lacunarity; + t += 0.25584929 * noise(p); p *= lacunarity; + t += 0.12527603 * noise(p); p *= lacunarity; + t += 0.06255931 * noise(p); + return t; +} + +float get_noise(vec3 x) +{ + float FBM_FREQ=2.76434; + return fbm(x, FBM_FREQ); +} + +vec3 render_sky_color(vec3 rd){ + vec3 sun_color = vec3(1., .7, .55); + vec3 SUN_DIR = normalize(vec3(0, abs(sin( .3)), -1)); + float sun_amount = max(dot(rd, SUN_DIR), 0.0); + + vec3 sky = mix(vec3(.0, .1, .4), vec3(.3, .6, .8), 1.0 - rd.y); + sky = sky + sun_color * min(pow(sun_amount, 1500.0) * 5.0, 1.0); + sky = sky + sun_color * min(pow(sun_amount, 10.0) * .6, 1.0); + + return sky; +} + +bool SphereIntersect(vec3 SpPos, float SpRad, vec3 ro, vec3 rd, out float t, out vec3 norm) { + ro -= SpPos; + + float A = dot(rd, rd); + float B = 2.0*dot(ro, rd); + float C = dot(ro, ro)-SpRad*SpRad; + float D = B*B-4.0*A*C; + if (D < 0.0) return false; + + D = sqrt(D); + A *= 2.0; + float t1 = (-B+D)/A; + float t2 = (-B-D)/A; + if (t1 < 0.0) t1 = t2; + if (t2 < 0.0) t2 = t1; + t1 = min(t1, t2); + if (t1 < 0.0) return false; + norm = ro+t1*rd; + t = t1; + //norm = normalize(norm); + return true; +} + +float density(vec3 pos,vec3 offset,float t){ + vec3 p = pos * .0212242 + offset; + float dens = get_noise(p); + + float cov = 1. - COVERAGE; + dens *= smoothstep (cov, cov + .05, dens); + return clamp(dens, 0., 1.); +} + + +vec4 render_clouds(vec3 ro,vec3 rd){ + + vec3 apos=vec3(0, -450, 0); + float arad=500.; + vec3 WIND=vec3(0, 0, -iTime * .2); + vec3 C = vec3(0, 0, 0); + float alpha = 0.; + vec3 n; + float tt; + if(SphereIntersect(apos,arad,ro,rd,tt,n)){ + float thickness = THICKNESS; + int steps = STEPS; + float march_step = thickness / float(steps); + vec3 dir_step = rd / rd.y * march_step; + vec3 pos =n; + float T = 1.; + + for (int i = 0; i < steps; i++) { + float h = float(i) / float(steps); + float dens = density (pos, WIND, h); + float T_i = exp(-ABSORPTION * dens * march_step); + T *= T_i; + if (T < .01) break; + C += T * (exp(h) / 1.75) *dens * march_step; + alpha += (1. - T_i) * (1. - alpha); + pos += dir_step; + if (length(pos) > 1e3) break; + } + + return vec4(C, alpha); + } + return vec4(C, alpha); +} + +float fbm2(in vec3 p) +{ + float f = 0.; + f += .50000 * noise(.5 * (p+vec3(0.,0.,-iTime*0.275))); + f += .25000 * noise(1. * (p+vec3(0.,0.,-iTime*0.275))); + f += .12500 * noise(2. * (p+vec3(0.,0.,-iTime*0.275))); + f += .06250 * noise(4. * (p+vec3(0.,0.,-iTime*0.275))); + return f; +} + +vec3 cube_bot(vec3 d, vec3 c1, vec3 c2) +{ + return fbm2(d) * mix(c1, c2, d * .5 + .5); +} + +vec3 rotate_y(vec3 v, float angle) +{ + float ca = cos(angle); float sa = sin(angle); + return v*mat3( + vec3(+ca, +.0, -sa), + vec3(+.0,+1.0, +.0), + vec3(+sa, +.0, +ca)); +} + +vec3 rotate_x(vec3 v, float angle) +{ + float ca = cos(angle); float sa = sin(angle); + return v*mat3( + vec3(+1.0, +.0, +.0), + vec3(+.0, +ca, -sa), + vec3(+.0, +sa, +ca)); +} + +void panorama_uv(vec2 fragCoord, out vec3 ro,out vec3 rd, in vec2 iResolution){ + float M_PI = 3.1415926535; + float ymul = 2.0; float ydiff = -1.0; + vec2 uv = fragCoord.xy / iResolution.xy; + uv.x = 2.0 * uv.x - 1.0; + uv.y = ymul * uv.y + ydiff; + ro = vec3(0., 5., 0.); + rd = normalize(rotate_y(rotate_x(vec3(0.0, 0.0, 1.0),-uv.y*M_PI/2.0),-uv.x*M_PI)); +} + +void mainImage( out vec4 fragColor, in vec2 fragCoord, in vec2 iResolution) +{ + vec3 ro = vec3 (0.,0.,0.); + vec3 rd = vec3(0.); + vec3 col=vec3(0.); + + panorama_uv(fragCoord,ro,rd,iResolution); + +// vec3 sky = render_sky_color(rd); + vec3 sky = vec3( 0.0, 0.0, 0.0); + vec4 cld = vec4(0.); + float skyPow = dot(rd, vec3(0.0, -1.0, 0.0)); + float horizonPow =1.-pow(1.0-abs(skyPow), 5.0); + if(rd.y>0.) + {cld=render_clouds(ro,rd); + cld=clamp(cld,vec4(0.),vec4(1.)); + cld.rgb+=0.04*cld.rgb*horizonPow; + cld*=clamp(( 1.0 - exp(-2.3 * pow(max((0.0), horizonPow), (2.6)))),0.,1.); + } + else{ + cld.rgb = cube_bot(rd,vec3(1.5,1.49,1.71), vec3(1.1,1.15,1.5)); + cld*=cld; + //cld=clamp(cld,vec4(0.),vec4(1.)); + cld.a=1.; + cld*=clamp(( 1.0 - exp(-1.3 * pow(max((0.0), horizonPow), (2.6)))),0.,1.); + } + col=mix(sky, cld.rgb/(0.0001+cld.a), cld.a); + //col*=col; + fragColor = vec4(col,1.0); +} + +void fragment(){ + ////////////////////////////////// + vec3 dir = ray_dir_from_uv(UV); + + // determine our sky color + vec3 color = atmosphere( + vec3( dir.x, -dir.y, dir.z ) + , vec3(0.0, earth_radius_km * 100.0 + cam_height_m * 0.1, 0.0) + , sun_pos + , sun_intensity + , earth_radius_km * 100.0 + , atmo_radius_km * 100.0 + , rayleigh_coeff / 100000.0 + , mie_coeff / 100000.0 + , rayleigh_scale + , mie_scale + , mie_scatter_dir + ); + + // Apply exposure. + color = 1.0 - exp(-1.0 * color); + + // Mix in night sky (already sRGB) + if (dir.y > 0.0) { + float f = (0.21 * color.r) + (0.72 * color.g) + (0.07 * color.b); + float cutoff = 0.1; + + vec2 ns_uv = uv_from_ray_dir(rotate_night_sky * dir); + color += texture(night_sky, ns_uv).rgb * clamp((cutoff - f) / cutoff, 0.0, 1.0); + } + + COLOR = vec4(color, 1.0); + //////////////////////////////////////// + + + + vec2 iResolution=1./TEXTURE_PIXEL_SIZE; + mainImage(COLOR,UV*iResolution,iResolution); + COLOR = vec4(color, 1.0)+COLOR; +} diff --git a/project.godot b/project.godot index a2093fb..d758244 100644 --- a/project.godot +++ b/project.godot @@ -26,6 +26,12 @@ Creatures="*res://ressources/scripts/creatures.gd" MusicManager="*res://scenes/interfaces/music_manager/music_manager.tscn" Connection="*res://scenes/connection/connection.tscn" +[debug] + +gdscript/warnings/unused_variable=false +gdscript/warnings/unused_argument=false +gdscript/warnings/return_value_discarded=false + [display] window/size/width=1280 diff --git a/scenes/game/game.tscn b/scenes/game/game.tscn index 9a35d3d..f3f8a6a 100644 --- a/scenes/game/game.tscn +++ b/scenes/game/game.tscn @@ -1,13 +1,84 @@ -[gd_scene load_steps=5 format=2] +[gd_scene load_steps=14 format=2] [ext_resource path="res://scenes/player/player.tscn" type="PackedScene" id=1] [ext_resource path="res://scenes/decors/terrains/dunes/dunes.tscn" type="PackedScene" id=2] [ext_resource path="res://scenes/game/game.gd" type="Script" id=3] [ext_resource path="res://scenes/decors/vegets/tree_001.tscn" type="PackedScene" id=4] +[ext_resource path="res://assets/sky/sky.shader" type="Shader" id=5] +[ext_resource path="res://scenes/game/sky.gd" type="Script" id=6] + +[sub_resource type="OpenSimplexNoise" id=1] +period = 8.0 + +[sub_resource type="NoiseTexture" id=4] +resource_local_to_scene = true +width = 1280 +height = 720 +seamless = true +noise = SubResource( 1 ) + +[sub_resource type="ShaderMaterial" id=5] +resource_local_to_scene = true +shader = ExtResource( 5 ) +shader_param/iTime = 6165.88 +shader_param/iFrame = 199437 +shader_param/COVERAGE = 0.5 +shader_param/THICKNESS = 25.0 +shader_param/ABSORPTION = 1.031 +shader_param/STEPS = 50 +shader_param/earth_radius_km = 6371.0 +shader_param/atmo_radius_km = 6471.0 +shader_param/cam_height_m = 1.8 +shader_param/sun_pos = Vector3( -1.15706e-06, 100, 8.66537e-06 ) +shader_param/sun_intensity = 42.0 +shader_param/rayleigh_coeff = Vector3( 5.5, 13, 22.4 ) +shader_param/mie_coeff = 21.0 +shader_param/rayleigh_scale = 800.0 +shader_param/mie_scale = 120.0 +shader_param/mie_scatter_dir = 0.758 +shader_param/rotate_night_sky = null +shader_param/iChannel0 = SubResource( 4 ) + +[sub_resource type="ImageTexture" id=6] +resource_local_to_scene = true +size = Vector2( 1280, 720 ) + +[sub_resource type="ViewportTexture" id=2] +viewport_path = NodePath("sky/viewport") + +[sub_resource type="PanoramaSky" id=3] +resource_local_to_scene = true +panorama = SubResource( 2 ) + +[sub_resource type="Environment" id=7] +resource_local_to_scene = true +background_mode = 2 +background_sky = SubResource( 3 ) +background_energy = 0.1 +ambient_light_energy = 3.82 [node name="game" type="Spatial"] script = ExtResource( 3 ) +[node name="sky" type="Spatial" parent="."] + +[node name="viewport" type="Viewport" parent="sky"] +size = Vector2( 1280, 720 ) +render_target_update_mode = 3 + +[node name="sky" type="Sprite" parent="sky/viewport"] +material = SubResource( 5 ) +texture = SubResource( 6 ) +offset = Vector2( 640, 360 ) +script = ExtResource( 6 ) +editor_clouds_playing = true +day_time_hours = 3.67154 +directional_light_node_path = NodePath("../../../directional_light") +sun_position = Vector3( -1.15706e-06, 100, 8.66537e-06 ) + +[node name="world_environment" type="WorldEnvironment" parent="."] +environment = SubResource( 7 ) + [node name="level" type="Spatial" parent="."] [node name="dunes" parent="level" instance=ExtResource( 2 )] @@ -22,5 +93,6 @@ transform = Transform( 1, 0, 0, 0, 1, 0, 0, 0, 1, -11.2768, 8, 13.9512 ) transform = Transform( 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 14.7098, 0 ) [node name="directional_light" type="DirectionalLight" parent="."] -transform = Transform( 0.556412, 0.175846, -0.812086, 0.830907, -0.117754, 0.543809, 0, -0.977349, -0.211632, -12.4893, 10.8693, -9.53674e-07 ) +transform = Transform( 0.991203, 0.132352, -1.15706e-08, 0, 8.74228e-08, 1, 0.132352, -0.991203, 8.66537e-08, -1.15706e-06, 100, 8.66537e-06 ) +light_energy = 1.0 shadow_enabled = true diff --git a/scenes/game/sky.gd b/scenes/game/sky.gd new file mode 100644 index 0000000..09d485d --- /dev/null +++ b/scenes/game/sky.gd @@ -0,0 +1,71 @@ +tool +extends Sprite + +export(bool) var editor_clouds_playing = false +export(float, 0.0, 24.0) var day_time_hours = 12.0 setget set_day_time_hours + +export(NodePath) var directional_light_node_path + +func _ready(): + if !Engine.is_editor_hint(): + editor_clouds_playing = true + +var iTime = 0.0 +var iFrame = 0 + + +func _process( delta ): + + iTime+=delta + iFrame+=1 + + if (Engine.is_editor_hint() and self.editor_clouds_playing) or !Engine.is_editor_hint(): + self.material.set("shader_param/iTime", iTime) + self.material.set("shader_param/iFrame", iFrame) + + day_time_hours += delta + if day_time_hours >= 24: + day_time_hours = 0 + + +func cov_scb(value): + self.material.set("shader_param/COVERAGE",float(value)) + +func thick_scb(value): + self.material.set("shader_param/THICKNESS",value) + +func absb_scb(value): + self.material.set("shader_param/ABSORPTION",float(value)) + +func step_scb(value): + self.material.set("shader_param/STEPS",value) + + +export var sun_position = Vector3(0.0, 1.0, 0.0) setget set_sun_position, get_sun_position +func set_sun_position(new_position): + sun_position = new_position + if self.material: + self.material.set_shader_param("sun_pos", sun_position) +# _trigger_update_sky() +func get_sun_position(): + return sun_position + +func set_time_of_day(hours, directional_light, horizontal_angle = 0.0): + var sun_position = Vector3(0.0, -100.0, 0.0) + sun_position = sun_position.rotated(Vector3(1.0, 0.0, 0.0), hours * PI / 12.0) + sun_position = sun_position.rotated(Vector3(0.0, 1.0, 0.0), horizontal_angle) + + if directional_light: + var t = directional_light.transform + t.origin = sun_position + directional_light.transform = t.looking_at(Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0)) + directional_light.light_energy = 1.0 - clamp(abs(hours - 12.0) / 6.0, 0.0, 1.0) + + # and update our sky + set_sun_position(sun_position) + + +func set_day_time_hours(hours): + if directional_light_node_path: + set_time_of_day(hours, get_node(directional_light_node_path), 25.0) + day_time_hours = hours