composhader_gfx.glsl.txt

#version 430
out vec4 fragColor;
layout(location = 0) uniform float iGlobalTime;
uniform sampler2D gm_BaseTexture;

//globals
vec2 iResolution = vec2(1920,1080);
vec3 rayorigin;
vec3 raydirection;

float lightCenterDist;
float lightRadius;
float lightFalloff;
float cellRadius;
float cellSize;
float halfCellSize;
float rounding;

int dofIter;
int sceneSelect;
int textLen;
int textChars[12];

bool hit;

//const float BPS = (60. / 108.);
const float BPS = .555555;
const float DEL = 1.;
const float dofFocus = 3.75;
const float dofRatio = 200.;
const float totalChars = 25.;
const float charWidth = 0.15;
const float charHeight = 0.2;

float beat()
{
    return (iGlobalTime-DEL) / BPS;
}

float cyclbeat()
{
    return mod((iGlobalTime-DEL) / BPS, 96.);
}

float saw(float beats)
{
    float wavel = BPS * beats;
    return mod(iGlobalTime-DEL, wavel) / wavel;
}

float revsaw(float beats)
{
    float wavel = BPS * beats;
    return 1. - mod(iGlobalTime-DEL, wavel) / wavel;
}

float square(float beats)
{
    float wavel = BPS * beats;
    return (mod(iGlobalTime-DEL, wavel) / wavel) < .5 ? 0. : 1.;
}

float beatstep(float beats)
{
    float wavel = BPS * beats;
    return (iGlobalTime-DEL) < wavel ? 0. : 1.;
}

mat3 rotate_x(float a){float sa = sin(a); float ca = cos(a); return mat3(vec3(1.,.0,.0),    vec3(.0,ca,sa),   vec3(.0,-sa,ca));}
mat3 rotate_y(float a){float sa = sin(a); float ca = cos(a); return mat3(vec3(ca,.0,sa),    vec3(.0,1.,.0),   vec3(-sa,.0,ca));}
mat3 rotate_z(float a){float sa = sin(a); float ca = cos(a); return mat3(vec3(ca,sa,.0),    vec3(-sa,ca,.0),  vec3(.0,.0,1.));}

float spacePlasma(vec3 p)
{
    float phase = iGlobalTime;
    vec3 po = p + vec3(sin(iGlobalTime * .01 + phase * .005) * 10.);
    po = beat() >= 192. ? po * rotate_x(iGlobalTime * .1 + p.y * .15) * rotate_z(iGlobalTime * .1) : (beat() >= 128.) ? po * rotate_z((cyclbeat() - 32.) * .025) : po;
    float val = sin(po.x * 1.8) + sin(phase * .2 + po.y * .3) * cos(po.x + po.z * 1.4) + sin(po.y * 3. - po.x * 1.5 + phase * .2);
    return sqrt(sqrt(clamp(val, 0.5, 5.)));
}

float box( vec3 p, vec3 b )
{
  vec3 q = abs(p) - b + rounding;
  return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0) - rounding;
}

float boxScene(in vec3 p)
{
    vec3 q = p * rotate_z(iGlobalTime) * rotate_x(iGlobalTime * .32);
    if (beat() > 192.) q = q - vec3(7.)*clamp(round(q/vec3(7.)),-vec3(2.),vec3(2.));
    float g = 100.;
    float scale = 7.;
    if (sceneSelect == 0) q *= .15;
    else scale = cyclbeat() < 16. ? 20. : (cyclbeat() > 64. || beat() >= 192.) ? 25. : max(5., (30. * square(2.) + 1.));

    g = min(g, box(q + vec3(-.2), vec3((1. + sin((iGlobalTime * 3. + -.3 + -.3 * 6.))) / scale)));
    g = min(g, box(q + vec3(-.1, .2, -.2), vec3((1. + sin((iGlobalTime * 2.2 + .3 + -.3 * 6. + -3. * 5.))) / scale)));

    g = min(g, box(q + vec3(0., -.2, 0.), vec3((1. + cos((iGlobalTime * 2.3 + -.3))) / scale)));
    g = min(g, box(q + vec3(0.), vec3((1. + cos((iGlobalTime * 1.4 + .3 * 5.))) / scale)));
    g = min(g, box(q + vec3(0., .2, -.2), vec3((1. + sin((iGlobalTime * 2.5 + .3 + -.3 * 5.))) / scale)));
    
    g = min(g, box(q + vec3(.2, -.2, 0.), vec3((1. + sin((iGlobalTime * 2.6 + -.3 + .3 * 6.))) / scale)));
    g = min(g, box(q + vec3(.2), vec3((1. + sin((iGlobalTime * 2.8 + .3 + .3 * 6. + -.3 * 5.))) / scale)));
    
    return -max(g, box(q, vec3(.3)));
}

