fog.glsl

#ifdef GL_ES
precision mediump float;
#endif

#extension GL_OES_standard_derivatives : enable

uniform float time;
uniform vec2 mouse;
uniform vec2 resolution;
uniform sampler2D textureA; //<-- eye
uniform sampler2D textureB; //<-landscape texture
uniform sampler2D textureC; //<-heightmap
uniform sampler2D textureD;

uniform sampler2D fft;
float freqs[4];

#define MaxSteps 30


#define PI 3.141592

#define Offset vec3(0.92858,0.92858,0.32858)


const float detail=.00002;
float ot=0.;
float det=0.;
vec3 lightdir=normalize(vec3(-1.,1,-2.));

vec2 rotate(vec2 v, float a) {
	return vec2(cos(a)*v.x + sin(a)*v.y, -sin(a)*v.x + cos(a)*v.y);
}


float tri(in float x){return abs(fract(x)-.5);}
vec3 tri3(in vec3 p){return vec3( tri(p.z+tri(p.y*1.)), tri(p.z+tri(p.x*1.)), tri(p.y+tri(p.x*1.)));}

float triNoise3d(in vec3 p, in float spd)
{
    float z=1.4;
	float rz = 0.;
    vec3 bp = p;
	for (float i=0.; i<=3.; i++ )
	{
        vec3 dg = tri3(bp*2.);
        p += (dg+time*spd);

        bp *= 1.8;
		z *= 1.5;
		p *= 1.2;
        //p.xz*= m2;
        
        rz+= (tri(p.z+tri(p.x+tri(p.y))))/z;
        bp += 0.14;
	}
	return rz;
}

float fogmap(in vec3 p, in float d)
{
    p.x += time*2.5;
    p.z += sin(p.x*.5);
    return triNoise3d(p*2.2/(d+20.),0.2)*(1.-smoothstep(0.,.7,p.y));
}

vec3 fog(in vec3 col, in vec3 ro, in vec3 rd, in float mt)
{
    float d = .5;
    for(int i=0; i<7; i++)
    {
        vec3  pos = ro + rd*d;
        float rz = fogmap(pos, d);
		float grd =  clamp((rz - fogmap(pos+.8-float(i)*0.1,d))*3., 0.1, 1. );
        vec3 col2 = (vec3(.1,0.8,.5)*.5 + .5*vec3(.5, .8, 1.)*(1.7-grd))*0.55;
        col = mix(col,col2,clamp(rz*smoothstep(d-0.4,d+2.+d*.75,mt),0.,1.) );
        d *= 1.5+0.3;
        if (d>mt)break;
    }
    return col;
}


float mandelBulb(vec3 p) {
    	vec3 op = p;
 	p = abs(1.0-mod(p,2.));
    	float r = 0., power = 8., dr = 1.;
    	vec3 z = p;
	
	
	for (int i = 0; i < 7; i++) {
	    
	 op = -1.0 + 2.0*fract(0.5*op+0.5);

	float r2 = dot(op,op);    
        r = length(z);
	
	    
        if (r > 2.) break;
        float theta = acos(z.z / r) ;//+ fract(time/20.) * 0.3;
        float phi = atan(z.y, z.x);

        dr = pow(r, power - 1.) * power * dr + 1.;
        float zr = pow(r, power);
        theta = theta * power;
        phi = phi * power;
        z = zr * vec3(sin(theta) * cos(phi), sin(phi) * sin(theta), cos(theta));
        z += p;
    }
    return (.5 * log(r) * r / dr) - 0.001;
}



float mengerSponge(in vec3 z)
{
	vec3 op = z;
	z  = abs(1.0-mod(z,2.));
	float d = 1000.0;
	for (int n = 0; n < 7; n++) {
		op = -1.0 + 2.0*fract(0.5*op+0.5);
		float r2 = dot(op,op);
        	//z.xy = rotate(z.xy,4.0+2.0*cos( time/16.0));
		z = abs(z);
		if (z.x<z.y){ z.xy = z.yx;}
		if (z.x< z.z){ z.xz = z.zx;}
		if (z.y<z.z){ z.yz = z.zy;}
		z = 3.0*z-Offset*(3.0-1.0);
		if( z.z<-0.5*Offset.z*(3.0-1.0))  z.z+=Offset.z*(3.0-1.0);
		d = min(d, length(z) * pow(3.0, float(-n)-1.0));
	}
	
	return d-0.0001;
}

float trap(vec3 p){
	return  length(p.x-0.5-0.5*sin(time/10.0)); // <- cube forms 
	
}




float map(vec3 p){
	return mengerSponge(p);	
}


vec3 normal(in vec3 p) {
	
 	vec2 e = vec2(0.005, -0.005); 
 	return normalize(e.xyy * map(p + e.xyy) + e.yyx * map(p + e.yyx) + e.yxy * map(p + e.yxy) + e.xxx * map(p + e.xxx));
}

