445 lines
12 KiB
GLSL
445 lines
12 KiB
GLSL
precision mediump float;
|
|
uniform vec2 u_resolution;
|
|
uniform float u_time;
|
|
uniform sampler2D texture_sampler;
|
|
uniform sampler2D texts;
|
|
|
|
// Rotate
|
|
mat2 rot2D(float angle) {
|
|
float s = sin(angle);
|
|
float c = cos(angle);
|
|
return mat2(c, -s, s, c);
|
|
}
|
|
|
|
// Exponential smoothing
|
|
float smin( float a, float b, float k )
|
|
{
|
|
k *= 1.0;
|
|
float r = exp2(-a/k) + exp2(-b/k);
|
|
return -k*log2(r);
|
|
}
|
|
|
|
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, 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time, 0.2);
|
|
}
|
|
|
|
/////////////////
|
|
// GEOMETRY //
|
|
/////////////////
|
|
|
|
float sdCylinder(vec3 p, vec3 a, vec3 b, float r)
|
|
{
|
|
vec3 ba = b - a;
|
|
vec3 pa = p - a;
|
|
float baba = dot(ba,ba);
|
|
float paba = dot(pa,ba);
|
|
float x = length(pa*baba-ba*paba) - r*baba;
|
|
float y = abs(paba-baba*0.5)-baba*0.5;
|
|
float x2 = x*x;
|
|
float y2 = y*y*baba;
|
|
|
|
float d = (max(x,y)<0.0)?-min(x2,y2):(((x>0.0)?x2:0.0)+((y>0.0)?y2:0.0));
|
|
|
|
return sign(d)*sqrt(abs(d))/baba;
|
|
}
|
|
|
|
float sdBox( in vec2 p, in vec2 r )
|
|
{
|
|
return length( max(abs(p)-r,0.0) );
|
|
}
|
|
|
|
float sdBox2(vec3 p, vec3 b) {
|
|
vec3 q = abs(p) - b;
|
|
return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);
|
|
}
|
|
|
|
float sdSphere(vec3 p, float r){
|
|
return length(p) -r;
|
|
}
|
|
|
|
float sdTriPrism( vec3 p, vec2 h, float rot )
|
|
{
|
|
p.xy *= rot2D(rot);
|
|
const float k = sqrt(3.0);
|
|
h.x *= 0.5*k;
|
|
p.xy /= h.x;
|
|
p.x = abs(p.x) - 1.0;
|
|
p.y = p.y + 1.0/k;
|
|
if( p.x+k*p.y>0.0 ) p.xy=vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;
|
|
p.x -= clamp( p.x, -2.0, 0.0 );
|
|
float d1 = length(p.xy)*sign(-p.y)*h.x;
|
|
float d2 = abs(p.z)-h.y;
|
|
|
|
return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.);
|
|
}
|
|
|
|
|
|
//////////////////
|
|
// ANIMATION //
|
|
//////////////////
|
|
const float TWOPI = 6.28318530718;
|
|
|
|
// Rotate ring with duration d and startTime s
|
|
float ringRotateFunc(float d, float s, float timeFact) {
|
|
float maxCycles = d;
|
|
float startTime = s;
|
|
float phase = ((u_time * timeFact) - startTime) / TWOPI;
|
|
phase = min(phase, maxCycles);
|
|
return TWOPI * phase;
|
|
}
|
|
|
|
// Animate ring movements
|
|
vec3 ringAnim( in vec3 p) {
|
|
const float STARTDELAY = 2.0;
|
|
|
|
float factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9);
|
|
|
|
// delay start
|
|
if( u_time >= STARTDELAY ) {
|
|
factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9);
|
|
p.xy = rot2D(factor) * p.xy;
|
|
}
|
|
|
|
if(u_time >= 14.0) {
|
|
factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 14.0, 1.0) * 0.05), -0.9, 0.9);
|
|
p.xy = rot2D(factor * -1.0) * p.xy;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
// Animate prism movements
|
|
float prismAnim(in float x, in float delay) {
|
|
if(u_time >= delay) {
|
|
x += (0.045*clamp(sin((ringRotateFunc(2.4, delay*10.0, 10.0) * 0.4)),-0.9, 0.9));
|
|
}
|
|
return x;
|
|
}
|
|
|
|
|
|
//////////////
|
|
// SCENE //
|
|
//////////////
|
|
|
|
vec2 map(in vec3 p)
|
|
{
|
|
float mat = 0.;
|
|
// Stargate
|
|
|
|
// Ring boxes
|
|
const float an = TWOPI/24.0;
|
|
float sector = floor(atan(p.y,p.x)/an + 0.5);
|
|
float angrot = sector*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.0), vec2(0.24,0.14) ) - 0.02;
|
|
|
|
// Main ring
|
|
float d2 = abs(length(p.xy) - 1.8) - 0.2;
|
|
d = min(d,d2);
|
|
|
|
// Inner ring
|
|
float d3 = abs(length(p.xy) - 1.75) - 0.08;
|
|
d3 = smax( d3, abs(p.z - 0.1)-0.04, 0.005 );
|
|
d = max(-d3,d);
|
|
|
|
// Depth slice rings
|
|
d = smax( d, abs(p.z)-0.1, 0.02 );
|
|
|
|
// Prisms
|
|
float index = 1.0;
|
|
for(int i=0; i<8; i++ ) {
|
|
|
|
//vec3 p2 = prismAnim(p);
|
|
|
|
float secDist = TWOPI / 8.0; // sector distance
|
|
float angle = ((24.67 / TWOPI )); // sector size
|
|
vec3 q = p;
|
|
float rotationIncrement = angle + (index * secDist);
|
|
|
|
// Nudge first and the last prism out of the ground
|
|
if (i == 1) {
|
|
rotationIncrement = rotationIncrement + 0.2;
|
|
}
|
|
if (i == 7) {
|
|
rotationIncrement = rotationIncrement - 0.2;
|
|
}
|
|
|
|
float prismSector = floor(atan(p.y,p.x)/(rotationIncrement) + 0.5);
|
|
q.xy = rot2D(rotationIncrement) * q.xy;
|
|
|
|
// We can now call each prism by it's index
|
|
// draw all except the middle bottom prism
|
|
if (i > 0) {
|
|
|
|
q.x = q.x - 1.95;
|
|
|
|
if(i == 1) {
|
|
q.x = prismAnim(q.x, 13.0);
|
|
}
|
|
|
|
if(i == 2) {
|
|
q.x = prismAnim(q.x, 26.0);
|
|
}
|
|
|
|
float d4 = sdTriPrism(vec3(q.x, q.y - 0.0 , q.z - 0.0), vec2(0.2,0.2), 0.5) - 0.02;
|
|
d = min(d, d4);
|
|
}
|
|
|
|
index += 1.0;
|
|
}
|
|
|
|
//Rotating glyphs
|
|
vec3 p2 = ringAnim(p);
|
|
float an2 = (TWOPI/32.0);
|
|
float sector2 = floor((atan(p2.y,p2.x)/an2) + 0.5 );
|
|
float angrot2 = sector2*an2;
|
|
vec3 q2 = p2;
|
|
q2.xy = rot2D(angrot2)*q2.xy;
|
|
float d5 = sdBox2( q2.xyz - vec3(1.75,0.0,0.0), vec3(0.04, 0.14, 0.05) ) - 0.02;
|
|
d = min(d, d5);
|
|
|
|
|
|
// Gate Base
|
|
const float stepHeight = 0.1;
|
|
float stepDist = 1.5;
|
|
const float stepWidth = 2.0;
|
|
float steps = 1000.;
|
|
|
|
for(int i = 0; i < 4; i++) {
|
|
float step = sdBox2(vec3(p.x,p.y+stepDist,p.z), vec3(stepWidth,stepHeight,stepDist)) - 0.05;
|
|
steps = min(steps, step);
|
|
d = min(d, step);
|
|
stepDist += stepHeight * 2.0;
|
|
}
|
|
|
|
float water = 1000.;
|
|
if (u_time > 2.0){
|
|
float cylinder1 = sdCylinder ( p, vec3(0.,0.,0.0), vec3(0.,0.,-0.01), 1.6);
|
|
float cylinder2 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1), (2. - (u_time*2.0 - 2.0*2.0)));
|
|
float cylinder3 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1.), 1.6);
|
|
float disp = 0.;
|
|
if (u_time > 5.0){
|
|
disp = displacement(p+4.)*min(((u_time-5.0)*0.5), 0.25);
|
|
}
|
|
cylinder1 = cylinder1 + disp;
|
|
water = max(-cylinder2, cylinder1);
|
|
water = max(water, cylinder3);
|
|
d = min(d, water);
|
|
}
|
|
|
|
if (d==min(water,0.1))
|
|
{
|
|
mat = 1.0;
|
|
}
|
|
else if (d==min(steps, 0.1))
|
|
{
|
|
mat = 2.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 < 50; i++) {
|
|
vec3 p = ro + rd * t; // "cast" rays
|
|
d = map(p).x; // Get distance to objects
|
|
t += d; // "march" the ray
|
|
if (abs(d) < .001 || t > 80.) 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( d<length(lightPos-p)) dif *= shadow;
|
|
return dif;
|
|
}
|
|
|
|
float getAmbientOcc(vec3 p, vec3 n) {
|
|
float occ = 0.;
|
|
float weight = 1.;
|
|
for (int i = 0; i < 8; i++) {
|
|
float len = 0.01 + 0.02 * float(i*i);
|
|
float dist = map(p+n*len).x;
|
|
occ += (len - dist) * weight;
|
|
weight *=0.85;
|
|
}
|
|
return 1.0 - clamp(0.6 * occ, 0., 1.);
|
|
}
|
|
|
|
vec3 applyFog(vec3 col, float t, vec3 rd, vec3 lightDir, float b ) {
|
|
float fogAmount = 1.0 - exp(-t*b);
|
|
float sunAmount = max( dot(rd, lightDir), 0.0 );
|
|
vec3 fogColor = mix( vec3(0.3686, 0.2431, 0.4392), // blue
|
|
vec3(0.4, 0.7294, 0.9216), // yellow
|
|
pow(sunAmount,8.0) );
|
|
return mix( col, fogColor, fogAmount );
|
|
}
|
|
|
|
|
|
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) {
|
|
// float random = noise(gl_FragCoord.xy, 0.01+u_time);
|
|
// float random2 = noise(gl_FragCoord.xy, .2+u_time);
|
|
//col += 0.075*clamp(vec3(0.5*random, 0.5*random2, 0.5*random), 0.02, 1.); // dither
|
|
|
|
// Normalized pixel coordinates (from 0 to 1)
|
|
vec2 screenCoord = gl_FragCoord.xy/u_resolution.xy;
|
|
|
|
// Vignette
|
|
float radius = 0.8;
|
|
float d = smoothstep(radius, radius-0.4, length(screenCoord-vec2(0.5)));
|
|
col = mix(col, col * d, .9);
|
|
|
|
// Contrast
|
|
float constrast = .4;
|
|
col = mix(col, smoothstep(0.0, 1.0, col), constrast);
|
|
|
|
// Colour mapping
|
|
col *= vec3(1.0, 1.0, 1.0);
|
|
col = pow( col, vec3(1.0/2.2) ); // gamma
|
|
|
|
// fade in at the beginning
|
|
//col*=vec3(clamp((u_time-1.8)*0.5,0., 1.));
|
|
|
|
// fade out at the end
|
|
// col*=vec3(clamp((120.-u_time)*.35, 0., 1.));
|
|
|
|
return col;
|
|
}
|
|
|
|
void main()
|
|
{
|
|
// Initialization
|
|
vec2 uv = (gl_FragCoord.xy * 2. - u_resolution.xy) / u_resolution.y;
|
|
//vec2 m = iMouse.xy/u_resolution.xy;
|
|
|
|
vec3 ro = vec3(0, 2, 6);
|
|
//ro.yz *= rot2D(-m.y*3.14+1.);
|
|
//ro.xz *= rot2D(-m.x*6.2831);
|
|
|
|
//vec3 ro = vec3(0,0,-3); // ray origin
|
|
|
|
vec3 rd = getCameraRayDir(uv, ro, vec3(0, 0., 0.), 1.); // ray direction
|
|
vec3 col = vec3(0); // color
|
|
|
|
if(u_time > 0.0)
|
|
{
|
|
float d = rayMarch(ro, rd);
|
|
|
|
if (d < 25.)
|
|
{
|
|
// 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 = 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( -3, 5, 5), 1., 0.2);
|
|
// Color for light 2
|
|
col += vec3(dif * vec3(0.502, 0.2824, 0.102));
|
|
|
|
dif = getLight(p, vec3( 3, -2, 5), 0.5, .8);
|
|
// Color for light 2
|
|
col += vec3(dif * vec3(0.1686, 0.2784, 0.6392));
|
|
|
|
vec3 n = getNormal(p);
|
|
float occ = getAmbientOcc(p,n);
|
|
vec3 dir = vec3(1. , 10., 1.);
|
|
float ind = clamp( dot( n, normalize(dir )), 0.0, 1.0 );
|
|
col += vec3(0.1255, 0.1255, 0.1137) * occ * ind;
|
|
|
|
if(mat==0.){
|
|
col *= vec3(.7,0.7,0.7);
|
|
}
|
|
else if(mat==1.){
|
|
col *= (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)) + vec3(0.,0.,0.5);
|
|
}
|
|
else if(mat==2.){
|
|
col *= vec3(0.3608, 0.1765, 0.0471) - 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);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
gl_FragColor = vec4(postProcess(col), 1);
|
|
}
|
|
|
|
else {
|
|
|
|
// ************* post-process pass ******************
|
|
// Uncomment this to try a post-processing "effect"
|
|
|
|
gl_FragColor = texture2D(texture_sampler, (gl_FragCoord.xy / u_resolution ));
|
|
|
|
}
|
|
}
|