digitalartifex/komplex
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added the sources of added shaders

Browse Source
This commit is contained in:
Digital Artifex
2025-08-11 00:01:34 -04:00
parent 0bb4269ae6
commit e3d6de2ffc
16 changed files with 1348 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
tools/src/generative/Accretion.frag Normal file
View File

@@ -0,0 +1,38 @@
/*
"Accretion" by @XorDev
I discovered an interesting refraction effect
by adding the raymarch iterator to the turbulence!
https://x.com/XorDev/status/1936884244128661986
*/
void mainImage(out vec4 O, vec2 I)
{
//Raymarch depth
float z,
//Step distance
d,
//Raymarch iterator
i;
//Clear fragColor and raymarch 100 steps
for(O*=i; i++<2e1; )
{
//Sample point (from ray direction)
vec3 p = z*normalize(vec3(I+I,0)-iResolution.xyx)+.1;
//Polar coordinates and additional transformations
p = vec3(atan(p.y/.2,p.x)*2., p.z/3., length(p.xy)-5.-z*.2);
//Apply turbulence and refraction effect
for(d=0.; d++<7.;)
p += sin(p.yzx*d+iTime+.3*i)/d;
//Distance to cylinder and waves with refraction
z += d = length(vec4(.4*cos(p)-.4, p.z));
//Coloring and brightness
O += (1.+cos(p.x+i*.4+z+vec4(6,1,2,0)))/d;
}
//Tanh tonemap
O = tanh(O*O/4e2);
}

49
tools/src/generative/Daedra.frag Normal file
View File

@@ -0,0 +1,49 @@
//const float gridSize = iResolution.x*0.1;
bool circleTest(vec2 pos, vec2 size, vec2 uv){
if(distance(pos,uv) < size.x){
return true;
} else {
return false;
}
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// Normalized pixel coordinates (from 0 to 1)
vec2 uv = fragCoord/iResolution.y;
float gridSize = iResolution.x*0.05;
uv = fract(uv*gridSize);
vec4 cam = texture(iChannel0, floor((fragCoord/iResolution.xy)*gridSize)*(1.0/gridSize));
vec3 col = vec3(0.0);
bool circleR = circleTest(vec2(0.7,0.7),vec2(cam.x*0.5), uv);
bool circleG = circleTest(vec2(0.3,0.5),vec2(cam.y*0.5), uv);
bool circleB = circleTest(vec2(0.7,0.3),vec2(cam.z*0.5), uv);
// Output to screen
if(circleR){
col.x = 1.0;
} else {
col.x = 0.0;
}
if(circleG){
col.y = 1.0;
} else {
col.y = 0.0;
}
if(circleB){
col.z = 1.0;
} else {
col.z = 0.0;
}
fragColor = vec4(col,1.0);
}

49
tools/src/generative/Just Another Cube.frag Normal file
View File

@@ -0,0 +1,49 @@
//const float gridSize = iResolution.x*0.1;
bool circleTest(vec2 pos, vec2 size, vec2 uv){
if(distance(pos,uv) < size.x){
return true;
} else {
return false;
}
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// Normalized pixel coordinates (from 0 to 1)
vec2 uv = fragCoord/iResolution.y;
float gridSize = iResolution.x*0.05;
uv = fract(uv*gridSize);
vec4 cam = texture(iChannel0, floor((fragCoord/iResolution.xy)*gridSize)*(1.0/gridSize));
vec3 col = vec3(0.0);
bool circleR = circleTest(vec2(0.7,0.7),vec2(cam.x*0.5), uv);
bool circleG = circleTest(vec2(0.3,0.5),vec2(cam.y*0.5), uv);
bool circleB = circleTest(vec2(0.7,0.3),vec2(cam.z*0.5), uv);
// Output to screen
if(circleR){
col.x = 1.0;
} else {
col.x = 0.0;
}
if(circleG){
col.y = 1.0;
} else {
col.y = 0.0;
}
if(circleB){
col.z = 1.0;
} else {
col.z = 0.0;
}
fragColor = vec4(col,1.0);
}

77
tools/src/generative/Orb Symmetry.frag Normal file
View File