float rand(vec2 co){
	return fract(cos(dot(co,vec2(4.898,7.23))) * 23421.631);
}



vec3 getColor(vec3 normal, vec3 pos) {
	return vec3(1.);
}


float kset(vec3 p) {
	p=abs(.5-fract(p*20.));
	float es, l=es=0.;
	for (int i=0;i<13;i++) {
		float pl=l;
		l=length(p);
		p=abs(p)/dot(p,p)-.5;
		es+=exp(-1./abs(l-pl));
	}
	return es;	
}

float shadow(vec3 pos, vec3 sdir) {
		float totalDist =2.0*det, sh=1.;
 		for (int steps=0; steps<30; steps++) {
			if (totalDist<1.) {
				vec3 p = pos - totalDist * sdir;
				float dist = map(p)*1.5;
				if (dist < detail)  sh=0.;
				totalDist += max(0.05,dist);
			}
		}
		return max(0.,sh);	
}

float calcAO( const vec3 pos, const vec3 nor ) {
	float aodet=detail*80.;
	float totao = 0.0;
    float sca = 10.0;
    for( int aoi=0; aoi<5; aoi++ ) {
        float hr = aodet + aodet*float(aoi*aoi);
        vec3 aopos =  nor * hr + pos;
        float dd = map( aopos );
        totao += -(dd-hr)*sca;
        sca *= 0.75;
    }
    return clamp( 1.0 - 5.0*totao, 0.0, 1.0 );
}


vec3 light(in vec3 p, in vec3 dir) {
	
	vec3 n=normal(p);
	float sh=min(5.,shadow(p, lightdir));

	float ao= calcAO(p,n);
	
	float diff=max(0.,dot(lightdir,-n))*sh*1.3;
	float amb=max(0.2,dot(dir,-n))*.4;
	vec3 r = reflect(lightdir,n);
	float spec=pow(max(0.,dot(dir,-r))*sh,10.)*(.5+ao*.5);
	float k=kset(p)*.18; 
	vec3 col=mix(vec3(k*1.1,k*k*1.3,k*k*k),vec3(k),.45)*2.;
	col=col*ao*(amb*vec3(.9,.85,1.)+diff*vec3(1.,.9,.9))+spec*vec3(1,.9,.5)*.7;	
	return col;
}




vec3 rayMarch(in vec3 from, in vec3 dir, in vec2 fragCoord) {
	vec2 lig=vec2(sin(time*2.)*.6,cos(time)*.25-.25);
	vec3 color =  vec3(0);
	float totalDistance = 0.; 
	float d;
	int steps = 0;
	vec3 pos;
	for (int i=0; i <32; i++) {
		
		pos = from + totalDistance * dir;	
		d = map(pos);	
		det=detail*(1.+totalDistance*55.);
		totalDistance += d;
		if (d < 0.001) break;
		steps = i;
	
	}
	float l=pow(max(0.,dot(normalize(-dir),normalize(lightdir))),10.);
	vec3 backg=vec3(0);
	
	if (d > 0.00002) {
		color=light(pos-det*dir*1.5, dir); 
		color*=vec3(1.,.85,.8)*.6;
		color*=min(1.2,.5+totalDistance*totalDistance*1.5);
		color = mix(color, backg, 1.0-exp(-1.3*pow(totalDistance,1.3)));
		
	}else{
		color = backg;
	}
	
		
	
	return color;
}


vec3 postProcess(vec3 color){
	
	color*=vec3(1.,.94,.87);
	color=pow(color,vec3(1.2));
	color=mix(vec3(length(color)),color,.85)*.95;
	
	return color;
}



void main( void ) {


	vec2 uv = (gl_FragCoord.xy / resolution.xy) -0.5;

	float t = time ;

	
	vec3 camPos = .1*t*vec3(0.3,0.,0.5);	
	
	vec3 target = camPos + vec3(1.,0.0*cos(t),0.);
	vec3 camUp  = vec3(1.0,0,1.);

	
	vec3 camDir   = normalize(target-camPos); 
		
	camUp = normalize(camUp-dot(camDir,camUp)*camDir); 
	
	vec3 camRight = normalize(cross(camDir,camUp));
	
	vec2 coord = -1.+2.*gl_FragCoord.xy/resolution.xy;
	
	coord.x *= resolution.x/resolution.y;
	
	
	vec3 rd = normalize(camDir + (coord.x*camRight + coord.y*camUp));
	
	
	vec3 tot = rayMarch(camPos, rd, coord ) ;
	
	if(tot.z < .3){
		
	tot = fog(tot,camPos-.9, rd, 3.5);
	}
	
	tot+=vec3(1,.85,.7)*pow(max(0.,.3-length(uv-vec2(0.,.03)))/.3,1.5)*.35;
	

	
	
	gl_FragColor =  vec4(postProcess(tot),1.);


}