mirror of
https://github.com/libretro/slang-shaders.git
synced 2024-06-22 22:31:45 -04:00
533 lines
14 KiB
Plaintext
533 lines
14 KiB
Plaintext
#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);
|
|
}
|