add shader script and keybinds
This commit is contained in:
parent
4c31a04197
commit
ea8f17368d
|
|
@ -0,0 +1,16 @@
|
|||
#version 300 es
|
||||
// Pure Red Channel Shader - OPTIMIZED
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// Using Rec. 709 for consistency
|
||||
const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
|
||||
|
||||
void main() {
|
||||
vec4 pixColor = texture(tex, v_texcoord);
|
||||
float gray = dot(pixColor.rgb, LUMA);
|
||||
fragColor = vec4(gray, 0.0, 0.0, pixColor.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
#version 300 es
|
||||
// Pure Green Channel Shader - FIXED
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
|
||||
|
||||
void main() {
|
||||
vec4 pixColor = texture(tex, v_texcoord);
|
||||
float gray = dot(pixColor.rgb, LUMA);
|
||||
// FIXED: Now correctly outputs to GREEN channel
|
||||
fragColor = vec4(0.0, gray, 0.0, pixColor.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
#version 300 es
|
||||
// Pure Blue Channel Shader - OPTIMIZED
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
|
||||
|
||||
void main() {
|
||||
vec4 pixColor = texture(tex, v_texcoord);
|
||||
float gray = dot(pixColor.rgb, LUMA);
|
||||
fragColor = vec4(0.0, 0.0, gray, pixColor.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#version 300 es
|
||||
// Retro CRT Shader - FULLY OPTIMIZED
|
||||
// Fixes: Resolution-aware scanlines, proper vignette, edge clamping,
|
||||
// correct aberration direction, anti-aliased scanlines
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float CURVATURE = 3.5;
|
||||
const float SCANLINE_STRENGTH = 0.25;
|
||||
// Approximate screen height in pixels (adjust to your resolution)
|
||||
const float SCREEN_HEIGHT = 1080.0;
|
||||
// Scanlines per screen height (lower = thicker lines)
|
||||
const float SCANLINE_COUNT = 540.0;
|
||||
const float ABERRATION = 0.002;
|
||||
const float VIGNETTE_RADIUS = 1.00;
|
||||
const float VIGNETTE_SOFTNESS = 0.45;
|
||||
// Phosphor glow simulation
|
||||
const float GLOW = 0.03;
|
||||
|
||||
vec2 curveUV(vec2 uv) {
|
||||
uv = uv * 2.0 - 1.0;
|
||||
vec2 offset = abs(uv.yx) / vec2(CURVATURE);
|
||||
uv = uv + uv * offset * offset;
|
||||
uv = uv * 0.5 + 0.5;
|
||||
return uv;
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 uv = curveUV(v_texcoord);
|
||||
|
||||
// Black bezel for out-of-bounds
|
||||
if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
|
||||
fragColor = vec4(0.0, 0.0, 0.0, 1.0);
|
||||
return;
|
||||
}
|
||||
|
||||
// FIXED: Clamp aberration samples to prevent edge artifacts
|
||||
vec2 centerDist = uv - 0.5;
|
||||
vec2 aberrOffset = centerDist * ABERRATION;
|
||||
|
||||
// FIXED: Correct direction - red focuses short, blue focuses long
|
||||
float r = texture(tex, clamp(uv + aberrOffset, 0.0, 1.0)).r;
|
||||
float g = texture(tex, uv).g;
|
||||
float b = texture(tex, clamp(uv - aberrOffset, 0.0, 1.0)).b;
|
||||
vec3 color = vec3(r, g, b);
|
||||
|
||||
// FIXED: Anti-aliased scanlines that don't shimmer during scroll
|
||||
// Using smooth triangle wave instead of harsh sine
|
||||
float scanlinePhase = uv.y * SCANLINE_COUNT * 2.0;
|
||||
float scanline = abs(fract(scanlinePhase) - 0.5) * 2.0; // Triangle wave 0-1
|
||||
scanline = smoothstep(0.0, 1.0, scanline); // Smooth it
|
||||
float scanlineFactor = 1.0 - (SCANLINE_STRENGTH * (1.0 - scanline));
|
||||
color *= scanlineFactor;
|
||||
|
||||
// Subtle phosphor glow (brightens slightly between scanlines)
|
||||
color += GLOW * (1.0 - scanline);
|
||||
|
||||
// FIXED: Proper circular vignette with correct smoothstep bounds
|
||||
float dist = length(centerDist) * 2.0; // 0 at center, ~1.414 at corners
|
||||
float vignette = 1.0 - smoothstep(VIGNETTE_RADIUS, VIGNETTE_RADIUS + VIGNETTE_SOFTNESS, dist);
|
||||
color *= vignette;
|
||||
|
||||
// Subtle brightness boost to compensate for darkening effects
|
||||
color *= 1.1;
|
||||
|
||||
fragColor = vec4(clamp(color, 0.0, 1.0), 1.0);
|
||||
}
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
#version 300 es
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float edge_threshold = 0.15; // Sensitivity (0.05-0.5) - lower = more edges
|
||||
const float edge_softness = 0.08; // Anti-aliasing amount
|
||||
const float line_thickness = 1.0; // 1.0 = normal, 2.0 = thicker
|
||||
const float line_darkness = 0.05; // 0.0 = pure black, higher = lighter
|
||||
const float paper_brightness = 0.98; // Paper color
|
||||
const float paper_grain = 0.03; // Paper texture intensity
|
||||
const float noise_reduction = 0.5; // Reduces speckles in smooth areas
|
||||
// ---------------------
|
||||
|
||||
float luminance(vec3 color) {
|
||||
return dot(color, vec3(0.2126, 0.7152, 0.0722));
|
||||
}
|
||||
|
||||
float hash12(vec2 p) {
|
||||
vec3 p3 = fract(vec3(p.xyx) * 0.1031);
|
||||
p3 += dot(p3, p3.yzx + 33.33);
|
||||
return fract((p3.x + p3.y) * p3.z);
|
||||
}
|
||||
|
||||
// Sample luminance with bounds checking
|
||||
float sampleLum(vec2 uv) {
|
||||
vec2 safe_uv = clamp(uv, 0.0, 1.0);
|
||||
return luminance(texture(tex, safe_uv).rgb);
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 screen_res = vec2(textureSize(tex, 0));
|
||||
vec2 pixel_size = line_thickness / screen_res;
|
||||
vec2 pixel_coords = v_texcoord * screen_res;
|
||||
|
||||
// Sobel kernel sampling with proper edge clamping
|
||||
float tl = sampleLum(v_texcoord + vec2(-pixel_size.x, -pixel_size.y));
|
||||
float t = sampleLum(v_texcoord + vec2( 0.0, -pixel_size.y));
|
||||
float tr = sampleLum(v_texcoord + vec2( pixel_size.x, -pixel_size.y));
|
||||
float l = sampleLum(v_texcoord + vec2(-pixel_size.x, 0.0));
|
||||
float c = sampleLum(v_texcoord); // Center pixel
|
||||
float r = sampleLum(v_texcoord + vec2( pixel_size.x, 0.0));
|
||||
float bl = sampleLum(v_texcoord + vec2(-pixel_size.x, pixel_size.y));
|
||||
float b = sampleLum(v_texcoord + vec2( 0.0, pixel_size.y));
|
||||
float br = sampleLum(v_texcoord + vec2( pixel_size.x, pixel_size.y));
|
||||
|
||||
// Sobel operators
|
||||
float Gx = (tr + 2.0 * r + br) - (tl + 2.0 * l + bl);
|
||||
float Gy = (bl + 2.0 * b + br) - (tl + 2.0 * t + tr);
|
||||
float gradient = sqrt(Gx * Gx + Gy * Gy);
|
||||
|
||||
// Calculate local variance for noise reduction
|
||||
// (reduces speckles in smooth areas while preserving real edges)
|
||||
float mean = (tl + t + tr + l + c + r + bl + b + br) / 9.0;
|
||||
float variance = 0.0;
|
||||
variance += (tl - mean) * (tl - mean);
|
||||
variance += (t - mean) * (t - mean);
|
||||
variance += (tr - mean) * (tr - mean);
|
||||
variance += (l - mean) * (l - mean);
|
||||
variance += (c - mean) * (c - mean);
|
||||
variance += (r - mean) * (r - mean);
|
||||
variance += (bl - mean) * (bl - mean);
|
||||
variance += (b - mean) * (b - mean);
|
||||
variance += (br - mean) * (br - mean);
|
||||
variance = sqrt(variance / 9.0);
|
||||
|
||||
// Adaptive threshold: require stronger edges in noisy areas
|
||||
float adaptive_threshold = edge_threshold + variance * noise_reduction;
|
||||
|
||||
// Smooth edge detection (anti-aliased)
|
||||
float edge = smoothstep(
|
||||
adaptive_threshold - edge_softness,
|
||||
adaptive_threshold + edge_softness,
|
||||
gradient
|
||||
);
|
||||
|
||||
// Paper texture
|
||||
float paper = paper_brightness;
|
||||
paper -= hash12(pixel_coords * 0.4) * paper_grain;
|
||||
paper -= hash12(pixel_coords * 2.1) * paper_grain * 0.4;
|
||||
|
||||
// Final blend
|
||||
float final_value = mix(paper, line_darkness, edge);
|
||||
|
||||
fragColor = vec4(vec3(final_value), 1.0);
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#version 300 es
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
uniform float TIME;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float wobble_speed = 3.0; // Animation speed
|
||||
const float wobble_frequency = 15.0; // Wave density
|
||||
const float wobble_amplitude = 0.025; // Displacement amount
|
||||
const float edge_fade = 0.1; // Fade near edges (0.0 to disable)
|
||||
const bool organic_motion = true; // Multi-frequency for natural look
|
||||
const bool prevent_edge_artifacts = true;
|
||||
// ---------------------
|
||||
|
||||
void main() {
|
||||
// Use local time to prevent floating point precision issues with large TIME values
|
||||
float t = mod(TIME, 628.318); // Wrap at 2*PI*100
|
||||
|
||||
vec2 new_uv = v_texcoord;
|
||||
|
||||
// Calculate edge fade mask (reduces artifacts at screen borders)
|
||||
float edge_mask = 1.0;
|
||||
if (edge_fade > 0.0) {
|
||||
vec2 dist_to_edge = min(v_texcoord, 1.0 - v_texcoord);
|
||||
float min_dist = min(dist_to_edge.x, dist_to_edge.y);
|
||||
edge_mask = smoothstep(0.0, edge_fade, min_dist);
|
||||
}
|
||||
|
||||
float amplitude = wobble_amplitude * edge_mask;
|
||||
|
||||
float h_offset, v_offset;
|
||||
|
||||
if (organic_motion) {
|
||||
// Layer multiple frequencies for organic, natural motion
|
||||
// Different speeds prevent repetitive patterns
|
||||
|
||||
// Horizontal wobble (based on Y position)
|
||||
h_offset = 0.0;
|
||||
h_offset += sin(v_texcoord.y * wobble_frequency * 1.0 + t * wobble_speed * 1.00) * 0.50;
|
||||
h_offset += sin(v_texcoord.y * wobble_frequency * 2.1 + t * wobble_speed * 1.37) * 0.30;
|
||||
h_offset += sin(v_texcoord.y * wobble_frequency * 0.5 + t * wobble_speed * 0.71) * 0.20;
|
||||
|
||||
// Vertical wobble (based on X position)
|
||||
v_offset = 0.0;
|
||||
v_offset += cos(v_texcoord.x * wobble_frequency * 0.9 + t * wobble_speed * 1.13) * 0.50;
|
||||
v_offset += cos(v_texcoord.x * wobble_frequency * 1.7 + t * wobble_speed * 0.83) * 0.30;
|
||||
v_offset += cos(v_texcoord.x * wobble_frequency * 0.4 + t * wobble_speed * 1.41) * 0.20;
|
||||
|
||||
// Add subtle interaction between axes
|
||||
h_offset += sin(v_texcoord.x * wobble_frequency * 0.3 + t * wobble_speed * 0.5) * 0.1;
|
||||
v_offset += cos(v_texcoord.y * wobble_frequency * 0.3 + t * wobble_speed * 0.6) * 0.1;
|
||||
|
||||
} else {
|
||||
// Simple single-frequency wobble
|
||||
h_offset = sin(v_texcoord.y * wobble_frequency + t * wobble_speed);
|
||||
v_offset = cos(v_texcoord.x * wobble_frequency + t * wobble_speed);
|
||||
}
|
||||
|
||||
new_uv.x += h_offset * amplitude;
|
||||
new_uv.y += v_offset * amplitude;
|
||||
|
||||
// Prevent sampling outside texture bounds
|
||||
if (prevent_edge_artifacts) {
|
||||
// Clamp with small margin to prevent edge bleeding
|
||||
new_uv = clamp(new_uv, 0.002, 0.998);
|
||||
}
|
||||
|
||||
fragColor = texture(tex, new_uv);
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#version 300 es
|
||||
// Chromatic Aberration Shader for Hyprland - OPTIMIZED
|
||||
// Fixes: Edge clamping, aspect ratio correction, quadratic falloff
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float STRENGTH = 0.010;
|
||||
// Set to your monitor's aspect ratio (16/9, 21/9, etc.) or use 1.0 for uncorrected
|
||||
const float ASPECT_RATIO = 16.0 / 9.0;
|
||||
// Use quadratic falloff for more realistic lens distortion
|
||||
const bool QUADRATIC_FALLOFF = true;
|
||||
|
||||
void main() {
|
||||
// Aspect-corrected center distance
|
||||
vec2 distFromCenter = v_texcoord - 0.5;
|
||||
distFromCenter.x *= ASPECT_RATIO;
|
||||
|
||||
// Calculate offset magnitude
|
||||
float dist = length(distFromCenter);
|
||||
float falloff = QUADRATIC_FALLOFF ? dist * dist : dist;
|
||||
|
||||
// Normalize direction and apply strength
|
||||
vec2 dir = normalize(distFromCenter + 0.0001); // Prevent div by zero
|
||||
vec2 offset = dir * falloff * STRENGTH;
|
||||
offset.x /= ASPECT_RATIO; // Correct back for sampling
|
||||
|
||||
// Sample with clamped coordinates to prevent edge artifacts
|
||||
vec2 redCoord = clamp(v_texcoord - offset, 0.0, 1.0);
|
||||
vec2 blueCoord = clamp(v_texcoord + offset, 0.0, 1.0);
|
||||
|
||||
float r = texture(tex, redCoord).r;
|
||||
vec4 centerPixel = texture(tex, v_texcoord);
|
||||
float g = centerPixel.g;
|
||||
float b = texture(tex, blueCoord).b;
|
||||
|
||||
// Preserve alpha from center sample
|
||||
fragColor = vec4(r, g, b, centerPixel.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
#version 300 es
|
||||
precision highp float; // CRITICAL: Prevents many artifacts
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float dot_spacing = 4.0; // 3.0-6.0 recommended
|
||||
const int color_levels = 4; // Posterization levels
|
||||
const vec3 paper_color = vec3(0.95, 0.92, 0.85);
|
||||
const float paper_texture_strength = 0.04;
|
||||
const float dot_softness = 1.5; // Higher = softer dot edges (anti-aliasing)
|
||||
const float ink_darkness = 0.95; // How dark the ink appears (0.0-1.0)
|
||||
const bool use_dithering = true; // Reduces posterization banding
|
||||
// ---------------------
|
||||
|
||||
// Improved hash function - less pattern artifacts than sin-based
|
||||
float hash12(vec2 p) {
|
||||
vec3 p3 = fract(vec3(p.xyx) * 0.1031);
|
||||
p3 += dot(p3, p3.yzx + 33.33);
|
||||
return fract((p3.x + p3.y) * p3.z);
|
||||
}
|
||||
|
||||
// Smoother 2D noise for paper texture
|
||||
float valueNoise(vec2 p) {
|
||||
vec2 i = floor(p);
|
||||
vec2 f = fract(p);
|
||||
|
||||
// Smooth interpolation
|
||||
vec2 u = f * f * (3.0 - 2.0 * f);
|
||||
|
||||
float a = hash12(i);
|
||||
float b = hash12(i + vec2(1.0, 0.0));
|
||||
float c = hash12(i + vec2(0.0, 1.0));
|
||||
float d = hash12(i + vec2(1.0, 1.0));
|
||||
|
||||
return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
|
||||
}
|
||||
|
||||
float luminance(vec3 color) {
|
||||
return dot(color, vec3(0.2126, 0.7152, 0.0722));
|
||||
}
|
||||
|
||||
// Bayer 4x4 dithering matrix - reduces posterization banding
|
||||
float bayerDither(vec2 pos) {
|
||||
ivec2 p = ivec2(mod(pos, 4.0));
|
||||
int index = p.x + p.y * 4;
|
||||
|
||||
// Bayer matrix values
|
||||
float matrix[16] = float[16](
|
||||
0.0, 8.0, 2.0, 10.0,
|
||||
12.0, 4.0, 14.0, 6.0,
|
||||
3.0, 11.0, 1.0, 9.0,
|
||||
15.0, 7.0, 13.0, 5.0
|
||||
);
|
||||
|
||||
return (matrix[index] / 16.0) - 0.5;
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec2 screen_res = vec2(textureSize(tex, 0));
|
||||
vec2 pixel_coords = v_texcoord * screen_res;
|
||||
|
||||
// 1. Sample original with clamped coordinates (prevents edge artifacts)
|
||||
vec2 safe_uv = clamp(v_texcoord, 0.0, 1.0);
|
||||
vec3 original_color = texture(tex, safe_uv).rgb;
|
||||
|
||||
// 2. Posterize with optional dithering to reduce banding
|
||||
float levels = float(color_levels);
|
||||
vec3 posterized_color;
|
||||
|
||||
if (use_dithering) {
|
||||
// Add dither before quantization
|
||||
float dither = bayerDither(pixel_coords) / (levels * 2.0);
|
||||
posterized_color = floor((original_color + dither) * levels) / (levels - 1.0);
|
||||
} else {
|
||||
posterized_color = floor(original_color * levels) / (levels - 1.0);
|
||||
}
|
||||
posterized_color = clamp(posterized_color, 0.0, 1.0);
|
||||
|
||||
// 3. Create layered paper texture (more natural looking)
|
||||
float paper_noise = 0.0;
|
||||
paper_noise += valueNoise(pixel_coords * 0.5) * 0.6; // Large grain
|
||||
paper_noise += valueNoise(pixel_coords * 1.5) * 0.3; // Medium grain
|
||||
paper_noise += hash12(pixel_coords) * 0.1; // Fine grain
|
||||
paper_noise *= paper_texture_strength;
|
||||
|
||||
vec3 textured_paper = max(paper_color - paper_noise, 0.0); // Prevent negative
|
||||
|
||||
// 4. Create halftone grid
|
||||
vec2 cell_coords = pixel_coords / dot_spacing;
|
||||
vec2 grid_uv = fract(cell_coords);
|
||||
|
||||
// 5. Calculate halftone dot
|
||||
// Use sqrt for area-proportional dots (perceptually correct)
|
||||
float lum = luminance(posterized_color);
|
||||
float darkness = 1.0 - lum;
|
||||
float dot_radius = sqrt(darkness) * 0.5; // Area proportional to darkness
|
||||
|
||||
// Distance from cell center
|
||||
float dist = length(grid_uv - 0.5);
|
||||
|
||||
// Anti-aliased dot edge using screen-space derivatives
|
||||
// This adapts to any resolution automatically
|
||||
float pixel_width = fwidth(dist) * dot_softness;
|
||||
float dot_mask = smoothstep(dot_radius - pixel_width, dot_radius + pixel_width, dist);
|
||||
|
||||
// 6. Combine: ink color where dots are, paper elsewhere
|
||||
vec3 ink_color = posterized_color * ink_darkness;
|
||||
vec3 final_color = mix(ink_color, textured_paper, dot_mask);
|
||||
|
||||
fragColor = vec4(final_color, 1.0);
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#version 300 es
|
||||
// Pixelation Shader - OPTIMIZED
|
||||
// Fixes: Sample from pixel CENTER (not corner), aspect ratio support
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
// Pixels across the shorter dimension (height usually)
|
||||
const float PIXEL_COUNT = 350.0;
|
||||
// Set to your aspect ratio, or 1.0 for square pixels
|
||||
const float ASPECT_RATIO = 16.0 / 9.0;
|
||||
|
||||
void main() {
|
||||
// Calculate pixel dimensions accounting for aspect ratio
|
||||
vec2 pixelCount = vec2(PIXEL_COUNT * ASPECT_RATIO, PIXEL_COUNT);
|
||||
vec2 pixelSize = 1.0 / pixelCount;
|
||||
|
||||
// FIXED: Sample from pixel CENTER, not corner
|
||||
// This prevents the "swimming" artifact when content moves
|
||||
vec2 pixelCoord = floor(v_texcoord * pixelCount) + 0.5;
|
||||
vec2 sampleCoord = pixelCoord / pixelCount;
|
||||
|
||||
fragColor = texture(tex, sampleCoord);
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#version 300 es
|
||||
// Grayscale Shader for Hyprland - OPTIMIZED
|
||||
// Added: Optional gamma-correct conversion for accurate luminance
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// Rec. 709 Luma coefficients (sRGB/HDTV standard)
|
||||
const vec3 LUMA_709 = vec3(0.2126, 0.7152, 0.0722);
|
||||
|
||||
// Set to true for gamma-correct grayscale (more accurate but slightly slower)
|
||||
const bool GAMMA_CORRECT = false;
|
||||
|
||||
// sRGB gamma functions
|
||||
float toLinear(float c) {
|
||||
return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4);
|
||||
}
|
||||
float toSRGB(float c) {
|
||||
return c <= 0.0031308 ? c * 12.92 : 1.055 * pow(c, 1.0/2.4) - 0.055;
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec4 pixColor = texture(tex, v_texcoord);
|
||||
|
||||
float gray;
|
||||
if (GAMMA_CORRECT) {
|
||||
// Convert to linear space, compute luminance, convert back
|
||||
vec3 linear = vec3(toLinear(pixColor.r), toLinear(pixColor.g), toLinear(pixColor.b));
|
||||
float luminance = dot(linear, LUMA_709);
|
||||
gray = toSRGB(luminance);
|
||||
} else {
|
||||
// Fast path: direct computation in gamma space
|
||||
gray = dot(pixColor.rgb, LUMA_709);
|
||||
}
|
||||
|
||||
fragColor = vec4(vec3(gray), pixColor.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
#version 300 es
|
||||
// Invert Colors Shader - OPTIMIZED
|
||||
// Added: Optional luminance-preserving mode
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// Set true for "smart invert" that preserves relative brightness
|
||||
const bool PRESERVE_LUMINANCE = false;
|
||||
const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722);
|
||||
|
||||
void main() {
|
||||
vec4 color = texture(tex, v_texcoord);
|
||||
vec3 inverted = 1.0 - color.rgb;
|
||||
|
||||
if (PRESERVE_LUMINANCE) {
|
||||
// Adjust inverted colors to match original luminance
|
||||
float origLuma = dot(color.rgb, LUMA);
|
||||
float invLuma = dot(inverted, LUMA);
|
||||
if (invLuma > 0.001) {
|
||||
inverted *= origLuma / invLuma;
|
||||
inverted = clamp(inverted, 0.0, 1.0);
|
||||
}
|
||||
}
|
||||
|
||||
fragColor = vec4(inverted, color.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
#version 300 es
|
||||
// Posterization Shader - OPTIMIZED
|
||||
// Fixes: Proper rounding, optional dithering to reduce banding
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float COLOR_LEVELS = 4.0;
|
||||
// Enable dithering to reduce visible banding
|
||||
const bool DITHER = true;
|
||||
|
||||
// Simple dither pattern
|
||||
float dither(vec2 pos) {
|
||||
// 4x4 Bayer matrix approximation
|
||||
vec2 p = fract(pos * 0.5);
|
||||
float d = fract(dot(p, vec2(0.75, 0.5)));
|
||||
return (d - 0.5) / COLOR_LEVELS;
|
||||
}
|
||||
|
||||
void main() {
|
||||
vec4 color = texture(tex, v_texcoord);
|
||||
|
||||
vec3 posterized;
|
||||
if (DITHER) {
|
||||
// Add dither noise before quantization
|
||||
float ditherValue = dither(gl_FragCoord.xy);
|
||||
posterized = floor((color.rgb + ditherValue) * COLOR_LEVELS + 0.5) / COLOR_LEVELS;
|
||||
} else {
|
||||
// FIXED: Use round() behavior instead of floor() for better color accuracy
|
||||
posterized = floor(color.rgb * COLOR_LEVELS + 0.5) / COLOR_LEVELS;
|
||||
}
|
||||
|
||||
posterized = clamp(posterized, 0.0, 1.0);
|
||||
fragColor = vec4(posterized, color.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#version 300 es
|
||||
// Sepia Tone Shader - OPTIMIZED
|
||||
// Fixes: Clamping to prevent overflow on bright pixels
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// W3C standard Sepia Matrix (column-major for GLSL)
|
||||
const mat3 SEPIA_MATRIX = mat3(
|
||||
0.393, 0.769, 0.189, // Red output weights
|
||||
0.349, 0.686, 0.168, // Green output weights
|
||||
0.272, 0.534, 0.131 // Blue output weights
|
||||
);
|
||||
|
||||
// Sepia intensity (0.0 = no effect, 1.0 = full sepia)
|
||||
const float INTENSITY = 1.0;
|
||||
|
||||
void main() {
|
||||
vec4 color = texture(tex, v_texcoord);
|
||||
|
||||
vec3 sepia = color.rgb * SEPIA_MATRIX;
|
||||
|
||||
// FIXED: Clamp to prevent overflow artifacts on bright pixels
|
||||
sepia = clamp(sepia, 0.0, 1.0);
|
||||
|
||||
// Optional: blend with original for partial effect
|
||||
vec3 final = mix(color.rgb, sepia, INTENSITY);
|
||||
|
||||
fragColor = vec4(final, color.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#version 300 es
|
||||
// Vignette Shader - OPTIMIZED
|
||||
// Fixes: Aspect ratio correction for circular vignette, safe smoothstep bounds
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float RADIUS = 0.65;
|
||||
const float SOFTNESS = 0.45;
|
||||
const float STRENGTH = 0.5;
|
||||
// Set to your monitor's aspect ratio for circular vignette
|
||||
const float ASPECT_RATIO = 16.0 / 9.0;
|
||||
|
||||
void main() {
|
||||
vec4 color = texture(tex, v_texcoord);
|
||||
|
||||
// FIXED: Aspect-corrected distance for circular (not elliptical) vignette
|
||||
vec2 centered = v_texcoord - 0.5;
|
||||
centered.x *= ASPECT_RATIO;
|
||||
float dist = length(centered);
|
||||
// Normalize so corner distance is ~1.0 regardless of aspect ratio
|
||||
dist /= length(vec2(ASPECT_RATIO * 0.5, 0.5));
|
||||
|
||||
// FIXED: Ensure smoothstep has valid bounds (edge1 > edge0)
|
||||
float innerEdge = RADIUS;
|
||||
float outerEdge = RADIUS + SOFTNESS;
|
||||
float vignette = 1.0 - smoothstep(innerEdge, outerEdge, dist);
|
||||
|
||||
// Apply with strength control
|
||||
color.rgb = mix(color.rgb, color.rgb * vignette, STRENGTH);
|
||||
|
||||
fragColor = color;
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#version 300 es
|
||||
// Anaglyph 3D Shader - OPTIMIZED
|
||||
// Fixes: Edge clamping, alpha preservation, depth-aware separation
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
const float SEPARATION = 0.003;
|
||||
// Make separation stronger at edges (simulates depth from screen curvature)
|
||||
const bool DEPTH_AWARE = true;
|
||||
|
||||
void main() {
|
||||
vec2 offset = vec2(SEPARATION, 0.0);
|
||||
|
||||
// Optional: Increase separation toward screen edges for more depth
|
||||
if (DEPTH_AWARE) {
|
||||
float edgeFactor = abs(v_texcoord.x - 0.5) * 2.0; // 0 at center, 1 at edges
|
||||
offset.x *= 1.0 + edgeFactor * 0.5;
|
||||
}
|
||||
|
||||
// Clamp coordinates to prevent edge sampling artifacts
|
||||
vec2 leftCoord = clamp(v_texcoord - offset, 0.0, 1.0);
|
||||
vec2 rightCoord = clamp(v_texcoord + offset, 0.0, 1.0);
|
||||
|
||||
vec4 leftEye = texture(tex, leftCoord);
|
||||
vec4 rightEye = texture(tex, rightCoord);
|
||||
vec4 center = texture(tex, v_texcoord);
|
||||
|
||||
// Combine: Red from left, Cyan (GB) from right
|
||||
fragColor = vec4(leftEye.r, rightEye.g, rightEye.b, center.a);
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#version 300 es
|
||||
// Vignette Shader for Hyprland
|
||||
// Description: Darkens the edges of the screen to draw focus to the center.
|
||||
// Uses smoothstep for a high-quality, organic falloff.
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
// The radius where the darkening begins (0.0 is center, 0.8 is near corners)
|
||||
const float RADIUS = 0.85;
|
||||
// How soft the transition is (higher = smoother gradient)
|
||||
const float SOFTNESS = 0.85;
|
||||
// The strength of the darkness (0.0 = no vignette, 1.0 = pitch black corners)
|
||||
const float STRENGTH = 0.8;
|
||||
|
||||
void main() {
|
||||
// 1. Sample the original screen color
|
||||
vec4 color = texture(tex, v_texcoord);
|
||||
|
||||
// 2. Calculate distance from center (0.5, 0.5)
|
||||
float dist = distance(v_texcoord, vec2(0.5));
|
||||
|
||||
// 3. Calculate vignette factor using smoothstep for high-quality falloff
|
||||
// We invert the smoothstep range so 1.0 is center and 0.0 is edges
|
||||
float vignette = smoothstep(RADIUS, RADIUS - SOFTNESS, dist);
|
||||
|
||||
// 4. Apply the vignette strength
|
||||
// Mix between the original color and the darkened version
|
||||
// This allows us to control intensity without changing the geometry of the falloff
|
||||
color.rgb = mix(color.rgb, color.rgb * vignette, STRENGTH);
|
||||
|
||||
fragColor = color;
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#version 300 es
|
||||
// Saturation & Contrast Shader for Hyprland
|
||||
// Description: Allows fine-tuning of screen vibrancy and dynamic range.
|
||||
// Efficiently applies saturation followed by contrast.
|
||||
|
||||
precision highp float;
|
||||
|
||||
in vec2 v_texcoord;
|
||||
uniform sampler2D tex;
|
||||
out vec4 fragColor;
|
||||
|
||||
// --- CONFIGURATION ---
|
||||
// 0.0 = Grayscale, 1.0 = Normal, 1.5 = Vibrant, 2.0 = Deep Fried
|
||||
const float SATURATION = 3.0;
|
||||
|
||||
// 1.0 = Normal, 1.2 = High Contrast, 0.8 = Low Contrast (Faded)
|
||||
const float CONTRAST = 1.0;
|
||||
// ---------------------
|
||||
|
||||
// Rec. 709 Luma coefficients for accurate saturation calculations
|
||||
const vec3 luma = vec3(0.2126, 0.7152, 0.0722);
|
||||
|
||||
void main() {
|
||||
// 1. Sample texture
|
||||
vec4 color = texture(tex, v_texcoord);
|
||||
|
||||
// 2. Apply Saturation
|
||||
// Calculate the grayscale value (luminance)
|
||||
float gray = dot(color.rgb, luma);
|
||||
// Interpolate between grayscale and original color
|
||||
vec3 satColor = mix(vec3(gray), color.rgb, SATURATION);
|
||||
|
||||
// 3. Apply Contrast
|
||||
// We shift color values so 0.5 is the "pivot" point.
|
||||
// Values > 0.5 get pushed up, values < 0.5 get pushed down.
|
||||
vec3 finalColor = (satColor - 0.5) * CONTRAST + 0.5;
|
||||
|
||||
// 4. Output
|
||||
fragColor = vec4(finalColor, color.a);
|
||||
}
|
||||
|
|
@ -76,18 +76,24 @@ bind = $mainMod SHIFT, S, movetoworkspace, special:magic
|
|||
workspace = special:h, on-created-empty: $terminal
|
||||
bind = $mainMod SHIFT, Return, togglespecialworkspace, h
|
||||
|
||||
# Screen Rotate
|
||||
bindld = CTRL ALT, R, Rotate Screen Clockwise, exec, hypr_screen_rotate.sh -90
|
||||
bindld = CTRL ALT SHIFT, R, Rotate Screen Anti-Clockwise, exec, hypr_screen_rotate.sh +90
|
||||
|
||||
# Accessibility: Zoom
|
||||
cursor:zoom_disable_aa = true
|
||||
# Zoom In
|
||||
binded = SUPER SHIFT, equal, Zoom In, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {print $2 * 1.25}')\""
|
||||
binded = SUPER, equal, Zoom In, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {print $2 * 1.25}')\""
|
||||
# Zoom Out
|
||||
binded = SUPER SHIFT, minus, Zoom Out, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {val = $2 / 1.25; if (val < 1.0) val = 1.0; print val}')\""
|
||||
binded = SUPER, minus, Zoom Out, exec, sh -c "hyprctl keyword cursor:zoom_factor \"$(hyprctl getoption cursor:zoom_factor | awk 'NR==1 {val = $2 / 1.25; if (val < 1.0) val = 1.0; print val}')\""
|
||||
# Reset Zoom
|
||||
bindld = SUPER SHIFT, BACKSPACE, Reset Zoom, exec, hyprctl keyword cursor:zoom_factor 1.0
|
||||
bindld = SUPER, BACKSPACE, Reset Zoom, exec, hyprctl keyword cursor:zoom_factor 1.0
|
||||
|
||||
# Screen Rotate
|
||||
bindld = $mainMod CTRL, comma, Rotate Screen Anti-Clockwise, exec, hypr_screen_rotate.sh +90
|
||||
bindld = $mainMod CTRL, period, Rotate Screen Clockwise, exec, hypr_screen_rotate.sh -90
|
||||
|
||||
# --- Hyprshade (Visual Filters) ---
|
||||
bindd = $mainMod CTRL, S, Shader Menu, exec, hypr_shader_menu.sh
|
||||
bindld = $mainMod CTRL, X, Disable Shader, exec, hyprshade off
|
||||
bindld = $mainMod CTRL, V, Vibrant Shader, exec, hyprshade on vibrance
|
||||
|
||||
# Scroll through existing workspaces with mainMod + scroll
|
||||
bind = $mainMod, mouse_down, workspace, e+1
|
||||
|
|
|
|||
|
|
@ -107,6 +107,7 @@
|
|||
"format-alt": "{icon} ",
|
||||
"format-good": "{icon} {capacity:3}%",
|
||||
"format-full": "{icon} {capacity:3}%",
|
||||
"tooltip-format": "{timeTo}\nHealth: {health}%\nPower Draw: {power:.2f} W\nCycles: {cycles}\n\nLMB: Toggle Format\nRMB: Timeout Settings",
|
||||
"format-icons": [
|
||||
"",
|
||||
"",
|
||||
|
|
|
|||
|
|
@ -0,0 +1,31 @@
|
|||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
# Check deps
|
||||
command -v fuzzel >/dev/null || { echo "fuzzel not found"; exit 1; }
|
||||
command -v hyprshade >/dev/null || { echo "hyprshade not found"; exit 1; }
|
||||
|
||||
# Get shader list
|
||||
mapfile -t SHADERS < <(hyprshade ls)
|
||||
|
||||
# Add "off" at top
|
||||
SHADERS=("off" "${SHADERS[@]}")
|
||||
|
||||
# Show in fuzzel
|
||||
CHOICE=$(printf "%s\n" "${SHADERS[@]}" \
|
||||
| fuzzel --dmenu --prompt "Hyprshade > " \
|
||||
| sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
|
||||
|
||||
# User cancelled
|
||||
[[ -z "$CHOICE" ]] && exit 0
|
||||
|
||||
# Apply
|
||||
if [[ "$CHOICE" == "off" ]]; then
|
||||
hyprshade off
|
||||
else
|
||||
hyprshade on "$CHOICE"
|
||||
fi
|
||||
|
||||
# Optional notification
|
||||
command -v notify-send >/dev/null && notify-send "Hyprshade" "Applied: $CHOICE"
|
||||
|
||||
Loading…
Reference in New Issue