SmoothDeathTransitions/Effects/transitions.fx

#ifdef GL_ES
precision mediump float;
#endif

sampler uImage0 : register(s0);
uniform float2 uResolution;
uniform float uTime;
float uProgress;

#define PI 3.14159

// Note: to whomever reads this trying to work out shaders, do NOT bundle them in one file like I have here. This is just an experiment.

float mod(float x, float y){
	float z = x;
	return z%y;
}

float4 lines(float2 st : TEXCOORD0) : COLOR0 {
    float time=uProgress*.06 + .5*PI;
    float2 ce = float2(.5,.5);
    
    float2 ef = st;
    ef.x=ef.x-0.3*mod(ef.y,0.2) + 0.2*ceil(5.*ef.y);

	float4 tex=tex2D(uImage0, st);
	float4 gl_FragColor=float4(0,0,0,0);
    float3 color = float3(0,0,0);
    //float3 notcolor = float3(0,1,0);
	float3 notcolor = tex.xyz;
    
    if(sin(time*1.+1.5*PI)>0.){
        if(ef.x-1.<sin(time)){
        	gl_FragColor=float4(notcolor,0.);  
        }else{
        	gl_FragColor=float4(color,1.);
        }
    }else{
        if(ef.x-1.<sin(time+PI)){
        	gl_FragColor=float4(color,1.);  
        }else{
			gl_FragColor=float4(notcolor,0.);
        }
    }
	
	//if(uProgress/100>st.x){gl_FragColor.r=1.;}
    return gl_FragColor;
}

float clam(float x, float minimum, float maximum){
	if(x>maximum){return maximum;}
	if(x<minimum){return minimum;}
	return x;
}

float smooth(float edge0, float edge1, float x){
	float t = clam((x - edge0) / (edge1 - edge0), 0.0, 1.0);
    return t * t * (3.0 - 2.0 * t);
}

float4 prideful(float2 st : TEXCOORD0) : COLOR0 {
    float time=uProgress*.01*2.4;
	
	float4 none=tex2D(uImage0, st);
    float4 color=none;
    float4 pink=float4(1.,.5,.5,1.);
    float4 blue=float4(.5,.7,1.,1.);
    
    for(float i=.0;i<.5;i+=.1){
        float4 use=float4(1,1,1,1);
        if(i==0. || i==.4){use=blue;}
        if(i==.1 || (i>.29 && i<.31)){use=pink;}
        float step1=smooth(0.,1.,time-i);
		//float step1=time-i;
		//float step2=time-i-1.;
    	float step2=smooth(0.,1.,time-1.-i);
        if(abs(st.y-.1-2.*i)<.1 && st.x<step1){color=use;}
    	if(abs(st.y-.1-2.*i)<.1 && st.x<step2){color=none;}
    }
    
    return color;
}

// Work on this one more later.
float4 heart(float2 ef : TEXCOORD0) : COLOR0 {
    //float time = uTime*2.;
    float time=uProgress;

    float2 ce = float2(.5,.5);
    //float2 st = gl_FragCoord.xy/u_resolution.xy;
    
    float2 st = ef; //* uResolution.x/uResolution.y;
    st.y+=.15;

    //st=(st-ce)/(6.0-clam(7.*sin(0.01*uProgress*PI), 0., 5.5))+ce;

    if(time>50)st.y+=2.;
    st.y-=1.-1.0*cos(0.01*uProgress*PI);

    st=(st-ce)/(6.0-clam(7.*sin(0.01*uProgress*PI+0.3), 0., 5.5))+ce;

    //st = (st-ce)*(1.0/(time*0.1)) + ce;
    //st.y+=sin(time/30.)*0.15;

    float3 color = float3(0,0,0);

    if (
        st.y>ce.y
        && abs(st.x-ce.x) < clam(.4*cos((ce.y-st.y)*PI), 0.0, 1.0)
        && st.y>0. && st.y<1.
        || st.y<ce.y
        && abs(st.x-ce.x)<.4
        && (
            length(st-ce+float2(.19,0.))<.21
    	 	|| length(st-ce+float2(-.19,0.))<.21
        )
	){
        return tex2D(uImage0, ef);
    }
    
    return float4(color,1.0);
}

