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

additions

Browse Source
This commit is contained in:
Petri Järvisalo
2024-07-26 00:54:30 +03:00
parent f9ecf51295
commit c2d5cd9ee4
8 changed files with 1734 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
base.config
View File

@ -18,10 +18,10 @@ RESOLUTION_UNIFORM_NAME='u_resolution'
# Frame-to-texture, mipmaps
TWO_PASS_RENDERING=1
TWO_PASS_RENDERING=0
FRAME_TO_TEXTURE=0
USE_MIPMAP=0
SECOND_PASS_NEGATIVE_TIME=1
SECOND_PASS_NEGATIVE_TIME=0
# Texts
USE_TEXTS=1

12
minified.config
View File

@ -12,12 +12,12 @@ CRINKLER_ORDERTRIES=4000
SHADER_FILE=shader_minified.h
TIME_UNIFORM_NAME='v'
RESOLUTION_UNIFORM_NAME='y'
TEXTS_UNIFORM_NAME='a'
TEXTS_UNIFORM_NAME='f'
USE_WIDECHAR_TEXTS=1
TIME_DIVIDER=44100.000
TIME_BASE=seconds
TIME_DIVIDER_INT=44100
TWO_PASS_RENDERING=1
SECOND_PASS_NEGATIVE_TIME=1
TIME_DIVIDER=91241.383
TIME_BASE=bars
TIME_DIVIDER_INT=91241
TWO_PASS_RENDERING=0
SECOND_PASS_NEGATIVE_TIME=0
USE_TEXTS=0
USE_TEXTS_UNIFORM=0

BIN
music/4k_sg_v2.xrns
View File

Binary file not shown.

1007
petrinshader.glsl Normal file
View File

File diff suppressed because it is too large Load Diff

227
shader.glsl
View File

