513 lines
11 KiB
Plaintext
513 lines
11 KiB
Plaintext
#version 130
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const int shader= 2;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Parameters from our host
|
|
// x: Scene.Zeit
|
|
// y: Base drum envelope
|
|
// z: Snare drum envelope
|
|
// w: undefinded
|
|
in vec4 Y;
|
|
|
|
// Position of the fragment
|
|
in vec2 Z;
|
|
|
|
// All data of our world
|
|
float L, CurScene, CurTime, CurAnim, cFac, CurStep, VolLight, pi2= 6.28319, LightHeight = 50.0;
|
|
int m;
|
|
vec3 cRes, CurColor, RayStep;
|
|
|
|
vec2 rotate(vec2 v,float y)
|
|
{
|
|
return cos(y)*v+sin(y)*vec2(-v.y,v.x);
|
|
}
|
|
|
|
//repeat around y axis w times
|
|
//void rp(inout vec3 p, float trans, float w)
|
|
float repeatr(inout vec2 v,float x, float y)
|
|
{
|
|
float a= atan(v.y,v.x);
|
|
float z=mod(a,y)-y*.5;
|
|
v=(length(v))*vec2(cos(z),sin(z));
|
|
v.x-=x;
|
|
return a-z;
|
|
}
|
|
|
|
void repeat( inout float w, float y )
|
|
{
|
|
w= mod( w - y*.5, y ) - y*.5;
|
|
}
|
|
|
|
void repeate( inout float w, float y, float z )
|
|
{
|
|
w= max( abs(w)-z, mod( w - y*.5, y ) - y*.5);
|
|
}
|
|
|
|
float CBox( in vec3 p, in vec3 box, float rad )
|
|
{
|
|
return length( max( abs(p) - box + vec3(rad), 0.0 ) ) - rad;
|
|
}
|
|
|
|
|
|
float plasm(float x, float a, float b,float c)
|
|
{
|
|
return sin(x+a+c*sin(x+b));
|
|
}
|
|
|
|
vec3 shad2move()
|
|
{
|
|
return vec3( CurTime*19.0, 24.0 - cos(CurAnim*9.0) * 8.0, cos(CurAnim*5.0) * 24.0);
|
|
}
|
|
|
|
void schad3transform( inout vec3 p )
|
|
{
|
|
p.xz = rotate(p.xz, 0.2 * cos( pow(abs(p.x),0.4 - CurTime * 0.1)) );
|
|
p.yx = rotate(p.yx, 0.2 * cos( pow(abs(p.x),0.3 + CurTime * 0.1)) );
|
|
}
|
|
|
|
float f0(vec3 p)
|
|
{
|
|
if( shader == 0 )
|
|
{
|
|
schad3transform(p);
|
|
repeat(p.x, 0.5);
|
|
return max( length(p.x) - 0.1, CBox( p, vec3(1000.,1.4,1.4), .5));
|
|
}
|
|
if( shader == 1 )
|
|
{
|
|
p -= shad2move();
|
|
//p.y = rotate(p.yz, 50. *CurAnim );
|
|
p.x = length (p.xz)+4*Y.y - 12.5;
|
|
repeat (p.x, 24.0);
|
|
return length( max( abs(p.xy) - vec2(3., .2), 0.0 ) ) - 0.2;
|
|
}
|
|
if( shader == 2 )
|
|
{
|
|
float d = p.x;
|
|
repeat(p.x, pi2);
|
|
p.y -= 0.3 * cos( (p.z + d - p.x)*.5);
|
|
p.z += 128.0 * CurTime * cos(0.7 * (d-p.x) );
|
|
repeat(p.z, 2.4);
|
|
return CBox( p, vec3(1.0, 0.1, 1.0), 0.1);
|
|
}
|
|
if( shader == 3 )
|
|
{
|
|
p.x -= 128. * CurAnim;
|
|
repeat(p.x, 64.);
|
|
p.x = length( p.x ) - 11.;
|
|
return (p.x < 0.0 ? length( p.yz ): length( p )) - 5.0 ;
|
|
}
|
|
}
|
|
|
|
float f1(vec3 p)
|
|
{
|
|
if( shader == 0 )
|
|
{
|
|
float d = p.y - 5.;
|
|
p.x *= 1.0;
|
|
repeat(p.x, 20.);
|
|
repeatr(p.yz, 28.0, pi2 / 9.0);
|
|
return max( d, CBox( p, vec3(10.,2.0,10.), 3.));
|
|
}
|
|
if( shader == 1 )
|
|
{
|
|
vec3 o= p;
|
|
repeat(p.x, 8.0);
|
|
repeat(p.z, 8.0);
|
|
o -= shad2move();
|
|
p.xz = rotate(p.xz, atan(o.x, o.z) );
|
|
p.yz = rotate(p.yz, atan(length(o.xz), 48.0) );
|
|
float d = CBox( p, vec3(2.5 , 2.0, 2.5), 0.8);
|
|
p.y += 12.;
|
|
return max(d, length(p)- 12.);
|
|
}
|
|
if( shader == 2 )
|
|
{
|
|
float d = p.z;
|
|
repeat(p.z, pi2);
|
|
p.y += 0.3 * cos( (p.x + d - p.z)*.5);
|
|
return CBox( p, vec3(1000.0, 0.1, 2.0), 0.1);
|
|
}
|
|
if( shader == 3 )
|
|
{
|
|
p.z = length(p.z) + 15.;
|
|
float d = length(p.y) - 15.;
|
|
repeat(p.x, 100.);
|
|
//repeat(p.y, 9.);
|
|
repeatr(p.zy, 85.0, pi2 / 40.0);
|
|
repeatr(p.zx, 58.0, pi2 / 50.0);
|
|
return max( d, CBox( p, vec3(4.,3.,1.), 1.)); //max( length(p) - 64., CBox( p, vec3(4.,4.,80.), 1.));
|
|
}
|
|
}
|
|
|
|
float f2(vec3 p)
|
|
{
|
|
if( shader == 0 )
|
|
{
|
|
schad3transform(p);
|
|
p.x += 256.0 * CurAnim;
|
|
repeat(p.x, 32.0);
|
|
return length(vec2(length(p.yz) - 3.0,p.x)) - 1.- Y.y;
|
|
}
|
|
if( shader == 1 )
|
|
{
|
|
return length(p-shad2move()) - 12.0;
|
|
}
|
|
if( shader == 2 )
|
|
{
|
|
p.y -= 8.;
|
|
|
|
float d = p.x;
|
|
repeat(p.x, 32.0);
|
|
|
|
p.yz = rotate(p.yz, plasm(d-p.x, 2., CurAnim, 1.0)- Y.z );
|
|
p.xz = rotate(p.xz, plasm(d-p.x, 1., CurAnim, 2.0) );
|
|
|
|
return CBox( p, vec3(8.0), 6. - CurAnim);
|
|
}
|
|
if( shader == 3 )
|
|
{
|
|
p.yz = rotate(p.yz, plasm(round(p.x / 8.0), 1., 4.0*CurTime, 2.0) );
|
|
repeat(p.x, 8.0);
|
|
repeatr(p.yz, 0.0, pi2 / 10.0);
|
|
return max( abs(length(p.yz) - 6.0)-.2, abs(length(p.xz) - 2.+0.5*Y.y)-.3);
|
|
}
|
|
}
|
|
|
|
float f3(vec3 p)
|
|
{
|
|
if( shader == 0 )
|
|
{
|
|
schad3transform(p);
|
|
return CBox( p, vec3(1000.,1.,1.), .1);
|
|
}
|
|
if( shader == 1 )
|
|
{
|
|
p.y += 20.;
|
|
repeat( p.x, 6.3);
|
|
repeat( p.z, 1.3);
|
|
//repeatr(p.xz, .0, pi2 / 4.0);
|
|
return CBox( p, vec3(3.0, 15.0, 0.5), 0.4);
|
|
}
|
|
if( shader == 2 )
|
|
{
|
|
p.y -= 20.;
|
|
repeat( p.x, 20.0);
|
|
repeat( p.z, 20.0);
|
|
repeatr(p.xz, .0, pi2 / 4.0);
|
|
return CBox( p, vec3(1000.0, 1.0, 1.0), 0.2);
|
|
}
|
|
if( shader == 3 )
|
|
{
|
|
repeat(p.z, 6.);
|
|
repeat(p.x, 5.5);
|
|
repeatr(p.xz, 2.0, pi2 / 6.0);
|
|
return max( abs(1.-length(p.xz))-0.1,abs(length(p.y)-15.0)-0.1);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
float f(vec3 p)
|
|
{
|
|
return (Y.y * 0.003+0.001) * plasm(p.x+Y.y*9., p.y, p.z, 1.0-Y.y) + min( min( min( f0(p), f1(p) ), f2(p) ), f3(p) );
|
|
}
|
|
|
|
float l(vec2 p)
|
|
{
|
|
float d = floor(0.5 - p.y/32.0) + floor(0.5 - p.x/70.0) * 3.;
|
|
if( shader == 1 || shader == 2 )
|
|
{
|
|
d= plasm( 33.0 * floor(0.5 - p.y/20.0), 17.0 * floor(0.5 - p.x/20.0), floor(CurTime * 8.0), 1.0);
|
|
repeate( p.x, 20.0, 60.0 );
|
|
repeat( p.y, 20.0);
|
|
L = length( max( abs(p) - vec2(3.0), 0.0 ) ) + 2.0;// max( length(p.x), length(p.y));
|
|
if (d > 0.5)
|
|
L /= 1.0 - 0.5 * Y.y;
|
|
else
|
|
L /= 1.0 - 0.5 * Y.z;
|
|
//float sync = shader == 1 ? Y.z : Y.y;
|
|
//repeate( p.x, 20.0, 60.0 );
|
|
//repeate( p.y, 20.0, 100.0 );
|
|
//vec2 q = p;
|
|
//q.y += 10;
|
|
//repeat (q.y, 40.0);
|
|
//repeat( p.y, 20.0);
|
|
//repeat( p.x, 20.0);
|
|
//L = length( max( abs(p) - vec2(3.0), 0.0 ) ) + 1.0;// max( length(p.x), length(p.y));
|
|
//L = L * step(q.y, 0) + L * step(0, q.y) / (1.0 - 0.3 * sync);
|
|
//L /= (1.0 - Y.y) * (step(0, q.y));
|
|
}
|
|
else
|
|
{
|
|
repeate( p.y, 32.0, 32.0 );
|
|
repeat( p.x, 70.0 );
|
|
p.x = length(p.x) - 25.0;
|
|
L = 2.0 + (p.x < 0. ? length(p.y) : length(p));
|
|
L *= 1.0 - 0.5 * Y.z;
|
|
}
|
|
if( CurScene == 0 )
|
|
return max(0., 4.0 * smoothstep(10.,-pow(sin(d+CurTime*15.0*CurTime*220.0)+CurTime*15.0-4.0,.2),L));
|
|
|
|
return 4.0 * smoothstep(10.,0.0,L);
|
|
}
|
|
|
|
void mat(vec3 p)
|
|
{
|
|
CurColor = vec3(1.,1.,0.);
|
|
CurStep= .3;
|
|
//CurNormal.y= 1.5;
|
|
|
|
float z= f0(p);
|
|
if( z > f1(p) )
|
|
{
|
|
z= f1(p);
|
|
CurColor = vec3(0.1);
|
|
CurStep= 0.85;
|
|
//CurNormal.y= 0.15;
|
|
}
|
|
|
|
if( z > f2(p) )
|
|
{
|
|
z= f2(p);
|
|
CurColor = vec3(0.6,0,0.15);
|
|
CurStep= .2;
|
|
//CurNormal.y= 0.0;
|
|
}
|
|
|
|
if( z > f3(p) )
|
|
{
|
|
//Wz= f3(p);
|
|
|
|
CurColor = vec3(.25);// + animTex(p.zy / 10.0) * 0.6;
|
|
CurStep= .1;
|
|
m=2;
|
|
}
|
|
}
|
|
|
|
|
|
void ToRes(vec3 Color, float Factor)
|
|
{
|
|
cRes+= Color * cFac;
|
|
cFac*= Factor;
|
|
}
|
|
|
|
void main()
|
|
{
|
|
CurScene= floor(Y.x);
|
|
CurTime= Y.x - CurScene;
|
|
CurAnim= CurTime;
|
|
|
|
// Get the look direction for the current pixel (always look forwards)
|
|
vec3 rayDir = vec3( 0.6, (Z.yx - 0.5));
|
|
|
|
//Kamera sitzt an dieser Position
|
|
vec3 p;
|
|
|
|
if( CurScene == 0.0 )
|
|
{
|
|
p= vec3( CurTime * 120. - 120. , -24.0, .0);
|
|
rayDir.xy= rotate( rayDir.xy, CurTime - 0.9 );
|
|
//rayDir.xz= rotate( rayDir.xz, CurTime );
|
|
//rayDir.yz= rotate( rayDir.yz, 0.9 - CurTime );
|
|
}
|
|
else if( CurScene == 1.0 )
|
|
{
|
|
p= vec3( 0., 5.0, -2.0);
|
|
rayDir.xy= rotate( rayDir.xy, -0.4 );
|
|
rayDir.xz= rotate( rayDir.xz, CurTime );
|
|
CurAnim= CurTime*CurTime;
|
|
}
|
|
else if( CurScene == 2.0 )
|
|
{
|
|
p= vec3( -CurTime * 200. + 140, -2., 5.0);
|
|
rayDir.xy= rotate( rayDir.xy, CurTime-0.8 );
|
|
rayDir.xz= rotate( rayDir.xz, 3.14 );
|
|
}
|
|
else if( CurScene == 3.0 )
|
|
{
|
|
p= vec3( -25. , 0., CurTime * 20.0 - 19.0);
|
|
rayDir.xy= rotate( rayDir.xy, -0.2 );
|
|
}
|
|
else if( CurScene == 4.0 )
|
|
{
|
|
p= vec3( 0., 40.0, CurTime *8.);
|
|
rayDir.xy= rotate( rayDir.xy, -CurTime );
|
|
CurAnim= 0;
|
|
}
|
|
else if( CurScene == 5.0 )
|
|
{
|
|
p= vec3( 0., 40.0, CurTime * -64. + 56.);
|
|
rayDir.xy= rotate( rayDir.xy, -1.0 );
|
|
CurAnim= 0.4*CurTime*CurTime;
|
|
}
|
|
else if( CurScene == 6.0 )
|
|
{
|
|
p= vec3( 0., 12.0, CurTime * -12.0);
|
|
rayDir.xy= rotate( rayDir.xy, CurTime - 1.5);
|
|
rayDir.xz= rotate( rayDir.xz, CurTime );
|
|
}
|
|
else if( CurScene == 7.0 )
|
|
{
|
|
p= vec3( -4., CurTime * 64. + 4.0, 0.);
|
|
rayDir.xy= rotate( rayDir.xy, -1.0 );
|
|
rayDir.xz= rotate( rayDir.xz, -CurTime );
|
|
}
|
|
else if( CurScene == 8.0 )
|
|
{
|
|
p= vec3( 8.0, 8.0, CurTime * 24. - 32.);
|
|
rayDir.xy= rotate( rayDir.xy, -0.3 );
|
|
rayDir.xz= rotate( rayDir.xz, CurTime );
|
|
CurAnim= 0;
|
|
}
|
|
else if( CurScene == 9.0 )
|
|
{
|
|
p= vec3( CurTime * 14., 18.0, 0.);
|
|
rayDir.xy= rotate( rayDir.xy, -CurTime-0.5 );
|
|
CurAnim= CurTime*CurTime;
|
|
}
|
|
else if( CurScene == 10.0 )
|
|
{
|
|
p= vec3( 2.0, CurTime * 4. + 2.0, CurTime * 12.+ 7.);
|
|
rayDir.xy= rotate( rayDir.xy, -0.2 );
|
|
rayDir.xz= rotate( rayDir.xz, -CurTime );
|
|
}
|
|
else if( CurScene == 11.0 )
|
|
{
|
|
p= vec3( CurTime * 70. - 80., CurTime * -4. + 6.0, CurTime * 64.- 56.);
|
|
rayDir.xy= rotate( rayDir.xy, -0.2 );
|
|
rayDir.xz= rotate( rayDir.xz, CurTime );
|
|
CurAnim= 4.*CurTime;
|
|
}
|
|
else if( CurScene == 12.0 )
|
|
{
|
|
p= vec3( 30.,-8.,-8.);
|
|
rayDir.xy= rotate( rayDir.xy, 0.2 );
|
|
rayDir.xz= rotate( rayDir.xz, -CurTime + 3.0 );
|
|
CurAnim= 0.4*CurTime*CurTime;
|
|
}
|
|
else if( CurScene == 13.0 )
|
|
{
|
|
p= vec3( -60.,12.,0.);
|
|
rayDir.xy= rotate( rayDir.xy, CurTime - 1.5 );
|
|
}
|
|
else if( CurScene == 14.0 )
|
|
{
|
|
p= vec3( -22.,0.,-8.);
|
|
//rayDir.xy= rotate( rayDir.xy, 0.2 );
|
|
rayDir.xz= rotate( rayDir.xz, -CurTime + 2.0 );
|
|
//CurAnim= 0.4*Y.y;
|
|
}
|
|
else if( CurScene == 15.0 )
|
|
{
|
|
p= vec3( 80. * CurTime, 7. ,-0.);
|
|
rayDir.xz= rotate( rayDir.xz, 3.*CurTime );
|
|
}
|
|
if( CurScene == 16.0 )
|
|
{
|
|
p.x = 43.0;
|
|
rayDir.xz= rotate( rayDir.xz, pi2/2.);
|
|
CurAnim= CurTime*CurTime;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//Debugzeug fuer Kamerasteuerung
|
|
if( true )
|
|
{
|
|
p.x= gl_ModelViewMatrix[0][0];
|
|
p.y= gl_ModelViewMatrix[0][1];
|
|
p.z= gl_ModelViewMatrix[0][2];
|
|
|
|
float a1= gl_ModelViewMatrix[1][1];
|
|
float c1,s1;vec3 q1= vec3((Z.xy - 0.5), 0.8);
|
|
c1 = cos(a1); s1 = sin(a1);
|
|
rayDir.y = c1 * q1.y - s1 * q1.z;
|
|
rayDir.x= q1.x;
|
|
rayDir.z = s1 * q1.y + c1 * q1.z;
|
|
|
|
a1= gl_ModelViewMatrix[1][0];
|
|
q1=rayDir;
|
|
c1 = cos(a1); s1 = sin(a1);
|
|
rayDir.x = c1 * q1.x + s1 * q1.z;
|
|
rayDir.z = -s1 * q1.x + c1 * q1.z;
|
|
}
|
|
//Ende Debugzeug fuer Kamerasteuerung
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
rayDir = normalize(rayDir);
|
|
|
|
cRes= vec3( .0 );
|
|
cFac=1.0;
|
|
|
|
float t=0.0,y,z;
|
|
|
|
m=0;
|
|
while (m++<2)
|
|
{
|
|
//bis zu einer Oberflaeche steppen
|
|
//for (CurStep=1.0;t<220.0 && CurStep>t*.003;t+=0.01+max(0.0, CurStep),RayStep=rayDir*t )
|
|
for (CurStep=1.0;t<220.0 && CurStep>t*.003;t+=CurStep,RayStep=rayDir*t )
|
|
CurStep = f(p+RayStep);
|
|
|
|
vec3 NextPos = p+RayStep;
|
|
VolLight = 0.0;
|
|
if( p.y < LightHeight && NextPos.y > LightHeight)
|
|
{
|
|
float f = (p.y - LightHeight) / (p.y - NextPos.y);
|
|
p += RayStep*f;
|
|
VolLight = l(p.xz) * smoothstep( 220.0,0.0, f * t );
|
|
}
|
|
|
|
//Startpunkt und Richtung fuer reflektierten Strahl;
|
|
p= NextPos;
|
|
|
|
vec3 n = vec3(0.04, 0.0, 0.0);
|
|
n= normalize(vec3( f(p + n.xyy) - f(p - n.xyy), f(p + n.yxy) - f(p - n.yxy), f(p + n.yyx) - f(p - n.yyx) ));
|
|
//n= normalize(n);
|
|
//CurStep ab hier == Reflektion !!!
|
|
mat(p);
|
|
|
|
float Ambient= 0.45 + 0.4 * dot( n,vec3(0,1.0,0) );
|
|
|
|
|
|
ToRes(vec3(0.7,1.0,0.9)*VolLight,1.0-VolLight);
|
|
L= smoothstep( 0.,128., t );
|
|
ToRes(vec3( 0.0, 0.0, 0.05 )*L,1.0-L); // FogColor
|
|
|
|
if( t > 220.0 )
|
|
break;
|
|
|
|
rayDir= reflect( rayDir, n );
|
|
|
|
//float ao(vec3 p, vec3 n, float d, float i) {
|
|
y= 6.0;
|
|
for (z=1.0;y>0.;y--)
|
|
z-=(y*.5-f(p+n*y*.5))/exp2(y);
|
|
CurColor*= z*Ambient;
|
|
|
|
//CurColor*= .4 + .3 * ( dot(normalize(LightPos-p),n) );
|
|
|
|
cRes+= cFac*CurColor;//*(1.0-Reflect);
|
|
cFac*= CurStep;// Reflect * (1.0-t/tmax);
|
|
t= 0.5;
|
|
RayStep=rayDir*t;
|
|
}
|
|
|
|
|
|
gl_FragColor.xyz = cRes;// + Y.w;// + cFac*FogColor;
|
|
|
|
}
|