#extension GL_OES_standard_derivatives : enable precision highp float; uniform vec2 resolution; uniform float time; uniform vec2 mouse; uniform sampler2D backbuffer; const float PI = 3.14159265; //use for differential const float EPS = 0.001; const vec3 moonPos = vec3(-7.5,4.5,6.0); const float cellSize = 1.5; //tracing result structure struct TraceData { vec3 normal; float t; float nearestT; float nearestD; int uniqueID; }; //common function mat2 genRot(float val){ return mat2(cos(val), -sin(val), sin(val), cos(val)); } //Setting CameraPos vec3 Camera(float t){ vec3 c1 = vec3(0,1.75,-2.5); c1.y += 0.25 * sin(t); c1.xz = (-7.5 - 2.5 * sin(t)) * vec2(sin(t),cos(t)); vec3 c2 = vec3(0,2.5,-7.5); c2.y += fract(t/ 12.) * 2. - 0.5; vec3 c3 = vec3(0,12.0,0.); c3.y += fract(t/ 12.) * 3.0 - 0.5; return fract(t / 12.) < 0.33 ? c1 : (fract(t/12.) < 0.66 ? c2 : c3); } //Setting Ray vec3 Ray(vec2 uv, float z,float t){ vec3 r1 = normalize(vec3(uv,z)); r1.xy *= genRot(-0.2); r1.xz *= genRot(-t); vec3 r2 = normalize(vec3(uv,z)); vec3 r3 = normalize(vec3(uv,z * 1.)); r3.yz *= genRot(PI / 2. * fract(t / 12.)); return fract(t / 12.) < 0.33 ? r1 : (fract(t/12.) < 0.66 ? r2 : r3); } float random (in vec2 st) { return fract(sin(dot(st.xy, vec2(12.9898,78.233)))* 43758.5453123); } float noise (in vec2 st) { vec2 i = floor(st); vec2 f = fract(st); // Four corners in 2D of a tile float a = random(i); float b = random(i + vec2(1.0, 0.0)); float c = random(i + vec2(0.0, 1.0)); float d = random(i + vec2(1.0, 1.0)); vec2 u = f * f * (3.0 - 2.0 * f); return mix(a, b, u.x) + (c - a)* u.y * (1.0 - u.x) + (d - b) * u.x * u.y; } float fbm (in vec2 st) { // Initial values float value = 0.0; float amplitude = .4; float frequency = 0.; // // Loop of octaves for (int i = 0; i < 6; i++) { value += amplitude * noise(st); st *= 2.; amplitude *= .5; } return value; } float phase(vec3 p){ //return (fract(iTime / 2.0) < 0.5)? // fract(floor(p.x / cellSize + 0.5) * 0.5 + floor(p.z / cellSize + 0.5) * 0.5 + iTime * 0.5) //: fract(random(vec2(floor(p.x / cellSize + 0.5),floor(p.z / cellSize + 0.5))) + iTime * 0.5); float p1 = fract(random(vec2(floor(p.x / cellSize + 0.5),floor(p.z / cellSize + 0.5))) + time * 0.5); float p2 = fract(floor(length(vec2(floor(p.x / cellSize + 0.5),floor(p.z / cellSize + 0.5)))) * 0.05 - time * 0.5); float p3 = fract((floor(abs(p.x) / cellSize + 0.5)+ floor(abs(p.z) / cellSize + 0.5)) * 0.05 + time * 0.5); return fract(time / 24.) < 0.33 ? p1 : (fract(time/24.) < 0.66 ? p2 : p3); } float smin( float a, float b, float k ) { float res = exp2( -k*a ) + exp2( -k*b ); return -log2( res )/k; } vec2 pmod(vec2 p,float c){ float tmp = PI * 2. / c; float l = length(p); float theta = atan(p.y/p.x); theta = mod(theta,PI * 2. / c); return vec2(l * cos(theta), l * sin(theta)); } vec3 modCell(vec3 p,vec3 cellSize){ p.x = (fract(p.x / cellSize.x + 0.5) - 0.5) * cellSize.x; p.y = (fract(p.y / cellSize.y + 0.5) - 0.5) * cellSize.y; p.z = (fract(p.z / cellSize.z + 0.5) - 0.5) * cellSize.z; return p; } //Common SDF float sphere(vec3 p,vec3 o,float r){ return length(p - o) - r; } float cylinder(vec2 p,vec2 o,float r){ return length(p - o) - r; } float cube(vec3 p,vec3 o,vec3 s){ float x = abs(p.x - o.x) - s.x/2.; float y = abs(p.y - o.y) - s.y/2.; float z = abs(p.z - o.z) - s.z/2.; return max(x,max(y,z)); } float line(vec3 p,vec3 q1,vec3 q2,float r){ float t = clamp( dot(q2 - p,q2 -q1)/dot(q2-q1,q2-q1), 0., 1. ); vec3 q = t * q1 + (1. - t) * q2; return length(q - p) - r; } //Gathering SDF float map(vec3 p){ vec2 st = p.xz; float time = time / 10.; float mult = exp(- abs(p.x * 0.5) + 1.25)* exp(- abs(p.z * 0.5) + 1.25); //mult = exp (- (p.x * p.x + p.z * p.z) * 0.75 + 1.5); mult = min(mult,4.); float f = (fbm(st + time) * 0.2 + 0.4) * mult; float terrain = p.y - f * 2.0 + 1.5; vec3 p2 = p; p2.xz = (fract(p2.xz / cellSize + 0.5) - 0.5) * cellSize; float groove = max(abs(p2.x),abs(p2.z)) > 0.4875 ? 0.05 : 0.; terrain += groove; float bamboo = 1.0 + max(0.,sin(p.y * 4.0) * sin(p.y * 4.0) - 0.75); float building = length(p2.xz) - bamboo * cellSize/6.0; building = max(building, -length(p2.xz) + cellSize / 8.0); float height = (p.x * p.x + p.z * p.z) * 0.02 + 1.5; float rand = phase(p); height -= rand > 0.25 ? 10000.0 : height * (3.0 * rand * rand * 16.0); building = max(building, p.y - height); vec3 q = p - moonPos; float theta = q.x; float phi = q.y; vec2 pol = vec2(q.x,q.y); float r= 1.2 + fbm(pol + time)/1.5; float moon = length(q) - r; float result = min(terrain,moon); result = min(result,building); float camSp = length(p - Camera(time/2.)) - 1.0; result = max(result,-camSp); return result; } //Getting Normal vec3 getNormal(vec3 p){ float d = 0.0001; return normalize(vec3( map(p + vec3( d, 0.0, 0.0)) - map(p + vec3( -d, 0.0, 0.0)), map(p + vec3(0.0, d, 0.0)) - map(p + vec3(0.0, -d, 0.0)), map(p + vec3(0.0, 0.0, d)) - map(p + vec3(0.0, 0.0, -d)) )); } //Tracing Ray TraceData trace (vec3 o, vec3 r){ TraceData data; float t = 0.0; float nearestT = 10000000.0; float nearestD = 10000000.0; vec3 p = vec3(0.0,0.0,0.0); for(int i = 0; i < 192; ++i){ p = o + r * t; float d = map(p); t += d * 0.15; nearestT = d < nearestD ? t : nearestT; nearestD = min(nearestD,d); } data.nearestD = nearestD; data.nearestT = nearestT; data.normal = getNormal(p); data.t = t; return data; } //Making color vec3 getColor(vec3 o,vec3 r,TraceData data){ float t = data.t; float a = dot(data.normal,r); vec3 p = o + r * t; vec3 fc = vec3(0.05); fc = fract(p.y * 4. + 0.5) < 0.1 && (p.y < -1.) ? vec3(0.95) : fc; fc = mix(fc,vec3(1.),1. + a*1.5); vec3 fogCol = vec3(27,47,82)/255.; vec3 moonCol = vec3(226,201,110)/255.; fc = length(p - moonPos) > 3.0 ? fc : moonCol; float farFromMoon = length(p - moonPos); fc += moonCol *1.0 / (1.0 + farFromMoon * farFromMoon * 0.005); fc = ((abs(p.x) + abs(p.z) < 3.0)&&(0. < p.y)) ? vec3(1.0) : fc; float fog = 1.0 / (1.0 + t * farFromMoon * 0.0025); float rand = phase(p); vec3 illColor; illColor.x = sin(rand * 2. * PI); illColor.y = sin(rand * 2. * PI + PI * 2. / 3.); illColor.z = sin(rand * 2. * PI - PI * 2. / 3.); illColor = illColor * 0.5 + 0.5; fc += rand > 0.5? vec3(0.0) : illColor * 1.2; fc = mix(fc,fogCol,1. - fog); //fc = vec3(fog); return fc; } //Drawing void main(void) { //set canvas vec2 uv = gl_FragCoord.xy /resolution.xy; uv = uv * 2.0 - 1.0; uv.x *= resolution.x / resolution.y; //set camera and ray vec3 r = Ray(uv,1.2,time/2.); vec3 o = Camera(time/2.); //trace ray TraceData data = trace(o,r); float vig = 1. - length(uv)/5.; vec3 fc = getColor(o,r,data) * vig ; //fc = vec3(fog); // Output to screen gl_FragColor = vec4(fc,1.0); }