float cell(vec3 p, float s)
{
    return max(length(p)-s, box(p, vec3(halfCellSize)));
}

vec3 closestFacePD(vec3 p, vec3 rd)
{
    vec3 borderp = vec3(halfCellSize) - p;
    float fxp = abs(borderp.x / rd.x);
    float fyp = abs(borderp.y / rd.y);
    float fzp = abs(borderp.z / rd.z);
    
    vec3 bordern = -vec3(halfCellSize) - p;
    float fxn = abs(bordern.x / rd.x);
    float fyn = abs(bordern.y / rd.y);
    float fzn = abs(bordern.z / rd.z);
    
    if (fxp < fyp && fxp < fzp && fxp < fxn && fxp < fyn && fxp < fzn)
    {
        return vec3(1., 0., 0.);
    }
    if (fyp < fxp && fyp < fzp && fyp < fxn && fyp < fyn && fyp < fzn)
    {
        return vec3(0., 1., 0.); 
    }
    if (fzp < fxp && fzp < fyp && fzp < fxn && fzp < fyn && fzp < fzn)
    {
        return vec3(0., 0., 1.); 
    }
    if (fxn < fyn && fxn < fzn && fxn < fxp && fxn < fyp && fxn < fzp)
    {
        return vec3(-1., 0., 0.);
    }
    if (fyn < fxn && fyn < fzn && fyn < fxp && fyn < fyp && fyn < fzp)
    {
        return vec3(0., -1., 0.); 
    }
    if (fzn < fxn && fzn < fyn && fzn < fxp && fzn < fyp && fzn < fzp)
    {
        return vec3(0., 0., -1.); 
    }
}

float sphereSize(in vec3 p)
{
    float damp = sceneSelect == 0 ? (min(length(p - rayorigin), 1.3) / 1.3) : (1. - pow(min(1., length(p * 1.5)), 2.5));
    float l = sceneSelect == 0 ? max(0., spacePlasma(p) - spacePlasma(p + vec3(.6))) : boxScene(p);
    if (beat() > 168.) l = l * max(0., length(p) - (26. * saw(32.) + beat() > 198. ? 7. : 3.)) + max(0., boxScene(p) * 4.);
    return max(.0, min(cellRadius, l * damp * damp * damp * damp));
}

float map(in vec3 p)
{
    vec3 s = vec3(cellSize);
    vec3 center = s*round(p/s);
    vec3 q = p - center;
     
    float me = cell(q, sphereSize(center));
    vec3 neighbour = center + s*closestFacePD(q, raydirection);
    vec3 npos = p - neighbour;
    float worst = cell(npos, sphereSize(neighbour));
    
    return min(worst, me);
}

vec3 calcNormal( in vec3 pos )
{
    vec2 e = vec2(1.0,-1.0)*0.5773;
    const float eps = 0.00005;
    return normalize( e.xyy*map( pos + e.xyy*eps ) + 
					  e.yyx*map( pos + e.yyx*eps ) + 
					  e.yxy*map( pos + e.yxy*eps ) + 
					  e.xxx*map( pos + e.xxx*eps ) );
}
    