float4 uparrow(float2 st : TEXCOORD0) : COLOR0 {
    float time=3.0*uProgress/100.;
    float2 ef = st;
    float2 ce = float2(.5,.5);
    
    float3 colour = tex2D(uImage0, ef).rgb;

    st.y-=abs(st.x-ce.x)+0.5 + 1.5;
    st.y+=time;
    if(st.y<ce.x)
        colour = float3(0,0,0);
    
    if(st.y+1.5<ce.x)
        colour=tex2D(uImage0, ef).rgb;
    
    return float4(colour, 1);
}

float4 downarrow(float2 st : TEXCOORD0) : COLOR0 {
    float time=3.0*uProgress/100.;
    float2 ef = st;
    float2 ce = float2(.5,.5);
    
    float3 colour = tex2D(uImage0, ef).rgb;

    st.y+=abs(st.x-ce.x)+0.5;
    st.y-=time;
    if(st.y<ce.x)
        colour = float3(0,0,0);
    
    if(st.y+1.5<ce.x)
        colour=tex2D(uImage0, ef).rgb;
    
    return float4(colour, 1);
}

float2 rotate(float2 st,float angle){
    float2 ce = float2(.5,.5);

	st-=ce;
	return float2(
		st.x*cos(angle)-st.y*sin(angle),
		st.x*sin(angle)+st.y*cos(angle)
	)+ce;
}

float3 star(float2 st, float3 colorOld, float3 colorNew){
    int PT = 5;
    float2 ce = float2(.5,.5);

	float angle = 2.*PI/float(PT);
	st=rotate(st,-.5*PI);
	float3 newt = colorOld;
	for(int i=0;i<PT;++i){
        st = rotate(st,angle);
        float te=st.x-ce.x; // Somehow putting this here makes this function 2 arithmetic operations per loop more efficient - just enough to actually compile with 5 points.
		if(
			te>0
			&& abs(st.y-ce.y)+.5*te<.2   
		){newt=colorNew;}
		
	}
	return newt;
}

float4 starry(float2 st : TEXCOORD0) : COLOR0 {
    // int BURST = 1; // Remind me to figure out how to compile things ps_3_0 PROPERLY (without modder's toolkit) so I can increase this a bunch.
    float2 ce = float2(.5,.5);
    float fP = uProgress;
	//float time = abs(sin(uProgress*0.5/PI));
	//float2 st = gl_FragCoord.xy/u_resolution.xy;
	
	float3 color2=float3(0,0,0);
	float3 color =tex2D(uImage0, st).rgb;
	
    if(fP>50){
        fP-=50;
        color2=color;
        color=float3(0,0,0);
    }
    float time = fP*0.07;

    float2 ef = st;
	ef=(ef-ce)/time + ce;
    ef = rotate(ef,PI);
	color=star(ef,color,color2);
	
	/*float separation = 1./(float(BURST)+1.);
	for(int i=0;i<BURST;++i){
		float2 ef = st;
		float3 offset = float3(
			separation*float(i) - (float(BURST)*separation - .5),
			0.4*sin(float(i*40)),
			separation*float(i)
		);
		ef+=offset.xy;
		float ntime = time - offset.z;
		if(ntime<0.)ntime=0.01;
		ef=(ef-ce)/(ntime) + ce;
		ef=rotate(ef,10.*offset.y+PI);
		color=star(ef,color,color2);
	}*/
		
	return float4(color,1.0);
}

float4 columns_ordered(float2 st : TEXCOORD0) : COLOR0 {
    float BURST = 16.;
    float time=uProgress/15. + .5*PI;
    float2 ce = float2(.5,.5);
    
    float3 color=tex2D(uImage0, st).rgb;
    
    float ttime = ceil(time/(PI*2.))*PI*2.-PI;
    float segment=ceil(BURST*(st.x+ttime))/BURST;
    st.y-=.3*sin(4.3*segment);
    
    if(
        abs(st.y-ce.y)<sin(time+segment)
    ){ 
        color=float3(0,0,0);
    }
    
    return float4(color,1.);
}

float4 columns_sudden(float2 st : TEXCOORD0) : COLOR0 {
    float BURST=16.;
	float time=uProgress/(10.*PI);
	float2 ce = float2(.5,.5);
	
	float3 color=tex2D(uImage0, st).rgb;
	
	float ttime = ceil(time/(PI*2.)  - .2)*PI*2.;
	
	float segment=ceil(BURST*(st.x+ttime))/BURST;
	st.y-=.3*sin(4.3*segment);
	
	float pause = abs(st.y-ce.y)+.3;
	
	if(
		.8*pause<abs(sin(time+.2*sin(segment*14.)))
	){
		color=float3(0,0,0);
	}
	
	return float4(color,1.);
}

