Add shaders

Shaders from https://github.com/hyprland-community/awesome-hyprland/issues/22
2026-03-11 17:44:35 -05:00 · 2023-12-10 16:30:29 -08:00
parent 70111455cc
commit 9978013d30
7 changed files with 749 additions and 0 deletions
--- a/bloom.frag
+++ b/bloom.frag
@@ -0,0 +1,45 @@
+// blooms entire screen (https://github.com/hyprland-community/awesome-hyprland/issues/22#issuecomment-1682012576) credit to https://github.com/mekb-turtle
+#version 330 core
+
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+
+uniform int bloomRadius = 10;
+uniform float bloomIntensity = 0.7f;
+uniform float bloomThreshold = 0.4f;
+
+void main() {
+	vec4 color = texture(tex, v_texcoord);
+
+	vec4 bloomThreshold4 = vec4(bloomThreshold);
+	bloomThreshold4.w = 0.0f;
+
+	vec2 invTextureSize = 1.0f / textureSize(tex, 0);
+	float invBloomRadius = bloomRadius == 0 ? 1.0f : 1.0f / float(bloomRadius);
+	float invBloomThreshold = 1.0f / (1.0f - bloomThreshold);
+
+	float samples = 0.0f;
+	vec4 colorSum = vec4(0.0f);
+	
+	for (int x = -bloomRadius; x <= bloomRadius; ++x) {
+		for (int y = -bloomRadius; y <= bloomRadius; ++y) {
+			vec2 offset = vec2(x, y) * invTextureSize;
+
+			vec2 coords = v_texcoord + offset;
+			vec4 color = texture(tex, coords);
+			color = max(color - bloomThreshold, vec4(0.0f));
+
+			float strength = 1 - (length(offset) * invBloomRadius);
+			samples += strength;
+
+			strength *= max(max(color.x, color.y), color.z) * invBloomThreshold;
+
+			strength *= bloomIntensity;
+			colorSum += color * strength;
+		}
+	}
+
+	colorSum /= samples;
+	gl_FragColor = min(color + colorSum, 1.0f);
+}
--- a/bluelight.frag
+++ b/bluelight.frag
@@ -0,0 +1,47 @@
+// bluelight filter for hyprland (https://github.com/hyprwm/Hyprland/issues/1140#issuecomment-1335128437) credit to https://github.com/MahouShoujoMivutilde
+
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+
+const float temperature = 2600.0;
+const float temperatureStrength = 1.0;
+
+#define WithQuickAndDirtyLuminancePreservation
+const float LuminancePreservationFactor = 1.0;
+
+// function from https://www.shadertoy.com/view/4sc3D7
+// valid from 1000 to 40000 K (and additionally 0 for pure full white)
+vec3 colorTemperatureToRGB(const in float temperature){
+    // values from: http://blenderartists.org/forum/showthread.php?270332-OSL-Goodness&p=2268693&viewfull=1#post2268693
+    mat3 m = (temperature <= 6500.0) ? mat3(vec3(0.0, -2902.1955373783176, -8257.7997278925690),
+                                            vec3(0.0, 1669.5803561666639, 2575.2827530017594),
+                                            vec3(1.0, 1.3302673723350029, 1.8993753891711275)) :
+                                       mat3(vec3(1745.0425298314172, 1216.6168361476490, -8257.7997278925690),
+                                            vec3(-2666.3474220535695, -2173.1012343082230, 2575.2827530017594),
+                                            vec3(0.55995389139931482, 0.70381203140554553, 1.8993753891711275));
+    return mix(
+        clamp(vec3(m[0] / (vec3(clamp(temperature, 1000.0, 40000.0)) + m[1]) + m[2]), vec3(0.0), vec3(1.0)),
+        vec3(1.0),
+        smoothstep(1000.0, 0.0, temperature)
+    );
+}
+
+void main() {
+    vec4 pixColor = texture2D(tex, v_texcoord);
+
+    // RGB
+    vec3 color = vec3(pixColor[0], pixColor[1], pixColor[2]);
+
+#ifdef WithQuickAndDirtyLuminancePreservation
+    color *= mix(1.0,
+                 dot(color, vec3(0.2126, 0.7152, 0.0722)) / max(dot(color, vec3(0.2126, 0.7152, 0.0722)), 1e-5),
+                 LuminancePreservationFactor);
+#endif
+
+    color = mix(color, color * colorTemperatureToRGB(temperature), temperatureStrength);
+
+    vec4 outCol = vec4(color, pixColor[3]);
+
+    gl_FragColor = outCol;
+}
--- a/blur.frag
+++ b/blur.frag
@@ -0,0 +1,36 @@
+// blurs whole screen (https://github.com/hyprland-community/awesome-hyprland/issues/22#issuecomment-1681505196) credit to https://github.com/mekb-turtle
+#version 330 core
+
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+
+uniform int blurRadius = 1;
+
+void main() {
+	if (blurRadius <= 0) {
+		gl_FragColor = texture(tex, v_texcoord);
+		return;
+	}
+
+	vec2 invTextureSize = 1.0f / textureSize(tex, 0);
+	float invBlurRadius = 1.0f / float(blurRadius);
+
+	float samples = 0.0f;
+	vec4 colorSum = vec4(0.0f);
+	
+	for (int x = -blurRadius; x <= blurRadius; ++x) {
+		for (int y = -blurRadius; y <= blurRadius; ++y) {
+			vec2 offset = vec2(x, y) * invTextureSize;
+
+			float strength = 1 - (length(offset) * invBlurRadius);
+			samples += strength;
+
+			vec2 coords = v_texcoord + offset;
+			colorSum += texture(tex, coords) * strength;
+		}
+	}
+	
+	colorSum /= samples;
+	gl_FragColor = colorSum;
+}
--- a/crt.frag
+++ b/crt.frag
@@ -0,0 +1,523 @@
+// crt shader for hyprland (https://github.com/hyprland-community/awesome-hyprland/issues/22#issuecomment-1665703581) based on https://github.com/sigma-957/hyprland-shaders/blob/main/crt.frag
+
+#version 100
+precision highp float;
+varying highp vec2 v_texcoord;
+varying highp vec3 v_pos;
+uniform highp sampler2D tex;
+uniform highp float time;
+
+#define BORDER_COLOR vec4(vec3(0.0, 0.0, 0.0), 1.0) // black border
+#define BORDER_RADIUS 1.0 // larger vignette radius
+#define BORDER_SIZE 0.01 // small border size
+#define CHROMATIC_ABERRATION_STRENGTH 0.0027
+#define DENOISE_INTENSITY 0.0001 //
+#define DISTORTION_AMOUNT 0.11 // moderate distortion amount
+#define HDR_BLOOM 0.75 // bloom intensity
+#define HDR_BRIGHTNESS 0.011 // brightness
+#define HDR_CONTRAST 0.011 // contrast
+#define HDR_SATURATION 1.0// saturation
+#define LENS_DISTORTION_AMOUNT 1.0
+#define NOISE_THRESHOLD 0.0001
+#define PHOSPHOR_BLUR_AMOUNT 0.77 // Amount of blur for phosphor glow
+#define PHOSPHOR_GLOW_AMOUNT 0.77 // Amount of phosphor glow
+#define SHARPNESS 0.25
+#define SUPERSAMPLING_SAMPLES 16.0
+#define VIGNETTE_RADIUS 0.8 // larger vignette radius
+#define PI 3.14159265359
+#define TWOPI 6.28318530718
+
+vec2 applyBarrelDistortion(vec2 coord, float amt) {
+    vec2 p = coord.xy / vec2(1.0);
+    vec2 v = p * 2.0 - vec2(1.0);
+    float r = dot(v, v);
+    float k = 1.0 + pow(r, 2.0) * pow(amt, 2.0);
+    vec2 result = v * k;
+    return vec2(0.5, 0.5) + 0.5 * result.xy;
+}
+
+vec4 applyColorCorrection(vec4 color) {
+    color.rgb *= vec3(1.0, 0.875, 1.0);
+    return vec4(color.rgb, 1.0);
+}
+
+vec4 applyBorder(vec2 tc, vec4 color, float borderSize, vec4 borderColor) {
+    float dist_x = min(tc.x, 1.0 - tc.x);
+    float dist_y = min(tc.y, 1.0 - tc.y);
+    float dist = min(dist_x, dist_y) * -1.0;
+    float border = smoothstep(borderSize, 0.0, dist);
+    border += smoothstep(borderSize, 0.0, dist);
+    return mix(color, borderColor, border);
+}
+
+vec4 applyFakeHDR(vec4 color, float brightness, float contrast, float saturation, float bloom) {
+    color.rgb = (color.rgb - vec3(0.5)) * exp2(brightness) + vec3(0.5);
+    vec3 crtfactor = vec3(1.05, 0.92, 1.0);
+    color.rgb = pow(color.rgb, crtfactor);
+    // // NTSC
+    // vec3 lumCoeff = vec3(0.2125, 0.7154, 0.0721);
+
+    // // BT.709
+    // vec3 lumCoeff = vec3(0.299, 0.587, 0.114);
+
+    // BT.2020
+    vec3 lumCoeff = vec3(0.2627, 0.6780, 0.0593);
+
+    // // Warm NTSC
+    // vec3 lumCoeff = vec3(0.2125, 0.7010, 0.0865);
+
+    float luminance = dot(color.rgb, lumCoeff);
+    luminance = pow(luminance, 2.2);
+    color.rgb = mix(vec3(luminance), color.rgb, saturation);
+    color.rgb = mix(color.rgb, vec3(1.0), pow(max(0.0, luminance - 1.0 + bloom), 4.0));
+    return color;
+}
+
+vec4 applyVignette(vec4 color) {
+    vec2 center = vec2(0.5, 0.5); // center of screen
+    float radius = VIGNETTE_RADIUS; // radius of vignette effect
+    float softness = 1.0; // softness of vignette effect
+    float intensity = 0.7; // intensity of vignette effect
+    vec2 offset = v_texcoord - center; // offset from center of screen
+    float distance = length(offset); // distance from center of screen
+    float alpha = smoothstep(radius, radius - radius * softness, distance) * intensity; // calculate alpha value for vignette effect
+    return mix(vec4(0.0, 0.0, 0.0, alpha), color, alpha); // mix black with color using calculated alpha value
+}
+
+vec4 applyPhosphorGlow(vec2 tc, vec4 color, sampler2D tex) {
+    // Calculate average color value of the texture
+    vec4 texelColor = color;
+    float averageColor = (texelColor.r + texelColor.g + texelColor.b) / 3.0;
+
+    // Determine brightness-dependent color factor
+    float factor = mix(
+        mix(0.09,
+            mix(0.005, 0.0075, (averageColor - 0.1) / 0.1),
+            step(0.01, averageColor)), 0.0005,
+        step(0.02, averageColor));
+    // Apply phosphor glow effect
+    vec4 sum = vec4(0.0);
+    vec4 pixels[9];
+    pixels[0] = texture2D(tex, tc - vec2(0.001, 0.001));
+    pixels[1] = texture2D(tex, tc - vec2(0.001, 0.0));
+    pixels[2] = texture2D(tex, tc - vec2(0.001, -0.001));
+    pixels[3] = texture2D(tex, tc - vec2(0.0, 0.001));
+    pixels[4] = texture2D(tex, tc);
+    pixels[5] = texture2D(tex, tc + vec2(0.001, 0.001));
+    pixels[6] = texture2D(tex, tc + vec2(0.001, 0.0));
+    pixels[7] = texture2D(tex, tc + vec2(0.001, -0.001));
+    pixels[8] = texture2D(tex, tc + vec2(0.0, 0.001));
+
+// Perform operations on input pixels in parallel
+    sum = pixels[0]
+        + pixels[1]
+        + pixels[2]
+        + pixels[3]
+        + pixels[4]
+        + pixels[5]
+        + pixels[6]
+        + pixels[7]
+        + pixels[8];
+    sum /= 9.0;
+    sum += texture2D(tex, tc - vec2(0.01, 0.01)) * 0.001;
+    sum += texture2D(tex, tc - vec2(0.0, 0.01)) * 0.001;
+    sum += texture2D(tex, tc - vec2(-0.01, 0.01)) * 0.001;
+    sum += texture2D(tex, tc - vec2(0.01, 0.0)) * 0.001;
+    sum += color * PHOSPHOR_BLUR_AMOUNT;
+    sum += texture2D(tex, tc - vec2(-0.01, 0.0)) * 0.001;
+    sum += texture2D(tex, tc - vec2(0.01, -0.01)) * 0.001;
+    sum += texture2D(tex, tc - vec2(0.0, -0.01)) * 0.001;
+    sum += texture2D(tex, tc - vec2(-0.01, -0.01)) * 0.001;
+    sum *= PHOSPHOR_GLOW_AMOUNT;
+
+    // Initialize sum_sum_factor to zero
+    vec4 sum_sum_factor = vec4(0.0);
+    // Compute sum_j for i = -1
+    vec4 sum_j = vec4(0.0);
+    sum_j += texture2D(tex, tc + vec2(-1, -1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(0, -1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(1, -1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(-1, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(0, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(1, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(-1, 1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(0, 1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(1, 1) * 0.01);
+    sum_sum_factor += sum_j * vec4(0.011);
+
+    // Compute sum_j for i = 0
+    sum_j = vec4(0.0);
+    sum_j += texture2D(tex, tc + vec2(-1, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(0, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(1, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(-1, 1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(0, 1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(1, 1) * 0.01);
+    sum_sum_factor += sum_j * vec4(0.011);
+
+    // Compute sum_j for i = 1
+    sum_j = vec4(0.0);
+    sum_j += texture2D(tex, tc + vec2(-1, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(0, 1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(1, 0) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(-1, 1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(0, 1) * 0.01);
+    sum_j += texture2D(tex, tc + vec2(1, 1) * 0.01);
+    sum_sum_factor += sum_j * vec4(0.011);
+    color += mix(sum_sum_factor * sum_sum_factor * vec4(factor), sum, 0.5);
+    return color;
+}
+
+vec4 applyAdaptiveSharpen(vec2 tc, vec4 color, sampler2D tex) {
+    vec4 color_tl = texture2D(tex, tc + vec2(-1.0, -1.0) * 0.5 / 2160.0);
+    vec4 color_tr = texture2D(tex, tc + vec2(1.0, -1.0) * 0.5 / 2160.0);
+    vec4 color_bl = texture2D(tex, tc + vec2(-1.0, 1.0) * 0.5 / 2160.0);
+    vec4 color_br = texture2D(tex, tc + vec2(1.0, 1.0) * 0.5 / 2160.0);
+    float sharpness = SHARPNESS;
+    vec3 color_no_alpha = color.rgb;
+    vec3 color_tl_no_alpha = color_tl.rgb;
+    vec3 color_tr_no_alpha = color_tr.rgb;
+    vec3 color_bl_no_alpha = color_bl.rgb;
+    vec3 color_br_no_alpha = color_br.rgb;
+    float delta = (dot(color_no_alpha, vec3(0.333333)) + dot(color_tl_no_alpha, vec3(0.333333)) + dot(color_tr_no_alpha, vec3(0.333333)) + dot(color_bl_no_alpha, vec3(0.333333)) + dot(color_br_no_alpha, vec3(0.333333))) * 0.2 - dot(color_no_alpha, vec3(0.333333));
+    vec3 sharp_color_no_alpha = color_no_alpha + min(vec3(0.0), vec3(delta * sharpness));
+    vec4 sharp_color = vec4(sharp_color_no_alpha, color.a);
+    return sharp_color;
+}
+
+
+#define SCANLINE_TRANSPARENCY 1.35
+#define SAMPLING_RADIUS 0.0001
+#define SCANLINE_FREQUENCY 20.0
+#define SCANLINE_THICKNESS 1.0
+#define SCANLINE_SPEED 5.5
+
+vec4 applyScanlines(vec2 tc, vec4 color) {
+    float scanline = sin(tc.y * SCANLINE_FREQUENCY + time * SCANLINE_SPEED) * 0.5 + 0.5;
+    scanline = smoothstep(0.5 - SCANLINE_THICKNESS * 0.5, 0.5 + SCANLINE_THICKNESS * 0.5, scanline);
+
+    // Adjust visibility using smoothstep
+    float alpha = mix(1.0, SCANLINE_TRANSPARENCY, scanline);
+
+    return vec4(color.rgb * alpha, color.a);
+}
+
+vec4 applyChromaticAberration(vec2 uv, vec4 color) {
+    vec2 center = vec2(0.5, 0.5); // center of the screen
+    vec2 offset = (uv - center) * CHROMATIC_ABERRATION_STRENGTH; // calculate the offset from the center
+
+    // apply lens distortion
+    float rSquared = dot(offset, offset);
+    float distortion = 1.0 + LENS_DISTORTION_AMOUNT * rSquared;
+    vec2 distortedOffset = offset * distortion;
+
+    // apply chromatic aberration
+    vec2 redOffset = vec2(distortedOffset.x * 1.00, distortedOffset.y * 1.00);
+    vec2 blueOffset = vec2(distortedOffset.x * 1.00, distortedOffset.y * 1.00);
+
+    vec4 redColor = texture2D(tex, uv + redOffset);
+    vec4 blueColor = texture2D(tex, uv + blueOffset);
+
+    vec4 result = vec4(redColor.r, color.g, blueColor.b, color.a);
+
+    return result;
+}
+
+vec4 reduceGlare(vec4 color) {
+    // Calculate the intensity of the color by taking the average of the RGB components
+    float intensity = (color.r + color.g + color.b) / 3.0;
+    // Set the maximum intensity that can be considered for glare
+    float maxIntensity = 0.98;
+    // Use smoothstep to create a smooth transition from no glare to full glare
+    // based on the intensity of the color and the maximum intensity
+    float glareIntensity = smoothstep(maxIntensity - 0.02, maxIntensity, intensity);
+    // Set the amount of glare to apply to the color
+    float glareAmount = 0.02;
+    // Mix the original color with the reduced color that has glare applied to it
+    vec3 reducedColor = mix(color.rgb, vec3(glareIntensity), glareAmount);
+    // Return the reduced color with the original alpha value
+    return vec4(reducedColor, color.a);
+}
+
+// Apply a fake HDR effect to the input color.
+// Parameters:
+// - inputColor: the color to apply the effect to.
+// - brightness: the brightness of the image. Should be a value between 0 and 1.
+// - contrast: the contrast of the image. Should be a value between 0 and 1.
+// - saturation: the saturation of the image. Should be a value between 0 and 2.
+// - bloom: the intensity of the bloom effect. Should be a value between 0 and 1.
+vec4 applyFakeHDREffect(vec4 inputColor, float brightness, float contrast, float saturation, float bloom) {
+    const float minBrightness = 0.0;
+    const float maxBrightness = 1.0;
+    const float minContrast = 0.0;
+    const float maxContrast = 1.0;
+    const float minSaturation = 0.0;
+    const float maxSaturation = 2.0;
+    const float minBloom = 0.0;
+    const float maxBloom = 1.0;
+
+    // Check input parameters for validity
+    if (brightness < minBrightness || brightness > maxBrightness) {
+        return vec4(0.0, 0.0, 0.0, 1.0); // Return black with alpha of 1.0 to indicate error
+    }
+    if (contrast < minContrast || contrast > maxContrast) {
+        return vec4(0.0, 0.0, 0.0, 1.0);
+    }
+    if (saturation < minSaturation || saturation > maxSaturation) {
+        return vec4(0.0, 0.0, 0.0, 1.0);
+    }
+    if (bloom < minBloom || bloom > maxBloom) {
+        return vec4(0.0, 0.0, 0.0, 1.0);
+    }
+
+    // Apply brightness and contrast
+    vec3 color = inputColor.rgb;
+    color = (color - vec3(0.5)) * exp2(brightness * 10.0) + vec3(0.5);
+    color = mix(vec3(0.5), color, pow(contrast * 4.0 + 1.0, 2.0));
+
+    // // NTSC
+    // vec3 lumCoeff = vec3(0.2125, 0.7154, 0.0721);
+
+    // // BT.709
+    // vec3 lumCoeff = vec3(0.299, 0.587, 0.114);
+
+    // // BT.2020
+    // vec3 lumCoeff = vec3(0.2627, 0.6780, 0.0593);
+
+    // Warm NTSC
+    vec3 lumCoeff = vec3(0.2125, 0.7010, 0.0865);
+
+    // Apply saturation
+    float luminance = dot(color, lumCoeff);
+    vec3 grey = vec3(luminance);
+    color = mix(grey, color, saturation);
+
+    // Apply bloom effect
+    float threshold = 1.0 - bloom;
+    vec3 bloomColor = max(color - threshold, vec3(0.0));
+    bloomColor = pow(bloomColor, vec3(2.0));
+    bloomColor = mix(vec3(0.0), bloomColor, pow(min(luminance, threshold), 4.0));
+    color += bloomColor;
+
+    return vec4(color, inputColor.a);
+}
+
+vec4 bilateralFilter(sampler2D tex, vec2 uv, vec4 color, float sampleRadius, float noiseThreshold, float intensity) {
+    vec4 filteredColor = vec4(0.0);
+    float totalWeight = 0.0;
+
+    // Top-left pixel
+    vec4 sample = texture2D(tex, uv + vec2(-1.0, -1.0));
+    float dist = length(vec2(-1.0, -1.0));
+    float colorDist = length(sample - color);
+    float weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+    // Top pixel
+    sample = texture2D(tex, uv + vec2(0.0, -1.0));
+    dist = length(vec2(0.0, -1.0));
+    colorDist = length(sample - color);
+    weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+    // Top-right pixel
+    sample = texture2D(tex, uv + vec2(1.0, -1.0));
+    dist = length(vec2(1.0, -1.0));
+    colorDist = length(sample - color);
+    weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+    // Left pixel
+    sample = texture2D(tex, uv + vec2(-1.0, 0.0));
+    dist = length(vec2(-1.0, 0.0));
+    colorDist = length(sample - color);
+    weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+    // Center pixel
+    sample = texture2D(tex, uv);
+    dist = 0.0;
+    colorDist = length(sample - color);
+    weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+    // Right pixel
+    sample = texture2D(tex, uv + vec2(1.0, 0.0));
+    dist = length(vec2(1.0, 0.0));
+    colorDist = length(sample - color);
+    weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+    // Bottom-left pixel
+    sample = texture2D(tex, uv + vec2(-1.0, 1.0));
+    dist = length(vec2(-1.0, 1.0));
+    colorDist = length(sample - color);
+    weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+// Bottom pixel
+    sample = texture2D(tex, uv + vec2(0.0, sampleRadius));
+    dist = length(vec2(0.0, sampleRadius));
+    colorDist = length(sample - color);
+    weight = exp(-0.5 * (dist * dist + colorDist * colorDist * intensity) / (sampleRadius * sampleRadius));
+    filteredColor += sample * weight;
+    totalWeight += weight;
+
+    filteredColor /= totalWeight;
+    return mix(color, filteredColor, step(noiseThreshold, length(filteredColor - color)));
+}
+
+vec4 supersample(sampler2D tex, vec2 uv, float sampleRadius, float noiseThreshold, float intensity) {
+    float radiusSq = sampleRadius * sampleRadius;
+    vec2 poissonDisk;
+    vec4 color = vec4(0.0);
+
+    float r1_0 = sqrt(0.0 / 16.0);
+    float r2_0 = fract(1.0 / 3.0);
+    float theta_0 = TWOPI * r2_0;
+    poissonDisk = vec2(r1_0 * cos(theta_0), r1_0 * sin(theta_0));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_1 = sqrt(1.0 / 16.0);
+    float r2_1 = fract(2.0 / 3.0);
+    float theta_1 = TWOPI * r2_1;
+    poissonDisk = vec2(r1_1 * cos(theta_1), r1_1 * sin(theta_1));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_2 = sqrt(2.0 / 16.0);
+    float r2_2 = fract(3.0 / 3.0);
+    float theta_2 = TWOPI * r2_2;
+    poissonDisk = vec2(r1_2 * cos(theta_2), r1_2 * sin(theta_2));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_3 = sqrt(3.0 / 16.0);
+    float r2_3 = fract(4.0 / 3.0);
+    float theta_3 = TWOPI * r2_3;
+    poissonDisk = vec2(r1_3 * cos(theta_3), r1_3 * sin(theta_3));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_4 = sqrt(4.0 / 16.0);
+    float r2_4 = fract(5.0 / 3.0);
+    float theta_4 = TWOPI * r2_4;
+    poissonDisk = vec2(r1_4 * cos(theta_4), r1_4 * sin(theta_4));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_5 = sqrt(5.0 / 16.0);
+    float r2_5 = fract(6.0 / 3.0);
+    float theta_5 = TWOPI * r2_5;
+    poissonDisk = vec2(r1_5 * cos(theta_5), r1_5 * sin(theta_5));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_6 = sqrt(6.0 / 16.0);
+    float r2_6 = fract(7.0 / 3.0);
+    float theta_6 = TWOPI * r2_6;
+    poissonDisk = vec2(r1_6 * cos(theta_6), r1_6 * sin(theta_6));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_7 = sqrt(7.0 / 16.0);
+    float r2_7 = fract(8.0 / 3.0);
+    float theta_7 = TWOPI * r2_7;
+    poissonDisk = vec2(r1_7 * cos(theta_7), r1_7 * sin(theta_7));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_8 = sqrt(8.0 / 16.0);
+    float r2_8 = fract(9.0 / 3.0);
+    float theta_8 = TWOPI * r2_8;
+    poissonDisk = vec2(r1_8 * cos(theta_8), r1_8 * sin(theta_8));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_9 = sqrt(9.0 / 16.0);
+    float r2_9 = fract(10.0 / 3.0);
+    float theta_9 = TWOPI * r2_9;
+    poissonDisk = vec2(r1_9 * cos(theta_9), r1_9 * sin(theta_9));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_10 = sqrt(10.0 / 16.0);
+    float r2_10 = fract(11.0 / 3.0);
+    float theta_10 = TWOPI * r2_10;
+    poissonDisk = vec2(r1_10 * cos(theta_10), r1_10 * sin(theta_10));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_11 = sqrt(11.0 / 16.0);
+    float r2_11 = fract(12.0 / 3.0);
+    float theta_11 = TWOPI * r2_11;
+    poissonDisk = vec2(r1_11 * cos(theta_11), r1_11 * sin(theta_11));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_12 = sqrt(12.0 / 16.0);
+    float r2_12 = fract(13.0 / 3.0);
+    float theta_12 = TWOPI * r2_12;
+    poissonDisk = vec2(r1_12 * cos(theta_12), r1_12 * sin(theta_12));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_13 = sqrt(13.0 / 16.0);
+    float r2_13 = fract(14.0 / 3.0);
+    float theta_13 = TWOPI * r2_13;
+    poissonDisk = vec2(r1_13 * cos(theta_13), r1_13 * sin(theta_13));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_14 = sqrt(14.0 / 16.0);
+    float r2_14 = fract(15.0 / 3.0);
+    float theta_14 = TWOPI * r2_14;
+    poissonDisk = vec2(r1_14 * cos(theta_14), r1_14 * sin(theta_14));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    float r1_15 = sqrt(15.0 / 16.0);
+    float r2_15 = fract(16.0 / 3.0);
+    float theta_15 = TWOPI * r2_15;
+    poissonDisk = vec2(r1_15 * cos(theta_15), r1_15 * sin(theta_15));
+    color += texture2D(tex, uv + poissonDisk * sampleRadius);
+
+    return bilateralFilter(tex, uv, color, sampleRadius, noiseThreshold, intensity);
+}
+void main() {
+    vec2 tc_no_dist = v_texcoord;
+
+    vec2 tc = applyBarrelDistortion(tc_no_dist, DISTORTION_AMOUNT);
+    // vec2 tc = tc_no_dist;
+
+    // [-1, 1]
+    vec2 tc_no_dist_symmetric = tc_no_dist * 2.0 - 1.0;
+
+    // [0,1]
+    vec2 tc_no_dist_normalized = (tc_no_dist_symmetric + 1.0) / 2.0;
+
+    // vec4 color = texture2D(tex, tc);
+    vec4 color = supersample(tex, tc, SAMPLING_RADIUS, NOISE_THRESHOLD, DENOISE_INTENSITY);
+
+    color = applyAdaptiveSharpen(tc, color, tex);
+
+    color = applyPhosphorGlow(tc, color, tex);
+
+    color = reduceGlare(color);
+
+    color = mix(applyFakeHDREffect(color, HDR_BRIGHTNESS, HDR_CONTRAST, HDR_SATURATION, HDR_BLOOM), color, 0.5);
+
+    color = applyColorCorrection(color);
+
+    color /= SUPERSAMPLING_SAMPLES;
+
+    color = mix(applyChromaticAberration(tc, color), color, 0.0);
+
+    color = mix(color, applyVignette(color), 0.1);
+
+    color = applyBorder(tc_no_dist_normalized, color, 1.0 - BORDER_SIZE * BORDER_RADIUS, BORDER_COLOR);
+
+    color = mix(applyBorder(tc, color, BORDER_SIZE, BORDER_COLOR), color, 0.05);
+
+    // color = vec4(color.rgb * 1.15, color.a);
+
+
+    color = applyScanlines(tc, color);
+
+    gl_FragColor = color;
+    gl_FragColor.a = 1.0;
+}
+
--- a/drugs.frag
+++ b/drugs.frag
@@ -0,0 +1,43 @@
+// applies waving effect and purple/pink tint (https://discord.com/channels/635612648934735892/1088009063306100756/1088079193042071603) r/unixporn discord
+
+precision highp float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+uniform float time;
+
+void warpco(inout vec2 tc) {
+    tc -= 0.5;
+    tc *= length(tc) * 2.0;
+    tc += 0.5;
+}
+
+float rand1d(float seed) {
+   return sin(seed*1454.0); 
+}
+
+float rand2d(vec2 co)
+{
+  return fract(sin(dot(co.xy, vec2(12.9898,78.233))) * 43758.5453);
+}
+
+vec3 rgb(in vec2 tc, float freq, float amp, inout vec4 centre) {
+    vec2 off = vec2(1.0/800.0, 0.0) * sin(tc.t * freq + time) * amp;
+    vec2 off2 = vec2(1.0/800.0, 0.0) * sin(tc.t * freq - time * 1.5) * amp;
+    centre = texture2D(tex, tc);
+    return vec3(texture2D(tex, tc-off).r, centre.g, texture2D(tex, tc+off2).b);
+}
+
+void main() {
+    // vec2 px = 1.0 / textureSize(tex, 0).st;
+    vec2 tc = v_texcoord;
+    warpco(tc);
+    tc = mix(v_texcoord, tc, sin(time * 2.0)*0.07);
+    tc.x += rand2d(floor(tc * 20.0 + floor(time * 2.5))) * 0.01;
+    tc.x += rand1d(floor(tc.x * 40.0)) * 0.005 * rand1d(time * 0.001);
+    tc.y += sin(tc.x + time) * 0.02;
+    vec4 centre;
+    vec3 bent = rgb(tc, 100.0, 5.0, centre);
+    vec3 col = mix(centre.rgb, bent, sin(time));
+    gl_FragColor = vec4(col, centre.a);
+    // gl_FragColor = vec4(texture2D(tex, v_texcoord));
+}
--- a/monochrome.frag
+++ b/monochrome.frag
@@ -0,0 +1,16 @@
+// monochrome filter (https://github.com/hyprland-community/awesome-hyprland/issues/22#issuecomment-1717441686) credit to https://github.com/ed-henrique
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+
+void main() {
+   vec4 pixColor = texture2D(tex, v_texcoord);
+
+   float lum = dot(pixColor.rgb, vec3(0.299, 0.587, 0.114));       // BT.601
+   // float lum = dot(pixColor.rgb, vec3(0.2126, 0.7152, 0.0722)); // BT.709
+   // float lum = dot(pixColor.rgb, vec3(0.2627, 0.6780, 0.0593)); // BT.2100
+   // Check https://en.wikipedia.org/wiki/Grayscale#Luma_coding_in_video_systems for more information about which one to choose
+
+   vec4 outCol = vec4(vec3(lum), pixColor.a);
+   gl_FragColor = outCol;
+}
--- a/vibrance.frag
+++ b/vibrance.frag
@@ -0,0 +1,39 @@
+// vibrance for hyprland (https://github.com/hyprwm/Hyprland/issues/1140#issuecomment-1614863627) credit to https://github.com/MahouShoujoMivutilde
+
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+
+// see https://github.com/CeeJayDK/SweetFX/blob/a792aee788c6203385a858ebdea82a77f81c67f0/Shaders/Vibrance.fx#L20-L30
+const vec3 VIB_RGB_BALANCE = vec3(1.0, 1.0, 1.0);
+const float VIB_VIBRANCE = 0.15;
+
+
+const vec3 VIB_coeffVibrance = VIB_RGB_BALANCE * -VIB_VIBRANCE;
+
+void main() {
+
+    vec4 pixColor = texture2D(tex, v_texcoord);
+
+    // RGB
+    vec3 color = vec3(pixColor[0], pixColor[1], pixColor[2]);
+
+
+    // vec3 VIB_coefLuma = vec3(0.333333, 0.333334, 0.333333); // was for `if VIB_LUMA == 1`
+    vec3 VIB_coefLuma = vec3(0.212656, 0.715158, 0.072186); // try both and see which one looks nicer.
+
+    float luma = dot(VIB_coefLuma, color);
+
+    float max_color = max(color[0], max(color[1], color[2]));
+    float min_color = min(color[0], min(color[1], color[2]));
+
+    float color_saturation = max_color - min_color;
+
+    vec3 p_col = vec3(vec3(vec3(vec3(sign(VIB_coeffVibrance) * color_saturation) - 1.0) * VIB_coeffVibrance) + 1.0);
+
+    pixColor[0] = mix(luma, color[0], p_col[0]);
+    pixColor[1] = mix(luma, color[1], p_col[1]);
+    pixColor[2] = mix(luma, color[2], p_col[2]);
+
+    gl_FragColor = pixColor;
+}