float hash(in float p)
{
	vec3 p3  = fract(vec3(p) * .1031);
    p3 += dot(p3, p3.yzx + 19.19);
    return fract((p3.x + p3.y) * p3.z);
}    
    
float ambientOcclusion( in vec3 p, in vec3 n, in float maxDist, in float falloff )
{
    float ao = 0.0;
    const int nbIte = 5;
    for( int i=0; i<nbIte; i++ )
    {
        float l = hash(float(i))*maxDist;
        vec3 rd = n*l;

        ao += (l - max(map( p + rd ),0.)) / maxDist * falloff;
    }
    // TODO occlude from foreground object
    return clamp( 1.-ao/float(nbIte), 0.05, 1.);
}

vec3 colorspace(in vec3 p)
{
    return vec3(sin(p.x) + sin(p.y * 3.2), 0.4, 1. - .5 * sin(.3 * p.z));
}

vec3 fragment( in vec2 p )
{
    hit = false;
    // camera movement	
	float an = sceneSelect == 0 ? 0.05*(iGlobalTime) + sin(iGlobalTime * 0.01) : 0.5*(iGlobalTime) + sin(iGlobalTime * 0.1);
    if (beat() > 128. && beat() < 176. && sceneSelect != 0)
    {
        an += (p.y + 1.5 + saw(1.) * 1.5) * .5;
    }
	vec3 ro = sceneSelect == 0 ? vec3(6. * cos(an), square(16.) * 1.76, sin(an) * -square(32.)) : vec3(cos(an) * .3, .56, sin(an) * .3);
    rayorigin = ro;
    vec3 ta = sceneSelect == 0 ? vec3( square(32.) * -5., sin(iGlobalTime * .15), sin(iGlobalTime * .33)) : vec3(.3 * (square(16.) + .5 * sin(iGlobalTime * .2)));
    
        // camera matrix
    vec3 up = vec3(0.0,cos(iGlobalTime * 0.05) * 0.6, sin(iGlobalTime * 0.03) * 0.5);
    vec3 ww = normalize( ta - ro );
    vec3 uu = normalize( cross(ww, up) );
    vec3 vv = normalize( cross(uu, ww) );
    
    vec3 tCol = vec3(0.);
    for (int i=0; i<dofIter; i++)
    {        
        // create view ray
        vec3 rd = normalize( p.x*uu + p.y*vv + ww );
        
        // perturb view ray for DOF
        vec3 focus = ro + rd * dofFocus;
        float anX = hash(float(i*300)) / dofRatio;
        float anY = hash(float(i*400)) / dofRatio;
        rd *= rotate_y(anX) * rotate_z(anY);        
        raydirection = rd;
        
        vec3 pRo = focus - rd * dofFocus;

        // raymarch
        const float tmax = 24.0;
        float t = 0.0;
        for( int i=0; i<256; i++ )
        {
            vec3 pos = pRo + t*rd;
            float h = map(pos);
            if( abs(h)<0.00001) {
                hit = true;
                break;
            }
            if ( t > tmax )
            {
                break;
            }
            t += h;
        }     

        // shading
        vec3 col;
        if( hit )
        {
            vec3 nor = calcNormal(pRo + t*rd);
            vec3 matColor = colorspace(pRo + t*rd);

            vec3 difDir = vec3(0.7,1.8,0.4);
            vec3 ambDir = vec3(0.6,0.8,0.2);
            if (sceneSelect == 1)
            {
                difDir *= rotate_x(iGlobalTime * 1.8);
                ambDir *= rotate_x(iGlobalTime * 1.8);
            }
            float dif = clamp( dot(nor, difDir), .3, sceneSelect == 0 ? 1. : 1.66 );
            float amb = .6*dot(nor,ambDir);

            col = matColor*amb + vec3(0.9,0.8,0.6) * dif; 
            col *= ambientOcclusion(pRo + t*rd, nor, 0.075, 0.9);
            
            if (sceneSelect == 0)
            {
                vec3 lightCenter = rayorigin + ww * lightCenterDist;
                float d = length(pRo + t*rd - lightCenter);
                col *= d < lightRadius ? 1. : max(0., 1. - pow(abs((d - lightRadius) / lightFalloff), 3.5));
            }
        }

        // gamma
        col *= col;
        tCol += col / float(dofIter);
    }
    // vignette
    float dist = length(p);
    dist *= dist;
    float vign = dist < 1. ? 1. : 1. - (dist - 1.) / 3.15;
    return tCol * vign;
}

