elars/copnix
1
0 Fork 0
mirror of https://github.com/elwrcl/copnix.git synced 2026-10-31 06:18:03 +03:00
Code Issues Packages Projects Releases Wiki Activity

removed ghostty shaders

Browse Source
This commit is contained in:
elwrcl committed 2026-09-17 19:31:18 +03:00
1 parent 5a4ee25fbd
commit ebaebf4d3d
3 files changed
-358
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

modules/home/ghostty/cursor-smear.glsl
-173
View File
@@ -1,173 +0,0 @@
///cursor-smear.glsl
const float DURATION = 0.45;
const float TRAIL_OPACITY = 0.65;
void processEdge(vec2 p, vec2 a, vec2 b, inout float minDist, inout float inside) {
vec2 edge = b - a;
vec2 pa = p - a;
float lenSq = dot(edge, edge);
float invLenSq = 1.0 / lenSq;
float t = clamp(dot(pa, edge) * invLenSq, 0.0, 1.0);
vec2 diff = pa - edge * t;
minDist = min(minDist, dot(diff, diff));
float crossZ = edge.x * pa.y - edge.y * pa.x;
inside = min(inside, step(0.0, crossZ));
}
// signed distance field for hexagon (negative inside, positive outside)
float sdHexagon(in vec2 p, in vec2 v0, in vec2 v1, in vec2 v2, in vec2 v3, in vec2 v4, in vec2 v5) {
float minDist = 1e20;
float inside = 1.0;
processEdge(p, v0, v1, minDist, inside);
processEdge(p, v1, v2, minDist, inside);
processEdge(p, v2, v3, minDist, inside);
processEdge(p, v3, v4, minDist, inside);
processEdge(p, v4, v5, minDist, inside);
processEdge(p, v5, v0, minDist, inside);
float dist = sqrt(max(minDist, 0.0));
return mix(dist, -dist, inside);
}
// signed distance field for rectangle (negative inside, positive outside)
float sdRectangle(in vec2 p, in vec2 center, in vec2 halfSize) {
vec2 d = abs(p - center) - halfSize;
return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
}
// represents cursor as a quad with four corners
struct Quad {
vec2 topLeft;
vec2 topRight;
vec2 bottomLeft;
vec2 bottomRight;
};
// construct quad from top-left position and size
Quad getQuad(vec2 pos, vec2 size) {
Quad q;
q.topLeft = pos;
q.topRight = pos + vec2(size.x, 0.0);
q.bottomLeft = pos - vec2(0.0, size.y);
q.bottomRight = pos + vec2(size.x, -size.y);
return q;
}
// selecting 3 corners from quad based on movement direction
// sel.x: 0=left, 1=right | sel.y: 0=top, 1=bottom
void selectTrailCorners(Quad q, vec2 sel, out vec2 p1, out vec2 p2, out vec2 p3) {
p1 = mix(mix(q.topRight, q.topLeft, sel.x),
mix(q.bottomRight, q.bottomLeft, sel.x),
sel.y);
p2 = mix(mix(q.topLeft, q.bottomLeft, sel.x),
mix(q.topRight, q.bottomRight, sel.x),
sel.y);
p3 = mix(mix(q.bottomRight, q.topRight, sel.x),
mix(q.bottomLeft, q.topLeft, sel.x),
sel.y);
}
// select 4 corners from quad based on movement direction
void selectCorners(Quad q, vec2 sel, out vec2 p1, out vec2 p2, out vec2 p3, out vec2 p4) {
selectTrailCorners(q, sel, p1, p2, p3);
p4 = mix(mix(q.bottomLeft, q.bottomRight, sel.x),
mix(q.topLeft, q.topRight, sel.x),
sel.y);
}
// cubic ease-out function for smooth animation (expects clamped input)
float easeClamped(float x) {
float t = 1.0 - x;
return 1.0 - t * t * t;
}
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
vec2 uv = fragCoord / iResolution.xy;
vec4 background = texture(iChannel0, uv);
fragColor = background;
// an unfocused split still reports cursor changes, and its frames arrive far
// apart, so a trail there is both wrong and jumpy.
if (iFocus == 0) {
return;
}
// calculate animation progress with easing
float baseProgress = clamp((iTime - iTimeCursorChange) / DURATION, 0.0, 1.0);
// skip further work when animation is complete
if (baseProgress >= 1.0) {
return;
}
// precompute reused values
float invResY = 1.0 / iResolution.y;
float scale = 2.0 * invResY;
float aaWidth = scale;
vec2 normOffset = iResolution.xy * invResY;
// normalize cursor positions and sizes to screen-independent coordinates
vec2 currentPos = iCurrentCursor.xy * scale - normOffset;
vec2 previousPos = iPreviousCursor.xy * scale - normOffset;
vec2 currentSize = iCurrentCursor.zw * scale;
vec2 previousSize = iPreviousCursor.zw * scale;
// determine movement direction and construct cursor quads
vec2 deltaPos = currentPos - previousPos;
Quad currentCursor = getQuad(currentPos, currentSize);
Quad previousCursor = getQuad(previousPos, previousSize);
vec2 selector = step(vec2(0.0), deltaPos);
// select corners based on movement direction
vec2 currP1, currP2, currP3, currP4;
vec2 prevP1, prevP2, prevP3;
selectCorners(currentCursor, selector, currP1, currP2, currP3, currP4);
selectTrailCorners(previousCursor, selector, prevP1, prevP2, prevP3);
float easedProgress = easeClamped(baseProgress);
float stretchedProgress = min(baseProgress * 2.0, 1.0);
float easedProgressDouble = easeClamped(stretchedProgress);
// create trailing effect by moving diagonal point slower
vec2 trailP1 = mix(prevP1, currP1, easedProgress);
vec2 trailP2 = mix(prevP2, currP2, easedProgressDouble);
vec2 trailP3 = mix(prevP3, currP3, easedProgressDouble);
// compute hexagon SDF and convert to alpha with antialiasing
vec2 normCoord = fragCoord * scale - normOffset;
float sdfHex = sdHexagon(normCoord, trailP1, trailP2, currP2, currP4, currP3, trailP3);
float alpha = 1.0 - smoothstep(-aaWidth, aaWidth, sdfHex);
// computing current cursor SDF
vec2 halfCurrentSize = currentSize * 0.5;
vec2 currentCenter = currentPos + vec2(halfCurrentSize.x, -halfCurrentSize.y);
float sdfCurrentCursor = sdRectangle(normCoord, currentCenter, halfCurrentSize);
// calculating line length (distance between cursor centers)
vec2 previousCenter = previousPos + vec2(previousSize.x * 0.5, -previousSize.y * 0.5);
// max() because a cursor change that does not move it (a recolour, say)
// gives a zero-length line, and smoothstep with equal edges is undefined.
float lineLength = max(distance(currentCenter, previousCenter), 1e-4);
// cursor already carries the palette accent, so the trail needs no color
// of its own and never fights the theme.
vec3 trailColor = iCurrentCursorColor.rgb;
// fade along the length, squared so the tail
float distFromCursor = distance(normCoord, currentCenter);
float lengthFade = 1.0 - smoothstep(0.0, lineLength, distFromCursor);
float timeFade = 1.0 - baseProgress * baseProgress;
float strength = TRAIL_OPACITY * lengthFade * lengthFade * timeFade;
// blend trail color with background
vec3 originalColor = fragColor.rgb;
fragColor.rgb = mix(fragColor.rgb, trailColor, alpha * strength);
// remove trail where it overlaps with current cursor
fragColor.rgb = mix(fragColor.rgb, originalColor, step(sdfCurrentCursor, 0.0));
}
modules/home/ghostty/degauss.glsl
-109
View File
@@ -1,109 +0,0 @@
///degauss.glsl
const float BOOT_DELAY = 0.45;
const float DURATION = 1.0;
// how hard the coil hits.
const float WOBBLE_AMP = 0.055;
const float WAVE_FREQ = 9.0;
const float WAVE_SPEED = 3.2;
const float WAVE_GLIDE = 0.35;
const float WARBLE_HZ = 7.0;
const float WARBLE_DEPTH = 0.25;
const float CHROMA_AMP = 0.016;
const float FLASH_AMP = 0.55;
const float JITTER_AMP = 0.006;
const float SQUEEZE_AMP = 0.075;
const float BAND_SWEEPS = 2.0;
const bool JUMP_DEGAUSS = false;
const float CURSOR_JUMP = 0.60;
#define TAU 6.28318530718
float envelope(float t) {
if (t <= 0.0 || t >= DURATION) return 0.0;
float k = t / DURATION;
float attack = 1.0 - exp(-45.0 * t);
float ring = exp(-2.3 * k);
float tail = 1.0 - k * k * k * k;
return attack * ring * tail;
}
float coilPhase(float t) {
float k = clamp(t / DURATION, 0.0, 1.0);
return WAVE_SPEED * t * (1.0 - 0.5 * WAVE_GLIDE * k);
}
float hash11(float x) {
return fract(sin(x * 78.233) * 43758.5453);
}
vec4 sampleTerm(vec2 uv) {
vec2 halfTexel = 0.5 / iResolution.xy;
return texture(iChannel0, clamp(uv, halfTexel, 1.0 - halfTexel));
}
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
vec2 uv = fragCoord / iResolution.xy;
float amp = 0.0;
float t = 0.0;
float boot = iTime - BOOT_DELAY;
float bootAmp = envelope(boot);
if (bootAmp > amp) { amp = bootAmp; t = boot; }
if (JUMP_DEGAUSS) {
float jump = abs(iCurrentCursor.y - iPreviousCursor.y);
float elapsed = iTime - iTimeCursorChange;
if (jump > CURSOR_JUMP * iResolution.y) {
float e = envelope(elapsed);
if (e > amp) { amp = e; t = elapsed; }
}
}
if (amp <= 0.0001) {
fragColor = texture(iChannel0, uv);
return;
}
// coil's own tremble, so the picture pulses along with the warble in the
// sound instead of sliding smoothly under it.
amp *= 1.0 - WARBLE_DEPTH + WARBLE_DEPTH * sin(t * TAU * WARBLE_HZ);
float ph = coilPhase(t);
// magnetic distortion
vec2 p = uv - 0.5;
float wave = sin(p.y * WAVE_FREQ * TAU - ph * TAU);
float wave2 = sin(p.y * WAVE_FREQ * 2.3 * TAU + ph * 0.62 * TAU);
float warp = wave * 0.7 + wave2 * 0.3;
// vertical breathing
p.y /= 1.0 + amp * SQUEEZE_AMP * sin(t * TAU * 3.0);
p *= 1.0 - amp * 0.04 * sin(t * TAU * 2.0);
// per-scanline jitter
float line = floor(uv.y * iResolution.y);
float jitter = (hash11(line + floor(t * 90.0)) - 0.5) * 2.0;
p.x += amp * (WOBBLE_AMP * warp + JITTER_AMP * jitter);
vec2 duv = p + 0.5;
// misconvergence
float ca = amp * CHROMA_AMP * (0.5 + abs(warp));
vec4 cr = sampleTerm(duv + vec2(ca, 0.0));
vec4 cg = sampleTerm(duv);
vec4 cb = sampleTerm(duv - vec2(ca, 0.0));
vec4 col = vec4(cr.r, cg.g, cb.b, cg.a);
// coil pulse sweeping down the tube
float bandY = 1.0 - fract(t / DURATION * BAND_SWEEPS);
float band = exp(-pow((uv.y - bandY) * 9.0, 2.0));
// background-opacity to solid for the length of the flash.
float glow = amp * FLASH_AMP * (0.25 + 0.75 * band);
col.rgb += glow * (iForegroundColor * 0.22 + col.rgb * 0.9);
fragColor = col;
}
modules/home/ghostty/home-ghostty-shaders.ulu.nix
-76
View File
@@ -1,76 +0,0 @@
{ ... }:
{
flake.homeModules.home-ghostty-shaders =
{ config, pkgs, ... }:
let
preamble = pkgs.writeText "ghostty-shader-preamble.glsl" ''
#version 330 core
#define CURSORSTYLE_BLOCK 0
#define CURSORSTYLE_BLOCK_HOLLOW 1
#define CURSORSTYLE_BAR 2
#define CURSORSTYLE_UNDERLINE 3
#define CURSORSTYLE_LOCK 4
uniform vec3 iResolution;
uniform float iTime;
uniform float iTimeDelta;
uniform float iFrameRate;
uniform int iFrame;
uniform float iChannelTime[4];
uniform vec3 iChannelResolution[4];
uniform vec4 iMouse;
uniform vec4 iDate;
uniform float iSampleRate;
uniform sampler2D iChannel0;
uniform vec4 iCurrentCursor;
uniform vec4 iPreviousCursor;
uniform vec4 iCurrentCursorColor;
uniform vec4 iPreviousCursorColor;
uniform vec4 iCurrentCursorStyle;
uniform vec4 iPreviousCursorStyle;
uniform vec4 iCursorVisible;
uniform float iTimeCursorChange;
uniform float iTimeFocus;
uniform int iFocus;
uniform vec3 iPalette[256];
uniform vec3 iBackgroundColor;
uniform vec3 iForegroundColor;
uniform vec3 iCursorColor;
uniform vec3 iCursorText;
uniform vec3 iSelectionBackgroundColor;
uniform vec3 iSelectionForegroundColor;
out vec4 _ghosttyFragColor;
#line 1
'';
entryPoint = pkgs.writeText "ghostty-shader-entry.glsl" ''
void main() { mainImage(_ghosttyFragColor, gl_FragCoord.xy); }
'';
compiled =
name: src:
pkgs.runCommandLocal "ghostty-shader-${name}.glsl"
{
nativeBuildInputs = [ pkgs.glslang ];
}
''
cat ${preamble} ${src} ${entryPoint} > wrapped.frag
glslangValidator -S frag wrapped.frag
cp ${src} $out
'';
shaderDir = "${config.xdg.configHome}/ghostty/shaders";
in
{
xdg.configFile."ghostty/shaders/cursor-smear.glsl".source =
compiled "cursor-smear" ./cursor-smear.glsl;
xdg.configFile."ghostty/shaders/degauss.glsl".source = compiled "degauss" ./degauss.glsl;
programs.ghostty.settings = {
custom-shader = [
"${shaderDir}/cursor-smear.glsl"
"${shaderDir}/degauss.glsl"
];
custom-shader-animation = true;
};
};
}