@ -1,3 +1,4 @@
//precision mediump float;
uniform vec2 u_resolution;
uniform float u_time;
uniform sampler2D texture_sampler;
@ -36,7 +37,7 @@ float noise( in vec2 p, float scale )
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),
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);
}
@ -44,7 +45,7 @@ float noise( in vec2 p, float scale )
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);
return noise(10.*p.xy+u_time+999., 0.4) + 0.5*noise(10.*(p.xz+2.0)-u_time+999., 0.4);
}
/////////////////
@ -109,39 +110,33 @@ float ringRotateFunc(float d, float s, float timeFact) {
float startTime = s;
float phase = ((u_time * timeFact) - startTime) / TWOPI;
phase = min(phase, maxCycles);
return TWOPI * phase;
return TWOPI * phase;
}
// Animate ring movements
vec3 ringAnim( in vec3 p) {
const float STARTDELAY = 9.0;
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 ) {
p.xy = rot2D(factor) * p.xy;
}
float factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9);
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;
}
// 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;
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;
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;
}
@ -149,7 +144,7 @@ return x;
// SCENE //
//////////////
vec2 map( in vec3 p)
vec2 map(in vec3 p)
{
float mat = 0.;
// Stargate
@ -162,8 +157,8 @@ vec2 map( in vec3 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
// Main ring
float d2 = abs(length(p.xy) - 1.8) - 0.2;
d = min(d,d2);
@ -174,13 +169,11 @@ vec2 map( in vec3 p)
// 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;
@ -194,30 +187,25 @@ vec2 map( in vec3 p)
rotationIncrement = rotationIncrement - 0.2;
}
float prismSector = floor(atan(p.y,p.x)/(rotationIncrement) + 0.5);
// 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);
}
if (i > 0) {
q.x -= 1.95;
q.x = prismAnim(q.x, float(i)*1.);
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);
if (d==d4) {
mat = 4.;
}
}
index += 1.0;
}
}
//Rotating glyphs
vec3 p2 = ringAnim(p);
float an2 = (TWOPI/32.0);
@ -227,8 +215,10 @@ vec2 map( in vec3 p)
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);
if (d==d5) {
mat = 4.;
}
// Gate Base
const float stepHeight = 0.1;
float stepDist = 1.5;
@ -245,19 +235,22 @@ vec2 map( in vec3 p)
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 cylinder2 = sdCylinder ( p, vec3(0.,0.,0.), vec3(0.,0.,-1), (2. - (u_time*2.0 - 2.0*13.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);
if (u_time > 2.0){
disp = displacement(p)*min(((u_time-14.0)*0.5), 0.25);
}
cylinder1 = cylinder1 + disp;
water = max(-cylinder2, cylinder1);
water = max(water, cylinder3);
water = max(-cylinder2+disp, cylinder1);
//water = max(water, cylinder3);
d = min(d, water);
}
if (d==min(water,0.1))
float sand = (p.y + 4.25) + noise((p.xz*0.04)+100., 9.);
d = min(d,sand);
if (d==water)
{
mat = 1.0;
}
@ -265,6 +258,10 @@ vec2 map( in vec3 p)
{
mat = 2.0;
}
else if (d==sand) {
mat = 3.0;
}
return vec2( d, mat );
}
@ -273,22 +270,18 @@ vec2 map( in vec3 p)
////////////////
float rayMarch(vec3 ro, vec3 rd) {
float t = 0.; // total distance travelled
float d;
// Raymarching
for (int i = 0; i < 80; i++) {
for (int i = 0; i < 200; 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>100.) break;
if (abs(d) < .001 || t > 800.) break;
}
return t;
}
vec3 getNormal(vec3 p) {
float d = map(p).x;
vec2 e = vec2(.01, 0);
@ -303,17 +296,25 @@ vec3 getNormal(vec3 p) {
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( d<length(lightPos-p)) dif *= shadow;
return dif;
}
vec3 GetRayDir(vec2 uv, vec3 p, vec3 l, float z)
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.2667, 0.2941, 0.3451), // blue
vec3(0.302, 0.3176, 0.3725), // 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)),
@ -324,68 +325,104 @@ vec3 GetRayDir(vec2 uv, vec3 p, vec3 l, float z)
return d;
}
void main( )
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.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);
// 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, 3);
//ro.yz *= rot2D(-m.y*3.14+1.);
//ro.xz *= rot2D(-m.x*6.2831);
vec3 ro = vec3(0, 2, 6);
ro.yz *= rot2D(sin(u_time)*0.5);
ro.xz *= rot2D(cos(u_time)*0.5);
//vec3 ro = vec3(0,0,-3); // ray origin
vec3 rd = GetRayDir(uv, ro, vec3(0, 0., 0.), 1.); // ray direction
vec3 rd = getCameraRayDir(uv, ro, vec3(0, -1., 0.), 1.); // ray direction
vec3 col = vec3(0); // color
if(u_time > 0.0)
{
float d = rayMarch(ro, rd);
float d = rayMarch(ro, rd);
if (d < 1000.)
{
if (d < 500.) {
// Lighting
vec3 p = ro + rd * d;
float mat = map(p).y;
// Light 1
// Light 1 Position
vec3 lightPos1 = vec3( 3, 5, 4);
// Light 1 Arguments
// 1: Ray starting point
// 2: Light position
// 3: Light intensity
// 4: Shadow intensity
float dif = getLight(p, lightPos1, 0.75, 0.2);
float dif = 0.; //getLight(p, vec3( 2, 50, 2), .5, .2);
// Color for light 1
col = vec3(dif * vec3(1));
// col = vec3(dif * vec3(0.9216, 0.9294, 0.9412));
// Light 2
vec3 lightPos2 = vec3( -3, 5, -4);
dif = getLight(p, lightPos2, 0.75, 0.1);
dif = getLight(p, vec3( -3, 5, 5), 1., 0.2);
// Color for light 2
col += vec3(dif * vec3(0.5,0.2,0.1));
col += vec3(dif * vec3(0.502, 0.2824, 0.102));
dif = getLight(p, vec3( 3, -2, 5), 0.75, .8);
// Color for light 2
col += vec3(dif * vec3(0.2784, 0.3647, 0.6588));
vec3 n = getNormal(p);
vec3 dir = vec3(1. , 10., 1.);
float ind = clamp( dot( n, normalize(dir )), 0.0, 1.0 );
col += vec3(0.1216, 0.1216, 0.1137) * ind;
if(mat==0.){
col *= vec3(1,1,1);
col *= vec3(.3,0.3,0.3);
}
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.545,0.27,0.074) - 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);
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.yz*1000., 0.1) + noise(p.xy*1000., 0.1);
}
else if(mat==4.){
col *= vec3(.1,0.1,0.1);
}
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 = vec3(0.1529, 0.1765, 0.3922) + rd.y * 0.4;
}
gl_FragColor = vec4(col, 1);
}
else {
// ************* post-process pass ******************
// Uncomment this to try a post-processing "effect"
gl_FragColor = texture2D(texture_sampler, (gl_FragCoord.xy / u_resolution ));
}
gl_FragColor = vec4(postProcess(col), 1);
}