@@ -0,0 +1,77 @@
// sleepy comments, most leftover from previous shader
// beware... i'll re-read tomorrow :D
#define T iTime
// @FabriceNeyret2 golfed this in my "Light Hall" shader
// the idea is that you pass in the movement frequency (f)
// the z offset (Z) and the radius (c), you then just do
// a sphere calc on p: length(p - offset) - radius
// the offset vec is composed of all the trig stuff below
// but it's basically just move x and y in squiggly lines
// and move z relative to iTime and the z offset
// T*3. because the camera is moving at T*3. speed as well
#define O(f,Z,c) abs( length( /* orb */ \
p - vec3( sin( sin(p.z*f*.5 ) +T*.7 ) * 3. , \
sin( sin(p.z*f*1.3) +T*.5 ) * 2., \
Z +8. +T*3. +cos(T*.3) *8. ) ) - c )
void mainImage(out vec4 o, vec2 u) {
float l, // distance to light orb
s, // spiral distance
d, // total distance marched
i, // raymarch iterator
n; // noise iterator
// p is resolution, then raymarch position
vec3 p = iResolution;
// scale coords
u = (u-p.xy/2.)/p.y;
// clear o, iterate 70 times, accumulate distance (d) and brightness (o)
// .001+abs(min(s,l)) means take the min of the spiral and the lights,
// and make it slightly translucent, *.7 to clean up some artifacts
for(o*=i; i++<60.;d += s = .001+abs(min(s,l))*.5, o += 1./s/l)
// this for-loop is the noise loop, before entering the loop body,
// we march. the below is equivalent to p = ro + rd * d, p.z += T;
// note that the orbs move at T*3. speed as well
for (p = vec3(u * d, d+T*3.),
// mirror
p = abs(p),
// it's just a mirrored plane with tanh wrapped around it to make it interesting
// why tanh? i was using cos for repetition and was curious, so i tried
// tanh, liked it, and kept it :)
s = tanh(4.-abs(p.x)),
// store dist to light in l
l = .01 + .8 * min( O(.5, 6., .4),
min( O(.4, 3., .2),
O(.3, 4., .3) )),
// start noise at 1, while < 6, n *= 1.3
// n += n works, n *= 1.x works, but keep in mind the number of iterations
// the loop will need
n = 1.; n < 6.; n *= 1.3 )
// apply the noise with a scale of .3
// add .5*T to p to make it move,
// add p.z to make it less repetitive looking
s += abs(dot(cos(.5*T+p.z+p*n), vec3(.3))) / n;
// tanh tonemap, vec4 divides color by d (green and blue) for depth,
// divide down brightness (o / 1e2),
// divide by distance for depth
// add a light in the center length(u),
o = tanh(2.*abs(vec4(.1,4./d, d/3e1,0)) * o/1e2/max(d,15.) / max(length(u), .001));
// @Shane color tip, mix o with swizzled components
o = mix(o.zyxw, o.yxzw, smoothstep(0., 1., length(u)*2.));
}

47
tools/src/generative/Phosphor.frag Normal file
View File

@@ -0,0 +1,47 @@
/*
"Phosphor 3" by @XorDev
https://x.com/XorDev/status/1949897576435581439
<512 playlist:
https://www.shadertoy.com/playlist/N3SyzR
*/
void mainImage(out vec4 O, vec2 I)
{
//Animation time
float t = iTime,
//Raymarch depth
z,
//Step distance
d,
//Signed distance
s,
//Raymarch iterator
i;
//Clear fragColor and raymarch 80 steps
for(O*=i; i++<8e1;
//Coloring and brightness
O+=(cos(s+vec4(0,1,8,0))+1.)/d)
{
//Sample point (from ray direction)
vec3 p = z*normalize(vec3(I+I,0)-iResolution.xyy),
//Rotation axis
a = normalize(cos(vec3(5,0,1)+t-d*4.));
//Move camera back 5 units
p.z+=5.,
//Rotated coordinates
a = a*dot(a,p)-cross(a,p);
//Turbulence loop
for(d=1.;d++<9.;)
a-=sin(a*d+t).zxy/d;
//Distance to ring
z+=d=.1*abs(length(p)-3.)+.07*abs(cos(s=a.y));
}
//Tanh tonemap
O = tanh(O/5e3);
}

370
tools/src/generative/Self Reflection.frag Normal file
View File

@@ -0,0 +1,370 @@
// https://www.shadertoy.com/view/XfyXRV
// CC0: Let's self reflect
// Always enjoyed the videos of Platonic solids with inner mirrors
// I made some previous attempts but thought I make another attempt it
// Reducing the alias effects on the inner reflections turned out to be a bit tricky.
// Simplest solution is just to run run fullscreen on a 4K screen ;)
// Function to generate the solid found here: https://www.shadertoy.com/view/MsKGzw
// Tinker with these parameters to create different solids
// -------------------------------------------------------
const float rotation_speed= 0.25;
const float poly_U = 1.; // [0, inf]
const float poly_V = 0.5; // [0, inf]
const float poly_W = 1.0; // [0, inf]
const int poly_type = 3; // [2, 5]
const float poly_zoom = 2.0;
const float inner_sphere = 1.;
const float refr_index = 0.9;
#define MAX_BOUNCES2 6
// -------------------------------------------------------
#define TIME iTime
#define RESOLUTION iResolution
#define PI 3.141592654
#define TAU (2.0*PI)
// License: WTFPL, author: sam hocevar, found: https://stackoverflow.com/a/17897228/418488
const vec4 hsv2rgb_K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 hsv2rgb(vec3 c) {
vec3 p = abs(fract(c.xxx + hsv2rgb_K.xyz) * 6.0 - hsv2rgb_K.www);
return c.z * mix(hsv2rgb_K.xxx, clamp(p - hsv2rgb_K.xxx, 0.0, 1.0), c.y);
}
// License: WTFPL, author: sam hocevar, found: https://stackoverflow.com/a/17897228/418488
// Macro version of above to enable compile-time constants
#define HSV2RGB(c) (c.z * mix(hsv2rgb_K.xxx, clamp(abs(fract(c.xxx + hsv2rgb_K.xyz) * 6.0 - hsv2rgb_K.www) - hsv2rgb_K.xxx, 0.0, 1.0), c.y))
#define TOLERANCE2 0.0005
//#define MAX_RAY_LENGTH2 10.0
#define MAX_RAY_MARCHES2 50
#define NORM_OFF2 0.005
#define BACKSTEP2
#define TOLERANCE3 0.0005
#define MAX_RAY_LENGTH3 10.0
#define MAX_RAY_MARCHES3 90
#define NORM_OFF3 0.005
const vec3 rayOrigin = vec3(0.0, 1., -5.);
const vec3 sunDir = normalize(-rayOrigin);
const vec3 sunCol = HSV2RGB(vec3(0.06 , 0.90, 1E-2))*1.;
const vec3 bottomBoxCol = HSV2RGB(vec3(0.66, 0.80, 0.5))*1.;
const vec3 topBoxCol = HSV2RGB(vec3(0.60, 0.90, 1.))*1.;
const vec3 glowCol0 = HSV2RGB(vec3(0.05 , 0.7, 1E-3))*1.;
const vec3 glowCol1 = HSV2RGB(vec3(0.95, 0.7, 1E-3))*1.;
const vec3 beerCol = -HSV2RGB(vec3(0.15+0.5, 0.7, 2.));
const float rrefr_index = 1./refr_index;
// License: Unknown, author: knighty, found: https://www.shadertoy.com/view/MsKGzw
const float poly_cospin = cos(PI/float(poly_type));
const float poly_scospin = sqrt(0.75-poly_cospin*poly_cospin);
const vec3 poly_nc = vec3(-0.5, -poly_cospin, poly_scospin);
const vec3 poly_pab = vec3(0., 0., 1.);
const vec3 poly_pbc_ = vec3(poly_scospin, 0., 0.5);
const vec3 poly_pca_ = vec3(0., poly_scospin, poly_cospin);
const vec3 poly_p = normalize((poly_U*poly_pab+poly_V*poly_pbc_+poly_W*poly_pca_));
const vec3 poly_pbc = normalize(poly_pbc_);
const vec3 poly_pca = normalize(poly_pca_);
mat3 g_rot;
vec2 g_gd;
// License: MIT, author: Inigo Quilez, found: https://iquilezles.org/articles/noacos/
mat3 rot(vec3 d, vec3 z) {
vec3 v = cross( z, d );
float c = dot( z, d );
float k = 1.0/(1.0+c);
return mat3( v.x*v.x*k + c, v.y*v.x*k - v.z, v.z*v.x*k + v.y,
v.x*v.y*k + v.z, v.y*v.y*k + c, v.z*v.y*k - v.x,
v.x*v.z*k - v.y, v.y*v.z*k + v.x, v.z*v.z*k + c );
}
// License: Unknown, author: Matt Taylor (https://github.com/64), found: https://64.github.io/tonemapping/
vec3 aces_approx(vec3 v) {
v = max(v, 0.0);
v *= 0.6;
float a = 2.51;
float b = 0.03;
float c = 2.43;
float d = 0.59;
float e = 0.14;
return clamp((v*(a*v+b))/(v*(c*v+d)+e), 0.0, 1.0);
}
float sphere(vec3 p, float r) {
return length(p) - r;
}
// License: MIT, author: Inigo Quilez, found: https://iquilezles.org/articles/distfunctions/
float box(vec2 p, vec2 b) {
vec2 d = abs(p)-b;
return length(max(d,0.0)) + min(max(d.x,d.y),0.0);
}
// License: Unknown, author: knighty, found: https://www.shadertoy.com/view/MsKGzw
void poly_fold(inout vec3 pos) {
vec3 p = pos;
for(int i = 0; i < poly_type; ++i){
p.xy = abs(p.xy);
p -= 2.*min(0., dot(p,poly_nc)) * poly_nc;
}
pos = p;
}
float poly_plane(vec3 pos) {
float d0 = dot(pos, poly_pab);
float d1 = dot(pos, poly_pbc);
float d2 = dot(pos, poly_pca);
float d = d0;
d = max(d, d1);
d = max(d, d2);
return d;
}
float poly_corner(vec3 pos) {
float d = length(pos) - .0125;
return d;
}
float dot2(vec3 p) {
return dot(p, p);
}
float poly_edge(vec3 pos) {
float dla = dot2(pos-min(0., pos.x)*vec3(1., 0., 0.));
float dlb = dot2(pos-min(0., pos.y)*vec3(0., 1., 0.));
float dlc = dot2(pos-min(0., dot(pos, poly_nc))*poly_nc);
return sqrt(min(min(dla, dlb), dlc))-2E-3;
}
vec3 shape(vec3 pos) {
pos *= g_rot;
pos /= poly_zoom;
poly_fold(pos);
pos -= poly_p;
return vec3(poly_plane(pos), poly_edge(pos), poly_corner(pos))*poly_zoom;
}
vec3 render0(vec3 ro, vec3 rd) {
vec3 col = vec3(0.0);
float srd = sign(rd.y);
float tp = -(ro.y-6.)/abs(rd.y);
if (srd < 0.) {
col += bottomBoxCol*exp(-0.5*(length((ro + tp*rd).xz)));
}
if (srd > 0.0) {
vec3 pos = ro + tp*rd;
vec2 pp = pos.xz;
float db = box(pp, vec2(5.0, 9.0))-3.0;
col += topBoxCol*rd.y*rd.y*smoothstep(0.25, 0.0, db);
col += 0.2*topBoxCol*exp(-0.5*max(db, 0.0));
col += 0.05*sqrt(topBoxCol)*max(-db, 0.0);
}
col += sunCol/(1.001-dot(sunDir, rd));
return col;
}
float df2(vec3 p) {
vec3 ds = shape(p);
float d2 = ds.y-5E-3;
float d0 = min(-ds.x, d2);
float d1 = sphere(p, inner_sphere);
g_gd = min(g_gd, vec2(d2, d1));
float d = (min(d0, d1));
return d;
}
float rayMarch2(vec3 ro, vec3 rd, float tinit) {
float t = tinit;
#if defined(BACKSTEP2)
vec2 dti = vec2(1e10,0.0);
#endif
int i;
for (i = 0; i < MAX_RAY_MARCHES2; ++i) {
float d = df2(ro + rd*t);
#if defined(BACKSTEP2)
if (d<dti.x) { dti=vec2(d,t); }
#endif
// Bouncing in a closed shell, will never miss
if (d < TOLERANCE2/* || t > MAX_RAY_LENGTH3 */) {
break;
}
t += d;
}
#if defined(BACKSTEP2)
if(i==MAX_RAY_MARCHES2) { t=dti.y; };
#endif
return t;
}
vec3 normal2(vec3 pos) {
vec2 eps = vec2(NORM_OFF2,0.0);
vec3 nor;
nor.x = df2(pos+eps.xyy) - df2(pos-eps.xyy);
nor.y = df2(pos+eps.yxy) - df2(pos-eps.yxy);
nor.z = df2(pos+eps.yyx) - df2(pos-eps.yyx);
return normalize(nor);
}
vec3 render2(vec3 ro, vec3 rd, float db) {
vec3 agg = vec3(0.0);
float ragg = 1.;
float tagg = 0.;
for (int bounce = 0; bounce < MAX_BOUNCES2; ++bounce) {
if (ragg < 0.1) break;
g_gd = vec2(1E3);
float t2 = rayMarch2(ro, rd, min(db+0.05, 0.3));
vec2 gd2 = g_gd;
tagg += t2;
vec3 p2 = ro+rd*t2;
vec3 n2 = normal2(p2);
vec3 r2 = reflect(rd, n2);
vec3 rr2 = refract(rd, n2, rrefr_index);
float fre2= 1.+dot(n2,rd);
vec3 beer = ragg*exp(0.2*beerCol*tagg);
agg += glowCol1*beer*((1.+tagg*tagg*4E-2)*6./max(gd2.x, 5E-4+tagg*tagg*2E-4/ragg));
vec3 ocol = 0.2*beer*render0(p2, rr2);
if (gd2.y <= TOLERANCE2) {
ragg *= 1.-0.9*fre2;
} else {
agg += ocol;
ragg *= 0.8;
}
ro = p2;
rd = r2;
db = gd2.x;
}
return agg;
}
float df3(vec3 p) {
vec3 ds = shape(p);
g_gd = min(g_gd, ds.yz);
const float sw = 0.02;
float d1 = min(ds.y, ds.z)-sw;
float d0 = ds.x;
d0 = min(d0, ds.y);
d0 = min(d0, ds.z);
return d0;
}
float rayMarch3(vec3 ro, vec3 rd, float tinit, out int iter) {
float t = tinit;
int i;
for (i = 0; i < MAX_RAY_MARCHES3; ++i) {
float d = df3(ro + rd*t);
if (d < TOLERANCE3 || t > MAX_RAY_LENGTH3) {
break;
}
t += d;
}
iter = i;
return t;
}
vec3 normal3(vec3 pos) {
vec2 eps = vec2(NORM_OFF3,0.0);
vec3 nor;
nor.x = df3(pos+eps.xyy) - df3(pos-eps.xyy);
nor.y = df3(pos+eps.yxy) - df3(pos-eps.yxy);
nor.z = df3(pos+eps.yyx) - df3(pos-eps.yyx);
return normalize(nor);
}
vec3 render3(vec3 ro, vec3 rd) {
int iter;
vec3 skyCol = render0(ro, rd);
vec3 col = skyCol;
g_gd = vec2(1E3);
float t1 = rayMarch3(ro, rd, 0.1, iter);
vec2 gd1 = g_gd;
vec3 p1 = ro+t1*rd;
vec3 n1 = normal3(p1);
vec3 r1 = reflect(rd, n1);
vec3 rr1 = refract(rd, n1, refr_index);
float fre1= 1.+dot(rd, n1);
fre1 *= fre1;
float ifo = mix(0.5, 1., smoothstep(1.0, 0.9, float(iter)/float(MAX_RAY_MARCHES3)));
if (t1 < MAX_RAY_LENGTH3) {
col = render0(p1, r1)*(0.5+0.5*fre1)*ifo;
vec3 icol = render2(p1, rr1, gd1.x);
if (gd1.x > TOLERANCE3 && gd1.y > TOLERANCE3 && rr1 != vec3(0.)) {
col += icol*(1.-0.75*fre1)*ifo;
}
}
col += (glowCol0+1.*fre1*(glowCol0))/max(gd1.x, 3E-4);
return col;
}
vec3 effect(vec2 p, vec2 pp) {
const float fov = 2.0;
const vec3 up = vec3(0., 1., 0.);
const vec3 la = vec3(0.0);
const vec3 ww = normalize(normalize(la-rayOrigin));
const vec3 uu = normalize(cross(up, ww));
const vec3 vv = cross(ww, uu);
vec3 rd = normalize(-p.x*uu + p.y*vv + fov*ww);
vec3 col = vec3(0.0);
col = render3(rayOrigin, rd);
col -= 2E-2*vec3(2.,3.,1.)*(length(p)+0.25);
col = aces_approx(col);
col = sqrt(col);
return col;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
vec2 q = fragCoord/RESOLUTION.xy;
vec2 p = -1. + 2. * q;
vec2 pp = p;
p.x *= RESOLUTION.x/RESOLUTION.y;
float a = TIME*rotation_speed;
vec3 r0 = vec3(1.0, sin(vec2(sqrt(0.5), 1.0)*a));
vec3 r1 = vec3(cos(vec2(sqrt(0.5), 1.0)*0.913*a), 1.0);
mat3 rot = rot(normalize(r0), normalize(r1));
g_rot = rot;
vec3 col = effect(p, pp);
fragColor = vec4(col, 1.0);
}

