401 lines
9.9 KiB
GLSL
401 lines
9.9 KiB
GLSL
#ifndef PI
|
|
#define PI 3.1415927
|
|
#endif
|
|
|
|
#include inc_time.glsl
|
|
#include inc_rand.glsl
|
|
#include inc_res.glsl
|
|
|
|
#ifndef INC_FUNCTIONS
|
|
#define INC_FUNCTIONS
|
|
|
|
// BASICS
|
|
|
|
float istep(float x, float y) {
|
|
return 1. - step(x, y);
|
|
}
|
|
|
|
float estep(float x, float y) {
|
|
return smoothstep(x - .0001, x + .0001, y);
|
|
}
|
|
|
|
float iestep(float x, float y) {
|
|
return 1. - estep(x, y);
|
|
}
|
|
|
|
float ease(float x) {
|
|
return .5 - cos(max(min(x, 1.), 0.) * PI) * .5;
|
|
}
|
|
|
|
vec2 ease(vec2 x) {
|
|
return .5 - cos(max(min(x, 1.), 0.) * PI) * .5;
|
|
}
|
|
|
|
vec3 ease(vec3 x) {
|
|
return .5 - cos(max(min(x, 1.), 0.) * PI) * .5;
|
|
}
|
|
|
|
float saw(float x) {
|
|
return abs(mod(x + 1., 2.) - 1.);
|
|
}
|
|
|
|
vec2 saw(vec2 x) {
|
|
return abs(mod(x + 1., 2.) - 1.);
|
|
}
|
|
|
|
vec3 saw(vec3 x) {
|
|
return abs(mod(x + 1., 2.) - 1.);
|
|
}
|
|
|
|
float cmod(float x, float k) {
|
|
return mod(x + k * .5, k) - k * .5;
|
|
}
|
|
|
|
vec2 cmod(vec2 x, float k) {
|
|
return mod(x + k * .5, k) - k * .5;
|
|
}
|
|
|
|
vec3 cmod(vec3 x, float k) {
|
|
return mod(x + k * .5, k) - k * .5;
|
|
}
|
|
|
|
// COLORS
|
|
|
|
vec3 col(float x) {
|
|
return vec3(
|
|
.5 * (sin(x * 2. * PI) + 1.),
|
|
.5 * (sin(x * 2. * PI + PI * .6666667) + 1.),
|
|
.5 * (sin(x * 2. * PI - PI * .6666667) + 1.)
|
|
);
|
|
}
|
|
|
|
vec3 shift(vec3 c, float f) {
|
|
return vec3(
|
|
c.x * (1. - f) + c.y * f,
|
|
c.y * (1. - f) + c.z * f,
|
|
c.z * (1. - f) + c.x * f
|
|
);
|
|
}
|
|
|
|
vec3 shift3(vec3 c, float f) {
|
|
return shift(shift(shift(c, f), f), f);
|
|
}
|
|
|
|
vec3 mix3(vec3 c1, vec3 c2, vec3 c3, float x) {
|
|
return istep(.5, x) * mix(c1, c2, x * 2.)
|
|
+ step(.5, x) * mix(c2, c3, x * 2. - 1.);
|
|
}
|
|
|
|
vec3 mix4(vec3 c1, vec3 c2, vec3 c3, vec3 c4, float x) {
|
|
return istep(.333, x) * mix(c1, c2, x * 3.)
|
|
+ step(.333, x) * istep(.667, x) * mix(c2, c3, x * 3. - 1.)
|
|
+ step(.667, x) * mix(c3, c4, x * 3. - 2.);
|
|
;
|
|
}
|
|
|
|
vec3 mix5(vec3 c1, vec3 c2, vec3 c3, vec3 c4, vec3 c5, float x) {
|
|
return istep(.25, x) * mix(c1, c2, x * 4.)
|
|
+ step(.25, x) * istep(.5, x) * mix(c2, c3, x * 4. - 1.)
|
|
+ step(.5, x) * istep(.75, x) * mix(c3, c4, x * 4. - 2.)
|
|
+ step(.75, x) * mix(c4, c5, x * 4. - 3.);
|
|
}
|
|
|
|
vec3 mix6(vec3 c1, vec3 c2, vec3 c3, vec3 c4, vec3 c5, vec3 c6, float x) {
|
|
return istep(.2, x) * mix(c1, c2, x * 5.)
|
|
+ step(.2, x) * istep(.4, x) * mix(c2, c3, x * 5. - 1.)
|
|
+ step(.4, x) * istep(.6, x) * mix(c3, c4, x * 5. - 2.)
|
|
+ step(.6, x) * istep(.8, x) * mix(c4, c5, x * 5. - 3.)
|
|
+ step(.8, x) * mix(c5, c6, x * 5. - 4.);
|
|
}
|
|
|
|
float mean(vec3 v)
|
|
{
|
|
return v.x * .3333 + v.y * .3333 + v.z * .3333;
|
|
}
|
|
|
|
float mean(vec4 v)
|
|
{
|
|
return v.x * .3333 + v.y * .3333 + v.z * .3333;
|
|
}
|
|
|
|
// OTHER
|
|
|
|
mat2 rot(float angle) {
|
|
return mat2(
|
|
cos(angle * 2. * PI), -sin(angle * 2. * PI),
|
|
sin(angle * 2. * PI), cos(angle * 2. * PI)
|
|
);
|
|
}
|
|
|
|
// EFFECTS
|
|
|
|
vec2 lens(vec2 uv, float limit, float power) {
|
|
return uv * (1. + limit + length(uv * power));
|
|
}
|
|
|
|
vec2 kal(vec2 uv, float n) {
|
|
float t = atan(uv.y, uv.x) + PI * .5;
|
|
float q = .4774648; // 3. / (2. * PI);
|
|
t = abs(mod(t + PI / n, 2. * PI / n) - PI / n);
|
|
return length(uv) * vec2(
|
|
cos(t),
|
|
sin(t)
|
|
);
|
|
}
|
|
|
|
vec2 kal2(vec2 uv, float n) {
|
|
float t = atan(uv.y, uv.x) + PI * .5;
|
|
float t2 = abs(mod(t + PI / n, 2. * PI / n) - PI / n);
|
|
return length(uv) * vec2(
|
|
cos(t2),
|
|
sin(t2)
|
|
);
|
|
}
|
|
|
|
// NOISE
|
|
|
|
float noise(vec2 n)
|
|
{
|
|
const vec2 d = vec2(0., 1.);
|
|
vec2 b = floor(n);
|
|
vec2 f = fract(n);
|
|
f *= f * (3. - 2. * f);
|
|
return mix(mix(rand(b), rand(b + d.yx), f.x), mix(rand(b + d.xy), rand(b + d.yy), f.x), f.y);
|
|
}
|
|
|
|
float noise_f(vec2 n, int f)
|
|
{
|
|
float o = noise(n) * .5;
|
|
o += mix(o, noise(n * 2.), f > 1. ? 1. : 0.) * .25;
|
|
o += mix(o, noise(n * 4.), f > 2. ? 1. : 0.) * .125;
|
|
o += mix(o, noise(n * 8.), f > 3. ? 1. : 0.) * .0625;
|
|
o += mix(o, noise(n * 16.), f > 4. ? 1. : 0.) * .03125;
|
|
return o;
|
|
}
|
|
|
|
// VORONOI
|
|
|
|
float v_index(vec2 uv) {
|
|
return floor(uv.x) + floor(uv.y) * 45.;
|
|
}
|
|
|
|
vec2 v_pos(float i, int seed, float time) {
|
|
int iTimeId = int(time);
|
|
float iTimeV = time - iTimeId;
|
|
|
|
float x0 = rand(i + seed + iTimeId);
|
|
float y0 = rand(i + seed + 10. + iTimeId);
|
|
|
|
float x1 = rand(i + seed + iTimeId + 1.);
|
|
float y1 = rand(i + seed + 10. + iTimeId + 1.);
|
|
|
|
return vec2(
|
|
mix(x0, x1, ease(ease(iTimeV))),
|
|
mix(y0, y1, ease(ease(iTimeV)))
|
|
);
|
|
}
|
|
|
|
vec4 voronoi(vec2 uv, float dist, int seed, float time) {
|
|
vec4 o = vec4(0., 0., 2., 0.);
|
|
vec4 t = vec4(0., 0., 2., 0.);
|
|
float d, i;
|
|
vec2 uv2, p;
|
|
int dx, dy;
|
|
for (dx = -1; dx <= 1; dx++) {
|
|
for (dy = -1; dy <= 1; dy++) {
|
|
uv2 = vec2(floor(uv.x) + dx, floor(uv.y) + dy);
|
|
i = v_index(uv2);
|
|
p = uv2 + v_pos(i, seed, time) * dist;
|
|
d = length(p - uv);
|
|
if (d < o.z) {
|
|
t = o;
|
|
o = vec4(p, d, i);
|
|
} else if (d < t.z) {
|
|
t = vec4(p, d, i);
|
|
}
|
|
}
|
|
}
|
|
return vec4(o.z, t.z, o.w, t.w);
|
|
}
|
|
|
|
// SHAPES
|
|
|
|
float circle(vec2 uv, vec2 c, float size) {
|
|
return istep(size, length(uv - c));
|
|
}
|
|
|
|
float h_circle(vec2 uv, vec2 c, float size, float k) {
|
|
return circle(uv, c, size + k * .5) - circle(uv, c, size - k * .5);
|
|
}
|
|
|
|
float stripe(float x, float k1, float k2)
|
|
{
|
|
return k2 > k1 ? (1. - step(x, k1)) * (step(x, k2)) : ((1. - step(x, k2)) * (step(x, k1)));
|
|
}
|
|
|
|
float capsule(vec2 uv, float r, float d, float a)
|
|
{
|
|
uv *= rot(a);
|
|
float f1 = step(uv.x, r) * step(-uv.x, r) * step(uv.y, d - r) * step(-uv.y, d - r);
|
|
float f2 = step(length(uv - vec2(0., d - r)), r);
|
|
float f3 = step(length(uv + vec2(0., d - r)), r);
|
|
return min(1., f1 + f2 + f3);
|
|
}
|
|
|
|
float rect(vec2 uv, vec2 c, vec2 size) {
|
|
uv -= c;
|
|
return step(abs(uv.x), size.x) * step(abs(uv.y), size.y);
|
|
}
|
|
|
|
float h_rect(vec2 uv, vec2 c, vec2 size, float k) {
|
|
return rect(uv, c, size + k * .5) - rect(uv, c, size - k * .5);
|
|
}
|
|
|
|
float line(vec2 uv, vec2 p1, vec2 p2, float thick) {
|
|
vec2 p = p2 - p1;
|
|
uv -= p1;
|
|
vec2 k;
|
|
|
|
if (abs(p.y) > abs(p.x)) {
|
|
k = vec2(
|
|
uv.x - p.x * uv.y / p.y,
|
|
uv.y / p.y
|
|
);
|
|
|
|
return step(k.x, thick * .5)
|
|
* step(-k.x, thick * .5)
|
|
* step(k.y, 1.)
|
|
* (1. - step(k.y, 0.));
|
|
} else {
|
|
k = vec2(
|
|
uv.x / p.x,
|
|
uv.y - p.y * uv.x / p.x
|
|
);
|
|
|
|
return step(k.y, thick * .5)
|
|
* step(-k.y, thick * .5)
|
|
* step(k.x, 1.)
|
|
* (1. - step(k.x, 0.));
|
|
}
|
|
}
|
|
|
|
const mat2x2 ISOMETRIC_MATRIX = mat2x2(
|
|
.5, 1.,
|
|
.5, -1.
|
|
);
|
|
|
|
vec2 iso(vec2 p) {
|
|
return p * ISOMETRIC_MATRIX;
|
|
}
|
|
|
|
vec2 iso_z(float z) {
|
|
return vec2(
|
|
-z,
|
|
z
|
|
);
|
|
}
|
|
|
|
vec2 iso(vec3 uv) {
|
|
return iso(uv.xy) + iso_z(uv.z);
|
|
}
|
|
|
|
// INPUTS
|
|
|
|
vec4 reframe(sampler2D tex, vec2 uv)
|
|
{
|
|
uv = uv * vec2(iResolution.y / iResolution.x, 1.) + .5;
|
|
uv = saw(uv);
|
|
return texture(tex, uv);
|
|
}
|
|
|
|
vec4 reframe_b(sampler2D tex, vec2 uv)
|
|
{
|
|
uv = uv * vec2(iResolution.y / iResolution.x, 1.) + .5;
|
|
return texture(tex, uv);
|
|
}
|
|
|
|
vec4 kernel(sampler2D tex, vec2 uv, mat3x3 k, float spm)
|
|
{
|
|
int x, y;
|
|
vec2 offset;
|
|
vec4 sum = vec4(0.);
|
|
for (y = -1; y <= 1; ++y) {
|
|
for (x = -1; x <= 1; ++x) {
|
|
offset = vec2(x, y) * spm;
|
|
if (abs(k[x + 1][y + 1]) > 0.) {
|
|
sum += k[x + 1][y + 1] * texture(tex, uv + offset);
|
|
}
|
|
}
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
// BLUR
|
|
|
|
float gaussian_weight(float x, float sigma)
|
|
{
|
|
return exp(-(x * x) / (2. * sigma * sigma));
|
|
}
|
|
|
|
vec4 gauss(sampler2D tex, vec2 uv, const int kernel_size, float spm, float sigma, float bloom)
|
|
{
|
|
int x, y;
|
|
vec2 offset;
|
|
float w;
|
|
vec4 sum = vec4(0.);
|
|
float weight_sum = 0.;
|
|
for (y = -kernel_size; y <= kernel_size; ++y) {
|
|
for (x = -kernel_size; x <= kernel_size; ++x) {
|
|
offset = vec2(x, y) * spm;
|
|
w = gaussian_weight(length(vec2(x, y)), sigma);
|
|
sum += texture(tex, uv + offset) * w;
|
|
weight_sum += w;
|
|
}
|
|
}
|
|
return (sum / weight_sum) * bloom;
|
|
}
|
|
|
|
vec4 gauss(sampler2D tex, vec2 uv, const int kernel_size, float spm, float sigma)
|
|
{
|
|
return gauss(tex, uv, kernel_size, spm, sigma, 1.);
|
|
}
|
|
|
|
vec4 gauss(sampler2D tex, vec2 uv, const int kernel_size, float spm)
|
|
{
|
|
return gauss(tex, uv, kernel_size, spm, 2.);
|
|
}
|
|
|
|
vec4 gauss(sampler2D tex, vec2 uv, const int kernel_size)
|
|
{
|
|
return gauss(tex, uv, kernel_size, 1. / max(iResolution.x, iResolution.y));
|
|
}
|
|
|
|
vec4 gauss(sampler2D tex, vec2 uv)
|
|
{
|
|
return gauss(tex, uv, 3);
|
|
}
|
|
|
|
float dither(vec2 uv, float x)
|
|
{
|
|
bool o = false;
|
|
o = o || x * 16. >= 1. && floor(mod(uv.x, 4.)) == 0. && floor(mod(uv.y, 4.)) == 0.;
|
|
o = o || x * 16. >= 2. && floor(mod(uv.x, 4.)) == 2. && floor(mod(uv.y, 4.)) == 2.;
|
|
o = o || x * 16. >= 3. && floor(mod(uv.x, 4.)) == 0. && floor(mod(uv.y, 4.)) == 2.;
|
|
o = o || x * 16. >= 4. && floor(mod(uv.x, 4.)) == 2. && floor(mod(uv.y, 4.)) == 0.;
|
|
o = o || x * 16. >= 5. && floor(mod(uv.x, 4.)) == 1. && floor(mod(uv.y, 4.)) == 1.;
|
|
o = o || x * 16. >= 6. && floor(mod(uv.x, 4.)) == 3. && floor(mod(uv.y, 4.)) == 3.;
|
|
o = o || x * 16. >= 7. && floor(mod(uv.x, 4.)) == 1. && floor(mod(uv.y, 4.)) == 3.;
|
|
o = o || x * 16. >= 8. && floor(mod(uv.x, 4.)) == 3. && floor(mod(uv.y, 4.)) == 1.;
|
|
o = o || x * 16. >= 9. && floor(mod(uv.x, 4.)) == 1. && floor(mod(uv.y, 4.)) == 0.;
|
|
o = o || x * 16. >= 10. && floor(mod(uv.x, 4.)) == 3. && floor(mod(uv.y, 4.)) == 2.;
|
|
o = o || x * 16. >= 11. && floor(mod(uv.x, 4.)) == 1. && floor(mod(uv.y, 4.)) == 2.;
|
|
o = o || x * 16. >= 12. && floor(mod(uv.x, 4.)) == 3. && floor(mod(uv.y, 4.)) == 0.;
|
|
o = o || x * 16. >= 13. && floor(mod(uv.x, 4.)) == 0. && floor(mod(uv.y, 4.)) == 1.;
|
|
o = o || x * 16. >= 14. && floor(mod(uv.x, 4.)) == 2. && floor(mod(uv.y, 4.)) == 3.;
|
|
o = o || x * 16. >= 15. && floor(mod(uv.x, 4.)) == 0. && floor(mod(uv.y, 4.)) == 3.;
|
|
o = o || x * 16. >= 16. && floor(mod(uv.x, 4.)) == 2. && floor(mod(uv.y, 4.)) == 1.;
|
|
return o ? 1. : 0.;
|
|
}
|
|
|
|
#endif
|