float4 water(float2 st : TEXCOORD0) : COLOR0 {
	float time=uProgress/4.+1.5*PI;
	float2 ce = float2(.5,.5);
	
	float3 color=tex2D(uImage0, st).rgb;
    st.y = 1.-st.y;
	
	st+=.2*sin(time+st.x+.25*PI);
	st+=sin(.25*time);
	
	if(st.y<ce.y) color=float3(0,0,0);
	
	return float4(color,1.);
}

float4 wonder(float2 st : TEXCOORD0) : COLOR0 {
    float time=uProgress*0.02*PI-.5*PI;
    float2 ce = float2(.5,.5);
    float2 ef = st;
    
    float3 color=float3(0,0,0);
    
    st=rotate(st,5.*length(st-ce));
    st=rotate(st,3.*sin(time));
    st.x-=sin(time);
    
    if(st.x-ce.x>abs(.2*sin(st.y*PI+.5*PI)))color=tex2D(uImage0, ef).rgb;
    
    return float4(color,1.);
}

float4 columns_sudden_angled(float2 st : TEXCOORD0) : COLOR0 {
    float BURST=9.;
	float time=(uProgress+50.)/(10.*PI);
	float2 ce = float2(.5,.5);
	
	float3 color2=tex2D(uImage0, st).rgb;
    float3 color=float3(0,0,0);
    st = rotate(st, 0.25*PI);
	
	float ttime = ceil(time/(PI*2.)  - .2)*PI*2.;
	
	float segment=ceil(BURST*(st.x+ttime))/BURST;
	st.y-=.4*sin(4.3*segment);
	
	float pause = abs(st.y-ce.y)+.3;
	
	if(
		.8*pause<abs(1.2*sin(time+.2*sin(segment*14.)))
	){
		color=color2;
	}
	
	return float4(color,1.);
}

float4 circle(float2 st : TEXCOORD0) : COLOR0 {
	//float time=uProgress;
	float2 ce = float2(.5,.5);
	
	float4 color=tex2D(uImage0, st);
    float4 color2=float4(0,0,0,0);
    float time = 60.-1.2*uProgress;
    if(time<0.)time=uProgress*1.2-60.; // For some reason just using abs() here causes it not to compile.
    
    //st.x = st.x*(uResolution.y/uResolution.x);
    if(length(st-ce)>time*0.02)return color2;
	return color;
}

float4 doors(float2 st : TEXCOORD0) : COLOR0 {
	float time=uProgress*0.01*PI;
	float2 ce = float2(.5,.5);
	
	float4 color2=tex2D(uImage0, st);
    float4 color=float4(0,0,0,0);

    if(.5-abs(st.x-ce.x)>0.5*sin(time))return color2;
	return color;
}

float4 doom(float2 st : TEXCOORD0) : COLOR0 {
    float time=uProgress*0.02;
    if(uProgress>50.){time=2.-uProgress*0.02;}
    
    float diff=sin(ceil(st.x*100.)*2.2 + ceil(st.x*st.x*100.)*3.)*0.2 -0.4+time*2.0;
    
    if(diff>0.){
        if(uProgress>50.){st.y+=diff;}
        else{st.y-=diff;}
    }
    float4 color = tex2D(uImage0, st);
    if(st.y>1. || st.y<0.)color = float4(0,0,0,0);

    return color;
}

technique Technique1
{
	pass Lines {PixelShader = compile ps_2_0 lines();}
	pass Prideful {PixelShader = compile ps_2_0 prideful();}
    pass Loving {PixelShader = compile ps_2_0 heart();}
    pass Rising {PixelShader = compile ps_2_0 uparrow();}
    pass Falling {PixelShader = compile ps_2_0 downarrow();}
    pass Starry {PixelShader = compile ps_2_0 starry();}
    pass Winding {PixelShader = compile ps_2_0 columns_ordered();}
    pass Jaws {PixelShader = compile ps_2_0 columns_sudden();}
    pass Flooding {PixelShader = compile ps_2_0 water();}
    pass Wonder {PixelShader = compile ps_2_0 wonder();}
    pass Collapse {PixelShader = compile ps_2_0 columns_sudden_angled();}
    pass Circle {PixelShader = compile ps_2_0 circle();}
    pass Doors {PixelShader = compile ps_2_0 doors();}
    pass Doom {PixelShader = compile ps_2_0 doom();}
}