137
tools/src/generative/Windows 10 Live.frag Normal file
View File

@@ -0,0 +1,137 @@
// https://www.shadertoy.com/view/lllSR2
#define PI 3.1415926535897921284
#define REP 25
#define d2r(x) (x * PI / 180.0)
#define WBCOL (vec3(0.5, 0.7, 1.7))
#define WBCOL2 (vec3(0.15, 0.8, 1.7))
#define ZERO (min(iFrame,0))
float hash( vec2 p ) {
float h = dot( p, vec2( 127.1, 311.7 ) );
return fract( sin( h ) * 458.325421) * 2.0 - 1.0;
}
float noise( vec2 p ) {
vec2 i = floor( p );
vec2 f = fract( p );
f = f * f * ( 3.0 - 2.0 * f );
return mix(
mix( hash( i + vec2( 0.0, 0.0 ) ), hash( i + vec2( 1.0, 0.0 ) ), f.x ),
mix( hash( i + vec2( 0.0, 1.0 ) ), hash( i + vec2( 1.0, 1.0 ) ), f.x ),
f.y
);
}
vec2 rot(vec2 p, float a) {
return vec2(
p.x * cos(a) - p.y * sin(a),
p.x * sin(a) + p.y * cos(a));
}
float nac(vec3 p, vec2 F, vec3 o) {
const float R = 0.0001;
p += o;
return length(max(abs(p.xy)-vec2(F),0.0)) - R;
}
float by(vec3 p, float F, vec3 o) {
const float R = 0.0001;
p += o;
return length(max(abs(mod(p.xy, 3.0))-F,0.0)) - R;
}
float recta(vec3 p, vec3 F, vec3 o) {
const float R = 0.0001;
p += o;
return length(max(abs(p)-F,0.0)) - R;
}
float map1(vec3 p, float scale) {
float G = 0.50;
float F = 0.50 * scale;
float t = nac(p, vec2(F,F), vec3( G, G, 0.0));
t = min(t, nac(p, vec2(F,F), vec3( G, -G, 0.0)));
t = min(t, nac(p, vec2(F,F), vec3(-G, G, 0.0)));
t = min(t, nac(p, vec2(F,F), vec3(-G, -G, 0.0)));
return t;
}
float map2(vec3 p) {
float t = map1(p, 0.9);
//t = max(t, recta(p, vec3(1.0, 1.0, 0.02), vec3(0.0, 0.0, 0.0)));
t = max(t, recta(p, vec3(1.0, 1.0, 0.02), vec3(0.0, 0.0, 0.0)));
return t;
}
// http://glslsandbox.com/e#26840.0
float gennoise(vec2 p) {
float d = 0.5;
mat2 h = mat2( 1.6, 1.2, -1.2, 1.6 );
float color = 0.0;
for( int i = 0; i < 2; i++ ) {
color += d * noise( p * 5.0 + iTime);
p *= h;
d /= 2.0;
}
return color;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
fragColor = vec4(0.0);
for(int count = 0 ; count < 2; count++) {
vec2 uv = -1.0 + 2.0 * ( fragCoord.xy / iResolution.xy );
uv *= 1.4;
uv.x += hash(uv.xy + iTime + float(count)) / 512.0;
uv.y += hash(uv.yx + iTime + float(count)) / 512.0;
vec3 dir = normalize(vec3(uv * vec2(iResolution.x / iResolution.y, 1.0), 1.0 + sin(iTime) * 0.01));
dir.xz = rot(dir.xz, d2r(70.0));
dir.xy = rot(dir.xy, d2r(90.0));
vec3 pos = vec3(-0.1 + sin(iTime * 0.3) * 0.1, 2.0 + cos(iTime * 0.4) * 0.1, -3.5);
vec3 col = vec3(0.0);
float t = 0.0;
float M = 1.002;
float bsh = 0.01;
float dens = 0.0;
for(int i = ZERO ; i < REP * 24; i++) {
float temp = map1(pos + dir * t, 0.6);
if(temp < 0.2) {
col += WBCOL * 0.005 * dens;
}
t += bsh * M;
bsh *= M;
dens += 0.025;
}
//windows
t = 0.0;
float y = 0.0;
//for(int i = 0 ; i < REP * 50; i++)
for(int i = ZERO ; i < REP; i++)
{
float temp = map2(pos + dir * t);
if(temp < 0.025) {
//col += WBCOL2 * 0.005;
col += WBCOL2 * 0.5;
}
t += temp;
y++;
}
col += ((2.0 + uv.x) * WBCOL2) + (y / (25.0 * 50.0));
col += gennoise(dir.xz) * 0.5;
col *= 1.0 - uv.y * 0.5;
col *= vec3(0.05);
col = pow(col, vec3(0.717));
fragColor += vec4(col, 1.0 / (t));
}
fragColor /= vec4(2.0);
}

