xTr1m/bluflame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

port from perforce

Browse Source
This commit is contained in:
Frank Tovar
2026-04-18 22:31:51 +02:00
commit 8d0ab5b7cc
8409 changed files with 3972376 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

512
evoke-64k/evk13-4k/mark.fs_3_dbg Normal file
View File

@@ -0,0 +1,512 @@
#version 130
const int shader= 3;
// 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;
}