init
This commit is contained in:
commit
3fa75abfb2
42 changed files with 5634 additions and 0 deletions
311
ghostty-shaders/crt.glsl
Normal file
311
ghostty-shaders/crt.glsl
Normal file
|
|
@ -0,0 +1,311 @@
|
|||
// source: https://gist.github.com/qwerasd205/c3da6c610c8ffe17d6d2d3cc7068f17f
|
||||
// credits: https://github.com/qwerasd205
|
||||
//==============================================================
|
||||
//
|
||||
// [CRTS] PUBLIC DOMAIN CRT-STYLED SCALAR by Timothy Lottes
|
||||
//
|
||||
// [+] Adapted with alterations for use in Ghostty by Qwerasd.
|
||||
// For more information on changes, see comment below license.
|
||||
//
|
||||
//==============================================================
|
||||
//
|
||||
// LICENSE = UNLICENSE (aka PUBLIC DOMAIN)
|
||||
//
|
||||
//--------------------------------------------------------------
|
||||
// This is free and unencumbered software released into the
|
||||
// public domain.
|
||||
//--------------------------------------------------------------
|
||||
// Anyone is free to copy, modify, publish, use, compile, sell,
|
||||
// or distribute this software, either in source code form or as
|
||||
// a compiled binary, for any purpose, commercial or
|
||||
// non-commercial, and by any means.
|
||||
//--------------------------------------------------------------
|
||||
// In jurisdictions that recognize copyright laws, the author or
|
||||
// authors of this software dedicate any and all copyright
|
||||
// interest in the software to the public domain. We make this
|
||||
// dedication for the benefit of the public at large and to the
|
||||
// detriment of our heirs and successors. We intend this
|
||||
// dedication to be an overt act of relinquishment in perpetuity
|
||||
// of all present and future rights to this software under
|
||||
// copyright law.
|
||||
//--------------------------------------------------------------
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
// KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE
|
||||
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
// AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
|
||||
// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS IN THE SOFTWARE.
|
||||
//--------------------------------------------------------------
|
||||
// For more information, please refer to
|
||||
// <http://unlicense.org/>
|
||||
//==============================================================
|
||||
|
||||
// This shader is a modified version of the excellent
|
||||
// FixingPixelArtFast by Timothy Lottes on Shadertoy.
|
||||
//
|
||||
// The original shader can be found at:
|
||||
// https://www.shadertoy.com/view/MtSfRK
|
||||
//
|
||||
// Modifications have been made to reduce the verbosity,
|
||||
// and many of the comments have been removed / reworded.
|
||||
// Additionally, the license has been moved to the top of
|
||||
// the file, and can be read above. I (Qwerasd) choose to
|
||||
// release the modified version under the same license.
|
||||
|
||||
// The appearance of this shader can be altered
|
||||
// by adjusting the parameters defined below.
|
||||
|
||||
// "Scanlines" per real screen pixel.
|
||||
// e.g. SCALE 0.5 means each scanline is 2 pixels.
|
||||
// Recommended values:
|
||||
// o High DPI displays: 0.33333333
|
||||
// - Low DPI displays: 0.66666666
|
||||
#define SCALE 0.33333333
|
||||
|
||||
// "Tube" warp
|
||||
#define CRTS_WARP 1
|
||||
|
||||
// Darkness of vignette in corners after warping
|
||||
// 0.0 = completely black
|
||||
// 1.0 = no vignetting
|
||||
#define MIN_VIN 0.5
|
||||
|
||||
// Try different masks
|
||||
// #define CRTS_MASK_GRILLE 1
|
||||
// #define CRTS_MASK_GRILLE_LITE 1
|
||||
// #define CRTS_MASK_NONE 1
|
||||
#define CRTS_MASK_SHADOW 1
|
||||
|
||||
// Scanline thinness
|
||||
// 0.50 = fused scanlines
|
||||
// 0.70 = recommended default
|
||||
// 1.00 = thinner scanlines (too thin)
|
||||
#define INPUT_THIN 0.75
|
||||
|
||||
// Horizonal scan blur
|
||||
// -3.0 = pixely
|
||||
// -2.5 = default
|
||||
// -2.0 = smooth
|
||||
// -1.0 = too blurry
|
||||
#define INPUT_BLUR -2.75
|
||||
|
||||
// Shadow mask effect, ranges from,
|
||||
// 0.25 = large amount of mask (not recommended, too dark)
|
||||
// 0.50 = recommended default
|
||||
// 1.00 = no shadow mask
|
||||
#define INPUT_MASK 0.65
|
||||
|
||||
float FromSrgb1(float c) {
|
||||
return (c <= 0.04045) ? c * (1.0 / 12.92) :
|
||||
pow(c * (1.0 / 1.055) + (0.055 / 1.055), 2.4);
|
||||
}
|
||||
vec3 FromSrgb(vec3 c) {
|
||||
return vec3(
|
||||
FromSrgb1(c.r), FromSrgb1(c.g), FromSrgb1(c.b));
|
||||
}
|
||||
|
||||
vec3 CrtsFetch(vec2 uv) {
|
||||
return FromSrgb(texture(iChannel0, uv.xy).rgb);
|
||||
}
|
||||
|
||||
#define CrtsRcpF1(x) (1.0/(x))
|
||||
#define CrtsSatF1(x) clamp((x),0.0,1.0)
|
||||
|
||||
float CrtsMax3F1(float a, float b, float c) {
|
||||
return max(a, max(b, c));
|
||||
}
|
||||
|
||||
vec2 CrtsTone(
|
||||
float thin,
|
||||
float mask) {
|
||||
#ifdef CRTS_MASK_NONE
|
||||
mask = 1.0;
|
||||
#endif
|
||||
|
||||
#ifdef CRTS_MASK_GRILLE_LITE
|
||||
// Normal R mask is {1.0,mask,mask}
|
||||
// LITE R mask is {mask,1.0,1.0}
|
||||
mask = 0.5 + mask * 0.5;
|
||||
#endif
|
||||
|
||||
vec2 ret;
|
||||
float midOut = 0.18 / ((1.5 - thin) * (0.5 * mask + 0.5));
|
||||
float pMidIn = 0.18;
|
||||
ret.x = ((-pMidIn) + midOut) / ((1.0 - pMidIn) * midOut);
|
||||
ret.y = ((-pMidIn) * midOut + pMidIn) / (midOut * (-pMidIn) + midOut);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec3 CrtsMask(vec2 pos, float dark) {
|
||||
#ifdef CRTS_MASK_GRILLE
|
||||
vec3 m = vec3(dark, dark, dark);
|
||||
float x = fract(pos.x * (1.0 / 3.0));
|
||||
if (x < (1.0 / 3.0)) m.r = 1.0;
|
||||
else if (x < (2.0 / 3.0)) m.g = 1.0;
|
||||
else m.b = 1.0;
|
||||
return m;
|
||||
#endif
|
||||
|
||||
#ifdef CRTS_MASK_GRILLE_LITE
|
||||
vec3 m = vec3(1.0, 1.0, 1.0);
|
||||
float x = fract(pos.x * (1.0 / 3.0));
|
||||
if (x < (1.0 / 3.0)) m.r = dark;
|
||||
else if (x < (2.0 / 3.0)) m.g = dark;
|
||||
else m.b = dark;
|
||||
return m;
|
||||
#endif
|
||||
|
||||
#ifdef CRTS_MASK_NONE
|
||||
return vec3(1.0, 1.0, 1.0);
|
||||
#endif
|
||||
|
||||
#ifdef CRTS_MASK_SHADOW
|
||||
pos.x += pos.y * 3.0;
|
||||
vec3 m = vec3(dark, dark, dark);
|
||||
float x = fract(pos.x * (1.0 / 6.0));
|
||||
if (x < (1.0 / 3.0)) m.r = 1.0;
|
||||
else if (x < (2.0 / 3.0)) m.g = 1.0;
|
||||
else m.b = 1.0;
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
vec3 CrtsFilter(
|
||||
vec2 ipos,
|
||||
vec2 inputSizeDivOutputSize,
|
||||
vec2 halfInputSize,
|
||||
vec2 rcpInputSize,
|
||||
vec2 rcpOutputSize,
|
||||
vec2 twoDivOutputSize,
|
||||
float inputHeight,
|
||||
vec2 warp,
|
||||
float thin,
|
||||
float blur,
|
||||
float mask,
|
||||
vec2 tone
|
||||
) {
|
||||
// Optional apply warp
|
||||
vec2 pos;
|
||||
#ifdef CRTS_WARP
|
||||
// Convert to {-1 to 1} range
|
||||
pos = ipos * twoDivOutputSize - vec2(1.0, 1.0);
|
||||
|
||||
// Distort pushes image outside {-1 to 1} range
|
||||
pos *= vec2(
|
||||
1.0 + (pos.y * pos.y) * warp.x,
|
||||
1.0 + (pos.x * pos.x) * warp.y);
|
||||
|
||||
// TODO: Vignette needs optimization
|
||||
float vin = 1.0 - (
|
||||
(1.0 - CrtsSatF1(pos.x * pos.x)) * (1.0 - CrtsSatF1(pos.y * pos.y)));
|
||||
vin = CrtsSatF1((-vin) * inputHeight + inputHeight);
|
||||
|
||||
// Leave in {0 to inputSize}
|
||||
pos = pos * halfInputSize + halfInputSize;
|
||||
#else
|
||||
pos = ipos * inputSizeDivOutputSize;
|
||||
#endif
|
||||
|
||||
// Snap to center of first scanline
|
||||
float y0 = floor(pos.y - 0.5) + 0.5;
|
||||
// Snap to center of one of four pixels
|
||||
float x0 = floor(pos.x - 1.5) + 0.5;
|
||||
|
||||
// Inital UV position
|
||||
vec2 p = vec2(x0 * rcpInputSize.x, y0 * rcpInputSize.y);
|
||||
// Fetch 4 nearest texels from 2 nearest scanlines
|
||||
vec3 colA0 = CrtsFetch(p);
|
||||
p.x += rcpInputSize.x;
|
||||
vec3 colA1 = CrtsFetch(p);
|
||||
p.x += rcpInputSize.x;
|
||||
vec3 colA2 = CrtsFetch(p);
|
||||
p.x += rcpInputSize.x;
|
||||
vec3 colA3 = CrtsFetch(p);
|
||||
p.y += rcpInputSize.y;
|
||||
vec3 colB3 = CrtsFetch(p);
|
||||
p.x -= rcpInputSize.x;
|
||||
vec3 colB2 = CrtsFetch(p);
|
||||
p.x -= rcpInputSize.x;
|
||||
vec3 colB1 = CrtsFetch(p);
|
||||
p.x -= rcpInputSize.x;
|
||||
vec3 colB0 = CrtsFetch(p);
|
||||
|
||||
// Vertical filter
|
||||
// Scanline intensity is using sine wave
|
||||
// Easy filter window and integral used later in exposure
|
||||
float off = pos.y - y0;
|
||||
float pi2 = 6.28318530717958;
|
||||
float hlf = 0.5;
|
||||
float scanA = cos(min(0.5, off * thin) * pi2) * hlf + hlf;
|
||||
float scanB = cos(min(0.5, (-off) * thin + thin) * pi2) * hlf + hlf;
|
||||
|
||||
// Horizontal kernel is simple gaussian filter
|
||||
float off0 = pos.x - x0;
|
||||
float off1 = off0 - 1.0;
|
||||
float off2 = off0 - 2.0;
|
||||
float off3 = off0 - 3.0;
|
||||
float pix0 = exp2(blur * off0 * off0);
|
||||
float pix1 = exp2(blur * off1 * off1);
|
||||
float pix2 = exp2(blur * off2 * off2);
|
||||
float pix3 = exp2(blur * off3 * off3);
|
||||
float pixT = CrtsRcpF1(pix0 + pix1 + pix2 + pix3);
|
||||
|
||||
#ifdef CRTS_WARP
|
||||
// Get rid of wrong pixels on edge
|
||||
pixT *= max(MIN_VIN, vin);
|
||||
#endif
|
||||
|
||||
scanA *= pixT;
|
||||
scanB *= pixT;
|
||||
|
||||
// Apply horizontal and vertical filters
|
||||
vec3 color =
|
||||
(colA0 * pix0 + colA1 * pix1 + colA2 * pix2 + colA3 * pix3) * scanA +
|
||||
(colB0 * pix0 + colB1 * pix1 + colB2 * pix2 + colB3 * pix3) * scanB;
|
||||
|
||||
// Apply phosphor mask
|
||||
color *= CrtsMask(ipos, mask);
|
||||
|
||||
// Tonal control, start by protecting from /0
|
||||
float peak = max(1.0 / (256.0 * 65536.0),
|
||||
CrtsMax3F1(color.r, color.g, color.b));
|
||||
// Compute the ratios of {R,G,B}
|
||||
vec3 ratio = color * CrtsRcpF1(peak);
|
||||
// Apply tonal curve to peak value
|
||||
peak = peak * CrtsRcpF1(peak * tone.x + tone.y);
|
||||
// Reconstruct color
|
||||
return ratio * peak;
|
||||
}
|
||||
|
||||
float ToSrgb1(float c) {
|
||||
return (c < 0.0031308 ? c * 12.92 : 1.055 * pow(c, 0.41666) - 0.055);
|
||||
}
|
||||
vec3 ToSrgb(vec3 c) {
|
||||
return vec3(
|
||||
ToSrgb1(c.r), ToSrgb1(c.g), ToSrgb1(c.b));
|
||||
}
|
||||
|
||||
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
||||
float aspect = iResolution.x / iResolution.y;
|
||||
fragColor.rgb = CrtsFilter(
|
||||
fragCoord.xy,
|
||||
vec2(1.0),
|
||||
iResolution.xy * SCALE * 0.5,
|
||||
1.0 / (iResolution.xy * SCALE),
|
||||
1.0 / iResolution.xy,
|
||||
2.0 / iResolution.xy,
|
||||
iResolution.y,
|
||||
vec2(1.0 / (50.0 * aspect), 1.0 / 50.0),
|
||||
INPUT_THIN,
|
||||
INPUT_BLUR,
|
||||
INPUT_MASK,
|
||||
CrtsTone(INPUT_THIN, INPUT_MASK)
|
||||
);
|
||||
|
||||
// Linear to SRGB for output.
|
||||
fragColor.rgb = ToSrgb(fragColor.rgb);
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue