// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform sampler2D prgm2Texture;
uniform vec2 resolution;
void main(void) {
vec2 uv = gl_FragCoord.xy / resolution.xy;
vec4 prgm2 = texture2D(prgm2Texture, uv);
gl_FragColor = vec4(prgm2.xyz, 1.0);
}
// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform sampler2D noiseTexture;
uniform vec2 resolution;
uniform vec2 mouse;
uniform float time;
uniform float fft;
const float PI = acos(-1.0);
const float TAU = PI * 2.0;
const float rndc = 43758.5453123;
float rand11(float p) {
return fract(sin(p * 591.32) * rndc);
}
vec2 rand22(vec2 p) {
return fract(vec2(sin(p.x * 591.32 + p.y * 154.077), cos(p.x * 391.32 + p.y * 49.077)));
}
float osc(float s, float e, float ts) {
return (e - s) / 2.0 + s + sin(time * ts) * (e - s) / 2.0;
}
float tNoise(vec2 n) {
n = fract(n * vec2(5.3987, 5.4421));
n += dot(n.yx, n.xy + vec2(21.5351, 14.3137));
float xy = n.x * n.y;
return fract(xy * 95.4307) + fract(xy * 75.04961) - 1.0;
}
float noise(vec2 x) {
vec2 p = floor(x);
vec2 f = fract(x);
f = f * f * (3.0 - 2.0 * f);
float a = texture2D(noiseTexture, (p + vec2(0.5, 0.5)) / 256.0, 0.0).x;
float b = texture2D(noiseTexture, (p + vec2(1.5, 0.5)) / 256.0, 0.0).x;
float c = texture2D(noiseTexture, (p + vec2(0.5, 1.5)) / 256.0, 0.0).x;
float d = texture2D(noiseTexture, (p + vec2(1.5, 1.5)) / 256.0, 0.0).x;
return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
}
vec4 vignette(vec2 xy, vec4 fragcol, float intensity, bool reverse) {
xy *= 1.0 - xy.yx;
float vig = pow(xy.x * xy.y * 8.0, 0.25 + intensity);
return reverse ? fragcol /= vec4(vig) : fragcol *= vec4(vig);
}
vec3 intersect(vec3 o, 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);
}
float sky(vec3 p) {
float a = atan(p.y, p.z);
float t = time;
float n = noise(vec2(p.x, p.z));
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.75
);
v = smoothstep(0.0, 3.0, v) + n / 4.0;
return v * 1.0 + fft * 0.5;
}
float ssin(float t) {
return (2.0 / PI) * atan(sin(TAU * t * 0.5) / 0.1) * 2.0;
}
vec3 voronoi(vec2 x) {
vec2 n = floor(x), f = fract(x), mg, mr;
float md = 16.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));
vec2 o = rand22(n + g);
vec2 r = g + o - f;
float d = mix(
abs(r.x) + abs(r.y), // manhattan distance
max(abs(r.x), abs(r.y)), // chebyshev distance
clamp(ssin(time * 0.05), 0.0, 1.0)
);
if (d < md) {
md2 = md; md = d; mr = r; mg = g;
} else if (d < md2) {
md2 = d;
}
}
}
return vec3(n + mg, md2 - md);
}
vec2 rotate(vec2 p, float a) {
return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a));
}
void main(void) {
vec2 uv = gl_FragCoord.xy / resolution.xy;
vec2 uvs = uv;
float ar = resolution.x / resolution.y;
uv = uv * 2.0 - 1.0;
uv.x *= ar;
vec3 ro = vec3(1.0, 0.3, 1.0);
vec3 ta = vec3(0.0, 0.0, 1.0);
vec3 ww = normalize(ta - ro);
vec3 uu = normalize(cross(ww, normalize(vec3(0.0, 1.0, osc(-0.125, 0.125, 0.25)))));
vec3 vv = normalize(cross(uu, ww));
vec3 rd = normalize(uv.x * uu + uv.y * vv + ww);
ro.x -= time * 21.0;
float inten = 0.0;
float sd = dot(rd, vec3(-0.01, 0.99, 0.0));
inten = (
pow(abs(0.99 - abs(sd)), 32.0 - fft * 64.0) +
pow(abs(sky(rd)), 6.0) * step(0.0, rd.y) * 2.0
);
inten = inten + 0.13 - length(uv) * 0.25;
vec3 its;
float v, g;
for (int i = 0; i < 3; i ++) {
float fi = float(i) + 1.0;
float layer = float(i);
float timea = time * 1.2 * float(i);
float timeb = time * 0.9 * float(i);
its = intersect(
ro, rd,
vec3(timeb, -30.0 - layer * 30.0, timea),
vec3(1.0, 0.0, 0.0),
vec3(0.0, 0.0, 1.0)
);
if (its.x > 0.0) {
vec3 vo = voronoi((its.yz * (i == 0 ? fi : fi * 0.6)) * 0.05 + 8.0 * noise(vec2(float(i))));
v = exp(-40.0 * (vo.z - 0.05));
float fx = 0.05;
if (i == 0) {
float fxi = cos(vo.x * 18.65 + time * 2.5);
fx = clamp(smoothstep(0.1, 1.0, fxi), 0.01, 1.9) * (2.0 + fft * 3.0) * noise(vo.zy * 16.0);
fx *= exp(-1.0 * vo.z) * 1.5;
} else if (i == 2) {
float fxi = cos(vo.x * 18.5 + (time * 2.0) * 2.5);
fx = clamp(smoothstep(0.1, 1.0, fxi), 0.01, 1.9) * (2.0 + fft * 3.0) * noise(vo.zy * 16.0);
fx *= exp(-4.0 * vo.z) * 1.5;
}
fx = smoothstep(0.0, 5.0, fx);
inten += sqrt(v) * 0.06 + fx;
}
}
vec3 col = pow(vec3(inten * 1.2), vec3(1.0, 1.0, 0.4));
col *= col;
gl_FragColor = vignette(uvs, vec4(col, 1.0), fft, true);
}
// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform sampler2D prgm1Texture;
uniform vec2 resolution;
uniform float time;
uniform float fft;
const float amount = 1.0;
const float saturation = 0.6;
const vec2 vignetteSize = vec2(0.25, 0.25);
const float vignetteRoundness = 0.12;
const float vignetteMix = 1.0;
const float vignetteSmoothness = 0.42;
const float W = 1.2;
const float T = 7.5;
float filmicReinhardCurve(float x) {
float q = (T * T + 1.0) * x * x;
return q / (q + x + T * T);
}
vec3 filmicReinhard(vec3 c) {
float w = filmicReinhardCurve(W);
return vec3(
filmicReinhardCurve(c.r),
filmicReinhardCurve(c.g),
filmicReinhardCurve(c.b)
) / w;
}
vec3 ContrastSaturationBrightness(vec3 color, float brt, float sat, float con) {
const float AvgLumR = 0.5;
const float AvgLumG = 0.5;
const float AvgLumB = 0.5;
const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
vec3 brtColor = color * brt;
vec3 intensity = vec3(dot(brtColor, LumCoeff));
vec3 satColor = mix(intensity, brtColor, sat);
vec3 conColor = mix(AvgLumin, satColor, con);
return conColor;
}
float sdSquare(vec2 point, float width) {
vec2 d = abs(point) - width;
return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
}
float vignette(vec2 uv, vec2 size, float roundness, float smoothness) {
uv -= 0.5;
float minWidth = min(size.x, size.y);
uv.x = sign(uv.x) * clamp(abs(uv.x) - abs(minWidth - size.x), 0.0, 1.0);
uv.y = sign(uv.y) * clamp(abs(uv.y) - abs(minWidth - size.y), 0.0, 1.0);
float boxSize = minWidth * (1.0 - roundness);
float dist = sdSquare(uv, boxSize) - (minWidth * roundness);
return 1.0 - smoothstep(0.0, smoothness, dist);
}
void main(void) {
float reinhardAmount = 0.4 + fft * 0.6;
float contrast = 1.0 + fft * 0.25;
float brightness = 1.5 + fft * 0.5;
vec2 uv = gl_FragCoord.xy / resolution.xy;
vec4 prgm1 = texture2D(prgm1Texture, uv);
vec3 reinhard = filmicReinhard(prgm1.rgb);
vec3 color = prgm1.rgb;
color = mix(prgm1.rgb, reinhard, reinhardAmount);
color = ContrastSaturationBrightness(color, brightness, saturation, contrast);
float v = vignette(uv, vignetteSize, vignetteRoundness, vignetteSmoothness);
vec3 vig = color * v;
color = mix(color, vig, vignetteMix);
color = mix(prgm1.xyz, color, amount);
color = clamp(color, 0.0, 1.0);
gl_FragColor = vec4(color, 1.0);
}