DLermite/puredata/extra/fog.frag

/////////////////////////start Pd Header
// 2015 Sofy Yuditskaya
// put all the shadertoy constants here for ease of use

uniform vec3      iResolution;           // viewport resolution (in pixels)
uniform float     iTime;           // shader playback time (in seconds)
uniform vec4      iMouse;                // mouse pixel coords. xy: current (if MLB down), zw: click

// changed samplerXX to sampler2D so it would be recognized, you can also change it to samplerCube as needed

// uniform sampler2D iChannel0;          // input channel. XX = 2D/Cube
// uniform sampler2D iChannel1;          // input channel. XX = 2D/Cube
// uniform sampler2D iChannel2;          // input channel. XX = 2D/Cube
// uniform sampler2D iChannel3;          // input channel. XX = 2D/Cube

// uniform vec4      iDate;                 // (year, month, day, time in seconds)
// uniform float     iSampleRate;           // sound sample rate (i.e., 44100)

void mainImage(out vec4 fragColor, in vec2 fragCoord);

// changelog for Pd:
//running mainImage() from main()
// declared Shadertoy's usual variables above
// declared iChannel0...3 variables individually

void main(  )
{
    mainImage(gl_FragColor, gl_FragCoord.xy);
}
//paste ShaderToy code below
/////////////////////////end Pd Header

// Created by inigo quilez - iq/2013
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

uniform float MARCH_DIST ;//     2.5
uniform int MARCH_COUNT ;//    20
uniform int SCATTER_DEPTH ;//  10
uniform float SCATTER_DIST ;//   2.5
uniform float SPHERE_RADIUS ;//  4.0
uniform float SPHERE_DENSITY ;// 3.0
//#define LIGHT_POS vec3(1.0 * cos(iTime), 10.0, 15.0)
#define LIGHT_COLOR vec3(1.0, 1.0, 1.0)
uniform float LIGHT_COLOR_SCALE ;// 1.2  
#define ABSORPTION_COLOR vec3(1.0, 1.0, 1.0) 
uniform float ABSORPTION_COLOR_SCALE ;// 0.0028
#define VOLUME_COLOR vec3(1.0, 1.0, 1.0)
uniform float VOLUME_COLOR_SCALE ;//0.045 * 
#define BG_COLOR vec3(0.2, 0.2, 0.2)
uniform float BG_COLOR_SCALE ;
uniform float NOISE_SCALE;// 1.2
uniform float xMove ;
uniform float yMove ;
uniform float zMove ;

float hash(float n)
{
    return fract(sin(n)*43758.5453);
}

float noise(in vec3 x)
{
    vec3 p = floor(x);
    vec3 f = fract(x);

    f = f * f * (3.0 - 2.0 * f);
 
    float n = p.x + p.y * 57.0 + 113.0 * p.z;

    float res = mix(mix(mix( hash(n+  0.0), hash(n+  1.0),f.x),
                        mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y),
                    mix(mix( hash(n+113.0), hash(n+114.0),f.x),
                        mix( hash(n+170.0), hash(n+171.0),f.x),f.y),f.z);
    return res;
}

float fbm( vec3 p )
{
    float f;
    f += 0.2500*noise( p ); p = p*2.03;
    f += 0.1250*noise( p );
    return f;
}

float get_density_at_pos(vec3 p)
{
    float d = (SPHERE_RADIUS - length(p)) / SPHERE_RADIUS;
    float noise_mult = fbm(NOISE_SCALE * (p + vec3(xMove*iTime, yMove*iTime, zMove*iTime)));
    return clamp(noise_mult * SPHERE_DENSITY * d, 0.0, 1.0);
}

//TODO: actual Rayleigh scattering
vec3 get_scatter_color(vec3 p)
{
    float absorption = 0.0;
    vec2 m = 2.0 * iMouse.xy / iResolution.xy - 1.0;
    vec3 light_pos = vec3(20.0 * m, 10.0);
    vec3 light_dir = normalize(light_pos - p);
    
    float t = 0.0;
    float rd = SCATTER_DIST / float(SCATTER_DEPTH);
    
    for(int i = 0; i < SCATTER_DEPTH; i++)
    {
    	vec3 sp = p + t * light_dir;
        float d = get_density_at_pos(sp);
        absorption += d;
    	t+= rd;
    }
    
   
    return clamp((LIGHT_COLOR * LIGHT_COLOR_SCALE) * (VOLUME_COLOR * VOLUME_COLOR_SCALE ) - absorption * (ABSORPTION_COLOR * ABSORPTION_COLOR_SCALE), 0.0, 1.0);
}


void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
	//1 : retrieve the fragment's coordinates
	vec2 uv = ( fragCoord.xy / iResolution.xy ) * 2.0 - 1.0;
	//preserve aspect ratio
	uv.x *= iResolution.x / iResolution.y;


	//2 : camera position and ray direction
	vec3 pos = vec3( 0.,0.,-3.);
	vec3 dir = normalize( vec3( uv, 1. ) );

	vec3 ip;
    float t = 0.0;
    float density = 0.0;
    vec3 march_color = BG_COLOR;
    float rd = MARCH_DIST / float(MARCH_COUNT);
    for(int i = 0; i < MARCH_COUNT; i++)
    {
        ip = pos + dir * t;
        float d = get_density_at_pos(ip);

        density += d;
        vec3 c = get_scatter_color(ip);
        march_color += density * c;
        t += rd;
    }
    

	//4 : apply color to this fragment
	fragColor = vec4(march_color, 1.0);

}