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

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


float noise(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 pos) {
    // properties
    const int octaves = 6;
    float lacunarity = 2.0;
    float gain = 0.5;
    mat3 m = mat3( 0.00,  0.80,  0.60,
              -0.80,  0.36, -0.48,
              -0.60, -0.48,  0.64 );

    // initial values
    float value = 0.0;
    float amp = 0.5;
    float frq = 0.0;

    // loop of octaves
    for (int i = 0; i < octaves; i++)
    {
        value += amp*noise(pos);
        pos = m*pos*lacunarity;
        amp *= gain;
        lacunarity += 0.01;
    }
    return value;
}


//--------------------------------------------
// Main SDF

// Cloud density function
float smokeVolume(vec3 p, float scale, float timeOffset)
{
    vec3 pn = p/scale;
    // a sphere centered at the world origin, of size 1 with noisy boundaries
    return attenuationCoefficient * (1.0 - smoothstep(0.9, 1.2, length(pn) + fbm(pn + vec3(0,0,timeOffset))));
}

//--------------------------------------------
// Ray marching in view frustum
// returns accumulated volume density on the travelled segment along the ray
float rayMarch(vec3 ray_d,
               mat4 invViewMat,
               float viewDepth,
               vec2 nearFar,
               float marchSteps,
               float volumeScale,
               float timeOffset)
{
    float accumDensity = 0;

    // march on the segment [start;end]; start/end being the intersections of the ray with the near/far planes.
    vec3 start = (nearFar.x / ray_d.z) * ray_d;
    vec3 end = (nearFar.y / ray_d.z) * ray_d;
    // size of one marching step
    float s = distance(start, end) / marchSteps;

    for (int i = 0; i < marchSteps; ++i) {
        vec3 pos = mix(start, end, float(i) / float(marchSteps));
        // ss is equal to the march step if we don't hit the surface, otherwise it's the distance from the beginning of the step to the surface
        float ss = s * (1.0 - max(0.0, (viewDepth - pos.z) / (-ray_d.z * s)));
        // back to world space to evaluate the volume density, which is defined in world space
        vec3 worldPos = (invViewMat * vec4(pos,1.)).xyz;
        // evaluate volume density
        // FIXME: we should probably evaluate the volume in the middle of the step along the ray (something like mix(start, end, (float(i)+0.5) / float(marchSteps)))
        float d = smokeVolume(worldPos, volumeScale, timeOffset);
        accumDensity += ss*d;
        if (pos.z < viewDepth) {
            break;
        }
    }
    return max(0.0, accumDensity);
}



//--------------------------------------------
// MAIN

vec4 viewPositionFromDepth(vec2 texcoord, mat4 invProj, float z) {
    // Get the depth value for this pixel
    // Get x/w and y/w from the viewport position
    float x = texcoord.x * 2 - 1;
    float y = texcoord.y * 2 - 1;
    vec4 vProjectedPos = vec4(x, y, z * 2.0 - 1.0, 1.0);
    // Transform by the inverse projection matrix
    vec4 vPositionVS = invProj * vProjectedPos;
    // Divide by w to get the view-space position
    return vPositionVS / vPositionVS.w;
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec2 texel = 1.0/vec2(iResolution);
    ivec2 screenPos = ivec2(fragCoord);
    vec2 uv = fragCoord * texel;

    // extract near/far from projection matrix (assume perspective)
    float near    = -iCamProjMatrix[3][2]/(iCamProjMatrix[2][2]-1);
    float far     = -iCamProjMatrix[3][2]/(iCamProjMatrix[2][2]+1);
    vec2 nearFar  = vec2(near,far);

    // reconstruct fragment position in view space
    vec4 depthTex = texture(iChannel1, uv);
    vec4 viewPos  = viewPositionFromDepth(uv, iCamInvProjMatrix, depthTex.r);
    // cast ray in view space in the direction of the frag position
    float accumLinearDensity = rayMarch(normalize(viewPos.xyz),iCamInvViewMatrix,viewPos.z,nearFar,maxMarchSteps,volumeScale,iTime);

    vec4 color = texelFetch(iChannel0, screenPos, 0);
    float attenuation = exp(-accumLinearDensity);

    // attenuate color
    color.rgb =  (1.0-attenuation) * volumeColor.rgb +  attenuation * color.rgb;
    color.a = (1.0-attenuation) + color.a * attenuation;

    fragColor = color;
}