45
tools/src/generative/sdEquilateral.frag Normal file
View File

@@ -0,0 +1,45 @@
vec3 palette( float t ) {
vec3 a = vec3(0.2, 0.2, 0.5); // blue has a greater default
vec3 b = vec3(0.5, 0.5, 0.5); // all channels contribute
vec3 c = vec3(0.1, 0.1, 0.4); // dampen blue oscillations
vec3 d = vec3(0.0,0.33,0.67); // phase shifting by 0.33
return a + b*cos( 6.28318*(c*t+d) );
}
float sdEquilateralTriangle( in vec2 p, in float r )
{
const float k = sqrt(3.0);
p.x = abs(p.x) - r;
p.y = p.y + r/k;
if( p.x+k*p.y>0.0 ) p = vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;
p.x -= clamp( p.x, -2.0*r, 0.0 );
return -length(p)*sign(p.y);
}
float norm( in vec2 p )
{
return sdEquilateralTriangle(p*1.5, 0.1);
}
void mainImage( out vec4 fragColour, in vec2 fragCoord ) {
vec2 uv = (fragCoord *2.0 - iResolution.xy) / iResolution.y;
uv = floor(uv*100.0f)/100.0f;
vec2 uv0 = uv;
vec3 finalColour = vec3(0.0);
for (float i = 0.0; i < 4.0; i++) {
uv = fract(uv * 1.5) - 0.5;
float d = norm(uv) * exp(-norm(uv0));
vec3 col = palette(norm(uv0) + i*.4 + iTime*.4);
d = sin(d*8. + iTime)/8.;
d = abs(d);
d = pow(0.009 / d, 1.6);
finalColour += col * d;
}
fragColour = vec4(finalColour, 1.0);
}