264
shader_minified.h
View File

@ -1,15 +1,15 @@
// Generated with Shader Minifier 1.3.6 (https://github.com/laurentlb/Shader_Minifier/)
#ifndef SHADER_MINIFIED_H_
# define SHADER_MINIFIED_H_
# define VAR_texts "a"
# define VAR_texture_sampler "f"
# define VAR_texts "f"
# define VAR_texture_sampler "x"
# define VAR_u_resolution "y"
# define VAR_u_time "v"
const char *__temp_cleaned_shader_glsl =
"uniform vec2 y;"
"uniform float v;"
"uniform sampler2D f,a;"
"uniform sampler2D x,f;"
"mat2 n(float v)"
"{"
"float f=sin(v),y=cos(v);"
@ -17,8 +17,8 @@ const char *__temp_cleaned_shader_glsl =
"}"
"float n(float v,float y,float x)"
"{"
"float f=max(x-abs(v-y),0.);"
"return max(v,y)+f*f*.25/x;"
"float m=max(x-abs(v-y),0.);"
"return max(v,y)+m*m*.25/x;"
"}"
"float s(vec2 v)"
"{"
@ -27,31 +27,31 @@ const char *__temp_cleaned_shader_glsl =
"}"
"float n(vec2 v,float y)"
"{"
"vec2 f=floor(v),m=fract(v),a=m*m*(3.-2.*m);"
"return-y+y*mix(mix(s(f+vec2(0)),s(f+vec2(1,0)),a.x),mix(s(f+vec2(0,1)),s(f+vec2(1)),a.x),a.y);"
"vec2 m=floor(v),a=fract(v),f=a*a*(3.-2.*a);"
"return-y+y*mix(mix(s(m+vec2(0)),s(m+vec2(1,0)),f.x),mix(s(m+vec2(0,1)),s(m+vec2(1)),f.x),f.y);"
"}"
"float m(vec3 y)"
"{"
"return n(10.*y.xy+v,.2)+.5*n(10.*(y.xy+2.)-v,.2);"
"return n(10.*y.xy+v+999.,.4)+.5*n(10.*(y.xz+2.)-v+999.,.4);"
"}"
"float m(vec3 v,vec3 y,vec3 m,float x)"
"float m(vec3 v,vec3 m,float y)"
"{"
"vec3 f=m-y,a=v-y;"
"float s=dot(f,f),c=dot(a,f),n=length(a*s-f*c)-x*s,h=abs(c-s*.5)-s*.5,i=n*n,z=h*h*s,g=max(n,h)<0.?"
"-min(i,z):"
"vec3 x=vec3(0),f=m-x,a=v-x;"
"float s=dot(f,f),c=dot(a,f),n=length(a*s-f*c)-y*s,z=abs(c-s*.5)-s*.5,i=n*n,l=z*z*s,d=max(n,z)<0.?"
"-min(i,l):"
"(n>0.?"
"i:"
"0.)+(h>0.?"
"z:"
"0.)+(z>0.?"
"l:"
"0.);"
"return sign(g)*sqrt(abs(g))/s;"
"return sign(d)*sqrt(abs(d))/s;"
"}"
"float m(vec3 v,vec3 y)"
"{"
"vec3 f=abs(v)-y;"
"return length(max(f,0.))+min(max(f.x,max(f.y,f.z)),0.);"
"}"
"float x(vec3 v)"
"float p(vec3 v)"
"{"
"vec2 f=vec2(.2);"
"v.xy*=n(.5);"
@ -63,154 +63,174 @@ const char *__temp_cleaned_shader_glsl =
"if(v.x+y*v.y>0.)"
"v.xy=vec2(v.x-y*v.y,-y*v.x-v.y)/2.;"
"v.x-=clamp(v.x,-2.,0.);"
"float x=length(v.xy)*sign(-v.y)*f.x,a=abs(v.z)-f.y;"
"return length(max(vec2(x,a),0.))+min(max(x,a),0.);"
"float m=length(v.xy)*sign(-v.y)*f.x,a=abs(v.z)-f.y;"
"return length(max(vec2(m,a),0.))+min(max(m,a),0.);"
"}"
"float m(float y,float x,float f)"
"float p(float y,float x,float a)"
"{"
"float i=(v*f-x)/(2.*acos(-1.));"
"i=min(i,y);"
"return 2.*acos(-1.)*i;"
"float f=(v*a-x)/(2.*acos(-1.));"
"f=min(f,y);"
"return 2.*acos(-1.)*f;"
"}"
"vec3 t(vec3 y)"
"{"
"float f=9.+9.*clamp(sin(m(2.,0.,1.)*.05),-.9,.9);"
"if(v>=2.)"
"f=9.+9.*clamp(sin(m(2.,0.,1.)*.05),-.9,.9),y.xy=n(f)*y.xy;"
"float f=9.+9.*clamp(sin(p(2.,0.,1.)*.05),-.9,.9);"
"if(v>=9.)"
"y.xy=n(f)*y.xy;"
"if(v>=14.)"
"f=9.+9.*clamp(sin(m(2.,14.,1.)*.05),-.9,.9),y.xy=n(f*-1.)*y.xy;"
"f=9.+9.*clamp(sin(p(2.,14.,1.)*.05),-.9,.9),y.xy=n(f*-1.)*y.xy;"
"return y;"
"}"
"float s(float y,float f)"
"float p(float y,float f)"
"{"
"if(v>=f)"
"y+=.045*clamp(sin(m(2.4,f*10.,10.)*.4),-.9,.9);"
"y+=.045*clamp(sin(p(2.4,f*10.,10.)*.4),-.9,.9);"
"return y;"
"}"
"vec2 h(vec3 y)"
"vec2 a(vec3 f)"
"{"
"float f=0.;"
"const float a=2.*acos(-1.)/24.;"
"float i=floor(atan(y.y,y.x)/a+.5)*a;"
"vec3 r=y;"
"r.xy=mat2(cos(i),-sin(i),sin(i),cos(i))*r.xy;"
"float c=length(max(abs(r.xy-vec2(1.8,0))-vec2(.24,.14),0.))-.02;"
"c=min(c,abs(length(y.xy)-1.8)-.2);"
"float g=abs(length(y.xy)-1.75)-.08;"
"g=n(g,abs(y.z-.1)-.04,.005);"
"c=max(-g,c);"
"c=n(c,abs(y.z)-.1,.02);"
"float h=1.;"
"for(int l=0;l<8;l++)"
"float y=0.;"
"const float x=2.*acos(-1.)/24.;"
"float a=floor(atan(f.y,f.x)/x+.5)*x;"
"vec3 i=f;"
"i.xy=mat2(cos(a),-sin(a),sin(a),cos(a))*i.xy;"
"float s=length(max(abs(i.xy-vec2(1.8,0))-vec2(.24,.14),0.))-.02;"
"s=min(s,abs(length(f.xy)-1.8)-.2);"
"float r=abs(length(f.xy)-1.75)-.08;"
"r=n(r,abs(f.z-.1)-.04,.005);"
"s=max(-r,s);"
"s=n(s,abs(f.z)-.1,.02);"
"float z=1.;"
"for(int c=0;c<8;c++)"
"{"
"vec3 z=y;"
"float b=24.67/(2.*acos(-1.))+h*(2.*acos(-1.)/8.);"
"if(l==1)"
"b+=.2;"
"if(l==7)"
"b-=.2;"
"z.xy=n(b)*z.xy;"
"if(l>0)"
"vec3 d=f;"
"float l=24.67/(2.*acos(-1.))+z*(2.*acos(-1.)/8.);"
"if(c==1)"
"l+=.2;"
"if(c==7)"
"l-=.2;"
"d.xy=n(l)*d.xy;"
"if(c>0)"
"{"
"z.x=z.x-1.95;"
"if(l==1)"
"z.x=s(z.x,13.);"
"if(l==2)"
"z.x=s(z.x,26.);"
"float p=x(vec3(z))-.02;"
"c=min(c,p);"
"d.x-=1.95;"
"d.x=p(d.x,float(c));"
"float h=p(vec3(d))-.02;"
"s=min(s,h);"
"if(s==h)"
"y=4.;"
"}"
"h+=1.;"
"z+=1.;"
"}"
"vec3 l=t(y);"
"float z=2.*acos(-1.)/32.;"
"vec3 b=l;"
"b.xy=n(floor(atan(l.y,l.x)/z+.5)*z)*b.xy;"
"float p=m(b.xyz-vec3(1.75,0,0),vec3(.04,.14,.05))-.02;"
"c=min(c,p);"
"float e=1.5,u=1e3;"
"for(int C=0;C<4;C++)"
"vec3 d=t(f);"
"float c=2.*acos(-1.)/32.;"
"vec3 l=d;"
"l.xy=n(floor(atan(d.y,d.x)/c+.5)*c)*l.xy;"
"float h=m(l.xyz-vec3(1.75,0,0),vec3(.04,.14,.05))-.02;"
"s=min(s,h);"
"if(s==h)"
"y=4.;"
"float e=1.5,g=1e3;"
"for(int u=0;u<4;u++)"
"{"
"float D=m(vec3(y.x,y.y+e,y.z),vec3(2,.1,e))-.05;"
"u=min(u,D);"
"c=min(c,D);"
"float C=m(vec3(f.x,f.y+e,f.z),vec3(2,.1,e))-.05;"
"g=min(g,C);"
"s=min(s,C);"
"e+=.2;"
"}"
"float D=1e3;"
"float C=1e3;"
"if(v>2.)"
"{"
"float C=m(y,vec3(0),vec3(0,0,-.01),1.6),F=m(y,vec3(0,0,1),vec3(0,0,-1),2.-v*2.+4.),E=m(y,vec3(0,0,1),vec3(0,0,-1),1.6),d=0.;"
"if(v>5.)"
"d=m(y+4.)*min((v-5.)*.5,.25);"
"C+=d;"
"D=max(-F,C);"
"D=max(D,E);"
"c=min(c,D);"
"float u=m(f,vec3(0,0,-.01),1.6),D=m(f,vec3(0,0,-1),2.-v*2.+26.),b=0.;"
"if(v>2.)"
"b=m(f)*min((v-14.)*.5,.25);"
"u+=b;"
"C=max(-D+b,u);"
"s=min(s,C);"
"}"
"if(c==min(D,.1))"
"f=1.;"
"else if(c==min(u,.1))"
"f=2.;"
"return vec2(c,f);"
"float u=f.y+4.25+n(f.xz*.04+1e2,9.);"
"s=min(s,u);"
"if(s==C)"
"y=1.;"
"else if(s==min(g,.1))"
"y=2.;"
"else if(s==u)"
"y=3.;"
"return vec2(s,y);"
"}"
"float h(vec3 y,vec3 v)"
"float a(vec3 v,vec3 y)"
"{"
"float f=0.,c;"
"for(int i=0;i<80;i++)"
"float f=0.,s;"
"for(int i=0;i<200;i++)"
"{"
"vec3 x=y+v*f;"
"c=h(x).x;"
"f+=c;"
"if(c<.001||f>1e2)"
"vec3 m=v+y*f;"
"s=a(m).x;"
"f+=s;"
"if(abs(s)<.001||f>8e2)"
"break;"
"}"
"return f;"
"}"
"vec3 p(vec3 v)"
"vec3 h(vec3 v)"
"{"
"float f=h(v).x;"
"vec2 y=vec2(.01,0);"
"vec3 c=f-vec3(h(v-y.xyy).x,h(v-y.yxy).x,h(v-y.yyx));"
"return normalize(c);"
"float m=a(v).x;"
"vec2 f=vec2(.01,0);"
"vec3 y=m-vec3(a(v-f.xyy).x,a(v-f.yxy).x,a(v-f.yyx));"
"return normalize(y);"
"}"
"float h(vec3 v,vec3 y,float f)"
"float a(vec3 v,vec3 f,float y,float m)"
"{"
"vec3 c=normalize(y-v),x=p(v);"
"float i=clamp(dot(x,c),0.,.75),a=h(v+x*.0025,c);"
"if(a<length(y-v))"
"i*=f;"
"vec3 s=normalize(f-v),x=h(v);"
"float i=clamp(dot(x,s),0.,y),c=a(v+x*.0025,s);"
"if(c<length(f-v))"
"i*=m;"
"return i;"
"}"
"vec3 p(vec2 v,vec3 y)"
"vec3 h(vec2 v,vec3 y)"
"{"
"vec3 f=normalize(vec3(0)-y),c=normalize(cross(vec3(0,1,0),f));"
"return normalize(f+v.x*c+v.y*cross(f,c));"
"vec3 f=normalize(vec3(0,-1,0)-y),s=normalize(cross(vec3(0,1,0),f));"
"return normalize(f+v.x*s+v.y*cross(f,s));"
"}"
"vec3 i(vec3 v)"
"{"
"vec2 f=gl_FragCoord.xy/y.xy;"
"v=mix(v,v*smoothstep(.9,.5,length(f-vec2(.5))),.9);"
"v=mix(v,smoothstep(0.,1.,v),.9);"
"v*=vec3(1);"
"return pow(v,vec3(1./2.2));"
"}"
"void main()"
"{"
"vec2 c=(gl_FragCoord.xy*2.-y.xy)/y.y;"
"vec3 x=vec3(0,2,3),a=p(c,x),i=vec3(0);"
"if(v>0.)"
"vec2 f=(gl_FragCoord.xy*2.-y.xy)/y.y;"
"vec3 s=vec3(0,2,6);"
"s.yz*=n(sin(v)*.5);"
"s.xz*=n(cos(v)*.5);"
"vec3 m=h(f,s),x=vec3(0);"
"float c=a(s,m);"
"if(c<5e2)"
"{"
"float l=h(x,a);"
"if(l<1e3)"
"{"
"vec3 z=x+a*l;"
"float m=h(z).y,r=h(z,vec3(3,5,4),.2);"
"i=vec3(r*vec3(1));"
"r=h(z,vec3(-3,5,-4),.1);"
"i+=vec3(r*vec3(.5,.2,.1));"
"if(m==0.)"
"i*=vec3(1);"
"else if(m==1.)"
"i*=(n(5.*(z.xy+2.)+v,-1.)*n(50.*(z.xy+2.),-.4)+.5*n(20.*(z.xy+2.)-v,-.5)*n(5.*(z.xy+2.),-.75))*smoothstep(0.,.75,(v-5.)*.1)+vec3(0,0,.5*n(10.*(z.xy+4.)-v,-.5))+vec3(0,0,.5);"
"else if(m==2.)"
"i*=vec3(.545,.27,.074)-.2*n(vec2(1e2*z.x+3e2,75.*z.z+150.),-2.2)*n(vec2(15.*z.x+2.,3.*z.z+2.),-1.)+n(vec2(15.*z.x+2.4,3.*z.z+2.),-.25);"
"}"
"gl_FragColor=vec4(i,1);"
"vec3 d=s+m*c;"
"float l=a(d).y,r=0.;"
"r=a(d,vec3(-3,5,5),1.,.2);"
"x+=vec3(r*vec3(.502,.2824,.102));"
"r=a(d,vec3(3,-2,5),.75,.8);"
"x+=vec3(r*vec3(.2784,.3647,.6588));"
"vec3 g=h(d);"
"x+=vec3(.1216,.1216,.1137)*clamp(dot(g,normalize(vec3(1,10,1))),0.,1.);"
"if(l==0.)"
"x*=vec3(.3);"
"else if(l==1.)"
"x*=(n(5.*(d.xy+2.)+v,-1.)*n(50.*(d.xy+2.),-.4)+.5*n(20.*(d.xy+2.)-v,-.5)*n(5.*(d.xy+2.),-.75))*smoothstep(0.,.75,(v-5.)*.1)+vec3(0,0,.5*n(10.*(d.xy+4.)-v,-.5))+vec3(0,0,.5);"
"else if(l==2.)"
"x*=vec3(.3608,.1765,.0471)-.2*n(vec2(1e2*d.x+3e2,75.*d.z+150.),-2.2)*n(vec2(15.*d.x+2.,3.*d.z+2.),-1.)+n(vec2(15.*d.x+2.4,3.*d.z+2.),-.25);"
"else if(l==3.)"
"x*=vec3(.8471,.8549,.4667)+n(d.yz*1e3,.1)+n(d.xy*1e3,.1);"
"else if(l==4.)"
"x*=vec3(.1);"
"x=x*exp(-c*.02)+mix(x,mix(vec3(.2667,.2941,.3451),vec3(.302,.3176,.3725),pow(max(dot(m,vec3(0,.3,-1)),0.),8.)),1.-exp(-c*.02))*(1.-exp(-c*.02));"
"}"
"else"
" gl_FragColor=texture2D(f,gl_FragCoord.xy/y);"
" x=vec3(.1529,.1765,.3922)+m.y*.4;"
"gl_FragColor=vec4(i(x),1);"
"}";
#endif // SHADER_MINIFIED_H_

444
shader_new.glsl Normal file
View File

@ -0,0 +1,444 @@
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 ));
}
}

2
shadertoy.glsl
View File

@ -891,7 +891,7 @@ vec3 getCameraFov(vec2 uv, vec3 camPos, vec3 camTarget) {
return normalize(uv.x * camRight + uv.y * camUp + fov * camForward + voff * fov/focusdistance);
}
vec3 applyFog(vec3 col, float t, vec3 rd, vec3 lightDir, float b ) {
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