markus/4kintro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

optimoitu

Browse Source
This commit is contained in:
Petri Järvisalo
2024-07-28 22:41:20 +03:00
parent 1d606da897
commit 02fc36ddd8
6 changed files with 441 additions and 621 deletions
Download Patch File Download Diff File Expand all files Collapse all files

399
shader.glsl
View File

@ -1,7 +1,7 @@
// precision mediump float;
uniform vec2 u_resolution;
uniform float u_time;
uniform sampler2D texture_sampler;
uniform sampler2D texts;
const float PI = 22./7.;
// Rotate
mat2 rot2D(float angle) {
@ -10,14 +10,6 @@ mat2 rot2D(float 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);
@ -41,10 +33,9 @@ float noise( in vec2 p, float scale )
hash( i + vec2(1.0,1.0) ), u.x), u.y);
}
float displacement( vec3 p )
{
return noise(10.*p.xy+u_time+999., 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time+999., 0.2);
return noise(10.*p.xy+u_time+1e3, 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time+1e3, 0.2);
}
/////////////////
@ -59,42 +50,28 @@ float sdCappedCylinder( vec3 p, float h, float r )
float sdBox( in vec2 p, in vec2 r )
{
return length( max(abs(p)-r,0.0) );
return length( max(abs(p)-r,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;
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);
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.);
vec3 q = abs(p);
return max(q.z-h.y,max(q.x*.866025+p.y*.5,-p.y)-h.x*.5);
}
//////////////////
// ANIMATION //
//////////////////
const float TWOPI = 6.28318530718;
// POSITIONS
vec3 lookAtPoint = vec3(0, -0.5, 0.);
/*
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);
@ -102,47 +79,42 @@ 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.0;
const float glyphPhase = 2.0;
const float STARTDELAY = 9.;
const float glyphPhase = 2.;
// COLORS
vec3 glyphColor = vec3(0.95, 0.35, 0.06); // glyph color
vec3 color1 = vec3(0.44, 0.29, 0.46); // fog color1
vec3 color2 = vec3(0.75, 0.45, 0.23); // fog color2
vec3 color3 = vec3(0.29, 0.17, 0.35); // indirect light color
vec3 color4 = vec3(0.7, 0.27, 0.09); // sky color1
vec3 color5 = vec3(0.09, 0.05, 0.66); // sky color2
vec3 light1Color = vec3(0.91, 0.57, 0.73);
vec3 light2Color = vec3(0.83, 0.71, 0.54);
// 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) {
float pi = TWOPI / 2.0;
startTime *= timeFact;
float phase = ((u_time * timeFact) - startTime) / pi;
phase = min(phase, maxCycles);
return pi * phase;
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.0 + 9.0*clamp(sin(timedSine(1.5, startTime, 4.0) * 0.06), -0.9, 0.9);
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.0; i<7.0; i++) {
for (float i = 0.; i < 7.; i++) {
float rotateDelay = STARTDELAY + (i * glyphPhase);
if(u_time > rotateDelay) {
if(mod(i,2.0) >= 1.0) {
p.xy = rot2D(calcFactor(rotateDelay) * -1.0) * p.xy;
} else {
p.xy = rot2D(calcFactor(rotateDelay)) * p.xy;
}
float o = 1.;
if(mod(i,2.) >= 1.) {
o = -1.;
}
p.xy *= rot2D(calcFactor(rotateDelay)*o);
}
}
return p;
@ -151,7 +123,7 @@ vec3 ringAnim( in vec3 p) {
// Animate prism movements
float prismAnim(in float x, in float delay) {
if(u_time >= delay) {
x += (0.045*clamp(sin((timedSine(3.0, delay, 40.0) * 0.4)),-0.8, 0.8));
x += (.045*clamp(sin((timedSine(3., delay, 40.) * .4)),-.8, .8));
}
return x;
}
@ -166,108 +138,80 @@ vec2 map(in vec3 p)
// Stargate
// Ring boxes
const float an = TWOPI/24.0;
float sector = floor(atan(p.y,p.x)/an + 0.5);
float angrot = sector*an;
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.0), vec2(0.24,0.14) ) - 0.02;
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) - 0.2;
float d2 = abs(length(p.xy) - 1.8) - .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 );
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)-0.1, 0.02 );
d = smax( d, abs(p.z)-.1, .02 );
// Prisms
float index = 1.0;
for(int i=0; i<8; i++ ) {
float secDist = TWOPI / 8.0; // sector distance
float angle = ((24.67 / TWOPI )); // sector size
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 + (index * secDist);
float rotationIncrement = angle + ((i+1.)*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;
}
if (i == 1.) rotationIncrement += .2;
if (i == 7.) rotationIncrement -= .2;
q.xy = rot2D(rotationIncrement) * q.xy;
float rotateDelay = STARTDELAY + ((index - 2.0) * glyphPhase + 1.5);
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) {
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 - 0.14, q2.y - 0.0 , q2.z), vec2(0.22,0.22), 0.5) - 0.01;
float prismIn = sdTriPrism(vec3(q2.x, q2.y, q2.z ), vec2(0.2,0.12), 0.5) - 0.02;
float prismTop = sdTriPrism(vec3(q.x - 0.06, q.y, q.z), vec2(0.10,0.15), 0.5) - 0.01;
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.;
}
if (d == d4) mat = 4.;
// glyph locking prism material
if(d == prismTop) {
if(u_time > rotateDelay + 0.2) {
mat = 5.;
}
}
}
index += 1.0;
if( d == prismTop && u_time > rotateDelay + .2) mat = 5.;
}
}
//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;
float an2 = PI/16.;
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;
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.;
}
if (d==d5) mat = 4.;
// Gate Base
const float stepHeight = 0.1;
float stepDist = 1.5;
const float stepWidth = 2.0;
float steps = 1000.;
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(stepWidth,stepHeight,stepDist)) - 0.05;
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 += stepHeight * 2.0;
stepDist += .2;
}
float sand = (p.y + 4.25) + 1.5*noise((vec2((p.x*0.04),(p.z-40.0)*0.04))+100., 15.);
sand += noise(p.yz, .25);
sand += 0.025*noise(p.xz*50.+100., .05);
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.;
@ -281,17 +225,9 @@ vec2 map(in vec3 p)
water = max(water, cylinder3);
d = min(d, water);
if (d==water)
{
mat = 1.0;
}
else if (d==steps)
{
mat = 2.0;
}
else if (d==sand) {
mat = 3.0;
}
if (d==water) mat = 1.0;
if (d==steps) mat = 2.0;
if (d==sand) mat = 3.0;
return vec2( d, mat );
}
@ -304,18 +240,17 @@ float rayMarch(vec3 ro, vec3 rd) {
float t = 0.; // total distance travelled
float d;
// Raymarching
for (int i = 0; i < 100; i++) {
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 (d < .001 || t > 500.) break;
if (abs(d) < .002 || t > 400.) break;
}
return t;
}
vec3 getNormal(vec3 p) {
float d = map(p).x;
vec2 e = vec2(.01, 0);
vec2 e = vec2(.01, 0.);
vec3 n = d - vec3(
map(p-e.xyy).x,
map(p-e.yxy).x,
@ -327,27 +262,24 @@ 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;
if(abs(d)<length(lightPos-p)) dif *= shadow;
return dif;
}
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( color1, // blue
color2, // yellow
pow(sunAmount,8.0) );
return mix( col, fogColor, fogAmount );
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)),
r = normalize(cross(vec3(0.,1.,0.), f)),
u = cross(f,r),
c = f*z,
i = c + uv.x*r + uv.y*u,
@ -356,103 +288,70 @@ vec3 getCameraRayDir(vec2 uv, vec3 p, vec3 l, float z)
}
vec3 postProcess(vec3 col) {
// Normalized pixel coordinates (from 0 to 1)
vec2 screenCoord = gl_FragCoord.xy/u_resolution.xy;
// Vignette
//float radius = 0.9;
//float d = smoothstep(radius, radius-0.4, length(screenCoord-vec2(0.5)));
//col = mix(col, col * d, .9);
// Contrast = a
col = mix(col, smoothstep(0.0, 1.0, col), 0.9);
float radius = .9;
col *= smoothstep(radius, radius-.4, length(gl_FragCoord.xy/u_resolution.xy-vec2(.5)));
// Colour mapping
col *= vec3(1.0, 1.0, 1.0);
col = pow( col, vec3(1.0/2.2) ); // gamma
col *= vec3(.9, 0.8, 0.7);
// gamma
col = pow( col, vec3(.4545) );
// Contrast = a
col = smoothstep(0., 1., col);
return col;
}
// zoom camera on glyph lock for extra oomph
float cameraZoomAnim(float o) {
float delay = 10.7;
if(u_time > delay) {
o += (0.25 - smoothstep(-0.7,0.5,sin((timedSine(1.5, delay, 35.0))))) * 0.1;
}
return o;
}
vec3 cameraPos()
{
// first zoom in to the gate
vec3 cPos = vec3(0, clamp(6.-u_time,2.,6.), clamp((75.-u_time*8.0),6.,75.));
if (u_time > 7.5)
{
cPos += vec3(0, clamp(7.5-u_time,-1.,0.), 0.);
}
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.0,-1.0,1.0);
}
//zoom away for 2nd glyph animation
if (u_time > 12.) {
cPos = vec3(-1.0, -1.0, 4.0);
}
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
cPos.z = cameraZoomAnim(cPos.z);
// !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 cameraPointAt() {
vec3 p = vec3(0., -.5, 0.);
// look at 1st glyph
if(u_time > 10.5) {
p = glyph1Pos;
}
if(u_time > 12.) {
p = vec3(0.0,0.1,0.0);
}
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.0,0.8,sin((timedSine(0.8, delay, 8.0)*2.0)));
col = mix(col, glyphColor * (x * 1.4), x * 0.76);
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;
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(lookAtPoint), 2.); // ray direction
vec3 col = vec3(0); // color
vec3 rd = getCameraRayDir(uv, ro, cameraPointAt(), 2.); // ray direction
vec3 col = vec3(0.); // color
float d = rayMarch(ro, rd);
if (d < 500.) {
if (d < 150.) {
// Lighting
vec3 p = ro + rd * d;
float mat = map(p).y;
// Light 1 Arguments
@ -463,68 +362,42 @@ void main()
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( -3, 5, 5), 1., 0.2);
// Color for light 2
col += vec3(dif * light1Color);
dif = getLight(p, vec3( 10., 15., 25.), 1., .2);
col += dif * light1Color;
dif = getLight(p, vec3( 3, -2, 5), 0.75, .8);
// Color for light 2
col += vec3(dif * light2Color);
dif = getLight(p, vec3( 4., 2., -15.), 1., 1.);
col += dif * light2Color;
vec3 lightPosition = glyph1Pos;
lightPosition.z = lightPosition.z + 0.3;
// dif = getLight(p, lightPosition, 3.75, 1.0);
// float minLight = 0.01;
// float radius = sqrt(1.0 / (lightPosition * minLight))
vec3 ld = lightPosition-p;
float len = length( ld ); // Distance from the light to the surface point.
ld /= len; // Normalizing the light-to-surface, aka light-direction, vector.
// float lightAtten = min( 1.0 / ( 0.25*len*len ), 1.0 ); // Keeps things between 0 and 1.
// float att = clamp(1.0 - len/radius, 0.0, 1.0);
/*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 * glyphColor * att);
}
col += vec3(dif * vec3(0.95, 0.35, 0.06) * att);
}*/
vec3 n = getNormal(p);
vec3 dir = vec3(1. , 10., 1.);
float ind = clamp( dot( n, normalize(dir )), 0.0, 1.0 );
col += color3 * ind;
// 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,0.3,0.3);
}
else if(mat==1.){
col *= vec3(0.,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(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);
}
else if(mat==3.){
col *= vec3(0.8471, 0.8549, 0.4667); // + noise(p.xz*1000.+5000., 0.1) + noise(p.xz*1000.+5000., 0.1);
}
else if(mat==4.){
col *= vec3(.1,0.1,0.1);
} else if(mat ==5.) {
col *= glyphColor; // activated glyph color
}
float fogAmount = 0.02;
col = col*exp(-d*fogAmount) + applyFog(col, d, rd, vec3(0., .3, -1.), fogAmount) * (1.0-exp(-d*fogAmount));
} else {
col = mix(color4, color5, rd.y * 1.2);
}
col = colorFlashesAnim(col); // animated color flash
gl_FragColor = vec4(postProcess(col), 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.);
}