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

514
ev4k/mark.h Normal file
View File

@@ -0,0 +1,514 @@
@D
#version 100
@@
// Parameters from our host
// x: Scene
// y: Zeit
// z: Quadratzeit mit Faktor
// w: Aspect ratio
varying vec4 Y,Z;
// All data of our world
float CurTime, CurScene, pi=acos(-1.0), sqrtOf075= sqrt( 0.75 );
vec2 rotate(vec2 v,float y)
{
return cos(y)*v+sin(y)*vec2(-v.y,v.x);
}
//repeat around y axis w times
void repeat(inout vec2 v,float x, float y)
{
float z=mod(atan(v.y,v.x),y)-y*.5;
v=(length(v))*vec2(cos(z),sin(z));
v.x-=x;
}
//radius of the torus/ radius of the ring
float torus(vec3 p,float f)
{
return length(vec2(length(p.xz) - f,p.y));
}
float EndlessBar( vec2 p, float y, float z )
{
return length( max( abs(p) - vec2(y) + vec2(z), 0.0 ) ) - z;
}
float noise3D( vec3 p )
{
return fract( sin( p.x * 151.0 + p.y * 33.0 + p.z ) * 11.0 );
}
float smoothnoise(vec3 p)
{
vec2 e = vec2(1.0, 0.0);
vec3 o= smoothstep(0.0,1.0,fract( p ));
p= floor( p );
vec4 n= mix(
vec4(
noise3D( p+e.yyy),//n000,
noise3D( p+e.xyy),//n100,
noise3D( p+e.yxy),//n010,
noise3D( p+e.xxy)),//n110),
vec4(
noise3D( p+e.yyx),//n001,
noise3D( p+e.xyx),//n101,
noise3D( p+e.yxx),//n011,
noise3D( p+e.xxx)),//n111),
o.z);
e = mix(n.xy, n.zw, o.y);
return mix(e.x, e.y, o.x);
}
@0
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Kugel ueber Plattform
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
float f0(vec3 p)
{
return p.y - smoothnoise( p + CurTime * 3.0 ) * 0.2 + 1.0;
}
float f1(vec3 p)
{
return min( length( p+vec3(0.0,8.0,0.0))- 8.5, torus( p, 2.3)-0.5 );
}
float f2(vec3 p)
{
p.xz= rotate( p.xz, Y.z * 11.0 );
float d1= max( length( p )- 6.0, p.y );
repeat( p.xz, 5.0, pi/32.0);
p.x= abs( p.x ) - 2.;
float dist= mix( length(p.yz),length(p.xyz), step(0.0, p.x) );
return min( d1 , dist - 0.4 );
}
float f3(vec3 p)
{
p.y -= 4.0;
p.xz= rotate( p.xz, CurTime * 6.0 );
repeat( p.xz,0.0, pi/1.5);
p.yz= rotate( p.yz, pi/2.0 );
float z= torus(p, 2.4)-0.5;
return min( max( 0.5 - z , length(p) - 1.5 - Y.z * 22.0 ), z );
}
float f(vec3 p)
{
float z= min( min( f0(p), f1(p) ), f2(p) );
return max( length( p ) - 33.0, min( z, max( 0.5 - z, f3(p) ) ) );
}
@@
@1
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// riesiges Hexgitter
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
float f0(vec3 p)
{
vec3 o= p;
p.x= mod( p.x + step( 2.0 * sqrtOf075, mod( p.y, 4.0 * sqrtOf075 ) ), 2.0 ) - 1.0;
p.y= mod( p.y, 2.0 * sqrtOf075 )- sqrtOf075;
//repeatHex( p.xy );
o-= p;
p.z-= (CurScene == 10.0 ? 0.0 : 44.0) + 2.0 * smoothstep( -0.3, 0.3, cos( o.x * 0.03 + cos( o.y * 0.03 ) + CurTime * 4.0 ) * cos( o.y * 0.01 + cos( o.x * 0.02 ) ) );
float z= length( p )- 1.5;
repeat( p.xy, 0.7, pi/3.0);
return max( z, p.x );
}
float f1(vec3 p)
{
return length( p+vec3(sin( CurTime* 3.0) * 22.0,CurTime * 11.0,-22.0))- 22.0;
}
float f2(vec3 p)
{
vec3 o= p;
p.x= mod( p.x + step( 2.0 * sqrtOf075, mod( p.y, 4.0 * sqrtOf075 ) ), 2.0 ) - 1.0;
p.y= mod( p.y, 2.0 * sqrtOf075 )- sqrtOf075;
//repeatHex( p.xy );
return max( abs( p.z + 1.0 ) - 0.2, sqrtOf075 - length( p.xy ) );
}
float f3(vec3 p)
{
return length( p-vec3(22.0,22.0,-14.0))- Y.z * 33.0 - 12.0;
}
float f(vec3 p)
{
float z= min( min( f0(p), f1(p) ), f2(p) );
return max(length(p) - 77.0, min( z, max( 0.5 - z, f3(p) ) ) );
}
@@
@2
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Schlange im Tunnel
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
float f0(vec3 p)
{
//p.z-= 5.5;
vec3 o= p;
p.z= mod( p.z, 11.0 ) - 5.5;
o-= p;
p.xy= rotate( p.xy, o.z + smoothstep( -0.2, 0.2, cos( CurTime * 5.0 + cos( o.z * 33.0 ) ) ) );
repeat( p.xy, 4.8, pi/4.5 );
return EndlessBar( p.xz, 1.0, 0.3 );
}
float f1(vec3 p)
{
return 99.0;
}
float f2(vec3 p)
{
//p.z-= CurTime * 33.0;
p.z= mod( p.z, 7.0 ) - 3.5;
repeat( p.xy, 0.0, pi/4.0 );
return max( abs( length( p.xy ) - 9.0 ) - 0.2, 3.0 - length( p.yz ) );
}
float f3(vec3 p)
{
p.z+= CurTime * 33.0;
p.xy= rotate( p.xy, p.z * 0.2 - CurTime * 8.0 );
p.x+= 1.0;
float z= 3.5 * smoothstep( -22.0, 0.0, p.z ) - 3.0 + Y.z * 17.0;
p.z= mod( p.z, 0.2 ) - 0.1;
return torus( p.xzy, z ) - 1.0;
}
float f(vec3 p)
{
float z= min( min( f0(p), f1(p) ), f2(p) );
return max( length( p ) - 66.0, min( z, max( 0.5 - z, f3(p) ) ) );
}
@@
@3
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Wellenlinien
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
float f0(vec3 p)
{
return 99.0;
}
float f1(vec3 p)
{
p.y+= cos( p.x * 0.3 + cos( p.z * 0.3 ) + CurTime * 4.0 ) * cos( p.z * 0.1 + cos( p.x * 0.2 ) ) + 8.0;
p.xz= rotate( p.xz,CurTime * 22.0 );
p.z= mod( p.z, 3.0 ) - 1.5;
return EndlessBar( p.yz, 1.0, 0.25 );
}
float f2(vec3 p)
{
p.y+= cos( p.x * 0.3 + cos( p.z * 0.3 ) + CurTime * 4.0 ) * cos( p.z * 0.1 + cos( p.x * 0.2 ) );
p.xz= rotate( p.xz,CurTime * 11.0 );
p.z= mod( p.z, 3.0 ) - 1.5;
return EndlessBar( p.yz, 0.5, 0.25 );
}
float f3(vec3 p)
{
return length( p+vec3(-11.0,-16.0,-22.0) ) - Y.z * 33.0 - 12.0;
}
float f(vec3 p)
{
float z= min( min( f0(p), f1(p) ), f2(p) );
return max( length( p ) - 66.0, min( z, max( 0.5 - z, f3(p) ) ) );
}
@@
void main()
{
CurScene= Y.x;
CurTime= Y.y;
// Get the look direction for the current pixel (always look forwards)
vec3 rayDir = vec3((Z.xy - 0.5), 1.0);
//Kamera sitzt an dieser Position
vec3 p;
@0
if( CurScene == 0.0 )
{
p= vec3( 12.0, 1.0, 0.0);
rayDir.yz= rotate( rayDir.yz, 1.0 + CurTime * -1.2 );
rayDir.xz= rotate( rayDir.xz, 3.0 - CurTime * 1.5 );
}
else if( CurScene == 1.0 )
{
p= vec3( -3.0, 3.0, -16.0 + CurTime * 10.0);
rayDir.xz= rotate( rayDir.xz, CurTime * -0.6 );
}
else if( CurScene == 2.0 )
{
p= vec3( 0.0, 12.0 - CurTime * 8.0, -16.0 + CurTime * 12.0);
rayDir.yz= rotate( rayDir.yz, 0.4 + CurTime * 0.4 );
}
else if( CurScene == 3.0 )
{
p= vec3( 2.0, 2.0, -6.0 - Y.z * 22.0);
//rayDir.yz= rotate( rayDir.yz, 0.0 );
}
@@
@3
if( CurScene == 4.0 )
{
p= vec3( 0.0, -6.5 + CurTime * 33.0, 5.0);
rayDir.yz= rotate( rayDir.yz, 1.0 );
rayDir.xz= rotate( rayDir.xz, 2.0 );
}
else if( CurScene == 5.0 )
{
p= vec3( 11.0, 2.0, 22.0 - CurTime * 66.0);
//rayDir.yz= rotate( rayDir.yz, 0.8 );
rayDir.xz= rotate( rayDir.xz, 4.0 - CurTime * 5.0 );
}
else if( CurScene == 6.0 )
{
p= vec3( 0.0, 7.0 - CurTime * 11.0, 0.0 + CurTime * -11.0 );
}
@@
@2
if( CurScene == 7.0 )
{
p= vec3( -11.0, 3.0, -28.0 - CurTime * 11.0);
rayDir.yz= rotate( rayDir.yz, 0.2 );
rayDir.xz= rotate( rayDir.xz, -2.0 + CurTime );
}
else if( CurScene == 8.0 )
{
p= vec3( -1.0, 1.0, -33.0 - CurTime * 7.0);
//rayDir.yz= rotate( rayDir.yz, 0.2 );
//rayDir.xz= rotate( rayDir.xz, -2.0 + CurTime );
}
else if( CurScene == 9.0 )
{
p= vec3( Y.z * 18.0 + 3.0 * smoothstep( 0.3, 0.4, CurTime ), Y.z * 3.0 + 3.0, CurTime * -60.0 );
rayDir.yz= rotate( rayDir.yz, 0.1 );
rayDir.xz= rotate( rayDir.xz, CurTime );
}
@@
@1
if( CurScene == 10.0 )
{
p= vec3( 33.0, 33.0, -11.0 + CurTime * 5.0);
rayDir.yz= rotate( rayDir.yz, 0.8 - CurTime );
rayDir.xz= rotate( rayDir.xz, 0.5 + CurTime );
}
else if( CurScene == 11.0 )
{
p= vec3(-11.0, -11.0, -11.0);
rayDir.yz= rotate( rayDir.yz, -CurTime * 0.7 );
rayDir.xz= rotate( rayDir.xz, -CurTime );
}
else if( CurScene == 12.0 )
{
p= vec3(33.0, 11.0, 33.0);
rayDir.yz= rotate( rayDir.yz, CurTime * 0.4 );
rayDir.xz= rotate( rayDir.xz, 1.2 + CurTime * 0.6);
}
else if( CurScene == 13.0 )
{
p= vec3( mix( 22.0 - 88.0 * Y.z, -44.0 * CurTime, CurTime), 22.0, 6.0 );
rayDir.yz= rotate( rayDir.yz, CurTime * 0.2 );
rayDir.xz= rotate( rayDir.xz, 3.4 + sqrt(CurTime) * 1.4 );
}
@@
@D
/////////////////////////////////////////////////////////////////////
//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), 1.0);
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);
vec3 cRes= vec3( .0,.0,.0 );
float cFac=1.0;
float t=smoothnoise( rayDir*666.0 )*0.2,y,z,CurStep,m=0;
while (m++<2.0)
{
//bis zu einer Oberflaeche steppen
for (CurStep=1.0;t<66.0 && CurStep>t*.003;t+=max( 0.01, CurStep+0.01) )
{
CurStep = f(p+rayDir*t);
}
if( t > 66.0 )
{
break;
}
//Startpunkt und Richtung fuer reflektierten Strahl;
p+= rayDir*t;
//vec3 n = normal(p);
vec2 e = vec2(0.04, 0.0);
vec3 n= vec3( f(p + e.xyy) - f(p - e.xyy), f(p + e.yxy) - f(p - e.yxy), f(p + e.yyx) - f(p - e.yyx) );
n= normalize(n);
z= f0(p);
//CurStep ab hier == Reflektion !!!
@0
vec3 c = vec3(0.05,.1,.2 ) * (t+5.0) * 0.2;
CurStep= .7;
@@
@1
vec3 c = vec3(0.8,.0,.0 );
CurStep= .15;
@@
@2
vec3 c = vec3(0.95,1.0,0.95 );
CurStep= .18;
@@
@3
vec3 c = vec3(0.05,.1,.2 );
CurStep= .7;
@@
if( z > f3(p) )
{
z= f3(p);
@0
c = vec3(1.0,0.0,0.0 );
CurStep= .15;
@@
@1
c = vec3(1.0,0.0,0.0 );
CurStep= .15;
@@
@2
c = vec3(1.0,0.0,0.0 );
CurStep= .15;
@@
@3
c = vec3(1.0,0.0,0.0 );
CurStep= .15;
@@
}
if( z > f1(p) )
{
z= f1(p);
@0
c = vec3(.1);
CurStep= .8;
@@
@1
c = vec3(0.05,.1,.2 );
CurStep= .7;
e.y= 0.3;
@@
@2
c = vec3(.1);
CurStep= .6;
@@
@3
c = vec3(.6);
CurStep= .3;
@@
}
if( z > f2(p) )
{
z= f2(p);
c = vec3(0.0,0.6,0.8 ) * (0.9 - 0.15 / clamp(dot( n, rayDir ), -1.0, -0.05));
@0
CurStep= .2;
e.y= 8.0;
@@
@1
CurStep= .2;
e.y= 2.0;
@@
@2
CurStep= .1;
e.y= 2.0;
@@
@3
CurStep= .2;
e.y= 5.0;
@@
}
n+= (smoothnoise( p * e.y ) + smoothnoise( p * e.y * 2.0 ) + smoothnoise( p * e.y * 4.0 )) * e.x;
n= normalize(n);
rayDir= reflect( rayDir, n );
y= 6.0;
for (z=1.0;y>0.;y--)
{
z-=(y*.5-f(p+n*y*.5))/exp2(y);
}
c*= z;
//lambertlight
n.yz= rotate( n.yz, 0.6 );
c*= .4 + .3 * ( 1.0 - abs( n.y - .9 ) );
cRes+= cFac*c;//*(1.0-Reflect);
cFac*= CurStep;// Reflect * (1.0-t/tmax);
t= 0.3;
}
p=vec3(0.8);
rayDir.yz= rotate( rayDir.yz, 0.6 );
p+= rayDir.y * 0.2;
if( m < 2 )
{
p*= vec3( 0.95, 1.1, 1.2);
}
if( rayDir.y > 0.0 )
{
repeat(rayDir.xz, 0.4, pi/8.0);
rayDir.x= abs( rayDir.x ) - .2;
p+= pow( smoothstep(.2, .0, mix( abs(rayDir.z),length(rayDir.xz), step(0.0, rayDir.x) ) ), 22.0 );
}
vec3 color = cRes + cFac*p;
gl_FragColor.xyz = length(color) * (cos((Z.y + color)*pi*2)*.125+.5);
}