libretro/slang-shaders
1
0
Fork 0
mirror of https://github.com/libretro/slang-shaders.git synced 2024-11-26 18:10:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

More shaders

Browse Source
This commit is contained in:
twinaphex 2018-02-24 02:20:43 +01:00
parent 239d4eb63a
commit 51a8c0b40d
41 changed files with 14674 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

324
procedural/2vs-pbr-test.slang Normal file
View File

@ -0,0 +1,324 @@
#version 450
// PBR_Test - 2v_S - 2015-05-24
// https://www.shadertoy.com/view/MIB3DV
// Physically Based Rendering Tes
/*
* References :
*
* http://renderwonk.com/publications/s2010-shading-course/hoffman/s2010_physically_based_shading_hoffman_b_notes.pdf
*
* http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
*
* http://graphicrants.blogspot.fr/2013/08/specular-brdf-reference.html
*
* http://www.filmicworlds.com/2014/04/21/optimizing-ggx-shaders-with-dotlh/
*
* http://blog.selfshadow.com/publications/s2013-shading-course/#course_content
*
* Ray marching code from iq
*/
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define NB_LIGHTS 3
// Metals values in linear space
#define GOLD vec3(1.0, 0.71, 0.29)
#define COPPER vec3(0.95, 0.64, 0.54)
#define IRON vec3(0.56, 0.57, 0.58)
#define ALUMINIUM vec3(0.91, 0.92, 0.92)
#define SILVER vec3(0.95, 0.93, 0.88)
float fPlane( vec3 p, vec4 n )
{
// n must be normalized
return dot(p,n.xyz) + n.w;
}
float fSphere( vec3 p, float s )
{
return length(p)-s;
}
float opS( float d1, float d2 )
{
return max(-d2,d1);
}
vec2 opU( vec2 d1, vec2 d2 )
{
return (d1.x<d2.x) ? d1 : d2;
}
vec3 opRep( vec3 p, vec3 c )
{
return mod(p,c)-0.5*c;
}
// ---- Scene definition
vec2 fScene(vec3 p) {
vec3 pSphere = p/*opRep(p, vec3( 2.0, 0.0, 2.0))*/;
vec2 sphere0 = vec2(fSphere(p, 1.0), 0.5);
vec2 sphere1 = vec2(fSphere(p+vec3(2.1, 0.0, 2.0), 1.0), 2.5);
vec2 sphere2 = vec2(fSphere(p+vec3(-2.1, 0.0, 2.0), 1.0), 3.5);
vec2 sphere3 = vec2(fSphere(p+vec3(2.1, 0.0, -2.0), 1.0), 4.5);
vec2 sphere4 = vec2(fSphere(p+vec3(-2.1, 0.0, -2.0), 1.0), 5.5);
vec2 plane = vec2(fPlane(p, vec4(0, 1, 0, 1.0)), 1.5);
return opU(opU(opU(opU(opU(plane, sphere0), sphere1), sphere2), sphere3), sphere4);
}
// -----
vec2 castRay( in vec3 ro, in vec3 rd )
{
float tmin = 1.0;
float tmax = 100.0;
float precis = 0.00001;
float t = tmin;
float m = -1.0;
for( int i=0; i<50; i++ )
{
vec2 res = fScene( ro+rd*t );
if( res.x<precis || t>tmax ) break;
t += res.x;
m = res.y;
}
if( t>tmax ) m=-1.0;
return vec2( t, m );
}
float softshadow( in vec3 ro, in vec3 rd, in float mint, in float tmax )
{
float res = 1.0;
float t = mint;
for( int i=0; i<16; i++ )
{
float h = fScene( ro + rd*t ).x;
res = min( res, 8.0*h/t );
t += clamp( h, 0.02, 0.10 );
if( h<0.001 || t>tmax ) break;
}
return clamp( res, 0.0, 1.0 );
}
vec3 calcNormal( in vec3 pos )
{
vec3 eps = vec3( 0.001, 0.0, 0.0 );
vec3 nor = vec3(
fScene(pos+eps.xyy).x - fScene(pos-eps.xyy).x,
fScene(pos+eps.yxy).x - fScene(pos-eps.yxy).x,
fScene(pos+eps.yyx).x - fScene(pos-eps.yyx).x );
return normalize(nor);
}
struct Light {
vec3 pos;
vec3 color;
};
Light lights[NB_LIGHTS];
float G1V ( float dotNV, float k ) {
return 1.0 / (dotNV*(1.0 - k) + k);
}
vec3 computePBRLighting ( in Light light, in vec3 position, in vec3 N, in vec3 V, in vec3 albedo, in float roughness, in vec3 F0 ) {
float alpha = roughness*roughness;
vec3 L = normalize(light.pos.xyz - position);
vec3 H = normalize (V + L);
float dotNL = clamp (dot (N, L), 0.0, 1.0);
float dotNV = clamp (dot (N, V), 0.0, 1.0);
float dotNH = clamp (dot (N, H), 0.0, 1.0);
float dotLH = clamp (dot (L, H), 0.0, 1.0);
float D, vis;
vec3 F;
// NDF : GGX
float alphaSqr = alpha*alpha;
float pi = 3.1415926535;
float denom = dotNH * dotNH *(alphaSqr - 1.0) + 1.0;
D = alphaSqr / (pi * denom * denom);
// Fresnel (Schlick)
float dotLH5 = pow (1.0 - dotLH, 5.0);
F = F0 + (1.0 - F0)*(dotLH5);
// Visibility term (G) : Smith with Schlick's approximation
float k = alpha / 2.0;
vis = G1V (dotNL, k) * G1V (dotNV, k);
vec3 specular = /*dotNL **/ D * F * vis;
vec3 ambient = vec3(.01);
float invPi = 0.31830988618;
vec3 diffuse = (albedo * invPi);
return ambient + (diffuse + specular) * light.color.xyz * dotNL ;
}
vec3 addPBR( in vec3 position, in vec3 N, in vec3 V, in vec3 baseColor, in float metalMask, in float smoothness, in float reflectance) {
vec3 color = vec3(0.0);
float roughness = 1.0 - smoothness*smoothness;
vec3 F0 = 0.16*reflectance*reflectance * (1.0-metalMask) + baseColor*metalMask;
vec3 albedo = baseColor;
float s = 0.0;
for ( int i = 0; i < NB_LIGHTS; ++i ) {
vec3 col = computePBRLighting ( lights[i], position, N, V, albedo, roughness, F0);
color += col;
s += softshadow( position, normalize(lights[i].pos.xyz - position), 0.02, 2.5 );
}
return color*s;
}
vec3 render( in vec3 ro, in vec3 rd )
{
vec3 col = vec3(0.8, 0.9, 1.0)*8.0; // Sky color
vec2 res = castRay( ro, rd );
float t = res.x;
float m = res.y;
vec3 p = ro + t*rd;
if(m>-0.5) { // Intersection found
if( m < 1.0 ) {
// float f = mod( floor( 5.0*p.z ) + floor( 5.0*p.x ), 2.0 );
vec3 sur = vec3(1.0,1.0,1.0)*smoothstep(-1.0,-0.6,sin(16.0*p.x));
col = addPBR( p, calcNormal( p ), -rd, GOLD*sur, sur.x, 0.3+0.6*sur.x, 0.5 );
}
else if( m < 2.0 ) {
float f = mod( floor( 5.0*p.z ) + floor( 5.0*p.x ), 2.0 );
col = addPBR(p, calcNormal( p ), -rd, vec3(0.5), 0.0, 0.3+0.6*f, 0.5 );
}
else if( m < 3.0 ) {
vec3 sur = vec3(1.0,1.0,1.0)*smoothstep(-1.0,-0.4,sin(18.0*p.x));
col = addPBR( p, calcNormal( p ), -rd, COPPER*sur, sur.x, 0.3+0.6*sur.x, 0.5 );
}
else if( m < 4.0 ) {
vec3 sur = vec3(1.0,1.0,1.0)*smoothstep(-1.0,-0.0995,sin(106.0*p.x))*smoothstep(-1.0,-0.9,sin(47.0*p.z));
col = addPBR( p, calcNormal( p ), -rd, vec3(0.2), 1.0-sur.x, 0.9*sur.x, 0.5 );
}
else if( m < 5.0 ) {
vec3 sur = vec3(1.0)*smoothstep(-1.0,-0.765,sin(24.0*p.x))*smoothstep(-1.0,-0.4,sin(70.9*p.z));
col = addPBR( p, calcNormal( p ), -rd, GOLD*(1.0-sur), sur.x, 0.3+0.6*sur.x, 0.5 );
}
else if( m < 6.0 ) {
vec3 sur = vec3(1.0,1.0,1.0)*smoothstep(-1.0,-0.4,sin(18.0*p.x));
col = addPBR( p, calcNormal( p ), -rd, ALUMINIUM*sur, sur.x, 0.3+0.6*sur.x, 0.5 );
}
}
return col;
}
mat3 setCamera( in vec3 ro, in vec3 ta, float cr )
{
vec3 cw = normalize(ta-ro);
vec3 cp = vec3(sin(cr), cos(cr),0.0);
vec3 cu = normalize( cross(cw,cp) );
vec3 cv = normalize( cross(cu,cw) );
return mat3( cu, cv, cw );
}
vec4 hejlToneMapping (in vec4 color) {
vec4 x = max(vec4(0.0), color-vec4(0.004));
return (x * ((6.2*x)+vec4(0.5))) / max(x * ((6.2*x)+vec4(1.7))+vec4(0.06), vec4(1e-8));
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
float time = 0.25*iGlobalTime;
lights[0] = Light(vec3(0.0, 5.0, .0), vec3(1.0));
lights[1] = Light(vec3(12.0*sin(iGlobalTime), 8.0, 12.0*cos(iGlobalTime)), vec3(1.0));
lights[2] = Light(vec3(-12.0*cos(-iGlobalTime), 8.0, 12.0*sin(-iGlobalTime)), vec3(.05));
vec2 q = fragCoord.xy/iResolution.xy;
vec2 p = -1.0+2.0*q;
p.x *= iResolution.x/iResolution.y;
#ifdef MOUSE
vec2 mo = iMouse.xy/iResolution.xy;
#else
vec2 mo = 0.0/iResolution.xy;
#endif
// camera
vec3 ro = vec3( 7.0*sin(time), 3.6 , -7.0*cos(time) );
vec3 ta = vec3( 0.0 );
// camera-to-world transformation
mat3 ca = setCamera( ro, ta, 0.0 );
// ray direction
vec3 rd = ca * normalize( vec3(p.xy,2.5) );
// render
vec3 col = render( ro, rd );
#if 0
col = pow( col, vec3(0.4545) );
fragColor=vec4( col, 1.0 );
#else
float exposure = 0.032 + 0.023*sin(time-3.14);
fragColor = hejlToneMapping(vec4(col, 1.0) * exposure) ;
#endif
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

332
procedural/bergi-cave-quest.slang Normal file
View File

@ -0,0 +1,332 @@
#version 450
// Cave Quest - Bergi - 2016-06-25
// https://www.shadertoy.com/view/XdGXD3
// Lot's of finetuning to get a nice cave fly-through.
// Greetings to Kali and Shane
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
/** Cave Quest
https://www.shadertoy.com/view/XdGXD3
(cc) 2016, stefan berke
Based on "Kali Trace" https://www.shadertoy.com/view/4sKXWG
Interesting things here might be:
- the distance formula in itself
- wrapping 3d-space using sin() for endless kali-set patterns
- kali-set used for normals, micro-normals and texturing
- epsilon in normal estimation for artistic tuning
*/
// minimum distance to axis-aligned planes in kali-space
// uses eiffie's mod (/p.w) https://www.shadertoy.com/view/XtlGRj
// to keep the result close to a true distance function
vec3 kali_set(in vec3 pos, in vec3 param)
{
vec4 p = vec4(pos, 1.);
vec3 d = vec3(100.);
for (int i=0; i<9; ++i)
{
p = abs(p) / dot(p.xyz,p.xyz);
d = min(d, p.xyz/p.w);
p.xyz = p.zxy - param;
}
return d;
}
// average of all iterations in kali-set
vec3 kali_set_av(in vec3 p, in vec3 param)
{
vec3 d = vec3(0.);
for (int i=0; i<13; ++i)
{
p = abs(p) / dot(p,p);
d += exp(-p*8.);
p.xyz = p.zxy - param;
}
return d / 8.;
}
// endless texture
vec3 kali_tex(in vec3 p, in vec3 par)
{
vec3 k = kali_set_av(sin(p*3.)*.3, par);
return 3.*k;
}
// endless texture normal
vec3 kali_tex_norm(in vec3 p, in vec3 param, vec3 mask, float eps)
{
vec2 e = vec2(eps, 0.);
return normalize(vec3(
dot(kali_tex(p+e.xyy, param),mask) - dot(kali_tex(p-e.xyy, param),mask),
dot(kali_tex(p+e.yxy, param),mask) - dot(kali_tex(p-e.yxy, param),mask),
dot(kali_tex(p+e.yyx, param),mask) - dot(kali_tex(p-e.yyx, param),mask)));
}
// camera path
vec3 path(in float z)
{
float t = z;
vec3 p = vec3(sin(t)*.5,
.26*sin(t*3.16),
z);
return p;
}
float DE(in vec3 p, in vec3 param)
{
// tube around path
float r = .13+.1*sin(p.z*.89);
vec3 pp = p - path(p.z); float d = r-max(abs(pp.x), abs(pp.y));
// displacement
vec3 k = kali_set(sin(p), param);
d += k.x+k.y+k.z;
//d += max(k.x,max(k.y,k.z));
//d += min(k.x,min(k.y,k.z));
return d;
}
vec3 DE_norm(in vec3 p, in vec3 param, in float eps)
{
vec2 e = vec2(eps, 0.);
return normalize(vec3(
DE(p+e.xyy, param) - DE(p-e.xyy, param),
DE(p+e.yxy, param) - DE(p-e.yxy, param),
DE(p+e.yyx, param) - DE(p-e.yyx, param)));
}
// lighting/shading currently depends on this beeing 1.
const float max_t = 1.;
// common sphere tracing
// note the check against abs(d) to get closer to surface
// in case of overstepping
float trace(in vec3 ro, in vec3 rd, in vec3 param)
{
float t = 0.001, d = max_t;
for (int i=0; i<50; ++i)
{
vec3 p = ro + rd * t;
d = DE(p, param);
if (abs(d) <= 0.00001 || t >= max_t)
break;
t += d * .5; // above kali-distance still needs a lot of fudging
}
return t;
}
// "Enhanced Sphere Tracing"
// Benjamin Keinert(1) Henry Schäfer(1) Johann Korndörfer Urs Ganse(2) Marc Stamminger(1)
// 1 University of Erlangen-Nuremberg, 2 University of Helsinki
//
// It was a try... disabled by default (see rayColor() below)
// Just here for experimentation
// Obviously the algorithm does not like "fudging" which is needed for my distance field..
// It renders more stuff close to edges but creates a lot of artifacts elsewhere
float trace_enhanced(in vec3 ro, in vec3 rd, in vec3 param)
{
float omega = 1.2; // overstepping
float t = 0.001;
float candidate_error = 100000.;
float candidate_t = t;
float previousRadius = 0.;
float stepLength = .0;
float signedRadius;
float pixelRadius = .012;
float fudge = 0.6;
for (int i = 0; i < 50; ++i)
{
signedRadius = DE(rd*t + ro, param);
float radius = abs(signedRadius);
bool sorFail = omega > 1. && (radius + previousRadius) < stepLength;
if (sorFail)
{
stepLength -= omega * stepLength;
omega = 1.;
}
else
{
stepLength = signedRadius * omega;
}
previousRadius = radius;
float error = radius / t;
if (!sorFail && error < candidate_error)
{
candidate_t = t;
candidate_error = error;
}
if (!sorFail && error < pixelRadius || t > max_t)
break;
t += stepLength * fudge;
}
return (t > max_t || candidate_error > pixelRadius)
? max_t : candidate_t;
}
// common ambient occlusion
float traceAO(in vec3 ro, in vec3 rd, in vec3 param)
{
float a = 0., t = 0.01;
for (int i=0; i<5; ++i)
{
float d = DE(ro+t*rd, param);
a += d / t;
t += abs(d);
}
return clamp(a / 8., 0., 1.);
}
// environment map, also drawn from kaliset
vec3 skyColor(in vec3 rd)
{
//vec3 par = vec3(0.075, 0.565, .03);
vec3 par = vec3(.9, .81, .71);
vec3 c = kali_set(sin(rd*6.), par);
c = pow(min(vec3(1.), c*2.+vec3(1.,.86,.6)), 1.+114.*c);
return clamp(c, 0., 1.);
}
// trace and color
vec3 rayColor(in vec3 ro, in vec3 rd)
{
// magic params for kali-set
vec3 par1 = vec3(.9, .6+.5*sin(ro.z/50.), 1.), // scene geometry
par2 = vec3(.63, .55, .73), // normal/bump map
par3 = vec3(1.02, 0.82, 0.77); // normal/texture
#if 1
float t = trace(ro, rd, par1);
#else
float t = trace_enhanced(ro, rd, par1);
#endif
vec3 p = ro + t * rd;
float d = DE(p, par1);
vec3 col = vec3(0.);
// did ray hit?
if (d < 0.03)
{
float scr_eps = max(0.001, (t-0.1)*0.025);
// "some" texture values
vec3 kt = kali_tex(p, par3);
// surface normal
vec3 n = DE_norm(p, par1, 0.5*scr_eps), nn = n;
// normal displacement
n = normalize(n + 0.3*kali_tex_norm(p, par3+0.1*n, vec3(1), scr_eps));
n = normalize(n + 0.3*DE_norm(sin(n*3.+kt), par2, 2.*scr_eps)); // micro-bumps
// reflected ray
vec3 rrd = reflect(rd,n);
// normal towards light
vec3 ln = normalize(path(p.z+.1) - p);
// 1. - occlusion
float ao = pow(traceAO(p, n, par1), 1.+3.*t);
// surface color
vec3 col1 = .45 * (vec3(.7,1.,.4) + kali_tex(p, par3));
vec3 col2 = vec3(1.,.8,.6) + .3 * vec3(1.,.7,-.6) * kali_tex(p, par3);
vec3 k = kali_set_av(sin(p*(1.+3.*ao))*.3, par3);
vec3 surf = (.1 + .9 * ao)
//* vec3(1.);
* mix(col1, col2, min(1., pow(ao*2.2-.8*kt.x,5.)));
// desaturate
surf += .24 * (dot(surf,vec3(.3,.6,.1)) - surf);
// -- lighting --
float fres = pow(max(0., 1.-dot(rrd, n)), 1.) / (1.+2.*t);
// phong
surf += .25 * ao * max(0., dot(n, ln));
// spec
float d = max(0., dot(rrd, ln));
surf += .4 * pow(ao*1.2,5.) * (.5 * d + .7 * pow(d, 8.));
// fresnel highlight
surf += clamp((t-.06)*8., 0.,1.6) *
(.2+.8*ao) * vec3(.7,.8,1.) * fres;
// environment map
surf += .2 * (1.-fres) * ao * skyColor(rrd);
// distance fog
col = surf * pow(1.-t / max_t, 1.3);
}
return col;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 suv = fragCoord.xy / iResolution.xy;
vec2 uv = (fragCoord.xy - iResolution.xy*.5) / iResolution.y * 2.;
float ti = (iGlobalTime-14.)/8.;
vec3 ro = path(ti);
vec3 look = path(ti+.5);
float turn = (ro.x-look.x)*1.;
// lazily copied from Shane
// (except the hacky turn param)
float FOV = .7; // FOV - Field of view.
vec3 fwd = normalize(look-ro);
vec3 rgt = normalize(vec3(fwd.z, turn, -fwd.x));
vec3 up = cross(fwd, rgt);
vec3 rd = normalize(fwd + FOV*(uv.x*rgt + uv.y*up));
vec3 col = rayColor(ro, rd);
//col = skyColor(rd);
col *= pow(1.-dot(suv-.5,suv-.5)/.5, .6);
fragColor = vec4(pow(col,vec3(.8)),1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

848
procedural/ciberxtrem-portal-highquality.slang Normal file
View File

@ -0,0 +1,848 @@
#version 450
// Portal Gameplay
// ciberxtrem - https://www.shadertoy.com/view/XlsSzM
// Inspired in Portal, Chamber 8.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
// Thanks iq and the Shadertoy comunity for all the shared knowledge! :)
#define PI 3.14159265359
struct LightStruct {
vec3 pos;
vec3 color;
};
struct PortalStruct {
vec3 pos;
vec3 front;
float rotateY;
float time;
};
struct StateStruct
{
vec3 posStart;
vec3 posEnd;
float lerptime;
float duration;
float isEnterTime;
float enterPortal;
float exitPortal;
};
struct OrientationStruct
{
vec3 orientation;
float lerptime;
float duration;
};
PortalStruct portalA;
PortalStruct portalB;
PortalStruct portalsA[8];
StateStruct states[10];
OrientationStruct orientations[15];
LightStruct lights[3];
float t;
vec3 position;
vec3 orientation;
float ambient = 0.05;
vec3 ambientcolor;
vec3 rotateY(vec3 p, float a){
return vec3(
p.x*cos(a) + p.z*sin(a),
p.y,
p.z*cos(a) - p.x*sin(a)
);
}
float hash( float n ) {
return fract(sin(n)*43758.5453123);
}
float noise( in vec2 x ) {
vec2 p = floor(x);
vec2 f = fract(x);
f = f*f*(3.0-2.0*f);
float n = p.x + p.y*157.0;
return mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x),
mix( hash(n+157.0), hash(n+158.0),f.x),f.y);
}
const mat2 m2 = mat2( 0.80, -0.60, 0.60, 0.80 );
float fbm( vec2 p ) {
float f = 0.0;
f += 0.5000*noise( p ); p = m2*p*2.02;
f += 0.2500*noise( p ); p = m2*p*2.03;
f += 0.1250*noise( p ); p = m2*p*2.01;
f += 0.0625*noise( p );
return f/0.9375;
}
float dBox(vec3 p, vec3 hsize)
{
return length(max(abs(p)-hsize,0.0));
}
float udRoundBox( vec3 p, vec3 b, float r )
{
return length(max(abs(p)-b,0.0))-r;
}
float sdCappedCylinder( vec3 p, vec2 h )
{
vec2 d = abs(vec2(length(p.xz),p.y)) - h;
return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
//-------------------------------
// Scene
float dElipse(vec3 p, vec3 hsize, float globalSize)
{
float d = length(max(abs(p)-hsize,0.0));
vec3 q = p;
q.y *= 0.6;
return max(d, length(q)-max(max(hsize.x, hsize.y)*globalSize, hsize.z));
}
vec2 dStructure(vec3 p)
{
// Front
vec2 res = vec2(-1., -1.);
vec3 q = p - vec3(0., 0.5, 28.25);
vec2 c = vec2(3., 6.2);
vec3 q2 = q; q2.xy = mod(q2.xy,c.xy)-0.5*c.xy;
float d = udRoundBox(q2, vec3(1.35, 3., 1.0), 0.25);
q = p - vec3(0.0, 9.5, 28.); // Hole for exit
float d2 = udRoundBox(q, vec3(3.0, 3.25, 2.0), 0.1);
d = max(d,-d2);
res = vec2(d, 24.);
//Back
q = p - vec3(0., 3.5, -28.0);
c = vec2(3., 6.2);
q.x = mod(q.x,c.x)-0.5*c.x;
d = udRoundBox(q, vec3(1.35, 3., 1.0), 0.25);
res = mix(vec2(d, 24.), res, step(res.x, d));
q = p - vec3(0., 0.6, -28.01); // Brown block
c = vec2(3., 3.0);
q.xy = mod(q.xy,c.xy)-0.5*c.xy;
d = udRoundBox(q, vec3(1.35, 1.35, 1.0), 0.25);
q = p - vec3(0.0, 9.5, -28.); // Hole for exit
d2 = udRoundBox(q, vec3(3.0, 3.25, 2.0), 0.1);
d = max(d,-d2);
res = mix(vec2(d, 20.), res, step(res.x, d));
//Exit
vec3 p2 = p; p2.z = abs(p.z);
q = p2 - vec3(0.0, 9.5, 30.5);
d = udRoundBox(q, vec3(3.0, 3.25, 0.1), 0.1);
if(d<res.x){res = vec2(d, 10.);} // magic panel
q2 = q - vec3(4.5, 0., -1.); q2.x += abs(sin(length(1.5+abs(q2.y)*0.36)));
d = udRoundBox(q2, vec3(1.5, 4.5, 2.0), 0.1);
q2 = q - vec3(-4.5, 0., -1.); q2.x -= abs(sin(length(1.5+abs(q2.y)*0.36)));
d2 = udRoundBox(q2, vec3(1.5, 4.5, 2.0), 0.1);
d = min(d, d2);
res = mix(vec2(d, 11.), res, step(res.x, d));
//Left
q = p - vec3(-16., 0.5, 0.0);
c = vec2(3.0, 6.2);
q2 = q; q2.zy = mod(q2.zy,c)-0.5*c;
d = udRoundBox(q2, vec3(1., 3., 1.35), 0.25);
res = mix(vec2(d, 24.), res, step(res.x, d));
//Right
q = p - vec3(16.0, 0.5, 0.0);
c = vec2(3.0, 6.2);
q.zy = mod(q.zy,c)-0.5*c;
d = udRoundBox(q, vec3(1., 3., 1.35), 0.25);
// Hole for window
q = p - vec3(15.0, 15.5, -9.0);
d2 = udRoundBox(q, vec3(2.0, 3., 6.0), 0.02);
d = max(d, -d2);
res = mix(vec2(d, 24.), res, step(res.x, d));
// Column
q = p - vec3(0., 0.6, -23.90);
c = vec2(3., 3.0);
q.xy = mod(q.xy,c)-0.5*c;
d = udRoundBox(q, vec3(1.35, 1.35, 2.70), 0.25);
d = max(d, -(p.x-6.1));
res = mix(vec2(d, 24.), res, step(res.x, d));
// Ceiling
q = p - vec3(0., 20.4, .0);
c = vec2(3.0, 3.0);
q2 = q; q2.xz = mod(q2.xz,c)-0.5*c;
d = udRoundBox(q2, vec3(1.35, 1., 1.35), 0.25);
d2 = length(q)-6.;
d = max(d, -d2);
res = mix(vec2(d, 23.), res, step(res.x, d));
//Window
q = p - vec3(16.0, 15.5, -9.0);
d = udRoundBox(q, vec3(1.25, 3., 6.0), 0.02); // framework
d2 = udRoundBox(q, vec3(1.5, 2.6, 5.6), 0.02);
d = max(d, -d2);
d = min(d, udRoundBox(q, vec3(1.2, 3., 0.2), 0.02)); // bars
res = mix(vec2(d, 7.), res, step(res.x, d));
d = udRoundBox(q, vec3(1.0, 2.6, 5.6), 0.1);
d -= smoothstep(-1., 1., cos(p.y*15.)) * 0.0025;
res = mix(vec2(d, 5.), res, step(res.x, d));
// Dome
q = p-vec3(0., 21.5, 0.);
q.y *= 1.0;
d = length(q) - 6.;
res = mix(vec2(d, 9.), res, step(res.x, d));
//Turbina
q = p - vec3(0.0, 15.0, 0.0);
q = rotateY(q, t);
d = dBox(q, vec3(5.5, 0.05, 0.4));
d2 = dBox(q, vec3(0.4, 0.05, 5.5));
d = min(d, d2);
d2 = sdCappedCylinder(q-vec3(0., 0.5, 0.), vec2(0.4, 0.5));
d = min(d, d2);
res = mix(vec2(d, 4.), res, step(res.x, d));
// Front railing
q = p - vec3(-5.5, 6.5, 23.2);
d = dBox(q, vec3(9.0, 0.1, 4.0));
res = mix(vec2(d, 8.), res, step(res.x, d));
d = udRoundBox(q-vec3(0., 1.6, -4.0), vec3(9.0, 1.7, 0.05), 0.02);
d2 = udRoundBox(q-vec3(0., 1.6, -4.0), vec3(8.8, 1.5, 0.5), 0.02);
d = max(d, -d2);
d = min(d, udRoundBox(q-vec3(8.9, 3.2, 0.0), vec3(0.10, 0.10, 4.0), 0.01));
res = mix(vec2(d, 7.), res, step(res.x, d));
// Back railing
q = p - vec3(-0.5, 6.5, -24.2);
d = dBox(q, vec3(6.0, 0.1, 3.0));
res = mix(vec2(d, 8.), res, step(res.x, d));
d = udRoundBox(q-vec3(0.5, 1.6, 3.2), vec3(6.0, 1.7, 0.1), 0.02);
d2 = udRoundBox(q-vec3(0.5, 1.6, 3.2), vec3(5.8, 1.5, 1.0), 0.02);
d = max(d, -d2);
res = mix(vec2(d, 7.), res, step(res.x, d));
return res;
}
vec2 dWater(vec3 p)
{
vec3 q = p - vec3(0., -0., .0);
float d = dBox(q, vec3(20., 0.2, 40.));
d-=smoothstep(-1., 1., cos(p.x*2.1+t*2.)*cos(p.z*3.5+t*1.6))*0.01;
float d2 = smoothstep(-1., 1., cos(length(p.xz)*2.-t))*0.05;
d2 = mix(0., d2, smoothstep(1.0, 10., length(q.xz)));
d -= d2;
return vec2(d, 3.);
}
vec2 dPlatforms(vec3 p)
{
// Front Right Platform
vec2 res = vec2(-1, -1.);
vec3 q = p - vec3(11.5, 7., 7.0);
vec2 c = vec2(3.0);
vec3 q2 = q; q2.xz = mod(q2.xz+vec2(0., 1.0),c)-0.5*c;
float d = udRoundBox(q2, vec3(1.415, 0.2, 1.415), 0.1);
d = max(d, q.z-5.); d = max(d, -(q.z+4.)); d = max(d, -(q.x+6.));
res = vec2(d, 21.);
//Tube
d = sdCappedCylinder(q-vec3(0., -4., 0.), vec2(0.65, 3.));
d = min(d, sdCappedCylinder(q-vec3(0., -7.5, 0.), vec2(1.0, 2.)));
res = mix(vec2(d, 6.), res, step(res.x, d));
// Front Left Platform
vec3 leftPlatPos = vec3(-10.0, 7., -2.0);
if(t > 29.0){
float phase = (t-29.)/7.;
float seq = mod(phase, 2.);
leftPlatPos =mix(vec3(-10, 7., -2.), vec3(-11.6, 7., -23.0), fract(phase));
}
q = p - leftPlatPos;
d = udRoundBox(q, vec3(3.8, 0.02, 3.8), 0.01);
res = mix(vec2(d, 22.), res, step(res.x, d));
// Border
d = udRoundBox(q, vec3(4.0, 0.05, 4.0), 0.1);
float d2 = udRoundBox(q, vec3(3.5, 0.1, 3.5), 0.1);
d = max(d, -d2);
res = mix(vec2(d, 24.), res, step(res.x, d));
// Crosses
d = udRoundBox(q-vec3(0., -0.05, 0.), vec3(4.0, 0.08, 0.1), 0.05);
d = min(d, udRoundBox(q-vec3(0., -0.05, 0.), vec3(0.1, 0.08, 4.0), 0.05));
res = mix(vec2(d, 24.), res, step(res.x, d));
//Tube
d = sdCappedCylinder(q-vec3(0., -1.5, 0.), vec2(0.65, 1.6));
d = min(d, sdCappedCylinder(q-vec3(0., -5.0, 0.), vec2(1.0, 2.)));
res = mix(vec2(d, 6.), res, step(res.x, d));
return res;
}
vec4 dBloomObjects(vec3 p)
{
vec4 res = vec4(-1, -1, 999., 0.);
//Lamp
vec3 q = p - vec3(0.0, 14.6, 0.0);
q.y *= 1.4;
float d = length(q)-0.8;
res.zw = vec2(d, 1.);
res.xy = vec2(d, 7.);
// FireballBaseStart
q = p - vec3(10.5, 9.5, 27.5);
d = length(vec3(q.x, q.y, q.z))-2.5;
d = max(d, -(q.z+1.5));
float d2 = (length((vec3(q.x, q.y, (q.z+1.5)*0.8)))-1.5); d2 += cos((p.z+0.5)*4.5)*0.1;
d = min(d, d2);
d += mix(0., 1., smoothstep(0.6, 1., cos(q.x*2.)*cos(q.y*2.)*cos(q.z+1.)))*1.0;
res.xy = mix(vec2(d, 12.), res.xy, step(res.x, d));
// FireballBaseEnd
q = p - vec3(-15.9, 9.5, -12.0);
q = rotateY(q, PI*0.5);
d = length(vec3(q.x, q.y, q.z))-2.5;
d = max(d, -(q.z+1.5));
d = max(d, -(length(q-vec3(0., 0., -5.6))-4.5));
d += mix(0., 1., smoothstep(0.5, 1., cos(q.x*2.)*cos(q.y*2.)*cos(q.z+1.)))*1.0;
res.xy = mix(vec2(d, 12.), res.xy, step(res.x, d));
// Redpoint
q = p - vec3(-15.4, 9.5, -12.0);
d = length(q)-0.9;
res.xy = mix(vec2(d, 22.), res.xy, step(res.x, d));
res.zw = mix(vec2(d, 0.),res.zw, step(res.z, d));
// RedPoint
q = p - vec3(14.8, 9.5, -12.0);
d = length(q)-0.01;
res.xy = mix(vec2(d, 22.), res.xy, step(res.x, d));
res.zw = mix(vec2(d, 0.),res.zw, step(res.z, d));
// Fireball
vec3 firePos = vec3(0.);
if(t < 20.) {
float phase = t/4.;
float phasePart = fract(phase);
float phaseSeq = mod(phase, 2.);
firePos = mix( mix(vec3(10., 9.5, 20.5), vec3(10., 9.5, -19.0), phasePart), mix(vec3(10., 9.5, -19.0), vec3(10., 9.5, 20.5), phasePart), step(1.0, phaseSeq));
} else if(t < 22.3) {
firePos = mix(vec3(14.5, 10., 7.5), vec3(-14.5, 10., 7.5), smoothstep(20., 22.3, t));
} else if(t < 24.3) {
firePos = mix(vec3(-14.5, 10., 7.5), vec3(14.5, 10., 7.5), smoothstep(22.3, 24.3, t));
} else {
firePos = mix(vec3(14.5, 9.5, -12.0), vec3(-15.0, 9.5, -12.0), smoothstep(24.3, 27.5, t));
}
q = p - firePos;
d = length(vec3(q.x, q.y, q.z))-0.15;
d += cos(q.x*15.+t*2.)*cos(q.y*12.)*cos(q.z*10.)*0.05;
res.xy = mix(vec2(d, 13.), res.xy, step(res.x, d));
res.zw = mix(vec2(d, 0.),res.zw, step(res.z, d));
return res;
}
vec2 dPortalA(vec3 p)
{
vec3 q = rotateY(p - portalA.pos, portalA.rotateY);
float d = dElipse(q, vec3(1.6, 2.6, 0.05), smoothstep(0., 0.15, t-portalA.time)*0.6);
return vec2(d, 1.);
}
vec2 dPortalB(vec3 p)
{
vec3 q = rotateY(p - portalB.pos, portalB.rotateY);
float d = dElipse(q, vec3(1.6, 2.6, 0.05), smoothstep(0., 0.15, t-portalB.time)*0.6);
return vec2(d, 2.);
}
vec4 map(vec3 p)
{
vec4 res = dBloomObjects(p);
vec2 res2 = dStructure(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dWater(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dPortalA(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dPortalB(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dPlatforms(p);
if(res2.x < res.x) res.xy = res2.xy;
return res;
}
vec4 intersect(vec3 o, vec3 rd, float tmin, float tmax)
{
float k = tmin;
vec4 res = vec4(tmax, -1, 999., 0.);
for(int i=0; i<120; ++i)
{
vec4 r = map(o + rd*k);
res.zw = mix(r.zw, res.zw, step(res.z, r.z));
if(r.x < 0.01)
{
res.x = k;
res.y = r.y;
break;
}
k+=r.x;
if(k > tmax)
{
break;
}
}
return res;
}
vec3 calcnormal(vec3 p)
{
vec2 e = vec2(0.001, 0.);
return normalize(
vec3(map(p+e.xyy).x-map(p-e.xyy).x,
map(p+e.yxy).x-map(p-e.yxy).x,
map(p+e.yyx).x-map(p-e.yyx).x)
);
}
float calcshadow(vec3 o, vec3 rd, float tmin, float tmax)
{
float k = tmin;
float shadow = 1.;
for(int i = 0; i < 20; ++i)
{
vec4 res = map(o + rd*k);
shadow = min(shadow, res.x*1.5);
k+=res.x;
if(k > tmax)
{
break;
}
}
return shadow;
}
vec4 mapPortalColor(vec3 p, vec3 portalPos, float rotY, vec4 cristalcolor, vec4 fxcolor)
{
vec2 q = rotateY(p-portalPos, rotY).xy; q.y *= 0.55;
float d = length(q) - 1.4 + sin(q.x*10.+t*2.)*cos(q.y*10.+t*2.) * 0.05;
return mix(cristalcolor, fxcolor, smoothstep(-0.5, 0.2, d));
}
void calculatePosRayDirFromPortals(in PortalStruct portalO, in PortalStruct portalD, in vec3 p, in vec3 rd, out vec3 refpos, out vec3 refdir)
{
vec3 oRight = cross(vec3(0., 1., 0.), portalO.front);
vec3 oUp = cross(portalO.front, oRight);
vec3 dRight = cross(vec3(0., 1., 0.), portalD.front);
vec3 dUp = cross(portalD.front, dRight);
vec3 projRD=vec3(dot(oRight, rd), dot(oUp, rd), dot(portalO.front, rd));
vec3 localPos = p-portalO.pos;
vec3 projPos = vec3(dot(localPos, oRight), dot(localPos, oUp), dot(localPos, portalO.front));
refdir = normalize(-portalD.front*projRD.z + -dRight*projRD.x + dUp*projRD.y);
refpos = portalD.pos + -dRight*projPos.x + dUp*projPos.y + -portalD.front*projPos.z;
}
vec4 texcube( sampler2D sam, in vec3 p, in vec3 n )
{
vec4 x = texture( sam, p.yz );
vec4 y = texture( sam, p.zx );
vec4 z = texture( sam, p.xy );
return x*abs(n.x) + y*abs(n.y) + z*abs(n.z);
}
vec2 point2plane( in vec3 p, in vec3 n )
{
return p.zy*abs(n.x) + p.xz*abs(n.y) + p.xy*abs(n.z);
}
vec4 mapcolor(inout vec3 p, in vec4 res, inout vec3 normal, in vec3 rd, out vec3 refpos, out vec3 refdir, out vec4 lparams)
{
vec4 color = vec4(0.498, 0.584, 0.619, 1.0); lparams = vec4(1.0, 10., 0., 0.);
refdir = reflect(rd, normal); refpos = p;
if(res.y < 1.1) { // PortalA
color = mapPortalColor(p, portalA.pos, portalA.rotateY, vec4(1., 1., 1., 0.1), vec4(0.0, 0.35, 1.0, 1.));
calculatePosRayDirFromPortals(portalA, portalB, p, rd, refpos, refdir);
}
else if(res.y < 2.1) { // PortalB
color = mapPortalColor(p, portalB.pos, portalB.rotateY, vec4(0.0, 1., 1.0, 0.1), vec4(0.91, 0.46, 0.07, 1.));
calculatePosRayDirFromPortals(portalB, portalA, p, rd, refpos, refdir);
}
else if(res.y < 3.1) { // Water
color = vec4(0.254, 0.239, 0.007, 1.0); lparams.xy = vec2(2.0, 50.);
color.rgb = mix(color.rgb, vec3(0.254, 0.023, 0.007), 1.-smoothstep(0.2, 1., fbm((p.xz+vec2(cos(t+p.x*2.)*0.2, cos(t+p.y*2.)*0.2))*0.5)));
color.rgb = mix(color.rgb, vec3(0.007, 0.254, 0.058), smoothstep(0.5, 1., fbm((p.xz*0.4+vec2(cos(t+p.x*2.)*0.2, cos(t+p.y*2.)*0.2))*0.5)));
}
else if(res.y < 4.1) { // Turbina
color = vec4(0.447, 0.490, 0.513, 1.0);
}
else if(res.y < 5.1) { //Window
color = vec4(0.662, 0.847, 0.898, 0.6); lparams=vec4(3., 5., 0., 0.9);
}
else if(res.y < 6.1) { // Metal tube
color = vec4(0.431, 0.482, 0.650, 0.6); lparams.xy=vec2(2., 5.);
}
else if(res.y < 7.1) {// Plastic
color = vec4(0.8, 0.8, 0.8, 1.); lparams.xy=vec2(0.5, 1.);
}
else if(res.y < 8.1) { //Railing
color = mix(vec4(1.), vec4(1., 1., 1., 0.), smoothstep(0.2, 0.21, fract(p.x)));
color = mix(vec4(1.), color, smoothstep(0.2, 0.21, fract(p.z)));
lparams.xy=vec2(1.0, 1.); refdir = rd;
}
else if(res.y < 9.1) { // Reflectance -> can be plastic
color = vec4(1., 1., 1., 0.1); lparams.xy=vec2(1.0, 10.);
}
else if(res.y < 10.1) { // Exit
vec3 q = p - vec3(1.5, 11.0, -31.);
color = vec4(0.6, 0.6, 0.6, 0.65);
color.rgb = mix(vec3(0.749, 0.898, 0.909), color.rgb, smoothstep(2., 10., length(q.xy)));
color.rgb += mix(vec3(0.1), vec3(0.), smoothstep(2., 5., length(q.xy)));
vec3 q2 = q;
vec2 c = vec2(2., 1.5);
float velsign = mix(-1., 1., step(0.5, fract(q2.y*0.5)));
q2.x = mod(velsign*t+q2.x+cos(q2.y*3.)*0.5, 1.8);
q2.y = mod(q2.y, 1.15);
float d = max(abs(q2.x)-0.9, abs(q2.y)-0.1);
color.rgb += mix(vec3(0.286, 0.941, 0.992)*1.6, vec3(0.), smoothstep(-0.1, 0.1, d));
vec3 localp = p - vec3(1.5, 11.0, -31.);
refpos = vec3(1.5, 11.0, 28.0) + localp;
lparams=vec4(1.0, 10., 0., 0.1); refdir = rd;
}
else if(res.y < 11.1) { // Exit border
vec3 q = p; q.z = abs(q.z); q = q - vec3(0.0, 9.5, 31.);
color = vec4(0.8, 0.8, 0.8, 1.);
float d =length(abs(q.x+cos(q.y*0.5)*0.6 -3.0))-0.06;
d = min(d, length(abs(q.x+cos(PI+q.y*0.5)*0.6 +3.0))-0.06);
color.rgb = mix(vec3(0.286, 0.941, 0.992), color.rgb, smoothstep(0., 0.01, d));
lparams = mix(vec4(0., 0., 0., 1.), lparams, smoothstep(0., 0.2, d));
}
else if(res.y < 12.1) { // Fireball base
vec3 q = p - vec3(10., 9.5, 26.5);
color = vec4(1.0, 1.0, 1.0, 1.);
float d = length(q-vec3(0., 0., -2.5)) - 2.0;
color = mix(vec4(0.976, 0.423, 0.262, 1.), color, smoothstep(-2., 0.01, d));
}
else if(res.y < 13.1) { // Fireball
color = vec4(1., 0.0, 0.0, 1.0);
color.rgb = mix(color.rgb, vec3(0.75, 0.94, 0.28), smoothstep(26.5, 27.0, t));
}
else if(res.y > 19. && res.y < 25.) { // Walls
float rand = fbm(point2plane(p, normal));
vec3 col = vec3(0.498, 0.584, 0.619);
color = vec4(vec3(col), 1.0);
color = mix(color, vec4(col*0.75, 1.0), smoothstep(0.2, 1.0, rand));
color = mix(color, vec4(col*0.80, 1.0), smoothstep(0.4, 1.0, fbm(point2plane(p*1.5, normal))));
color = mix(color, vec4(col*0.7, 1.0), smoothstep(0.6, 1.0, fbm(point2plane(p*4.5, normal))));
vec3 dirtcolor = mix(vec3(0., 0., 0.), vec3(0.403, 0.380, 0.274)*0.2, rand);
float dirtheight = 0.1+rand*1.0;
dirtcolor = mix(dirtcolor, vec3(0.243, 0.223, 0.137), smoothstep(dirtheight, dirtheight + 0.5, p.y));
dirtheight = rand*2.;
color.rgb = mix(dirtcolor, color.rgb, smoothstep(dirtheight, dirtheight+2.0, p.y));
#ifdef TEXTURE
vec4 noise = mix(vec4(0.), texture(iChannel0, point2plane(p*0.037, normal)) * 0.2, smoothstep(0.2, 1., rand));
#else
vec4 noise = vec4(0.0, 0.0, 0.0, 0.0);
#endif
normal = normalize(normal + vec3(noise.x, 0., noise.z));
refdir = normalize(reflect(rd, normal));
if(res.y < 20.1) { // BROWN_WALL_BLOCK
float d = -(p.x-6.1);
d = max(d, p.y-12.6); d = min(d, p.y-6.5);
color *= mix(vec4(1.), vec4(0.227, 0.137, 0.011, 1.0), smoothstep(0.0, 0.1, d));
}
else if(res.y < 21.1) { // WHITE_PLATFORM_BLOCK
color *= vec4(0.529, 0.572, 0.709, 1.0);
vec3 q = p - vec3(11.5, 6.85, 7.0);
float d = abs(q.y)-0.05;
color.rgb = mix(vec3(0.945, 0.631, 0.015), color.rgb, smoothstep(0., 0.01, d));
lparams.w = mix(1., 0., smoothstep(0., 0.2, d));
}
else if(res.y < 22.1) { // TRANSPARENT_PLATFORM_BLOCK
color *= vec4(0.431, 0.482, 0.650, 0.1);
refdir = rd; lparams.xy=vec2(2., 5.);
}
else if(res.y < 23.1) { // CEILING_BLOCK
color *= mix(vec4(0.227, 0.137, 0.011, 1.0), vec4(1.), smoothstep(0., 0.01, p.z+6.));
}
}
return color;
}
void initLights()
{
vec3 col = vec3(0.925, 0.968, 0.972);
ambientcolor = col;
// Center Up
lights[0].pos = vec3(0., 13.0, 0.);
lights[0].color = col*0.25;
// Window
lights[1].pos = vec3(14.0, 15.5, -12.0);
lights[1].color = col*0.25;
lights[2].pos = vec3(14.0, 15.5, -6.0);
lights[2].color = col*0.25;
}
void initPortals()
{
portalsA[0].pos = vec3(-140.5, 10., 23.0); portalsA[0].front = vec3(1., 0., 0.); portalsA[0].rotateY = PI*0.5; portalsA[0].time = 0.;
portalsA[1].pos = vec3(-14.5, 10., 23.0); portalsA[1].front = vec3(1., 0., 0.); portalsA[1].rotateY = PI*0.5; portalsA[1].time = 6.0;
portalsA[2].pos = vec3(-14.5, 10., -2.5); portalsA[2].front = vec3(1., 0., 0.); portalsA[2].rotateY = PI*0.5; portalsA[2].time = 13.5;
portalsA[3].pos = vec3(10.5, 9.6, -20.5); portalsA[3].front = vec3(0., 0., 1.); portalsA[3].rotateY = 0.; portalsA[3].time = 18.;
portalsA[4].pos = vec3(14.5, 9.5, -12.0); portalsA[4].front = vec3(-1., 0., 0.); portalsA[4].rotateY = PI*0.5; portalsA[4].time = 23.5;
portalA = portalsA[0];
portalB.pos = vec3(14.5, 10., 7.5);
portalB.front = vec3(-1., 0., 0.);
portalB.rotateY = -PI*0.5; portalB.time = 0.;
}
void initState()
{
states[0].posStart = vec3(0., 11.0, 26.0); states[0].posEnd = vec3(0., 11.0, 26.0); states[0].duration = 0.; states[0].lerptime = 0.; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[1].posStart = vec3(0., 11.0, 26.0); states[1].posEnd = vec3(0., 11.0, 23.0); states[1].duration = 6.75; states[1].lerptime = 0.5; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[2].posStart = vec3(0., 11.0, 23.0); states[2].posEnd = vec3(-12.6, 11.0, 23.0); states[2].duration = 4.0; states[2].lerptime = 1.0; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
// Go to Portal B
states[3].posStart = vec3(-12.6, 11.0, 23.0); states[3].posEnd = vec3(-14.5, 11., 23.0); states[3].duration = 0.1; states[3].lerptime = 0.1; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[4].posStart = vec3(14.5, 11., 7.5); states[4].posEnd = vec3(13.5, 11., 7.5); states[4].duration = 3.0; states[4].lerptime = 0.5; states[0].isEnterTime = 1.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
// Go to Portal A
states[5].posStart = vec3(13.5, 11., 7.5); states[5].posEnd = vec3(14.5, 11., 7.5); states[5].duration = 0.1; states[5].lerptime = 1.25; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[6].posStart = vec3(-14.5, 11., -2.5); states[6].posEnd = vec3(-11.6, 11., -2.5); states[6].duration = 15.; states[6].lerptime = 1.0; states[0].isEnterTime = 1.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[7].posStart = vec3(-11.6, 11., -2.5); states[7].posEnd = vec3(-11.6, 11., -23.0); states[7].duration = 7.5; states[7].lerptime = 7.0; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[8].posStart = vec3(-11.6, 11., -23.0); states[8].posEnd = vec3(0.5, 11., -23.0); states[8].duration = 3.0; states[8].lerptime = 2.5; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[9].posStart = vec3(0.5, 11., -23.0); states[9].posEnd = vec3(0.5, 11., -28.0); states[9].duration = 10.; states[9].lerptime = 0.5; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
t = mod(t, 40.);
}
void initOrientations()
{
orientations[0].orientation = vec3(0., 0., -1.); orientations[0].lerptime = 0.; orientations[0].duration = 0.;
orientations[1].orientation = vec3(0., 0., -1.); orientations[1].lerptime = 0.0; orientations[1].duration = 1.0;
orientations[2].orientation = normalize(vec3(0.1, 0.25, -0.5)); orientations[2].lerptime = 1.50; orientations[2].duration = 2.0;
orientations[3].orientation = normalize(vec3(1., 0., -1.5)); orientations[3].lerptime = 0.75; orientations[3].duration = 2.0;
orientations[4].orientation = vec3(0., 0., -1.); orientations[4].lerptime = 1.25; orientations[4].duration = 1.25;
orientations[4].orientation = vec3(-1., 0., 0.); orientations[4].lerptime = 1.0; orientations[4].duration = 6.25;
orientations[5].orientation = vec3(0., 0., -1.); orientations[5].lerptime = 0.75; orientations[5].duration = 1.25;
orientations[6].orientation = vec3(-1., 0., -0.4); orientations[6].lerptime = 0.60; orientations[6].duration = 3.25;
orientations[7].orientation = vec3(0., 0., 1.); orientations[7].lerptime = 0.75; orientations[7].duration = 0.75;
orientations[8].orientation = vec3(1., 0., -0.65); orientations[8].lerptime = 0.75; orientations[8].duration = 3.8;
orientations[9].orientation = vec3(0.0, 0., 1.); orientations[9].lerptime = 1.0; orientations[9].duration = 1.5;
orientations[10].orientation = vec3(1.0, 0., -0.2); orientations[10].lerptime = 0.75; orientations[10].duration = 3.2;
orientations[11].orientation = vec3(-0.2, 0., -1.); orientations[11].lerptime = 2.0; orientations[11].duration = 5.0;
orientations[12].orientation = normalize(vec3(0.6, -0.5, -1.)); orientations[12].lerptime = 0.5; orientations[12].duration = 5.0;
orientations[13].orientation = vec3(1., 0., 0.); orientations[13].lerptime = 0.5; orientations[13].duration = 3.5;
orientations[14].orientation = vec3(0., 0., -1.); orientations[14].lerptime = 0.5; orientations[14].duration = 10.0;
orientation = orientations[0].orientation;
}
vec3 modOrientationToPortals(vec3 or, vec3 enterFront, vec3 exitFront)
{
vec3 enterRight = cross(vec3(0., 1., 0.), enterFront);
vec3 enterUp = cross(enterFront, enterRight);
vec3 exitRight = cross(vec3(0., 1., 0.), exitFront);
vec3 exitUp = cross(exitFront, exitRight);
vec3 enterProjection = vec3
(
dot(or, enterRight),
dot(or, enterUp),
dot(or, enterFront)
);
return exitFront*enterProjection.z + exitRight*enterProjection.x + exitUp*enterProjection.y;
}
void updateState()
{
vec3 axisEnterFront = vec3(0., 0., -1.);
vec3 axisExitFront = vec3(0., 0., -1.);
float portalEnterTime = 0.;
float at = 0.;
position = vec3(-5., 11.0, 26.);
for(int i = 4; i >= 0; i--) { // Set current Portal
if(t > portalsA[i].time) {
portalA = portalsA[i];
break;
}
}
for(int i = 1; i < 10; ++i) { // Set Camera position
at += states[i].duration;
portalEnterTime = mix(portalEnterTime, at-states[i].duration, step(0.5, states[i].isEnterTime));
vec3 axisEnterFrontA = -mix(portalA.front, portalB.front, step(0.5, states[i].enterPortal));
axisEnterFront = mix(axisEnterFront, axisEnterFrontA, step(0.5, states[i].isEnterTime));
vec3 axisExitFrontA = mix(portalA.front, portalB.front, step(0.5, states[i].exitPortal));
axisExitFront = mix(axisExitFront, axisExitFrontA, step(0.5, states[i].isEnterTime));
if(t < at) {
position = mix(states[i].posStart, states[i].posEnd, clamp((t - (at-states[i].duration)) / (states[i].lerptime), 0., 1.));
break;
}
}
at = 0.;
for(int i = 1; i < 15; ++i) { // Set Camera orientation
at += orientations[i].duration;
if(t < at) {
vec3 prevOrientation = mix(modOrientationToPortals(orientations[i-1].orientation, axisEnterFront, axisExitFront), orientations[i-1].orientation, step(portalEnterTime, at-orientations[i].duration-orientations[i-1].duration));
vec3 currentOrientation = mix(modOrientationToPortals(orientations[i].orientation, axisEnterFront, axisExitFront), orientations[i].orientation, step(portalEnterTime, at-orientations[i].duration));
orientation = normalize(mix(prevOrientation, currentOrientation, clamp((t - (at-orientations[i].duration)) / (orientations[i].lerptime), 0., 1.)));
break;
}
}
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
t = iGlobalTime;
initState();
initPortals();
initOrientations();
initLights();
updateState();
vec2 uv = fragCoord.xy / iResolution.xy;
vec2 p = (uv * 2. -1.) * vec2(iResolution.x/iResolution.y, 1.);
#ifdef MOUSE
vec2 mo = mix(vec2(0.), iMouse.xy / iResolution.xy, step(0.001, length(iMouse.zw)));
#else
vec2 mo = mix(vec2(0.), 0.0 / iResolution.xy, step(0.001, length(0.0)));
#endif
vec3 right = cross(vec3(0., 1., 0.), orientation);
orientation += right*mo.x + vec3(0., 1., 0)*mo.y;
vec3 ww = normalize(orientation);
vec3 uu = normalize(cross(vec3(0., 1., 0.), ww));
vec3 vv = normalize(cross(ww, uu));
vec3 rd = normalize(p.x*uu*0.7 + p.y*vv + 1.*ww);
float fov = tan(0.46);
rd = normalize(p.x*uu*fov + p.y*vv*fov + 1.*ww);
vec3 color = vec3(0.);
float att = 1.;
for(int i = 0; i < 3; ++i)
{
vec4 res = intersect(position, rd, 0.40, 9999.);
if(res.y > 0.0)
{
vec3 point = position + rd*res.x;
vec3 normal = calcnormal(point);
vec3 refposition;
vec3 refdir;
vec4 lparams;
vec4 colorrgba = mapcolor(point, res, normal, rd, refposition, refdir, lparams);
float latt = 1.-ambient;
vec3 acolor = colorrgba.rgb*ambientcolor*ambient;
for(int lidx = 0; lidx < 3; ++lidx)
{
vec3 ldir = lights[lidx].pos - point;
float ldirLength = length(ldir);
ldir /= ldirLength;
latt *= 1.-clamp((ldirLength-5.)/35., 0., 1.);
vec3 diffuse = colorrgba.rgb;
float diffactor = max(0., pow(dot(ldir, normal), 1.0))*latt;
vec3 reflec = reflect(rd, normal);
float specfactor = pow(max(0., dot(ldir, reflec)), lparams.y) * lparams.x;
float shadow = 1.;
shadow = max(calcshadow(point, ldir, 0.8, ldirLength), 0.01);
acolor += diffuse * diffactor * lights[lidx].color* shadow;
acolor += specfactor * lights[lidx].color* shadow;
color += (acolor*colorrgba.a*att);
}
color = lparams.w*colorrgba.rgb + (1.-lparams.w)*color.rgb;;
vec3 fireballcolor = mix(vec3(0.91, 0.46, 0.07), vec3(0.42, 0.90, 0.00), smoothstep(26.5, 27.0, t));
vec3 bloomcolor = mix(fireballcolor, vec3(1.6, 1.65, 1.65), step(0.5, res.w));
color.rgb = mix(mix(bloomcolor, color.rgb, 0.5), color.rgb, smoothstep(0., 1.0, res.z));
att = max(att*(1.-colorrgba.a), 0.);
if(att < 0.01)
{
break;
}
rd = refdir;
position = refposition;
}
else
{
att = 0.;
break;
}
}
float fadeFactor = mix(0., 1., smoothstep(39., 40., t));
fadeFactor = mix(1., fadeFactor, smoothstep(0., 1., t));
fragColor = mix(vec4(color, 1.), vec4(0.), fadeFactor);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragCoord = vTexCoord.xy*global.OutputSize.xy;
FragCoord.y = -FragCoord.y;
mainImage(FragColor,FragCoord);
}

862
procedural/ciberxtrem-portal.slang Normal file
View File

@ -0,0 +1,862 @@
#version 450
// Portal Gameplay
// ciberxtrem - https://www.shadertoy.com/view/XlsSzM
// Inspired in Portal, Chamber 8.
// Note: Set the APPLY_COLORS and APPLY_SHADOW to 1 to see all colors and shadows
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
// Thanks iq and the Shadertoy comunity for all the shared knowledge! :)
// Set this to 1 to enable colors!
#define APPLY_COLORS 0
#define APPLY_SHADOW 0
//---------------------------
#define PI 3.14159265359
struct LightStruct {
vec3 pos;
vec3 color;
};
struct PortalStruct {
vec3 pos;
vec3 front;
float rotateY;
float time;
};
struct StateStruct
{
vec3 posStart;
vec3 posEnd;
float lerptime;
float duration;
float isEnterTime;
float enterPortal;
float exitPortal;
};
struct OrientationStruct
{
vec3 orientation;
float lerptime;
float duration;
};
PortalStruct portalA;
PortalStruct portalB;
PortalStruct portalsA[8];
StateStruct states[10];
OrientationStruct orientations[15];
LightStruct lights[3];
float t;
vec3 position;
vec3 orientation;
float ambient = 0.05;
vec3 ambientcolor;
vec3 rotateY(vec3 p, float a){
return vec3(
p.x*cos(a) + p.z*sin(a),
p.y,
p.z*cos(a) - p.x*sin(a)
);
}
float hash( float n ) {
return fract(sin(n)*43758.5453123);
}
float noise( in vec2 x ) {
vec2 p = floor(x);
vec2 f = fract(x);
f = f*f*(3.0-2.0*f);
float n = p.x + p.y*157.0;
return mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x),
mix( hash(n+157.0), hash(n+158.0),f.x),f.y);
}
const mat2 m2 = mat2( 0.80, -0.60, 0.60, 0.80 );
float fbm( vec2 p ) {
float f = 0.0;
f += 0.5000*noise( p ); p = m2*p*2.02;
f += 0.2500*noise( p ); p = m2*p*2.03;
f += 0.1250*noise( p ); p = m2*p*2.01;
f += 0.0625*noise( p );
return f/0.9375;
}
float dBox(vec3 p, vec3 hsize)
{
return length(max(abs(p)-hsize,0.0));
}
float udRoundBox( vec3 p, vec3 b, float r )
{
return length(max(abs(p)-b,0.0))-r;
}
float sdCappedCylinder( vec3 p, vec2 h )
{
vec2 d = abs(vec2(length(p.xz),p.y)) - h;
return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
//-------------------------------
// Scene
float dElipse(vec3 p, vec3 hsize, float globalSize)
{
float d = length(max(abs(p)-hsize,0.0));
vec3 q = p;
q.y *= 0.6;
return max(d, length(q)-max(max(hsize.x, hsize.y)*globalSize, hsize.z));
}
vec2 dStructure(vec3 p)
{
// Front
vec2 res = vec2(-1., -1.);
vec3 q = p - vec3(0., 0.5, 28.25);
vec2 c = vec2(3., 6.2);
vec3 q2 = q; q2.xy = mod(q2.xy,c.xy)-0.5*c.xy;
float d = udRoundBox(q2, vec3(1.35, 3., 1.0), 0.25);
q = p - vec3(0.0, 9.5, 28.); // Hole for exit
float d2 = udRoundBox(q, vec3(3.0, 3.25, 2.0), 0.1);
d = max(d,-d2);
res = vec2(d, 24.);
//Back
q = p - vec3(0., 3.5, -28.0);
c = vec2(3., 6.2);
q.x = mod(q.x,c.x)-0.5*c.x;
d = udRoundBox(q, vec3(1.35, 3., 1.0), 0.25);
res = mix(vec2(d, 24.), res, step(res.x, d));
q = p - vec3(0., 0.6, -28.01); // Brown block
c = vec2(3., 3.0);
q.xy = mod(q.xy,c.xy)-0.5*c.xy;
d = udRoundBox(q, vec3(1.35, 1.35, 1.0), 0.25);
q = p - vec3(0.0, 9.5, -28.); // Hole for exit
d2 = udRoundBox(q, vec3(3.0, 3.25, 2.0), 0.1);
d = max(d,-d2);
res = mix(vec2(d, 20.), res, step(res.x, d));
//Exit
vec3 p2 = p; p2.z = abs(p.z);
q = p2 - vec3(0.0, 9.5, 30.5);
d = udRoundBox(q, vec3(3.0, 3.25, 0.1), 0.1);
if(d<res.x){res = vec2(d, 10.);} // magic panel
q2 = q - vec3(4.5, 0., -1.); q2.x += abs(sin(length(1.5+abs(q2.y)*0.36)));
d = udRoundBox(q2, vec3(1.5, 4.5, 2.0), 0.1);
q2 = q - vec3(-4.5, 0., -1.); q2.x -= abs(sin(length(1.5+abs(q2.y)*0.36)));
d2 = udRoundBox(q2, vec3(1.5, 4.5, 2.0), 0.1);
d = min(d, d2);
res = mix(vec2(d, 11.), res, step(res.x, d));
//Left
q = p - vec3(-16., 0.5, 0.0);
c = vec2(3.0, 6.2);
q2 = q; q2.zy = mod(q2.zy,c)-0.5*c;
d = udRoundBox(q2, vec3(1., 3., 1.35), 0.25);
res = mix(vec2(d, 24.), res, step(res.x, d));
//Right
q = p - vec3(16.0, 0.5, 0.0);
c = vec2(3.0, 6.2);
q.zy = mod(q.zy,c)-0.5*c;
d = udRoundBox(q, vec3(1., 3., 1.35), 0.25);
// Hole for window
q = p - vec3(15.0, 15.5, -9.0);
d2 = udRoundBox(q, vec3(2.0, 3., 6.0), 0.02);
d = max(d, -d2);
res = mix(vec2(d, 24.), res, step(res.x, d));
// Column
q = p - vec3(0., 0.6, -23.90);
c = vec2(3., 3.0);
q.xy = mod(q.xy,c)-0.5*c;
d = udRoundBox(q, vec3(1.35, 1.35, 2.70), 0.25);
d = max(d, -(p.x-6.1));
res = mix(vec2(d, 24.), res, step(res.x, d));
// Ceiling
q = p - vec3(0., 20.4, .0);
c = vec2(3.0, 3.0);
q2 = q; q2.xz = mod(q2.xz,c)-0.5*c;
d = udRoundBox(q2, vec3(1.35, 1., 1.35), 0.25);
d2 = length(q)-6.;
d = max(d, -d2);
res = mix(vec2(d, 23.), res, step(res.x, d));
//Window
q = p - vec3(16.0, 15.5, -9.0);
d = udRoundBox(q, vec3(1.25, 3., 6.0), 0.02); // framework
d2 = udRoundBox(q, vec3(1.5, 2.6, 5.6), 0.02);
d = max(d, -d2);
d = min(d, udRoundBox(q, vec3(1.2, 3., 0.2), 0.02)); // bars
res = mix(vec2(d, 7.), res, step(res.x, d));
d = udRoundBox(q, vec3(1.0, 2.6, 5.6), 0.1);
d -= smoothstep(-1., 1., cos(p.y*15.)) * 0.0025;
res = mix(vec2(d, 5.), res, step(res.x, d));
// Dome
q = p-vec3(0., 21.5, 0.);
q.y *= 1.0;
d = length(q) - 6.;
res = mix(vec2(d, 9.), res, step(res.x, d));
//Turbina
q = p - vec3(0.0, 15.0, 0.0);
q = rotateY(q, t);
d = dBox(q, vec3(5.5, 0.05, 0.4));
d2 = dBox(q, vec3(0.4, 0.05, 5.5));
d = min(d, d2);
d2 = sdCappedCylinder(q-vec3(0., 0.5, 0.), vec2(0.4, 0.5));
d = min(d, d2);
res = mix(vec2(d, 4.), res, step(res.x, d));
// Front railing
q = p - vec3(-5.5, 6.5, 23.2);
d = dBox(q, vec3(9.0, 0.1, 4.0));
res = mix(vec2(d, 8.), res, step(res.x, d));
d = udRoundBox(q-vec3(0., 1.6, -4.0), vec3(9.0, 1.7, 0.05), 0.02);
d2 = udRoundBox(q-vec3(0., 1.6, -4.0), vec3(8.8, 1.5, 0.5), 0.02);
d = max(d, -d2);
d = min(d, udRoundBox(q-vec3(8.9, 3.2, 0.0), vec3(0.10, 0.10, 4.0), 0.01));
res = mix(vec2(d, 7.), res, step(res.x, d));
// Back railing
q = p - vec3(-0.5, 6.5, -24.2);
d = dBox(q, vec3(6.0, 0.1, 3.0));
res = mix(vec2(d, 8.), res, step(res.x, d));
d = udRoundBox(q-vec3(0.5, 1.6, 3.2), vec3(6.0, 1.7, 0.1), 0.02);
d2 = udRoundBox(q-vec3(0.5, 1.6, 3.2), vec3(5.8, 1.5, 1.0), 0.02);
d = max(d, -d2);
res = mix(vec2(d, 7.), res, step(res.x, d));
return res;
}
vec2 dWater(vec3 p)
{
vec3 q = p - vec3(0., -0., .0);
float d = dBox(q, vec3(20., 0.2, 40.));
d-=smoothstep(-1., 1., cos(p.x*2.1+t*2.)*cos(p.z*3.5+t*1.6))*0.01;
float d2 = smoothstep(-1., 1., cos(length(p.xz)*2.-t))*0.05;
d2 = mix(0., d2, smoothstep(1.0, 10., length(q.xz)));
d -= d2;
return vec2(d, 3.);
}
vec2 dPlatforms(vec3 p)
{
// Front Right Platform
vec2 res = vec2(-1, -1.);
vec3 q = p - vec3(11.5, 7., 7.0);
vec2 c = vec2(3.0);
vec3 q2 = q; q2.xz = mod(q2.xz+vec2(0., 1.0),c)-0.5*c;
float d = udRoundBox(q2, vec3(1.415, 0.2, 1.415), 0.1);
d = max(d, q.z-5.); d = max(d, -(q.z+4.)); d = max(d, -(q.x+6.));
res = vec2(d, 21.);
//Tube
d = sdCappedCylinder(q-vec3(0., -4., 0.), vec2(0.65, 3.));
d = min(d, sdCappedCylinder(q-vec3(0., -7.5, 0.), vec2(1.0, 2.)));
res = mix(vec2(d, 6.), res, step(res.x, d));
// Front Left Platform
vec3 leftPlatPos = vec3(-10.0, 7., -2.0);
if(t > 29.0){
float phase = (t-29.)/7.;
float seq = mod(phase, 2.);
leftPlatPos =mix(vec3(-10, 7., -2.), vec3(-11.6, 7., -23.0), fract(phase));
}
q = p - leftPlatPos;
d = udRoundBox(q, vec3(3.8, 0.02, 3.8), 0.01);
res = mix(vec2(d, 22.), res, step(res.x, d));
// Border
d = udRoundBox(q, vec3(4.0, 0.05, 4.0), 0.1);
float d2 = udRoundBox(q, vec3(3.5, 0.1, 3.5), 0.1);
d = max(d, -d2);
res = mix(vec2(d, 24.), res, step(res.x, d));
// Crosses
d = udRoundBox(q-vec3(0., -0.05, 0.), vec3(4.0, 0.08, 0.1), 0.05);
d = min(d, udRoundBox(q-vec3(0., -0.05, 0.), vec3(0.1, 0.08, 4.0), 0.05));
res = mix(vec2(d, 24.), res, step(res.x, d));
//Tube
d = sdCappedCylinder(q-vec3(0., -1.5, 0.), vec2(0.65, 1.6));
d = min(d, sdCappedCylinder(q-vec3(0., -5.0, 0.), vec2(1.0, 2.)));
res = mix(vec2(d, 6.), res, step(res.x, d));
return res;
}
vec4 dBloomObjects(vec3 p)
{
vec4 res = vec4(-1, -1, 999., 0.);
//Lamp
vec3 q = p - vec3(0.0, 14.6, 0.0);
q.y *= 1.4;
float d = length(q)-0.8;
res.zw = vec2(d, 1.);
res.xy = vec2(d, 7.);
// FireballBaseStart
q = p - vec3(10.5, 9.5, 27.5);
d = length(vec3(q.x, q.y, q.z))-2.5;
d = max(d, -(q.z+1.5));
float d2 = (length((vec3(q.x, q.y, (q.z+1.5)*0.8)))-1.5); d2 += cos((p.z+0.5)*4.5)*0.1;
d = min(d, d2);
d += mix(0., 1., smoothstep(0.6, 1., cos(q.x*2.)*cos(q.y*2.)*cos(q.z+1.)))*1.0;
res.xy = mix(vec2(d, 12.), res.xy, step(res.x, d));
// FireballBaseEnd
q = p - vec3(-15.9, 9.5, -12.0);
q = rotateY(q, PI*0.5);
d = length(vec3(q.x, q.y, q.z))-2.5;
d = max(d, -(q.z+1.5));
d = max(d, -(length(q-vec3(0., 0., -5.6))-4.5));
d += mix(0., 1., smoothstep(0.5, 1., cos(q.x*2.)*cos(q.y*2.)*cos(q.z+1.)))*1.0;
res.xy = mix(vec2(d, 12.), res.xy, step(res.x, d));
// Redpoint
q = p - vec3(-15.4, 9.5, -12.0);
d = length(q)-0.9;
res.xy = mix(vec2(d, 22.), res.xy, step(res.x, d));
res.zw = mix(vec2(d, 0.),res.zw, step(res.z, d));
// RedPoint
q = p - vec3(14.8, 9.5, -12.0);
d = length(q)-0.01;
res.xy = mix(vec2(d, 22.), res.xy, step(res.x, d));
res.zw = mix(vec2(d, 0.),res.zw, step(res.z, d));
// Fireball
vec3 firePos = vec3(0.);
if(t < 20.) {
float phase = t/4.;
float phasePart = fract(phase);
float phaseSeq = mod(phase, 2.);
firePos = mix( mix(vec3(10., 9.5, 20.5), vec3(10., 9.5, -19.0), phasePart), mix(vec3(10., 9.5, -19.0), vec3(10., 9.5, 20.5), phasePart), step(1.0, phaseSeq));
} else if(t < 22.3) {
firePos = mix(vec3(14.5, 10., 7.5), vec3(-14.5, 10., 7.5), smoothstep(20., 22.3, t));
} else if(t < 24.3) {
firePos = mix(vec3(-14.5, 10., 7.5), vec3(14.5, 10., 7.5), smoothstep(22.3, 24.3, t));
} else {
firePos = mix(vec3(14.5, 9.5, -12.0), vec3(-15.0, 9.5, -12.0), smoothstep(24.3, 27.5, t));
}
q = p - firePos;
d = length(vec3(q.x, q.y, q.z))-0.15;
d += cos(q.x*15.+t*2.)*cos(q.y*12.)*cos(q.z*10.)*0.05;
res.xy = mix(vec2(d, 13.), res.xy, step(res.x, d));
res.zw = mix(vec2(d, 0.),res.zw, step(res.z, d));
return res;
}
vec2 dPortalA(vec3 p)
{
vec3 q = rotateY(p - portalA.pos, portalA.rotateY);
float d = dElipse(q, vec3(1.6, 2.6, 0.05), smoothstep(0., 0.15, t-portalA.time)*0.6);
return vec2(d, 1.);
}
vec2 dPortalB(vec3 p)
{
vec3 q = rotateY(p - portalB.pos, portalB.rotateY);
float d = dElipse(q, vec3(1.6, 2.6, 0.05), smoothstep(0., 0.15, t-portalB.time)*0.6);
return vec2(d, 2.);
}
vec4 map(vec3 p)
{
vec4 res = dBloomObjects(p);
vec2 res2 = dStructure(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dWater(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dPortalA(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dPortalB(p);
if(res2.x < res.x) res.xy = res2.xy;
res2 = dPlatforms(p);
if(res2.x < res.x) res.xy = res2.xy;
return res;
}
vec4 intersect(vec3 o, vec3 rd, float tmin, float tmax)
{
float k = tmin;
vec4 res = vec4(tmax, -1, 999., 0.);
for(int i=0; i<120; ++i)
{
vec4 r = map(o + rd*k);
res.zw = mix(r.zw, res.zw, step(res.z, r.z));
if(r.x < 0.01)
{
res.x = k;
res.y = r.y;
break;
}
k+=r.x;
if(k > tmax)
{
break;
}
}
return res;
}
vec3 calcnormal(vec3 p)
{
vec2 e = vec2(0.001, 0.);
return normalize(
vec3(map(p+e.xyy).x-map(p-e.xyy).x,
map(p+e.yxy).x-map(p-e.yxy).x,
map(p+e.yyx).x-map(p-e.yyx).x)
);
}
#if APPLY_SHADOW == 1
float calcshadow(vec3 o, vec3 rd, float tmin, float tmax)
{
float k = tmin;
float shadow = 1.;
for(int i = 0; i < 20; ++i)
{
vec4 res = map(o + rd*k);
shadow = min(shadow, res.x*1.5);
k+=res.x;
if(k > tmax)
{
break;
}
}
return shadow;
}
#endif
vec4 mapPortalColor(vec3 p, vec3 portalPos, float rotY, vec4 cristalcolor, vec4 fxcolor)
{
vec2 q = rotateY(p-portalPos, rotY).xy; q.y *= 0.55;
float d = length(q) - 1.4 + sin(q.x*10.+t*2.)*cos(q.y*10.+t*2.) * 0.05;
return mix(cristalcolor, fxcolor, smoothstep(-0.5, 0.2, d));
}
void calculatePosRayDirFromPortals(in PortalStruct portalO, in PortalStruct portalD, in vec3 p, in vec3 rd, out vec3 refpos, out vec3 refdir)
{
vec3 oRight = cross(vec3(0., 1., 0.), portalO.front);
vec3 oUp = cross(portalO.front, oRight);
vec3 dRight = cross(vec3(0., 1., 0.), portalD.front);
vec3 dUp = cross(portalD.front, dRight);
vec3 projRD=vec3(dot(oRight, rd), dot(oUp, rd), dot(portalO.front, rd));
vec3 localPos = p-portalO.pos;
vec3 projPos = vec3(dot(localPos, oRight), dot(localPos, oUp), dot(localPos, portalO.front));
refdir = normalize(-portalD.front*projRD.z + -dRight*projRD.x + dUp*projRD.y);
refpos = portalD.pos + -dRight*projPos.x + dUp*projPos.y + -portalD.front*projPos.z;
}
vec4 texcube( sampler2D sam, in vec3 p, in vec3 n )
{
vec4 x = texture( sam, p.yz );
vec4 y = texture( sam, p.zx );
vec4 z = texture( sam, p.xy );
return x*abs(n.x) + y*abs(n.y) + z*abs(n.z);
}
vec2 point2plane( in vec3 p, in vec3 n )
{
return p.zy*abs(n.x) + p.xz*abs(n.y) + p.xy*abs(n.z);
}
vec4 mapcolor(inout vec3 p, in vec4 res, inout vec3 normal, in vec3 rd, out vec3 refpos, out vec3 refdir, out vec4 lparams)
{
vec4 color = vec4(0.498, 0.584, 0.619, 1.0); lparams = vec4(1.0, 10., 0., 0.);
refdir = reflect(rd, normal); refpos = p;
if(res.y < 1.1) { // PortalA
color = mapPortalColor(p, portalA.pos, portalA.rotateY, vec4(1., 1., 1., 0.1), vec4(0.0, 0.35, 1.0, 1.));
calculatePosRayDirFromPortals(portalA, portalB, p, rd, refpos, refdir);
}
else if(res.y < 2.1) { // PortalB
color = mapPortalColor(p, portalB.pos, portalB.rotateY, vec4(0.0, 1., 1.0, 0.1), vec4(0.91, 0.46, 0.07, 1.));
calculatePosRayDirFromPortals(portalB, portalA, p, rd, refpos, refdir);
}
#if APPLY_COLORS == 1
else if(res.y < 3.1) { // Water
color = vec4(0.254, 0.239, 0.007, 1.0); lparams.xy = vec2(2.0, 50.);
color.rgb = mix(color.rgb, vec3(0.254, 0.023, 0.007), 1.-smoothstep(0.2, 1., fbm((p.xz+vec2(cos(t+p.x*2.)*0.2, cos(t+p.y*2.)*0.2))*0.5)));
color.rgb = mix(color.rgb, vec3(0.007, 0.254, 0.058), smoothstep(0.5, 1., fbm((p.xz*0.4+vec2(cos(t+p.x*2.)*0.2, cos(t+p.y*2.)*0.2))*0.5)));
}
else if(res.y < 4.1) { // Turbina
color = vec4(0.447, 0.490, 0.513, 1.0);
}
else if(res.y < 5.1) { //Window
color = vec4(0.662, 0.847, 0.898, 0.6); lparams=vec4(3., 5., 0., 0.9);
}
else if(res.y < 6.1) { // Metal tube
color = vec4(0.431, 0.482, 0.650, 0.6); lparams.xy=vec2(2., 5.);
}
else if(res.y < 7.1) {// Plastic
color = vec4(0.8, 0.8, 0.8, 1.); lparams.xy=vec2(0.5, 1.);
}
else if(res.y < 8.1) { //Railing
color = mix(vec4(1.), vec4(1., 1., 1., 0.), smoothstep(0.2, 0.21, fract(p.x)));
color = mix(vec4(1.), color, smoothstep(0.2, 0.21, fract(p.z)));
lparams.xy=vec2(1.0, 1.); refdir = rd;
}
else if(res.y < 9.1) { // Reflectance -> can be plastic
color = vec4(1., 1., 1., 0.1); lparams.xy=vec2(1.0, 10.);
}
else if(res.y < 10.1) { // Exit
vec3 q = p - vec3(1.5, 11.0, -31.);
color = vec4(0.6, 0.6, 0.6, 0.65);
color.rgb = mix(vec3(0.749, 0.898, 0.909), color.rgb, smoothstep(2., 10., length(q.xy)));
color.rgb += mix(vec3(0.1), vec3(0.), smoothstep(2., 5., length(q.xy)));
vec3 q2 = q;
vec2 c = vec2(2., 1.5);
float velsign = mix(-1., 1., step(0.5, fract(q2.y*0.5)));
q2.x = mod(velsign*t+q2.x+cos(q2.y*3.)*0.5, 1.8);
q2.y = mod(q2.y, 1.15);
float d = max(abs(q2.x)-0.9, abs(q2.y)-0.1);
color.rgb += mix(vec3(0.286, 0.941, 0.992)*1.6, vec3(0.), smoothstep(-0.1, 0.1, d));
vec3 localp = p - vec3(1.5, 11.0, -31.);
refpos = vec3(1.5, 11.0, 28.0) + localp;
lparams=vec4(1.0, 10., 0., 0.1); refdir = rd;
}
else if(res.y < 11.1) { // Exit border
vec3 q = p; q.z = abs(q.z); q = q - vec3(0.0, 9.5, 31.);
color = vec4(0.8, 0.8, 0.8, 1.);
float d =length(abs(q.x+cos(q.y*0.5)*0.6 -3.0))-0.06;
d = min(d, length(abs(q.x+cos(PI+q.y*0.5)*0.6 +3.0))-0.06);
color.rgb = mix(vec3(0.286, 0.941, 0.992), color.rgb, smoothstep(0., 0.01, d));
lparams = mix(vec4(0., 0., 0., 1.), lparams, smoothstep(0., 0.2, d));
}
else if(res.y < 12.1) { // Fireball base
vec3 q = p - vec3(10., 9.5, 26.5);
color = vec4(1.0, 1.0, 1.0, 1.);
float d = length(q-vec3(0., 0., -2.5)) - 2.0;
color = mix(vec4(0.976, 0.423, 0.262, 1.), color, smoothstep(-2., 0.01, d));
}
else if(res.y < 13.1) { // Fireball
color = vec4(1., 0.0, 0.0, 1.0);
color.rgb = mix(color.rgb, vec3(0.75, 0.94, 0.28), smoothstep(26.5, 27.0, t));
}
else if(res.y > 19. && res.y < 25.) { // Walls
float rand = fbm(point2plane(p, normal));
vec3 col = vec3(0.498, 0.584, 0.619);
color = vec4(vec3(col), 1.0);
color = mix(color, vec4(col*0.75, 1.0), smoothstep(0.2, 1.0, rand));
color = mix(color, vec4(col*0.80, 1.0), smoothstep(0.4, 1.0, fbm(point2plane(p*1.5, normal))));
color = mix(color, vec4(col*0.7, 1.0), smoothstep(0.6, 1.0, fbm(point2plane(p*4.5, normal))));
vec3 dirtcolor = mix(vec3(0., 0., 0.), vec3(0.403, 0.380, 0.274)*0.2, rand);
float dirtheight = 0.1+rand*1.0;
dirtcolor = mix(dirtcolor, vec3(0.243, 0.223, 0.137), smoothstep(dirtheight, dirtheight + 0.5, p.y));
dirtheight = rand*2.;
color.rgb = mix(dirtcolor, color.rgb, smoothstep(dirtheight, dirtheight+2.0, p.y));
#ifdef TEXTURE
vec4 noise = mix(vec4(0.), texture(iChannel0, point2plane(p*0.037, normal)) * 0.2, smoothstep(0.2, 1., rand));
#else
vec4 noise = vec4(0.0, 0.0, 0.0, 0.0);
#endif
normal = normalize(normal + vec3(noise.x, 0., noise.z));
refdir = normalize(reflect(rd, normal));
if(res.y < 20.1) { // BROWN_WALL_BLOCK
float d = -(p.x-6.1);
d = max(d, p.y-12.6); d = min(d, p.y-6.5);
color *= mix(vec4(1.), vec4(0.227, 0.137, 0.011, 1.0), smoothstep(0.0, 0.1, d));
}
else if(res.y < 21.1) { // WHITE_PLATFORM_BLOCK
color *= vec4(0.529, 0.572, 0.709, 1.0);
vec3 q = p - vec3(11.5, 6.85, 7.0);
float d = abs(q.y)-0.05;
color.rgb = mix(vec3(0.945, 0.631, 0.015), color.rgb, smoothstep(0., 0.01, d));
lparams.w = mix(1., 0., smoothstep(0., 0.2, d));
}
else if(res.y < 22.1) { // TRANSPARENT_PLATFORM_BLOCK
color *= vec4(0.431, 0.482, 0.650, 0.1);
refdir = rd; lparams.xy=vec2(2., 5.);
}
else if(res.y < 23.1) { // CEILING_BLOCK
color *= mix(vec4(0.227, 0.137, 0.011, 1.0), vec4(1.), smoothstep(0., 0.01, p.z+6.));
}
}
#endif
return color;
}
void initLights()
{
vec3 col = vec3(0.925, 0.968, 0.972);
ambientcolor = col;
// Center Up
lights[0].pos = vec3(0., 13.0, 0.);
lights[0].color = col*0.25;
// Window
lights[1].pos = vec3(14.0, 15.5, -12.0);
lights[1].color = col*0.25;
lights[2].pos = vec3(14.0, 15.5, -6.0);
lights[2].color = col*0.25;
}
void initPortals()
{
portalsA[0].pos = vec3(-140.5, 10., 23.0); portalsA[0].front = vec3(1., 0., 0.); portalsA[0].rotateY = PI*0.5; portalsA[0].time = 0.;
portalsA[1].pos = vec3(-14.5, 10., 23.0); portalsA[1].front = vec3(1., 0., 0.); portalsA[1].rotateY = PI*0.5; portalsA[1].time = 6.0;
portalsA[2].pos = vec3(-14.5, 10., -2.5); portalsA[2].front = vec3(1., 0., 0.); portalsA[2].rotateY = PI*0.5; portalsA[2].time = 13.5;
portalsA[3].pos = vec3(10.5, 9.6, -20.5); portalsA[3].front = vec3(0., 0., 1.); portalsA[3].rotateY = 0.; portalsA[3].time = 18.;
portalsA[4].pos = vec3(14.5, 9.5, -12.0); portalsA[4].front = vec3(-1., 0., 0.); portalsA[4].rotateY = PI*0.5; portalsA[4].time = 23.5;
portalA = portalsA[0];
portalB.pos = vec3(14.5, 10., 7.5);
portalB.front = vec3(-1., 0., 0.);
portalB.rotateY = -PI*0.5; portalB.time = 0.;
}
void initState()
{
states[0].posStart = vec3(0., 11.0, 26.0); states[0].posEnd = vec3(0., 11.0, 26.0); states[0].duration = 0.; states[0].lerptime = 0.; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[1].posStart = vec3(0., 11.0, 26.0); states[1].posEnd = vec3(0., 11.0, 23.0); states[1].duration = 6.75; states[1].lerptime = 0.5; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[2].posStart = vec3(0., 11.0, 23.0); states[2].posEnd = vec3(-12.6, 11.0, 23.0); states[2].duration = 4.0; states[2].lerptime = 1.0; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
// Go to Portal B
states[3].posStart = vec3(-12.6, 11.0, 23.0); states[3].posEnd = vec3(-14.5, 11., 23.0); states[3].duration = 0.1; states[3].lerptime = 0.1; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[4].posStart = vec3(14.5, 11., 7.5); states[4].posEnd = vec3(13.5, 11., 7.5); states[4].duration = 3.0; states[4].lerptime = 0.5; states[0].isEnterTime = 1.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
// Go to Portal A
states[5].posStart = vec3(13.5, 11., 7.5); states[5].posEnd = vec3(14.5, 11., 7.5); states[5].duration = 0.1; states[5].lerptime = 1.25; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[6].posStart = vec3(-14.5, 11., -2.5); states[6].posEnd = vec3(-11.6, 11., -2.5); states[6].duration = 15.; states[6].lerptime = 1.0; states[0].isEnterTime = 1.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[7].posStart = vec3(-11.6, 11., -2.5); states[7].posEnd = vec3(-11.6, 11., -23.0); states[7].duration = 7.5; states[7].lerptime = 7.0; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[8].posStart = vec3(-11.6, 11., -23.0); states[8].posEnd = vec3(0.5, 11., -23.0); states[8].duration = 3.0; states[8].lerptime = 2.5; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
states[9].posStart = vec3(0.5, 11., -23.0); states[9].posEnd = vec3(0.5, 11., -28.0); states[9].duration = 10.; states[9].lerptime = 0.5; states[0].isEnterTime = 0.; states[0].enterPortal = 0.; states[0].exitPortal = 1.;
t = mod(t, 40.);
}
void initOrientations()
{
orientations[0].orientation = vec3(0., 0., -1.); orientations[0].lerptime = 0.; orientations[0].duration = 0.;
orientations[1].orientation = vec3(0., 0., -1.); orientations[1].lerptime = 0.0; orientations[1].duration = 1.0;
orientations[2].orientation = normalize(vec3(0.1, 0.25, -0.5)); orientations[2].lerptime = 1.50; orientations[2].duration = 2.0;
orientations[3].orientation = normalize(vec3(1., 0., -1.5)); orientations[3].lerptime = 0.75; orientations[3].duration = 2.0;
orientations[4].orientation = vec3(0., 0., -1.); orientations[4].lerptime = 1.25; orientations[4].duration = 1.25;
orientations[4].orientation = vec3(-1., 0., 0.); orientations[4].lerptime = 1.0; orientations[4].duration = 6.25;
orientations[5].orientation = vec3(0., 0., -1.); orientations[5].lerptime = 0.75; orientations[5].duration = 1.25;
orientations[6].orientation = vec3(-1., 0., -0.4); orientations[6].lerptime = 0.60; orientations[6].duration = 3.25;
orientations[7].orientation = vec3(0., 0., 1.); orientations[7].lerptime = 0.75; orientations[7].duration = 0.75;
orientations[8].orientation = vec3(1., 0., -0.65); orientations[8].lerptime = 0.75; orientations[8].duration = 3.8;
orientations[9].orientation = vec3(0.0, 0., 1.); orientations[9].lerptime = 1.0; orientations[9].duration = 1.5;
orientations[10].orientation = vec3(1.0, 0., -0.2); orientations[10].lerptime = 0.75; orientations[10].duration = 3.2;
orientations[11].orientation = vec3(-0.2, 0., -1.); orientations[11].lerptime = 2.0; orientations[11].duration = 5.0;
orientations[12].orientation = normalize(vec3(0.6, -0.5, -1.)); orientations[12].lerptime = 0.5; orientations[12].duration = 5.0;
orientations[13].orientation = vec3(1., 0., 0.); orientations[13].lerptime = 0.5; orientations[13].duration = 3.5;
orientations[14].orientation = vec3(0., 0., -1.); orientations[14].lerptime = 0.5; orientations[14].duration = 10.0;
orientation = orientations[0].orientation;
}
vec3 modOrientationToPortals(vec3 or, vec3 enterFront, vec3 exitFront)
{
vec3 enterRight = cross(vec3(0., 1., 0.), enterFront);
vec3 enterUp = cross(enterFront, enterRight);
vec3 exitRight = cross(vec3(0., 1., 0.), exitFront);
vec3 exitUp = cross(exitFront, exitRight);
vec3 enterProjection = vec3
(
dot(or, enterRight),
dot(or, enterUp),
dot(or, enterFront)
);
return exitFront*enterProjection.z + exitRight*enterProjection.x + exitUp*enterProjection.y;
}
void updateState()
{
vec3 axisEnterFront = vec3(0., 0., -1.);
vec3 axisExitFront = vec3(0., 0., -1.);
float portalEnterTime = 0.;
float at = 0.;
position = vec3(-5., 11.0, 26.);
for(int i = 4; i >= 0; i--) { // Set current Portal
if(t > portalsA[i].time) {
portalA = portalsA[i];
break;
}
}
for(int i = 1; i < 10; ++i) { // Set Camera position
at += states[i].duration;
portalEnterTime = mix(portalEnterTime, at-states[i].duration, step(0.5, states[i].isEnterTime));
vec3 axisEnterFrontA = -mix(portalA.front, portalB.front, step(0.5, states[i].enterPortal));
axisEnterFront = mix(axisEnterFront, axisEnterFrontA, step(0.5, states[i].isEnterTime));
vec3 axisExitFrontA = mix(portalA.front, portalB.front, step(0.5, states[i].exitPortal));
axisExitFront = mix(axisExitFront, axisExitFrontA, step(0.5, states[i].isEnterTime));
if(t < at) {
position = mix(states[i].posStart, states[i].posEnd, clamp((t - (at-states[i].duration)) / (states[i].lerptime), 0., 1.));
break;
}
}
at = 0.;
for(int i = 1; i < 15; ++i) { // Set Camera orientation
at += orientations[i].duration;
if(t < at) {
vec3 prevOrientation = mix(modOrientationToPortals(orientations[i-1].orientation, axisEnterFront, axisExitFront), orientations[i-1].orientation, step(portalEnterTime, at-orientations[i].duration-orientations[i-1].duration));
vec3 currentOrientation = mix(modOrientationToPortals(orientations[i].orientation, axisEnterFront, axisExitFront), orientations[i].orientation, step(portalEnterTime, at-orientations[i].duration));
orientation = normalize(mix(prevOrientation, currentOrientation, clamp((t - (at-orientations[i].duration)) / (orientations[i].lerptime), 0., 1.)));
break;
}
}
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
t = iGlobalTime;
initState();
initPortals();
initOrientations();
initLights();
updateState();
vec2 uv = fragCoord.xy / iResolution.xy;
vec2 p = (uv * 2. -1.) * vec2(iResolution.x/iResolution.y, 1.);
#ifdef MOUSE
vec2 mo = mix(vec2(0.), iMouse.xy / iResolution.xy, step(0.001, length(iMouse.zw)));
#else
vec2 mo = mix(vec2(0.), 0.0 / iResolution.xy, step(0.001, length(0.0)));
#endif
vec3 right = cross(vec3(0., 1., 0.), orientation);
orientation += right*mo.x + vec3(0., 1., 0)*mo.y;
vec3 ww = normalize(orientation);
vec3 uu = normalize(cross(vec3(0., 1., 0.), ww));
vec3 vv = normalize(cross(ww, uu));
vec3 rd = normalize(p.x*uu*0.7 + p.y*vv + 1.*ww);
float fov = tan(0.46);
rd = normalize(p.x*uu*fov + p.y*vv*fov + 1.*ww);
vec3 color = vec3(0.);
float att = 1.;
for(int i = 0; i < 3; ++i)
{
vec4 res = intersect(position, rd, 0.40, 9999.);
if(res.y > 0.0)
{
vec3 point = position + rd*res.x;
vec3 normal = calcnormal(point);
vec3 refposition;
vec3 refdir;
vec4 lparams;
vec4 colorrgba = mapcolor(point, res, normal, rd, refposition, refdir, lparams);
float latt = 1.-ambient;
vec3 acolor = colorrgba.rgb*ambientcolor*ambient;
for(int lidx = 0; lidx < 3; ++lidx)
{
vec3 ldir = lights[lidx].pos - point;
float ldirLength = length(ldir);
ldir /= ldirLength;
latt *= 1.-clamp((ldirLength-5.)/35., 0., 1.);
vec3 diffuse = colorrgba.rgb;
float diffactor = max(0., pow(dot(ldir, normal), 1.0))*latt;
vec3 reflec = reflect(rd, normal);
float specfactor = pow(max(0., dot(ldir, reflec)), lparams.y) * lparams.x;
float shadow = 1.;
#if APPLY_SHADOW == 1
shadow = max(calcshadow(point, ldir, 0.8, ldirLength), 0.01);
#endif
acolor += diffuse * diffactor * lights[lidx].color* shadow;
acolor += specfactor * lights[lidx].color* shadow;
color += (acolor*colorrgba.a*att);
}
color = lparams.w*colorrgba.rgb + (1.-lparams.w)*color.rgb;;
vec3 fireballcolor = mix(vec3(0.91, 0.46, 0.07), vec3(0.42, 0.90, 0.00), smoothstep(26.5, 27.0, t));
vec3 bloomcolor = mix(fireballcolor, vec3(1.6, 1.65, 1.65), step(0.5, res.w));
color.rgb = mix(mix(bloomcolor, color.rgb, 0.5), color.rgb, smoothstep(0., 1.0, res.z));
att = max(att*(1.-colorrgba.a), 0.);
if(att < 0.01)
{
break;
}
rd = refdir;
position = refposition;
}
else
{
att = 0.;
break;
}
}
float fadeFactor = mix(0., 1., smoothstep(39., 40., t));
fadeFactor = mix(1., fadeFactor, smoothstep(0., 1., t));
fragColor = mix(vec4(color, 1.), vec4(0.), fadeFactor);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragCoord = vTexCoord.xy*global.OutputSize.xy;
FragCoord.y = -FragCoord.y;
mainImage(FragColor,FragCoord);
}

398
procedural/dave_hoskins-frozen-wasteland.slang Normal file
View File

@ -0,0 +1,398 @@
#version 450
// Frozen Wasteland - 2015-03-02
// https://www.shadertoy.com/view/Xls3D2
// Frozen wasteland. Built on nimitz's model, although I didn't use his fog stuff afterall. It uses fog ray tracing included within the main ray march.
// Frozen wasteland
// https://www.shadertoy.com/view/Xls3D2
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
// By Dave Hoskins
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define ITR 90
#define FAR 110.
#define time iGlobalTime
#define MOD3 vec3(.16532,.17369,.15787)
#define SUN_COLOUR vec3(1., .95, .85)
#define TRIANGLE_NOISE // .. This
//#define FOUR_D_NOISE // ...Or this
//#define TEXTURE_NOISE // .. Or this (faster, but not as sharp edged)
//#define VALUE_NOISE // .. or more normal noise.
float height(in vec2 p)
{
float h = sin(p.x*.1+p.y*.2)+sin(p.y*.1-p.x*.2)*.5;
h += sin(p.x*.04+p.y*.01+3.0)*4.;
h -= sin(h*10.0)*.1;
return h;
}
float camHeight(in vec2 p)
{
float h = sin(p.x*.1+p.y*.2)+sin(p.y*.1-p.x*.2)*.5;
h += sin(p.x*.04+p.y*.01+3.0)*4.;
return h;
}
float smin( float a, float b)
{
const float k = 2.7;
float h = clamp( 0.5 + 0.5*(b-a)/k, 0.0, 1.0 );
return mix( b, a, h ) - k*h*(1.0-h);
}
#define MOD2 vec2(.16632,.17369)
#define MOD3 vec3(.16532,.17369,.15787)
float tri(in float x){return abs(fract(x)-.5);}
float hash12(vec2 p)
{
p = fract(p * MOD2);
p += dot(p.xy, p.yx+19.19);
return fract(p.x * p.y);
}
float vine(vec3 p, in float c, in float h)
{
p.y += sin(p.z*.5625+1.3)*3.5-.5;
p.x += cos(p.z*2.)*1.;
vec2 q = vec2(mod(p.x, c)-c/2., p.y);
return length(q) - h*1.4 -sin(p.z*3.+sin(p.x*7.)*0.5)*0.1;
}
//========================================================================
// ################ DIFFERENT NOISE FUNCTIONS ################
#ifdef TRIANGLE_NOISE
vec3 tri3(in vec3 p){return vec3( tri(p.z+tri(p.y)), tri(p.z+tri(p.x)), tri(p.y+tri(p.x)));}
float Noise3d(in vec3 p)
{
float z=1.4;
float rz = 0.;
vec3 bp = p;
for (float i=0.; i<= 2.; i++ )
{
vec3 dg = tri3(bp);
p += (dg);
bp *= 2.;
z *= 1.5;
p *= 1.3;
rz+= (tri(p.z+tri(p.x+tri(p.y))))/z;
bp += 0.14;
}
return rz;
}
#endif
//--------------------------------------------------------------------------------
#ifdef FOUR_D_NOISE
vec4 quad(in vec4 p){return abs(fract(p.yzwx+p.wzxy)-.5);}
float Noise3d(in vec3 q)
{
float z=1.4;
vec4 p = vec4(q, iGlobalTime*.1);
float rz = 0.;
vec4 bp = p;
for (float i=0.; i<= 2.; i++ )
{
vec4 dg = quad(bp);
p += (dg);
z *= 1.5;
p *= 1.3;
rz+= (tri(p.z+tri(p.w+tri(p.y+tri(p.x)))))/z;
bp = bp.yxzw*2.0+.14;
}
return rz;
}
#endif
//--------------------------------------------------------------------------------
#ifdef TEXTURE_NOISE
float Noise3d(in vec3 x)
{
x*=10.0;
float h = 0.0;
float a = .34;
for (int i = 0; i < 4; i++)
{
vec3 p = floor(x);
vec3 f = fract(x);
f = f*f*(3.0-2.0*f);
vec2 uv = (p.xy+vec2(37.0,17.0)*p.z) + f.xy;
vec2 rg = textureLod( iChannel0, (uv+ 0.5)/256.0, 0.0 ).yx;
h += mix( rg.x, rg.y, f.z )*a;
a*=.5;
x+=x;
}
return h;
}
#endif
//--------------------------------------------------------------------------------
#ifdef VALUE_NOISE
float Hash(vec3 p)
{
p = fract(p * MOD3);
p += dot(p.xyz, p.yzx + 19.19);
return fract(p.x * p.y * p.z);
}
float Noise3d(in vec3 p)
{
vec2 add = vec2(1.0, 0.0);
p *= 10.0;
float h = 0.0;
float a = .3;
for (int n = 0; n < 4; n++)
{
vec3 i = floor(p);
vec3 f = fract(p);
f *= f * (3.0-2.0*f);
h += mix(
mix(mix(Hash(i), Hash(i + add.xyy),f.x),
mix(Hash(i + add.yxy), Hash(i + add.xxy),f.x),
f.y),
mix(mix(Hash(i + add.yyx), Hash(i + add.xyx),f.x),
mix(Hash(i + add.yxx), Hash(i + add.xxx),f.x),
f.y),
f.z)*a;
a*=.5;
p += p;
}
return h;
}
#endif
//--------------------------------------------------------------------------------
float map(vec3 p)
{
p.y += height(p.zx);
float d = p.y+.5;
d = smin(d, vine(p+vec3(.8,0.,0),30.,3.3) );
d = smin(d, vine(p.zyx+vec3(0.,0,17.),33.,1.4) );
d += Noise3d(p*.05)*(p.y*1.2);
p.xz *=.2;
d+= Noise3d(p*.3);
return d;
}
float fogmap(in vec3 p, in float d)
{
p.xz -= time*7.+sin(p.z*.3)*3.;
p.y -= time*.5;
return (max(Noise3d(p*.008+.1)-.1,0.0)*Noise3d(p*.1))*.3;
}
float march(in vec3 ro, in vec3 rd, out float drift, in vec2 scUV)
{
float precis = 0.01;
float h=precis*2.0;
float d = hash12(scUV);
drift = 0.0;
for( int i=0; i<ITR; i++ )
{
vec3 p = ro+rd*d;
if(h < precis || d > FAR) break;
h = map(p);
drift += fogmap(p, d);
d += min(h*.65 + d * .002, 8.0);
}
drift = min(drift, 1.0);
return d;
}
vec3 normal( in vec3 pos, in float d )
{
vec2 eps = vec2( d *d* .003+.01, 0.0);
vec3 nor = vec3(
map(pos+eps.xyy) - map(pos-eps.xyy),
map(pos+eps.yxy) - map(pos-eps.yxy),
map(pos+eps.yyx) - map(pos-eps.yyx) );
return normalize(nor);
}
float bnoise(in vec3 p)
{
p.xz*=.4;
float n = Noise3d(p*3.)*0.4;
n += Noise3d(p*1.5)*0.2;
return n*n*.2;
}
vec3 bump(in vec3 p, in vec3 n, in float ds)
{
p.xz *= .4;
//p *= 1.0;
vec2 e = vec2(.01,0);
float n0 = bnoise(p);
vec3 d = vec3(bnoise(p+e.xyy)-n0, bnoise(p+e.yxy)-n0, bnoise(p+e.yyx)-n0)/e.x;
n = normalize(n-d*10./(ds));
return n;
}
float shadow(in vec3 ro, in vec3 rd, in float mint)
{
float res = 1.0;
float t = mint;
for( int i=0; i<12; i++ )
{
float h = map(ro + rd*t);
res = min( res, 4.*h/t );
t += clamp( h, 0.1, 1.5 );
}
return clamp( res, 0., 1.0 );
}
vec3 Clouds(vec3 sky, vec3 rd)
{
rd.y = max(rd.y, 0.0);
float ele = rd.y;
float v = (200.0)/rd.y;
rd.y = v;
rd.xz = rd.xz * v - time*8.0;
rd.xz *= .0004;
float f = Noise3d(rd.xzz*3.) * Noise3d(rd.zxx*1.3)*2.5;
f = f*pow(ele, .5)*2.;
f = clamp(f-.15, 0.01, 1.0);
return mix(sky, vec3(1),f );
}
vec3 Sky(vec3 rd, vec3 ligt)
{
rd.y = max(rd.y, 0.0);
vec3 sky = mix(vec3(.1, .15, .25), vec3(.8), pow(.8-rd.y, 3.0));
return mix(sky, SUN_COLOUR, min(pow(max(dot(rd,ligt), 0.0), 4.5)*1.2, 1.0));
}
float Occ(vec3 p)
{
float h = 0.0;
h = clamp(map(p), 0.5, 1.0);
return sqrt(h);
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 p = fragCoord.xy/iResolution.xy-0.5;
vec2 q = fragCoord.xy/iResolution.xy;
p.x*=iResolution.x/iResolution.y;
#ifdef MOUSE
vec2 mo = iMouse.xy / iResolution.xy-.5;
#else
vec2 mo = 0.0 / iResolution.xy-.5;
#endif
mo = (mo==vec2(-.5))?mo=vec2(-0.1,0.07):mo;
mo.x *= iResolution.x/iResolution.y;
vec3 ro = vec3(0.+smoothstep(0.,1.,tri(time*1.5)*.3)*1.5, smoothstep(0.,1.,tri(time*3.)*3.)*0.08, -time*3.5-130.0);
ro.y -= camHeight(ro.zx)-.4;
mo.x += smoothstep(0.7,1.,sin(time*.35))*.5-1.5 - smoothstep(-.7,-1.,sin(time*.35))*.5;
vec3 eyedir = normalize(vec3(cos(mo.x),mo.y*2.-.05+sin(time*.5)*0.1,sin(mo.x)));
vec3 rightdir = normalize(vec3(cos(mo.x+1.5708),0.,sin(mo.x+1.5708)));
vec3 updir = normalize(cross(rightdir,eyedir));
vec3 rd=normalize((p.x*rightdir+p.y*updir)*1.+eyedir);
vec3 ligt = normalize( vec3(1.5, .9, -.5) );
float fg;
float rz = march(ro,rd, fg, fragCoord);
vec3 sky = Sky(rd, ligt);
vec3 col = sky;
if ( rz < FAR )
{
vec3 pos = ro+rz*rd;
vec3 nor= normal( pos, rz);
float d = distance(pos,ro);
nor = bump(pos,nor,d);
float shd = (shadow(pos,ligt,.04));
float dif = clamp( dot( nor, ligt ), 0.0, 1.0 );
vec3 ref = reflect(rd,nor);
float spe = pow(clamp( dot( ref, ligt ), 0.0, 1.0 ),5.)*2.;
float fre = pow( clamp(1.+dot(rd, nor),0.0,1.0), 3. );
col = vec3(.8);
col = col*dif*shd + fre*spe*shd*SUN_COLOUR +abs(nor.y)*vec3(.12, .13, .13);
// Fake the red absorption of ice...
d = Occ(pos+nor*3.);
col *= vec3(d, d, min(d*1.4, 1.0));
// Fog from ice storm...
col = mix(col, sky, smoothstep(FAR-25.,FAR,rz));
}
else
{
col = Clouds(col, rd);
}
// Fog mix...
col = mix(col, vec3(0.7, .7, .7), fg);
// Post...
col = mix(col, vec3(.5), -.1);
//col = clamp(pow(col*1.,vec3(0.4)),0.0, 1.0);
col = sqrt(col);
// Borders...
float f = smoothstep(0.0, 3.0, iGlobalTime)*.5;
col *= f+f*pow(70. *q.x*q.y*(1.0-q.x)*(1.0-q.y), .2);
fragColor = vec4( col, 1.0 );
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

81
procedural/dave_hoskins-galaxy-of-universes.slang Normal file
View File

@ -0,0 +1,81 @@
#version 450
// Galaxy of Universes - 2014-06-19
// https://www.shadertoy.com/view/MdXSzS
// Big Bang? *pfft* It's just a small explosion somewhere in a rotating Galaxy of Universes!
// Thanks to Kali for his fractal formula.
// https://www.shadertoy.com/view/MdXSzS
// The Big Bang - just a small explosion somewhere in a massive Galaxy of Universes.
// Outside of this there's a massive galaxy of 'Galaxy of Universes'... etc etc. :D
// To fake a perspective it takes advantage of the screen being wider than it is tall.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = (fragCoord.xy / iResolution.xy) - .5;
float t = iGlobalTime * .1 + ((.25 + .05 * sin(iGlobalTime * .1))/(length(uv.xy) + .07)) * 2.2;
float si = sin(t);
float co = cos(t);
mat2 ma = mat2(co, si, -si, co);
float v1, v2, v3;
v1 = v2 = v3 = 0.0;
float s = 0.0;
for (int i = 0; i < 90; i++)
{
vec3 p = s * vec3(uv, 0.0);
p.xy *= ma;
p += vec3(.22, .3, s - 1.5 - sin(iGlobalTime * .13) * .1);
for (int i = 0; i < 8; i++) p = abs(p) / dot(p,p) - 0.659;
v1 += dot(p,p) * .0015 * (1.8 + sin(length(uv.xy * 13.0) + .5 - iGlobalTime * .2));
v2 += dot(p,p) * .0013 * (1.5 + sin(length(uv.xy * 14.5) + 1.2 - iGlobalTime * .3));
v3 += length(p.xy*10.) * .0003;
s += .035;
}
float len = length(uv);
v1 *= smoothstep(.7, .0, len);
v2 *= smoothstep(.5, .0, len);
v3 *= smoothstep(.9, .0, len);
vec3 col = vec3( v3 * (1.5 + sin(iGlobalTime * .2) * .4),
(v1 + v3) * .3,
v2) + smoothstep(0.2, .0, len) * .85 + smoothstep(.0, .6, v3) * .3;
fragColor=vec4(min(pow(abs(col), vec3(1.2)), 1.0), 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

645
procedural/dave_hoskins-ray-q-bert.slang Normal file
View File

@ -0,0 +1,645 @@
#version 450
// Ray * Bert - 2013-03-08
// https://www.shadertoy.com/view/4sl3RH
// --------
// Ray*Bert!!! ( @!#?@! )
// --| |---
// |/
// By Dave Hoskins
// Finished for now... may come back later to put the other characters in.
// V. 0.8 - Added colour changes and a fixed path for Q*Bert.
// V. 0.7 - Better fur and ambient lighting.
// V. 0.64 - Moving Q*bert.Behaves differently on different machines! :(
// V. 0.63 - Pupil watching.
// V. 0.62 - Asynchronous bounces.
// V. 0.61 - Fur.
// V. 0.60 - In the middle of getting old Q to move about.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define REFLECTIONS_ON
#define PI 3.1415926535
vec3 areaPlane = normalize(vec3(-1.0, 1.0, 1.0));
vec3 lightDir = normalize(vec3(-1437.0, 1743.0, 430.0));
vec3 QbertPos;
float QbertRotation;
vec3 balls[3];
float squish[4];
float radius[3];
const vec3 ballStart1 = vec3(-.0, 2.6, -1.);
const vec3 ballStart2 = vec3( 1.0, 2.6, 0.);
const vec3 addLeft = vec3(-1.0, -1.0, 0.0);
const vec3 addRight = vec3(.0, -1.0, 1.0);
const vec3 QbertStart = vec3(-3.0, -1.3, .00);
float time;
float rand( float n )
{
return fract(sin(n*1233.23)*43758.5453);
}
float hash( float n )
{
return fract(sin(n)*43758.5453123);
}
float noise( in vec3 x )
{
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;
float res = 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);
return res;
}
vec2 rotate2D(vec2 p, float a)
{
float sa = sin(a);
float ca = cos(a);
vec2 r;
r.x = ca*p.x + sa*p.y;
r.y = -sa*p.x + ca*p.y;
return r;
}
// Finding the movement location at a set time. Loopy IF-tastic!!...
void GetLocation(int i, float s, out vec3 outPos1, out vec3 outPos2)
{
int end = int(mod(s, 8.0))-1;
float r = floor(s/8.0) + float(i*547);
vec3 pos;
if (rand(float(r)) > .5)
{
pos = ballStart1;
}else
{
pos = ballStart2;
}
for (int t = 0; t < 9; t++)
{
if (t == 0)
{
outPos1 = pos + vec3(0.0, 3.5, 0.0);
}
if (t == end)
{
outPos1 = pos;
}
if (t == end+1)
{
outPos2 = pos;
if (t == 7)
{
outPos2 = outPos1 + vec3(0.0, -8.5, 0.0);
}
}
if (rand(float(t)+r) > .5)
{
pos += addLeft;
}else
{
pos += addRight;
}
}
}
//--------------------------------------------------------------------------------------------
vec3 MoveQbert(int n, in vec3 pos, out float dir)
{
if (n == 0)
{
pos -= addLeft;
dir = -90.0;
}else
if (n == 1)
{
pos -= addRight;
dir = 180.0;
}else
if (n == 3)
{
pos += addLeft;
dir = 90.0;
}else
{
pos += addRight;
dir = 0.0;
}
return pos;
}
//--------------------------------------------------------------------------------------------
int DirTable[19];
float GetQbertLocation(float s, out vec3 out1, out vec3 out2)
{
int end = int(mod(s, 18.0));
float r = floor(s/18.0);
vec3 pos = QbertStart;
float dir = 0.0;
float outDir;
vec3 newPos;
for (int t = 0; t < 19; t++)
{
if (t == end)
{
out1 = pos;
}
if (t == end+1)
{
out2 = pos;
outDir = dir / 180.0 * PI;
}
int val = DirTable[t];
pos = MoveQbert(val, pos, dir);
}
return outDir;
}
//----------------------- Distance Estimation fields -------------------
float deTorus( vec3 p, vec2 t )
{
vec2 q = vec2(length(p.xy)-t.x,p.z);
return length(q)-t.y;
}
float deQBertEyes(vec3 p)
{
float t = squish[3];//clamp(fra*.25, 0.0, 0.2)-.2;
p.y -= t;
p.xz = rotate2D(p.xz, QbertRotation);
vec3 pos = p + vec3(-.08, -.17, -.18);
float d = length(pos)-.12;
pos = p + vec3(.08, -.17, -.18);
d = min(d, length(pos)-.12);
return d;
}
float deQBert(vec3 pos)
{
pos.xz = rotate2D(pos.xz, QbertRotation);
vec3 p = pos;
// Torso...
float t = squish[3];//clamp(fra*.25, 0.0, 0.2)-.2;
p.y -=t;
p.y *= .9;
float d = length(p)-.32;
p = pos * vec3(1.0, 1.0, .3);
p.z -= .1;
p.y -= t;
d = min(d, deTorus(p, vec2(.07, .06)));
// Vertical legs...
p = (pos * vec3(1.0, .4, 1.0))- vec3(-.13, -.2, -.1);
d = min(d, length(p)-.06);
p = (pos * vec3(1.0, .4, 1.0))- vec3(.13, -.2, -.1);
d = min(d, length(p)-.06);
// Feet...
p = (pos * vec3(.4, .8, .3))- vec3(-.05, -.5, .01);
d = min(d, length(p)-.03);
p = (pos * vec3(.4, .8, .3))- vec3(.05, -.5, .01);
d = min(d, length(p)-.03);
return d;
}
float deBall(vec3 p, float s)
{
return length(p)-s;
}
float dePlane(vec3 p, vec3 planeN)
{
return dot(p, planeN);
}
float PlayArea(vec3 p)
{
float d;
d = dePlane(p, areaPlane);
return d;
}
//--------------------------------------------------------------------------------------------
float Scene(in vec3 p, out int which)
{
float d = 1000.0, f;
for (int i =0; i < 3; i++)
{
vec3 pos = p-balls[i];
// Squish it...
pos.xz /= squish[i];
pos.y *= squish[i];
f = deBall(pos, radius[i]);
if (f < d)
{
d = f;
which = i;
}
}
f = deQBert(p - QbertPos);
if (f < d)
{
d = f;
which = 4;
}
f = deQBertEyes(p - QbertPos);
if (f < d)
{
d = f;
which = 5;
}
return d;
}
//------------------------------ Lighting ------------------------------------
// Calculate scene normal
vec3 SceneNormal(vec3 pos )
{
float eps = 0.001;
vec3 n;
int m;
float d = Scene(pos, m);
n.x = Scene( vec3(pos.x+eps, pos.y, pos.z), m ) - d;
n.y = Scene( vec3(pos.x, pos.y+eps, pos.z),m ) - d;
n.z = Scene( vec3(pos.x, pos.y, pos.z+eps),m ) - d;
return normalize(n);
}
vec3 HueGradient(float t)
{
t += .4;
vec3 p = abs(fract(t + vec3(1.0, 2.0 / 3.0, 1.0 / 3.0)) * 6.0 - 3.0);
return (clamp(p - 1.0, 0.0, 1.0));
}
// Colouring in the fragments...
vec3 LightCubes(vec3 pos, vec3 n)
{
vec3 qpos = QbertStart;
float dir;
ivec3 ipos = ivec3(floor(pos+.5));
float foundHit = 0.0;
int end = int(mod(time*.8, 18.0));
vec3 areaColour = vec3(.53, .7, .85);
for (int t = 0; t < 18; t++)
{
qpos = MoveQbert(DirTable[t], qpos, dir);
ivec3 ip = ivec3(floor(qpos+.5));
if (ip == ipos && n.y >= .8)
{
if (t >= end)
foundHit = .5;
else
foundHit = 1.5;
}
}
if (foundHit > 0.0) areaColour = HueGradient((floor((time*.8/18.0))+foundHit)/4.23);
float diff = dot(n, lightDir);
diff = max(diff, 0.0);
return diff * areaColour;
}
vec3 LightCharacters(vec3 pos, vec3 norm, vec3 dir, int m)
{
float specular = 0.0;
vec3 ballColour;
float specSize = 8.0;
vec3 specColour = vec3(1.0, 1.0, 1.0);
if (m == 7)
{
ballColour = vec3(1.0, 1.0, 1.0);
specColour = vec3(0.0, 0.0, 0.0);
specSize = 2.0;
}
if (m == 6)
{
norm += (noise((pos-QbertPos)*42.0)*.5)-.5;
ballColour = vec3(1.2, 0.42, 0.);
}
else
{
vec3 reflect = ((-2.0*(dot(dir, norm))*norm)+dir);
specular = pow(max(dot(reflect, lightDir), 0.0), specSize);
if (m == 2)
{
ballColour = vec3(1.0, 0.0, 1.0);
}else
if (m == 3)
{
ballColour = vec3(1.0, 0.0, 0.0);
}else
if (m == 4)
{
ballColour = vec3(0.0, 1.0, 0.0);
}
}
float diff = dot(norm, lightDir);
diff = max(diff, 0.3);
return mix(diff * ballColour, specColour, specular);
}
//--------------------------------------------------------------------------------------------
float DistanceFields(vec3 ro, vec3 rd, out int hit, out vec3 pos)
{
float len = .0;
float d;
hit = 0;
int m = 0;
for (int st = 0; st < 22; st++)
{
pos = ro + rd * len;
d = Scene(pos, m);
if (d < 0.01)
{
hit = m+1;
break;
}
len += d;
}
return len;
}
//--------------------------------------------------------------------------------------------
// Voxel grid search that I found in 1994 in Graphics Gems IV - "Voxel Traversal along a 3D Line"!
// This (Amanatides & Woo) varient is from another shader on here, but with some calculations removed,
// and the distance value fixed.
// I had to use voxels as standard distance fields don't work for perfectly aligned cubes.
float VoxelTrace(vec3 ro, vec3 rd, out bool hit, out vec3 hitNormal, out vec3 pos)
{
const int maxSteps = 41;
vec3 voxel = floor(ro)+.5001;
vec3 step = sign(rd);
//voxel = voxel - vec3(rd.x > 0.0, rd.y > 0.0, rd.z > 0.0);
vec3 tMax = (voxel - ro) / rd;
vec3 tDelta = 1.0 / abs(rd);
vec3 hitVoxel = voxel;
hit = false;
float hitT = 0.0;
for(int i=0; i < maxSteps; i++)
{
if (!hit)
{
float d = PlayArea(voxel);
if (d <= 0.0 && !hit)
{
hit = true;
hitVoxel = voxel;
break;
}
bool c1 = tMax.x < tMax.y;
bool c2 = tMax.x < tMax.z;
bool c3 = tMax.y < tMax.z;
if (c1 && c2)
{
voxel.x += step.x;
tMax.x += tDelta.x;
if (!hit)
{
hitNormal = vec3(-step.x, 0.0, 0.0);
hitT = tMax.x-tDelta.x;
}
} else if (c3 && !c1)
{
voxel.y += step.y;
tMax.y += tDelta.y;
if (!hit)
{
hitNormal = vec3(0.0, -step.y, 0.0);
hitT = tMax.y-tDelta.y;
}
} else
{
voxel.z += step.z;
tMax.z += tDelta.z;
if (!hit)
{
hitNormal = vec3(0.0, 0.0, -step.z);
hitT = tMax.z-tDelta.z;
}
}
}
}
if (hit)
{
if (hitVoxel.x > 1.75 || hitVoxel.z < -1.75 || hitVoxel.y < -3.5)
{
hit = false;
hitT = 1000.0;
}
}
pos = ro + hitT * rd;
return hitT;
}
//--------------------------------------------------------------------------------------------
// Do all the ray casting for voxels and normal distance fields...
float TraceEverything(vec3 ro,vec3 rd, out int material, out vec3 hitNormal, out vec3 pos)
{
bool hit1;
int hit2;
vec3 pos2;
float dist = VoxelTrace(ro, rd, hit1, hitNormal, pos);
float dist2 = DistanceFields(ro, rd, hit2, pos2);
if (hit2 > 0 && dist2 < dist)
{
hitNormal = SceneNormal(pos2);
pos = pos2;
material = hit2+1;
}else
if (hit1)
{
material = 1;
}else
{
material = 0;
}
return dist;
}
//--------------------------------------------------------------------------------------------
int TraceShadow(vec3 ro, vec3 rd)
{
int hit;
vec3 pos;
float dist2 = DistanceFields(ro, rd, hit, pos);
return hit;
}
//--------------------------------------------------------------------------------------------
vec3 DoMaterialRGB(int m, vec3 pos, vec3 norm, vec3 rd)
{
vec3 rgb;
if (m == 1)
{
rgb = LightCubes(pos, norm);
}else
if (m >= 2)
{
rgb = LightCharacters(pos, norm, rd, m);
}else
{
rgb = mix(vec3(.0, .05, .1), vec3(0.4, 0.6, .8), abs(rd.y*1.));
}
return rgb;
}
//--------------------------------------------------------------------------------------------
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
// For Q*Bert's movement to loop properly they needed a direction table...
// 1 0
// \ /
// @
// / \
// 3 2
DirTable[0] = 0; DirTable[1] = 2; DirTable[2] = 0; DirTable[3] = 2;
DirTable[4] = 0; DirTable[5] = 2; DirTable[6] = 0; DirTable[7] = 1; DirTable[8] = 1; DirTable[9] = 3; DirTable[10] = 1;
DirTable[11] = 1; DirTable[12] = 3; DirTable[13] = 3; DirTable[14] = 3;
DirTable[15] = 3; DirTable[16] = 2; DirTable[17] = 0; DirTable[18] = 0;
time = iGlobalTime*1.8878;;
vec2 pixel = (fragCoord.xy / iResolution.xy)*2.0-1.0;
float asp = iResolution.x / iResolution.y;
vec3 rd = normalize(vec3(asp*pixel.x, pixel.y-1.23, -3.5));
vec3 ro = vec3(-14.0, 6.3, 14.0);
// Rotate it to look at the plane
rd.xz = rotate2D(rd.xz, -(PI/4.0));
float sec, fra;
vec3 rgb;
vec3 norm, pos;
int material;
vec3 pos1, pos2;
radius[0] = .4;
radius[1] = .33;
radius[2] = .25;
for (int i = 0; i < 3; i++)
{
sec = time * float(i+3) * .2;
fra = fract(sec);
sec = floor(sec);
GetLocation(i, sec, pos1, pos2);
balls[i] = mix(pos1, pos2, fra);
balls[i].y += sin(fra*PI);
if (balls[i].y > -2.5)
{
float t = clamp(-fra*.75+1.3, 1.0, 1.3);
squish[i] = t;
}else
{
squish[i] = 1.0;
}
}
fra = fract(time*.8);
sec = floor(time*.8);
QbertRotation = GetQbertLocation(sec, pos1, pos2);
float t = clamp(fra*.5, 0.0, 0.2)-.3;
squish[3] = t;
QbertPos = mix(pos1, pos2, fra);
QbertPos.y += sin(fra*PI)+.5;
TraceEverything(ro, rd, material, norm, pos);
rgb = DoMaterialRGB(material, pos, norm, rd);
// Do the shadow casting of the balls...
if (dot(norm, lightDir) > 0.1 && material > 0 && TraceShadow(pos+lightDir*.04, lightDir) != 0)
{
rgb *= .4;
}
#ifdef REFLECTIONS_ON
if (material > 0 && material != 6)
{
ro = pos;
rd = ((-2.0*(dot(rd, norm))*norm)+rd);
TraceEverything(ro+rd*0.04, rd, material, norm, pos);
rgb = mix(rgb, DoMaterialRGB(material, pos, norm, rd), .13);
}
#endif
// Curve the brightness a little...
rgb = pow(rgb, vec3(.8, .8, .8));
fragColor=vec4(rgb, 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

74
procedural/dave_hoskins-ribbon-assault.slang Normal file
View File

@ -0,0 +1,74 @@
#version 450
// Ribbon Assault - 2014-02-26
// https://www.shadertoy.com/view/MdBGDK
// Inspired by the 'Kali2 scope' - https://www.shadertoy.com/view/lsBGWK
// Should be fast full-screen for everybody. : )
// Use mouse for manual movement.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
float gTime = iGlobalTime+11.0;
float f = 3., g = 3.;
vec2 res = iResolution.xy;
#ifdef MOUSE
vec2 mou = iMouse.xy;
if (iMouse.z < 0.5)
{
mou = vec2(sin(gTime * .3)*sin(gTime * .17) * 1. + sin(gTime * .3),(1.0-cos(gTime * .632))*sin(gTime * .131)*1.0+cos(gTime * .3));
mou = (mou+1.0) * res;
}
#else
vec2 mou = vec2(0.0, 0.0);
mou = vec2(sin(gTime * .3)*sin(gTime * .17) * 1. + sin(gTime * .3),(1.0-cos(gTime * .632))*sin(gTime * .131)*1.0+cos(gTime * .3));
mou = (mou+1.0) * res;
#endif
vec2 z = ((-res+2.0 * fragCoord.xy) / res.y);
vec2 p = ((-res+2.0+mou) / res.y);
for( int i = 0; i < 20; i++)
{
float d = dot(z,z);
z = (vec2( z.x, -z.y ) / d) + p;
z.x = abs(z.x);
f = max( f, (dot(z-p,z-p) ));
g = min( g, sin(dot(z+p,z+p))+1.0);
}
f = abs(-log(f) / 3.5);
g = abs(-log(g) / 8.0);
fragColor = vec4(min(vec3(g, g*f, f), 1.0),1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

425
procedural/dave_hoskins-rolling-hills.slang Normal file
View File

@ -0,0 +1,425 @@
#version 450
// Rolling Hills - 2013-07-29
// https://www.shadertoy.com/view/Xsf3zX
// Grassy fields. Ray marches a ray to a smooth hill, then enters detailed stepping through a grass like distance, erm, field.
// Now uses eiffie's 'Circle of Confusion' function for blurred ray marching into the grass.
// Thanks eiffie!
// Rolling hills. By David Hoskins, November 2013.
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
// https://www.shadertoy.com/view/Xsf3zX
// v.2.00 Uses eiffie's 'Circle of Confusion' function
// for blurred ray marching into the grass.
// v.1.02 Camera aberrations.
// v.1.01 Added better grass, with wind movement.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
// For red/cyan 3D...
//#define STEREO
#define MOD2 vec2(3.07965, 7.4235)
float PI = 4.0*atan(1.0);
vec3 sunLight = normalize( vec3( 0.35, 0.2, 0.3 ) );
vec3 cameraPos;
vec3 sunColour = vec3(1.0, .75, .6);
const mat2 rotate2D = mat2(1.932, 1.623, -1.623, 1.952);
float gTime = 0.0;
//--------------------------------------------------------------------------
// Noise functions...
float Hash( float p )
{
vec2 p2 = fract(vec2(p) / MOD2);
p2 += dot(p2.yx, p2.xy+19.19);
return fract(p2.x * p2.y);
}
//--------------------------------------------------------------------------
float Hash(vec2 p)
{
p = fract(p / MOD2);
p += dot(p.xy, p.yx+19.19);
return fract(p.x * p.y);
}
//--------------------------------------------------------------------------
float Noise( in vec2 x )
{
vec2 p = floor(x);
vec2 f = fract(x);
f = f*f*(3.0-2.0*f);
float n = p.x + p.y*57.0;
float res = 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);
return res;
}
vec2 Voronoi( in vec2 x )
{
vec2 p = floor( x );
vec2 f = fract( x );
float res=100.0,id;
for( int j=-1; j<=1; j++ )
for( int i=-1; i<=1; i++ )
{
vec2 b = vec2( float(i), float(j) );
vec2 r = vec2( b ) - f + Hash( p + b );
float d = dot(r,r);
if( d < res )
{
res = d;
id = Hash(p+b);
}
}
return vec2(max(.4-sqrt(res), 0.0),id);
}
//--------------------------------------------------------------------------
vec2 Terrain( in vec2 p)
{
float type = 0.0;
vec2 pos = p*0.003;
float w = 50.0;
float f = .0;
for (int i = 0; i < 3; i++)
{
f += Noise(pos) * w;
w = w * 0.62;
pos *= 2.5;
}
return vec2(f, type);
}
//--------------------------------------------------------------------------
vec2 Map(in vec3 p)
{
vec2 h = Terrain(p.xz);
return vec2(p.y - h.x, h.y);
}
//--------------------------------------------------------------------------
float FractalNoise(in vec2 xy)
{
float w = .7;
float f = 0.0;
for (int i = 0; i < 3; i++)
{
f += Noise(xy) * w;
w = w*0.6;
xy = 2.0 * xy;
}
return f;
}
//--------------------------------------------------------------------------
// Grab all sky information for a given ray from camera
vec3 GetSky(in vec3 rd)
{
float sunAmount = max( dot( rd, sunLight), 0.0 );
float v = pow(1.0-max(rd.y,0.0),6.);
vec3 sky = mix(vec3(.1, .2, .3), vec3(.32, .32, .32), v);
sky = sky + sunColour * sunAmount * sunAmount * .25;
sky = sky + sunColour * min(pow(sunAmount, 800.0)*1.5, .3);
return clamp(sky, 0.0, 1.0);
}
//--------------------------------------------------------------------------
// Merge grass into the sky background for correct fog colouring...
vec3 ApplyFog( in vec3 rgb, in float dis, in vec3 dir)
{
float fogAmount = clamp(dis*dis* 0.0000012, 0.0, 1.0);
return mix( rgb, GetSky(dir), fogAmount );
}
//--------------------------------------------------------------------------
vec3 DE(vec3 p)
{
float base = Terrain(p.xz).x - 1.9;
float height = Noise(p.xz*2.0)*.75 + Noise(p.xz)*.35 + Noise(p.xz*.5)*.2;
//p.y += height;
float y = p.y - base-height;
y = y*y;
vec2 ret = Voronoi((p.xz*2.5+sin(y*4.0+p.zx*12.3)*.12+vec2(sin(iGlobalTime*2.3+1.5*p.z),sin(iGlobalTime*3.6+1.5*p.x))*y*.5));
float f = ret.x * .6 + y * .58;
return vec3( y - f*1.4, clamp(f * 1.5, 0.0, 1.0), ret.y);
}
//--------------------------------------------------------------------------
// eiffie's code for calculating the aperture size for a given distance...
float CircleOfConfusion(float t)
{
return max(t * .04, (2.0 / iResolution.y) * (1.0+t));
}
//--------------------------------------------------------------------------
float Linstep(float a, float b, float t)
{
return clamp((t-a)/(b-a),0.,1.);
}
//--------------------------------------------------------------------------
vec3 GrassBlades(in vec3 rO, in vec3 rD, in vec3 mat, in float dist)
{
float d = 0.0;
// Only calculate cCoC once is enough here...
float rCoC = CircleOfConfusion(dist*.3);
float alpha = 0.0;
vec4 col = vec4(mat*0.15, 0.0);
for (int i = 0; i < 15; i++)
{
if (col.w > .99) break;
vec3 p = rO + rD * d;
vec3 ret = DE(p);
ret.x += .5 * rCoC;
if (ret.x < rCoC)
{
alpha = (1.0 - col.y) * Linstep(-rCoC, rCoC, -ret.x);//calculate the mix like cloud density
// Mix material with white tips for grass...
vec3 gra = mix(mat, vec3(.35, .35, min(pow(ret.z, 4.0)*35.0, .35)), pow(ret.y, 9.0)*.7) * ret.y;
col += vec4(gra * alpha, alpha);
}
d += max(ret.x * .7, .1);
}
if(col.w < .2)
col.xyz = vec3(0.1, .15, 0.05);
return col.xyz;
}
//--------------------------------------------------------------------------
// Calculate sun light...
void DoLighting(inout vec3 mat, in vec3 pos, in vec3 normal, in vec3 eyeDir, in float dis)
{
float h = dot(sunLight,normal);
mat = mat * sunColour*(max(h, 0.0)+.2);
}
//--------------------------------------------------------------------------
vec3 TerrainColour(vec3 pos, vec3 dir, vec3 normal, float dis, float type)
{
vec3 mat;
if (type == 0.0)
{
// Random colour...
mat = mix(vec3(.0,.3,.0), vec3(.2,.3,.0), Noise(pos.xz*.025));
// Random shadows...
float t = FractalNoise(pos.xz * .1)+.5;
// Do grass blade tracing...
mat = GrassBlades(pos, dir, mat, dis) * t;
DoLighting(mat, pos, normal,dir, dis);
}
mat = ApplyFog(mat, dis, dir);
return mat;
}
//--------------------------------------------------------------------------
// Home in on the surface by dividing by two and split...
float BinarySubdivision(in vec3 rO, in vec3 rD, float t, float oldT)
{
float halfwayT = 0.0;
for (int n = 0; n < 5; n++)
{
halfwayT = (oldT + t ) * .5;
if (Map(rO + halfwayT*rD).x < .05)
{
t = halfwayT;
}else
{
oldT = halfwayT;
}
}
return t;
}
//--------------------------------------------------------------------------
bool Scene(in vec3 rO, in vec3 rD, out float resT, out float type )
{
float t = 5.;
float oldT = 0.0;
float delta = 0.;
vec2 h = vec2(1.0, 1.0);
bool hit = false;
for( int j=0; j < 70; j++ )
{
vec3 p = rO + t*rD;
h = Map(p); // ...Get this position's height mapping.
// Are we inside, and close enough to fudge a hit?...
if( h.x < 0.05)
{
hit = true;
break;
}
delta = h.x + (t*0.03);
oldT = t;
t += delta;
}
type = h.y;
resT = BinarySubdivision(rO, rD, t, oldT);
return hit;
}
//--------------------------------------------------------------------------
vec3 CameraPath( float t )
{
//t = time + t;
vec2 p = vec2(200.0 * sin(3.54*t), 200.0 * cos(2.0*t) );
return vec3(p.x+55.0, 12.0+sin(t*.3)*6.5, -94.0+p.y);
}
//--------------------------------------------------------------------------
vec3 PostEffects(vec3 rgb, vec2 xy)
{
// Gamma first...
rgb = pow(rgb, vec3(0.45));
// Then...
#define CONTRAST 1.1
#define SATURATION 1.3
#define BRIGHTNESS 1.3
rgb = mix(vec3(.5), mix(vec3(dot(vec3(.2125, .7154, .0721), rgb*BRIGHTNESS)), rgb*BRIGHTNESS, SATURATION), CONTRAST);
// Vignette...
rgb *= .4+0.5*pow(40.0*xy.x*xy.y*(1.0-xy.x)*(1.0-xy.y), 0.2 );
return rgb;
}
//--------------------------------------------------------------------------
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
#ifdef MOUSE
float m = (iMouse.x/iResolution.x)*300.0;
##else
float m = (0.0/iResolution.x)*300.0;
#endif
float gTime = (iGlobalTime*5.0+m+2352.0)*.006;
vec2 xy = fragCoord.xy / iResolution.xy;
vec2 uv = (-1.0 + 2.0 * xy) * vec2(iResolution.x/iResolution.y,1.0);
vec3 camTar;
if (xy.y < .13 || xy.y >= .87)
{
// Top and bottom cine-crop - what a waste! :)
fragColor=vec4(vec4(0.0));
return;
}
#ifdef STEREO
float isCyan = mod(fragCoord.x + mod(fragCoord.y,2.0),2.0);
#endif
cameraPos = CameraPath(gTime + 0.0);
cameraPos.x -= 3.0;
camTar = CameraPath(gTime + .009);
cameraPos.y += Terrain(CameraPath(gTime + .009).xz).x;
camTar.y = cameraPos.y;
float roll = .4*sin(gTime+.5);
vec3 cw = normalize(camTar-cameraPos);
vec3 cp = vec3(sin(roll), cos(roll),0.0);
vec3 cu = cross(cw,cp);
vec3 cv = cross(cu,cw);
vec3 dir = normalize(uv.x*cu + uv.y*cv + 1.3*cw);
mat3 camMat = mat3(cu, cv, cw);
#ifdef STEREO
cameraPos += .85*cu*isCyan; // move camera to the right - the rd vector is still good
#endif
vec3 col;
float distance;
float type;
if( !Scene(cameraPos, dir, distance, type) )
{
// Missed scene, now just get the sky...
col = GetSky(dir);
}
else
{
// Get world coordinate of landscape...
vec3 pos = cameraPos + distance * dir;
// Get normal from sampling the high definition height map
// Use the distance to sample larger gaps to help stop aliasing...
vec2 p = vec2(0.1, 0.0);
vec3 nor = vec3(0.0, Terrain(pos.xz).x, 0.0);
vec3 v2 = nor-vec3(p.x, Terrain(pos.xz+p).x, 0.0);
vec3 v3 = nor-vec3(0.0, Terrain(pos.xz-p.yx).x, -p.x);
nor = cross(v2, v3);
nor = normalize(nor);
// Get the colour using all available data...
col = TerrainColour(pos, dir, nor, distance, type);
}
// bri is the brightness of sun at the centre of the camera direction.
// Yeah, the lens flares is not exactly subtle, but it was good fun making it.
float bri = dot(cw, sunLight)*.75;
if (bri > 0.0)
{
vec2 sunPos = vec2( dot( sunLight, cu ), dot( sunLight, cv ) );
vec2 uvT = uv-sunPos;
uvT = uvT*(length(uvT));
bri = pow(bri, 6.0)*.8;
// glare = the red shifted blob...
float glare1 = max(dot(normalize(vec3(dir.x, dir.y+.3, dir.z)),sunLight),0.0)*1.4;
// glare2 is the yellow ring...
float glare2 = max(1.0-length(uvT+sunPos*.5)*4.0, 0.0);
uvT = mix (uvT, uv, -2.3);
// glare3 is a purple splodge...
float glare3 = max(1.0-length(uvT+sunPos*5.0)*1.2, 0.0);
col += bri * vec3(1.0, .0, .0) * pow(glare1, 12.5)*.05;
col += bri * vec3(1.0, 1.0, 0.2) * pow(glare2, 2.0)*2.5;
col += bri * sunColour * pow(glare3, 2.0)*3.0;
}
col = PostEffects(col, xy);
#ifdef STEREO
col *= vec3( isCyan, 1.0-isCyan, 1.0-isCyan );
#endif
fragColor=vec4(col,1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

283
procedural/dave_hoskins-skin-peeler.slang Normal file
View File

@ -0,0 +1,283 @@
#version 450
// Skin peeler - 2015-08-19
// https://www.shadertoy.com/view/XtfSWX
// Skin peeler
// by Dave Hoskins
// Originally from Xyptonjtroz by nimitz (twitter: @stormoid)
// Edited by Dave Hoskins, by changing atmosphere with quite a few lighting changes & added audio
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define ITR 100
#define FAR 30.
#define time iGlobalTime
/*
Believable animated volumetric dust storm in 7 samples,
blending each layer in based on geometry distance allows to
render it without visible seams. 3d Triangle noise is
used for the dust volume.
Further explanation of the dust generation...
The basic idea is to have layers of gradient shaded volumetric
animated noise. The problem is when geometry is intersected
before the ray reaches the far plane. A way to smoothly blend
the low sampled noise is needed. So I am blending (smoothstep)
each dust layer based on current ray distance and the solid
interesction distance. I am also scaling the noise taps as a
function of the current distance so that the distant dust doesn't
appear too noisy and as a function of current height to get some
"ground hugging" effect.
*/
#define MOD3 vec3(.16532,.17369,.15787)
mat2 mm2(in float a){float c = cos(a), s = sin(a);return mat2(c,s,-s,c);}
float height(in vec2 p)
{
p *= 0.2;
return sin(p.y)*0.4 + sin(p.x)*0.4;
}
//smooth min form iq
float smin( float a, float b)
{
const float k = 0.7;
float h = clamp( 0.5 + 0.5*(b-a)/k, 0.0, 1.0 );
return mix( b, a, h ) - k*h*(1.0-h);
}
/// 2 out, 2 in...
vec2 hash22(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * MOD3);
p3 += dot(p3.zxy, p3.yxz+19.19);
return fract(vec2(p3.x * p3.y, p3.z*p3.x));
}
float vine(vec3 p, in float c, in float h)
{
p.y += sin(p.z*.5625+1.3)*1.5-.5;
p.x += cos(p.z*.4575)*1.;
//p.z -=.3;
vec2 q = vec2(mod(p.x, c)-c/2., p.y);
return length(q) - h -sin(p.z*3.+sin(p.x*7.)*0.5+time)*0.13;
}
float map(vec3 p)
{
p.y += height(p.zx);
vec3 bp = p;
vec2 hs = hash22(floor(p.zx/4.));
p.zx = mod(p.zx,4.)-2.;
float d = p.y+0.5;
p.y -= hs.x*0.4-0.15;
p.zx += hs*1.3;
d = smin(d, length(p)-hs.x*0.4);
d = smin(d, vine(bp+vec3(1.8,0.,0),15.,.8) );
d = smin(d, vine(bp.zyx+vec3(0.,0,17.),20.,0.75) );
return d*1.1;
}
float march(in vec3 ro, in vec3 rd)
{
float precis = 0.002;
float h=precis*2.0;
float d = 0.;
for( int i=0; i<ITR; i++ )
{
if( abs(h)<precis || d>FAR ) break;
d += h;
h = map(ro+rd*d);
}
return d;
}
float tri(in float x){return abs(fract(x)-.5);}
vec3 tri3(in vec3 p){return vec3( tri(p.z+tri(p.y*1.)), tri(p.z+tri(p.x*1.)), tri(p.y+tri(p.x*1.)));}
mat2 m2 = mat2(0.970, 0.242, -0.242, 0.970);
float triNoise3d(in vec3 p)
{
float z=1.4;
float rz = 0.;
vec3 bp = p;
for (float i=0.; i<=3.; i++ )
{
vec3 dg = tri3(bp);
p += (dg);
bp *= 2.;
z *= 1.5;
p *= 1.2;
//p.xz*= m2;
rz+= (tri(p.z+tri(p.x+tri(p.y))))/z;
bp += 0.14;
}
return rz;
}
float fogmap(in vec3 p, in float d)
{
p.x += time;
p.z += time*.5;
return triNoise3d(p*2.2/(d+8.0))*(smoothstep(.7,.0,p.y));
}
vec3 fog(in vec3 col, in vec3 ro, in vec3 rd, in float mt)
{
float d = .5;
for(int i=0; i<7; i++)
{
vec3 pos = ro + rd*d;
float rz = fogmap(pos, d);
col = mix(col,vec3(.85, .65, .5),clamp(rz*smoothstep(d,d*1.8,mt),0.,1.) );
d *= 1.8;
if (d>mt)break;
}
return col;
}
vec3 normal(in vec3 p)
{
vec2 e = vec2(-1., 1.)*0.005;
return normalize(e.yxx*map(p + e.yxx) + e.xxy*map(p + e.xxy) +
e.xyx*map(p + e.xyx) + e.yyy*map(p + e.yyy) );
}
float bnoise(in vec3 p)
{
float n = sin(triNoise3d(p*3.)*7.)*0.4;
n += sin(triNoise3d(p*1.5)*7.)*0.2;
return (n*n)*0.01;
}
vec3 bump(in vec3 p, in vec3 n, in float ds)
{
vec2 e = vec2(.005,0);
float n0 = bnoise(p);
vec3 d = vec3(bnoise(p+e.xyy)-n0, bnoise(p+e.yxy)-n0, bnoise(p+e.yyx)-n0)/e.x;
n = normalize(n-d*2.5/sqrt(ds));
return n;
}
float shadow(in vec3 ro, in vec3 rd, in float mint, in float tmax)
{
float res = 1.0;
float t = mint;
for( int i=0; i<20; i++ )
{
float h = map(ro + rd*t);
res = min( res, 4.*h/t );
t += clamp( h, 0.2, 1.5 );
}
return clamp( res, 0.0, 1.0 );
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 p = fragCoord.xy/iResolution.xy-0.5;
vec2 q = fragCoord.xy/iResolution.xy;
p.x*=iResolution.x/iResolution.y;
#ifdef MOUSE
vec2 mo = iMouse.xy / iResolution.xy-.5;
#else
vec2 mo = 0.0 / iResolution.xy-.5;
#endif
mo = (mo==vec2(-.5))?mo=vec2(-0.1,0.07):mo;
mo.x *= iResolution.x/iResolution.y;
vec3 ro = vec3(smoothstep(0.,1.,tri(time*.6)*2.)*0.1, smoothstep(0.,1.,tri(time*1.2)*2.)*0.05, -time*0.6);
ro.y -= height(ro.zx)+0.07;
mo.x += smoothstep(0.7,1.,sin(time*.35))-1.5 - smoothstep(-.7,-1.,sin(time*.35));
vec3 eyedir = normalize(vec3(cos(mo.x),mo.y*2.-0.2+sin(time*.75*1.37)*0.15,sin(mo.x)));
vec3 rightdir = normalize(vec3(cos(mo.x+1.5708),0.,sin(mo.x+1.5708)));
vec3 updir = normalize(cross(rightdir,eyedir));
vec3 rd=normalize((p.x*rightdir+p.y*updir)*1.+eyedir);
vec3 ligt = normalize( vec3(.5, .5, -.2) );
float rz = march(ro,rd);
vec3 fogb = mix(vec3(.5, .4,.4), vec3(1.,.9,.8), min(pow(max(dot(rd,ligt), 0.0), 1.5)*1.25, 1.0));
vec3 col = fogb;
if ( rz < FAR )
{
vec3 pos = ro+rz*rd;
vec3 nor= normal( pos );
float d = distance(pos,ro);
nor = bump(pos,nor,d);
float shd = shadow(pos,ligt,0.1,3.);
float dif = clamp( dot( nor, ligt ), 0.0, 1.0 )*shd;
float spe = pow(clamp( dot( reflect(rd,nor), ligt ), 0.0, 1.0 ),3.)*shd;
float fre = pow( clamp(1.0+dot(nor,rd),0.0,1.0), 1.5 );
vec3 brdf = dif*vec3(1.00)+abs(nor.y)*.4;
col = clamp(mix(vec3(.7,0.4,.3),vec3(.3, 0.1, 0.1),(pos.y+.5)*.25), .0, 1.0);
col *= (sin(bnoise(pos*.1)*250.)*0.5+0.5);
col = col*brdf + spe*fre;// + fre*vec3(.4,.4,0.4)*.5*crv;
}
//ordinary distance fog first
col = mix(col, fogb, smoothstep(FAR-10.,FAR,rz));
//then volumetric fog
col = fog(col, ro, rd, rz);
//post...
col = pow(col,vec3(0.8));
col = smoothstep(0.0, 1.0, col);
col *= .5+.5*pow(70. *q.x*q.y*(1.0-q.x)*(1.0-q.y), .2);
fragColor = vec4( col * smoothstep(0.0, 3.0, time), 1.0 );
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

812
procedural/davidbargo-sg15-midgar.slang Normal file
View File

@ -0,0 +1,812 @@
#version 450
// Fully procedural Midgar city from Final Fantasy VII
// Created by David Bargo - davidbargo/2015
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define ITR 100
#define FAR 150.
#define PI 3.141592
#define precis 0.001
#define time iGlobalTime
mat3 rot_x(float a)
{
float sa = sin(a);
float ca = cos(a);
return mat3(1.,0.,0., 0.,ca,sa, 0.,-sa,ca);
}
mat3 rot_z(float a)
{
float sa = sin(a);
float ca = cos(a);
return mat3(ca,sa,0., -sa,ca,0., 0.,0.,1.);
}
//----------------------------------------------------------------------------------------
// From Dave_Hoskins
vec2 hash22(vec2 p){
p = fract(p * vec2(5.3983, 5.4427));
p += dot(p.yx, p.xy + vec2(21.5351, 14.3137));
return fract(vec2(p.x * p.y * 95.4337, p.x * p.y * 97.597));
}
vec3 hash33(vec3 p){
p = fract(p * vec3(5.3983, 5.4427, 6.9371));
p += dot(p.yzx, p.xyz + vec3(21.5351, 14.3137, 15.3219));
return fract(vec3(p.x * p.z * 95.4337, p.x * p.y * 97.597, p.y * p.z * 93.8365));
}
float hash12(vec2 p)
{
p = fract(p * vec2(443.8975,397.2973));
p += dot(p.xy, p.yx+19.19);
return fract(p.x * p.y);
}
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
// Distance functions by iq
float ssphere( vec3 p, float s )
{
return length(p)-s;
}
float sbox( vec3 p, vec3 b )
{
vec3 d = abs(p) - b;
return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0));
}
float ubox( vec3 p, vec3 b )
{
return length(max(abs(p)-b,0.0));
}
float urbox( vec3 p, vec3 b, float r )
{
return length(max(abs(p)-b,0.0))-r;
}
float cyl( vec3 p, vec2 h )
{
vec2 d = abs(vec2(length(p.xz),p.y)) - h;
return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float caps( vec3 p, vec3 a, vec3 b, float r )
{
vec3 pa = p - a, ba = b - a;
float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
return length( pa - ba*h ) - r;
}
float torus( vec3 p, vec2 t )
{
return length( vec2(length(p.xz)-t.x,p.y) )-t.y;
}
float length8(vec2 p)
{
p *= p;
p *= p;
return pow(dot(p, p), 0.125);
}
float tube( vec3 p, vec2 t )
{
return length(vec2(length8(p.xz)-t.x,p.y))-t.y;
}
//----------------------------------------------------------------------------------------
// From iq
mat3 m = mat3( 0.00, 0.80, 0.60,
-0.80, 0.36, -0.48,
-0.60, -0.48, 0.64 );
float hash( float n )
{
return fract(sin(n)*43758.5453);
}
float noise( in vec3 x )
{
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;
float res = 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);
return res;
}
//----------------------------------------------------------------------------------------
float fbm(vec3 p)
{
return 0.65*noise(p) + 0.35*noise(m*p*2.02);
}
float matid = 0.;
float light = 0.;
float map(vec3 p)
{
// center bottom
float mn2 = cyl(p+vec3(p.x*0.35, 0.0, 0.2-0.1*p.y), vec2(0.64,0.98));
matid = 1.;
// center middle
float mn = cyl(p+vec3(p.x*0.5,-1.,0.2-0.1*p.y), vec2(0.4,0.45));
matid += step(mn, mn2);
mn2 = min(mn, mn2);
// side towers
float signx = sign(-p.x);
float stw = mix(0.2, 0.24, smoothstep(0.65, 0.7, p.y));
stw = mix(stw, 0.2, smoothstep(0.9, 0.95, p.y));
stw = mix(stw, 0.24, smoothstep(1.15, 1.22, p.y));
mn = caps(p + vec3( signx*0.75, 2.,0.3), vec3(0.,0.0,0.), vec3(0.0,3.2,0.), stw);
matid = mix(matid, 3., step(mn, mn2));
mn2 = min(mn, mn2);
// top main
mn = urbox(p+vec3(0.,-2.64,-0.09), vec3(0.06, 0.39, 0.2), 0.1);
// top support
mn = min(mn, urbox(p+ vec3(0.12*signx, -1.8,-0.21 - 0.2*smoothstep(2.2, 1.8,p.y)), vec3(-0.01, 1., 0.06), 0.05));
matid = mix(matid, 4., step(mn, mn2));
mn2 = min(mn, mn2);
// polar coords
vec3 pc = vec3(length(p.xz)*0.5, p.y*0.5, atan(p.z,p.x) - PI/16.);
// mini towers
vec3 ps = pc;
float mtl = step(-3.22, pc.z)*step(pc.z, -2.67);
ps.z = (0.5+0.5*sin((ps.z)*48. - 1.))*0.15;
ps.x += -.87;
ps.x*=2.;
mn = caps(ps, vec3(0.), mtl*vec3(0.0,0.23,0.0), 0.07*mtl);
ps.x += -.17;
mn = min(mn, caps(ps, vec3(0.), mtl*vec3(0.0,0.17,0.0), 0.07*mtl));
matid = mix(matid, 5., mtl*step(mn, mn2));
mn2 = min(mn, mn2);
// small wall lights
ps = pc;
ps.z = (0.5+0.5*sin((ps.z)*40. - 2.3))*0.06;
ps.y -= 0.14;
float wlc = smoothstep(0.78, 0.68, ps.x);
ps.x += -0.69;
float ss = 0.06*smoothstep(0.06, 0.03, ps.x) - 0.025*wlc;
float sls = step(-1.65, pc.z)*step(pc.z, -1.46) + step(-2.45, pc.z)*step(pc.z, -1.95);
mn = ssphere(ps, ss*sls);
// big wall lights
ps = pc;
ps.z = (0.5+0.5*sin((ps.z)*48. + 1.))*0.12;
ps.y -= 0.27;
float wl = smoothstep(2.01, 1.9, ps.x);
ps.x += -2. + 0.08*wl;
float sb = 0.1*smoothstep(0.08, 0.03, ps.x) - 0.025*wl;
float slb = step(2.215, abs(pc.z))*step(abs(pc.z), 2.495) + step(-0.14, pc.z)*step(pc.z, 0.15);
mn = min(mn, ssphere(ps, sb*slb) + FAR*(1. - slb));
matid = mix(matid, 6., step(mn, mn2));
mn2 = min(mn, mn2);
// platforms
vec3 pl = pc;
float plr = step(abs(pl.z + 0.6), 0.33);
pl.z = 0.5+0.5*sin((pl.z)*8. + PI);
vec3 hashp = hash33(floor(p*7.)/7.);
vec2 polarhash = hash22(floor(pc.zz*8.)/8. + 0.75)*0.6;
float bra = smoothstep(0., 1.2, pc.x);
bra *= bra; bra *= bra; bra *= bra;
float br = step(0.15*bra*bra, abs(pc.z + 0.55 + 0.1*hashp.z));
float bdgs = hash12(floor(pc.xz*32.)/32.);
bdgs *= step(bdgs, 0.5)*0.04;
mn = sbox(pl + vec3(-2.8+mix(polarhash.x, 1.5, plr),0.0,-0.3),
br*vec3(2.15 - mix(polarhash.x, 1.5, plr), 0.05 + step(pc.x, 1.9)*bdgs, 0.6));
matid = mix(matid, 7., step(mn, mn2));
mn2 = min(mn, mn2);
// wall columns
ps = pc;
ps.z = 0.5+0.5*sin((ps.z)*8.);
float w = smoothstep(0.57, 0., pc.y);
ps.x += -2.;
mn = max(urbox(ps, vec3(0.075+0.025*w,0.38,-0.06 + 0.05*w), 0.1), -urbox(ps, vec3(0.07, 1.,-0.048), 0.05));
matid = mix(matid, 8., step(mn, mn2));
mn2 = min(mn, mn2);
// back main building
mn = sbox(p+vec3(0.,0.0,-0.25+0.1*p.y), vec3(0.472, 0.98, 0.34));
mn = min(mn, sbox(p+vec3(0.,-.81,-0.4+0.1*p.y), vec3(0.262, 0.64, 0.36)));
// building center tubes
mn = min(mn, cyl(p+ vec3(0.34*signx, -1.1+0.6*abs(p.x), 0.3), vec2(0.07, 0.5)));
mn = min(mn, cyl(p+ vec3(0.35*signx, -1.05+0.6*abs(p.x), 0.15), vec2(0.07, 0.5)));
mn = min(mn, cyl(p+ vec3(0.36*signx, -1.+0.6*abs(p.x), 0.), vec2(0.07, 0.5)));
// building center cylinder
float sinpx = sin(p.x*100.);
float tw = mix(0.2, 0.25 + 0.005*sinpx, smoothstep( -0.4, -0.35, p.x));
tw = mix( tw, 0.3, smoothstep(-0.25, -0.15, p.x));
tw = mix( tw, 0.3 + 0.005*sinpx, smoothstep( 0.15, 0.3, p.x));
tw = mix( tw, 0.2, smoothstep( 0.3, 0.42, p.x));
mn = min(mn, cyl(p.yxz+vec3(-1.8, 0., 0.1), vec2(tw, 0.45)));
mn = min(mn, torus((p.xzy+vec3(-0.04, 0.1, -1.8))*rot_z(1.2), vec2(0.32, 0.044)));
// building back
float ba = smoothstep(0.925, 0., p.y);
mn = min(mn, max( urbox(p+ vec3(0.2*signx, -0.9,-1.2 + ba*1.5),
vec3(0.1-p.y*0.08, 0.45, 0.2 + ba*0.88), 0.1),
-urbox(p+vec3(0.2*signx, -1.2, -1.2), vec3(0.02, 0.3, 0.15), 0.01))); // bottom back
mn = min(mn, cyl(p.yxz+vec3(-0.6, 0.28*signx, -1.), vec2(0.12,0.2))); // back tube
vec3 pos = (p+ vec3(0.4*signx, -1.1,-0.58))*rot_x(-PI*0.22);
mn = min(mn, urbox(pos, vec3(-0.01, 0.66, 0.04 + 0.16*smoothstep(-0.85, 0.85, pos.y)), 0.05));
pos = (p+vec3(0.,-1.95,-0.4))*rot_x(PI*0.15);
pos.z -= 0.2*smoothstep(0.5,0.0,pos.y);
mn = min(mn, urbox(pos, vec3(0.01, 0.76, 0.1 + 0.12*smoothstep(0.5,0.0, pos.y)), 0.1)); // top back
mn = min(mn, urbox(p+vec3(0.,-2.94,-0.2), vec3(0.01, 0.4, 0.01), 0.001)); // antenna
mn = min(mn, tube(p+vec3(-signx*0.25,-2.34 - 0.3*p.z*step(0., p.z),-0.2), vec2(0.5, 0.05)));
// center tubes
mn = min(mn, tube(p.zxy+vec3(1.43 ,0., -0.1), vec2(0.4, 0.1))); //center
mn = min(mn, cyl(p+vec3(0.,0.,1.85), vec2(0.46, 0.22)));
mn = min(mn, cyl(p+vec3(0.,0.,1.85), vec2(0.24, 0.3)));
mn = min(mn, tube((p.zxy+vec3(0.25 ,1.2, -0.1))*rot_z(PI/6.), vec2(0.4, 0.14))); // right 1
mn = min(mn, tube((p.xzy+vec3(0.7 , -0.3, -0.1))*rot_z(-PI/8.), vec2(0.8, 0.1))); // right 2
mn = min(mn, tube((p.xzy+vec3(0.5, -0.5, -0.4))*rot_z(-PI/4.), vec2(0.8, 0.1))); // right 3
mn = min(mn, tube((p.xzy+vec3(-1., 1., -0.4))*rot_z(-PI/4.), vec2(0.4, 0.1))); // left 1
mn = min(mn, tube(p.xzy+vec3(-1.3, 0., -0.2), vec2(0.4, 0.08))); // left 2
// back towers
mn = min(mn, cyl(p + vec3(0.76, 2., -0.3), vec2(0.2-smoothstep(1.6, 2.1, p.y)*0.14, 4.0)));
mn = min(mn, cyl(p + vec3(0.64, 2., -0.64), vec2(0.2-smoothstep(1.8, 2.3, p.y)*0.14, 4.2)));
// small platforms
float cp = step(-2., pc.z)*0.06;
mn = min(mn, ubox(pl + vec3(-0.83+cp,0.0,0.), vec3(0.17-cp,0.09*(step(pc.z, -0.1)+step(2.1, pc.z)),0.85)));
// sectors walls
ps = pc;
ps.z = 0.5+0.5*sin((ps.z)*8. +0.7);
ps.x += -1.325;
mn = min(mn, sbox(ps, vec3(0.6,0.065+pc.x*0.052,0.02)));
ps.z = 0.5+0.5*sin((pc.z)*8. -0.7);
mn = min(mn, sbox(ps, vec3(0.6,0.065+pc.x*0.052,0.02)));
// first wall
ps = pc;
ps.z = 0.;
ps.y += 1.;
ps.x += -0.65;
mn = min(mn, urbox(ps, vec3(0.0,1.13,2.), 0.05));
// second wall
ps = pc;
ps.z = 0.5+0.5*sin((ps.z)*72.);
ps.x += -2.;
mn = min(mn, sbox(ps, br*vec3(0.1, min(0.25, 0.24 - ps.x*1.1), 0.993+2.*step(ps.y, 0.13))));
// presecond wall
mn = min(mn, sbox(pl + vec3(-1.9,-0.06,-0.35), br*vec3(0.1, 0.005+pc.x*0.052+step(1.86, pc.x)*0.005, 0.6)));
// sectors connector tube
ps.x += 0.7;
ps.y += -0.02;
mn = min(mn, sbox(ps, br*vec3(0.03,0.03,2.)));
matid = mix(matid, 0., step(mn, mn2));
return min(mn, mn2);
}
float march(in vec3 ro, in vec3 rd)
{
float h=precis*2.0;
float d = 0.;
for( int i=0; i<ITR; i++ )
{
if( abs(h)<precis || d>FAR ) break;
d += h;
h = map(ro+rd*d);
}
return d;
}
float smalllights(vec3 pc)
{
vec3 ps = pc;
ps.z = (0.5+0.5*sin((ps.z)*40. - 2.3))*0.06;
ps.y -= 0.14;
float wlc = smoothstep(0.78, 0.68, ps.x);
ps.x += -0.69;
ps.x = min(ps.x-0.05, 0.);
float sc = step(-1.65, pc.z)*step(pc.z, -1.46) + step(-2.45, pc.z)*step(pc.z, -1.95);
return ssphere(ps, 0.02*(2.*sc -1.));
}
float biglights(vec3 pc)
{
vec3 ps = pc;
ps.z = (0.5+0.5*sin((ps.z)*48. + 1.))*0.1;
ps.y -= 0.27;
float wl = smoothstep(1.62, 1.52, ps.x);
ps.x += -1.95 + 0.08*wl;
ps.x = min(ps.x-0.005, 0.);
float sl = step(2.215, abs(pc.z))*step(abs(pc.z), 2.495) + step(-0.14, pc.z)*step(pc.z, 0.15);
return ssphere(ps, 0.04*(2.*sl -1.)+.01*(pc.x-1.95));
}
float lights(vec3 p)
{
vec3 pc = vec3(length(p.xz)*0.5, p.y*0.5, atan(p.z,p.x) - PI/16.);
float sl = smalllights(pc);
float bl = biglights(pc);
light = step(bl, sl);
return min(bl, sl);
}
vec3 marchlights(in vec3 ro, in vec3 rd, float far)
{
light = 0.;
float h=precis*2.0;
float d = 0.;
for( int i=0; i<60; i++ )
{
if( abs(h)<precis || d>far ) break;
d += h;
h = lights(ro+rd*d);
}
if (d < far)
{
vec3 lpos = (ro+rd*d);
float dist = length(lpos.xz);
if (light == 0.)
{
float ld = precis*2.;
for( int i=0; i<30; i++ )
{
if( h > precis*2.) break;
vec3 lposb = (lpos+rd*ld);
vec3 pc = vec3(length(lposb.xz)*0.5, lposb.y*0.5, atan(lposb.z,lposb.x) - PI/16.);
h = smalllights(pc);
ld += max(abs(h), precis*2.);
}
light = smoothstep(2.2, 0., dist)*ld*ld*10.;
}
else if (light == 1.)
{
float ld = precis*2.;
for( int i=0; i<40; i++ )
{
if( h > precis*2.) break;
vec3 lposb = (lpos+rd*ld);
vec3 pc = vec3(length(lposb.xz)*0.5, lposb.y*0.5, atan(lposb.z,lposb.x) - PI/16.);
h = biglights(pc);
ld += max(abs(h), precis*2.);
}
light = smoothstep(6.7, 0., dist)*ld*ld*1.5;
}
}
return vec3(1.,1.,0.7)*fract(light);
}
float makolight(vec3 p)
{
p.y *= 0.3;
return ssphere(p, 1.15);
}
vec3 makocolor(vec3 p)
{
float n = noise(p.xzz);
vec3 pc = vec3(length(p.xz)*0.5, p.y, atan(p.z,p.x));
float hl = mix(0.4, 1., smoothstep(-2.8, -2.7, pc.z));
hl = mix(hl, 0.4, smoothstep(-1.8, -1.65, pc.z));
hl = mix(hl, 1., smoothstep(-1.5, -1.4, pc.z));
hl = mix(hl, 0.6, smoothstep(-1., -0.9, pc.z));
hl = mix(hl, 1., smoothstep(-0.7, -0.6, pc.z));
hl = mix(hl, 0.5, smoothstep(-0.2, -0.05, pc.z));
hl = mix(hl, 1., smoothstep(0.05, 0.2, pc.z));
hl = mix(hl, 0.4, smoothstep(1., 1.2, pc.z));
hl = mix(hl, 0.9, smoothstep(1.9, 2.2, pc.z));
hl = mix(hl, 0.4, smoothstep(2.8, 3., pc.z));
float intensity = 0.25*smoothstep((0.7+0.8*n)*hl, 0., p.y)*step(pc.x, 0.6);
float mp = intensity*fbm(vec3(30.*p.x,1.5*p.y-2.*time,p.z*30.));
return mp*mix(vec3(0.0, 0.4, 0.8),
mix(vec3(0.2, 0.9, 0.6),
vec3(0.5, 0.5, 0.0), smoothstep(0.3 + 0.3*n, 0.6 + 0.6*n, p.y)), smoothstep(-0.5, 0.3 + 0.3*n, p.y));
}
vec3 marchmako(in vec3 ro, in vec3 rd, float far)
{
vec3 color = vec3(0.);
float h=precis*2.0;
float d = h;
for( int i=0; i<50; i++ )
{
if( abs(h)<precis || d>far ) break;
d += h;
h = makolight(ro+rd*d);
}
if (d < far)
{
color = makocolor(ro+rd*d);
// back face
d += h;
for(int i = 0; i < 50; i++)
{
if(h > precis*2. || d > far) break;
h = makolight(ro+rd*d);
d += max(abs(h), precis*2.);
}
if (d < far)
{
color += makocolor(ro+rd*d);
}
}
return color;
}
float tex(in vec3 q)
{
vec3 h = hash33(floor(q*4.)/4.);
return (h.x+h.y+h.z)*0.1;
}
float mapN(in vec3 p)
{
float d= map(p);
d += tex(p*10.)*0.005;
return d;
}
vec3 normal(const in vec3 p)
{
vec2 e = vec2(-1., 1.)*0.008;
return normalize(e.yxx*mapN(p + e.yxx) + e.xxy*mapN(p + e.xxy) +
e.xyx*mapN(p + e.xyx) + e.yyy*mapN(p + e.yyy) );
}
//from iq
float getAO( in vec3 pos, in vec3 nor )
{
float occ = 0.0;
float sca = 1.0;
for( int i=0; i<5; i++ )
{
float hr = 0.01 + 0.13*float(i)/3.;
vec3 aopos = nor * hr + pos;
float dd = map( aopos );
occ += -(dd-hr)*sca;
sca *= 0.95;
}
return clamp( 1. - 3.5*occ, 0.0, 1.0 );
}
vec3 shinralogo(vec2 pos, vec2 center, float size)
{
vec2 absp = vec2(abs(pos.x - center.x), abs(pos.y - center.y)*1.3);
float clogo = step(size, absp.y + absp.x);
float blogo = step(absp.y, size*0.8)*step(absp.x, size*0.8);
vec3 col = vec3(step(absp.y, size)*step(absp.x, size));
col.r -= 0.8*clogo*blogo;
float gb = 1. - (1.-blogo)*clogo;
col.gb -= gb*step(2.*(pos.y - center.y) - absp.x*4., 0.4*size);
return clamp(col, 0., 1.);
}
float tri(in float x)
{
return abs(fract(x)-.5);
}
// From nimitz
vec3 stars(in vec3 p)
{
vec3 c = vec3(0.);
//Triangular deformation (used to break sphere intersection pattterns)
p.x += (tri(p.z*50.)+tri(p.y*50.))*0.006;
p.y += (tri(p.z*50.)+tri(p.x*50.))*0.006;
p.z += (tri(p.x*50.)+tri(p.y*50.))*0.006;
for (float i=0.;i<2.;i++)
{
vec3 q = fract(p*250.)-0.5;
vec3 id = floor(p*250.);
float rn = hash33(id).z;
float c2 = 1.-smoothstep(-0.2,.4,length(q));
c2 *= step(rn,0.005+i*0.014);
c += c2*(mix(vec3(1.0,0.75,0.5),vec3(0.85,0.9,1.),rn*30.)*0.5 + 0.5);
p *= 1.15;
}
return c*c*smoothstep(-0.1, 0., p.y);
}
float platformTex(vec2 p)
{
float hp = hash12(floor(p));
vec2 fp = fract(p);
float s = sign(fp.x - hp);
float ha = hash12(floor(p-vec2(s, 0.0)));
float hb = hash12(floor(p+vec2(0.0, s))) + s;
float hc = hash12(floor(p+vec2(s, s))) + s;
vec2 p1 = vec2(hp, ha);
vec2 p2 = vec2(hb, hc);
vec2 sp = sign(p1 - p2);
vec2 sp1 = p1*sp;
vec2 sp2 = -p2*sp;
vec2 f = max(abs(fp - (p1+p2)*0.5) - (sp1+sp2)*0.5 + 0.033, 0.0);
return clamp(1.0 - dot(f, f)*1000., 0.0, 1.0);
}
vec3 cam()
{
float t = time*0.25 - 0.5;
vec3 pos = vec3(-6.5, 7.3, -11.5);
pos = mix(pos, vec3(-6.5, 1.2, -3.2), smoothstep(1., 10., time));
pos = mix(pos, vec3(0., 3.5, -8.5), smoothstep(8., 18., time));
pos = mix(pos, vec3(9.5, 7.2, -2.5), smoothstep(16., 26., time));
pos = mix(pos, vec3(9.5, 6.2, -2.5), smoothstep(25., 27., time));
pos = mix(pos, vec3(4.5, 1., 4.5), smoothstep(29., 36., time));
pos = mix(pos, vec3(-1., 1., 4.5), smoothstep(34., 42., time));
pos = mix(pos, vec3(13.*sin(t),8.+2.5*sin(t+0.1),-13.*cos(t)), smoothstep(40., 50., time));
return pos;
}
vec3 target()
{
vec3 ta = vec3(0.0,0.7,0.0);
ta = mix(ta, vec3(0.0,1.9,0.0), smoothstep(1., 10., time));
ta = mix(ta, vec3(0.0,1.6,0.0), smoothstep(9., 18., time));
ta = mix(ta, vec3(0.0,1.,0.0), smoothstep(16., 26., time));
ta = mix(ta, vec3(0.0,-1.,0.0), smoothstep(24., 27., time));
ta = mix(ta, vec3(0.0,-3.,5.0), smoothstep(26.5, 30., time));
ta = mix(ta, vec3(0.0,1.,4.0), smoothstep(30.5, 36., time));
ta = mix(ta, vec3(-1.0,1.,0.0), smoothstep(34., 42., time));
ta = mix(ta, vec3(0.0,0.7,0.0), smoothstep(40., 50., time));
return ta;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 p = fragCoord.xy/iResolution.xy-0.5;
p.x *= iResolution.x/iResolution.y;
vec3 ro = cam();
vec3 ta = target();
vec3 ww = normalize( ta - ro );
vec3 uu = normalize( cross(ww,vec3(0.0,1.0,0.0) ) );
vec3 vv = normalize( cross(uu,ww));
vec3 rd = normalize( p.x*uu + p.y*vv + 2.0*ww );
float d = march(ro,rd);
vec3 col = stars(rd);
if ( d < FAR )
{
vec3 pos = ro+d*rd;
float mid = matid;
vec3 nor = normal(pos);
vec3 pc = vec3(length(pos.xz), pos.y, atan(pos.z,pos.x) - PI/16.);
vec3 pl = pc;
pl.z = 0.5+0.5*sin(pl.z*8. + PI);
vec3 lpos = vec3(0., 0.38, 0.);
lpos.xz = 1.25*normalize(pos.xz);
vec3 lt = (lpos - pos);
vec3 lgt = 0.15*lt;
vec3 lgtp = (ta + 0.5*normalize(pos - ta) - pos)*0.5;
float dif = clamp( dot( nor, lgt ), 0.0, 1.0 ) + 0.4*clamp( dot( nor, lgtp ), 0.0, 1.0 );
float spe = pow(clamp( dot( reflect(rd,nor), lgt ), 0.0, 1.0 ),7.);
float fre = pow( clamp(1.0+dot(nor,rd),0.0,1.0), 3.0 );
vec3 brdf = vec3(1.)*2.*dif;
col = vec3(0.04,0.04,0.02);
float ao = getAO(pos,nor);
if (mid == 1.)
{
col = col*brdf +.03*fre;
col *= ao;
float l = 0.5 + 0.5*sin(pos.y*98.);
l *= l*step(pos.y, 0.95);
float h = hash12(floor(pos.xy*31.)/31.);
h = 0.9*step(0.7, h);
col += vec3(1. - h*0.7, 1. - h,0.)*l*l*0.1;
}
else if (mid == 2.)
{
col += shinralogo(pos.xy, vec2(0., 1.22), 0.12)*0.5;
col = col*brdf +.03*fre;
col *= ao;
float l = 0.5 + 0.5*sin(pos.y*98.);
l *= l*step(abs(pos.y - 1.19), 0.19)*step(0.15, abs(pos.x));
float h = hash12(floor(pos.xy*31.)/31.);
h = 0.9*step(0.8, h);
col += vec3(1. - h*0.7, 1. - h,0.)*l*l*0.1;
}
else if (mid == 3.)
{
col = col*brdf +.03*fre;
col *= ao;
float l = 0.5 + 0.5*sin(pos.y*98.);
l *= l*step(pos.y, 1.15)*(step(pos.y, 0.65) + step(0.95, pos.y));
float h = hash12(floor(pos.xy*31.)/31.);
h = 0.9*step(0.8, h);
col += vec3(1. - h*0.7, 1. - h,0.)*l*l*0.1;
}
else if (mid == 4.)
{
col += shinralogo(pos.xy, vec2(0., 2.5), 0.06)*0.5;
col = col*(0.05) +.03*fre;
col *= ao;
float l = 0.5 + 0.5*sin(pos.y*98.);
l *= l*step(pos.z, -0.16*step(pos.y, 2.88))*step(pos.y, 3.05)*step(2.6, pos.y);
float h = hash12(floor(pos.xy*23.)/23.);
h = 0.9*step(0.5, h);
col += vec3(1. - h*0.7, 1. - h,0.)*l*l*0.1;
}
else if (mid == 5.)
{
col = col*brdf +.03*fre;
col *= ao;
float d = mix(step(abs(pos.y - 0.49), 0.01), step(abs(pos.y - 0.38), 0.01), step(1.82, pl.x));
col += vec3(1., 1.,0.)*d*0.1;
}
else if (mid == 6.)
{
col = col*brdf +.03*fre;
col *= ao;
col += 0.5*mix(smoothstep(1.448, 1.458, pl.x), smoothstep(4.08, 4.11, pl.x), step(2.5, pl.x));
}
else if (mid == 7.)
{
float f = 0.;
vec3 l = vec3(0.);
if (pl.x < 3.6)
{
float br = step(0.4, abs(pc.z + 0.46));
col += vec3(0.5, 0.35, 0.)*noise(pos*5.5)*(0.3 + 0.7*br);
l = vec3(0.5, 0.3, 0.)*step(0.993, hash12(floor(pos.xz*50.)/50.))*step(pl.x, 3.4)*br;
}
else
{
vec2 pt = vec2(pc.x, pc.z*7.);
col += platformTex(pt)*0.04;
float el = step(4.18, pl.x)*smoothstep(0.51, 0.42, pl.z*10.0/pl.x)*smoothstep(-0.2, -0.18, -pl.y)*smoothstep(5.7, 4.3, pl.x);
l = vec3(1.,1.,0.7)*(0.02*el*smoothstep(0., 0.2, col.r));
}
col = col*0.05 + 0.03*fre;
col *= ao;
col += l;
}
else if (mid == 8.)
{
col += shinralogo(pl.xy, vec2(4.02, 0.6), .16)*0.5;
float rl = hash12(floor((pos.xz )*0.25 + 1.5)/1.);
float st = 0.5 + 0.5*sin(time*(2.+rl) + rl*10.);
col += vec3(0.0, 0.75, 0.3)*smoothstep(0.85, 1., pos.y);
col = col*0.05 +.03*fre;
col *= ao*(4. - 3.*mix(1., smoothstep(0.95, 0.75, pos.y), st));
col += (0.25 + 0.75*st)*vec3(0.1, 1., 0.7)*smoothstep(0.95, 0.75, pos.y)*step(0.998, pl.z)*step(abs(pl.x - 4.), 0.16);
}
else
{
col = col*brdf +.03*fre;
col *= ao;
}
// fake platform lights
float el = step(4.18, pl.x)*smoothstep(0.51, 0.42, pl.z*10.0/pl.x)*smoothstep(-0.2, -0.18, -pl.y)*smoothstep(5.7, 4.3, pl.x);
col += vec3(1.,1.,0.7)*(0.6*el*smoothstep(4.22, 4.2, pl.x));
col *= smoothstep(90.0, 0.0, dot(pos, pos));
col *= smoothstep(-0.6, -0.1, pos.y);
}
col += marchlights(ro, rd, d);
col += marchmako(ro, rd, d);
col = pow(clamp(col*1.5,0.,1.), vec3(0.416667))*1.055 - 0.055; //sRGB
fragColor = vec4( col, 1.0 );
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

532
procedural/dr2-blob-zoo.slang Normal file
View File

@ -0,0 +1,532 @@
#version 450
// Blob Zoo - dr2 - 2018-02-18
// https://www.shadertoy.com/view/4sdcWN
// Lots of strange critters
// "Blob Zoo" by dr2 - 2018
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
float PrBox2Df (vec2 p, vec2 b);
float PrBoxAn2Df (vec2 p, vec2 b, float w);
float PrSphDf (vec3 p, float r);
float PrCylDf (vec3 p, float r, float h);
float PrCylAnDf (vec3 p, float r, float w, float h);
float PrCapsDf (vec3 p, float r, float h);
float SmoothMin (float a, float b, float r);
float SmoothBump (float lo, float hi, float w, float x);
vec2 Rot2D (vec2 q, float a);
vec3 HsvToRgb (vec3 c);
float Hashfv2 (vec2 p);
float Fbm2 (vec2 p);
vec3 VaryNf (vec3 p, vec3 n, float f);
vec2 PixToHex (vec2 p);
vec2 HexToPix (vec2 h);
vec3 HexGrid (vec2 p);
vec3 sunDir;
vec2 gId;
float tCur, dstFar, gcRnd, bHt;
int idObj;
const float pi = 3.14159, sqrt3 = 1.7320508;
#define DMIN(id) if (d < dMin) { dMin = d; idObj = id; }
vec3 SMap (vec3 p, float t)
{
float f;
f = 2.;
for (int k = 0; k < 5; k ++) {
p += 0.4 * sin (1.7 * p.yzx / f + f * t);
f *= 0.8;
}
return p;
}
float BlobDf (vec3 p)
{
float t;
t = tCur + 25. * gcRnd;
p *= 2.;
p.xz = Rot2D (p.xz, 0.2 * t);
return max (0.1 * SmoothMin (PrSphDf (SMap (p - vec3 (0.7, 1.8, 0.), t + 2.), 1.1 + 0.31 * sin (t)),
PrSphDf (SMap (p + vec3 (0.7, -1.8, 0.), 1.3 * t), 1. + 0.41 * sin (1.7 * t)), 0.5), - p.y);
}
float ObjDf (vec3 p)
{
vec3 q, qq;
float dMin, d, szFac, w, s;
szFac = 0.1;
dMin = dstFar / szFac;
p.xz -= HexToPix (gId);
p /= szFac;
w = 0.05;
q = p;
d = max (min (max (PrBoxAn2Df (q.xz, vec2 (2., 7.5), w), - PrBox2Df (q.xz, vec2 (2.1 + w, 2. - w))),
max (PrBoxAn2Df (q.xz, vec2 (7.5, 2.), w), - PrBox2Df (q.xz, vec2 (2. - w, 2.1 + w)))), abs (q.y - bHt) - bHt);
qq = q;
qq.xz = mod (qq.xz, 0.5) - 0.25;
s = 1. - sqrt (1. - smoothstep (1.3, 1.7, qq.y));
qq.y -= 0.82;
d = max (d, - min (PrBox2Df (qq.xy, vec2 (0.2 - 0.2 * s, 0.9)),
PrBox2Df (qq.zy, vec2 (0.2 - 0.2 * s, 0.9))));
DMIN (1);
q.xz = Rot2D (q.xz, pi / 6.);
q.xz = Rot2D (q.xz, 2. * pi * ((floor (6. * atan (q.z, - q.x) / (2. * pi) + 0.5)) / 6.));
q.xy -= vec2 (-10., 1.6);
d = PrCylAnDf (q.xzy, 1.15, 0.08, 0.015);
DMIN (2);
q.xz = Rot2D (vec2 (q.x - 0.65, abs (q.z)), - pi / 3.);
q.x = abs (q.x);
q.xy -= vec2 (0.7, -0.8);
d = PrCylDf (q.xzy, 0.03, 0.8);
DMIN (3);
q = p;
q.y -= 0.05;
d = PrCylAnDf (q.xzy, 1.7, 0.07, 0.05);
DMIN (2);
q = p;
d = length (q.xz) - 1.7;
if (d < 0.1) {
d = BlobDf (q);
DMIN (4);
} else dMin = min (dMin, d);
return dMin * szFac;
}
void SetGrdConf ()
{
gcRnd = Hashfv2 (17.3 * gId);
bHt = (1./24.) * floor (22. + 5. * gcRnd);
}
float ObjRay (vec3 ro, vec3 rd)
{
vec3 vri, vf, hv, p;
vec2 edN[3], pM, gIdP;
float dHit, d, s;
edN[0] = vec2 (1., 0.);
edN[1] = 0.5 * vec2 (1., sqrt3);
edN[2] = 0.5 * vec2 (1., - sqrt3);
for (int k = 0; k < 3; k ++) edN[k] *= sign (dot (edN[k], rd.xz));
vri = 1. / vec3 (dot (rd.xz, edN[0]), dot (rd.xz, edN[1]), dot (rd.xz, edN[2]));
vf = 0.5 * sqrt3 - vec3 (dot (ro.xz, edN[0]), dot (ro.xz, edN[1]),
dot (ro.xz, edN[2]));
pM = HexToPix (PixToHex (ro.xz));
hv = (vf + vec3 (dot (pM, edN[0]), dot (pM, edN[1]), dot (pM, edN[2]))) * vri;
s = min (hv.x, min (hv.y, hv.z));
gIdP = vec2 (-999.);
dHit = 0.;
for (int j = 0; j < 220; j ++) {
p = ro + dHit * rd;
gId = PixToHex (p.xz);
if (gId.x != gIdP.x || gId.y != gIdP.y) {
gIdP = gId;
SetGrdConf ();
}
d = ObjDf (p);
if (dHit + d < s) dHit += d;
else {
dHit = s + 0.001;
pM += sqrt3 * ((s == hv.x) ? edN[0] : ((s == hv.y) ? edN[1] : edN[2]));
hv = (vf + vec3 (dot (pM, edN[0]), dot (pM, edN[1]), dot (pM, edN[2]))) * vri;
s = min (hv.x, min (hv.y, hv.z));
}
if (d < 0.0002 || dHit > dstFar || p.y < 0. || p.y > 2.) break;
}
if (d >= 0.0002) dHit = dstFar;
return dHit;
}
vec3 ObjNf (vec3 p)
{
vec4 v;
vec2 e = vec2 (0.00002, -0.00002);
v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy), ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
vec2 TrackPath (float t)
{
vec2 r;
float tt;
tt = mod (t, 4.);
if (tt < 1.) r = mix (vec2 (sqrt3 * 0.5, -0.5), vec2 (sqrt3 * 0.5, 0.5), tt);
else if (tt < 2.) r = mix (vec2 (sqrt3 * 0.5, 0.5), vec2 (0., 1.), tt - 1.);
else if (tt < 3.) r = mix (vec2 (0., 1.), vec2 (0., 2.), tt - 2.);
else r = mix (vec2 (0., 2.), vec2 (sqrt3 * 0.5, 2.5), tt - 3.);
r += vec2 (0.005, 3. * floor (t / 4.));
return r;
}
float ObjSShadow (vec3 ro, vec3 rd)
{
vec3 p;
vec2 gIdP;
float sh, d, h;
sh = 1.;
gIdP = vec2 (-999.);
d = 0.001;
for (int j = 0; j < 40; j ++) {
p = ro + d * rd;
gId = PixToHex (p.xz);
if (gId.x != gIdP.x || gId.y != gIdP.y) {
gIdP = gId;
SetGrdConf ();
}
h = ObjDf (p);
sh = min (sh, smoothstep (0., 0.03 * d, h));
d += min (0.005, 3. * h);
if (h < 0.001) break;
}
return 0.8 + 0.2 * sh;
}
vec3 SkyCol (vec3 rd)
{
return mix (vec3 (0.2, 0.3, 0.5) + 0.3 * pow (max (dot (rd, sunDir), 0.), 8.), vec3 (1.),
0.2 + 0.8 * rd.y * Fbm2 (2. * rd.xz / rd.y));
}
vec3 ShStagGrid (vec2 p, vec2 g)
{
vec2 q, sq, ss;
q = p * g;
if (2. * floor (0.5 * floor (q.y)) != floor (q.y)) q.x += 0.5;
sq = smoothstep (0.03, 0.07, abs (fract (q + 0.5) - 0.5));
q = fract (q) - 0.5;
ss = 0.3 * smoothstep (0.35, 0.5, abs (q.xy)) * sign (q.xy);
if (abs (q.x) < abs (q.y)) ss.x = 0.;
else ss.y = 0.;
return vec3 (ss.x, 0.9 + 0.1 * sq.x * sq.y, ss.y);
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec3 col, vn, qh, rg;
vec2 g, vf;
float dstObj, dstGrnd, spec, sh, f;
bool fxz;
dstGrnd = (rd.y < 0.) ? - ro.y / rd.y : dstFar;
dstObj = ObjRay (ro, rd);
if (min (dstObj, dstGrnd) < dstFar) {
sh = 1.;
vf = vec2 (0.);
if (dstObj < dstGrnd) {
ro += dstObj * rd;
gId = PixToHex (ro.xz);
SetGrdConf ();
vn = ObjNf (ro);
if (idObj == 1) {
col = HsvToRgb (vec3 (0.04 + 0.12 * gcRnd, 0.7, 0.7));
spec = 0.05;
if (ro.y > 0.2 * bHt - 0.0005) col*= 0.7;
if (abs (vn.y) < 0.01) {
rg = 10. * ro;
fxz = (abs (vn.x) > 0.99);
rg = ShStagGrid ((fxz ? rg.zy : rg.xy), 6. * vec2 (1., 2.));
col *= rg.y;
rg.xz *= sign (fxz ? vn.x : vn.z);
if (fxz) {
if (rg.x == 0.) vn.xy = Rot2D (vn.xy, rg.z);
else vn.xz = Rot2D (vn.xz, rg.x);
} else {
if (rg.x == 0.) vn.zy = Rot2D (vn.zy, rg.z);
else vn.zx = Rot2D (vn.zx, rg.x);
}
}
} else if (idObj == 2) {
col = vec3 (0.6, 0.6, 0.7);
spec = 0.1;
vf = vec2 (1024., 0.5);
} else if (idObj == 3) {
f = mod (256. * ro.y + atan (vn.z, vn.x) / (2. * pi), 1.);
if (abs (f - 0.5) < 0.4) {
col = vec3 (0.6, 0.6, 0.7);
spec = 0.1;
vf = vec2 (1024., 0.5);
} else {
col = vec3 (0.5, 0.7, 0.2);
vn.y = sin (2. * pi * (abs (f - 0.5) - 0.4) * sign (f));
vn.xz *= sqrt (1. - vn.y * vn.y);
spec = 0.3;
}
} else if (idObj == 4) {
col = HsvToRgb (vec3 (mod (13. * gcRnd, 1.), 1., 0.9));
spec = 0.3;
vf = vec2 (256., 0.5);
}
if (idObj != 3) sh = ObjSShadow (ro, sunDir);
} else {
ro += dstGrnd * rd;
gId = PixToHex (ro.xz);
SetGrdConf ();
vn = vec3 (0., 1., 0.);
g = ro.xz - HexToPix (gId);
if (length (g) < 0.17) {
col = vec3 (0.4, 0.4, 0.5);
vf = vec2 (256., 0.2);
} else if (abs (g.x) < 0.2 && abs (g.y) < 0.75 || abs (g.x) < 0.75 && abs (g.y) < 0.2) {
col = HsvToRgb (vec3 (0.3 + 0.15 * gcRnd, 1., 0.5));
vf = vec2 (256., 2.);
} else {
qh = HexGrid (32. * sqrt3 * ro.zx);
f = max (length (qh.xy) - 0.5, 0.);
vn = vec3 (0., Rot2D (vec2 (1., 0.), 4. * f * f));
vn.zx = vn.z * normalize (qh.xy);
col = vec3 (0.5, 0.45, 0.45);
col = mix (vec3 (0.5, 0.5, 0.3), col, smoothstep (0.036, 0.038, HexGrid (ro.xz).z));
col *= 0.8 + 0.2 * smoothstep (0.03, 0.06, qh.z);
g = Rot2D (g, pi / 6.);
g = Rot2D (g, 2. * pi * ((floor (6. * atan (g.y, - g.x) / (2. * pi) + 0.5)) / 6.));
g = Rot2D (vec2 (g.x + 0.935, abs (g.y)), - pi / 3.);
col *= 0.8 + 0.2 * smoothstep (0.003, 0.006, length (vec2 (abs (g.x) - 0.07, g.y)));
}
spec = 0.1;
sh = ObjSShadow (ro, sunDir);
}
if (vf.x > 0.) vn = VaryNf (vf.x * ro, vn, vf.y);
col = col * (0.2 + 0.2 * max (dot (normalize (- sunDir.xz), vn.xz), 0.) +
0.7 * sh * max (dot (vn, sunDir), 0.)) +
spec * sh * pow (max (dot (normalize (sunDir - rd), vn), 0.), 32.);
} else {
col = (rd.y > 0.) ? SkyCol (rd) : vec3 (0.5, 0.45, 0.45);
}
return clamp (col, 0., 1.);
}
// hack for libretro spec
vec4 iDate = vec4(0.0, 0.0, 0.0, 0.0);
#ifndef MOUSE
// hack for libretro spec
vec4 iMouse = vec4(0.0, 0.0, 0.0, 0.0);
#endif
void mainImage (out vec4 fragColor, in vec2 fragCoord)
{
mat3 vuMat;
vec4 mPtr, dateCur;
vec3 ro, rd;
vec2 canvas, uv, ori, ca, sa, vd, p1, p2;
float el, az, asp, vel, tCyc, tt, a;
canvas = iResolution.xy;
uv = 2. * fragCoord.xy / canvas - 1.;
uv.x *= canvas.x / canvas.y;
tCur = iGlobalTime;
dateCur = iDate;
mPtr = iMouse;
mPtr.xy = mPtr.xy / canvas - 0.5;
vel = 0.12;
tCyc = 4. / vel;
tCur = mod (tCur, 36000.) + floor (2. + floor (dateCur.w / 600.) / tCyc) * tCyc;
p1 = TrackPath (vel * tCur + 0.11);
p2 = TrackPath (vel * tCur - 0.11);
ro.xz = 0.5 * (p1 + p2);
ro.y = 0.09;
vd = p1 - p2;
az = atan (vd.x, vd.y);
el = 0.;
#ifdef MOUSE
if (mPtr.z > 0.) {
az += 2. * pi * mPtr.x;
el += 0.2 * pi * mPtr.y;
}
else
{
a = 0.45 * pi * SmoothBump (0.25, 0.75, 0.12, mod (tCur / (0.25 * tCyc), 1.));
tt = mod (tCur / tCyc, 1.) - 0.375;
az += a * (step (abs (tt + 0.25), 0.125) - step (abs (tt - 0.25), 0.125));
}
#else
a = 0.45 * pi * SmoothBump (0.25, 0.75, 0.12, mod (tCur / (0.25 * tCyc), 1.));
tt = mod (tCur / tCyc, 1.) - 0.375;
az += a * (step (abs (tt + 0.25), 0.125) - step (abs (tt - 0.25), 0.125));
#endif
ori = vec2 (el, az);
ca = cos (ori);
sa = sin (ori);
vuMat = mat3 (ca.y, 0., - sa.y, 0., 1., 0., sa.y, 0., ca.y) *
mat3 (1., 0., 0., 0., ca.x, - sa.x, 0., sa.x, ca.x);
asp = canvas.x / canvas.y;
uv.xy /= 2.5;
rd = vuMat * normalize (vec3 (2. * tan (0.5 * atan (uv.x / asp)) * asp, uv.y, 1.));
dstFar = 50.;
sunDir = normalize (vec3 (0.5, 3., -1.));
fragColor = vec4 (ShowScene (ro, rd), 1.);
}
float PrBoxDf (vec3 p, vec3 b)
{
vec3 d;
d = abs (p) - b;
return min (max (d.x, max (d.y, d.z)), 0.) + length (max (d, 0.));
}
float PrBox2Df (vec2 p, vec2 b)
{
vec2 d;
d = abs (p) - b;
return min (max (d.x, d.y), 0.) + length (max (d, 0.));
}
float PrBoxAn2Df (vec2 p, vec2 b, float w)
{
return max (PrBox2Df (p, vec2 (b + w)), - PrBox2Df (p, vec2 (b - w)));
}
float PrSphDf (vec3 p, float r)
{
return length (p) - r;
}
float PrCylDf (vec3 p, float r, float h)
{
return max (length (p.xy) - r, abs (p.z) - h);
}
float PrCylAnDf (vec3 p, float r, float w, float h)
{
return max (abs (length (p.xy) - r) - w, abs (p.z) - h);
}
float SmoothMin (float a, float b, float r)
{
float h;
h = clamp (0.5 + 0.5 * (b - a) / r, 0., 1.);
return mix (b, a, h) - r * h * (1. - h);
}
float SmoothBump (float lo, float hi, float w, float x)
{
return (1. - smoothstep (hi - w, hi + w, x)) * smoothstep (lo - w, lo + w, x);
}
vec2 Rot2D (vec2 q, float a)
{
return q * cos (a) * vec2 (1., 1.) + q.yx * sin (a) * vec2 (-1., 1.);
}
vec2 PixToHex (vec2 p)
{
vec3 c, r, dr;
c.xz = vec2 ((1./sqrt3) * p.x - (1./3.) * p.y, (2./3.) * p.y);
c.y = - c.x - c.z;
r = floor (c + 0.5);
dr = abs (r - c);
r -= step (dr.yzx, dr) * step (dr.zxy, dr) * dot (r, vec3 (1.));
return r.xz;
}
vec2 HexToPix (vec2 h)
{
return vec2 (sqrt3 * (h.x + 0.5 * h.y), (3./2.) * h.y);
}
vec3 HexGrid (vec2 p)
{
vec2 q;
p -= HexToPix (PixToHex (p));
q = abs (p);
return vec3 (p, 0.5 * sqrt3 - q.x + 0.5 * min (q.x - sqrt3 * q.y, 0.));
}
vec3 HsvToRgb (vec3 c)
{
vec3 p;
p = abs (fract (c.xxx + vec3 (1., 2./3., 1./3.)) * 6. - 3.);
return c.z * mix (vec3 (1.), clamp (p - 1., 0., 1.), c.y);
}
const float cHashM = 43758.54;
float Hashfv2 (vec2 p)
{
return fract (sin (dot (p, vec2 (37., 39.))) * cHashM);
}
vec2 Hashv2v2 (vec2 p)
{
vec2 cHashVA2 = vec2 (37., 39.);
return fract (sin (vec2 (dot (p, cHashVA2), dot (p + vec2 (1., 0.), cHashVA2))) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec2 t, ip, fp;
ip = floor (p);
fp = fract (p);
fp = fp * fp * (3. - 2. * fp);
t = mix (Hashv2v2 (ip), Hashv2v2 (ip + vec2 (0., 1.)), fp.y);
return mix (t.x, t.y, fp.x);
}
float Fbm2 (vec2 p)
{
float f, a;
f = 0.;
a = 1.;
for (int j = 0; j < 5; j ++) {
f += a * Noisefv2 (p);
a *= 0.5;
p *= 2.;
}
return f * (1. / 1.9375);
}
float Fbmn (vec3 p, vec3 n)
{
vec3 s;
float a;
s = vec3 (0.);
a = 1.;
for (int j = 0; j < 5; j ++) {
s += a * vec3 (Noisefv2 (p.yz), Noisefv2 (p.zx), Noisefv2 (p.xy));
a *= 0.5;
p *= 2.;
}
return dot (s, abs (n));
}
vec3 VaryNf (vec3 p, vec3 n, float f)
{
vec3 g;
vec2 e = vec2 (0.1, 0.);
g = vec3 (Fbmn (p + e.xyy, n), Fbmn (p + e.yxy, n), Fbmn (p + e.yyx, n)) - Fbmn (p, n);
return normalize (n + f * (g - n * dot (n, g)));
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

268
procedural/dr2-droplet.slang Normal file
View File

@ -0,0 +1,268 @@
#version 450
// Droplet - dr2 - 2015-09-17
// https://www.shadertoy.com/view/4l2Szm
// Probably liquid mercury (change viewpoint using the mouse).
// "Droplet" by dr2 - 2015
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
const float pi = 3.14159;
const vec4 cHashA4 = vec4 (0., 1., 57., 58.);
const vec3 cHashA3 = vec3 (1., 57., 113.);
const float cHashM = 43758.54;
vec4 Hashv4f (float p)
{
return fract (sin (p + cHashA4) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec2 i = floor (p);
vec2 f = fract (p);
f = f * f * (3. - 2. * f);
vec4 t = Hashv4f (dot (i, cHashA3.xy));
return mix (mix (t.x, t.y, f.x), mix (t.z, t.w, f.x), f.y);
}
float Fbm2 (vec2 p)
{
float f, a;
f = 0.;
a = 1.;
for (int i = 0; i < 5; i ++) {
f += a * Noisefv2 (p);
a *= 0.5;
p *= 2.;
}
return f;
}
float Fbmn (vec3 p, vec3 n)
{
vec3 s;
float a;
s = vec3 (0.);
a = 1.;
for (int i = 0; i < 5; i ++) {
s += a * vec3 (Noisefv2 (p.yz), Noisefv2 (p.zx), Noisefv2 (p.xy));
a *= 0.5;
p *= 2.;
}
return dot (s, abs (n));
}
vec3 VaryNf (vec3 p, vec3 n, float f)
{
vec3 g;
float s;
vec3 e = vec3 (0.1, 0., 0.);
s = Fbmn (p, n);
g = vec3 (Fbmn (p + e.xyy, n) - s,
Fbmn (p + e.yxy, n) - s, Fbmn (p + e.yyx, n) - s);
return normalize (n + f * (g - n * dot (n, g)));
}
float Length4 (vec2 p)
{
p *= p;
p *= p;
return pow (p.x + p.y, 1. / 4.);
}
float Length6 (vec2 p)
{
p *= p * p;
p *= p;
return pow (p.x + p.y, 1. / 6.);
}
float PrSphDf (vec3 p, float s)
{
return length (p) - s;
}
float PrCylDf (vec3 p, float r, float h)
{
return max (length (p.xy) - r, abs (p.z) - h);
}
float PrTorus4Df (vec3 p, float ri, float rc)
{
return Length4 (vec2 (length (p.xz) - rc, p.y)) - ri;
}
vec3 sunDir;
float tCur;
int idObj;
const float dstFar = 100.;
const int idRing = 1, idWat = 2;
vec3 BgCol (vec3 ro, vec3 rd)
{
vec3 col;
float sd, f;
if (rd.y > 0.) {
col = vec3 (0.1, 0.2, 0.4) + 0.2 * pow (1. - max (rd.y, 0.), 8.);
sd = max (dot (rd, sunDir), 0.);
ro.xz += 2. * tCur;
f = Fbm2 (0.1 * (rd.xz * (50. - ro.y) / rd.y + ro.xz));
col += 0.35 * pow (sd, 6.) + 0.65 * min (pow (sd, 256.), 0.3);
col = mix (col, vec3 (1.), clamp (0.8 * f * rd.y + 0.1, 0., 1.));
} else {
f = Fbm2 (0.4 * (ro.xz - ro.y * rd.xz / rd.y));
col = mix ((1. + min (f, 1.)) * vec3 (0.05, 0.1, 0.05),
vec3 (0.1, 0.15, 0.25), pow (1. + rd.y, 5.));
}
return col;
}
float StoneRingDf (vec3 p, float r, float w, float n)
{
return Length6 (vec2 (length (p.xz) - r, p.y)) -
w * (0.2 * pow (abs (sin (atan (p.x, p.z) * n)), 0.25) + 0.8);
}
float ObjDf (vec3 p)
{
vec3 q;
float dMin, d, db, r, s, t;
bool up;
dMin = dstFar;
t = mod (tCur, 10.);
r = abs (sin (2. * pi * 0.1 * t));
q = p;
up = (t < 5.);
q.y -= up ? 2.5 : 0.55;
d = PrTorus4Df (q, 1., r);
q.y -= up ? -0.5 : 0.5;
d = max (PrCylDf (q.xzy, r, 0.5), - d);
if (up) d = max (d, q.y);
q.y -= up ? -0.75 : 0.2;
s = length (q.xz);
q.y -= 0.02 * cos (15. * s - 7. * tCur) * clamp (1. - s / 2.5, 0., 1.) *
clamp (s, 0., 1.);
db = PrCylDf (q.xzy, 2.5, 0.25);
d = up ? min (db, d) : max (db, - d);
if (d < dMin) { dMin = d; idObj = idWat; }
q = p;
s = 1. - sqrt (max (1. - r * r, 0.));
q.y -= 1.2 + (up ? s : - s);
d = PrSphDf (q, 0.3);
d = max (d, 1. - p.y);
if (d < dMin) { dMin = d; idObj = idWat; }
q = p;
q.y -= 1.3;
d = StoneRingDf (q, 2.8, 0.3, 16.);
if (d < dMin) { dMin = d; idObj = idRing; }
return dMin;
}
float ObjRay (vec3 ro, vec3 rd)
{
float dHit, d;
dHit = 0.;
for (int j = 0; j < 100; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < 0.001 || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjNf (vec3 p)
{
vec4 v;
const vec3 e = vec3 (0.001, -0.001, 0.);
v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy),
ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec3 objCol, col, vn;
float dstHit, dif, bk;
int idObjT;
const int nRefl = 3;
for (int k = 0; k < nRefl; k ++) {
idObj = -1;
dstHit = ObjRay (ro, rd);
if (dstHit < dstFar && idObj == idWat) {
ro += rd * dstHit;
rd = reflect (rd, VaryNf (ro, ObjNf (ro), 0.1));
ro += 0.02 * rd;
} else break;
}
if (dstHit < dstFar) {
ro += rd * dstHit;
idObjT = idObj;
vn = ObjNf (ro);
idObj = idObjT;
if (idObj == idRing) {
objCol = vec3 (0.8, 0.6, 0.2);
vn = VaryNf (40. * ro, vn, 2.);
}
bk = max (dot (vn, sunDir * vec3 (-1., 1., -1.)), 0.);
dif = max (dot (vn, sunDir), 0.);
col = objCol * (0.1 + 0.1 * bk + 0.8 * dif +
0.3 * pow (max (0., dot (sunDir, reflect (rd, vn))), 64.));
} else col = BgCol (ro, rd);
return clamp (col, 0., 1.);
}
void mainImage (out vec4 fragColor, in vec2 fragCoord)
{
vec2 canvas = iResolution.xy;
vec2 uv = 2. * fragCoord.xy / canvas - 1.;
uv.x *= canvas.x / canvas.y;
tCur = iGlobalTime;
sunDir = normalize (vec3 (1., 1., 1.));
float el = 0.6;
#ifdef MOUSE
vec4 mPtr = iMouse;
mPtr.xy = mPtr.xy / canvas - 0.5;
if (mPtr.z > 0.) el = clamp (el - mPtr.y, 0.25, 0.8);
#endif
float cEl = cos (el);
float sEl = sin (el);
mat3 vuMat = mat3 (1., 0., 0., 0., cEl, - sEl, 0., sEl, cEl);
vec3 rd = normalize (vec3 (uv, 4.)) * vuMat;
vec3 ro = vec3 (0., 0.7, -10.) * vuMat;
fragColor = vec4 (ShowScene (ro, rd), 1.);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

415
procedural/dr2-hexpo.slang Normal file
View File

@ -0,0 +1,415 @@
#version 450
// "Hexpo" by dr2 - 2018
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
float PrBox2Df (vec2 p, vec2 b);
float PrCylDf (vec3 p, float r, float h);
float SmoothMin (float a, float b, float r);
float SmoothBump (float lo, float hi, float w, float x);
vec2 Rot2D (vec2 q, float a);
vec3 HueToRgb (float c);
float Hashfv2 (vec2 p);
float Fbm2 (vec2 p);
vec3 VaryNf (vec3 p, vec3 n, float f);
vec2 PixToHex (vec2 p);
vec2 HexToPix (vec2 h);
vec3 HexGrid (vec2 p);
vec3 sunDir, qHit;
vec2 gId;
float tCur, dstFar, gcRnd, hgSize;
int idObj;
const float pi = 3.14159, sqrt3 = 1.7320508;
#define DMINQ(id) if (d < dMin) { dMin = d; idObj = id; qHit = q; }
float ObjDf (vec3 p)
{
vec3 q, qq;
float dMin, d, w, s, r, rh, a, s3;
dMin = dstFar;
s3 = 0.5 * sqrt3 * hgSize;
rh = 3.07;
w = 0.1;
p.xz -= HexToPix (gId * hgSize);
r = length (p.xz);
a = (r > 0.) ? atan (p.z, - p.x) / (2. * pi) : 0.;
q = p;
q.xz = Rot2D (q.xz, 2. * pi * ((floor (6. * a + 0.5)) / 6.));
qq = q;
s = 1. - sqrt (1. - smoothstep (0.65, 0.85, q.y));
d = max (max (abs (q.x + 3.) - 0.07, abs (q.y - 0.5) - 0.5),
- PrBox2Df (vec2 (mod (q.z, 0.25) - 0.125, q.y - 0.41), vec2 (0.08 - 0.08 * s, 0.45)));
s = smoothstep (1., 2.2, q.y);
d = min (d, max (max (mix (abs (q.x + 0.5 * rh) - 0.5 * rh, r - 2. - w, s),
- mix (abs (q.x + 0.5 * rh - w) - 0.5 * rh + w, r - 2. + w, s)), abs (q.y - 1.6) - 0.6));
d = min (d, max (abs (r - 2.) - w, abs (q.y - 2.25) - 0.05));
s = smoothstep (2.3, rh, q.y);
d = min (d, max (max (mix (r - 2. - w, r - 1.4 - w, s), - mix (r - 2. + w, r - 1.4 + w, s)), abs (q.y - 2.6) - 0.3));
DMINQ (1);
q.xy -= vec2 (- s3 + 0.06, 0.06);
d = length (q.xy) - 0.05;
DMINQ (2);
q.y -= 1.15 - 0.2 * q.x * q.x;
d = PrCylDf (vec3 (q.xy, abs (q.z) - 0.04).yzx, 0.03, s3 - rh);
DMINQ (3);
q = qq; q.xy -= vec2 (- s3, 1.21);
d = PrCylDf (q.xzy, 0.1, 0.04);
q = qq; q.z = abs (q.z); q -= vec3 (- s3, 0.07, 0.5 * hgSize);
d = min (d, PrCylDf (q.xzy, 0.15, 0.07));
DMINQ (4);
q = qq; q.y -= 2.2;
d = PrCylDf (q.xzy, 0.3, 2.2);
DMINQ (5);
q = qq; q.xy -= vec2 (-0.6, 1.8);
d = PrCylDf (q.xzy, 0.25, 1.8);
DMINQ (6);
return 0.6 * dMin;
}
void SetGrdConf ()
{
gcRnd = Hashfv2 (17.3 * gId);
}
float ObjRay (vec3 ro, vec3 rd)
{
vec3 vri, vf, hv, p;
vec2 edN[3], pM, gIdP;
float dHit, d, s;
if (rd.x == 0.) rd.x = 0.0001;
if (rd.y == 0.) rd.y = 0.0001;
if (rd.z == 0.) rd.z = 0.0001;
edN[0] = vec2 (1., 0.);
edN[1] = 0.5 * vec2 (1., sqrt3);
edN[2] = 0.5 * vec2 (1., - sqrt3);
for (int k = 0; k < 3; k ++) edN[k] *= sign (dot (edN[k], rd.xz));
vri = hgSize / vec3 (dot (rd.xz, edN[0]), dot (rd.xz, edN[1]), dot (rd.xz, edN[2]));
vf = 0.5 * sqrt3 - vec3 (dot (ro.xz, edN[0]), dot (ro.xz, edN[1]),
dot (ro.xz, edN[2])) / hgSize;
pM = HexToPix (PixToHex (ro.xz / hgSize));
hv = (vf + vec3 (dot (pM, edN[0]), dot (pM, edN[1]), dot (pM, edN[2]))) * vri;
s = min (hv.x, min (hv.y, hv.z));
gIdP = vec2 (-999.);
dHit = 0.;
for (int j = 0; j < 320; j ++) {
p = ro + dHit * rd;
gId = PixToHex (p.xz / hgSize);
if (gId.x != gIdP.x || gId.y != gIdP.y) {
gIdP = gId;
SetGrdConf ();
}
d = ObjDf (p);
if (dHit + d < s) dHit += d;
else {
dHit = s + 0.001;
pM += sqrt3 * ((s == hv.x) ? edN[0] : ((s == hv.y) ? edN[1] : edN[2]));
hv = (vf + vec3 (dot (pM, edN[0]), dot (pM, edN[1]), dot (pM, edN[2]))) * vri;
s = min (hv.x, min (hv.y, hv.z));
}
if (d < 0.0005 || dHit > dstFar || p.y < 0. || p.y > 5.) break;
}
if (d >= 0.0005) dHit = dstFar;
return dHit;
}
vec3 ObjNf (vec3 p)
{
vec4 v;
vec2 e = vec2 (0.0001, -0.0001);
v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy), ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
vec2 TrackPath (float t)
{
vec2 r;
float tt;
tt = mod (t, 4.);
if (tt < 1.) r = mix (vec2 (sqrt3 * 0.5, -0.5), vec2 (sqrt3 * 0.5, 0.5), tt);
else if (tt < 2.) r = mix (vec2 (sqrt3 * 0.5, 0.5), vec2 (0., 1.), tt - 1.);
else if (tt < 3.) r = mix (vec2 (0., 1.), vec2 (0., 2.), tt - 2.);
else r = mix (vec2 (0., 2.), vec2 (sqrt3 * 0.5, 2.5), tt - 3.);
r *= hgSize;
r += vec2 (0.001, hgSize * 3. * floor (t / 4.));
return r;
}
vec3 SkyCol (vec3 rd)
{
rd.y = abs (rd.y);
return 0.2 * mix (vec3 (0.2, 0.3, 0.5) + 0.3 * pow (max (dot (rd, sunDir), 0.), 8.), vec3 (1.),
0.2 + 0.8 * rd.y * Fbm2 (2. * rd.xz / max (rd.y, 0.0001)));
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec3 col, gCol, vn, qc, qh;
vec2 vf;
float dstObj, dstGrnd, spec, f, s;
bool isLit;
dstGrnd = (rd.y < 0.) ? - ro.y / rd.y : dstFar;
dstObj = ObjRay (ro, rd);
isLit = true;
if (min (dstObj, dstGrnd) < dstFar) {
vf = vec2 (0.);
ro += min (dstObj, dstGrnd) * rd;
gId = PixToHex (ro.xz / hgSize);
SetGrdConf ();
gCol = HueToRgb (mod (77.7 * gcRnd, 1.));
spec = 0.1;
if (dstObj < dstGrnd) {
vn = ObjNf (ro);
if (idObj == 1) {
qc = ro - vec3 (hgSize * HexToPix (gId).xy, 0.).xzy;
f = dot (vn, normalize (qc));
col = gCol;
vf = vec2 (1024., 0.5);
if (f < 0. || ro.y < 1. && f < 0.6) {
col = 0.8 * mix (vec3 (1.), col, 0.5) * (0.55 - 0.45 * f) * (0.7 +
0.3 * SmoothBump (0.25, 0.75, 0.1, mod (tCur + gcRnd, 1.)));
isLit = false;
} else {
col = 0.2 * mix (vec3 (1.), col, 0.2) * (0.2 + 0.8 * f);
s = atan (qc.z, - qc.x) / (2. * pi);
if (ro.y < 2.6) {
s = SmoothBump (1., 2.5, 0.1, ro.y) * SmoothBump (0.4, 0.6, 0.02, mod (128. * s, 1.)) *
SmoothBump (0.4, 0.6, 0.02, mod (8. * qc.y - 2. * tCur, 1.));
col *= 1. + 5. * s;
} else {
s = smoothstep (2.6, 2.85, ro.y) * SmoothBump (0.4, 0.6, 0.05, mod (32. * s +
2. * (2. * step (gcRnd, 0.5) - 1.) * tCur, 1.));
col *= 1. + 4. * s;
}
isLit = (s > 0.1);
}
} else if (idObj == 2) {
col = 0.8 * gCol * (0.4 + 0.6 * SmoothBump (0.25, 0.75, 0.05, mod (2. * qHit.z + tCur, 1.)));
} else if (idObj == 3) {
col = 0.8 * HueToRgb (mod (0.1 * tCur, 1.)) * (0.4 +
0.6 * SmoothBump (0.25, 0.75, 0.05, mod (4. * qHit.x + 2. * tCur * sign (qHit.z), 1.)));
} else if (idObj == 4) {
col = vec3 (0.7, 0.7, 0.2) * (0.3 + 0.7 * smoothstep (0., 0.4, - dot (vn, rd)));
isLit = false;
} else if (idObj == 5 || idObj == 6) {
col = 0.8 * ((idObj == 5) ? gCol : HueToRgb (mod (mod (77.7 * gcRnd, 1.) + 0.5, 1.)));
if (vn.y < 0.99) col *= (0.4 + 0.6 * SmoothBump (0.25, 0.75, 0.05, mod (8. * qHit.y +
atan (vn.z, vn.x) / (2. * pi) + ((idObj == 5) ? - 4. : 4.) * tCur, 1.)));
else col *= 0.5;
}
} else {
qh = HexGrid (32. * sqrt3 * ro.zx / hgSize);
f = max (length (qh.xy) - 0.5, 0.);
vn = vec3 (0., Rot2D (vec2 (1., 0.), 4. * f * f));
vn.zx = vn.z * normalize (qh.xy);
s = HexGrid (ro.xz / hgSize).z;
col = 0.3 * mix (vec3 (1.), gCol, 0.2) * (0.8 + 0.2 * smoothstep (0.025, 0.03, s)) *
(0.8 + 0.2 * smoothstep (0.03, 0.06, qh.z));
col = mix (col, 0.5 * gCol * (0.7 + 0.3 * SmoothBump (0.25, 0.75, 0.1, mod (tCur + gcRnd, 1.))),
smoothstep (0.1, 0.35, s));
}
if (isLit) {
if (vf.x > 0.) vn = VaryNf (vf.x * ro, vn, vf.y);
col = col * (0.5 + 0.5 * max (dot (vn, sunDir), 0.)) +
spec * pow (max (dot (normalize (sunDir - rd), vn), 0.), 32.);
}
s = min (dstObj, dstGrnd) / dstFar;
col = mix (col * (1. - 0.95 * smoothstep (0.3, 1., s)), SkyCol (rd), smoothstep (0.4, 1., s));
} else {
col = SkyCol (rd);
}
return clamp (col, 0., 1.);
}
void mainImage (out vec4 fragColor, in vec2 fragCoord)
{
mat3 vuMat;
vec4 mPtr, dateCur;
vec3 ro, rd;
vec2 canvas, uv, ori, ca, sa, vd, p1, p2;
float el, az, zmFac, asp, vel, tCyc, tt, s;
canvas = iResolution.xy;
uv = 2. * fragCoord.xy / canvas - 1.;
uv.x *= canvas.x / canvas.y;
tCur = iGlobalTime;
dateCur = iDate;
mPtr = iMouse;
mPtr.xy = mPtr.xy / canvas - 0.5;
hgSize = 5.;
vel = 0.3;
tCyc = 4. / vel;
tCur = mod (tCur, 36000.) + floor (2. + floor (dateCur.w / 600.) / tCyc + 1.) * tCyc;
p1 = TrackPath (vel * tCur + 0.3);
p2 = TrackPath (vel * tCur - 0.3);
s = SmoothBump (0.25, 0.75, 0.02, mod (tCur / (4. * tCyc), 1.));
ro = vec3 (0.5 * (p1 + p2), 0.7 + 3.3 * s).xzy;
vd = p1 - p2;
az = atan (vd.x, vd.y);
el = -0.1 * pi * s;
zmFac = 1.5 + s;
if (mPtr.z > 0.) {
az += 2. * pi * mPtr.x;
el += 0.5 * pi * mPtr.y;
}
ori = vec2 (el, az);
ca = cos (ori);
sa = sin (ori);
vuMat = mat3 (ca.y, 0., - sa.y, 0., 1., 0., sa.y, 0., ca.y) *
mat3 (1., 0., 0., 0., ca.x, - sa.x, 0., sa.x, ca.x);
asp = canvas.x / canvas.y;
dstFar = 300.;
uv.xy /= zmFac;
rd = vuMat * normalize (vec3 (2. * tan (0.5 * atan (uv.x / asp)) * asp, uv.y, 1.));
sunDir = normalize (vec3 (0.5, 1., -1.));
fragColor = vec4 (ShowScene (ro, rd), 1.);
}
float PrBox2Df (vec2 p, vec2 b)
{
vec2 d;
d = abs (p) - b;
return min (max (d.x, d.y), 0.) + length (max (d, 0.));
}
float PrCylDf (vec3 p, float r, float h)
{
return max (length (p.xy) - r, abs (p.z) - h);
}
float SmoothMin (float a, float b, float r)
{
float h;
h = clamp (0.5 + 0.5 * (b - a) / r, 0., 1.);
return mix (b, a, h) - r * h * (1. - h);
}
float SmoothBump (float lo, float hi, float w, float x)
{
return (1. - smoothstep (hi - w, hi + w, x)) * smoothstep (lo - w, lo + w, x);
}
vec2 Rot2D (vec2 q, float a)
{
return q * cos (a) * vec2 (1., 1.) + q.yx * sin (a) * vec2 (-1., 1.);
}
vec2 PixToHex (vec2 p)
{
vec3 c, r, dr;
c.xz = vec2 ((1./sqrt3) * p.x - (1./3.) * p.y, (2./3.) * p.y);
c.y = - c.x - c.z;
r = floor (c + 0.5);
dr = abs (r - c);
r -= step (dr.yzx, dr) * step (dr.zxy, dr) * dot (r, vec3 (1.));
return r.xz;
}
vec2 HexToPix (vec2 h)
{
return vec2 (sqrt3 * (h.x + 0.5 * h.y), (3./2.) * h.y);
}
vec3 HexGrid (vec2 p)
{
vec2 q;
p = p - HexToPix (PixToHex (p));
q = abs (p);
return vec3 (p, 0.5 * sqrt3 - q.x + 0.5 * min (q.x - sqrt3 * q.y, 0.));
}
vec3 HueToRgb (float c)
{
return clamp (abs (fract (c + vec3 (1., 2./3., 1./3.)) * 6. - 3.) - 1., 0., 1.);
}
const float cHashM = 43758.54;
float Hashfv2 (vec2 p)
{
return fract (sin (dot (p, vec2 (37., 39.))) * cHashM);
}
vec2 Hashv2v2 (vec2 p)
{
vec2 cHashVA2 = vec2 (37., 39.);
return fract (sin (vec2 (dot (p, cHashVA2), dot (p + vec2 (1., 0.), cHashVA2))) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec2 t, ip, fp;
ip = floor (p);
fp = fract (p);
fp = fp * fp * (3. - 2. * fp);
t = mix (Hashv2v2 (ip), Hashv2v2 (ip + vec2 (0., 1.)), fp.y);
return mix (t.x, t.y, fp.x);
}
float Fbm2 (vec2 p)
{
float f, a;
f = 0.;
a = 1.;
for (int j = 0; j < 5; j ++) {
f += a * Noisefv2 (p);
a *= 0.5;
p *= 2.;
}
return f * (1. / 1.9375);
}
float Fbmn (vec3 p, vec3 n)
{
vec3 s;
float a;
s = vec3 (0.);
a = 1.;
for (int j = 0; j < 5; j ++) {
s += a * vec3 (Noisefv2 (p.yz), Noisefv2 (p.zx), Noisefv2 (p.xy));
a *= 0.5;
p *= 2.;
}
return dot (s, abs (n));
}
vec3 VaryNf (vec3 p, vec3 n, float f)
{
vec3 g;
vec2 e = vec2 (0.1, 0.);
g = vec3 (Fbmn (p + e.xyy, n), Fbmn (p + e.yxy, n), Fbmn (p + e.yyx, n)) - Fbmn (p, n);
return normalize (n + f * (g - n * dot (n, g)));
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

740
procedural/dr2-ocean-structure.slang Normal file
View File

@ -0,0 +1,740 @@
#version 450
// Ocean Structure - dr2 - 2017-11-01
// https://www.shadertoy.com/view/ltBczc
// Abstract construction with fire, smoke, reflections and aurora.
// Look around using mouse; mouse to lower-right corner for daylight view.
// "Ocean Structure" by dr2 - 2017
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define REAL_WAVE 0 // real (=1) or fake (=0, less work) water waves
#define N_REFL 3 // number of reflections (1-4, 0 = none)
float PrBoxDf (vec3 p, vec3 b);
float PrSphDf (vec3 p, float s);
float PrSphAnDf (vec3 p, float r, float w);
float PrCylDf (vec3 p, float r, float h);
float PrTorusDf (vec3 p, float ri, float rc);
float PrCapsDf (vec3 p, float r, float h);
float PrCapsAnDf (vec3 p, float r, float w, float h);
float PrFlatCylDf (vec3 p, float rhi, float rlo, float h);
float Noisefv2 (vec2 p);
float Noisefv3 (vec3 p);
float Fbm1 (float p);
float Fbm2 (vec2 p);
float Fbm3 (vec3 p);
vec3 VaryNf (vec3 p, vec3 n, float f);
vec3 HsvToRgb (vec3 c);
vec2 Rot2D (vec2 q, float a);
vec3 qHit, sunDir, smkPos;
float dstFar, tCur, smkRadEx, smkRadIn, smkPhs, smkHt, tWav;
int idObj;
bool isNite;
const int idBase = 1, idPlat = 2, isShel = 3, idFrm = 4, idDway = 5,
idTwr = 6, idBrg = 7, idBrCab = 8, idRdw = 9;
const float pi = 3.14159;
float BridgeDf (vec3 p, float dMin)
{
float cbRad = 0.06;
vec3 q, qq;
float d, cLen, wRd;
wRd = 1.;
q = p; q.x = abs (q.x) - wRd; q.y -= -0.3;
d = PrBoxDf (q, vec3 (0.15, 5., 0.15));
q = p; q.y -= 4.85;
d = min (d, PrBoxDf (q, vec3 (wRd + 0.15, 0.15, 0.15)));
if (d < dMin) { dMin = d; qHit = q; idObj = idBrg; }
qq = p; qq.x = abs (qq.x) - wRd + 0.07; qq.z = abs (qq.z);
q = qq; q.y -= 4.92;
q.yz = Rot2D (q.yz, -0.1 * pi);
q.z -= 9.5;
d = PrCylDf (q, cbRad, 9.5);
q = qq; q.y -= 4.82;
q.yz = Rot2D (q.yz, -0.15 * pi);
q.z -= 6.4;
d = min (d, PrCylDf (q, cbRad, 6.4));
q = qq; q.y -= 4.77;
q.yz = Rot2D (q.yz, -0.26 * pi);
q.z -= 4.;
d = min (d, PrCylDf (q, cbRad, 4.));
if (d < dMin) { dMin = d; qHit = q; idObj = idBrCab; }
return dMin;
}
float CentStrucDf (vec3 p, float dMin, float ar)
{
float cRad = 6., cLen = 8., ww = 0.03, wThk = 0.05,
doorHt = 1.6, doorWd = 1.4;
vec3 q;
vec2 qo;
float d, dd;
q = p; q.y -= -1.05;
d = PrCylDf (q.xzy, 8.5, 0.15);
if (d < dMin) { dMin = d; qHit = q; idObj = idPlat; }
d = PrTorusDf (vec3 (q.xz, abs (abs (q.y - 1.1) - 0.4) - 0.2), 0.03, 8.5);
q.xz = Rot2D (q.xz, 2. * pi * (floor (16. * ar) + 0.5) / 16.);
q.xy -= vec2 (-8.5, 0.9);
d = min (d, PrCylDf (q.xzy, 0.05, 0.82));
if (d < dMin) { dMin = d; qHit = q; idObj = idBrCab; }
q = p;
qo = Rot2D (q.xz, 2. * pi * (floor (4. * ar) + 0.5) / 4.);
q.xz = qo; q.y -= cLen + 1.2 * doorHt - 9.;
dd = PrFlatCylDf (q.yzx, doorHt, doorWd, 0.);
q = p; q.y -= cLen - 9.;
d = max (max (max (PrCapsAnDf (q.xzy, cRad, wThk, cLen), - q.y), q.y - 1.635 * cLen), - dd);
if (d < dMin) { dMin = d; qHit = q; idObj = isShel; }
q.xz = Rot2D (q.xz, 2. * pi * (floor (8. * ar) + 0.5) / 8.);
d = max (max (max (PrCapsAnDf (q.xzy, cRad, 0.2, cLen),
min (abs (mod (q.y, 2.) - 1.) - 0.1,
dot (vec2 (q.x, abs (q.z)), vec2 (sin (0.04 * 2. * pi / 16.), cos (0.04 * 2. * pi / 16.))))),
- q.y), - dd);
if (d < dMin) { dMin = d; qHit = q; idObj = idFrm; }
q = p; q.xz = qo; q.xy -= vec2 (-0.98 * cRad, cLen + 1.2 * doorHt - 9.);
d = max (max (max (PrFlatCylDf (q.yzx, doorHt, doorWd, 0.1 * cRad),
- PrFlatCylDf (q.yzx, doorHt - ww, doorWd - ww, 0.)),
- (q.y + 2. * doorHt - ww - wThk)), - (q.y + 1.2 * doorHt));
if (d < dMin) { dMin = d; qHit = q; idObj = idDway; }
return dMin;
}
float CornStrucDf (vec3 p, float dMin)
{
vec3 q;
float d, a;
q = p; q.y -= -1.2;
d = PrCylDf (q.xzy, 3.2, 0.15);
if (d < dMin) { dMin = d; qHit = q; idObj = idPlat; }
q = p; q.y -= 1.;
d = max (PrCapsAnDf (q.xzy, 2.5, 0.1, 3.), -2.2 - q.y);
q = p; q.y -= 7.;
d = min (d, max (PrCapsDf (q.xzy, 0.7, 2.), -1. - q.y));
q = p;
a = (length (q.xz) > 0.) ? atan (q.z, - q.x) / (2. * pi) : 0.;
q.xz = Rot2D (q.xz, 2. * pi * (floor (4. * a + 0.5) / 4.));
d = max (d, - PrFlatCylDf (q.yzx, 1.5, 1., 0.));
q = p;
q.xz = Rot2D (q.xz, 2. * pi * (floor (16. * a) + 0.5) / 16.);
q.y -= 4.3;
d = max (d, - (length (max (abs (q.yz) - vec2 (0.6, 0.08), 0.)) - 0.2));
if (d < dMin) { dMin = d; qHit = q; idObj = idTwr; }
return dMin;
}
float ObjDf (vec3 p)
{
vec3 q;
float d, dMin, hs, wRd, ar;
dMin = dstFar;
hs = 5.;
q = p; q.xz = abs (q.xz) - 4.;
d = max (PrSphAnDf (q, 4.85, 0.15), - min (3.9 - q.y, q.y));
q.y -= 0.5;
d = max (d, 2.2 - min (length (q.yz), length (q.xy)));
if (d < dMin) { dMin = d; qHit = q; idObj = idBase; }
q = p; q.xz = abs (q.xz) - 20.;
d = max (PrSphAnDf (q, 4.85, 0.15), - min (3.9 - q.y, q.y));
q.y -= 0.5;
d = max (d, 2.2 - min (length (q.yz), length (q.xy)));
if (d < dMin) { dMin = d; qHit = q; idObj = idBase; }
wRd = 1.;
q = p; q.xz = abs (q.xz) - 20.7 + wRd;
d = max (max (length (max (q.xz - wRd, 0.)) - 0.3,
- (length (max (q.xz + wRd, 0.)) - 0.3)), abs (q.y - hs + 1.) - 0.1);
if (d < dMin) { dMin = d; qHit = q; idObj = idRdw; }
q = p;
ar = (length (p.xz) > 0.) ? atan (p.z, - p.x) / (2. * pi) : 0.;
q.y -= hs;
dMin = CentStrucDf (q, dMin, ar);
q = p; q.y -= hs; q.xz = abs (q.xz) - vec2 (20.);
dMin = CornStrucDf (q, dMin);
q = p; q.y -= hs;
q.xz = Rot2D (q.xz, 2. * pi * (floor (4. * ar + 0.5) / 4.));
q.x += 20.;
dMin = BridgeDf (q, dMin);
return dMin;
}
float ObjRay (vec3 ro, vec3 rd)
{
float dHit, d;
dHit = 0.;
for (int j = 0; j < 120; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < 0.001 || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjNf (vec3 p)
{
vec4 v;
vec3 e = vec3 (0.001, -0.001, 0.);
v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy), ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
float WaveHt (vec2 p)
{
mat2 qRot = mat2 (0.8, -0.6, 0.6, 0.8);
vec4 t4, v4;
vec2 t;
float wFreq, wAmp, ht;
wFreq = 1.;
wAmp = 1.;
ht = 0.;
for (int j = 0; j < 3; j ++) {
p *= qRot;
t = tWav * vec2 (1., -1.);
t4 = (p.xyxy + t.xxyy) * wFreq;
t = vec2 (Noisefv2 (t4.xy), Noisefv2 (t4.zw));
t4 += 2. * t.xxyy - 1.;
v4 = (1. - abs (sin (t4))) * (abs (sin (t4)) + abs (cos (t4)));
ht += wAmp * dot (pow (1. - sqrt (v4.xz * v4.yw), vec2 (8.)), vec2 (1.));
wFreq *= 2.;
wAmp *= 0.5;
}
return ht;
}
vec3 WaveNf (vec3 p, float d)
{
vec3 vn;
vec2 e;
e = vec2 (max (0.01, 0.005 * d * d), 0.);
p *= 0.3;
vn.xz = 0.4 * (WaveHt (p.xz) - vec2 (WaveHt (p.xz + e.xy), WaveHt (p.xz + e.yx)));
vn.y = e.x;
return normalize (vn);
}
#if REAL_WAVE
float WaveRay (vec3 ro, vec3 rd)
{
vec3 p;
float dHit, h, s, sLo, sHi, f1, f2;
dHit = dstFar;
f1 = 0.4;
f2 = 0.3;
s = max (- (ro.y - 1.2 * f1) / rd.y, 0.);
sLo = s;
for (int j = 0; j < 80; j ++) {
p = ro + s * rd;
h = p.y - f1 * WaveHt (f2 * p.xz);
if (h < 0.) break;
sLo = s;
s += max (0.3, h) + 0.005 * s;
if (s >= dstFar) break;
}
if (h < 0.) {
sHi = s;
for (int j = 0; j < 5; j ++) {
s = 0.5 * (sLo + sHi);
p = ro + s * rd;
h = step (0., p.y - f1 * WaveHt (f2 * p.xz));
sLo += h * (s - sLo);
sHi += (1. - h) * (s - sHi);
}
dHit = sHi;
}
return dHit;
}
#endif
float SmokeDens (vec3 p)
{
mat2 rMat;
vec3 q, u;
float f;
f = PrTorusDf (p.xzy, smkRadIn, smkRadEx);
if (f < 0.) {
q = p.xzy / smkRadEx;
u = normalize (vec3 (q.xy, 0.));
q -= u;
rMat = mat2 (vec2 (u.x, - u.y), u.yx);
q.xy = rMat * q.xy;
q.xz = Rot2D (q.xz, 2.5 * tCur);
q.xy = q.xy * rMat;
q += u;
q.xy = Rot2D (q.xy, 0.1 * tCur);
f = smoothstep (0., smkRadIn, - f) * Fbm3 (10. * q);
} else f = 0.;
return f;
}
vec4 SmokeCol (vec3 ro, vec3 rd, float dstObj)
{
vec4 col4;
vec3 q;
float densFac, dens, d, h, sh;
d = 0.;
for (int j = 0; j < 150; j ++) {
q = ro + d * rd;
q.xz = abs (q.xz);
q -= smkPos;
h = PrTorusDf (q.xzy, smkRadIn, smkRadEx);
d += h;
if (h < 0.001 || d > dstFar) break;
}
col4 = vec4 (0.);
if (d < min (dstObj, dstFar)) {
densFac = 1.45 * (1.08 - pow (smkPhs, 1.5));
for (int j = 0; j < 150; j ++) {
q = ro + d * rd;
q.xz = abs (q.xz);
q -= smkPos;
dens = SmokeDens (q);
sh = 0.3 + 0.7 * smoothstep (-0.3, 0.1, dens - SmokeDens (q + 0.1 * sunDir));
col4 += densFac * dens * (1. - col4.w) * vec4 (sh * vec3 (0.9) - col4.rgb, 0.3);
d += 2.2 * smkRadEx / 150.;
if (col4.w > 0.99 || d > dstFar) break;
}
}
if (isNite) col4.rgb *= vec3 (0.3, 0.4, 0.3);
return col4;
}
vec4 ObjCol (vec3 n)
{
vec4 col;
if (idObj == idBase) col = vec4 (0.3, 0.4, 0.1, 0.1);
else if (idObj == idPlat) col = vec4 (0.4, 0.4, 0.3, 0.1);
else if (idObj == isShel) col = vec4 (0.5, 0.5, 0.5, 0.3);
else if (idObj == idFrm) col = vec4 (0.8, 0.8, 0.9, 0.5);
else if (idObj == idDway) col = vec4 (0.7, 0.8, 0.7, 0.3);
else if (idObj == idTwr) col = vec4 (0.7, 0.7, 0.6, 0.3);
else if (idObj == idBrg) col = vec4 (1., 0.3, 0.3, 0.3);
else if (idObj == idBrCab) col = vec4 (0.9, 0.9, 1., 0.5);
else if (idObj == idRdw) col = vec4 (0.4, 0.3, 0.3, 0.1);
return col;
}
vec4 AurCol (vec3 ro, vec3 rd)
{
vec4 col, mCol;
vec3 p, dp;
float ar;
dp = rd / rd.y;
p = ro + (40. - ro.y) * dp;
col = vec4 (0.);
mCol = vec4 (0.);
tWav = 0.05 * tCur;
for (float ns = 0.; ns < 50.; ns ++) {
p += dp;
ar = 0.05 - clamp (0.06 * WaveHt (0.01 * p.xz), 0., 0.04);
mCol = mix (mCol, ar * vec4 (HsvToRgb (vec3 (0.34 + 0.007 * ns, 1., 1. - 0.02 * ns)), 1.), 0.5);
col += mCol;
}
return col;
}
vec3 NtSkyCol (vec3 rd)
{
vec3 rds;
rds = floor (2000. * rd);
rds = 0.00015 * rds + 0.1 * Noisefv3 (0.0005 * rds.yzx);
for (int j = 0; j < 19; j ++) rds = abs (rds) / dot (rds, rds) - 0.9;
return 0.3 * vec3 (1., 1., 0.9) * min (1., 0.5e-3 * pow (min (6., length (rds)), 5.));
}
vec3 BgCol (vec3 ro, vec3 rd)
{
vec3 col;
float f, a;
if (rd.y > 0.) {
a = atan (rd.x, - rd.z);
if (rd.y < 0.03 * Fbm1 (32. * a) + 0.005)
col = (isNite ? vec3 (0.07, 0.1, 0.07) : vec3 (0.4, 0.5, 0.7)) * (1. - 0.3 * Fbm2 (128. * vec2 (a, rd.y)));
else {
if (isNite) {
vec4 aCol = AurCol (ro, rd);
col = (1. - 0.5 * aCol.a) * NtSkyCol (rd) + 0.6 * aCol.rgb;
} else {
ro.xz += 2. * tCur;
col = vec3 (0.2, 0.3, 0.6) + 0.2 * (1. - max (rd.y, 0.)) +
0.1 * pow (max (dot (rd, sunDir), 0.), 16.);
f = Fbm2 (0.02 * (ro.xz + rd.xz * (100. - ro.y) / max (rd.y, 0.01)));
col = mix (col, vec3 (1.), 0.2 + 0.8 * f * rd.y);
}
}
} else {
col = vec3 (0.6, 0.5, 0.3);
if (- ro.y / rd.y < dstFar) {
ro += - (ro.y / rd.y) * rd;
col *= 1.1 - 0.2 * Noisefv2 (30. * ro.xz);
}
col = mix (col, 0.9 * (vec3 (0.4, 0.2, 0.1) + 0.2) + 0.1, pow (1. + rd.y, 5.));
}
return col;
}
vec4 GlowCol (vec3 ro, vec3 rd, float dstObj)
{
vec3 gloDir;
float gloDist, wGlow, s;
wGlow = 0.;
for (float j = 0.; j < 4.; j ++) {
gloDir = vec3 (20., 9.3, 20.) * (1. - 2. * vec3 (floor (j / 2.), 0., mod (j, 2.))) - ro;
gloDist = length (gloDir);
s = dot (rd, normalize (gloDir));
if (s > 0. && gloDist < dstObj) wGlow += 1. - smoothstep (1., 2., sqrt (1. - s * s) * gloDist);
}
gloDir = vec3 (0., 15.5, 0.) - ro;
gloDist = length (gloDir);
s = dot (rd, normalize (gloDir));
if (s > 0. && gloDist < dstObj) wGlow += 1. - smoothstep (2., 3., sqrt (1. - s * s) * gloDist);
return (0.6 + 0.4 * sin (0.3 * 2. * pi * tCur)) * clamp (wGlow, 0., 1.) * vec4 (1., 0.5, 0.3, 1.);
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec4 objCol, smkCol, smkColR, smkColW, glwCol, glwColR, glwColW;
vec3 col, vn;
float dstObj, dstWat, reflCol;
bool wRefl;
col = vec3 (0.2, 0.2, 0.);
wRefl = false;
dstObj = ObjRay (ro, rd);
smkCol = SmokeCol (ro, rd, dstObj);
glwCol = GlowCol (ro, rd, dstObj);
glwColR = vec4 (0.);
glwColW = vec4 (0.);
smkColR = vec4 (0.);
smkColW = vec4 (0.);
tWav = 0.4 * tCur;
reflCol = 1.;
if (N_REFL >= 2 && dstObj < dstFar && idObj == isShel) {
if (length (qHit.xz) > 6. || qHit.y >= 8.8) {
ro += dstObj * rd;
vn = ObjNf (ro);
rd = reflect (rd, vn);
ro += 0.01 * rd;
dstObj = ObjRay (ro, rd);
smkColR = SmokeCol (ro, rd, dstObj);
glwColR = GlowCol (ro, rd, dstObj);
reflCol *= 0.9;
}
}
if (N_REFL >= 1 && rd.y < 0.) {
#if REAL_WAVE
dstWat = WaveRay (ro, rd);
#else
dstWat = - ro.y / rd.y;
#endif
if (dstWat < min (dstObj, dstFar)) {
wRefl = true;
ro += dstWat * rd;
vn = WaveNf (ro, dstWat);
rd = reflect (rd, vn);
ro += 0.01 * rd;
dstObj = ObjRay (ro, rd);
smkColW = SmokeCol (ro, rd, dstObj);
glwColW = GlowCol (ro, rd, dstObj);
if (N_REFL >= 3 && dstObj < dstFar && idObj == isShel) {
ro += dstObj * rd;
vn = ObjNf (ro);
rd = reflect (rd, vn);
if (N_REFL == 4) {
ro += 0.01 * rd;
dstObj = ObjRay (ro, rd);
} else {
dstObj = dstFar;
}
}
reflCol *= 0.7;
}
}
if (dstObj < dstFar) {
ro += dstObj * rd;
vn = ObjNf (ro);
if (idObj == idRdw) vn = VaryNf (5. * qHit, vn, 1.);
else if (idObj == idBase) vn = VaryNf (2. * floor (16. * qHit), vn, 2.);
objCol = ObjCol (vn);
if (isNite) col = objCol.rgb * vec3 (0.3, 0.35, 0.3) * (0.2 + 0.8 * max (0.,vn.y));
else col = objCol.rgb * (0.2 + 0.8 * max (0., max (dot (vn, sunDir), 0.))) +
objCol.a * pow (max (dot (normalize (sunDir - rd), vn), 0.), 64.);
} else if (rd.y > 0.) {
col = BgCol (ro, rd);
} else {
#if N_REFL == 0
dstWat = - ro.y / rd.y;
#endif
col = BgCol (ro + dstWat * rd, reflect (rd, vec3 (0., 1., 0.)));
reflCol = 0.7;
}
col = clamp (reflCol * col, 0., 1.);
col = mix (col, glwCol.rgb, glwCol.a);
col = mix (col, glwColR.rgb, glwColR.a);
col = mix (col, smkCol.rgb, smkCol.a);
col = mix (col, smkColR.rgb, smkColR.a);
if (wRefl) {
col = mix (col, reflCol * glwColW.rgb, glwColW.a);
col = mix (col, reflCol * smkColW.rgb, smkColW.a);
col = mix (mix (vec3 (0., 0.1, 0.), vec3 (0., 0.05, 0.05),
smoothstep (0.4, 0.6, Fbm2 (0.5 * ro.xz))), col, 1. - pow (abs (rd.y), 4.));
}
return clamp (col, 0., 1.);
}
void mainImage (out vec4 fragColor, in vec2 fragCoord)
{
mat3 vuMat;
#ifdef MOUSE
vec4 mPtr;
#endif
vec3 ro, rd;
vec2 uv, ori, ca, sa;
float el, az;
uv = 2. * fragCoord.xy / iResolution.xy - 1.;
uv.x *= iResolution.x / iResolution.y;
tCur = iGlobalTime;
#ifdef MOUSE
mPtr = iMouse;
mPtr.xy = mPtr.xy / iResolution.xy - 0.5;
#endif
smkPhs = mod (0.15 * tCur + 0.3, 1.);
smkPos = vec3 (20., 9. + 10. * smkPhs, 20.);
smkRadIn = 0.6 * (0.1 + 0.9 * smoothstep (0.01, 0.1, smkPhs));
smkRadEx = smkRadIn + 2.5;
dstFar = 140.;
isNite = true;
az = 0.33 * pi;
el = -0.016 * pi;
#ifdef MOUSE
if (mPtr.z > 0.) {
if (mPtr.x > 0.45 && mPtr.y < -0.45) isNite = false;
else {
az += pi * mPtr.x;
el += 0.05 * pi * mPtr.y;
}
} else {
az += 0.002 * pi * tCur;
el += 0.01 * pi * sin (0.01 * pi * tCur);
}
#else
az += 0.002 * pi * tCur;
el += 0.01 * pi * sin (0.01 * pi * tCur);
#endif
el = clamp (el, -0.4 * pi, -0.01 * pi);
ori = vec2 (el, az);
ca = cos (ori);
sa = sin (ori);
vuMat = mat3 (ca.y, 0., - sa.y, 0., 1., 0., sa.y, 0., ca.y) *
mat3 (1., 0., 0., 0., ca.x, - sa.x, 0., sa.x, ca.x);
ro = vuMat * vec3 (0., 10., -100.);
rd = vuMat * normalize (vec3 (uv, 4.2));
sunDir = vuMat * normalize (vec3 (1., 1., -1.));
fragColor = vec4 (ShowScene (ro, rd), 1.);
}
float PrBoxDf (vec3 p, vec3 b)
{
vec3 d;
d = abs (p) - b;
return min (max (d.x, max (d.y, d.z)), 0.) + length (max (d, 0.));
}
float PrSphDf (vec3 p, float s)
{
return length (p) - s;
}
float PrSphAnDf (vec3 p, float r, float w)
{
return abs (length (p) - r) - w;
}
float PrCylDf (vec3 p, float r, float h)
{
return max (length (p.xy) - r, abs (p.z) - h);
}
float PrCapsDf (vec3 p, float r, float h)
{
return length (p - vec3 (0., 0., h * clamp (p.z / h, -1., 1.))) - r;
}
float PrCapsAnDf (vec3 p, float r, float w, float h)
{
p.z = abs (p.z);
return max (length (p - vec3 (0., 0., min (p.z, h + w))) - r,
- length (p - vec3 (0., 0., min (p.z, h - w))) + r) - w;
}
float PrFlatCylDf (vec3 p, float rhi, float rlo, float h)
{
float d;
d = length (p.xy - vec2 (rhi * clamp (p.x / rhi, -1., 1.), 0.)) - rlo;
if (h > 0.) d = max (d, abs (p.z) - h);
return d;
}
float PrTorusDf (vec3 p, float ri, float rc)
{
return length (vec2 (length (p.xy) - rc, p.z)) - ri;
}
const float cHashM = 43758.54;
vec2 Hashv2f (float p)
{
return fract (sin (p + vec2 (0., 1.)) * cHashM);
}
vec2 Hashv2v2 (vec2 p)
{
vec2 cHashVA2 = vec2 (37., 39.);
return fract (sin (vec2 (dot (p, cHashVA2), dot (p + vec2 (1., 0.), cHashVA2))) * cHashM);
}
vec4 Hashv4v3 (vec3 p)
{
vec3 cHashVA3 = vec3 (37., 39., 41.);
vec2 e = vec2 (1., 0.);
return fract (sin (vec4 (dot (p + e.yyy, cHashVA3), dot (p + e.xyy, cHashVA3),
dot (p + e.yxy, cHashVA3), dot (p + e.xxy, cHashVA3))) * cHashM);
}
float Noiseff (float p)
{
vec2 t;
float ip, fp;
ip = floor (p);
fp = fract (p);
fp = fp * fp * (3. - 2. * fp);
t = Hashv2f (ip);
return mix (t.x, t.y, fp);
}
float Noisefv2 (vec2 p)
{
vec2 t, ip, fp;
ip = floor (p);
fp = fract (p);
fp = fp * fp * (3. - 2. * fp);
t = mix (Hashv2v2 (ip), Hashv2v2 (ip + vec2 (0., 1.)), fp.y);
return mix (t.x, t.y, fp.x);
}
float Noisefv3 (vec3 p)
{
vec4 t;
vec3 ip, fp;
ip = floor (p);
fp = fract (p);
fp *= fp * (3. - 2. * fp);
t = mix (Hashv4v3 (ip), Hashv4v3 (ip + vec3 (0., 0., 1.)), fp.z);
return mix (mix (t.x, t.y, fp.x), mix (t.z, t.w, fp.x), fp.y);
}
float Fbm1 (float p)
{
float f, a;
f = 0.;
a = 1.;
for (int i = 0; i < 5; i ++) {
f += a * Noiseff (p);
a *= 0.5;
p *= 2.;
}
return f * (1. / 1.9375);
}
float Fbm2 (vec2 p)
{
float f, a;
f = 0.;
a = 1.;
for (int i = 0; i < 5; i ++) {
f += a * Noisefv2 (p);
a *= 0.5;
p *= 2.;
}
return f * (1. / 1.9375);
}
float Fbm3 (vec3 p)
{
float f, a;
f = 0.;
a = 1.;
for (int i = 0; i < 5; i ++) {
f += a * Noisefv3 (p);
a *= 0.5;
p *= 2.;
}
return f * (1. / 1.9375);
}
float Fbmn (vec3 p, vec3 n)
{
vec3 s;
float a;
s = vec3 (0.);
a = 1.;
for (int i = 0; i < 5; i ++) {
s += a * vec3 (Noisefv2 (p.yz), Noisefv2 (p.zx), Noisefv2 (p.xy));
a *= 0.5;
p *= 2.;
}
return dot (s, abs (n));
}
vec3 VaryNf (vec3 p, vec3 n, float f)
{
vec3 g;
vec2 e = vec2 (0.1, 0.);
g = vec3 (Fbmn (p + e.xyy, n), Fbmn (p + e.yxy, n), Fbmn (p + e.yyx, n)) - Fbmn (p, n);
return normalize (n + f * (g - n * dot (n, g)));
}
vec3 HsvToRgb (vec3 c)
{
vec3 p;
p = abs (fract (c.xxx + vec3 (1., 2./3., 1./3.)) * 6. - 3.);
return c.z * mix (vec3 (1.), clamp (p - 1., 0., 1.), c.y);
}
vec2 Rot2D (vec2 q, float a)
{
return q * cos (a) + q.yx * sin (a) * vec2 (-1., 1.);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

414
procedural/dr2-rainbow-cavern.slang Normal file
View File

@ -0,0 +1,414 @@
#version 450
// Rainbow Cavern - dr2 - 2017-06-01
// https://www.shadertoy.com/view/XsfBWM
// Underground boat ride (mouseable)
// "Rainbow Cavern" by dr2 - 2017
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define USE_BMAP true
//#define USE_BMAP false // for weaker GPUs
float PrSphDf (vec3 p, float r);
float PrCapsDf (vec3 p, float r, float h);
float SmoothBump (float lo, float hi, float w, float x);
vec2 Rot2D (vec2 q, float a);
float Hashfv3 (vec3 p);
vec3 Hashv3f (float p);
vec3 VaryNf (vec3 p, vec3 n, float f);
vec4 vcId;
vec3 ltPos[2], boatPos[2];
float boatAng[2], dstFar, tCur, htWat, dstBMap;
int idObj;
bool uWat, hitWat;
const int idBoat = 1, idBLamp = 2, idFLamp = 3;
const float pi = 3.14159;
float ObjDf (vec3 p)
{
vec3 q;
float dMin, d;
dMin = dstFar;
for (int k = 0; k < 2; k ++) {
q = p - boatPos[k];
q.xz = Rot2D (q.xz, boatAng[k]);
d = max (PrCapsDf (q, 0.11, 0.25),
- PrCapsDf (q + vec3 (0., -0.02, 0.), 0.1, 0.24));
if (d < dMin) { dMin = d; idObj = idBoat; }
q.y -= 0.1;
q.z -= 0.3;
d = PrSphDf (q, 0.01);
if (d < dMin) { dMin = d; idObj = idFLamp; }
q.z -= -0.6;
d = PrSphDf (q, 0.01);
if (d < dMin) { dMin = d; idObj = idBLamp; }
}
return dMin;
}
float ObjRay (vec3 ro, vec3 rd)
{
float dHit, d;
dHit = 0.;
for (int j = 0; j < 100; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < 0.001 || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjNf (vec3 p)
{
vec4 v;
vec3 e = vec3 (0.001, -0.001, 0.);
v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy),
ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
float VPoly (vec3 p)
{
vec3 ip, fp, g, w, a;
ip = floor (p);
fp = fract (p);
a = vec3 (2.);
for (float gz = -1.; gz <= 1.; gz ++) {
for (float gy = -1.; gy <= 1.; gy ++) {
for (float gx = -1.; gx <= 1.; gx ++) {
g = vec3 (gx, gy, gz);
w = g + 0.7 * Hashfv3 (ip + g) - fp;
a.x = dot (w, w);
if (a.x < a.y) {
vcId = vec4 (ip + g, a.y - a.x);
a = a.zxy;
} else a.z = min (a.z, a.x);
}
}
}
return a.y;
}
vec3 TrackPath (float t)
{
return vec3 (4.7 * sin (t * 0.15) + 2.7 * cos (t * 0.19), 0., t);
}
float CaveDf (vec3 p)
{
vec3 hv;
float s, d;
s = p.y - htWat;
p.xy -= TrackPath (p.z).xy;
p += 0.1 * (1. - cos (2. * pi * (p + 0.2 * (1. - cos (2. * pi * p.zxy)))));
hv = cos (0.6 * p - 0.5 * sin (1.4 * p.zxy + 0.4 * cos (2.7 * p.yzx)));
if (USE_BMAP && dstBMap < 10.) hv *= 1. + 0.01 *
(1. - smoothstep (0., 10., dstBMap)) *
smoothstep (0.05, 0.4, VPoly (10. * p)) / length (hv);
d = 0.9 * (length (hv) - 1.1);
if (! uWat) d = min (d, s);
return d;
}
float CaveRay (vec3 ro, vec3 rd)
{
float d, dHit;
dHit = 0.;
for (int j = 0; j < 200; j ++) {
dstBMap = dHit;
d = CaveDf (ro + dHit * rd);
dHit += d;
if (d < 0.001 || dHit > dstFar) break;
}
return dHit;
}
vec3 CaveNf (vec3 p)
{
vec4 v;
const vec3 e = vec3 (0.001, -0.001, 0.);
v = vec4 (CaveDf (p + e.xxx), CaveDf (p + e.xyy),
CaveDf (p + e.yxy), CaveDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
float CaveSShadow (vec3 ro, vec3 rd)
{
float sh, d, h;
sh = 1.;
d = 0.1;
for (int j = 0; j < 16; j ++) {
h = CaveDf (ro + rd * d);
sh = min (sh, smoothstep (0., 0.05 * d, h));
d += max (0.2, 0.1 * d);
if (sh < 0.05) break;
}
return 0.4 + 0.6 * sh;
}
vec3 CaveCol (vec3 ro, vec3 rd, vec3 ltDir, float atten)
{
vec3 col, vn, q, vno;
float glit;
VPoly (10. * ro);
q = ro;
if (! USE_BMAP) q = 0.004 * floor (250. * q);
vn = VaryNf (10. * q, CaveNf (q), 1.);
col = (vec3 (0.3, 0.1, 0.) + vec3 (0.3, 0.2, 0.1) * Hashv3f (Hashfv3 (vcId.xyz))) *
(1.2 - 0.4 * Hashfv3 (100. * ro)) *
(0.4 + 0.6 * smoothstep (0.05, 1., sqrt (vcId.w))) *
(0.2 + 0.8 * max (dot (vn, ltDir), 0.) +
2. * pow (max (dot (normalize (ltDir - rd), vn), 0.), 256.));
if (! hitWat) {
vno = CaveNf (ro);
glit = 20. * pow (max (0., dot (ltDir, reflect (rd, vno))), 4.) *
pow (1. - 0.6 * abs (dot (normalize (ltDir - rd),
VaryNf (100. * ro, vno, 5.))), 8.);
col += vec3 (1., 1., 0.5) * glit;
}
col *= atten * CaveSShadow (ro, ltDir);
return col;
}
vec3 ObjCol (vec3 ro, vec3 rd, vec3 vn, vec3 ltDir, float atten)
{
vec4 col4;
if (idObj == idBoat) col4 = vec4 (0.3, 0.3, 0.6, 0.2);
else if (idObj == idFLamp) col4 = vec4 (0., 1., 0., -1.);
else if (idObj == idBLamp) col4 = vec4 (1., 0., 0., -1.);
if (col4.a >= 0.)
col4.rgb = col4.rgb * (0.2 + 0.8 * CaveSShadow (ro, ltDir)) *
(0.1 + 0.9 * atten * max (dot (ltDir, vn), 0.)) +
col4.a * atten * pow (max (dot (normalize (ltDir - rd), vn), 0.), 64.);
return col4.rgb;
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec3 col, colR, bgCol, ltVec, vn, roo, rdo, row, vnw;
float dstCave, dstObj, atten, frFac;
roo = ro;
rdo = rd;
bgCol = (abs (rd.y) < 0.5) ? vec3 (0., 0.05, 0.08) : vec3 (0.01);
uWat = false;
hitWat = false;
dstCave = CaveRay (ro, rd);
dstObj = ObjRay (ro, rd);
if (dstCave < min (dstObj, dstFar) && ro.y + rd.y * dstCave < htWat + 0.001) {
hitWat = true;
ro += rd * dstCave;
row = ro;
vnw = VaryNf (1.5 * ro, vec3 (0., 1., 0.), 0.1);
rd = reflect (rd, vnw);
ro += 0.01 * rd;
dstCave = CaveRay (ro, rd);
dstObj = ObjRay (ro, rd);
}
if (min (dstCave, dstObj) < dstFar) {
ltVec = roo + ltPos[0] - ro;
atten = 1. / (0.1 + dot (ltVec, ltVec));
if (hitWat) atten *= 3.;
ltVec = normalize (ltVec);
ro += min (dstCave, dstObj) * rd;
if (dstCave < dstObj) col = mix (CaveCol (ro, rd, ltVec, atten), bgCol,
smoothstep (0.45, 0.99, dstCave / dstFar));
else col = ObjCol (ro, rd, ObjNf (ro), ltVec, atten);
} else col = bgCol;
if (hitWat) {
frFac = rdo.y * rdo.y;
frFac *= frFac;
if (frFac > 0.005) {
rd = refract (rdo, vnw, 1./1.333);
ro = row + 0.01 * rd;
uWat = true;
dstCave = CaveRay (ro, rd);
if (min (dstCave, dstObj) < dstFar) {
ltVec = roo + ltPos[1] - ro;
atten = 1. / (0.1 + dot (ltVec, ltVec));
ltVec = normalize (ltVec);
ro += rd * dstCave;
hitWat = false;
colR = mix (CaveCol (ro, rd, ltVec, atten), bgCol,
smoothstep (0.45, 0.99, dstCave / dstFar));
} else colR = bgCol;
col = mix (col, colR * vec3 (0.4, 1., 0.6) * exp (0.02 * ro.y), frFac);
}
}
return pow (clamp (col, 0., 1.), vec3 (0.8));
}
void mainImage (out vec4 fragColor, in vec2 fragCoord)
{
mat3 vuMat;
#ifdef MOUSE
vec4 mPtr;
#endif
vec3 ro, rd, fpF, fpB, vd;
vec2 canvas, uv, ori, ca, sa;
float el, az, t, tt, a;
canvas = iResolution.xy;
uv = 2. * fragCoord.xy / canvas - 1.;
uv.x *= canvas.x / canvas.y;
tCur = iGlobalTime;
#ifdef MOUSE
mPtr = iMouse;
mPtr.xy = mPtr.xy / canvas - 0.5;
#endif
t = 1. * tCur;
az = 0.;
el = 0.;
#ifdef MOUSE
if (mPtr.z > 0.) {
az = az + 2. * pi * mPtr.x;
el = el + 0.95 * pi * mPtr.y;
} else {
tt = mod (floor (0.05 * tCur), 4.);
a = 0.45 * pi * SmoothBump (0.75, 0.95, 0.05, mod (0.05 * tCur, 1.));
if (tt < 2.) el = (2. * tt - 1.) * a;
else az = (2. * tt - 5.) * a;
}
#else
tt = mod (floor (0.05 * tCur), 4.);
a = 0.45 * pi * SmoothBump (0.75, 0.95, 0.05, mod (0.05 * tCur, 1.));
if (tt < 2.) el = (2. * tt - 1.) * a;
else az = (2. * tt - 5.) * a;
#endif
htWat = -0.5;
for (int k = 0; k < 2; k ++) {
fpF = TrackPath (t + 3. + 3. * float (k) + 0.1);
fpB = TrackPath (t + 3. + 3. * float (k) - 0.1);
boatPos[k] = 0.5 * (fpF + fpB);
boatPos[k].y = htWat + 0.01;
vd = fpF - fpB;
boatAng[k] = (length (vd.xz) > 0.) ? atan (vd.x, vd.z) : 0.5 * pi;
}
fpF = TrackPath (t + 0.1);
fpB = TrackPath (t - 0.1);
ro = 0.5 * (fpF + fpB);
vd = fpF - fpB;
ori = vec2 (el, az + ((length (vd.xz) > 0.) ? atan (vd.x, vd.z) : 0.5 * pi));
ca = cos (ori);
sa = sin (ori);
vuMat = mat3 (ca.y, 0., - sa.y, 0., 1., 0., sa.y, 0., ca.y) *
mat3 (1., 0., 0., 0., ca.x, - sa.x, 0., sa.x, ca.x);
rd = vuMat * normalize (vec3 (uv, 2.));
ltPos[0] = 0.5 * vuMat * vec3 (0., 1., -1.);
ltPos[1] = 0.5 * vuMat * vec3 (0., -1., -1.);
dstFar = 50.;
fragColor = vec4 (ShowScene (ro, rd) , 1.);
}
float PrSphDf (vec3 p, float r)
{
return length (p) - r;
}
float PrCapsDf (vec3 p, float r, float h)
{
return length (p - vec3 (0., 0., clamp (p.z, - h, h))) - r;
}
float SmoothBump (float lo, float hi, float w, float x)
{
return (1. - smoothstep (hi - w, hi + w, x)) * smoothstep (lo - w, lo + w, x);
}
vec2 Rot2D (vec2 q, float a)
{
return q * cos (a) + q.yx * sin (a) * vec2 (-1., 1.);
}
const vec4 cHashA4 = vec4 (0., 1., 57., 58.);
const vec3 cHashA3 = vec3 (1., 57., 113.);
const float cHashM = 43758.54;
float Hashfv2 (vec2 p)
{
return fract (sin (dot (p, cHashA3.xy)) * cHashM);
}
float Hashfv3 (vec3 p)
{
return fract (sin (dot (p, cHashA3)) * cHashM);
}
vec3 Hashv3f (float p)
{
return fract (sin (vec3 (p, p + 1., p + 2.)) *
vec3 (cHashM, cHashM * 0.43, cHashM * 0.37));
}
vec4 Hashv4f (float p)
{
return fract (sin (p + cHashA4) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec4 t;
vec2 ip, fp;
ip = floor (p);
fp = fract (p);
fp = fp * fp * (3. - 2. * fp);
t = Hashv4f (dot (ip, cHashA3.xy));
return mix (mix (t.x, t.y, fp.x), mix (t.z, t.w, fp.x), fp.y);
}
float Fbmn (vec3 p, vec3 n)
{
vec3 s;
float a;
s = vec3 (0.);
a = 1.;
for (int i = 0; i < 5; i ++) {
s += a * vec3 (Noisefv2 (p.yz), Noisefv2 (p.zx), Noisefv2 (p.xy));
a *= 0.5;
p *= 2.;
}
return dot (s, abs (n));
}
vec3 VaryNf (vec3 p, vec3 n, float f)
{
vec3 g;
const vec3 e = vec3 (0.1, 0., 0.);
g = vec3 (Fbmn (p + e.xyy, n), Fbmn (p + e.yxy, n), Fbmn (p + e.yyx, n)) -
Fbmn (p, n);
return normalize (n + f * (g - n * dot (n, g)));
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

629
procedural/dr2-river-flight.slang Normal file
View File

@ -0,0 +1,629 @@
#version 450
// River Flight - dr2 - 2014-11-06
// https://www.shadertoy.com/view/4sSXDG
// Fasten your seatbelts for a wild ride.
// "River Flight" by dr2 - 2014
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
const vec4 cHashA4 = vec4 (0., 1., 57., 58.);
const vec3 cHashA3 = vec3 (1., 57., 113.);
const float cHashM = 43758.54;
vec4 Hashv4f (float p)
{
return fract (sin (p + cHashA4) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec2 i = floor (p);
vec2 f = fract (p);
f = f * f * (3. - 2. * f);
vec4 t = Hashv4f (dot (i, cHashA3.xy));
return mix (mix (t.x, t.y, f.x), mix (t.z, t.w, f.x), f.y);
}
float Noisefv3 (vec3 p)
{
vec3 i = floor (p);
vec3 f = fract (p);
f = f * f * (3. - 2. * f);
float q = dot (i, cHashA3);
vec4 t1 = Hashv4f (q);
vec4 t2 = Hashv4f (q + cHashA3.z);
return mix (mix (mix (t1.x, t1.y, f.x), mix (t1.z, t1.w, f.x), f.y),
mix (mix (t2.x, t2.y, f.x), mix (t2.z, t2.w, f.x), f.y), f.z);
}
vec3 Noisev3v2 (vec2 p)
{
vec2 i = floor (p);
vec2 f = fract (p);
vec2 ff = f * f;
vec2 u = ff * (3. - 2. * f);
vec2 uu = 30. * ff * (ff - 2. * f + 1.);
vec4 h = Hashv4f (dot (i, cHashA3.xy));
return vec3 (h.x + (h.y - h.x) * u.x + (h.z - h.x) * u.y +
(h.x - h.y - h.z + h.w) * u.x * u.y, uu * (vec2 (h.y - h.x, h.z - h.x) +
(h.x - h.y - h.z + h.w) * u.yx));
}
float SmoothMin (float a, float b, float r)
{
float h = clamp (0.5 + 0.5 * (b - a) / r, 0., 1.);
return mix (b, a, h) - r * h * (1. - h);
}
float SmoothBump (float lo, float hi, float w, float x)
{
return (1. - smoothstep (hi - w, hi + w, x)) * smoothstep (lo - w, lo + w, x);
}
float PrCapsDf (vec3 p, vec2 b)
{
return length (p - vec3 (0., 0., b.x * clamp (p.z / b.x, -1., 1.))) - b.y;
}
float PrCylDf (vec3 p, vec2 b)
{
return max (length (p.xy) - b.x, abs (p.z) - b.y);
}
float PrConeDf (vec3 p, vec3 b)
{
return max (dot (vec2 (length (p.xy), p.z), b.xy), abs (p.z) - b.z);
}
int idObj;
mat3 flyerMat;
vec3 flyerPos, engPos, qHit, qHitTransObj, sunDir, sunCol;
vec2 trkOffset;
float szFac, wSpan, tCur;
const float dstFar = 400.;
const float pi = 3.14159;
vec3 TrackPath (float t)
{
return vec3 (24. * sin (0.035 * t) * sin (0.012 * t) * cos (0.01 * t) +
19. * sin (0.0032 * t) + 100. * trkOffset.x, 0., t);
}
float GrndHt (vec2 p, int hiRes)
{
const vec2 vRot = vec2 (1.4624, 1.6721);
vec2 q = p * 0.06;
float w = 0.75 * Noisefv2 (0.25 * q) + 0.15;
w *= 36. * w;
vec2 vyz = vec2 (0.);
float ht = 0.;
for (int j = 0; j < 10; j ++) {
vec3 v = Noisev3v2 (q);
vyz += v.yz;
ht += w * v.x / (1. + dot (vyz, vyz));
if (j == 4) {
if (hiRes == 0) break;
}
w *= -0.37;
q *= mat2 (vRot.x, vRot.y, - vRot.y, vRot.x);
}
vec3 pt = TrackPath (p.y);
pt.y -= 2.;
float g = smoothstep (1.5, 4.5, sqrt (abs (p.x - pt.x)));
return min (ht, pt.y * (1. - g) + ht * g);
}
vec3 GrndNf (vec3 p, float d)
{
float ht = GrndHt (p.xz, 1);
vec2 e = vec2 (max (0.01, 0.00001 * d * d), 0.);
return normalize (vec3 (ht - GrndHt (p.xz + e.xy, 1), e.x,
ht - GrndHt (p.xz + e.yx, 1)));
}
vec4 GrndCol (vec3 p, vec3 n)
{
const vec3 gCol1 = vec3 (0.6, 0.7, 0.7), gCol2 = vec3 (0.2, 0.1, 0.1),
gCol3 = vec3 (0.4, 0.3, 0.3), gCol4 = vec3 (0.1, 0.2, 0.1),
gCol5 = vec3 (0.7, 0.7, 0.8), gCol6 = vec3 (0.05, 0.3, 0.03),
gCol7 = vec3 (0.1, 0.08, 0.);
vec2 q = p.xz;
float f, d;
float cSpec = 0.;
f = 0.5 * (clamp (Noisefv2 (0.1 * q), 0., 1.) +
0.8 * Noisefv2 (0.2 * q + 2.1 * n.xy + 2.2 * n.yz));
vec3 col = f * mix (f * gCol1 + gCol2, f * gCol3 + gCol4, 0.65 * f);
if (n.y < 0.5) {
f = 0.4 * (Noisefv2 (0.4 * q + vec2 (0., 0.57 * p.y)) +
0.5 * Noisefv2 (6. * q));
d = 4. * (0.5 - n.y);
col = mix (col, vec3 (f), clamp (d * d, 0.1, 1.));
cSpec += 0.1;
}
if (p.y > 22.) {
if (n.y > 0.25) {
f = clamp (0.07 * (p.y - 22. - Noisefv2 (0.2 * q) * 15.), 0., 1.);
col = mix (col, gCol5, f);
cSpec += f;
}
} else {
if (n.y > 0.45) {
vec3 c = (n.y - 0.3) * (gCol6 * vec3 (Noisefv2 (0.4 * q),
Noisefv2 (0.34 * q), Noisefv2 (0.38 * q)) + vec3 (0.02, 0.1, 0.02));
col = mix (col, c, smoothstep (0.45, 0.65, n.y) *
(1. - smoothstep (15., 22., p.y - 1.5 + 1.5 * Noisefv2 (0.2 * q))));
}
if (p.y < 0.65 && n.y > 0.4) {
d = n.y - 0.4;
col = mix (col, d * d + gCol7, 2. * clamp ((0.65 - p.y -
0.35 * (Noisefv2 (0.4 * q) + 0.5 * Noisefv2 (0.8 * q) +
0.25 * Noisefv2 (1.6 * q))), 0., 0.3));
cSpec += 0.1;
}
}
return vec4 (col, cSpec);
}
float GrndRay (vec3 ro, vec3 rd)
{
vec3 p;
float h, s, sLo, sHi;
s = 0.;
sLo = 0.;
float dHit = dstFar;
for (int j = 0; j < 150; j ++) {
p = ro + s * rd;
h = p.y - GrndHt (p.xz, 0);
if (h < 0.) break;
sLo = s;
s += max (0.15, 0.4 * h) + 0.008 * s;
if (s > dstFar) break;
}
if (h < 0.) {
sHi = s;
for (int j = 0; j < 10; j ++) {
s = 0.5 * (sLo + sHi);
p = ro + s * rd;
h = step (0., p.y - GrndHt (p.xz, 0));
sLo += h * (s - sLo);
sHi += (1. - h) * (s - sHi);
}
dHit = sHi;
}
return dHit;
}
float WaterHt (vec3 p)
{
p *= 0.1;
float ht = 0.;
const float wb = 1.414;
float w = 0.2 * wb;
for (int j = 0; j < 7; j ++) {
w *= 0.5;
p = wb * vec3 (p.y + p.z, p.z - p.y, 2. * p.x);
ht += w * abs (Noisefv3 (p) - 0.5);
}
return ht;
}
vec3 WaterNf (vec3 p, float d)
{
float ht = WaterHt (p);
vec2 e = vec2 (max (0.01, 0.001 * d * d), 0.);
return normalize (vec3 (ht - WaterHt (p + e.xyy), e.x, ht - WaterHt (p + e.yyx)));
}
vec3 SkyBg (vec3 rd)
{
const vec3 sbCol = vec3 (0.15, 0.2, 0.65);
vec3 col;
col = sbCol + 0.2 * sunCol * pow (1. - max (rd.y, 0.), 5.);
return col;
}
vec3 SkyCol (vec3 ro, vec3 rd)
{
const float skyHt = 200.;
vec3 col;
float cloudFac;
if (rd.y > 0.) {
ro.x += 0.5 * tCur;
vec2 p = 0.01 * (rd.xz * (skyHt - ro.y) / rd.y + ro.xz);
float w = 0.65;
float f = 0.;
for (int j = 0; j < 4; j ++) {
f += w * Noisefv2 (p);
w *= 0.5;
p *= 2.3;
}
cloudFac = clamp (5. * (f - 0.5) * rd.y - 0.1, 0., 1.);
} else cloudFac = 0.;
float s = max (dot (rd, sunDir), 0.);
col = SkyBg (rd) + sunCol * (0.35 * pow (s, 6.) +
0.65 * min (pow (s, 256.), 0.3));
col = mix (col, vec3 (0.85), cloudFac);
return col;
}
float GrndSShadow (vec3 ro, vec3 rd)
{
float sh = 1.;
float d = 0.01;
for (int i = 0; i < 80; i++) {
vec3 p = ro + rd * d;
float h = p.y - GrndHt (p.xz, 0);
sh = min (sh, 20. * h / d);
d += 0.5;
if (h < 0.001) break;
}
return clamp (sh, 0., 1.);
}
struct WingParm
{
float span, sRad, trans, thck, leCut, leRad;
};
float WingDf (vec3 p, WingParm wg)
{
vec2 q = p.yz;
float w = max (length (q - vec2 (wg.sRad, 0.)),
length (q + vec2 (wg.sRad, 0.)));
w = max (max (w - wg.thck, abs (p.x - wg.trans) - wg.span),
p.z - wg.leCut);
return min (w, max (length (q - vec2 (0., wg.leCut)) - wg.leRad,
abs (p.x - wg.trans) - wg.span));
}
float PropelDf (vec3 p, float dHit)
{
vec3 q;
float d;
dHit /= szFac;
p /= szFac;
q = p;
q.x = abs (q.x);
q -= engPos;
d = PrCylDf (q - vec3 (0., 0., 3.65), vec2 (1.9, 0.05));
if (d < dHit) {
dHit = d;
qHitTransObj = q;
}
return dHit * szFac;
}
float TransObjDf (vec3 p)
{
float dHit = dstFar;
dHit = PropelDf (flyerMat * (p - flyerPos), dHit);
return dHit;
}
float TransObjRay (vec3 ro, vec3 rd)
{
const float dTol = 0.001;
float d;
float dHit = 0.;
for (int j = 0; j < 150; j ++) {
d = TransObjDf (ro + dHit * rd);
dHit += d;
if (d < dTol || dHit > dstFar) break;
}
return dHit;
}
float FlyerDf (vec3 p, float dHit)
{
vec3 q;
WingParm wg;
float d, wr, ws, cLen;
const float wSweep = 0.2;
const float fusLen = 11.;
const float taPos = 12.5;
dHit /= szFac;
p /= szFac;
q = p;
wr = q.z / fusLen;
d = PrCapsDf (q - fusLen * vec3 (0., 0.045 + 0.08 * wr, 0.),
fusLen * vec2 (0.46, 0.11));
if (d < dHit) {
dHit = d; idObj = 1; qHit = q;
}
d = PrCapsDf (q - fusLen * vec3 (0., 0., -0.32),
fusLen * vec2 (1., 0.15 - 0.051 * wr * wr));
if (d < dHit + 0.1) {
dHit = SmoothMin (dHit, d, 0.1); idObj = 2; qHit = q;
}
ws = wSweep * abs (p.x) / wSpan;
q = p + vec3 (0., 0.054 * fusLen - 6. * ws, 12. * ws);
wg = WingParm (wSpan, 13.7, 0., 14., 1.72, 0.195);
d = WingDf (q, wg);
if (d < dHit + 0.2) {
dHit = SmoothMin (dHit, d, 0.2); idObj = 3; qHit = q;
}
q = p + vec3 (0., -0.1 - 6. * ws, taPos + 12. * ws);
wg = WingParm (0.4 * wSpan, 6.8, 0., 7., 1.2, 0.095);
d = WingDf (q, wg);
if (d < dHit + 0.1) {
dHit = SmoothMin (dHit, d, 0.1); idObj = 4; qHit = q;
}
ws = wSweep * abs (p.y) / wSpan;
q = p.yxz + vec3 (-0.2, 0., taPos + 12. * ws);
wg = WingParm (0.15 * wSpan, 6.8, 2.2, 7., 1.2, 0.095);
d = WingDf (q, wg);
if (d < dHit + 0.1) {
dHit = SmoothMin (dHit, d, 0.1); idObj = 5; qHit = q;
}
q = p;
q.x = abs (q.x);
cLen = 3.5;
wr = q.z / cLen;
d = PrCylDf (q - engPos, cLen * vec2 (0.2 - 0.07 * wr * wr, 1.));
float d2 = PrCylDf (q - engPos, cLen * vec2 (0.04, 1.02));
d = max (d, - d2);
if (d < dHit) {
dHit = d; idObj = 6; qHit = q;
}
q = p;
q.x = abs (q.x);
d = PrConeDf (q - engPos - vec3 (0., 0., 4.2), vec3 (0.8, 0.6, 0.7));
if (d < dHit) {
dHit = d; idObj = 7; qHit = q;
}
q = p;
cLen = 2.8;
q.z += wSweep * wSpan - 0.025 * cLen;
q.x = abs (q.x);
wr = q.z / cLen;
d = PrCapsDf (q - vec3 (wSpan + 0.1, 0.5 * wSweep * wSpan - 0.6, -0.5),
cLen * vec2 (1., 0.15 - 0.055 * wr * wr));
if (d < dHit) {
dHit = d; idObj = 8; qHit = q;
}
return 0.8 * dHit * szFac;
}
float ObjDf (vec3 p)
{
float dHit = dstFar;
dHit = FlyerDf (flyerMat * (p - flyerPos), dHit);
return dHit;
}
float ObjRay (vec3 ro, vec3 rd)
{
const float dTol = 0.001;
float d;
float dHit = 0.;
for (int j = 0; j < 150; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < dTol || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjNf (vec3 p)
{
const vec3 e = vec3 (0.001, -0.001, 0.);
float v0 = ObjDf (p + e.xxx);
float v1 = ObjDf (p + e.xyy);
float v2 = ObjDf (p + e.yxy);
float v3 = ObjDf (p + e.yyx);
return normalize (vec3 (v0 - v1 - v2 - v3) + 2. * vec3 (v1, v2, v3));
}
float ObjSShadow (vec3 ro, vec3 rd)
{
float sh = 1.;
float d = 0.07 * szFac;
for (int i = 0; i < 50; i++) {
float h = ObjDf (ro + rd * d);
sh = min (sh, 20. * h / d);
d += 0.07 * szFac;
if (h < 0.001) break;
}
return clamp (sh, 0., 1.);
}
vec3 ObjCol (vec3 p, vec3 n)
{
vec3 bCol = vec3 (0.8, 0.8, 0.85), wCol = vec3 (0.3, 0.3, 0.7),
tCol = vec3 (0.9, 0.7, 0.), uCol = vec3 (0.9, 0.1, 0.);
float cFac = 1.;
if (idObj >= 3 && idObj <= 5) {
float s1, s2;
if (idObj == 3) {
s1 = 2.2; s2 = 6.;
} else if (idObj == 4) {
s1 = 1.2; s2 = 1.7;
} else if (idObj == 5) {
s1 = 1.; s2 = 1.;
}
if (abs (qHit.x) > s2 - 0.03)
cFac = 1. - 0.9 * SmoothBump (- 0.08, 0.08, 0.02, qHit.z + s1);
if (qHit.z < - s1)
cFac = 1. - 0.9 * SmoothBump (- 0.05, 0.05, 0.02, abs (qHit.x) - s2);
}
vec3 col;
vec3 nn;
if (idObj >= 1 && idObj <= 5) nn = flyerMat * n;
if (idObj == 1 || idObj == 2) {
col = mix (uCol, bCol, 1. - smoothstep (-0.6, 0., nn.y));
if (idObj == 2 && nn.y < 0.)
col = mix (bCol, wCol, SmoothBump (-0.8, 0.8, 0.3, qHit.z + 0.28));
} else if (idObj == 3 || idObj == 4) {
col = mix (bCol, wCol, SmoothBump (-0.8, 0.8, 0.3, qHit.z));
} else if (idObj == 5) {
col = mix (bCol, tCol, SmoothBump (-0.6, 0.8, 0.3, qHit.z));
} else if (idObj == 6) {
col = bCol;
} else if (idObj == 7 || idObj == 8) {
col = tCol;
}
if (idObj == 1) {
if (qHit.z > 4.5 && abs (qHit.x) > 0.07) idObj = 10;
} else if (idObj == 2) {
float s = - qHit.z;
if (s > 0. && s < 9.) {
vec2 ws = vec2 (qHit.y - 0.5, mod (s + 1.5, 1.5) - 0.75);
ws *= ws;
if (dot (ws, ws) < 0.02) idObj = 10;
}
}
return col * cFac;
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
const float eps = 0.01;
vec4 col4;
vec3 objCol, col, vn;
float dstHit, dstGrnd, dstObj, dstPropel, f;
int idObjT;
vec3 roo = ro;
dstHit = dstFar;
dstGrnd = GrndRay (ro, rd);
wSpan = 12.;
engPos = vec3 (0.35 * wSpan, -0.2, -1.5);
idObj = 0;
dstObj = ObjRay (ro, rd);
idObjT = idObj;
dstPropel = TransObjRay (ro, rd);
if (dstObj < dstPropel) dstPropel = dstFar;
float refFac = 1.;
if (dstGrnd < dstObj && ro.y + dstGrnd * rd.y < 0.) {
float dw = - ro.y / rd.y;
ro += dw * rd;
rd = reflect (rd, WaterNf (ro, dw));
ro += eps * rd;
dstGrnd = GrndRay (ro, rd);
idObj = 0;
dstObj = ObjRay (ro, rd);
idObjT = idObj;
refFac *= 0.6;
}
bool isGrnd = false;
if (dstObj < dstGrnd) {
ro += dstObj * rd;
vn = ObjNf (ro);
idObj = idObjT;
objCol = ObjCol (ro, vn);
if (idObj == 10) objCol = vec3 (0.2) + 0.5 * SkyCol (ro, reflect (rd, vn));
float dif = max (dot (vn, sunDir), 0.);
col = sunCol * objCol * (0.2 * (1. +
max (dot (vn, - normalize (vec3 (sunDir.x, 0., sunDir.z))), 0.)) +
max (0., dif) * ObjSShadow (ro, sunDir) *
(dif + 0.5 * pow (max (0., dot (sunDir, reflect (rd, vn))), 100.)));
dstHit = dstObj;
} else {
vec3 rp = ro + dstGrnd * rd;
if (refFac < 1.) dstHit = length (rp - roo);
else dstHit = dstGrnd;
if (dstHit < dstFar) {
ro = rp;
isGrnd = true;
} else {
col = refFac * SkyCol (ro, rd);
}
}
if (isGrnd) {
vn = GrndNf (ro, dstHit);
col4 = GrndCol (ro, vn);
col = col4.xyz * refFac;
float dif = max (dot (vn, sunDir), 0.);
col *= sunCol * (0.2 * (1. +
max (dot (vn, - normalize (vec3 (sunDir.x, 0., sunDir.z))), 0.)) +
max (0., dif) * GrndSShadow (ro, sunDir) *
(dif + col4.w * pow (max (0., dot (sunDir, reflect (rd, vn))), 100.)));
}
if (dstPropel < dstFar) col = 0.7 * col + 0.1 -
0.04 * SmoothBump (1.5, 1.7, 0.02, length (qHitTransObj.xy));
if (dstHit < dstFar) {
f = dstHit / dstFar;
col = mix (col, refFac * SkyBg (rd), clamp (1.03 * f * f, 0., 1.));
}
col = sqrt (clamp (col, 0., 1.));
return clamp (col, 0., 1.);
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = 2. * fragCoord.xy / iResolution.xy - 1.;
vec2 uvs = uv;
uv.x *= iResolution.x / iResolution.y;
trkOffset = vec2 (0.);
float zmFac = 2.7;
tCur = 15. * iGlobalTime + 100. * trkOffset.y;
sunDir = normalize (vec3 (0.9, 1., 0.4));
sunCol = vec3 (1., 0.9, 0.8);
vec3 ro, rd, vd, fpF, fpB, vDir;
szFac = 0.25;
float dt = 1.;
fpF = TrackPath (tCur + dt);
flyerPos = TrackPath (tCur);
fpB = TrackPath (tCur - dt);
vec3 vel = (fpF - fpB) / (2. * dt);
vel.y = 0.;
vec3 acc = (fpF - 2. * flyerPos + fpB) / (dt * dt);
acc.y = 0.;
vec3 va = cross (acc, vel) / length (vel);
float roll = 12. * length (va);
if (va.y < 0.) roll *= -1.;
vDir = normalize (vel);
float cRl = cos (roll);
float sRl = sin (roll);
flyerMat = mat3 (cRl, - sRl, 0., sRl, cRl, 0., 0., 0., 1.) *
mat3 (vDir.z, 0., vDir.x, 0., 1., 0., - vDir.x, 0., vDir.z);
float vuPeriod = 500.;
flyerPos.y = 3. + 1.5 * sin (2.5 * tCur / vuPeriod);
float lookDir = 2. * mod (floor (tCur / vuPeriod), 2.) - 1.;
ro = TrackPath (tCur - 40. * lookDir * (1. -
0.8 * abs (sin (pi * mod (tCur, vuPeriod) / vuPeriod))));
ro.y = 3. + 0.6 * sin (0.16 * tCur / vuPeriod);
vd = flyerPos - ro;
vd.y = 0.;
vd = normalize (lookDir * vDir + 0.3 * normalize (vd));
mat3 scMat = mat3 (vd.z, 0., - vd.x, 0., 1., 0., vd);
rd = scMat * normalize (vec3 (uv, zmFac));
vec3 col = ShowScene (ro, rd);
uvs *= uvs * uvs;
col = mix (vec3 (0.7), col, pow (max (0., 0.95 - length (uvs * uvs * uvs)), 0.3));
fragColor = vec4 (col, 1.);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

515
procedural/dr2-seabirds-at-sunset.slang Normal file
View File

@ -0,0 +1,515 @@
#version 450
// Seabirds at Sunset - dr2 - 2014-12-24
// https://www.shadertoy.com/view/Mtl3z4
// Searching for dinner.
// "Seabirds at Sunset" by dr2 - 2014
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// Clouds and sky colors borrowed from nimitz's "PostCard".
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
const float pi = 3.14159;
const vec4 cHashA4 = vec4 (0., 1., 57., 58.);
const vec3 cHashA3 = vec3 (1., 57., 113.);
const float cHashM = 43758.54;
vec4 Hashv4f (float p)
{
return fract (sin (p + cHashA4) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec2 i = floor (p);
vec2 f = fract (p);
f = f * f * (3. - 2. * f);
vec4 t = Hashv4f (dot (i, cHashA3.xy));
return mix (mix (t.x, t.y, f.x), mix (t.z, t.w, f.x), f.y);
}
float Noisefv3 (vec3 p)
{
vec3 i = floor (p);
vec3 f = fract (p);
f = f * f * (3. - 2. * f);
float q = dot (i, cHashA3);
vec4 t1 = Hashv4f (q);
vec4 t2 = Hashv4f (q + cHashA3.z);
return mix (mix (mix (t1.x, t1.y, f.x), mix (t1.z, t1.w, f.x), f.y),
mix (mix (t2.x, t2.y, f.x), mix (t2.z, t2.w, f.x), f.y), f.z);
}
float SmoothMin (float a, float b, float r)
{
float h = clamp (0.5 + 0.5 * (b - a) / r, 0., 1.);
return mix (b, a, h) - r * h * (1. - h);
}
float SmoothBump (float lo, float hi, float w, float x)
{
return (1. - smoothstep (hi - w, hi + w, x)) * smoothstep (lo - w, lo + w, x);
}
vec2 Rot2D (vec2 q, float a)
{
return q * cos (a) * vec2 (1., 1.) + q.yx * sin (a) * vec2 (-1., 1.);
}
float PrSphDf (vec3 p, float s)
{
return length (p) - s;
}
float PrCapsDf (vec3 p, float r, float h)
{
return length (p - vec3 (0., 0., h * clamp (p.z / h, -1., 1.))) - r;
}
float PrCylDf (vec3 p, float r, float h)
{
return max (length (p.xy) - r, abs (p.z) - h);
}
float PrFlatCylDf (vec3 p, float rhi, float rlo, float h)
{
return max (length (p.xy - vec2 (rhi *
clamp (p.x / rhi, -1., 1.), 0.)) - rlo, abs (p.z) - h);
}
float PrTorusDf (vec3 p, float ri, float rc)
{
return length (vec2 (length (p.xy) - rc, p.z)) - ri;
}
int idObj, idObjGrp;
mat3 bdMat, birdMat[2];
vec3 bdPos, birdPos[2], fltBox, qHit, sunDir, waterDisp, cloudDisp;
float tCur, birdVel, birdLen, legAng;
const float dstFar = 100.;
const int idWing = 21, idBdy = 22, idEye = 23, idBk = 24, idLeg = 25;
float WaterHt (vec3 p)
{
p *= 0.03;
p += waterDisp;
float ht = 0.;
const float wb = 1.414;
float w = wb;
for (int j = 0; j < 7; j ++) {
w *= 0.5;
p = wb * vec3 (p.y + p.z, p.z - p.y, 2. * p.x) + 20. * waterDisp;
ht += w * abs (Noisefv3 (p) - 0.5);
}
return ht;
}
vec3 WaterNf (vec3 p, float d)
{
vec2 e = vec2 (max (0.01, 0.001 * d * d), 0.);
float ht = WaterHt (p);
return normalize (vec3 (ht - WaterHt (p + e.xyy), e.x, ht - WaterHt (p + e.yyx)));
}
float FbmS (vec2 p)
{
float a = 1.;
float v = 0.;
for (int i = 0; i < 5; i ++) {
v += a * (sin (6. * Noisefv2 (p)) + 1.);
a *= 0.5;
p *= 2.;
p *= mat2 (0.8, -0.6, 0.6, 0.8);
}
return v;
}
vec3 SkyCol (vec3 ro, vec3 rd)
{
vec3 col, skyCol, sunCol, p;
float ds, fd, att, attSum, d, dDotS, skyHt;
skyHt = 200.;
p = ro + rd * (skyHt - ro.y) / rd.y;
ds = 0.1 * sqrt (distance (ro, p));
fd = 0.001 / (smoothstep (0., 10., ds) + 0.1);
p.xz *= fd;
p.xz += cloudDisp.xz;
att = FbmS (p.xz);
attSum = att;
d = fd;
ds *= fd;
for (int i = 0; i < 4; i ++) {
attSum += FbmS (p.xz + d * sunDir.xz);
d += ds;
}
attSum *= 0.27;
att *= 0.27;
dDotS = clamp (dot (sunDir, rd), 0., 1.);
skyCol = mix (vec3 (0.7, 1., 1.), vec3 (1., 0.4, 0.1), 0.25 + 0.75 * dDotS);
sunCol = vec3 (1., 0.8, 0.7) * pow (dDotS, 1024.) +
vec3 (1., 0.4, 0.2) * pow (dDotS, 256.);
col = mix (vec3 (0.5, 0.75, 1.), skyCol, exp (-2. * (3. - dDotS) *
max (rd.y - 0.1, 0.))) + 0.3 * sunCol;
attSum = 1. - smoothstep (1., 9., attSum);
col = mix (vec3 (0.4, 0., 0.2), mix (col, vec3 (0.2), att), attSum) +
vec3 (1., 0.4, 0.) * pow (attSum * att, 3.) * (pow (dDotS, 10.) + 0.5);
return col;
}
float AngQnt (float a, float s1, float s2, float nr)
{
return (s1 + floor (s2 + a * (nr / (2. * pi)))) * (2. * pi / nr);
}
float BdWingDf (vec3 p, float dHit)
{
vec3 q, qh;
float d, dd, a, wr;
float wngFreq = 6.;
float wSegLen = 0.15 * birdLen;
float wChord = 0.3 * birdLen;
float wSpar = 0.03 * birdLen;
float fTap = 8.;
float tFac = (1. - 1. / fTap);
q = p - vec3 (0., 0., 0.3 * birdLen);
q.x = abs (q.x) - 0.1 * birdLen;
float wf = 1.;
a = -0.1 + 0.2 * sin (wngFreq * tCur);
d = dHit;
qh = q;
for (int k = 0; k < 5; k ++) {
q.xy = Rot2D (q.xy, a);
q.x -= wSegLen;
wr = wf * (1. - 0.5 * q.x / (fTap * wSegLen));
dd = PrFlatCylDf (q.zyx, wr * wChord, wr * wSpar, wSegLen);
if (k < 4) {
q.x -= wSegLen;
dd = min (dd, PrCapsDf (q, wr * wSpar, wr * wChord));
} else {
q.x += wSegLen;
dd = max (dd, PrCylDf (q.xzy, wr * wChord, wSpar));
dd = min (dd, max (PrTorusDf (q.xzy, 0.98 * wr * wSpar,
wr * wChord), - q.x));
}
if (dd < d) { d = dd; qh = q; }
a *= 1.03;
wf *= tFac;
}
if (d < dHit) { dHit = min (dHit, d); idObj = idObjGrp + idWing; qHit = qh; }
return dHit;
}
float BdBodyDf (vec3 p, float dHit)
{
vec3 q;
float d, a, wr;
float bkLen = 0.15 * birdLen;
q = p;
wr = q.z / birdLen;
float tr, u;
if (wr > 0.5) {
u = (wr - 0.5) / 0.5;
tr = 0.17 - 0.11 * u * u;
} else {
u = clamp ((wr - 0.5) / 1.5, -1., 1.);
u *= u;
tr = 0.17 - u * (0.34 - 0.18 * u);
}
d = PrCapsDf (q, tr * birdLen, birdLen);
if (d < dHit) {
dHit = d; idObj = idObjGrp + idBdy; qHit = q;
}
q = p;
q.x = abs (q.x);
wr = (wr + 1.) * (wr + 1.);
q -= birdLen * vec3 (0.3 * wr, 0.1 * wr, -1.2);
d = PrCylDf (q, 0.009 * birdLen, 0.2 * birdLen);
if (d < dHit) { dHit = min (dHit, d); idObj = idObjGrp + idBdy; qHit = q; }
q = p;
q.x = abs (q.x);
q -= birdLen * vec3 (0.08, 0.05, 0.9);
d = PrSphDf (q, 0.04 * birdLen);
if (d < dHit) { dHit = d; idObj = idObjGrp + idEye; qHit = q; }
q = p; q -= birdLen * vec3 (0., -0.015, 1.15);
wr = clamp (0.5 - 0.3 * q.z / bkLen, 0., 1.);
d = PrFlatCylDf (q, 0.25 * wr * bkLen, 0.25 * wr * bkLen, bkLen);
if (d < dHit) { dHit = d; idObj = idObjGrp + idBk; qHit = q; }
return dHit;
}
float BdFootDf (vec3 p, float dHit)
{
vec3 q;
float d;
float lgLen = 0.1 * birdLen;
float ftLen = 0.5 * lgLen;
q = p;
q.x = abs (q.x);
q -= birdLen * vec3 (0.1, -0.12, 0.6);
q.yz = Rot2D (q.yz, legAng);
q.xz = Rot2D (q.xz, -0.05 * pi);
q.z += lgLen;
d = PrCylDf (q, 0.15 * lgLen, lgLen);
if (d < dHit) { dHit = d; idObj = idLeg; qHit = q; }
q.z += lgLen;
q.xy = Rot2D (q.xy, 0.5 * pi);
q.xy = Rot2D (q.xy, AngQnt (atan (q.y, - q.x), 0., 0.5, 3.));
q.xz = Rot2D (q.xz, - pi + 0.4 * legAng);
q.z -= ftLen;
d = PrCapsDf (q, 0.2 * ftLen, ftLen);
if (d < dHit) { dHit = d; idObj = idObjGrp + idLeg; qHit = q; }
return dHit;
}
float BirdDf (vec3 p, float dHit)
{
dHit = BdWingDf (p, dHit);
dHit = BdBodyDf (p, dHit);
dHit = BdFootDf (p, dHit);
return dHit;
}
vec4 BirdCol (vec3 n)
{
vec3 col;
int ig = idObj / 256;
int id = idObj - 256 * ig;
float spec = 1.;
if (id == idWing) {
float gw = 0.15 * birdLen;
float w = mod (qHit.x, gw);
w = SmoothBump (0.15 * gw, 0.65 * gw, 0.1 * gw, w);
col = mix (vec3 (0.05), vec3 (1.), w);
} else if (id == idEye) {
col = vec3 (0., 0.6, 0.);
spec = 5.;
} else if (id == idBdy) {
vec3 nn;
if (ig == 1) nn = birdMat[0] * n;
else nn = birdMat[1] * n;
col = mix (mix (vec3 (1.), vec3 (0.1), smoothstep (0.5, 1., nn.y)), vec3 (1.),
1. - smoothstep (-1., -0.7, nn.y));
} else if (id == idBk) {
col = vec3 (1., 1., 0.);
} else if (id == idLeg) {
col = (0.5 + 0.4 * sin (100. * qHit.z)) * vec3 (0.6, 0.4, 0.);
}
col.gb *= 0.7;
return vec4 (col, spec);
}
float ObjDf (vec3 p)
{
float dHit = dstFar;
idObjGrp = 1 * 256;
dHit = BirdDf (birdMat[0] * (p - birdPos[0]), dHit);
idObjGrp = 2 * 256;
dHit = BirdDf (birdMat[1] * (p - birdPos[1]), dHit);
return 0.9 * dHit;
}
float ObjRay (vec3 ro, vec3 rd)
{
float dTol = 0.001;
float d;
float dHit = 0.;
for (int j = 0; j < 150; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < dTol || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjNf (vec3 p)
{
vec3 e = vec3 (0.001, -0.001, 0.);
vec4 v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy),
ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * vec3 (v.y, v.z, v.w));
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec3 vn;
vec4 objCol;
float dstHit;
float htWat = -1.5;
float reflFac = 1.;
vec3 col = vec3 (0.);
idObj = -1;
dstHit = ObjRay (ro, rd);
if (rd.y < 0. && dstHit >= dstFar) {
float dw = - (ro.y - htWat) / rd.y;
ro += dw * rd;
rd = reflect (rd, WaterNf (ro, dw));
ro += 0.01 * rd;
idObj = -1;
dstHit = ObjRay (ro, rd);
reflFac *= 0.7;
}
int idObjT = idObj;
if (idObj < 0) dstHit = dstFar;
if (dstHit >= dstFar) col = reflFac * SkyCol (ro, rd);
else {
ro += rd * dstHit;
vn = ObjNf (ro);
idObj = idObjT;
objCol = BirdCol (vn);
float dif = max (dot (vn, sunDir), 0.);
col = reflFac * objCol.xyz * (0.2 + max (0., dif) *
(dif + objCol.a * pow (max (0., dot (sunDir, reflect (rd, vn))), 128.)));
}
return col;
}
vec3 BirdTrack (float t)
{
t = - t;
vec3 bp;
float rdTurn = 0.45 * min (fltBox.x, fltBox.z);
float tC = 0.5 * pi * rdTurn / birdVel;
vec3 tt = vec3 (fltBox.x - rdTurn, length (fltBox.xy), fltBox.z - rdTurn) *
2. / birdVel;
float tCyc = 2. * (2. * tt.z + tt.x + 4. * tC + tt.y);
float tSeq = mod (t, tCyc);
float ti[9]; ti[0] = 0.; ti[1] = ti[0] + tt.z; ti[2] = ti[1] + tC;
ti[3] = ti[2] + tt.x; ti[4] = ti[3] + tC; ti[5] = ti[4] + tt.z;
ti[6] = ti[5] + tC; ti[7] = ti[6] + tt.y; ti[8] = ti[7] + tC;
float a, h, hd, tf;
h = - fltBox.y;
hd = 1.;
if (tSeq > 0.5 * tCyc) { tSeq -= 0.5 * tCyc; h = - h; hd = - hd; }
float rSeg = -1.;
vec3 fbR = vec3 (1.);
fbR.xz -= vec2 (rdTurn) / fltBox.xz;
bp.xz = fltBox.xz;
bp.y = h;
if (tSeq < ti[4]) {
if (tSeq < ti[1]) {
tf = (tSeq - ti[0]) / (ti[1] - ti[0]);
bp.xz *= vec2 (1., fbR.z * (2. * tf - 1.));
} else if (tSeq < ti[2]) {
tf = (tSeq - ti[1]) / (ti[2] - ti[1]); rSeg = 0.;
bp.xz *= fbR.xz;
} else if (tSeq < ti[3]) {
tf = (tSeq - ti[2]) / (ti[3] - ti[2]);
bp.xz *= vec2 (fbR.x * (1. - 2. * tf), 1.);
} else {
tf = (tSeq - ti[3]) / (ti[4] - ti[3]); rSeg = 1.;
bp.xz *= fbR.xz * vec2 (-1., 1.);
}
} else {
if (tSeq < ti[5]) {
tf = (tSeq - ti[4]) / (ti[5] - ti[4]);
bp.xz *= vec2 (- 1., fbR.z * (1. - 2. * tf));
} else if (tSeq < ti[6]) {
tf = (tSeq - ti[5]) / (ti[6] - ti[5]); rSeg = 2.;
bp.xz *= - fbR.xz;
} else if (tSeq < ti[7]) {
tf = (tSeq - ti[6]) / (ti[7] - ti[6]);
bp.xz *= vec2 (fbR.x * (2. * tf - 1.), - 1.);
bp.y = h + 2. * fltBox.y * hd * tf;
} else {
tf = (tSeq - ti[7]) / (ti[8] - ti[7]); rSeg = 3.;
bp.xz *= fbR.xz * vec2 (1., -1.);
bp.y = - h;
}
}
if (rSeg >= 0.) {
a = 0.5 * pi * (rSeg + tf);
bp += rdTurn * vec3 (cos (a), 0., sin (a));
}
bp.y -= - 1.1 * fltBox.y;
return bp;
}
void BirdPM (float t)
{
float dt = 1.;
bdPos = BirdTrack (t);
vec3 bpF = BirdTrack (t + dt);
vec3 bpB = BirdTrack (t - dt);
vec3 vel = (bpF - bpB) / (2. * dt);
float vy = vel.y;
vel.y = 0.;
vec3 acc = (bpF - 2. * bdPos + bpB) / (dt * dt);
acc.y = 0.;
vec3 va = cross (acc, vel) / length (vel);
vel.y = vy;
float el = - 0.7 * asin (vel.y / length (vel));
vec3 ort = vec3 (el, atan (vel.z, vel.x) - 0.5 * pi, 0.2 * length (va) * sign (va.y));
vec3 cr = cos (ort);
vec3 sr = sin (ort);
bdMat = mat3 (cr.z, - sr.z, 0., sr.z, cr.z, 0., 0., 0., 1.) *
mat3 (1., 0., 0., 0., cr.x, - sr.x, 0., sr.x, cr.x) *
mat3 (cr.y, 0., - sr.y, 0., 1., 0., sr.y, 0., cr.y);
legAng = pi * clamp (0.4 + 1.5 * el, 0.12, 0.8);
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = 2. * fragCoord.xy / iResolution.xy - 1.;
uv.x *= iResolution.x / iResolution.y;
tCur = iGlobalTime;
vec3 ro, rd, vd;
float zmFac = 2.4;
sunDir = normalize (vec3 (-1., 0.05, 0.));
waterDisp = -0.002 * tCur * vec3 (-1., 0., 1.);
cloudDisp = -0.05 * tCur * vec3 (1., 0., 1.);
birdLen = 1.2;
birdVel = 7.;
float tGap = 10.;
fltBox = vec3 (12., 4., 12.);
BirdPM (tCur);
birdMat[0] = bdMat;
birdPos[0] = bdPos;
BirdPM (tCur + tGap);
birdMat[1] = bdMat;
birdPos[1] = bdPos;
float el = 0.;
float az = -0.5 * pi;
vec2 ca = cos (vec2 (el, az));
vec2 sa = sin (vec2 (el, az));
mat3 vuMat = mat3 (ca.y, 0., - sa.y, 0., 1., 0., sa.y, 0., ca.y) *
mat3 (1., 0., 0., 0., ca.x, - sa.x, 0., sa.x, ca.x);
rd = vuMat * normalize (vec3 (uv, zmFac));
ro = vuMat * vec3 (0., 0., -30.);
ro.y = 4.;
vec3 col = ShowScene (ro, rd);
fragColor = vec4 (col, 1.);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

336
procedural/dr2-stairway-to-the-stars.slang Normal file
View File

@ -0,0 +1,336 @@
#version 450
// Stairway to the Stars - dr2 - 2015-05-13
// https://www.shadertoy.com/view/lls3z7
// A long climb; use the mouse to look around.
// "Stairway to the Stars" by dr2 - 2015
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
const float pi = 3.14159;
const vec4 cHashA4 = vec4 (0., 1., 57., 58.);
const vec3 cHashA3 = vec3 (1., 57., 113.);
const float cHashM = 43758.54;
vec4 Hashv4f (float p)
{
return fract (sin (p + cHashA4) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec2 i = floor (p);
vec2 f = fract (p);
f = f * f * (3. - 2. * f);
vec4 t = Hashv4f (dot (i, cHashA3.xy));
return mix (mix (t.x, t.y, f.x), mix (t.z, t.w, f.x), f.y);
}
float Fbm2 (vec2 p)
{
float s = 0.;
float a = 1.;
for (int i = 0; i < 5; i ++) {
s += a * Noisefv2 (p);
a *= 0.5;
p *= 2.;
}
return s;
}
float PrSphDf (vec3 p, float s)
{
return length (p) - s;
}
vec2 Rot2D (vec2 q, float a)
{
return q * cos (a) * vec2 (1., 1.) + q.yx * sin (a) * vec2 (-1., 1.);
}
#define REFBALL
int idObj;
float tCur, stPitch, rotAng, rOut, rIn, rWid;
vec3 qHit, ltPos[2];
int doLt;
const float dstFar = 20.;
vec3 BrickCol (vec2 p)
{
vec2 i = floor (p);
if (2. * floor (i.y / 2.) != i.y) {
p.x += 0.5;
i = floor (p);
}
p = smoothstep (0.02, 0.08, abs (fract (p + 0.5) - 0.5));
return (0.5 + 0.5 * p.x * p.y) * vec3 (0.5, 0.4, 0.3);
}
vec3 WoodCol (vec2 p)
{
float f = Fbm2 (p * vec2 (1., 0.1));
return mix (vec3 (0.8, 0.4, 0.2), vec3 (0.45, 0.25, 0.1), f);
}
float ObjDf (vec3 p)
{
vec3 q, pp;
float d, dr, da, dy, dMin, r, ns, nh, sh, sw, rw, ca, sa;
const int ins = 12;
const int inh = 6;
dMin = dstFar;
ns = float (ins);
nh = float (inh);
sh = 0.2 * stPitch / ns;
sw = 1.1 * pi * rOut / ns;
rw = 0.09;
pp = p;
pp.xz = Rot2D (pp.xz, rotAng);
pp.y += stPitch * rotAng / (2. * pi);
r = length (pp.xz);
dr = max (r - rOut, rIn - r);
q = pp;
d = dMin;
dy = stPitch / ns;
q.y -= dy;
da = 2. * pi / ns;
ca = cos (da); sa = sin (da);
for (int j = 0; j < ins; j ++) {
q.y = mod (q.y + dy + 0.5 * stPitch, stPitch) - 0.5 * stPitch;
d = min (d, max (max (max (dr, abs (q.z) - sw), q.x), abs (q.y) - sh));
if (d < dMin) { dMin = d; idObj = 1; qHit = q; }
q.xz = q.xz * ca + q.zx * vec2 (- sa, sa);
}
d = min (min (d, max (r - rIn, - (r - rIn + rWid))),
max (r - rOut - rWid, - (r - rOut)));
q = pp;
dy = stPitch / nh;
q.y -= 0.25 * stPitch + dy;
da = 2. * pi / nh;
ca = cos (da); sa = sin (da);
for (int j = 0; j < inh; j ++) {
q.y = mod (q.y + dy + 0.5 * stPitch, stPitch) - 0.5 * stPitch;
d = max (d, - length (q.xy) + rw);
q.xz = q.xz * ca + q.zx * vec2 (- sa, sa);
}
if (d < dMin) { dMin = d; idObj = 2; qHit = q; }
if (doLt != 0) {
d = PrSphDf (p - ltPos[0], 0.07 * rIn);
if (d < dMin) { dMin = d; idObj = 5; }
}
if (doLt != 1) {
d = PrSphDf (p - ltPos[1], 0.07 * rIn);
if (d < dMin) { dMin = d; idObj = 6; }
}
#ifdef REFBALL
d = min (d, max (r - 0.006 * rIn, 0.));
if (d < dMin) { dMin = d; idObj = 3; }
pp = p;
pp.y = mod (pp.y + stPitch * rotAng / (2. * pi) + 0.5 * stPitch, stPitch) -
0.5 * stPitch;
d = PrSphDf (pp, 0.3 * rIn);
if (d < dMin) { dMin = d; idObj = 4; }
#endif
return dMin;
}
vec3 ObjNf (vec3 p)
{
const vec3 e = vec3 (0.001, -0.001, 0.);
vec4 v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy),
ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * vec3 (v.y, v.z, v.w));
}
float ObjRay (vec3 ro, vec3 rd)
{
float dHit, d;
dHit = 0.;
for (int j = 0; j < 100; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < 0.001 || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjCol (vec3 ro, vec3 rd, vec3 vn)
{
vec3 ltDir, acDif, col;
float ltDist, ltDistSq, dif, atten, acSpe, sh, d, h;
col = vec3 (0.);
if (idObj == 1) {
col = WoodCol (120. * qHit.zx);
} else if (idObj == 2) {
if (abs (vn.y) > 0.005) col = 0.4 * vec3 (0.5, 0.4, 0.3);
else col = BrickCol (vec2 (20. * (atan (qHit.z, qHit.x) / pi + 1.),
40. * qHit.y));
} else if (idObj == 3) {
col = vec3 (0.4, 0.4, 0.2);
} else if (idObj == 5) {
col = vec3 (1., 1., 0.5) * (0.75 + 0.25 * dot (rd, normalize (ltPos[0] - ro)));
} else if (idObj == 6) {
col = vec3 (1., 1., 0.5) * (0.75 + 0.25 * dot (rd, normalize (ltPos[1] - ro)));
}
if (idObj < 5) {
acDif = vec3 (0.);
acSpe = 0.;
for (int j = 0; j < 2; j ++) {
doLt = j;
ltDir = ltPos[j] - ro;
ltDistSq = dot (ltDir, ltDir);
ltDist = sqrt (ltDistSq);
ltDir /= ltDist;
dif = clamp (dot (vn, ltDir), 0., 1.);
sh = 0.;
if (dif > 0.) {
sh = 1.;
d = 0.01;
for (int i = 0; i < 60; i ++) {
h = ObjDf (ro + ltDir * d);
sh = min (sh, 50. * h / d);
d += h;
if (d > ltDist) break;
}
dif *= sh;
}
atten = 1. / (0.1 + ltDistSq);
acDif += atten * dif;
acSpe += atten * sh * pow (clamp (dot (reflect (rd, vn), ltDir), 0., 1.), 16.);
}
col = (0.4 + 0.2 * acDif) * col + 0.03 * acSpe * vec3 (1.);
}
return col;
}
float GlowCol (vec3 ro, vec3 rd, float dstHit)
{
vec3 ltDir;
float ltDist, wGlow;
wGlow = 0.;
for (int j = 0; j < 2; j ++) {
ltDir = ltPos[j] - ro;
ltDist = length (ltDir);
ltDir /= ltDist;
if (ltDist < dstHit) wGlow += pow (max (dot (rd, ltDir), 0.), 1024.) / ltDist;
}
return clamp (0.5 * wGlow, 0., 1.);
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec3 col, vn, roo, rds;
float dstHit, rLt, aLt;
int idObjT;
rotAng = 0.3 * tCur;
stPitch = 0.4;
rWid = 0.006;
rLt = 0.6 * rOut;
aLt = 0.1 * pi;
ltPos[0] = vec3 (rLt * cos (aLt), stPitch * (0.1 - 0.14 * cos (tCur)),
rLt * sin (aLt));
aLt = - 0.95 * pi;
ltPos[1] = vec3 (rLt * cos (aLt), stPitch * (-0.4 + 0.14 * sin (tCur)),
rLt * sin (aLt));
roo = ro;
idObj = -1;
doLt = -1;
dstHit = ObjRay (ro, rd);
if (idObj < 0) dstHit = dstFar;
#ifdef REFBALL
if (idObj == 4 && dstHit < dstFar) {
ro += rd * dstHit;
rd = reflect (rd, ObjNf (ro));
ro += 0.01 * rd;
roo = ro;
idObj = -1;
dstHit = ObjRay (ro, rd);
}
#endif
if (dstHit >= dstFar) {
col = vec3 (0., 0., 0.1);
rds = rd;
rds.xz = Rot2D (rds.xz, rotAng);
rds = (rds + vec3 (1.));
for (int j = 0; j < 10; j ++)
rds = 11. * abs (rds) / dot (rds, rds) - 3.;
col += min (1., 1.5e-6 * pow (min (16., length (rds)), 5.)) *
vec3 (0.7, 0.6, 0.6);
} else {
ro += rd * dstHit;
idObjT = idObj;
vn = ObjNf (ro);
idObj = idObjT;
col = ObjCol (ro, rd, vn);
}
col = mix (col, vec3 (1., 1., 0.5), GlowCol (roo, rd, dstHit));
return clamp (col, 0., 1.);
}
void mainImage (out vec4 fragColor, in vec2 fragCoord)
{
vec2 canvas = iResolution.xy;
vec2 uv = 2. * fragCoord.xy / canvas - 1.;
uv.x *= canvas.x / canvas.y;
tCur = iGlobalTime;
#ifdef MOUSE
vec4 mPtr = iMouse;
mPtr.xy = mPtr.xy / canvas - 0.5;
#endif
mat3 vuMat;
vec3 ro, rd;
vec2 vEl, vAz;
float az, el;
rOut = 0.5;
rIn = 0.2;
ro = - vec3 (0., 0.1, 0.9) * rOut;
az = 0.2;
el = 0.1;
#ifdef MOUSE
if (mPtr.z > 0.) {
ro.z = clamp (ro.z + 0.8 * mPtr.x, - 0.99 * rOut, - 0.4 * rIn);
el = clamp (el + 3. * mPtr.y, -1.5, 1.5);
}
#endif
vEl = vec2 (cos (el), sin (el));
vAz = vec2 (cos (az), sin (az));
vuMat = mat3 (1., 0., 0., 0., vEl.x, - vEl.y, 0., vEl.y, vEl.x) *
mat3 (vAz.x, 0., vAz.y, 0., 1., 0., - vAz.y, 0., vAz.x);
rd = normalize (vec3 (uv, 1.5)) * vuMat;
fragColor = vec4 (ShowScene (ro, rd), 1.);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

566
procedural/dr2-wavescape.slang Normal file
View File

@ -0,0 +1,566 @@
#version 450
// Wavescape - dr2 - 2015-01-05
// https://www.shadertoy.com/view/lls3z7
// Another wave renderer, from both above and below the waterline. See the source for where it all comes from.
// "Wavescape" by dr2 - 2015
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// Water waves, including what the fish sees.
// Acknowledgments: thanks for the following -
// Dave_H's multilayered clouds with nimitz's variable layer spacing
// (but depends on elevation rather than distance).
// Wave shapes from TDM; they seem a little more "energetic" than TekF's.
// Raymarching with binary subdivision, as used by Dave_H for mountains;
// TekF and TDM use one or the other, not both.
// Buoy based on TekF's, but raymarched for generality; shows aging effects
// below waterline.
// Foam idea from TekF.
// Noise functions from iq.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
const float pi = 3.14159;
const vec4 cHashA4 = vec4 (0., 1., 57., 58.);
const vec3 cHashA3 = vec3 (1., 57., 113.);
const float cHashM = 43758.54;
vec2 Hashv2f (float p)
{
return fract (sin (p + cHashA4.xy) * cHashM);
}
vec4 Hashv4f (float p)
{
return fract (sin (p + cHashA4) * cHashM);
}
vec4 Hashv4v3 (vec3 p)
{
const vec3 cHashVA3 = vec3 (37.1, 61.7, 12.4);
const vec3 e = vec3 (1., 0., 0.);
return fract (sin (vec4 (dot (p + e.yyy, cHashVA3), dot (p + e.xyy, cHashVA3),
dot (p + e.yxy, cHashVA3), dot (p + e.xxy, cHashVA3))) * cHashM);
}
float Noiseff (float p)
{
float i, f;
i = floor (p); f = fract (p);
f = f * f * (3. - 2. * f);
vec2 t = Hashv2f (i);
return mix (t.x, t.y, f);
}
float Noisefv2 (vec2 p)
{
vec2 i, f;
i = floor (p); f = fract (p);
f = f * f * (3. - 2. * f);
vec4 t = Hashv4f (dot (i, cHashA3.xy));
return mix (mix (t.x, t.y, f.x), mix (t.z, t.w, f.x), f.y);
}
float Noisefv3a (vec3 p)
{
vec3 i, f;
i = floor (p); f = fract (p);
f *= f * (3. - 2. * f);
vec4 t1 = Hashv4v3 (i);
vec4 t2 = Hashv4v3 (i + vec3 (0., 0., 1.));
return mix (mix (mix (t1.x, t1.y, f.x), mix (t1.z, t1.w, f.x), f.y),
mix (mix (t2.x, t2.y, f.x), mix (t2.z, t2.w, f.x), f.y), f.z);
}
float Fbm1 (float p)
{
float f, a;
f = 0.; a = 1.;
for (int i = 0; i < 5; i ++) {
f += a * Noiseff (p);
a *= 0.5; p *= 2.;
}
return f;
}
float Fbm3 (vec3 p)
{
const mat3 mr = mat3 (0., 0.8, 0.6, -0.8, 0.36, -0.48, -0.6, -0.48, 0.64);
float f, a, am, ap;
f = 0.; a = 0.5;
am = 0.5; ap = 4.;
p *= 0.5;
for (int i = 0; i < 6; i ++) {
f += a * Noisefv3a (p);
p *= mr * ap; a *= am;
}
return f;
}
float Fbmn (vec3 p, vec3 n)
{
vec3 f = vec3 (0.);
float a = 1.;
for (int i = 0; i < 5; i ++) {
f += a * vec3 (Noisefv2 (p.yz), Noisefv2 (p.zx), Noisefv2 (p.xy));
a *= 0.5; p *= 2.;
}
return dot (f, abs (n));
}
vec3 VaryNf (vec3 p, vec3 n, float f)
{
vec3 e = vec3 (0.2, 0., 0.);
float s = Fbmn (p, n);
vec3 g = vec3 (Fbmn (p + e.xyy, n) - s,
Fbmn (p + e.yxy, n) - s, Fbmn (p + e.yyx, n) - s);
return normalize (n + f * (g - n * dot (n, g)));
}
float SmoothBump (float lo, float hi, float w, float x)
{
return (1. - smoothstep (hi - w, hi + w, x)) * smoothstep (lo - w, lo + w, x);
}
float PrSphDf (vec3 p, float s)
{
return length (p) - s;
}
float PrCylDf (vec3 p, float r, float h)
{
return max (length (p.xy) - r, abs (p.z) - h);
}
int idObj;
mat3 ballMat;
vec3 qHit, ballPos, sunCol, sunDir, cloudDisp, waterDisp;
float tCur, fCloud;
const float dstFar = 300.;
vec3 SkyGrndCol (vec3 ro, vec3 rd)
{
vec3 p, q, cSun, skyBg, clCol, col;
float colSum, attSum, s, att, a, dDotS, ds;
const vec3 cCol1 = 0.5 * vec3 (0.15, 0.2, 0.4),
cCol2 = 0.5 * vec3 (0.25, 0.5, 0.7), gCol = 1.3 * vec3 (0.05, 0.08, 0.05);
const float cloudLo = 100., cloudRngI = 1./50., atFac = 0.06;
const int nLay = 30;
if (rd.y < 0.015 * Fbm1 (16. * rd.x)) col = gCol * (0.5 + 0.5 *
Noisefv2 (1000. * vec2 (5. * atan (rd.x, rd.z), rd.y)));
else {
fCloud = clamp (fCloud, 0., 1.);
dDotS = max (dot (rd, sunDir), 0.);
ro += cloudDisp;
p = ro;
p.xz += (cloudLo - p.y) * rd.xz / rd.y;
p.y = cloudLo;
ds = 1. / (cloudRngI * rd.y * (2. - rd.y) * float (nLay));
colSum = 0.; attSum = 0.;
s = 0.; att = 0.;
for (int j = 0; j < nLay; j ++) {
q = p + rd * s;
q.z *= 0.7;
att += atFac * max (fCloud - Fbm3 (0.02 * q), 0.);
a = (1. - attSum) * att;
colSum += a * (q.y - cloudLo) * cloudRngI;
attSum += a; s += ds;
if (attSum >= 1.) break;
}
colSum += 0.5 * min ((1. - attSum) * pow (dDotS, 3.), 1.);
clCol = vec3 (1.) * colSum + 0.05 * sunCol;
cSun = sunCol * clamp ((min (pow (dDotS, 1500.) * 2., 1.) +
min (pow (dDotS, 10.) * 0.75, 1.)), 0., 1.);
skyBg = mix (cCol1, cCol2, 1. - rd.y);
col = clamp (mix (skyBg + cSun, 1.6 * clCol, attSum), 0., 1.);
}
return col;
}
vec3 SeaFloorCol (vec3 rd)
{
vec2 p;
float w, f;
p = 5. * rd.xz / rd.y;
w = 1.;
f = 0.;
for (int j = 0; j < 4; j ++) {
f += w * Noisefv2 (p);
w *= 0.5; p *= 2.;
}
return mix (vec3 (0.01, 0.04, 0.02), vec3 (0, 0.05, 0.05),
smoothstep (0.4, 0.7, f));
}
float WaveHt (vec3 p)
{
const mat2 qRot = mat2 (1.6, -1.2, 1.2, 1.6);
vec4 t4, ta4, v4;
vec2 q2, t2, v2;
float wFreq, wAmp, pRough, ht;
wFreq = 0.16; wAmp = 0.6; pRough = 5.;
q2 = p.xz + waterDisp.xz;
ht = 0.;
for (int j = 0; j < 5; j ++) {
t2 = 1.1 * tCur * vec2 (1., -1.);
t4 = vec4 (q2 + t2.xx, q2 + t2.yy) * wFreq;
t2 = vec2 (Noisefv2 (t4.xy), Noisefv2 (t4.zw));
t4 += 2. * vec4 (t2.xx, t2.yy) - 1.;
ta4 = abs (sin (t4));
v4 = (1. - ta4) * (ta4 + abs (cos (t4)));
v2 = pow (1. - pow (v4.xz * v4.yw, vec2 (0.65)), vec2 (pRough));
ht += (v2.x + v2.y) * wAmp;
q2 *= qRot; wFreq *= 1.9; wAmp *= 0.22;
pRough = 0.8 * pRough + 0.2;
}
return ht;
}
float WaveRay (vec3 ro, vec3 rd)
{
vec3 p;
float dHit, h, s, sLo, sHi;
s = 0.;
sLo = 0.;
dHit = dstFar;
for (int j = 0; j < 150; j ++) {
p = ro + s * rd;
h = p.y - WaveHt (p);
if (h < 0.) break;
sLo = s;
s += max (0.2, h) + 0.005 * s;
if (s > dstFar) break;
}
if (h < 0.) {
sHi = s;
for (int j = 0; j < 7; j ++) {
s = 0.5 * (sLo + sHi);
p = ro + s * rd;
h = step (0., p.y - WaveHt (p));
sLo += h * (s - sLo);
sHi += (1. - h) * (s - sHi);
}
dHit = sHi;
}
return dHit;
}
float WaveOutRay (vec3 ro, vec3 rd)
{
vec3 p;
float dHit, h, s, sLo, sHi;
s = 0.;
sLo = 0.;
dHit = dstFar;
ro.y *= -1.;
rd.y *= -1.;
for (int j = 0; j < 150; j ++) {
p = ro + s * rd;
h = p.y + WaveHt (p);
if (h < 0.) break;
sLo = s;
s += max (0.2, h) + 0.005 * s;
if (s > dstFar) break;
}
if (h < 0.) {
sHi = s;
for (int j = 0; j < 7; j ++) {
s = 0.5 * (sLo + sHi);
p = ro + s * rd;
h = step (0., p.y + WaveHt (p));
sLo += h * (s - sLo);
sHi += (1. - h) * (s - sHi);
}
dHit = sHi;
}
return dHit;
}
vec3 WaveNf (vec3 p, float d)
{
vec2 e = vec2 (max (0.1, 5e-5 * d * d), 0.);
float h = WaveHt (p);
return normalize (vec3 (h - WaveHt (p + e.xyy), e.x, h - WaveHt (p + e.yyx)));
}
float ObjDf (vec3 p)
{
vec3 q;
float dHit, d;
dHit = dstFar;
q = p;
q -= ballPos;
q *= ballMat;
d = PrSphDf (q, 2.);
if (d < dHit) { dHit = d; idObj = 1; qHit = q; }
q.y -= 3.;
d = PrCylDf (q.xzy, 0.05, 1.);
if (d < dHit) { dHit = d; idObj = 2; qHit = q; }
q.y -= 1.3;
d = PrCylDf (q.xzy, 0.15, 0.3);
if (d < dHit) { dHit = d; idObj = 3; qHit = q; }
return dHit;
}
float ObjRay (in vec3 ro, in vec3 rd)
{
float d, dHit;
dHit = 0.;
for (int j = 0; j < 150; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < 0.002 || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjNf (vec3 p)
{
const vec3 e = vec3 (0.001, -0.001, 0.);
vec4 v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy),
ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
vec3 ObjCol (vec3 n)
{
vec3 col;
col = vec3 (0.);
if (idObj == 1) {
col = vec3 (1., 0.01, 0.);
if (abs (qHit.y) < 0.21) col =
(mod (floor (7. * (atan (qHit.x, qHit.z) / pi + 1.)), 2.) == 0.) ?
vec3 (1., 0.8, 0.08) : vec3 (0.04);
else if (qHit.y > 1.93) col = vec3 (0.15, 0.05, 0.);
else if (abs (qHit.y) < 0.25) col = vec3 (1., 0.8, 0.08);
else if (abs (abs (qHit.y) - 0.55) < 0.05) col = vec3 (1.);
else if (abs (abs (qHit.y) - 0.65) < 0.05) col = vec3 (0.04);
if (qHit.y < 0.) col = mix (col, vec3 (0.05, 0.2, 0.05),
min (- 2. * qHit.y, 0.9));
} else if (idObj == 2) {
col = vec3 (0.6, 0.4, 0.2);
} else if (idObj == 3) {
if (abs (qHit.y) < 0.2)
col = vec3 (0., 1., 0.) * (2. + 1.5 * cos (10. * tCur));
else col = vec3 (0.6, 0.4, 0.2);
}
return col;
}
float ObjSShadow (vec3 ro, vec3 rd)
{
float sh, d, h;
sh = 1.;
d = 0.1;
for (int j = 0; j < 40; j ++) {
h = ObjDf (ro + rd * d);
sh = min (sh, 20. * h / d);
d += 0.1;
if (h < 0.001) break;
}
return clamp (sh, 0., 1.);
}
vec3 ObjRender (vec3 ro, vec3 rd)
{
vec3 col, vn;
float dif, bk, sh, cc;
int idObjT;
idObjT = idObj;
vn = ObjNf (ro);
idObj = idObjT;
if (idObj == 1) {
vn = VaryNf (20. * qHit, vn, 0.3);
if (qHit.y < 0.) vn = mix (vn, VaryNf (12. * qHit, vn, 2.),
min (- 5. * qHit.y, 1.));
}
col = ObjCol (rd);
cc = 1. - smoothstep (0.3, 0.6, fCloud);
sh = ObjSShadow (ro, sunDir);
bk = max (dot (vn, - normalize (vec3 (sunDir.x, 0., sunDir.z))), 0.);
dif = max (dot (vn, sunDir), 0.);
return col * (0.2 + 0.1 * bk + max (0., dif) * (0.7 + 0.3 * cc * sh)) +
0.3 * cc * sh * sunCol * pow (max (0., dot (sunDir, reflect (rd, vn))), 32.);
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec3 col, vn, rdd, refCol, uwatCol;
float dstHit, dstWat, dif, bk, sh, foamFac;
const float eta = 0.75, att = 0.5;
int idObjT;
bool doReflect;
if (ro.y > WaveHt (ro)) {
dstWat = WaveRay (ro, rd);
idObj = -1;
dstHit = ObjRay (ro, rd);
if (idObj < 0) dstHit = dstFar;
doReflect = (dstWat < dstFar && dstWat < dstHit);
if (doReflect) {
ro += rd * dstWat;
vn = WaveNf (ro, dstWat);
rdd = rd;
rd = reflect (rd, vn);
idObj = -1;
dstHit = ObjRay (ro, rd);
if (idObj < 0) dstHit = dstFar;
}
col = (dstHit < dstFar) ? ObjRender (ro + rd * dstHit, rd) :
SkyGrndCol (ro, rd);
if (doReflect) {
refCol = col;
rd = refract (rdd, vn, eta);
idObj = -1;
dstHit = ObjRay (ro, rd);
if (idObj < 0) dstHit = dstFar;
col = (dstHit < dstFar) ? ObjRender (ro + rd * dstHit, rd) *
exp (- att * dstHit) : SeaFloorCol (rd);
col = mix (col, 0.8 * refCol, pow (1. - abs (dot (rdd, vn)), 5.));
foamFac = pow (clamp (WaveHt (ro) +
0.004 * Fbm3 (256. * ro) - 0.65, 0., 1.), 8.);
col = mix (col, vec3 (1.), foamFac);
}
} else {
uwatCol = vec3 (0., 0.05, 0.05) +
step (0.4, Fbm1 (20. * tCur)) * vec3 (0.02, 0.02, 0.03);
col = uwatCol;
dstWat = WaveOutRay (ro, rd);
idObj = -1;
dstHit = ObjRay (ro, rd);
if (idObj < 0) dstHit = dstFar;
if (dstWat < dstFar && dstWat < dstHit) {
ro += rd * dstWat;
vn = - WaveNf (ro, dstWat);
rdd = refract (rd, vn, 1. / eta);
if (length (rdd) > 0.) rd = rdd;
else rd = reflect (rd, vn);
idObj = -1;
dstHit = ObjRay (ro, rd);
if (idObj < 0) dstHit = dstFar;
if (dstHit < dstFar) col = 0.9 * ObjRender (ro + rd * dstHit, rd);
else if (rd.y > 0.) col = mix (uwatCol, 0.9 * SkyGrndCol (ro, rd),
exp (- 0.07 * att * dstWat));
} else if (dstHit < dstFar) col = mix (uwatCol,
ObjRender (ro + rd * dstHit, rd), exp (- 0.07 * att * dstHit));
}
return col;
}
void BallPM ()
{
const vec3 e = vec3 (1., 0., 0.);
float h[5], b;
ballPos = vec3 (0., 0., 0.);
h[0] = WaveHt (ballPos);
h[1] = WaveHt (ballPos + e.yyx); h[2] = WaveHt (ballPos - e.yyx);
h[3] = WaveHt (ballPos + e); h[4] = WaveHt (ballPos - e);
ballPos.y = 0.5 + (2. * h[0] + h[1] + h[2] + h[3] + h[4]) / 9.;
b = (h[1] - h[2]) / (4. * e.x);
ballMat[2] = normalize (vec3 (0., b, 1.));
b = (h[3] - h[4]) / (4. * e.x);
ballMat[1] = normalize (cross (ballMat[2], vec3 (1., b, 0.)));
ballMat[0] = cross (ballMat[1], ballMat[2]);
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = 2. * fragCoord.xy / iResolution.xy - 1.;
uv.x *= iResolution.x / iResolution.y;
tCur = iGlobalTime;
#ifdef MOUSE
vec4 mPtr = iMouse;
mPtr.xy = mPtr.xy / iResolution.xy - 0.5;
#endif
mat3 vuMat;
vec3 col, ro, rd;
vec2 vEl, vAz;
float el, az, zmFac, a, tPer, tSeq;
cloudDisp = 10. * tCur * vec3 (1., 0., 1.);
waterDisp = 0.5 * tCur * vec3 (-1., 0., 1.);
sunDir = normalize (vec3 (0.2, 0.5, 0.5));
sunCol = vec3 (1., 0.4, 0.3) + vec3 (0., 0.5, 0.2) * sunDir.y;
fCloud = 0.5 + 0.2 * sin (0.022 * 2. * pi * tCur);
zmFac = 3.5;
tPer = 35.;
#ifdef MOUSE
if (mPtr.z <= 0.) {
az = 0.01 * tCur;
el = 0.2 * pi;
tSeq = mod (tCur, tPer);
if (mod (floor (tCur / tPer), 2.) == 0.) {
a = SmoothBump (10., 30., 5., tSeq);
zmFac -= 0.1 * a;
el -= 0.19 * pi * a;
} else {
a = SmoothBump (8., 26., 8., tSeq);
zmFac -= 0.05 * a;
el -= 0.55 * pi * a;
}
}
else
{
az = 1.1 * pi * mPtr.x;
el = 0.02 * pi - 0.7 * pi * mPtr.y;
}
#else
{
az = 0.01 * tCur;
el = 0.2 * pi;
tSeq = mod (tCur, tPer);
if (mod (floor (tCur / tPer), 2.) == 0.) {
a = SmoothBump (10., 30., 5., tSeq);
zmFac -= 0.1 * a;
el -= 0.19 * pi * a;
} else {
a = SmoothBump (8., 26., 8., tSeq);
zmFac -= 0.05 * a;
el -= 0.55 * pi * a;
}
}
#endif
vEl = vec2 (cos (el), sin (el));
vAz = vec2 (cos (az), sin (az));
rd = normalize (vec3 (uv, zmFac));
vuMat = mat3 (1., 0., 0., 0., vEl.x, - vEl.y, 0., vEl.y, vEl.x) *
mat3 (vAz.x, 0., vAz.y, 0., 1., 0., - vAz.y, 0., vAz.x);
rd = rd * vuMat;
ro = vec3 (0., 0., -20.) * vuMat;
ro.y += 2.;
BallPM ();
col = ShowScene (ro, rd);
fragColor = vec4 (sqrt (clamp (col, 0., 1.)), 1.);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

527
procedural/dr2-white-folly.slang Normal file
View File

@ -0,0 +1,527 @@
#version 450
// White Folly - dr2 - 2017-11-07
// https://www.shadertoy.com/view/ll2cDG
// Folly (architectural) with spiral stairways (in a pond filled with Voronoi stones); mouse enabled
// "White Folly" by dr2 - 2017
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
float PrBoxDf (vec3 p, vec3 b);
float PrBox2Df (vec2 p, vec2 b);
float PrCylDf (vec3 p, float r, float h);
float PrCylAnDf (vec3 p, float r, float w, float h);
void HexVorInit ();
vec4 HexVor (vec2 p);
float SmoothMin (float a, float b, float r);
float SmoothBump (float lo, float hi, float w, float x);
vec2 Rot2D (vec2 q, float a);
vec3 HsvToRgb (vec3 c);
float Hashfv2 (vec2 p);
vec2 Hashv2v2 (vec2 p);
float Noisefv2 (vec2 p);
float Fbm2 (vec2 p);
vec3 VaryNf (vec3 p, vec3 n, float f);
const float pi = 3.14159;
vec3 sunDir, qHit;
float dstFar, tCur, tWav;
int idObj;
bool inWat;
const int idStr = 1, idBal = 2, idPlat = 3, idBalc = 4, idPil = 5, idWl = 6, idFlr = 7;
float ObjDfS (vec3 p, float dMin)
{
vec3 q;
float d, db, s, a;
q = p;
q.xz = abs (Rot2D (q.xz, pi)) - 6.5;
db = PrBox2Df (q.xz, vec2 (4.));
q.xz += 6.5;
q.xz = Rot2D (q.xz, 0.75 * pi);
q.x += 4.;
a = (length (q.xz) > 0.) ? atan (q.z, - q.x) / (2. * pi) : 0.;
q.xz = vec2 (24. * a, length (q.xz) - 6.);
q.xy = Rot2D (q.xy, -0.25 * pi);
s = mod (q.x, sqrt (0.5));
d = max (0.3 * max (q.y - min (s, sqrt (0.5) - s), max (-0.1 - q.y, abs (q.z) - 1.5)),
abs (p.y) - 3.5);
d = max (d, db);
if (d < dMin) { dMin = d; idObj = idStr; }
q.xy -= vec2 (1.5, 1.4);
q.z = abs (q.z) - 1.43;
d = PrBoxDf (q, vec3 (4.7, 0.07, 0.07));
q.x = 0.5 * mod (96. * a + 0.5, 1.) - 0.35;
q.y += 0.7;
d = min (d, PrCylDf (q.xzy, 0.05, 0.7));
d = max (0.3 * d, db);
if (d < dMin) { dMin = d; idObj = idBal; }
return dMin;
}
/*
This function is called twice, for the two orientations of the horizontal
walkway. Could be replaced by a single call, with orientation dependent on
position along ray path; this is faster (good) but there are visual artifacts for
certain view directions (bad). Artifacts can be removed by using cells in the
vertical direction (good), but this is slower (bad).
*/
float ObjDfB (vec3 p, float dMin)
{
vec3 q;
float d;
q = p;
d = max (PrBoxDf (q, vec3 (10.35, 0.26, 2.85)),
- max (length (vec2 (mod (q.x + 2., 4.) - 2., q.z)) - 1.5, 0.3 - abs (q.z)));
if (d < dMin) { dMin = d; idObj = idPlat; qHit = q; }
q = p; q.y -= 2.05; q.z = abs (q.z) - 2.45;
d = PrBoxDf (q, vec3 (7.45, 0.08, 0.07));
q.x = mod (q.x + 0.25, 0.5) - 0.25;
q.y += 0.95;
d = min (d, max (PrCylDf (q.xzy, 0.06, 0.9), abs (p.x) - 7.45));
q = p; q.y -= 1.06; q.x = abs (q.x) - 10.23; q.y -= 0.95;
d = min (d, PrBoxDf (q, vec3 (0.07, 0.08, 2.5)));
q.y += 0.95; q.z = mod (q.z + 0.25, 0.5) - 0.25;
d = min (d, max (PrCylDf (q.xzy, 0.06, 0.9), abs (p.z) - 2.45));
if (d < dMin) { dMin = d; idObj = idBalc; }
q = p; q.xz = abs (q.xz) - vec2 (8.8, 2.4); q.x = abs (q.x) - 1.45; q.y -= 1.3;
d = PrCylDf (q.xzy, 0.2, 1.05);
if (d < dMin) { dMin = d; idObj = idPil; qHit = q; }
return dMin;
}
float ObjDf (vec3 p)
{
vec3 q;
float dMin, d;
dMin = dstFar;
p.y -= 3.;
if (! inWat) {
dMin = ObjDfS (p, dMin);
q = p; q.y -= 3.25;
dMin = ObjDfB (q, dMin);
q = p; q.y -= -3.25; q.xz = vec2 (- q.z, q.x);
dMin = ObjDfB (q, dMin);
q = p; q.y -= 9.;
d = max (PrBoxDf (q, vec3 (2.5, 0.15, 2.5)),
- max (length (q.xz) - 1., max (0.1 - abs (q.x), 0.1 - abs (q.z))));
if (d < dMin) { dMin = d; idObj = idPlat; qHit = q; }
}
q = p; q.xz = abs (q.xz) - 1.8; q.y -= 1.;
d = PrCylDf (q.xzy, 0.2, 8.);
if (d < dMin) { dMin = d; idObj = idPil; qHit = q; }
q = p; q.y -= -5.2;
d = PrCylAnDf (q.xzy, 20., 0.3, 2.3);
if (d < dMin) { dMin = d; idObj = idWl; }
q = p; q.y -= -7.4;
d = PrCylDf (q.xzy, 20., 0.01);
if (d < dMin) { dMin = d; idObj = idFlr; }
return dMin;
}
float ObjRay (vec3 ro, vec3 rd)
{
float dHit, d, eps;
eps = 0.001;
dHit = 0.;
for (int j = 0; j < 160; j ++) {
d = ObjDf (ro + dHit * rd);
dHit += d;
if (d < eps || dHit > dstFar) break;
}
return dHit;
}
vec3 ObjNf (vec3 p)
{
vec4 v;
vec3 e = vec3 (0.001, -0.001, 0.);
v = vec4 (ObjDf (p + e.xxx), ObjDf (p + e.xyy), ObjDf (p + e.yxy), ObjDf (p + e.yyx));
return normalize (vec3 (v.x - v.y - v.z - v.w) + 2. * v.yzw);
}
float ObjSShadow (vec3 ro, vec3 rd)
{
float sh, d, h;
sh = 1.;
d = 0.05;
for (int j = 0; j < 40; j ++) {
h = ObjDf (ro + rd * d);
sh = min (sh, smoothstep (0., 0.05 * d, h));
d += h;
if (sh < 0.05) break;
}
return sh;
}
vec3 BgCol (vec3 ro, vec3 rd)
{
vec3 col;
if (rd.y >= 0.) col = mix (vec3 (0.1, 0.2, 0.4), vec3 (1.), 0.1 + 0.8 * rd.y);
else {
ro -= ((ro.y + 0.5) / rd.y) * rd;
col = mix (0.7 * mix (vec3 (0.3, 0.4, 0.1), vec3 (0.4, 0.5, 0.2), Fbm2 (ro.xz)) *
(1. - 0.15 * Noisefv2 (330. * ro.xz)), vec3 (0.18, 0.28, 0.48), pow (1. + rd.y, 5.));
}
return col;
}
float WaveHt (vec2 p)
{
mat2 qRot = mat2 (0.8, -0.6, 0.6, 0.8);
vec4 t4, v4;
vec2 t;
float wFreq, wAmp, ht;
wFreq = 1.;
wAmp = 1.;
ht = 0.;
for (int j = 0; j < 3; j ++) {
p *= qRot;
t = tWav * vec2 (1., -1.);
t4 = (p.xyxy + t.xxyy) * wFreq;
t = vec2 (Noisefv2 (t4.xy), Noisefv2 (t4.zw));
t4 += 2. * t.xxyy - 1.;
v4 = (1. - abs (sin (t4))) * (abs (sin (t4)) + abs (cos (t4)));
ht += wAmp * dot (pow (1. - sqrt (v4.xz * v4.yw), vec2 (8.)), vec2 (1.));
wFreq *= 2.;
wAmp *= 0.5;
}
return ht;
}
vec3 WaveNf (vec3 p, float d)
{
vec3 vn;
vec2 e;
e = vec2 (max (0.01, 0.005 * d * d), 0.);
p *= 0.5;
vn.xz = 3. * (WaveHt (p.xz) - vec2 (WaveHt (p.xz + e.xy), WaveHt (p.xz + e.yx)));
vn.y = e.x;
return normalize (vn);
}
vec3 ShowScene (vec3 ro, vec3 rd)
{
vec4 vc;
vec3 vn, vnw, row, rdw, col;
float dstObj, dstWat, s, a, sh;
bool isRefl;
HexVorInit ();
inWat = false;
isRefl = false;
tWav = 0.3 * tCur;
dstObj = ObjRay (ro, rd);
dstWat = - (ro.y + 0.6) / rd.y;
if (dstWat < min (dstObj, dstFar) && length ((ro + dstWat * rd).xz) < 20.) {
ro += dstWat * rd;
row = ro;
rdw = rd;
vnw = WaveNf (1.5 * ro, dstWat);;
rd = refract (rd, vnw, 1./1.333);
ro += 0.01 * rd;
inWat = true;
dstObj = ObjRay (ro, rd);
inWat = false;
isRefl = true;
}
if (dstObj < dstFar) {
ro += rd * dstObj;
if (ro.y < -0.5 && length (ro.xz) > 20.3) col = BgCol (ro, rd);
else {
vn = ObjNf (ro);
if (idObj == idStr) {
col = vec3 (0.95, 0.95, 1.);
} else if (idObj == idBal || idObj == idBalc) {
col = vec3 (0.8, 0.8, 1.);
} else if (idObj == idPlat) {
col = vec3 (1.);
if (vn.y > 0.99) {
if (ro.y > 7.5) s = mod (3. * length (qHit.xz), 1.);
else s = mod (3. * qHit.x, 1.);
col *= 0.8 + 0.2 * SmoothBump (0.1, 0.9, 0.03, s);
} else if (abs (vn.y) < 0.01) {
s = mod (8. * ro.y, 1.);
col *= 0.8 + 0.2 * SmoothBump (0.1, 0.9, 0.03, s);
}
vn = VaryNf (100. * ro, vn, 0.2);
} else if (idObj == idPil) {
if (abs (vn.y) < 0.01) {
a = (length (qHit.xz) > 0.) ? atan (qHit.z, - qHit.x) / pi : 0.;
s = mod (3. * qHit.y + a, 1.);
vn.y = 0.2 * (1. - SmoothBump (0.2, 0.8, 0.1, s)) * sign (s - 0.5);
vn.xz *= sqrt (1. - vn.y * vn.y);
}
col = vec3 (0.9, 0.9, 0.3);
} else if (idObj == idWl) {
a = (length (ro.xz) > 0.) ? atan (ro.z, - ro.x) / pi : 0.;
col = vec3 (0.6, 0.4, 0.3) * (0.5 +
0.5 * SmoothBump (0.05, 0.95, 0.02, mod (64. * a, 1.))) *
(0.5 + 0.5 * SmoothBump (0.03, 0.97, 0.01, mod (ro.y + 0.5, 1.)));
vn = VaryNf (20. * ro, vn, 1.);
} else if (idObj == idFlr) {
vc = HexVor (ro.xz);
vn.xz = - 0.7 * vc.yz;
vn = normalize (vn);
s = mod (10. * vc.w, 1.);
col = HsvToRgb (vec3 (0.1 + 0.3 * step (2. * s, 1.) + 0.1 * mod (5. * s, 1.),
0.5 + 0.5 * mod (17. * s, 1.), 0.7 + 0.3 * mod (12. * s, 1.))) *
(0.6 + 0.4 * smoothstep (0., 0.2, vc.x)) * (1. - 0.2 * Noisefv2 (128. * ro.xz));
}
sh = 0.4 + 0.6 * ObjSShadow (ro, sunDir);
col = col * (0.2 + sh * max (dot (sunDir, vn), 0.) +
0.1 * max (dot (- sunDir.xz, vn.xz), 0.)) +
0.1 * sh * pow (max (dot (normalize (sunDir - rd), vn), 0.), 64.);
}
} else {
if (isRefl) sh = ObjSShadow (row, sunDir);
col = BgCol (ro, rd);
}
if (isRefl) {
col = mix (0.9 * col, vec3 (1., 1., 0.9), sh *
pow (max (0., dot (sunDir, reflect (rdw, vnw))), 64.));
}
return clamp (col, 0., 1.);
}
void mainImage (out vec4 fragColor, in vec2 fragCoord)
{
mat3 vuMat;
#ifdef MOUSE
vec4 mPtr;
#endif
vec3 ro, rd;
vec2 canvas, uv, ori, ca, sa;
float el, az, zmFac;
canvas = iResolution.xy;
uv = 2. * fragCoord.xy / canvas - 1.;
uv.x *= canvas.x / canvas.y;
tCur = iGlobalTime;
#ifdef MOUSE
mPtr = iMouse;
mPtr.xy = mPtr.xy / canvas - 0.5;
#endif
dstFar = 120.;
az = 0.;
el = -0.2 * pi;
#ifdef MOUSE
if (mPtr.z > 0.) {
az += 3. * pi * mPtr.x;
el += 1. * pi * mPtr.y;
} else {
az -= 0.1 * tCur;
el -= 0.1 * pi * cos (0.03 * pi * tCur);
}
#else
az -= 0.1 * tCur;
el -= 0.1 * pi * cos (0.03 * pi * tCur);
#endif
el = clamp (el, -0.4 * pi, -0.05 * pi);
ori = vec2 (el, az);
ca = cos (ori);
sa = sin (ori);
vuMat = mat3 (ca.y, 0., - sa.y, 0., 1., 0., sa.y, 0., ca.y) *
mat3 (1., 0., 0., 0., ca.x, - sa.x, 0., sa.x, ca.x);
zmFac = 7. - 2. * cos (az);
rd = vuMat * normalize (vec3 (uv, zmFac));
ro = vuMat * vec3 (0., 1., -70.);
sunDir = vuMat * normalize (vec3 (1., 1., -1.));
fragColor = vec4 (ShowScene (ro, rd), 1.);
}
float PrBoxDf (vec3 p, vec3 b)
{
vec3 d;
d = abs (p) - b;
return min (max (d.x, max (d.y, d.z)), 0.) + length (max (d, 0.));
}
float PrBox2Df (vec2 p, vec2 b)
{
vec2 d;
d = abs (p) - b;
return min (max (d.x, d.y), 0.) + length (max (d, 0.));
}
float PrCylDf (vec3 p, float r, float h)
{
return max (length (p.xy) - r, abs (p.z) - h);
}
float PrCylAnDf (vec3 p, float r, float w, float h)
{
return max (abs (length (p.xy) - r) - w, abs (p.z) - h);
}
vec2 gVec[7], hVec[7];
#define SQRT3 1.7320508
vec2 PixToHex (vec2 p)
{
vec3 c, r, dr;
c.xz = vec2 ((1./SQRT3) * p.x - (1./3.) * p.y, (2./3.) * p.y);
c.y = - c.x - c.z;
r = floor (c + 0.5);
dr = abs (r - c);
r -= step (dr.yzx, dr) * step (dr.zxy, dr) * dot (r, vec3 (1.));
return r.xz;
}
vec2 HexToPix (vec2 h)
{
return vec2 (SQRT3 * (h.x + 0.5 * h.y), (3./2.) * h.y);
}
void HexVorInit ()
{
vec3 e = vec3 (1., 0., -1.);
gVec[0] = e.yy;
gVec[1] = e.xy;
gVec[2] = e.yx;
gVec[3] = e.xz;
gVec[4] = e.zy;
gVec[5] = e.yz;
gVec[6] = e.zx;
for (int k = 0; k < 7; k ++) hVec[k] = HexToPix (gVec[k]);
}
vec4 HexVor (vec2 p)
{
vec4 sd, udm;
vec2 ip, fp, d, u;
float amp, a;
amp = 0.7;
ip = PixToHex (p);
fp = p - HexToPix (ip);
sd = vec4 (4.);
udm = vec4 (4.);
for (int k = 0; k < 7; k ++) {
u = Hashv2v2 (ip + gVec[k]);
a = 2. * pi * (u.y - 0.5);
d = hVec[k] + amp * (0.4 + 0.6 * u.x) * vec2 (cos (a), sin (a)) - fp;
sd.w = dot (d, d);
if (sd.w < sd.x) {
sd = sd.wxyw;
udm = vec4 (d, u);
} else sd = (sd.w < sd.y) ? sd.xwyw : ((sd.w < sd.z) ? sd.xyww : sd);
}
sd.xyz = sqrt (sd.xyz);
return vec4 (SmoothMin (sd.y, sd.z, 0.3) - sd.x, udm.xy, Hashfv2 (udm.zw));
}
float SmoothMin (float a, float b, float r)
{
float h;
h = clamp (0.5 + 0.5 * (b - a) / r, 0., 1.);
return mix (b, a, h) - r * h * (1. - h);
}
float SmoothBump (float lo, float hi, float w, float x)
{
return (1. - smoothstep (hi - w, hi + w, x)) * smoothstep (lo - w, lo + w, x);
}
vec2 Rot2D (vec2 q, float a)
{
return q * cos (a) + q.yx * sin (a) * vec2 (-1., 1.);
}
vec3 HsvToRgb (vec3 c)
{
vec3 p;
p = abs (fract (c.xxx + vec3 (1., 2./3., 1./3.)) * 6. - 3.);
return c.z * mix (vec3 (1.), clamp (p - 1., 0., 1.), c.y);
}
const float cHashM = 43758.54;
float Hashfv2 (vec2 p)
{
return fract (sin (dot (p, vec2 (37., 39.))) * cHashM);
}
vec2 Hashv2v2 (vec2 p)
{
vec2 cHashVA2 = vec2 (37., 39.);
return fract (sin (vec2 (dot (p, cHashVA2), dot (p + vec2 (1., 0.), cHashVA2))) * cHashM);
}
float Noisefv2 (vec2 p)
{
vec2 t, ip, fp;
ip = floor (p);
fp = fract (p);
fp = fp * fp * (3. - 2. * fp);
t = mix (Hashv2v2 (ip), Hashv2v2 (ip + vec2 (0., 1.)), fp.y);
return mix (t.x, t.y, fp.x);
}
float Fbm2 (vec2 p)
{
float f, a;
f = 0.;
a = 1.;
for (int i = 0; i < 5; i ++) {
f += a * Noisefv2 (p);
a *= 0.5;
p *= 2.;
}
return f * (1. / 1.9375);
}
float Fbmn (vec3 p, vec3 n)
{
vec3 s;
float a;
s = vec3 (0.);
a = 1.;
for (int i = 0; i < 5; i ++) {
s += a * vec3 (Noisefv2 (p.yz), Noisefv2 (p.zx), Noisefv2 (p.xy));
a *= 0.5;
p *= 2.;
}
return dot (s, abs (n));
}
vec3 VaryNf (vec3 p, vec3 n, float f)
{
vec3 g;
vec2 e = vec2 (0.1, 0.);
g = vec3 (Fbmn (p + e.xyy, n), Fbmn (p + e.yxy, n), Fbmn (p + e.yyx, n)) - Fbmn (p, n);
return normalize (n + f * (g - n * dot (n, g)));
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

91
procedural/fabriceneyret2-skyline-3d.slang Normal file
View File

@ -0,0 +1,91 @@
#version 450
// Skyline 3D - FabriceNeyret2 - 2015-07-02
// https://www.shadertoy.com/view/4tlSWr
// in the spirit of the 2D skylines (e.g., https://www.shadertoy.com/view/4tlXzM )... but in 3D :-) ( I even reproduced the original temporal aliasing :-D )
// Be sure to wait long enough ;-)
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define T iGlobalTime
// --- using the base ray-marcher of Trisomie21: https://www.shadertoy.com/view/4tfGRB#
vec4 bg = vec4(0); // vec4(0,0,.3,0);
void mainImage( out vec4 f, vec2 w ) {
vec4 p = vec4(w,0,1)/iResolution.yyxy-.5, d,c; p.x-=.4; // init ray
// r(p.xz,.13); r(p.yz,.2); r(p.xy,.1); // camera rotations
d =p; // ray dir = ray0-vec3(0)
p.x += 15.*T; p += 2.*d;
f = bg;
float l,x=1e9, closest = 999.;
for (float i=1.; i>0.; i-=.01) {
vec4 u = floor(p/8.), t = mod(p, 8.)-4., ta; // objects id + local frame
u.y = 0.;
u = sin(78.17*(u+u.yzxw)); // randomize ids
c = p/p*1.2;
ta = abs(t);
x=1e9;
if (sin(17.*(u.x+u.y+u.z))>.95) { // 10% of blocks
ta.y = p.y + 30.*u.x - .3*pow(abs(.03*floor(p.z)),3.) + 35.;
x = max(ta.x,max(ta.y,ta.z)) -3.;
}
closest = min(closest, p.y+150.);
// artifacts: passed a object, we might be fooled about dist to next (hidden in next modulo-tile)
#if 1 // if dist to box border is closest to object, go there. <<< the working solution ! (at mod8 scale)
vec4 k, k1 = (4.-t)/d ,k2 = (-4.-t)/d, dd;
k = min (k1-1e5*sign(k1),k2-1e5*sign(k2))+1e5; // ugly trick to get the min only if positive.
// 2 less ugly/costly formulations, but less robust close to /0 :
// k = mix(k1,k2, .5+.5*sign(k2));
// dd = d+.001*clamp(1.-d*d,.999,1.); k = (4.*sign(dd)-t)/dd;
l = min(k.x,min(k.y,k.z));
if (l<x) { p+= 1.*d*(l+0.01); continue; }
#endif
// if (x<.01) c = texture(iChannel0,.1*(p.xy+p.yz));
if(x<.01) // hit !
{ f = mix(bg,c,i*i); break; } // color texture + black fog
p += d*x; // march ray
}
//if (length(f)==0.) f = vec4(1,1,.6,0)*smoothstep(.31,.3,length(w/iResolution.y-vec2(1.3,.7)));
f += vec4(1) * exp(-.01*closest)*(.5+.5*cos(1.+T/8.)); // thanks kuvkar !
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

114
procedural/greendestruction-ironicflux.slang Normal file
View File

@ -0,0 +1,114 @@
#version 450
// ironicflux - greendestruction - 2018-02-22
// https://www.shadertoy.com/view/MdcyzB
// The words of these songs were composed without any human intervention whatever on an instrument known as a versificator. But the woman sang so tunefully as to turn the dreadful rubbish into an almost pleasant sound.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
/* it even comes with a little message */
mat2 rot(float x) {
return mat2(cos(x), sin(x), -sin(x), cos(x));
}
float map(vec3 p) {
p.z = abs(p.z) - 2.0;
p.z = abs(p.z) - 2.0;
float gt = iGlobalTime * 2.0;
p.x += gt;
float d = 1000.0;
const int n = 12;
for (int i = 1; i < n; ++i) {
float x = float(i) / float(n);
vec3 q = p;
q.x += x * 3.141592 * 1.0;
q.z = abs(q.z) - 1.0;
q.yz *= rot(x * q.x);
q.y = abs(q.y) - 2.0;
q.y += x * 3.141592 * 0.5;
float k = length(q.yz) - 0.125;
d = min(d, k);
d = max(d, 1.5 * x + gt - p.x);
}
return min(d, 5.0 + gt - p.x);
}
float trace(vec3 o, vec3 r) {
float t = 0.0;
for (int i = 0; i < 32; ++i) {
t += map(o + r * t) * 0.5;
}
return t;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = fragCoord.xy / iResolution.xy;
uv = uv * 2.0 - 1.0;
uv.x *= iResolution.x / iResolution.y;
vec3 r = normalize(vec3(uv, 1.0 - dot(uv, uv) * 0.5));
vec3 o = vec3(0.0, 0.0, 0.0);
r.xz *= rot(3.141592 * 0.5);
float t = trace(o, r);
vec3 w = o + r * t;
float fd = map(w);
float f = 1.0 / (1.0 + t * t * 0.1 + fd * 1000.0);
vec3 c = vec3(0.0, 0.5, 1.0) * f;
c = mix(c, vec3(1.0), 1.0 / (1.0 + t * t * 0.1));
c = mix(vec3(0.125), c, 1.0 / (1.0 + t * t * 0.1));
vec3 fc = vec3(c);
float b = sign((fract(uv.y * 16.0) - 0.5) / 16.0) * 0.5 + 0.5;
float b2 = sign(0.8 - abs(uv.y)) * 0.5 + 0.5;
fc = mix(fc * vec3(0.5, 0.5, 0.5), fc, b);
fc *= b2;
fragColor = vec4(fc, 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

288
procedural/kali-emerging.slang Normal file
View File

@ -0,0 +1,288 @@
#version 450
// Emerging - Kali - 2015-03-10
// https://www.shadertoy.com/view/XlfGWI
// An emerging fractal tower. You can use the mouse. Or not.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define ENABLE_HARD_SHADOWS // turn off to enable faster AO soft shadows
#define RAY_STEPS 80
#define SHADOW_STEPS 50
#define LIGHT_COLOR vec3(.97,.92,.82)
#define AMBIENT_COLOR vec3(.57,.55,.6)
#define FLOOR_COLOR vec3(.35,.25,.2)
#define ENERGY_COLOR vec3(1.,.7,.4)
#define BRIGHTNESS 1.5
#define GAMMA 1.2
#define SATURATION .9
#define detail .00003
#define t iGlobalTime*.1
float cc,ss;
vec3 lightdir=normalize(vec3(0.5,-0.4,-1.));
vec3 ambdir=normalize(vec3(0.,0.,1.));
const vec3 origin=vec3(0.,3.11,0.);
float det=0.0;
vec3 pth1;
float smin( float a, float b, float k )
{
float h = clamp( 0.5+0.5*(b-a)/k, 0.0, 1.0 );
return mix( b, a, h ) - k*h*(1.0-h);
}
mat2 rot(float a) {
return mat2(cos(a),sin(a),-sin(a),cos(a));
}
vec3 path(float ti) {
return vec3(0.,2.5,0.)+vec3(cos(ti)*.9,cos(ti*.5),sin(ti)*.8);
}
vec4 formula (vec4 p) {
p.y-=t*.25;
p.y=abs(3.-mod(p.y-t,6.));
for (int i=0; i<6; i++) {
p.xyz = abs(p.xyz)-vec3(.0,1.,.0);
p=p*1.6/clamp(dot(p.xyz,p.xyz),.2,1.)-vec4(0.4,1.5,0.4,0.);
p.xz*=mat2(cc,ss,-ss,cc);
}
return p;
}
float texture1(vec3 p) {
p=abs(1.-mod(p,2.));
vec3 c=vec3(3.);
float es=1000., l=0.;
for (int i = 0; i < 8; i++) {
p = abs(p + c) - abs(p - c) - p;
p/= clamp(dot(p, p), .25, 1.);
p = p* -1.5 + c;
es=min(min(abs(p.x),abs(p.y)),es);
}
return es*es;
}
float texture2 (vec3 p) {
//p.xz=abs(.75-mod(p.xz,1.5));
p=formula(vec4(p,0.)).xyz;
return .13+clamp(pow(max(0.,1.-max(abs(p.x),abs(p.z))),2.)*2.,.1,.7);
}
vec2 de(vec3 pos) {
float aa=smoothstep(0.,1.,clamp(cos(t-pos.y*.4)*1.5,0.,1.))*3.14159;
cc=cos(aa);ss=sin(aa);
float hid=0.;
vec3 tpos=pos;
//tpos.xz=abs(1.5-mod(tpos.xz,3.))-1.5;
vec4 p=vec4(tpos,1.);
float y=max(0.,.3-abs(pos.y-3.3))/.3;
p=formula(p);
float fl=pos.y-3.7-length(sin(pos.xz*60.))*.01;
float fr=max(abs(p.z/p.w)-.01,length(p.zx)/p.w-.002);
float bl=max(abs(p.x/p.w)-.01,length(p.zy)/p.w-.0005);
fr=smin(bl,fr,.02);
fr*=.9;
//float fr=length(p.xyz)/p.w;
fl-=(length(p.xz)*.005+length(sin(pos*3.+t*5.))*.15);
fl*=.9;
float d=smin(fl,fr,.7);
if (abs(d-fl)<.2) {
hid=1.;
}
return vec2(d,hid);
}
vec3 normal(vec3 p) {
vec3 e = vec3(0.0,det,0.0);
return normalize(vec3(
de(p+e.yxx).x-de(p-e.yxx).x,
de(p+e.xyx).x-de(p-e.xyx).x,
de(p+e.xxy).x-de(p-e.xxy).x
)
);
}
float shadow(vec3 pos, vec3 sdir) {//THIS ONLY RUNS WHEN WITH HARD SHADOWS
float sh=1.0;
float totdist =2.0*det;
float dist=5.;
for (int steps=0; steps<SHADOW_STEPS; steps++) {
if (totdist<4. && dist>detail) {
vec3 p = pos - totdist * sdir;
dist = de(p).x;
sh = min( sh, max(20.*dist/totdist,0.0) );
totdist += max(.01,dist);
}
}
return clamp(sh,0.1,1.0);
}
float calcAO( const vec3 pos, const vec3 nor ) {
float aodet=detail*75.;
float totao = 0.0;
float sca = 10.0;
for( int aoi=0; aoi<5; aoi++ ) {
float hr = aodet*float(aoi*aoi);
vec3 aopos = nor * hr + pos;
float dd = de( aopos ).x;
totao += -(dd-hr)*sca;
sca *= 0.7;
}
return clamp( 1.0 - 5.0*totao, 0., 1. );
}
vec3 light(in vec3 p, in vec3 dir, in vec3 n, in float hid) {//PASSING IN THE NORMAL
#ifdef ENABLE_HARD_SHADOWS
float sh=shadow(p, lightdir);
#else
float sh=calcAO(p,-2.5*lightdir);//USING AO TO MAKE VERY SOFT SHADOWS
#endif
float ao=calcAO(p,n);
float diff=max(0.,dot(lightdir,-n))*sh*.95;
float y=3.16-p.y;
vec3 amb=max(.6,dot(dir,-n))*.7*AMBIENT_COLOR;
vec3 r = reflect(lightdir,n);
float spec=pow(max(0.,dot(dir,-r))*sh,15.)*.5;
vec3 col;
float energysource=pow(max(0.,.1-abs(y))/.1,3.)*1.5;
float k=texture2(p);
col=mix(vec3(k,k*k,k*k*k)*.9+.1,vec3(k)*1.5,.4);
if (abs(hid-1.)<.001) col=FLOOR_COLOR;
col=col*(amb*ao+diff*(.3+ao*.5)*LIGHT_COLOR)+spec*LIGHT_COLOR;
return col;
}
vec3 raymarch(in vec3 from, in vec3 dir)
{
float ey=mod(t*.5,1.);
float glow,eglow,ref,sphdist,totdist=glow=eglow=ref=sphdist=0.;
vec2 d=vec2(1.,0.);
vec3 p, col=vec3(0.);
vec3 origdir=dir,origfrom=from,sphNorm;
for (int i=0; i<RAY_STEPS; i++) {
if (d.x>det && totdist<6.0) {
p=from+totdist*dir;
d=de(p);
det=detail*(1.+totdist*60.)*(1.+ref*5.);
totdist+=max(detail,d.x);
if (d.y<.5) glow+=max(0.,.02-d.x)/.02;
}
}
vec3 ov=normalize(vec3(1.,.5,1.));
vec3 sol=dir+lightdir;
float l=pow(max(0.,dot(normalize(-dir*ov),normalize(lightdir*ov))),1.5)+sin(atan(sol.x,sol.y)*20.+length(from)*50.)*.002;
totdist=min(5.9,totdist);
p=from+dir*(totdist-detail);
vec3 backg=.4*(1.2-l)+LIGHT_COLOR*l*.75;
backg*=AMBIENT_COLOR*(1.-max(0.2,dot(normalize(dir),vec3(0.,1.,0.)))*.2);
float fondo=0.;
vec3 pp=p*.5+sin(t*2.)*.5;
for (int i=0; i<15; i++) {
fondo+=clamp(0.,1.,texture1(pp+dir*float(i)*.02))*max(0.,1.-exp(-.03*float(i)));
}
vec3 backg2=backg*(1.+fondo*(LIGHT_COLOR)*.75);
if (d.x<.01) {
vec3 norm=normal(p);
col=mix(light(p-abs(d.x-det)*dir, dir, norm, d.y),backg,1.-exp(-.3*totdist*totdist));
col = mix(col, backg2, 1.0-exp(-.02*pow(abs(totdist),2.)));
} else {
col=backg2;
}
vec3 lglow=LIGHT_COLOR*pow(abs(l),30.)*.5;
col+=glow*(.3+backg+lglow)*.005;
col+=lglow*min(1.,totdist*totdist*.03)*1.2;
return col;
}
vec3 move(inout mat2 rotview1,inout mat2 rotview2) {
vec3 go=path(t);
vec3 adv=path(t+.5);
vec3 advec=normalize(adv-go);
float an=atan(advec.x,advec.z);
rotview1=mat2(cos(an),sin(an),-sin(an),cos(an));
an=advec.y*1.5-.2;
rotview2=mat2(cos(an),sin(an),-sin(an),cos(an));
return go;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
pth1 = path(t+.3)+origin+vec3(0.,.01,0.);
vec2 uv = fragCoord.xy / iResolution.xy*2.-1.;
vec2 uv2=uv;
uv.y*=iResolution.y/iResolution.x;
#ifdef MOUSE
vec2 mouse=(iMouse.xy/iResolution.xy-.5)*3.;
if (iMouse.z<1.) mouse=vec2(0.);
##else
vec2 mouse=(0.0 / iResolution.xy-.5)*3.;
#endif
mat2 rotview1, rotview2;
vec3 from=origin+move(rotview1,rotview2);
vec3 dir=normalize(vec3(uv*1.5,1.));
dir.yz*=rot(mouse.y);
dir.xz*=rot(mouse.x-1.);
dir.yz*=rotview2;
dir.xz*=rotview1;
vec3 color=raymarch(from,dir);
color=clamp(color,vec3(.0),vec3(1.));
color=pow(abs(color),vec3(GAMMA))*BRIGHTNESS;
color=mix(vec3(length(color)),color,SATURATION);
color*=1.2-length(pow(abs(uv2),vec2(4.)))*.3;
float fadein=clamp(iGlobalTime-.5,0.,1.);
fragColor = vec4(color*vec3(.93,.95,.91),1.)*fadein;
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

326
procedural/kali-generators.slang Normal file
View File

@ -0,0 +1,326 @@
#version 450
// Generators - Kali - 2013-10-10
// https://www.shadertoy.com/view/Xtf3Rn
// Generators!
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
// "GENERATORS REDUX" by Kali
// Same fractal as "Ancient Temple" + rotations, improved shading
// (better coloring, AO and shadows), some lighting effects, and a path for the camera
// following a liquid metal ball.
#define ENABLE_HARD_SHADOWS // turn off to enable faster AO soft shadows
//#define ENABLE_VIBRATION
//#define ENABLE_POSTPROCESS // Works better on window view rather than full screen
#define RAY_STEPS 70
#define SHADOW_STEPS 50
#define LIGHT_COLOR vec3(.85,.9,1.)
#define AMBIENT_COLOR vec3(.8,.83,1.)
#define FLOOR_COLOR vec3(1.,.7,.9)
#define ENERGY_COLOR vec3(1.,.7,.4)
#define BRIGHTNESS .9
#define GAMMA 1.3
#define SATURATION .85
#define detail .00005
#define t iGlobalTime*.25
vec3 lightdir=normalize(vec3(0.5,-0.3,-1.));
vec3 ambdir=normalize(vec3(0.,0.,1.));
const vec3 origin=vec3(0.,3.11,0.);
vec3 energy=vec3(0.01);
#ifdef ENABLE_VIBRATION
float vibration=sin(iGlobalTime*60.)*.0013;
#else
float vibration=0.;
#endif
float det=0.0;
vec3 pth1;
mat2 rot(float a) {
return mat2(cos(a),sin(a),-sin(a),cos(a));
}
vec3 path(float ti) {
return vec3(sin(ti),.3-sin(ti*.632)*.3,cos(ti*.5))*.5;
}
float Sphere(vec3 p, vec3 rd, float r){//A RAY TRACED SPHERE
float b = dot( -p, rd );
float inner = b * b - dot( p, p ) + r * r;
if( inner < 0.0 ) return -1.0;
return b - sqrt( inner );
}
vec2 de(vec3 pos) {
float hid=0.;
vec3 tpos=pos;
tpos.xz=abs(.5-mod(tpos.xz,1.));
vec4 p=vec4(tpos,1.);
float y=max(0.,.35-abs(pos.y-3.35))/.35;
for (int i=0; i<7; i++) {//LOWERED THE ITERS
p.xyz = abs(p.xyz)-vec3(-0.02,1.98,-0.02);
p=p*(2.0+vibration*y)/clamp(dot(p.xyz,p.xyz),.4,1.)-vec4(0.5,1.,0.4,0.);
p.xz*=mat2(-0.416,-0.91,0.91,-0.416);
}
float fl=pos.y-3.013;
float fr=(length(max(abs(p.xyz)-vec3(0.1,5.0,0.1),vec3(0.0)))-0.05)/p.w;//RETURN A RRECT
//float fr=length(p.xyz)/p.w;
float d=min(fl,fr);
d=min(d,-pos.y+3.95);
if (abs(d-fl)<.001) hid=1.;
return vec2(d,hid);
}
vec3 normal(vec3 p) {
vec3 e = vec3(0.0,det,0.0);
return normalize(vec3(
de(p+e.yxx).x-de(p-e.yxx).x,
de(p+e.xyx).x-de(p-e.xyx).x,
de(p+e.xxy).x-de(p-e.xxy).x
)
);
}
float shadow(vec3 pos, vec3 sdir) {//THIS ONLY RUNS WHEN WITH HARD SHADOWS
float sh=1.0;
float totdist =2.0*det;
float dist=10.;
float t1=Sphere((pos-.005*sdir)-pth1,-sdir,0.015);
if (t1>0. && t1<.5) {
vec3 sphglowNorm=normalize(pos-t1*sdir-pth1);
sh=1.-pow(max(.0,dot(sphglowNorm,sdir))*1.2,3.);
}
for (int steps=0; steps<SHADOW_STEPS; steps++) {
if (totdist<.6 && dist>detail) {
vec3 p = pos - totdist * sdir;
dist = de(p).x;
sh = min( sh, max(50.*dist/totdist,0.0) );
totdist += max(.01,dist);
}
}
return clamp(sh,0.1,1.0);
}
float calcAO( const vec3 pos, const vec3 nor ) {
float aodet=detail*40.;
float totao = 0.0;
float sca = 14.0;
for( int aoi=0; aoi<5; aoi++ ) {
float hr = aodet*float(aoi*aoi);
vec3 aopos = nor * hr + pos;
float dd = de( aopos ).x;
totao += -(dd-hr)*sca;
sca *= 0.7;
}
return clamp( 1.0 - 5.0*totao, 0., 1.0 );
}
float _texture(vec3 p) {
p=abs(.5-fract(p*10.));
vec3 c=vec3(3.);
float es, l=es=0.;
for (int i = 0; i < 10; i++) {
p = abs(p + c) - abs(p - c) - p;
p/= clamp(dot(p, p), .0, 1.);
p = p* -1.5 + c;
if ( mod(float(i), 2.) < 1. ) {
float pl = l;
l = length(p);
es+= exp(-1. / abs(l - pl));
}
}
return es;
}
vec3 light(in vec3 p, in vec3 dir, in vec3 n, in float hid) {//PASSING IN THE NORMAL
#ifdef ENABLE_HARD_SHADOWS
float sh=shadow(p, lightdir);
#else
float sh=calcAO(p,-2.5*lightdir);//USING AO TO MAKE VERY SOFT SHADOWS
#endif
float ao=calcAO(p,n);
float diff=max(0.,dot(lightdir,-n))*sh;
float y=3.35-p.y;
vec3 amb=max(.5,dot(dir,-n))*.5*AMBIENT_COLOR;
if (hid<.5) {
amb+=max(0.2,dot(vec3(0.,1.,0.),-n))*FLOOR_COLOR*pow(max(0.,.2-abs(3.-p.y))/.2,1.5)*2.;
amb+=energy*pow(max(0.,.4-abs(y))/.4,2.)*max(0.2,dot(vec3(0.,-sign(y),0.),-n))*2.;
}
vec3 r = reflect(lightdir,n);
float spec=pow(max(0.,dot(dir,-r))*sh,10.);
vec3 col;
float energysource=pow(max(0.,.04-abs(y))/.04,4.)*2.;
if (hid>1.5) {col=vec3(1.); spec=spec*spec;}
else{
float k=_texture(p)*.23+.2;
k=min(k,1.5-energysource);
col=mix(vec3(k,k*k,k*k*k),vec3(k),.3);
if (abs(hid-1.)<.001) col*=FLOOR_COLOR*1.3;
}
col=col*(amb+diff*LIGHT_COLOR)+spec*LIGHT_COLOR;
if (hid<.5) {
col=max(col,energy*2.*energysource);
}
col*=min(1.,ao+length(energy)*.5*max(0.,.1-abs(y))/.1);
return col;
}
vec3 raymarch(in vec3 from, in vec3 dir)
{
float ey=mod(t*.5,1.);
float glow,eglow,ref,sphdist,totdist=glow=eglow=ref=sphdist=0.;
vec2 d=vec2(1.,0.);
vec3 p, col=vec3(0.);
vec3 origdir=dir,origfrom=from,sphNorm;
//FAKING THE SQUISHY BALL BY MOVING A RAY TRACED BALL
vec3 wob=cos(dir*500.0*length(from-pth1)+(from-pth1)*250.+iGlobalTime*10.)*0.0005;
float t1=Sphere(from-pth1+wob,dir,0.015);
float tg=Sphere(from-pth1+wob,dir,0.02);
if(t1>0.){
ref=1.0;from+=t1*dir;sphdist=t1;
sphNorm=normalize(from-pth1+wob);
dir=reflect(dir,sphNorm);
}
else if (tg>0.) {
vec3 sphglowNorm=normalize(from+tg*dir-pth1+wob);
glow+=pow(max(0.,dot(sphglowNorm,-dir)),5.);
};
for (int i=0; i<RAY_STEPS; i++) {
if (d.x>det && totdist<3.0) {
p=from+totdist*dir;
d=de(p);
det=detail*(1.+totdist*60.)*(1.+ref*5.);
totdist+=d.x;
energy=ENERGY_COLOR*(1.5+sin(iGlobalTime*20.+p.z*10.))*.25;
if(d.x<0.015)glow+=max(0.,.015-d.x)*exp(-totdist);
if (d.y<.5 && d.x<0.03){//ONLY DOING THE GLOW WHEN IT IS CLOSE ENOUGH
float glw=min(abs(3.35-p.y-ey),abs(3.35-p.y+ey));//2 glows at once
eglow+=max(0.,.03-d.x)/.03*
(pow(max(0.,.05-glw)/.05,5.)
+pow(max(0.,.15-abs(3.35-p.y))/.15,8.))*1.5;
}
}
}
float l=pow(max(0.,dot(normalize(-dir.xz),normalize(lightdir.xz))),2.);
l*=max(0.2,dot(-dir,lightdir));
vec3 backg=.5*(1.2-l)+LIGHT_COLOR*l*.7;
backg*=AMBIENT_COLOR;
if (d.x<=det) {
vec3 norm=normal(p-abs(d.x-det)*dir);//DO THE NORMAL CALC OUTSIDE OF LIGHTING (since we already have the sphere normal)
col=light(p-abs(d.x-det)*dir, dir, norm, d.y)*exp(-.2*totdist*totdist);
col = mix(col, backg, 1.0-exp(-1.*pow(totdist,1.5)));
} else {
col=backg;
}
vec3 lglow=LIGHT_COLOR*pow(l,30.)*.5;
col+=glow*(backg+lglow)*1.3;
col+=pow(eglow,2.)*energy*.015;
col+=lglow*min(1.,totdist*totdist*.3);
if (ref>0.5) {
vec3 sphlight=light(origfrom+sphdist*origdir,origdir,sphNorm,2.);
col=mix(col*.3+sphlight*.7,backg,1.0-exp(-1.*pow(sphdist,1.5)));
}
return col;
}
vec3 move(inout mat2 rotview1,inout mat2 rotview2) {
vec3 go=path(t);
vec3 adv=path(t+.7);
vec3 advec=normalize(adv-go);
float an=atan(advec.x,advec.z);
rotview1=mat2(cos(an),sin(an),-sin(an),cos(an));
an=advec.y*1.7;
rotview2=mat2(cos(an),sin(an),-sin(an),cos(an));
return go;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
pth1 = path(t+.3)+origin+vec3(0.,.01,0.);
vec2 uv = fragCoord.xy / iResolution.xy*2.-1.;
vec2 uv2=uv;
#ifdef ENABLE_POSTPROCESS
uv*=1.+pow(length(uv2*uv2*uv2*uv2),4.)*.07;
#endif
uv.y*=iResolution.y/iResolution.x;
#ifdef MOUSE
vec2 mouse=(iMouse.xy/iResolution.xy-.5)*3.;
if (iMouse.z<1.) mouse=vec2(0.);
#else
vec2 mouse = vec2(0.0, 0.0);
#endif
mat2 rotview1, rotview2;
vec3 from=origin+move(rotview1,rotview2);
vec3 dir=normalize(vec3(uv*.8,1.));
dir.yz*=rot(mouse.y);
dir.xz*=rot(mouse.x);
dir.yz*=rotview2;
dir.xz*=rotview1;
vec3 color=raymarch(from,dir);
color=clamp(color,vec3(.0),vec3(1.));
color=pow(color,vec3(GAMMA))*BRIGHTNESS;
color=mix(vec3(length(color)),color,SATURATION);
#ifdef ENABLE_POSTPROCESS
vec3 rain=pow(texture(iChannel0,uv2+iGlobalTime*7.25468).rgb,vec3(1.5));
color=mix(rain,color,clamp(iGlobalTime*.5-.5,0.,1.));
color*=1.-pow(length(uv2*uv2*uv2*uv2)*1.1,6.);
uv2.y *= iResolution.y / 360.0;
color.r*=(.5+abs(.5-mod(uv2.y ,.021)/.021)*.5)*1.5;
color.g*=(.5+abs(.5-mod(uv2.y+.007,.021)/.021)*.5)*1.5;
color.b*=(.5+abs(.5-mod(uv2.y+.014,.021)/.021)*.5)*1.5;
color*=.9+rain*.35;
#endif
fragColor = vec4(color,1.);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

108
procedural/knarkowicz-bokeh-parallax.slang Normal file
View File

@ -0,0 +1,108 @@
#version 450
// Bokeh Parallax - knarkowicz - 2017-04-12
// https://www.shadertoy.com/view/4s2yW1
// Feeling artsy
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
const float MATH_PI = float( 3.14159265359 );
void Rotate( inout vec2 p, float a )
{
p = cos( a ) * p + sin( a ) * vec2( p.y, -p.x );
}
float Circle( vec2 p, float r )
{
return ( length( p / r ) - 1.0 ) * r;
}
float Rand( vec2 c )
{
return fract( sin( dot( c.xy, vec2( 12.9898, 78.233 ) ) ) * 43758.5453 );
}
float saturate( float x )
{
return clamp( x, 0.0, 1.0 );
}
void BokehLayer( inout vec3 color, vec2 p, vec3 c )
{
float wrap = 450.0;
if ( mod( floor( p.y / wrap + 0.5 ), 2.0 ) == 0.0 )
{
p.x += wrap * 0.5;
}
vec2 p2 = mod( p + 0.5 * wrap, wrap ) - 0.5 * wrap;
vec2 cell = floor( p / wrap + 0.5 );
float cellR = Rand( cell );
c *= fract( cellR * 3.33 + 3.33 );
float radius = mix( 30.0, 70.0, fract( cellR * 7.77 + 7.77 ) );
p2.x *= mix( 0.9, 1.1, fract( cellR * 11.13 + 11.13 ) );
p2.y *= mix( 0.9, 1.1, fract( cellR * 17.17 + 17.17 ) );
float sdf = Circle( p2, radius );
float circle = 1.0 - smoothstep( 0.0, 1.0, sdf * 0.04 );
float glow = exp( -sdf * 0.025 ) * 0.3 * ( 1.0 - circle );
color += c * ( circle + glow );
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = fragCoord.xy / iResolution.xy;
vec2 p = ( 2.0 * fragCoord - iResolution.xy ) / iResolution.x * 1000.0;
// background
vec3 color = mix( vec3( 0.3, 0.1, 0.3 ), vec3( 0.1, 0.4, 0.5 ), dot( uv, vec2( 0.2, 0.7 ) ) );
float time = iGlobalTime - 15.0;
Rotate( p, 0.2 + time * 0.03 );
BokehLayer( color, p + vec2( -50.0 * time + 0.0, 0.0 ), 3.0 * vec3( 0.4, 0.1, 0.2 ) );
Rotate( p, 0.3 - time * 0.05 );
BokehLayer( color, p + vec2( -70.0 * time + 33.0, -33.0 ), 3.5 * vec3( 0.6, 0.4, 0.2 ) );
Rotate( p, 0.5 + time * 0.07 );
BokehLayer( color, p + vec2( -60.0 * time + 55.0, 55.0 ), 3.0 * vec3( 0.4, 0.3, 0.2 ) );
Rotate( p, 0.9 - time * 0.03 );
BokehLayer( color, p + vec2( -25.0 * time + 77.0, 77.0 ), 3.0 * vec3( 0.4, 0.2, 0.1 ) );
Rotate( p, 0.0 + time * 0.05 );
BokehLayer( color, p + vec2( -15.0 * time + 99.0, 99.0 ), 3.0 * vec3( 0.2, 0.0, 0.4 ) );
fragColor = vec4( color, 1.0 );
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

243
procedural/leon-mam-stairs.slang Normal file
View File

@ -0,0 +1,243 @@
#version 450
// M.A.M. Stairs - leon - 2017-11-24
// https://www.shadertoy.com/view/MIIBR7
// Another raymarching sketch inspired by Marc-Antoine Mathieu.
// M.A.M. Stairs by Leon Denise aka ponk
// another raymarching sketch inspired by Marc-Antoine Mathieu.
// using code from IQ, Mercury, LJ, Duke, Koltes
// made with Atom Editor GLSL viewer (that's why there is 2 space tabulations)
// 2017-11-24
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define STEPS 50.
#define VOLUME 0.01
#define PI 3.14159
#define TAU (2.*PI)
#define time iGlobalTime
#define repeat(v,c) (mod(v,c)-c/2.)
#define sDist(v,r) (length(v)-r)
mat2 rot (float a) { float c=cos(a),s=sin(a); return mat2(c,-s,s,c); }
float rng (vec2 seed) { return fract(sin(dot(seed*.1684,vec2(32.649,321.547)))*43415.); }
float sdBox( vec3 p, vec3 b ) { vec3 d = abs(p) - b; return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0)); }
float amod (inout vec2 p, float count) { float an = TAU/count; float a = atan(p.y,p.x)+an/2.; float c = floor(a/an); c = mix(c,abs(c),step(count*.5,abs(c))); a = mod(a,an)-an/2.; p.xy = vec2(cos(a),sin(a))*length(p); return c; }
float aindex (vec2 p, float count) { float an = TAU/count; float a = atan(p.y,p.x)+an/2.; float c = floor(a/an); return mix(c,abs(c),step(count*.5,abs(c))); }
float map (vec3);
vec3 getNormal (vec3 p) { vec2 e = vec2(.001,0); return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx))); }
float hardShadow (vec3 pos, vec3 light) {
vec3 dir = normalize(light - pos);
float maxt = length(light - pos);
float t = .02;
for (float i = 0.; i <= 1.; i += 1./30.) {
float dist = map(pos + dir * t);
if (dist < VOLUME) return 0.;
t += dist;
if (t >= maxt) break;
}
return 1.;
}
float map (vec3 pos) {
float scene = 1000.;
float wallThin = .2;
float wallRadius = 8.;
float wallOffset = .2;
float wallCount = 10.;
float floorThin = .1;
float stairRadius = 5.;
float stairHeight = .4;
float stairCount = 40.;
float stairDepth = .31;
float bookCount = 100.;
float bookRadius = 9.5;
float bookSpace = 1.75;
vec3 bookSize = vec3(1.,.2,.2);
vec3 panelSize = vec3(.03,.2,.7);
vec2 cell = vec2(1.4,3.);
float paperRadius = 4.;
vec3 paperSize = vec3(.3,.01,.4);
vec3 p;
// move it
pos.y += time;
// twist it
// pos.xz *= rot(pos.y*.05+time*.1);
// pos.xz += normalize(pos.xz) * sin(pos.y*.5+time);
// holes
float holeWall = sDist(pos.xz, wallRadius);
float holeStair = sDist(pos.xz, stairRadius);
// walls
p = pos;
amod(p.xz, wallCount);
p.x -= wallRadius;
scene = min(scene, max(-p.x, abs(p.z)-wallThin));
scene = max(scene, -sDist(pos.xz, wallRadius-wallOffset));
// floors
p = pos;
p.y = repeat(p.y, cell.y);
float disk = max(sDist(p.xz, 1000.), abs(p.y)-floorThin);
disk = max(disk, -sDist(pos.xz, wallRadius));
scene = min(scene, disk);
// stairs
p = pos;
float stairIndex = amod(p.xz, stairCount);
p.y -= stairIndex*stairHeight;
p.y = repeat(p.y, stairCount*stairHeight);
float stair = sdBox(p, vec3(100,stairHeight,stairDepth));
scene = min(scene, max(stair, max(holeWall, -holeStair)));
p = pos;
p.xz *= rot(PI/stairCount);
stairIndex = amod(p.xz, stairCount);
p.y -= stairIndex*stairHeight;
p.y = repeat(p.y, stairCount*stairHeight);
stair = sdBox(p, vec3(100,stairHeight,stairDepth));
scene = min(scene, max(stair, max(holeWall, -holeStair)));
p = pos;
p.y += stairHeight*.5;
p.y -= stairHeight*stairCount*atan(p.z,p.x)/TAU;
p.y = repeat(p.y, stairCount*stairHeight);
scene = min(scene, max(max(sDist(p.xz, wallRadius), abs(p.y)-stairHeight), -holeStair));
// books
p = pos;
p.y -= cell.y*.5;
vec2 seed = vec2(floor(p.y/cell.y), 0);
p.y = repeat(p.y, cell.y);
p.xz *= rot(PI/wallCount);
seed.y += amod(p.xz, wallCount)/10.;
seed.y += floor(p.z/(bookSize.z*bookSpace));
p.z = repeat(p.z, bookSize.z*bookSpace);
float salt = rng(seed);
bookSize.x *= .5+.5*salt;
bookSize.y += salt;
bookSize.z *= .5+.5*salt;
p.x -= bookRadius + wallOffset;
p.x += cos(p.z*2.) - bookSize.x - salt * .25;
p.x += .01*smoothstep(.99,1.,sin(p.y*(1.+10.*salt)));
scene = min(scene, max(sdBox(p, vec3(bookSize.x,100.,bookSize.z)), p.y-bookSize.y));
// panel
p = pos;
p.y = repeat(p.y, cell.y);
p.xz *= rot(PI/wallCount);
amod(p.xz, wallCount);
p.x -= wallRadius;
float panel = sdBox(p, panelSize);
float pz = p.z;
p.z = repeat(p.z, .2+.3*salt);
panel = min(panel, max(sdBox(p, vec3(.1,.1,.04)), abs(pz)-panelSize.z*.8));
scene = min(scene, panel);
// papers
p = pos;
p.y -= stairHeight;
p.y += time*2.;
p.xz *= rot(PI/stairCount);
float ry = 8.;
float iy = floor(p.y/ry);
salt = rng(vec2(iy));
float a = iy;
p.xz -= vec2(cos(a),sin(a))*paperRadius;
p.y = repeat(p.y, ry);
p.xy *= rot(p.z);
p.xz *= rot(PI/4.+salt+time);
scene = min(scene, sdBox(p, paperSize));
return scene;
}
vec3 getCamera (vec3 eye, vec2 uv) {
vec3 lookAt = vec3(0.);
#ifdef MOUSE
float click = clamp(iMouse.w,0.,1.);
lookAt.x += mix(0.,((iMouse.x/iResolution.x)*2.-1.) * 10., click);
lookAt.y += mix(0.,iMouse.y/iResolution.y * 10., click);
#else
float click = clamp(0.,0.,1.);
lookAt.x += mix(0.,((0./iResolution.x)*2.-1.) * 10., click);
lookAt.y += mix(0.,0./iResolution.y * 10., click);
#endif
float fov = .65;
vec3 forward = normalize(lookAt - eye);
vec3 right = normalize(cross(vec3(0,1,0), forward));
vec3 up = normalize(cross(forward, right));
return normalize(fov * forward + uv.x * right + uv.y * up);
}
float getLight (vec3 pos, vec3 eye) {
vec3 light = vec3(-.5,7.,1.);
vec3 normal = getNormal(pos);
vec3 view = normalize(eye-pos);
float shade = dot(normal, view);
shade *= hardShadow(pos, light);
return shade;
}
vec4 raymarch () {
vec2 uv = (gl_FragCoord.xy-.5*iResolution.xy)/iResolution.y;
float dither = rng(uv+fract(time));
vec3 eye = vec3(0,5,-4.5);
vec3 ray = getCamera(eye, uv);
vec3 pos = eye;
float shade = 0.;
for (float i = 0.; i <= 1.; i += 1./STEPS) {
float dist = map(pos);
if (dist < VOLUME) {
shade = 1.-i;
break;
}
dist *= .5 + .1 * dither;
pos += ray * dist;
}
vec4 color = vec4(shade);
color *= getLight(pos, eye);
color = smoothstep(.0, .5, color);
color = sqrt(color);
return color;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
fragColor = raymarch();
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

120
procedural/leon-smoke-rings.slang Normal file
View File

@ -0,0 +1,120 @@
#version 450
// Smoke Rings - leon - 2017-05-09
// https://www.shadertoy.com/view/4sSyDd
// Experimenting shapes
// training for modeling shapes
// using koltes code as base https://www.shadertoy.com/view/XdByD3
// using iq articles
// using mercury library
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define PI 3.1415926535897932384626433832795
#define TAU 6.283185307179586476925286766559
#define t iGlobalTime
mat2 rz2 (float a) { float c=cos(a), s=sin(a); return mat2(c,s,-s,c); }
float sphere (vec3 p, float r) { return length(p)-r; }
float iso (vec3 p, float r) { return dot(p, normalize(sign(p)))-r; }
float cyl (vec2 p, float r) { return length(p)-r; }
float cube (vec3 p, vec3 r) { return length(max(abs(p)-r,0.)); }
vec2 modA (vec2 p, float count) {
float an = TAU/count;
float a = atan(p.y,p.x)+an*.5;
a = mod(a, an)-an*.5;
return vec2(cos(a),sin(a))*length(p);
}
float smin (float a, float b, float r)
{
float h = clamp(.5+.5*(b-a)/r,0.,1.);
return mix(b, a, h) - r*h*(1.-h);
}
float map (vec3 p)
{
float sph3 = sphere(p, 3.);
p.yz *= rz2(t*.2);
p.xy *= rz2(t*.3);
float d = length(p);
float a = atan(p.y,p.x);
float l = length(p.xy)-2.;
p.xy = vec2(l,a);
float as = PI*0.3;
p.z += sin(a*2.+sin(l*4.))*.5;
float wave1 = sin(p.y*6.)*.5+.5;
float wave2 = .5+.5*sin(p.z*3.+t);
p.x -= sin(p.z*1.+t)*.5;
p.z = mod(p.z+t,as)-as*.5;
float sphR = .2-.1*wave1;
float sphC = .3;
float sphN = 0.2;
float sph1 = sphere(vec3(p.x,mod(sphN*p.y/TAU+t*.1,sphC)-sphC*.5,p.z), sphR);
p.xz *= rz2(p.y*3.);
p.xz = modA(p.xz, 3.);
p.x -= 0.3*wave2;
float cyl1 = cyl(p.xz, 0.02);
float sph2 = sphere(vec3(p.x,mod(p.y*2.-t,1.)-.5,p.z), .1);
return smin(sph1, smin(cyl1,sph2,.2), .2);
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = (fragCoord.xy-.5*iResolution.xy)/iResolution.y;
vec3 ro = vec3(uv,-5), rp = vec3(uv,1), mp = ro;
int i = 0;
const int count = 50;
for(;i<count;++i) {
float md = map(mp);
if (md < 0.001) {
break;
}
mp += rp*md*.35;
}
float r = float(i)/float(count);
fragColor = vec4(1);
fragColor *= smoothstep(.0,10.,length(mp-ro));
fragColor *= r;
fragColor = 1. - fragColor;
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

195
procedural/leon-spell-demons-souls.slang Normal file
View File

@ -0,0 +1,195 @@
#version 450
// Spell Demon's Souls - leon - 2017-10-21
// https://www.shadertoy.com/view/XljcD1
// A sketch inspired by Dark Souls. Sometime you can see the twisted souls emerging from the distorted shapes. I could tweak this for days and nights...
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define STEPS 1./50.
#define VOLUME_BIAS 0.01
#define MIN_DIST 0.005
#define STEP_DAMPING .9
#define PI 3.14159
#define TAU PI*2.
// raymarch toolbox
float rng (vec2 seed) { return fract(sin(dot(seed*.1684,vec2(54.649,321.547)))*450315.); }
mat2 rot (float a) { float c=cos(a),s=sin(a); return mat2(c,-s,s,c); }
float sdSphere (vec3 p, float r) { return length(p)-r; }
float sdCylinder (vec2 p, float r) { return length(p)-r; }
float sdIso(vec3 p, float r) { return max(0.,dot(p,normalize(sign(p))))-r; }
float sdBox( vec3 p, vec3 b ) {
vec3 d = abs(p) - b;
return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0));
}
float amod (inout vec2 p, float count) {
float an = TAU/count;
float a = atan(p.y,p.x)+an/2.;
float c = floor(a/an);
a = mod(a,an)-an/2.;
p.xy = vec2(cos(a),sin(a))*length(p);
return c;
}
float repeat (float v, float c) { return mod(v,c)-c/2.; }
float smin (float a, float b, float r) {
float h = clamp(.5+.5*(b-a)/r, 0., 1.);
return mix(b,a,h)-r*h*(1.-h);
}
// geometry for spell
float tubes (vec3 pos) {
// cylinder made of 8 tube
float cylinderRadius = .02; // change shape
vec3 p = pos;
p.xz *= rot(p.y*.5); // twist amount
float c = amod(p.xz, 8.); // amount of tubes
p.x -= 2.; // tube cylinder radius
float tube = sdCylinder(p.xz, cylinderRadius);
// another cylinder made of tubes 16
p = pos;
p.xz *= rot(-p.y*.5); // twist amount
c = amod(p.xz, 16.); // amount of tubes
p.x -= 2.; // tube cylinder radius
tube = smin(tube, sdCylinder(p.xz, cylinderRadius), .15);
return tube;
}
// geometry for spell
float disks (vec3 pos) {
float radius = 1.5;
float radiusInner = .57;
float thin = .01;
float repeatY = 2.;
float cellY = floor(pos.y/repeatY);
float a = atan(pos.z,pos.x)-iGlobalTime*.3+cellY*.1;
vec3 p = pos;
p.y += sin(a*6.)*.1;
p.y = repeat(p.y, repeatY);
float disk = max(-sdCylinder(p.xz, radiusInner), sdCylinder(p.xz, radius));
disk = max(abs(p.y)-thin,disk);
return disk;
}
vec3 anim1 (vec3 p) {
float t = iGlobalTime*.5;
p.xz *= rot(t);
p.xy *= rot(t*.7);
p.yz *= rot(t*.5);
return p;
}
vec3 anim2 (vec3 p) {
float t = -iGlobalTime*.4;
p.xz *= rot(t*.9);
p.xy *= rot(t*.6);
p.yz *= rot(t*.3);
return p;
}
float map (vec3 pos) {
float scene = 1000.;
// ground and ceiling
#ifdef BUMP
float bump = texture(iChannel0, pos.xz*.1).r;
#else
float bump = 0.0;
#endif
float ground = 2. - bump*.1;
scene = min(scene, pos.y+ground);
scene = min(scene, -(pos.y-ground));
// spell geometry 1
vec3 p = pos;
p.y += sin(atan(p.z,p.x)*10.)*3.; // change numbers to get new distortion
p.xz *= rot(p.y*.2-iGlobalTime);
p = anim1(p);
p.x = length(p.xyz)-3.;
scene = smin(scene, tubes(p), .5);
scene = smin(scene, disks(p), .5);
// spell geometry 2
p = pos;
p.y += sin(atan(p.z,p.x)*3.)*2.; // change numbers to get new distortion
p = anim2(p);
p.xz *= rot(p.y+iGlobalTime);
p.x = length(p.xyz)-3.;
scene = smin(scene, tubes(p), .3);
scene = smin(scene, disks(p), .3);
return scene;
}
void camera (inout vec3 p) {
#ifdef MOUSE
p.xz *= rot((-PI*(iMouse.x/iResolution.x-.5)));
#else
p.xz *= rot((-PI*(0.0/iResolution.x-.5)));
#endif
}
void mainImage( out vec4 color, in vec2 uv )
{
uv = (uv.xy-.5*iResolution.xy)/iResolution.y;
#ifdef MOUSE
vec2 mouse = iMouse.xy/iResolution.xy;
#else
vec2 mouse = 0.0/iResolution.xy;
#endif
vec3 eye = vec3(0.,0.,-7.+mouse.y*3.);
vec3 ray = normalize(vec3(uv,.7));
camera(eye);
camera(ray);
vec3 pos = eye;
float shade = 0.;
for (float i = 0.; i <= 1.; i += STEPS) {
float dist = map(pos);
if (dist < VOLUME_BIAS) {
shade += STEPS;
}
if (shade >= 1.) break;
dist *= STEP_DAMPING + .1 * rng(uv+fract(iGlobalTime));
dist = max(MIN_DIST, dist);
pos += dist * ray;
}
color = vec4(1);
color.rgb *= shade;
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

239
procedural/leon-tribute-to-marc-antoine-mathieu.slang Normal file
View File

@ -0,0 +1,239 @@
#version 450
// Tribute to Marc-Antoine Mathieu - leon - 2017-11-21
// https://www.shadertoy.com/view/XlfBR7
// Raymarching skectch inspired by the work of Marc-Antoine Mathieu
// Raymarching sketch inspired by the work of Marc-Antoine Mathieu
// Leon 2017-11-21
// using code from IQ, Mercury, LJ, Duke, Koltes
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
// tweak it
#define donut 30.
#define cell 4.
#define height 2.
#define thin .04
#define radius 15.
#define speed 1.
#define STEPS 100.
#define VOLUME 0.001
#define PI 3.14159
#define TAU (2.*PI)
#define time iGlobalTime
// raymarching toolbox
float rng (vec2 seed) { return fract(sin(dot(seed*.1684,vec2(54.649,321.547)))*450315.); }
mat2 rot (float a) { float c=cos(a),s=sin(a); return mat2(c,-s,s,c); }
float sdSphere (vec3 p, float r) { return length(p)-r; }
float sdCylinder (vec2 p, float r) { return length(p)-r; }
float sdDisk (vec3 p, vec3 s) { return max(max(length(p.xz)-s.x, s.y), abs(p.y)-s.z); }
float sdIso(vec3 p, float r) { return max(0.,dot(p,normalize(sign(p))))-r; }
float sdBox( vec3 p, vec3 b ) { vec3 d = abs(p) - b; return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0)); }
float sdTorus( vec3 p, vec2 t ) { vec2 q = vec2(length(p.xz)-t.x,p.y); return length(q)-t.y; }
float amod (inout vec2 p, float count) { float an = TAU/count; float a = atan(p.y,p.x)+an/2.; float c = floor(a/an); c = mix(c,abs(c),step(count*.5,abs(c))); a = mod(a,an)-an/2.; p.xy = vec2(cos(a),sin(a))*length(p); return c; }
float amodIndex (vec2 p, float count) { float an = TAU/count; float a = atan(p.y,p.x)+an/2.; float c = floor(a/an); c = mix(c,abs(c),step(count*.5,abs(c))); return c; }
float repeat (float v, float c) { return mod(v,c)-c/2.; }
vec2 repeat (vec2 v, vec2 c) { return mod(v,c)-c/2.; }
vec3 repeat (vec3 v, float c) { return mod(v,c)-c/2.; }
float smoo (float a, float b, float r) { return clamp(.5+.5*(b-a)/r, 0., 1.); }
float smin (float a, float b, float r) { float h = smoo(a,b,r); return mix(b,a,h)-r*h*(1.-h); }
float smax (float a, float b, float r) { float h = smoo(a,b,r); return mix(a,b,h)+r*h*(1.-h); }
vec2 displaceLoop (vec2 p, float r) { return vec2(length(p.xy)-r, atan(p.y,p.x)); }
float map (vec3);
float getShadow (vec3 pos, vec3 at, float k) {
vec3 dir = normalize(at - pos);
float maxt = length(at - pos);
float f = 01.;
float t = VOLUME*50.;
for (float i = 0.; i <= 1.; i += 1./15.) {
float dist = map(pos + dir * t);
if (dist < VOLUME) return 0.;
f = min(f, k * dist / t);
t += dist;
if (t >= maxt) break;
}
return f;
}
vec3 getNormal (vec3 p) { vec2 e = vec2(.01,0); return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx))); }
void camera (inout vec3 p) {
p.xz *= rot(PI/8.);
p.yz *= rot(PI/6.);
}
float windowCross (vec3 pos, vec4 size, float salt) {
vec3 p = pos;
float sx = size.x * (.6+salt*.4);
float sy = size.y * (.3+salt*.7);
vec2 sxy = vec2(sx,sy);
p.xy = repeat(p.xy+sxy/2., sxy);
float scene = sdBox(p, size.zyw*2.);
scene = min(scene, sdBox(p, size.xzw*2.));
scene = max(scene, sdBox(pos, size.xyw));
return scene;
}
float window (vec3 pos, vec2 dimension, float salt) {
float thinn = .008;
float depth = .04;
float depthCadre = .06;
float padding = .08;
float scene = windowCross(pos, vec4(dimension,thinn,depth), salt);
float cadre = sdBox(pos, vec3(dimension, depthCadre));
cadre = max(cadre, -sdBox(pos, vec3(dimension - padding, depthCadre*2.)));
scene = min(scene, cadre);
return scene;
}
float boxes (vec3 pos, float salt) {
vec3 p = pos;
float ry = cell * .43*(.3+salt);
float rz = cell * .2*(.5+salt);
float salty = rng(vec2(floor(pos.y/ry), floor(pos.z/rz)));
pos.y = repeat(pos.y, ry);
pos.z = repeat(pos.z, rz);
float scene = sdBox(pos, vec3(.1+.8*salt+salty,.1+.2*salt,.1+.2*salty));
scene = max(scene, sdBox(p, vec3(cell*.2)));
return scene;
}
float map (vec3 pos) {
vec3 camOffset = vec3(-4,0,0.);
float scene = 1000.;
vec3 p = pos + camOffset;
float segments = PI*radius;
float indexX, indexY, salt;
vec2 seed;
// donut distortion
vec3 pDonut = p;
pDonut.x += donut;
pDonut.y += radius;
pDonut.xz = displaceLoop(pDonut.xz, donut);
pDonut.z *= donut;
pDonut.xzy = pDonut.xyz;
pDonut.xz *= rot(time*.05*speed);
// ground
p = pDonut;
scene = min(scene, sdCylinder(p.xz, radius-height));
// walls
p = pDonut;
float py = p.y + time * speed;
indexY = floor(py / (cell+thin));
p.y = repeat(py, cell+thin);
scene = min(scene, max(abs(p.y)-thin, sdCylinder(p.xz, radius)));
amod(p.xz, segments);
p.x -= radius;
scene = min(scene, max(abs(p.z)-thin, p.x));
// horizontal windot
p = pDonut;
p.xz *= rot(PI/segments);
py = p.y + time * speed;
indexY = floor(py / (cell+thin));
p.y = repeat(py, cell+thin);
indexX = amodIndex(p.xz, segments);
amod(p.xz, segments);
seed = vec2(indexX, indexY);
salt = rng(seed);
p.x -= radius;
vec2 dimension = vec2(.75,.5);
p.x += dimension.x * 1.5;
scene = max(scene, -sdBox(p, vec3(dimension.x, .1, dimension.y)));
scene = min(scene, window(p.xzy, dimension, salt));
// vertical window
p = pDonut;
py = p.y + cell/2. + time * speed;
indexY = floor(py / (cell+thin));
p.y = repeat(py, cell+thin);
indexX = amodIndex(p.xz, segments);
amod(p.xz, segments);
seed = vec2(indexX, indexY);
salt = rng(seed);
p.x -= radius;
dimension.y = 1.5;
p.x += dimension.x * 1.25;
scene = max(scene, -sdBox(p, vec3(dimension, .1)));
scene = min(scene, window(p, dimension, salt));
// elements
p = pDonut;
p.xz *= rot(PI/segments);
py = p.y + cell/2. + time * speed;
indexY = floor(py / (cell+thin));
p.y = repeat(py, cell+thin);
indexX = amodIndex(p.xz, segments);
amod(p.xz, segments);
seed = vec2(indexX, indexY);
salt = rng(seed);
p.x -= radius - height;
scene = min(scene, boxes(p, salt));
return scene;
}
void mainImage( out vec4 color, in vec2 coord ) {
vec2 uv = (coord.xy-.5*iResolution.xy)/iResolution.y;
vec3 eye = vec3(0,0,-20);
vec3 ray = normalize(vec3(uv, 1.3));
camera(eye);
camera(ray);
float dither = rng(uv+fract(time));
vec3 pos = eye;
float shade = 0.;
for (float i = 0.; i <= 1.; i += 1./STEPS) {
float dist = map(pos);
if (dist < VOLUME) {
shade = 1.-i;
break;
}
dist *= .5 + .1 * dither;
pos += ray * dist;
}
vec3 light = vec3(40.,100.,-10.);
float shadow = getShadow(pos, light, 4.);
color = vec4(1);
color *= shade;
color *= shadow;
color = smoothstep(.0, .5, color);
color.rgb = sqrt(color.rgb);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

443
procedural/sdf-platform.slang Normal file
View File

@ -0,0 +1,443 @@
#version 450
// Xafer - 2017-04-30
// https://www.shadertoy.com/view/4dlyzl
// Reflections, refractions, lights such
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define NEAR 0.01
#define FAR 12.0
#define STEP_SIZE 0.1
#define MAX_ITER 300
#define MAX_CYCLES 2
#define DELTA 0.01
#define A_SPEED 0.3
#define CAM_DIST 3.3
#define RECAST_MAX 5
#define GLOW_POWER 6.0
#define GLOW_COLOR vec3(0.2,0.4,0.4)
#define GRASS_SIZE vec2(0.005,0.4)
#define SKY_COLOR vec3(0.1,0.3,0.4)
//Structures
struct Light
{
vec3 pos;
vec3 color;
float radius;
float intensity;
};
struct lComp
{
vec3 specular;
float specularIntensity;
vec3 diffuse;
};
struct Ray
{
vec3 pos;
vec3 dir;
float dist;
float near;
};
struct Material
{
vec3 color;
float specular;
float diffuse;//
float ambient;//Ambient light factor
float refl;//How reflective is a surface
float refr;//Refraction index
float opacity;//For refractions
};
//Signed Distance Functions
float sdSphere(vec3 p)
{
return length(p) - 1.0;
}
float sdPlane(vec3 p)
{
return -p.y;
}
float sdBox( vec3 p)
{
vec3 d = abs(p) - vec3(1.0);
return min(max(d.x,max(d.y,d.z)),0.0) + length(max(d,0.0));
}
float opAdd(float d1, float d2)
{
return min(d1,d2);
}
float opSub(float d1, float d2)
{
return max(-d1,d2);
}
float opInter(float d1, float d2)
{
return max(d1,d2);
}
//Combinations
float walls(vec3 p)
{
p.y -= 1.0;
p.y * 2.0;
vec3 p2 = p;
vec3 p3 = p;
float width = 0.1;
vec2 dist = vec2(5.0);
p2.xz = mod(p2.xz,dist)-(dist/2.0);
p2.x /= width;
p2.z /= 2.0;
p3.xz = mod(p3.xz,dist)-(dist/2.0);
p3.z /= width;
p3.x /= 2.0;
float env = opAdd(sdPlane(p),opAdd(sdBox(p2),sdBox(p3)));
env = opSub(max(-p.y - 0.3, p.y + 0.2),max(env,sdSphere(p/(CAM_DIST-0.4))));
env = opAdd(env,sdSphere(p/0.7 + vec3(0,0.5,0)));
return opSub(sdSphere(p),env);
}
float map(vec3 pos, float factor)
{
return walls(pos);
}
float map(vec3 pos)
{
return map(pos,0.0);
}
//Environment propreties
vec3 getNormal(vec3 p)
{
vec2 delta = vec2 (DELTA, 0.0);
vec3 normal = normalize (vec3 (
map (p + delta.xyy) - map (p - delta.xyy),
map (p + delta.yxy) - map (p - delta.yxy),
map (p + delta.yyx) - map (p - delta.yyx)));
return normalize(normal);
}
Material getMaterial(vec3 pos)
{
Material mat;
mat.color = vec3(sin(pos.y),cos(pos.x),sin(pos.z))/2.0 + 0.5;
mat.refl = 0.0;
mat.refr = 0.8;
mat.opacity = 0.7;
mat.color = mix(mat.color,getNormal(pos),0.2);
return mat;
}
//RayMarching
Ray march(Ray ray, int iterations)
{
float n = 1.0 / min(iResolution.x, iResolution.y);
for(int i = 0; i < iterations; i++)
{
ray.near = map(ray.pos,sqrt(ray.dist)*n);
if(ray.near < DELTA || ray.dist > FAR)
break;
float n = ray.near * STEP_SIZE;
ray.pos += ray.dir * n;
ray.dist += n;
}
return ray;
}
lComp getLighting(Ray ray)
{
lComp lightComposition;
//Looping through lights
Light light;
light.radius = 3.5;
light.intensity = 1.0;
light.pos = vec3(0,-1,0);
light.color = vec3(1.0,0.8,0.6);
float specular;
float diffuse;
vec3 rayPos = ray.pos;
vec3 dir = light.pos - ray.pos;
float lDist = length(dir);
dir = normalize(dir);
rayPos += DELTA*dir;
float near = 0.0;
float dist = 0.0;
float l;
for(int i =0 ; i < MAX_ITER;i++)
{
near = map(rayPos);
l = length(rayPos-light.pos);
if(near < DELTA || dist > lDist)
break;
float n = abs(near * 0.1);
rayPos += n*dir;
dist += n;
}
if(near < DELTA)
diffuse = 0.0;
else if(dist > lDist)
{
diffuse = max(0.0,1.0 - (lDist/light.radius));
specular = dot(reflect(ray.dir,getNormal(ray.pos)),dir)/2.0 + 0.5;
specular = -cos(specular*3.1416)/2.0 + 0.5;
specular = pow(specular,lDist*lDist);
//if(specular > 0.9);
// specular /= 20.0;
}
vec3 normal = getNormal(ray.pos);
lightComposition.diffuse = mix(SKY_COLOR, light.color, diffuse);
lightComposition.specular = light.color;
lightComposition.specularIntensity = specular;
return lightComposition;
}
//Marching through refractions
vec3 getRefraction(Ray ray)
{
vec3 color;
float colorFactor;
float intensity = 1.0;
Material mat = getMaterial(ray.pos);;
for(int i = 0; i < MAX_CYCLES; i++)
{
vec3 normal = getNormal(ray.pos);
ray.dir = refract(ray.dir, normal, mat.refr);
vec3 m = ray.dir*DELTA*2.0;
int inside = 0;
for(int j = 0; j < MAX_ITER && (ray.near < DELTA || inside == 1); j++)
{
ray.pos += m;
ray.dist += DELTA*2.0;
ray.near = map(ray.pos);
}
ray.dir = refract(ray.dir,normal,mat.refr);
ray = march(ray,MAX_ITER);
if(ray.near > DELTA || ray.dist > FAR)
{
color += SKY_COLOR*intensity;
colorFactor += intensity;
break;
}
lComp lightComposition = getLighting(ray);
mat = getMaterial(ray.pos);
vec3 col = mix(mat.color * lightComposition.diffuse,lightComposition.specular, lightComposition.specularIntensity);
color += mix(col,SKY_COLOR,ray.dist/FAR)*intensity;
colorFactor += intensity;
intensity *= 1.0 - mat.opacity;
}
return color/colorFactor;
}
//Marching through reflections
vec3 getReflection(Ray ray)
{
vec3 color;
float colorFactor;
float intensity = 1.0;
for(int i = 0; i < MAX_CYCLES; i++)
{
vec3 normal = getNormal(ray.pos);
ray.dir = reflect(ray.dir,normal);
ray.pos += ray.dir * DELTA;
ray = march(ray, MAX_ITER);
Material mat = getMaterial(ray.pos);
intensity *= mat.refl;
lComp lightComposition = getLighting(ray);
vec3 col = mix(mat.color * lightComposition.diffuse, lightComposition.specular, lightComposition.specularIntensity);
color += mix(col,SKY_COLOR,ray.dist/FAR)*intensity;
colorFactor += intensity;
}
return color/colorFactor;
}
//Getting the color at the specified point
vec3 getColor(Ray ray)
{
vec3 color;
vec3 normal = getNormal(ray.pos);
if(ray.dist > FAR)
{
color = SKY_COLOR;
}
else if(ray.near <= DELTA)
{
Material mat = getMaterial(ray.pos);
color = mat.color;
lComp lightComposition = getLighting(ray);
color *= lightComposition.diffuse;
if(mat.refr > 0.0)
color = mix(getRefraction(ray),color,mat.opacity);
if(mat.refl > 0.0)
color = mix(color,getReflection(ray),mat.refl);
color = mix(color, lightComposition.specular, lightComposition.specularIntensity);
color = mix(color, SKY_COLOR , ray.dist/FAR);
color = mix(color, SKY_COLOR , dot(ray.dir,normal)/2.0 + 0.5);
}
return color;
}
vec3 castRay(vec3 origin, vec3 direction)
{
//Generating ray
Ray ray;
ray.pos = origin;
ray.dir = direction;
ray.dist = 0.0;
//Move the ray to a surface up to far distance
ray = march(ray, MAX_ITER*2);
return getColor(ray);
}
//Initialisation
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
//Setting up screen-correct uv
vec2 uv = ( fragCoord.xy / iResolution.xy ) * 2.0 - vec2( 1 );
uv.x *= iResolution.x/iResolution.y;
//Setting up rotation
float sa = sin( iGlobalTime * A_SPEED );
float ca = cos( iGlobalTime * A_SPEED );
float cDist = CAM_DIST + sin(iGlobalTime * A_SPEED);
//Creating ray
vec3 or = vec3(sa*cDist,0.5,-ca*cDist);
vec3 di = -normalize(vec3(uv.x,uv.y,-1.0));
//Rotating orientation
mat3 r;
r[0] = vec3(ca,0,sa);
r[1] = vec3(0,1,0);
r[2] = vec3(-sa,0,ca);
di = r*di;
vec3 color = castRay(or,di);
fragColor = vec4(color,1);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

304
procedural/srtuss-industry.slang Normal file
View File

@ -0,0 +1,304 @@
#version 450
// Industry - srtuss - 2013-07-06
// https://www.shadertoy.com/view/Msf3D7
// Me beeing creative in 2D ;)
// Its a work in progress, but you guys might still enjoy it.
// by srtuss, 2013
// a little expression of my love for complex machines and stuff
// was going for some cartoonish 2d look
// still could need some optimisation
// * improved gears
// * improved camera movement
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
float hash(float x)
{
return fract(sin(x) * 43758.5453);
}
vec2 hash(vec2 p)
{
p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
return fract(sin(p) * 43758.5453);
}
// simulates a resonant lowpass filter
float mechstep(float x, float f, float r)
{
float fr = fract(x);
float fl = floor(x);
return fl + pow(fr, 0.5) + sin(fr * f) * exp(-fr * 3.5) * r;
}
// voronoi cell id noise
vec3 voronoi(in vec2 x)
{
vec2 n = floor(x);
vec2 f = fract(x);
vec2 mg, mr;
float md = 8.0;
for(int j = -1; j <= 1; j ++)
{
for(int i = -1; i <= 1; i ++)
{
vec2 g = vec2(float(i),float(j));
vec2 o = hash(n + g);
vec2 r = g + o - f;
float d = max(abs(r.x), abs(r.y));
if(d < md)
{
md = d;
mr = r;
mg = g;
}
}
}
return vec3(n + mg, mr);
}
vec2 rotate(vec2 p, float a)
{
return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
}
float stepfunc(float a)
{
return step(a, 0.0);
}
float fan(vec2 p, vec2 at, float ang)
{
p -= at;
p *= 3.0;
float v = 0.0, w, a;
float le = length(p);
v = le - 1.0;
if(v > 0.0)
return 0.0;
a = sin(atan(p.y, p.x) * 3.0 + ang);
w = le - 0.05;
v = max(v, -(w + a * 0.8));
w = le - 0.15;
v = max(v, -w);
return stepfunc(v);
}
float gear(vec2 p, vec2 at, float teeth, float size, float ang)
{
p -= at;
float v = 0.0, w;
float le = length(p);
w = le - 0.3 * size;
v = w;
w = sin(atan(p.y, p.x) * teeth + ang);
w = smoothstep(-0.7, 0.7, w) * 0.1;
v = min(v, v - w);
w = le - 0.05;
v = max(v, -w);
return stepfunc(v);
}
float car(vec2 p, vec2 at)
{
p -= at;
float v = 0.0, w;
w = length(p + vec2(-0.05, -0.31)) - 0.03;
v = w;
w = length(p + vec2(0.05, -0.31)) - 0.03;
v = min(v, w);
vec2 box = abs(p + vec2(0.0, -0.3 - 0.07));
w = max(box.x - 0.1, box.y - 0.05);
v = min(v, w);
return stepfunc(v);
}
float layerA(vec2 p, float seed)
{
float v = 0.0, w, a;
float si = floor(p.y);
float sr = hash(si + seed * 149.91);
vec2 sp = vec2(p.x, mod(p.y, 4.0));
float strut = 0.0;
strut += step(abs(sp.y), 0.3);
strut += step(abs(sp.y - 0.2), 0.1);
float st = iGlobalTime + sr;
float ct = mod(st * 3.0, 5.0 + sr) - 2.5;
v = step(2.0, abs(voronoi(p + vec2(0.35, seed * 194.9)).x));
w = length(sp - vec2(-2.0, 0.0)) - 0.8;
v = min(v, 1.0 - step(w, 0.0));
a = st;
w = fan(sp, vec2(2.5, 0.65), a * 40.0);
v = min(v, 1.0 - w);
return v;
}
float layerB(vec2 p, float seed)
{
float v = 0.0, w, a;
float si = floor(p.y / 3.0) * 3.0;
vec2 sp = vec2(p.x, mod(p.y, 3.0));
float sr = hash(si + seed * 149.91);
sp.y -= sr * 2.0;
float strut = 0.0;
strut += step(abs(sp.y), 0.3);
strut += step(abs(sp.y - 0.2), 0.1);
float st = iGlobalTime + sr;
float cs = 2.0;
if(hash(sr) > 0.5)
cs *= -1.0;
float ct = mod(st * cs, 5.0 + sr) - 2.5;
v = step(2.0, abs(voronoi(p + vec2(0.35, seed * 194.9)).x) + strut);
w = length(sp - vec2(-2.3, 0.6)) - 0.15;
v = min(v, 1.0 - step(w, 0.0));
w = length(sp - vec2(2.3, 0.6)) - 0.15;
v = min(v, 1.0 - step(w, 0.0));
if(v > 0.0)
return 1.0;
w = car(sp, vec2(ct, 0.0));
v = w;
if(hash(si + 81.0) > 0.5)
a = mechstep(st * 2.0, 20.0, 0.4) * 3.0;
else
a = st * (sr - 0.5) * 30.0;
w = gear(sp, vec2(-2.0 + 4.0 * sr, 0.5), 8.0, 1.0, a);
v = max(v, w);
w = gear(sp, vec2(-2.0 + 0.65 + 4.0 * sr, 0.35), 7.0, 0.8, -a);
v = max(v, w);
if(hash(si - 105.13) > 0.8)
{
w = gear(sp, vec2(-2.0 + 0.65 + 4.0 * sr, 0.35), 7.0, 0.8, -a);
v = max(v, w);
}
if(hash(si + 77.29) > 0.8)
{
w = gear(sp, vec2(-2.0 - 0.55 + 4.0 * sr, 0.30), 5.0, 0.5, -a + 0.7);
v = max(v, w);
}
return v;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = fragCoord.xy / iResolution.xy;
uv = uv * 2.0 - 1.0;
vec2 p = uv;
p.x *= iResolution.x / iResolution.y;
float t = iGlobalTime;
vec2 cam = vec2(sin(t) * 0.2, t);
// for future use
/*float quake = exp(-fract(t) * 5.0) * 0.5;
if(quake > 0.001)
{
cam.x += (hash(t) - 0.5) * quake;
cam.y += (hash(t - 118.29) - 0.5) * quake;
}*/
p = rotate(p, sin(t) * 0.02);
vec2 o = vec2(0.0, t);
float v = 0.0, w;
float z = 3.0 - sin(t * 0.7) * 0.1;
for(int i = 0; i < 5; i ++)
{
float f = 1.0;
float zz = 0.3 + z;
f = zz * 2.0 * 0.9;
if(i == 3 || i == 1)
w = layerA(vec2(p.x, p.y) * f + cam, float(i));
else
w = layerB(vec2(p.x, p.y) * f + cam, float(i));
v = mix(v, exp(-abs(zz) * 0.3 + 0.1), w);
z -= 0.6;
}
v = 1.0 - v;// * pow(1.0 - abs(uv.x), 0.1);
fragColor = vec4(v, v, v, 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

303
procedural/srtuss-relentless.slang Normal file
View File

@ -0,0 +1,303 @@
#version 450
// Relentless - srtuss - 2013-09-09
// https://www.shadertoy.com/view/Iss3WS
// Collecting some design ideas for a new game project. Heavily inspired by movAX13h's io shader. Thanks to iq for his ray-plane-intersection code.
// srtuss, 2013
// collecting some design ideas for a new game project.
// no raymarching is used.
// if i could add a custom soundtrack, it'd use this one (essential for desired sensation)
// http://www.youtube.com/watch?v=1uFAu65tZpo
//#define GREEN_VERSION
// ** improved camera shaking
// ** cleaned up code
// ** added stuff to the gates
// *******************************************************************************************
// Please do NOT use this shader in your own productions/videos/games without my permission!
// If you'd still like to do so, please drop me a mail (stral@aon.at)
// *******************************************************************************************
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define time iGlobalTime
vec2 rotate(vec2 p, float a)
{
return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
}
float box(vec2 p, vec2 b, float r)
{
return length(max(abs(p) - b, 0.0)) - r;
}
// iq's ray-plane-intersection code
vec3 intersect(in vec3 o, in vec3 d, vec3 c, vec3 u, vec3 v)
{
vec3 q = o - c;
return vec3(
dot(cross(u, v), q),
dot(cross(q, u), d),
dot(cross(v, q), d)) / dot(cross(v, u), d);
}
// some noise functions for fast developing
float rand11(float p)
{
return fract(sin(p * 591.32) * 43758.5357);
}
float rand12(vec2 p)
{
return fract(sin(dot(p.xy, vec2(12.9898, 78.233))) * 43758.5357);
}
vec2 rand21(float p)
{
return fract(vec2(sin(p * 591.32), cos(p * 391.32)));
}
vec2 rand22(in vec2 p)
{
return fract(vec2(sin(p.x * 591.32 + p.y * 154.077), cos(p.x * 391.32 + p.y * 49.077)));
}
float noise11(float p)
{
float fl = floor(p);
return mix(rand11(fl), rand11(fl + 1.0), fract(p));//smoothstep(0.0, 1.0, fract(p)));
}
float fbm11(float p)
{
return noise11(p) * 0.5 + noise11(p * 2.0) * 0.25 + noise11(p * 5.0) * 0.125;
}
vec3 noise31(float p)
{
return vec3(noise11(p), noise11(p + 18.952), noise11(p - 11.372)) * 2.0 - 1.0;
}
// something that looks a bit like godrays coming from the surface
float sky(vec3 p)
{
float a = atan(p.x, p.z);
float t = time * 0.1;
float v = rand11(floor(a * 4.0 + t)) * 0.5 + rand11(floor(a * 8.0 - t)) * 0.25 + rand11(floor(a * 16.0 + t)) * 0.125;
return v;
}
vec3 voronoi(in vec2 x)
{
vec2 n = floor(x); // grid cell id
vec2 f = fract(x); // grid internal position
vec2 mg; // shortest distance...
vec2 mr; // ..and second shortest distance
float md = 8.0, md2 = 8.0;
for(int j = -1; j <= 1; j ++)
{
for(int i = -1; i <= 1; i ++)
{
vec2 g = vec2(float(i), float(j)); // cell id
vec2 o = rand22(n + g); // offset to edge point
vec2 r = g + o - f;
float d = max(abs(r.x), abs(r.y)); // distance to the edge
if(d < md)
{md2 = md; md = d; mr = r; mg = g;}
else if(d < md2)
{md2 = d;}
}
}
return vec3(n + mg, md2 - md);
}
#define A2V(a) vec2(sin((a) * 6.28318531 / 100.0), cos((a) * 6.28318531 / 100.0))
float circles(vec2 p)
{
float v, w, l, c;
vec2 pp;
l = length(p);
pp = rotate(p, time * 3.0);
c = max(dot(pp, normalize(vec2(-0.2, 0.5))), -dot(pp, normalize(vec2(0.2, 0.5))));
c = min(c, max(dot(pp, normalize(vec2(0.5, -0.5))), -dot(pp, normalize(vec2(0.2, -0.5)))));
c = min(c, max(dot(pp, normalize(vec2(0.3, 0.5))), -dot(pp, normalize(vec2(0.2, 0.5)))));
// innerest stuff
v = abs(l - 0.5) - 0.03;
v = max(v, -c);
v = min(v, abs(l - 0.54) - 0.02);
v = min(v, abs(l - 0.64) - 0.05);
pp = rotate(p, time * -1.333);
c = max(dot(pp, A2V(-5.0)), -dot(pp, A2V(5.0)));
c = min(c, max(dot(pp, A2V(25.0 - 5.0)), -dot(pp, A2V(25.0 + 5.0))));
c = min(c, max(dot(pp, A2V(50.0 - 5.0)), -dot(pp, A2V(50.0 + 5.0))));
c = min(c, max(dot(pp, A2V(75.0 - 5.0)), -dot(pp, A2V(75.0 + 5.0))));
w = abs(l - 0.83) - 0.09;
v = min(v, max(w, c));
return v;
}
float shade1(float d)
{
float v = 1.0 - smoothstep(0.0, mix(0.012, 0.2, 0.0), d);
float g = exp(d * -20.0);
return v + g * 0.5;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = fragCoord.xy / iResolution.xy;
uv = uv * 2.0 - 1.0;
uv.x *= iResolution.x / iResolution.y;
// using an iq styled camera this time :)
// ray origin
vec3 ro = 0.7 * vec3(cos(0.2 * time), 0.0, sin(0.2 * time));
ro.y = cos(0.6 * time) * 0.3 + 0.65;
// camera look at
vec3 ta = vec3(0.0, 0.2, 0.0);
// camera shake intensity
float shake = clamp(3.0 * (1.0 - length(ro.yz)), 0.3, 1.0);
float st = mod(time, 10.0) * 143.0;
// build camera matrix
vec3 ww = normalize(ta - ro + noise31(st) * shake * 0.01);
vec3 uu = normalize(cross(ww, normalize(vec3(0.0, 1.0, 0.2 * sin(time)))));
vec3 vv = normalize(cross(uu, ww));
// obtain ray direction
vec3 rd = normalize(uv.x * uu + uv.y * vv + 1.0 * ww);
// shaking and movement
ro += noise31(-st) * shake * 0.015;
ro.x += time * 2.0;
float inten = 0.0;
// background
float sd = dot(rd, vec3(0.0, 1.0, 0.0));
inten = pow(1.0 - abs(sd), 20.0) + pow(sky(rd), 5.0) * step(0.0, rd.y) * 0.2;
vec3 its;
float v, g;
// voronoi floor layers
for(int i = 0; i < 4; i ++)
{
float layer = float(i);
its = intersect(ro, rd, vec3(0.0, -5.0 - layer * 5.0, 0.0), vec3(1.0, 0.0, 0.0), vec3(0.0, 0.0, 1.0));
if(its.x > 0.0)
{
vec3 vo = voronoi((its.yz) * 0.05 + 8.0 * rand21(float(i)));
v = exp(-100.0 * (vo.z - 0.02));
float fx = 0.0;
// add some special fx to lowest layer
if(i == 3)
{
float crd = 0.0;//fract(time * 0.2) * 50.0 - 25.0;
float fxi = cos(vo.x * 0.2 + time * 1.5);//abs(crd - vo.x);
fx = clamp(smoothstep(0.9, 1.0, fxi), 0.0, 0.9) * 1.0 * rand12(vo.xy);
fx *= exp(-3.0 * vo.z) * 2.0;
}
inten += v * 0.1 + fx;
}
}
// draw the gates, 4 should be enough
float gatex = floor(ro.x / 8.0 + 0.5) * 8.0 + 4.0;
float go = -16.0;
for(int i = 0; i < 4; i ++)
{
its = intersect(ro, rd, vec3(gatex + go, 0.0, 0.0), vec3(0.0, 1.0, 0.0), vec3(0.0, 0.0, 1.0));
if(dot(its.yz, its.yz) < 2.0 && its.x > 0.0)
{
v = circles(its.yz);
inten += shade1(v);
}
go += 8.0;
}
// draw the stream
for(int j = 0; j < 20; j ++)
{
float id = float(j);
vec3 bp = vec3(0.0, (rand11(id) * 2.0 - 1.0) * 0.25, 0.0);
vec3 its = intersect(ro, rd, bp, vec3(1.0, 0.0, 0.0), vec3(0.0, 0.0, 1.0));
if(its.x > 0.0)
{
vec2 pp = its.yz;
float spd = (1.0 + rand11(id) * 3.0) * 2.5;
pp.y += time * spd;
pp += (rand21(id) * 2.0 - 1.0) * vec2(0.3, 1.0);
float rep = rand11(id) + 1.5;
pp.y = mod(pp.y, rep * 2.0) - rep;
float d = box(pp, vec2(0.02, 0.3), 0.1);
float foc = 0.0;
float v = 1.0 - smoothstep(0.0, 0.03, abs(d) - 0.001);
float g = min(exp(d * -20.0), 2.0);
inten += (v + g * 0.7) * 0.5;
}
}
inten *= 0.4 + (sin(time) * 0.5 + 0.5) * 0.6;
// find a color for the computed intensity
#ifdef GREEN_VERSION
vec3 col = pow(vec3(inten), vec3(2.0, 0.15, 9.0));
#else
vec3 col = pow(vec3(inten), 1.5 * vec3(0.15, 2.0, 9.0));
#endif
fragColor = vec4(col, 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

131
procedural/srtuss-sound-digital-ambience.slang Normal file
View File

@ -0,0 +1,131 @@
#version 450
// Sound - Digital Ambience - srtuss - 2014-07-31
// https://www.shadertoy.com/view/MdXXW2
// i tried to rebuild the technique that creates the ambience sounds in my game project. it's based on additive synthesis. go ahead and "listen" to various textures
// srtuss, 2014
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
vec2 rotate(vec2 p, float a)
{
return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
}
#define ITS 8
vec2 circuit(vec3 p)
{
p = mod(p, 2.0) - 1.0;
float w = 1e38;
vec3 cut = vec3(1.0, 0.0, 0.0);
vec3 e1 = vec3(-1.0);
vec3 e2 = vec3(1.0);
float rnd = 0.23;
float pos, plane, cur;
float fact = 0.9;
float j = 0.0;
for(int i = 0; i < ITS; i ++)
{
pos = mix(dot(e1, cut), dot(e2, cut), (rnd - 0.5) * fact + 0.5);
plane = dot(p, cut) - pos;
if(plane > 0.0)
{
e1 = mix(e1, vec3(pos), cut);
rnd = fract(rnd * 9827.5719);
cut = cut.yzx;
}
else
{
e2 = mix(e2, vec3(pos), cut);
rnd = fract(rnd * 15827.5719);
cut = cut.zxy;
}
j += step(rnd, 0.2);
w = min(w, abs(plane));
}
return vec2(j / float(ITS - 1), w);
}
float scene(vec3 p)
{
vec2 cir = circuit(p);
return exp(-100.0 * cir.y) + pow(cir.x * 1.8 * (sin(p.z * 10.0 + iGlobalTime * -5.0 + cir.x * 10.0) * 0.5 + 0.5), 8.0);
}
float nse(float x)
{
return fract(sin(x * 297.9712) * 90872.2961);
}
float nseI(float x)
{
float fl = floor(x);
return mix(nse(fl), nse(fl + 1.0), smoothstep(0.0, 1.0, fract(x)));
}
float fbm(float x)
{
return nseI(x) * 0.5 + nseI(x * 2.0) * 0.25 + nseI(x * 4.0) * 0.125;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = fragCoord.xy / iResolution.xy;
vec2 suv = uv;
uv = 2.0 * uv - 1.0;
uv.x *= iResolution.x / iResolution.y;
vec3 ro = vec3(0.0, iGlobalTime * 0.2, 0.1);
vec3 rd = normalize(vec3(uv, 0.9));
ro.xz = rotate(ro.xz, iGlobalTime * 0.1);
ro.xy = rotate(ro.xy, 0.2);
rd.xz = rotate(rd.xz, iGlobalTime * 0.2);
rd.xy = rotate(rd.xy, 0.2);
float acc = 0.0;
vec3 r = ro + rd * 0.5;
for(int i = 0; i < 50; i ++)
{
acc += scene(r + nse(r.x) * 0.03);
r += rd * 0.015;
}
vec3 col = pow(vec3(acc * 0.04), vec3(0.2, 0.6, 2.0) * 8.0) * 2.0;
//col -= exp(length(suv - 0.5) * -2.5 - 0.2);
col = clamp(col, vec3(0.0), vec3(1.0));
col *= fbm(iGlobalTime * 6.0) * 2.0;
col = pow(col, vec3(1.0 / 2.2));
//col = clamp(col, vec3(0.0), vec3(1.0));
fragColor = vec4(col, 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

104
procedural/srtuss-star-swirl.slang Normal file
View File

@ -0,0 +1,104 @@
#version 450
// Star Swirl - srtuss - 2014-10-08
// https://www.shadertoy.com/view/Xd2XDm
// playing around in with 2d things. has an 178 bpm breakbeat in it ^^
// srtuss, 2014
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define pi 3.1415926535897932384626433832795
float tri(float x)
{
return abs(fract(x) * 2.0 - 1.0);
}
float dt(vec2 uv, float t)
{
vec2 p = mod(uv * 10.0, 2.0) - 1.0;
float v = 1.0 / (dot(p, p) + 0.01);
p = mod(uv * 11.0, 2.0) - 1.0;
v += 0.5 / (dot(p, p) + 0.01);
return v * (sin(uv.y * 2.0 + t * 8.0) + 1.5);
}
float fun(vec2 uv, float a, float t)
{
float beat = t * 178.0 / 4.0 / 60.0;
float e = floor(beat) * 0.1 + 1.0;
beat = fract(beat) * 16.0;
float b1 = 1.0 - mod(beat, 10.0) / 10.0;
float b2 = mod(beat, 8.0) / 8.0;
b1 = exp(b1 * -1.0) * 0.1;
b2 = exp(b2 * -4.0);
e = floor(fract(sin(e * 272.0972) * 10802.5892) * 4.0) + 1.0;
float l = length(uv);
float xx = l - 0.5 + sin(mod(l * 0.5 - beat / 16.0, 1.0) * pi * 2.0);
a += exp(xx * xx * -10.0) * 0.05;
vec2 pp = vec2(a * e + l * sin(t * 0.4) * 2.0, l);
pp.y = exp(l * -2.0) * 10.0 + tri(pp.x) + t * 2.0 - b1 * 4.0;
float v = pp.y;
v = sin(v) + sin(v * 0.5) + sin(v * 3.0) * 0.2;
v = fract(v) + b2 * 0.2;
v += exp(l * -4.5);
v += dt(pp * vec2(0.5, 1.0), t) * 0.01;
return v;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
float t = iGlobalTime;
vec2 uv = fragCoord.xy / iResolution.xy * 2.0 - 1.0;
uv.x *= 0.7 * iResolution.x / iResolution.y;
float an = atan(uv.y, uv.x) / pi;
float a = 0.02;
float v =
fun(uv, an, t + a * -3.) +
fun(uv, an, t + a * -2.) * 6. +
fun(uv, an, t + a * -1.) * 15. +
fun(uv, an, t + a * 0.) * 20. +
fun(uv, an, t + a * 1.) * 15. +
fun(uv, an, t + a * 2.) * 6. +
fun(uv, an, t + a * 3.);
v /= 64.0;
vec3 col;
col = clamp(col, vec3(0.0), vec3(1.0));
col = pow(vec3(v, v, v), vec3(0.5, 2.0, 1.5) * 8.0) * 3.0;
col = pow(col, vec3(1.0 / 2.2));
fragColor = vec4(col, 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

113
procedural/srtuss-the-eye.slang Normal file
View File

@ -0,0 +1,113 @@
#version 450
// The Eye - srtuss - 2014-10-08
// https://www.shadertoy.com/view/Xd2XDm
// Another interesting, trippy 2D effect, with a cool retro colorset.
// srtuss, 2014
// a fun little effect based on repetition and motion-blur :)
// enjoy staring at the center, in fullscreen :)
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define pi2 3.1415926535897932384626433832795
float tri(float x, float s)
{
return (abs(fract(x / s) - 0.5) - 0.25) * s;
}
float hash(float x)
{
return fract(sin(x * 171.2972) * 18267.978 + 31.287);
}
vec3 pix(vec2 p, float t, float s)
{
s += floor(t * 0.25);
float scl = (hash(s + 30.0) * 4.0);
scl += sin(t * 2.0) * 0.25 + sin(t) * 0.5;
t *= 3.0;
vec2 pol = vec2(atan(p.y, p.x), length(p));
float v;
float id = floor(pol.y * 2.0 * scl);
pol.x += t * (hash(id + s) * 2.0 - 1.0) * 0.4;
float si = hash(id + s * 2.0);
float rp = floor(hash(id + s * 4.0) * 5.0 + 4.0);
v = (abs(tri(pol.x, pi2 / rp)) - si * 0.1) * pol.y;
v = max(v, abs(tri(pol.y, 1.0 / scl)) - (1.0 - si) * 0.11);
v = smoothstep(0.01, 0.0, v);
return vec3(v);
}
vec3 pix2(vec2 p, float t, float s)
{
return clamp(pix(p, t, s) - pix(p, t, s + 8.0) + pix(p * 0.1, t, s + 80.0) * 0.2, vec3(0.0), vec3(1.0));
}
vec2 hash2(in vec2 p)
{
return fract(1965.5786 * vec2(sin(p.x * 591.32 + p.y * 154.077), cos(p.x * 391.32 + p.y * 49.077)));
}
#define globaltime (iGlobalTime - 2.555)
vec3 blur(vec2 p)
{
vec3 ite = vec3(0.0);
for(int i = 0; i < 20; i ++)
{
float tc = 0.15;
ite += pix2(p, globaltime * 3.0 + (hash2(p + float(i)) - 0.5).x * tc, 5.0);
}
ite /= 20.0;
ite += exp(fract(globaltime * 0.25 * 6.0) * -40.0) * 2.0;
return ite;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 uv = fragCoord.xy / iResolution.xy;
uv = 2.0 * uv - 1.0;
uv.x *= iResolution.x / iResolution.y;
uv += (vec2(hash(globaltime), hash(globaltime + 9.999)) - 0.5) * 0.03;
vec3 c = vec3(blur(uv + vec2(0.005, 0.0)).x, blur(uv + vec2(0.0, 0.005)).y, blur(uv).z);
c = pow(c, vec3(0.4, 0.6, 1.0) * 2.0) * 1.5;
c *= exp(length(uv) * -1.0) * 2.5;
c = pow(c, vec3(1.0 / 2.2));
fragColor = vec4(c, 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

326
procedural/stellabialek-moonlight-sillyness.slang Normal file
View File

@ -0,0 +1,326 @@
#version 450
// stellabialek - Moonlight Sillyness - 2018-02-22
// https://www.shadertoy.com/view/ld3czS
// having some fun
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define CLOUDS_ON
const float STEPS = 120.0;
const float STEPSIZE = 0.05;
const float DRAWDIST = STEPS * STEPSIZE;
const float PI = 3.1415926535897932384626433832795;
const float TWOPI = 2.0 * PI;
const int OCTAVES = 3;
struct ray
{
vec3 o; //origin
vec3 d; //direction
};
vec3 calcCameraRayDir(float fov, vec2 fragCoord, vec2 resolution)
{
float fx = tan(radians(fov) / 2.0) / resolution.x;
vec2 d = fx * (fragCoord * 2.0 - resolution);
vec3 rayDir = normalize(vec3(d, 1.0));
return rayDir;
}
float hash(vec3 p)
{
p = fract( p*0.3183099 + .1 );
p *= 17.0;
return fract( p.x*p.y*p.z*(p.x+p.y+p.z) );
}
float rand(float seed)
{
return fract(sin(seed) * 1231534.9);
}
float rand(vec2 seed)
{
return rand(dot(seed, vec2(12.9898, 783.233)));
}
float noise( in vec3 x )
{
x *= 2.0;
vec3 p = floor(x);
vec3 f = fract(x);
f = f*f*(3.0-2.0*f);
return mix(mix(mix( hash(p+vec3(0,0,0)),
hash(p+vec3(1,0,0)),f.x),
mix( hash(p+vec3(0,1,0)),
hash(p+vec3(1,1,0)),f.x),f.y),
mix(mix( hash(p+vec3(0,0,1)),
hash(p+vec3(1,0,1)),f.x),
mix( hash(p+vec3(0,1,1)),
hash(p+vec3(1,1,1)),f.x),f.y),f.z);
}
float fbm(vec3 p)
{
p *= 1.4;
float f = 0.0;
float weight = 0.5;
for(int i = 0; i < OCTAVES; ++i)
{
f += weight * noise( p );
p.z -= iGlobalTime * float(i) * 0.5;
weight *= 0.5;
p *= 2.0;
}
return f;
}
float density(vec3 p)
{
p.y += 1.2;
p.y += cos(p.x*1.4) * 0.2;
p.y += cos(p.z)*0.1;
p *= 1.2;
p.z += iGlobalTime * 0.4;
float noise = fbm(p);
float clouds = noise*1.5 - p.y - 1.3;
return clamp(clouds, 0.0, 1.0);
}
vec3 clouds(vec3 p, float d, float l, vec3 bg)
{
vec3 lPos = vec3(0,0, DRAWDIST*1.75);
vec3 lDir = lPos - p;
float dL = density(p + normalize(lDir) * 0.2);
float dG = clamp(d - dL, 0.0, 1.0);
dG *= 1.0 - smoothstep(2.0,8.0, length(lDir));
dG *= 70.0;
vec3 cL = vec3(0, 0.1, 0.1) + vec3(1.0) * dG;
vec3 cA = mix( vec3(1.0, 1.0, 1.0), vec3(1.0)*0.01, d);
float a = 0.2;
float t = exp(-a * l);
return mix(bg, cL * cA, t);
}
float stars(vec2 uv, float amount, float radius)
{
uv = uv * amount;
vec2 gridID = floor(uv);
vec2 starPos = vec2(rand(gridID),rand(gridID+1.0));
starPos = (starPos - 0.5) * 2.0;
starPos = vec2(0.5) + starPos * (0.5 - radius * 2.0);
float stars = distance(fract(uv), starPos);
float size = rand(gridID)*radius;
stars = 1.0 - smoothstep(size, size + radius, stars);
return stars;
}
float gradient(vec2 uv)
{
uv.x *= 0.8;
uv *= 1.0 + sin(iGlobalTime*10.0) * 0.01;
float g = clamp(1.0 - length(uv), 0.0, 1.0);
return clamp(g, 0.0, 1.0);
}
float circle(vec2 uv, float r)
{
return length(uv)-r;
}
float smin(float a, float b, float k)
{
float h = clamp( 0.5+0.5*(b-a)/k, 0.0, 1.0 );
return mix( b, a, h ) - k*h*(1.0-h);
}
vec2 rotate(vec2 p, float angle)
{
mat2 mat = mat2(cos(angle),-sin(angle),
sin(angle),cos(angle));
return p * mat;
}
float timefunc(float scale, float k)
{
float var = sin(iGlobalTime * scale);
var = (var + 1.0)/2.0;
var = mix(var,smoothstep(0.0, 1.0, var),k);
var = (var - 0.5)*2.0;
return var;
}
float ghost1(vec2 uv)
{
float time = iGlobalTime * 6.0;
float t = timefunc(6.0, 0.5);
uv.x += 0.5;
uv = rotate(uv, t*max(0.0, uv.y)*0.2);
uv.y -= 0.4 + sin(time * 2.0) * 0.1 * smoothstep(-0.5, 1.5, uv.y);
vec2 originalUV = uv;
uv.x *= 1.0 + uv.y;
uv.y += max(0.0, -uv.y*0.8);
float body = circle(uv, 0.2);
uv = originalUV;
uv += vec2(-0.2, 0.2);
uv = rotate(uv, -PI/4.0 + t*0.8*uv.x);
uv *= vec2(0.4, 2.0);
float arms = circle(uv, 0.1);
uv = originalUV;
uv += vec2(0.2, 0.2);
uv = rotate(uv, PI/4.0 + t*0.8*(-uv.x));
uv *= vec2(0.4, 2.0);
arms = min(arms, circle(uv, 0.1));
uv = originalUV;
uv.x -= 0.01;
uv.y += 0.05;
uv.y *= 1.0 + cos(time*2.0)*0.4;
float mouth = circle(uv, 0.02);
uv = originalUV;
uv.x -= 0.11;
float eyeR = circle(uv, 0.02);
uv.x += 0.2;
float eyeL = circle(uv, 0.04);
float d = body;
d = smin(arms,body, 0.1);
d = max(d, -eyeR);
d = max(d, -eyeL);
d = max(d, -mouth);
float threshold = mix(0.04, 0.06, (0.5 +sin(iGlobalTime)*0.5));
d = 1.0 - smoothstep(-threshold, threshold, d);
return d;
}
float ghost2(vec2 uv)
{
uv.x -= 0.4;
uv.y += timefunc(6.0, 0.5)*0.2* smoothstep(-1.0, 0.0, uv.y);
vec2 originalUV = uv;
uv.x *= 1.0 + uv.y*0.4;
uv.y *= mix(0.0, 1.0, smoothstep(-0.1, 0.0, uv.y));
float body = circle(uv, 0.15);
uv = originalUV;
uv.x -= 0.06;
float eyeR = circle(uv, 0.03);
uv.x += 0.14;
float eyeL = circle(uv, 0.025);
float d = max(body,-eyeR);
d = max(d, -eyeL);
float threshold = mix(0.04, 0.06, (0.5 +sin(iGlobalTime)*0.5));
d = 1.0 - smoothstep(-threshold, threshold, d);
d *= 0.6;
return d;
}
float ghosts(vec2 uv)
{
float d = ghost1(uv) + ghost2(uv);
return clamp(d, 0.0, 1.0);
}
vec3 tonemapping(vec3 color, float exposure, float gamma)
{
color *= exposure/(1. + color / exposure);
color = pow(color, vec3(1. / gamma));
float lum = 0.3*color.r + 0.6*color.g + 0.1*color.b;
color = mix(color, color*color, 1.0 - smoothstep(0.0,0.4,lum));
return color;
}
void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 res = vec2(max(iResolution.x, iResolution.y));
vec2 uv = fragCoord.xy / res;
uv = (uv-vec2(0.5))*2.0;
uv.y += 0.5;
uv *= 1.3;
ray r;
r.o = vec3(0.0);
r.d = calcCameraRayDir(60.0, gl_FragCoord.xy, res);
float gradient = gradient(uv);
float moon = distance(uv, vec2(0.0,0.1));
moon = 1.0 - smoothstep(0.05, 0.08, moon);
vec3 bg = mix(vec3(0.0, 0.1, 0.1),vec3(0.1, 0.3, 0.5), min(1.0, gradient*2.0));
bg = mix(bg, vec3(0.6, 0.9, 1.0), (max(0.0, gradient - 0.5)) * 2.0);
bg += vec3(0.8) * moon;
bg += vec3(0.4) * stars(uv,5.0,0.01);
bg += vec3(0.4) * stars(uv, 100.0, 0.04);
bg += vec3(0.4) * ghosts(uv) * (uv.y+1.0)*0.5;
vec4 sum = vec4(0);
float t = 0.0;
#ifdef CLOUDS_ON
for(int i = 0; i < int(STEPS); i++)
{
vec3 p = r.o + r.d * t;
float d = density(p);
if(d > 0.01)
{
float a = d * (1.0 - smoothstep(DRAWDIST / 2.0, DRAWDIST, t))*0.4;
vec3 c = clouds(p, d, t, bg);
sum += vec4(c * a, a) * ( 1.0 - sum.a );
if(sum.a > 0.99) break;
}
t += STEPSIZE;
}
#endif
vec4 c;
c = vec4(bg, 1.0) * (1.0 - sum.a) + sum;
c.rgb = tonemapping(c.rgb, 1.5,1.2);
fragColor = c;
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

301
procedural/tdm-mountain-peak.slang Normal file
View File

@ -0,0 +1,301 @@
#version 450
// Mountain Peak - TDM - 2014-09-26
// https://www.shadertoy.com/view/llK3WR
// Terrain with procedural hydraulic erosion.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
// "Mountain Peak" by Alexander Alekseev aka TDM - 2014
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
#define WIND
const int NUM_STEPS = 38;
const int NUM_STEPS_VOLUME = 10;
const float STRIDE = 0.75;
const float STRIDE_VOLUME = 1.0;
const float PI = 3.1415;
const float EPSILON = 1e-3;
// terrain
const int ITER_GEOMETRY = 4;
const int ITER_FRAGMENT = 7;
const float TERR_HEIGHT = 12.0;
const float TERR_WARP = 0.7;
const float TERR_OCTAVE_AMP = 0.55;
const float TERR_OCTAVE_FREQ = 2.5;
const float TERR_MULTIFRACT = 0.27;
const float TERR_CHOPPY = 1.9;
const float TERR_FREQ = 0.24;
const vec2 TERR_OFFSET = vec2(13.5,15.);
const vec3 SKY_COLOR = vec3(0.5,0.59,0.75) * 0.6;
const vec3 SUN_COLOR = vec3(1.,1.,0.98) * 0.75;
const vec3 COLOR_SNOW = vec3(1.0,1.0,1.1) * 2.0;
const vec3 COLOR_ROCK = vec3(0.0,0.1,0.1);
vec3 light = normalize(vec3(1.0,1.0,-0.3));
// math
mat3 fromEuler(vec3 ang) {
vec2 a1 = vec2(sin(ang.x),cos(ang.x));
vec2 a2 = vec2(sin(ang.y),cos(ang.y));
vec2 a3 = vec2(sin(ang.z),cos(ang.z));
mat3 m;
m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);
m[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);
m[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);
return m;
}
float saturate(float x) { return clamp(x,0.,1.); }
/*float hash(vec2 p) {
float h = dot(p,vec2(127.1,311.7));
return fract(sin(h)*43758.5453123);
}*/
float hash(vec2 p) {
uint n = floatBitsToUint(p.x * 122.0 + p.y);
n = (n << 13U) ^ n;
n = n * (n * n * 15731U + 789221U) + 1376312589U;
return uintBitsToFloat( (n>>9U) | 0x3f800000U ) - 1.0;
}
float hash3(vec3 p) {
return fract(sin(p.x*p.y*p.z)*347624.531834);
}
// 3d noise
float noise_3(in vec3 p) {
vec3 i = floor( p );
vec3 f = fract( p );
vec3 u = f*f*(3.0-2.0*f);
float a = hash3( i + vec3(0.0,0.0,0.0) );
float b = hash3( i + vec3(1.0,0.0,0.0) );
float c = hash3( i + vec3(0.0,1.0,0.0) );
float d = hash3( i + vec3(1.0,1.0,0.0) );
float v1 = mix(mix(a,b,u.x), mix(c,d,u.x), u.y);
a = hash3( i + vec3(0.0,0.0,1.0) );
b = hash3( i + vec3(1.0,0.0,1.0) );
c = hash3( i + vec3(0.0,1.0,1.0) );
d = hash3( i + vec3(1.0,1.0,1.0) );
float v2 = mix(mix(a,b,u.x), mix(c,d,u.x), u.y);
return abs(mix(v1,v2,u.z));
}
// noise with analytical derivatives (thanks to iq)
vec3 noise_deriv(in vec2 p) {
vec2 i = floor( p );
vec2 f = fract( p );
vec2 u = f*f*(3.0-2.0*f);
float a = hash( i + vec2(0.0,0.0) );
float b = hash( i + vec2(1.0,0.0) );
float c = hash( i + vec2(0.0,1.0) );
float d = hash( i + vec2(1.0,1.0) );
float h1 = mix(a,b,u.x);
float h2 = mix(c,d,u.x);
return vec3(abs(mix(h1,h2,u.y)),
6.0*f*(1.0-f)*(vec2(b-a,c-a)+(a-b-c+d)*u.yx));
}
// lighting
float diffuse(vec3 n,vec3 l,float p) { return pow(max(dot(n,l),0.0),p); }
float specular(vec3 n,vec3 l,vec3 e,float s) {
float nrm = (s + 8.0) / (3.1415 * 8.0);
return pow(max(dot(reflect(e,n),l),0.0),s) * nrm;
}
// terrain
vec3 octave(vec2 uv) {
vec3 n = noise_deriv(uv);
return vec3(pow(n.x,TERR_CHOPPY), n.y, n.z);
}
float map(vec3 p) {
float frq = TERR_FREQ;
float amp = 1.0;
vec2 uv = p.xz * frq + TERR_OFFSET;
vec2 dsum = vec2(0.0);
float h = 0.0;
for(int i = 0; i < ITER_GEOMETRY; i++) {
vec3 n = octave((uv - dsum * TERR_WARP) * frq);
h += n.x * amp;
dsum += n.yz * (n.x*2.0-1.0) * amp;
frq *= TERR_OCTAVE_FREQ;
amp *= TERR_OCTAVE_AMP;
amp *= pow(n.x,TERR_MULTIFRACT);
}
h *= TERR_HEIGHT / (1.0 + dot(p.xz,p.xz) * 1e-3);
return p.y - h;
}
float map_detailed(vec3 p) {
float frq = TERR_FREQ;
float amp = 1.0;
vec2 uv = p.xz * frq + TERR_OFFSET;
vec2 dsum = vec2(0.0);
float h = 0.0;
for(int i = 0; i < ITER_FRAGMENT; i++) {
vec3 n = octave((uv - dsum * TERR_WARP) * frq);
h += n.x * amp;
dsum += n.yz * (n.x*2.0-1.0) * amp;
frq *= TERR_OCTAVE_FREQ;
amp *= TERR_OCTAVE_AMP;
amp *= pow(n.x,TERR_MULTIFRACT);
}
h *= TERR_HEIGHT / (1.0 + dot(p.xz,p.xz) * 1e-3);
return p.y - h;
}
float map_noise(vec3 p) {
p *= 0.5;
float ret = noise_3(p);
ret += noise_3(p * 2.0) * 0.5;
ret = (ret - 1.0) * 5.0;
return saturate(ret * 0.5 + 0.5);
}
// tracing
vec3 getNormal(vec3 p, float eps) {
vec3 n;
n.y = map_detailed(p);
n.x = map_detailed(vec3(p.x+eps,p.y,p.z)) - n.y;
n.z = map_detailed(vec3(p.x,p.y,p.z+eps)) - n.y;
n.y = eps;
return normalize(n);
}
float hftracing(vec3 ori, vec3 dir, out vec3 p, out float t) {
float d = 0.0;
t = 0.0;
for(int i = 0; i < NUM_STEPS; i++) {
p = ori + dir * t;
d = map(p);
if(d < 0.0) break;
t += d*0.6;
}
return d;
}
float volume_tracing(vec3 ori, vec3 dir, float maxt) {
float d = 0.0;
float t = 0.0;
float count = 0.0;
for(int i = 0; i < NUM_STEPS_VOLUME; i++) {
vec3 p = ori + dir * t;
d += map_noise(p);
if(t >= maxt) break;
t += STRIDE_VOLUME;
count += 1.0;
}
return d / count;
}
// color
vec3 sky_color(vec3 e) {
e.y = max(e.y,0.0);
vec3 ret;
ret.x = pow(1.0-e.y,3.0);
ret.y = pow(1.0-e.y, 1.2);
ret.z = 0.7+(1.0-e.y)*0.3;
return ret;
}
vec3 terr_color(in vec3 p, in vec3 n, in vec3 eye, in vec3 dist) {
float slope = 1.0-dot(n,vec3(0.,1.,0.));
vec3 ret = mix(COLOR_SNOW,COLOR_ROCK,smoothstep(0.0,0.2,slope*slope));
ret = mix(ret,COLOR_SNOW,saturate(smoothstep(0.6,0.8,slope+(p.y-TERR_HEIGHT*0.5)*0.05)));
return ret;
}
// main
void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
vec2 uv = fragCoord.xy / iResolution.xy;
uv = uv * 2.0 - 1.0;
uv.x *= iResolution.x / iResolution.y;
float time = iGlobalTime * 0.1;
// ray
#ifdef MOUSE
vec3 ang = vec3(sin(time*6.0)*0.1,0.1,-time + iMouse.x*0.01);
#else
vec3 ang = vec3(sin(time*6.0)*0.1,0.1,-time + 0.0*0.01);
#endif
mat3 rot = fromEuler(ang);
vec3 ori = vec3(0.0,5.0,40.0);
vec3 dir = normalize(vec3(uv.xy,-2.0));
dir.z += length(uv) * 0.12;
dir = normalize(dir) * rot;
ori = ori * rot;
ori.y -= map(ori) * 0.75 - 3.0;
// tracing
vec3 p;
float t;
float dens = hftracing(ori,dir,p,t);
vec3 dist = p - ori;
vec3 n = getNormal(p, dot(dist,dist)* (1e-1 / iResolution.x));
// terrain
vec3 color = terr_color(p,n,dir,dist) * SKY_COLOR;
color += vec3(diffuse(n,light,2.0) * SUN_COLOR);
color += vec3(specular(n,light,dir,20.0) * SUN_COLOR*0.4);
// fog
vec3 fog = sky_color(vec3(dir.x,0.,dir.z));
color = mix(color,fog,saturate(min(length(dist)*0.018, dot(p.xz,p.xz)*0.001)));
// sky
color = mix(sky_color(dir),color,step(dens,4.0));
color += pow(max(dot(dir,light),0.0),3.0)*0.3;
// wind
#ifdef WIND
float wind = volume_tracing(ori,dir,t) * saturate(1.8 - p.y * 0.2);
color = mix(color,fog, wind * 1.6);
#endif
// post
color = (1.0 - exp(-color)) * 1.5;
color = pow(color,vec3(0.85));
fragColor = vec4(color,1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

379
procedural/tdm-psx-rendering.slang Normal file
View File

@ -0,0 +1,379 @@
#version 450
// PSX Rendering - TDM - 2016-08-06
// https://www.shadertoy.com/view/Mt3Gz2
// Lack of perspective-correct texturing, z-buffer, float data type and bilinear filtering lead to this kind of buggy rendering.
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
/*
"PSX rendering" by Alexander Alekseev aka TDM - 2016
License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
*/
#define PSX_MODE
#ifdef PSX_MODE
#define INT_VERTICES
vec2 RESOLUTION = vec2(320.0, 240.0);
#else
#define BILINEAR
vec2 RESOLUTION = iResolution.xy;
#endif
// math
float _cross(vec2 a, vec2 b) {
return a.x * b.y - a.y * b.x;
}
vec3 barycentric(vec2 a, vec2 b, vec2 c, vec2 p) {
vec2 ab = b - a, ac = c - a, ap = p - a;
vec2 vw = vec2(_cross(ap,ac),_cross(ab,ap)) / _cross(ab,ac);
return vec3(1.0-vw.x-vw.y, vw);
}
float quantization(float a, float b) {
return floor(a * b) / b;
}
vec2 quantization(vec2 a, float b) {
return floor(a * b) / b;
}
vec2 quantization(vec2 a, vec2 b) {
return floor(a * b) / b;
}
vec3 quantization(vec3 a, float b) {
return floor(a * b) / b;
}
float hash( vec2 p ) {
float h = dot(p,vec2(127.1,311.7));
return fract(sin(h)*43758.5453123);
}
float noise1(vec2 p) {
#ifndef BILINEAR
return hash(floor(p));
#else
vec2 i = floor(p);
vec2 f = fract(p);
vec2 tx = mix(vec2(hash(i),hash(i+vec2(0.,1.))) ,
vec2(hash(i+vec2(1.,0.)),hash(i+vec2(1.))),f.x);
return mix(tx.x,tx.y,f.y);
#endif
}
mat4 getRotMatrix(vec3 a) {
vec3 s = sin(a);
vec3 c = cos(a);
mat4 ret;
ret[0] = vec4(c.y*c.z,c.y*s.z,-s.y,0.0);
ret[1] = vec4(s.x*s.y*c.z-c.x*s.z,s.x*s.y*s.z+c.x*c.z,s.x*c.y,0.0);
ret[2] = vec4(c.x*s.y*c.z+s.x*s.z, c.x*s.y*s.z-s.x*c.z, c.x*c.y,0.0);
ret[3] = vec4(0.0,0.0,0.0,1.0);
return ret;
}
mat4 getPosMatrix(vec3 p) {
mat4 ret;
ret[0] = vec4(1.0,0.0,0.0,p.x);
ret[1] = vec4(0.0,1.0,0.0,p.y);
ret[2] = vec4(0.0,0.0,1.0,p.z);
ret[3] = vec4(0.0,0.0,0.0,1.0);
return ret;
}
// textures
vec4 textureGround(vec2 uv) {
const vec2 RES = vec2(8.0, 8.0);
vec2 NEW = uv * RES;
float n = noise1(NEW);
n = n * 0.2 + 0.5;
return vec4(n*0.9,n*0.6,n*0.4,1.0);
}
vec4 textureWall(vec2 uv) {
const vec2 RES = vec2(32.0, 16.0);
vec2 NEW = uv * RES;
vec2 iuv = floor(NEW);
float n = noise1(NEW);
n = n * 0.5 + 0.25;
float nc = n * (smoothstep(1.0,0.4, iuv.x / RES.x) * 0.5 + 0.5);
return vec4(nc * 0.4, nc * 1.0, nc * 0.5, n + uv.x - abs(uv.y-0.5) );
}
vec4 textureBox(vec2 uv) {
const vec2 RES = vec2(8.0, 8.0);
vec2 NEW = uv * RES;
vec2 iuv = (floor(NEW) + 0.5) / RES;
float n = noise1(NEW);
n = max(abs(iuv.x - 0.5), abs(iuv.y - 0.5)) * 2.0;
n = n * n;
n = 0.5 + n * 0.4 + noise1(NEW) * 0.1;
return vec4(n, n*0.8, n*0.5, 1.0);
}
vec4 textureSky(vec2 uv) {
const vec2 RES = vec2(8.0, 32.0);
vec2 NEW = uv * RES;
float n = noise1(NEW);
n = n * 0.05 + 0.8;
return vec4(0.5,n*1.0,n*1.1,1.0);
}
// rasterization
void triangle(vec2 p,
vec2 v0, vec2 v1, vec2 v2,
vec2 uv0, vec2 uv1, vec2 uv2,
in int tex, inout vec3 color) {
if(_cross(v2-v0,v1-v0) <= 1e-4) return;
vec3 bary = abs(barycentric(v0,v1,v2, p));
if(bary.x + bary.y + bary.z <= 1.0001) {
vec2 uv = uv0 * bary.x + uv1 * bary.y + uv2 * bary.z;
vec4 frag;
if(tex == 0) {
frag = textureGround(uv);
} else if(tex == 1) {
frag = textureWall(uv);
} else {
frag = textureBox(uv);
}
if(frag.w > 0.5) color = frag.xyz;
}
}
void quad(vec2 p,
vec2 v0, vec2 v1, vec2 v2, vec2 v3,
vec2 uv0, vec2 uv1, vec2 uv2, vec2 uv3,
in int tex, inout vec3 color) {
triangle(p, v0,v1,v2, uv0,uv1,uv2, tex,color);
triangle(p, v2,v3,v0, uv2,uv3,uv0, tex,color);
}
// geometry transformation engine
void gte(inout vec3 v, mat4 mat) {
// perspective
v = (vec4(v,1.0) * mat).xyz;
v.xy /= max(v.z, 1.0);
v *= 2.0;
// quantization to simulate int
#ifdef INT_VERTICES
const vec2 QUANT = vec2(320.0, 240.0) * 0.25;
v.xy = quantization(v.xy, QUANT);
#endif
}
// renderer
void gpu(vec2 p,
vec2 v0, vec2 v1, vec2 v2, vec2 v3,
vec2 uv0, vec2 uv1, vec2 uv2, vec2 uv3,
in int tex, inout vec3 color) {
quad(p,
v0,v1,v2,v3,
uv0,uv1,uv2,uv3,
tex,color);
}
void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
vec2 uv = fragCoord.xy / iResolution.xy;
uv = uv * 2.0 - 1.0;
uv.x *= iResolution.x / iResolution.y;
uv = quantization(uv, RESOLUTION * 0.5);
const float WIDTH = 1.3;
const float HEIGHT = 6.0;
const float DEPTH = 4.0;
const float LOD = 4.0;
float time = iGlobalTime * 2.;
vec3 posv = vec3(-WIDTH*3.0,-2.0, -time+5.0);
vec3 rotv = vec3(sin(time)*0.05 + 0.1,
sin(time*0.9)*0.05,
sin(time*0.7)*0.05);
// int-like position
#ifdef INT_VERTICES
posv = quantization(posv, 64.0);
rotv = quantization(rotv, 256.0);
#endif
mat4 cam = getPosMatrix(posv);
mat4 rot = getRotMatrix(rotv);
cam = cam * rot;
vec3 c = textureSky(uv + vec2(rotv.y,-rotv.x) * 3.0).xyz;
// ground
float z_offset = -floor((posv.z + DEPTH * 1.5) / DEPTH) * DEPTH * 0.5;
float poly_depth = DEPTH;
for(int dip = 0; dip < 32; dip++) {
// kinda LOD
z_offset += step(mod(float(dip),4.0), 0.5) * poly_depth * 0.5;
#ifdef PSX_MODE
if(dip > 11) poly_depth = DEPTH * LOD;
#endif
vec3 vert[4];
vert[0] = vec3(-WIDTH,0.0, poly_depth);
vert[1] = vec3(-WIDTH,0.0, 0.0);
vert[2] = vec3( WIDTH,0.0, 0.0);
vert[3] = vec3( WIDTH,0.0, poly_depth);
vec3 posv = vec3(mod(float(dip),4.0) * WIDTH,
0.0,
z_offset);
mat4 pos = getPosMatrix(posv * 2.0);
mat4 mat = pos * cam;
for(int i = 0; i < 4; i++) gte(vert[i], mat);
gpu(uv,
vert[3].xy,vert[2].xy,vert[1].xy,vert[0].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
0, c);
}
// walls
z_offset = -floor((posv.z + DEPTH ) / DEPTH) * DEPTH * 0.5;
poly_depth = DEPTH;
for(int dip = 0; dip < 8; dip++) {
// kinda LOD
z_offset += poly_depth * 0.5;
#ifdef PSX_MODE
if(dip > 2) poly_depth = DEPTH * LOD;
#endif
vec3 vert[4];
vert[0] = vec3(0.0,HEIGHT, poly_depth);
vert[1] = vec3(0.0,HEIGHT, 0.0);
vert[2] = vec3(0.0,0.0, 0.0);
vert[3] = vec3(0.0,0.0, poly_depth);
vec3 posv = vec3(WIDTH * 3.5,
0.0,
z_offset);
//posv.z -= z_offset;
mat4 posm = getPosMatrix(posv * 2.0);
mat4 mat = posm * cam;
for(int i = 0; i < 4; i++) gte(vert[i], mat);
gpu(uv,
vert[0].xy,vert[1].xy,vert[2].xy,vert[3].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
1, c);
vert[0] = vec3(0.0,HEIGHT, poly_depth);
vert[1] = vec3(0.0,HEIGHT, 0.0);
vert[2] = vec3( 0.0,0.0, 0.0);
vert[3] = vec3( 0.0,0.0, poly_depth);
posv = vec3(-WIDTH * 0.5,
0.0,
z_offset);
posm = getPosMatrix(posv * 2.0);
mat = posm * cam;
for(int i = 0; i < 4; i++) gte(vert[i], mat);
gpu(uv,
vert[3].xy,vert[2].xy,vert[1].xy,vert[0].xy,
vec2(1.0,0.0), vec2(1.0), vec2(0.0,1.0),vec2(0.0),
1, c);
}
// box
vec3 vert[8];
vert[0] = vec3(-1.0,-1.0, 1.0);
vert[1] = vec3(-1.0, 1.0, 1.0);
vert[2] = vec3( 1.0, 1.0, 1.0);
vert[3] = vec3( 1.0,-1.0, 1.0);
vert[4] = vec3(-1.0,-1.0,-1.0);
vert[5] = vec3(-1.0, 1.0,-1.0);
vert[6] = vec3( 1.0, 1.0,-1.0);
vert[7] = vec3( 1.0,-1.0,-1.0);
vec3 box_posv = vec3(-posv.x,
2.0,
-posv.z + 15.0);
rotv = vec3(time * 0.5, time * 0.6, time * 0.7);
mat4 posm = getRotMatrix(rotv) * getPosMatrix(box_posv);
mat4 mat = posm * cam;
for(int i = 0; i < 8; i++) {
vert[i].y *= 0.65;
gte(vert[i], mat);
}
gpu(uv,
vert[3].xy,vert[2].xy,vert[1].xy,vert[0].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
2, c);
gpu(uv,
vert[4].xy,vert[5].xy,vert[6].xy,vert[7].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
2, c);
gpu(uv,
vert[7].xy,vert[6].xy,vert[2].xy,vert[3].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
2, c);
gpu(uv,
vert[0].xy,vert[1].xy,vert[5].xy,vert[4].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
2, c);
gpu(uv,
vert[2].xy,vert[6].xy,vert[5].xy,vert[1].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
2, c);
gpu(uv,
vert[0].xy,vert[4].xy,vert[7].xy,vert[3].xy,
vec2(0.0),vec2(0.0,1.0),vec2(1.0),vec2(1.0,0.0),
2, c);
// fragment
fragColor = vec4(c,1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

230
procedural/tdm-seascape.slang Normal file
View File

@ -0,0 +1,230 @@
#version 450
// Seascape - TDM - 2014-09-26
// https://www.shadertoy.com/view/Ms2SD1
// fully-procedural sea surface computing. without textures.
// Android version: https://play.google.com/store/apps/details?id=com.nature.seascape
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
/*
* "Seascape" by Alexander Alekseev aka TDM - 2014
* License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
* Contact: tdmaav@gmail.com
*/
const int NUM_STEPS = 8;
const float PI = 3.141592;
const float EPSILON = 1e-3;
#define EPSILON_NRM (0.1 / iResolution.x)
// sea
const int ITER_GEOMETRY = 3;
const int ITER_FRAGMENT = 5;
const float SEA_HEIGHT = 0.6;
const float SEA_CHOPPY = 4.0;
const float SEA_SPEED = 0.8;
const float SEA_FREQ = 0.16;
const vec3 SEA_BASE = vec3(0.1,0.19,0.22);
const vec3 SEA_WATER_COLOR = vec3(0.8,0.9,0.6);
#define SEA_TIME (1.0 + iGlobalTime * SEA_SPEED)
const mat2 octave_m = mat2(1.6,1.2,-1.2,1.6);
// math
mat3 fromEuler(vec3 ang) {
vec2 a1 = vec2(sin(ang.x),cos(ang.x));
vec2 a2 = vec2(sin(ang.y),cos(ang.y));
vec2 a3 = vec2(sin(ang.z),cos(ang.z));
mat3 m;
m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);
m[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);
m[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);
return m;
}
float hash( vec2 p ) {
float h = dot(p,vec2(127.1,311.7));
return fract(sin(h)*43758.5453123);
}
float noise( in vec2 p ) {
vec2 i = floor( p );
vec2 f = fract( p );
vec2 u = f*f*(3.0-2.0*f);
return -1.0+2.0*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);
}
// lighting
float diffuse(vec3 n,vec3 l,float p) {
return pow(dot(n,l) * 0.4 + 0.6,p);
}
float specular(vec3 n,vec3 l,vec3 e,float s) {
float nrm = (s + 8.0) / (PI * 8.0);
return pow(max(dot(reflect(e,n),l),0.0),s) * nrm;
}
// sky
vec3 getSkyColor(vec3 e) {
e.y = max(e.y,0.0);
return vec3(pow(1.0-e.y,2.0), 1.0-e.y, 0.6+(1.0-e.y)*0.4);
}
// sea
float sea_octave(vec2 uv, float choppy) {
uv += noise(uv);
vec2 wv = 1.0-abs(sin(uv));
vec2 swv = abs(cos(uv));
wv = mix(wv,swv,wv);
return pow(1.0-pow(wv.x * wv.y,0.65),choppy);
}
float map(vec3 p) {
float freq = SEA_FREQ;
float amp = SEA_HEIGHT;
float choppy = SEA_CHOPPY;
vec2 uv = p.xz; uv.x *= 0.75;
float d, h = 0.0;
for(int i = 0; i < ITER_GEOMETRY; i++) {
d = sea_octave((uv+SEA_TIME)*freq,choppy);
d += sea_octave((uv-SEA_TIME)*freq,choppy);
h += d * amp;
uv *= octave_m; freq *= 1.9; amp *= 0.22;
choppy = mix(choppy,1.0,0.2);
}
return p.y - h;
}
float map_detailed(vec3 p) {
float freq = SEA_FREQ;
float amp = SEA_HEIGHT;
float choppy = SEA_CHOPPY;
vec2 uv = p.xz; uv.x *= 0.75;
float d, h = 0.0;
for(int i = 0; i < ITER_FRAGMENT; i++) {
d = sea_octave((uv+SEA_TIME)*freq,choppy);
d += sea_octave((uv-SEA_TIME)*freq,choppy);
h += d * amp;
uv *= octave_m; freq *= 1.9; amp *= 0.22;
choppy = mix(choppy,1.0,0.2);
}
return p.y - h;
}
vec3 getSeaColor(vec3 p, vec3 n, vec3 l, vec3 eye, vec3 dist) {
float fresnel = clamp(1.0 - dot(n,-eye), 0.0, 1.0);
fresnel = pow(fresnel,3.0) * 0.65;
vec3 reflected = getSkyColor(reflect(eye,n));
vec3 refracted = SEA_BASE + diffuse(n,l,80.0) * SEA_WATER_COLOR * 0.12;
vec3 color = mix(refracted,reflected,fresnel);
float atten = max(1.0 - dot(dist,dist) * 0.001, 0.0);
color += SEA_WATER_COLOR * (p.y - SEA_HEIGHT) * 0.18 * atten;
color += vec3(specular(n,l,eye,60.0));
return color;
}
// tracing
vec3 getNormal(vec3 p, float eps) {
vec3 n;
n.y = map_detailed(p);
n.x = map_detailed(vec3(p.x+eps,p.y,p.z)) - n.y;
n.z = map_detailed(vec3(p.x,p.y,p.z+eps)) - n.y;
n.y = eps;
return normalize(n);
}
float heightMapTracing(vec3 ori, vec3 dir, out vec3 p) {
float tm = 0.0;
float tx = 1000.0;
float hx = map(ori + dir * tx);
if(hx > 0.0) return tx;
float hm = map(ori + dir * tm);
float tmid = 0.0;
for(int i = 0; i < NUM_STEPS; i++) {
tmid = mix(tm,tx, hm/(hm-hx));
p = ori + dir * tmid;
float hmid = map(p);
if(hmid < 0.0) {
tx = tmid;
hx = hmid;
} else {
tm = tmid;
hm = hmid;
}
}
return tmid;
}
// main
void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
vec2 uv = fragCoord.xy / iResolution.xy;
uv = uv * 2.0 - 1.0;
uv.x *= iResolution.x / iResolution.y;
#ifdef MOUSE
float time = iGlobalTime * 0.3 + iMouse.x*0.01;
#else
float time = iGlobalTime * 0.3 + 0.0 * 0.01;
#endif
// ray
vec3 ang = vec3(sin(time*3.0)*0.1,sin(time)*0.2+0.3,time);
vec3 ori = vec3(0.0,3.5,time*5.0);
vec3 dir = normalize(vec3(uv.xy,-2.0)); dir.z += length(uv) * 0.15;
dir = normalize(dir) * fromEuler(ang);
// tracing
vec3 p;
heightMapTracing(ori,dir,p);
vec3 dist = p - ori;
vec3 n = getNormal(p, dot(dist,dist) * EPSILON_NRM);
vec3 light = normalize(vec3(0.0,1.0,0.8));
// color
vec3 color = mix(
getSkyColor(dir),
getSeaColor(p,n,light,dir,dist),
pow(smoothstep(0.0,-0.05,dir.y),0.3));
// post
fragColor = vec4(pow(color,vec3(0.75)), 1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}

290
procedural/tdm-wet-stone.slang Normal file
View File

@ -0,0 +1,290 @@
#version 450
// Wet Stone - TDM - 2014-10-20
// https://www.shadertoy.com/view/ldSSzV
// stone generation
/*
"Wet stone" by Alexander Alekseev aka TDM - 2014
License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
Contact: tdmaav@gmail.com
*/
layout(std140, set = 0, binding = 0) uniform UBO
{
mat4 MVP;
vec4 OutputSize;
vec4 OriginalSize;
vec4 SourceSize;
uint FrameCount;
} global;
#pragma stage vertex
layout(location = 0) in vec4 Position;
layout(location = 1) in vec2 TexCoord;
layout(location = 0) out vec2 vTexCoord;
const vec2 madd = vec2(0.5, 0.5);
void main()
{
gl_Position = global.MVP * Position;
vTexCoord = gl_Position.xy;
}
#pragma stage fragment
layout(location = 0) in vec2 vTexCoord;
layout(location = 0) out vec4 FragColor;
float iGlobalTime = float(global.FrameCount)*0.025;
vec2 iResolution = global.OutputSize.xy;
#define SMOOTH
const int NUM_STEPS = 32;
const int AO_SAMPLES = 3;
const vec2 AO_PARAM = vec2(1.2, 3.8);
const vec2 CORNER_PARAM = vec2(0.25, 40.0);
const float INV_AO_SAMPLES = 1.0 / float(AO_SAMPLES);
const float TRESHOLD = 0.1;
const float EPSILON = 1e-3;
const float LIGHT_INTENSITY = 0.25;
const vec3 RED = vec3(1.0,0.7,0.7) * LIGHT_INTENSITY;
const vec3 ORANGE = vec3(1.0,0.67,0.43) * LIGHT_INTENSITY;
const vec3 BLUE = vec3(0.54,0.77,1.0) * LIGHT_INTENSITY;
const vec3 WHITE = vec3(1.2,1.07,0.98) * LIGHT_INTENSITY;
const float DISPLACEMENT = 0.1;
// math
mat3 fromEuler(vec3 ang) {
vec2 a1 = vec2(sin(ang.x),cos(ang.x));
vec2 a2 = vec2(sin(ang.y),cos(ang.y));
vec2 a3 = vec2(sin(ang.z),cos(ang.z));
mat3 m;
m[0] = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);
m[1] = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);
m[2] = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);
return m;
}
float hash11(float p) {
return fract(sin(p * 727.1)*435.545);
}
float hash12(vec2 p) {
float h = dot(p,vec2(127.1,311.7));
return fract(sin(h)*437.545);
}
vec3 hash31(float p) {
vec3 h = vec3(127.231,491.7,718.423) * p;
return fract(sin(h)*435.543);
}
// 3d noise
float noise_3(in vec3 p) {
vec3 i = floor(p);
vec3 f = fract(p);
vec3 u = f*f*(3.0-2.0*f);
vec2 ii = i.xy + i.z * vec2(5.0);
float a = hash12( ii + vec2(0.0,0.0) );
float b = hash12( ii + vec2(1.0,0.0) );
float c = hash12( ii + vec2(0.0,1.0) );
float d = hash12( ii + vec2(1.0,1.0) );
float v1 = mix(mix(a,b,u.x), mix(c,d,u.x), u.y);
ii += vec2(5.0);
a = hash12( ii + vec2(0.0,0.0) );
b = hash12( ii + vec2(1.0,0.0) );
c = hash12( ii + vec2(0.0,1.0) );
d = hash12( ii + vec2(1.0,1.0) );
float v2 = mix(mix(a,b,u.x), mix(c,d,u.x), u.y);
return max(mix(v1,v2,u.z),0.0);
}
// fBm
float fbm3(vec3 p, float a, float f) {
return noise_3(p);
}
float fbm3_high(vec3 p, float a, float f) {
float ret = 0.0;
float amp = 1.0;
float frq = 1.0;
for(int i = 0; i < 4; i++) {
float n = pow(noise_3(p * frq),2.0);
ret += n * amp;
frq *= f;
amp *= a * (pow(n,0.2));
}
return ret;
}
// lighting
float diffuse(vec3 n,vec3 l,float p) { return pow(max(dot(n,l),0.0),p); }
float specular(vec3 n,vec3 l,vec3 e,float s) {
float nrm = (s + 8.0) / (3.1415 * 8.0);
return pow(max(dot(reflect(e,n),l),0.0),s) * nrm;
}
// distance functions
float plane(vec3 gp, vec4 p) {
return dot(p.xyz,gp+p.xyz*p.w);
}
float sphere(vec3 p,float r) {
return length(p)-r;
}
float capsule(vec3 p,float r,float h) {
p.y -= clamp(p.y,-h,h);
return length(p)-r;
}
float cylinder(vec3 p,float r,float h) {
return max(abs(p.y/h),capsule(p,r,h));
}
float box(vec3 p,vec3 s) {
p = abs(p)-s;
return max(max(p.x,p.y),p.z);
}
float rbox(vec3 p,vec3 s) {
p = abs(p)-s;
return length(p-min(p,0.0));
}
float quad(vec3 p,vec2 s) {
p = abs(p) - vec3(s.x,0.0,s.y);
return max(max(p.x,p.y),p.z);
}
// boolean operations
float boolUnion(float a,float b) { return min(a,b); }
float boolIntersect(float a,float b) { return max(a,b); }
float boolSub(float a,float b) { return max(a,-b); }
// smooth operations. thanks to iq
float boolSmoothIntersect(float a, float b, float k ) {
float h = clamp(0.5+0.5*(b-a)/k, 0.0, 1.0);
return mix(a,b,h) + k*h*(1.0-h);
}
float boolSmoothSub(float a, float b, float k ) {
return boolSmoothIntersect(a,-b,k);
}
// world
float rock(vec3 p) {
float d = sphere(p,1.0);
for(int i = 0; i < 9; i++) {
float ii = float(i);
float r = 2.5 + hash11(ii);
vec3 v = normalize(hash31(ii) * 2.0 - 1.0);
#ifdef SMOOTH
d = boolSmoothSub(d,sphere(p+v*r,r * 0.8), 0.03);
#else
d = boolSub(d,sphere(p+v*r,r * 0.8));
#endif
}
return d;
}
float map(vec3 p) {
float d = rock(p) + fbm3(p*4.0,0.4,2.96) * DISPLACEMENT;
d = boolUnion(d,plane(p,vec4(0.0,1.0,0.0,1.0)));
return d;
}
float map_detailed(vec3 p) {
float d = rock(p) + fbm3_high(p*4.0,0.4,2.96) * DISPLACEMENT;
d = boolUnion(d,plane(p,vec4(0.0,1.0,0.0,1.0)));
return d;
}
// tracing
vec3 getNormal(vec3 p, float dens) {
vec3 n;
n.x = map_detailed(vec3(p.x+EPSILON,p.y,p.z));
n.y = map_detailed(vec3(p.x,p.y+EPSILON,p.z));
n.z = map_detailed(vec3(p.x,p.y,p.z+EPSILON));
return normalize(n-map_detailed(p));
}
vec2 getOcclusion(vec3 p, vec3 n) {
vec2 r = vec2(0.0);
for(int i = 0; i < AO_SAMPLES; i++) {
float f = float(i)*INV_AO_SAMPLES;
float hao = 0.01+f*AO_PARAM.x;
float hc = 0.01+f*CORNER_PARAM.x;
float dao = map(p + n * hao) - TRESHOLD;
float dc = map(p - n * hc) - TRESHOLD;
r.x += clamp(hao-dao,0.0,1.0) * (1.0-f);
r.y += clamp(hc+dc,0.0,1.0) * (1.0-f);
}
r.x = pow(clamp(1.0-r.x*INV_AO_SAMPLES*AO_PARAM.y,0.0,1.0),0.5);
r.y = clamp(r.y*INV_AO_SAMPLES*CORNER_PARAM.y,0.0,1.0);
return r;
}
vec2 spheretracing(vec3 ori, vec3 dir, out vec3 p) {
vec2 td = vec2(0.0);
for(int i = 0; i < NUM_STEPS; i++) {
p = ori + dir * td.x;
td.y = map(p);
if(td.y < TRESHOLD) break;
td.x += (td.y-TRESHOLD) * 0.9;
}
return td;
}
// stone
vec3 getStoneColor(vec3 p, float c, vec3 l, vec3 n, vec3 e) {
c = min(c + pow(noise_3(vec3(p.x*20.0,0.0,p.z*20.0)),70.0) * 8.0, 1.0);
float ic = pow(1.0-c,0.5);
vec3 base = vec3(0.42,0.3,0.2) * 0.6;
vec3 sand = vec3(0.51,0.41,0.32);
vec3 color = mix(base,sand,c);
float f = pow(1.0 - max(dot(n,-e),0.0), 1.5) * 0.75 * ic;
color = mix(color,vec3(1.0),f);
color += vec3(diffuse(n,l,0.5) * WHITE);
color += vec3(specular(n,l,e,8.0) * WHITE * 1.5 * ic);
n = normalize(n - normalize(p) * 0.4);
color += vec3(specular(n,l,e,80.0) * WHITE * 1.5 * ic);
return color;
}
// main
void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
vec2 iuv = fragCoord.xy / iResolution.xy * 2.0 - 1.0;
vec2 uv = iuv;
uv.x *= iResolution.x / iResolution.y;
float time = iGlobalTime * 0.3;
// ray
vec3 ang = vec3(0.0,0.2,time);
#ifdef MOUSE
if(iMouse.z > 0.0) ang = vec3(0.0,clamp(2.0-iMouse.y*0.01,0.0,3.1415),iMouse.x*0.01);
#endif
mat3 rot = fromEuler(ang);
vec3 ori = vec3(0.0,0.0,2.8);
vec3 dir = normalize(vec3(uv.xy,-2.0));
ori = ori * rot;
dir = dir * rot;
// tracing
vec3 p;
vec2 td = spheretracing(ori,dir,p);
vec3 n = getNormal(p,td.y);
vec2 occ = getOcclusion(p,n);
vec3 light = normalize(vec3(0.0,1.0,0.0));
// color
vec3 color = vec3(1.0);
if(td.x < 3.5 && p.y > -0.89) color = getStoneColor(p,occ.y,light,n,dir);
color *= occ.x;
// post
float vgn = smoothstep(1.2,0.7,abs(iuv.y)) * smoothstep(1.1,0.8,abs(iuv.x));
color *= 1.0 - (1.0 - vgn) * 0.15;
fragColor = vec4(color,1.0);
}
void main(void)
{
//just some shit to wrap shadertoy's stuff
vec2 FragmentCoord = vTexCoord.xy*global.OutputSize.xy;
FragmentCoord.y = -FragmentCoord.y;
mainImage(FragColor,FragmentCoord);
}