vec3 readchar(int n, in vec2 p)
{
    if (p.x < 0. || p.y < 0. || p.x > charWidth || p.y > charHeight) return vec3(0.);
    return texture(gm_BaseTexture, vec2(.99 * p.x / charWidth / totalChars + float(n) * (1. / totalChars), p.y / charHeight)).rgb;
}

vec3 text( in vec2 p )
{
    vec3 res = vec3(0);
    for (int i=0; i<textLen; i++)
    {
       res = max(res, .02 * readchar(textChars[i], p - float(i) * vec2(charWidth, 0.) - vec2(float(textLen) * -charWidth * .5, -.1) - vec2(p.y/2.+.02, -.02)));
       res = max(res, readchar(textChars[i], p - float(i) * vec2(charWidth, 0.) - vec2(float(textLen) * -charWidth * .5, -.1) - vec2(p.y/2., 0.)));
    }
    return res;
}

void main( void )
{
    vec2 p = (-iResolution.xy + 2.0*gl_FragCoord.xy)/iResolution.y;
    if (beat() < 44. || (beat() > 96. && beat() < 112.) || beat() > 208.) 
    {
        textLen = 9;
        textChars = int[12](2,24,20,5,18,9,4,5,18,0,0,0);
    }
    else if (beat() > 132. && beat() < 144.)
    {
        textLen = 5;
        textChars = int[12](7,9,13,12,5,0,0,0,0,0,0,0);
    }
    else if (beat() > 148. && beat() < 160.)
    {
        textLen = 12;
        textChars = int[12](19,15,14,10,1,24,0,2,5,1,20,19);
    }
    else 
    {
        textLen = 0;
    }
    
    fragColor = vec4(text(p), 1.);
    if (iGlobalTime-DEL > 0.)
    {
        if (fragColor.r == 0.)
        {
            if (beat() > 96. && beat() < 204.)
            {
                cellRadius = .0175;
                cellSize = .025;
                halfCellSize = .0125;
                rounding = .0035;
                sceneSelect = 1;
                dofIter = 1;

                fragColor = vec4( fragment(p), 1.0 );
                if (hit) return;
            }
            cellRadius = .175;
            cellSize = .25;
            halfCellSize = .125;
            rounding = .035;
            dofIter = 5;
            sceneSelect = 0;

            lightRadius = 6.;
            lightFalloff = 3.;
            lightCenterDist = -square(16.) * 2.;
            if (cyclbeat() < 16.)
            {
                lightCenterDist += 4.;
                lightFalloff = 2.;
                lightRadius = 1.;
            }
            else if (cyclbeat() < 32.)
            {
                lightCenterDist += 6.;
                lightRadius = square(2.) * 3.;
            }
            else if (cyclbeat() < 64.)
            {
                lightCenterDist = 6.;
            }
            else if (cyclbeat() < 96.)
            {
                if (beat() >= 96.) 
                {
                    lightCenterDist = 6.;
                }
                else
                {
                    lightCenterDist = 12.;
                    lightRadius = 9.;
                }
            }

            lightCenterDist += min(1., floor(beat() / 96.)) * 5.;
            lightFalloff += floor(beat() / 96.) * 3.;
            if (beat() >= 192. && cyclbeat() > 16.) 
            {
                lightCenterDist += (cyclbeat() - 16.) * .5;
                lightRadius -= (cyclbeat() - 16.) * .05;
            }

            fragColor = vec4( fragment(p), 1.0 );
        }
    }
}