404 lines
12 KiB
GLSL
404 lines
12 KiB
GLSL
// precision mediump float;
|
|
uniform vec2 u_resolution;
|
|
uniform float u_time;
|
|
const float PI = 22./7.;
|
|
|
|
// Rotate
|
|
mat2 rot2D(float angle) {
|
|
float s = sin(angle);
|
|
float c = cos(angle);
|
|
return mat2(c, -s, s, c);
|
|
}
|
|
|
|
float smax( float a, float b, float k )
|
|
{
|
|
float h = max(k-abs(a-b),0.0);
|
|
return max(a, b) + h*h*0.25/k;
|
|
}
|
|
|
|
float hash(vec2 p)
|
|
{
|
|
p = 50.*fract( p*0.3183099);
|
|
return fract( p.x*p.y*(p.x+p.y) );
|
|
}
|
|
|
|
float noise( in vec2 p, float scale )
|
|
{
|
|
vec2 i = floor( p );
|
|
vec2 f = fract( p );
|
|
vec2 u = f*f*(3.0-2.0*f);
|
|
return -scale+scale*mix( mix( hash( i + vec2(0.0,0.0) ),
|
|
hash( i + vec2(1.0,0.0) ), u.x),
|
|
mix( hash( i + vec2(0.0,1.0) ),
|
|
hash( i + vec2(1.0,1.0) ), u.x), u.y);
|
|
}
|
|
|
|
float displacement( vec3 p )
|
|
{
|
|
return noise(10.*p.xy+u_time+1e3, 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time+1e3, 0.2);
|
|
}
|
|
|
|
/////////////////
|
|
// GEOMETRY //
|
|
/////////////////
|
|
|
|
float sdCappedCylinder( vec3 p, float h, float r )
|
|
{
|
|
vec2 d = abs(vec2(length(p.xy),p.z)) - vec2(r,h);
|
|
return min(max(d.x,d.y),0.0) + length(max(d,0.0));
|
|
}
|
|
|
|
float sdBox( in vec2 p, in vec2 r )
|
|
{
|
|
return length( max(abs(p)-r,0.) );
|
|
}
|
|
|
|
float sdBox2(vec3 p, vec3 b) {
|
|
vec3 q = abs(p) - b;
|
|
return length(max(q,0.)) + min(max(q.x,max(q.y,q.z)),0.);
|
|
}
|
|
|
|
float sdTriPrism( vec3 p, vec2 h, float rot )
|
|
{
|
|
p.xy *= rot2D(rot);
|
|
vec3 q = abs(p);
|
|
return max(q.z-h.y,max(q.x*.866025+p.y*.5,-p.y)-h.x*.5);
|
|
}
|
|
|
|
|
|
//////////////////
|
|
// ANIMATION //
|
|
//////////////////
|
|
|
|
// POSITIONS
|
|
/*
|
|
const vec3 glyph1Pos = vec3(1.7,-1.1,0.0);
|
|
const vec3 glyph2Pos = vec3(2.0,0.0,0.0);
|
|
const vec3 glyph3Pos = vec3(1.5,1.4,0.0);
|
|
const vec3 glyph4Pos = vec3(0.0,2.0,0.0);
|
|
const vec3 glyph5Pos = vec3(1.5,1.4,0.0);
|
|
const vec3 glyph6Pos = vec3(1.5 * -1.,1.4,0.0);
|
|
const vec3 glyph7Pos = vec3(1.7 * -1.,-1.1,0.0);
|
|
*/
|
|
|
|
// DELAYS
|
|
const float STARTDELAY = 9.;
|
|
const float glyphPhase = 2.;
|
|
|
|
// COLORS
|
|
vec3 fogColor1 = vec3(.4, .2, .4); // fog color1
|
|
vec3 fogColor2 = vec3(.7, .4, .2); // fog color2
|
|
vec3 indirColor = vec3(.2, .1, .3); // indirect light color
|
|
vec3 light1Color = vec3(.9, .5, .7);
|
|
vec3 light2Color = vec3(.8, .7, .5);
|
|
|
|
// with duration d, startTime s and speed up with timeFact
|
|
float timedSine(float maxCycles, float startTime, float timeFact) {
|
|
startTime *= timeFact;
|
|
float phase = ((u_time * timeFact) - startTime) / PI;
|
|
return PI * min(phase, maxCycles);
|
|
}
|
|
|
|
float calcFactor (float startTime)
|
|
{
|
|
float factor = 9. + 9.*clamp(sin(timedSine(1.5, startTime, 4.) * 0.06), -.9, .9);
|
|
return factor;
|
|
}
|
|
|
|
// Animate ring movements
|
|
vec3 ringAnim( in vec3 p) {
|
|
for (float i = 0.; i < 7.; i++) {
|
|
float rotateDelay = STARTDELAY + (i * glyphPhase);
|
|
if(u_time > rotateDelay) {
|
|
float o = 1.;
|
|
if(mod(i,2.) >= 1.) {
|
|
o = -1.;
|
|
}
|
|
p.xy *= rot2D(calcFactor(rotateDelay)*o);
|
|
}
|
|
}
|
|
return p;
|
|
}
|
|
|
|
// Animate prism movements
|
|
float prismAnim(in float x, in float delay) {
|
|
if(u_time >= delay) {
|
|
x += (.045*clamp(sin((timedSine(3., delay, 40.) * .4)),-.8, .8));
|
|
}
|
|
return x;
|
|
}
|
|
|
|
//////////////
|
|
// SCENE //
|
|
//////////////
|
|
|
|
vec2 map(in vec3 p)
|
|
{
|
|
float mat = 0.;
|
|
// Stargate
|
|
|
|
// Ring boxes
|
|
const float an = PI/12.;
|
|
float angrot = floor(atan(p.y,p.x)/an + .5)*an;
|
|
vec3 q = p;
|
|
q.xy = mat2(cos(angrot),-sin(angrot),
|
|
sin(angrot), cos(angrot))*q.xy;
|
|
float d = sdBox( q.xy - vec2(1.8,0.), vec2(0.24,0.14) ) - .02;
|
|
|
|
// Main ring
|
|
float d2 = abs(length(p.xy) - 1.8) - .2;
|
|
d = min(d,d2);
|
|
|
|
// Inner ring
|
|
float d3 = abs(length(p.xy) - 1.75) - .08;
|
|
d3 = smax( d3, abs(p.z - .1)-.04, .005 );
|
|
d = max(-d3,d);
|
|
|
|
// Depth slice rings
|
|
d = smax( d, abs(p.z)-.1, .02 );
|
|
|
|
// Prisms
|
|
|
|
for(float i = 0.; i < 8.; i++ ) {
|
|
float secDist = PI / 4.; // sector distance
|
|
float angle = 24.67 / (PI * 2.); // sector size
|
|
vec3 q = p;
|
|
float rotationIncrement = angle + ((i+1.)*secDist);
|
|
|
|
// Nudge first and the last prism out of the ground
|
|
if (i == 1.) rotationIncrement += .2;
|
|
if (i == 7.) rotationIncrement -= .2;
|
|
q.xy = rot2D(rotationIncrement) * q.xy;
|
|
|
|
float rotateDelay = STARTDELAY + ((i - 1.) * glyphPhase + 1.5);
|
|
// We can now call each prism by it's index
|
|
// draw all except the middle bottom prism
|
|
if (i > 0.) {
|
|
q.x -= 1.95;
|
|
vec3 q2 = q; // new point for movable parts
|
|
if(u_time > rotateDelay) q2.x = prismAnim(q2.x, rotateDelay);
|
|
float prismOut = sdTriPrism(vec3(q2.x - .14, q2.y - 0. , q2.z), vec2(.22,.22), .5) - .01;
|
|
float prismIn = sdTriPrism(vec3(q2.x, q2.y, q2.z ), vec2(.2,.12), .5) - .02;
|
|
float prismTop = sdTriPrism(vec3(q.x - .06, q.y, q.z), vec2(.1,.15), .5) - .01;
|
|
float d4 = max(-prismOut, prismIn);
|
|
d4 = min(d4, prismTop);
|
|
d = min(d, d4);
|
|
|
|
// glyph locking thing material
|
|
if (d == d4) mat = 4.;
|
|
// glyph locking prism material
|
|
if( d == prismTop && u_time > rotateDelay + .2) mat = 5.;
|
|
}
|
|
}
|
|
|
|
//Rotating glyphs
|
|
vec3 p2 = ringAnim(p);
|
|
float an2 = PI/16.;
|
|
vec3 q2 = p2;
|
|
q2.xy = rot2D(floor((atan(p2.y,p2.x)/an2) + .5)*an2)*q2.xy;
|
|
float d5 = sdBox2( q2.xyz - vec3(1.75,0.,0.), vec3(.04, .14, .05) ) - .02;
|
|
d = min(d, d5);
|
|
if (d==d5) mat = 4.;
|
|
|
|
// Gate Base
|
|
float stepDist = 1.5;
|
|
float steps = 1e3;
|
|
for(int i = 0; i < 4; i++) {
|
|
float step = sdBox2(vec3(p.x,p.y+stepDist,p.z), vec3(2., .1,stepDist)) - .05;
|
|
steps = min(steps, step);
|
|
d = min(d, step);
|
|
stepDist += .2;
|
|
}
|
|
|
|
float sand = (p.y + 4.25) + 1.5*noise((vec2((p.x*.04),(p.z-40.)*.04))+100., 15.);
|
|
//sand += noise(p.yz, .25); // + 0.025*noise(p.xz*50.+100., .05);
|
|
d = min(d,sand);
|
|
|
|
float water = 1000.;
|
|
float cylinder1 = sdCappedCylinder ( p, .025, 1.6);
|
|
float cylinder2 = sdCappedCylinder ( p, 2.0, clamp((2.0 - (u_time*2.0 - 2.0*23.0)),0.,2.0));
|
|
float cylinder3 = sdCappedCylinder ( p, 0.3, 1.6);
|
|
float disp = 0.;
|
|
disp = displacement(p)*clamp(((u_time-24.0)*0.5), 0., 0.25);
|
|
cylinder1 = cylinder1 + disp;
|
|
water = max(-cylinder2, cylinder1);
|
|
water = max(water, cylinder3);
|
|
d = min(d, water);
|
|
|
|
if (d==water) mat = 1.0;
|
|
if (d==steps) mat = 2.0;
|
|
if (d==sand) mat = 3.0;
|
|
|
|
return vec2( d, mat );
|
|
}
|
|
|
|
////////////////
|
|
// DRAWING //
|
|
////////////////
|
|
|
|
float rayMarch(vec3 ro, vec3 rd) {
|
|
float t = 0.; // total distance travelled
|
|
float d;
|
|
// Raymarching
|
|
for (int i = 0; i < 90; i++) {
|
|
vec3 p = ro + rd * t; // "cast" rays
|
|
d = map(p).x; // Get distance to objects
|
|
t += d; // "march" the ray
|
|
if (abs(d) < .002 || t > 400.) break;
|
|
}
|
|
return t;
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
float d = map(p).x;
|
|
vec2 e = vec2(.01, 0.);
|
|
vec3 n = d - vec3(
|
|
map(p-e.xyy).x,
|
|
map(p-e.yxy).x,
|
|
map(p-e.yyx).x);
|
|
return normalize(n);
|
|
}
|
|
|
|
float getLight(vec3 p, vec3 lightPos, float intensity, float shadow) {
|
|
vec3 l = normalize(lightPos - p);
|
|
vec3 n = getNormal(p);
|
|
float dif = clamp(dot(n, l), 0., intensity);
|
|
// Shadows
|
|
float d = rayMarch(p+n*.0025, l);
|
|
if(abs(d)<length(lightPos-p)) dif *= shadow;
|
|
return dif;
|
|
}
|
|
|
|
vec3 applyFog(vec3 col, float t, vec3 rd, vec3 lightDir, float b ) {
|
|
float sunAmount = max( dot(rd, lightDir), 0. );
|
|
vec3 fogColor = mix( fogColor1, // blue
|
|
fogColor2, // yellow
|
|
pow(sunAmount,8.));
|
|
return mix( col, fogColor, 1.0 - exp(-t*b) );
|
|
}
|
|
|
|
vec3 getCameraRayDir(vec2 uv, vec3 p, vec3 l, float z)
|
|
{
|
|
vec3 f = normalize(l-p),
|
|
r = normalize(cross(vec3(0.,1.,0.), f)),
|
|
u = cross(f,r),
|
|
c = f*z,
|
|
i = c + uv.x*r + uv.y*u,
|
|
d = normalize(i);
|
|
return d;
|
|
}
|
|
|
|
vec3 postProcess(vec3 col) {
|
|
// Vignette
|
|
float radius = .9;
|
|
col *= smoothstep(radius, radius-.4, length(gl_FragCoord.xy/u_resolution.xy-vec2(.5)));
|
|
// Colour mapping
|
|
col *= vec3(.9, 0.8, 0.7);
|
|
// gamma
|
|
col = pow( col, vec3(.4545) );
|
|
// Contrast = a
|
|
col = smoothstep(0., 1., col);
|
|
return col;
|
|
}
|
|
|
|
vec3 cameraPos()
|
|
{
|
|
// first zoom in to the gate
|
|
vec3 cPos = vec3(0., clamp(6.-u_time,2.,6.), clamp((75.-u_time*8.),6.,75.));
|
|
if (u_time > 7.5) cPos += vec3(0., clamp(7.5-u_time,-1.,0.), 0.);
|
|
|
|
// close up shot for 1st glyph lock
|
|
if (u_time > 10.5) cPos = vec3(2.,-1.,1.);
|
|
//zoom away for 2nd glyph animation
|
|
if (u_time > 12.) cPos = vec3(-1., -1., 4.);
|
|
|
|
//close up shot for the 2nd glyph lock
|
|
// !NOTE: disabled by petri due takes alot of space and has small visual impact on the scene
|
|
/*
|
|
float delay = 11.2;
|
|
if(u_time > delay) cPos.z += (0.25 - smoothstep(-0.7,0.5,sin((timedSine(1.5, delay, 35.0))))) * 0.1;
|
|
*/
|
|
|
|
return cPos;
|
|
}
|
|
|
|
vec3 cameraPointAt() {
|
|
vec3 p = vec3(0., -.5, 0.);
|
|
// look at 1st glyph
|
|
if (u_time > 10.5) p = vec3(1.7,-1.1,0.);
|
|
// look gate at distance
|
|
if(u_time > 12.) p = vec3(.0,.1,0.);
|
|
return p;
|
|
}
|
|
|
|
// flash screen with glyph color when it is locked
|
|
vec3 colorFlashesAnim(in vec3 col) {
|
|
float delay = 10.75;
|
|
if(u_time > delay) {
|
|
float x = smoothstep(-1.,.8,sin((timedSine(.8, delay, 8.)*2.)));
|
|
col = mix(col, vec3(.95, .35, .06) * (x * 1.4), x *.76);
|
|
}
|
|
return col;
|
|
}
|
|
|
|
void main()
|
|
{
|
|
// Initialization
|
|
vec2 uv = (gl_FragCoord.xy * 2. - u_resolution.xy) / u_resolution.y;
|
|
vec3 ro = cameraPos();
|
|
vec3 rd = getCameraRayDir(uv, ro, cameraPointAt(), 2.); // ray direction
|
|
vec3 col = vec3(0.); // color
|
|
float d = rayMarch(ro, rd);
|
|
|
|
if (d < 150.) {
|
|
// Lighting
|
|
vec3 p = ro + rd * d;
|
|
float mat = map(p).y;
|
|
|
|
// Light 1 Arguments
|
|
// 1: Ray starting point
|
|
// 2: Light position
|
|
// 3: Light intensity
|
|
// 4: Shadow intensity
|
|
float dif = 0.; //getLight(p, vec3( 2, 50, 2), .5, .2);
|
|
// Color for light 1
|
|
// col = vec3(dif * vec3(0.9216, 0.9294, 0.9412));
|
|
|
|
// Light 2
|
|
dif = getLight(p, vec3( 10., 15., 25.), 1., .2);
|
|
col += dif * light1Color;
|
|
|
|
dif = getLight(p, vec3( 4., 2., -15.), 1., 1.);
|
|
col += dif * light2Color;
|
|
|
|
/*vec3 lightPosition = vec3(1.7,-1.1,0.3);
|
|
float len = length( lightPosition - p);
|
|
float att = 8.0 / (1.0 + 8.1*len + 0.01*len*len); // light attenuation
|
|
if(u_time > 10.76) {
|
|
col += vec3(dif * vec3(0.95, 0.35, 0.06) * att);
|
|
}*/
|
|
|
|
// indirect lightning -> vec3 in normalize is light direction
|
|
col += indirColor * clamp( dot( getNormal(p), normalize(vec3(0. , 1., 10.))), 0., 1.);
|
|
|
|
if(mat==0.)
|
|
col *= vec3(.3);
|
|
else if(mat==1.)
|
|
col *= vec3(0.,0.,.5); // + (noise(5.*(p.xy+2.)+u_time, -1.0) * noise(50.*(p.xy+2.), -0.4) + 0.5*noise(20.*(p.xy+2.0)-u_time, -0.5) * noise(5.*(p.xy+2.0), -0.75))*smoothstep(0.,0.75,(u_time-5.0)*0.1) + vec3(0.,0.,0.5*noise(10.*(p.xy+4.0)-u_time, -0.5));
|
|
else if(mat==2.)
|
|
col *= vec3(.3, .1, .0); // - 0.2*noise((vec2(100.*p.x+300.,75.*p.z+150.0)), -2.2) * noise((vec2(15.*p.x+2.0,3.*p.z+2.)), -1.) + noise((vec2(15.*p.x+2.4,3.*p.z+2.)), -0.25);
|
|
else if(mat==3.)
|
|
col *= vec3(.8, .8, .5) + noise(p.xz*500.+100., .3); // + noise(p.xz*1000.+5000., 0.1) + noise(p.xz*1000.+5000., 0.1);
|
|
else if(mat==4.)
|
|
col *= vec3(.1);
|
|
else if(mat ==5.)
|
|
col *= vec3(0.9, 0.3, 0.); // activated glyph color
|
|
|
|
}
|
|
float fogAmount = .01;
|
|
// col = col*exp(-d*fogAmount) + applyFog(col, d, rd, vec3(0., .3, -1.), fogAmount) * (1.0-exp(-d*fogAmount));
|
|
col = applyFog(col, d, rd, vec3(0., -.1, -1.), fogAmount);
|
|
|
|
col = colorFlashesAnim(col); // animated color flash
|
|
gl_FragColor = vec4(postProcess(col), 1.);
|
|
}
|