precision highp float; varying vec2 v_uv; uniform sampler2D u_image; uniform sampler2D u_charAtlas; uniform sampler2D u_charAtlas2; uniform float u_outputLayer; // 0 = composite, 1 = transparent characters, 2 = background uniform vec2 u_charFrac; uniform float u_charSoft; uniform float u_regionActive; uniform vec4 u_regionRect; uniform float u_regionCharCount; uniform float u_regionBright; uniform float u_regionBold; uniform vec2 u_resolution; uniform vec2 u_cellSize; uniform float u_charCount; uniform float u_bgDarken; uniform float u_threshold; uniform float u_blur; uniform float u_waveIntensity; uniform float u_waveScale; uniform float u_density; uniform float u_edgeBoost; uniform float u_colorGrad; uniform float u_charOpacity; uniform float u_fadeRange; uniform float u_charGamma; uniform float u_monoMode; uniform vec3 u_monoBg; uniform vec3 u_monoChar; uniform float u_invert; uniform float u_edgeThreshold; uniform float u_edgeFade; uniform float u_time; uniform float u_flickerSpeed; uniform float u_flickerIntensity; uniform float u_flickerRandom; uniform float u_gradientOn; uniform float u_gradientDir; uniform float u_gradientIntensity; uniform float u_gradStopCount; uniform float u_noise; uniform vec4 u_gradStops[8]; // === Post-Processing === uniform float u_pp_vignette; uniform float u_pp_scanlines; uniform float u_pp_crt; uniform float u_pp_chromatic; uniform float u_pp_grain; uniform float u_pp_glitch; uniform float u_pp_glitchSpeed; uniform float u_pp_pixelate; uniform float u_pp_halftone; uniform float u_pp_halftoneSize; uniform float u_pp_dust; uniform vec3 u_pp_overlay; uniform float u_pp_overlayAmt; uniform float u_pp_bloom; uniform float u_charDither; uniform float u_revealProgress; // -1 = disabled, 0..1 = sweep uniform float u_revealAngle; // radians uniform sampler2D u_motionMask; // r: 0 = static, 1 = moving uniform float u_motionOn; uniform float u_motionOriginal; uniform float u_motionStatic; uniform float u_motionView; vec4 outColor; vec3 sampleGradient(float t) { t = clamp(t, 0.0, 1.0); vec3 color = u_gradStops[0].rgb; for (int i = 1; i < 8; i++) { if (float(i) >= u_gradStopCount) break; float prevPos = u_gradStops[i - 1].w; float currPos = u_gradStops[i].w; if (t >= prevPos && t <= currPos) { float localT = (t - prevPos) / max(currPos - prevPos, 0.001); color = mix(u_gradStops[i - 1].rgb, u_gradStops[i].rgb, localT); } else if (t > currPos) { color = u_gradStops[i].rgb; } } return color; } float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); } float noise(vec2 p) { vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f); float a = hash(i), b = hash(i + vec2(1,0)), c = hash(i + vec2(0,1)), d = hash(i + vec2(1,1)); return mix(mix(a, b, f.x), mix(c, d, f.x), f.y); } float sampleChar(sampler2D atlas, vec2 uv, float count, float soft) { if (soft < 0.005) return texture2D(atlas, uv).r; float s = soft * 0.12; float sx = s / count; float c = texture2D(atlas, uv).r * 0.36; c += texture2D(atlas, uv + vec2( sx, 0.0)).r * 0.12; c += texture2D(atlas, uv + vec2(-sx, 0.0)).r * 0.12; c += texture2D(atlas, uv + vec2( 0.0, s )).r * 0.12; c += texture2D(atlas, uv + vec2( 0.0, -s )).r * 0.12; c += texture2D(atlas, uv + vec2( sx, s )).r * 0.04; c += texture2D(atlas, uv + vec2(-sx, s )).r * 0.04; c += texture2D(atlas, uv + vec2( sx, -s )).r * 0.04; c += texture2D(atlas, uv + vec2(-sx, -s )).r * 0.04; return c; } float fbm(vec2 p) { float v = 0.0, a = 0.5; for (int i = 0; i < 4; i++) { v += a * noise(p); p *= 2.0; a *= 0.5; } return v; } vec3 blurSample(vec2 uv, float radius) { vec3 sum = vec3(0.0); float count = 0.0; vec2 texel = 1.0 / u_resolution; for (float x = -4.0; x <= 4.0; x += 1.0) for (float y = -4.0; y <= 4.0; y += 1.0) { sum += texture2D(u_image, uv + vec2(x,y) * texel * radius).rgb; count += 1.0; } return sum / count; } float edgeDetect(vec2 uv) { vec2 t = 1.0 / u_resolution; float tl = dot(texture2D(u_image, uv+vec2(-1, 1)*t).rgb, vec3(.299,.587,.114)); float tm = dot(texture2D(u_image, uv+vec2( 0, 1)*t).rgb, vec3(.299,.587,.114)); float tr = dot(texture2D(u_image, uv+vec2( 1, 1)*t).rgb, vec3(.299,.587,.114)); float ml = dot(texture2D(u_image, uv+vec2(-1, 0)*t).rgb, vec3(.299,.587,.114)); float mr = dot(texture2D(u_image, uv+vec2( 1, 0)*t).rgb, vec3(.299,.587,.114)); float bl = dot(texture2D(u_image, uv+vec2(-1,-1)*t).rgb, vec3(.299,.587,.114)); float bm = dot(texture2D(u_image, uv+vec2( 0,-1)*t).rgb, vec3(.299,.587,.114)); float br = dot(texture2D(u_image, uv+vec2( 1,-1)*t).rgb, vec3(.299,.587,.114)); float gx = -tl - 2.0*ml - bl + tr + 2.0*mr + br; float gy = -tl - 2.0*tm - tr + bl + 2.0*bm + br; return sqrt(gx*gx + gy*gy); } vec3 applyPP(vec3 col, vec2 suv) { if (u_pp_vignette > 0.001) { vec2 vc = suv - 0.5; col *= clamp(1.0 - dot(vc, vc) * u_pp_vignette * 3.5, 0.0, 1.0); } if (u_pp_scanlines > 0.001) { float sl = sin(suv.y * u_resolution.y * 3.14159) * 0.5 + 0.5; col *= 1.0 - u_pp_scanlines * 0.45 * (1.0 - sl); } if (u_pp_grain > 0.001) { float g = (hash(suv * u_resolution + fract(u_time * 43.7)) - 0.5) * u_pp_grain; col = clamp(col + g, 0.0, 1.0); } if (u_pp_bloom > 0.001) { float lum = dot(col, vec3(0.299, 0.587, 0.114)); col = clamp(col + col * lum * u_pp_bloom * 1.5, 0.0, 1.0); } if (u_pp_halftone > 0.001) { float sz = max(u_pp_halftoneSize, 2.0); vec2 hc = (floor(suv * u_resolution / sz) + 0.5) * sz / u_resolution; float r = length(suv - hc) * min(u_resolution.x, u_resolution.y) / sz; float lum = dot(col, vec3(0.299, 0.587, 0.114)); float inside = step(r, lum * u_pp_halftone * 1.4); col = mix(col, col * inside, u_pp_halftone * 0.7); } if (u_pp_dust > 0.001) { float dh = hash(floor(suv * u_resolution / 2.0) + floor(u_time * 10.0) * 77.0); if (dh > 1.0 - u_pp_dust * 0.012) { float db = hash(suv * 831.0 + u_time * 0.4); col = mix(col, vec3(db * 0.6 + 0.4), 0.7); } } if (u_pp_overlayAmt > 0.001) { col = clamp(mix(col, col * u_pp_overlay * 2.0, u_pp_overlayAmt), 0.0, 1.0); } return col; } void effect() { vec2 suv = gl_FragCoord.xy / u_resolution; // CRT barrel distortion vec2 sampUV = v_uv; if (u_pp_crt > 0.001) { vec2 cc = sampUV - 0.5; sampUV = sampUV + cc * dot(cc, cc) * u_pp_crt * 1.5; if (sampUV.x < 0.0 || sampUV.x > 1.0 || sampUV.y < 0.0 || sampUV.y > 1.0) { outColor = vec4(0.0, 0.0, 0.0, u_outputLayer == 1.0 ? 0.0 : 1.0); return; } } // Pixelate if (u_pp_pixelate > 1.5) { float ps = u_pp_pixelate; sampUV = (floor(sampUV * u_resolution / ps) * ps + ps * 0.5) / u_resolution; } // Glitch if (u_pp_glitch > 0.001) { float rowH = max(2.0, u_resolution.y * 0.04); float row = floor(sampUV.y * u_resolution.y / rowH); float t = floor(u_time * (u_pp_glitchSpeed * 5.0 + 1.0)); float gh = hash(vec2(row, t)); if (gh > 1.0 - u_pp_glitch * 0.3) { float shift = (hash(vec2(row + 0.5, t)) - 0.5) * u_pp_glitch * 0.15; sampUV.x = fract(sampUV.x + shift); } } float chromAmt = u_pp_chromatic * 0.025; vec2 cell = floor(gl_FragCoord.xy / u_cellSize); vec2 cellUV = (cell + 0.5) * u_cellSize / u_resolution; cellUV.y = 1.0 - cellUV.y; // Apply same distortions to cellUV for image sampling vec2 cellSampUV = cellUV; if (u_pp_crt > 0.001) { vec2 cc2 = cellSampUV - 0.5; cellSampUV = clamp(cellSampUV + cc2 * dot(cc2, cc2) * u_pp_crt * 1.5, 0.001, 0.999); } if (u_pp_pixelate > 1.5) { float ps = u_pp_pixelate; cellSampUV = (floor(cellSampUV * u_resolution / ps) * ps + ps * 0.5) / u_resolution; } // Moving vs static: the mask is built per frame from a running background model float motion = 0.0; float motionMult = 1.0; if (u_motionOn > 0.5) { if (u_motionView > 0.5 && u_outputLayer != 1.0) { float m = texture2D(u_motionMask, sampUV).r; vec3 base = texture2D(u_image, sampUV).rgb * 0.35; outColor = vec4(mix(base, vec3(0.29, 0.871, 0.502), m * 0.85), 1.0); return; } motion = texture2D(u_motionMask, cellSampUV).r; motionMult = mix(u_motionStatic, 1.0, motion); } vec3 cellColor; if (chromAmt > 0.001) { cellColor = vec3( texture2D(u_image, cellSampUV + vec2(chromAmt, 0.0)).r, texture2D(u_image, cellSampUV).g, texture2D(u_image, cellSampUV - vec2(chromAmt, 0.0)).b ); } else { cellColor = texture2D(u_image, cellSampUV).rgb; } float brightness = dot(cellColor, vec3(0.299, 0.587, 0.114)); float edgeRaw = clamp(edgeDetect(cellUV) * 0.25, 0.0, 1.0); // Boost edge detection in bright areas where subtle edges are lost float brightBoost = smoothstep(0.55, 0.85, brightness) * 3.0; float boostedEdgeRaw = clamp(edgeRaw + edgeRaw * brightBoost, 0.0, 1.0); // Edge Min/Width: only edges above threshold contribute to brightness float edgeGate = smoothstep(u_edgeThreshold, u_edgeThreshold + max(u_edgeFade, 0.01), boostedEdgeRaw); float edge = edgeGate * u_edgeBoost * 1.5; vec2 wc = cell / u_waveScale; float wave = fbm(wc) * 2.0 - 1.0; float waveOff = wave * u_waveIntensity; // Enhance local contrast in bright areas float localContrast = smoothstep(0.6, 0.9, brightness); float adjustedBri = mix(brightness, brightness * brightness, localContrast * 0.5); float eBri = clamp(adjustedBri + waveOff * 0.3 + edge, 0.0, 1.0); if (u_invert > 0.5) eBri = 1.0 - eBri; float flickerVal = 1.0; if (u_flickerSpeed > 0.001) { float cellId = hash(cell * 17.31); float phase = cellId * u_flickerRandom * 6.2832; float speed = u_flickerSpeed * (0.5 + cellId * u_flickerRandom * 1.5); flickerVal = 0.5 + 0.5 * sin(u_time * speed + phase); flickerVal = mix(1.0, flickerVal, u_flickerIntensity); } vec3 gradColor = vec3(1.0); if (u_gradientOn > 0.5) { float gt = 0.0; vec2 nuv = gl_FragCoord.xy / u_resolution; if (u_gradientDir < 0.5) gt = nuv.x; else if (u_gradientDir < 1.5) gt = 1.0 - nuv.y; else if (u_gradientDir < 2.5) gt = (nuv.x + (1.0 - nuv.y)) * 0.5; else gt = length(nuv - 0.5) * 1.414; gradColor = sampleGradient(gt); } if (u_monoMode > 0.5) { vec3 monoBg = u_monoBg; float monograin = (hash(gl_FragCoord.xy + fract(u_time * 100.0)) - 0.5) * u_noise; monoBg = clamp(monoBg + monograin, 0.0, 1.0); if (u_outputLayer == 2.0) { outColor = vec4(applyPP(monoBg, suv), 1.0); return; } vec3 charCol = u_monoChar; if (u_gradientOn > 0.5) charCol = mix(u_monoChar, gradColor, u_gradientIntensity); float cVal = pow(clamp(eBri + waveOff * 0.2, 0.0, 1.0), u_charGamma); float cDither = (hash(cell + 31.7) - 0.5) * u_charDither; float cIdx = floor(clamp(cVal + cDither, 0.0, 1.0) * (u_charCount - 1.0) + 0.5); vec2 lp = fract(gl_FragCoord.xy / u_cellSize); lp.y = 1.0 - lp.y; float cAlpha = 0.0; if (lp.x < u_charFrac.x && lp.y < u_charFrac.y) { vec2 alp = vec2(lp.x / u_charFrac.x, lp.y / u_charFrac.y); cAlpha = sampleChar(u_charAtlas, vec2((cIdx + alp.x) / u_charCount, alp.y), u_charCount, u_charSoft); } float intensity = cAlpha * (0.3 + eBri * 0.7) * u_charOpacity * flickerVal * motionMult; if (u_outputLayer == 1.0) { float alpha = clamp(intensity, 0.0, 1.0); outColor = alpha > 0.0 ? vec4(applyPP(charCol, suv), alpha) : vec4(0.0); return; } vec3 result = mix(monoBg, charCol, clamp(intensity, 0.0, 1.0)); outColor = vec4(applyPP(result, suv), 1.0); return; } vec3 orig; if (chromAmt > 0.001) { orig = vec3( texture2D(u_image, sampUV + vec2(chromAmt, 0.0)).r, texture2D(u_image, sampUV).g, texture2D(u_image, sampUV - vec2(chromAmt, 0.0)).b ); } else { orig = texture2D(u_image, sampUV).rgb; } vec3 blurred = blurSample(sampUV, u_blur); vec3 bg = mix(orig, blurred, clamp(u_blur / 10.0, 0.0, 1.0)) * u_bgDarken; float grain = (hash(gl_FragCoord.xy + fract(u_time * 100.0)) - 0.5) * u_noise; bg = clamp(bg + grain, 0.0, 1.0); if (u_outputLayer == 2.0) { outColor = vec4(applyPP(bg, suv), 1.0); return; } bool showChar = hash(cell) < u_density; float effectiveThreshold = u_threshold; if (u_revealProgress >= 0.0) { vec2 revDir = vec2(cos(u_revealAngle), -sin(u_revealAngle)); float proj = dot(cellUV - 0.5, revDir) * 0.5 + 0.5; if (u_revealProgress < proj) { outColor = u_outputLayer == 1.0 ? vec4(0.0) : vec4(applyPP(bg, suv), 1.0); return; } float behind = u_revealProgress - proj; effectiveThreshold = mix(1.0, u_threshold, smoothstep(0.0, 0.35, behind)); } float fade = smoothstep(effectiveThreshold, effectiveThreshold + u_fadeRange, eBri); if (fade < 0.01 || !showChar) { outColor = u_outputLayer == 1.0 ? vec4(0.0) : vec4(applyPP(bg, suv), 1.0); return; } float cVal = pow(clamp(eBri + waveOff * 0.2, 0.0, 1.0), u_charGamma); vec2 lp = fract(gl_FragCoord.xy / u_cellSize); lp.y = 1.0 - lp.y; vec2 regionCenter = u_regionRect.xy; float regionRadius = u_regionRect.z; float regionDist = length(cellUV - regionCenter); bool inRegion = u_regionActive > 0.5 && regionDist <= regionRadius; float cAlpha = 0.0; if (lp.x < u_charFrac.x && lp.y < u_charFrac.y) { vec2 atlasLp = vec2(lp.x / u_charFrac.x, lp.y / u_charFrac.y); if (inRegion && u_regionCharCount > 0.5) { float rIdx = floor(cVal * (u_regionCharCount - 1.0) + 0.5); vec2 ruv = vec2((rIdx + atlasLp.x) / u_regionCharCount, atlasLp.y); cAlpha = sampleChar(u_charAtlas2, ruv, u_regionCharCount, u_charSoft); cAlpha = clamp(cAlpha + u_regionBold * 0.4 - 0.1, 0.0, 1.0); } else { float cDither = (hash(cell + 31.7) - 0.5) * u_charDither; float cIdx = floor(clamp(cVal + cDither, 0.0, 1.0) * (u_charCount - 1.0) + 0.5); vec2 cuv = vec2((cIdx + atlasLp.x) / u_charCount, atlasLp.y); cAlpha = sampleChar(u_charAtlas, cuv, u_charCount, u_charSoft); } } vec3 cc = mix(vec3(1.0), cellColor / max(dot(cellColor, vec3(.299,.587,.114)), 0.01) * 0.7, u_colorGrad * 0.5); cc = clamp(cc, 0.0, 1.0); float hs = wave * u_colorGrad * 0.15; float cosH = cos(hs * 3.14159), sinH = sin(hs * 3.14159); vec3 sh = vec3( cc.r*(.667+cosH*.333)+cc.g*(.333-cosH*.333-sinH*.577)+cc.b*(.333-cosH*.333+sinH*.577), cc.r*(.333-cosH*.333+sinH*.577)+cc.g*(.667+cosH*.333)+cc.b*(.333-cosH*.333-sinH*.577), cc.r*(.333-cosH*.333-sinH*.577)+cc.g*(.333-cosH*.333+sinH*.577)+cc.b*(.667+cosH*.333) ); vec3 fcc = clamp(sh, 0.0, 1.0); if (u_gradientOn > 0.5) { fcc = mix(fcc, gradColor, u_gradientIntensity); } float regionMult = inRegion ? u_regionBright : 1.0; float fA = clamp(cAlpha * fade * u_charOpacity * flickerVal * regionMult * motionMult, 0.0, 1.0); if (u_outputLayer == 1.0) { outColor = fA > 0.0 ? vec4(applyPP(fcc * 0.8, suv), fA) : vec4(0.0); return; } vec3 result = min(bg + fcc * fA * 0.8, vec3(1.0)); outColor = vec4(applyPP(result, suv), 1.0); } // Moving areas show the untouched frame: no characters, darkening, blur or post-processing void main() { effect(); if (u_motionOn > 0.5 && u_motionView < 0.5 && u_motionOriginal > 0.001) { float m = smoothstep(0.15, 0.5, texture2D(u_motionMask, v_uv).r) * u_motionOriginal; if (u_outputLayer == 1.0) outColor.a *= 1.0 - m; else outColor = vec4(mix(outColor.rgb, texture2D(u_image, v_uv).rgb, m), 1.0); } gl_FragColor = outColor; }