0d14e5a379
Needs a lot of cleanup. Data has been de-duplicated, and where identical copies existed, one of them has been replaced with a symlink. Some files have been excluded, such as binaries, installers and debug dumps. Some of that may still be present.
178 lines
No EOL
7.8 KiB
GLSL
178 lines
No EOL
7.8 KiB
GLSL
// skybox version of https://www.shadertoy.com/view/MllXz4
|
|
//noise function taken from https://www.shadertoy.com/view/XslGRr
|
|
|
|
float hash( float n ){
|
|
return fract(sin(n)*43758.5453);
|
|
}
|
|
|
|
//this noise function was originally 3D noise,
|
|
//but I am just setting z to 0 for the sake of simplicity here
|
|
//also cause most effects only care about 2D noise
|
|
float noise( vec2 uv ){
|
|
vec3 x = vec3(uv, 0);
|
|
|
|
vec3 p = floor(x);
|
|
vec3 f = fract(x);
|
|
|
|
f = f*f*(3.0-2.0*f);
|
|
float n = p.x + p.y*57.0 + 113.0*p.z;
|
|
|
|
return mix(mix(mix( hash(n+0.0), hash(n+1.0),f.x),
|
|
mix( hash(n+57.0), hash(n+58.0),f.x),f.y),
|
|
mix(mix( hash(n+113.0), hash(n+114.0),f.x),
|
|
mix( hash(n+170.0), hash(n+171.0),f.x),f.y),f.z);
|
|
}
|
|
|
|
float ring( float angle, float dist, float ANG, float THICKNESS, float POS, float SIZE ) {
|
|
//angles between 4 and 15 are good
|
|
//negative thickness makes it black, values around 0.02 are good
|
|
|
|
float ZIGZAG = abs( mod( angle, ANG ) - ANG * 0.5 ) * SIZE;
|
|
return ceil( dist - POS + ZIGZAG) - ceil( dist - (POS+THICKNESS) + ZIGZAG);
|
|
}
|
|
float burst( float angle, float dist, float ANG ) {
|
|
float B = abs( mod( angle, ANG ) - ANG * 0.5 );
|
|
return B;
|
|
}
|
|
float lim( float IN, float amount ) {
|
|
return IN * amount + (1.0 - amount);
|
|
}
|
|
float inv( float IN ) {
|
|
return 1.0 - IN;
|
|
}
|
|
float ppp( float IN ) {
|
|
return IN * IN * IN;
|
|
}
|
|
float dots( float angle, float dist, float ANG, float POS ) {
|
|
return ppp(7.5*burst( angle, dist, ANG )/ANG) * ppp(inv(ANG*1.5*distance( dist, POS )));
|
|
}
|
|
|
|
#ifdef GL_ES
|
|
precision mediump float;
|
|
#endif
|
|
|
|
float normpdf(in float x, in float sigma)
|
|
{
|
|
return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;
|
|
}
|
|
|
|
vec4 myoutput( vec2 spherical )
|
|
{
|
|
|
|
float dist = spherical.y;
|
|
float angle = spherical.x;
|
|
|
|
float TIMESCALE = 0.13;
|
|
float T = iGlobalTime * TIMESCALE * 1.0;
|
|
|
|
|
|
float n = noise( vec2( dist, T ) );
|
|
float slow_n = noise( vec2( dist, T * 0.02) );
|
|
float fast_n = noise( vec2( dist, T * 0.1) );
|
|
float vslow_n = noise( vec2( dist, T * 0.001) );
|
|
float vfast_n = noise( vec2( dist, T * 0.02) );
|
|
float t = noise( vec2( iGlobalTime, T ) );
|
|
|
|
float rand_r = noise( vec2( -T, T ) );
|
|
float slow_r = noise( vec2( -T * 0.5, 1.0 ) );
|
|
float vslow_r = noise( vec2( -T * 0.2, 1.0 ) );
|
|
float vvslow_r = noise( vec2( -T* 0.05, 1.0 ) );
|
|
|
|
float div = 7.0;
|
|
float m = sin ( mod( angle, div )/(div*0.5) * 3.14 * 0.5 );
|
|
float a = mod( angle, 10.0 ) * noise( vec2( T, angle ) );
|
|
|
|
float TIME_MOD_SCALE = 0.5;
|
|
float TIME_MOD = floor(0.5+sin( noise( vec2(-iGlobalTime + 10.0, 1.0 )) ))*0.5*TIMESCALE*TIME_MOD_SCALE;
|
|
|
|
TIMESCALE = TIMESCALE * TIME_MOD;
|
|
|
|
float GRANULARITY = 0.05;
|
|
float GRAN_DIST_FALLOFF = 0.5;
|
|
float GRAN_DIST_FALLOFF_MOD = tan(noise (vec2( 500.0, -T ) ));
|
|
GRAN_DIST_FALLOFF = GRAN_DIST_FALLOFF + GRAN_DIST_FALLOFF_MOD * 0.5;
|
|
|
|
|
|
|
|
float Gr = (GRANULARITY-(dist * GRANULARITY * GRAN_DIST_FALLOFF)) * 0.1;
|
|
float Gg = (GRANULARITY-(dist * GRANULARITY * GRAN_DIST_FALLOFF)) * 0.005;
|
|
float Gb = (GRANULARITY-(dist * GRANULARITY * GRAN_DIST_FALLOFF)) * 0.01;
|
|
|
|
float Gsign = clamp( sign( noise (vec2( T * 0.22, -T * 1.5 )) -0.5 ), -1.0, 0.0 );
|
|
|
|
float rn = 360.0 / (ceil( noise(vec2( sin(T*0.1), 0.5 ) ) * 50.0) * 2.0 ); //randomly some divisor of 360
|
|
float rd1 = ceil( noise(vec2( tan(T/10.0), 1.0 ) ) * 2.0 ); //randomly either 1 or 2
|
|
float rd2 = ceil( noise(vec2( sin(T/10.0), 1.0 ) ) * 2.0 ); //randomly either 1 or 2
|
|
float rd3 = ceil( noise(vec2( cos(T/10.0), 1.0 ) ) * 2.0 ); //randomly either 1 or 2
|
|
float rd4 = ceil( noise(vec2( tan(T*0.0075+99.0), 1.0 ) ) * 1.2 ); //randomly either 1 or 2
|
|
float rd5 = ceil( noise(vec2( tan(T*0.008+124.0), 1.0 ) ) * 1.5 ); //randomly either 1 or 2
|
|
float rd6 = ceil( noise(vec2( tan(T*0.007+24.0), 1.0 ) ) * 1.7 ); //randomly either 1 or 2
|
|
float rd7 = ceil( noise(vec2( tan(T*0.005), 1.0 ) ) * 1.4 ); //randomly either 1 or 2
|
|
float exp4 = ceil( noise(vec2( tan(T*0.5), 1.0 ) ) * 2.0 ) * rd1;
|
|
float coarse3 = ceil( noise(vec2( cos(T), 1.0 ) ) * 3.0 );
|
|
float coarse10 = ceil( noise(vec2( cos(T), 1.0 ) ) * 10.0 );
|
|
|
|
vec3 RING1 = rd2 * 0.5 * ring( angle, dist,6.0, 0.02, n, 0.01) * vec3( 1.0, 1.0, 1.0 ) * floor( n + 0.5 ); // PINK ZIG ZAG
|
|
vec3 RING2 = ring( angle, dist,10.0, 0.01, n/2.0, 0.01) * vec3( 1.0, 1.0, 1.0 ) * ceil( n - 0.3 );// PINK ZIG ZAG HIGH
|
|
vec3 RING3 = ring( angle+(vslow_n*200.0*coarse3)*(2.0+n), dist,90.0*rd1/rd4, (0.02 + rand_r*0.01 + ppp(slow_r)*0.011)*ppp(rd4), n, 0.01) * vec3( 1.0, 1.0, 1.0 ) * 0.5; // SPIRAL FLickers too much
|
|
vec3 RING4 = ring( angle-iGlobalTime*(5.0*n), dist,10.0, 0.05, n, 0.01) * vec3( sin(T), cos(T), 0.1 ) * 0.5; // LARGE SLOW RED ZIG ZAG NICE
|
|
vec3 RING5 = ring( angle, dist,30.0, n*20.0, n+0.3, 0.01) * vec3( 1.0, 1.0, 1.0 ) * 0.05 + (dist)*0.05; // COARSE AND HARD TO LOOK AT - HIDE ME
|
|
vec3 BURST1 = burst( angle, dist, rn * rd1 ) * vec3( 1.0, 1.0, 1.0 ) * 0.03 * (1.0 - dist); // FLICKERS HIDE ME
|
|
vec3 RING6 = max(ring( angle-(vslow_n*200.0*coarse3)*(2.0+vslow_n), dist,45.0*rd1, 0.3, n, 0.01),0.0) * vec3( sin(T), tan(T) * 0.05, rand_r ) * (rd7 - 1.0) * inv(dist) * 0.5; // NICE DANCING SPIRALS BUT POPS OUT IN YELLOW
|
|
vec3 DOTS1 = max(ceil(dots( angle + T*30.0, dist, 10.0, 0.25 + rand_r*0.1 )-24.5 * (1.0+rand_r)),0.0) * vec3( rand_r, inv(rand_r), n ) * 0.15;
|
|
vec3 DOTS2 = max(ceil(dots( angle - T*35.0, dist, 10.0, 0.3 + rand_r*0.2 )-16.4 * (2.0-rand_r)),0.0) * vec3( n, rand_r, inv(rand_r) ) * 0.15;
|
|
vec3 DOTS3 = clamp( 1.0 * dots( angle + T * 45.0, dist, 15.0, 0.9 ), 0.0, 1.0) * vec3( 1.0, 1.0, 1.0 ) * 0.05;
|
|
vec3 DOTS4 = clamp( 1.0 * dots( angle - T * 45.0, dist, 15.0, 0.82 ), 0.0, 1.0) * vec3( 1.0, 1.0, 1.0 ) * 0.025;
|
|
vec3 RING = RING1 + RING2 +RING4 + DOTS1 + DOTS2+ DOTS3+RING3 +RING6 + DOTS4;
|
|
|
|
float r = RING.b + max((1.0 - dist * 2.0),-0.5) + noise( vec2( dist * Gr * sin( noise(vec2( iGlobalTime * 8.0 * TIMESCALE, -iGlobalTime )) ), dist ) );;//floor(n*2.0) * a;
|
|
float g = RING.g + max((1.0 - dist * 3.5),-1.5) + noise( vec2( dist * Gg * TIMESCALE * cos( noise(vec2( iGlobalTime * 12.0 * TIMESCALE, -iGlobalTime )) ), dist ) );;//ceil(n/3.0 - 0.1) - a;
|
|
g = g * 0.001;
|
|
float b = RING.r + max((1.0 - dist * 2.5),-1.0) + noise( vec2( dist * Gb * tan( noise(vec2( iGlobalTime * 1.0 * TIMESCALE, -iGlobalTime )) ), dist ) );;//ceil(n/3.0 - 0.2) - a;
|
|
|
|
vec3 boost = vec3( 1,0,1);
|
|
|
|
return vec4(r*boost.r,g*boost.g,b*boost.b,1.0) * mix(dist,1.0,0.7);
|
|
|
|
float over = DOTS3.x + DOTS4.x;
|
|
}
|
|
|
|
vec3 getOutput(vec3 d) {
|
|
vec2 spherical;
|
|
spherical.x = degrees(atan(d.x, d.z));
|
|
spherical.y = (acos(d.y) + 1.0) / 4.0;
|
|
return myoutput(spherical).rgb;
|
|
}
|
|
|
|
|
|
mat3 rot(vec3 a, float b) {
|
|
a = normalize(a);
|
|
float s = sin(b);
|
|
float c = cos(b);
|
|
float d = 1.0 - c;
|
|
return mat3(d * a.x * a.x + c, d * a.x * a.y - a.z * s, d * a.z * a.x + a.y * s, d * a.x * a.y + a.z * s, d * a.y * a.y + c,
|
|
d * a.y * a.z - a.x * s, d * a.z * a.x - a.y * s, d * a.y * a.z + a.x * s, d * a.z * a.z + c);
|
|
}
|
|
|
|
float e = 2.3, p = atan(1.) * 4.;
|
|
|
|
vec3 getPixelDirection(in vec2 fragCoord) {
|
|
vec2 R = iResolution.xy, u = fragCoord / R;
|
|
vec4 m = iMouse / R.xyxx;
|
|
mat3 rmx = rot(vec3(0, 1, 0), clamp(-m.w * R.x, 0., 1.) * 3.14 / 10. + m.x * p * 2.);
|
|
rmx *= rot(cross(vec3(0, 1, 0), vec3(0, 0, 1) * rmx), m.y * p - p / 2.);
|
|
vec3 d = normalize(vec3((u * 2. - 1.) * vec2(iResolution.x / iResolution.y, 1), 1)) * rmx;
|
|
return d;
|
|
}
|
|
|
|
|
|
void mainImage( out vec4 fragColor, in vec2 fragCoord )
|
|
{
|
|
vec3 d = getPixelDirection(fragCoord);
|
|
fragColor = vec4(getOutput(d), 1.0);
|
|
}
|
|
|
|
vec3 getSkyboxColor()
|
|
{
|
|
return getOutput(normalize(_normal));
|
|
} |