// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform sampler2D prgm2Texture;
uniform sampler2D prgm4Texture;
uniform vec2 resolution;
uniform float time;
float osc(float s, float e, float t) {
return (e - s) * 0.5 + s + sin(t) * (e - s) * 0.5;
}
void main(void) {
vec2 uv = gl_FragCoord.xy / resolution.xy;
vec4 texA = texture2D(prgm4Texture, uv);
vec4 texB = texture2D(prgm2Texture, uv);
float t = time * 0.25;
float o = osc(t, t + 2.0, time * 0.35);
vec3 color = mix(texA.xyz, texB.xyz, osc(-0.2, 0.2, o));
gl_FragColor = vec4(color, 1.0);
}
// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform vec2 resolution;
uniform float time;
uniform float fft;
const float PI = acos(-1.0);
const float TAU = PI * 2.0;
const vec2 hashv2 = vec2(12.9898, 78.233);
const float hashS = 43758.5453123;
const float starsSpeed = 1.2;
const int starsLayers = 12;
float rand(float n) {
return fract(sin(n) * hashS);
}
float rand(vec2 uv) {
return fract(sin(dot(uv, hashv2)) * hashS);
}
float noise (vec2 uv) {
vec2 b = floor(uv);
return mix(
mix(rand(b), rand(b + vec2(1.0, 0.0)), 0.5),
mix(rand(b + vec2(0.0, 1.0)), rand(b + vec2(1.0, 1.0)), 0.5),
0.5
);
}
float gaussian(float z, float u, float o) {
return (
(1.0 / (o * sqrt(TAU))) *
(exp(-(((z - u) * (z - u)) / (2.0 * (o * o)))))
);
}
vec3 gaussgrain(float t) {
vec2 ps = vec2(1.0) / resolution.xy;
vec2 uv = gl_FragCoord.xy * ps;
float seed = dot(uv, hashv2);
float noise = fract(sin(seed) * hashS + t);
noise = gaussian(noise, 0.0, 0.5);
return vec3(noise);
}
float circle(vec2 uv, float r) {
vec2 dist = uv - vec2(0.5);
return 1.0 - smoothstep(r - (r * 0.03), r + (r * 0.03), dot(dist, dist) * 4.0);
}
float mapRange(float val, float min1, float max1, float min2, float max2) {
return min2 + (val - min1) * (max2 - min2) / (max1 - min1);
}
float renderStars(vec2 uv) {
float stars = 0.0;
float fl, s;
for (int layer = 0; layer < starsLayers; layer++) {
fl = float(layer);
s = (500.0 - fl * 30.0);
stars += step(
0.1,
pow(
abs(noise(mod(vec2(uv.x * s + time * starsSpeed - fl * 100.0, uv.y * s), resolution.x))),
21.0
)
) * (fl / float(starsLayers));
}
return stars;
}
void main(void) {
const float skyLimit = 0.3;
const float seaSpread = 0.1;
const float sunLightSpread = 0.15;
const float srDuration = 1.6;
float audio = fft * 0.12;
float stripsSize = 13.0;
float seaRadius = 0.3 + audio;
float sunRadius = 0.35 + audio;
float sunLightRadius = sunRadius * 0.91;
vec2 uv = gl_FragCoord.xy / resolution.xy;
float rtime = clamp(log(time * 0.5) * 0.9, 0.0, srDuration);
seaRadius += sin(rtime) * 0.1;
sunRadius += sin(rtime) * 0.2;
float sunStart = 0.9 - sin(rtime) * 0.9;
vec3 bgColor = vec3(0.17, 0.12, 0.25);
if (uv.y > skyLimit) {
bgColor += mix(bgColor, (1.0 - uv.y) * vec3(0.7, 0.2, 0.5), 0.7);
}
vec3 sunLightColor = vec3(1.00, 0.14, 0.73);
vec3 color = bgColor;
float stars = renderStars(uv);
float starsInSky = mix(0.0, stars, 1.0 - step(uv.y, skyLimit));
color = mix(color, vec3(0.63, 0.60, 0.74), starsInSky * clamp(time * 0.5 - 0.5, 0.0, 1.0) * 0.6);
float ar = resolution.x / resolution.y;
vec2 cuv = vec2(
uv.x * ar - ((resolution.x - resolution.y) / resolution.y * 0.5) / resolution.y,
uv.y + sunStart
);
cuv -= vec2(0.12, 0.0);
float sunLight = 1.0 - smoothstep(sunLightRadius - sunLightSpread, sunLightRadius + sunLightSpread, length(cuv - vec2(0.5, 0.55 - sunStart)));
float sunLightMix = sunLight * 0.9 * (0.6 + noise(vec2(uv.x * 10.0 + time, uv.y * 60.0 + time)) * 0.4);
color = mix(color, sunLightColor, sunLightMix);
vec3 sunColor = mix(vec3(0.99, 0.98, 0.22), vec3(1.0, 0.0, 0.73), 1.0 - uv.y);
float sunCut = step(1.0 - uv.y - sunStart, 0.75);
float sun = circle(cuv, sunRadius) * sunCut;
float sy = mapRange(pow(1.0 - uv.y + 0.0, 7.0), 0.0, skyLimit, 0.0, 1.0);
float sunStrips = 1.0 - step(fract(sy * stripsSize), 0.5);
sunStrips = mix(sunStrips, 0.0, step(1.0 - uv.y , skyLimit));
float sunStripsFade = 1.0 - smoothstep(0.32 - seaSpread * 2., 0.32 + seaSpread * 2., length(cuv - vec2(0.5, 0.45)));
sunStrips *= sunStripsFade * (1.0 - (srDuration - rtime));
sunColor = mix(sunColor, bgColor, sunStrips);
color = mix(color, sunColor, sun);
float y = mapRange(fract(uv.y), 0.0, skyLimit, 0.0, 1.0) - 0.04 + time * 0.05;
float seaStrips = step(fract(y * stripsSize), 0.5);
seaStrips = mix(seaStrips, 1.0, step(1.0 - uv.y, 1.0 - skyLimit));
float seaGradient = mapRange(uv.y, 0.0, skyLimit, 0.0, 1.0);
float seaFade = smoothstep(seaRadius - seaSpread, seaRadius + seaSpread, length(uv - vec2(0.5, 0.35)));
vec3 seaColor = mix(vec3(0.212, 0.263, 0.467), vec3(0.208, 0.376, 0.761), seaGradient);
seaColor = mix(seaColor, bgColor, seaFade);
float seaStripsFade = 1.0 - smoothstep(0.3 - seaSpread * 2.0, 0.3 + seaSpread * 2.0, length(cuv - vec2(0.5, 0.45)));
seaStrips *= seaStripsFade;
vec3 seaReflectColor = mix(
vec3(1.0, 0.58, 0.35),
vec3(1.0, 0.10, 0.73),
1.0 - mapRange(uv.y, skyLimit * 0.5, skyLimit, 0.0, 1.0)
);
seaColor = mix(seaColor, seaReflectColor, seaStrips);
color = mix(color, seaColor, step(uv.y, skyLimit)) * clamp(time * 0.6667, 0.0, 1.0);
color += gaussgrain(time * 0.35) * vec3(step(uv.y, skyLimit)) * 0.21;
float frameScale = 2.00;
float frameTime = floor(time * frameScale) / frameScale;
float noise = rand(uv * 3.0);
color = mix(color, vec3(noise), 0.06);
color = mix(color, color * color, 0.5);
color = color - gaussgrain(time) * 0.02;
color *= clamp(time * 0.12, 0.0, 1.0);
gl_FragColor = vec4(color, 1.0);
}
// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform sampler2D noiseTexture;
uniform sampler2D prgm1Texture;
uniform vec2 resolution;
uniform float time;
uniform float fft;
const float g = 0.12;
float osc(float s, float e, float t) {
return (e - s) * 0.5 + s + sin(t) * (e - s) * 0.5;
}
float stepm(float a, float b, float c) {
return step(c, sin(time + a * cos(time * b)));
}
float gaussian(float z, float u, float o) {
return (
(1.0 / (o * sqrt(2.0 * acos(-1.0)))) *
(exp(-(((z - u) * (z - u)) / (2.0 * (o * o)))))
);
}
vec3 gaussgrain(float t) {
vec2 ps = vec2(1.0) / resolution.xy;
vec2 uv = gl_FragCoord.xy * ps;
float seed = dot(uv, vec2(12.9898, 78.233));
float noise = fract(sin(seed) * 43758.5453123 + t);
noise = gaussian(noise, 0.0, 0.5);
return vec3(noise);
}
float texNoise(vec2 uv) {
float s = texture2D(noiseTexture, vec2(1.0, 2.0 * cos(time)) * time * 8.0 + uv * 1.0).x;
s *= s;
return s;
}
float ramp(float y, float start, float end) {
float ins = step(start, y) - step(end, y);
float fact = (y - start) / (end - start) * ins;
return (1.0 - fact) * ins;
}
float stripes(vec2 uv) {
float n = texNoise(uv * vec2(0.5, 1.0) + vec2(1.0, 3.0));
return ramp(mod(uv.y * 3.0 + time / 2.0 + sin(time * 0.5 + sin(time * 0.6)), 1.0), 0.5, 0.6) * n;
}
vec3 badVHS(vec2 uv, sampler2D tex) {
float h = osc(0.0, 0.001, time * 0.2);
float v = osc(0.0, 0.03, time * 0.3);
float tmod = mod(time * 0.25, 3.0);
float lookyMod = uv.y - tmod;
float window = 1.0 / (1.0 + 20.0 * lookyMod * lookyMod);
float lookyStep = stepm(4.0, 4.0, 0.3) * 0.5;
uv.x = uv.x + sin(uv.y * 10.0 + time) / 100.0 * lookyStep * (1.0 + cos(time * 80.0)) * window * 0.25;
float vShift = v * stepm(2.0, 3.0, 0.9) * (sin(time) * sin(time * 20.0) + (0.5 + 0.1 * sin(time * 200.0) * cos(time)));
uv.y = mod(uv.y + vShift, 5.0);
vec3 desatColor;
float _r, _g, _b;
float x = sin(0.3 * time + uv.y * 21.0) * sin(0.7 * time + uv.y * 29.0) * sin(0.3 + 0.33 * time + uv.y * 31.0) * h;
_r = texture2D(tex, vec2(x + uv.x + 0.001, uv.y + 0.001)).x + 0.007;
_g = texture2D(tex, vec2(x + uv.x + 0.000, uv.y - 0.002)).y + 0.007;
_b = texture2D(tex, vec2(x + uv.x - 0.002, uv.y + 0.000)).z + 0.007;
_r += 0.08 * texture2D(tex, 0.75 * vec2(x + 0.012, -0.013) + vec2(uv.x + 0.001, uv.y + 0.001)).x;
_g += 0.05 * texture2D(tex, 0.75 * vec2(x + -0.011, -0.010) + vec2(uv.x + 0.000, uv.y - 0.002)).y;
_b += 0.08 * texture2D(tex, 0.75 * vec2(x + -0.010, -0.009) + vec2(uv.x - 0.002, uv.y + 0.000)).z;
float _luma = 0.3 * _r + 0.6 * _g + 0.1 * _b;
float _desat = 0.3;
desatColor = vec3(
_r + _desat * (_luma - _r),
_g + _desat * (_luma - _g),
_b + _desat * (_luma - _b)
);
float s = stripes(uv) * osc(-0.3, 0.4, osc(time, time + 2.0, time * 0.35));
float sb = stripes(uv - osc(0.001, 0.02, time * 0.1)) * osc(-0.3, 0.4, osc(time, time + 2.0, time * 0.45));
desatColor += s * s + sb * sb;
desatColor = clamp(desatColor, 0.0, 1.0);
return desatColor;
}
void main(void) {
vec2 uv = gl_FragCoord.xy / resolution.xy;
vec4 prgm1 = texture2D(prgm1Texture, uv);
float frameScale = 29.97;
float frameTime = floor(time * frameScale) / frameScale;
vec3 grain = gaussgrain(frameTime * 2.0);
vec3 color = badVHS(uv, prgm1Texture) + grain * g;
gl_FragColor = vec4(color, 1.0);
}
// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform sampler2D prgm2Texture;
uniform vec2 resolution;
uniform float time;
uniform float fft;
const float amount = 1.0;
const float reinhardAmount = 1.05;
const float contrast = 1.1;
const float brightness = 1.0;
const float saturation = 0.75;
const vec2 vignetteSize = vec2(0.3, 0.3);
const float vignetteRoundness = 0.9;
const float vignetteMix = 0.21;
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) {
vec2 uv = gl_FragCoord.xy / resolution.xy;
vec4 prgm2 = texture2D(prgm2Texture, uv);
vec3 reinhard = filmicReinhard(prgm2.rgb);
vec3 color = prgm2.rgb;
color = mix(prgm2.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(prgm2.xyz, color, amount);
color = clamp(color, 0.0, 1.0);
gl_FragColor = vec4(color, 1.0);
}
// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;
uniform sampler2D prgm3Texture;
uniform vec2 resolution;
uniform float time;
const float hardscan = -16.0;
const float hardPix = -4.0;
const float maskDark = 0.5;
const float maskLight = 2.5;
float toLinear(float c) {
return (c <= 0.04045) ? c / 12.92 : pow(abs((c + 0.055) / 1.055), 2.4);
}
vec3 toLinear(vec3 c) {
return vec3(toLinear(c.r), toLinear(c.g), toLinear(c.b));
}
float toSRGB(float c) {
return(c < 0.0031308 ? c * 12.92 : 1.055 * pow(abs(c), 0.41666) - 0.055);
}
vec3 toSRGB(vec3 c) {
return vec3(toSRGB(c.r), toSRGB(c.g), toSRGB(c.b));
}
vec3 fetch(vec2 pos, vec2 off, vec2 res) {
pos = floor(pos * res + off) / res;
if (max(abs(pos.x - 0.5), abs(pos.y - 0.5)) > 0.5) {
return vec3(0.0);
}
return toLinear(texture2D(prgm3Texture, pos.xy, -16.0).xyz);
}
vec2 dist(vec2 pos, vec2 res) {
pos = pos * res;
return -((pos - floor(pos)) - vec2(0.5));
}
float gauss(float pos, float scale) {
return exp2(scale * pos * pos);
}
vec3 horz3(vec2 pos, float off, vec2 res) {
vec3 b = fetch(pos, vec2(-1.0, off), res);
vec3 c = fetch(pos, vec2(+0.0, off), res);
vec3 d = fetch(pos, vec2(+1.0, off), res);
float dst = dist(pos, res).x;
float scale = hardPix;
float wb = gauss(dst - 1.0, scale);
float wc = gauss(dst + 0.0, scale);
float wd = gauss(dst + 1.0, scale);
return (b * wb + c * wc + d * wd) / (wb + wc + wd);
}
vec3 horz5(vec2 pos, float off, vec2 res) {
vec3 a = fetch(pos, vec2(-2.0, off), res);
vec3 b = fetch(pos, vec2(-1.0, off), res);
vec3 c = fetch(pos, vec2(+0.0, off), res);
vec3 d = fetch(pos, vec2(+1.0, off), res);
vec3 e = fetch(pos, vec2(+2.0, off), res);
float dst = dist(pos, res).x;
float scale = hardPix;
float wa = gauss(dst - 2.0, scale);
float wb = gauss(dst - 1.0, scale);
float wc = gauss(dst + 0.0, scale);
float wd = gauss(dst + 1.0, scale);
float we = gauss(dst + 2.0, scale);
return (a * wa + b * wb + c * wc + d * wd + e * we) / (wa + wb + wc + wd + we);
}
float scan(vec2 pos, float off, vec2 res) {
float dst = dist(pos, res).y;
return gauss(dst + off, hardscan);
}
vec3 tri(vec2 pos, vec2 res) {
vec3 a = horz3(pos, -1.0, res);
vec3 b = horz5(pos, +0.0, res);
vec3 c = horz3(pos, +1.0, res);
float wa = scan(pos, -1.0, res);
float wb = scan(pos, +0.0, res);
float wc = scan(pos, +1.0, res);
return a * wa + b * wb + c * wc;
}
vec3 mask(vec2 pos) {
pos.x += pos.y * 3.0;
vec3 m = vec3(maskDark, maskDark, maskDark);
pos.x = fract(pos.x / 6.0);
if (pos.x < 0.333) {
m.r = maskLight;
} else if (pos.x < 0.666) {
m.g = maskLight;
} else {
m.b = maskLight;
}
return m;
}
float bar(float pos, float bar) {
pos -= bar;
return pos * pos < 4.0 ? 0.0 : 1.0;
}
vec2 warp(vec2 uv, vec2 warpAmount) {
uv = uv * 2.0 - 1.0;
vec2 offset = abs(uv.yx) / vec2(warpAmount.x, warpAmount.y);
uv = uv + uv * offset * offset;
uv = uv * 0.5 + 0.5;
return uv;
}
void drawVig(inout vec3 color, vec2 uv) {
float vignette = uv.x * uv.y * (1.0 - uv.x) * (1.0 - uv.y);
vignette = clamp(pow(abs(16.0 * vignette), 0.1), 0.0, 1.0);
color *= vignette;
}
void main(void) {
vec2 warpAmount = vec2(7.0, 5.0);
vec2 res = vec2(640.0, 320.0);
vec2 uv = gl_FragCoord.xy / resolution.xy;
float vig = (0.0 + 1.0 * 21.0 * uv.x * uv.y * (1.0 - uv.x) * (1.0 - uv.y));
float v = exp(-0.01 * length(uv)) * vig;
float frameScale = 29.97;
float frameTime = floor(time * frameScale) / frameScale;
vec2 pos = warp(uv, warpAmount);
vec4 color = vec4(tri(pos, res) * mask(gl_FragCoord.xy), 1.0);
color.xyz = toSRGB(color.xyz * 2.0);
color = mix(color, color * v, 0.5);
drawVig(color.xyz, pos);
gl_FragColor = color;
}